package net

Import Path
	net (on go.dev)

Dependency Relation
	imports 16 packages, and imported by 5 packages

Involved Source Files

	      addrselect.go
	      cgo_stub.go
	      conf.go
	      dial.go
	      dnsclient.go
	      dnsclient_unix.go
	      dnsconfig_unix.go
	      error_posix.go
	      error_unix.go
	      fd_posix.go
	      fd_unix.go
	      file.go
	      file_unix.go
	      hook.go
	      hook_unix.go
	      hosts.go
	      interface.go
	      interface_bsd.go
	      interface_darwin.go
	      ip.go
	      iprawsock.go
	      iprawsock_posix.go
	      ipsock.go
	      ipsock_posix.go
	      lookup.go
	      lookup_unix.go
	      mac.go
	   #d net.go
		Package net provides a portable interface for network I/O, including
		TCP/IP, UDP, domain name resolution, and Unix domain sockets.

		Although the package provides access to low-level networking
		primitives, most clients will need only the basic interface provided
		by the Dial, Listen, and Accept functions and the associated
		Conn and Listener interfaces. The crypto/tls package uses
		the same interfaces and similar Dial and Listen functions.

		The Dial function connects to a server:

		conn, err := net.Dial("tcp", "golang.org:80")
		if err != nil {
			// handle error
		}
		fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n")
		status, err := bufio.NewReader(conn).ReadString('\n')
		// ...

		The Listen function creates servers:

		ln, err := net.Listen("tcp", ":8080")
		if err != nil {
			// handle error
		}
		for {
			conn, err := ln.Accept()
			if err != nil {
				// handle error
			}
			go handleConnection(conn)
		}

		Name Resolution

		The method for resolving domain names, whether indirectly with functions like Dial
		or directly with functions like LookupHost and LookupAddr, varies by operating system.

		On Unix systems, the resolver has two options for resolving names.
		It can use a pure Go resolver that sends DNS requests directly to the servers
		listed in /etc/resolv.conf, or it can use a cgo-based resolver that calls C
		library routines such as getaddrinfo and getnameinfo.

		By default the pure Go resolver is used, because a blocked DNS request consumes
		only a goroutine, while a blocked C call consumes an operating system thread.
		When cgo is available, the cgo-based resolver is used instead under a variety of
		conditions: on systems that do not let programs make direct DNS requests (OS X),
		when the LOCALDOMAIN environment variable is present (even if empty),
		when the RES_OPTIONS or HOSTALIASES environment variable is non-empty,
		when the ASR_CONFIG environment variable is non-empty (OpenBSD only),
		when /etc/resolv.conf or /etc/nsswitch.conf specify the use of features that the
		Go resolver does not implement, and when the name being looked up ends in .local
		or is an mDNS name.

		The resolver decision can be overridden by setting the netdns value of the
		GODEBUG environment variable (see package runtime) to go or cgo, as in:

		export GODEBUG=netdns=go    # force pure Go resolver
		export GODEBUG=netdns=cgo   # force cgo resolver

		The decision can also be forced while building the Go source tree
		by setting the netgo or netcgo build tag.

		A numeric netdns setting, as in GODEBUG=netdns=1, causes the resolver
		to print debugging information about its decisions.
		To force a particular resolver while also printing debugging information,
		join the two settings by a plus sign, as in GODEBUG=netdns=go+1.

		On Plan 9, the resolver always accesses /net/cs and /net/dns.

		On Windows, the resolver always uses C library functions, such as GetAddrInfo and DnsQuery.

	      nss.go
	      parse.go
	      pipe.go
	      port.go
	      port_unix.go
	      rawconn.go
	      sendfile_stub.go
	      sock_bsd.go
	      sock_posix.go
	      sockaddr_posix.go
	      sockopt_bsd.go
	      sockopt_posix.go
	      sockoptip_bsdvar.go
	      sockoptip_posix.go
	      splice_stub.go
	      sys_cloexec.go
	      tcpsock.go
	      tcpsock_posix.go
	      tcpsockopt_darwin.go
	      tcpsockopt_posix.go
	      udpsock.go
	      udpsock_posix.go
	      unixsock.go
	      unixsock_posix.go
	      writev_unix.go
Code Examples

	CIDRMask
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			// This mask corresponds to a /31 subnet for IPv4.
			fmt.Println(net.CIDRMask(31, 32))
		
			// This mask corresponds to a /64 subnet for IPv6.
			fmt.Println(net.CIDRMask(64, 128))
		
		}

	Dialer
		package main
		
		import (
			"context"
			"log"
			"net"
			"time"
		)
		
		func main() {
			var d net.Dialer
			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
			defer cancel()
		
			conn, err := d.DialContext(ctx, "tcp", "localhost:12345")
			if err != nil {
				log.Fatalf("Failed to dial: %v", err)
			}
			defer conn.Close()
		
			if _, err := conn.Write([]byte("Hello, World!")); err != nil {
				log.Fatal(err)
			}
		}

	Dialer_unix
		package main
		
		import (
			"context"
			"log"
			"net"
			"time"
		)
		
		func main() {
			// DialUnix does not take a context.Context parameter. This example shows
			// how to dial a Unix socket with a Context. Note that the Context only
			// applies to the dial operation; it does not apply to the connection once
			// it has been established.
			var d net.Dialer
			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
			defer cancel()
		
			d.LocalAddr = nil // if you have a local addr, add it here
			raddr := net.UnixAddr{Name: "/path/to/unix.sock", Net: "unix"}
			conn, err := d.DialContext(ctx, "unix", raddr.String())
			if err != nil {
				log.Fatalf("Failed to dial: %v", err)
			}
			defer conn.Close()
			if _, err := conn.Write([]byte("Hello, socket!")); err != nil {
				log.Fatal(err)
			}
		}

	IP_DefaultMask
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ip := net.ParseIP("192.0.2.1")
			fmt.Println(ip.DefaultMask())
		
		}

	IP_Mask
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv4Addr := net.ParseIP("192.0.2.1")
			// This mask corresponds to a /24 subnet for IPv4.
			ipv4Mask := net.CIDRMask(24, 32)
			fmt.Println(ipv4Addr.Mask(ipv4Mask))
		
			ipv6Addr := net.ParseIP("2001:db8:a0b:12f0::1")
			// This mask corresponds to a /32 subnet for IPv6.
			ipv6Mask := net.CIDRMask(32, 128)
			fmt.Println(ipv6Addr.Mask(ipv6Mask))
		
		}

	IPv4
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			fmt.Println(net.IPv4(8, 8, 8, 8))
		
		}

	IPv4Mask
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			fmt.Println(net.IPv4Mask(255, 255, 255, 0))
		
		}

	Listener
		package main
		
		import (
			"io"
			"log"
			"net"
		)
		
		func main() {
			// Listen on TCP port 2000 on all available unicast and
			// anycast IP addresses of the local system.
			l, err := net.Listen("tcp", ":2000")
			if err != nil {
				log.Fatal(err)
			}
			defer l.Close()
			for {
				// Wait for a connection.
				conn, err := l.Accept()
				if err != nil {
					log.Fatal(err)
				}
				// Handle the connection in a new goroutine.
				// The loop then returns to accepting, so that
				// multiple connections may be served concurrently.
				go func(c net.Conn) {
					// Echo all incoming data.
					io.Copy(c, c)
					// Shut down the connection.
					c.Close()
				}(conn)
			}
		}

	ParseCIDR
		package main
		
		import (
			"fmt"
			"log"
			"net"
		)
		
		func main() {
			ipv4Addr, ipv4Net, err := net.ParseCIDR("192.0.2.1/24")
			if err != nil {
				log.Fatal(err)
			}
			fmt.Println(ipv4Addr)
			fmt.Println(ipv4Net)
		
			ipv6Addr, ipv6Net, err := net.ParseCIDR("2001:db8:a0b:12f0::1/32")
			if err != nil {
				log.Fatal(err)
			}
			fmt.Println(ipv6Addr)
			fmt.Println(ipv6Net)
		
		}

	ParseIP
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			fmt.Println(net.ParseIP("192.0.2.1"))
			fmt.Println(net.ParseIP("2001:db8::68"))
			fmt.Println(net.ParseIP("192.0.2"))
		
		}

	UDPConn_WriteTo
		package main
		
		import (
			"log"
			"net"
		)
		
		func main() {
			// Unlike Dial, ListenPacket creates a connection without any
			// association with peers.
			conn, err := net.ListenPacket("udp", ":0")
			if err != nil {
				log.Fatal(err)
			}
			defer conn.Close()
		
			dst, err := net.ResolveUDPAddr("udp", "192.0.2.1:2000")
			if err != nil {
				log.Fatal(err)
			}
		
			// The connection can write data to the desired address.
			_, err = conn.WriteTo([]byte("data"), dst)
			if err != nil {
				log.Fatal(err)
			}
		}


