From b79eba247d4dcc40d3a5688da52b493e72567172 Mon Sep 17 00:00:00 2001 From: Finn Date: Sat, 20 Sep 2025 20:41:08 +0200 Subject: [PATCH] - Finished with Domain resolving --- .../protocol/ProtocolBridge.java | 54 +++++++------ .../protocol/packets/OACPacket.java | 6 +- .../v1_0_0/beta/GetDestinationPacket.java | 76 +++++++++++++++++++ .../v1_0_0/beta/UnsupportedClassicPacket.java | 6 +- .../v1_0_0/beta/ValidateDomainPacket.java | 56 ++++++++++++++ .../v1_0_0/classic/Classic_MessagePacket.java | 2 +- .../protocol/side/client/ProtocolClient.java | 13 +++- .../protocol/side/server/ProtocolServer.java | 5 ++ .../versions/v1_0_0/beta/DNSResponseCode.java | 20 +++-- .../protocol/versions/v1_0_0/beta/Domain.java | 3 + .../v1_0_0/classic/ClassicHandlerServer.java | 4 +- 11 files changed, 211 insertions(+), 34 deletions(-) create mode 100644 src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/GetDestinationPacket.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/ValidateDomainPacket.java diff --git a/src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java b/src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java index 9772d37..69b960e 100644 --- a/src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java +++ b/src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java @@ -3,7 +3,13 @@ package github.openautonomousconnection.protocol; import github.openautonomousconnection.protocol.listeners.ClientListener; import github.openautonomousconnection.protocol.listeners.ServerListener; import github.openautonomousconnection.protocol.packets.OACPacket; +import github.openautonomousconnection.protocol.packets.v1_0_0.beta.AuthPacket; +import github.openautonomousconnection.protocol.packets.v1_0_0.beta.GetDestinationPacket; +import github.openautonomousconnection.protocol.packets.v1_0_0.beta.UnsupportedClassicPacket; +import github.openautonomousconnection.protocol.packets.v1_0_0.beta.ValidateDomainPacket; import github.openautonomousconnection.protocol.versions.ProtocolVersion; +import github.openautonomousconnection.protocol.versions.v1_0_0.beta.DNSResponseCode; +import github.openautonomousconnection.protocol.versions.v1_0_0.beta.Domain; import github.openautonomousconnection.protocol.versions.v1_0_0.classic.ClassicHandlerClient; import github.openautonomousconnection.protocol.versions.v1_0_0.classic.ClassicHandlerServer; import github.openautonomousconnection.protocol.packets.v1_0_0.classic.Classic_DomainPacket; @@ -66,17 +72,8 @@ public class ProtocolBridge { System.exit(1); } - if (isClassicSupported()) { - protocolSettings.eventManager.unregisterListener(new Classic_ClientListener()); - - Classic_DomainPacket cDomainPacket = new Classic_DomainPacket(); - Classic_DomainPacket cMessagePacket = new Classic_DomainPacket(); - Classic_DomainPacket cPingPacket = new Classic_DomainPacket(); - - if (isPacketSupported(cDomainPacket)) protocolSettings.packetHandler.registerPacket(cDomainPacket); - if (isPacketSupported(cMessagePacket)) protocolSettings.packetHandler.registerPacket(cMessagePacket); - if (isPacketSupported(cPingPacket)) protocolSettings.packetHandler.registerPacket(cPingPacket); - } + if (isClassicSupported()) protocolSettings.eventManager.unregisterListener(new Classic_ClientListener()); + registerPackets(); instance = this; } @@ -104,21 +101,34 @@ public class ProtocolBridge { System.exit(1); } - if (isClassicSupported()) { - protocolSettings.eventManager.registerListener(new Classic_ClientListener()); - - Classic_DomainPacket cDomainPacket = new Classic_DomainPacket(); - Classic_DomainPacket cMessagePacket = new Classic_DomainPacket(); - Classic_DomainPacket cPingPacket = new Classic_DomainPacket(); - - if (isPacketSupported(cDomainPacket)) protocolSettings.packetHandler.registerPacket(cDomainPacket); - if (isPacketSupported(cMessagePacket)) protocolSettings.packetHandler.registerPacket(cMessagePacket); - if (isPacketSupported(cPingPacket)) protocolSettings.packetHandler.registerPacket(cPingPacket); - } + if (isClassicSupported()) protocolSettings.eventManager.registerListener(new Classic_ClientListener()); + registerPackets(); instance = this; } + private void registerPackets() { + // Classic packets + Classic_DomainPacket cDomainPacket = new Classic_DomainPacket(); + Classic_DomainPacket cMessagePacket = new Classic_DomainPacket(); + Classic_DomainPacket cPingPacket = new Classic_DomainPacket(); + + if (isPacketSupported(cDomainPacket)) protocolSettings.packetHandler.registerPacket(cDomainPacket); + if (isPacketSupported(cMessagePacket)) protocolSettings.packetHandler.registerPacket(cMessagePacket); + if (isPacketSupported(cPingPacket)) protocolSettings.packetHandler.registerPacket(cPingPacket); + + // 1.0.0-BETA packets + AuthPacket v100bAuthPath = new AuthPacket(); + UnsupportedClassicPacket v100bUnsupportedClassicPacket = new UnsupportedClassicPacket(); + ValidateDomainPacket v100bValidateDomainPacket = new ValidateDomainPacket(); + GetDestinationPacket v100bGetDestinationPacket = new GetDestinationPacket(); + + if (isPacketSupported(v100bAuthPath)) protocolSettings.packetHandler.registerPacket(v100bAuthPath); + if (isPacketSupported(v100bUnsupportedClassicPacket)) protocolSettings.packetHandler.registerPacket(v100bUnsupportedClassicPacket); + if (isPacketSupported(v100bValidateDomainPacket)) protocolSettings.packetHandler.registerPacket(v100bValidateDomainPacket); + if (isPacketSupported(v100bGetDestinationPacket)) protocolSettings.packetHandler.registerPacket(v100bGetDestinationPacket); + } + public boolean isPacketSupported(OACPacket packet) { return isVersionSupported(packet.getProtocolVersion()); } diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java index 1a4d29b..f4137c4 100644 --- a/src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java +++ b/src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java @@ -39,9 +39,13 @@ public abstract class OACPacket extends Packet { @Override public final void read(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException { onRead(packetHandler, objectInputStream); - if (protocolVersion != ProtocolVersion.PV_1_0_0_CLASSIC) responseCode = (DNSResponseCode) objectInputStream.readObject(); + if (protocolVersion != ProtocolVersion.PV_1_0_0_CLASSIC) { + responseCode = (DNSResponseCode) objectInputStream.readObject(); + onResponseCodeRead(packetHandler, objectInputStream); + } } public abstract void onWrite(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException; public abstract void onRead(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException; + protected void onResponseCodeRead(PacketHandler packetHandler, ObjectInputStream objectInputStream) {} } diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/GetDestinationPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/GetDestinationPacket.java new file mode 100644 index 0000000..fdfba9a --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/GetDestinationPacket.java @@ -0,0 +1,76 @@ +package github.openautonomousconnection.protocol.packets.v1_0_0.beta; + +import github.openautonomousconnection.protocol.ProtocolBridge; +import github.openautonomousconnection.protocol.packets.OACPacket; +import github.openautonomousconnection.protocol.versions.ProtocolVersion; +import github.openautonomousconnection.protocol.versions.v1_0_0.beta.DNSResponseCode; +import github.openautonomousconnection.protocol.versions.v1_0_0.beta.Domain; +import me.finn.unlegitlibrary.network.system.packets.PacketHandler; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.function.DoubleBinaryOperator; + +public class GetDestinationPacket extends OACPacket { + private Domain domain; + private int clientID; + private DNSResponseCode validationResponse; + private String destination; + + public GetDestinationPacket(Domain domain, DNSResponseCode validationResponse, String destination) { + this(); + this.domain = domain; + this.validationResponse = validationResponse; + this.destination = destination; + } + + public GetDestinationPacket() { + super(6, ProtocolVersion.PV_1_0_0_BETA); + } + + @Override + public void onWrite(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException { + if (ProtocolBridge.getInstance().isRunningAsClient()) { + if (validationResponse != DNSResponseCode.RESPONSE_DOMAIN_FULLY_EXIST) return; + + objectOutputStream.writeInt(ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().getClientID()); + objectOutputStream.writeObject(domain); + objectOutputStream.writeObject(validationResponse); + } else { + objectOutputStream.writeObject(domain); + objectOutputStream.writeObject(validationResponse); + objectOutputStream.writeUTF(destination); + } + } + + @Override + public void onRead(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException { + if (ProtocolBridge.getInstance().isRunningAsServer()) { + clientID = objectInputStream.readInt(); + domain = (Domain) objectInputStream.readObject(); + validationResponse = (DNSResponseCode) objectInputStream.readObject(); + } else { + domain = (Domain) objectInputStream.readObject(); + validationResponse = (DNSResponseCode) objectInputStream.readObject(); + destination = objectInputStream.readUTF(); + + ProtocolBridge.getInstance().getProtocolClient().getDestinationCompleted(domain, destination, validationResponse); + } + } + + @Override + protected void onResponseCodeRead(PacketHandler packetHandler, ObjectInputStream objectInputStream) { + super.onResponseCodeRead(packetHandler, objectInputStream); + + if (ProtocolBridge.getInstance().isRunningAsServer()) { + if (validationResponse != DNSResponseCode.RESPONSE_DOMAIN_FULLY_EXIST) return; + destination = domain.getDestination(); + try { + ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID).getConnectionHandler().sendPacket(new GetDestinationPacket(domain, validationResponse, destination)); + } catch (IOException | ClassNotFoundException exception) { + ProtocolBridge.getInstance().getProtocolServer().getDomainDestinationFailed(ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID), domain, validationResponse, exception); + } + } + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/UnsupportedClassicPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/UnsupportedClassicPacket.java index 07a758b..d36c92a 100644 --- a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/UnsupportedClassicPacket.java +++ b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/UnsupportedClassicPacket.java @@ -27,6 +27,7 @@ public class UnsupportedClassicPacket extends OACPacket { @Override public void onWrite(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException { + if (ProtocolBridge.getInstance().isRunningAsClient()) objectOutputStream.writeInt(ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().getClientID()); objectOutputStream.writeUTF(unsupportedClassicPacket.getName()); objectOutputStream.writeInt(content.length); for (Object o : content) objectOutputStream.writeObject(o); @@ -35,6 +36,8 @@ public class UnsupportedClassicPacket extends OACPacket { @Override public void onRead(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException { + int clientID = 0; + if (ProtocolBridge.getInstance().isRunningAsServer()) clientID = objectInputStream.readInt(); String className = objectInputStream.readUTF(); int size = objectInputStream.readInt(); content = new Object[size]; @@ -43,6 +46,7 @@ public class UnsupportedClassicPacket extends OACPacket { content[i] = objectInputStream.readObject(); } - ProtocolBridge.getInstance().getClassicHandlerClient().unsupportedClassicPacket(className, content); + if (ProtocolBridge.getInstance().isRunningAsServer()) ProtocolBridge.getInstance().getClassicHandlerServer().unsupportedClassicPacket(className, content, ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID)); + else ProtocolBridge.getInstance().getClassicHandlerClient().unsupportedClassicPacket(className, content); } } diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/ValidateDomainPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/ValidateDomainPacket.java new file mode 100644 index 0000000..946887c --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/beta/ValidateDomainPacket.java @@ -0,0 +1,56 @@ +package github.openautonomousconnection.protocol.packets.v1_0_0.beta; + +import github.openautonomousconnection.protocol.ProtocolBridge; +import github.openautonomousconnection.protocol.packets.OACPacket; +import github.openautonomousconnection.protocol.versions.ProtocolVersion; +import github.openautonomousconnection.protocol.versions.v1_0_0.beta.Domain; +import me.finn.unlegitlibrary.network.system.packets.PacketHandler; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; + +public class ValidateDomainPacket extends OACPacket { + private Domain domain; + private int clientID; + + public ValidateDomainPacket(Domain domain) { + this(); + this.domain = domain; + } + + public ValidateDomainPacket() { + super(6, ProtocolVersion.PV_1_0_0_BETA); + } + + @Override + public void onWrite(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException { + if (ProtocolBridge.getInstance().isRunningAsClient()) objectOutputStream.writeInt(ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().getClientID()); + else setResponseCode(ProtocolBridge.getInstance().getProtocolServer().validateDomain(domain)); + + objectOutputStream.writeObject(domain); + } + + @Override + public void onRead(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException { + if (ProtocolBridge.getInstance().isRunningAsServer()) clientID = objectInputStream.readInt(); + domain = (Domain) objectInputStream.readObject(); + } + + @Override + protected void onResponseCodeRead(PacketHandler packetHandler, ObjectInputStream objectInputStream) { + super.onResponseCodeRead(packetHandler, objectInputStream); + + if (ProtocolBridge.getInstance().isRunningAsServer()) { + try { + ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID).getConnectionHandler().sendPacket(new ValidateDomainPacket(domain)); + } catch (IOException | ClassNotFoundException e) { + ProtocolBridge.getInstance().getProtocolServer().validationFailed(domain, ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID), e); + } + + return; + } + + ProtocolBridge.getInstance().getProtocolClient().validationCompleted(domain, getResponseCode()); + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_MessagePacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_MessagePacket.java index a8ae3f0..951a7f7 100644 --- a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_MessagePacket.java +++ b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_MessagePacket.java @@ -44,7 +44,7 @@ public class Classic_MessagePacket extends OACPacket { String message = objectInputStream.readUTF(); Classic_ProtocolVersion protocolVersion = (Classic_ProtocolVersion) objectInputStream.readObject(); - ProtocolBridge.getInstance().getClassicHandlerServer().handleMessage(ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID), message, protocolVersion); + ProtocolBridge.getInstance().getClassicHandlerServer().handleMessage(ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID), message, protocolVersion); } else { clientID = objectInputStream.readInt(); String message = objectInputStream.readUTF(); diff --git a/src/main/java/github/openautonomousconnection/protocol/side/client/ProtocolClient.java b/src/main/java/github/openautonomousconnection/protocol/side/client/ProtocolClient.java index 2587f7e..5325206 100644 --- a/src/main/java/github/openautonomousconnection/protocol/side/client/ProtocolClient.java +++ b/src/main/java/github/openautonomousconnection/protocol/side/client/ProtocolClient.java @@ -2,15 +2,19 @@ package github.openautonomousconnection.protocol.side.client; import github.openautonomousconnection.protocol.ProtocolBridge; import github.openautonomousconnection.protocol.packets.OACPacket; +import github.openautonomousconnection.protocol.packets.v1_0_0.beta.ValidateDomainPacket; import github.openautonomousconnection.protocol.versions.ProtocolVersion; +import github.openautonomousconnection.protocol.versions.v1_0_0.beta.DNSResponseCode; +import github.openautonomousconnection.protocol.versions.v1_0_0.beta.Domain; import lombok.Getter; import me.finn.unlegitlibrary.network.system.client.NetworkClient; import me.finn.unlegitlibrary.network.system.client.events.ClientDisconnectedEvent; import me.finn.unlegitlibrary.utils.DefaultMethodsOverrider; import java.io.File; +import java.io.IOException; -public class ProtocolClient extends DefaultMethodsOverrider { +public abstract class ProtocolClient extends DefaultMethodsOverrider { private ProtocolVersion serverVersion = null; @Getter @@ -78,6 +82,10 @@ public class ProtocolClient extends DefaultMethodsOverrider { return getServerVersion() == targetVersion || getServerVersion().getCompatibleVersions().contains(targetVersion); } + public final void validateDomain(Domain domain) throws IOException, ClassNotFoundException { + networkClient.sendPacket(new ValidateDomainPacket(domain)); + } + public ProtocolClient(File caFolder, File certificatesClientFolder, File certificatesKeyFolder) { if (!caFolder.exists()) caFolder.mkdirs(); if (!certificatesClientFolder.exists()) certificatesClientFolder.mkdirs(); @@ -89,4 +97,7 @@ public class ProtocolClient extends DefaultMethodsOverrider { setRootCAFolder(caFolder).setClientCertificatesFolder(certificatesClientFolder, certificatesKeyFolder). build(); } + + public abstract void validationCompleted(Domain domain, DNSResponseCode responseCode); + public abstract void getDestinationCompleted(Domain domain, String destination, DNSResponseCode validationResponse); } diff --git a/src/main/java/github/openautonomousconnection/protocol/side/server/ProtocolServer.java b/src/main/java/github/openautonomousconnection/protocol/side/server/ProtocolServer.java index c5b0943..b5da4a3 100644 --- a/src/main/java/github/openautonomousconnection/protocol/side/server/ProtocolServer.java +++ b/src/main/java/github/openautonomousconnection/protocol/side/server/ProtocolServer.java @@ -1,9 +1,11 @@ package github.openautonomousconnection.protocol.side.server; import github.openautonomousconnection.protocol.ProtocolBridge; +import github.openautonomousconnection.protocol.versions.v1_0_0.beta.DNSResponseCode; import github.openautonomousconnection.protocol.versions.v1_0_0.beta.Domain; import lombok.Getter; import me.finn.unlegitlibrary.file.ConfigurationManager; +import me.finn.unlegitlibrary.network.system.server.ConnectionHandler; import me.finn.unlegitlibrary.network.system.server.NetworkServer; import me.finn.unlegitlibrary.utils.DefaultMethodsOverrider; @@ -60,4 +62,7 @@ public abstract class ProtocolServer extends DefaultMethodsOverrider { public abstract String getDomainDestination(Domain domain); public abstract String getSubnameDestination(Domain domain, String subname); public abstract String getTLNInfoSite(String topLevelName); + public abstract DNSResponseCode validateDomain(Domain requestedDomain); + public abstract void validationFailed(Domain domain, ConnectedProtocolClient client, Exception exception); + public abstract void getDomainDestinationFailed(ConnectedProtocolClient client, Domain domain, DNSResponseCode validationResponse, Exception exception); } diff --git a/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/DNSResponseCode.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/DNSResponseCode.java index 9483a68..c653c4b 100644 --- a/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/DNSResponseCode.java +++ b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/DNSResponseCode.java @@ -2,16 +2,19 @@ package github.openautonomousconnection.protocol.versions.v1_0_0.beta; import lombok.Getter; -public enum DNSResponseCode { +import java.io.Serializable; + +public enum DNSResponseCode implements Serializable { RESPONSE_NOT_REQUIRED(0, "Response code not required"), + RESPONSE_INVALID_REQUEST(1, "Invalid request"), - RESPONSE_AUTH_SUCCESS(1, "Auth success"), - RESPONSE_AUTH_FAILED(2, "Auth failed"), + RESPONSE_AUTH_SUCCESS(4, "Auth success"), + RESPONSE_AUTH_FAILED(5, "Auth failed"), - RESPONSE_DOMAIN_EXIST(100, "Domain exist"), - RESPONSE_DOMAIN_NOT_EXIST(101, "Domain does not exist"), - RESPONSE_DOMAIN_CREATED(105, "Domain created"), - RESPONSE_DOMAIN_DELETED(106, "Domain deleted"), + RESPONSE_DOMAIN_NAME_EXIST(100, "Domainname exist"), + RESPONSE_DOMAIN_NAME_NOT_EXIST(101, "Domainname does not exist"), + RESPONSE_DOMAIN_NAME_CREATED(105, "Domainname created"), + RESPONSE_DOMAIN_NAME_DELETED(106, "Domainname deleted"), RESPONSE_DOMAIN_TLN_EXIST(110, "TopLevelName exist"), RESPONSE_DOMAIN_TLN_NOT_EXIST(111, "TopLevelName does not exist"), @@ -22,6 +25,9 @@ public enum DNSResponseCode { RESPONSE_DOMAIN_SUBNAME_NOT_EXIST(121, "Subname does not exist"), RESPONSE_DOMAIN_SUBNAME_CREATED(125, "Subname created"), RESPONSE_DOMAIN_SUBNAME_DELETED(126, "Subname deleted"), + + RESPONSE_DOMAIN_FULLY_EXIST(130, "Full domain exist"), + RESPONSE_DOMAIN_FULLY_NOT_EXIST(131, "Full domain does not exist") ; @Getter diff --git a/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/Domain.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/Domain.java index e61b3e3..9fad6df 100644 --- a/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/Domain.java +++ b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/beta/Domain.java @@ -85,7 +85,10 @@ public class Domain implements Serializable { domain.getTopLevelName().equalsIgnoreCase(this.topLevelName) && domain.getProtocol().equalsIgnoreCase(this.protocol); } + public final String getDestination() { + if (ProtocolBridge.getInstance().isRunningAsClient()) return DNSResponseCode.RESPONSE_INVALID_REQUEST.toString(); + if (this.equals(DefaultDomains.DNS_INFO_SITE)) return ProtocolBridge.getInstance().getProtocolServer().getDNSInfoSite(); if (this.equals(DefaultDomains.DNS_REGISTER_SITE)) return ProtocolBridge.getInstance().getProtocolServer().getDNSRegisterSite(); if (this.name.equalsIgnoreCase("about") && this.protocol.equalsIgnoreCase("oac")) return ProtocolBridge.getInstance().getProtocolServer().getTLNInfoSite(topLevelName); diff --git a/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicHandlerServer.java b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicHandlerServer.java index 777b9a6..069e905 100644 --- a/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicHandlerServer.java +++ b/src/main/java/github/openautonomousconnection/protocol/versions/v1_0_0/classic/ClassicHandlerServer.java @@ -1,11 +1,13 @@ package github.openautonomousconnection.protocol.versions.v1_0_0.classic; +import github.openautonomousconnection.protocol.side.server.ConnectedProtocolClient; import me.finn.unlegitlibrary.network.system.server.ConnectionHandler; import java.sql.SQLException; public abstract class ClassicHandlerServer { - public abstract void handleMessage(ConnectionHandler connectionHandler, String message, Classic_ProtocolVersion protocolVersion); + public abstract void handleMessage(ConnectedProtocolClient client, String message, Classic_ProtocolVersion protocolVersion); public abstract Classic_Domain getDomain(Classic_RequestDomain requestDomain) throws SQLException; public abstract Classic_Domain ping(Classic_RequestDomain requestDomain) throws SQLException; + public abstract void unsupportedClassicPacket(String className, Object[] content, ConnectedProtocolClient client); }