AddressParser-related changes and fixes

README.md

@@ -127,9 +127,22 @@ registry synchronization (fabric-registry-sync mod).
 
 ### How can I set the version for specific servers?:
 
-- Append ._v(VERSION).viafabric.
-- Examples: ``minigame.example.com._v1_8.viafabric``, ``native.example.com._v-1.viafabric``
- , ``auto.example.com._v-2.viafabric``
+#### Suffix Style
+
+- Append ``._v(VERSION).viafabric`` after the host, before any port.
+ - All dots (``.``) in a given version must be replaced with underscores (``_``).
+- Examples:
+ - ``minigame.example.com._v1_8.viafabric``
+ - ``native.example.com._v-1.viafabric``
+ - ``auto.example.com._v-2.viafabric``
+
+#### Prefix Style
+
+- Add ``viafabric.v(VERSION);`` before the address.
+- Examples:
+ - ``viafabric.v1.8;minigame.example.com``
+ - ``viafabric.v-1;native.example.com``
+ - ``viafabric.v-2;auto.example.com``
 
 ## ViaFabricPlus
 

build.gradle

@@ -142,6 +142,8 @@ dependencies {
 
  includeJ8("com.viaversion:viaversion:${rootProject.viaver_version}")
  include("com.github.TinfoilMC:ClientCommands:1.1.0")
+
+ testImplementation("org.testng:testng:6.13.1")
 }
 
 remapJar {
@@ -169,6 +171,11 @@ processResources {
  }
 }
 
+test {
+ // Minimal insurance to make sure we get expected results.
+ useTestNG()
+}
+
 List<String> mcReleases = Arrays.stream(rootProject.publish_mc_versions.toString().split(","))
  .map({ it -> it.trim() })
  .collect(Collectors.toList())

src/main/java/com/viaversion/fabric/common/AddressParser.java

@@ -20,85 +20,286 @@
 import com.google.common.collect.Lists;
 import com.google.common.primitives.Ints;
 import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
