Status request

pom.xml

@@ -72,6 +72,11 @@
             <artifactId>commons-io</artifactId>
             <version>2.6</version>
         </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>24.1-jre</version>
+        </dependency>
     </dependencies>
 
     <build>

src/main/java/mc/core/CSPacket.java

@@ -5,4 +5,6 @@
 package mc.core;
 
 public interface CSPacket {
+    default void readSelf(NetStream netStream) {
+    }
 }

src/main/java/mc/core/NetStream.java

@@ -0,0 +1,57 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.nio.charset.StandardCharsets;
+
+@Slf4j
+public abstract class NetStream {
+    public static int sizeVarInt(final int value) {
+        byte size = 0;
+        int v = value;
+
+        do {
+            v >>>= 7;
+            size++;
+        } while (v != 0);
+
+        return size;
+    }
+
+    public int readVarInt() {
+        int result = 0;
+        byte read;
+        byte numRead = 0;
+
+        do {
+            read = readByte();
+            int value = (read & 0b01111111);
+            result |= (value << (7 * numRead));
+
+            numRead++;
+            if (numRead > 5) {
+                log.debug("VarInt is too big!");
+                break;
+            }
+        } while ((read & 0b10000000) != 0);
+
+        return result;
+    }
+
+    public String readString() {
+        int length = readVarInt();
+
+        byte[] buffer = new byte[length];
+        readBytes(buffer);
+
+        return new String(buffer, StandardCharsets.UTF_8);
+    }
+
+    public abstract byte readByte();
+    public abstract void readBytes(byte[] buffer);
+    public abstract int readUnsignedShort();
+}

src/main/java/mc/core/netty/PacketDecoder.java

@@ -8,62 +8,60 @@ import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.ByteToMessageDecoder;
 import lombok.extern.slf4j.Slf4j;
