Golang net error

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)

}

Output:

192.0.2.1
192.0.2.0/24
2001:db8:a0b:12f0::1
2001:db8::/32

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 (e *AddrError) Temporary() bool

func (e *AddrError) Timeout() bool

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.

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.

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.

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.

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.

type DNSConfigError struct {
	Err error
}

func (e *DNSConfigError) Temporary() bool

func (e *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.

func (e *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.

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

Output:

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

Output:

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
DialContext.

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.

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

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

}

Output:

<nil>
10.255.0.0

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.

package main

import (
	"fmt"
	"net"
)

func main() {
	fmt.Println(net.IPv4(8, 8, 8, 8))

}

Output:

8.8.8.8

LookupIP looks up host using the local resolver.
It returns a slice of that host’s IPv4 and IPv6 addresses.

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.

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

}

Output:

192.0.2.1
2001:db8::68
<nil>

func (ip 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.

package main

import (
	"fmt"
	"net"
)

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

}

Output:

ffffff00

func (ip 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.

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

}

Output:

true
false
true

func (ip 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.

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

}

Output:

true
true
false
true
true
false

func (ip IP) IsInterfaceLocalMulticast() bool

IsInterfaceLocalMulticast reports whether ip is
an interface-local multicast address.

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

}

Output:

true
false
false

func (ip IP) IsLinkLocalMulticast() bool

IsLinkLocalMulticast reports whether ip is a link-local
multicast address.

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

}

Output:

true
false
true
false

func (ip IP) IsLinkLocalUnicast() bool

IsLinkLocalUnicast reports whether ip is a link-local
unicast address.

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

}

Output:

true
false
true
false

func (ip IP) IsLoopback() bool

IsLoopback reports whether ip is a loopback address.

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

}

Output:

true
false
true
false

func (ip IP) IsMulticast() bool

IsMulticast reports whether ip is a multicast address.

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

}

Output:

true
true
false
true
true
false

func (ip IP) IsPrivate() bool

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

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

}

Output:

true
false
true
false

func (ip IP) IsUnspecified() bool

IsUnspecified reports whether ip is an unspecified address, either
the IPv4 address «0.0.0.0» or the IPv6 address «::».

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

}

Output:

true
false
true
false

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

func (ip IP) Mask(mask IPMask) IP

Mask returns the result of masking the IP address ip with 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))

}

Output:

192.0.2.0
2001:db8::

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

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

}

Output:

fc00::
10.255.0.0

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.

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

}

Output:

fc00::
10.255.0.0

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

UnmarshalText implements the encoding.TextUnmarshaler interface.
The IP address is expected in a form accepted by ParseIP.

type IPAddr struct {
	IP   IP
	Zone string 
}

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.

Network returns the address’s network name, «ip».

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.

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 (c *IPConn) Close() error

Close closes the connection.

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.

func (c *IPConn) LocalAddr() Addr

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

Read implements the Conn Read method.

ReadFrom implements the PacketConn ReadFrom method.

ReadFromIP acts like ReadFrom but returns an IPAddr.

