1.20.2 Support

api/src/main/java/com/velocitypowered/api/network/ProtocolVersion.java

@@ -62,7 +62,8 @@ public enum ProtocolVersion {
   MINECRAFT_1_19_1(760, "1.19.1", "1.19.2"),
   MINECRAFT_1_19_3(761, "1.19.3"),
   MINECRAFT_1_19_4(762, "1.19.4"),
-  MINECRAFT_1_20(763, "1.20", "1.20.1");
+  MINECRAFT_1_20(763, "1.20", "1.20.1"),
+  MINECRAFT_1_20_2(764, "1.20.2");
 
   private static final int SNAPSHOT_BIT = 30;
 

api/src/main/java/com/velocitypowered/api/proxy/LoginPhaseConnection.java

@@ -26,7 +26,7 @@ public interface LoginPhaseConnection extends InboundConnection, KeyIdentifiable
    * @param contents the message to send
    * @param consumer the consumer that will respond to the message
    */
-  void sendLoginPluginMessage(ChannelIdentifier identifier, byte[] contents,
+  void sendLoginPluginMessage(int messageId, ChannelIdentifier identifier, byte[] contents,
       MessageConsumer consumer);
 
   /**

proxy/build.gradle.kts

@@ -12,7 +12,8 @@ application {
 
 tasks {
     withType<Checkstyle> {
-        exclude("**/com/velocitypowered/proxy/protocol/packet/**")
+        exclude("**/com/velocitypowered/proxy/protocol/**")
+        exclude("**/com/velocitypowered/proxy/connection/**")
     }
 
     jar {

proxy/src/main/java/com/velocitypowered/proxy/connection/MinecraftConnection.java

@@ -60,6 +60,9 @@
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.security.GeneralSecurityException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 import javax.crypto.SecretKey;
 import javax.crypto.spec.SecretKeySpec;
@@ -78,7 +81,8 @@ public class MinecraftConnection extends ChannelInboundHandlerAdapter {
   private final Channel channel;
   private SocketAddress remoteAddress;
   private StateRegistry state;
-  private @Nullable MinecraftSessionHandler sessionHandler;
+  private Map<StateRegistry, MinecraftSessionHandler> sessionHandlers;
+  private @Nullable MinecraftSessionHandler activeSessionHandler;
   private ProtocolVersion protocolVersion;
   private @Nullable MinecraftConnectionAssociation association;
   public final VelocityServer server;
@@ -96,12 +100,14 @@ public MinecraftConnection(Channel channel, VelocityServer server) {
     this.remoteAddress = channel.remoteAddress();
     this.server = server;
     this.state = StateRegistry.HANDSHAKE;
+
+    this.sessionHandlers = new HashMap<>();
   }
 
   @Override
   public void channelActive(ChannelHandlerContext ctx) throws Exception {
-    if (sessionHandler != null) {
-      sessionHandler.connected();
+    if (activeSessionHandler != null) {
+      activeSessionHandler.connected();
     }
 
     if (association != null && server.getConfiguration().isLogPlayerConnections()) {
@@ -111,26 +117,26 @@ public void channelActive(ChannelHandlerContext ctx) throws Exception {
 
   @Override
   public void channelInactive(ChannelHandlerContext ctx) throws Exception {
-    if (sessionHandler != null) {
-      sessionHandler.disconnected();
+    if (activeSessionHandler != null) {
+      activeSessionHandler.disconnected();
     }
 
     if (association != null && !knownDisconnect
-        && !(sessionHandler instanceof StatusSessionHandler)
-        && server.getConfiguration().isLogPlayerConnections()) {
+            && !(activeSessionHandler instanceof StatusSessionHandler)
+            && server.getConfiguration().isLogPlayerConnections()) {
       logger.info("{} has disconnected", association);
     }
   }
 
   @Override
   public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
     try {
-      if (sessionHandler == null) {
+      if (activeSessionHandler == null) {
         // No session handler available, do nothing
         return;
       }
 
-      if (sessionHandler.beforeHandle()) {
+      if (activeSessionHandler.beforeHandle()) {
         return;
       }
 
@@ -140,15 +146,15 @@ public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
 
       if (msg instanceof MinecraftPacket) {
         MinecraftPacket pkt = (MinecraftPacket) msg;
-        if (!pkt.handle(sessionHandler)) {
-          sessionHandler.handleGeneric((MinecraftPacket) msg);
+        if (!pkt.handle(activeSessionHandler)) {
+          activeSessionHandler.handleGeneric((MinecraftPacket) msg);
         }
       } else if (msg instanceof HAProxyMessage) {
         HAProxyMessage proxyMessage = (HAProxyMessage) msg;
         this.remoteAddress = new InetSocketAddress(proxyMessage.sourceAddress(),
-            proxyMessage.sourcePort());
+                proxyMessage.sourcePort());
       } else if (msg instanceof ByteBuf) {
-        sessionHandler.handleUnknown((ByteBuf) msg);
+        activeSessionHandler.handleUnknown((ByteBuf) msg);
       }
     } finally {
       ReferenceCountUtil.release(msg);
@@ -157,34 +163,34 @@ public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
 
   @Override
   public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
-    if (sessionHandler != null) {
-      sessionHandler.readCompleted();
+    if (activeSessionHandler != null) {
+      activeSessionHandler.readCompleted();
     }
   }
 
   @Override
   public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
     if (ctx.channel().isActive()) {
-      if (sessionHandler != null) {
+      if (activeSessionHandler != null) {
         try {
-          sessionHandler.exception(cause);
+          activeSessionHandler.exception(cause);
         } catch (Exception ex) {
           logger.error("{}: exception handling exception in {}",
-              (association != null ? association : channel.remoteAddress()), sessionHandler, cause);
+                  (association != null ? association : channel.remoteAddress()), activeSessionHandler, cause);
         }
       }
 
       if (association != null) {
         if (cause instanceof ReadTimeoutException) {
           logger.error("{}: read timed out", association);
         } else {
-          boolean frontlineHandler = sessionHandler instanceof InitialLoginSessionHandler
-              || sessionHandler instanceof HandshakeSessionHandler
-              || sessionHandler instanceof StatusSessionHandler;
+          boolean frontlineHandler = activeSessionHandler instanceof InitialLoginSessionHandler
+                  || activeSessionHandler instanceof HandshakeSessionHandler
+                  || activeSessionHandler instanceof StatusSessionHandler;
           boolean isQuietDecoderException = cause instanceof QuietDecoderException;
           boolean willLog = !isQuietDecoderException && !frontlineHandler;
           if (willLog) {
-            logger.error("{}: exception encountered in {}", association, sessionHandler, cause);
+            logger.error("{}: exception encountered in {}", association, activeSessionHandler, cause);
           } else {
             knownDisconnect = true;
           }
@@ -197,8 +203,8 @@ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws E
 
   @Override
   public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
-    if (sessionHandler != null) {
-      sessionHandler.writabilityChanged();
+    if (activeSessionHandler != null) {
+      activeSessionHandler.writabilityChanged();
     }
   }
 
@@ -253,7 +259,7 @@ public void flush() {
   public void closeWith(Object msg) {
     if (channel.isActive()) {
       boolean is17 = this.getProtocolVersion().compareTo(ProtocolVersion.MINECRAFT_1_8) < 0
-          && this.getProtocolVersion().compareTo(ProtocolVersion.MINECRAFT_1_7_2) >= 0;
+              && this.getProtocolVersion().compareTo(ProtocolVersion.MINECRAFT_1_7_2) >= 0;
       if (is17 && this.getState() != StateRegistry.STATUS) {
         channel.eventLoop().execute(() -> {
           // 1.7.x versions have a race condition with switching protocol states, so just explicitly
@@ -341,12 +347,8 @@ public void setAutoReading(boolean autoReading) {
     }
   }
 
-  /**
-   * Changes the state of the Minecraft connection.
-   *
-   * @param state the new state
-   */
-  public void setState(StateRegistry state) {
+  // Ideally only used by the state switch
+  private void setState(StateRegistry state) {
     ensureInEventLoop();
 
     this.state = state;
@@ -382,25 +384,73 @@ public void setProtocolVersion(ProtocolVersion protocolVersion) {
     }
   }
 
-  public @Nullable MinecraftSessionHandler getSessionHandler() {
-    return sessionHandler;
+  public @Nullable MinecraftSessionHandler getActiveSessionHandler() {
+    return activeSessionHandler;
+  }
+
+  public @Nullable MinecraftSessionHandler getSessionHandlerForRegistry(StateRegistry registry) {
+    return this.sessionHandlers.getOrDefault(registry, null);
   }
 
   /**
    * Sets the session handler for this connection.
    *
+   * @param registry the registry of the handler
    * @param sessionHandler the handler to use
    */
-  public void setSessionHandler(MinecraftSessionHandler sessionHandler) {
+  public void setActiveSessionHandler(StateRegistry registry, MinecraftSessionHandler sessionHandler) {
+    Preconditions.checkNotNull(registry);
     ensureInEventLoop();
 
-    if (this.sessionHandler != null) {
-      this.sessionHandler.deactivated();
+    if (this.activeSessionHandler != null) {
+      this.activeSessionHandler.deactivated();
     }
-    this.sessionHandler = sessionHandler;
+    this.sessionHandlers.put(registry, sessionHandler);
+    this.activeSessionHandler = sessionHandler;
+    setState(registry);
     sessionHandler.activated();
   }
 
+  /**
+   * Switches the active session handler to the respective registry one.
+   *
+   * @param registry the registry of the handler
+   * @return true if successful and handler is present
+   */
+  public boolean setActiveSessionHandler(StateRegistry registry) {
+    Preconditions.checkNotNull(registry);
+    ensureInEventLoop();
+
+    MinecraftSessionHandler handler = getSessionHandlerForRegistry(registry);
+    if (handler != null) {
+      boolean flag = true;
+      if (this.activeSessionHandler != null
+              && (flag = !Objects.equals(handler, this.activeSessionHandler))) {
+        this.activeSessionHandler.deactivated();
+      }
+      this.activeSessionHandler = handler;
+      setState(registry);
+      if (flag) {
+        handler.activated();
+      }
+    }
+    return handler != null;
+  }
+
+  /**
+   * Adds a secondary session handler for this connection.
+   *
+   * @param registry the registry of the handler
+   * @param sessionHandler the handler to use
+   */
+  public void addSessionHandler(StateRegistry registry, MinecraftSessionHandler sessionHandler) {
+    Preconditions.checkNotNull(registry);
+    Preconditions.checkArgument(registry != state, "Handler would overwrite handler");
+    ensureInEventLoop();
+
+    this.sessionHandlers.put(registry, sessionHandler);
+  }
+
   private void ensureOpen() {
     Preconditions.checkState(!isClosed(), "Connection is closed.");
   }
@@ -421,14 +471,14 @@ public void setCompressionThreshold(int threshold) {
 
       if (removedDecoder != null && removedEncoder != null) {
         channel.pipeline().addBefore(MINECRAFT_DECODER, FRAME_ENCODER,
-            MinecraftVarintLengthEncoder.INSTANCE);
+                MinecraftVarintLengthEncoder.INSTANCE);
         channel.pipeline().fireUserEventTriggered(VelocityConnectionEvent.COMPRESSION_DISABLED);
       }
     } else {
       MinecraftCompressDecoder decoder = (MinecraftCompressDecoder) channel.pipeline()
-          .get(COMPRESSION_DECODER);
+              .get(COMPRESSION_DECODER);
       MinecraftCompressorAndLengthEncoder encoder =
-          (MinecraftCompressorAndLengthEncoder) channel.pipeline().get(COMPRESSION_ENCODER);
+              (MinecraftCompressorAndLengthEncoder) channel.pipeline().get(COMPRESSION_ENCODER);
       if (decoder != null && encoder != null) {
         decoder.setThreshold(threshold);
         encoder.setThreshold(threshold);
@@ -464,9 +514,9 @@ public void enableEncryption(byte[] secret) throws GeneralSecurityException {
     VelocityCipher decryptionCipher = factory.forDecryption(key);
     VelocityCipher encryptionCipher = factory.forEncryption(key);
     channel.pipeline()
-        .addBefore(FRAME_DECODER, CIPHER_DECODER, new MinecraftCipherDecoder(decryptionCipher));
+            .addBefore(FRAME_DECODER, CIPHER_DECODER, new MinecraftCipherDecoder(decryptionCipher));
     channel.pipeline()
-        .addBefore(FRAME_ENCODER, CIPHER_ENCODER, new MinecraftCipherEncoder(encryptionCipher));
+            .addBefore(FRAME_ENCODER, CIPHER_ENCODER, new MinecraftCipherEncoder(encryptionCipher));
 
     channel.pipeline().fireUserEventTriggered(VelocityConnectionEvent.ENCRYPTION_ENABLED);
   }
@@ -498,4 +548,4 @@ public void setType(ConnectionType connectionType) {
     this.connectionType = connectionType;
   }
 
-}
+}

proxy/src/main/java/com/velocitypowered/proxy/connection/MinecraftSessionHandler.java

@@ -18,43 +18,15 @@
 package com.velocitypowered.proxy.connection;
 
 import com.velocitypowered.proxy.protocol.MinecraftPacket;
-import com.velocitypowered.proxy.protocol.packet.AvailableCommands;
-import com.velocitypowered.proxy.protocol.packet.BossBar;
-import com.velocitypowered.proxy.protocol.packet.ClientSettings;
-import com.velocitypowered.proxy.protocol.packet.Disconnect;
-import com.velocitypowered.proxy.protocol.packet.EncryptionRequest;
-import com.velocitypowered.proxy.protocol.packet.EncryptionResponse;
-import com.velocitypowered.proxy.protocol.packet.Handshake;
-import com.velocitypowered.proxy.protocol.packet.HeaderAndFooter;
-import com.velocitypowered.proxy.protocol.packet.JoinGame;
-import com.velocitypowered.proxy.protocol.packet.KeepAlive;
-import com.velocitypowered.proxy.protocol.packet.LegacyHandshake;
-import com.velocitypowered.proxy.protocol.packet.LegacyPing;
-import com.velocitypowered.proxy.protocol.packet.LegacyPlayerListItem;
-import com.velocitypowered.proxy.protocol.packet.LoginPluginMessage;
-import com.velocitypowered.proxy.protocol.packet.LoginPluginResponse;
-import com.velocitypowered.proxy.protocol.packet.PluginMessage;
-import com.velocitypowered.proxy.protocol.packet.RemovePlayerInfo;
-import com.velocitypowered.proxy.protocol.packet.ResourcePackRequest;
-import com.velocitypowered.proxy.protocol.packet.ResourcePackResponse;
-import com.velocitypowered.proxy.protocol.packet.Respawn;
-import com.velocitypowered.proxy.protocol.packet.ServerData;
-import com.velocitypowered.proxy.protocol.packet.ServerLogin;
-import com.velocitypowered.proxy.protocol.packet.ServerLoginSuccess;
-import com.velocitypowered.proxy.protocol.packet.SetCompression;
-import com.velocitypowered.proxy.protocol.packet.StatusPing;
-import com.velocitypowered.proxy.protocol.packet.StatusRequest;
-import com.velocitypowered.proxy.protocol.packet.StatusResponse;
-import com.velocitypowered.proxy.protocol.packet.TabCompleteRequest;
-import com.velocitypowered.proxy.protocol.packet.TabCompleteResponse;
-import com.velocitypowered.proxy.protocol.packet.UpsertPlayerInfo;
+import com.velocitypowered.proxy.protocol.packet.*;
 import com.velocitypowered.proxy.protocol.packet.chat.PlayerChatCompletion;
 import com.velocitypowered.proxy.protocol.packet.chat.SystemChat;
 import com.velocitypowered.proxy.protocol.packet.chat.keyed.KeyedPlayerChat;
 import com.velocitypowered.proxy.protocol.packet.chat.keyed.KeyedPlayerCommand;
 import com.velocitypowered.proxy.protocol.packet.chat.legacy.LegacyChat;
 import com.velocitypowered.proxy.protocol.packet.chat.session.SessionPlayerChat;
 import com.velocitypowered.proxy.protocol.packet.chat.session.SessionPlayerCommand;
+import com.velocitypowered.proxy.protocol.packet.config.*;
 import com.velocitypowered.proxy.protocol.packet.title.LegacyTitlePacket;
 import com.velocitypowered.proxy.protocol.packet.title.TitleActionbarPacket;
 import com.velocitypowered.proxy.protocol.packet.title.TitleClearPacket;
@@ -279,4 +251,32 @@ default boolean handle(RemovePlayerInfo packet) {
   default boolean handle(UpsertPlayerInfo packet) {
     return false;
   }
+
+  default boolean handle(LoginAcknowledged packet) {
+    return false;
+  }
+
+  default boolean handle(ActiveFeatures packet) {
+    return false;
+  }
+
+  default boolean handle(FinishedUpdate packet) {
+    return false;
+  }
+
+  default boolean handle(RegistrySync packet) {
+    return false;
+  }
+
+  default boolean handle(TagsUpdate packet) {
+    return false;
+  }
+
+  default boolean handle(StartUpdate packet) {
+    return false;
+  }
+
+  default boolean handle(PingIdentify pingIdentify) {
+    return false;
+  }
 }