Update bungee platform injection handlers for rewrite refactor

booky10 · Dec 29, 2024 · 6ba494e · 6ba494e
1 parent ac6cd15
commit 6ba494e
Show file tree

Hide file tree

Showing 2 changed files with 48 additions and 76 deletions.
diff --git a/bungeecord/src/main/java/io/github/retrooper/packetevents/handlers/PacketEventsDecoder.java b/bungeecord/src/main/java/io/github/retrooper/packetevents/handlers/PacketEventsDecoder.java
@@ -18,11 +18,10 @@
 
 package io.github.retrooper.packetevents.handlers;
 
-import com.github.retrooper.packetevents.PacketEvents;
-import com.github.retrooper.packetevents.event.PacketReceiveEvent;
-import com.github.retrooper.packetevents.netty.buffer.ByteBufHelper;
+import com.github.retrooper.packetevents.event.ProtocolPacketEvent;
+import com.github.retrooper.packetevents.protocol.PacketSide;
 import com.github.retrooper.packetevents.protocol.player.User;
-import com.github.retrooper.packetevents.util.EventCreationUtil;
+import com.github.retrooper.packetevents.util.PacketEventsImplHelper;
 import io.github.retrooper.packetevents.injector.ServerConnectionInitializer;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandler;
@@ -35,52 +34,29 @@
 
 @ChannelHandler.Sharable
 public class PacketEventsDecoder extends MessageToMessageDecoder<ByteBuf> {
+
+    private final PacketSide side = PacketSide.CLIENT;
     public User user;
     public ProxiedPlayer player;
 
     public PacketEventsDecoder(User user) {
         this.user = user;
     }
 
-    public void read(ChannelHandlerContext ctx, ByteBuf byteBuf, List<Object> output) throws Exception {
-        ByteBuf transformed = ctx.alloc().buffer().writeBytes(byteBuf);
-        try {
-            int firstReaderIndex = transformed.readerIndex();
-            PacketReceiveEvent packetReceiveEvent = EventCreationUtil.createReceiveEvent(ctx.channel(),
-                    user, player, transformed, false);
-            int readerIndex = transformed.readerIndex();
-            PacketEvents.getAPI().getEventManager().callEvent(packetReceiveEvent, () -> transformed.readerIndex(readerIndex));
-            if (!packetReceiveEvent.isCancelled()) {
-                if (packetReceiveEvent.getLastUsedWrapper() != null) {
-                    ByteBufHelper.clear(packetReceiveEvent.getByteBuf());
-                    packetReceiveEvent.getLastUsedWrapper().writeVarInt(packetReceiveEvent.getPacketId());
-                    packetReceiveEvent.getLastUsedWrapper().write();
-                }
-                else {
-                    transformed.readerIndex(firstReaderIndex);
-                }
-                output.add(transformed.retain());
-            }
-            if (packetReceiveEvent.hasPostTasks()) {
-                for (Runnable task : packetReceiveEvent.getPostTasks()) {
-                    task.run();
-                }
-            }
-        } finally {
-            transformed.release();
-        }
-    }
-
     @Override
-    protected void decode(ChannelHandlerContext ctx, ByteBuf byteBuf, List<Object> out) throws Exception {
-        if (byteBuf.isReadable()) {
-            read(ctx, byteBuf, out);
+    protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
+        if (!msg.isReadable()) {
+            return;
         }
-    }
+        ProtocolPacketEvent event = PacketEventsImplHelper.handlePacket(ctx.channel(), this.user, this.player,
+                msg.retain(), false, this.side);
+        ByteBuf buf = event != null ? (ByteBuf) event.getByteBuf() : msg;
 
-    @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
-        super.exceptionCaught(ctx, cause);
+        if (buf.isReadable()) {
+            out.add(buf);
+        } else {
+            buf.release();
+        }
     }
 
     @Override

diff --git a/bungeecord/src/main/java/io/github/retrooper/packetevents/handlers/PacketEventsEncoder.java b/bungeecord/src/main/java/io/github/retrooper/packetevents/handlers/PacketEventsEncoder.java
@@ -19,10 +19,10 @@
 package io.github.retrooper.packetevents.handlers;
 
 import com.github.retrooper.packetevents.PacketEvents;
-import com.github.retrooper.packetevents.event.PacketSendEvent;
-import com.github.retrooper.packetevents.netty.buffer.ByteBufHelper;
+import com.github.retrooper.packetevents.event.ProtocolPacketEvent;
+import com.github.retrooper.packetevents.protocol.PacketSide;
 import com.github.retrooper.packetevents.protocol.player.User;
-import com.github.retrooper.packetevents.util.EventCreationUtil;
+import com.github.retrooper.packetevents.util.PacketEventsImplHelper;
 import io.github.retrooper.packetevents.injector.CustomPipelineUtil;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandler;
@@ -32,7 +32,6 @@
 import io.netty.channel.ChannelPromise;
 import io.netty.handler.codec.EncoderException;
 import io.netty.util.Recycler;
-import io.netty.util.ReferenceCountUtil;
 import io.netty.util.concurrent.PromiseCombiner;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 
@@ -51,6 +50,7 @@ protected OutList newObject(Handle<OutList> handle) {
         }
     };
 