+import mc.core.CSPacket;
+import mc.core.NetStream;
 import mc.core.netty.packets.RawPacket;
 
 import java.util.List;
 
 @Slf4j
 public class PacketDecoder extends ByteToMessageDecoder {
-    private int readVarInt(ByteBuf byteBuf) throws Exception {
+    @Override
-        int result = 0;
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
-        byte read;
+        ctx.channel().attr(State.ATTR_STATE).set(State.STATUS);
-        byte numRead = 0;
+        ctx.fireChannelActive();
-
-        do {
-            read = byteBuf.readByte();
-            int value = (read & 0b01111111);
-            result |= (value << (7 * numRead));
-
-            numRead++;
-            if (numRead > 5)
-                throw new Exception("VarInt is too big");
-        } while ((read & 0b10000000) != 0);
-
-        return result;
     }
 
-    private int sizeVarInt(final int value) {
+    @Override
-        byte size = 0;
+    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
-        int v = value;
+        ctx.channel().attr(State.ATTR_STATE).set(null);
-
+        ctx.fireChannelInactive();
-        do {
-            v >>>= 7;
-            size++;
-        } while (v != 0);
-
-        return size;
     }
 
     @Override
     protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
+        State state = ctx.channel().attr(State.ATTR_STATE).get();
+        NetStream netStream = new WrapperNetStream(in);
+
         log.debug("ByteBuf readableBytes: {}", in.readableBytes());
 
-        int size = readVarInt(in);
+        int size = netStream.readVarInt();
         log.debug("Pkt-Size: {}", size);
-        int id = readVarInt(in);
+        int id = netStream.readVarInt();
         log.debug("Pkt-Id: {}", id);
 
-        byte[] rawData;
+        Class<? extends CSPacket> clientSidePacketClass = state.getClientSidePacket(id);
-        if (size > in.readableBytes()) {
+        if (clientSidePacketClass == null) {
-            rawData = new byte[in.readableBytes()];
+            log.warn("Unknown packet: {}:{}", state.name(), id);
-        } else {
-            rawData = new byte[size - sizeVarInt(id)];
-        }
-        in.readBytes(rawData);
 
-        RawPacket packet = new RawPacket();
+            if (log.isDebugEnabled()) {
-        packet.setRawData(rawData);
+                byte[] rawData;
-        out.add(packet);
+                if (size > in.readableBytes()) {
+                    rawData = new byte[in.readableBytes()];
+                } else {
+                    rawData = new byte[size - NetStream.sizeVarInt(id)];
+                }
+                in.readBytes(rawData);
+
+                RawPacket packet = new RawPacket();
+                packet.setRawData(rawData);
+                out.add(packet);
+            }
+        } else {
+            CSPacket packet = clientSidePacketClass.newInstance();
+            packet.readSelf(netStream);
+            out.add(packet);
+        }
 
         log.debug("ByteBuf readableBytes: {}", in.readableBytes());
         in.skipBytes(in.readableBytes());

src/main/java/mc/core/netty/PacketHandler.java

@@ -8,11 +8,32 @@ import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
 import lombok.extern.slf4j.Slf4j;
 import mc.core.CSPacket;
+import mc.core.netty.packets.StatusRequest;
+
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Optional;
 
 @Slf4j
 public class PacketHandler extends SimpleChannelInboundHandler<CSPacket> {
     @Override
     protected void channelRead0(ChannelHandlerContext ctx, CSPacket packet) throws Exception {
-        log.info("{}: {}", packet.getClass().getSimpleName(), packet.toString());
+        log.debug("{}: {}", packet.getClass().getSimpleName(), packet.toString());
+
+        Optional<Method> optionalMethod = Arrays.stream(this.getClass().getDeclaredMethods())
+                .filter(method -> method.getName().equals("on" + packet.getClass().getSimpleName())
+                    && method.getParameterCount() == 2
+                    && method.getParameterTypes()[0].isAssignableFrom(ctx.getClass())
+                    && method.getParameterTypes()[1].isAssignableFrom(packet.getClass()))
+                .findFirst();
+
+        if (optionalMethod.isPresent()) {
+            Method method = optionalMethod.get();
+            method.invoke(this, ctx, packet);
+        }
+    }
+
+    public void onStatusRequest(ChannelHandlerContext ctx, StatusRequest packet) {
+        log.info("Catch!");
     }
 }

src/main/java/mc/core/netty/State.java

@@ -0,0 +1,40 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core.netty;
+
+import com.google.common.collect.ImmutableMap;
+import io.netty.util.AttributeKey;
+import lombok.RequiredArgsConstructor;
+import mc.core.CSPacket;
+import mc.core.netty.packets.StatusRequest;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Optional;
+
+@RequiredArgsConstructor
+public enum State {
+    UNKNOWN(0, ImmutableMap.of()),
+    STATUS(1, ImmutableMap.of(
+            0, StatusRequest.class
+    ));
+
+    public static final AttributeKey<State> ATTR_STATE = AttributeKey.newInstance("ATTR_STATE");
+
+    public static State getStateById(final int id) {
+        Optional<State> optionalState = Arrays.stream(State.values())
+                .filter(state -> state.id == id)
+                .findFirst();
+
+        return optionalState.orElse(UNKNOWN);
+    }
+
+    private final int id;
+    private final Map<Integer, Class<? extends CSPacket>> clientSidePackets;
+
+    public Class<? extends CSPacket> getClientSidePacket(final int packetId) {
+        return clientSidePackets.get(packetId);
+    }
+}

src/main/java/mc/core/netty/WrapperNetStream.java

@@ -0,0 +1,29 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core.netty;
+
+import io.netty.buffer.ByteBuf;
+import lombok.RequiredArgsConstructor;
+import mc.core.NetStream;
+
+@RequiredArgsConstructor
+public class WrapperNetStream extends NetStream {
+    private final ByteBuf byteBuf;
+
+    @Override
+    public byte readByte() {
+        return byteBuf.readByte();
+    }
+
+    @Override
+    public void readBytes(byte[] buffer) {
+        byteBuf.readBytes(buffer);
+    }
+
+    @Override
+    public int readUnsignedShort() {
+        return byteBuf.readUnsignedShort();
+    }
+}

src/main/java/mc/core/netty/packets/StatusRequest.java

@@ -0,0 +1,38 @@
+/*
+ * DmitriyMX <dimon550@gmail.com>
+ * 2018-04-08
+ */
+package mc.core.netty.packets;
+
+import lombok.Getter;
+import lombok.ToString;
+import lombok.extern.slf4j.Slf4j;
+import mc.core.CSPacket;
+import mc.core.NetStream;
+import mc.core.netty.State;
+
+@Slf4j
+@Getter
+@ToString
+public class StatusRequest implements CSPacket {
+    private int protocolVersion;
+    private String serverAddress;
+    private int serverPort;
+    private State nextState;
+
+    @Override
+    public void readSelf(NetStream netStream) {
+        protocolVersion = netStream.readVarInt();
+        serverAddress = netStream.readString();
+        serverPort = netStream.readUnsignedShort();
+
+        int nextStateId = netStream.readVarInt();
+        State state = State.getStateById(nextStateId);
+        if (state != null) {
+            nextState = state;
+        } else {
+            log.warn("Unknown state ({})!", nextStateId);
+            nextState = State.UNKNOWN;
+        }
+    }
+}