public static final int NETWORK_INTERFACE_CAP_RDMA = 0x00000002;
    
    public NetworkInterfaceInfo(InetAddress address, int linkSpeed) {
        this.address = address;
        this.linkSpeed = linkSpeed;
        this.ipv6 = address.getAddress().length == 16;
        this.capability = 0;
        
        // Check for RSS capability (simplified - would need OS-specific checks)
        this.rssCapable = checkRSSCapability();

    val InetSocketAddress.socketHost: String get() {
      // The InetSocketAddress was specified with a string (either a numeric IP or a host name). If
      // it is a name, all IPs for that name should be tried. If it is an IP address, only that IP
      // address should be tried.
      val address = address ?: return hostName

         * Creates a new witness IP address.
         *
         * @param address the IP address
         */
        public WitnessIPAddress(InetAddress address) {
            this.address = address;
            this.flags = address.getAddress().length == 4 ? IPV4 : IPV6;
        }

        /**
         * Gets the IP address.
         *
         * @return the IP address
         */
        public InetAddress getAddress() {

  companion object {
    /**
     * A network that resolves only one IP address per host. Use this when testing route selection
     * fallbacks to prevent the host machine's various IP addresses from interfering.
     */
    private val SINGLE_INET_ADDRESS_DNS =
      Dns { hostname ->
        val addresses = Dns.SYSTEM.lookup(hostname)
        listOf(addresses[0])
      }

In the DNS server(s) you would configure a record (an "`A record`") to point **your domain** to the public **IP address of your server**.

You would probably do this just once, the first time, when setting everything up.

/// tip

This Domain Name part is way before HTTPS, but as everything depends on the domain and the IP address, it's worth mentioning it here.

///

  //
  if (b != address.size) {
    if (compress == -1) return null // Address didn't have compression or enough groups.
    address.copyInto(address, address.size - (b - compress), compress, b)
    address.fill(0.toByte(), compress, compress + (address.size - b))
  }

  return address
}

/** Decodes an IPv4 address suffix of an IPv6 address, like 1111::5555:6666:192.168.0.1. */

## `fastapi run` { #fastapi-run }

Executing `fastapi run` starts FastAPI in production mode by default.

                addresses = new UniAddress[1];
                addresses[0] = UniAddress.getByName(server);
                return getNextAddress();
            }
            final String address = queryLookup(query, "address");
            if (address != null && address.length() > 0) {
                final byte[] ip = java.net.InetAddress.getByName(address).getAddress();

    /**
     * Retrieve all addresses of a host by it's address. NetBIOS hosts can
     * have many names for a given IP address. The name and IP address make the
     * NetBIOS address. This provides a way to retrieve the other names for a
     * host with the same IP address.
     *
     * @param addr the address to query
     * @return array of NetBIOS addresses
     * @throws UnknownHostException if address cannot be resolved
     */

    rather than the duration specified in the response's cache-control header.
 *  Fix: Verify certificate IP addresses in canonical form. When a server presents a TLS certificate
    containing an IP address we must match that address against the URL's IP address, even when the
    two addresses are encoded differently, such as `192.168.1.1` and `0::0:0:FFFF:C0A8:101`. Note