* an IPv4 address or not.
   *
   * <p>IPv6 addresses are <b>coerced</b> to IPv4 addresses before being converted to integers.
   *
   * <p>As long as there are applications that assume that all IP addresses are IPv4 addresses and
   * can therefore be converted safely to integers (for whatever purpose) this function can be used
   * to handle IPv6 addresses as well until the application is suitably fixed.
   *

   */
  @ExperimentalOkHttpApi
  interface Callback {
    /**
     * Return addresses for a dns query for a single class of IPv4 (A) or IPv6 (AAAA).
     * May be an empty list indicating that the host is unreachable.
     */
    fun onResponse(
      hostname: String,
      addresses: List<InetAddress>,
    )

    /**
     * Returns an error for the DNS query.
     */
    fun onFailure(

  private var nextAddress = 0xff000064L // 255.0.0.100 in IPv4; ::ff00:64 in IPv6.

  /** Sets the results for `hostname`.  */
  operator fun set(
    hostname: String,
    addresses: List<InetAddress>,
  ): FakeDns {
    hostAddresses[hostname] = addresses
    return this
  }

  /** Clears the results for `hostname`.  */
  fun clear(hostname: String): FakeDns {
    hostAddresses.remove(hostname)
    return this
  }

   * an IPv4 address or not.
   *
   * <p>IPv6 addresses are <b>coerced</b> to IPv4 addresses before being converted to integers.
   *
   * <p>As long as there are applications that assume that all IP addresses are IPv4 addresses and
   * can therefore be converted safely to integers (for whatever purpose) this function can be used
   * to handle IPv6 addresses as well until the application is suitably fixed.
   *

import okhttp3.Dns.Companion.SYSTEM

/**
 * A domain name service that resolves IP addresses for host names. Most applications will use the
 * [system DNS service][SYSTEM], which is the default. Some applications may provide their own
 * implementation to use a different DNS server, to prefer IPv6 addresses, to prefer IPv4 addresses,
 * or to force a specific known IP address.
 *

        loc.share = this.share;
        loc.dfsReferral = this.dfsReferral;
        loc.unc = this.unc;
        if ( this.addresses != null ) {
            loc.addresses = new UniAddress[this.addresses.length];
            System.arraycopy(this.addresses, 0, loc.addresses, 0, this.addresses.length);
        }
        loc.addressIndex = this.addressIndex;
        loc.type = this.type;
        return loc;
    }

	if l.Address == "" && l.Port == 0 && l.Type == "" {
		return true
	}
	if l.Address != "" {
		addresses := retrieveListenerAdditionalAddresses(listener)
		addresses = append(addresses, retrieveListenerAddress(listener))
		found := false
		for _, address := range addresses {
			if strings.EqualFold(address, l.Address) {
				found = true
			}
		}
		if !found {
			return false
		}
	}

    val result = proxies[nextProxyIndex++]
    resetNextInetSocketAddress(result)
    return result
  }

  /** Prepares the socket addresses to attempt for the current proxy or host. */
  @Throws(IOException::class)
  private fun resetNextInetSocketAddress(proxy: Proxy) {
    // Clear the addresses. Necessary if getAllByName() below throws!
    val mutableInetSocketAddresses = mutableListOf<InetSocketAddress>()

	"github.com/minio/minio/internal/logger"
	xnet "github.com/minio/pkg/v3/net"
)

var (
	// IPv4 addresses of localhost.
	localIP4 = mustGetLocalIP4()

	// IPv6 addresses of localhost.
	localIP6 = mustGetLocalIP6()

	// List of all local loopback addresses.
	localLoopbacks = mustGetLocalLoopbacks()
)

// mustSplitHostPort is a wrapper to net.SplitHostPort() where error is assumed to be a fatal.

They're also concrete: each URL identifies a specific path (like `/square/okhttp`) and query (like `?q=sharks&lang=en`). Each webserver hosts many URLs.

### [Addresses](https://square.github.io/okhttp/4.x/okhttp/okhttp3/-address/)

Addresses specify a webserver (like `github.com`) and all of the **static** configuration necessary to connect to that server: the port number, HTTPS settings, and preferred network protocols (like HTTP/2).