- Updated to new repo

2025-09-24 22:02:10 +02:00
parent 1556896a5a
commit d090b1067c
40 changed files with 201 additions and 195 deletions
--- a/src/main/java/org/openautonomousconnection/protocol/packets/OACPacket.java
+++ b/src/main/java/org/openautonomousconnection/protocol/packets/OACPacket.java
@@ -0,0 +1,54 @@
+package org.openautonomousconnection.protocol.packets;
+
+import org.openautonomousconnection.protocol.versions.ProtocolVersion;
+import org.openautonomousconnection.protocol.versions.v1_0_0.beta.DNSResponseCode;
+import lombok.Getter;
+import dev.unlegitdqrk.unlegitlibrary.network.system.packets.Packet;
+import dev.unlegitdqrk.unlegitlibrary.network.system.packets.PacketHandler;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+public abstract class OACPacket extends Packet {
+
+    @Getter
+    private final ProtocolVersion protocolVersion;
+
+    private DNSResponseCode responseCode = DNSResponseCode.RESPONSE_NOT_REQUIRED;
+
+    public OACPacket(int id, ProtocolVersion protocolVersion) {
+        super(id);
+        this.protocolVersion = protocolVersion;
+    }
+
+    protected final DNSResponseCode getResponseCode() {
+        return responseCode;
+    }
+
+    protected final void setResponseCode(DNSResponseCode responseCode) {
+        this.responseCode = responseCode;
+    }
+
+    @Override
+    public final void write(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException {
+        onWrite(packetHandler, objectOutputStream);
+        if (protocolVersion != ProtocolVersion.PV_1_0_0_CLASSIC) objectOutputStream.writeObject(responseCode);
+    }
+
+    @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();
+            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/org/openautonomousconnection/protocol/packets/v1_0_0/beta/AuthPacket.java
+++ b/src/main/java/org/openautonomousconnection/protocol/packets/v1_0_0/beta/AuthPacket.java
@@ -0,0 +1,133 @@
+package org.openautonomousconnection.protocol.packets.v1_0_0.beta;
+
+import org.openautonomousconnection.protocol.ProtocolBridge;
+import org.openautonomousconnection.protocol.packets.OACPacket;
+import org.openautonomousconnection.protocol.side.client.events.ConnectedToProtocolServer;
+import org.openautonomousconnection.protocol.side.server.ConnectedProtocolClient;
+import org.openautonomousconnection.protocol.side.server.events.ProtocolClientConnected;
+import org.openautonomousconnection.protocol.versions.ProtocolVersion;
+import org.openautonomousconnection.protocol.versions.v1_0_0.beta.DNSResponseCode;
+import dev.unlegitdqrk.unlegitlibrary.file.FileUtils;
+import dev.unlegitdqrk.unlegitlibrary.network.system.packets.PacketHandler;
+import dev.unlegitdqrk.unlegitlibrary.network.system.server.ConnectionHandler;
+import dev.unlegitdqrk.unlegitlibrary.network.utils.NetworkUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+public class AuthPacket extends OACPacket {
+
+    public AuthPacket() {
+        super(4, ProtocolVersion.PV_1_0_0_BETA);
+    }
+
+    File certificatesFolder = new File("certificates");
+
+    File publicFolder = new File(certificatesFolder, "public");
+    File privateFolder = new File(certificatesFolder, "private");
+
+    File privateCAFolder = new File(privateFolder, "ca");
+    File privateServerFolder = new File(privateFolder, "server");
+
+    File publicCAFolder = new File(publicFolder, "ca");
+    File publicServerFolder = new File(publicFolder, "server");
+
+    @Override
+    public void onWrite(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException {
+        if (ProtocolBridge.getInstance().isRunningAsServer()) {
+            objectOutputStream.writeObject(ProtocolBridge.getInstance().getProtocolVersion());
+
+            // Read ca files
+            String caKey = "N/A";
+            String caPem = "N/A";
+            String caSrl = "N/A";
+            try {
+                objectOutputStream.writeUTF(ProtocolBridge.getInstance().getProtocolServer().getFolderStructure().caPrefix + NetworkUtils.getPublicIPAddress());
+
+                caKey = FileUtils.readFileFull(new File(
+                        ProtocolBridge.getInstance().getProtocolServer().getFolderStructure().privateCAFolder,
+                        ProtocolBridge.getInstance().getProtocolServer().getFolderStructure().caPrefix + NetworkUtils.getPublicIPAddress() + ".key"));
+
+                caPem = FileUtils.readFileFull(new File(
+                        ProtocolBridge.getInstance().getProtocolServer().getFolderStructure().publicCAFolder,
+                        ProtocolBridge.getInstance().getProtocolServer().getFolderStructure().caPrefix + NetworkUtils.getPublicIPAddress() + ".pem"));
+
+                caSrl = FileUtils.readFileFull(new File(
+                        ProtocolBridge.getInstance().getProtocolServer().getFolderStructure().publicCAFolder,
+                        ProtocolBridge.getInstance().getProtocolServer().getFolderStructure().caPrefix + NetworkUtils.getPublicIPAddress() + ".srl"));
+            } catch (Exception exception) {
+                ProtocolBridge.getInstance().getLogger().exception("Failed to read ca-files", exception);
+                setResponseCode(DNSResponseCode.RESPONSE_AUTH_FAILED);
+            }
+
+            // Send ca data
+            objectOutputStream.writeUTF(caKey);
+            objectOutputStream.writeUTF(caPem);
+            objectOutputStream.writeUTF(caSrl);
+        } else {
+            objectOutputStream.writeInt(ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().getClientID());
+            objectOutputStream.writeObject(ProtocolBridge.getInstance().getProtocolVersion());
+        }
+    }
+
+    @Override
+    public void onRead(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        if (ProtocolBridge.getInstance().isRunningAsServer()) {
+            int clientID = objectInputStream.readInt();
+            ProtocolVersion clientVersion = (ProtocolVersion) objectInputStream.readObject();
+            ConnectionHandler connectionHandler = ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID);
+
+            if (!ProtocolBridge.getInstance().isVersionSupported(clientVersion)) {
+                setResponseCode(DNSResponseCode.RESPONSE_AUTH_FAILED);
+                connectionHandler.disconnect();
+                return;
+            } else setResponseCode(DNSResponseCode.RESPONSE_AUTH_SUCCESS);
+
+
+            ConnectedProtocolClient client = ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID);
+            client.setClientVersion(clientVersion);
+            ProtocolBridge.getInstance().getProtocolSettings().eventManager.executeEvent(new ProtocolClientConnected(client));
+        } else {
+            ProtocolVersion serverVersion = (ProtocolVersion) objectInputStream.readObject();
+
+            if (!ProtocolBridge.getInstance().isVersionSupported(serverVersion)) {
+                setResponseCode(DNSResponseCode.RESPONSE_AUTH_FAILED);
+                ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().disconnect();
+                return;
+            } else setResponseCode(DNSResponseCode.RESPONSE_AUTH_SUCCESS);
+
+            String caPrefix = objectInputStream.readUTF();
+
+            String caKey = objectInputStream.readUTF();
+            String caPem = objectInputStream.readUTF();
+            String caSrl = objectInputStream.readUTF();
+
+            if (caKey.equalsIgnoreCase("N/A") || caPem.equalsIgnoreCase("N/A") || caSrl.equalsIgnoreCase("N/A"))
+                setResponseCode(DNSResponseCode.RESPONSE_AUTH_FAILED);
+            else {
+
+                File caPemFile = new File(ProtocolBridge.getInstance().getProtocolClient().getFolderStructure().publicCAFolder, caPrefix + ".pem");
+                File caSrlFile = new File(ProtocolBridge.getInstance().getProtocolClient().getFolderStructure().publicCAFolder, caPrefix + ".srl");
+                File caKeyFile = new File(ProtocolBridge.getInstance().getProtocolClient().getFolderStructure().privateCAFolder, caPrefix + ".key");
+
+                try {
+                    if (!caPemFile.exists()) caPemFile.createNewFile();
+                    if (!caSrlFile.exists()) caSrlFile.createNewFile();
+                    if (!caKeyFile.exists()) caKeyFile.createNewFile();
+
+                    FileUtils.writeFile(caPemFile, caPem);
+                    FileUtils.writeFile(caSrlFile, caKey);
+                    FileUtils.writeFile(caKeyFile, caSrl);
+                } catch (Exception exception) {
+                    ProtocolBridge.getInstance().getLogger().exception("Failed to create/save ca-files", exception);
+                    setResponseCode(DNSResponseCode.RESPONSE_AUTH_FAILED);
+                }
+            }
+
+            ProtocolBridge.getInstance().getProtocolClient().setServerVersion(serverVersion);
+            ProtocolBridge.getInstance().getProtocolSettings().eventManager.executeEvent(new ConnectedToProtocolServer());
+        }
+    }
+}
--- a/src/main/java/org/openautonomousconnection/protocol/packets/v1_0_0/beta/GetDestinationPacket.java
+++ b/src/main/java/org/openautonomousconnection/protocol/packets/v1_0_0/beta/GetDestinationPacket.java
@@ -0,0 +1,75 @@
+package org.openautonomousconnection.protocol.packets.v1_0_0.beta;
+
+import org.openautonomousconnection.protocol.ProtocolBridge;
+import org.openautonomousconnection.protocol.packets.OACPacket;
+import org.openautonomousconnection.protocol.versions.ProtocolVersion;
+import org.openautonomousconnection.protocol.versions.v1_0_0.beta.DNSResponseCode;
+import org.openautonomousconnection.protocol.versions.v1_0_0.beta.Domain;
+import dev.unlegitdqrk.unlegitlibrary.network.system.packets.PacketHandler;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+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/org/openautonomousconnection/protocol/packets/v1_0_0/beta/UnsupportedClassicPacket.java
+++ b/src/main/java/org/openautonomousconnection/protocol/packets/v1_0_0/beta/UnsupportedClassicPacket.java
@@ -0,0 +1,53 @@
+package org.openautonomousconnection.protocol.packets.v1_0_0.beta;
+
+import org.openautonomousconnection.protocol.ProtocolBridge;
+import org.openautonomousconnection.protocol.packets.OACPacket;
+import org.openautonomousconnection.protocol.versions.ProtocolVersion;
+import org.openautonomousconnection.protocol.versions.v1_0_0.beta.DNSResponseCode;
+import dev.unlegitdqrk.unlegitlibrary.network.system.packets.PacketHandler;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+public class UnsupportedClassicPacket extends OACPacket {
+    private Class<? extends OACPacket> unsupportedClassicPacket;
+    private Object[] content;
+
+    public UnsupportedClassicPacket(Class<? extends OACPacket> unsupportedClassicPacket, Object[] content) {
+        this();
+        this.unsupportedClassicPacket = unsupportedClassicPacket;
+        this.content = content;
+    }
+
+    public UnsupportedClassicPacket() {
+        super(5, 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());
+        objectOutputStream.writeUTF(unsupportedClassicPacket.getName());
+        objectOutputStream.writeInt(content.length);
+        for (Object o : content) objectOutputStream.writeObject(o);
+        setResponseCode(DNSResponseCode.RESPONSE_NOT_REQUIRED);
+    }
+
+    @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];
+
+        for (int i = 0; i < size; i++) {
+            content[i] = objectInputStream.readObject();
+        }
+
+        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/org/openautonomousconnection/protocol/packets/v1_0_0/beta/ValidateDomainPacket.java
+++ b/src/main/java/org/openautonomousconnection/protocol/packets/v1_0_0/beta/ValidateDomainPacket.java
@@ -0,0 +1,57 @@
+package org.openautonomousconnection.protocol.packets.v1_0_0.beta;
+
+import org.openautonomousconnection.protocol.ProtocolBridge;
+import org.openautonomousconnection.protocol.packets.OACPacket;
+import org.openautonomousconnection.protocol.versions.ProtocolVersion;
+import org.openautonomousconnection.protocol.versions.v1_0_0.beta.Domain;
+import dev.unlegitdqrk.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/org/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_DomainPacket.java
+++ b/src/main/java/org/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_DomainPacket.java
@@ -0,0 +1,78 @@
+package org.openautonomousconnection.protocol.packets.v1_0_0.classic;
+
+import org.openautonomousconnection.protocol.ProtocolBridge;
+import org.openautonomousconnection.protocol.packets.OACPacket;
+import org.openautonomousconnection.protocol.packets.v1_0_0.beta.UnsupportedClassicPacket;
+import org.openautonomousconnection.protocol.versions.ProtocolVersion;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_Domain;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_DomainPacketReceivedEvent;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_ProtocolVersion;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_RequestDomain;
+import dev.unlegitdqrk.unlegitlibrary.network.system.packets.PacketHandler;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.sql.SQLException;
+
+public class Classic_DomainPacket extends OACPacket {
+    private Classic_RequestDomain requestDomain;
+    private Classic_Domain domain;
+    private int clientID;
+
+    public Classic_DomainPacket(int toClient, Classic_RequestDomain requestDomain, Classic_Domain domain) {
+        this();
+        this.clientID = toClient;
+
+        this.requestDomain = requestDomain;
+        this.domain = domain;
+    }
+
+    public Classic_DomainPacket() {
+        super(2, ProtocolVersion.PV_1_0_0_CLASSIC);
+    }
+
+    @Override
+    public void onWrite(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException {
+        if (ProtocolBridge.getInstance().isRunningAsServer()) {
+            objectOutputStream.writeInt(clientID);
+            objectOutputStream.writeObject(requestDomain);
+            objectOutputStream.writeObject(domain);
+        } else {
+            clientID = ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().getClientID();
+            objectOutputStream.writeInt(clientID);
+            objectOutputStream.writeObject(requestDomain);
+        }
+
+        objectOutputStream.writeObject(Classic_ProtocolVersion.PV_1_0_0);
+    }
+
+    @Override
+    public void onRead(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        if (ProtocolBridge.getInstance().isRunningAsServer()) {
+            clientID = objectInputStream.readInt();
+            requestDomain = (Classic_RequestDomain) objectInputStream.readObject();
+            Classic_ProtocolVersion protocolVersion = (Classic_ProtocolVersion) objectInputStream.readObject();
+
+            try {
+                domain = ProtocolBridge.getInstance().getClassicHandlerServer().getDomain(requestDomain);
+            } catch (SQLException exception) {
+                exception.printStackTrace();
+            }
+
+            ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getEventManager().executeEvent(new Classic_DomainPacketReceivedEvent(protocolVersion, domain, requestDomain, clientID));
+
+            if (ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID).clientSupportClassic())
+                ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID).sendPacket(new Classic_DomainPacket(clientID, requestDomain, domain));
+            else
+                ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID).sendPacket(new UnsupportedClassicPacket(Classic_PingPacket.class, new Object[]{clientID, requestDomain, domain}));
+        } else {
+            clientID = objectInputStream.readInt();
+            requestDomain = (Classic_RequestDomain) objectInputStream.readObject();
+            domain = (Classic_Domain) objectInputStream.readObject();
+            Classic_ProtocolVersion protocolVersion = (Classic_ProtocolVersion) objectInputStream.readObject();
+
+            ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().getEventManager().executeEvent(new Classic_DomainPacketReceivedEvent(protocolVersion, domain, requestDomain, clientID));
+        }
+    }
+}
--- a/src/main/java/org/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_MessagePacket.java
+++ b/src/main/java/org/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_MessagePacket.java
@@ -0,0 +1,55 @@
+package org.openautonomousconnection.protocol.packets.v1_0_0.classic;
+
+import org.openautonomousconnection.protocol.ProtocolBridge;
+import org.openautonomousconnection.protocol.packets.OACPacket;
+import org.openautonomousconnection.protocol.versions.ProtocolVersion;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_ProtocolVersion;
+import dev.unlegitdqrk.unlegitlibrary.network.system.packets.PacketHandler;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+public class Classic_MessagePacket extends OACPacket {
+    private String message;
+    private int clientID;
+
+    public Classic_MessagePacket(String message, int toClient) {
+        this();
+        this.message = message;
+        this.clientID = toClient;
+    }
+
+    public Classic_MessagePacket() {
+        super(3, ProtocolVersion.PV_1_0_0_CLASSIC);
+    }
+
+    @Override
+    public void onWrite(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException {
+        if (ProtocolBridge.getInstance().isRunningAsServer()) objectOutputStream.writeInt(clientID);
+        else {
+            clientID = ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().getClientID();
+            objectOutputStream.writeInt(clientID);
+        }
+
+        objectOutputStream.writeUTF(message);
+        objectOutputStream.writeObject(Classic_ProtocolVersion.PV_1_0_0);
+    }
+
+    @Override
+    public void onRead(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        if (ProtocolBridge.getInstance().isRunningAsServer()) {
+            clientID = objectInputStream.readInt();
+            String message = objectInputStream.readUTF();
+            Classic_ProtocolVersion protocolVersion = (Classic_ProtocolVersion) objectInputStream.readObject();
+
+            ProtocolBridge.getInstance().getClassicHandlerServer().handleMessage(ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID), message, protocolVersion);
+        } else {
+            clientID = objectInputStream.readInt();
+            String message = objectInputStream.readUTF();
+            Classic_ProtocolVersion protocolVersion = (Classic_ProtocolVersion) objectInputStream.readObject();
+
+            ProtocolBridge.getInstance().getClassicHandlerClient().handleMessage(message);
+        }
+    }
+}
--- a/src/main/java/org/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_PingPacket.java
+++ b/src/main/java/org/openautonomousconnection/protocol/packets/v1_0_0/classic/Classic_PingPacket.java
@@ -0,0 +1,83 @@
+package org.openautonomousconnection.protocol.packets.v1_0_0.classic;
+
+import org.openautonomousconnection.protocol.ProtocolBridge;
+import org.openautonomousconnection.protocol.packets.OACPacket;
+import org.openautonomousconnection.protocol.packets.v1_0_0.beta.UnsupportedClassicPacket;
+import org.openautonomousconnection.protocol.versions.ProtocolVersion;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_Domain;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_PingPacketReceivedEvent;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_ProtocolVersion;
+import org.openautonomousconnection.protocol.versions.v1_0_0.classic.Classic_RequestDomain;
+import dev.unlegitdqrk.unlegitlibrary.network.system.packets.PacketHandler;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.sql.SQLException;
+
+public class Classic_PingPacket extends OACPacket {
+    private Classic_RequestDomain requestDomain;
+    private Classic_Domain domain;
+    private int clientID;
+    private boolean reachable;
+    private Classic_ProtocolVersion protocolVersion;
+
+    public Classic_PingPacket(Classic_RequestDomain requestDomain, Classic_Domain domain, boolean reachable) {
+        this();
+
+        this.requestDomain = requestDomain;
+        this.domain = domain;
+        this.reachable = reachable;
+        this.protocolVersion = Classic_ProtocolVersion.PV_1_0_0;
+    }
+
+    public Classic_PingPacket() {
+        super(1, ProtocolVersion.PV_1_0_0_CLASSIC);
+    }
+
+    @Override
+    public void onWrite(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException {
+        if (ProtocolBridge.getInstance().isRunningAsServer()) {
+            objectOutputStream.writeInt(clientID);
+            objectOutputStream.writeObject(requestDomain);
+            objectOutputStream.writeObject(domain);
+            objectOutputStream.writeBoolean(reachable);
+        } else {
+            clientID = ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().getClientID();
+            objectOutputStream.writeInt(clientID);
+            objectOutputStream.writeObject(requestDomain);
+        }
+
+        objectOutputStream.writeObject(protocolVersion);
+    }
+
+    @Override
+    public void onRead(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {
+        if (ProtocolBridge.getInstance().isRunningAsServer()) {
+            clientID = objectInputStream.readInt();
+            requestDomain = (Classic_RequestDomain) objectInputStream.readObject();
+            protocolVersion = (Classic_ProtocolVersion) objectInputStream.readObject();
+
+            try {
+                domain = ProtocolBridge.getInstance().getClassicHandlerServer().ping(requestDomain);
+            } catch (SQLException exception) {
+                exception.printStackTrace();
+            }
+
+            reachable = domain != null;
+            ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getEventManager().executeEvent(new Classic_PingPacketReceivedEvent(protocolVersion, domain, requestDomain, reachable, clientID));
+            if (ProtocolBridge.getInstance().getProtocolServer().getClientByID(clientID).clientSupportClassic())
+                ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID).sendPacket(new Classic_PingPacket(requestDomain, domain, reachable));
+            else
+                ProtocolBridge.getInstance().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID).sendPacket(new UnsupportedClassicPacket(Classic_PingPacket.class, new Object[]{requestDomain, domain, reachable}));
+        } else {
+            clientID = objectInputStream.readInt();
+            requestDomain = (Classic_RequestDomain) objectInputStream.readObject();
+            domain = (Classic_Domain) objectInputStream.readObject();
+            boolean reachable = objectInputStream.readBoolean();
+            Classic_ProtocolVersion protocolVersion = (Classic_ProtocolVersion) objectInputStream.readObject();
+
+            ProtocolBridge.getInstance().getProtocolClient().getNetworkClient().getEventManager().executeEvent(new Classic_PingPacketReceivedEvent(protocolVersion, domain, requestDomain, reachable, clientID));
+        }
+    }
+}