2020-04-24 03:25:58 +02:00
|
|
|
package net.minestom.server.utils;
|
2019-08-22 14:52:32 +02:00
|
|
|
|
2020-04-17 01:16:02 +02:00
|
|
|
import io.netty.buffer.ByteBuf;
|
|
|
|
import io.netty.buffer.Unpooled;
|
2020-11-20 03:57:05 +01:00
|
|
|
import net.minestom.server.MinecraftServer;
|
2020-11-13 07:43:35 +01:00
|
|
|
import net.minestom.server.entity.Player;
|
2020-11-20 03:57:05 +01:00
|
|
|
import net.minestom.server.listener.manager.PacketListenerManager;
|
2020-11-20 05:37:13 +01:00
|
|
|
import net.minestom.server.network.netty.packet.FramedPacket;
|
2020-04-24 03:25:58 +02:00
|
|
|
import net.minestom.server.network.packet.server.ServerPacket;
|
2020-11-18 19:39:06 +01:00
|
|
|
import net.minestom.server.network.packet.server.ServerPacketIdentifier;
|
2020-11-20 03:57:05 +01:00
|
|
|
import net.minestom.server.network.player.NettyPlayerConnection;
|
|
|
|
import net.minestom.server.network.player.PlayerConnection;
|
2020-08-19 20:34:21 +02:00
|
|
|
import net.minestom.server.utils.binary.BinaryWriter;
|
2020-11-05 22:20:51 +01:00
|
|
|
import org.jetbrains.annotations.NotNull;
|
2019-08-22 14:52:32 +02:00
|
|
|
|
2020-11-13 07:43:35 +01:00
|
|
|
import java.util.Collection;
|
2020-11-20 05:37:13 +01:00
|
|
|
import java.util.zip.Deflater;
|
2020-11-13 07:43:35 +01:00
|
|
|
|
2020-08-15 04:05:15 +02:00
|
|
|
/**
|
2020-11-13 09:17:53 +01:00
|
|
|
* Utils class for packets. Including writing a {@link ServerPacket} into a {@link ByteBuf}
|
|
|
|
* for network processing.
|
2020-08-15 04:05:15 +02:00
|
|
|
*/
|
2020-08-07 08:10:10 +02:00
|
|
|
public final class PacketUtils {
|
|
|
|
|
2020-11-20 03:57:05 +01:00
|
|
|
private static final PacketListenerManager PACKET_LISTENER_MANAGER = MinecraftServer.getPacketListenerManager();
|
|
|
|
|
2020-11-20 18:16:45 +01:00
|
|
|
private final static Deflater deflater = new Deflater(3);
|
|
|
|
private final static byte[] buffer = new byte[8192];
|
2020-11-20 05:37:13 +01:00
|
|
|
|
2020-08-07 08:10:10 +02:00
|
|
|
private PacketUtils() {
|
|
|
|
|
|
|
|
}
|
2019-08-22 14:52:32 +02:00
|
|
|
|
2020-11-13 09:17:53 +01:00
|
|
|
/**
|
2020-11-20 03:57:05 +01:00
|
|
|
* Sends a {@link ServerPacket} to multiple players.
|
2020-11-13 09:17:53 +01:00
|
|
|
* <p>
|
2020-11-20 03:57:05 +01:00
|
|
|
* Can drastically improve performance since the packet will not have to be processed as much.
|
2020-11-13 09:17:53 +01:00
|
|
|
*
|
|
|
|
* @param players the players to send the packet to
|
|
|
|
* @param packet the packet to send to the players
|
|
|
|
*/
|
|
|
|
public static void sendGroupedPacket(@NotNull Collection<Player> players, @NotNull ServerPacket packet) {
|
2020-11-20 14:14:55 +01:00
|
|
|
if (players.isEmpty())
|
|
|
|
return;
|
|
|
|
|
2020-11-20 03:57:05 +01:00
|
|
|
final boolean success = PACKET_LISTENER_MANAGER.processServerPacket(packet, players);
|
|
|
|
if (success) {
|
2020-11-20 18:16:45 +01:00
|
|
|
final ByteBuf finalBuffer = createFramedPacket(packet, true);
|
|
|
|
final FramedPacket framedPacket = new FramedPacket(finalBuffer, true);
|
2020-11-20 04:48:33 +01:00
|
|
|
|
2020-11-20 18:16:45 +01:00
|
|
|
final int refIncrease = players.size() - 1;
|
|
|
|
if (refIncrease > 0)
|
|
|
|
finalBuffer.retain(refIncrease);
|
2020-11-20 03:57:05 +01:00
|
|
|
for (Player player : players) {
|
|
|
|
final PlayerConnection playerConnection = player.getPlayerConnection();
|
|
|
|
if (playerConnection instanceof NettyPlayerConnection) {
|
2020-11-20 04:48:33 +01:00
|
|
|
final NettyPlayerConnection nettyPlayerConnection = (NettyPlayerConnection) playerConnection;
|
2020-11-20 18:16:45 +01:00
|
|
|
nettyPlayerConnection.write(framedPacket);
|
2020-11-20 03:57:05 +01:00
|
|
|
} else {
|
|
|
|
playerConnection.sendPacket(packet);
|
2020-11-20 18:16:45 +01:00
|
|
|
finalBuffer.release();
|
2020-11-20 03:57:05 +01:00
|
|
|
}
|
|
|
|
}
|
2020-11-13 07:43:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-15 04:05:15 +02:00
|
|
|
/**
|
2020-10-15 21:16:31 +02:00
|
|
|
* Writes a {@link ServerPacket} into a {@link ByteBuf}.
|
2020-08-15 04:05:15 +02:00
|
|
|
*
|
|
|
|
* @param buf the recipient of {@code packet}
|
|
|
|
* @param packet the packet to write into {@code buf}
|
|
|
|
*/
|
2020-11-05 22:20:51 +01:00
|
|
|
public static void writePacket(@NotNull ByteBuf buf, @NotNull ServerPacket packet) {
|
2020-08-21 13:16:44 +02:00
|
|
|
final ByteBuf packetBuffer = getPacketBuffer(packet);
|
|
|
|
|
|
|
|
writePacket(buf, packetBuffer, packet.getId());
|
2020-06-28 22:07:48 +02:00
|
|
|
}
|
2020-04-17 01:16:02 +02:00
|
|
|
|
2020-08-15 04:05:15 +02:00
|
|
|
/**
|
2020-10-15 21:16:31 +02:00
|
|
|
* Writes a {@link ServerPacket} into a newly created {@link ByteBuf}.
|
2020-08-15 04:05:15 +02:00
|
|
|
*
|
|
|
|
* @param packet the packet to write
|
|
|
|
* @return a {@link ByteBuf} containing {@code packet}
|
|
|
|
*/
|
2020-11-05 22:20:51 +01:00
|
|
|
@NotNull
|
|
|
|
public static ByteBuf writePacket(@NotNull ServerPacket packet) {
|
2020-08-21 13:16:44 +02:00
|
|
|
final ByteBuf packetBuffer = getPacketBuffer(packet);
|
2020-04-17 01:16:02 +02:00
|
|
|
|
2020-08-21 13:16:44 +02:00
|
|
|
// Add 5 for the packet id and for the packet size
|
|
|
|
final int size = packetBuffer.writerIndex() + 5 + 5;
|
2020-11-20 18:16:45 +01:00
|
|
|
ByteBuf buffer = BufUtils.getBuffer(true, size);
|
2020-08-21 13:16:44 +02:00
|
|
|
|
|
|
|
writePacket(buffer, packetBuffer, packet.getId());
|
2020-03-20 19:50:22 +01:00
|
|
|
|
2020-05-26 15:35:48 +02:00
|
|
|
return buffer;
|
2019-08-23 15:37:38 +02:00
|
|
|
}
|
|
|
|
|
2020-08-21 13:16:44 +02:00
|
|
|
/**
|
2020-10-15 21:16:31 +02:00
|
|
|
* Writes a packet buffer into {@code buf}.
|
2020-08-21 13:16:44 +02:00
|
|
|
*
|
|
|
|
* @param buf the buffer which will receive the packet id/data
|
|
|
|
* @param packetBuffer the buffer containing the raw packet data
|
|
|
|
* @param packetId the packet id
|
|
|
|
*/
|
2020-11-05 22:20:51 +01:00
|
|
|
private static void writePacket(@NotNull ByteBuf buf, @NotNull ByteBuf packetBuffer, int packetId) {
|
2020-08-21 13:16:44 +02:00
|
|
|
Utils.writeVarIntBuf(buf, packetId);
|
|
|
|
buf.writeBytes(packetBuffer);
|
2020-11-18 06:39:20 +01:00
|
|
|
packetBuffer.release();
|
2020-08-21 13:16:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2020-10-15 21:16:31 +02:00
|
|
|
* Gets the buffer representing the raw packet data.
|
2020-08-21 13:16:44 +02:00
|
|
|
*
|
|
|
|
* @param packet the packet to write
|
|
|
|
* @return the {@link ByteBuf} containing the raw packet data
|
|
|
|
*/
|
2020-11-05 22:20:51 +01:00
|
|
|
@NotNull
|
|
|
|
private static ByteBuf getPacketBuffer(@NotNull ServerPacket packet) {
|
2020-11-18 19:39:06 +01:00
|
|
|
BinaryWriter writer;
|
|
|
|
if (packet.getId() == ServerPacketIdentifier.CHUNK_DATA)
|
|
|
|
writer = new BinaryWriter(BufUtils.getBuffer(true, 40_000));
|
|
|
|
else
|
|
|
|
writer = new BinaryWriter(BufUtils.getBuffer(true));
|
2020-11-19 02:28:56 +01:00
|
|
|
try {
|
|
|
|
packet.write(writer);
|
|
|
|
} catch (Exception e) {
|
|
|
|
e.printStackTrace();
|
|
|
|
}
|
2020-08-21 13:16:44 +02:00
|
|
|
return writer.getBuffer();
|
|
|
|
}
|
|
|
|
|
2020-11-20 14:05:22 +01:00
|
|
|
/**
|
|
|
|
* Frames a buffer for it to be understood by a Minecraft client.
|
|
|
|
* <p>
|
|
|
|
* The content of {@code packetBuffer} can be either a compressed or uncompressed packet buffer,
|
|
|
|
* it depends of it the client did receive a {@link net.minestom.server.network.packet.server.login.SetCompressionPacket} packet before.
|
|
|
|
*
|
|
|
|
* @param packetBuffer the buffer containing compressed or uncompressed packet data
|
|
|
|
* @param frameTarget the buffer which will receive the framed version of {@code from}
|
|
|
|
*/
|
|
|
|
public static void frameBuffer(@NotNull ByteBuf packetBuffer, @NotNull ByteBuf frameTarget) {
|
|
|
|
final int packetSize = packetBuffer.readableBytes();
|
2020-11-20 05:37:13 +01:00
|
|
|
final int headerSize = Utils.getVarIntSize(packetSize);
|
|
|
|
|
|
|
|
if (headerSize > 3) {
|
|
|
|
throw new IllegalStateException("Unable to fit " + headerSize + " into 3");
|
|
|
|
}
|
|
|
|
|
2020-11-20 14:05:22 +01:00
|
|
|
frameTarget.ensureWritable(packetSize + headerSize);
|
2020-11-20 05:37:13 +01:00
|
|
|
|
2020-11-20 14:05:22 +01:00
|
|
|
Utils.writeVarIntBuf(frameTarget, packetSize);
|
|
|
|
frameTarget.writeBytes(packetBuffer, packetBuffer.readerIndex(), packetSize);
|
2020-11-20 05:37:13 +01:00
|
|
|
}
|
|
|
|
|
2020-11-20 14:05:22 +01:00
|
|
|
/**
|
|
|
|
* Compress using zlib the content of a packet.
|
|
|
|
* <p>
|
|
|
|
* {@code packetBuffer} needs to be the packet content without any header (if you want to use it to write a Minecraft packet).
|
|
|
|
*
|
|
|
|
* @param deflater the deflater for zlib compression
|
|
|
|
* @param buffer a cached buffer which will be used to store temporary the deflater output
|
|
|
|
* @param packetBuffer the buffer containing all the packet fields
|
|
|
|
* @param compressionTarget the buffer which will receive the compressed version of {@code packetBuffer}
|
|
|
|
*/
|
|
|
|
public static void compressBuffer(@NotNull Deflater deflater, @NotNull byte[] buffer, @NotNull ByteBuf packetBuffer, @NotNull ByteBuf compressionTarget) {
|
|
|
|
final int packetLength = packetBuffer.readableBytes();
|
2020-11-20 05:37:13 +01:00
|
|
|
|
|
|
|
if (packetLength < MinecraftServer.getCompressionThreshold()) {
|
2020-11-20 14:05:22 +01:00
|
|
|
Utils.writeVarIntBuf(compressionTarget, 0);
|
|
|
|
compressionTarget.writeBytes(packetBuffer);
|
2020-11-20 05:37:13 +01:00
|
|
|
} else {
|
2020-11-20 14:05:22 +01:00
|
|
|
Utils.writeVarIntBuf(compressionTarget, packetLength);
|
2020-11-20 05:37:13 +01:00
|
|
|
|
2020-11-20 14:05:22 +01:00
|
|
|
deflater.setInput(packetBuffer.nioBuffer());
|
2020-11-20 05:37:13 +01:00
|
|
|
deflater.finish();
|
|
|
|
|
|
|
|
while (!deflater.finished()) {
|
|
|
|
final int length = deflater.deflate(buffer);
|
2020-11-20 14:05:22 +01:00
|
|
|
compressionTarget.writeBytes(buffer, 0, length);
|
2020-11-20 05:37:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
deflater.reset();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-20 14:05:22 +01:00
|
|
|
/**
|
|
|
|
* Creates a "framed packet" (packet which can be send and understood by a Minecraft client)
|
|
|
|
* from a server packet.
|
|
|
|
* <p>
|
|
|
|
* Can be used if you want to store a raw buffer and send it later without the additional writing cost.
|
|
|
|
* Compression is applied if {@link MinecraftServer#getCompressionThreshold()} is greater than 0.
|
|
|
|
*
|
|
|
|
* @param serverPacket the server packet to write
|
|
|
|
* @return the framed packet from the server one
|
|
|
|
*/
|
2020-11-20 18:16:45 +01:00
|
|
|
public static ByteBuf createFramedPacket(@NotNull ServerPacket serverPacket, boolean directBuffer) {
|
2020-11-20 05:37:13 +01:00
|
|
|
ByteBuf packetBuf = writePacket(serverPacket);
|
|
|
|
|
2020-11-20 05:50:52 +01:00
|
|
|
// TODO use pooled buffers instead of unpooled ones
|
2020-11-20 05:37:13 +01:00
|
|
|
if (MinecraftServer.getCompressionThreshold() > 0) {
|
|
|
|
|
2020-11-20 18:16:45 +01:00
|
|
|
ByteBuf compressedBuf = directBuffer ? BufUtils.getBuffer(true) : Unpooled.buffer();
|
|
|
|
ByteBuf framedBuf = directBuffer ? BufUtils.getBuffer(true) : Unpooled.buffer();
|
2020-11-20 05:37:13 +01:00
|
|
|
synchronized (deflater) {
|
|
|
|
compressBuffer(deflater, buffer, packetBuf, compressedBuf);
|
|
|
|
}
|
2020-11-20 18:16:45 +01:00
|
|
|
packetBuf.release();
|
2020-11-20 05:37:13 +01:00
|
|
|
|
|
|
|
frameBuffer(compressedBuf, framedBuf);
|
2020-11-20 18:16:45 +01:00
|
|
|
compressedBuf.release();
|
2020-11-20 05:37:13 +01:00
|
|
|
|
|
|
|
return framedBuf;
|
|
|
|
} else {
|
2020-11-20 18:16:45 +01:00
|
|
|
ByteBuf framedBuf = directBuffer ? BufUtils.getBuffer(true) : Unpooled.buffer();
|
2020-11-20 05:37:13 +01:00
|
|
|
frameBuffer(packetBuf, framedBuf);
|
2020-11-20 18:16:45 +01:00
|
|
|
packetBuf.release();
|
2020-11-20 05:37:13 +01:00
|
|
|
|
|
|
|
return framedBuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2019-08-22 14:52:32 +02:00
|
|
|
}
|