package net
import "net"
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", "google.com:80") if err != nil { // handle error } fmt.Fprintf(conn, "GET / HTTP/1.0\r\n\r\n") status, err := bufio.NewReader(conn).ReadString('\n') // ...
The Listen function creates servers:
ln, err := net.Listen("tcp", ":8080") if err != nil { // handle error } for { conn, err := ln.Accept() if err != nil { // handle error } go handleConnection(conn) }
Name Resolution
The method for resolving domain names, whether indirectly with functions like Dial or directly with functions like LookupHost and LookupAddr, varies by operating system.
On Unix systems, the resolver has two options for resolving names. It can use a pure Go resolver that sends DNS requests directly to the servers listed in /etc/resolv.conf, or it can use a cgo-based resolver that calls C library routines such as getaddrinfo and getnameinfo.
By default the pure Go resolver is used, because a blocked DNS request consumes only a goroutine, while a blocked C call consumes an operating system thread. When cgo is available, the cgo-based resolver is used instead under a variety of conditions: on systems that do not let programs make direct DNS requests (OS X), when the LOCALDOMAIN environment variable is present (even if empty), when the RES_OPTIONS or HOSTALIASES environment variable is non-empty, when the ASR_CONFIG environment variable is non-empty (OpenBSD only), when /etc/resolv.conf or /etc/nsswitch.conf specify the use of features that the Go resolver does not implement, and when the name being looked up ends in .local or is an mDNS name.
The resolver decision can be overridden by setting the netdns value of the GODEBUG environment variable (see package runtime) to go or cgo, as in:
export GODEBUG=netdns=go # force pure Go resolver export GODEBUG=netdns=cgo # force cgo resolver
The decision can also be forced while building the Go source tree by setting the netgo or netcgo build tag.
A numeric netdns setting, as in GODEBUG=netdns=1, causes the resolver to print debugging information about its decisions. To force a particular resolver while also printing debugging information, join the two settings by a plus sign, as in GODEBUG=netdns=go+1.
On Plan 9, the resolver always accesses /net/cs and /net/dns.
On Windows, the resolver always uses C library functions, such as GetAddrInfo and DnsQuery.
Index ¶
- Constants
- Variables
- func JoinHostPort(host, port string) string
- func LookupAddr(addr string) (names []string, err error)
- func LookupCNAME(name string) (cname string, err error)
- func LookupHost(host string) (addrs []string, err error)
- func LookupPort(network, service string) (port int, err error)
- func LookupTXT(name string) (txts []string, err error)
- func ParseCIDR(s string) (IP, *IPNet, error)
- func Pipe() (Conn, Conn)
- func SplitHostPort(hostport string) (host, port string, err error)
- type Addr
- type AddrError
- func (e *AddrError) Error() string
- func (e *AddrError) Temporary() bool
- func (e *AddrError) Timeout() bool
- type Conn
- 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)
- type DNSConfigError
- func (e *DNSConfigError) Error() string
- func (e *DNSConfigError) Temporary() bool
- func (e *DNSConfigError) Timeout() bool
- type DNSError
- func (e *DNSError) Error() string
- func (e *DNSError) Temporary() bool
- func (e *DNSError) Timeout() bool
- type Dialer
- type Error
- type Flags
- type HardwareAddr
- type IP
- func IPv4(a, b, c, d byte) IP
- func LookupIP(host string) (ips []IP, err error)
- func ParseIP(s string) IP
- func (ip IP) DefaultMask() IPMask
- func (ip IP) Equal(x IP) bool
- func (ip IP) IsGlobalUnicast() bool
- func (ip IP) IsInterfaceLocalMulticast() bool
- func (ip IP) IsLinkLocalMulticast() bool
- func (ip IP) IsLinkLocalUnicast() bool
- func (ip IP) IsLoopback() bool
- func (ip IP) IsMulticast() bool
- func (ip IP) IsUnspecified() bool
- func (ip IP) MarshalText() ([]byte, error)
- func (ip IP) Mask(mask IPMask) IP
- func (ip IP) String() string
- func (ip IP) To16() IP
- func (ip IP) To4() IP
- func (ip *IP) UnmarshalText(text []byte) error
- type IPAddr
- func ResolveIPAddr(net, addr string) (*IPAddr, error)
- func (a *IPAddr) Network() string
- func (a *IPAddr) String() string
- type IPMask
- func CIDRMask(ones, bits int) IPMask
- func IPv4Mask(a, b, c, d byte) IPMask
- func (m IPMask) Size() (ones, bits int)
- func (m IPMask) String() string
- type IPNet
- func (n *IPNet) Contains(ip IP) bool
- func (n *IPNet) Network() string
- func (n *IPNet) String() string
- type Interface
- func InterfaceByIndex(index int) (*Interface, error)
- func InterfaceByName(name string) (*Interface, error)
- func Interfaces() ([]Interface, error)
- func (ifi *Interface) Addrs() ([]Addr, error)
- func (ifi *Interface) MulticastAddrs() ([]Addr, error)
- type InvalidAddrError
- func (e InvalidAddrError) Error() string
- func (e InvalidAddrError) Temporary() bool
- func (e InvalidAddrError) Timeout() bool
- type Listener
- func FileListener(f *os.File) (ln Listener, err error)
- func Listen(net, laddr string) (Listener, error)
- type MX
- type NS
- type OpError
- func (e *OpError) Error() string
- func (e *OpError) Temporary() bool
- func (e *OpError) Timeout() bool
- type PacketConn
- func FilePacketConn(f *os.File) (c PacketConn, err error)
- func ListenPacket(net, laddr string) (PacketConn, error)
- type ParseError
- type SRV
- type TCPAddr
- func ResolveTCPAddr(net, addr string) (*TCPAddr, error)
- func (a *TCPAddr) Network() string
- func (a *TCPAddr) String() string
- type UDPAddr
- func ResolveUDPAddr(net, addr string) (*UDPAddr, error)
- func (a *UDPAddr) Network() string
- func (a *UDPAddr) String() string
- type UnixAddr
- func ResolveUnixAddr(net, addr string) (*UnixAddr, error)
- func (a *UnixAddr) Network() string
- func (a *UnixAddr) String() string
- type UnknownNetworkError
Examples ¶
Constants ¶
const ( IPv4len = 4 IPv6len = 16 )
IP address lengths (bytes).
Variables ¶
var ( IPv4bcast = IPv4(255, 255, 255, 255) // broadcast IPv4allsys = IPv4(224, 0, 0, 1) // all systems IPv4allrouter = IPv4(224, 0, 0, 2) // all routers IPv4zero = IPv4(0, 0, 0, 0) // all zeros )
Well-known IPv4 addresses
var ( IPv6zero = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} IPv6unspecified = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} IPv6loopback = IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1} IPv6interfacelocalallnodes = IP{0xff, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01} IPv6linklocalallnodes = IP{0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01} IPv6linklocalallrouters = IP{0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x02} )
Well-known IPv6 addresses
Various errors contained in OpError.
Functions ¶
func JoinHostPort ¶
JoinHostPort combines host and port into a network address of the form "host:port" or, if host contains a colon or a percent sign, "[host]:port".
func LookupAddr ¶
LookupAddr performs a reverse lookup for the given address, returning a list of names mapping to that address.
func LookupCNAME ¶
LookupCNAME returns the canonical DNS host for the given name. 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.
func LookupHost ¶
LookupHost looks up the given host using the local resolver. It returns an array of that host's addresses.
func LookupPort ¶
LookupPort looks up the port for the given network and service.
func LookupTXT ¶
LookupTXT returns the DNS TXT records for the given domain name.
func ParseCIDR ¶
ParseCIDR parses s as a CIDR notation IP address and mask, like "192.168.100.1/24" or "2001:DB8::/48", as defined in RFC 4632 and RFC 4291.
It returns the IP address and the network implied by the IP and mask. For example, ParseCIDR("192.168.100.1/16") returns the IP address 192.168.100.1 and the network 192.168.0.0/16.
func Pipe ¶
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 SplitHostPort ¶
SplitHostPort splits a network address of the form "host:port", "[host]:port" or "[ipv6-host%zone]:port" into host or ipv6-host%zone and port. A literal address or host name for IPv6 must be enclosed in square brackets, as in "[::1]:80", "[ipv6-host]:http" or "[ipv6-host%zone]:80".
Types ¶
type Addr ¶
type Addr interface { Network() string // name of the network String() string // string form of address }
Addr represents a network end point address.
func InterfaceAddrs ¶
InterfaceAddrs returns a list of the system's network interface addresses.
type AddrError ¶
func (*AddrError) Error ¶
func (*AddrError) Temporary ¶
func (*AddrError) Timeout ¶
type Conn ¶
type Conn interface { // Read reads data from the connection. // Read can be made to time out and return a Error with Timeout() == true // after a fixed time limit; see SetDeadline and SetReadDeadline. Read(b []byte) (n int, err error) // Write writes data to the connection. // Write can be made to time out and return a Error with Timeout() == true // after a fixed time limit; see SetDeadline and SetWriteDeadline. Write(b []byte) (n int, err error) // Close closes the connection. // Any blocked Read or Write operations will be unblocked and return errors. Close() error // LocalAddr returns the local network address. LocalAddr() Addr // RemoteAddr returns the remote network address. RemoteAddr() Addr // 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 with a timeout (see type Error) instead of // blocking. The deadline applies to all future I/O, not just // the immediately following call to Read or Write. // // 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. SetDeadline(t time.Time) error // SetReadDeadline sets the deadline for future Read calls. // A zero value for t means Read will not time out. SetReadDeadline(t time.Time) error // SetWriteDeadline sets the deadline for future Write calls. // 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. SetWriteDeadline(t time.Time) error }
Conn is a generic stream-oriented network connection.
Multiple goroutines may invoke methods on a Conn simultaneously.
func Dial ¶
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, addresses have the form host:port. If host is a literal IPv6 address it must be enclosed in square brackets as in "[::1]:80" or "[ipv6-host%zone]:80". The functions JoinHostPort and SplitHostPort manipulate addresses in this form. If the host is empty, as in ":80", the local system is assumed.
Examples:
Dial("tcp", "12.34.56.78:80") Dial("tcp", "google.com:http") Dial("tcp", "[2001:db8::1]:http") Dial("tcp", "[fe80::1%lo0]:80") Dial("tcp", ":80")
For IP networks, the network must be "ip", "ip4" or "ip6" followed by a colon and a protocol number or name and the addr must be a literal IP address.
Examples:
Dial("ip4:1", "127.0.0.1") Dial("ip6:ospf", "::1")
For Unix networks, the address must be a file system path.
func DialTimeout ¶
DialTimeout acts like Dial but takes a timeout. The timeout includes name resolution, if required.
func FileConn ¶
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 ¶
type DNSConfigError struct { Err error }
DNSConfigError represents an error reading the machine's DNS configuration. (No longer used; kept for compatibility.)
func (*DNSConfigError) Error ¶
func (e *DNSConfigError) Error() string
func (*DNSConfigError) Temporary ¶
func (e *DNSConfigError) Temporary() bool
func (*DNSConfigError) Timeout ¶
func (e *DNSConfigError) Timeout() bool
type DNSError ¶
type DNSError struct { Err string // description of the error Name string // name looked for Server string // server used IsTimeout bool // if true, timed out; not all timeouts set this IsTemporary bool // if true, error is temporary; not all errors set this }
DNSError represents a DNS lookup error.
func (*DNSError) Error ¶
func (*DNSError) Temporary ¶
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 (*DNSError) Timeout ¶
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.
type Dialer ¶
type Dialer struct { // 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 dialing a 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. Timeout time.Duration // 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. Deadline time.Time // 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. LocalAddr Addr // DualStack enables RFC 6555-compliant "Happy Eyeballs" dialing // when the network is "tcp" and the destination is a host name // with both IPv4 and IPv6 addresses. This allows a client to // tolerate networks where one address family is silently broken. DualStack bool // FallbackDelay specifies the length of time to wait before // spawning a fallback connection, when DualStack is enabled. // If zero, a default delay of 300ms is used. FallbackDelay time.Duration // KeepAlive specifies the keep-alive period for an active // network connection. // If zero, keep-alives are not enabled. Network protocols // that do not support keep-alives ignore this field. KeepAlive time.Duration // Cancel is an optional channel whose closure indicates that // the dial should be canceled. Not all types of dials support // cancelation. Cancel <-chan 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.
func (*Dialer) Dial ¶
Dial connects to the address on the named network.
See func Dial for a description of the network and address parameters.
type Error ¶
type Error interface { error Timeout() bool // Is the error a timeout? Temporary() bool // Is the error temporary? }
An Error represents a network error.
type Flags ¶
type Flags uint
const ( FlagUp Flags = 1 << iota // interface is up FlagBroadcast // interface supports broadcast access capability FlagLoopback // interface is a loopback interface FlagPointToPoint // interface belongs to a point-to-point link FlagMulticast // interface supports multicast access capability )
func (Flags) String ¶
type HardwareAddr ¶
type HardwareAddr []byte
A HardwareAddr represents a physical hardware address.
func ParseMAC ¶
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:
01:23:45:67:89:ab 01:23:45:67:89:ab:cd:ef 01:23:45:67:89:ab:cd:ef:00:00:01:23:45:67:89:ab:cd:ef:00:00 01-23-45-67-89-ab 01-23-45-67-89-ab-cd-ef 01-23-45-67-89-ab-cd-ef-00-00-01-23-45-67-89-ab-cd-ef-00-00 0123.4567.89ab 0123.4567.89ab.cdef 0123.4567.89ab.cdef.0000.0123.4567.89ab.cdef.0000
func (HardwareAddr) String ¶
func (a HardwareAddr) String() string
type IP ¶
type IP []byte
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.
func IPv4 ¶
IPv4 returns the IP address (in 16-byte form) of the IPv4 address a.b.c.d.
func LookupIP ¶
LookupIP looks up host using the local resolver. It returns an array of that host's IPv4 and IPv6 addresses.
func ParseIP ¶
ParseIP parses s as an IP address, returning the result. The string s can be in dotted decimal ("74.125.19.99") or IPv6 ("2001:4860:0:2001::68") form. If s is not a valid textual representation of an IP address, ParseIP returns nil.
func (IP) DefaultMask ¶
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.
func (IP) Equal ¶
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.
func (IP) IsGlobalUnicast ¶
IsGlobalUnicast reports whether ip is a global unicast address.
func (IP) IsInterfaceLocalMulticast ¶
IsInterfaceLocalMulticast reports whether ip is an interface-local multicast address.
func (IP) IsLinkLocalMulticast ¶
IsLinkLocalMulticast reports whether ip is a link-local multicast address.
func (IP) IsLinkLocalUnicast ¶
IsLinkLocalUnicast reports whether ip is a link-local unicast address.
func (IP) IsLoopback ¶
IsLoopback reports whether ip is a loopback address.
func (IP) IsMulticast ¶
IsMulticast reports whether ip is a multicast address.
func (IP) IsUnspecified ¶
IsUnspecified reports whether ip is an unspecified address.
func (IP) MarshalText ¶
MarshalText implements the encoding.TextMarshaler interface. The encoding is the same as returned by String.
func (IP) Mask ¶
Mask returns the result of masking the IP address ip with mask.
func (IP) String ¶
String returns the string form of the IP address ip. If the address is an IPv4 address, the string representation is dotted decimal ("74.125.19.99"). Otherwise the representation is IPv6 ("2001:4860:0:2001::68").
func (IP) To16 ¶
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.
func (IP) To4 ¶
To4 converts the IPv4 address ip to a 4-byte representation. If ip is not an IPv4 address, To4 returns nil.
func (*IP) UnmarshalText ¶
UnmarshalText implements the encoding.TextUnmarshaler interface. The IP address is expected in a form accepted by ParseIP.
type IPAddr ¶
IPAddr represents the address of an IP end point.
func ResolveIPAddr ¶
ResolveIPAddr parses addr as an IP address of the form "host" or "ipv6-host%zone" and resolves the domain name on the network net, which must be "ip", "ip4" or "ip6".
func (*IPAddr) Network ¶
Network returns the address's network name, "ip".
func (*IPAddr) String ¶
type IPMask ¶
type IPMask []byte
An IP mask is an IP address.
func CIDRMask ¶
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 IPv4Mask ¶
IPv4Mask returns the IP mask (in 4-byte form) of the IPv4 mask a.b.c.d.
func (IPMask) Size ¶
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.
func (IPMask) String ¶
String returns the hexadecimal form of m, with no punctuation.
type IPNet ¶
An IPNet represents an IP network.
func (*IPNet) Contains ¶
Contains reports whether the network includes ip.
func (*IPNet) Network ¶
Network returns the address's network name, "ip+net".
func (*IPNet) String ¶
String returns the CIDR notation of n like "192.168.100.1/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 "192.168.100.1/c000ff00".
type Interface ¶
type Interface struct { 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" HardwareAddr HardwareAddr // IEEE MAC-48, EUI-48 and EUI-64 form Flags Flags // e.g., FlagUp, FlagLoopback, FlagMulticast }
Interface represents a mapping between network interface name and index. It also represents network interface facility information.
func InterfaceByIndex ¶
InterfaceByIndex returns the interface specified by index.
func InterfaceByName ¶
InterfaceByName returns the interface specified by name.
func Interfaces ¶
Interfaces returns a list of the system's network interfaces.
func (*Interface) Addrs ¶
Addrs returns interface addresses for a specific interface.
func (*Interface) MulticastAddrs ¶
MulticastAddrs returns multicast, joined group addresses for a specific interface.
type InvalidAddrError ¶
type InvalidAddrError string
func (InvalidAddrError) Error ¶
func (e InvalidAddrError) Error() string
func (InvalidAddrError) Temporary ¶
func (e InvalidAddrError) Temporary() bool
func (InvalidAddrError) Timeout ¶
func (e InvalidAddrError) Timeout() bool
type Listener ¶
type Listener interface { // Accept waits for and returns the next connection to the listener. Accept() (Conn, error) // Close closes the listener. // Any blocked Accept operations will be unblocked and return errors. Close() error // Addr returns the listener's network address. Addr() Addr }
A Listener is a generic network listener for stream-oriented protocols.
Multiple goroutines may invoke methods on a Listener simultaneously.
Code:play
Example¶
package main
import (
"io"
"log"
"net"
)
func main() {
// Listen on TCP port 2000 on all interfaces.
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)
}
}
func FileListener ¶
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 Listen ¶
Listen announces on the local network address laddr. The network net must be a stream-oriented network: "tcp", "tcp4", "tcp6", "unix" or "unixpacket". For TCP and UDP, the syntax of laddr is "host:port", like "127.0.0.1:8080". If host is omitted, as in ":8080", Listen listens on all available interfaces instead of just the interface with the given host address. See Dial for more details about address syntax.
type MX ¶
An MX represents a single DNS MX record.
func LookupMX ¶
LookupMX returns the DNS MX records for the given domain name sorted by preference.
type NS ¶
type NS struct { Host string }
An NS represents a single DNS NS record.
func LookupNS ¶
LookupNS returns the DNS NS records for the given domain name.
type OpError ¶
type OpError struct { // Op is the operation which caused the error, such as // "read" or "write". Op string // Net is the network type on which this error occurred, // such as "tcp" or "udp6". Net string // For operations involving a remote network connection, like // Dial, Read, or Write, Source is the corresponding local // network address. Source 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. Addr Addr // Err is the error that occurred during the operation. Err error }
OpError is the error type usually returned by functions in the net package. It describes the operation, network type, and address of an error.
func (*OpError) Error ¶
func (*OpError) Temporary ¶
func (*OpError) Timeout ¶
type PacketConn ¶
type PacketConn interface { // ReadFrom reads a packet from the connection, // copying the payload into b. It returns the number of // bytes copied into b and the return address that // was on the packet. // ReadFrom can be made to time out and return // an error with Timeout() == true after a fixed time limit; // see SetDeadline and SetReadDeadline. ReadFrom(b []byte) (n int, addr Addr, err error) // WriteTo writes a packet with payload b to addr. // WriteTo can be made to time out and return // an error with Timeout() == true after a fixed time limit; // see SetDeadline and SetWriteDeadline. // On packet-oriented connections, write timeouts are rare. WriteTo(b []byte, addr Addr) (n int, err error) // Close closes the connection. // Any blocked ReadFrom or WriteTo operations will be unblocked and return errors. Close() error // LocalAddr returns the local network address. LocalAddr() Addr // SetDeadline sets the read and write deadlines associated // with the connection. SetDeadline(t time.Time) error // SetReadDeadline sets the deadline for future Read calls. // If the deadline is reached, Read will fail with a timeout // (see type Error) instead of blocking. // A zero value for t means Read will not time out. SetReadDeadline(t time.Time) error // SetWriteDeadline sets the deadline for future Write calls. // If the deadline is reached, Write will fail with a timeout // (see type Error) instead of blocking. // A zero value for t means Write will not time out. // Even if write times out, it may return n > 0, indicating that // some of the data was successfully written. SetWriteDeadline(t time.Time) error }
PacketConn is a generic packet-oriented network connection.
Multiple goroutines may invoke methods on a PacketConn simultaneously.
func FilePacketConn ¶
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 ListenPacket ¶
func ListenPacket(net, laddr string) (PacketConn, error)
ListenPacket announces on the local network address laddr. The network net must be a packet-oriented network: "udp", "udp4", "udp6", "ip", "ip4", "ip6" or "unixgram". For TCP and UDP, the syntax of laddr is "host:port", like "127.0.0.1:8080". If host is omitted, as in ":8080", ListenPacket listens on all available interfaces instead of just the interface with the given host address. See Dial for the syntax of laddr.
type ParseError ¶
type ParseError struct { // Type is the type of string that was expected, such as // "IP address", "CIDR address". Type string // Text is the malformed text string. Text string }
A ParseError is the error type of literal network address parsers.
func (*ParseError) Error ¶
func (e *ParseError) Error() string
type SRV ¶
An SRV represents a single DNS SRV record.
func LookupSRV ¶
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.
type TCPAddr ¶
TCPAddr represents the address of a TCP end point.
func ResolveTCPAddr ¶
ResolveTCPAddr parses addr as a TCP address of the form "host:port" or "[ipv6-host%zone]:port" and resolves a pair of domain name and port name on the network net, which must be "tcp", "tcp4" or "tcp6". A literal address or host name for IPv6 must be enclosed in square brackets, as in "[::1]:80", "[ipv6-host]:http" or "[ipv6-host%zone]:80".
func (*TCPAddr) Network ¶
Network returns the address's network name, "tcp".
func (*TCPAddr) String ¶
type UDPAddr ¶
UDPAddr represents the address of a UDP end point.
func ResolveUDPAddr ¶
ResolveUDPAddr parses addr as a UDP address of the form "host:port" or "[ipv6-host%zone]:port" and resolves a pair of domain name and port name on the network net, which must be "udp", "udp4" or "udp6". A literal address or host name for IPv6 must be enclosed in square brackets, as in "[::1]:80", "[ipv6-host]:http" or "[ipv6-host%zone]:80".
func (*UDPAddr) Network ¶
Network returns the address's network name, "udp".
func (*UDPAddr) String ¶
type UnixAddr ¶
UnixAddr represents the address of a Unix domain socket end point.
func ResolveUnixAddr ¶
ResolveUnixAddr parses addr as a Unix domain socket address. The string net gives the network name, "unix", "unixgram" or "unixpacket".
func (*UnixAddr) Network ¶
Network returns the address's network name, "unix", "unixgram" or "unixpacket".
func (*UnixAddr) String ¶
type UnknownNetworkError ¶
type UnknownNetworkError string
func (UnknownNetworkError) Error ¶
func (e UnknownNetworkError) Error() string
func (UnknownNetworkError) Temporary ¶
func (e UnknownNetworkError) Temporary() bool
func (UnknownNetworkError) Timeout ¶
func (e UnknownNetworkError) Timeout() bool
Source Files ¶
dial.go dnsclient.go dnsmsg.go fd_mutex.go file.go hook.go hosts.go interface.go ip.go iprawsock.go ipsock.go lookup.go mac.go net.go parse.go pipe.go tcpsock.go udpsock.go unixsock.go
Directories ¶
Path | Synopsis |
---|---|
net/http | Package http provides HTTP client and server implementations. |
net/http/cgi | Package cgi implements CGI (Common Gateway Interface) as specified in RFC 3875. |
net/http/cookiejar | Package cookiejar implements an in-memory RFC 6265-compliant http.CookieJar. |
net/http/fcgi | Package fcgi implements the FastCGI protocol. |
net/http/httptest | Package httptest provides utilities for HTTP testing. |
net/http/httputil | Package httputil provides HTTP utility functions, complementing the more common ones in the net/http package. |
net/http/internal | Package internal contains HTTP internals shared by net/http and net/http/httputil. |
net/http/pprof | Package pprof serves via its HTTP server runtime profiling data in the format expected by the pprof visualization tool. |
net/internal | |
net/mail | Package mail implements parsing of mail messages. |
net/rpc | Package rpc provides access to the exported methods of an object across a network or other I/O connection. |
net/rpc/jsonrpc | Package jsonrpc implements a JSON-RPC ClientCodec and ServerCodec for the rpc package. |
net/smtp | Package smtp implements the Simple Mail Transfer Protocol as defined in RFC 5321. |
net/textproto | Package textproto implements generic support for text-based request/response protocols in the style of HTTP, NNTP, and SMTP. |
net/url | Package url parses URLs and implements query escaping. |
- Version
- v1.6.0-beta.2
- Published
- Jan 14, 2016
- Platform
- js/wasm
- Imports
- 11 packages
- Last checked
- 32 seconds ago –
Tools for package owners.