func (c *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.

func (c *IPConn) RemoteAddr() Addr

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

SetDeadline implements the Conn SetDeadline method.

func (c *IPConn) SetReadBuffer(bytes int) error

SetReadBuffer sets the size of the operating system’s
receive buffer associated with the connection.

SetReadDeadline implements the Conn SetReadDeadline method.

func (c *IPConn) SetWriteBuffer(bytes int) error

SetWriteBuffer sets the size of the operating system’s
transmit buffer associated with the connection.

SetWriteDeadline implements the Conn SetWriteDeadline method.

SyscallConn returns a raw network connection.
This implements the syscall.Conn interface.

Write implements the Conn Write method.

func (c *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.

WriteTo implements the PacketConn WriteTo method.

WriteToIP acts like WriteTo but takes an IPAddr.

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.

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

}

Output:

fffffffe
ffffffffffffffff0000000000000000

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.

package main

import (
	"fmt"
	"net"
)

func main() {
	fmt.Println(net.IPv4Mask(255, 255, 255, 0))

}

Output:

ffffff00

func (m 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.

String returns the hexadecimal form of m, with no punctuation.

type IPNet struct {
	IP   IP     
	Mask IPMask 
}

func (n *IPNet) Contains(ip IP) bool

Contains reports whether the network includes ip.

Network returns the address’s network name, «ip+net».

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».

type Interface struct {
	Index        int          
	MTU          int          
	Name         string       
	HardwareAddr HardwareAddr 
	Flags        Flags        
}

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.

InterfaceByName returns the interface specified by name.

Interfaces returns a list of the system’s network interfaces.

func (ifi *Interface) Addrs() ([]Addr, error)

Addrs returns a list of unicast interface addresses for a specific
interface.

func (ifi *Interface) MulticastAddrs() ([]Addr, error)

MulticastAddrs returns a list of multicast, joined group addresses
for a specific interface.

Listen announces on the local network address.

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

ListenPacket announces on the local network address.

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

type Listener interface {
	
	Accept() (Conn, error)

	
	
	Close() error

	
	Addr() Addr
}

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

Output:

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.

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.

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.

type NS struct {
	Host string
}

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 (e *OpError) Temporary() bool

func (e *OpError) Timeout() bool

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.

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 (e *ParseError) Temporary() bool

func (e *ParseError) Timeout() bool

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.

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.

LookupHost looks up the given host using the local resolver.
It returns a slice of that host’s addresses.

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».

LookupIPAddr looks up host using the local resolver.
It returns a slice of that host’s IPv4 and IPv6 addresses.

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.

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.

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».

LookupPort looks up the port for the given network and service.

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.

LookupTXT returns the DNS TXT records for the given domain name.

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.

type TCPAddr struct {
	IP   IP
	Port int
	Zone string 
}

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.

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.

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.

Network returns the address’s network name, «tcp».

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 (c *TCPConn) Close() error

Close closes the connection.

CloseRead shuts down the reading side of the TCP connection.
Most callers should just use Close.

func (c *TCPConn) CloseWrite() error

CloseWrite shuts down the writing side of the TCP connection.
Most callers should just use Close.

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.

func (c *TCPConn) LocalAddr() Addr

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

Read implements the Conn Read method.

ReadFrom implements the io.ReaderFrom ReadFrom method.

func (c *TCPConn) RemoteAddr() Addr

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

SetDeadline implements the Conn SetDeadline method.

SetKeepAlive sets whether the operating system should send
keep-alive messages on the connection.

SetKeepAlivePeriod sets period between keep-alives.

SetLinger sets the behavior of Close on a connection which still
has data waiting to be sent or to be acknowledged.

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

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

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

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.

func (c *TCPConn) SetReadBuffer(bytes int) error

SetReadBuffer sets the size of the operating system’s
receive buffer associated with the connection.

SetReadDeadline implements the Conn SetReadDeadline method.

func (c *TCPConn) SetWriteBuffer(bytes int) error

SetWriteBuffer sets the size of the operating system’s
transmit buffer associated with the connection.

SetWriteDeadline implements the Conn SetWriteDeadline method.

SyscallConn returns a raw network connection.
This implements the syscall.Conn interface.

Write implements the Conn Write method.

type TCPListener struct {
	
}

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.

Accept implements the Accept method in the Listener interface; it
waits for the next call and returns a generic Conn.

AcceptTCP accepts the next incoming call and returns the new
connection.

func (l *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.

Close stops listening on the TCP address.
Already Accepted connections are not closed.

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.

SetDeadline sets the deadline associated with the listener.
A zero time value disables the deadline.

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.

type UDPAddr struct {
	IP   IP
	Port int
	Zone string 
}

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.

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.

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.

Network returns the address’s network name, «udp».

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.

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.

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 (c *UDPConn) Close() error

Close closes the connection.

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.

func (c *UDPConn) LocalAddr() Addr

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

Read implements the Conn Read method.

ReadFrom implements the PacketConn ReadFrom method.

ReadFromUDP acts like ReadFrom but returns a UDPAddr.

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.

func (c *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.

ReadMsgUDPAddrPort is like ReadMsgUDP but returns an netip.AddrPort instead of a UDPAddr.

func (c *UDPConn) RemoteAddr() Addr

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

SetDeadline implements the Conn SetDeadline method.

func (c *UDPConn) SetReadBuffer(bytes int) error

SetReadBuffer sets the size of the operating system’s
receive buffer associated with the connection.

SetReadDeadline implements the Conn SetReadDeadline method.

func (c *UDPConn) SetWriteBuffer(bytes int) error

SetWriteBuffer sets the size of the operating system’s
transmit buffer associated with the connection.

SetWriteDeadline implements the Conn SetWriteDeadline method.

SyscallConn returns a raw network connection.
This implements the syscall.Conn interface.

Write implements the Conn Write method.

func (c *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.

WriteMsgUDPAddrPort is like WriteMsgUDP but takes a netip.AddrPort instead of a UDPAddr.

WriteTo implements the PacketConn WriteTo method.

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

Output:

WriteToUDP acts like WriteTo but takes a UDPAddr.

WriteToUDPAddrPort acts like WriteTo but takes a netip.AddrPort.

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.

Network returns the address’s network name, «unix», «unixgram» or
«unixpacket».

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.

ListenUnixgram acts like ListenPacket for Unix networks.

The network must be «unixgram».

func (c *UnixConn) Close() error

Close closes the connection.

CloseRead shuts down the reading side of the Unix domain connection.
Most callers should just use Close.

func (c *UnixConn) CloseWrite() error

CloseWrite shuts down the writing side of the Unix domain connection.
Most callers should just use Close.

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.

func (c *UnixConn) LocalAddr() Addr

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

Read implements the Conn Read method.

ReadFrom implements the PacketConn ReadFrom method.

ReadFromUnix acts like ReadFrom but returns a UnixAddr.

func (c *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.

func (c *UnixConn) RemoteAddr() Addr

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

SetDeadline implements the Conn SetDeadline method.

func (c *UnixConn) SetReadBuffer(bytes int) error

SetReadBuffer sets the size of the operating system’s
receive buffer associated with the connection.

SetReadDeadline implements the Conn SetReadDeadline method.

func (c *UnixConn) SetWriteBuffer(bytes int) error

SetWriteBuffer sets the size of the operating system’s
transmit buffer associated with the connection.

SetWriteDeadline implements the Conn SetWriteDeadline method.

SyscallConn returns a raw network connection.
This implements the syscall.Conn interface.

Write implements the Conn Write method.

func (c *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.

WriteTo implements the PacketConn WriteTo method.

WriteToUnix acts like WriteTo but takes a UnixAddr.

type UnixListener struct {
	
}

ListenUnix acts like Listen for Unix networks.

The network must be «unix» or «unixpacket».

Accept implements the Accept method in the Listener interface.
Returned connections will be of type *UnixConn.

AcceptUnix accepts the next incoming call and returns the new
connection.

func (l *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.

Close stops listening on the Unix address. Already accepted
connections are not closed.

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.

SetDeadline sets the deadline associated with the listener.
A zero time value disables the deadline.

func (l *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.

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.