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;
|
2021-03-30 16:54:56 +02:00
|
|
|
import net.kyori.adventure.audience.Audience;
|
|
|
|
import net.kyori.adventure.audience.ForwardingAudience;
|
2020-11-20 03:57:05 +01:00
|
|
|
import net.minestom.server.MinecraftServer;
|
2021-06-11 17:19:11 +02:00
|
|
|
import net.minestom.server.adventure.MinestomAdventure;
|
2021-03-30 16:54:56 +02:00
|
|
|
import net.minestom.server.adventure.audience.PacketGroupingAudience;
|
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;
|
2021-03-12 16:33:19 +01:00
|
|
|
import net.minestom.server.network.packet.server.ComponentHoldingServerPacket;
|
2020-04-24 03:25:58 +02:00
|
|
|
import net.minestom.server.network.packet.server.ServerPacket;
|
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-12-14 06:06:28 +01:00
|
|
|
import net.minestom.server.utils.callback.validator.PlayerValidator;
|
2020-11-05 22:20:51 +01:00
|
|
|
import org.jetbrains.annotations.NotNull;
|
2020-12-14 06:06:28 +01:00
|
|
|
import org.jetbrains.annotations.Nullable;
|
2019-08-22 14:52:32 +02:00
|
|
|
|
2021-06-20 20:59:53 +02:00
|
|
|
import java.nio.ByteBuffer;
|
2020-11-13 07:43:35 +01:00
|
|
|
import java.util.Collection;
|
2021-06-20 20:59:53 +02: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();
|
2021-06-20 20:59:53 +02:00
|
|
|
private static final ThreadLocal<Deflater> COMPRESSOR = ThreadLocal.withInitial(Deflater::new);
|
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
|
|
|
|
2021-03-30 16:54:56 +02:00
|
|
|
/**
|
|
|
|
* Sends a packet to an audience. This method performs the following steps in the
|
|
|
|
* following order:
|
|
|
|
* <ol>
|
|
|
|
* <li>If {@code audience} is a {@link Player}, send the packet to them.</li>
|
|
|
|
* <li>Otherwise, if {@code audience} is a {@link PacketGroupingAudience}, call
|
|
|
|
* {@link #sendGroupedPacket(Collection, ServerPacket)} on the players that the
|
|
|
|
* grouping audience contains.</li>
|
|
|
|
* <li>Otherwise, if {@code audience} is a {@link ForwardingAudience.Single},
|
|
|
|
* call this method on the single audience inside the forwarding audience.</li>
|
|
|
|
* <li>Otherwise, if {@code audience} is a {@link ForwardingAudience}, call this
|
|
|
|
* method for each audience member of the forwarding audience.</li>
|
|
|
|
* <li>Otherwise, do nothing.</li>
|
|
|
|
* </ol>
|
|
|
|
*
|
|
|
|
* @param audience the audience
|
2021-05-08 22:45:57 +02:00
|
|
|
* @param packet the packet
|
2021-03-30 16:54:56 +02:00
|
|
|
*/
|
|
|
|
@SuppressWarnings("OverrideOnly") // we need to access the audiences inside ForwardingAudience
|
|
|
|
public static void sendPacket(@NotNull Audience audience, @NotNull ServerPacket packet) {
|
|
|
|
if (audience instanceof Player) {
|
|
|
|
((Player) audience).getPlayerConnection().sendPacket(packet);
|
|
|
|
} else if (audience instanceof PacketGroupingAudience) {
|
|
|
|
PacketUtils.sendGroupedPacket(((PacketGroupingAudience) audience).getPlayers(), packet);
|
|
|
|
} else if (audience instanceof ForwardingAudience.Single) {
|
|
|
|
PacketUtils.sendPacket(((ForwardingAudience.Single) audience).audience(), packet);
|
|
|
|
} else if (audience instanceof ForwardingAudience) {
|
|
|
|
for (Audience member : ((ForwardingAudience) audience).audiences()) {
|
|
|
|
PacketUtils.sendPacket(member, packet);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
*
|
2020-12-14 06:06:28 +01:00
|
|
|
* @param players the players to send the packet to
|
|
|
|
* @param packet the packet to send to the players
|
|
|
|
* @param playerValidator optional callback to check if a specify player of {@code players} should receive the packet
|
2020-11-13 09:17:53 +01:00
|
|
|
*/
|
2020-12-14 06:06:28 +01:00
|
|
|
public static void sendGroupedPacket(@NotNull Collection<Player> players, @NotNull ServerPacket packet,
|
|
|
|
@Nullable PlayerValidator playerValidator) {
|
2020-11-20 14:14:55 +01:00
|
|
|
if (players.isEmpty())
|
|
|
|
return;
|
|
|
|
|
2021-03-12 16:33:19 +01:00
|
|
|
// work out if the packet needs to be sent individually due to server-side translating
|
|
|
|
boolean needsTranslating = false;
|
2021-06-11 17:19:11 +02:00
|
|
|
if (MinestomAdventure.AUTOMATIC_COMPONENT_TRANSLATION && packet instanceof ComponentHoldingServerPacket) {
|
|
|
|
needsTranslating = ComponentUtils.areAnyTranslatable(((ComponentHoldingServerPacket) packet).components());
|
2021-03-12 16:33:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (MinecraftServer.hasGroupedPacket() && !needsTranslating) {
|
2021-01-02 15:44:50 +01:00
|
|
|
// Send grouped packet...
|
|
|
|
final boolean success = PACKET_LISTENER_MANAGER.processServerPacket(packet, players);
|
|
|
|
if (success) {
|
2021-05-08 22:45:57 +02:00
|
|
|
final ByteBuf finalBuffer = createFramedPacket(packet);
|
2021-01-02 15:44:50 +01:00
|
|
|
final FramedPacket framedPacket = new FramedPacket(finalBuffer);
|
2020-11-20 04:48:33 +01:00
|
|
|
|
2021-01-02 15:44:50 +01:00
|
|
|
// Send packet to all players
|
|
|
|
for (Player player : players) {
|
2021-02-07 22:02:03 +01:00
|
|
|
if (!player.isOnline())
|
|
|
|
continue;
|
2021-01-02 15:44:50 +01:00
|
|
|
// Verify if the player should receive the packet
|
|
|
|
if (playerValidator != null && !playerValidator.isValid(player))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
final PlayerConnection playerConnection = player.getPlayerConnection();
|
|
|
|
if (playerConnection instanceof NettyPlayerConnection) {
|
|
|
|
final NettyPlayerConnection nettyPlayerConnection = (NettyPlayerConnection) playerConnection;
|
2021-03-15 15:19:43 +01:00
|
|
|
nettyPlayerConnection.write(framedPacket, true);
|
2021-01-02 15:44:50 +01:00
|
|
|
} else {
|
|
|
|
playerConnection.sendPacket(packet);
|
|
|
|
}
|
|
|
|
}
|
2021-03-20 11:59:02 +01:00
|
|
|
finalBuffer.release(); // Release last reference
|
2021-01-02 15:44:50 +01:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Write the same packet for each individual players
|
2020-11-20 03:57:05 +01:00
|
|
|
for (Player player : players) {
|
2020-12-14 06:06:28 +01:00
|
|
|
// Verify if the player should receive the packet
|
|
|
|
if (playerValidator != null && !playerValidator.isValid(player))
|
|
|
|
continue;
|
|
|
|
|
2020-11-20 03:57:05 +01:00
|
|
|
final PlayerConnection playerConnection = player.getPlayerConnection();
|
2021-03-15 15:19:43 +01:00
|
|
|
playerConnection.sendPacket(packet, false);
|
2020-11-20 03:57:05 +01:00
|
|
|
}
|
2020-11-13 07:43:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-14 06:06:28 +01:00
|
|
|
/**
|
|
|
|
* Same as {@link #sendGroupedPacket(Collection, ServerPacket, PlayerValidator)}
|
|
|
|
* but with the player validator sets to null.
|
|
|
|
*
|
|
|
|
* @see #sendGroupedPacket(Collection, ServerPacket, PlayerValidator)
|
|
|
|
*/
|
|
|
|
public static void sendGroupedPacket(@NotNull Collection<Player> players, @NotNull ServerPacket packet) {
|
|
|
|
sendGroupedPacket(players, packet, null);
|
|
|
|
}
|
|
|
|
|
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) {
|
2021-05-11 03:10:18 +02:00
|
|
|
Utils.writeVarInt(buf, packet.getId());
|
2021-03-22 14:31:38 +01:00
|
|
|
writePacketPayload(buf, packet);
|
2020-06-28 22:07:48 +02:00
|
|
|
}
|
2020-04-17 01:16:02 +02:00
|
|
|
|
2020-08-15 04:05:15 +02:00
|
|
|
/**
|
2021-03-22 14:31:38 +01:00
|
|
|
* Writes a packet payload.
|
2020-08-15 04:05:15 +02:00
|
|
|
*
|
|
|
|
* @param packet the packet to write
|
|
|
|
*/
|
2021-03-22 14:31:38 +01:00
|
|
|
private static void writePacketPayload(@NotNull ByteBuf buffer, @NotNull ServerPacket packet) {
|
|
|
|
BinaryWriter writer = new BinaryWriter(buffer);
|
2020-11-19 02:28:56 +01:00
|
|
|
try {
|
|
|
|
packet.write(writer);
|
|
|
|
} catch (Exception e) {
|
2021-01-19 18:25:54 +01:00
|
|
|
MinecraftServer.getExceptionManager().handleException(e);
|
2020-11-19 02:28:56 +01:00
|
|
|
}
|
2020-08-21 13:16:44 +02:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2021-05-11 03:10:18 +02:00
|
|
|
Utils.writeVarInt(frameTarget, packetSize);
|
2020-11-20 14:05:22 +01:00
|
|
|
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).
|
|
|
|
*
|
2021-06-20 20:59:53 +02:00
|
|
|
* @param deflater the deflater for zlib compression
|
2020-11-20 14:05:22 +01:00
|
|
|
* @param packetBuffer the buffer containing all the packet fields
|
|
|
|
* @param compressionTarget the buffer which will receive the compressed version of {@code packetBuffer}
|
|
|
|
*/
|
2021-06-20 20:59:53 +02:00
|
|
|
public static void compressBuffer(@NotNull Deflater deflater, @NotNull ByteBuf packetBuffer, @NotNull ByteBuf compressionTarget) {
|
2020-11-20 14:05:22 +01:00
|
|
|
final int packetLength = packetBuffer.readableBytes();
|
2021-03-22 14:31:38 +01:00
|
|
|
final boolean compression = packetLength > MinecraftServer.getCompressionThreshold();
|
2021-05-11 03:10:18 +02:00
|
|
|
Utils.writeVarInt(compressionTarget, compression ? packetLength : 0);
|
2021-03-22 14:31:38 +01:00
|
|
|
if (compression) {
|
2021-06-20 20:59:53 +02:00
|
|
|
compress(deflater, packetBuffer, compressionTarget);
|
2020-11-20 05:37:13 +01:00
|
|
|
} else {
|
2021-03-22 14:31:38 +01:00
|
|
|
compressionTarget.writeBytes(packetBuffer);
|
|
|
|
}
|
|
|
|
}
|
2021-01-08 16:20:04 +01:00
|
|
|
|
2021-06-20 20:59:53 +02:00
|
|
|
private static void compress(@NotNull Deflater deflater, @NotNull ByteBuf uncompressed, @NotNull ByteBuf compressed) {
|
|
|
|
deflater.setInput(uncompressed.nioBuffer());
|
|
|
|
deflater.finish();
|
|
|
|
|
|
|
|
while (!deflater.finished()) {
|
|
|
|
ByteBuffer nioBuffer = compressed.nioBuffer(compressed.writerIndex(), compressed.writableBytes());
|
|
|
|
compressed.writerIndex(deflater.deflate(nioBuffer) + compressed.writerIndex());
|
|
|
|
|
|
|
|
if (compressed.writableBytes() == 0) {
|
|
|
|
compressed.ensureWritable(8192);
|
|
|
|
}
|
2020-11-20 05:37:13 +01:00
|
|
|
}
|
2021-06-20 20:59:53 +02:00
|
|
|
|
|
|
|
deflater.reset();
|
2020-11-20 05:37:13 +01:00
|
|
|
}
|
|
|
|
|
2021-03-26 13:08:05 +01:00
|
|
|
public static void writeFramedPacket(@NotNull ByteBuf buffer,
|
2021-03-28 15:58:52 +02:00
|
|
|
@NotNull ServerPacket serverPacket) {
|
2021-03-22 14:31:38 +01:00
|
|
|
final int compressionThreshold = MinecraftServer.getCompressionThreshold();
|
2020-11-20 05:37:13 +01:00
|
|
|
|
2021-05-10 05:47:14 +02:00
|
|
|
// Index of the var-int containing the complete packet length
|
2021-05-11 03:10:18 +02:00
|
|
|
final int packetLengthIndex = Utils.writeEmpty3BytesVarInt(buffer);
|
|
|
|
final int startIndex = buffer.writerIndex(); // Index where the content starts (after length)
|
2021-05-10 11:02:12 +02:00
|
|
|
if (compressionThreshold > 0) {
|
2021-05-10 05:47:14 +02:00
|
|
|
// Index of the uncompressed payload length
|
2021-05-11 03:10:18 +02:00
|
|
|
final int dataLengthIndex = Utils.writeEmpty3BytesVarInt(buffer);
|
2021-03-26 15:58:46 +01:00
|
|
|
|
|
|
|
// Write packet
|
|
|
|
final int contentIndex = buffer.writerIndex();
|
|
|
|
writePacket(buffer, serverPacket);
|
2021-05-10 11:02:12 +02:00
|
|
|
final int packetSize = buffer.writerIndex() - contentIndex;
|
2021-03-26 15:58:46 +01:00
|
|
|
|
2021-05-10 11:02:12 +02:00
|
|
|
final int uncompressedLength = packetSize >= compressionThreshold ? packetSize : 0;
|
2021-05-11 03:10:18 +02:00
|
|
|
Utils.write3BytesVarInt(buffer, dataLengthIndex, uncompressedLength);
|
2021-05-10 11:02:12 +02:00
|
|
|
if (uncompressedLength > 0) {
|
2021-05-10 07:00:16 +02:00
|
|
|
// Packet large enough, compress
|
2021-03-28 15:58:52 +02:00
|
|
|
ByteBuf uncompressedCopy = buffer.copy(contentIndex, packetSize);
|
|
|
|
buffer.writerIndex(contentIndex);
|
2021-05-10 11:03:58 +02:00
|
|
|
compress(COMPRESSOR.get(), uncompressedCopy, buffer);
|
2021-03-28 15:58:52 +02:00
|
|
|
uncompressedCopy.release();
|
2021-03-26 13:08:05 +01:00
|
|
|
}
|
2021-03-26 15:58:46 +01:00
|
|
|
} else {
|
2021-05-10 05:47:14 +02:00
|
|
|
// No compression, write packet id + payload
|
2021-03-26 15:58:46 +01:00
|
|
|
writePacket(buffer, serverPacket);
|
2021-03-26 13:08:05 +01:00
|
|
|
}
|
2021-05-10 11:02:12 +02:00
|
|
|
// Total length
|
2021-05-11 03:10:18 +02:00
|
|
|
final int totalPacketLength = buffer.writerIndex() - startIndex;
|
|
|
|
Utils.write3BytesVarInt(buffer, packetLengthIndex, totalPacketLength);
|
2021-03-26 13:08:05 +01:00
|
|
|
}
|
2021-03-22 14:31:38 +01:00
|
|
|
|
2021-03-26 13:08:05 +01:00
|
|
|
/**
|
|
|
|
* Creates a "framed packet" (packet which can be send and understood by a Minecraft client)
|
|
|
|
* from a server packet, directly into an output buffer.
|
|
|
|
* <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.
|
|
|
|
*/
|
2021-05-08 22:45:57 +02:00
|
|
|
public static @NotNull ByteBuf createFramedPacket(@NotNull ServerPacket serverPacket) {
|
|
|
|
ByteBuf packetBuf = BufUtils.direct();
|
2021-03-28 15:58:52 +02:00
|
|
|
writeFramedPacket(packetBuf, serverPacket);
|
2021-03-26 13:08:05 +01:00
|
|
|
return packetBuf;
|
2020-11-20 05:37:13 +01:00
|
|
|
}
|
2019-08-22 14:52:32 +02:00
|
|
|
}
|