package net

Import Path
	net (on go.dev)

Dependency Relation
	imports 23 packages, and imported by 18 packages

Involved Source Files

	    addrselect.go
	    cgo_stub.go
	    conf.go
	    dial.go
	    dnsclient.go
	    dnsclient_unix.go
	    dnsconfig.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_linux.go
	    ip.go
	    iprawsock.go
	    iprawsock_posix.go
	    ipsock.go
	    ipsock_posix.go
	    lookup.go
	    lookup_unix.go
	    mac.go
	    mptcpsock_linux.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.
		
		On Unix the pure Go resolver is preferred over the cgo resolver, 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.
		
		On all systems (except Plan 9), when the cgo resolver is being used
		this package applies a concurrent cgo lookup limit to prevent the system
		from running out of system threads. Currently, it is limited to 500 concurrent lookups.
		
		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 native resolver (cgo, win32)
		
		The decision can also be forced while building the Go source tree
		by setting the netgo or netcgo build tag.
		The netgo build tag disables entirely the use of the native (CGO) resolver,
		meaning the Go resolver is the only one that can be used.
		With the netcgo build tag the native and the pure Go resolver are compiled into the binary,
		but the native (CGO) resolver is preferred over the Go resolver.
		With netcgo, the Go resolver can still be forced at runtime with GODEBUG=netdns=go.
		
		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.
		
		The Go resolver will send an EDNS0 additional header with a DNS request,
		to signal a willingness to accept a larger DNS packet size.
		This can reportedly cause sporadic failures with the DNS server run
		by some modems and routers. Setting GODEBUG=netedns0=0 will disable
		sending the additional header.
		
		On macOS, if Go code that uses the net package is built with
		-buildmode=c-archive, linking the resulting archive into a C program
		requires passing -lresolv when linking the C code.
		
		On Plan 9, the resolver always accesses /net/cs and /net/dns.
		
		On Windows, in Go 1.18.x and earlier, the resolver always used C
		library functions, such as GetAddrInfo and DnsQuery.

	    netcgo_off.go
	    netgo_off.go
	    nss.go
	    parse.go
	    pipe.go
	    port.go
	    port_unix.go
	    rawconn.go
	    rlimit_unix.go
	    sendfile_linux.go
	    sock_cloexec.go
	    sock_linux.go
	    sock_posix.go
	    sockaddr_posix.go
	    sockopt_linux.go
	    sockopt_posix.go
	    sockoptip_linux.go
	    sockoptip_posix.go
	    splice_linux.go
	    tcpsock.go
	    tcpsock_posix.go
	    tcpsock_unix.go
	    tcpsockopt_posix.go
	    tcpsockopt_unix.go
	    udpsock.go
	    udpsock_posix.go
	    unixsock.go
	    unixsock_posix.go
	    unixsock_readmsg_cmsg_cloexec.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_Equal
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv4DNS := net.ParseIP("8.8.8.8")
			ipv4Lo := net.ParseIP("127.0.0.1")
			ipv6DNS := net.ParseIP("0:0:0:0:0:FFFF:0808:0808")
		
			fmt.Println(ipv4DNS.Equal(ipv4DNS))
			fmt.Println(ipv4DNS.Equal(ipv4Lo))
			fmt.Println(ipv4DNS.Equal(ipv6DNS))
		
		}

	IP_IsGlobalUnicast
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv6Global := net.ParseIP("2000::")
			ipv6UniqLocal := net.ParseIP("2000::")
			ipv6Multi := net.ParseIP("FF00::")
		
			ipv4Private := net.ParseIP("10.255.0.0")
			ipv4Public := net.ParseIP("8.8.8.8")
			ipv4Broadcast := net.ParseIP("255.255.255.255")
		
			fmt.Println(ipv6Global.IsGlobalUnicast())
			fmt.Println(ipv6UniqLocal.IsGlobalUnicast())
			fmt.Println(ipv6Multi.IsGlobalUnicast())
		
			fmt.Println(ipv4Private.IsGlobalUnicast())
			fmt.Println(ipv4Public.IsGlobalUnicast())
			fmt.Println(ipv4Broadcast.IsGlobalUnicast())
		
		}

	IP_IsInterfaceLocalMulticast
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv6InterfaceLocalMulti := net.ParseIP("ff01::1")
			ipv6Global := net.ParseIP("2000::")
			ipv4 := net.ParseIP("255.0.0.0")
		
			fmt.Println(ipv6InterfaceLocalMulti.IsInterfaceLocalMulticast())
			fmt.Println(ipv6Global.IsInterfaceLocalMulticast())
			fmt.Println(ipv4.IsInterfaceLocalMulticast())
		
		}

	IP_IsLinkLocalMulticast
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv6LinkLocalMulti := net.ParseIP("ff02::2")
			ipv6LinkLocalUni := net.ParseIP("fe80::")
			ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")
			ipv4LinkLocalUni := net.ParseIP("169.254.0.0")
		
			fmt.Println(ipv6LinkLocalMulti.IsLinkLocalMulticast())
			fmt.Println(ipv6LinkLocalUni.IsLinkLocalMulticast())
			fmt.Println(ipv4LinkLocalMulti.IsLinkLocalMulticast())
			fmt.Println(ipv4LinkLocalUni.IsLinkLocalMulticast())
		
		}

	IP_IsLinkLocalUnicast
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv6LinkLocalUni := net.ParseIP("fe80::")
			ipv6Global := net.ParseIP("2000::")
			ipv4LinkLocalUni := net.ParseIP("169.254.0.0")
			ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")
		
			fmt.Println(ipv6LinkLocalUni.IsLinkLocalUnicast())
			fmt.Println(ipv6Global.IsLinkLocalUnicast())
			fmt.Println(ipv4LinkLocalUni.IsLinkLocalUnicast())
			fmt.Println(ipv4LinkLocalMulti.IsLinkLocalUnicast())
		
		}

	IP_IsLoopback
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv6Lo := net.ParseIP("::1")
			ipv6 := net.ParseIP("ff02::1")
			ipv4Lo := net.ParseIP("127.0.0.0")
			ipv4 := net.ParseIP("128.0.0.0")
		
			fmt.Println(ipv6Lo.IsLoopback())
			fmt.Println(ipv6.IsLoopback())
			fmt.Println(ipv4Lo.IsLoopback())
			fmt.Println(ipv4.IsLoopback())
		
		}

	IP_IsMulticast
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv6Multi := net.ParseIP("FF00::")
			ipv6LinkLocalMulti := net.ParseIP("ff02::1")
			ipv6Lo := net.ParseIP("::1")
			ipv4Multi := net.ParseIP("239.0.0.0")
			ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")
			ipv4Lo := net.ParseIP("127.0.0.0")
		
			fmt.Println(ipv6Multi.IsMulticast())
			fmt.Println(ipv6LinkLocalMulti.IsMulticast())
			fmt.Println(ipv6Lo.IsMulticast())
			fmt.Println(ipv4Multi.IsMulticast())
			fmt.Println(ipv4LinkLocalMulti.IsMulticast())
			fmt.Println(ipv4Lo.IsMulticast())
		
		}

	IP_IsPrivate
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv6Private := net.ParseIP("fc00::")
			ipv6Public := net.ParseIP("fe00::")
			ipv4Private := net.ParseIP("10.255.0.0")
			ipv4Public := net.ParseIP("11.0.0.0")
		
			fmt.Println(ipv6Private.IsPrivate())
			fmt.Println(ipv6Public.IsPrivate())
			fmt.Println(ipv4Private.IsPrivate())
			fmt.Println(ipv4Public.IsPrivate())
		
		}

	IP_IsUnspecified
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv6Unspecified := net.ParseIP("::")
			ipv6Specified := net.ParseIP("fe00::")
			ipv4Unspecified := net.ParseIP("0.0.0.0")
			ipv4Specified := net.ParseIP("8.8.8.8")
		
			fmt.Println(ipv6Unspecified.IsUnspecified())
			fmt.Println(ipv6Specified.IsUnspecified())
			fmt.Println(ipv4Unspecified.IsUnspecified())
			fmt.Println(ipv4Specified.IsUnspecified())
		
		}

	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))
		
		}

	IP_String
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
			ipv4 := net.IPv4(10, 255, 0, 0)
		
			fmt.Println(ipv6.String())
			fmt.Println(ipv4.String())
		
		}

	IP_To16
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
			ipv4 := net.IPv4(10, 255, 0, 0)
		
			fmt.Println(ipv6.To16())
			fmt.Println(ipv4.To16())
		
		}

	IP_to4
		package main
		
		import (
			"fmt"
			"net"
		)
		
		func main() {
			ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
			ipv4 := net.IPv4(10, 255, 0, 0)
		
			fmt.Println(ipv6.To4())
			fmt.Println(ipv4.To4())
		
		}

	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 36)

	/* sort by: alphabet | popularity */
	 type Addr (interface)
		Addr represents a network end point address.
		
		The two methods [Addr.Network] and [Addr.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)
			( Addr) Network() string
				// name of the network (for example, "tcp", "udp")

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

		Implemented By (at least 5)
			*IPAddr
			*IPNet
			*TCPAddr
			*UDPAddr
			*UnixAddr
		Implements (at least 2)
			 Addr : expvar.Var
			 Addr : fmt.Stringer
		As Outputs Of (at least 15)
			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
		As Inputs Of (at least 4)
			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)

	 type AddrError (struct)

		Fields (total 2)
			Addr string
			Err string
		Methods (total 3)
			(*AddrError) Error() string
			(*AddrError) Temporary() bool
			(*AddrError) Timeout() bool
		Implements (at least 2)
			*AddrError : Error
			*AddrError : error

	 type Buffers ([])
		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 2)
			(*Buffers) Read(p []byte) (n int, err error)
				Read from the buffers.
				
				Read implements [io.Reader] for [Buffers].
				
				Read modifies the slice v as well as v[i] for 0 <= i < len(v),
				but does not modify v[i][j] for any i, j.

			(*Buffers) WriteTo(w io.Writer) (n int64, err error)
				WriteTo writes contents of the buffers to w.
				
				WriteTo implements [io.WriterTo] for [Buffers].
				
				WriteTo modifies the slice v as well as v[i] for 0 <= i < len(v),
				but does not modify v[i][j] for any i, j.

		Implements (at least 2)
			*Buffers : io.Reader
			*Buffers : 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)
			( Conn) Close() error
				Close closes the connection.
				Any blocked Read or Write operations will be unblocked and return errors.

			( Conn) LocalAddr() Addr
				LocalAddr returns the local network address, if known.

			( Conn) 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.

			( Conn) RemoteAddr() Addr
				RemoteAddr returns the remote network address, if known.

			( Conn) 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.

			( Conn) 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.

			( Conn) 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.

			( Conn) 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 5)
			*IPConn
			*TCPConn
			*UDPConn
			*UnixConn
			*crypto/tls.Conn
		Implements (at least 8)
			 Conn : internal/bisect.Writer
			 Conn : io.Closer
			 Conn : io.ReadCloser
			 Conn : io.Reader
			 Conn : io.ReadWriteCloser
			 Conn : io.ReadWriter
			 Conn : io.WriteCloser
			 Conn : io.Writer
		As Outputs Of (at least 17)
			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 net/http.Hijacker.Hijack() (Conn, *bufio.ReadWriter, error)
			func net/http.(*ResponseController).Hijack() (Conn, *bufio.ReadWriter, error)
			func net/http/httputil.(*ClientConn).Hijack() (c Conn, r *bufio.Reader)
			func net/http/httputil.(*ServerConn).Hijack() (Conn, *bufio.Reader)
			func crypto/tls.(*Conn).NetConn() Conn
			func crypto/tls.(*Dialer).Dial(network, addr string) (Conn, error)
			func crypto/tls.(*Dialer).DialContext(ctx context.Context, network, addr string) (Conn, error)
		As Inputs Of (at least 6)
			func net/http/httputil.NewClientConn(c Conn, r *bufio.Reader) *httputil.ClientConn
			func net/http/httputil.NewProxyClientConn(c Conn, r *bufio.Reader) *httputil.ClientConn
			func net/http/httputil.NewServerConn(c Conn, r *bufio.Reader) *httputil.ServerConn
			func net/smtp.NewClient(conn Conn, host string) (*smtp.Client, error)
			func crypto/tls.Client(conn Conn, config *tls.Config) *tls.Conn
			func crypto/tls.Server(conn Conn, config *tls.Config) *tls.Conn

	 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 11)
			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 function are not
				necessarily the ones passed to Dial. Calling Dial with TCP networks
				will cause the Control function to be called with "tcp4" or "tcp6",
				UDP networks become "udp4" or "udp6", IP networks become "ip4" or "ip6",
				and other known networks are passed as-is.
				
				Control is ignored if ControlContext is not nil.

			ControlContext func(ctx context.Context, network, address string, c syscall.RawConn) error
				If ControlContext is not nil, it is called after creating the network
				connection but before actually dialing.
				
				Network and address parameters passed to ControlContext function are not
				necessarily the ones passed to Dial. Calling Dial with TCP networks
				will cause the ControlContext function to be called with "tcp4" or "tcp6",
				UDP networks become "udp4" or "udp6", IP networks become "ip4" or "ip6",
				and other known networks are passed as-is.
				
				If ControlContext is not nil, Control is ignored.

			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.
				
				KeepAlive is ignored if KeepAliveConfig.Enable is true.
				
				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-alive ignore this field.
				If negative, keep-alive probes are disabled.

			KeepAliveConfig KeepAliveConfig
				KeepAliveConfig specifies the keep-alive probe configuration
				for an active network connection, when supported by the
				protocol and operating system.
				
				If KeepAliveConfig.Enable is true, keep-alive probes are enabled.
				If KeepAliveConfig.Enable is false and KeepAlive is 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 4)
			(*Dialer) 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.
				
				Dial uses [context.Background] internally; to specify the context, use
				[Dialer.DialContext].

			(*Dialer) 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.

			(*Dialer) MultipathTCP() bool
				MultipathTCP reports whether MPTCP will be used.
				
				This method doesn't check if MPTCP is supported by the operating
				system or not.

			(*Dialer) SetMultipathTCP(use bool)
				SetMultipathTCP directs the [Dial] methods to use, or not use, MPTCP,
				if supported by the operating system. This method overrides the
				system default and the GODEBUG=multipathtcp=... setting if any.
				
				If MPTCP is not available on the host or not supported by the server,
				the Dial methods will fall back to TCP.

		As Inputs Of (at least one exported)
			func crypto/tls.DialWithDialer(dialer *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)
			Err error
		Methods (total 4)
			(*DNSConfigError) Error() string
			(*DNSConfigError) Temporary() bool
			(*DNSConfigError) Timeout() bool
			(*DNSConfigError) Unwrap() error
		Implements (at least 2)
			*DNSConfigError : Error
			*DNSConfigError : error

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

		Fields (total 7)
			Err string
				// description of the error

			IsNotFound bool
				IsNotFound is set to true when the requested name does not
				contain any records of the requested type (data not found),
				or the name itself was not found (NXDOMAIN).

			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

			UnwrapErr error
				// error returned by the [DNSError.Unwrap] method, might be nil

		Methods (total 4)
			(*DNSError) Error() string
			(*DNSError) 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.

			(*DNSError) 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.

			(*DNSError) Unwrap() error
				Unwrap returns e.UnwrapErr.

		Implements (at least 2)
			*DNSError : Error
			*DNSError : error

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

		Methods (total 3)
			( Error) Error() builtin.string
			( Error) Temporary() bool
				Deprecated: Temporary errors are not well-defined.
				Most "temporary" errors are timeouts, and the few exceptions are surprising.
				Do not use this method.

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

		Implemented By (at least 10)
			*AddrError
			*DNSConfigError
			*DNSError
			 InvalidAddrError
			*OpError
			*ParseError
			 UnknownNetworkError
			*net/url.Error
			*internal/poll.DeadlineExceededError
			 syscall.Errno
		Implements (at least one exported)
			 Error : error

	 type Flags uint (basic type)

		Methods (only one)
			( Flags) String() string
		Implements (at least 2)
			 Flags : expvar.Var
			 Flags : fmt.Stringer
		As Inputs Of (at least one exported)
			func vendor/golang.org/x/net/nettest.RoutedInterface(network string, flags Flags) (*Interface, error)
		As Types Of (total 6)
			const FlagBroadcast
			const FlagLoopback
			const FlagMulticast
			const FlagPointToPoint
			const FlagRunning
			const FlagUp

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

		Methods (only one)
			( HardwareAddr) String() string
		Implements (at least 2)
			 HardwareAddr : expvar.Var
			 HardwareAddr : fmt.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)
			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)
			(*Interface) Addrs() ([]Addr, error)
				Addrs returns a list of unicast interface addresses for a specific
				interface.

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

		As Outputs Of (at least 5)
			func InterfaceByIndex(index int) (*Interface, error)
			func InterfaceByName(name string) (*Interface, error)
			func Interfaces() ([]Interface, error)
			func vendor/golang.org/x/net/nettest.LoopbackInterface() (*Interface, error)
			func vendor/golang.org/x/net/nettest.RoutedInterface(network string, flags Flags) (*Interface, error)
		As Inputs Of (at least 2)
			func ListenMulticastUDP(network string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error)
			func vendor/golang.org/x/net/nettest.MulticastSource(network string, ifi *Interface) (IP, error)

	 type InvalidAddrError string (basic type)

		Methods (total 3)
			( InvalidAddrError) Error() string
			( InvalidAddrError) Temporary() bool
			( InvalidAddrError) Timeout() bool
		Implements (at least 2)
			 InvalidAddrError : Error
			 InvalidAddrError : error

	 type IP ([])
		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 17)
			( IP) AppendText(b []byte) ([]byte, error)
				AppendText implements the [encoding.TextAppender] interface.
				The encoding is the same as returned by [IP.String], with one exception:
				When len(ip) is zero, it appends nothing.

			( IP) 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.

			( IP) 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.

			( IP) 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.

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

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

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

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

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

			( IP) IsPrivate() bool
				IsPrivate reports whether ip is a private address, according to
				RFC 1918 (IPv4 addresses) and RFC 4193 (IPv6 addresses).

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

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

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

			( IP) 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 conforming to RFC 5952 ("2001:db8::1"), if ip is a valid IPv6 address
				  - the hexadecimal form of ip, without punctuation, if no other cases apply

			( IP) 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.

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

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

		Implements (at least 5)
			 IP : encoding.TextAppender
			 IP : encoding.TextMarshaler
			*IP : encoding.TextUnmarshaler
			 IP : expvar.Var
			 IP : fmt.Stringer
		As Outputs Of (at least 9)
			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)
			func vendor/golang.org/x/net/nettest.MulticastSource(network string, ifi *Interface) (IP, error)
		As Inputs Of (at least 2)
			func IP.Equal(x IP) bool
			func (*IPNet).Contains(ip IP) bool
		As Types Of (total 10)
			  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)
			IP IP
			Zone string
				// IPv6 scoped addressing zone

		Methods (total 2)
			(*IPAddr) Network() string
				Network returns the address's network name, "ip".

			(*IPAddr) String() string
		Implements (at least 3)
			*IPAddr : Addr
			*IPAddr : expvar.Var
			*IPAddr : fmt.Stringer
		As Outputs Of (at least 4)
			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)
		As Inputs Of (at least 4)
			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)

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

		Methods (total 18)
			(*IPConn) Close() error
				Close closes the connection.

			(*IPConn) 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.

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

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

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

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

			(*IPConn) 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.

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

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

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

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

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

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

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

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

			(*IPConn) 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.

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

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

		Implements (at least 11)
			*IPConn : Conn
			*IPConn : PacketConn
			*IPConn : internal/bisect.Writer
			*IPConn : io.Closer
			*IPConn : io.ReadCloser
			*IPConn : io.Reader
			*IPConn : io.ReadWriteCloser
			*IPConn : io.ReadWriter
			*IPConn : io.WriteCloser
			*IPConn : io.Writer
			*IPConn : syscall.Conn
		As Outputs Of (at least 2)
			func DialIP(network string, laddr, raddr *IPAddr) (*IPConn, error)
			func ListenIP(network string, laddr *IPAddr) (*IPConn, error)

	 type IPMask ([])
		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)
			( IPMask) 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.

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

		Implements (at least 2)
			 IPMask : expvar.Var
			 IPMask : fmt.Stringer
		As Outputs Of (at least 3)
			func CIDRMask(ones, bits int) IPMask
			func IPv4Mask(a, b, c, d byte) IPMask
			func IP.DefaultMask() IPMask
		As Inputs Of (at least one exported)
			func IP.Mask(mask IPMask) IP

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

		Fields (total 2)
			IP IP
				// network number

			Mask IPMask
				// network mask

		Methods (total 3)
			(*IPNet) Contains(ip IP) bool
				Contains reports whether the network includes ip.

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

			(*IPNet) 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 3)
			*IPNet : Addr
			*IPNet : expvar.Var
			*IPNet : fmt.Stringer
		As Outputs Of (at least one exported)
			func ParseCIDR(s string) (IP, *IPNet, error)

	 type KeepAliveConfig (struct)
		KeepAliveConfig contains TCP keep-alive options.
		
		If the Idle, Interval, or Count fields are zero, a default value is chosen.
		If a field is negative, the corresponding socket-level option will be left unchanged.
		
		Note that prior to Windows 10 version 1709, neither setting Idle and Interval
		separately nor changing Count (which is usually 10) is supported.
		Therefore, it's recommended to set both Idle and Interval to non-negative values
		in conjunction with a -1 for Count on those old Windows if you intend to customize
		the TCP keep-alive settings.
		By contrast, if only one of Idle and Interval is set to a non-negative value,
		the other will be set to the system default value, and ultimately,
		set both Idle and Interval to negative values if you want to leave them unchanged.
		
		Note that Solaris and its derivatives do not support setting Interval to a non-negative value
		and Count to a negative value, or vice-versa.

		Fields (total 4)
			Count int
				Count is the maximum number of keep-alive probes that
				can go unanswered before dropping a connection.
				If zero, a default value of 9 is used.

			Enable bool
				If Enable is true, keep-alive probes are enabled.

			Idle time.Duration
				Idle is the time that the connection must be idle before
				the first keep-alive probe is sent.
				If zero, a default value of 15 seconds is used.

			Interval time.Duration
				Interval is the time between keep-alive probes.
				If zero, a default value of 15 seconds is used.

		As Inputs Of (at least one exported)
			func (*TCPConn).SetKeepAliveConfig(config KeepAliveConfig) error

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

		Fields (total 3)
			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 function are not
				necessarily the ones passed to Listen. Calling Listen with TCP networks
				will cause the Control function to be called with "tcp4" or "tcp6",
				UDP networks become "udp4" or "udp6", IP networks become "ip4" or "ip6",
				and other known networks are passed as-is.

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

			KeepAliveConfig KeepAliveConfig
				KeepAliveConfig specifies the keep-alive probe configuration
				for an active network connection, when supported by the
				protocol and operating system.
				
				If KeepAliveConfig.Enable is true, keep-alive probes are enabled.
				If KeepAliveConfig.Enable is false and KeepAlive is negative,
				keep-alive probes are disabled.

		Methods (total 4)
			(*ListenConfig) 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.
				
				The ctx argument is used while resolving the address on which to listen;
				it does not affect the returned Listener.

			(*ListenConfig) 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.
				
				The ctx argument is used while resolving the address on which to listen;
				it does not affect the returned Listener.

			(*ListenConfig) MultipathTCP() bool
				MultipathTCP reports whether MPTCP will be used.
				
				This method doesn't check if MPTCP is supported by the operating
				system or not.

			(*ListenConfig) SetMultipathTCP(use bool)
				SetMultipathTCP directs the [Listen] method to use, or not use, MPTCP,
				if supported by the operating system. This method overrides the
				system default and the GODEBUG=multipathtcp=... setting if any.
				
				If MPTCP is not available on the host or not supported by the client,
				the Listen method will fall back to TCP.


	 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)
			( Listener) Accept() (Conn, error)
				Accept waits for and returns the next connection to the listener.

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

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

		Implemented By (at least 2)
			*TCPListener
			*UnixListener
		Implements (at least one exported)
			 Listener : io.Closer
		As Outputs Of (at least 6)
			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
			func vendor/golang.org/x/net/nettest.NewLocalListener(network string) (Listener, error)
		As Inputs Of (at least 8)
			func net/http.Serve(l Listener, handler http.Handler) error
			func net/http.ServeTLS(l Listener, handler http.Handler, certFile, keyFile string) error
			func net/http.(*Server).Serve(l Listener) error
			func net/http.(*Server).ServeTLS(l Listener, certFile, keyFile string) error
			func net/http/fcgi.Serve(l Listener, handler http.Handler) error
			func net/rpc.Accept(lis Listener)
			func net/rpc.(*Server).Accept(lis Listener)
			func crypto/tls.NewListener(inner Listener, config *tls.Config) Listener

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

		Fields (total 2)
			Host string
			Pref uint16
		As Outputs Of (at least 2)
			func LookupMX(name string) ([]*MX, error)
			func (*Resolver).LookupMX(ctx context.Context, name string) ([]*MX, error)

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

		Fields (only one)
			Host string
		As Outputs Of (at least 2)
			func LookupNS(name string) ([]*NS, error)
			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)
			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)
			(*OpError) Error() string
			(*OpError) Temporary() bool
			(*OpError) Timeout() bool
			(*OpError) Unwrap() error
		Implements (at least 2)
			*OpError : Error
			*OpError : error

	 type PacketConn (interface)
		PacketConn is a generic packet-oriented network connection.
		
		Multiple goroutines may invoke methods on a PacketConn simultaneously.

		Methods (total 7)
			( PacketConn) Close() error
				Close closes the connection.
				Any blocked ReadFrom or WriteTo operations will be unblocked and return errors.

			( PacketConn) LocalAddr() Addr
				LocalAddr returns the local network address, if known.

			( PacketConn) 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.

			( PacketConn) 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.

			( PacketConn) 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.

			( PacketConn) 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.

			( PacketConn) 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)
			*IPConn
			*UDPConn
			*UnixConn
		Implements (at least one exported)
			 PacketConn : io.Closer
		As Outputs Of (at least 4)
			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)
			func vendor/golang.org/x/net/nettest.NewLocalPacketListener(network string) (PacketConn, error)

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

		Fields (total 2)
			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 (total 3)
			(*ParseError) Error() string
			(*ParseError) Temporary() bool
			(*ParseError) Timeout() bool
		Implements (at least 2)
			*ParseError : Error
			*ParseError : error

	 type Resolver (struct)
		A Resolver looks up names and numbers.
		
		A nil *Resolver is equivalent to a zero Resolver.

		Fields (total 3)
			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.

		Methods (total 11)
			(*Resolver) 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. If the response contains invalid names, those records are filtered
				out and an error will be returned alongside the remaining results, if any.

			(*Resolver) 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.

			(*Resolver) 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.

			(*Resolver) 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".

			(*Resolver) 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.

			(*Resolver) 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. If the response contains
				invalid names, those records are filtered out and an error
				will be returned alongside the remaining results, if any.

			(*Resolver) 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. If the response contains
				invalid names, those records are filtered out and an error
				will be returned alongside the remaining results, if any.

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

			(*Resolver) LookupPort(ctx context.Context, network, service string) (port int, err error)
				LookupPort looks up the port for the given network and service.
				
				The network must be one of "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6" or "ip".

			(*Resolver) 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. If the response contains
				invalid names, those records are filtered out and an error
				will be returned alongside the remaining results, if any.

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

		As Types Of (only one)
			  var DefaultResolver *Resolver

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

		Fields (total 4)
			Port uint16
			Priority uint16
			Target string
			Weight uint16
		As Outputs Of (at least 2)
			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)

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

		Fields (total 3)
			IP IP
			Port int
			Zone string
				// IPv6 scoped addressing zone

		Methods (total 3)
			(*TCPAddr) AddrPort() netip.AddrPort
				AddrPort returns the [TCPAddr] a as a [netip.AddrPort].
				
				If a.Port does not fit in a uint16, it's silently truncated.
				
				If a is nil, a zero value is returned.

			(*TCPAddr) Network() string
				Network returns the address's network name, "tcp".

			(*TCPAddr) String() string
		Implements (at least 3)
			*TCPAddr : Addr
			*TCPAddr : expvar.Var
			*TCPAddr : fmt.Stringer
		As Outputs Of (at least 2)
			func ResolveTCPAddr(network, address string) (*TCPAddr, error)
			func TCPAddrFromAddrPort(addr netip.AddrPort) *TCPAddr
		As Inputs Of (at least 2)
			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.

		Methods (total 22)
			(*TCPConn) Close() error
				Close closes the connection.

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

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

			(*TCPConn) 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.

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

			(*TCPConn) MultipathTCP() (bool, error)
				MultipathTCP reports whether the ongoing connection is using MPTCP.
				
				If Multipath TCP is not supported by the host, by the other peer or
				intentionally / accidentally filtered out by a device in between, a
				fallback to TCP will be done. This method does its best to check if
				MPTCP is still being used or not.
				
				On Linux, more conditions are verified on kernels >= v5.16, improving
				the results.

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

			(*TCPConn) ReadFrom(r io.Reader) (int64, error)
				ReadFrom implements the [io.ReaderFrom] ReadFrom method.

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

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

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

			(*TCPConn) SetKeepAliveConfig(config KeepAliveConfig) error
				SetKeepAliveConfig configures keep-alive messages sent by the operating system.

			(*TCPConn) SetKeepAlivePeriod(d time.Duration) error
				SetKeepAlivePeriod sets the duration the connection needs to
				remain idle before TCP starts sending keepalive probes.
				
				Note that calling this method on Windows prior to Windows 10 version 1709
				will reset the KeepAliveInterval to the default system value, which is normally 1 second.

			(*TCPConn) 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 including Linux, this may cause Close to block
				until all data has been sent or discarded.
				On some operating systems after sec seconds have elapsed any remaining
				unsent data may be discarded.

			(*TCPConn) 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.

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

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

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

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

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

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

			(*TCPConn) WriteTo(w io.Writer) (int64, error)
				WriteTo implements the io.WriterTo WriteTo method.

		Implements (at least 12)
			*TCPConn : Conn
			*TCPConn : internal/bisect.Writer
			*TCPConn : io.Closer
			*TCPConn : io.ReadCloser
			*TCPConn : io.Reader
			*TCPConn : io.ReaderFrom
			*TCPConn : io.ReadWriteCloser
			*TCPConn : io.ReadWriter
			*TCPConn : io.WriteCloser
			*TCPConn : io.Writer
			*TCPConn : io.WriterTo
			*TCPConn : syscall.Conn
		As Outputs Of (at least 2)
			func DialTCP(network string, laddr, raddr *TCPAddr) (*TCPConn, error)
			func (*TCPListener).AcceptTCP() (*TCPConn, error)

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

		Methods (total 7)
			(*TCPListener) Accept() (Conn, error)
				Accept implements the Accept method in the [Listener] interface; it
				waits for the next call and returns a generic [Conn].

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

			(*TCPListener) 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.

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

			(*TCPListener) 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.

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

			(*TCPListener) 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.

		Implements (at least 3)
			*TCPListener : Listener
			*TCPListener : io.Closer
			*TCPListener : 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)
			IP IP
			Port int
			Zone string
				// IPv6 scoped addressing zone

		Methods (total 3)
			(*UDPAddr) AddrPort() netip.AddrPort
				AddrPort returns the [UDPAddr] a as a [netip.AddrPort].
				
				If a.Port does not fit in a uint16, it's silently truncated.
				
				If a is nil, a zero value is returned.

			(*UDPAddr) Network() string
				Network returns the address's network name, "udp".

			(*UDPAddr) String() string
		Implements (at least 3)
			*UDPAddr : Addr
			*UDPAddr : expvar.Var
			*UDPAddr : fmt.Stringer
		As Outputs Of (at least 4)
			func ResolveUDPAddr(network, address string) (*UDPAddr, error)
			func UDPAddrFromAddrPort(addr netip.AddrPort) *UDPAddr
			func (*UDPConn).ReadFromUDP(b []byte) (n int, addr *UDPAddr, err error)
			func (*UDPConn).ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error)
		As Inputs Of (at least 5)
			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)

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

		Methods (total 22)
			(*UDPConn) Close() error
				Close closes the connection.

			(*UDPConn) 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.

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

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

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

			(*UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err error)
				ReadFromUDP acts like [UDPConn.ReadFrom] but returns a UDPAddr.

			(*UDPConn) ReadFromUDPAddrPort(b []byte) (n int, addr netip.AddrPort, err error)
				ReadFromUDPAddrPort acts like ReadFrom but returns a [netip.AddrPort].
				
				If c is bound to an unspecified address, the returned
				netip.AddrPort's address might be an IPv4-mapped IPv6 address.
				Use [netip.Addr.Unmap] to get the address without the IPv6 prefix.

			(*UDPConn) 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.

			(*UDPConn) ReadMsgUDPAddrPort(b, oob []byte) (n, oobn, flags int, addr netip.AddrPort, err error)
				ReadMsgUDPAddrPort is like [UDPConn.ReadMsgUDP] but returns an [netip.AddrPort] instead of a [UDPAddr].

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

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

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

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

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

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

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

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

			(*UDPConn) 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.

			(*UDPConn) WriteMsgUDPAddrPort(b, oob []byte, addr netip.AddrPort) (n, oobn int, err error)
				WriteMsgUDPAddrPort is like [UDPConn.WriteMsgUDP] but takes a [netip.AddrPort] instead of a [UDPAddr].

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

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

			(*UDPConn) WriteToUDPAddrPort(b []byte, addr netip.AddrPort) (int, error)
				WriteToUDPAddrPort acts like [UDPConn.WriteTo] but takes a [netip.AddrPort].

		Implements (at least 11)
			*UDPConn : Conn
			*UDPConn : PacketConn
			*UDPConn : internal/bisect.Writer
			*UDPConn : io.Closer
			*UDPConn : io.ReadCloser
			*UDPConn : io.Reader
			*UDPConn : io.ReadWriteCloser
			*UDPConn : io.ReadWriter
			*UDPConn : io.WriteCloser
			*UDPConn : io.Writer
			*UDPConn : syscall.Conn
		As Outputs Of (at least 3)
			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)

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

		Fields (total 2)
			Name string
			Net string
		Methods (total 2)
			(*UnixAddr) Network() string
				Network returns the address's network name, "unix", "unixgram" or
				"unixpacket".

			(*UnixAddr) String() string
		Implements (at least 3)
			*UnixAddr : Addr
			*UnixAddr : expvar.Var
			*UnixAddr : fmt.Stringer
		As Outputs Of (at least 3)
			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)
		As Inputs Of (at least 5)
			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)

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

		Methods (total 20)
			(*UnixConn) Close() error
				Close closes the connection.

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

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

			(*UnixConn) 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.

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

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

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

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

			(*UnixConn) 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.

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

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

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

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

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

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

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

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

			(*UnixConn) 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.

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

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

		Implements (at least 11)
			*UnixConn : Conn
			*UnixConn : PacketConn
			*UnixConn : internal/bisect.Writer
			*UnixConn : io.Closer
			*UnixConn : io.ReadCloser
			*UnixConn : io.Reader
			*UnixConn : io.ReadWriteCloser
			*UnixConn : io.ReadWriter
			*UnixConn : io.WriteCloser
			*UnixConn : io.Writer
			*UnixConn : syscall.Conn
		As Outputs Of (at least 3)
			func DialUnix(network string, laddr, raddr *UnixAddr) (*UnixConn, error)
			func ListenUnixgram(network string, laddr *UnixAddr) (*UnixConn, error)
			func (*UnixListener).AcceptUnix() (*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.

		Methods (total 8)
			(*UnixListener) Accept() (Conn, error)
				Accept implements the Accept method in the [Listener] interface.
				Returned connections will be of type [*UnixConn].

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

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

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

			(*UnixListener) 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.

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

			(*UnixListener) 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.

			(*UnixListener) 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.

		Implements (at least 3)
			*UnixListener : Listener
			*UnixListener : io.Closer
			*UnixListener : 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)
			( UnknownNetworkError) Error() string
			( UnknownNetworkError) Temporary() bool
			( UnknownNetworkError) Timeout() bool
		Implements (at least 2)
			 UnknownNetworkError : Error
			 UnknownNetworkError : error


