From 72223ececadac841487d57c501ec9bbb401c2925 Mon Sep 17 00:00:00 2001 From: Dries C Date: Sat, 10 Feb 2024 15:14:14 +0100 Subject: [PATCH] Add support for WDPE 2.0.2-Snapshot --- pom.xml | 2 +- .../compression/FrameIdCodec.java | 22 +++ .../compression/ProxyTransportAlgorithm.java | 11 ++ .../ProxyTransportCompressionCodec.java | 77 ++++++++++ .../compression/ZstdCompression.java | 67 +++++++++ .../compression/ZstdCompressionCodec.java | 136 ------------------ .../impl/TransportChannelInitializer.java | 17 ++- .../impl/TransportClientConnection.java | 51 +++++-- .../CustomTransportServerInfo.java | 17 ++- .../proxytransport/utils/CompressionType.java | 7 - 10 files changed, 234 insertions(+), 173 deletions(-) create mode 100644 src/main/java/org/nethergames/proxytransport/compression/FrameIdCodec.java create mode 100644 src/main/java/org/nethergames/proxytransport/compression/ProxyTransportAlgorithm.java create mode 100644 src/main/java/org/nethergames/proxytransport/compression/ProxyTransportCompressionCodec.java create mode 100644 src/main/java/org/nethergames/proxytransport/compression/ZstdCompression.java delete mode 100644 src/main/java/org/nethergames/proxytransport/compression/ZstdCompressionCodec.java delete mode 100644 src/main/java/org/nethergames/proxytransport/utils/CompressionType.java diff --git a/pom.xml b/pom.xml index 06140e1..c040d8f 100644 --- a/pom.xml +++ b/pom.xml @@ -39,7 +39,7 @@ dev.waterdog.waterdogpe waterdog - 2.0.1-SNAPSHOT + 2.0.2-SNAPSHOT provided diff --git a/src/main/java/org/nethergames/proxytransport/compression/FrameIdCodec.java b/src/main/java/org/nethergames/proxytransport/compression/FrameIdCodec.java new file mode 100644 index 0000000..1c2dafd --- /dev/null +++ b/src/main/java/org/nethergames/proxytransport/compression/FrameIdCodec.java @@ -0,0 +1,22 @@ +package org.nethergames.proxytransport.compression; + +import io.netty.buffer.ByteBuf; +import io.netty.channel.ChannelHandlerContext; +import io.netty.handler.codec.MessageToMessageCodec; +import org.cloudburstmc.protocol.bedrock.netty.BedrockBatchWrapper; + +import java.util.List; + +public class FrameIdCodec extends MessageToMessageCodec { + public static final String NAME = "frame-id-codec"; + + @Override + protected void encode(ChannelHandlerContext ctx, BedrockBatchWrapper msg, List out) throws Exception { + out.add(msg.getCompressed().retain()); + } + + @Override + protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List out) throws Exception { + out.add(BedrockBatchWrapper.newInstance(msg.readRetainedSlice(msg.readableBytes()), null)); + } +} diff --git a/src/main/java/org/nethergames/proxytransport/compression/ProxyTransportAlgorithm.java b/src/main/java/org/nethergames/proxytransport/compression/ProxyTransportAlgorithm.java new file mode 100644 index 0000000..5cf5764 --- /dev/null +++ b/src/main/java/org/nethergames/proxytransport/compression/ProxyTransportAlgorithm.java @@ -0,0 +1,11 @@ +package org.nethergames.proxytransport.compression; + +import org.cloudburstmc.protocol.bedrock.data.CompressionAlgorithm; + +public enum ProxyTransportAlgorithm implements CompressionAlgorithm { + ZSTD; + + private ProxyTransportAlgorithm() { + + } +} diff --git a/src/main/java/org/nethergames/proxytransport/compression/ProxyTransportCompressionCodec.java b/src/main/java/org/nethergames/proxytransport/compression/ProxyTransportCompressionCodec.java new file mode 100644 index 0000000..f77b664 --- /dev/null +++ b/src/main/java/org/nethergames/proxytransport/compression/ProxyTransportCompressionCodec.java @@ -0,0 +1,77 @@ +package org.nethergames.proxytransport.compression; + +import dev.waterdog.waterdogpe.network.connection.codec.compression.ProxiedCompressionCodec; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.CompositeByteBuf; +import io.netty.channel.ChannelHandlerContext; +import org.cloudburstmc.protocol.bedrock.data.CompressionAlgorithm; +import org.cloudburstmc.protocol.bedrock.data.PacketCompressionAlgorithm; +import org.cloudburstmc.protocol.bedrock.netty.BedrockBatchWrapper; +import org.cloudburstmc.protocol.bedrock.netty.codec.compression.BatchCompression; +import org.cloudburstmc.protocol.bedrock.netty.codec.compression.CompressionStrategy; + +import java.util.List; + +public class ProxyTransportCompressionCodec extends ProxiedCompressionCodec { + private final boolean prefixed; + private final ZstdCompression zstdCompression = new ZstdCompression(); + + public ProxyTransportCompressionCodec(CompressionStrategy strategy, boolean prefixed) { + super(strategy, prefixed); + this.prefixed = prefixed; + } + + protected void encode(ChannelHandlerContext ctx, BedrockBatchWrapper msg, List out) throws Exception { + if (msg.getCompressed() == null && msg.getUncompressed() == null) { + throw new IllegalStateException("Batch was not encoded before"); + } else if (msg.getCompressed() != null && !msg.isModified()) { // already compressed + if (!this.prefixed) { // we need to prefix the compressed data + CompositeByteBuf buf = ctx.alloc().compositeDirectBuffer(2); + buf.addComponent(true, ctx.alloc().ioBuffer(1).writeByte(getCompressionHeader(msg.getAlgorithm()))); + buf.addComponent(true, msg.getCompressed().retainedSlice()); + msg.setCompressed(buf, msg.getAlgorithm()); + } + + this.onPassedThrough(ctx, msg); + out.add(msg.retain()); + } else { + BatchCompression compression = this.getStrategy().getCompression(msg); + if (!compression.getAlgorithm().equals(PacketCompressionAlgorithm.NONE)) { + compression = this.zstdCompression; + } + + ByteBuf compressed = compression.encode(ctx, msg.getUncompressed()); + + try { + ByteBuf outBuf; + + outBuf = ctx.alloc().ioBuffer(1 + compressed.readableBytes()); + outBuf.writeByte(this.getCompressionHeader(compression.getAlgorithm())); + outBuf.writeBytes(compressed); + + msg.setCompressed(outBuf, compression.getAlgorithm()); + } finally { + compressed.release(); + } + + this.onCompressed(ctx, msg); + out.add(msg.retain()); + } + } + + protected byte getCompressionHeader0(CompressionAlgorithm algorithm) { + if (algorithm instanceof ProxyTransportAlgorithm) { + return -2; + } + + return super.getCompressionHeader0(algorithm); + } + + protected CompressionAlgorithm getCompressionAlgorithm0(byte header) { + if (header == -2) { + return ProxyTransportAlgorithm.ZSTD; + } + + return super.getCompressionAlgorithm0(header); + } +} diff --git a/src/main/java/org/nethergames/proxytransport/compression/ZstdCompression.java b/src/main/java/org/nethergames/proxytransport/compression/ZstdCompression.java new file mode 100644 index 0000000..f87499c --- /dev/null +++ b/src/main/java/org/nethergames/proxytransport/compression/ZstdCompression.java @@ -0,0 +1,67 @@ +package org.nethergames.proxytransport.compression; + +import com.github.luben.zstd.Zstd; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.CompositeByteBuf; +import io.netty.channel.ChannelHandlerContext; +import io.netty.util.ReferenceCountUtil; +import org.cloudburstmc.protocol.bedrock.data.CompressionAlgorithm; +import org.cloudburstmc.protocol.bedrock.netty.codec.compression.BatchCompression; + +import java.nio.ByteBuffer; + +public class ZstdCompression implements BatchCompression { + private int level = -1; + + public ByteBuf encode(ChannelHandlerContext ctx, ByteBuf msg) throws Exception { + ByteBuf direct; + if (!msg.isDirect() || msg instanceof CompositeByteBuf) { + direct = ctx.alloc().ioBuffer(msg.readableBytes()); + direct.writeBytes(msg); + } else { + direct = msg; + } + + ByteBuf output = ctx.alloc().directBuffer(); + try { + int uncompressedLength = direct.readableBytes(); + int maxLength = (int) Zstd.compressBound(uncompressedLength); + + output.ensureWritable(maxLength); + + int compressedLength; + if (direct.hasMemoryAddress()) { + compressedLength = (int) Zstd.compressUnsafe(output.memoryAddress(), maxLength, direct.memoryAddress() + direct.readerIndex(), uncompressedLength, this.level); + } else { + ByteBuffer sourceNio = direct.nioBuffer(direct.readerIndex(), direct.readableBytes()); + ByteBuffer targetNio = output.nioBuffer(0, maxLength); + + compressedLength = Zstd.compress(targetNio, sourceNio, this.level); + } + + output.writerIndex(compressedLength); + return output.retain(); + } finally { + ReferenceCountUtil.release(output); + if (direct != msg) { + ReferenceCountUtil.release(direct); + } + } + } + + public ByteBuf decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception { + throw new UnsupportedOperationException("Zstd is not supported"); + } + + public CompressionAlgorithm getAlgorithm() { + return ProxyTransportAlgorithm.ZSTD; + } + + public void setLevel(int level) { + this.level = level; + } + + public int getLevel() { + return level; + } +} diff --git a/src/main/java/org/nethergames/proxytransport/compression/ZstdCompressionCodec.java b/src/main/java/org/nethergames/proxytransport/compression/ZstdCompressionCodec.java deleted file mode 100644 index 942ec47..0000000 --- a/src/main/java/org/nethergames/proxytransport/compression/ZstdCompressionCodec.java +++ /dev/null @@ -1,136 +0,0 @@ -package org.nethergames.proxytransport.compression; - -import com.github.luben.zstd.Zstd; -import dev.waterdog.waterdogpe.ProxyServer; -import dev.waterdog.waterdogpe.network.NetworkMetrics; -import dev.waterdog.waterdogpe.network.PacketDirection; -import dev.waterdog.waterdogpe.network.connection.client.ClientConnection; -import dev.waterdog.waterdogpe.network.connection.codec.BedrockBatchWrapper; -import dev.waterdog.waterdogpe.network.connection.codec.compression.SnappyCompressionCodec; -import io.netty.buffer.ByteBuf; -import io.netty.buffer.CompositeByteBuf; -import io.netty.channel.ChannelHandlerContext; -import io.netty.handler.codec.MessageToMessageCodec; -import io.netty.util.ReferenceCountUtil; -import lombok.AllArgsConstructor; -import org.cloudburstmc.protocol.common.util.Zlib; -import org.nethergames.proxytransport.utils.CompressionType; - -import java.nio.ByteBuffer; -import java.util.List; - -@AllArgsConstructor -public class ZstdCompressionCodec extends MessageToMessageCodec { - public static final String NAME = "compression-codec"; - - private static final SnappyCompressionCodec snappyCompressionCodec = new SnappyCompressionCodec(); - - private final int compressionLevel; - private final ClientConnection connection; - - @Override - protected void encode(ChannelHandlerContext ctx, BedrockBatchWrapper msg, List out) { - CompositeByteBuf buf = ctx.alloc().compositeDirectBuffer(2); - - try { - NetworkMetrics metrics = ctx.channel().attr(NetworkMetrics.ATTRIBUTE).get(); - PacketDirection direction = ctx.channel().attr(PacketDirection.ATTRIBUTE).get(); - - // The batch is already compressed correctly, we can send the buffer straight to the server - if (!msg.isModified() && msg.getCompressed() != null) { - buf.addComponent(true, ctx.alloc().ioBuffer(1).writeByte(msg.getAlgorithm().getBedrockAlgorithm().ordinal())); - buf.addComponent(true, msg.getCompressed().retainedSlice()); - - if (metrics != null) { - metrics.passedThroughBytes(msg.getCompressed().readableBytes(), direction); - } - } else { - // The batch was modified or the wrapper has no compressed data while still retaining - // the uncompressed data. - if ((msg.isModified() || msg.getCompressed() == null) && msg.getUncompressed() == null) { - throw new IllegalArgumentException("BedrockPacket is not encoded."); - } - - msg.setCompressed(encode0(ctx, msg.getUncompressed())); - - buf.addComponent(true, ctx.alloc().ioBuffer(1).writeByte(CompressionType.METHOD_ZSTD.ordinal())); - buf.addComponent(true, msg.getCompressed().retainedSlice()); - - if (metrics != null) { - metrics.compressedBytes(msg.getCompressed().readableBytes(), direction); - } - } - - out.add(buf.retain()); - } catch (Throwable err) { - ProxyServer.getInstance().getLogger().error("An exception were thrown while encoding packet", err); - } finally { - ReferenceCountUtil.release(buf); - } - } - - @Override - protected void decode(ChannelHandlerContext ctx, ByteBuf compressed, List out) { - BedrockBatchWrapper msg = BedrockBatchWrapper.newInstance(compressed.retain(), null); - - try { - msg.setAlgorithm(connection.getPlayer().getCompression()); - switch (connection.getPlayer().getCompression().getBedrockAlgorithm()) { - case ZLIB -> msg.setUncompressed(Zlib.RAW.inflate(msg.getCompressed().slice(), 1024 * 1024 * 12)); - case SNAPPY -> msg.setUncompressed(snappyCompressionCodec.decode0(ctx, msg.getCompressed().slice())); - } - - if (msg.getUncompressed() == null) { - throw new UnsupportedOperationException("The given compression algorithm is not supported by ProxyTransport"); - } - - NetworkMetrics metrics = ctx.channel().attr(NetworkMetrics.ATTRIBUTE).get(); - if (metrics != null) { - PacketDirection direction = ctx.channel().attr(PacketDirection.ATTRIBUTE).get(); - metrics.decompressedBytes(msg.getUncompressed().readableBytes(), direction); - } - - out.add(msg.retain()); - } catch (Throwable err) { - ProxyServer.getInstance().getLogger().error("An exception were thrown while decoding packet", err); - } finally { - ReferenceCountUtil.release(msg); - } - } - - private ByteBuf encode0(ChannelHandlerContext ctx, ByteBuf source) { - ByteBuf direct; - if (!source.isDirect() || source instanceof CompositeByteBuf) { - direct = ctx.alloc().ioBuffer(source.readableBytes()); - direct.writeBytes(source); - } else { - direct = source; - } - - ByteBuf output = ctx.alloc().directBuffer(); - try { - int uncompressedLength = direct.readableBytes(); - int maxLength = (int) Zstd.compressBound(uncompressedLength); - - output.ensureWritable(maxLength); - - int compressedLength; - if (direct.hasMemoryAddress()) { - compressedLength = (int) Zstd.compressUnsafe(output.memoryAddress(), maxLength, direct.memoryAddress() + direct.readerIndex(), uncompressedLength, compressionLevel); - } else { - ByteBuffer sourceNio = direct.nioBuffer(direct.readerIndex(), direct.readableBytes()); - ByteBuffer targetNio = output.nioBuffer(0, maxLength); - - compressedLength = Zstd.compress(targetNio, sourceNio, compressionLevel); - } - - output.writerIndex(compressedLength); - return output.retain(); - } finally { - ReferenceCountUtil.release(output); - if (direct != source) { - ReferenceCountUtil.release(direct); - } - } - } -} diff --git a/src/main/java/org/nethergames/proxytransport/impl/TransportChannelInitializer.java b/src/main/java/org/nethergames/proxytransport/impl/TransportChannelInitializer.java index dadcabd..988e989 100644 --- a/src/main/java/org/nethergames/proxytransport/impl/TransportChannelInitializer.java +++ b/src/main/java/org/nethergames/proxytransport/impl/TransportChannelInitializer.java @@ -5,6 +5,8 @@ import dev.waterdog.waterdogpe.network.connection.client.ClientConnection; import dev.waterdog.waterdogpe.network.connection.codec.batch.BedrockBatchDecoder; import dev.waterdog.waterdogpe.network.connection.codec.batch.BedrockBatchEncoder; +import dev.waterdog.waterdogpe.network.connection.codec.client.ClientPacketQueue; +import dev.waterdog.waterdogpe.network.connection.codec.compression.CompressionType; import dev.waterdog.waterdogpe.network.connection.codec.packet.BedrockPacketCodec; import dev.waterdog.waterdogpe.network.serverinfo.ServerInfo; import dev.waterdog.waterdogpe.player.ProxiedPlayer; @@ -16,13 +18,14 @@ import org.cloudburstmc.netty.channel.raknet.RakChannel; import org.cloudburstmc.netty.channel.raknet.config.RakChannelOption; import org.cloudburstmc.netty.channel.raknet.config.RakMetrics; -import org.nethergames.proxytransport.compression.ZstdCompressionCodec; +import org.cloudburstmc.protocol.bedrock.netty.codec.compression.CompressionCodec; +import org.nethergames.proxytransport.compression.FrameIdCodec; +import org.nethergames.proxytransport.compression.ProxyTransportCompressionCodec; import org.nethergames.proxytransport.integration.CustomClientEventHandler; import static dev.waterdog.waterdogpe.network.connection.codec.initializer.ProxiedSessionInitializer.*; public class TransportChannelInitializer extends ChannelInitializer { - private static final int ZSTD_COMPRESSION_LEVEL = 3; private final ProxiedPlayer player; private final ServerInfo serverInfo; @@ -39,6 +42,7 @@ public TransportChannelInitializer(ProxiedPlayer player, ServerInfo serverInfo, @Override protected void initChannel(Channel channel) { int rakVersion = this.player.getProtocol().getRaknetVersion(); + CompressionType compression = this.player.getProxy().getConfiguration().getCompression(); channel.attr(PacketDirection.ATTRIBUTE).set(PacketDirection.FROM_SERVER); @@ -55,14 +59,15 @@ protected void initChannel(Channel channel) { .addLast(FRAME_DECODER, new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4)) .addLast(FRAME_ENCODER, new LengthFieldPrepender(4)); - - ClientConnection connection = this.createConnection(channel); channel.pipeline() - .addLast(ZstdCompressionCodec.NAME, new ZstdCompressionCodec(ZSTD_COMPRESSION_LEVEL, connection)) + .addLast(FrameIdCodec.NAME, new FrameIdCodec()) + .addLast(CompressionCodec.NAME, new ProxyTransportCompressionCodec(getCompressionStrategy(compression, rakVersion, true), false)) .addLast(BedrockBatchDecoder.NAME, BATCH_DECODER) .addLast(BedrockBatchEncoder.NAME, new BedrockBatchEncoder()) - .addLast(BedrockPacketCodec.NAME, getPacketCodec(rakVersion)); + .addLast(BedrockPacketCodec.NAME, getPacketCodec(rakVersion)) + .addLast(ClientPacketQueue.NAME, new ClientPacketQueue()); + ClientConnection connection = this.createConnection(channel); if (connection instanceof ChannelHandler handler) { // For reference: This will take care of the packets received being handled. channel.pipeline().addLast(ClientConnection.NAME, handler); } diff --git a/src/main/java/org/nethergames/proxytransport/impl/TransportClientConnection.java b/src/main/java/org/nethergames/proxytransport/impl/TransportClientConnection.java index f6b2c10..11d1800 100644 --- a/src/main/java/org/nethergames/proxytransport/impl/TransportClientConnection.java +++ b/src/main/java/org/nethergames/proxytransport/impl/TransportClientConnection.java @@ -1,23 +1,28 @@ package org.nethergames.proxytransport.impl; import dev.waterdog.waterdogpe.network.connection.client.BedrockClientConnection; -import dev.waterdog.waterdogpe.network.connection.codec.BedrockBatchWrapper; -import dev.waterdog.waterdogpe.network.connection.codec.compression.CompressionAlgorithm; import dev.waterdog.waterdogpe.network.connection.codec.packet.BedrockPacketCodec; +import dev.waterdog.waterdogpe.network.protocol.ProtocolVersion; import dev.waterdog.waterdogpe.network.protocol.handler.ProxyBatchBridge; import dev.waterdog.waterdogpe.network.serverinfo.ServerInfo; import dev.waterdog.waterdogpe.player.ProxiedPlayer; import io.netty.buffer.ByteBuf; import io.netty.channel.Channel; +import io.netty.channel.ChannelHandler; import io.netty.channel.ChannelHandlerContext; import lombok.NonNull; import lombok.extern.log4j.Log4j2; import org.cloudburstmc.protocol.bedrock.codec.BedrockCodec; import org.cloudburstmc.protocol.bedrock.codec.BedrockCodecHelper; +import org.cloudburstmc.protocol.bedrock.netty.BedrockBatchWrapper; import org.cloudburstmc.protocol.bedrock.netty.BedrockPacketWrapper; +import org.cloudburstmc.protocol.bedrock.netty.codec.compression.CompressionCodec; +import org.cloudburstmc.protocol.bedrock.netty.codec.compression.CompressionStrategy; import org.cloudburstmc.protocol.bedrock.packet.BedrockPacket; import org.cloudburstmc.protocol.bedrock.packet.NetworkStackLatencyPacket; import org.cloudburstmc.protocol.bedrock.packet.TickSyncPacket; +import org.nethergames.proxytransport.compression.FrameIdCodec; +import org.nethergames.proxytransport.compression.ProxyTransportCompressionCodec; import javax.crypto.SecretKey; import java.util.ArrayList; @@ -100,26 +105,36 @@ private void onBedrockBatch(@NonNull BedrockBatchWrapper batch) { } } + private boolean increaseRateLimit(int value) { + packetSendingLimit.set(this.packetSendingLimit.get() + value); + + if (packetSendingLimit.get() >= MAX_UPSTREAM_PACKETS) { + if (packetSendingLock.compareAndSet(false, true)) { + getPlayer().getLogger().warning(getPlayer().getName() + " sent too many packets (" + packetSendingLimit.get() + "/s), disconnecting."); + getPlayer().getConnection().disconnect("§cToo many packets!"); + } + } else return !packetSendingLock.get(); + + return false; + } + @Override public void sendPacket(BedrockPacket packet) { - this.sendPacket(BedrockBatchWrapper.create(getSubClientId(), packet)); + if (this.increaseRateLimit(1)) { + super.sendPacket(packet); + } } @Override public void sendPacketImmediately(BedrockPacket packet) { - this.sendPacket(BedrockBatchWrapper.create(getSubClientId(), packet)); + if (this.increaseRateLimit(1)) { + super.sendPacketImmediately(packet); + } } @Override public void sendPacket(BedrockBatchWrapper wrapper) { - packetSendingLimit.set(this.packetSendingLimit.get() + wrapper.getPackets().size()); - - if (packetSendingLimit.get() >= MAX_UPSTREAM_PACKETS) { - if (packetSendingLock.compareAndSet(false, true)) { - getPlayer().getLogger().warning(getPlayer().getName() + " sent too many packets (" + packetSendingLimit.get() + "/s), disconnecting."); - getPlayer().getConnection().disconnect("§cToo many packets!"); - } - } else if (!packetSendingLock.get()) { + if (this.increaseRateLimit(wrapper.getPackets().size())) { super.sendPacket(wrapper); return; } @@ -128,8 +143,16 @@ public void sendPacket(BedrockBatchWrapper wrapper) { } @Override - public void setCompression(CompressionAlgorithm compression) { - // We do not want to change compression because we have our own logic + public void setCompressionStrategy(CompressionStrategy strategy) { + super.setCompressionStrategy(strategy); + + boolean needsPrefix = this.getPlayer().getProtocol().isAfterOrEqual(ProtocolVersion.MINECRAFT_PE_1_20_60); + ChannelHandler handler = this.channel.pipeline().get(CompressionCodec.NAME); + if (handler == null) { + this.channel.pipeline().addAfter(FrameIdCodec.NAME, CompressionCodec.NAME, new ProxyTransportCompressionCodec(strategy, needsPrefix)); + } else { + this.channel.pipeline().replace(CompressionCodec.NAME, CompressionCodec.NAME, new ProxyTransportCompressionCodec(strategy, needsPrefix)); + } } @Override diff --git a/src/main/java/org/nethergames/proxytransport/integration/CustomTransportServerInfo.java b/src/main/java/org/nethergames/proxytransport/integration/CustomTransportServerInfo.java index d0ef0c9..41b7169 100644 --- a/src/main/java/org/nethergames/proxytransport/integration/CustomTransportServerInfo.java +++ b/src/main/java/org/nethergames/proxytransport/integration/CustomTransportServerInfo.java @@ -47,19 +47,18 @@ public Future createConnection(ProxiedPlayer proxiedPlayer) { EventLoop eventLoop = proxiedPlayer.getProxy().getWorkerEventLoopGroup().next(); Promise promise = eventLoop.newPromise(); - Bootstrap b = new Bootstrap() + new Bootstrap() .group(downstreamLoopGroup) .handler(new TransportChannelInitializer(proxiedPlayer, this, promise)) .localAddress(new InetSocketAddress("0.0.0.0", 0)) .channel(getProperSocketChannel()) - .remoteAddress(this.getAddress()); - - b.connect().addListener((ChannelFuture future) -> { - if (!future.isSuccess()) { - promise.tryFailure(future.cause()); - future.channel().close(); - } - }); + .remoteAddress(this.getAddress()) + .connect().addListener((ChannelFuture future) -> { + if (!future.isSuccess()) { + promise.tryFailure(future.cause()); + future.channel().close(); + } + }); return promise; } diff --git a/src/main/java/org/nethergames/proxytransport/utils/CompressionType.java b/src/main/java/org/nethergames/proxytransport/utils/CompressionType.java deleted file mode 100644 index 62fb838..0000000 --- a/src/main/java/org/nethergames/proxytransport/utils/CompressionType.java +++ /dev/null @@ -1,7 +0,0 @@ -package org.nethergames.proxytransport.utils; - -public enum CompressionType { - METHOD_ZLIB, - METHOD_ZSTD, - METHOD_SNAPPY; -} \ No newline at end of file