+    private final PacketSide side = PacketSide.SERVER;
     public ProxiedPlayer player;
     public User user;
     public boolean handledCompression;
@@ -59,47 +59,43 @@ public PacketEventsEncoder(User user) {
         this.user = user;
     }
 
-    public void read(ChannelHandlerContext ctx, ByteBuf buffer, ChannelPromise promise) throws Exception {
-        boolean doCompression = handleCompressionOrder(ctx, buffer);
-        int firstReaderIndex = buffer.readerIndex();
-        PacketSendEvent packetSendEvent = EventCreationUtil.createSendEvent(ctx.channel(), user, player,
-                buffer, false);
-        int readerIndex = buffer.readerIndex();
-        PacketEvents.getAPI().getEventManager().callEvent(packetSendEvent, () -> buffer.readerIndex(readerIndex));
-        if (!packetSendEvent.isCancelled()) {
-            if (packetSendEvent.getLastUsedWrapper() != null) {
-                ByteBufHelper.clear(packetSendEvent.getByteBuf());
-                packetSendEvent.getLastUsedWrapper().writeVarInt(packetSendEvent.getPacketId());
-                packetSendEvent.getLastUsedWrapper().write();
-            } else {
-                buffer.readerIndex(firstReaderIndex);
-            }
-            if (doCompression) {
-                this.recompress(ctx, buffer, promise);
-            } else {
-                ctx.write(buffer, promise);
-            }
-        } else {
-            ReferenceCountUtil.release(packetSendEvent.getByteBuf());
+    public void handle(ChannelHandlerContext ctx, ByteBuf in, ChannelPromise promise) throws Exception {
+        boolean doCompression = this.handleCompressionOrder(ctx, in);
+        ProtocolPacketEvent event = PacketEventsImplHelper.handlePacket(ctx.channel(),
+                this.user, this.player, in.retain(), false, this.side);
+        ByteBuf buf = event != null ? (ByteBuf) event.getByteBuf() : in;
+
+        if (!buf.isReadable()) {
+            // cancelled, stop it
+            buf.release();
+            promise.setSuccess(); // mark as done
+            return;
         }
-        if (packetSendEvent.hasPostTasks()) {
-            for (Runnable task : packetSendEvent.getPostTasks()) {
-                task.run();
-            }
+
+        if (doCompression) {
+            this.recompress(ctx, buf, promise);
+        } else {
+            ctx.write(buf, promise);
         }
     }
 
     @Override
     public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
         if (!(msg instanceof ByteBuf)) {
-            super.write(ctx, msg, promise);
+            ctx.write(msg, promise);
             return;
         }
-        ByteBuf buf = (ByteBuf) msg;
-        if (!buf.isReadable()) {
-            buf.release();
-        } else {
-            this.read(ctx, buf, promise);
+        ByteBuf in = (ByteBuf) msg;
+        if (!in.isReadable()) {
+            in.release();
+            promise.setSuccess(); // mark as done
+            return;
+        }
+
+        try {
+            this.handle(ctx, in, promise);
+        } finally {
+            in.release();
         }
     }