Connect Geyser players directly to the server for plugin versions (#2413)

- Faster loading times and improved latency; Geyser no longer creates a physical TCP connection to join the server
- Less configuration: remote address and port are now irrelevant
- Accurate IP addresses without needing Floodgate.

Co-authored-by: Redned <redned235@gmail.com>

bootstrap/spigot/src/main/java/org/geysermc/platform/spigot/GeyserSpigotInjector.java

@@ -0,0 +1,166 @@
+/*
+ * Copyright (c) 2019-2021 GeyserMC. http://geysermc.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @author GeyserMC
+ * @link https://github.com/GeyserMC/Geyser
+ */
+
+package org.geysermc.platform.spigot;
+
+import com.github.steveice10.packetlib.io.local.LocalServerChannelWrapper;
+import com.viaversion.viaversion.bukkit.handlers.BukkitChannelInitializer;
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.*;
+import io.netty.channel.local.LocalAddress;
+import org.bukkit.Bukkit;
+import org.geysermc.connector.bootstrap.GeyserBootstrap;
+import org.geysermc.connector.common.GeyserInjector;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.util.List;
+
+public class GeyserSpigotInjector extends GeyserInjector {
+    /**
+     * Used to determine if ViaVersion is setup to a state where Geyser players will fail at joining if injection is enabled
+     */
+    private final boolean isViaVersion;
+    /**
+     * Used to uninject ourselves on shutdown.
+     */
+    private List<ChannelFuture> allServerChannels;
+
+    public GeyserSpigotInjector(boolean isViaVersion) {
+        this.isViaVersion = isViaVersion;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected void initializeLocalChannel0(GeyserBootstrap bootstrap) throws Exception {
+        Class<?> serverClazz;
+        try {
+            serverClazz = Class.forName("net.minecraft.server.MinecraftServer");
+            // We're using 1.17+
+        } catch (ClassNotFoundException e) {
+            // We're using pre-1.17
+            String prefix = Bukkit.getServer().getClass().getPackage().getName().replace("org.bukkit.craftbukkit", "net.minecraft.server");
+            serverClazz = Class.forName(prefix + ".MinecraftServer");
+        }
+        Method getServer = serverClazz.getDeclaredMethod("getServer");
+        Object server = getServer.invoke(null);
+        Object connection = null;
+        // Find the class that manages network IO
+        for (Method m : serverClazz.getDeclaredMethods()) {
+            if (m.getReturnType() != null) {
+                // First is Spigot-mapped name, second is Mojang-mapped name which is implemented as future-proofing
+                if (m.getReturnType().getSimpleName().equals("ServerConnection") || m.getReturnType().getSimpleName().equals("ServerConnectionListener")) {
+                    if (m.getParameterTypes().length == 0) {
+                        connection = m.invoke(server);
+                    }
+                }
+            }
+        }
+        if (connection == null) {
+            throw new RuntimeException("Unable to find ServerConnection class!");
+        }
+
+        // Find the channel that Minecraft uses to listen to connections
+        ChannelFuture listeningChannel = null;
+        for (Field field : connection.getClass().getDeclaredFields()) {
+            if (field.getType() != List.class) {
+                continue;
+            }
+            field.setAccessible(true);
+            boolean rightList = ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0] == ChannelFuture.class;
+            if (!rightList) continue;
+
+            allServerChannels = (List<ChannelFuture>) field.get(connection);
+            for (ChannelFuture o : allServerChannels) {
+                listeningChannel = o;
+                break;
+            }
+        }
+        if (listeningChannel == null) {
+            throw new RuntimeException("Unable to find listening channel!");
+        }
+
+        // Making this a function prevents childHandler from being treated as a non-final variable
+        ChannelInitializer<Channel> childHandler = getChildHandler(bootstrap, listeningChannel);
+        // This method is what initializes the connection in Java Edition, after Netty is all set.
+        Method initChannel = childHandler.getClass().getDeclaredMethod("initChannel", Channel.class);
+        initChannel.setAccessible(true);
+
+        ChannelFuture channelFuture = (new ServerBootstrap()
+                .channel(LocalServerChannelWrapper.class)
+                .childHandler(new ChannelInitializer<Channel>() {
+                    @Override
+                    protected void initChannel(Channel ch) throws Exception {
+                        initChannel.invoke(childHandler, ch);
+                    }
+                })
+                .group(new DefaultEventLoopGroup())
+                .localAddress(LocalAddress.ANY))
+                .bind()
+                .syncUninterruptibly();
+        // We don't need to add to the list, but plugins like ProtocolSupport and ProtocolLib that add to the main pipeline
+        // will work when we add to the list.
+        allServerChannels.add(channelFuture);
+        this.localChannel = channelFuture;
+        this.serverSocketAddress = channelFuture.channel().localAddress();
+    }
+
+    @SuppressWarnings("unchecked")
+    private ChannelInitializer<Channel> getChildHandler(GeyserBootstrap bootstrap, ChannelFuture listeningChannel) {
+        List<String> names = listeningChannel.channel().pipeline().names();
+        ChannelInitializer<Channel> childHandler = null;
+        for (String name : names) {
+            ChannelHandler handler = listeningChannel.channel().pipeline().get(name);
+            try {
+                Field childHandlerField = handler.getClass().getDeclaredField("childHandler");
+                childHandlerField.setAccessible(true);
+                childHandler = (ChannelInitializer<Channel>) childHandlerField.get(handler);
+                // ViaVersion non-Paper-injector workaround so we aren't double-injecting
+                if (isViaVersion && childHandler instanceof BukkitChannelInitializer) {
+                    childHandler = ((BukkitChannelInitializer) childHandler).getOriginal();
+                }
+                break;
+            } catch (Exception e) {
+                if (bootstrap.getGeyserConfig().isDebugMode()) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        if (childHandler == null) {
+            throw new RuntimeException();
+        }
+        return childHandler;
+    }
+
+    @Override
+    public void shutdown() {
+        if (this.allServerChannels != null) {
+            this.allServerChannels.remove(this.localChannel);
+            this.allServerChannels = null;
+        }
+        super.shutdown();
+    }
+}

bootstrap/spigot/src/main/java/org/geysermc/platform/spigot/GeyserSpigotPlugin.java

@@ -54,6 +54,7 @@ import org.geysermc.platform.spigot.world.manager.*;
 
 import java.io.File;
 import java.io.IOException;
+import java.net.SocketAddress;
 import java.nio.file.Path;
 import java.util.List;
 import java.util.UUID;
@@ -62,6 +63,7 @@ import java.util.logging.Level;
 public class GeyserSpigotPlugin extends JavaPlugin implements GeyserBootstrap {
     private GeyserSpigotCommandManager geyserCommandManager;
     private GeyserSpigotConfiguration geyserConfig;
+    private GeyserSpigotInjector geyserInjector;
     private GeyserSpigotLogger geyserLogger;
     private IGeyserPingPassthrough geyserSpigotPingPassthrough;
     private GeyserSpigotWorldManager geyserWorldManager;
@@ -176,6 +178,11 @@ public class GeyserSpigotPlugin extends JavaPlugin implements GeyserBootstrap {
         // Set if we need to use a different method for getting a player's locale
         SpigotCommandSender.setUseLegacyLocaleMethod(isPre1_12);
 
+        // We want to do this late in the server startup process to allow plugins such as ViaVersion and ProtocolLib
+        // To do their job injecting, then connect into *that*
+        this.geyserInjector = new GeyserSpigotInjector(isViaVersion);
+        this.geyserInjector.initializeLocalChannel(this);
+
         if (connector.getConfig().isUseAdapters()) {
             try {
                 String name = Bukkit.getServer().getClass().getPackage().getName();
@@ -233,6 +240,9 @@ public class GeyserSpigotPlugin extends JavaPlugin implements GeyserBootstrap {
         if (connector != null) {
             connector.shutdown();
         }
+        if (geyserInjector != null) {
+            geyserInjector.shutdown();
+        }
     }
 
     @Override
@@ -275,6 +285,11 @@ public class GeyserSpigotPlugin extends JavaPlugin implements GeyserBootstrap {
         return this.minecraftVersion;
     }
 
+    @Override
+    public SocketAddress getSocketAddress() {
+        return this.geyserInjector.getServerSocketAddress();
+    }
+
     public boolean isCompatible(String version, String whichVersion) {
         int[] currentVersion = parseVersion(version);
         int[] otherVersion = parseVersion(whichVersion);