/*
    * junixsocket
    *
    * Copyright 2009-2024 Christian Kohlschütter
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.newsclub.net.unix;
  
  import java.io.ByteArrayInputStream;
  import java.io.File;
  import java.io.FileDescriptor;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.net.DatagramSocket;
  import java.net.InetAddress;
  import java.net.InetSocketAddress;
  import java.net.ServerSocket;
  import java.net.SocketAddress;
  import java.net.SocketException;
  import java.net.URI;
  import java.nio.ByteBuffer;
  import java.nio.charset.StandardCharsets;
  import java.util.HashMap;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Objects;
  
  import org.eclipse.jdt.annotation.NonNull;
  import org.eclipse.jdt.annotation.Nullable;
  
  import com.google.errorprone.annotations.Immutable;
  import com.kohlschutter.annotations.compiletime.SuppressFBWarnings;
  
  /**
   * Some {@link SocketAddress} that is supported by junixsocket, such as {@link AFUNIXSocketAddress}.
   *
   * @author Christian Kohlschütter
   */
  @Immutable
  @SuppressWarnings({"PMD.CouplingBetweenObjects", "PMD.CyclomaticComplexity"})
  public abstract class AFSocketAddress extends InetSocketAddress {
    private static final long serialVersionUID = 1L; // do not change!
  
    /**
     * Just a marker for "don't actually bind" (checked with "=="). Used in combination with a
     * superclass' bind method, which should trigger "setBound()", etc.
     */
    static final AFSocketAddress INTERNAL_DUMMY_BIND = new SentinelSocketAddress(0);
    static final AFSocketAddress INTERNAL_DUMMY_CONNECT = new SentinelSocketAddress(1);
    static final AFSocketAddress INTERNAL_DUMMY_DONT_CONNECT = new SentinelSocketAddress(2);
  
    private static final int SOCKADDR_NATIVE_FAMILY_OFFSET = NativeUnixSocket.isLoaded() //
        ? NativeUnixSocket.sockAddrNativeFamilyOffset() : -1;
  
    private static final int SOCKADDR_NATIVE_DATA_OFFSET = NativeUnixSocket.isLoaded() //
        ? NativeUnixSocket.sockAddrNativeDataOffset() : -1;
  
    private static final int SOCKADDR_MAX_LEN = NativeUnixSocket.isLoaded() //
        ? NativeUnixSocket.sockAddrLength(0) : 256;
  
    private static final Map<AFAddressFamily<?>, Map<Integer, Map<ByteBuffer, AFSocketAddress>>> ADDRESS_CACHE =
        new HashMap<>();
  
    static final ThreadLocal<ByteBuffer> SOCKETADDRESS_BUFFER_TL = new ThreadLocal<ByteBuffer>() {
  
      @Override
      protected ByteBuffer initialValue() {
        return AFSocketAddress.newSockAddrDirectBuffer(SOCKADDR_MAX_LEN);
      }
    };
  
    private static final boolean USE_DESERIALIZATION_FOR_INIT;
  
    static {
      String v = System.getProperty("org.newsclub.net.unix.AFSocketAddress.deserialize", "");
      USE_DESERIALIZATION_FOR_INIT = v.isEmpty() ? NativeLibraryLoader.isAndroid() : Boolean
          .parseBoolean(v);
    }
  
    /**
     * Some byte-level representation of this address, which can only be converted to a native
     * representation in combination with the domain ID.
     */
    @SuppressFBWarnings("JCIP_FIELD_ISNT_FINAL_IN_IMMUTABLE_CLASS")
    private byte[] bytes;
  
   /**
    * An {@link InetAddress}-wrapped representation of this address. Only created upon demand.
    */
   @SuppressFBWarnings("JCIP_FIELD_ISNT_FINAL_IN_IMMUTABLE_CLASS") // only modified during
                                                                   // construction/deserialization
   private InetAddress inetAddress = null; // derived from bytes
 
   /**
    * The system-native representation of this address, or {@code null}.
    */
   @SuppressWarnings("PMD.ImmutableField")
   private transient ByteBuffer nativeAddress;
 
   /**
    * The address family.
    */
   private transient AFAddressFamily<?> addressFamily;
 
   /**
    * Creates a new socket address.
    *
    * @param port The port.
    * @param socketAddress The socket address in junixsocket-specific byte-array representation.
    * @param nativeAddress The socket address in system-native representation.
    * @param af The address family.
    * @throws SocketException on error.
    */
   @SuppressFBWarnings("CT_CONSTRUCTOR_THROW")
   protected AFSocketAddress(int port, final byte[] socketAddress, ByteBuffer nativeAddress,
       AFAddressFamily<?> af) throws SocketException {
     /*
      * Initializing the superclass with an unresolved hostname helps us pass the #equals and
      * #hashCode checks, which unfortunately are declared final in InetSocketAddress.
      *
      * Using a resolved address (with the address bit initialized) would be ideal, but resolved
      * addresses can only be IPv4 or IPv6 (at least as of Java 16 and earlier).
      */
     super(AFInetAddress.createUnresolvedHostname(socketAddress, af), port >= 0 && port <= 0xffff
         ? port : 0);
     initAFSocketAddress(this, port, socketAddress, nativeAddress, af);
   }
 
   /**
    * Only for {@link SentinelSocketAddress}.
    *
    * @param clazz The {@link SentinelSocketAddress} class.
    * @param port A sentinel port number.
    */
   @SuppressWarnings("PMD.UnusedFormalParameter")
   AFSocketAddress(Class<SentinelSocketAddress> clazz, int port) {
     super(InetAddress.getLoopbackAddress(), port);
     this.nativeAddress = null;
     this.bytes = new byte[0];
     this.addressFamily = null;
   }
 
   @SuppressWarnings({"cast", "this-escape"})
   private static void initAFSocketAddress(AFSocketAddress addr, int port,
       final byte[] socketAddress, ByteBuffer nativeAddress, AFAddressFamily<?> af)
       throws SocketException {
     if (socketAddress.length == 0) {
       throw new SocketException("Illegal address length: " + socketAddress.length);
     }
 
     addr.nativeAddress = nativeAddress == null ? null : (ByteBuffer) (Object) nativeAddress
         .duplicate().rewind();
     if (port < -1) {
       throw new IllegalArgumentException("port out of range");
     } else if (port > 0xffff) {
       if (!NativeUnixSocket.isLoaded()) {
         throw (SocketException) new SocketException(
             "Cannot set SocketAddress port - junixsocket JNI library is not available").initCause(
                 NativeUnixSocket.unsupportedException());
       }
       NativeUnixSocket.setPort1(addr, port);
     }
 
     addr.bytes = socketAddress.clone();
     addr.addressFamily = af;
   }
 
   /**
    * Returns a new {@link AFSocketAddress} instance via deserialization. This is a trick to
    * workaround certain environments that do not allow the construction of {@link InetSocketAddress}
    * instances without trying DNS resolution.
    *
    * @param <A> The subclass (must be a direct subclass of {@link AFSocketAddress}).
    * @param port The port to use.
    * @param socketAddress The junixsocket representation of the socket address.
    * @param nativeAddress The system-native representation of the socket address, or {@code null}.
    * @param af The address family, corresponding to the subclass
    * @param constructor The constructor to use as fallback
    * @return The new instance.
    * @throws SocketException on error.
    */
   protected static <A extends AFSocketAddress> A newDeserializedAFSocketAddress(int port,
       final byte[] socketAddress, ByteBuffer nativeAddress, AFAddressFamily<A> af,
       AFSocketAddressConstructor<A> constructor) throws SocketException {
     String hostname = AFInetAddress.createUnresolvedHostname(socketAddress, af);
     if (hostname == null || hostname.isEmpty()) {
       return constructor.newAFSocketAddress(port, socketAddress, nativeAddress);
     }
     try (ObjectInputStream oin = new ObjectInputStream(new ByteArrayInputStream(AFSocketAddress
         .craftSerializedObject(af.getSocketAddressClass(), hostname, (port >= 0 && port <= 0xffff
             ? port : 0))))) {
       @SuppressWarnings("unchecked")
       A addr = (A) oin.readObject();
       initAFSocketAddress(addr, port, socketAddress, nativeAddress, af);
       return addr;
     } catch (SocketException e) {
       throw e;
     } catch (ClassNotFoundException | IOException e) {
       throw (SocketException) new SocketException("Unexpected deserialization problem").initCause(
           e);
     }
   }
 
   /**
    * Creates a byte-representation of a serialized {@link AFSocketAddress} instance, overriding
    * hostname and port, which allows bypassing DNS resolution.
    *
    * @param className The actual subclass.
    * @param hostname The hostname to use (must not be empty or null).
    * @param port The port to use.
    * @return The byte representation.
    */
   private static byte[] craftSerializedObject(Class<? extends AFSocketAddress> className,
       String hostname, int port) {
     ByteBuffer bb = ByteBuffer.allocate(768);
     bb.putShort((short) 0xaced); // STREAM_MAGIC
     bb.putShort((short) 5); // STREAM_VERSION
     bb.put((byte) 0x73); // TC_OBJECT
     bb.put((byte) 0x72); // TC_CLASSDESC
 
     putShortLengthUtf8(bb, className.getName());
     bb.putLong(1); // serialVersionUID of subclass (expected to be 1)
     bb.putInt(0x02000078);
     bb.put((byte) 0x72);
 
     putShortLengthUtf8(bb, AFSocketAddress.class.getName());
     bb.putLong(serialVersionUID); // serialVersionUID of AFSocketAddress
     bb.putInt(0x0300025B);
     putShortLengthUtf8(bb, "bytes");
 
     bb.putInt(0x7400025B);
     bb.putShort((short) 0x424C);
 
     putShortLengthUtf8(bb, "inetAddress");
     bb.put((byte) 0x74);
 
     putShortLengthEncodedClassName(bb, InetAddress.class);
 
     bb.putShort((short) 0x7872);
     putShortLengthUtf8(bb, InetSocketAddress.class.getName());
     bb.putLong(5076001401234631237L); // NOPMD InetSocketAddress serialVersionUID
 
     bb.putInt(0x03000349);
     putShortLengthUtf8(bb, "port");
 
     bb.put((byte) 0x4C);
     putShortLengthUtf8(bb, "addr");
 
     bb.putInt(0x71007E00);
     bb.putShort((short) 0x034C);
     putShortLengthUtf8(bb, "hostname");
     bb.put((byte) 0x74);
 
     putShortLengthEncodedClassName(bb, String.class);
 
     bb.putShort((short) 0x7872);
     putShortLengthUtf8(bb, SocketAddress.class.getName());
     bb.putLong(5215720748342549866L); // NOPMD SocketAddress serialVersionUID
 
     bb.putInt(0x02000078);
     bb.put((byte) 0x70);
     bb.putInt(port);
 
     bb.putShort((short) 0x7074);
     putShortLengthUtf8(bb, hostname);
 
     bb.putInt(0x78707077);
     bb.put((byte) 0x0B);
 
     putShortLengthUtf8(bb, "undefined");
 
     bb.put((byte) 0x78); // TC_ENDBLOCKDATA
     bb.flip();
 
     byte[] buf = new byte[bb.remaining()];
     bb.get(buf);
     return buf;
   }
 
   private static void putShortLengthEncodedClassName(ByteBuffer bb, Class<?> klazz) {
     putShortLengthUtf8(bb, "L" + klazz.getName().replace('.', '/') + ";");
   }
 
   private static void putShortLengthUtf8(ByteBuffer bb, String s) {
     byte[] utf8 = s.getBytes(StandardCharsets.UTF_8);
     bb.putShort((short) utf8.length);
     bb.put(utf8);
   }
 
   /**
    * Checks if {@link AFSocketAddress} instantiation should be performed via deserialization.
    *
    * @return {@code true} if so.
    * @see #newDeserializedAFSocketAddress(int, byte[], ByteBuffer, AFAddressFamily,
    *      AFSocketAddressConstructor)
    */
   protected static boolean isUseDeserializationForInit() {
     return USE_DESERIALIZATION_FOR_INIT;
   }
 
   /**
    * Checks if the address can be resolved to a {@link File}.
    *
    * @return {@code true} if the address has a filename.
    */
   public abstract boolean hasFilename();
 
   /**
    * Returns the {@link File} corresponding with this address, if possible.
    *
    * A {@link FileNotFoundException} is thrown if there is no filename associated with the address,
    * which applies to addresses in the abstract namespace, for example.
    *
    * @return The filename.
    * @throws FileNotFoundException if the address is not associated with a filename.
    */
   public abstract File getFile() throws FileNotFoundException;
 
   /**
    * Returns the corresponding {@link AFAddressFamily}.
    *
    * @return The address family instance.
    */
   public final AFAddressFamily<?> getAddressFamily() {
     return addressFamily;
   }
 
   /**
    * Wraps the socket name/peer name of a file descriptor as an {@link InetAddress}.
    *
    * @param fdesc The file descriptor.
    * @param peerName If {@code true}, the remote peer name (instead of the local name) is retrieved.
    * @param af The address family.
    * @return The {@link InetAddress}.
    */
   protected static final InetAddress getInetAddress(FileDescriptor fdesc, boolean peerName,
       AFAddressFamily<?> af) {
     if (!fdesc.valid()) {
       return null;
     }
     byte[] addr = NativeUnixSocket.sockname(af.getDomain(), fdesc, peerName);
     if (addr == null) {
       return null;
     }
     return AFInetAddress.wrapAddress(addr, af);
   }
 
   /**
    * Gets the socket name/peer name of a file descriptor as an {@link AFSocketAddress}.
    *
    * @param <A> The corresponding address type.
    * @param fdesc The file descriptor.
    * @param requestPeerName If {@code true}, the remote peer name (instead of the local name) is
    *          retrieved.
    * @param port The port.
    * @param af The address family.
    * @return The {@link InetAddress}.
    */
   protected static final <A extends AFSocketAddress> @Nullable A getSocketAddress(
       FileDescriptor fdesc, boolean requestPeerName, int port, AFAddressFamily<A> af) {
     if (!fdesc.valid()) {
       return null;
     }
     byte[] addr = NativeUnixSocket.sockname(af.getDomain(), fdesc, requestPeerName);
     if (addr == null) {
       return null;
     }
     try {
       // FIXME we could infer the "port" from the path if the socket factory supports that
       return AFSocketAddress.unwrap(AFInetAddress.wrapAddress(addr, af), port, af);
     } catch (SocketException e) {
       throw new IllegalStateException(e);
     }
   }
 
   static final AFSocketAddress preprocessSocketAddress(
       Class<? extends AFSocketAddress> supportedAddressClass, SocketAddress endpoint,
       AFSocketAddressFromHostname<?> afh) throws SocketException {
     Objects.requireNonNull(endpoint);
     if (endpoint instanceof SentinelSocketAddress) {
       return (SentinelSocketAddress) endpoint;
     }
 
     if (!(endpoint instanceof AFSocketAddress)) {
       if (afh != null) {
         if (endpoint instanceof InetSocketAddress) {
           InetSocketAddress isa = (InetSocketAddress) endpoint;
 
           String hostname = isa.getHostString();
           if (afh.isHostnameSupported(hostname)) {
             try {
               endpoint = afh.addressFromHost(hostname, isa.getPort());
             } catch (SocketException e) {
               throw e;
             }
           }
         }
       }
     }
 
     Objects.requireNonNull(endpoint);
 
     if (!supportedAddressClass.isAssignableFrom(endpoint.getClass())) {
       throw new IllegalArgumentException("Can only connect to endpoints of type "
           + supportedAddressClass.getName() + ", got: " + endpoint.getClass() + ": " + endpoint);
     }
 
     return (AFSocketAddress) endpoint;
   }
 
   /**
    * Returns the (non-native) byte-level representation of this address.
    *
    * @return The byte array.
    */
   protected final byte[] getBytes() {
     return bytes; // NOPMD
   }
 
   /**
    * Returns a "special" {@link InetAddress} that contains information about this
    * {@link AFSocketAddress}.
    *
    * IMPORTANT: This {@link InetAddress} does not properly compare (using
    * {@link InetAddress#equals(Object)} and {@link InetAddress#hashCode()}). It should be used
    * exclusively to circumvent existing APIs like {@link DatagramSocket} that only accept/return
    * {@link InetAddress} and not arbitrary {@link SocketAddress} types.
    *
    * @return The "special" {@link InetAddress}.
    */
   public final InetAddress wrapAddress() {
     return AFInetAddress.wrapAddress(bytes, getAddressFamily());
   }
 
   /**
    * A reference to the constructor of an AFSocketAddress subclass.
    *
    * @param <T> The actual subclass.
    * @author Christian Kohlschütter
    */
   @FunctionalInterface
   protected interface AFSocketAddressConstructor<T extends AFSocketAddress> {
     /**
      * Constructs a new AFSocketAddress instance.
      *
      * @param port The port.
      * @param socketAddress The socket address in junixsocket-specific byte-array representation.
      * @param nativeAddress The socket address in system-native representation.
      * @return The instance.
      * @throws SocketException on error.
      */
     @NonNull
     T newAFSocketAddress(int port, byte[] socketAddress, ByteBuffer nativeAddress)
         throws SocketException;
   }
 
   /**
    * Resolves a junixsocket-specific byte-array representation of an {@link AFSocketAddress} to an
    * actual {@link AFSocketAddress} instance, possibly reusing a cached instance.
    *
    * @param <A> The concrete {@link AFSocketAddress} that is supported by this type.
    * @param socketAddress The socket address in junixsocket-specific byte-array representation.
    * @param port The port.
    * @param af The address family.
    * @return The instance.
    * @throws SocketException on error.
    */
   @SuppressWarnings({"unchecked", "null"})
   protected static final <A extends AFSocketAddress> A resolveAddress(final byte[] socketAddress,
       int port, AFAddressFamily<A> af) throws SocketException {
     if (socketAddress.length == 0) {
       throw new SocketException("Address cannot be empty");
     }
 
     if (port == -1) {
       port = 0;
     }
 
     ByteBuffer direct = SOCKETADDRESS_BUFFER_TL.get();
     int limit = NativeUnixSocket.isLoaded() ? NativeUnixSocket.bytesToSockAddr(af.getDomain(),
         direct, socketAddress) : -1;
     if (limit == -1) {
       // not supported, but we can still create an address
       return af.getAddressConstructor().newAFSocketAddress(port, socketAddress, null);
     } else if (limit > SOCKADDR_MAX_LEN) {
       throw new IllegalStateException("Unexpected address length");
     }
     direct.rewind();
     direct.limit(limit);
 
     A instance;
     synchronized (AFSocketAddress.class) {
       Map<ByteBuffer, AFSocketAddress> map;
       Map<Integer, Map<ByteBuffer, AFSocketAddress>> mapPorts = ADDRESS_CACHE.get(af);
       if (mapPorts == null) {
         instance = null;
         mapPorts = new HashMap<>();
         map = new HashMap<>();
         mapPorts.put(port, map);
         ADDRESS_CACHE.put(af, mapPorts);
       } else {
         map = mapPorts.get(port);
         if (map == null) {
           instance = null;
           map = new HashMap<>();
           mapPorts.put(port, map);
         } else {
           instance = (A) map.get(direct);
         }
       }
 
       if (instance == null) {
         ByteBuffer key = newSockAddrKeyBuffer(limit);
         key.put(direct);
         key = key.asReadOnlyBuffer();
 
         instance = af.getAddressConstructor().newAFSocketAddress(port, socketAddress, key);
 
         map.put(key, instance);
       }
     }
 
     return instance;
   }
 
   @SuppressWarnings("null")
   static final <A extends AFSocketAddress> A ofInternal(ByteBuffer socketAddressBuffer,
       AFAddressFamily<A> af) throws SocketException {
     synchronized (AFSocketAddress.class) {
       socketAddressBuffer.rewind();
 
       Map<Integer, Map<ByteBuffer, AFSocketAddress>> mapPorts = ADDRESS_CACHE.get(af);
       if (mapPorts != null) {
         Map<ByteBuffer, AFSocketAddress> map = mapPorts.get(0); // FIXME get port, something like
                                                                 // sockAddrToPort
         if (map != null) {
           @SuppressWarnings("unchecked")
           A address = (A) map.get(socketAddressBuffer);
           if (address != null) {
             return address;
           }
         }
       }
 
       if (!socketAddressBuffer.isDirect()) {
         ByteBuffer buf = getNativeAddressDirectBuffer(Math.min(socketAddressBuffer.limit(),
             SOCKADDR_MAX_LEN));
         buf.put(socketAddressBuffer);
         socketAddressBuffer = buf;
       }
 
       byte[] sockAddrToBytes = NativeUnixSocket.sockAddrToBytes(af.getDomain(),
           socketAddressBuffer);
       if (sockAddrToBytes == null) {
         return null;
       } else {
         return AFSocketAddress.resolveAddress(sockAddrToBytes, 0, af);
       }
     }
   }
 
   /**
    * Wraps an address as an {@link InetAddress}.
    *
    * @param af The address family.
    * @return The {@link InetAddress}.
    */
   protected final synchronized InetAddress getInetAddress(AFAddressFamily<?> af) {
     if (inetAddress == null) {
       inetAddress = AFInetAddress.wrapAddress(bytes, af);
     }
     return inetAddress;
   }
 
   /**
    * Wraps this address as an {@link InetAddress}.
    *
    * @return The {@link InetAddress}.
    */
   protected final InetAddress getInetAddress() {
     return getInetAddress(getAddressFamily());
   }
 
   static final ByteBuffer newSockAddrDirectBuffer(int length) {
     return ByteBuffer.allocateDirect(length);
   }
 
   static final ByteBuffer newSockAddrKeyBuffer(int length) {
     return ByteBuffer.allocate(length);
   }
 
   /**
    * Returns an {@link AFSocketAddress} given a special {@link InetAddress} that encodes the byte
    * sequence of an AF_UNIX etc. socket address, like those returned by {@link #wrapAddress()}.
    *
    * @param <A> The corresponding address type.
    * @param address The "special" {@link InetAddress}.
    * @param port The port (use 0 for "none").
    * @param af The address family.
    * @return The {@link AFSocketAddress} instance.
    * @throws SocketException if the operation fails, for example when an unsupported address is
    *           specified.
    */
   @SuppressWarnings("null")
   @NonNull
   protected static final <A extends AFSocketAddress> A unwrap(InetAddress address, int port,
       AFAddressFamily<A> af) throws SocketException {
     Objects.requireNonNull(address);
     return resolveAddress(AFInetAddress.unwrapAddress(address, af), port, af);
   }
 
   /**
    * Returns an {@link AFSocketAddress} given a special {@link InetAddress} hostname that encodes
    * the byte sequence of an AF_UNIX etc. socket address, like those returned by
    * {@link #wrapAddress()}.
    *
    * @param <A> The corresponding address type.
    * @param hostname The "special" hostname, as provided by {@link InetAddress#getHostName()}.
    * @param port The port (use 0 for "none").
    * @param af The address family.
    * @return The {@link AFSocketAddress} instance.
    * @throws SocketException if the operation fails, for example when an unsupported address is
    *           specified.
    */
   @SuppressWarnings("null")
   @NonNull
   protected static final <A extends AFSocketAddress> A unwrap(String hostname, int port,
       AFAddressFamily<A> af) throws SocketException {
     Objects.requireNonNull(hostname);
     return resolveAddress(AFInetAddress.unwrapAddress(hostname, af), port, af);
   }
 
   static final int unwrapAddressDirectBufferInternal(ByteBuffer socketAddressBuffer,
       SocketAddress address) throws SocketException {
     if (!NativeUnixSocket.isLoaded()) {
       throw new SocketException("Unsupported operation; junixsocket native library is not loaded");
     }
     Objects.requireNonNull(address);
 
     if (!(address instanceof AFSocketAddress)) {
       AFSupplier<? extends AFSocketAddress> supp = AFUNIXSocketAddress.supportedAddressSupplier(
           address);
       address = supp == null ? null : supp.get();
       if (address == null) {
         throw new SocketException("Unsupported address");
       }
     }
 
     AFSocketAddress socketAddress = (AFSocketAddress) address;
 
     byte[] addr = socketAddress.getBytes();
     int domain = socketAddress.getAddressFamily().getDomain();
 
     int len = NativeUnixSocket.bytesToSockAddr(domain, socketAddressBuffer, addr);
     if (len == -1) {
       throw new SocketException("Unsupported domain");
     }
     return len;
   }
 
   /**
    * Returns a thread-local direct ByteBuffer containing the native socket address representation of
    * this {@link AFSocketAddress}.
    *
    * @return The direct {@link ByteBuffer}.
    */
   final ByteBuffer getNativeAddressDirectBuffer() throws SocketException {
     ByteBuffer address = nativeAddress;
     if (address == null) {
       throw (SocketException) new SocketException("Cannot access native address").initCause(
           NativeUnixSocket.unsupportedException());
     }
     address = address.duplicate();
 
     ByteBuffer direct = getNativeAddressDirectBuffer(address.limit());
     address.position(0);
     direct.put(address);
 
     return direct;
   }
 
   static final ByteBuffer getNativeAddressDirectBuffer(int limit) {
     ByteBuffer direct = SOCKETADDRESS_BUFFER_TL.get();
     direct.position(0);
     direct.limit(limit);
     return direct;
   }
 
   /**
    * Checks if the given address is supported by this address family.
    *
    * @param addr The address.
    * @param af The address family.
    * @return {@code true} if supported.
    */
   protected static final boolean isSupportedAddress(InetAddress addr, AFAddressFamily<?> af) {
     return AFInetAddress.isSupportedAddress(addr, af);
   }
 
   /**
    * Writes the native (system-level) representation of this address to the given buffer.
    *
    * The position of the target buffer will be at the end (i.e., after) the written data.
    *
    * @param buf The target buffer.
    * @throws IOException on error.
    */
   public final void writeNativeAddressTo(ByteBuffer buf) throws IOException {
     if (nativeAddress == null) {
       throw (SocketException) new SocketException("Cannot access native address").initCause(
           NativeUnixSocket.unsupportedException());
     }
     buf.put(nativeAddress);
   }
 
   /**
    * Creates a new socket connected to this address.
    *
    * @return The socket instance.
    * @throws IOException on error.
    */
   public AFSocket<?> newConnectedSocket() throws IOException {
     AFSocket<?> socket = getAddressFamily().newSocket();
     socket.connect(this);
     return socket;
   }
 
   /**
    * Creates a new server socket bound to this address.
    *
    * @return The server socket instance.
    * @throws IOException on error.
    */
   public AFServerSocket<?> newBoundServerSocket() throws IOException {
     AFServerSocket<?> serverSocket = getAddressFamily().newServerSocket();
     serverSocket.bind(this);
     return serverSocket;
   }
 
   /**
    * Creates a new server socket force-bound to this address (i.e., any additional call to
    * {@link ServerSocket#bind(SocketAddress)} will ignore the passed address and use this one
    * instead.
    *
    * @return The server socket instance.
    * @throws IOException on error.
    */
   public AFServerSocket<?> newForceBoundServerSocket() throws IOException {
     AFServerSocket<?> serverSocket = getAddressFamily().newServerSocket();
     serverSocket.forceBindAddress(this).bind(this);
     return serverSocket;
   }
 
   /**
    * Tries to parse the given URI and return a corresponding {@link AFSocketAddress} for it.
    *
    * NOTE: Only certain URI schemes are supported, such as {@code unix://} (for
    * {@link AFUNIXSocketAddress}) and {@code tipc://} for {@link AFTIPCSocketAddress}.
    *
    * @param u The URI.
    * @return The address.
    * @throws SocketException on error.
    * @see AFAddressFamily#uriSchemes()
    */
   @SuppressWarnings("PMD.ShortMethodName")
   public static AFSocketAddress of(URI u) throws SocketException {
     return of(u, -1);
   }
 
   /**
    * Tries to parse the given URI and return a corresponding {@link AFSocketAddress} for it.
    *
    * NOTE: Only certain URI schemes are supported, such as {@code unix://} (for
    * {@link AFUNIXSocketAddress}) and {@code tipc://} for {@link AFTIPCSocketAddress}.
    *
    * @param u The URI.
    * @param overridePort The port to forcibly use, or {@code -1} for "don't override".
    * @return The address.
    * @throws SocketException on error.
    * @see AFAddressFamily#uriSchemes()
    */
   @SuppressWarnings("PMD.ShortMethodName")
   public static AFSocketAddress of(URI u, int overridePort) throws SocketException {
     AFAddressFamily<?> af = AFAddressFamily.getAddressFamily(u);
     if (af == null) {
       throw new SocketException("Cannot resolve AFSocketAddress from URI scheme: " + u.getScheme());
     }
     return af.parseURI(u, overridePort);
   }
 
   /**
    * Tries to create a URI based on this {@link AFSocketAddress}.
    *
    * @param scheme The target scheme.
    * @param template An optional template to reuse certain parameters (e.g., the "path" component
    *          for an {@code http} request), or {@code null}.
    * @return The URI.
    * @throws IOException on error.
    */
   public URI toURI(String scheme, URI template) throws IOException {
     throw new IOException("Unsupported operation");
   }
 
   /**
    * Returns a address string that can be used with {@code socat}'s {@code SOCKET-CONNECT},
    * {@code SOCKET-LISTEN}, {@code SOCKET-DATAGRAM}, etc., address types, or {@code null} if the
    * address type is not natively supported by this platform.
    *
    * This call is mostly suited for debugging purposes. The resulting string is specific to the
    * platform the code is executed on, and thus may be different among platforms.
    *
    * @param socketType The socket type, or {@code null} to omit from string.
    * @param socketProtocol The socket protocol, or {@code null} to omit from string.
    * @return The string (such as 1:0:x2f746d702f796f).
    * @throws IOException on error (a {@link SocketException} is thrown if the native address cannot
    *           be accessed).
    */
   public @Nullable @SuppressWarnings("PMD.NPathComplexity") String toSocatAddressString(
       AFSocketType socketType, AFSocketProtocol socketProtocol) throws IOException {
 
     if (SOCKADDR_NATIVE_FAMILY_OFFSET == -1 || SOCKADDR_NATIVE_DATA_OFFSET == -1) {
       return null;
     }
     if (nativeAddress == null) {
       throw (SocketException) new SocketException("Cannot access native address").initCause(
           NativeUnixSocket.unsupportedException());
     }
     if (socketProtocol != null && socketProtocol.getId() != 0) {
       throw new IOException("Protocol not (yet) supported"); // FIXME support additional protocols
     }
 
     int family = (nativeAddress.get(SOCKADDR_NATIVE_FAMILY_OFFSET) & 0xFF);
     int type = socketType == null ? -1 : NativeUnixSocket.sockTypeToNative(socketType.getId());
     StringBuilder sb = new StringBuilder();
     sb.append(family);
     if (type != -1) {
       sb.append(':');
       sb.append(type);
     }
     if (socketProtocol != null) {
       sb.append(':');
       sb.append(socketProtocol.getId()); // FIXME needs native conversion
     }
     sb.append(":x");
     int n = nativeAddress.limit();
     while (n > 1 && nativeAddress.get(n - 1) == 0) {
       n--;
     }
     for (int pos = SOCKADDR_NATIVE_DATA_OFFSET; pos < n; pos++) {
       byte b = nativeAddress.get(pos);
       sb.append(String.format(Locale.ENGLISH, "%02x", b));
     }
     return sb.toString();
   }
 
   /**
    * Checks if the given address could cover another address.
    *
    * By default, this is only true if both addresses are regarded equal using
    * {@link #equals(Object)}.
    *
    * However, implementations may support "wildcard" addresses, and this method would compare a
    * wildcard address against some non-wildcard address, for example.
    *
    * @param other The other address that could be covered by this address.
    * @return {@code true} if the other address could be covered.
    */
   public boolean covers(AFSocketAddress other) {
     return this.equals(other);
   }
 
   /**
    * Custom serialization: Reference {@link AFAddressFamily} instance by identifier string.
    *
    * @param in The {@link ObjectInputStream}.
    * @throws ClassNotFoundException on error.
    * @throws IOException on error.
    */
   private void readObject(ObjectInputStream in) throws ClassNotFoundException, IOException {
     in.defaultReadObject();
 
     String af = in.readUTF();
     if ("undefined".equals(af)) {
       this.addressFamily = null;
     } else {
       this.addressFamily = Objects.requireNonNull(AFAddressFamily.getAddressFamily(af),
           "address family");
     }
   }
 
   /**
    * Custom serialization: Reference {@link AFAddressFamily} instance by identifier string.
    *
    * @param out The {@link ObjectOutputStream}.
    * @throws IOException on error.
    */
   private void writeObject(ObjectOutputStream out) throws IOException {
     out.defaultWriteObject();
     out.writeUTF(addressFamily == null ? "undefined" : addressFamily.getJuxString());
   }
 
   /**
    * Returns a string representation of the argument as an unsigned decimal value.
    * <p>
    * Works like {@link Integer#toUnsignedString(int)}; added to allow execution on Java 1.7.
    *
    * @param i The value.
    * @return The string.
    */
   static String toUnsignedString(int i) {
     return Long.toString(toUnsignedLong(i));
   }
 
   /**
    * Returns a string representation of the first argument as an unsigned integer value in the radix
    * specified by the second argument; added to allow execution on Java 1.7.
    *
    * @param i The value.
    * @param radix The radix.
    * @return The string.
    */
   static String toUnsignedString(int i, int radix) {
     return Long.toUnsignedString(toUnsignedLong(i), radix);
   }
 
   private static long toUnsignedLong(long x) {
     return x & 0xffffffffL;
   }
 
   /**
    * Parses the string argument as an unsigned integer in the radix specified by the second
    * argument. Works like {@link Integer#parseUnsignedInt(String, int)}; added to allow execution on
    * Java 1.7.
    *
    * @param s The string.
    * @param radix The radix.
    * @return The integer.
    * @throws NumberFormatException on parse error.
    */
   protected static int parseUnsignedInt(String s, int radix) throws NumberFormatException {
     if (s == null || s.isEmpty()) {
       throw new NumberFormatException("Cannot parse null or empty string");
     }
 
     int len = s.length();
     if (s.startsWith("-")) {
       throw new NumberFormatException("Illegal leading minus sign on unsigned string " + s);
     }
 
     if (len <= 5 || (radix == 10 && len <= 9)) {
       return Integer.parseInt(s, radix);
     } else {
       long ell = Long.parseLong(s, radix);
       if ((ell & 0xffff_ffff_0000_0000L) == 0) {
         return (int) ell;
       } else {
         throw new NumberFormatException("String value exceeds " + "range of unsigned int: " + s);
       }
     }
   }
 }