From bf467bec89690d2cc7cb020356dfa7ce9d900ef0 Mon Sep 17 00:00:00 2001 From: Finn Date: Fri, 19 Sep 2025 21:27:35 +0200 Subject: [PATCH] Initial commit --- .gitignore | 38 ++++++++ .idea/.gitignore | 3 + .idea/copilot.data.migration.agent.xml | 6 ++ .idea/copilot.data.migration.edit.xml | 6 ++ .idea/discord.xml | 7 ++ .idea/encodings.xml | 7 ++ .idea/misc.xml | 14 +++ .idea/vcs.xml | 6 ++ pom.xml | 48 ++++++++++ .../protocol/ProtocolBridge.java | 93 +++++++++++++++++++ .../protocol/ProtocolSettings.java | 14 +++ .../protocol/ProtocolVersion.java | 70 ++++++++++++++ .../protocol/classic/ClassicConverter.java | 4 + .../protocol/classic/Classic_Domain.java | 77 +++++++++++++++ .../protocol/classic/Classic_DomainUtils.java | 66 +++++++++++++ .../protocol/classic/Classic_LocalDomain.java | 7 ++ .../classic/Classic_ProtocolVersion.java | 13 +++ .../classic/Classic_RequestDomain.java | 10 ++ .../protocol/classic/Classic_SiteType.java | 15 +++ .../protocol/handle/ClassicHandler.java | 9 ++ .../protocol/packets/OACPacket.java | 19 ++++ .../packets/v1_0_0/classic/DomainPacket.java | 42 +++++++++ .../packets/v1_0_0/classic/MessagePacket.java | 42 +++++++++ .../packets/v1_0_0/classic/PingPacket.java | 4 + .../protocol/side/ProtocolClient.java | 4 + .../protocol/side/ProtocolServer.java | 24 +++++ 26 files changed, 648 insertions(+) create mode 100644 .gitignore create mode 100644 .idea/.gitignore create mode 100644 .idea/copilot.data.migration.agent.xml create mode 100644 .idea/copilot.data.migration.edit.xml create mode 100644 .idea/discord.xml create mode 100644 .idea/encodings.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/vcs.xml create mode 100644 pom.xml create mode 100644 src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/ProtocolSettings.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/ProtocolVersion.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/classic/ClassicConverter.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/classic/Classic_Domain.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/classic/Classic_DomainUtils.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/classic/Classic_LocalDomain.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/classic/Classic_ProtocolVersion.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/classic/Classic_RequestDomain.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/classic/Classic_SiteType.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/handle/ClassicHandler.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/DomainPacket.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/MessagePacket.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/PingPacket.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/side/ProtocolClient.java create mode 100644 src/main/java/github/openautonomousconnection/protocol/side/ProtocolServer.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5ff6309 --- /dev/null +++ b/.gitignore @@ -0,0 +1,38 @@ +target/ +!.mvn/wrapper/maven-wrapper.jar +!**/src/main/**/target/ +!**/src/test/**/target/ + +### IntelliJ IDEA ### +.idea/modules.xml +.idea/jarRepositories.xml +.idea/compiler.xml +.idea/libraries/ +*.iws +*.iml +*.ipr + +### Eclipse ### +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache + +### NetBeans ### +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ +build/ +!**/src/main/**/build/ +!**/src/test/**/build/ + +### VS Code ### +.vscode/ + +### Mac OS ### +.DS_Store \ No newline at end of file diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/copilot.data.migration.agent.xml b/.idea/copilot.data.migration.agent.xml new file mode 100644 index 0000000..4ea72a9 --- /dev/null +++ b/.idea/copilot.data.migration.agent.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/copilot.data.migration.edit.xml b/.idea/copilot.data.migration.edit.xml new file mode 100644 index 0000000..8648f94 --- /dev/null +++ b/.idea/copilot.data.migration.edit.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/discord.xml b/.idea/discord.xml new file mode 100644 index 0000000..d8e9561 --- /dev/null +++ b/.idea/discord.xml @@ -0,0 +1,7 @@ + + + + + \ No newline at end of file diff --git a/.idea/encodings.xml b/.idea/encodings.xml new file mode 100644 index 0000000..aa00ffa --- /dev/null +++ b/.idea/encodings.xml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..001e756 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,14 @@ + + + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..1accb05 --- /dev/null +++ b/pom.xml @@ -0,0 +1,48 @@ + + + 4.0.0 + + github.openautonomousconnection + protocol + 1.0-SNAPSHOT + + + 23 + 23 + UTF-8 + + + + + github + https://maven.pkg.github.com/unlegitdqrk/unlegitlibrary + + true + + + + + + + github + Protocol + https://maven.pkg.github.com/open-autonomous-connection/protocol + + + + + + me.finn.unlegitlibrary + unlegitlibrary + 1.5.13 + + + org.projectlombok + lombok + 1.18.38 + provided + + + \ No newline at end of file diff --git a/src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java b/src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java new file mode 100644 index 0000000..81864cb --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/ProtocolBridge.java @@ -0,0 +1,93 @@ +package github.openautonomousconnection.protocol; + +import github.openautonomousconnection.protocol.handle.ClassicHandler; +import github.openautonomousconnection.protocol.side.ProtocolClient; +import github.openautonomousconnection.protocol.side.ProtocolServer; +import lombok.Getter; +import lombok.Setter; +import me.finn.unlegitlibrary.utils.Logger; + +import java.io.File; +import java.io.IOException; + +public class ProtocolBridge { + + @Getter + private final ProtocolSettings protocolSettings; + + @Getter + private final ProtocolVersion protocolVersion; + + @Getter + private ProtocolServer protocolServer; + + @Getter + private ProtocolClient protocolClient; + + @Getter + private final Logger logger; + + @Getter @Setter + private ClassicHandler classicHandler; + + public ProtocolBridge(ProtocolServer protocolServer, ProtocolSettings protocolSettings, ProtocolVersion protocolVersion, File logFolder) { + this.protocolServer = protocolServer; + this.protocolSettings = protocolSettings; + this.protocolVersion = protocolVersion; + + Logger tmpLogger = null; + try { + tmpLogger = new Logger(logFolder, false, true); + } catch (IOException | NoSuchFieldException | IllegalAccessException exception) { + exception.printStackTrace(); + tmpLogger = null; + System.exit(1); + } + + this.logger = tmpLogger; + + if (!validateProtocolVersion()) { + this.logger.error("Invalid protocol version '" + protocolVersion.toString() + "'!"); + System.exit(1); + } + } + + public ProtocolBridge(ProtocolClient protocolClient, ProtocolSettings protocolSettings, ProtocolVersion protocolVersion, File logFolder) { + this.protocolClient = protocolClient; + this.protocolSettings = protocolSettings; + this.protocolVersion = protocolVersion; + + Logger tmpLogger = null; + try { + tmpLogger = new Logger(logFolder, false, true); + } catch (IOException | NoSuchFieldException | IllegalAccessException exception) { + exception.printStackTrace(); + tmpLogger = null; + System.exit(1); + } + + this.logger = tmpLogger; + + if (!validateProtocolVersion()) { + this.logger.error("Invalid protocol version '" + protocolVersion.toString() + "'!"); + System.exit(1); + } + } + + public boolean isRunningAsServer() { + return protocolServer != null; + } + + public boolean isRunningAsClient() { + return protocolClient != null; + } + + private boolean validateProtocolVersion() { + return (isRunningAsServer() && protocolVersion.getProtocolSide() != ProtocolVersion.ProtocolSide.CLIENT) || + (isRunningAsClient() && protocolVersion.getProtocolSide() != ProtocolVersion.ProtocolSide.SERVER); + } + + public boolean validateProtocolVersion(ProtocolVersion targetVersion) { + return protocolVersion == targetVersion || protocolVersion.getCompatibleVersions().contains(targetVersion); + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/ProtocolSettings.java b/src/main/java/github/openautonomousconnection/protocol/ProtocolSettings.java new file mode 100644 index 0000000..2c56aaf --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/ProtocolSettings.java @@ -0,0 +1,14 @@ +package github.openautonomousconnection.protocol; + +import me.finn.unlegitlibrary.event.EventManager; +import me.finn.unlegitlibrary.network.system.packets.PacketHandler; +import me.finn.unlegitlibrary.utils.DefaultMethodsOverrider; + +public class ProtocolSettings extends DefaultMethodsOverrider { + + public String host; + public int port; + public PacketHandler packetHandler; + public EventManager eventManager; + +} diff --git a/src/main/java/github/openautonomousconnection/protocol/ProtocolVersion.java b/src/main/java/github/openautonomousconnection/protocol/ProtocolVersion.java new file mode 100644 index 0000000..35969ed --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/ProtocolVersion.java @@ -0,0 +1,70 @@ +package github.openautonomousconnection.protocol; + +import lombok.Getter; + +import java.io.Serializable; +import java.util.Arrays; +import java.util.List; + +public enum ProtocolVersion implements Serializable { + PV_1_0_0_CLASSIC("1.0.0", ProtocolType.CLASSIC, ProtocolSide.SERVER), + PV_1_0_0_BETA("1.0.0", ProtocolType.BETA, ProtocolSide.BOTH, PV_1_0_0_CLASSIC) + ; + + @Getter + private final String version; + @Getter + private final ProtocolType protocolType; + @Getter + private final ProtocolSide protocolSide; + @Getter + private final List compatibleVersions; + + ProtocolVersion(String version, ProtocolType protocolType, ProtocolSide protocolSide, ProtocolVersion... compatibleVersions) { + this.version = version; + this.protocolType = protocolType; + this.protocolSide = protocolSide; + this.compatibleVersions = Arrays.stream(compatibleVersions).toList(); + if (!this.compatibleVersions.contains(this)) this.compatibleVersions.add(this); + } + + @Override + public final String toString() { + StringBuilder compatible = new StringBuilder("["); + for (ProtocolVersion compatibleVersion : compatibleVersions) compatible.append(compatibleVersion.buildName()); + compatible.append("]"); + + return "{version=" + version + ";type=" + protocolType.toString() + ";side=" + protocolSide.toString() + ";compatible=" + compatible.toString() + "}"; + } + + public final String buildName() { + return version + "-" + protocolType.toString(); + } + + public enum ProtocolType { + CLASSIC, // -> See "_old" Projects on GitHub Organisation https://github.com/Open-Autonomous-Connection/ + BETA, + ALPHA, + STABLE + + ; + + @Override + public final String toString() { + return name().toUpperCase(); + } + } + + public enum ProtocolSide { + CLIENT, // Protocol version can only used on Client + SERVER, // Protocol version can only used on Server + BOTH // Protocol version can only used on Server and Client + + ; + + @Override + public final String toString() { + return name().toUpperCase(); + } + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/ClassicConverter.java b/src/main/java/github/openautonomousconnection/protocol/classic/ClassicConverter.java new file mode 100644 index 0000000..9ceb4c5 --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/classic/ClassicConverter.java @@ -0,0 +1,4 @@ +package github.openautonomousconnection.protocol.classic; + +public class ClassicConverter { +} diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_Domain.java b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_Domain.java new file mode 100644 index 0000000..55eb160 --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_Domain.java @@ -0,0 +1,77 @@ +package github.openautonomousconnection.protocol.classic; + +import me.finn.unlegitlibrary.string.StringUtils; + +import java.io.Serializable; + +public class Classic_Domain implements Serializable { + public final String name; + public final String topLevelDomain; + private final String destination; + private final String path; + + public Classic_Domain(String name, String topLevelDomain, String destination, String path) { + if (path == null) path = ""; + + this.name = name; + this.topLevelDomain = topLevelDomain; + this.destination = destination; + this.path = path; + } + + public final String realDestination() { + String tmpDestination = destination.endsWith("/") ? destination : destination + "/"; + String tmpPath = getPath(); + + if (tmpPath == null) tmpPath = ""; + if (tmpPath.startsWith("/")) tmpPath = tmpPath.substring("/".length()); + if (tmpPath.endsWith("/")) tmpPath = tmpPath.substring(0, tmpPath.length() - "/".length()); + + return tmpDestination + tmpPath; + } + + public final String getPath() { + if (path.endsWith("/")) return path.substring(0, path.length() - "/".length()); + if (path.startsWith("/")) return path.substring("/".length()); + return path; + } + + public final String parsedDestination() { + if (destination.toLowerCase().startsWith("https://github.com/")) { + String base = "https://raw.githubusercontent.com/"; + String username = Classic_DomainUtils.getPath(destination).split("/")[0]; + String site = Classic_DomainUtils.getPath(destination).split("/")[1]; + + String tmpPath = getPath(); + if (tmpPath == null || StringUtils.isEmptyString(tmpPath)) tmpPath = "index.html"; + if (tmpPath.startsWith("/")) tmpPath = tmpPath.substring("/".length()); + if (tmpPath.endsWith("/")) tmpPath = tmpPath.substring(0, tmpPath.length() - "/".length()); + + base = base + username + "/" + site + "/main/" + tmpPath; + return base; + } + + return realDestination(); + } + + @Override + protected final Object clone() throws CloneNotSupportedException { + return new Classic_Domain(name, topLevelDomain, destination, path); + } + + @Override + public final boolean equals(Object obj) { + if (!(obj instanceof Classic_Domain other)) return false; + return other.name.equalsIgnoreCase(name) && other.topLevelDomain.equalsIgnoreCase(topLevelDomain); + } + + @Override + public final String toString() { + return "{parsed='" + parsedDestination() + "';real='" + realDestination() + "'}"; + } + + @Override + public final int hashCode() { + return super.hashCode(); + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_DomainUtils.java b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_DomainUtils.java new file mode 100644 index 0000000..209e4fc --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_DomainUtils.java @@ -0,0 +1,66 @@ +package github.openautonomousconnection.protocol.classic; + +import me.finn.unlegitlibrary.utils.DefaultMethodsOverrider; + +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URISyntaxException; +import java.net.URL; + +class Classic_DomainUtils extends DefaultMethodsOverrider { + + public static String getTopLevelDomain(String url) throws MalformedURLException { + URL uri = null; + String tldString = null; + + if (url.startsWith(Classic_SiteType.PUBLIC.name + "://")) url = url.substring((Classic_SiteType.PUBLIC.name + "://").length()); + if (url.startsWith(Classic_SiteType.CLIENT.name + "://")) url = url.substring((Classic_SiteType.CLIENT.name + "://").length()); + if (url.startsWith(Classic_SiteType.SERVER.name + "://")) url = url.substring((Classic_SiteType.SERVER.name + "://").length()); + if (url.startsWith(Classic_SiteType.PROTOCOL.name + "://")) url = url.substring((Classic_SiteType.PROTOCOL.name + "://").length()); + if (url.startsWith(Classic_SiteType.LOCAL.name + "://")) url = url.substring((Classic_SiteType.LOCAL.name + "://").length()); + + if (!url.startsWith("https://") && !url.startsWith("http://")) url = "https://" + url; + + uri = new URL(url); + String[] domainNameParts = uri.getHost().split("\\."); + tldString = domainNameParts[domainNameParts.length - 1]; + + return tldString; + } + + public static String getDomainName(String url) throws URISyntaxException, MalformedURLException { + if (url.startsWith(Classic_SiteType.PUBLIC.name + "://")) url = url.substring((Classic_SiteType.PUBLIC.name + "://").length()); + if (url.startsWith(Classic_SiteType.CLIENT.name + "://")) url = url.substring((Classic_SiteType.CLIENT.name + "://").length()); + if (url.startsWith(Classic_SiteType.SERVER.name + "://")) url = url.substring((Classic_SiteType.SERVER.name + "://").length()); + if (url.startsWith(Classic_SiteType.PROTOCOL.name + "://")) url = url.substring((Classic_SiteType.PROTOCOL.name + "://").length()); + if (url.startsWith(Classic_SiteType.LOCAL.name + "://")) url = url.substring((Classic_SiteType.LOCAL.name + "://").length()); + + if (!url.startsWith("https://") && !url.startsWith("http://")) url = "https://" + url; + + URI uri = new URI(url); + String domain = uri.getHost().replace("." + getTopLevelDomain(url), ""); + return domain; + } + + + public static String getPath(String url) { + if (!url.startsWith(Classic_SiteType.PUBLIC.name + "://") && !url.startsWith(Classic_SiteType.CLIENT.name + "://") && + !url.startsWith(Classic_SiteType.SERVER.name + "://") && !url.startsWith(Classic_SiteType.PROTOCOL.name + "://") && + !url.startsWith(Classic_SiteType.LOCAL.name + "://") && !url.startsWith("http") && !url.startsWith("https")) { + url = Classic_SiteType.PUBLIC.name + "://" + url; + } + + String[] split = url.split("/"); + if (split.length <= 3) return ""; + + StringBuilder path = new StringBuilder(); + + for (int i = 3; i < split.length; i++) path.append(split[i]).append("/"); + + String pathStr = path.toString(); + if (pathStr.startsWith("/")) pathStr = pathStr.substring("/".length()); + if (pathStr.endsWith("/")) pathStr = pathStr.substring(0, pathStr.length() - "/".length()); + + return pathStr; + } +} \ No newline at end of file diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_LocalDomain.java b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_LocalDomain.java new file mode 100644 index 0000000..9d635d1 --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_LocalDomain.java @@ -0,0 +1,7 @@ +package github.openautonomousconnection.protocol.classic; + +public class Classic_LocalDomain extends Classic_Domain { + public Classic_LocalDomain(String name, String endName, String path) { + super(name, endName, null, path); + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_ProtocolVersion.java b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_ProtocolVersion.java new file mode 100644 index 0000000..82b491f --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_ProtocolVersion.java @@ -0,0 +1,13 @@ +package github.openautonomousconnection.protocol.classic; + +import java.io.Serializable; + +public enum Classic_ProtocolVersion implements Serializable { + PV_1_0_0("1.0.0"); + ; + public final String version; + + Classic_ProtocolVersion(String version) { + this.version = version; + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_RequestDomain.java b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_RequestDomain.java new file mode 100644 index 0000000..3b68223 --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_RequestDomain.java @@ -0,0 +1,10 @@ +package github.openautonomousconnection.protocol.classic; + +import java.io.Serializable; + +public class Classic_RequestDomain extends Classic_Domain implements Serializable { + + public Classic_RequestDomain(String name, String topLevelDomain, String path) { + super(name, topLevelDomain, null, path); + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/classic/Classic_SiteType.java b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_SiteType.java new file mode 100644 index 0000000..7cd9fcc --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/classic/Classic_SiteType.java @@ -0,0 +1,15 @@ +package github.openautonomousconnection.protocol.classic; + +import java.io.Serializable; + +enum Classic_SiteType implements Serializable { + CLIENT("oac-client"), SERVER("oac-server"), + PUBLIC("oac"), PROTOCOL("oac-protocol"), LOCAL("oac-local"); + ; + + public final String name; + + Classic_SiteType(String name) { + this.name = name; + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/handle/ClassicHandler.java b/src/main/java/github/openautonomousconnection/protocol/handle/ClassicHandler.java new file mode 100644 index 0000000..fb3c824 --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/handle/ClassicHandler.java @@ -0,0 +1,9 @@ +package github.openautonomousconnection.protocol.handle; + +import me.finn.unlegitlibrary.network.system.server.ConnectionHandler; + +public abstract class ClassicHandler { + + public abstract void handleMessage(ConnectionHandler connectionHandler, String message); + +} diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java new file mode 100644 index 0000000..ac3a33a --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/packets/OACPacket.java @@ -0,0 +1,19 @@ +package github.openautonomousconnection.protocol.packets; + +import github.openautonomousconnection.protocol.ProtocolBridge; +import github.openautonomousconnection.protocol.ProtocolVersion; +import lombok.Getter; +import me.finn.unlegitlibrary.network.system.packets.Packet; + +public abstract class OACPacket extends Packet { + @Getter + private final ProtocolVersion.ProtocolType packetType; + @Getter + private final ProtocolBridge protocolBridge; + + public OACPacket(int id, ProtocolVersion.ProtocolType packetType, ProtocolBridge protocolBridge) { + super(id); + this.packetType = packetType; + this.protocolBridge = protocolBridge; + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/DomainPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/DomainPacket.java new file mode 100644 index 0000000..fac7aae --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/DomainPacket.java @@ -0,0 +1,42 @@ +package github.openautonomousconnection.protocol.packets.v1_0_0.classic; + +import github.openautonomousconnection.protocol.ProtocolBridge; +import github.openautonomousconnection.protocol.ProtocolVersion; +import github.openautonomousconnection.protocol.classic.Classic_Domain; +import github.openautonomousconnection.protocol.classic.Classic_ProtocolVersion; +import github.openautonomousconnection.protocol.classic.Classic_RequestDomain; +import github.openautonomousconnection.protocol.packets.OACPacket; +import me.finn.unlegitlibrary.network.system.packets.Packet; +import me.finn.unlegitlibrary.network.system.packets.PacketHandler; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; + +// ProtocolVersion 1.0.0-CLASSIC is ProtocolSide Server only +public class DomainPacket extends OACPacket { + private final Classic_RequestDomain requestDomain; + private final Classic_Domain domain; + private final int clientID; + + public DomainPacket(ProtocolBridge protocolBridge, int toClient, Classic_RequestDomain requestDomain, Classic_Domain domain) { + super(2, ProtocolVersion.ProtocolType.CLASSIC, protocolBridge); + this.clientID = toClient; + this.requestDomain = requestDomain; + this.domain = domain; + } + + @Override + public void write(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException { + objectOutputStream.writeInt(clientID); + objectOutputStream.writeObject(requestDomain); + objectOutputStream.writeObject(domain); + + objectOutputStream.writeObject(Classic_ProtocolVersion.PV_1_0_0); + } + + @Override + public void read(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException { + + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/MessagePacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/MessagePacket.java new file mode 100644 index 0000000..63e62a7 --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/MessagePacket.java @@ -0,0 +1,42 @@ +package github.openautonomousconnection.protocol.packets.v1_0_0.classic; + +import github.openautonomousconnection.protocol.ProtocolBridge; +import github.openautonomousconnection.protocol.ProtocolVersion; +import github.openautonomousconnection.protocol.classic.Classic_ProtocolVersion; +import github.openautonomousconnection.protocol.packets.OACPacket; +import github.openautonomousconnection.protocol.side.ProtocolClient; +import me.finn.unlegitlibrary.network.system.packets.PacketHandler; + +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; + +// ProtocolVersion 1.0.0-CLASSIC is ProtocolSide Server only +public class MessagePacket extends OACPacket { + private final String message; + private Classic_ProtocolVersion protocolVersion; + private final int clientID; + + public MessagePacket(String message, int toClient, ProtocolBridge protocolBridge) { + super(3, ProtocolVersion.ProtocolType.CLASSIC, protocolBridge); + this.message = message; + this.clientID = toClient; + } + + @Override + public void write(PacketHandler packetHandler, ObjectOutputStream objectOutputStream) throws IOException, ClassNotFoundException { + objectOutputStream.writeInt(clientID); + + objectOutputStream.writeUTF(message); + objectOutputStream.writeObject(Classic_ProtocolVersion.PV_1_0_0); + } + + @Override + public void read(PacketHandler packetHandler, ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException { + int clientID = objectInputStream.readInt(); + String message = objectInputStream.readUTF(); + protocolVersion = (Classic_ProtocolVersion) objectInputStream.readObject(); + + getProtocolBridge().getClassicHandler().handleMessage(getProtocolBridge().getProtocolServer().getNetworkServer().getConnectionHandlerByID(clientID), message); + } +} diff --git a/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/PingPacket.java b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/PingPacket.java new file mode 100644 index 0000000..22e5df8 --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/packets/v1_0_0/classic/PingPacket.java @@ -0,0 +1,4 @@ +package github.openautonomousconnection.protocol.packets.v1_0_0.classic; + +public class PingPacket { +} diff --git a/src/main/java/github/openautonomousconnection/protocol/side/ProtocolClient.java b/src/main/java/github/openautonomousconnection/protocol/side/ProtocolClient.java new file mode 100644 index 0000000..09ff1e1 --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/side/ProtocolClient.java @@ -0,0 +1,4 @@ +package github.openautonomousconnection.protocol.side; + +public class ProtocolClient { +} diff --git a/src/main/java/github/openautonomousconnection/protocol/side/ProtocolServer.java b/src/main/java/github/openautonomousconnection/protocol/side/ProtocolServer.java new file mode 100644 index 0000000..709b84d --- /dev/null +++ b/src/main/java/github/openautonomousconnection/protocol/side/ProtocolServer.java @@ -0,0 +1,24 @@ +package github.openautonomousconnection.protocol.side; + +import github.openautonomousconnection.protocol.ProtocolBridge; +import github.openautonomousconnection.protocol.handle.ClassicHandler; +import lombok.Getter; +import me.finn.unlegitlibrary.network.system.server.NetworkServer; + +public abstract class ProtocolServer { + @Getter + private final ProtocolBridge protocolBridge; + + @Getter + private NetworkServer networkServer; + + public ProtocolServer(ProtocolBridge protocolBridge) { + this.protocolBridge = protocolBridge; + + this.networkServer = new NetworkServer.ServerBuilder(). + setEventManager(protocolBridge.getProtocolSettings().eventManager). + setPacketHandler(protocolBridge.getProtocolSettings().packetHandler). + setPort(protocolBridge.getProtocolSettings().port). + build(); + } +}