R3944Realms/Ambassador
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Server switch logic rewritten

Browse Source
This commit is contained in:
Adrian Bergqvist 2023-02-16 21:11:13 +01:00
parent ce5420768d
commit d6cc47aba1
No known key found for this signature in database
GPG Key ID: FAE7D8EDE225E686
13 changed files with 195 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
build.gradle.kts
View File

@ -24,6 +24,7 @@ dependencies {
compileOnly("io.netty:netty-buffer:4.1.86.Final")
compileOnly("io.netty:netty-transport:4.1.86.Final")
compileOnly("io.netty:netty-codec:4.1.86.Final")
compileOnly("io.netty:netty-handler:4.1.86.Final")
}
tasks {

76
src/main/java/org/adde0109/ambassador/forge/FML2CRPMClientConnectionPhase.java
View File

@ -1,76 +0,0 @@
package org.adde0109.ambassador.forge;
import com.velocitypowered.api.event.player.KickedFromServerEvent;
import com.velocitypowered.api.proxy.server.RegisteredServer;
import com.velocitypowered.api.util.UuidUtils;
import com.velocitypowered.proxy.VelocityServer;
import com.velocitypowered.proxy.config.PlayerInfoForwarding;
import com.velocitypowered.proxy.config.VelocityConfiguration;
import com.velocitypowered.proxy.connection.MinecraftConnection;
import com.velocitypowered.proxy.connection.client.ConnectedPlayer;
import com.velocitypowered.proxy.network.Connections;
import com.velocitypowered.proxy.protocol.StateRegistry;
import com.velocitypowered.proxy.protocol.packet.PluginMessage;
import com.velocitypowered.proxy.protocol.packet.ServerLoginSuccess;
import io.netty.buffer.Unpooled;
import org.adde0109.ambassador.Ambassador;
import org.adde0109.ambassador.velocity.VelocityForgeClientConnectionPhase;
import org.adde0109.ambassador.velocity.VelocityForgeHandshakeSessionHandler;
import org.adde0109.ambassador.velocity.VelocityLoginPayloadManager;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
public class FML2CRPMClientConnectionPhase extends VelocityForgeClientConnectionPhase {
//TODO: Use modData inside ConnectedPlayer instead
public byte[] modListData;
private RegisteredServer backupServer;
public FML2CRPMClientConnectionPhase(VelocityForgeClientConnectionPhase.ClientPhase clientPhase, VelocityLoginPayloadManager payloadManager) {
super(clientPhase,payloadManager);
}
public CompletableFuture<Boolean> reset(RegisteredServer server, ConnectedPlayer player) {
CompletableFuture<Boolean> future = new CompletableFuture<>();
if (player.getConnectedServer() != null) {
backupServer = player.getConnectedServer().getServer();
player.getConnectedServer().disconnect();
player.setConnectedServer(null);
}
MinecraftConnection connection = player.getConnection();
connection.setSessionHandler(new VelocityForgeHandshakeSessionHandler(connection.getSessionHandler(),player));
((VelocityServer) Ambassador.getInstance().server).unregisterConnection(player);
this.clientPhase = null;
ScheduledFuture<?> scheduledFuture = connection.eventLoop().schedule(()-> {
connection.getChannel().pipeline().remove(ForgeConstants.RESET_LISTENER);
future.complete(false);
}, Ambassador.getInstance().config.getResetTimeout(), TimeUnit.MILLISECONDS);
connection.getChannel().pipeline().addBefore(Connections.MINECRAFT_DECODER, ForgeConstants.RESET_LISTENER,new FML2CRPMResetCompleteDecoder());
getPayloadManager().listenFor(98).thenAccept(ignore -> {
if (scheduledFuture.cancel(false)) {
connection.getChannel().pipeline().remove(ForgeConstants.RESET_LISTENER);
connection.setState(StateRegistry.LOGIN);
this.clientPhase = ClientPhase.HANDSHAKE;
future.complete(true);
}
});
connection.write(new PluginMessage("fml:handshake",Unpooled.wrappedBuffer(ForgeHandshakeUtils.generatePluginResetPacket())));
return future;
}
public void handleKick(KickedFromServerEvent event) {
if (backupServer != null && !(event.getResult() instanceof KickedFromServerEvent.RedirectPlayer)) {
net.kyori.adventure.text.Component reason = event.getServerKickReason().orElse(null);
event.setResult(KickedFromServerEvent.RedirectPlayer.create(backupServer,reason));
backupServer = null;
}
}
}

52
src/main/java/org/adde0109/ambassador/forge/FML2ClientConnectionPhase.java
View File

@ -1,54 +1,17 @@
package org.adde0109.ambassador.forge;
import com.velocitypowered.api.event.Continuation;
import com.velocitypowered.api.proxy.server.RegisteredServer;
import com.velocitypowered.proxy.VelocityServer;
import com.velocitypowered.proxy.connection.MinecraftConnection;
import com.velocitypowered.proxy.connection.backend.VelocityServerConnection;
import com.velocitypowered.proxy.connection.client.ConnectedPlayer;
import com.velocitypowered.proxy.protocol.ProtocolUtils;
import com.velocitypowered.proxy.protocol.packet.LoginPluginMessage;
import com.velocitypowered.proxy.protocol.packet.LoginPluginResponse;
import io.netty.buffer.ByteBuf;
import net.kyori.adventure.text.Component;
import org.adde0109.ambassador.Ambassador;
import org.adde0109.ambassador.velocity.VelocityForgeClientConnectionPhase;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
public class FML2ClientConnectionPhase extends VelocityForgeClientConnectionPhase {
private Throwable throwable;
private RegisteredServer triedServer;
private CompletableFuture<Void> onServerSuccess;
private CompletableFuture<Void> onJoinGame;
private static final Method CONNECT_TO_INITIAL_SERVER;
static {
Class clazz;
try {
clazz = Class.forName("com.velocitypowered.proxy.connection.client.LoginSessionHandler");
} catch (ClassNotFoundException ignored){
try {
clazz = Class.forName("com.velocitypowered.proxy.connection.client.AuthSessionHandler");
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
try {
CONNECT_TO_INITIAL_SERVER = clazz.getDeclaredMethod("connectToInitialServer", ConnectedPlayer.class);
CONNECT_TO_INITIAL_SERVER.setAccessible(true);
} catch (ReflectiveOperationException e) {
throw new RuntimeException(e);
}
}
public class FML2ClientConnectionPhase {
/*
@Override
public RegisteredServer chooseServer(ConnectedPlayer player) {
forced = Ambassador.getTemporaryForced().remove(player.getUsername());
@ -70,15 +33,8 @@ public class FML2ClientConnectionPhase extends VelocityForgeClientConnectionPhas
}
public void handleJoinGame() {
this.onJoinGame.complete(null);
}
public CompletableFuture<Void> awaitJoinGame() {
return this.onJoinGame;
}
@Override
/*
public void handleForward(VelocityServerConnection serverConnection, LoginPluginMessage payload) {
final ByteBuf buf = payload.content().duplicate();
ProtocolUtils.readString(buf); //Channel
@ -96,5 +52,7 @@ public class FML2ClientConnectionPhase extends VelocityForgeClientConnectionPhas
}
});
}
}
*/
}

2
src/main/java/org/adde0109/ambassador/forge/ForgeConstants.java
View File

@ -5,9 +5,9 @@ import com.velocitypowered.proxy.connection.ConnectionType;
public class ForgeConstants {
public static final String HANDLER = "Modern Forge handler";
public static final String MARKER_ADDER = "FML2/3 Marker Adder";
public static final String OUTBOUND_CATCHER_NAME = "ambassador-catcher";
public static final String RESET_LISTENER = "ambassador-reset-listener";
public static final String SERVER_SUCCESS_LISTENER = "ambassador-server-success-listener";
public static final String FORGE_HANDSHAKE_HOLDER = "ambassador-forge-handshake-holder";
public static final String FML2Marker = "\0FML2\0";
public static final String FML3Marker = "\0FML3\0";

3
src/main/java/org/adde0109/ambassador/forge/ForgeFMLConnectionType.java
View File

@ -5,6 +5,7 @@ import com.velocitypowered.proxy.config.PlayerInfoForwarding;
import com.velocitypowered.proxy.connection.ConnectionType;
import com.velocitypowered.proxy.connection.backend.BackendConnectionPhase;
import com.velocitypowered.proxy.connection.client.ClientConnectionPhase;
import org.adde0109.ambassador.velocity.VelocityForgeClientConnectionPhase;
import org.adde0109.ambassador.velocity.backend.VelocityForgeBackendConnectionPhase;
import java.util.Collections;
@ -19,7 +20,7 @@ public class ForgeFMLConnectionType implements ConnectionType {
@Override
public ClientConnectionPhase getInitialClientPhase() {
return new FML2ClientConnectionPhase();
return VelocityForgeClientConnectionPhase.NOT_STARTED;
}
@Override

27
src/main/java/org/adde0109/ambassador/velocity/VelocityEventHandler.java
View File

@ -11,7 +11,6 @@ import com.velocitypowered.proxy.connection.backend.VelocityServerConnection;
import com.velocitypowered.proxy.connection.client.ConnectedPlayer;
import com.velocitypowered.proxy.protocol.StateRegistry;
import org.adde0109.ambassador.Ambassador;
import org.adde0109.ambassador.forge.FML2CRPMClientConnectionPhase;
public class VelocityEventHandler {
@ -40,31 +39,9 @@ public class VelocityEventHandler {
continuation.resume();
}
@Subscribe(order = PostOrder.LAST)
public void onKickedFromServerEvent(KickedFromServerEvent event, Continuation continuation) {
if (((ConnectedPlayer) event.getPlayer()).getPhase() instanceof FML2CRPMClientConnectionPhase phase) {
phase.handleKick(event);
}
continuation.resume();
}
@Subscribe(order = PostOrder.LAST)
public void onServerPreConnectEvent(ServerPreConnectEvent event, Continuation continuation) {
ConnectedPlayer player = (ConnectedPlayer) event.getPlayer();
if (!(player.getPhase() instanceof VelocityForgeClientConnectionPhase phase)) {
continuation.resume();
return;
}
if (phase.internalServerConnection != null) {
event.setResult(ServerPreConnectEvent.ServerResult.denied());
player.setConnectedServer((VelocityServerConnection) phase.internalServerConnection);
phase.internalServerConnection = null;
} else if (phase.clientPhase == VelocityForgeClientConnectionPhase.ClientPhase.MODDED) {
player.getConnection().eventLoop().submit(() -> phase.reset(event.getOriginalServer(), (ConnectedPlayer) event.getPlayer())
.thenAccept((ignored) -> continuation.resume()));
} else {
continuation.resume();
}
continuation.resume();
}
@Subscribe(order = PostOrder.LAST)
@ -74,7 +51,7 @@ public class VelocityEventHandler {
continuation.resume();
return;
}
RegisteredServer chosenServer = phase.chooseServer(player);
RegisteredServer chosenServer = Ambassador.getTemporaryForced().remove(player.getUsername());
if (chosenServer != null)
event.setInitialServer(chosenServer);
continuation.resume();

126
src/main/java/org/adde0109/ambassador/velocity/VelocityForgeClientConnectionPhase.java
View File

@ -1,5 +1,6 @@
package org.adde0109.ambassador.velocity;
import com.velocitypowered.api.event.player.KickedFromServerEvent;
import com.velocitypowered.api.proxy.ServerConnection;
import com.velocitypowered.api.proxy.server.RegisteredServer;
import com.velocitypowered.proxy.VelocityServer;
@ -7,58 +8,115 @@ import com.velocitypowered.proxy.connection.MinecraftConnection;
import com.velocitypowered.proxy.connection.backend.VelocityServerConnection;
import com.velocitypowered.proxy.connection.client.ClientConnectionPhase;
import com.velocitypowered.proxy.connection.client.ConnectedPlayer;
import com.velocitypowered.proxy.network.Connections;
import com.velocitypowered.proxy.protocol.StateRegistry;
import com.velocitypowered.proxy.protocol.packet.LoginPluginMessage;
import com.velocitypowered.proxy.protocol.packet.LoginPluginResponse;
import com.velocitypowered.proxy.protocol.packet.PluginMessage;
import io.netty.buffer.Unpooled;
import net.kyori.adventure.text.Component;
import org.adde0109.ambassador.Ambassador;
import org.adde0109.ambassador.forge.FML2CRPMResetCompleteDecoder;
import org.adde0109.ambassador.forge.ForgeConstants;
import org.adde0109.ambassador.forge.ForgeHandshakeUtils;
import org.adde0109.ambassador.velocity.client.OutboundForgeHandshakeHolder;
import java.lang.reflect.InvocationTargetException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ScheduledFuture;
public abstract class VelocityForgeClientConnectionPhase implements ClientConnectionPhase {
public enum VelocityForgeClientConnectionPhase implements ClientConnectionPhase {
//TODO:Make class when PCF is done
NOT_STARTED {
@Override
VelocityForgeClientConnectionPhase nextPhase() {
return IN_PROGRESS;
}
},
IN_PROGRESS {
VelocityLoginPayloadManager payloadManager;
public VelocityForgeClientConnectionPhase.ClientPhase clientPhase = ClientPhase.HANDSHAKE;
},
COMPLETE {
public ServerConnection internalServerConnection;
public RegisteredServer forced;
@Override
public void resetConnectionPhase(ConnectedPlayer player) {
MinecraftConnection connection = player.getConnection();
protected VelocityForgeClientConnectionPhase(ClientPhase clientPhase, VelocityLoginPayloadManager payloadManager) {
this.clientPhase = clientPhase;
this.payloadManager = payloadManager;
}
protected VelocityForgeClientConnectionPhase() {
}
public RegisteredServer chooseServer(ConnectedPlayer player) {
return null;
}
//We unregister so no plugin sees this client while the client is being reset.
((VelocityServer) Ambassador.getInstance().server).unregisterConnection(player);
connection.getChannel().pipeline().addBefore(Connections.MINECRAFT_DECODER, ForgeConstants.RESET_LISTENER,new FML2CRPMResetCompleteDecoder());
connection.getChannel().pipeline().addLast(ForgeConstants.FORGE_HANDSHAKE_HOLDER,new OutboundForgeHandshakeHolder());
connection.write(new PluginMessage("fml:handshake", Unpooled.wrappedBuffer(ForgeHandshakeUtils.generatePluginResetPacket())));
player.setPhase(WAITING_RESET);
WAITING_RESET.onTransitionToNewPhase(player);
}
},
WAITING_RESET {
ScheduledFuture<?> scheduledFuture;
@Override
void onTransitionToNewPhase(ConnectedPlayer player) {
scheduledFuture = player.getConnection().eventLoop().schedule(()-> {
player.getConnection().getChannel().pipeline().remove(ForgeConstants.RESET_LISTENER);
Ambassador.getTemporaryForced().put(player.getUsername(), player.getConnectionInFlight().getServer(),
Ambassador.getInstance().config.getServerSwitchCancellationTime(), TimeUnit.SECONDS);
//Disconnect - Reset Timeout
player.disconnect(Component.text(Ambassador.getInstance().config.getDisconnectResetMessage()));
}, Ambassador.getInstance().config.getResetTimeout(), TimeUnit.MILLISECONDS);
}
@Override
public boolean handle(ConnectedPlayer player, LoginPluginResponse response, VelocityServerConnection server) {
if (response.getId() == 98) {
if (scheduledFuture.cancel(false)) {
player.getConnection().getChannel().pipeline().remove(ForgeConstants.RESET_LISTENER);
player.getConnection().setState(StateRegistry.LOGIN);
player.setPhase(NOT_STARTED);
//Send all held messages
player.getConnection().getChannel().pipeline().remove(ForgeConstants.FORGE_HANDSHAKE_HOLDER);
player.getConnection().setSessionHandler(new VelocityForgeHandshakeSessionHandler(player.getConnection().getSessionHandler(),player));
}
return true;
} else {
return false;
}
}
};
public CompletableFuture<Boolean> reset(RegisteredServer server, ConnectedPlayer player) {
return CompletableFuture.completedFuture(false);
}
final void onFirstLogin(ConnectedPlayer player, VelocityServer server) throws InterruptedException, InvocationTargetException, IllegalAccessException {
}
public void handleForward(VelocityServerConnection serverConnection, LoginPluginMessage payload) {
}
public final VelocityLoginPayloadManager getPayloadManager() {
return payloadManager;
}
public ServerConnection internalServerConnection;
public boolean handle(ConnectedPlayer player, LoginPluginResponse response, VelocityServerConnection server) {
server.getConnection().write(response.retain());
player.setPhase(nextPhase());
player.getConnectionInFlight().getConnection().write(response.retain());
return true;
}
public enum ClientPhase {
VANILLA,
HANDSHAKE,
MODLIST,
MODDED
private RegisteredServer lastKnownWorking;
void onTransitionToNewPhase(ConnectedPlayer player) {
}
VelocityForgeClientConnectionPhase nextPhase() {
return this;
}
/*
public void handleKick(KickedFromServerEvent event) {
//If kicked before the client has entered PLAY and has been reset.
if (lastKnownWorking != null && !(event.getResult() instanceof KickedFromServerEvent.RedirectPlayer)) {
net.kyori.adventure.text.Component reason = event.getServerKickReason().orElse(null);
event.setResult(KickedFromServerEvent.RedirectPlayer.create(lastKnownWorking,reason));
lastKnownWorking = null;
}
}
*/
}

62
src/main/java/org/adde0109/ambassador/velocity/VelocityLoginPayloadManager.java
View File

@ -1,62 +0,0 @@
package org.adde0109.ambassador.velocity;
import com.velocitypowered.proxy.connection.MinecraftConnection;
import com.velocitypowered.proxy.protocol.packet.LoginPluginMessage;
import com.velocitypowered.proxy.protocol.packet.LoginPluginResponse;
import io.netty.buffer.ByteBuf;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.CompletableFuture;
public class VelocityLoginPayloadManager {
private final HashMap<Integer, CompletableFuture<ByteBuf>> listenerList = new HashMap<>();
private int counter = 0;
private final MinecraftConnection connection;
public VelocityLoginPayloadManager(MinecraftConnection connection) {
this.connection = connection;
}
public CompletableFuture<ByteBuf> sendPayload(String channel, ByteBuf data) {
connection.write(new LoginPluginMessage(counter,channel,data));
CompletableFuture<ByteBuf> future = listenFor(counter);
counter++;
return future;
}
public CompletableFuture<ByteBuf> sendPayloads(String channel, List<ByteBuf> dataList) {
final CompletableFuture<ByteBuf> callback = new CompletableFuture<>();
for (ByteBuf data : dataList) {
connection.delayedWrite(new LoginPluginMessage(counter, channel, data));
listenerList.put(counter,callback);
counter++;
}
connection.flush();
return callback;
}
public CompletableFuture<ByteBuf> listenFor(int id) {
CompletableFuture<ByteBuf> value = listenerList.get(id);
if (value == null) {
CompletableFuture<ByteBuf> callback = new CompletableFuture<>();
listenerList.put(id,callback);
return callback;
} else {
return value;
}
}
boolean handlePayload(LoginPluginResponse response) {
final CompletableFuture<ByteBuf> callback = listenerList.get(response.getId());
if (callback != null) {
listenerList.remove(response.getId());
if (!listenerList.containsValue(callback)) {
callback.complete(response.content());
}
return true;
} else {
return false;
}
}
}

19
src/main/java/org/adde0109/ambassador/velocity/backend/ForgeHandshakeSessionHandler.java → src/main/java/org/adde0109/ambassador/velocity/backend/ForgeLoginSessionHandler.java
View File

@ -4,26 +4,19 @@ import com.velocitypowered.proxy.VelocityServer;
import com.velocitypowered.proxy.connection.MinecraftSessionHandler;
import com.velocitypowered.proxy.connection.backend.BackendConnectionPhases;
import com.velocitypowered.proxy.connection.backend.LoginSessionHandler;
import com.velocitypowered.proxy.connection.backend.TransitionSessionHandler;
import com.velocitypowered.proxy.connection.backend.VelocityServerConnection;
import com.velocitypowered.proxy.protocol.MinecraftPacket;
import com.velocitypowered.proxy.protocol.packet.Disconnect;
import com.velocitypowered.proxy.protocol.packet.LoginPluginMessage;
import com.velocitypowered.proxy.protocol.packet.ServerLoginSuccess;
import io.netty.buffer.ByteBuf;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.format.TextColor;
import org.adde0109.ambassador.forge.ForgeConstants;
import org.adde0109.ambassador.forge.ForgeFMLConnectionType;
import org.adde0109.ambassador.velocity.VelocityForgeClientConnectionPhase;
public class ForgeHandshakeSessionHandler implements MinecraftSessionHandler {
public class ForgeLoginSessionHandler implements MinecraftSessionHandler {
private final LoginSessionHandler original;
private final VelocityServerConnection serverConnection;
private final VelocityServer server;
public ForgeHandshakeSessionHandler(LoginSessionHandler original, VelocityServerConnection serverConnection, VelocityServer server) {
public ForgeLoginSessionHandler(LoginSessionHandler original, VelocityServerConnection serverConnection, VelocityServer server) {
this.original = original;
this.serverConnection = serverConnection;
this.server = server;
@ -47,7 +40,11 @@ public class ForgeHandshakeSessionHandler implements MinecraftSessionHandler {
if ((serverConnection.getPhase() instanceof VelocityForgeBackendConnectionPhase phase)) {
phase.onLoginSuccess(serverConnection,serverConnection.getPlayer());
}
return original.handle(packet);
original.handle(packet);
serverConnection.getConnection().setSessionHandler(
new ForgePlaySessionHandler((TransitionSessionHandler) serverConnection
.getConnection().getSessionHandler(),serverConnection));
return true;
}

41
src/main/java/org/adde0109/ambassador/velocity/backend/ForgePlaySessionHandler.java Normal file
View File

@ -0,0 +1,41 @@
package org.adde0109.ambassador.velocity.backend;
import com.velocitypowered.proxy.connection.MinecraftSessionHandler;
import com.velocitypowered.proxy.connection.backend.TransitionSessionHandler;
import com.velocitypowered.proxy.connection.backend.VelocityServerConnection;
import com.velocitypowered.proxy.protocol.MinecraftPacket;
import com.velocitypowered.proxy.protocol.packet.JoinGame;
import org.adde0109.ambassador.velocity.VelocityForgeClientConnectionPhase;
public class ForgePlaySessionHandler implements MinecraftSessionHandler {
private final TransitionSessionHandler original;
private final VelocityServerConnection serverConnection;
public ForgePlaySessionHandler(TransitionSessionHandler original, VelocityServerConnection serverConnection) {
this.original = original;
this.serverConnection = serverConnection;
}
@Override
public boolean handle(JoinGame packet) {
if (serverConnection.getPlayer().getPhase() instanceof VelocityForgeClientConnectionPhase clientPhase) {
serverConnection.getPlayer().setPhase(VelocityForgeClientConnectionPhase.COMPLETE);
}
return MinecraftSessionHandler.super.handle(packet);
}
@Override
public void disconnected() {
original.disconnected();
}
public void handleGeneric(MinecraftPacket packet) {
if (!packet.handle(original))
original.handleGeneric(packet);
}
public MinecraftSessionHandler getOriginal() {
return this.original;
}
}

27
src/main/java/org/adde0109/ambassador/velocity/backend/VelocityForgeBackendConnectionPhase.java
View File

@ -3,9 +3,11 @@ package org.adde0109.ambassador.velocity.backend;
import com.velocitypowered.proxy.connection.MinecraftConnection;
import com.velocitypowered.proxy.connection.backend.BackendConnectionPhase;
import com.velocitypowered.proxy.connection.backend.VelocityServerConnection;
import com.velocitypowered.proxy.connection.client.ClientConnectionPhase;
import com.velocitypowered.proxy.connection.client.ConnectedPlayer;
import com.velocitypowered.proxy.protocol.StateRegistry;
import com.velocitypowered.proxy.protocol.packet.LoginPluginMessage;
import io.netty.channel.PendingWriteQueue;
import org.adde0109.ambassador.forge.ForgeConstants;
import org.adde0109.ambassador.velocity.VelocityForgeClientConnectionPhase;
@ -34,34 +36,21 @@ public enum VelocityForgeBackendConnectionPhase implements BackendConnectionPhas
}
};
VelocityForgeBackendConnectionPhase() {
}
public void handle(VelocityServerConnection server, ConnectedPlayer player, LoginPluginMessage message) {
VelocityForgeBackendConnectionPhase newPhase = nextPhase();
server.setConnectionPhase(newPhase);
VelocityForgeClientConnectionPhase clientPhase = ((VelocityForgeClientConnectionPhase) player.getPhase());
if (player.getConnection().getState() != StateRegistry.LOGIN) {
final LoginPluginMessage msg = message;
msg.content().retain().discardSomeReadBytes();
server.getConnection().getChannel().config().setAutoRead(false);
clientPhase.reset(server.getServer(),player).thenAccept((success) -> {
if (success) {
player.getConnection().write(msg);
server.getConnection().getChannel().config().setAutoRead(true);
} else {
msg.release();
}
});
} else {
player.getConnection().write(message.retain());
}
//Reset client if not ready to receive new handshake
VelocityForgeClientConnectionPhase clientPhase = (VelocityForgeClientConnectionPhase) player.getPhase();
clientPhase.resetConnectionPhase(player);
player.getConnection().write(message.retain());
}
public void onLoginSuccess(VelocityServerConnection serverCon, ConnectedPlayer player) {

2
src/main/java/org/adde0109/ambassador/velocity/backend/VelocityForgeBackendHandshakeHandler.java
View File

@ -25,7 +25,7 @@ public class VelocityForgeBackendHandshakeHandler extends ChannelInboundHandlerA
ctx.pipeline().remove(this);
if (serverConnection.getPlayer().getConnection().getType() instanceof ForgeFMLConnectionType) {
connection.setSessionHandler(new ForgeHandshakeSessionHandler((LoginSessionHandler) connection.getSessionHandler(),serverConnection,server));
connection.setSessionHandler(new ForgeLoginSessionHandler((LoginSessionHandler) connection.getSessionHandler(),serverConnection,server));
}
ctx.pipeline().fireChannelActive();

34
src/main/java/org/adde0109/ambassador/velocity/client/OutboundForgeHandshakeHolder.java Normal file
View File

@ -0,0 +1,34 @@
package org.adde0109.ambassador.velocity.client;
import com.velocitypowered.proxy.protocol.packet.LoginPluginMessage;
import com.velocitypowered.proxy.protocol.packet.ServerLoginSuccess;
import io.netty.channel.*;
public class OutboundForgeHandshakeHolder extends ChannelOutboundHandlerAdapter {
PendingWriteQueue writeQueue;
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
writeQueue = new PendingWriteQueue(ctx);
}
@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
if ((msg instanceof LoginPluginMessage packet)) {
writeQueue.add(msg, promise);
} else {
ctx.write(msg, promise);
}
}
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
if (ctx.channel().isActive()) {
writeQueue.removeAndWriteAll();
ctx.flush();
} else {
writeQueue.removeAndFailAll(new ChannelException());
}
}
}