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/bungeecord/pom.xml

@@ -17,10 +17,11 @@
             <version>1.4.1-SNAPSHOT</version>
             <scope>compile</scope>
         </dependency>
+        <!-- Used for better working with internals without reflection -->
         <dependency>
-            <groupId>net.md-5</groupId>
-            <artifactId>bungeecord-api</artifactId>
-            <version>1.16-R0.5-SNAPSHOT</version>
+            <groupId>com.github.SpigotMC.BungeeCord</groupId>
+            <artifactId>bungeecord-proxy</artifactId>
+            <version>a7c6ede</version>
             <scope>provided</scope>
         </dependency>
     </dependencies>

bootstrap/bungeecord/src/main/java/org/geysermc/platform/bungeecord/GeyserBungeeInjector.java

@@ -0,0 +1,134 @@
+/*
+ * 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.bungeecord;
+
+import com.github.steveice10.packetlib.io.local.LocalServerChannelWrapper;
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.local.LocalAddress;
+import io.netty.util.AttributeKey;
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.api.config.ListenerInfo;
+import net.md_5.bungee.netty.PipelineUtils;
+import org.geysermc.connector.bootstrap.GeyserBootstrap;
+import org.geysermc.connector.common.GeyserInjector;
+
+import java.lang.reflect.Method;
+
+public class GeyserBungeeInjector extends GeyserInjector {
+    private final ProxyServer proxy;
+    /**
+     * Set as a variable so it is only set after the proxy has finished initializing
+     */
+    private ChannelInitializer<Channel> channelInitializer = null;
+
+    public GeyserBungeeInjector(ProxyServer proxy) {
+        this.proxy = proxy;
+    }
+
+    @Override
+    protected void initializeLocalChannel0(GeyserBootstrap bootstrap) throws Exception {
+        // TODO - allow Geyser to specify its own listener info properties
+        if (proxy.getConfig().getListeners().size() != 1) {
+            throw new UnsupportedOperationException("Geyser does not currently support multiple listeners with injection! " +
+                    "Please reach out to us on our Discord at https://discord.gg/GeyserMC so we can hear feedback on your setup.");
+        }
+        ListenerInfo listenerInfo = proxy.getConfig().getListeners().stream().findFirst().orElseThrow(IllegalStateException::new);
+
+        Class<? extends ProxyServer> proxyClass = proxy.getClass();
+        // Using the specified EventLoop is required, or else an error will be thrown
+        EventLoopGroup bossGroup;
+        EventLoopGroup workerGroup;
+        try {
+            EventLoopGroup eventLoops = (EventLoopGroup) proxyClass.getField("eventLoops").get(proxy);
+            // Netty redirects ServerBootstrap#group(EventLoopGroup) to #group(EventLoopGroup, EventLoopGroup) and uses the same event loop for both.
+            bossGroup = eventLoops;
+            workerGroup = eventLoops;
+            bootstrap.getGeyserLogger().debug("BungeeCord event loop style detected.");
+        } catch (NoSuchFieldException e) {
+            // Waterfall uses two separate event loops
+            // https://github.com/PaperMC/Waterfall/blob/fea7ec356dba6c6ac28819ff11be604af6eb484e/BungeeCord-Patches/0022-Use-a-worker-and-a-boss-event-loop-group.patch
+            bossGroup = (EventLoopGroup) proxyClass.getField("bossEventLoopGroup").get(proxy);
+            workerGroup = (EventLoopGroup) proxyClass.getField("workerEventLoopGroup").get(proxy);
+            bootstrap.getGeyserLogger().debug("Waterfall event loop style detected.");
+        }
+
+        // Is currently just AttributeKey.valueOf("ListerInfo") but we might as well copy the value itself.
+        AttributeKey<ListenerInfo> listener = PipelineUtils.LISTENER;
+        listenerInfo = new ListenerInfo(
+                listenerInfo.getSocketAddress(),
+                listenerInfo.getMotd(),
+                listenerInfo.getMaxPlayers(),
+                listenerInfo.getTabListSize(),
+                listenerInfo.getServerPriority(),
+                listenerInfo.isForceDefault(),
+                listenerInfo.getForcedHosts(),
+                listenerInfo.getTabListType(),
+                listenerInfo.isSetLocalAddress(),
+                listenerInfo.isPingPassthrough(),
+                listenerInfo.getQueryPort(),
+                listenerInfo.isQueryEnabled(),
+                bootstrap.getGeyserConfig().getRemote().isUseProxyProtocol() // If Geyser is expecting HAProxy, so should the Bungee end
+        );
+
+        // This method is what initializes the connection in Java Edition, after Netty is all set.
+        Method initChannel = ChannelInitializer.class.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 {
+                        if (proxy.getConfig().getServers() == null) {
+                            // Proxy hasn't finished loading all plugins - it loads the config after all plugins
+                            // Probably doesn't need to be translatable?
+                            bootstrap.getGeyserLogger().info("Disconnecting player as Bungee has not finished loading");
+                            ch.close();
+                            return;
+                        }
+
+                        if (channelInitializer == null) {
+                            // Proxy has finished initializing; we can safely grab this variable without fear of plugins modifying it
+                            // (ViaVersion replaces this to inject)
+                            channelInitializer = PipelineUtils.SERVER_CHILD;
+                        }
+                        initChannel.invoke(channelInitializer, ch);
+                    }
+                })
+                .childAttr(listener, listenerInfo)
+                .group(bossGroup, workerGroup)
+                .localAddress(LocalAddress.ANY))
+                .bind()
+                .syncUninterruptibly();
+
+        this.localChannel = channelFuture;
+        this.serverSocketAddress = channelFuture.channel().localAddress();
+    }
+}