+import com.viaversion.viaversion.libs.fastutil.ints.IntArrayList;
+import com.viaversion.viaversion.libs.fastutil.ints.IntImmutableList;
+import com.viaversion.viaversion.libs.fastutil.ints.IntList;
 import org.apache.commons.lang3.StringUtils;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.VisibleForTesting;
 
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 // Based on VIAaaS parser
 public class AddressParser {
- public Integer protocol;
- public String viaSuffix;
- public String serverAddress;
- public String viaOptions;
+ private static final String VIA = "viafabric";
+ private static final Pattern DOT_SUFFIX = Pattern.compile("\\.$");
 
- public AddressParser parse(String address) {
- return parse(address, "viafabric");
+ // Retaining a list for now; not exposing it to the end consumer.
+ // An idea tossed about is to retry the server for the given protocols.
+ @Nullable
+ @VisibleForTesting
+ final IntList protocols;
+ @NotNull
+ private final String serverAddress;
+ @Nullable
+ private final Integer port;
+
+ private AddressParser(@NotNull String address, @Nullable Integer port) {
+ this(address, null, port);
  }
 
- public String getSuffixWithOptions() {
- if (viaOptions != null && !viaOptions.isEmpty()) {
- return viaOptions + "." + viaSuffix;
- }
- return viaSuffix;
+ private AddressParser(@NotNull String address, @Nullable IntList protocols, @Nullable Integer port) {
+ this.serverAddress = address;
+ this.port = port;
+ this.protocols = protocols;
+ }
+
+ @NotNull
+ public static AddressParser parse(String address) {
+ return parse(address, VIA);
  }
 
- public AddressParser parse(String address, String viaHostName) {
+ @NotNull
+ private static AddressParser parse(String address, String viaHostName) {
+ int portIndex = address.lastIndexOf(':');
+ Integer port = portIndex >= 0 ? Ints.tryParse(address.substring(portIndex + 1)) : null;
+
+ if (port != null && port >= 0 && port < 65536) {
+ if (address.charAt(portIndex - 1) == '.') {
+ // Let's not allocate an intermediate string.
+ portIndex -= 1;
+ } else if (port < 10000 &&
+ // I don't like this but there's not really a better way of doing this
+ address.lastIndexOf(':', portIndex - 1) > Math.max(
+ address.lastIndexOf(']', portIndex - 1),
+ address.lastIndexOf('.', portIndex - 1)
+ )) {
+ // We parsed an IPv6, a port isn't ideal here.
+ port = null;
+ }
+
+ // Keeping a sane flow control.
+ if (port != null) {
+ // Truncate the port off, as that interferes.
+ address = address.substring(0, portIndex);
+ }
+ }
+
  address = StringUtils.removeEnd(address, ".");
- String suffixRemoved = StringUtils.removeEnd(address, "." + viaHostName);
 
- if (suffixRemoved.equals(address)) {
- serverAddress = address;
- return this;
+ String truncated = StringUtils.removeEnd(address, '.' + viaHostName);
+ if (!address.equals(truncated)) {
+ return parseSuffix(truncated, port);
+ }
+
+ truncated = StringUtils.removeStart(address, viaHostName + '.');
+ if (!address.equals(truncated)) {
+ final AddressParser addr = parsePrefix(truncated, port);
+ if (addr != null) {
+ return addr;
+ }
  }
 
+ return new AddressParser(address, port);
+ }
+
+ @NotNull
+ private static AddressParser parseSuffix(String address, Integer port) {
  boolean stopOptions = false;
- List<String> optionsParts = new ArrayList<>();
+ IntList protocolParts = new IntArrayList();
  List<String> serverParts = new ArrayList<>();
 
- for (String part : Lists.reverse(Arrays.asList(suffixRemoved.split(Pattern.quote("."))))) {
- if (!stopOptions && parseOption(part)) {
- optionsParts.add(part);
+ Integer protocol;
+ for (String part : Lists.reverse(Arrays.asList(address.split("\\.")))) {
+ if (!stopOptions && (protocol = parseSuffixOption(part)) != null) {
+ protocolParts.add(protocol.intValue());
  continue;
  }
  stopOptions = true;
  serverParts.add(part);
  }
 
- serverAddress = String.join(".", Lists.reverse(serverParts));
- viaOptions = String.join(".", Lists.reverse(optionsParts));
- viaSuffix = viaHostName;
+ return new AddressParser(
+ String.join(".", Lists.reverse(serverParts)),
+ new IntImmutableList(Lists.reverse(protocolParts)),
+ port
+ );
+ }
+
+ // Fail condition = returns null; caller must fall through.
+ @Nullable
+ private static AddressParser parsePrefix(String address, Integer port) {
+ IntList protocols = new IntArrayList();
+ int index = 0, lastIndex, colonIndex = address.indexOf(';');
+
+ if (colonIndex < 0) {
+ return null;
+ }
+
+ while ((index = address.indexOf('+', lastIndex = index)) >= 0 && index < colonIndex) {
+ parseAndAdd(address.substring(lastIndex, index), protocols);
+ index++;
+ }
+
+ parseAndAdd(address.substring(lastIndex, colonIndex), protocols);
+
+ return new AddressParser(
+ address.substring(colonIndex + 1),
+ new IntImmutableList(protocols),
+ port
+ );
+ }
+
+ private static void parseAndAdd(String part, IntList protocols) {
+ final Integer protocol = parseSchemeOption(part);
+ if (protocol != null) {
+ protocols.add(protocol.intValue());
+ }
+ }
+
+ public String getSuffixWithOptions() {
+ if (protocols == null) {
+ return "";
+ }
+ if (protocols.isEmpty()) {
+ return VIA;
+ }
+ return protocols.intStream()
+ .mapToObj(AddressParser::toProtocolName)
+ .map(str -> str.replace('.', '_'))
+ .collect(Collectors.joining("._v", "_v", "." + VIA));
+ }
+
+ public String getPrefixWithOptions() {
+ if (protocols == null) {
+ return "";
+ }
+ if (protocols.isEmpty()) {
+ return VIA;
+ }
+ return protocols.intStream()
+ .mapToObj(AddressParser::toProtocolName)
+ .collect(Collectors.joining("+v", VIA + ".v", ""));
+ }
+
+ public boolean hasViaMetadata() {
+ return protocols != null;
+ }
+
+ public boolean hasProtocol() {
+ return protocols != null && !protocols.isEmpty();
+ }
+
+ public Integer protocol() {
+ if (protocols != null && !protocols.isEmpty()) {
+ return protocols.getInt(0);
+ }
+ return null;
+ }
+
+ @NotNull
+ public String serverAddress() {
+ return this.serverAddress;
+ }
+
+ @Nullable
+ public Integer port() {
+ return this.port;
+ }
+
+ public String toAddress() {
+ if (port != null) {
+ return serverAddress + ':' + port;
+ }
+ return serverAddress;
+ }
+
+ public String toSuffixedViaAddress() {
+ final String address = addAddressSuffix(serverAddress);
+ if (port != null) {
+ return address + ':' + port;
+ }
+ return address;
+ }
+
+ public InetAddress resolve() throws UnknownHostException {
+ return this.addAddressSuffix(InetAddress.getByName(serverAddress));
+ }
 
- return this;
+ public InetSocketAddress addAddressSuffix(InetSocketAddress address) throws UnknownHostException {
+ return new InetSocketAddress(addAddressSuffix(address.getAddress()), address.getPort());
  }
 
- public boolean parseOption(String part) {
+ public InetAddress addAddressSuffix(InetAddress address) throws UnknownHostException {
+ return InetAddress.getByAddress(addAddressSuffix(address.getHostName()), address.getAddress());
+ }
+
+ public String addAddressSuffix(String input) {
+ if (!this.hasViaMetadata()) {
+ return input;
+ }
+ return DOT_SUFFIX.matcher(input).replaceAll("") + '.' + this.getSuffixWithOptions();
+ }
+
+ private static Integer parseSuffixOption(String part) {
  String option;
  if (part.length() < 2) {
- return false;
+ return null;
  } else if (part.startsWith("_")) {
  option = String.valueOf(part.charAt(1));
  } else if (part.charAt(1) == '_') {
  option = String.valueOf(part.charAt(0));
  } else {
- return false;
+ return null;
  }
 
  String arg = part.substring(2);
  if ("v".equals(option)) {
- parseProtocol(arg);
+ return parseProtocol(arg);
+ }
+
+ return null;
+ }
+
+ private static Integer parseSchemeOption(String part) {
+ if (part.length() < 2) {
+ return null;
  }
+ if (!part.startsWith("v")) {
+ return null;
+ }
+ return parseProtocol(part.substring(1));
+ }
 
- return true;
+ private static Integer parseProtocol(String arg) {
+ final Integer protocol = Ints.tryParse(arg);
+ if (protocol != null) {
+ return protocol;
+ }
+ ProtocolVersion ver = ProtocolVersion.getClosest(arg.replace('_', '.'));
+ if (ver != null) {
+ return ver.getVersion();
+ }
+ return null;
  }
 
- public void parseProtocol(String arg) {
- protocol = Ints.tryParse(arg);
- if (protocol == null) {
- ProtocolVersion ver = ProtocolVersion.getClosest(arg.replace("_", "."));
- if (ver != null) protocol = ver.getVersion();
+ private static String toProtocolName(int protocol) {
+ if (protocol < 0 || !ProtocolVersion.isRegistered(protocol)) {
+ return Integer.toString(protocol);
  }
+ return ProtocolVersion.getProtocol(protocol).getIncludedVersions().iterator().next();
+ }
+
+ @Override
+ public String toString() {
+ return "AddressParser{" + this.toSuffixedViaAddress() + '}';
  }
 }

src/main/java/com/viaversion/fabric/common/protocol/HostnameParserProtocol.java

@@ -20,10 +20,9 @@
 import com.viaversion.fabric.common.AddressParser;
 import com.viaversion.viaversion.api.protocol.AbstractSimpleProtocol;
 import com.viaversion.viaversion.api.protocol.packet.PacketWrapper;
+import com.viaversion.viaversion.api.protocol.packet.State;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandlers;
 import com.viaversion.viaversion.api.protocol.remapper.ValueTransformer;
-import com.viaversion.viaversion.api.type.Type;
-import com.viaversion.viaversion.api.protocol.packet.State;
 import com.viaversion.viaversion.api.type.Types;
 import com.viaversion.viaversion.protocols.base.ServerboundHandshakePackets;
 
@@ -39,7 +38,7 @@ protected void register() {
  map(Types.STRING, new ValueTransformer<String, String>(Types.STRING) {
  @Override
  public String transform(PacketWrapper packetWrapper, String s) {
- return new AddressParser().parse(s).serverAddress;
+ return AddressParser.parse(s).serverAddress();
  }
  });
  }