Package-Level Functions (total 45)

	 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.
		
		Listen uses context.Background internally; to specify the context, use
		[ListenConfig.Listen].

	 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.
		
		ListenPacket uses context.Background internally; to specify the context, use
		[ListenConfig.ListenPacket].

	 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. If the response contains invalid names, those records are filtered
		out and an error will be returned alongside the remaining results, if any.
		
		When using the host C library resolver, at most one result will be
		returned. To bypass the host resolver, use a custom [Resolver].
		
		LookupAddr uses [context.Background] internally; to specify the context, use
		[Resolver.LookupAddr].

	 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.
		
		LookupCNAME uses [context.Background] internally; to specify the context, use
		[Resolver.LookupCNAME].

	 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.
		
		LookupHost uses [context.Background] internally; to specify the context, use
		[Resolver.LookupHost].

	 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. If the response contains
		invalid names, those records are filtered out and an error
		will be returned alongside the remaining results, if any.
		
		LookupMX uses [context.Background] internally; to specify the context, use
		[Resolver.LookupMX].

	 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. If the response contains
		invalid names, those records are filtered out and an error
		will be returned alongside the remaining results, if any.
		
		LookupNS uses [context.Background] internally; to specify the context, use
		[Resolver.LookupNS].

	 func LookupPort(network, service string) (port int, err error)
		LookupPort looks up the port for the given network and service.
		
		LookupPort uses [context.Background] internally; to specify the context, use
		[Resolver.LookupPort].

	 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. If the response contains
		invalid names, those records are filtered out and an error
		will be returned alongside the remaining results, if any.

	 func LookupTXT(name string) ([]string, error)
		LookupTXT returns the DNS TXT records for the given domain name.
		
		LookupTXT uses [context.Background] internally; to specify the context, use
		[Resolver.LookupTXT].

	 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. The returned address is always 16 bytes,
		IPv4 addresses are returned in IPv4-mapped IPv6 form.

	 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.

	 func TCPAddrFromAddrPort(addr netip.AddrPort) *TCPAddr
		TCPAddrFromAddrPort returns addr as a [TCPAddr]. If addr.IsValid() is false,
		then the returned TCPAddr will contain a nil IP field, indicating an
		address family-agnostic unspecified address.

	 func UDPAddrFromAddrPort(addr netip.AddrPort) *UDPAddr
		UDPAddrFromAddrPort returns addr as a [UDPAddr]. If addr.IsValid() is false,
		then the returned UDPAddr will contain a nil IP field, indicating an
		address family-agnostic unspecified address.


Package-Level Variables (total 13)

	  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


Package-Level Constants (total 8)

	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 FlagRunning Flags = 32 // interface is in running state
	const FlagUp Flags = 1 // interface is administratively up
	const IPv4len = 4
		IP address lengths (bytes).

	const IPv6len = 16
		IP address lengths (bytes).

The pages are generated with Golds v0.7.3-preview. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.