Package-Level Type Names (total 72, in which 35 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Addr (interface)
		Addr represents a network end point address.

		The two methods Network and String conventionally return strings
		that can be passed as the arguments to Dial, but the exact form
		and meaning of the strings is up to the implementation.

		Methods (total 2, both are exported)
			( T) Network() string
				// name of the network (for example, "tcp", "udp")

			( T) String() string
				// string form of address (for example, "192.0.2.1:25", "[2001:db8::1]:80")

		Implemented By (at least 8, in which 5 are exported)
			*IPAddr
			*IPNet
			*TCPAddr
			*UDPAddr
			*UnixAddr
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			 fileAddr
			 pipeAddr
			 sockaddr (interface)
		Implements (at least 3, in which 1 are exported)
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least 27, in which 15 are exported)
			func InterfaceAddrs() ([]Addr, error)
			func Conn.LocalAddr() Addr
			func Conn.RemoteAddr() Addr
			func (*Interface).Addrs() ([]Addr, error)
			func (*Interface).MulticastAddrs() ([]Addr, error)
			func (*IPConn).ReadFrom(b []byte) (int, Addr, error)
			func Listener.Addr() Addr
			func PacketConn.LocalAddr() Addr
			func PacketConn.ReadFrom(p []byte) (n int, addr Addr, err error)
			func (*TCPListener).Addr() Addr
			func (*UDPConn).ReadFrom(b []byte) (int, Addr, error)
			func (*UnixConn).ReadFrom(b []byte) (int, Addr, error)
			func (*UnixListener).Addr() Addr
			func crypto/tls.(*Conn).LocalAddr() Addr
			func crypto/tls.(*Conn).RemoteAddr() Addr
			/* 12+ unexporteds ... *//* 12+ unexporteds: */
			func interfaceAddrTable(ifi *Interface) ([]Addr, error)
			func interfaceMulticastAddrTable(ifi *Interface) ([]Addr, error)
			func sockaddrToIP(sa syscall.Sockaddr) Addr
			func sockaddrToTCP(sa syscall.Sockaddr) Addr
			func sockaddrToUDP(sa syscall.Sockaddr) Addr
			func sockaddrToUnix(sa syscall.Sockaddr) Addr
			func sockaddrToUnixgram(sa syscall.Sockaddr) Addr
			func sockaddrToUnixpacket(sa syscall.Sockaddr) Addr
			func (*IPAddr).opAddr() Addr
			func (*TCPAddr).opAddr() Addr
			func (*UDPAddr).opAddr() Addr
			func (*UnixAddr).opAddr() Addr
		As Inputs Of (at least 8, in which 4 are exported)
			func (*IPConn).WriteTo(b []byte, addr Addr) (int, error)
			func PacketConn.WriteTo(p []byte, addr Addr) (n int, err error)
			func (*UDPConn).WriteTo(b []byte, addr Addr) (int, error)
			func (*UnixConn).WriteTo(b []byte, addr Addr) (int, error)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func isIPv4(addr Addr) bool
			func isNotIPv4(addr Addr) bool
			func (*Resolver).resolveAddrList(ctx context.Context, op, network, addr string, hint Addr) (addrList, error)
			func crypto/tls.clientSessionCacheKey(serverAddr Addr, config *tls.Config) string

	 type AddrError (struct)

		Fields (total 2, both are exported)
			Addr string
			Err string
		Methods (total 3, all are exported)
			(*T) Error() string
			(*T) Temporary() bool
			(*T) Timeout() bool
		Implements (at least 5, in which 2 are exported)
			*T : Error
			*T : error
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*T : temporary
			*T : timeout
			*T : os.timeout

	 type Buffers ([]T)
		Buffers contains zero or more runs of bytes to write.

		On certain machines, for certain types of connections, this is
		optimized into an OS-specific batch write operation (such as
		"writev").

		Methods (total 3, in which 2 are exported)
			(*T) Read(p []byte) (n int, err error)
			(*T) WriteTo(w io.Writer) (n int64, err error)
			/* one unexported ... *//* one unexported: */
			(*T) consume(n int64)
		Implements (at least 2, both are exported)
			*T : io.Reader
			*T : io.WriterTo

	 type Conn (interface)
		Conn is a generic stream-oriented network connection.

		Multiple goroutines may invoke methods on a Conn simultaneously.

		Methods (total 8, all are exported)
			( T) Close() error
				Close closes the connection.
				Any blocked Read or Write operations will be unblocked and return errors.

			( T) LocalAddr() Addr
				LocalAddr returns the local network address.

			( T) Read(b []byte) (n int, err error)
				Read reads data from the connection.
				Read can be made to time out and return an error after a fixed
				time limit; see SetDeadline and SetReadDeadline.

			( T) RemoteAddr() Addr
				RemoteAddr returns the remote network address.

			( T) SetDeadline(t time.Time) error
				SetDeadline sets the read and write deadlines associated
				with the connection. It is equivalent to calling both
				SetReadDeadline and SetWriteDeadline.

				A deadline is an absolute time after which I/O operations
				fail instead of blocking. The deadline applies to all future
				and pending I/O, not just the immediately following call to
				Read or Write. After a deadline has been exceeded, the
				connection can be refreshed by setting a deadline in the future.

				If the deadline is exceeded a call to Read or Write or to other
				I/O methods will return an error that wraps os.ErrDeadlineExceeded.
				This can be tested using errors.Is(err, os.ErrDeadlineExceeded).
				The error's Timeout method will return true, but note that there
				are other possible errors for which the Timeout method will
				return true even if the deadline has not been exceeded.

				An idle timeout can be implemented by repeatedly extending
				the deadline after successful Read or Write calls.

				A zero value for t means I/O operations will not time out.

			( T) SetReadDeadline(t time.Time) error
				SetReadDeadline sets the deadline for future Read calls
				and any currently-blocked Read call.
				A zero value for t means Read will not time out.

			( T) SetWriteDeadline(t time.Time) error
				SetWriteDeadline sets the deadline for future Write calls
				and any currently-blocked Write call.
				Even if write times out, it may return n > 0, indicating that
				some of the data was successfully written.
				A zero value for t means Write will not time out.

			( T) Write(b []byte) (n int, err error)
				Write writes data to the connection.
				Write can be made to time out and return an error after a fixed
				time limit; see SetDeadline and SetWriteDeadline.

		Implemented By (at least 7, in which 5 are exported)
			*IPConn
			*TCPConn
			*UDPConn
			*UnixConn
			*crypto/tls.Conn
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*conn
			*pipe
		Implements (at least 7, all are exported)
			 T : io.Closer
			 T : io.ReadCloser
			 T : io.Reader
			 T : io.ReadWriteCloser
			 T : io.ReadWriter
			 T : io.WriteCloser
			 T : io.Writer
		As Outputs Of (at least 14, in which 12 are exported)
			func Dial(network, address string) (Conn, error)
			func DialTimeout(network, address string, timeout time.Duration) (Conn, error)
			func FileConn(f *os.File) (c Conn, err error)
			func Pipe() (Conn, Conn)
			func Pipe() (Conn, Conn)
			func (*Dialer).Dial(network, address string) (Conn, error)
			func (*Dialer).DialContext(ctx context.Context, network, address string) (Conn, error)
			func Listener.Accept() (Conn, error)
			func (*TCPListener).Accept() (Conn, error)
			func (*UnixListener).Accept() (Conn, error)
			func crypto/tls.(*Dialer).Dial(network, addr string) (Conn, error)
			func crypto/tls.(*Dialer).DialContext(ctx context.Context, network, addr string) (Conn, error)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func fileConn(f *os.File) (Conn, error)
			func (*Resolver).dial(ctx context.Context, network, server string) (Conn, error)
		As Inputs Of (at least 10, in which 5 are exported)
			func crypto/tls.Client(conn Conn, config *tls.Config) *tls.Conn
			func crypto/tls.Server(conn Conn, config *tls.Config) *tls.Conn
			func github.com/neo4j/neo4j-go-driver/v4/neo4j/internal/bolt.Connect(serverName string, conn Conn, auth map[string]interface{}, userAgent string, routingContext map[string]string, logger log.Logger, boltLog log.BoltLogger) (db.Connection, error)
			func github.com/neo4j/neo4j-go-driver/v4/neo4j/internal/bolt.NewBolt3(serverName string, conn Conn, log log.Logger, boltLog log.BoltLogger) *bolt.bolt3
			func github.com/neo4j/neo4j-go-driver/v4/neo4j/internal/bolt.NewBolt4(serverName string, conn Conn, log log.Logger, boltLog log.BoltLogger) *bolt.bolt4
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			func dnsPacketRoundTrip(c Conn, id uint16, query dnsmessage.Question, b []byte) (dnsmessage.Parser, dnsmessage.Header, error)
			func dnsStreamRoundTrip(c Conn, id uint16, query dnsmessage.Question, b []byte) (dnsmessage.Parser, dnsmessage.Header, error)
			func crypto/tls.(*Conn).newRecordHeaderError(conn Conn, msg string) (err tls.RecordHeaderError)
			func github.com/neo4j/neo4j-go-driver/v4/neo4j/internal/bolt.dechunkMessage(conn Conn, msgBuf []byte, readTimeout time.Duration, logger log.Logger, logId string) ([]byte, []byte, error)
			func github.com/neo4j/neo4j-go-driver/v4/neo4j/internal/bolt.resetConnectionReadDeadline(conn Conn, readTimeout time.Duration, logger log.Logger, logId string)

	 type Dialer (struct)
		A Dialer contains options for connecting to an address.

		The zero value for each field is equivalent to dialing
		without that option. Dialing with the zero value of Dialer
		is therefore equivalent to just calling the Dial function.

		It is safe to call Dialer's methods concurrently.

		Fields (total 9, all are exported)
			Cancel <-chan struct{}
				Cancel is an optional channel whose closure indicates that
				the dial should be canceled. Not all types of dials support
				cancellation.

				Deprecated: Use DialContext instead.

			Control func(network, address string, c syscall.RawConn) error
				If Control is not nil, it is called after creating the network
				connection but before actually dialing.

				Network and address parameters passed to Control method are not
				necessarily the ones passed to Dial. For example, passing "tcp" to Dial
				will cause the Control function to be called with "tcp4" or "tcp6".

			Deadline time.Time
				Deadline is the absolute point in time after which dials
				will fail. If Timeout is set, it may fail earlier.
				Zero means no deadline, or dependent on the operating system
				as with the Timeout option.

			DualStack bool
				DualStack previously enabled RFC 6555 Fast Fallback
				support, also known as "Happy Eyeballs", in which IPv4 is
				tried soon if IPv6 appears to be misconfigured and
				hanging.

				Deprecated: Fast Fallback is enabled by default. To
				disable, set FallbackDelay to a negative value.

			FallbackDelay time.Duration
				FallbackDelay specifies the length of time to wait before
				spawning a RFC 6555 Fast Fallback connection. That is, this
				is the amount of time to wait for IPv6 to succeed before
				assuming that IPv6 is misconfigured and falling back to
				IPv4.

				If zero, a default delay of 300ms is used.
				A negative value disables Fast Fallback support.

			KeepAlive time.Duration
				KeepAlive specifies the interval between keep-alive
				probes for an active network connection.
				If zero, keep-alive probes are sent with a default value
				(currently 15 seconds), if supported by the protocol and operating
				system. Network protocols or operating systems that do
				not support keep-alives ignore this field.
				If negative, keep-alive probes are disabled.

			LocalAddr Addr
				LocalAddr is the local address to use when dialing an
				address. The address must be of a compatible type for the
				network being dialed.
				If nil, a local address is automatically chosen.

			Resolver *Resolver
				Resolver optionally specifies an alternate resolver to use.

			Timeout time.Duration
				Timeout is the maximum amount of time a dial will wait for
				a connect to complete. If Deadline is also set, it may fail
				earlier.

				The default is no timeout.

				When using TCP and dialing a host name with multiple IP
				addresses, the timeout may be divided between them.

				With or without a timeout, the operating system may impose
				its own earlier timeout. For instance, TCP timeouts are
				often around 3 minutes.

		Methods (total 6, in which 2 are exported)
			(*T) Dial(network, address string) (Conn, error)
				Dial connects to the address on the named network.

				See func Dial for a description of the network and address
				parameters.

			(*T) DialContext(ctx context.Context, network, address string) (Conn, error)
				DialContext connects to the address on the named network using
				the provided context.

				The provided Context must be non-nil. If the context expires before
				the connection is complete, an error is returned. Once successfully
				connected, any expiration of the context will not affect the
				connection.

				When using TCP, and the host in the address parameter resolves to multiple
				network addresses, any dial timeout (from d.Timeout or ctx) is spread
				over each consecutive dial, such that each is given an appropriate
				fraction of the time to connect.
				For example, if a host has 4 IP addresses and the timeout is 1 minute,
				the connect to each single address will be given 15 seconds to complete
				before trying the next one.

				See func Dial for a description of the network and address
				parameters.

			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) deadline(ctx context.Context, now time.Time) (earliest time.Time)
				deadline returns the earliest of:
				  - now+Timeout
				  - d.Deadline
				  - the context's deadline
				Or zero, if none of Timeout, Deadline, or context's deadline is set.

			(*T) dualStack() bool
			(*T) fallbackDelay() time.Duration
			(*T) resolver() *Resolver
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func crypto/tls.(*Dialer).netDialer() *Dialer
		As Inputs Of (at least 2, in which 1 are exported)
			func crypto/tls.DialWithDialer(dialer *Dialer, network, addr string, config *tls.Config) (*tls.Conn, error)
			/* at least one unexported ... *//* at least one unexported: */
			func crypto/tls.dial(ctx context.Context, netDialer *Dialer, network, addr string, config *tls.Config) (*tls.Conn, error)

	 type DNSConfigError (struct)
		DNSConfigError represents an error reading the machine's DNS configuration.
		(No longer used; kept for compatibility.)

		Fields (only one, which is exported)
			Err error
		Methods (total 4, all are exported)
			(*T) Error() string
			(*T) Temporary() bool
			(*T) Timeout() bool
			(*T) Unwrap() error
		Implements (at least 5, in which 2 are exported)
			*T : Error
			*T : error
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*T : temporary
			*T : timeout
			*T : os.timeout

	 type DNSError (struct)
		DNSError represents a DNS lookup error.

		Fields (total 6, all are exported)
			Err string
				// description of the error

			IsNotFound bool
				// if true, host could not be found

			IsTemporary bool
				// if true, error is temporary; not all errors set this

			IsTimeout bool
				// if true, timed out; not all timeouts set this

			Name string
				// name looked for

			Server string
				// server used

		Methods (total 3, all are exported)
			(*T) Error() string
			(*T) Temporary() bool
				Temporary reports whether the DNS error is known to be temporary.
				This is not always known; a DNS lookup may fail due to a temporary
				error and return a DNSError for which Temporary returns false.

			(*T) Timeout() bool
				Timeout reports whether the DNS lookup is known to have timed out.
				This is not always known; a DNS lookup may fail due to a timeout
				and return a DNSError for which Timeout returns false.

		Implements (at least 5, in which 2 are exported)
			*T : Error
			*T : error
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*T : temporary
			*T : timeout
			*T : os.timeout

	 type Error (interface)
		An Error represents a network error.

		Methods (total 3, all are exported)
			( T) Error() builtin.string
			( T) Temporary() bool
				// Is the error temporary?

			( T) Timeout() bool
				// Is the error a timeout?

		Implemented By (at least 14, in which 9 are exported)
			*AddrError
			*DNSConfigError
			*DNSError
			 InvalidAddrError
			*OpError
			 UnknownNetworkError
			*net/url.Error
			*internal/poll.DeadlineExceededError
			 syscall.Errno
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			 addrinfoErrno
			*timeoutError
			 context.deadlineExceededError
			*crypto/tls.permanentError
			 crypto/tls.timeoutError
		Implements (at least 4, in which 1 are exported)
			 T : error
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			 T : temporary
			 T : timeout
			 T : os.timeout

	 type Flags uint (basic type)

		Methods (only one, which is exported)
			( T) String() string
		Implements (at least 3, in which 1 are exported)
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func linkFlags(rawFlags int) Flags
		As Types Of (total 5, all are exported)
			const FlagBroadcast
			const FlagLoopback
			const FlagMulticast
			const FlagPointToPoint
			const FlagUp

	 type HardwareAddr ([]T)
		A HardwareAddr represents a physical hardware address.

		Methods (only one, which is exported)
			( T) String() string
		Implements (at least 3, in which 1 are exported)
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least one exported)
			func ParseMAC(s string) (hw HardwareAddr, err error)

	 type Interface (struct)
		Interface represents a mapping between network interface name
		and index. It also represents network interface facility
		information.

		Fields (total 5, all are exported)
			Flags Flags
				// e.g., FlagUp, FlagLoopback, FlagMulticast

			HardwareAddr HardwareAddr
				// IEEE MAC-48, EUI-48 and EUI-64 form

			Index int
				// positive integer that starts at one, zero is never used

			MTU int
				// maximum transmission unit

			Name string
				// e.g., "en0", "lo0", "eth0.100"

		Methods (total 2, both are exported)
			(*T) Addrs() ([]Addr, error)
				Addrs returns a list of unicast interface addresses for a specific
				interface.

			(*T) MulticastAddrs() ([]Addr, error)
				MulticastAddrs returns a list of multicast, joined group addresses
				for a specific interface.

		As Outputs Of (at least 6, in which 3 are exported)
			func InterfaceByIndex(index int) (*Interface, error)
			func InterfaceByName(name string) (*Interface, error)
			func Interfaces() ([]Interface, error)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func interfaceByIndex(ift []Interface, index int) (*Interface, error)
			func interfaceTable(ifindex int) ([]Interface, error)
			func ipv4AddrToInterface(ip IP) (*Interface, error)
		As Inputs Of (at least 12, in which 1 are exported)
			func ListenMulticastUDP(network string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error)
			/* 11+ unexporteds ... *//* 11+ unexporteds: */
			func interfaceAddrTable(ifi *Interface) ([]Addr, error)
			func interfaceByIndex(ift []Interface, index int) (*Interface, error)
			func interfaceMulticastAddrTable(ifi *Interface) ([]Addr, error)
			func interfaceToIPv4Addr(ifi *Interface) (IP, error)
			func joinIPv4Group(fd *netFD, ifi *Interface, ip IP) error
			func joinIPv6Group(fd *netFD, ifi *Interface, ip IP) error
			func listenIPv4MulticastUDP(c *UDPConn, ifi *Interface, ip IP) error
			func listenIPv6MulticastUDP(c *UDPConn, ifi *Interface, ip IP) error
			func setIPv4MreqToInterface(mreq *syscall.IPMreq, ifi *Interface) error
			func setIPv4MulticastInterface(fd *netFD, ifi *Interface) error
			func setIPv6MulticastInterface(fd *netFD, ifi *Interface) error

	 type InvalidAddrError string (basic type)

		Methods (total 3, all are exported)
			( T) Error() string
			( T) Temporary() bool
			( T) Timeout() bool
		Implements (at least 5, in which 2 are exported)
			 T : Error
			 T : error
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			 T : temporary
			 T : timeout
			 T : os.timeout

	 type IP ([]T)
		An IP is a single IP address, a slice of bytes.
		Functions in this package accept either 4-byte (IPv4)
		or 16-byte (IPv6) slices as input.

		Note that in this documentation, referring to an
		IP address as an IPv4 address or an IPv6 address
		is a semantic property of the address, not just the
		length of the byte slice: a 16-byte slice can still
		be an IPv4 address.

		Methods (total 16, in which 15 are exported)
			( T) DefaultMask() IPMask
				DefaultMask returns the default IP mask for the IP address ip.
				Only IPv4 addresses have default masks; DefaultMask returns
				nil if ip is not a valid IPv4 address.

			( T) Equal(x IP) bool
				Equal reports whether ip and x are the same IP address.
				An IPv4 address and that same address in IPv6 form are
				considered to be equal.

			( T) IsGlobalUnicast() bool
				IsGlobalUnicast reports whether ip is a global unicast
				address.

				The identification of global unicast addresses uses address type
				identification as defined in RFC 1122, RFC 4632 and RFC 4291 with
				the exception of IPv4 directed broadcast addresses.
				It returns true even if ip is in IPv4 private address space or
				local IPv6 unicast address space.

			( T) IsInterfaceLocalMulticast() bool
				IsInterfaceLocalMulticast reports whether ip is
				an interface-local multicast address.

			( T) IsLinkLocalMulticast() bool
				IsLinkLocalMulticast reports whether ip is a link-local
				multicast address.

			( T) IsLinkLocalUnicast() bool
				IsLinkLocalUnicast reports whether ip is a link-local
				unicast address.

			( T) IsLoopback() bool
				IsLoopback reports whether ip is a loopback address.

			( T) IsMulticast() bool
				IsMulticast reports whether ip is a multicast address.

			( T) IsUnspecified() bool
				IsUnspecified reports whether ip is an unspecified address, either
				the IPv4 address "0.0.0.0" or the IPv6 address "::".

			( T) MarshalText() ([]byte, error)
				MarshalText implements the encoding.TextMarshaler interface.
				The encoding is the same as returned by String, with one exception:
				When len(ip) is zero, it returns an empty slice.

			( T) Mask(mask IPMask) IP
				Mask returns the result of masking the IP address ip with mask.

			( T) String() string
				String returns the string form of the IP address ip.
				It returns one of 4 forms:
				  - "<nil>", if ip has length 0
				  - dotted decimal ("192.0.2.1"), if ip is an IPv4 or IP4-mapped IPv6 address
				  - IPv6 ("2001:db8::1"), if ip is a valid IPv6 address
				  - the hexadecimal form of ip, without punctuation, if no other cases apply

			( T) To16() IP
				To16 converts the IP address ip to a 16-byte representation.
				If ip is not an IP address (it is the wrong length), To16 returns nil.

			( T) To4() IP
				To4 converts the IPv4 address ip to a 4-byte representation.
				If ip is not an IPv4 address, To4 returns nil.

			(*T) UnmarshalText(text []byte) error
				UnmarshalText implements the encoding.TextUnmarshaler interface.
				The IP address is expected in a form accepted by ParseIP.

			/* one unexported ... *//* one unexported: */
			( T) matchAddrFamily(x IP) bool
		Implements (at least 5, in which 3 are exported)
			 T : encoding.TextMarshaler
			*T : encoding.TextUnmarshaler
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least 17, in which 8 are exported)
			func IPv4(a, b, c, d byte) IP
			func LookupIP(host string) ([]IP, error)
			func ParseCIDR(s string) (IP, *IPNet, error)
			func ParseIP(s string) IP
			func IP.Mask(mask IPMask) IP
			func IP.To16() IP
			func IP.To4() IP
			func (*Resolver).LookupIP(ctx context.Context, network, host string) ([]IP, error)
			/* 9+ unexporteds ... *//* 9+ unexporteds: */
			func interfaceToIPv4Addr(ifi *Interface) (IP, error)
			func loopbackIP(net string) IP
			func networkNumberAndMask(n *IPNet) (ip IP, m IPMask)
			func parseIPv4(s string) IP
			func parseIPv6(s string) (ip IP)
			func parseIPv6Zone(s string) (IP, string)
			func parseIPZone(s string) (IP, string)
			func srcAddrs(addrs []IPAddr) []IP
			func crypto/x509.parseSANExtension(value []byte) (dnsNames, emailAddresses []string, ipAddresses []IP, uris []*url.URL, err error)
		As Inputs Of (at least 17, in which 2 are exported)
			func IP.Equal(x IP) bool
			func (*IPNet).Contains(ip IP) bool
			/* 15+ unexporteds ... *//* 15+ unexporteds: */
			func classifyScope(ip IP) scope
			func commonPrefixLen(a, b IP) (cpl int)
			func ipAttrOf(ip IP) ipAttr
			func ipEmptyString(ip IP) string
			func ipToSockaddr(family int, ip IP, port int, zone string) (syscall.Sockaddr, error)
			func ipv4AddrToInterface(ip IP) (*Interface, error)
			func isZeros(p IP) bool
			func joinIPv4Group(fd *netFD, ifi *Interface, ip IP) error
			func joinIPv6Group(fd *netFD, ifi *Interface, ip IP) error
			func listenIPv4MulticastUDP(c *UDPConn, ifi *Interface, ip IP) error
			func listenIPv6MulticastUDP(c *UDPConn, ifi *Interface, ip IP) error
			func sortByRFC6724withSrcs(addrs []IPAddr, srcs []IP)
			func IP.matchAddrFamily(x IP) bool
			func crypto/x509.marshalSANs(dnsNames, emailAddresses []string, ipAddresses []IP, uris []*url.URL) (derBytes []byte, err error)
			func crypto/x509.matchIPConstraint(ip IP, constraint *IPNet) (bool, error)
		As Types Of (total 10, all are exported)
			  var IPv4allrouter
			  var IPv4allsys
			  var IPv4bcast
			  var IPv4zero
			  var IPv6interfacelocalallnodes
			  var IPv6linklocalallnodes
			  var IPv6linklocalallrouters
			  var IPv6loopback
			  var IPv6unspecified
			  var IPv6zero

	 type IPAddr (struct)
		IPAddr represents the address of an IP end point.

		Fields (total 2, both are exported)
			IP IP
			Zone string
				// IPv6 scoped addressing zone

		Methods (total 7, in which 2 are exported)
			(*T) Network() string
				Network returns the address's network name, "ip".

			(*T) String() string
			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*T) family() int
			(*T) isWildcard() bool
			(*T) opAddr() Addr
			(*T) sockaddr(family int) (syscall.Sockaddr, error)
			(*T) toLocal(net string) sockaddr
		Implements (at least 5, in which 2 are exported)
			*T : Addr
			*T : fmt.Stringer
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*T : sockaddr
			*T : context.stringer
			*T : runtime.stringer
		As Outputs Of (at least 13, in which 4 are exported)
			func ResolveIPAddr(network, address string) (*IPAddr, error)
			func (*IPConn).ReadFromIP(b []byte) (int, *IPAddr, error)
			func (*IPConn).ReadMsgIP(b, oob []byte) (n, oobn, flags int, addr *IPAddr, err error)
			func (*Resolver).LookupIPAddr(ctx context.Context, host string) ([]IPAddr, error)
			/* 9+ unexporteds ... *//* 9+ unexporteds: */
			func cgoLookupIP(ctx context.Context, network, name string) (addrs []IPAddr, err error, completed bool)
			func goLookupIPFiles(name string) (addrs []IPAddr)
			func lookupIPReturn(addrsi interface{}, err error, shared bool) ([]IPAddr, error)
			func (*IPConn).readFrom(b []byte) (int, *IPAddr, error)
			func (*IPConn).readMsg(b, oob []byte) (n, oobn, flags int, addr *IPAddr, err error)
			func (*Resolver).goLookupIP(ctx context.Context, host string) (addrs []IPAddr, err error)
			func (*Resolver).goLookupIPCNAMEOrder(ctx context.Context, name string, order hostLookupOrder) (addrs []IPAddr, cname dnsmessage.Name, err error)
			func (*Resolver).lookupIP(ctx context.Context, network, host string) (addrs []IPAddr, err error)
			func (*Resolver).lookupIPAddr(ctx context.Context, network, host string) ([]IPAddr, error)
		As Inputs Of (at least 13, in which 4 are exported)
			func DialIP(network string, laddr, raddr *IPAddr) (*IPConn, error)
			func ListenIP(network string, laddr *IPAddr) (*IPConn, error)
			func (*IPConn).WriteMsgIP(b, oob []byte, addr *IPAddr) (n, oobn int, err error)
			func (*IPConn).WriteToIP(b []byte, addr *IPAddr) (int, error)
			/* 9+ unexporteds ... *//* 9+ unexporteds: */
			func filterAddrList(filter func(IPAddr) bool, ips []IPAddr, inetaddr func(IPAddr) Addr, originalAddr string) (addrList, error)
			func ipAddrsEface(addrs []IPAddr) []interface{}
			func ipv4only(addr IPAddr) bool
			func ipv6only(addr IPAddr) bool
			func sortByRFC6724(addrs []IPAddr)
			func sortByRFC6724withSrcs(addrs []IPAddr, srcs []IP)
			func srcAddrs(addrs []IPAddr) []IP
			func (*IPConn).writeMsg(b, oob []byte, addr *IPAddr) (n, oobn int, err error)
			func (*IPConn).writeTo(b []byte, addr *IPAddr) (int, error)

	 type IPConn (struct)
		IPConn is the implementation of the Conn and PacketConn interfaces
		for IP network connections.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			conn conn
			conn.fd *netFD
		Methods (total 24, in which 18 are exported)
			(*T) Close() error
				Close closes the connection.

			(*T) File() (f *os.File, err error)
				File returns a copy of the underlying os.File.
				It is the caller's responsibility to close f when finished.
				Closing c does not affect f, and closing f does not affect c.

				The returned os.File's file descriptor is different from the connection's.
				Attempting to change properties of the original using this duplicate
				may or may not have the desired effect.

			(*T) LocalAddr() Addr
				LocalAddr returns the local network address.
				The Addr returned is shared by all invocations of LocalAddr, so
				do not modify it.

			(*T) Read(b []byte) (int, error)
				Read implements the Conn Read method.

			(*T) ReadFrom(b []byte) (int, Addr, error)
				ReadFrom implements the PacketConn ReadFrom method.

			(*T) ReadFromIP(b []byte) (int, *IPAddr, error)
				ReadFromIP acts like ReadFrom but returns an IPAddr.

			(*T) ReadMsgIP(b, oob []byte) (n, oobn, flags int, addr *IPAddr, err error)
				ReadMsgIP reads a message from c, copying the payload into b and
				the associated out-of-band data into oob. It returns the number of
				bytes copied into b, the number of bytes copied into oob, the flags
				that were set on the message and the source address of the message.

				The packages golang.org/x/net/ipv4 and golang.org/x/net/ipv6 can be
				used to manipulate IP-level socket options in oob.

			(*T) RemoteAddr() Addr
				RemoteAddr returns the remote network address.
				The Addr returned is shared by all invocations of RemoteAddr, so
				do not modify it.

			(*T) SetDeadline(t time.Time) error
				SetDeadline implements the Conn SetDeadline method.

			(*T) SetReadBuffer(bytes int) error
				SetReadBuffer sets the size of the operating system's
				receive buffer associated with the connection.

			(*T) SetReadDeadline(t time.Time) error
				SetReadDeadline implements the Conn SetReadDeadline method.

			(*T) SetWriteBuffer(bytes int) error
				SetWriteBuffer sets the size of the operating system's
				transmit buffer associated with the connection.

			(*T) SetWriteDeadline(t time.Time) error
				SetWriteDeadline implements the Conn SetWriteDeadline method.

			(*T) SyscallConn() (syscall.RawConn, error)
				SyscallConn returns a raw network connection.
				This implements the syscall.Conn interface.

			(*T) Write(b []byte) (int, error)
				Write implements the Conn Write method.

			(*T) WriteMsgIP(b, oob []byte, addr *IPAddr) (n, oobn int, err error)
				WriteMsgIP writes a message to addr via c, copying the payload from
				b and the associated out-of-band data from oob. It returns the
				number of payload and out-of-band bytes written.

				The packages golang.org/x/net/ipv4 and golang.org/x/net/ipv6 can be
				used to manipulate IP-level socket options in oob.

			(*T) WriteTo(b []byte, addr Addr) (int, error)
				WriteTo implements the PacketConn WriteTo method.

			(*T) WriteToIP(b []byte, addr *IPAddr) (int, error)
				WriteToIP acts like WriteTo but takes an IPAddr.

			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*T) ok() bool
			(*T) readFrom(b []byte) (int, *IPAddr, error)
			(*T) readMsg(b, oob []byte) (n, oobn, flags int, addr *IPAddr, err error)
			(*T) writeBuffers(v *Buffers) (int64, error)
			(*T) writeMsg(b, oob []byte, addr *IPAddr) (n, oobn int, err error)
			(*T) writeTo(b []byte, addr *IPAddr) (int, error)
		Implements (at least 11, in which 10 are exported)
			*T : Conn
			*T : PacketConn
			*T : io.Closer
			*T : io.ReadCloser
			*T : io.Reader
			*T : io.ReadWriteCloser
			*T : io.ReadWriter
			*T : io.WriteCloser
			*T : io.Writer
			*T : syscall.Conn
			/* at least one unexported ... *//* at least one unexported: */
			*T : buffersWriter
		As Outputs Of (at least 3, in which 2 are exported)
			func DialIP(network string, laddr, raddr *IPAddr) (*IPConn, error)
			func ListenIP(network string, laddr *IPAddr) (*IPConn, error)
			/* at least one unexported ... *//* at least one unexported: */
			func newIPConn(fd *netFD) *IPConn

	 type IPMask ([]T)
		An IPMask is a bitmask that can be used to manipulate
		IP addresses for IP addressing and routing.

		See type IPNet and func ParseCIDR for details.

		Methods (total 2, both are exported)
			( T) Size() (ones, bits int)
				Size returns the number of leading ones and total bits in the mask.
				If the mask is not in the canonical form--ones followed by zeros--then
				Size returns 0, 0.

			( T) String() string
				String returns the hexadecimal form of m, with no punctuation.

		Implements (at least 3, in which 1 are exported)
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least 4, in which 3 are exported)
			func CIDRMask(ones, bits int) IPMask
			func IPv4Mask(a, b, c, d byte) IPMask
			func IP.DefaultMask() IPMask
			/* at least one unexported ... *//* at least one unexported: */
			func networkNumberAndMask(n *IPNet) (ip IP, m IPMask)
		As Inputs Of (at least 2, in which 1 are exported)
			func IP.Mask(mask IPMask) IP
			/* at least one unexported ... *//* at least one unexported: */
			func simpleMaskLength(mask IPMask) int
		As Types Of (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			  var classAMask
			  var classBMask
			  var classCMask

	 type IPNet (struct)
		An IPNet represents an IP network.

		Fields (total 2, both are exported)
			IP IP
				// network number

			Mask IPMask
				// network mask

		Methods (total 3, all are exported)
			(*T) Contains(ip IP) bool
				Contains reports whether the network includes ip.

			(*T) Network() string
				Network returns the address's network name, "ip+net".

			(*T) String() string
				String returns the CIDR notation of n like "192.0.2.0/24"
				or "2001:db8::/48" as defined in RFC 4632 and RFC 4291.
				If the mask is not in the canonical form, it returns the
				string which consists of an IP address, followed by a slash
				character and a mask expressed as hexadecimal form with no
				punctuation like "198.51.100.0/c000ff00".

		Implements (at least 4, in which 2 are exported)
			*T : Addr
			*T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*T : context.stringer
			*T : runtime.stringer
		As Outputs Of (at least 2, in which 1 are exported)
			func ParseCIDR(s string) (IP, *IPNet, error)
			/* at least one unexported ... *//* at least one unexported: */
			func mustCIDR(s string) *IPNet
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func networkNumberAndMask(n *IPNet) (ip IP, m IPMask)
			func crypto/x509.matchIPConstraint(ip IP, constraint *IPNet) (bool, error)

	 type ListenConfig (struct)
		ListenConfig contains options for listening to an address.

		Fields (total 2, both are exported)
			Control func(network, address string, c syscall.RawConn) error
				If Control is not nil, it is called after creating the network
				connection but before binding it to the operating system.

				Network and address parameters passed to Control method are not
				necessarily the ones passed to Listen. For example, passing "tcp" to
				Listen will cause the Control function to be called with "tcp4" or "tcp6".

			KeepAlive time.Duration
				KeepAlive specifies the keep-alive period for network
				connections accepted by this listener.
				If zero, keep-alives are enabled if supported by the protocol
				and operating system. Network protocols or operating systems
				that do not support keep-alives ignore this field.
				If negative, keep-alives are disabled.

		Methods (total 2, both are exported)
			(*T) Listen(ctx context.Context, network, address string) (Listener, error)
				Listen announces on the local network address.

				See func Listen for a description of the network and address
				parameters.

			(*T) ListenPacket(ctx context.Context, network, address string) (PacketConn, error)
				ListenPacket announces on the local network address.

				See func ListenPacket for a description of the network and address
				parameters.


	 type Listener (interface)
		A Listener is a generic network listener for stream-oriented protocols.

		Multiple goroutines may invoke methods on a Listener simultaneously.

		Methods (total 3, all are exported)
			( T) Accept() (Conn, error)
				Accept waits for and returns the next connection to the listener.

			( T) Addr() Addr
				Addr returns the listener's network address.

			( T) Close() error
				Close closes the listener.
				Any blocked Accept operations will be unblocked and return errors.

		Implemented By (at least 3, in which 2 are exported)
			*TCPListener
			*UnixListener
			/* at least one unexported ... *//* at least one unexported: */
			*crypto/tls.listener
		Implements (at least one exported)
			 T : io.Closer
		As Outputs Of (at least 6, in which 5 are exported)
			func FileListener(f *os.File) (ln Listener, err error)
			func Listen(network, address string) (Listener, error)
			func (*ListenConfig).Listen(ctx context.Context, network, address string) (Listener, error)
			func crypto/tls.Listen(network, laddr string, config *tls.Config) (Listener, error)
			func crypto/tls.NewListener(inner Listener, config *tls.Config) Listener
			/* at least one unexported ... *//* at least one unexported: */
			func fileListener(f *os.File) (Listener, error)
		As Inputs Of (at least one exported)
			func crypto/tls.NewListener(inner Listener, config *tls.Config) Listener

	 type MX (struct)
		An MX represents a single DNS MX record.

		Fields (total 2, both are exported)
			Host string
			Pref uint16
		As Outputs Of (at least 3, in which 2 are exported)
			func LookupMX(name string) ([]*MX, error)
			func (*Resolver).LookupMX(ctx context.Context, name string) ([]*MX, error)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Resolver).lookupMX(ctx context.Context, name string) ([]*MX, error)

	 type NS (struct)
		An NS represents a single DNS NS record.

		Fields (only one, which is exported)
			Host string
		As Outputs Of (at least 3, in which 2 are exported)
			func LookupNS(name string) ([]*NS, error)
			func (*Resolver).LookupNS(ctx context.Context, name string) ([]*NS, error)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Resolver).lookupNS(ctx context.Context, name string) ([]*NS, error)

	 type OpError (struct)
		OpError is the error type usually returned by functions in the net
		package. It describes the operation, network type, and address of
		an error.

		Fields (total 5, all are exported)
			Addr Addr
				Addr is the network address for which this error occurred.
				For local operations, like Listen or SetDeadline, Addr is
				the address of the local endpoint being manipulated.
				For operations involving a remote network connection, like
				Dial, Read, or Write, Addr is the remote address of that
				connection.

			Err error
				Err is the error that occurred during the operation.
				The Error method panics if the error is nil.

			Net string
				Net is the network type on which this error occurred,
				such as "tcp" or "udp6".

			Op string
				Op is the operation which caused the error, such as
				"read" or "write".

			Source Addr
				For operations involving a remote network connection, like
				Dial, Read, or Write, Source is the corresponding local
				network address.

		Methods (total 4, all are exported)
			(*T) Error() string
			(*T) Temporary() bool
			(*T) Timeout() bool
			(*T) Unwrap() error
		Implements (at least 5, in which 2 are exported)
			*T : Error
			*T : error
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*T : temporary
			*T : timeout
			*T : os.timeout

	 type PacketConn (interface)
		PacketConn is a generic packet-oriented network connection.

		Multiple goroutines may invoke methods on a PacketConn simultaneously.

		Methods (total 7, all are exported)
			( T) Close() error
				Close closes the connection.
				Any blocked ReadFrom or WriteTo operations will be unblocked and return errors.

			( T) LocalAddr() Addr
				LocalAddr returns the local network address.

			( T) ReadFrom(p []byte) (n int, addr Addr, err error)
				ReadFrom reads a packet from the connection,
				copying the payload into p. It returns the number of
				bytes copied into p and the return address that
				was on the packet.
				It returns the number of bytes read (0 <= n <= len(p))
				and any error encountered. Callers should always process
				the n > 0 bytes returned before considering the error err.
				ReadFrom can be made to time out and return an error after a
				fixed time limit; see SetDeadline and SetReadDeadline.

			( T) SetDeadline(t time.Time) error
				SetDeadline sets the read and write deadlines associated
				with the connection. It is equivalent to calling both
				SetReadDeadline and SetWriteDeadline.

				A deadline is an absolute time after which I/O operations
				fail instead of blocking. The deadline applies to all future
				and pending I/O, not just the immediately following call to
				Read or Write. After a deadline has been exceeded, the
				connection can be refreshed by setting a deadline in the future.

				If the deadline is exceeded a call to Read or Write or to other
				I/O methods will return an error that wraps os.ErrDeadlineExceeded.
				This can be tested using errors.Is(err, os.ErrDeadlineExceeded).
				The error's Timeout method will return true, but note that there
				are other possible errors for which the Timeout method will
				return true even if the deadline has not been exceeded.

				An idle timeout can be implemented by repeatedly extending
				the deadline after successful ReadFrom or WriteTo calls.

				A zero value for t means I/O operations will not time out.

			( T) SetReadDeadline(t time.Time) error
				SetReadDeadline sets the deadline for future ReadFrom calls
				and any currently-blocked ReadFrom call.
				A zero value for t means ReadFrom will not time out.

			( T) SetWriteDeadline(t time.Time) error
				SetWriteDeadline sets the deadline for future WriteTo calls
				and any currently-blocked WriteTo call.
				Even if write times out, it may return n > 0, indicating that
				some of the data was successfully written.
				A zero value for t means WriteTo will not time out.

			( T) WriteTo(p []byte, addr Addr) (n int, err error)
				WriteTo writes a packet with payload p to addr.
				WriteTo can be made to time out and return an Error after a
				fixed time limit; see SetDeadline and SetWriteDeadline.
				On packet-oriented connections, write timeouts are rare.

		Implemented By (at least 3, all are exported)
			*IPConn
			*UDPConn
			*UnixConn
		Implements (at least one exported)
			 T : io.Closer
		As Outputs Of (at least 4, in which 3 are exported)
			func FilePacketConn(f *os.File) (c PacketConn, err error)
			func ListenPacket(network, address string) (PacketConn, error)
			func (*ListenConfig).ListenPacket(ctx context.Context, network, address string) (PacketConn, error)
			/* at least one unexported ... *//* at least one unexported: */
			func filePacketConn(f *os.File) (PacketConn, error)

	 type ParseError (struct)
		A ParseError is the error type of literal network address parsers.

		Fields (total 2, both are exported)
			Text string
				Text is the malformed text string.

			Type string
				Type is the type of string that was expected, such as
				"IP address", "CIDR address".

		Methods (only one, which is exported)
			(*T) Error() string
		Implements (at least one exported)
			*T : error

	 type Resolver (struct)
		A Resolver looks up names and numbers.

		A nil *Resolver is equivalent to a zero Resolver.

		Fields (total 4, in which 3 are exported)
			Dial func(ctx context.Context, network, address string) (Conn, error)
				Dial optionally specifies an alternate dialer for use by
				Go's built-in DNS resolver to make TCP and UDP connections
				to DNS services. The host in the address parameter will
				always be a literal IP address and not a host name, and the
				port in the address parameter will be a literal port number
				and not a service name.
				If the Conn returned is also a PacketConn, sent and received DNS
				messages must adhere to RFC 1035 section 4.2.1, "UDP usage".
				Otherwise, DNS messages transmitted over Conn must adhere
				to RFC 7766 section 5, "Transport Protocol Selection".
				If nil, the default dialer is used.

			PreferGo bool
				PreferGo controls whether Go's built-in DNS resolver is preferred
				on platforms where it's available. It is equivalent to setting
				GODEBUG=netdns=go, but scoped to just this resolver.

			StrictErrors bool
				StrictErrors controls the behavior of temporary errors
				(including timeout, socket errors, and SERVFAIL) when using
				Go's built-in resolver. For a query composed of multiple
				sub-queries (such as an A+AAAA address lookup, or walking the
				DNS search list), this option causes such errors to abort the
				whole query instead of returning a partial result. This is
				not enabled by default because it may affect compatibility
				with resolvers that process AAAA queries incorrectly.

			/* one unexported ... *//* one unexported: */
			lookupGroup singleflight.Group
				lookupGroup merges LookupIPAddr calls together for lookups for the same
				host. The lookupGroup key is the LookupIPAddr.host argument.
				The return values are ([]IPAddr, error).

		Methods (total 35, in which 10 are exported)
			(*T) LookupAddr(ctx context.Context, addr string) ([]string, error)
				LookupAddr performs a reverse lookup for the given address, returning a list
				of names mapping to that address.

				The returned names are validated to be properly formatted presentation-format
				domain names.

			(*T) LookupCNAME(ctx context.Context, host string) (string, error)
				LookupCNAME returns the canonical name for the given host.
				Callers that do not care about the canonical name can call
				LookupHost or LookupIP directly; both take care of resolving
				the canonical name as part of the lookup.

				A canonical name is the final name after following zero
				or more CNAME records.
				LookupCNAME does not return an error if host does not
				contain DNS "CNAME" records, as long as host resolves to
				address records.

				The returned canonical name is validated to be a properly
				formatted presentation-format domain name.

			(*T) LookupHost(ctx context.Context, host string) (addrs []string, err error)
				LookupHost looks up the given host using the local resolver.
				It returns a slice of that host's addresses.

			(*T) LookupIP(ctx context.Context, network, host string) ([]IP, error)
				LookupIP looks up host for the given network using the local resolver.
				It returns a slice of that host's IP addresses of the type specified by
				network.
				network must be one of "ip", "ip4" or "ip6".

			(*T) LookupIPAddr(ctx context.Context, host string) ([]IPAddr, error)
				LookupIPAddr looks up host using the local resolver.
				It returns a slice of that host's IPv4 and IPv6 addresses.

			(*T) LookupMX(ctx context.Context, name string) ([]*MX, error)
				LookupMX returns the DNS MX records for the given domain name sorted by preference.

				The returned mail server names are validated to be properly
				formatted presentation-format domain names.

			(*T) LookupNS(ctx context.Context, name string) ([]*NS, error)
				LookupNS returns the DNS NS records for the given domain name.

				The returned name server names are validated to be properly
				formatted presentation-format domain names.

			(*T) LookupPort(ctx context.Context, network, service string) (port int, err error)
				LookupPort looks up the port for the given network and service.

			(*T) LookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error)
				LookupSRV tries to resolve an SRV query of the given service,
				protocol, and domain name. The proto is "tcp" or "udp".
				The returned records are sorted by priority and randomized
				by weight within a priority.

				LookupSRV constructs the DNS name to look up following RFC 2782.
				That is, it looks up _service._proto.name. To accommodate services
				publishing SRV records under non-standard names, if both service
				and proto are empty strings, LookupSRV looks up name directly.

				The returned service names are validated to be properly
				formatted presentation-format domain names.

			(*T) LookupTXT(ctx context.Context, name string) ([]string, error)
				LookupTXT returns the DNS TXT records for the given domain name.

			/* 25 unexporteds ... *//* 25 unexporteds: */
			(*T) dial(ctx context.Context, network, server string) (Conn, error)
			(*T) exchange(ctx context.Context, server string, q dnsmessage.Question, timeout time.Duration, useTCP bool) (dnsmessage.Parser, dnsmessage.Header, error)
				exchange sends a query on the connection and hopes for a response.

			(*T) getLookupGroup() *singleflight.Group
			(*T) goLookupCNAME(ctx context.Context, host string) (string, error)
				goLookupCNAME is the native Go (non-cgo) implementation of LookupCNAME.

			(*T) goLookupHost(ctx context.Context, name string) (addrs []string, err error)
				goLookupHost is the native Go implementation of LookupHost.
				Used only if cgoLookupHost refuses to handle the request
				(that is, only if cgoLookupHost is the stub in cgo_stub.go).
				Normally we let cgo use the C library resolver instead of
				depending on our lookup code, so that Go and C get the same
				answers.

			(*T) goLookupHostOrder(ctx context.Context, name string, order hostLookupOrder) (addrs []string, err error)
			(*T) goLookupIP(ctx context.Context, host string) (addrs []IPAddr, err error)
				goLookupIP is the native Go implementation of LookupIP.
				The libc versions are in cgo_*.go.

			(*T) goLookupIPCNAMEOrder(ctx context.Context, name string, order hostLookupOrder) (addrs []IPAddr, cname dnsmessage.Name, err error)
			(*T) goLookupPTR(ctx context.Context, addr string) ([]string, error)
				goLookupPTR is the native Go implementation of LookupAddr.
				Used only if cgoLookupPTR refuses to handle the request (that is,
				only if cgoLookupPTR is the stub in cgo_stub.go).
				Normally we let cgo use the C library resolver instead of depending
				on our lookup code, so that Go and C get the same answers.

			(*T) internetAddrList(ctx context.Context, net, addr string) (addrList, error)
				internetAddrList resolves addr, which may be a literal IP
				address or a DNS name, and returns a list of internet protocol
				family addresses. The result contains at least one address when
				error is nil.

			(*T) lookup(ctx context.Context, name string, qtype dnsmessage.Type) (dnsmessage.Parser, string, error)
			(*T) lookupAddr(ctx context.Context, addr string) ([]string, error)
			(*T) lookupCNAME(ctx context.Context, name string) (string, error)
			(*T) lookupHost(ctx context.Context, host string) (addrs []string, err error)
			(*T) lookupIP(ctx context.Context, network, host string) (addrs []IPAddr, err error)
			(*T) lookupIPAddr(ctx context.Context, network, host string) ([]IPAddr, error)
				lookupIPAddr looks up host using the local resolver and particular network.
				It returns a slice of that host's IPv4 and IPv6 addresses.

			(*T) lookupMX(ctx context.Context, name string) ([]*MX, error)
			(*T) lookupNS(ctx context.Context, name string) ([]*NS, error)
			(*T) lookupPort(ctx context.Context, network, service string) (int, error)
			(*T) lookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error)
			(*T) lookupTXT(ctx context.Context, name string) ([]string, error)
			(*T) preferGo() bool
			(*T) resolveAddrList(ctx context.Context, op, network, addr string, hint Addr) (addrList, error)
				resolveAddrList resolves addr using hint and returns a list of
				addresses. The result contains at least one address when error is
				nil.

			(*T) strictErrors() bool
			(*T) tryOneName(ctx context.Context, cfg *dnsConfig, name string, qtype dnsmessage.Type) (dnsmessage.Parser, string, error)
				Do a lookup for a single name, which must be rooted
				(otherwise answer will not find the answers).

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Dialer).resolver() *Resolver
		As Types Of (only one, which is exported)
			  var DefaultResolver *Resolver

	 type SRV (struct)
		An SRV represents a single DNS SRV record.

		Fields (total 4, all are exported)
			Port uint16
			Priority uint16
			Target string
			Weight uint16
		As Outputs Of (at least 3, in which 2 are exported)
			func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err error)
			func (*Resolver).LookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Resolver).lookupSRV(ctx context.Context, service, proto, name string) (string, []*SRV, error)

	 type TCPAddr (struct)
		TCPAddr represents the address of a TCP end point.

		Fields (total 3, all are exported)
			IP IP
			Port int
			Zone string
				// IPv6 scoped addressing zone

		Methods (total 7, in which 2 are exported)
			(*T) Network() string
				Network returns the address's network name, "tcp".

			(*T) String() string
			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*T) family() int
			(*T) isWildcard() bool
			(*T) opAddr() Addr
			(*T) sockaddr(family int) (syscall.Sockaddr, error)
			(*T) toLocal(net string) sockaddr
		Implements (at least 5, in which 2 are exported)
			*T : Addr
			*T : fmt.Stringer
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*T : sockaddr
			*T : context.stringer
			*T : runtime.stringer
		As Outputs Of (at least one exported)
			func ResolveTCPAddr(network, address string) (*TCPAddr, error)
		As Inputs Of (at least 2, both are exported)
			func DialTCP(network string, laddr, raddr *TCPAddr) (*TCPConn, error)
			func ListenTCP(network string, laddr *TCPAddr) (*TCPListener, error)

	 type TCPConn (struct)
		TCPConn is an implementation of the Conn interface for TCP network
		connections.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			conn conn
			conn.fd *netFD
		Methods (total 22, in which 19 are exported)
			(*T) Close() error
				Close closes the connection.

			(*T) CloseRead() error
				CloseRead shuts down the reading side of the TCP connection.
				Most callers should just use Close.

			(*T) CloseWrite() error
				CloseWrite shuts down the writing side of the TCP connection.
				Most callers should just use Close.

			(*T) File() (f *os.File, err error)
				File returns a copy of the underlying os.File.
				It is the caller's responsibility to close f when finished.
				Closing c does not affect f, and closing f does not affect c.

				The returned os.File's file descriptor is different from the connection's.
				Attempting to change properties of the original using this duplicate
				may or may not have the desired effect.

			(*T) LocalAddr() Addr
				LocalAddr returns the local network address.
				The Addr returned is shared by all invocations of LocalAddr, so
				do not modify it.

			(*T) Read(b []byte) (int, error)
				Read implements the Conn Read method.

			(*T) ReadFrom(r io.Reader) (int64, error)
				ReadFrom implements the io.ReaderFrom ReadFrom method.

			(*T) RemoteAddr() Addr
				RemoteAddr returns the remote network address.
				The Addr returned is shared by all invocations of RemoteAddr, so
				do not modify it.

			(*T) SetDeadline(t time.Time) error
				SetDeadline implements the Conn SetDeadline method.

			(*T) SetKeepAlive(keepalive bool) error
				SetKeepAlive sets whether the operating system should send
				keep-alive messages on the connection.

			(*T) SetKeepAlivePeriod(d time.Duration) error
				SetKeepAlivePeriod sets period between keep-alives.

			(*T) SetLinger(sec int) error
				SetLinger sets the behavior of Close on a connection which still
				has data waiting to be sent or to be acknowledged.

				If sec < 0 (the default), the operating system finishes sending the
				data in the background.

				If sec == 0, the operating system discards any unsent or
				unacknowledged data.

				If sec > 0, the data is sent in the background as with sec < 0. On
				some operating systems after sec seconds have elapsed any remaining
				unsent data may be discarded.

			(*T) SetNoDelay(noDelay bool) error
				SetNoDelay controls whether the operating system should delay
				packet transmission in hopes of sending fewer packets (Nagle's
				algorithm).  The default is true (no delay), meaning that data is
				sent as soon as possible after a Write.

			(*T) SetReadBuffer(bytes int) error
				SetReadBuffer sets the size of the operating system's
				receive buffer associated with the connection.

			(*T) SetReadDeadline(t time.Time) error
				SetReadDeadline implements the Conn SetReadDeadline method.

			(*T) SetWriteBuffer(bytes int) error
				SetWriteBuffer sets the size of the operating system's
				transmit buffer associated with the connection.

			(*T) SetWriteDeadline(t time.Time) error
				SetWriteDeadline implements the Conn SetWriteDeadline method.

			(*T) SyscallConn() (syscall.RawConn, error)
				SyscallConn returns a raw network connection.
				This implements the syscall.Conn interface.

			(*T) Write(b []byte) (int, error)
				Write implements the Conn Write method.

			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) ok() bool
			(*T) readFrom(r io.Reader) (int64, error)
			(*T) writeBuffers(v *Buffers) (int64, error)
		Implements (at least 11, in which 10 are exported)
			*T : Conn
			*T : io.Closer
			*T : io.ReadCloser
			*T : io.Reader
			*T : io.ReaderFrom
			*T : io.ReadWriteCloser
			*T : io.ReadWriter
			*T : io.WriteCloser
			*T : io.Writer
			*T : syscall.Conn
			/* at least one unexported ... *//* at least one unexported: */
			*T : buffersWriter
		As Outputs Of (at least 4, in which 2 are exported)
			func DialTCP(network string, laddr, raddr *TCPAddr) (*TCPConn, error)
			func (*TCPListener).AcceptTCP() (*TCPConn, error)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func newTCPConn(fd *netFD) *TCPConn
			func (*TCPListener).accept() (*TCPConn, error)

	 type TCPListener (struct)
		TCPListener is a TCP network listener. Clients should typically
		use variables of type Listener instead of assuming TCP.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			fd *netFD
			lc ListenConfig
		Methods (total 11, in which 7 are exported)
			(*T) Accept() (Conn, error)
				Accept implements the Accept method in the Listener interface; it
				waits for the next call and returns a generic Conn.

			(*T) AcceptTCP() (*TCPConn, error)
				AcceptTCP accepts the next incoming call and returns the new
				connection.

			(*T) Addr() Addr
				Addr returns the listener's network address, a *TCPAddr.
				The Addr returned is shared by all invocations of Addr, so
				do not modify it.

			(*T) Close() error
				Close stops listening on the TCP address.
				Already Accepted connections are not closed.

			(*T) File() (f *os.File, err error)
				File returns a copy of the underlying os.File.
				It is the caller's responsibility to close f when finished.
				Closing l does not affect f, and closing f does not affect l.

				The returned os.File's file descriptor is different from the
				connection's. Attempting to change properties of the original
				using this duplicate may or may not have the desired effect.

			(*T) SetDeadline(t time.Time) error
				SetDeadline sets the deadline associated with the listener.
				A zero time value disables the deadline.

			(*T) SyscallConn() (syscall.RawConn, error)
				SyscallConn returns a raw network connection.
				This implements the syscall.Conn interface.

				The returned RawConn only supports calling Control. Read and
				Write return an error.

			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) accept() (*TCPConn, error)
			(*T) close() error
			(*T) file() (*os.File, error)
			(*T) ok() bool
		Implements (at least 3, all are exported)
			*T : Listener
			*T : io.Closer
			*T : syscall.Conn
		As Outputs Of (at least one exported)
			func ListenTCP(network string, laddr *TCPAddr) (*TCPListener, error)

	 type UDPAddr (struct)
		UDPAddr represents the address of a UDP end point.

		Fields (total 3, all are exported)
			IP IP
			Port int
			Zone string
				// IPv6 scoped addressing zone

		Methods (total 7, in which 2 are exported)
			(*T) Network() string
				Network returns the address's network name, "udp".

			(*T) String() string
			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*T) family() int
			(*T) isWildcard() bool
			(*T) opAddr() Addr
			(*T) sockaddr(family int) (syscall.Sockaddr, error)
			(*T) toLocal(net string) sockaddr
		Implements (at least 5, in which 2 are exported)
			*T : Addr
			*T : fmt.Stringer
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*T : sockaddr
			*T : context.stringer
			*T : runtime.stringer
		As Outputs Of (at least 5, in which 3 are exported)
			func ResolveUDPAddr(network, address string) (*UDPAddr, error)
			func (*UDPConn).ReadFromUDP(b []byte) (int, *UDPAddr, error)
			func (*UDPConn).ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func (*UDPConn).readFrom(b []byte) (int, *UDPAddr, error)
			func (*UDPConn).readMsg(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error)
		As Inputs Of (at least 7, in which 5 are exported)
			func DialUDP(network string, laddr, raddr *UDPAddr) (*UDPConn, error)
			func ListenMulticastUDP(network string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error)
			func ListenUDP(network string, laddr *UDPAddr) (*UDPConn, error)
			func (*UDPConn).WriteMsgUDP(b, oob []byte, addr *UDPAddr) (n, oobn int, err error)
			func (*UDPConn).WriteToUDP(b []byte, addr *UDPAddr) (int, error)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func (*UDPConn).writeMsg(b, oob []byte, addr *UDPAddr) (n, oobn int, err error)
			func (*UDPConn).writeTo(b []byte, addr *UDPAddr) (int, error)

	 type UDPConn (struct)
		UDPConn is the implementation of the Conn and PacketConn interfaces
		for UDP network connections.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			conn conn
			conn.fd *netFD
		Methods (total 24, in which 18 are exported)
			(*T) Close() error
				Close closes the connection.

			(*T) File() (f *os.File, err error)
				File returns a copy of the underlying os.File.
				It is the caller's responsibility to close f when finished.
				Closing c does not affect f, and closing f does not affect c.

				The returned os.File's file descriptor is different from the connection's.
				Attempting to change properties of the original using this duplicate
				may or may not have the desired effect.

			(*T) LocalAddr() Addr
				LocalAddr returns the local network address.
				The Addr returned is shared by all invocations of LocalAddr, so
				do not modify it.

			(*T) Read(b []byte) (int, error)
				Read implements the Conn Read method.

			(*T) ReadFrom(b []byte) (int, Addr, error)
				ReadFrom implements the PacketConn ReadFrom method.

			(*T) ReadFromUDP(b []byte) (int, *UDPAddr, error)
				ReadFromUDP acts like ReadFrom but returns a UDPAddr.

			(*T) ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error)
				ReadMsgUDP reads a message from c, copying the payload into b and
				the associated out-of-band data into oob. It returns the number of
				bytes copied into b, the number of bytes copied into oob, the flags
				that were set on the message and the source address of the message.

				The packages golang.org/x/net/ipv4 and golang.org/x/net/ipv6 can be
				used to manipulate IP-level socket options in oob.

			(*T) RemoteAddr() Addr
				RemoteAddr returns the remote network address.
				The Addr returned is shared by all invocations of RemoteAddr, so
				do not modify it.

			(*T) SetDeadline(t time.Time) error
				SetDeadline implements the Conn SetDeadline method.

			(*T) SetReadBuffer(bytes int) error
				SetReadBuffer sets the size of the operating system's
				receive buffer associated with the connection.

			(*T) SetReadDeadline(t time.Time) error
				SetReadDeadline implements the Conn SetReadDeadline method.

			(*T) SetWriteBuffer(bytes int) error
				SetWriteBuffer sets the size of the operating system's
				transmit buffer associated with the connection.

			(*T) SetWriteDeadline(t time.Time) error
				SetWriteDeadline implements the Conn SetWriteDeadline method.

			(*T) SyscallConn() (syscall.RawConn, error)
				SyscallConn returns a raw network connection.
				This implements the syscall.Conn interface.

			(*T) Write(b []byte) (int, error)
				Write implements the Conn Write method.

			(*T) WriteMsgUDP(b, oob []byte, addr *UDPAddr) (n, oobn int, err error)
				WriteMsgUDP writes a message to addr via c if c isn't connected, or
				to c's remote address if c is connected (in which case addr must be
				nil). The payload is copied from b and the associated out-of-band
				data is copied from oob. It returns the number of payload and
				out-of-band bytes written.

				The packages golang.org/x/net/ipv4 and golang.org/x/net/ipv6 can be
				used to manipulate IP-level socket options in oob.

			(*T) WriteTo(b []byte, addr Addr) (int, error)
				WriteTo implements the PacketConn WriteTo method.

			(*T) WriteToUDP(b []byte, addr *UDPAddr) (int, error)
				WriteToUDP acts like WriteTo but takes a UDPAddr.

			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*T) ok() bool
			(*T) readFrom(b []byte) (int, *UDPAddr, error)
			(*T) readMsg(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error)
			(*T) writeBuffers(v *Buffers) (int64, error)
			(*T) writeMsg(b, oob []byte, addr *UDPAddr) (n, oobn int, err error)
			(*T) writeTo(b []byte, addr *UDPAddr) (int, error)
		Implements (at least 11, in which 10 are exported)
			*T : Conn
			*T : PacketConn
			*T : io.Closer
			*T : io.ReadCloser
			*T : io.Reader
			*T : io.ReadWriteCloser
			*T : io.ReadWriter
			*T : io.WriteCloser
			*T : io.Writer
			*T : syscall.Conn
			/* at least one unexported ... *//* at least one unexported: */
			*T : buffersWriter
		As Outputs Of (at least 4, in which 3 are exported)
			func DialUDP(network string, laddr, raddr *UDPAddr) (*UDPConn, error)
			func ListenMulticastUDP(network string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error)
			func ListenUDP(network string, laddr *UDPAddr) (*UDPConn, error)
			/* at least one unexported ... *//* at least one unexported: */
			func newUDPConn(fd *netFD) *UDPConn
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func listenIPv4MulticastUDP(c *UDPConn, ifi *Interface, ip IP) error
			func listenIPv6MulticastUDP(c *UDPConn, ifi *Interface, ip IP) error

	 type UnixAddr (struct)
		UnixAddr represents the address of a Unix domain socket end point.

		Fields (total 2, both are exported)
			Name string
			Net string
		Methods (total 7, in which 2 are exported)
			(*T) Network() string
				Network returns the address's network name, "unix", "unixgram" or
				"unixpacket".

			(*T) String() string
			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*T) family() int
			(*T) isWildcard() bool
			(*T) opAddr() Addr
			(*T) sockaddr(family int) (syscall.Sockaddr, error)
			(*T) toLocal(net string) sockaddr
		Implements (at least 5, in which 2 are exported)
			*T : Addr
			*T : fmt.Stringer
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*T : sockaddr
			*T : context.stringer
			*T : runtime.stringer
		As Outputs Of (at least 5, in which 3 are exported)
			func ResolveUnixAddr(network, address string) (*UnixAddr, error)
			func (*UnixConn).ReadFromUnix(b []byte) (int, *UnixAddr, error)
			func (*UnixConn).ReadMsgUnix(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func (*UnixConn).readFrom(b []byte) (int, *UnixAddr, error)
			func (*UnixConn).readMsg(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error)
		As Inputs Of (at least 7, in which 5 are exported)
			func DialUnix(network string, laddr, raddr *UnixAddr) (*UnixConn, error)
			func ListenUnix(network string, laddr *UnixAddr) (*UnixListener, error)
			func ListenUnixgram(network string, laddr *UnixAddr) (*UnixConn, error)
			func (*UnixConn).WriteMsgUnix(b, oob []byte, addr *UnixAddr) (n, oobn int, err error)
			func (*UnixConn).WriteToUnix(b []byte, addr *UnixAddr) (int, error)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func (*UnixConn).writeMsg(b, oob []byte, addr *UnixAddr) (n, oobn int, err error)
			func (*UnixConn).writeTo(b []byte, addr *UnixAddr) (int, error)

	 type UnixConn (struct)
		UnixConn is an implementation of the Conn interface for connections
		to Unix domain sockets.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			conn conn
			conn.fd *netFD
		Methods (total 26, in which 20 are exported)
			(*T) Close() error
				Close closes the connection.

			(*T) CloseRead() error
				CloseRead shuts down the reading side of the Unix domain connection.
				Most callers should just use Close.

			(*T) CloseWrite() error
				CloseWrite shuts down the writing side of the Unix domain connection.
				Most callers should just use Close.

			(*T) File() (f *os.File, err error)
				File returns a copy of the underlying os.File.
				It is the caller's responsibility to close f when finished.
				Closing c does not affect f, and closing f does not affect c.

				The returned os.File's file descriptor is different from the connection's.
				Attempting to change properties of the original using this duplicate
				may or may not have the desired effect.

			(*T) LocalAddr() Addr
				LocalAddr returns the local network address.
				The Addr returned is shared by all invocations of LocalAddr, so
				do not modify it.

			(*T) Read(b []byte) (int, error)
				Read implements the Conn Read method.

			(*T) ReadFrom(b []byte) (int, Addr, error)
				ReadFrom implements the PacketConn ReadFrom method.

			(*T) ReadFromUnix(b []byte) (int, *UnixAddr, error)
				ReadFromUnix acts like ReadFrom but returns a UnixAddr.

			(*T) ReadMsgUnix(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error)
				ReadMsgUnix reads a message from c, copying the payload into b and
				the associated out-of-band data into oob. It returns the number of
				bytes copied into b, the number of bytes copied into oob, the flags
				that were set on the message and the source address of the message.

				Note that if len(b) == 0 and len(oob) > 0, this function will still
				read (and discard) 1 byte from the connection.

			(*T) RemoteAddr() Addr
				RemoteAddr returns the remote network address.
				The Addr returned is shared by all invocations of RemoteAddr, so
				do not modify it.

			(*T) SetDeadline(t time.Time) error
				SetDeadline implements the Conn SetDeadline method.

			(*T) SetReadBuffer(bytes int) error
				SetReadBuffer sets the size of the operating system's
				receive buffer associated with the connection.

			(*T) SetReadDeadline(t time.Time) error
				SetReadDeadline implements the Conn SetReadDeadline method.

			(*T) SetWriteBuffer(bytes int) error
				SetWriteBuffer sets the size of the operating system's
				transmit buffer associated with the connection.

			(*T) SetWriteDeadline(t time.Time) error
				SetWriteDeadline implements the Conn SetWriteDeadline method.

			(*T) SyscallConn() (syscall.RawConn, error)
				SyscallConn returns a raw network connection.
				This implements the syscall.Conn interface.

			(*T) Write(b []byte) (int, error)
				Write implements the Conn Write method.

			(*T) WriteMsgUnix(b, oob []byte, addr *UnixAddr) (n, oobn int, err error)
				WriteMsgUnix writes a message to addr via c, copying the payload
				from b and the associated out-of-band data from oob. It returns the
				number of payload and out-of-band bytes written.

				Note that if len(b) == 0 and len(oob) > 0, this function will still
				write 1 byte to the connection.

			(*T) WriteTo(b []byte, addr Addr) (int, error)
				WriteTo implements the PacketConn WriteTo method.

			(*T) WriteToUnix(b []byte, addr *UnixAddr) (int, error)
				WriteToUnix acts like WriteTo but takes a UnixAddr.

			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*T) ok() bool
			(*T) readFrom(b []byte) (int, *UnixAddr, error)
			(*T) readMsg(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error)
			(*T) writeBuffers(v *Buffers) (int64, error)
			(*T) writeMsg(b, oob []byte, addr *UnixAddr) (n, oobn int, err error)
			(*T) writeTo(b []byte, addr *UnixAddr) (int, error)
		Implements (at least 11, in which 10 are exported)
			*T : Conn
			*T : PacketConn
			*T : io.Closer
			*T : io.ReadCloser
			*T : io.Reader
			*T : io.ReadWriteCloser
			*T : io.ReadWriter
			*T : io.WriteCloser
			*T : io.Writer
			*T : syscall.Conn
			/* at least one unexported ... *//* at least one unexported: */
			*T : buffersWriter
		As Outputs Of (at least 5, in which 3 are exported)
			func DialUnix(network string, laddr, raddr *UnixAddr) (*UnixConn, error)
			func ListenUnixgram(network string, laddr *UnixAddr) (*UnixConn, error)
			func (*UnixListener).AcceptUnix() (*UnixConn, error)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func newUnixConn(fd *netFD) *UnixConn
			func (*UnixListener).accept() (*UnixConn, error)

	 type UnixListener (struct)
		UnixListener is a Unix domain socket listener. Clients should
		typically use variables of type Listener instead of assuming Unix
		domain sockets.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			fd *netFD
			path string
			unlink bool
			unlinkOnce sync.Once
		Methods (total 12, in which 8 are exported)
			(*T) Accept() (Conn, error)
				Accept implements the Accept method in the Listener interface.
				Returned connections will be of type *UnixConn.

			(*T) AcceptUnix() (*UnixConn, error)
				AcceptUnix accepts the next incoming call and returns the new
				connection.

			(*T) Addr() Addr
				Addr returns the listener's network address.
				The Addr returned is shared by all invocations of Addr, so
				do not modify it.

			(*T) Close() error
				Close stops listening on the Unix address. Already accepted
				connections are not closed.

			(*T) File() (f *os.File, err error)
				File returns a copy of the underlying os.File.
				It is the caller's responsibility to close f when finished.
				Closing l does not affect f, and closing f does not affect l.

				The returned os.File's file descriptor is different from the
				connection's. Attempting to change properties of the original
				using this duplicate may or may not have the desired effect.

			(*T) SetDeadline(t time.Time) error
				SetDeadline sets the deadline associated with the listener.
				A zero time value disables the deadline.

			(*T) SetUnlinkOnClose(unlink bool)
				SetUnlinkOnClose sets whether the underlying socket file should be removed
				from the file system when the listener is closed.

				The default behavior is to unlink the socket file only when package net created it.
				That is, when the listener and the underlying socket file were created by a call to
				Listen or ListenUnix, then by default closing the listener will remove the socket file.
				but if the listener was created by a call to FileListener to use an already existing
				socket file, then by default closing the listener will not remove the socket file.

			(*T) SyscallConn() (syscall.RawConn, error)
				SyscallConn returns a raw network connection.
				This implements the syscall.Conn interface.

				The returned RawConn only supports calling Control. Read and
				Write return an error.

			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) accept() (*UnixConn, error)
			(*T) close() error
			(*T) file() (*os.File, error)
			(*T) ok() bool
		Implements (at least 3, all are exported)
			*T : Listener
			*T : io.Closer
			*T : syscall.Conn
		As Outputs Of (at least one exported)
			func ListenUnix(network string, laddr *UnixAddr) (*UnixListener, error)

	 type UnknownNetworkError string (basic type)

		Methods (total 3, all are exported)
			( T) Error() string
			( T) Temporary() bool
			( T) Timeout() bool
		Implements (at least 5, in which 2 are exported)
			 T : Error
			 T : error
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			 T : temporary
			 T : timeout
			 T : os.timeout

	/* 37 unexporteds ... *//* 37 unexporteds: */
	 type addrinfoErrno int (basic type)

		Methods (total 3, all are exported)
			( T) Error() string
			( T) Temporary() bool
			( T) Timeout() bool
		Implements (at least 5, in which 2 are exported)
			 T : Error
			 T : error
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			 T : temporary
			 T : timeout
			 T : os.timeout

	 type addrList ([]T)
		An addrList represents a list of network endpoint addresses.

		Methods (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			( T) first(strategy func(Addr) bool) Addr
				first returns the first address which satisfies strategy, or if
				none do, then the first address of any kind.

			( T) forResolve(network, addr string) Addr
				forResolve returns the most appropriate address in address for
				a call to ResolveTCPAddr, ResolveUDPAddr, or ResolveIPAddr.
				IPv4 is preferred, unless addr contains an IPv6 literal.

			( T) partition(strategy func(Addr) bool) (primaries, fallbacks addrList)
				partition divides an address list into two categories, using a
				strategy function to assign a boolean label to each address.
				The first address, and any with a matching label, are returned as
				primaries, while addresses with the opposite label are returned
				as fallbacks. For non-empty inputs, primaries is guaranteed to be
				non-empty.

		As Outputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func filterAddrList(filter func(IPAddr) bool, ips []IPAddr, inetaddr func(IPAddr) Addr, originalAddr string) (addrList, error)
			func (*Resolver).internetAddrList(ctx context.Context, net, addr string) (addrList, error)
			func (*Resolver).resolveAddrList(ctx context.Context, op, network, addr string, hint Addr) (addrList, error)

	 type buffersWriter (interface)
		buffersWriter is the interface implemented by Conns that support a
		"writev"-like batch write optimization.
		writeBuffers should fully consume and write all chunks from the
		provided Buffers, else it should report a non-nil error.

		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			( T) writeBuffers(*Buffers) (int64, error)
		Implemented By (at least 6, in which 4 are exported)
			*IPConn
			*TCPConn
			*UDPConn
			*UnixConn
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*conn
			*netFD

	 type byMaskLength ([]T)
		byMaskLength sorts policyTableEntry by the size of their Prefix.Mask.Size,
		from smallest mask, to largest.

		Methods (total 3, all are exported)
			( T) Len() int
			( T) Less(i, j int) bool
			( T) Swap(i, j int)
		Implements (at least one exported)
			 T : sort.Interface

	 type byPref ([]T)
		byPref implements sort.Interface to sort MX records by preference

		Methods (total 4, in which 3 are exported)
			( T) Len() int
			( T) Less(i, j int) bool
			( T) Swap(i, j int)
			/* one unexported ... *//* one unexported: */
			( T) sort()
				sort reorders MX records as specified in RFC 5321.

		Implements (at least one exported)
			 T : sort.Interface

	 type byPriorityWeight ([]T)
		byPriorityWeight sorts SRV records by ascending priority and weight.

		Methods (total 5, in which 3 are exported)
			( T) Len() int
			( T) Less(i, j int) bool
			( T) Swap(i, j int)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			( T) shuffleByWeight()
				shuffleByWeight shuffles SRV records by weight using the algorithm
				described in RFC 2782.

			( T) sort()
				sort reorders SRV records as specified in RFC 2782.

		Implements (at least one exported)
			 T : sort.Interface

	 type byRFC6724 (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			addrAttr []ipAttr
			addrs []IPAddr
				// addrs to sort

			srcAttr []ipAttr
			srcs []IP
				// or nil if unreachable

		Methods (total 3, all are exported)
			(*T) Len() int
			(*T) Less(i, j int) bool
				Less reports whether i is a better destination address for this
				host than j.

				The algorithm and variable names comes from RFC 6724 section 6.

			(*T) Swap(i, j int)
		Implements (at least one exported)
			*T : sort.Interface

	 type conf (struct)
		conf represents a system's network configuration.

		Fields (total 8, none are exported)
			/* 8 unexporteds ... *//* 8 unexporteds: */
			dnsDebugLevel int
			forceCgoLookupHost bool
				forceCgoLookupHost forces CGO to always be used, if available.

			goos string
				// the runtime.GOOS, to ease testing

			hasMDNSAllow bool
				machine has an /etc/mdns.allow file

			netCgo bool
				// cgo DNS resolution forced

			netGo bool
				// go DNS resolution forced

			nss *nssConf
			resolv *dnsConfig
		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) canUseCgo() bool
				canUseCgo reports whether calling cgo functions is allowed
				for non-hostname lookups.

			(*T) hostLookupOrder(r *Resolver, hostname string) (ret hostLookupOrder)
				hostLookupOrder determines which strategy to use to resolve hostname.
				The provided Resolver is optional. nil means to not consider its options.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func systemConf() *conf
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var confVal *conf

	 type conn (struct)

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			fd *netFD
		Methods (total 13, in which 11 are exported)
			(*T) Close() error
				Close closes the connection.

			(*T) File() (f *os.File, err error)
				File returns a copy of the underlying os.File.
				It is the caller's responsibility to close f when finished.
				Closing c does not affect f, and closing f does not affect c.

				The returned os.File's file descriptor is different from the connection's.
				Attempting to change properties of the original using this duplicate
				may or may not have the desired effect.

			(*T) LocalAddr() Addr
				LocalAddr returns the local network address.
				The Addr returned is shared by all invocations of LocalAddr, so
				do not modify it.

			(*T) Read(b []byte) (int, error)
				Read implements the Conn Read method.

			(*T) RemoteAddr() Addr
				RemoteAddr returns the remote network address.
				The Addr returned is shared by all invocations of RemoteAddr, so
				do not modify it.

			(*T) SetDeadline(t time.Time) error
				SetDeadline implements the Conn SetDeadline method.

			(*T) SetReadBuffer(bytes int) error
				SetReadBuffer sets the size of the operating system's
				receive buffer associated with the connection.

			(*T) SetReadDeadline(t time.Time) error
				SetReadDeadline implements the Conn SetReadDeadline method.

			(*T) SetWriteBuffer(bytes int) error
				SetWriteBuffer sets the size of the operating system's
				transmit buffer associated with the connection.

			(*T) SetWriteDeadline(t time.Time) error
				SetWriteDeadline implements the Conn SetWriteDeadline method.

			(*T) Write(b []byte) (int, error)
				Write implements the Conn Write method.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) ok() bool
			(*T) writeBuffers(v *Buffers) (int64, error)
		Implements (at least 9, in which 8 are exported)
			*T : Conn
			*T : io.Closer
			*T : io.ReadCloser
			*T : io.Reader
			*T : io.ReadWriteCloser
			*T : io.ReadWriter
			*T : io.WriteCloser
			*T : io.Writer
			/* at least one unexported ... *//* at least one unexported: */
			*T : buffersWriter

	 type dnsConfig (struct)

		Fields (total 13, none are exported)
			/* 13 unexporteds ... *//* 13 unexporteds: */
			attempts int
				// lost packets before giving up on server

			err error
				// any error that occurs during open of resolv.conf

			lookup []string
				// OpenBSD top-level database "lookup" order

			mtime time.Time
				// time of resolv.conf modification

			ndots int
				// number of dots in name to trigger absolute lookup

			rotate bool
				// round robin among servers

			search []string
				// rooted suffixes to append to local name

			servers []string
				// server addresses (in host:port form) to use

			singleRequest bool
				// use sequential A and AAAA queries instead of parallel queries

			soffset uint32
				// used by serverOffset

			timeout time.Duration
				// wait before giving up on a query, including retries

			unknownOpt bool
				// anything unknown was encountered

			useTCP bool
				// force usage of TCP for DNS resolutions

		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) nameList(name string) []string
				nameList returns a list of names for sequential DNS queries.

			(*T) serverOffset() uint32
				serverOffset returns an offset that can be used to determine
				indices of servers in c.servers when making queries.
				When the rotate option is enabled, this offset increases.
				Otherwise it is always 0.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func dnsReadConfig(filename string) *dnsConfig
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Resolver).tryOneName(ctx context.Context, cfg *dnsConfig, name string, qtype dnsmessage.Type) (dnsmessage.Parser, string, error)

	 type file (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			atEOF bool
			data []byte
			file *os.File
		Methods (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) close()
			(*T) getLineFromData() (s string, ok bool)
			(*T) readLine() (s string, ok bool)
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func open(name string) (*file, error)

	 type fileAddr string (basic type)

		Methods (total 2, both are exported)
			( T) Network() string
			( T) String() string
		Implements (at least 4, in which 2 are exported)
			 T : Addr
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer

	 type hostLookupOrder int (basic type)
		hostLookupOrder specifies the order of LookupHost lookup strategies.
		It is basically a simplified representation of nsswitch.conf.
		"files" means /etc/hosts.

		Methods (only one, which is exported)
			( T) String() string
		Implements (at least 3, in which 1 are exported)
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func (*Resolver).goLookupHostOrder(ctx context.Context, name string, order hostLookupOrder) (addrs []string, err error)
			func (*Resolver).goLookupIPCNAMEOrder(ctx context.Context, name string, order hostLookupOrder) (addrs []IPAddr, cname dnsmessage.Name, err error)
		As Types Of (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			const hostLookupCgo
			const hostLookupDNS
			const hostLookupDNSFiles
			const hostLookupFiles
			const hostLookupFilesDNS

	 type ipAttr (struct)

		Fields (total 3, all are exported)
			Label uint8
			Precedence uint8
			Scope scope
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func ipAttrOf(ip IP) ipAttr

	 type ipStackCapabilities (struct)

		Fields (total 6, in which 1 are exported)
			Once sync.Once
				// guards following

			/* 5 unexporteds ... *//* 5 unexporteds: */
			ipv4Enabled bool
			ipv4MappedIPv6Enabled bool
			ipv6Enabled bool
			Once.done uint32
				done indicates whether the action has been performed.
				It is first in the struct because it is used in the hot path.
				The hot path is inlined at every call site.
				Placing done first allows more compact instructions on some architectures (amd64/386),
				and fewer instructions (to calculate offset) on other architectures.

			Once.m sync.Mutex
		Methods (total 3, in which 1 are exported)
			(*T) Do(f func())
				Do calls the function f if and only if Do is being called for the
				first time for this instance of Once. In other words, given
					var once Once
				if once.Do(f) is called multiple times, only the first call will invoke f,
				even if f has a different value in each invocation. A new instance of
				Once is required for each function to execute.

				Do is intended for initialization that must be run exactly once. Since f
				is niladic, it may be necessary to use a function literal to capture the
				arguments to a function to be invoked by Do:
					config.once.Do(func() { config.init(filename) })

				Because no call to Do returns until the one call to f returns, if f causes
				Do to be called, it will deadlock.

				If f panics, Do considers it to have returned; future calls of Do return
				without calling f.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) doSlow(f func())
			(*T) probe()
				Probe probes IPv4, IPv6 and IPv4-mapped IPv6 communication
				capabilities which are controlled by the IPV6_V6ONLY socket option
				and kernel configuration.

				Should we try to use the IPv4 socket interface if we're only
				dealing with IPv4 sockets? As long as the host system understands
				IPv4-mapped IPv6, it's okay to pass IPv4-mapeed IPv6 addresses to
				the IPv6 interface. That simplifies our code and is most
				general. Unfortunately, we need to run on kernels built without
				IPv6 support too. So probe the kernel to figure it out.

		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var ipStackCaps

	 type ipv6ZoneCache (struct)
		An ipv6ZoneCache represents a cache holding partial network
		interface information. It is used for reducing the cost of IPv6
		addressing scope zone resolution.

		Multiple names sharing the index are managed by first-come
		first-served basis for consistency.

		Fields (total 9, in which 1 are exported)
			RWMutex sync.RWMutex
				// guard the following

			/* 8 unexporteds ... *//* 8 unexporteds: */
			lastFetched time.Time
				// last time routing information was fetched

			RWMutex.readerCount int32
				// number of pending readers

			RWMutex.readerSem uint32
				// semaphore for readers to wait for completing writers

			RWMutex.readerWait int32
				// number of departing readers

			RWMutex.w sync.Mutex
				// held if there are pending writers

			RWMutex.writerSem uint32
				// semaphore for writers to wait for completing readers

			toIndex map[string]int
				// interface name to its index

			toName map[int]string
				// interface index to its name

		Methods (total 9, in which 5 are exported)
			(*T) Lock()
				Lock locks rw for writing.
				If the lock is already locked for reading or writing,
				Lock blocks until the lock is available.

			(*T) RLock()
				RLock locks rw for reading.

				It should not be used for recursive read locking; a blocked Lock
				call excludes new readers from acquiring the lock. See the
				documentation on the RWMutex type.

			(*T) RLocker() sync.Locker
				RLocker returns a Locker interface that implements
				the Lock and Unlock methods by calling rw.RLock and rw.RUnlock.

			(*T) RUnlock()
				RUnlock undoes a single RLock call;
				it does not affect other simultaneous readers.
				It is a run-time error if rw is not locked for reading
				on entry to RUnlock.

			(*T) Unlock()
				Unlock unlocks rw for writing. It is a run-time error if rw is
				not locked for writing on entry to Unlock.

				As with Mutexes, a locked RWMutex is not associated with a particular
				goroutine. One goroutine may RLock (Lock) a RWMutex and then
				arrange for another goroutine to RUnlock (Unlock) it.

			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) index(name string) int
			(*T) name(index int) string
			(*T) rUnlockSlow(r int32)
			(*T) update(ift []Interface, force bool) (updated bool)
				update refreshes the network interface information if the cache was last
				updated more than 1 minute ago, or if force is set. It reports whether the
				cache was updated.

		Implements (at least one exported)
			*T : sync.Locker
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var zoneCache

	 type netFD (struct)
		Network file descriptor.

		Fields (total 7, none are exported)
			/* 7 unexporteds ... *//* 7 unexporteds: */
			family int
				immutable until Close

			isConnected bool
				// handshake completed or use of association with peer

			laddr Addr
			net string
			pfd poll.FD
			raddr Addr
			sotype int
		Methods (total 25, in which 6 are exported)
			(*T) Close() error
			(*T) Read(p []byte) (n int, err error)
			(*T) SetDeadline(t time.Time) error
			(*T) SetReadDeadline(t time.Time) error
			(*T) SetWriteDeadline(t time.Time) error
			(*T) Write(p []byte) (nn int, err error)
			/* 19 unexporteds ... *//* 19 unexporteds: */
			(*T) accept() (netfd *netFD, err error)
			(*T) addrFunc() func(syscall.Sockaddr) Addr
			(*T) closeRead() error
			(*T) closeWrite() error
			(*T) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa syscall.Sockaddr, ret error)
			(*T) ctrlNetwork() string
			(*T) dial(ctx context.Context, laddr, raddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) error
			(*T) dup() (f *os.File, err error)
			(*T) init() error
			(*T) listenDatagram(laddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) error
			(*T) listenStream(laddr sockaddr, backlog int, ctrlFn func(string, string, syscall.RawConn) error) error
			(*T) name() string
			(*T) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error)
			(*T) readMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.Sockaddr, err error)
			(*T) setAddr(laddr, raddr Addr)
			(*T) shutdown(how int) error
			(*T) writeBuffers(v *Buffers) (n int64, err error)
			(*T) writeMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oobn int, err error)
			(*T) writeTo(p []byte, sa syscall.Sockaddr) (n int, err error)
		Implements (at least 8, in which 7 are exported)
			*T : io.Closer
			*T : io.ReadCloser
			*T : io.Reader
			*T : io.ReadWriteCloser
			*T : io.ReadWriter
			*T : io.WriteCloser
			*T : io.Writer
			/* at least one unexported ... *//* at least one unexported: */
			*T : buffersWriter
		As Outputs Of (at least 5, none are exported)
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			func internetSocket(ctx context.Context, net string, laddr, raddr sockaddr, sotype, proto int, mode string, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error)
			func newFD(sysfd, family, sotype int, net string) (*netFD, error)
			func newFileFD(f *os.File) (*netFD, error)
			func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error)
			func unixSocket(ctx context.Context, net string, laddr, raddr sockaddr, mode string, ctrlFn func(string, string, syscall.RawConn) error) (*netFD, error)
		As Inputs Of (at least 21, none are exported)
			/* 21+ unexporteds ... *//* 21+ unexporteds: */
			func joinIPv4Group(fd *netFD, ifi *Interface, ip IP) error
			func joinIPv6Group(fd *netFD, ifi *Interface, ip IP) error
			func newIPConn(fd *netFD) *IPConn
			func newRawConn(fd *netFD) (*rawConn, error)
			func newRawListener(fd *netFD) (*rawListener, error)
			func newTCPConn(fd *netFD) *TCPConn
			func newUDPConn(fd *netFD) *UDPConn
			func newUnixConn(fd *netFD) *UnixConn
			func selfConnect(fd *netFD, err error) bool
			func sendFile(c *netFD, r io.Reader) (n int64, err error, handled bool)
			func setIPv4MulticastInterface(fd *netFD, ifi *Interface) error
			func setIPv4MulticastLoopback(fd *netFD, v bool) error
			func setIPv6MulticastInterface(fd *netFD, ifi *Interface) error
			func setIPv6MulticastLoopback(fd *netFD, v bool) error
			func setKeepAlive(fd *netFD, keepalive bool) error
			func setKeepAlivePeriod(fd *netFD, d time.Duration) error
			func setLinger(fd *netFD, sec int) error
			func setNoDelay(fd *netFD, noDelay bool) error
			func setReadBuffer(fd *netFD, bytes int) error
			func setWriteBuffer(fd *netFD, bytes int) error
			func splice(c *netFD, r io.Reader) (int64, error, bool)

	 type nssConf (struct)
		nssConf represents the state of the machine's /etc/nsswitch.conf file.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			err error
				// any error encountered opening or parsing the file

			sources map[string][]nssSource
				// keyed by database (e.g. "hosts")

		As Outputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func parseNSSConf(r io.Reader) *nssConf
			func parseNSSConfFile(file string) *nssConf

	 type nssCriterion (struct)
		nssCriterion is the parsed structure of one of the criteria in brackets
		after an NSS source name.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			action string
				// e.g. "return", "continue" (lowercase)

			negate bool
				// if "!" was present

			status string
				// e.g. "success", "unavail" (lowercase)

		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			( T) standardStatusAction(last bool) bool
				standardStatusAction reports whether c is equivalent to not
				specifying the criterion at all. last is whether this criteria is the
				last in the list.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func parseCriteria(x []byte) (c []nssCriterion, err error)

	 type nssSource (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			criteria []nssCriterion
			source string
				// e.g. "compat", "files", "mdns4_minimal"

		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			( T) standardCriteria() bool
				standardCriteria reports all specified criteria have the default
				status actions.


	 type onlyValuesCtx (struct)
		onlyValuesCtx is a context that uses an underlying context
		for value lookup if the underlying context hasn't yet expired.

		Fields (total 2, in which 1 are exported)
			Context context.Context
			/* one unexported ... *//* one unexported: */
			lookupValues context.Context
		Methods (total 4, all are exported)
			( T) Deadline() (deadline time.Time, ok bool)
				Deadline returns the time when work done on behalf of this context
				should be canceled. Deadline returns ok==false when no deadline is
				set. Successive calls to Deadline return the same results.

			( T) Done() <-chan struct{}
				Done returns a channel that's closed when work done on behalf of this
				context should be canceled. Done may return nil if this context can
				never be canceled. Successive calls to Done return the same value.
				The close of the Done channel may happen asynchronously,
				after the cancel function returns.

				WithCancel arranges for Done to be closed when cancel is called;
				WithDeadline arranges for Done to be closed when the deadline
				expires; WithTimeout arranges for Done to be closed when the timeout
				elapses.

				Done is provided for use in select statements:

				 // Stream generates values with DoSomething and sends them to out
				 // until DoSomething returns an error or ctx.Done is closed.
				 func Stream(ctx context.Context, out chan<- Value) error {
				 	for {
				 		v, err := DoSomething(ctx)
				 		if err != nil {
				 			return err
				 		}
				 		select {
				 		case <-ctx.Done():
				 			return ctx.Err()
				 		case out <- v:
				 		}
				 	}
				 }

				See https://blog.golang.org/pipelines for more examples of how to use
				a Done channel for cancellation.

			( T) Err() error
				If Done is not yet closed, Err returns nil.
				If Done is closed, Err returns a non-nil error explaining why:
				Canceled if the context was canceled
				or DeadlineExceeded if the context's deadline passed.
				After Err returns a non-nil error, successive calls to Err return the same error.

			(*T) Value(key interface{}) interface{}
				Value performs a lookup if the original context hasn't expired.

		Implements (at least one exported)
			*T : context.Context

	 type pipe (struct)

		Fields (total 10, none are exported)
			/* 10 unexporteds ... *//* 10 unexporteds: */
			localDone chan struct{}
			once sync.Once
				// Protects closing localDone

			rdRx <-chan []byte
				Used by local Read to interact with remote Write.
				Successful receive on rdRx is always followed by send on rdTx.

			rdTx chan<- int
			readDeadline pipeDeadline
			remoteDone <-chan struct{}
			wrMu sync.Mutex
				// Serialize Write operations

			wrRx <-chan int
			wrTx chan<- []byte
				Used by local Write to interact with remote Read.
				Successful send on wrTx is always followed by receive on wrRx.

			writeDeadline pipeDeadline
		Methods (total 10, in which 8 are exported)
			(*T) Close() error
			(*T) LocalAddr() Addr
			(*T) Read(b []byte) (int, error)
			(*T) RemoteAddr() Addr
			(*T) SetDeadline(t time.Time) error
			(*T) SetReadDeadline(t time.Time) error
			(*T) SetWriteDeadline(t time.Time) error
			(*T) Write(b []byte) (int, error)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) read(b []byte) (n int, err error)
			(*T) write(b []byte) (n int, err error)
		Implements (at least 8, all are exported)
			*T : Conn
			*T : io.Closer
			*T : io.ReadCloser
			*T : io.Reader
			*T : io.ReadWriteCloser
			*T : io.ReadWriter
			*T : io.WriteCloser
			*T : io.Writer

	 type pipeAddr (struct)

		Methods (total 2, both are exported)
			( T) Network() string
			( T) String() string
		Implements (at least 4, in which 2 are exported)
			 T : Addr
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer

	 type pipeDeadline (struct)
		pipeDeadline is an abstraction for handling timeouts.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			cancel chan struct{}
				// Must be non-nil

			mu sync.Mutex
				// Guards timer and cancel

			timer *time.Timer
		Methods (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) set(t time.Time)
				set sets the point in time when the deadline will time out.
				A timeout event is signaled by closing the channel returned by waiter.
				Once a timeout has occurred, the deadline can be refreshed by specifying a
				t value in the future.

				A zero value for t prevents timeout.

			(*T) wait() chan struct{}
				wait returns a channel that is closed when the deadline is exceeded.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func makePipeDeadline() pipeDeadline

	 type policyTable ([]T)

		Methods (only one, which is exported)
			( T) Classify(ip IP) policyTableEntry
				Classify returns the policyTableEntry of the entry with the longest
				matching prefix that contains ip.
				The table t must be sorted from largest mask size to smallest.

		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var rfc6724policyTable

	 type policyTableEntry (struct)

		Fields (total 3, all are exported)
			Label uint8
			Precedence uint8
			Prefix *IPNet

	 type rawConn (struct)

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			fd *netFD
		Methods (total 4, in which 3 are exported)
			(*T) Control(f func(uintptr)) error
			(*T) Read(f func(uintptr) bool) error
			(*T) Write(f func(uintptr) bool) error
			/* one unexported ... *//* one unexported: */
			(*T) ok() bool
		Implements (at least one exported)
			*T : syscall.RawConn
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newRawConn(fd *netFD) (*rawConn, error)

	 type rawListener (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			rawConn rawConn
			rawConn.fd *netFD
		Methods (total 4, in which 3 are exported)
			(*T) Control(f func(uintptr)) error
			(*T) Read(func(uintptr) bool) error
			(*T) Write(func(uintptr) bool) error
			/* one unexported ... *//* one unexported: */
			(*T) ok() bool
		Implements (at least one exported)
			*T : syscall.RawConn
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newRawListener(fd *netFD) (*rawListener, error)

	 type resolverConfig (struct)
		A resolverConfig represents a DNS stub resolver configuration.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			ch chan struct{}
				ch is used as a semaphore that only allows one lookup at a
				time to recheck resolv.conf.
				// guards lastChecked and modTime

			dnsConfig *dnsConfig
				// parsed resolv.conf structure used in lookups

			initOnce sync.Once
				// guards init of resolverConfig

			lastChecked time.Time
				// last time resolv.conf was checked

			mu sync.RWMutex
				// protects dnsConfig

		Methods (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) init()
				init initializes conf and is only called via conf.initOnce.

			(*T) releaseSema()
			(*T) tryAcquireSema() bool
			(*T) tryUpdate(name string)
				tryUpdate tries to update conf with the named resolv.conf file.
				The name variable only exists for testing. It is otherwise always
				"/etc/resolv.conf".

		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var resolvConf

	 type scope uint8 (basic type)
		RFC 6724 section 3.1.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func classifyScope(ip IP) scope
		As Types Of (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 unexporteds: */
			const scopeAdminLocal
			const scopeGlobal
			const scopeInterfaceLocal
			const scopeLinkLocal
			const scopeOrgLocal
			const scopeSiteLocal

	 type sockaddr (interface)
		A sockaddr represents a TCP, UDP, IP or Unix network endpoint
		address that can be converted into a syscall.Sockaddr.

		Methods (total 6, in which 2 are exported)
			( T) Network() string
				// name of the network (for example, "tcp", "udp")

			( T) String() string
				// string form of address (for example, "192.0.2.1:25", "[2001:db8::1]:80")

			/* 4 unexporteds ... *//* 4 unexporteds: */
			( T) family() int
				family returns the platform-dependent address family
				identifier.

			( T) isWildcard() bool
				isWildcard reports whether the address is a wildcard
				address.

			( T) sockaddr(family int) (syscall.Sockaddr, error)
				sockaddr returns the address converted into a syscall
				sockaddr type that implements syscall.Sockaddr
				interface. It returns a nil interface when the address is
				nil.

			( T) toLocal(net string) sockaddr
				toLocal maps the zero address to a local system address (127.0.0.1 or ::1)

		Implemented By (at least 4, all are exported)
			*IPAddr
			*TCPAddr
			*UDPAddr
			*UnixAddr
		Implements (at least 4, in which 2 are exported)
			 T : Addr
			 T : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 T : context.stringer
			 T : runtime.stringer
		As Outputs Of (at least 4, none are exported)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func (*IPAddr).toLocal(net string) sockaddr
			func (*TCPAddr).toLocal(net string) sockaddr
			func (*UDPAddr).toLocal(net string) sockaddr
			func (*UnixAddr).toLocal(net string) sockaddr
		As Inputs Of (at least 4, none are exported)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func favoriteAddrFamily(network string, laddr, raddr sockaddr, mode string) (family int, ipv6only bool)
			func internetSocket(ctx context.Context, net string, laddr, raddr sockaddr, sotype, proto int, mode string, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error)
			func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error)
			func unixSocket(ctx context.Context, net string, laddr, raddr sockaddr, mode string, ctrlFn func(string, string, syscall.RawConn) error) (*netFD, error)

	 type sysDialer (struct)
		sysDialer contains a Dial's parameters and configuration.

		Fields (total 12, in which 10 are exported)
			Dialer Dialer
			Dialer.Cancel <-chan struct{}
				Cancel is an optional channel whose closure indicates that
				the dial should be canceled. Not all types of dials support
				cancellation.

				Deprecated: Use DialContext instead.

			Dialer.Control func(network, address string, c syscall.RawConn) error
				If Control is not nil, it is called after creating the network
				connection but before actually dialing.

				Network and address parameters passed to Control method are not
				necessarily the ones passed to Dial. For example, passing "tcp" to Dial
				will cause the Control function to be called with "tcp4" or "tcp6".

			Dialer.Deadline time.Time
				Deadline is the absolute point in time after which dials
				will fail. If Timeout is set, it may fail earlier.
				Zero means no deadline, or dependent on the operating system
				as with the Timeout option.

			Dialer.DualStack bool
				DualStack previously enabled RFC 6555 Fast Fallback
				support, also known as "Happy Eyeballs", in which IPv4 is
				tried soon if IPv6 appears to be misconfigured and
				hanging.

				Deprecated: Fast Fallback is enabled by default. To
				disable, set FallbackDelay to a negative value.

			Dialer.FallbackDelay time.Duration
				FallbackDelay specifies the length of time to wait before
				spawning a RFC 6555 Fast Fallback connection. That is, this
				is the amount of time to wait for IPv6 to succeed before
				assuming that IPv6 is misconfigured and falling back to
				IPv4.

				If zero, a default delay of 300ms is used.
				A negative value disables Fast Fallback support.

			Dialer.KeepAlive time.Duration
				KeepAlive specifies the interval between keep-alive
				probes for an active network connection.
				If zero, keep-alive probes are sent with a default value
				(currently 15 seconds), if supported by the protocol and operating
				system. Network protocols or operating systems that do
				not support keep-alives ignore this field.
				If negative, keep-alive probes are disabled.

			Dialer.LocalAddr Addr
				LocalAddr is the local address to use when dialing an
				address. The address must be of a compatible type for the
				network being dialed.
				If nil, a local address is automatically chosen.

			Dialer.Resolver *Resolver
				Resolver optionally specifies an alternate resolver to use.

			Dialer.Timeout time.Duration
				Timeout is the maximum amount of time a dial will wait for
				a connect to complete. If Deadline is also set, it may fail
				earlier.

				The default is no timeout.

				When using TCP and dialing a host name with multiple IP
				addresses, the timeout may be divided between them.

				With or without a timeout, the operating system may impose
				its own earlier timeout. For instance, TCP timeouts are
				often around 3 minutes.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			address string
			network string
		Methods (total 14, in which 2 are exported)
			(*T) Dial(network, address string) (Conn, error)
				Dial connects to the address on the named network.

				See func Dial for a description of the network and address
				parameters.

			(*T) DialContext(ctx context.Context, network, address string) (Conn, error)
				DialContext connects to the address on the named network using
				the provided context.

				The provided Context must be non-nil. If the context expires before
				the connection is complete, an error is returned. Once successfully
				connected, any expiration of the context will not affect the
				connection.

				When using TCP, and the host in the address parameter resolves to multiple
				network addresses, any dial timeout (from d.Timeout or ctx) is spread
				over each consecutive dial, such that each is given an appropriate
				fraction of the time to connect.
				For example, if a host has 4 IP addresses and the timeout is 1 minute,
				the connect to each single address will be given 15 seconds to complete
				before trying the next one.

				See func Dial for a description of the network and address
				parameters.

			/* 12 unexporteds ... *//* 12 unexporteds: */
			(*T) deadline(ctx context.Context, now time.Time) (earliest time.Time)
				deadline returns the earliest of:
				  - now+Timeout
				  - d.Deadline
				  - the context's deadline
				Or zero, if none of Timeout, Deadline, or context's deadline is set.

			(*T) dialIP(ctx context.Context, laddr, raddr *IPAddr) (*IPConn, error)
			(*T) dialParallel(ctx context.Context, primaries, fallbacks addrList) (Conn, error)
				dialParallel races two copies of dialSerial, giving the first a
				head start. It returns the first established connection and
				closes the others. Otherwise it returns an error from the first
				primary address.

			(*T) dialSerial(ctx context.Context, ras addrList) (Conn, error)
				dialSerial connects to a list of addresses in sequence, returning
				either the first successful connection, or the first error.

			(*T) dialSingle(ctx context.Context, ra Addr) (c Conn, err error)
				dialSingle attempts to establish and returns a single connection to
				the destination address.

			(*T) dialTCP(ctx context.Context, laddr, raddr *TCPAddr) (*TCPConn, error)
			(*T) dialUDP(ctx context.Context, laddr, raddr *UDPAddr) (*UDPConn, error)
			(*T) dialUnix(ctx context.Context, laddr, raddr *UnixAddr) (*UnixConn, error)
			(*T) doDialTCP(ctx context.Context, laddr, raddr *TCPAddr) (*TCPConn, error)
			(*T) dualStack() bool
			(*T) fallbackDelay() time.Duration
			(*T) resolver() *Resolver

	 type sysListener (struct)
		sysListener contains a Listen's parameters and configuration.

		Fields (total 5, in which 3 are exported)
			ListenConfig ListenConfig
			ListenConfig.Control func(network, address string, c syscall.RawConn) error
				If Control is not nil, it is called after creating the network
				connection but before binding it to the operating system.

				Network and address parameters passed to Control method are not
				necessarily the ones passed to Listen. For example, passing "tcp" to
				Listen will cause the Control function to be called with "tcp4" or "tcp6".

			ListenConfig.KeepAlive time.Duration
				KeepAlive specifies the keep-alive period for network
				connections accepted by this listener.
				If zero, keep-alives are enabled if supported by the protocol
				and operating system. Network protocols or operating systems
				that do not support keep-alives ignore this field.
				If negative, keep-alives are disabled.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			address string
			network string
		Methods (total 8, in which 2 are exported)
			(*T) Listen(ctx context.Context, network, address string) (Listener, error)
				Listen announces on the local network address.

				See func Listen for a description of the network and address
				parameters.

			(*T) ListenPacket(ctx context.Context, network, address string) (PacketConn, error)
				ListenPacket announces on the local network address.

				See func ListenPacket for a description of the network and address
				parameters.

			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*T) listenIP(ctx context.Context, laddr *IPAddr) (*IPConn, error)
			(*T) listenMulticastUDP(ctx context.Context, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error)
			(*T) listenTCP(ctx context.Context, laddr *TCPAddr) (*TCPListener, error)
			(*T) listenUDP(ctx context.Context, laddr *UDPAddr) (*UDPConn, error)
			(*T) listenUnix(ctx context.Context, laddr *UnixAddr) (*UnixListener, error)
			(*T) listenUnixgram(ctx context.Context, laddr *UnixAddr) (*UnixConn, error)

	 type temporary (interface)

		Methods (only one, which is exported)
			( T) Temporary() bool
		Implemented By (at least 15, in which 10 are exported)
			*AddrError
			*DNSConfigError
			*DNSError
			 Error (interface)
			 InvalidAddrError
			*OpError
			 UnknownNetworkError
			*net/url.Error
			*internal/poll.DeadlineExceededError
			 syscall.Errno
			/* 5+ unexporteds ... *//* 5+ unexporteds: */
			 addrinfoErrno
			*timeoutError
			 context.deadlineExceededError
			*crypto/tls.permanentError
			 crypto/tls.timeoutError

	 type timeout (interface)

		Methods (only one, which is exported)
			( T) Timeout() bool
		Implemented By (at least 18, in which 12 are exported)
			*AddrError
			*DNSConfigError
			*DNSError
			 Error (interface)
			 InvalidAddrError
			*OpError
			 UnknownNetworkError
			*net/url.Error
			*internal/poll.DeadlineExceededError
			*io/fs.PathError
			*os.SyscallError
			 syscall.Errno
			/* 6+ unexporteds ... *//* 6+ unexporteds: */
			 addrinfoErrno
			*timeoutError
			 context.deadlineExceededError
			*crypto/tls.permanentError
			 crypto/tls.timeoutError
			 os.timeout (interface)
		Implements (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			 T : os.timeout

	 type timeoutError (struct)

		Methods (total 3, all are exported)
			(*T) Error() string
			(*T) Temporary() bool
			(*T) Timeout() bool
		Implements (at least 5, in which 2 are exported)
			*T : Error
			*T : error
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*T : temporary
			*T : timeout
			*T : os.timeout

	 type writerOnly (struct)

		Fields (only one, which is exported)
			Writer io.Writer
		Methods (only one, which is exported)
			( T) Write(p []byte) (n int, err error)
		Implements (at least one exported)
			 T : io.Writer


Package-Level Functions (total 218, in which 43 are exported)

	 func CIDRMask(ones, bits int) IPMask
		CIDRMask returns an IPMask consisting of 'ones' 1 bits
		followed by 0s up to a total length of 'bits' bits.
		For a mask of this form, CIDRMask is the inverse of IPMask.Size.

	 func Dial(network, address string) (Conn, error)
		Dial connects to the address on the named network.

		Known networks are "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only),
		"udp", "udp4" (IPv4-only), "udp6" (IPv6-only), "ip", "ip4"
		(IPv4-only), "ip6" (IPv6-only), "unix", "unixgram" and
		"unixpacket".

		For TCP and UDP networks, the address has the form "host:port".
		The host must be a literal IP address, or a host name that can be
		resolved to IP addresses.
		The port must be a literal port number or a service name.
		If the host is a literal IPv6 address it must be enclosed in square
		brackets, as in "[2001:db8::1]:80" or "[fe80::1%zone]:80".
		The zone specifies the scope of the literal IPv6 address as defined
		in RFC 4007.
		The functions JoinHostPort and SplitHostPort manipulate a pair of
		host and port in this form.
		When using TCP, and the host resolves to multiple IP addresses,
		Dial will try each IP address in order until one succeeds.

		Examples:
			Dial("tcp", "golang.org:http")
			Dial("tcp", "192.0.2.1:http")
			Dial("tcp", "198.51.100.1:80")
			Dial("udp", "[2001:db8::1]:domain")
			Dial("udp", "[fe80::1%lo0]:53")
			Dial("tcp", ":80")

		For IP networks, the network must be "ip", "ip4" or "ip6" followed
		by a colon and a literal protocol number or a protocol name, and
		the address has the form "host". The host must be a literal IP
		address or a literal IPv6 address with zone.
		It depends on each operating system how the operating system
		behaves with a non-well known protocol number such as "0" or "255".

		Examples:
			Dial("ip4:1", "192.0.2.1")
			Dial("ip6:ipv6-icmp", "2001:db8::1")
			Dial("ip6:58", "fe80::1%lo0")

		For TCP, UDP and IP networks, if the host is empty or a literal
		unspecified IP address, as in ":80", "0.0.0.0:80" or "[::]:80" for
		TCP and UDP, "", "0.0.0.0" or "::" for IP, the local system is
		assumed.

		For Unix networks, the address must be a file system path.

	 func DialIP(network string, laddr, raddr *IPAddr) (*IPConn, error)
		DialIP acts like Dial for IP networks.

		The network must be an IP network name; see func Dial for details.

		If laddr is nil, a local address is automatically chosen.
		If the IP field of raddr is nil or an unspecified IP address, the
		local system is assumed.

	 func DialTCP(network string, laddr, raddr *TCPAddr) (*TCPConn, error)
		DialTCP acts like Dial for TCP networks.

		The network must be a TCP network name; see func Dial for details.

		If laddr is nil, a local address is automatically chosen.
		If the IP field of raddr is nil or an unspecified IP address, the
		local system is assumed.

	 func DialTimeout(network, address string, timeout time.Duration) (Conn, error)
		DialTimeout acts like Dial but takes a timeout.

		The timeout includes name resolution, if required.
		When using TCP, and the host in the address parameter resolves to
		multiple IP addresses, the timeout is spread over each consecutive
		dial, such that each is given an appropriate fraction of the time
		to connect.

		See func Dial for a description of the network and address
		parameters.

	 func DialUDP(network string, laddr, raddr *UDPAddr) (*UDPConn, error)
		DialUDP acts like Dial for UDP networks.

		The network must be a UDP network name; see func Dial for details.

		If laddr is nil, a local address is automatically chosen.
		If the IP field of raddr is nil or an unspecified IP address, the
		local system is assumed.

	 func DialUnix(network string, laddr, raddr *UnixAddr) (*UnixConn, error)
		DialUnix acts like Dial for Unix networks.

		The network must be a Unix network name; see func Dial for details.

		If laddr is non-nil, it is used as the local address for the
		connection.

	 func FileConn(f *os.File) (c Conn, err error)
		FileConn returns a copy of the network connection corresponding to
		the open file f.
		It is the caller's responsibility to close f when finished.
		Closing c does not affect f, and closing f does not affect c.

	 func FileListener(f *os.File) (ln Listener, err error)
		FileListener returns a copy of the network listener corresponding
		to the open file f.
		It is the caller's responsibility to close ln when finished.
		Closing ln does not affect f, and closing f does not affect ln.

	 func FilePacketConn(f *os.File) (c PacketConn, err error)
		FilePacketConn returns a copy of the packet network connection
		corresponding to the open file f.
		It is the caller's responsibility to close f when finished.
		Closing c does not affect f, and closing f does not affect c.

	 func InterfaceAddrs() ([]Addr, error)
		InterfaceAddrs returns a list of the system's unicast interface
		addresses.

		The returned list does not identify the associated interface; use
		Interfaces and Interface.Addrs for more detail.

	 func InterfaceByIndex(index int) (*Interface, error)
		InterfaceByIndex returns the interface specified by index.

		On Solaris, it returns one of the logical network interfaces
		sharing the logical data link; for more precision use
		InterfaceByName.

	 func InterfaceByName(name string) (*Interface, error)
		InterfaceByName returns the interface specified by name.

	 func Interfaces() ([]Interface, error)
		Interfaces returns a list of the system's network interfaces.

	 func IPv4(a, b, c, d byte) IP
		IPv4 returns the IP address (in 16-byte form) of the
		IPv4 address a.b.c.d.

	 func IPv4Mask(a, b, c, d byte) IPMask
		IPv4Mask returns the IP mask (in 4-byte form) of the
		IPv4 mask a.b.c.d.

	 func JoinHostPort(host, port string) string
		JoinHostPort combines host and port into a network address of the
		form "host:port". If host contains a colon, as found in literal
		IPv6 addresses, then JoinHostPort returns "[host]:port".

		See func Dial for a description of the host and port parameters.

	 func Listen(network, address string) (Listener, error)
		Listen announces on the local network address.

		The network must be "tcp", "tcp4", "tcp6", "unix" or "unixpacket".

		For TCP networks, if the host in the address parameter is empty or
		a literal unspecified IP address, Listen listens on all available
		unicast and anycast IP addresses of the local system.
		To only use IPv4, use network "tcp4".
		The address can use a host name, but this is not recommended,
		because it will create a listener for at most one of the host's IP
		addresses.
		If the port in the address parameter is empty or "0", as in
		"127.0.0.1:" or "[::1]:0", a port number is automatically chosen.
		The Addr method of Listener can be used to discover the chosen
		port.

		See func Dial for a description of the network and address
		parameters.

	 func ListenIP(network string, laddr *IPAddr) (*IPConn, error)
		ListenIP acts like ListenPacket for IP networks.

		The network must be an IP network name; see func Dial for details.

		If the IP field of laddr is nil or an unspecified IP address,
		ListenIP listens on all available IP addresses of the local system
		except multicast IP addresses.

	 func ListenMulticastUDP(network string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error)
		ListenMulticastUDP acts like ListenPacket for UDP networks but
		takes a group address on a specific network interface.

		The network must be a UDP network name; see func Dial for details.

		ListenMulticastUDP listens on all available IP addresses of the
		local system including the group, multicast IP address.
		If ifi is nil, ListenMulticastUDP uses the system-assigned
		multicast interface, although this is not recommended because the
		assignment depends on platforms and sometimes it might require
		routing configuration.
		If the Port field of gaddr is 0, a port number is automatically
		chosen.

		ListenMulticastUDP is just for convenience of simple, small
		applications. There are golang.org/x/net/ipv4 and
		golang.org/x/net/ipv6 packages for general purpose uses.

		Note that ListenMulticastUDP will set the IP_MULTICAST_LOOP socket option
		to 0 under IPPROTO_IP, to disable loopback of multicast packets.

	 func ListenPacket(network, address string) (PacketConn, error)
		ListenPacket announces on the local network address.

		The network must be "udp", "udp4", "udp6", "unixgram", or an IP
		transport. The IP transports are "ip", "ip4", or "ip6" followed by
		a colon and a literal protocol number or a protocol name, as in
		"ip:1" or "ip:icmp".

		For UDP and IP networks, if the host in the address parameter is
		empty or a literal unspecified IP address, ListenPacket listens on
		all available IP addresses of the local system except multicast IP
		addresses.
		To only use IPv4, use network "udp4" or "ip4:proto".
		The address can use a host name, but this is not recommended,
		because it will create a listener for at most one of the host's IP
		addresses.
		If the port in the address parameter is empty or "0", as in
		"127.0.0.1:" or "[::1]:0", a port number is automatically chosen.
		The LocalAddr method of PacketConn can be used to discover the
		chosen port.

		See func Dial for a description of the network and address
		parameters.

	 func ListenTCP(network string, laddr *TCPAddr) (*TCPListener, error)
		ListenTCP acts like Listen for TCP networks.

		The network must be a TCP network name; see func Dial for details.

		If the IP field of laddr is nil or an unspecified IP address,
		ListenTCP listens on all available unicast and anycast IP addresses
		of the local system.
		If the Port field of laddr is 0, a port number is automatically
		chosen.

	 func ListenUDP(network string, laddr *UDPAddr) (*UDPConn, error)
		ListenUDP acts like ListenPacket for UDP networks.

		The network must be a UDP network name; see func Dial for details.

		If the IP field of laddr is nil or an unspecified IP address,
		ListenUDP listens on all available IP addresses of the local system
		except multicast IP addresses.
		If the Port field of laddr is 0, a port number is automatically
		chosen.

	 func ListenUnix(network string, laddr *UnixAddr) (*UnixListener, error)
		ListenUnix acts like Listen for Unix networks.

		The network must be "unix" or "unixpacket".

	 func ListenUnixgram(network string, laddr *UnixAddr) (*UnixConn, error)
		ListenUnixgram acts like ListenPacket for Unix networks.

		The network must be "unixgram".

	 func LookupAddr(addr string) (names []string, err error)
		LookupAddr performs a reverse lookup for the given address, returning a list
		of names mapping to that address.

		The returned names are validated to be properly formatted presentation-format
		domain names.

		When using the host C library resolver, at most one result will be
		returned. To bypass the host resolver, use a custom Resolver.

	 func LookupCNAME(host string) (cname string, err error)
		LookupCNAME returns the canonical name for the given host.
		Callers that do not care about the canonical name can call
		LookupHost or LookupIP directly; both take care of resolving
		the canonical name as part of the lookup.

		A canonical name is the final name after following zero
		or more CNAME records.
		LookupCNAME does not return an error if host does not
		contain DNS "CNAME" records, as long as host resolves to
		address records.

		The returned canonical name is validated to be a properly
		formatted presentation-format domain name.

	 func LookupHost(host string) (addrs []string, err error)
		LookupHost looks up the given host using the local resolver.
		It returns a slice of that host's addresses.

	 func LookupIP(host string) ([]IP, error)
		LookupIP looks up host using the local resolver.
		It returns a slice of that host's IPv4 and IPv6 addresses.

	 func LookupMX(name string) ([]*MX, error)
		LookupMX returns the DNS MX records for the given domain name sorted by preference.

		The returned mail server names are validated to be properly
		formatted presentation-format domain names.

	 func LookupNS(name string) ([]*NS, error)
		LookupNS returns the DNS NS records for the given domain name.

		The returned name server names are validated to be properly
		formatted presentation-format domain names.

	 func LookupPort(network, service string) (port int, err error)
		LookupPort looks up the port for the given network and service.

	 func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err error)
		LookupSRV tries to resolve an SRV query of the given service,
		protocol, and domain name. The proto is "tcp" or "udp".
		The returned records are sorted by priority and randomized
		by weight within a priority.

		LookupSRV constructs the DNS name to look up following RFC 2782.
		That is, it looks up _service._proto.name. To accommodate services
		publishing SRV records under non-standard names, if both service
		and proto are empty strings, LookupSRV looks up name directly.

		The returned service names are validated to be properly
		formatted presentation-format domain names.

	 func LookupTXT(name string) ([]string, error)
		LookupTXT returns the DNS TXT records for the given domain name.

	 func ParseCIDR(s string) (IP, *IPNet, error)
		ParseCIDR parses s as a CIDR notation IP address and prefix length,
		like "192.0.2.0/24" or "2001:db8::/32", as defined in
		RFC 4632 and RFC 4291.

		It returns the IP address and the network implied by the IP and
		prefix length.
		For example, ParseCIDR("192.0.2.1/24") returns the IP address
		192.0.2.1 and the network 192.0.2.0/24.

	 func ParseIP(s string) IP
		ParseIP parses s as an IP address, returning the result.
		The string s can be in IPv4 dotted decimal ("192.0.2.1"), IPv6
		("2001:db8::68"), or IPv4-mapped IPv6 ("::ffff:192.0.2.1") form.
		If s is not a valid textual representation of an IP address,
		ParseIP returns nil.

	 func ParseMAC(s string) (hw HardwareAddr, err error)
		ParseMAC parses s as an IEEE 802 MAC-48, EUI-48, EUI-64, or a 20-octet
		IP over InfiniBand link-layer address using one of the following formats:
			00:00:5e:00:53:01
			02:00:5e:10:00:00:00:01
			00:00:00:00:fe:80:00:00:00:00:00:00:02:00:5e:10:00:00:00:01
			00-00-5e-00-53-01
			02-00-5e-10-00-00-00-01
			00-00-00-00-fe-80-00-00-00-00-00-00-02-00-5e-10-00-00-00-01
			0000.5e00.5301
			0200.5e10.0000.0001
			0000.0000.fe80.0000.0000.0000.0200.5e10.0000.0001

	 func Pipe() (Conn, Conn)
		Pipe creates a synchronous, in-memory, full duplex
		network connection; both ends implement the Conn interface.
		Reads on one end are matched with writes on the other,
		copying data directly between the two; there is no internal
		buffering.

	 func ResolveIPAddr(network, address string) (*IPAddr, error)
		ResolveIPAddr returns an address of IP end point.

		The network must be an IP network name.

		If the host in the address parameter is not a literal IP address,
		ResolveIPAddr resolves the address to an address of IP end point.
		Otherwise, it parses the address as a literal IP address.
		The address parameter can use a host name, but this is not
		recommended, because it will return at most one of the host name's
		IP addresses.

		See func Dial for a description of the network and address
		parameters.

	 func ResolveTCPAddr(network, address string) (*TCPAddr, error)
		ResolveTCPAddr returns an address of TCP end point.

		The network must be a TCP network name.

		If the host in the address parameter is not a literal IP address or
		the port is not a literal port number, ResolveTCPAddr resolves the
		address to an address of TCP end point.
		Otherwise, it parses the address as a pair of literal IP address
		and port number.
		The address parameter can use a host name, but this is not
		recommended, because it will return at most one of the host name's
		IP addresses.

		See func Dial for a description of the network and address
		parameters.

	 func ResolveUDPAddr(network, address string) (*UDPAddr, error)
		ResolveUDPAddr returns an address of UDP end point.

		The network must be a UDP network name.

		If the host in the address parameter is not a literal IP address or
		the port is not a literal port number, ResolveUDPAddr resolves the
		address to an address of UDP end point.
		Otherwise, it parses the address as a pair of literal IP address
		and port number.
		The address parameter can use a host name, but this is not
		recommended, because it will return at most one of the host name's
		IP addresses.

		See func Dial for a description of the network and address
		parameters.

	 func ResolveUnixAddr(network, address string) (*UnixAddr, error)
		ResolveUnixAddr returns an address of Unix domain socket end point.

		The network must be a Unix network name.

		See func Dial for a description of the network and address
		parameters.

	 func SplitHostPort(hostport string) (host, port string, err error)
		SplitHostPort splits a network address of the form "host:port",
		"host%zone:port", "[host]:port" or "[host%zone]:port" into host or
		host%zone and port.

		A literal IPv6 address in hostport must be enclosed in square
		brackets, as in "[::1]:80", "[::1%lo0]:80".

		See func Dial for a description of the hostport parameter, and host
		and port results.

	/* 175 unexporteds ... *//* 175 unexporteds: */
	 func absDomainName(b []byte) string
		absDomainName returns an absolute domain name which ends with a
		trailing dot to match pure Go reverse resolver and all other lookup
		routines.
		See golang.org/issue/12189.
		But we don't want to add dots for local names from /etc/hosts.
		It's hard to tell so we settle on the heuristic that names without dots
		(like "localhost" or "myhost") do not get trailing dots, but any other
		names do.

	 func acquireThread()
	 func allFF(b []byte) bool
	 func appendHex(dst []byte, i uint32) []byte
		Convert i to a hexadecimal string. Leading zeros are not printed.

	 func avoidDNS(name string) bool
		avoidDNS reports whether this is a hostname for which we should not
		use DNS. Currently this includes only .onion, per RFC 7686. See
		golang.org/issue/13705. Does not cover .local names (RFC 6762),
		see golang.org/issue/16739.

	 func boolint(b bool) int
		Boolean to int.

	 func cgoLookupCNAME(ctx context.Context, name string) (cname string, err error, completed bool)
	 func cgoLookupHost(ctx context.Context, name string) (addrs []string, err error, completed bool)
	 func cgoLookupIP(ctx context.Context, network, name string) (addrs []IPAddr, err error, completed bool)
	 func cgoLookupPort(ctx context.Context, network, service string) (port int, err error, completed bool)
	 func cgoLookupPTR(ctx context.Context, addr string) (ptrs []string, err error, completed bool)
	 func checkHeader(p *dnsmessage.Parser, h dnsmessage.Header) error
		checkHeader performs basic sanity checks on the header.

	 func checkResponse(reqID uint16, reqQues dnsmessage.Question, respHdr dnsmessage.Header, respQues dnsmessage.Question) bool
	 func classifyScope(ip IP) scope
	 func commonPrefixLen(a, b IP) (cpl int)
		commonPrefixLen reports the length of the longest prefix (looking
		at the most significant, or leftmost, bits) that the
		two addresses have in common, up to the length of a's prefix (i.e.,
		the portion of the address not including the interface ID).

		If a or b is an IPv4 address as an IPv6 address, the IPv4 addresses
		are compared (with max common prefix length of 32).
		If a and b are different IP versions, 0 is returned.

		See https://tools.ietf.org/html/rfc6724#section-2.2

	 func concurrentThreadsLimit() int
		concurrentThreadsLimit returns the number of threads we permit to
		run concurrently doing DNS lookups via cgo. A DNS lookup may use a
		file descriptor so we limit this to less than the number of
		permitted open files. On some systems, notably Darwin, if
		getaddrinfo is unable to open a file descriptor it simply returns
		EAI_NONAME rather than a useful error. Limiting the number of
		concurrent getaddrinfo calls to less than the permitted number of
		file descriptors makes that error less likely. We don't bother to
		apply the same limit to DNS lookups run directly from Go, because
		there we will return a meaningful "too many open files" error.

	 func count(s string, b byte) int
		Number of occurrences of b in s.

	 func countAnyByte(s string, t string) int
		Count occurrences in s of any bytes in t.

	 func dnsDefaultSearch() []string
	 func dnsPacketRoundTrip(c Conn, id uint16, query dnsmessage.Question, b []byte) (dnsmessage.Parser, dnsmessage.Header, error)
	 func dnsReadConfig(filename string) *dnsConfig
		See resolv.conf(5) on a Linux machine.

	 func dnsStreamRoundTrip(c Conn, id uint16, query dnsmessage.Question, b []byte) (dnsmessage.Parser, dnsmessage.Header, error)
	 func dtoi(s string) (n int, i int, ok bool)
		Decimal to integer.
		Returns number, characters consumed, success.

	 func dupSocket(f *os.File) (int, error)
	 func ensureRooted(s string) string
	 func equalASCIIName(x, y dnsmessage.Name) bool
	 func fastrand() uint32
		provided by runtime

	 func favoriteAddrFamily(network string, laddr, raddr sockaddr, mode string) (family int, ipv6only bool)
		favoriteAddrFamily returns the appropriate address family for the
		given network, laddr, raddr and mode.

		If mode indicates "listen" and laddr is a wildcard, we assume that
		the user wants to make a passive-open connection with a wildcard
		address family, both AF_INET and AF_INET6, and a wildcard address
		like the following:

			- A listen for a wildcard communication domain, "tcp" or
			  "udp", with a wildcard address: If the platform supports
			  both IPv6 and IPv4-mapped IPv6 communication capabilities,
			  or does not support IPv4, we use a dual stack, AF_INET6 and
			  IPV6_V6ONLY=0, wildcard address listen. The dual stack
			  wildcard address listen may fall back to an IPv6-only,
			  AF_INET6 and IPV6_V6ONLY=1, wildcard address listen.
			  Otherwise we prefer an IPv4-only, AF_INET, wildcard address
			  listen.

			- A listen for a wildcard communication domain, "tcp" or
			  "udp", with an IPv4 wildcard address: same as above.

			- A listen for a wildcard communication domain, "tcp" or
			  "udp", with an IPv6 wildcard address: same as above.

			- A listen for an IPv4 communication domain, "tcp4" or "udp4",
			  with an IPv4 wildcard address: We use an IPv4-only, AF_INET,
			  wildcard address listen.

			- A listen for an IPv6 communication domain, "tcp6" or "udp6",
			  with an IPv6 wildcard address: We use an IPv6-only, AF_INET6
			  and IPV6_V6ONLY=1, wildcard address listen.

		Otherwise guess: If the addresses are IPv4 then returns AF_INET,
		or else returns AF_INET6. It also returns a boolean value what
		designates IPV6_V6ONLY option.

		Note that the latest DragonFly BSD and OpenBSD kernels allow
		neither "net.inet6.ip6.v6only=1" change nor IPPROTO_IPV6 level
		IPV6_V6ONLY socket option setting.

	 func fileConn(f *os.File) (Conn, error)
	 func fileListener(f *os.File) (Listener, error)
	 func filePacketConn(f *os.File) (PacketConn, error)
	 func filterAddrList(filter func(IPAddr) bool, ips []IPAddr, inetaddr func(IPAddr) Addr, originalAddr string) (addrList, error)
		filterAddrList applies a filter to a list of IP addresses,
		yielding a list of Addr objects. Known filters are nil, ipv4only,
		and ipv6only. It returns every address when the filter is nil.
		The result contains at least one address when error is nil.

	 func foreachField(x []byte, fn func(field []byte) error) error
		foreachField runs fn on each non-empty run of non-space bytes in x.
		It returns the first non-nil error returned by fn.

	 func foreachLine(x []byte, fn func(line []byte) error) error
		foreachLine runs fn on each line of x.
		Each line (except for possibly the last) ends in '\n'.
		It returns the first non-nil error returned by fn.

	 func genericReadFrom(w io.Writer, r io.Reader) (n int64, err error)
		Fallback implementation of io.ReaderFrom's ReadFrom, when sendfile isn't
		applicable.

	 func getFields(s string) []string
	 func goDebugNetDNS() (dnsMode string, debugLevel int)
		goDebugNetDNS parses the value of the GODEBUG "netdns" value.
		The netdns value can be of the form:
		   1       // debug level 1
		   2       // debug level 2
		   cgo     // use cgo for DNS lookups
		   go      // use go for DNS lookups
		   cgo+1   // use cgo for DNS lookups + debug level 1
		   1+cgo   // same
		   cgo+2   // same, but debug level 2
		etc.

	 func goDebugString(key string) string
		goDebugString returns the value of the named GODEBUG key.
		GODEBUG is of the form "key=val,key2=val2"

	 func goLookupIPFiles(name string) (addrs []IPAddr)
		lookup entries from /etc/hosts

	 func goLookupPort(network, service string) (port int, err error)
		goLookupPort is the native Go implementation of LookupPort.

	 func hasPrefix(s, prefix string) bool
	 func hexString(b []byte) string
	 func init()
	 func init()
	 func initConfVal()
	 func interfaceAddrTable(ifi *Interface) ([]Addr, error)
		If the ifi is nil, interfaceAddrTable returns addresses for all
		network interfaces. Otherwise it returns addresses for a specific
		interface.

	 func interfaceByIndex(ift []Interface, index int) (*Interface, error)
	 func interfaceMessages(ifindex int) ([]route.Message, error)
	 func interfaceMulticastAddrTable(ifi *Interface) ([]Addr, error)
		interfaceMulticastAddrTable returns addresses for a specific
		interface.

	 func interfaceTable(ifindex int) ([]Interface, error)
		If the ifindex is zero, interfaceTable returns mappings of all
		network interfaces. Otherwise it returns a mapping of a specific
		interface.

	 func interfaceToIPv4Addr(ifi *Interface) (IP, error)
	 func internetSocket(ctx context.Context, net string, laddr, raddr sockaddr, sotype, proto int, mode string, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error)
	 func ipAddrsEface(addrs []IPAddr) []interface{}
		ipAddrsEface returns an empty interface slice of addrs.

	 func ipAttrOf(ip IP) ipAttr
	 func ipEmptyString(ip IP) string
		ipEmptyString is like ip.String except that it returns
		an empty string when ip is unset.

	 func ipToSockaddr(family int, ip IP, port int, zone string) (syscall.Sockaddr, error)
	 func ipv4AddrToInterface(ip IP) (*Interface, error)
	 func ipv4only(addr IPAddr) bool
		ipv4only reports whether addr is an IPv4 address.

	 func ipv6only(addr IPAddr) bool
		ipv6only reports whether addr is an IPv6 address except IPv4-mapped IPv6 address.

	 func ipVersion(network string) byte
		ipVersion returns the provided network's IP version: '4', '6' or 0
		if network does not end in a '4' or '6' byte.

	 func isClosedChan(c <-chan struct{}) bool
	 func isConnError(err error) bool
	 func isDomainName(s string) bool
		isDomainName checks if a string is a presentation-format domain name
		(currently restricted to hostname-compatible "preferred name" LDH labels and
		SRV-like "underscore labels"; see golang.org/issue/12421).

	 func isGateway(h string) bool
		isGateway reports whether h should be considered a "gateway"
		name for the myhostname NSS module.

	 func isIPv4(addr Addr) bool
		isIPv4 reports whether addr contains an IPv4 address.

	 func isLocalhost(h string) bool
		isLocalhost reports whether h should be considered a "localhost"
		name for the myhostname NSS module.

	 func isNotIPv4(addr Addr) bool
		isNotIPv4 reports whether addr does not contain an IPv4 address.

	 func isSpace(b byte) bool
		isSpace reports whether b is an ASCII space character.

	 func isZeros(p IP) bool
		Is p all zeros?

	 func itoa(val int) string
		Convert integer to decimal string.

	 func joinIPv4Group(fd *netFD, ifi *Interface, ip IP) error
	 func joinIPv6Group(fd *netFD, ifi *Interface, ip IP) error
	 func last(s string, b byte) int
		Index of rightmost occurrence of b in s.

	 func linkFlags(rawFlags int) Flags
	 func listenerBacklog() int
		listenerBacklog is a caching wrapper around maxListenerBacklog.

	 func listenIPv4MulticastUDP(c *UDPConn, ifi *Interface, ip IP) error
	 func listenIPv6MulticastUDP(c *UDPConn, ifi *Interface, ip IP) error
	 func lookupIPReturn(addrsi interface{}, err error, shared bool) ([]IPAddr, error)
		lookupIPReturn turns the return values from singleflight.Do into
		the return values from LookupIP.

	 func lookupPortMap(network, service string) (port int, error error)
	 func lookupProtocol(_ context.Context, name string) (int, error)
		lookupProtocol looks up IP protocol name in /etc/protocols and
		returns correspondent protocol number.

	 func lookupProtocolMap(name string) (int, error)
	 func lookupStaticAddr(addr string) []string
		lookupStaticAddr looks up the hosts for the given address from /etc/hosts.

	 func lookupStaticHost(host string) []string
		lookupStaticHost looks up the addresses for the given host from /etc/hosts.

	 func loopbackIP(net string) IP
	 func lowerASCII(b byte) byte
		lowerASCII returns the ASCII lowercase version of b.

	 func lowerASCIIBytes(x []byte)
		lowerASCIIBytes makes x ASCII lowercase in-place.

	 func makePipeDeadline() pipeDeadline
	 func mapErr(err error) error
		mapErr maps from the context errors to the historical internal net
		error values.

		TODO(bradfitz): get rid of this after adjusting tests and making
		context.DeadlineExceeded implement net.Error?

	 func maxListenerBacklog() int
	 func minNonzeroTime(a, b time.Time) time.Time
	 func mustCIDR(s string) *IPNet
		mustCIDR calls ParseCIDR and panics on any error, or if the network
		is not IPv6.

	 func networkNumberAndMask(n *IPNet) (ip IP, m IPMask)
	 func newFD(sysfd, family, sotype int, net string) (*netFD, error)
	 func newFileFD(f *os.File) (*netFD, error)
	 func newIPConn(fd *netFD) *IPConn
	 func newRawConn(fd *netFD) (*rawConn, error)
	 func newRawListener(fd *netFD) (*rawListener, error)
	 func newRequest(q dnsmessage.Question) (id uint16, udpReq, tcpReq []byte, err error)
	 func newTCPConn(fd *netFD) *TCPConn
	 func newUDPConn(fd *netFD) *UDPConn
	 func newUnixConn(fd *netFD) *UnixConn
	 func open(name string) (*file, error)
	 func parseCriteria(x []byte) (c []nssCriterion, err error)
		parses "foo=bar !foo=bar"

	 func parseIPv4(s string) IP
		Parse IPv4 address (d.d.d.d).

	 func parseIPv6(s string) (ip IP)
		parseIPv6 parses s as a literal IPv6 address described in RFC 4291
		and RFC 5952.

	 func parseIPv6Zone(s string) (IP, string)
		parseIPv6Zone parses s as a literal IPv6 address and its associated zone
		identifier which is described in RFC 4007.

	 func parseIPZone(s string) (IP, string)
		parseIPZone parses s as an IP address, return it and its associated zone
		identifier (IPv6 only).

	 func parseLiteralIP(addr string) string
	 func parseNetwork(ctx context.Context, network string, needsProto bool) (afnet string, proto int, err error)
	 func parseNSSConf(r io.Reader) *nssConf
	 func parseNSSConfFile(file string) *nssConf
	 func parsePort(service string) (port int, needsLookup bool)
		parsePort parses service as a decimal integer and returns the
		corresponding value as port. It is the caller's responsibility to
		parse service as a non-decimal integer when needsLookup is true.

		Some system resolvers will return a valid port number when given a number
		over 65536 (see https://golang.org/issues/11715). Alas, the parser
		can't bail early on numbers > 65536. Therefore reasonably large/small
		numbers are parsed in full and rejected if invalid.

	 func partialDeadline(now, deadline time.Time, addrsRemaining int) (time.Time, error)
		partialDeadline returns the deadline to use for a single address,
		when multiple addresses are pending.

	 func randInt() int
	 func randIntn(n int) int
	 func readFull(r io.Reader) (all []byte, err error)
	 func readHosts()
	 func readProtocols()
		readProtocols loads contents of /etc/protocols into protocols map
		for quick access.

	 func readServices()
	 func releaseThread()
	 func removeComment(line []byte) []byte
		removeComment returns line, removing any '#' byte and any following
		bytes.

	 func reverseaddr(addr string) (arpa string, err error)
		reverseaddr returns the in-addr.arpa. or ip6.arpa. hostname of the IP
		address addr suitable for rDNS (PTR) record lookup or an error if it fails
		to parse the IP address.

	 func roundDurationUp(d time.Duration, to time.Duration) time.Duration
		roundDurationUp rounds d to the next multiple of to.

	 func selfConnect(fd *netFD, err error) bool
	 func sendFile(c *netFD, r io.Reader) (n int64, err error, handled bool)
	 func setDefaultListenerSockopts(s int) error
	 func setDefaultMulticastSockopts(s int) error
	 func setDefaultSockopts(s, family, sotype int, ipv6only bool) error
	 func setIPv4MreqToInterface(mreq *syscall.IPMreq, ifi *Interface) error
	 func setIPv4MulticastInterface(fd *netFD, ifi *Interface) error
	 func setIPv4MulticastLoopback(fd *netFD, v bool) error
	 func setIPv6MulticastInterface(fd *netFD, ifi *Interface) error
	 func setIPv6MulticastLoopback(fd *netFD, v bool) error
	 func setKeepAlive(fd *netFD, keepalive bool) error
	 func setKeepAlivePeriod(fd *netFD, d time.Duration) error
	 func setLinger(fd *netFD, sec int) error
	 func setNoDelay(fd *netFD, noDelay bool) error
	 func setReadBuffer(fd *netFD, bytes int) error
	 func setWriteBuffer(fd *netFD, bytes int) error
	 func simpleMaskLength(mask IPMask) int
		If mask is a sequence of 1 bits followed by 0 bits,
		return the number of 1 bits.

	 func skipToAnswer(p *dnsmessage.Parser, qtype dnsmessage.Type) error
	 func sockaddrToIP(sa syscall.Sockaddr) Addr
	 func sockaddrToTCP(sa syscall.Sockaddr) Addr
	 func sockaddrToUDP(sa syscall.Sockaddr) Addr
	 func sockaddrToUnix(sa syscall.Sockaddr) Addr
	 func sockaddrToUnixgram(sa syscall.Sockaddr) Addr
	 func sockaddrToUnixpacket(sa syscall.Sockaddr) Addr
	 func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error)
		socket returns a network file descriptor that is ready for
		asynchronous I/O using the network poller.

	 func sortByRFC6724(addrs []IPAddr)
	 func sortByRFC6724withSrcs(addrs []IPAddr, srcs []IP)
	 func sotypeToNet(sotype int) string
	 func splice(c *netFD, r io.Reader) (int64, error, bool)
	 func splitAtBytes(s string, t string) []string
		Split s at any bytes in t.

	 func splitHostZone(s string) (host, zone string)
	 func spuriousENOTAVAIL(err error) bool
	 func srcAddrs(addrs []IPAddr) []IP
		srcsAddrs tries to UDP-connect to each address to see if it has a
		route. (This doesn't send any packets). The destination port
		number is irrelevant.

	 func stat(name string) (mtime time.Time, size int64, err error)
	 func stringsEqualFold(s, t string) bool
		stringsEqualFold is strings.EqualFold, ASCII only. It reports whether s and t
		are equal, ASCII-case-insensitively.

	 func stringsHasPrefix(s, prefix string) bool
		stringsHasPrefix is strings.HasPrefix. It reports whether s begins with prefix.

	 func stringsHasSuffix(s, suffix string) bool
		stringsHasSuffix is strings.HasSuffix. It reports whether s ends in
		suffix.

	 func stringsHasSuffixFold(s, suffix string) bool
		stringsHasSuffixFold reports whether s ends in suffix,
		ASCII-case-insensitively.

	 func stripIPv4Header(n int, b []byte) int
	 func supportsIPv4() bool
		supportsIPv4 reports whether the platform supports IPv4 networking
		functionality.

	 func supportsIPv4map() bool
		supportsIPv4map reports whether the platform supports mapping an
		IPv4 address inside an IPv6 address at transport layer
		protocols. See RFC 4291, RFC 4038 and RFC 3493.

	 func supportsIPv6() bool
		supportsIPv6 reports whether the platform supports IPv6 networking
		functionality.

	 func sysSocket(family, sotype, proto int) (int, error)
		Wrapper around the socket system call that marks the returned file
		descriptor as nonblocking and close-on-exec.

	 func systemConf() *conf
		systemConf returns the machine's network configuration.

	 func trimSpace(x []byte) []byte
		trimSpace returns x without any leading or trailing ASCII whitespace.

	 func ubtoa(dst []byte, start int, v byte) int
		ubtoa encodes the string form of the integer v to dst[start:] and
		returns the number of bytes written to dst. The caller must ensure
		that dst has sufficient length.

	 func uitoa(val uint) string
		Convert unsigned integer to decimal string.

	 func unixSocket(ctx context.Context, net string, laddr, raddr sockaddr, mode string, ctrlFn func(string, string, syscall.RawConn) error) (*netFD, error)
	 func withUnexpiredValuesPreserved(lookupCtx context.Context) context.Context
		withUnexpiredValuesPreserved returns a context.Context that only uses lookupCtx
		for its values, otherwise it is never canceled and has no deadline.
		If the lookup context expires, any looked up values will return nil.
		See Issue 28600.

	 func wrapSyscallError(name string, err error) error
		wrapSyscallError takes an error and a syscall name. If the error is
		a syscall.Errno, it wraps it in a os.SyscallError using the syscall name.

	 func xtoi(s string) (n int, i int, ok bool)
		Hexadecimal to integer.
		Returns number, characters consumed, success.

	 func xtoi2(s string, e byte) (byte, bool)
		xtoi2 converts the next two hex digits of s into a byte.
		If s is longer than 2 bytes then the third byte must be e.
		If the first two bytes of s are not hex digits or the third byte
		does not match e, false is returned.


Package-Level Variables (total 69, in which 13 are exported)

	  var DefaultResolver *Resolver
		DefaultResolver is the resolver used by the package-level Lookup
		functions and by Dialers without a specified Resolver.

	  var ErrClosed error
		ErrClosed is the error returned by an I/O call on a network
		connection that has already been closed, or that is closed by
		another goroutine before the I/O is completed. This may be wrapped
		in another error, and should normally be tested using
		errors.Is(err, net.ErrClosed).

	  var ErrWriteToConnected error
		Various errors contained in OpError.

	  var IPv4allrouter IP // all routers
		Well-known IPv4 addresses

	  var IPv4allsys IP // all systems
		Well-known IPv4 addresses

	  var IPv4bcast IP // limited broadcast
		Well-known IPv4 addresses

	  var IPv4zero IP // all zeros
		Well-known IPv4 addresses

	  var IPv6interfacelocalallnodes IP
		Well-known IPv6 addresses

	  var IPv6linklocalallnodes IP
		Well-known IPv6 addresses

	  var IPv6linklocalallrouters IP
		Well-known IPv6 addresses

	  var IPv6loopback IP
		Well-known IPv6 addresses

	  var IPv6unspecified IP
		Well-known IPv6 addresses

	  var IPv6zero IP
		Well-known IPv6 addresses

	/* 56 unexporteds ... *//* 56 unexporteds: */
	  var aLongTimeAgo time.Time
		aLongTimeAgo is a non-zero time, far in the past, used for
		immediate cancellation of dials.

	  var classAMask IPMask
		Default route masks for IPv4.

	  var classBMask IPMask
		Default route masks for IPv4.

	  var classCMask IPMask
		Default route masks for IPv4.

	  var confOnce sync.Once // guards init of confVal via initConfVal
	  var confVal *conf
	  var connectFunc (int, syscall.Sockaddr) error
	  var defaultNS []string
	  var dnsWaitGroup sync.WaitGroup
		dnsWaitGroup can be used by tests to wait for all DNS goroutines to
		complete. This avoids races on the test hooks.

	  var errCanceled error
		For both read and write operations.

	  var errCannotMarshalDNSMessage error
	  var errCannotUnmarshalDNSMessage error
	  var errClosed error
		errClosed exists just so that the docs for ErrClosed don't mention
		the internal package poll.

	  var errInvalidDNSResponse error
	  var errInvalidInterface error
	  var errInvalidInterfaceIndex error
	  var errInvalidInterfaceName error
	  var errLameReferral error
	  var errMissingAddress error
		For connection setup and write operations.

	  var errNoAnswerFromDNSServer error
	  var errNoSuchHost error
		Various errors contained in DNSError.

	  var errNoSuchInterface error
	  var errNoSuchMulticastInterface error
	  var errNoSuitableAddress error
		For connection setup operations.

	  var errServerMisbehaving error
	  var errServerTemporarilyMisbehaving error
		errServerTemporarilyMisbehaving is like errServerMisbehaving, except
		that when it gets translated to a DNSError, the IsTemporary field
		gets set to true.

	  var errTimeout error
		errTimeout exists to return the historical "i/o timeout" string
		for context.DeadlineExceeded. See mapErr.
		It is also used when Dialer.Deadline is exceeded.

		TODO(iant): We could consider changing this to os.ErrDeadlineExceeded
		in the future, but note that that would conflict with the TODO
		at mapErr that suggests changing it to context.DeadlineExceeded.

	  var flagNames []string
	  var getHostname func() (name string, err error) // variable for testing
	  var getsockoptIntFunc (int, int, int) (int, error)
	  var hosts struct{sync.Mutex; byName map[string][]string; byAddr map[string][]string; expire time.Time; path string; mtime time.Time; size int64}
		hosts contains known host entries.

	  var ipStackCaps ipStackCapabilities
	  var listenerBacklogCache struct{sync.Once; val int}
	  var listenFunc (int, int) error
	  var lookupOrderName map[hostLookupOrder]string
	  var netCgo bool // set true in conf_netcgo.go for build tag "netcgo"
		netGo and netCgo contain the state of the build tags used
		to build this binary, and whether cgo is available.
		conf.go mirrors these into conf for easier testing.

	  var netGo bool // set true in cgo_stub.go for build tag "netgo" (or no cgo)
		netGo and netCgo contain the state of the build tags used
		to build this binary, and whether cgo is available.
		conf.go mirrors these into conf for easier testing.

	  var noCancel chan struct{}
	  var noDeadline time.Time
		nonDeadline and noCancel are just zero values for
		readability with functions taking too many parameters.

	  var onceReadProtocols sync.Once
	  var onceReadServices sync.Once
	  var protocols map[string]int
		protocols contains minimal mappings between internet protocol
		names and numbers for platforms that don't have a complete list of
		protocol numbers.

		See https://www.iana.org/assignments/protocol-numbers

		On Unix, this map is augmented by readProtocols via lookupProtocol.

	  var resolvConf resolverConfig
	  var rfc6724policyTable policyTable
		RFC 6724 section 2.1.

	  var services map[string]map[string]int
		services contains minimal mappings between services names and port
		numbers for platforms that don't have a complete list of port numbers.

		See https://www.iana.org/assignments/service-names-port-numbers

		On Unix, this map is augmented by readServices via goLookupPort.

	  var socketFunc (int, int, int) (int, error)
		Placeholders for socket system calls.

	  var testHookCanceledDial func() // for golang.org/issue/16523
	  var testHookDialChannel func() // for golang.org/issue/5349
	  var testHookDialTCP (ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error)
		if non-nil, overrides dialTCP.

	  var testHookHostsPath string
	  var testHookLookupIP func(ctx context.Context, fn func(context.Context, string, string) ([]IPAddr, error), network string, host string) ([]IPAddr, error)
	  var testHookSetKeepAlive func(time.Duration)
	  var threadLimit chan struct{}
	  var threadOnce sync.Once
	  var v4InV6Prefix []byte
	  var zoneCache ipv6ZoneCache
Package-Level Constants (total 33, in which 7 are exported)

	const FlagBroadcast Flags = 2 // interface supports broadcast access capability
	const FlagLoopback Flags = 4 // interface is a loopback interface
	const FlagMulticast Flags = 16 // interface supports multicast access capability
	const FlagPointToPoint Flags = 8 // interface belongs to a point-to-point link
	const FlagUp Flags = 1 // interface is up
	const IPv4len = 4
		IP address lengths (bytes).

	const IPv6len = 16
		IP address lengths (bytes).

	/* 26 unexporteds ... *//* 26 unexporteds: */
	const big = 16777215
		Bigger than we need, not too big to worry about overflow

	const cacheMaxAge time.Duration = 5000000000
	const defaultTCPKeepAlive time.Duration = 15000000000
		defaultTCPKeepAlive is a default constant value for TCPKeepAlive times
		See golang.org/issue/31510

	const hexDigit = "0123456789abcdef"
	const hostLookupCgo hostLookupOrder = 0
		hostLookupCgo means defer to cgo.

	const hostLookupDNS hostLookupOrder = 4 // only DNS
	const hostLookupDNSFiles hostLookupOrder = 2 // dns first
	const hostLookupFiles hostLookupOrder = 3 // only files
	const hostLookupFilesDNS hostLookupOrder = 1 // files first
	const maxPortBufSize int = 25
		maxPortBufSize is the longest reasonable name of a service
		(non-numeric port).
		Currently the longest known IANA-unregistered name is
		"mobility-header", so we use that length, plus some slop in case
		something longer is added in the future.

	const maxProtoLength int = 25 // with room to grow
	const readFromSyscallName = "recvfrom"
	const readMsgSyscallName = "recvmsg"
	const readSyscallName = "read"
	const scopeAdminLocal scope = 4
	const scopeGlobal scope = 14
	const scopeInterfaceLocal scope = 1
	const scopeLinkLocal scope = 2
	const scopeOrgLocal scope = 8
	const scopeSiteLocal scope = 5
	const sysTCP_KEEPINTVL = 257
		syscall.TCP_KEEPINTVL is missing on some darwin architectures.

	const useTCPOnly = true
		to be used as a useTCP parameter to exchange

	const useUDPOrTCP = false
	const writeMsgSyscallName = "sendmsg"
	const writeSyscallName = "write"
	const writeToSyscallName = "sendto"