- Finished with Domain resolving

2025-09-20 20:41:08 +02:00
parent f574271d61
commit b79eba247d
11 changed files with 211 additions and 34 deletions
--- 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());
    }
--- 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) {}
 }
--- 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
@@ -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);
+            }
+        }
+    }
+}
--- 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);
    }
 }
--- 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
@@ -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());
+    }
+}
--- 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();
--- 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);
 }
--- 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);
 }
--- 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
--- 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);
--- 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);
 }