WIP, not tested yet

src/main/java/org/adde0109/ambassador/Ambassador.java

@@ -1,13 +1,18 @@
 package org.adde0109.ambassador;
 
 import com.google.inject.Inject;
+import com.velocitypowered.api.event.Continuation;
 import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.connection.PreLoginEvent;
 import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
 import com.velocitypowered.api.plugin.Plugin;
 import com.velocitypowered.api.plugin.annotation.DataDirectory;
+import com.velocitypowered.api.proxy.LoginPhaseConnection;
 import com.velocitypowered.api.proxy.ProxyServer;
 import com.velocitypowered.api.proxy.server.RegisteredServer;
 
+import java.net.InetSocketAddress;
+import java.util.concurrent.atomic.AtomicBoolean;
 import org.slf4j.Logger;
 
 import java.nio.file.Path;
@@ -24,6 +29,9 @@ public class Ambassador {
 
   private static ForgeHandshakeDataHandler forgeHandshakeDataHandler;
 
+  public Map<RegisteredServer, ForgeServerConnection> forgeServerConnectionMap;
+  public Map<InetSocketAddress,ForgeConnection> incomingForgeConnections;
+
   @Inject
   public Ambassador(ProxyServer server, Logger logger, @DataDirectory Path dataDirectory) {
     this.server = server;
@@ -35,7 +43,7 @@ public class Ambassador {
   public void onProxyInitialization(ProxyInitializeEvent event) {
     config = AmbassadorConfig.readOrCreateConfig(dataDirectory,server,logger);
     if(config != null) {
-      forgeHandshakeDataHandler = new ForgeHandshakeDataHandler(config,logger,server);
+      forgeHandshakeDataHandler = new ForgeHandshakeDataHandler(logger,server);
       server.getEventManager().register(this, forgeHandshakeDataHandler);
     }
     else {
@@ -43,6 +51,64 @@ public class Ambassador {
     }
 
   }
+  @Subscribe
+  public void onPreLoginEvent(PreLoginEvent event, Continuation continuation) {
+    if (!config.shouldHandle(event.getConnection().getProtocolVersion().getProtocol())) {
+      continuation.resume();
+      return;
+    }
+    RegisteredServer defaultServer = config.getServer(event.getConnection().getProtocolVersion().getProtocol());
+
+    this.server.getEventManager().fire(new PreSyncEvent(event.getUsername(),event.getConnection(), defaultServer))
+        .thenAccept((e) -> {
+          if (e.getResult().getServer().isEmpty()) {
+            //Do not sync
+            return;
+          }
+          RegisteredServer newServer = e.getResult().getServer().get();
+
+          ForgeConnection forgeConnection =  new ForgeConnection((LoginPhaseConnection) event.getConnection());
+
+          //If a connection does not already exist, create one.
+          if (!forgeServerConnectionMap.containsKey(newServer)) {
+            forgeServerConnectionMap.put(newServer, new ForgeServerConnection(this,logger,newServer));
+          }
+
+          ForgeServerConnection forgeServerConnection = forgeServerConnectionMap.get(newServer);
+
+          //Syncing
+          forgeServerConnection.getHandshake().whenComplete((msg,ex) -> {
+            if (ex != null) {
+              logger.warn("Could not sync player '" + event.getUsername() + "' to server '"
+                  + forgeServerConnection.getServerInfo().getName() +"' Cause: " + ex.getMessage());
+            } else {
+              forgeConnection.sendModlist(msg.modListPacket).thenAccept((response) -> {
+                if (response != null) {
+                  forgeServerConnection.setDefaultClientModlist(response);
+                }
+              });
+              forgeConnection.sendOther(msg.otherPackets).thenAccept((response) -> {
+                if (response != null) {
+                  forgeServerConnection.setDefaultClientACK(response);
+                }
+                onSyncComplete(forgeConnection);
+              });
+            }
+            //Writes the messages
+            continuation.resume();
+          });
+        });
+  }
+
+  public void onSyncComplete(ForgeConnection forgeConnection) {
+    if (forgeConnection.isModded()) {
+      incomingForgeConnections.values().removeIf((c) -> !c.getConnection().isActive());
+      incomingForgeConnections.put(forgeConnection.getConnection().getRemoteAddress(), forgeConnection);
+    }
+  }
+
+
+
 
 
 }

src/main/java/org/adde0109/ambassador/ForgeConnection.java

@@ -0,0 +1,51 @@
+package org.adde0109.ambassador;
+
+import com.velocitypowered.api.proxy.InboundConnection;
+import com.velocitypowered.api.proxy.LoginPhaseConnection;
+import com.velocitypowered.api.proxy.messages.MinecraftChannelIdentifier;
+import com.velocitypowered.api.proxy.server.RegisteredServer;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public class ForgeConnection {
+
+  private final LoginPhaseConnection connection;
+
+  private byte[] recivedClientModlist;
+
+  private boolean isModded = false;
+
+  ForgeConnection(LoginPhaseConnection connection) {
+    this.connection = connection;
+  }
+
+  public CompletableFuture<byte[]> sendModlist(byte[] modListPacket) {
+    CompletableFuture<byte[]> future = new CompletableFuture<byte[]>();
+    connection.sendLoginPluginMessage(MinecraftChannelIdentifier.create("fml","loginwrapper"), modListPacket,
+        responseBody -> {
+      if (responseBody != null) {
+        isModded = true;
+      }
+      recivedClientModlist = responseBody;
+      future.complete(recivedClientModlist);
+        });
+    return future;
+  }
+
+  CompletableFuture<byte[]> sendOther(List<byte[]> otherPackets) {
+    CompletableFuture<byte[]> future = new CompletableFuture<byte[]>();
+    for (int i = 0;i<otherPackets.size();i++) {
+      connection.sendLoginPluginMessage(MinecraftChannelIdentifier.create("fml","loginwrapper"), otherPackets.get(i),
+          (i<(otherPackets.size()-1)) ? responseBody -> {} : future::complete);
+    }
+    return future;
+  }
+
+  public boolean isModded() {
+    return isModded;
+  }
+  public LoginPhaseConnection getConnection() {
+    return connection;
+  }
+
+}

src/main/java/org/adde0109/ambassador/ForgeHandshakeDataHandler.java

@@ -6,6 +6,7 @@ import com.velocitypowered.api.event.Subscribe;
 import com.velocitypowered.api.event.connection.PreLoginEvent;
 import com.velocitypowered.api.event.player.ServerLoginPluginMessageEvent;
 import com.velocitypowered.api.event.player.ServerPostConnectEvent;
+import com.velocitypowered.api.proxy.ConnectionRequestBuilder;
 import com.velocitypowered.api.proxy.InboundConnection;
 import com.velocitypowered.api.proxy.LoginPhaseConnection;
 import com.velocitypowered.api.proxy.Player;
@@ -26,7 +27,7 @@ import java.util.concurrent.CompletableFuture;
 
 public class ForgeHandshakeDataHandler {
 
-  public Map<RegisteredServer, handshakeReceiver.CachedServerHandshake> cachedServerHandshake = new HashMap<RegisteredServer, handshakeReceiver.CachedServerHandshake>();
+  public Map<RegisteredServer,CachedServerHandshake> cachedServerHandshake = new HashMap<RegisteredServer,CachedServerHandshake>();
   public byte[] recivedClientACK;
   public Map<RegisteredServer,byte[]> recivedClientModlist = new HashMap<RegisteredServer,byte[]>();
   public LoginPhaseConnection connection;
@@ -36,45 +37,14 @@ public class ForgeHandshakeDataHandler {
 
   private static final int PACKET_LENGTH_INDEX = 14;    //length of "fml:handshake"+1
 
-  private final AmbassadorConfig config;
   private final Logger logger;
   private final ProxyServer server;
 
-  public ForgeHandshakeDataHandler(AmbassadorConfig config, Logger logger, ProxyServer server) {
+  public ForgeHandshakeDataHandler(Logger logger, ProxyServer server) {
-    this.config = config;
     this.logger = logger;
     this.server = server;
   }
 
-  @Subscribe
-  public void onPreLoginEvent(PreLoginEvent event, Continuation continuation) {
-    if (!config.shouldHandle(event.getConnection().getProtocolVersion().getProtocol())) {
-      continuation.resume();
-      return;
-    }
-    RegisteredServer server = config.getServer(event.getConnection().getProtocolVersion().getProtocol());
-
-    this.server.getEventManager().fire(new PreSyncEvent(event.getUsername(),event.getConnection(), server))
-            .thenAccept((e) -> {
-              if (!e.getResult().getServer().isPresent()) {
-                //Do not sync
-                return;
-              }
-                getHandshake(server).whenComplete((msg,ex) -> {
-                  if (ex != null) {
-                    logger.warn("Could not sync player '" + event.getUsername() + "' to server '"
-                        + server.getServerInfo().getName() +"' Cause: " + ex.getMessage());
-                  } else {
-                    AtomicBoolean isForge = new AtomicBoolean(false);
-                    sendModlist(msg.modListPacket, (LoginPhaseConnection) event.getConnection(), server).thenAccept(isForge::set);
-                    sendOther(msg.otherPackets, (LoginPhaseConnection) event.getConnection(), server).thenAccept((ignored) -> {});
-                  }
-                  //Writes the messages
-                  continuation.resume();
-                });
-            });
-  }
-
 
   @Subscribe
   public void onServerPostConnectEvent(ServerPostConnectEvent event) {
@@ -121,8 +91,8 @@ public class ForgeHandshakeDataHandler {
   }
 
 
-  public CompletableFuture<handshakeReceiver.CachedServerHandshake> getHandshake(RegisteredServer handshakeServer) {
+  public CompletableFuture<CachedServerHandshake> getHandshake(RegisteredServer handshakeServer) {
-    CompletableFuture<handshakeReceiver.CachedServerHandshake> future;
+    CompletableFuture<CachedServerHandshake> future;
     if((handshakeServer.getPlayersConnected().isEmpty()) || (!cachedServerHandshake.containsKey(handshakeServer))) {
       handshakeReceiver receiver = new handshakeReceiver(handshakeServer, logger);
       future = receiver.downloadHandshake();
@@ -139,7 +109,7 @@ public class ForgeHandshakeDataHandler {
   }
 
   //Should return ForgePlayer instead of Boolean in the future...
-  private CompletableFuture<Boolean> sendModlist(byte[] modListPacket, LoginPhaseConnection connection, RegisteredServer server) {
+  CompletableFuture<Boolean> sendModlist(byte[] modListPacket, LoginPhaseConnection connection, RegisteredServer server) {
     CompletableFuture<Boolean> future = new CompletableFuture<Boolean>();
     connection.sendLoginPluginMessage(MinecraftChannelIdentifier.create("fml","loginwrapper"), modListPacket, responseBody ->  {
       if (responseBody != null) {
@@ -152,7 +122,7 @@ public class ForgeHandshakeDataHandler {
     return future;
   }
 
-  private CompletableFuture<Void> sendOther(List<byte[]> otherPackets, LoginPhaseConnection connection, RegisteredServer server) {
+  CompletableFuture<Void> sendOther(List<byte[]> otherPackets, LoginPhaseConnection connection, RegisteredServer server) {
     CompletableFuture<Void> future = new CompletableFuture<Void>();
     for (int i = 0;i<otherPackets.size();i++) {
       connection.sendLoginPluginMessage(MinecraftChannelIdentifier.create("fml","loginwrapper"), otherPackets.get(i),
@@ -181,7 +151,7 @@ public class ForgeHandshakeDataHandler {
     return i;
   }
 
-  private class handshakeReceiver {
+  public static class handshakeReceiver {
 
     private int partLength;
 
@@ -192,7 +162,7 @@ public class ForgeHandshakeDataHandler {
     private int recivedBytes;
     private final RegisteredServer forgeServer;
 
-    private handshakeReceiver(RegisteredServer server, Logger logger) {
+    public handshakeReceiver(RegisteredServer server, Logger logger) {
 
       this.logger = logger;
       this.forgeServer = server;
@@ -217,7 +187,7 @@ public class ForgeHandshakeDataHandler {
 
     public void onBackendPong(ServerPing status, CompletableFuture<CachedServerHandshake> future) {
       numberOfRecivedParts++;
-      if ((!status.getModinfo().isPresent()) || (!Objects.equals(status.getModinfo().get().getType(), "ambassador"))) {
+      if ((status.getModinfo().isEmpty()) || (!Objects.equals(status.getModinfo().get().getType(), "ambassador"))) {
         future.completeExceptionally(new Exception("The specified Forge server is not running the Forge-side version of this plugin!"));
         return;
       }
@@ -252,8 +222,8 @@ public class ForgeHandshakeDataHandler {
 
     private void placePartInArray(byte[] temp, int partNr) {
       int head = partNr * partLength;
-      for (int i = 0; i < temp.length; i++) {
+      for (byte b : temp) {
-        recivedParts[head] = temp[i];
+        recivedParts[head] = b;
         head++;
         recivedBytes++;
       }
@@ -262,9 +232,9 @@ public class ForgeHandshakeDataHandler {
     private byte[] getPacket(byte[] data, int startByteIndex, int lastByteIndex) {
       byte[] temp = new byte[lastByteIndex - startByteIndex + 1];
 
-      for (int i = startByteIndex; i <= lastByteIndex; i++) {
+      if (lastByteIndex + 1 - startByteIndex >= 0)
-        temp[i - startByteIndex] = data[i];
+        System.arraycopy(data, startByteIndex, temp, 0,
-      }
+            lastByteIndex + 1 - startByteIndex);
       return temp;
     }
 
@@ -279,16 +249,17 @@ public class ForgeHandshakeDataHandler {
     }
 
 
-    private class CachedServerHandshake {
-      private String sessionID;
-      private byte[] modListPacket;
-      private List<byte[]> otherPackets;
 
-      private CachedServerHandshake(String sessionID,byte[] modListPacket,List<byte[]> otherPackets) {
+  }
-        this.sessionID = sessionID;
+  public static class CachedServerHandshake {
-        this.modListPacket = modListPacket;
+    private String sessionID;
-        this.otherPackets = otherPackets;
+    public byte[] modListPacket;
-      }
+    public List<byte[]> otherPackets;
+
+    private CachedServerHandshake(String sessionID,byte[] modListPacket,List<byte[]> otherPackets) {
+      this.sessionID = sessionID;
+      this.modListPacket = modListPacket;
+      this.otherPackets = otherPackets;
     }
   }
 }

src/main/java/org/adde0109/ambassador/ForgeServerConnection.java

@@ -0,0 +1,58 @@
+package org.adde0109.ambassador;
+
+import com.velocitypowered.api.proxy.server.RegisteredServer;
+import com.velocitypowered.api.proxy.server.ServerInfo;
+import java.util.concurrent.CompletableFuture;
+import org.slf4j.Logger;
+
+public class ForgeServerConnection {
+
+  private final Ambassador ambassador;
+  private final Logger logger;
+  private final RegisteredServer handshakeServer;
+
+  private ForgeHandshakeDataHandler.CachedServerHandshake handshake;
+
+  private byte[] defaultClientModlist;
+  private byte[] defaultClientACK;
+
+  public RegisteredServer getServer() {
+    return handshakeServer;
+  }
+
+  public ForgeServerConnection(Ambassador ambassador, Logger logger, RegisteredServer handshakeServer) {
+    this.ambassador = ambassador;
+    this.logger = logger;
+    this.handshakeServer = handshakeServer;
+  }
+
+  public CompletableFuture<ForgeHandshakeDataHandler.CachedServerHandshake> getHandshake() {
+    CompletableFuture<ForgeHandshakeDataHandler.CachedServerHandshake> future;
+    if (handshakeServer.getPlayersConnected().isEmpty() || (handshake == null)) {
+      ForgeHandshakeDataHandler.handshakeReceiver
+          receiver = new ForgeHandshakeDataHandler.handshakeReceiver(handshakeServer, logger);
+      future = receiver.downloadHandshake();
+      future.thenAccept(p -> {
+        handshake = p;
+      });
+      return future;
+    } else {
+      future = new CompletableFuture<>();
+      future.complete(handshake);
+      return future;
+    }
+  }
+
+  public void setDefaultClientModlist(byte[] modlist) {
+    this.defaultClientModlist = modlist;
+  }
+
+  public void setDefaultClientACK(byte[] ACK) {
+    this.defaultClientACK = ACK;
+  }
+
+  public ServerInfo getServerInfo() {
+    return handshakeServer.getServerInfo();
+  }
+
+}