}
	}
	panic("unknown address type on listener")
}

// Addrs - returns all address information of TCP listeners.
func (listener *httpListener) Addrs() (addrs []net.Addr) {
	addrs = make([]net.Addr, 0, len(listener.listeners))
	for i := range listener.listeners {
		addrs = append(addrs, listener.listeners[i].Addr())
	}

	return addrs
}

// TCPOptions specify customizable TCP optimizations on raw socket

                    }
                    final InetAddress[] iaddrs = InetAddress.getAllByName(hostname);
                    final UniAddress[] addrs = new UniAddress[iaddrs.length];
                    for (int ii = 0; ii < iaddrs.length; ii++) {
                        addrs[ii] = new UniAddress(iaddrs[ii]);
                    }
                    return addrs; // Success
                default:

	logger.FatalIf(err, "Unable to get IP addresses of this host")

	for _, interf := range ifs {
		addrs, err := interf.Addrs()
		if err != nil {
			continue
		}
		if runtime.GOOS == "windows" && interf.Flags&net.FlagUp == 0 {
			continue
		}

		for _, addr := range addrs {
			var ip net.IP
			switch v := addr.(type) {
			case *net.IPNet:
				ip = v.IP
			case *net.IPAddr:
				ip = v.IP
			}

        final UniAddress[] addrs = new UniAddress[iaddrs.length];
        for (int ii = 0; ii < iaddrs.length; ii++) {
            addrs[ii] = new UniAddress(iaddrs[ii]);
        }
        return addrs;
    }

    private static UniAddress[] wrapNetbiosAddresses(final NetbiosAddress[] addr) {
        final UniAddress[] addrs = new UniAddress[addr.length];

				t.Fatalf("Test %d: error: expected = <nil>, got = %v", i+1, err)
			}
		}

		addrs := listener.Addrs()
		addrSet := set.NewStringSet()
		for _, addr := range addrs {
			addrSet.Add(addr.String())
		}

		if !addrSet.Equals(testCase.expectedAddrs) {
			t.Fatalf("Test %d: addr: expected = %v, got = %v", i+1, testCase.expectedAddrs, addrs)
		}

		listener.Close()
	}

func (srv *Server) UseTCPOptions(opts TCPOptions) *Server {
	srv.TCPOptions = opts
	return srv
}

// NewServer - creates new HTTP server using given arguments.
func NewServer(addrs []string) *Server {
	httpServer := &Server{
		Addrs: addrs,
	}
	// This is not configurable for now.
	httpServer.MaxHeaderBytes = DefaultMaxHeaderBytes
	return httpServer
}

        } else if (calledName == SMBSERVER_NAME) {
            NbtAddress[] addrs;

            try {
                addrs = CLIENT.getNodeStatus(this);
                if (hostName.hexCode == 0x1D) {
                    for (final NbtAddress addr : addrs) {
                        if (addr.hostName.hexCode == 0x20) {
                            return addr.hostName.name;
                        }
                    }

            final boolean forceSigning) throws IOException {

        final Address[] addrs = tf.getNameServiceClient().getAllByName(name, true);

        if (addrs == null || addrs.length == 0) {
            throw new UnknownHostException(name);
        }

        Arrays.sort(addrs, (o1, o2) -> {
            Integer fail1 = SmbTransportPoolImpl.this.failCounts.get(o1.getHostAddress());

            NetbiosAddress[] addrs;

            try {
                addrs = tc.getNameServiceClient().getNodeStatus(this);
                if (this.getNameType() == 0x1D) {
                    for (final NetbiosAddress addr : addrs) {
                        if (addr.getNameType() == 0x20) {
                            return addr.getHostName();
                        }
                    }

		}).DialContext
	}

	return func(ctx context.Context, network, addr string) (conn net.Conn, err error) {
		host, port, err := net.SplitHostPort(addr)
		if err != nil {
			return nil, err
		}

		if net.ParseIP(host) != nil {
			// For IP only setups there is no need for DNS lookups.
			return baseDialCtx(ctx, "tcp", addr)
		}

		ips, err := lookupHost(ctx, host)
		if err != nil {
			return nil, err