bootstrap/bungeecord/src/main/java/org/geysermc/platform/bungeecord/GeyserBungeePlugin.java

@@ -40,10 +40,12 @@ import org.geysermc.connector.utils.FileUtils;
 import org.geysermc.connector.utils.LanguageUtils;
 import org.geysermc.platform.bungeecord.command.GeyserBungeeCommandExecutor;
 import org.geysermc.platform.bungeecord.command.GeyserBungeeCommandManager;
+import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
 import java.io.IOException;
 import java.net.InetSocketAddress;
+import java.net.SocketAddress;
 import java.nio.file.Path;
 import java.util.UUID;
 import java.util.logging.Level;
@@ -52,6 +54,7 @@ public class GeyserBungeePlugin extends Plugin implements GeyserBootstrap {
 
     private GeyserBungeeCommandManager geyserCommandManager;
     private GeyserBungeeConfiguration geyserConfig;
+    private GeyserBungeeInjector geyserInjector;
     private GeyserBungeeLogger geyserLogger;
     private IGeyserPingPassthrough geyserBungeePingPassthrough;
 
@@ -114,6 +117,9 @@ public class GeyserBungeePlugin extends Plugin implements GeyserBootstrap {
 
         this.connector = GeyserConnector.start(PlatformType.BUNGEECORD, this);
 
+        this.geyserInjector = new GeyserBungeeInjector(getProxy());
+        this.geyserInjector.initializeLocalChannel(this);
+
         this.geyserCommandManager = new GeyserBungeeCommandManager(connector);
 
         if (geyserConfig.isLegacyPingPassthrough()) {
@@ -127,7 +133,12 @@ public class GeyserBungeePlugin extends Plugin implements GeyserBootstrap {
 
     @Override
     public void onDisable() {
-        connector.shutdown();
+        if (connector != null) {
+            connector.shutdown();
+        }
+        if (geyserInjector != null) {
+            geyserInjector.shutdown();
+        }
     }
 
     @Override
@@ -159,4 +170,10 @@ public class GeyserBungeePlugin extends Plugin implements GeyserBootstrap {
     public BootstrapDumpInfo getDumpInfo() {
         return new GeyserBungeeDumpInfo(getProxy());
     }
+
+    @Nullable
+    @Override
+    public SocketAddress getSocketAddress() {
+        return this.geyserInjector.getServerSocketAddress();
+    }
 }

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);

bootstrap/velocity/src/main/java/org/geysermc/platform/velocity/GeyserVelocityInjector.java

@@ -0,0 +1,82 @@
+/*
+ * 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.velocity;
+
+import com.github.steveice10.packetlib.io.local.LocalServerChannelWrapper;
+import com.velocitypowered.api.proxy.ProxyServer;
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.*;
+import io.netty.channel.local.LocalAddress;
+import org.geysermc.connector.bootstrap.GeyserBootstrap;
+import org.geysermc.connector.common.GeyserInjector;
+
+import java.lang.reflect.Field;
+import java.util.function.Supplier;
+
+public class GeyserVelocityInjector extends GeyserInjector {
+    private final ProxyServer proxy;
+
+    public GeyserVelocityInjector(ProxyServer proxy) {
+        this.proxy = proxy;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    protected void initializeLocalChannel0(GeyserBootstrap bootstrap) throws Exception {
+        Field cm = proxy.getClass().getDeclaredField("cm");
+        cm.setAccessible(true);
+        Object connectionManager = cm.get(proxy);
+        Class<?> connectionManagerClass = connectionManager.getClass();
+
+        Supplier<ChannelInitializer<Channel>> serverChannelInitializerHolder = (Supplier<ChannelInitializer<Channel>>) connectionManagerClass
+                .getMethod("getServerChannelInitializer")
+                .invoke(connectionManager);
+        ChannelInitializer<Channel> channelInitializer = serverChannelInitializerHolder.get();
+
+        // Is set on Velocity's end for listening to Java connections - required on ours or else the initial world load process won't finish sometimes
+        Field serverWriteMarkField = connectionManagerClass.getDeclaredField("SERVER_WRITE_MARK");
+        serverWriteMarkField.setAccessible(true);
+        WriteBufferWaterMark serverWriteMark = (WriteBufferWaterMark) serverWriteMarkField.get(null);
+
+        EventLoopGroup bossGroup = (EventLoopGroup) connectionManagerClass.getMethod("getBossGroup").invoke(connectionManager);
+
+        Field workerGroupField = connectionManagerClass.getDeclaredField("workerGroup");
+        workerGroupField.setAccessible(true);
+        EventLoopGroup workerGroup = (EventLoopGroup) workerGroupField.get(connectionManager);
+
+        ChannelFuture channelFuture = (new ServerBootstrap()
+                .channel(LocalServerChannelWrapper.class)
+                .childHandler(channelInitializer)
+                .group(bossGroup, workerGroup) // Cannot be DefaultEventLoopGroup
+                .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, serverWriteMark) // Required or else rare network freezes can occur
+                .localAddress(LocalAddress.ANY))
+                .bind()
+                .syncUninterruptibly();
+
+        this.localChannel = channelFuture;
+        this.serverSocketAddress = channelFuture.channel().localAddress();
+    }
+}

bootstrap/velocity/src/main/java/org/geysermc/platform/velocity/GeyserVelocityPlugin.java

@@ -28,6 +28,7 @@ package org.geysermc.platform.velocity;
 import com.google.inject.Inject;
 import com.velocitypowered.api.command.CommandManager;
 import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.proxy.ListenerBoundEvent;
 import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
 import com.velocitypowered.api.event.proxy.ProxyShutdownEvent;
 import com.velocitypowered.api.plugin.Plugin;
@@ -45,11 +46,13 @@ import org.geysermc.connector.utils.FileUtils;
 import org.geysermc.connector.utils.LanguageUtils;
 import org.geysermc.platform.velocity.command.GeyserVelocityCommandExecutor;
 import org.geysermc.platform.velocity.command.GeyserVelocityCommandManager;
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 
 import java.io.File;
 import java.io.IOException;
 import java.net.InetSocketAddress;
+import java.net.SocketAddress;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.UUID;
@@ -68,6 +71,7 @@ public class GeyserVelocityPlugin implements GeyserBootstrap {
 
     private GeyserVelocityCommandManager geyserCommandManager;
     private GeyserVelocityConfiguration geyserConfig;
+    private GeyserVelocityInjector geyserInjector;
     private GeyserVelocityLogger geyserLogger;
     private IGeyserPingPassthrough geyserPingPassthrough;
 
@@ -130,6 +134,9 @@ public class GeyserVelocityPlugin implements GeyserBootstrap {
 
         this.connector = GeyserConnector.start(PlatformType.VELOCITY, this);
 
+        this.geyserInjector = new GeyserVelocityInjector(proxyServer);
+        // Will be initialized after the proxy has been bound
+
         this.geyserCommandManager = new GeyserVelocityCommandManager(connector);
         this.commandManager.register("geyser", new GeyserVelocityCommandExecutor(connector));
         if (geyserConfig.isLegacyPingPassthrough()) {
@@ -141,7 +148,12 @@ public class GeyserVelocityPlugin implements GeyserBootstrap {
 
     @Override
     public void onDisable() {
-        connector.shutdown();
+        if (connector != null) {
+            connector.shutdown();
+        }
+        if (geyserInjector != null) {
+            geyserInjector.shutdown();
+        }
     }
 
     @Override
@@ -174,8 +186,20 @@ public class GeyserVelocityPlugin implements GeyserBootstrap {
         onDisable();
     }
 
+    @Subscribe
+    public void onProxyBound(ListenerBoundEvent event) {
+        // After this bound, we know that the channel initializer cannot change without it being ineffective for Velocity, too
+        geyserInjector.initializeLocalChannel(this);
+    }
+
     @Override
     public BootstrapDumpInfo getDumpInfo() {
         return new GeyserVelocityDumpInfo(proxyServer);
     }
+
+    @Nullable
+    @Override
+    public SocketAddress getSocketAddress() {
+        return this.geyserInjector.getServerSocketAddress();
+    }
 }