class="kw">package com.hypixel.hytale.server.core.io.ice;

class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import java.net.Inet4Address;
class="kw">import java.net.InetAddress;
class="kw">import java.net.InetSocketAddress;
class="kw">import java.net.InterfaceAddress;
class="kw">import java.net.NetworkInterface;
class="kw">import java.net.SocketException;
class="kw">import java.time.Duration;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Enumeration;
class="kw">import java.util.List;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class="kw">final class IceAddressFilter {
   class="kw">private class="kw">static class="kw">final Duration INTERFACE_SUBNET_CACHE_EXPIRY = Duration.ofSeconds(30L);
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   @Nullable
   class="kw">private class="kw">static class="kw">volatile IceAddressFilter.InterfaceSubnetCache interfaceSubnetCache;
   class="kw">private class="kw">static boolean interfaceEnumerationFailureLogged;

   class="kw">private IceAddressFilter() {
   }

   @Nullable
   class="kw">public class="kw">static InetSocketAddress parse(@Nonnull String var0, int var1) {
      if (var1 > 0 && var1 <= 65535) {
         InetAddress var2;
         try {
            var2 = InetAddress.ofLiteral(var0);
         } catch (IllegalArgumentException var4) {
            class="kw">return null;
         }

         InetSocketAddress var3 = new InetSocketAddress(var2, var1);
         class="kw">return isAcceptable(var3) ? var3 : null;
      } else {
         class="kw">return null;
      }
   }

   class="kw">public class="kw">static boolean isAcceptable(@Nonnull InetSocketAddress var0) {
      InetAddress var1 = var0.getAddress();
      if (var1 == null || var0.getPort() <= 0 || var0.getPort() > 65535) {
         class="kw">return false;
      } else if (var1.isAnyLocalAddress()
         || var1.isLoopbackAddress()
         || var1.isLinkLocalAddress()
         || var1.isMulticastAddress()
         || isBroadcast(var1)
         || isDocumentation(var1)
         || isReserved(var1)
         || hasUnsafeTranslatedIpv4(var1)) {
         LOGGER.at(Level.FINE).log("Refusing ICE candidate address %s", var0);
         class="kw">return false;
      } else if (!isAllowedByHostSubnets(var1, getInterfaceSubnetCache().subnets())) {
         LOGGER.at(Level.FINE).log("Refusing ICE candidate address %s", var0);
         class="kw">return false;
      } else {
         class="kw">return true;
      }
   }

   class="kw">static boolean isAllowedByHostSubnets(@Nonnull InetAddress var0, @Nonnull List<IceAddressFilter.Subnet> var1) {
      for (IceAddressFilter.Subnet var3 : var1) {
         if (var0.equals(var3.address())) {
            class="kw">return false;
         }
      }

      class="kw">return !isPrivate(var0) || isInAnySubnet(var0, var1);
   }

   class="kw">static boolean isInAnySubnet(@Nonnull InetAddress var0, @Nonnull List<IceAddressFilter.Subnet> var1) {
      for (IceAddressFilter.Subnet var3 : var1) {
         if (isInSubnet(var0, var3)) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   class="kw">private class="kw">static IceAddressFilter.InterfaceSubnetCache getInterfaceSubnetCache() {
      IceAddressFilter.InterfaceSubnetCache var0 = interfaceSubnetCache;
      long var1 = System.nanoTime();
      class="kw">return var0 != null && !isInterfaceSubnetCacheExpired(var0, var1) ? var0 : refreshInterfaceSubnetCache(var1);
   }

   class="kw">private class="kw">static class="kw">synchronized IceAddressFilter.InterfaceSubnetCache refreshInterfaceSubnetCache(long var0) {
      IceAddressFilter.InterfaceSubnetCache var2 = interfaceSubnetCache;
      if (var2 != null && !isInterfaceSubnetCacheExpired(var2, var0)) {
         class="kw">return var2;
      }

      ArrayList var3 = new ArrayList<>();

      try {
         Enumeration var4 = NetworkInterface.getNetworkInterfaces();
         if (var4 != null) {
            while (var4.hasMoreElements()) {
               NetworkInterface var5 = var4.nextElement();
               if (var5.isUp() && !var5.isLoopback()) {
                  for (InterfaceAddress var7 : var5.getInterfaceAddresses()) {
                     InetAddress var8 = var7.getAddress();
                     short var9 = var7.getNetworkPrefixLength();
                     if (var8 != null) {
                        var3.add(new IceAddressFilter.Subnet(var8, var9));
                     }
                  }
               }
            }
         }
      } catch (SocketException var10) {
         if (!interfaceEnumerationFailureLogged) {
            ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var10)).log("Could not enumerate class="kw">interface subnets for ICE candidates");
            interfaceEnumerationFailureLogged = true;
         }

         class="kw">return updateInterfaceSubnetCache(List.of(), var0);
      }

      class="kw">return updateInterfaceSubnetCache(List.copyOf(var3), var0);
   }

   class="kw">private class="kw">static IceAddressFilter.InterfaceSubnetCache updateInterfaceSubnetCache(List<IceAddressFilter.Subnet> var0, long var1) {
      IceAddressFilter.InterfaceSubnetCache var3 = new IceAddressFilter.InterfaceSubnetCache(var0, var1);
      interfaceSubnetCache = var3;
      class="kw">return var3;
   }

   class="kw">private class="kw">static boolean isInterfaceSubnetCacheExpired(IceAddressFilter.InterfaceSubnetCache var0, long var1) {
      class="kw">return var1 - var0.loadedAtNanos() >= INTERFACE_SUBNET_CACHE_EXPIRY.toNanos();
   }

   class="kw">private class="kw">static boolean isInSubnet(InetAddress var0, IceAddressFilter.Subnet var1) {
      byte[] var2 = var0.getAddress();
      byte[] var3 = var1.address().getAddress();
      short var4 = var1.prefixLength();
      if (var2.length == var3.length && var4 >= 0 && var4 <= var2.length * 8) {
         int var5 = var4 / 8;

         for (int var6 = 0; var6 < var5; var6++) {
            if (var2[var6] != var3[var6]) {
               class="kw">return false;
            }
         }

         int var8 = var4 % 8;
         if (var8 == 0) {
            class="kw">return true;
         }

         int var7 = 255 << 8 - var8;
         class="kw">return (var2[var5] & var7) == (var3[var5] & var7);
      } else {
         class="kw">return false;
      }
   }

   class="kw">private class="kw">static boolean isPrivate(InetAddress var0) {
      byte[] var1 = var0.getAddress();
      if (!(var0 class="kw">instanceof Inet4Address)) {
         class="kw">return (var1[0] & 254) == 252;
      }

      int var2 = var1[0] & 255;
      int var3 = var1[1] & 255;
      class="kw">return var2 == 10 || var2 == 172 && var3 >= 16 && var3 <= 31 || var2 == 192 && var3 == 168 || var2 == 100 && var3 >= 64 && var3 <= 127;
   }

   class="kw">private class="kw">static boolean isBroadcast(InetAddress var0) {
      if (!(var0 class="kw">instanceof Inet4Address)) {
         class="kw">return false;
      }

      byte[] var1 = var0.getAddress();
      class="kw">return (var1[0] & 255) == 255 && (var1[1] & 255) == 255 && (var1[2] & 255) == 255 && (var1[3] & 255) == 255;
   }

   class="kw">private class="kw">static boolean isReserved(InetAddress var0) {
      byte[] var1 = var0.getAddress();
      if (var0 class="kw">instanceof Inet4Address) {
         int var2 = var1[0] & 255;
         int var3 = var1[1] & 255;
         class="kw">return var2 == 0 || var2 >= 240 || var2 == 198 && (var3 & 254) == 18 || var2 == 192 && var3 == 0 && var1[2] == 0;
      } else {
         class="kw">return (var1[0] & 255) == 254 && (var1[1] & 192) == 192;
      }
   }

   class="kw">private class="kw">static boolean hasUnsafeTranslatedIpv4(InetAddress var0) {
      if (var0 class="kw">instanceof Inet4Address) {
         class="kw">return false;
      }

      byte[] var1 = var0.getAddress();
      int var2 = -1;
      boolean var3 = false;
      if ((var1[0] & 255) == 0 && (var1[1] & 255) == 100 && (var1[2] & 255) == 255 && (var1[3] & 255) == 155 && allZero(var1, 4, 12)) {
         var2 = 12;
      } else if ((var1[0] & 255) == 32 && (var1[1] & 255) == 2) {
         var2 = 2;
      } else if ((var1[0] & 255) == 32 && (var1[1] & 255) == 1 && var1[2] == 0 && var1[3] == 0) {
         var2 = 12;
         var3 = true;
      }

      if (var2 < 0) {
         class="kw">return false;
      }

      byte[] var4 = new byte[4];

      for (int var5 = 0; var5 < var4.length; var5++) {
         var4[var5] = var3 ? (byte)(~var1[var2 + var5]) : var1[var2 + var5];
      }

      class="kw">return isUnsafeTranslatedIpv4(var4);
   }

   class="kw">private class="kw">static boolean allZero(byte[] var0, int var1, int var2) {
      for (int var3 = var1; var3 < var2; var3++) {
         if (var0[var3] != 0) {
            class="kw">return false;
         }
      }

      class="kw">return true;
   }

   class="kw">private class="kw">static boolean isUnsafeTranslatedIpv4(byte[] var0) {
      int var1 = var0[0] & 255;
      int var2 = var0[1] & 255;
      class="kw">return var1 == 0
         || var1 == 10
         || var1 == 127
         || var1 >= 224
         || var1 == 169 && var2 == 254
         || var1 == 172 && var2 >= 16 && var2 <= 31
         || var1 == 192 && var2 == 168
         || var1 == 100 && var2 >= 64 && var2 <= 127
         || var1 == 192 && var2 == 0 && (var0[2] & 255) == 2
         || var1 == 198 && var2 == 51 && (var0[2] & 255) == 100
         || var1 == 203 && var2 == 0 && (var0[2] & 255) == 113;
   }

   class="kw">private class="kw">static boolean isDocumentation(InetAddress var0) {
      byte[] var1 = var0.getAddress();
      if (var0 class="kw">instanceof Inet4Address) {
         if ((var1[0] & 255) == 192 && (var1[1] & 255) == 0 && (var1[2] & 255) == 2) {
            class="kw">return true;
         } else {
            class="kw">return (var1[0] & 255) == 198 && (var1[1] & 255) == 51 && (var1[2] & 255) == 100
               ? true
               : (var1[0] & 255) == 203 && (var1[1] & 255) == 0 && (var1[2] & 255) == 113;
         }
      } else {
         class="kw">return (var1[0] & 255) == 32 && (var1[1] & 255) == 1 && (var1[2] & 255) == 13 && (var1[3] & 255) == 184;
      }
   }

   class="kw">private record InterfaceSubnetCache(@Nonnull List<IceAddressFilter.Subnet> subnets, long loadedAtNanos) {
      class="kw">private InterfaceSubnetCache {
      }
   }

   record Subnet(@Nonnull InetAddress address, short prefixLength) {
      Subnet {
      }
   }
}