# package net

`import "net"`

net包提供了可移植的网络I/O接口，包括TCP/IP、UDP、域名解析和Unix域socket。

虽然本包提供了对网络原语的访问，大部分使用者只需要Dial、Listen和Accept函数提供的基本接口；以及相关的Conn和Listener接口。crypto/tls包提供了相同的接口和类似的Dial和Listen函数。

Dial函数和服务端建立连接：

    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')
    // ...

Listen函数创建的服务端：

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

    const (
        IPv4len = 4
        IPv6len = 16
    )

IP address lengths (bytes).

## Variables

    var (
        IPv4bcast     = IPv4(255, 255, 255, 255) // 广播地址
        IPv4allsys    = IPv4(224, 0, 0, 1)       // 所有主机和路由器
        IPv4allrouter = IPv4(224, 0, 0, 2)       // 所有路由器
        IPv4zero      = IPv4(0, 0, 0, 0)         // 本地地址，只能作为源地址（曾用作广播地址）
    )

常用的IPv4地址。

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

常用的IPv6地址。

    var (
        ErrWriteToConnected = errors.New("use of WriteTo with pre-connected connection")
    )

很多OpError类型的错误会包含本错误。

## type ParseError

    type ParseError struct {
        Type string
        Text string
    }

ParseError代表一个格式错误的字符串，Type为期望的格式。

### func (*ParseError) Error

    func (e *ParseError) Error() string

## type Error

    type Error interface {
        error
        Timeout() bool   // 错误是否为超时？
        Temporary() bool // 错误是否是临时的？
    }

Error代表一个网络错误。

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

## 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 DNSConfigError

    type DNSConfigError struct {
        Err error
    }

DNSConfigError代表读取主机DNS配置时出现的错误。

### 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 // 错误的描述
        Name      string // 查询的名称
        Server    string // 使用的服务器
        IsTimeout bool
    }

DNSError代表DNS查询的错误。

### func (*DNSError) Error

    func (e *DNSError) Error() string

### func (*DNSError) Temporary

    func (e *DNSError) Temporary() bool

### func (*DNSError) Timeout

    func (e *DNSError) Timeout() bool

## type AddrError

    type AddrError struct {
        Err  string
        Addr string
    }

### func (*AddrError) Error

    func (e *AddrError) Error() string

### func (*AddrError) Temporary

    func (e *AddrError) Temporary() bool

### func (*AddrError) Timeout

    func (e *AddrError) Timeout() bool

## type OpError

    type OpError struct {
        // Op是出现错误的操作，如"read"或"write"
        Op  string
        // Net是错误所在的网络类型，如"tcp"或"udp6"
        Net string
        // Addr是出现错误的网络地址
        Addr Addr
        // Err是操作中出现的错误
        Err error
    }

OpError是经常被net包的函数返回的错误类型。它描述了该错误的操作、网络类型和网络地址。

### func (*OpError) Error

    func (e *OpError) Error() string

### func (*OpError) Temporary

    func (e *OpError) Temporary() bool

### func (*OpError) Timeout

    func (e *OpError) Timeout() bool

## func SplitHostPort

    func SplitHostPort(hostport string) (host, port string, err error)

函数将格式为"host:port"、"[host]:port"或"[ipv6-host%zone]:port"的网络地址分割为host或ipv6-host%zone和port两个部分。Ipv6的文字地址或者主机名必须用方括号括起来，如"[::1]:80"、"[ipv6-host]:http"、"[ipv6-host%zone]:80"。

## func JoinHostPort

    func JoinHostPort(host, port string) string

函数将host和port合并为一个网络地址。一般格式为"host:port"；如果host含有冒号或百分号，格式为"[host]:port"。

## type HardwareAddr

    type HardwareAddr []byte

HardwareAddr类型代表一个硬件地址（MAC地址）。

### func ParseMAC

    func ParseMAC(s string) (hw HardwareAddr, err error)

ParseMAC函数使用如下格式解析一个IEEE 802 MAC-48、EUI-48或EUI-64硬件地址：

    01:23:45:67:89:ab
    01:23:45:67:89:ab:cd:ef
    01-23-45-67-89-ab
    01-23-45-67-89-ab-cd-ef
    0123.4567.89ab
    0123.4567.89ab.cdef

### func (HardwareAddr) String

    func (a HardwareAddr) String() string

## type Flags

    type Flags uint

    const (
        FlagUp           Flags = 1 << iota // 接口在活动状态
        FlagBroadcast                      // 接口支持广播
        FlagLoopback                       // 接口是环回的
        FlagPointToPoint                   // 接口是点对点的
        FlagMulticast                      // 接口支持组播
    )

### func (Flags) String

    func (f Flags) String() string

## type Interface

    type Interface struct {
        Index        int          // 索引，>=1的整数
        MTU          int          // 最大传输单元
        Name         string       // 接口名，例如"en0"、"lo0"、"eth0.100"
        HardwareAddr HardwareAddr // 硬件地址，IEEE MAC-48、EUI-48或EUI-64格式
        Flags        Flags        // 接口的属性，例如FlagUp、FlagLoopback、FlagMulticast
    }

Interface类型代表一个网络接口（系统与网络的一个接点）。包含接口索引到名字的映射，也包含接口的设备信息。

### func InterfaceByIndex

    func InterfaceByIndex(index int) (*Interface, error)

InterfaceByIndex返回指定索引的网络接口。

### func InterfaceByName

    func InterfaceByName(name string) (*Interface, error)

InterfaceByName返回指定名字的网络接口。

### func (*Interface) Addrs

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

Addrs方法返回网络接口ifi的一或多个接口地址。

### func (*Interface) MulticastAddrs

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

MulticastAddrs返回网络接口ifi加入的多播组地址。

## func Interfaces

    func Interfaces() ([]Interface, error)

Interfaces返回该系统的网络接口列表。

## func InterfaceAddrs

    func InterfaceAddrs() ([]Addr, error)

InterfaceAddrs返回该系统的网络接口的地址列表。

## type IP

    type IP []byte

IP类型是代表单个IP地址的[]byte切片。本包的函数都可以接受4字节（IPv4）和16字节（IPv6）的切片作为输入。

注意，IP地址是IPv4地址还是IPv6地址是语义上的属性，而不取决于切片的长度：16字节的切片也可以是IPv4地址。

### func IPv4

    func IPv4(a, b, c, d byte) IP

IPv4返回包含一个IPv4地址a.b.c.d的IP地址（16字节格式）。

### func ParseIP

    func ParseIP(s string) IP

ParseIP将s解析为IP地址，并返回该地址。如果s不是合法的IP地址文本表示，ParseIP会返回nil。

字符串可以是小数点分隔的IPv4格式（如"74.125.19.99"）或IPv6格式（如"2001:4860:0:2001::68"）格式。

### func (IP) IsGlobalUnicast

    func (ip IP) IsGlobalUnicast() bool

如果ip是全局单播地址，则返回真。

### func (IP) IsLinkLocalUnicast

    func (ip IP) IsLinkLocalUnicast() bool

如果ip是链路本地单播地址，则返回真。

### func (IP) IsInterfaceLocalMulticast

    func (ip IP) IsInterfaceLocalMulticast() bool

如果ip是接口本地组播地址，则返回真。

### func (IP) IsLinkLocalMulticast

    func (ip IP) IsLinkLocalMulticast() bool

如果ip是链路本地组播地址，则返回真。

### func (IP) IsMulticast

    func (ip IP) IsMulticast() bool

如果ip是组播地址，则返回真。

### func (IP) IsLoopback

    func (ip IP) IsLoopback() bool

如果ip是环回地址，则返回真。

### func (IP) IsUnspecified

    func (ip IP) IsUnspecified() bool

如果ip是未指定地址，则返回真。

### func (IP) DefaultMask

    func (ip IP) DefaultMask() IPMask

函数返回IP地址ip的默认子网掩码。只有IPv4有默认子网掩码；如果ip不是合法的IPv4地址，会返回nil。

### func (IP) Equal

    func (ip IP) Equal(x IP) bool

如果ip和x代表同一个IP地址，Equal会返回真。代表同一地址的IPv4地址和IPv6地址也被认为是相等的。

### func (IP) To16

    func (ip IP) To16() IP

To16将一个IP地址转换为16字节表示。如果ip不是一个IP地址（长度错误），To16会返回nil。

### func (IP) To4

    func (ip IP) To4() IP

To4将一个IPv4地址转换为4字节表示。如果ip不是IPv4地址，To4会返回nil。

### func (IP) Mask

    func (ip IP) Mask(mask IPMask) IP

Mask方法认为mask为ip的子网掩码，返回ip的网络地址部分的ip。（主机地址部分都置0）

### func (IP) String

    func (ip IP) String() string

String返回IP地址ip的字符串表示。如果ip是IPv4地址，返回值的格式为点分隔的，如"74.125.19.99"；否则表示为IPv6格式，如"2001:4860:0:2001::68"。

### func (IP) MarshalText

    func (ip IP) MarshalText() ([]byte, error)

MarshalText实现了encoding.TextMarshaler接口，返回值和String方法一样。

### func (*IP) UnmarshalText

    func (ip *IP) UnmarshalText(text []byte) error

UnmarshalText实现了encoding.TextUnmarshaler接口。IP地址字符串应该是ParseIP函数可以接受的格式。

## type IPMask

    type IPMask []byte

IPMask代表一个IP地址的掩码。

### func IPv4Mask

    func IPv4Mask(a, b, c, d byte) IPMask

IPv4Mask返回一个4字节格式的IPv4掩码a.b.c.d。

### func CIDRMask

    func CIDRMask(ones, bits int) IPMask

CIDRMask返回一个IPMask类型值，该返回值总共有bits个字位，其中前ones个字位都是1，其余字位都是0。

### func (IPMask) Size

    func (m IPMask) Size() (ones, bits int)

Size返回m的前导的1字位数和总字位数。如果m不是规范的子网掩码（字位：/^1+0+$/），将返会(0, 0)。

### func (IPMask) String

    func (m IPMask) String() string

String返回m的十六进制格式，没有标点。

## type IPNet

    type IPNet struct {
        IP   IP     // 网络地址
        Mask IPMask // 子网掩码
    }

IPNet表示一个IP网络。

### func ParseCIDR

    func ParseCIDR(s string) (IP, *IPNet, error)

ParseCIDR将s作为一个CIDR（无类型域间路由）的IP地址和掩码字符串，如"192.168.100.1/24"或"2001:DB8::/48"，解析并返回IP地址和IP网络，参见RFC 4632和RFC 4291。

本函数会返回IP地址和该IP所在的网络和掩码。例如，ParseCIDR("192.168.100.1/16")会返回IP地址192.168.100.1和IP网络192.168.0.0/16。

### func (*IPNet) Contains

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

Contains报告该网络是否包含地址ip。

### func (*IPNet) Network

    func (n *IPNet) Network() string

Network返回网络类型名："ip+net"，注意该类型名是不合法的。

### func (*IPNet) String

    func (n *IPNet) String() string

String返回n的CIDR表示，如"192.168.100.1/24"或"2001:DB8::/48"，参见RFC 4632和RFC 4291。如果n的Mask字段不是规范格式，它会返回一个包含n.IP.String()、斜线、n.Mask.String()（此时表示为无标点十六进制格式）的字符串，如"192.168.100.1/c000ff00"。

## type Addr

    type Addr interface {
        Network() string // 网络名
        String() string  // 字符串格式的地址
    }

Addr代表一个网络终端地址。

## type Conn

    type Conn interface {
        // Read从连接中读取数据
        // Read方法可能会在超过某个固定时间限制后超时返回错误，该错误的Timeout()方法返回真
        Read(b []byte) (n int, err error)
        // Write从连接中写入数据
        // Write方法可能会在超过某个固定时间限制后超时返回错误，该错误的Timeout()方法返回真
        Write(b []byte) (n int, err error)
        // Close方法关闭该连接
        // 并会导致任何阻塞中的Read或Write方法不再阻塞并返回错误
        Close() error
        // 返回本地网络地址
        LocalAddr() Addr
        // 返回远端网络地址
        RemoteAddr() Addr
        // 设定该连接的读写deadline，等价于同时调用SetReadDeadline和SetWriteDeadline
        // deadline是一个绝对时间，超过该时间后I/O操作就会直接因超时失败返回而不会阻塞
        // deadline对之后的所有I/O操作都起效，而不仅仅是下一次的读或写操作
        // 参数t为零值表示不设置期限
        SetDeadline(t time.Time) error
        // 设定该连接的读操作deadline，参数t为零值表示不设置期限
        SetReadDeadline(t time.Time) error
        // 设定该连接的写操作deadline，参数t为零值表示不设置期限
        // 即使写入超时，返回值n也可能>0，说明成功写入了部分数据
        SetWriteDeadline(t time.Time) error
    }

Conn接口代表通用的面向流的网络连接。多个线程可能会同时调用同一个Conn的方法。

### func Dial

    func Dial(network, address string) (Conn, error)

在网络network上连接地址address，并返回一个Conn接口。可用的网络类型有：

"tcp"、"tcp4"、"tcp6"、"udp"、"udp4"、"udp6"、"ip"、"ip4"、"ip6"、"unix"、"unixgram"、"unixpacket"

对TCP和UDP网络，地址格式是host:port或[host]:port，参见函数JoinHostPort和SplitHostPort。

    Dial("tcp", "12.34.56.78:80")
    Dial("tcp", "google.com:http")
    Dial("tcp", "[2001:db8::1]:http")
    Dial("tcp", "[fe80::1%lo0]:80")

对IP网络，network必须是"ip"、"ip4"、"ip6"后跟冒号和协议号或者协议名，地址必须是IP地址字面值。

    Dial("ip4:1", "127.0.0.1")
    Dial("ip6:ospf", "::1")

对Unix网络，地址必须是文件系统路径。

### func DialTimeout

    func DialTimeout(network, address string, timeout time.Duration) (Conn, error)

DialTimeout类似Dial但采用了超时。timeout参数如果必要可包含名称解析。

### func Pipe

    func Pipe() (Conn, Conn)

Pipe创建一个内存中的同步、全双工网络连接。连接的两端都实现了Conn接口。一端的读取对应另一端的写入，直接将数据在两端之间作拷贝；没有内部缓冲。

## type PacketConn

    type PacketConn interface {
        // ReadFrom方法从连接读取一个数据包，并将有效信息写入b
        // ReadFrom方法可能会在超过某个固定时间限制后超时返回错误，该错误的Timeout()方法返回真
        // 返回写入的字节数和该数据包的来源地址
        ReadFrom(b []byte) (n int, addr Addr, err error)
        // WriteTo方法将有效数据b写入一个数据包发送给addr
        // WriteTo方法可能会在超过某个固定时间限制后超时返回错误，该错误的Timeout()方法返回真
        // 在面向数据包的连接中，写入超时非常罕见
        WriteTo(b []byte, addr Addr) (n int, err error)
        // Close方法关闭该连接
        // 会导致任何阻塞中的ReadFrom或WriteTo方法不再阻塞并返回错误
        Close() error
        // 返回本地网络地址
        LocalAddr() Addr
        // 设定该连接的读写deadline
        SetDeadline(t time.Time) error
        // 设定该连接的读操作deadline，参数t为零值表示不设置期限
        // 如果时间到达deadline，读操作就会直接因超时失败返回而不会阻塞
        SetReadDeadline(t time.Time) error
        // 设定该连接的写操作deadline，参数t为零值表示不设置期限
        // 如果时间到达deadline，写操作就会直接因超时失败返回而不会阻塞
        // 即使写入超时，返回值n也可能>0，说明成功写入了部分数据
        SetWriteDeadline(t time.Time) error
    }

PacketConn接口代表通用的面向数据包的网络连接。多个线程可能会同时调用同一个Conn的方法。

### func ListenPacket

    func ListenPacket(net, laddr string) (PacketConn, error)

ListenPacket函数监听本地网络地址laddr。网络类型net必须是面向数据包的网络类型：

"ip"、"ip4"、"ip6"、"udp"、"udp4"、"udp6"、或"unixgram"。laddr的格式参见Dial函数。

## type Dialer

    type Dialer struct {
        // Timeout是dial操作等待连接建立的最大时长，默认值代表没有超时。
        // 如果Deadline字段也被设置了，dial操作也可能更早失败。
        // 不管有没有设置超时，操作系统都可能强制执行它的超时设置。
        // 例如，TCP（系统）超时一般在3分钟左右。
        Timeout time.Duration
        // Deadline是一个具体的时间点期限，超过该期限后，dial操作就会失败。
        // 如果Timeout字段也被设置了，dial操作也可能更早失败。
        // 零值表示没有期限，即遵守操作系统的超时设置。
        Deadline time.Time
        // LocalAddr是dial一个地址时使用的本地地址。
        // 该地址必须是与dial的网络相容的类型。
        // 如果为nil，将会自动选择一个本地地址。
        LocalAddr Addr
        // DualStack允许单次dial操作在网络类型为"tcp"，
        // 且目的地是一个主机名的DNS记录具有多个地址时，
        // 尝试建立多个IPv4和IPv6连接，并返回第一个建立的连接。
        DualStack bool
        // KeepAlive指定一个活动的网络连接的生命周期；如果为0，会禁止keep-alive。
        // 不支持keep-alive的网络连接会忽略本字段。
        KeepAlive time.Duration
    }

Dialer类型包含与某个地址建立连接时的参数。

每一个字段的零值都等价于没有该字段。因此调用Dialer零值的Dial方法等价于调用Dial函数。

### func (*Dialer) Dial

    func (d *Dialer) Dial(network, address string) (Conn, error)

Dial在指定的网络上连接指定的地址。参见Dial函数获取网络和地址参数的描述。

## type Listener

    type Listener interface {
        // Addr返回该接口的网络地址
        Addr() Addr
        // Accept等待并返回下一个连接到该接口的连接
        Accept() (c Conn, err error)
        // Close关闭该接口，并使任何阻塞的Accept操作都会不再阻塞并返回错误。
        Close() error
    }

Listener是一个用于面向流的网络协议的公用的网络监听器接口。多个线程可能会同时调用一个Listener的方法。

Example

    // 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 Listen

    func Listen(net, laddr string) (Listener, error)

返回在一个本地网络地址laddr上监听的Listener。网络类型参数net必须是面向流的网络：

"tcp"、"tcp4"、"tcp6"、"unix"或"unixpacket"。参见Dial函数获取laddr的语法。

## type IPAddr

    type IPAddr struct {
        IP   IP
        Zone string // IPv6范围寻址域
    }

IPAddr代表一个IP终端的地址。

### func ResolveIPAddr

    func ResolveIPAddr(net, addr string) (*IPAddr, error)

ResolveIPAddr将addr作为一个格式为"host"或"ipv6-host%zone"的IP地址来解析。 函数会在参数net指定的网络类型上解析，net必须是"ip"、"ip4"或"ip6"。

### func (*IPAddr) Network

    func (a *IPAddr) Network() string

Network返回地址的网络类型："ip"。

### func (*IPAddr) String

    func (a *IPAddr) String() string

## type TCPAddr

    type TCPAddr struct {
        IP   IP
        Port int
        Zone string // IPv6范围寻址域
    }

TCPAddr代表一个TCP终端地址。

### func ResolveTCPAddr

    func ResolveTCPAddr(net, addr string) (*TCPAddr, error)

ResolveTCPAddr将addr作为TCP地址解析并返回。参数addr格式为"host:port"或"[ipv6-host%zone]:port"，解析得到网络名和端口名；net必须是"tcp"、"tcp4"或"tcp6"。

IPv6地址字面值/名称必须用方括号包起来，如"[::1]:80"、"[ipv6-host]:http"或"[ipv6-host%zone]:80"。

### func (*TCPAddr) Network

    func (a *TCPAddr) Network() string

返回地址的网络类型，"tcp"。

### func (*TCPAddr) String

    func (a *TCPAddr) String() string

## type UDPAddr

    type UDPAddr struct {
        IP   IP
        Port int
        Zone string // IPv6范围寻址域
    }

UDPAddr代表一个UDP终端地址。

### func ResolveUDPAddr

    func ResolveUDPAddr(net, addr string) (*UDPAddr, error)

ResolveTCPAddr将addr作为TCP地址解析并返回。参数addr格式为"host:port"或"[ipv6-host%zone]:port"，解析得到网络名和端口名；net必须是"udp"、"udp4"或"udp6"。

IPv6地址字面值/名称必须用方括号包起来，如"[::1]:80"、"[ipv6-host]:http"或"[ipv6-host%zone]:80"。

### func (*UDPAddr) Network

    func (a *UDPAddr) Network() string

返回地址的网络类型，"udp"。

### func (*UDPAddr) String

    func (a *UDPAddr) String() string

## type UnixAddr

    type UnixAddr struct {
        Name string
        Net  string
    }

UnixAddr代表一个Unix域socket终端地址。

### func ResolveUnixAddr

    func ResolveUnixAddr(net, addr string) (*UnixAddr, error)

ResolveUnixAddr将addr作为Unix域socket地址解析，参数net指定网络类型："unix"、"unixgram"或"unixpacket"。

### func (*UnixAddr) Network

    func (a *UnixAddr) Network() string

返回地址的网络类型，"unix"，"unixgram"或"unixpacket"。

### func (*UnixAddr) String

    func (a *UnixAddr) String() string

## type IPConn

    type IPConn struct {
        // 内含隐藏或非导出字段
    }

IPConn类型代表IP网络连接，实现了Conn和PacketConn接口。

### func DialIP

    func DialIP(netProto string, laddr, raddr *IPAddr) (*IPConn, error)

DialIP在网络协议netProto上连接本地地址laddr和远端地址raddr，netProto必须是"ip"、"ip4"或"ip6"后跟冒号和协议名或协议号。

### func ListenIP

    func ListenIP(netProto string, laddr *IPAddr) (*IPConn, error)

ListenIP创建一个接收目的地是本地地址laddr的IP数据包的网络连接，返回的*IPConn的ReadFrom和WriteTo方法可以用来发送和接收IP数据包。（每个包都可获取来源址或者设置目标地址）

### func (*IPConn) LocalAddr

    func (c *IPConn) LocalAddr() Addr

LocalAddr返回本地网络地址

### func (*IPConn) RemoteAddr

    func (c *IPConn) RemoteAddr() Addr

RemoteAddr返回远端网络地址

### func (*IPConn) SetReadBuffer

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

SetReadBuffer设置该连接的系统接收缓冲

### func (*IPConn) SetWriteBuffer

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

SetWriteBuffer设置该连接的系统发送缓冲

### func (*IPConn) SetDeadline

    func (c *IPConn) SetDeadline(t time.Time) error

SetDeadline设置读写操作绝对期限，实现了Conn接口的SetDeadline方法

### func (*IPConn) SetReadDeadline

    func (c *IPConn) SetReadDeadline(t time.Time) error

SetReadDeadline设置读操作绝对期限，实现了Conn接口的SetReadDeadline方法

### func (*IPConn) SetWriteDeadline

    func (c *IPConn) SetWriteDeadline(t time.Time) error

SetWriteDeadline设置写操作绝对期限，实现了Conn接口的SetWriteDeadline方法

### func (*IPConn) Read

    func (c *IPConn) Read(b []byte) (int, error)

Read实现Conn接口Read方法

### func (*IPConn) ReadFrom

    func (c *IPConn) ReadFrom(b []byte) (int, Addr, error)

ReadFrom实现PacketConn接口ReadFrom方法。注意本方法有bug，应避免使用。

### func (*IPConn) ReadFromIP

    func (c *IPConn) ReadFromIP(b []byte) (int, *IPAddr, error)

ReadFromIP从c读取一个IP数据包，将有效负载拷贝到b，返回拷贝字节数和数据包来源地址。

ReadFromIP方法会在超过一个固定的时间点之后超时，并返回一个错误。注意本方法有bug，应避免使用。

### func (*IPConn) ReadMsgIP

    func (c *IPConn) ReadMsgIP(b, oob []byte) (n, oobn, flags int, addr *IPAddr, err error)

ReadMsgIP从c读取一个数据包，将有效负载拷贝进b，相关的带外数据拷贝进oob，返回拷贝进b的字节数，拷贝进oob的字节数，数据包的flag，数据包来源地址和可能的错误。

### func (*IPConn) Write

    func (c *IPConn) Write(b []byte) (int, error)

Write实现Conn接口Write方法

### func (*IPConn) WriteTo

    func (c *IPConn) WriteTo(b []byte, addr Addr) (int, error)

WriteTo实现PacketConn接口WriteTo方法

### func (*IPConn) WriteToIP

    func (c *IPConn) WriteToIP(b []byte, addr *IPAddr) (int, error)

WriteToIP通过c向地址addr发送一个数据包，b为包的有效负载，返回写入的字节。

WriteToIP方法会在超过一个固定的时间点之后超时，并返回一个错误。在面向数据包的连接上，写入超时是十分罕见的。

### func (*IPConn) WriteMsgIP

    func (c *IPConn) WriteMsgIP(b, oob []byte, addr *IPAddr) (n, oobn int, err error)

WriteMsgIP通过c向地址addr发送一个数据包，b和oob分别为包有效负载和对应的带外数据，返回写入的字节数（包数据、带外数据）和可能的错误。

### func (*IPConn) Close

    func (c *IPConn) Close() error

Close关闭连接

### func (*IPConn) File

    func (c *IPConn) File() (f *os.File, err error)

File方法设置下层的os.File为阻塞模式并返回其副本。

使用者有责任在用完后关闭f。关闭c不影响f，关闭f也不影响c。返回的os.File类型文件描述符和原本的网络连接是不同的。试图使用该副本修改本体的属性可能会（也可能不会）得到期望的效果。

## type TCPConn

    type TCPConn struct {
        // 内含隐藏或非导出字段
    }

TCPConn代表一个TCP网络连接，实现了Conn接口。

### func DialTCP

    func DialTCP(net string, laddr, raddr *TCPAddr) (*TCPConn, error)

DialTCP在网络协议net上连接本地地址laddr和远端地址raddr。net必须是"tcp"、"tcp4"、"tcp6"；如果laddr不是nil，将使用它作为本地地址，否则自动选择一个本地地址。

### func (*TCPConn) LocalAddr

    func (c *TCPConn) LocalAddr() Addr

LocalAddr返回本地网络地址

### func (*TCPConn) RemoteAddr

    func (c *TCPConn) RemoteAddr() Addr

RemoteAddr返回远端网络地址

### func (*TCPConn) SetReadBuffer

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

SetReadBuffer设置该连接的系统接收缓冲

### func (*TCPConn) SetWriteBuffer

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

SetWriteBuffer设置该连接的系统发送缓冲

### func (*TCPConn) SetDeadline

    func (c *TCPConn) SetDeadline(t time.Time) error

SetDeadline设置读写操作期限，实现了Conn接口的SetDeadline方法

### func (*TCPConn) SetReadDeadline

    func (c *TCPConn) SetReadDeadline(t time.Time) error

SetReadDeadline设置读操作期限，实现了Conn接口的SetReadDeadline方法

### func (*TCPConn) SetWriteDeadline

    func (c *TCPConn) SetWriteDeadline(t time.Time) error

SetWriteDeadline设置写操作期限，实现了Conn接口的SetWriteDeadline方法

### func (*TCPConn) SetKeepAlive

    func (c *TCPConn) SetKeepAlive(keepalive bool) error

SetKeepAlive设置操作系统是否应该在该连接中发送keepalive信息

### func (*TCPConn) SetKeepAlivePeriod

    func (c *TCPConn) SetKeepAlivePeriod(d time.Duration) error

SetKeepAlivePeriod设置keepalive的周期，超出会断开

### func (*TCPConn) SetLinger

    func (c *TCPConn) SetLinger(sec int) error

SetLinger设定当连接中仍有数据等待发送或接受时的Close方法的行为。

如果sec < 0（默认），Close方法立即返回，操作系统停止后台数据发送；如果 sec == 0，Close立刻返回，操作系统丢弃任何未发送或未接收的数据；如果sec > 0，Close方法阻塞最多sec秒，等待数据发送或者接收，在一些操作系统中，在超时后，任何未发送的数据会被丢弃。

### func (*TCPConn) SetNoDelay

    func (c *TCPConn) SetNoDelay(noDelay bool) error

SetNoDelay设定操作系统是否应该延迟数据包传递，以便发送更少的数据包（Nagle's算法）。默认为真，即数据应该在Write方法后立刻发送。

### func (*TCPConn) Read

    func (c *TCPConn) Read(b []byte) (int, error)

Read实现了Conn接口Read方法

### func (*TCPConn) Write

    func (c *TCPConn) Write(b []byte) (int, error)

Write实现了Conn接口Write方法

### func (*TCPConn) ReadFrom

    func (c *TCPConn) ReadFrom(r io.Reader) (int64, error)

ReadFrom实现了io.ReaderFrom接口的ReadFrom方法

### func (*TCPConn) Close

    func (c *TCPConn) Close() error

Close关闭连接

### func (*TCPConn) CloseRead

    func (c *TCPConn) CloseRead() error

CloseRead关闭TCP连接的读取侧（以后不能读取），应尽量使用Close方法。

### func (*TCPConn) CloseWrite

    func (c *TCPConn) CloseWrite() error

CloseWrite关闭TCP连接的写入侧（以后不能写入），应尽量使用Close方法。

### func (*TCPConn) File

    func (c *TCPConn) File() (f *os.File, err error)

File方法设置下层的os.File为阻塞模式并返回其副本。

使用者有责任在用完后关闭f。关闭c不影响f，关闭f也不影响c。返回的os.File类型文件描述符和原本的网络连接是不同的。试图使用该副本修改本体的属性可能会（也可能不会）得到期望的效果。

## type UDPConn

    type UDPConn struct {
        // 内含隐藏或非导出字段
    }

UDPConn代表一个UDP网络连接，实现了Conn和PacketConn接口。

### func DialUDP

    func DialUDP(net string, laddr, raddr *UDPAddr) (*UDPConn, error)

DialTCP在网络协议net上连接本地地址laddr和远端地址raddr。net必须是"udp"、"udp4"、"udp6"；如果laddr不是nil，将使用它作为本地地址，否则自动选择一个本地地址。

### func ListenUDP

    func ListenUDP(net string, laddr *UDPAddr) (*UDPConn, error)

ListenUDP创建一个接收目的地是本地地址laddr的UDP数据包的网络连接。net必须是"udp"、"udp4"、"udp6"；如果laddr端口为0，函数将选择一个当前可用的端口，可以用Listener的Addr方法获得该端口。返回的*UDPConn的ReadFrom和WriteTo方法可以用来发送和接收UDP数据包（每个包都可获得来源地址或设置目标地址）。

### func ListenMulticastUDP

    func ListenMulticastUDP(net string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error)

ListenMulticastUDP接收目的地是ifi接口上的组地址gaddr的UDP数据包。它指定了使用的接口，如果ifi是nil，将使用默认接口。

### func (*UDPConn) LocalAddr

    func (c *UDPConn) LocalAddr() Addr

LocalAddr返回本地网络地址

### func (*UDPConn) RemoteAddr

    func (c *UDPConn) RemoteAddr() Addr

RemoteAddr返回远端网络地址

### func (*UDPConn) SetReadBuffer

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

SetReadBuffer设置该连接的系统接收缓冲

### func (*UDPConn) SetWriteBuffer

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

SetWriteBuffer设置该连接的系统发送缓冲

### func (*UDPConn) SetDeadline

    func (c *UDPConn) SetDeadline(t time.Time) error

SetDeadline设置读写操作期限，实现了Conn接口的SetDeadline方法

### func (*UDPConn) SetReadDeadline

    func (c *UDPConn) SetReadDeadline(t time.Time) error

SetReadDeadline设置读操作期限，实现了Conn接口的SetReadDeadline方法

### func (*UDPConn) SetWriteDeadline

    func (c *UDPConn) SetWriteDeadline(t time.Time) error

SetWriteDeadline设置写操作期限，实现了Conn接口的SetWriteDeadline方法

### func (*UDPConn) Read

    func (c *UDPConn) Read(b []byte) (int, error)

Read实现Conn接口Read方法

### func (*UDPConn) ReadFrom

    func (c *UDPConn) ReadFrom(b []byte) (int, Addr, error)

ReadFrom实现PacketConn接口ReadFrom方法

### func (*UDPConn) ReadFromUDP

    func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err error)

ReadFromUDP从c读取一个UDP数据包，将有效负载拷贝到b，返回拷贝字节数和数据包来源地址。

ReadFromUDP方法会在超过一个固定的时间点之后超时，并返回一个错误。

### func (*UDPConn) ReadMsgUDP

    func (c *UDPConn) ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error)

ReadMsgUDP从c读取一个数据包，将有效负载拷贝进b，相关的带外数据拷贝进oob，返回拷贝进b的字节数，拷贝进oob的字节数，数据包的flag，数据包来源地址和可能的错误。

### func (*UDPConn) Write

    func (c *UDPConn) Write(b []byte) (int, error)

Write实现Conn接口Write方法

### func (*UDPConn) WriteTo

    func (c *UDPConn) WriteTo(b []byte, addr Addr) (int, error)

WriteTo实现PacketConn接口WriteTo方法

### func (*UDPConn) WriteToUDP

    func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error)

WriteToUDP通过c向地址addr发送一个数据包，b为包的有效负载，返回写入的字节。

WriteToUDP方法会在超过一个固定的时间点之后超时，并返回一个错误。在面向数据包的连接上，写入超时是十分罕见的。

### func (*UDPConn) WriteMsgUDP

    func (c *UDPConn) WriteMsgUDP(b, oob []byte, addr *UDPAddr) (n, oobn int, err error)

WriteMsgUDP通过c向地址addr发送一个数据包，b和oob分别为包有效负载和对应的带外数据，返回写入的字节数（包数据、带外数据）和可能的错误。

### func (*UDPConn) Close

    func (c *UDPConn) Close() error

Close关闭连接

### func (*UDPConn) File

    func (c *UDPConn) File() (f *os.File, err error)

File方法设置下层的os.File为阻塞模式并返回其副本。

使用者有责任在用完后关闭f。关闭c不影响f，关闭f也不影响c。返回的os.File类型文件描述符和原本的网络连接是不同的。试图使用该副本修改本体的属性可能会（也可能不会）得到期望的效果。

## type UnixConn

    type UnixConn struct {
        // 内含隐藏或非导出字段
    }

UnixConn代表Unix域socket连接，实现了Conn和PacketConn接口。

### func DialUnix

    func DialUnix(net string, laddr, raddr *UnixAddr) (*UnixConn, error)

DialUnix在网络协议net上连接本地地址laddr和远端地址raddr。net必须是"unix"、"unixgram"、"unixpacket"，如果laddr不是nil将使用它作为本地地址，否则自动选择一个本地地址。

### func ListenUnixgram

    func ListenUnixgram(net string, laddr *UnixAddr) (*UnixConn, error)

ListenUnixgram接收目的地是本地地址laddr的Unix datagram网络连接。net必须是"unixgram"，返回的*UnixConn的ReadFrom和WriteTo方法可以用来发送和接收数据包（每个包都可获取来源址或者设置目标地址）。

### func (*UnixConn) LocalAddr

    func (c *UnixConn) LocalAddr() Addr

LocalAddr返回本地网络地址

### func (*UnixConn) RemoteAddr

    func (c *UnixConn) RemoteAddr() Addr

RemoteAddr返回远端网络地址

### func (*UnixConn) SetReadBuffer

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

SetReadBuffer设置该连接的系统接收缓冲

### func (*UnixConn) SetWriteBuffer

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

SetWriteBuffer设置该连接的系统发送缓冲

### func (*UnixConn) SetDeadline

    func (c *UnixConn) SetDeadline(t time.Time) error

SetDeadline设置读写操作期限，实现了Conn接口的SetDeadline方法

### func (*UnixConn) SetReadDeadline

    func (c *UnixConn) SetReadDeadline(t time.Time) error

SetReadDeadline设置读操作期限，实现了Conn接口的SetReadDeadline方法

### func (*UnixConn) SetWriteDeadline

    func (c *UnixConn) SetWriteDeadline(t time.Time) error

SetWriteDeadline设置写操作期限，实现了Conn接口的SetWriteDeadline方法

### func (*UnixConn) Read

    func (c *UnixConn) Read(b []byte) (int, error)

Read实现了Conn接口Read方法

### func (*UnixConn) ReadFrom

    func (c *UnixConn) ReadFrom(b []byte) (int, Addr, error)

ReadFrom实现PacketConn接口ReadFrom方法

### func (*UnixConn) ReadFromUnix

    func (c *UnixConn) ReadFromUnix(b []byte) (n int, addr *UnixAddr, err error)

ReadFromUnix从c读取一个UDP数据包，将有效负载拷贝到b，返回拷贝字节数和数据包来源地址。

ReadFromUnix方法会在超过一个固定的时间点之后超时，并返回一个错误。

### func (*UnixConn) ReadMsgUnix

    func (c *UnixConn) ReadMsgUnix(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error)

ReadMsgUnix从c读取一个数据包，将有效负载拷贝进b，相关的带外数据拷贝进oob，返回拷贝进b的字节数，拷贝进oob的字节数，数据包的flag，数据包来源地址和可能的错误。

### func (*UnixConn) Write

    func (c *UnixConn) Write(b []byte) (int, error)

Write实现了Conn接口Write方法

### func (*UnixConn) WriteTo

    func (c *UnixConn) WriteTo(b []byte, addr Addr) (n int, err error)

WriteTo实现PacketConn接口WriteTo方法

### func (*UnixConn) WriteToUnix

    func (c *UnixConn) WriteToUnix(b []byte, addr *UnixAddr) (n int, err error)

WriteToUnix通过c向地址addr发送一个数据包，b为包的有效负载，返回写入的字节。

WriteToUnix方法会在超过一个固定的时间点之后超时，并返回一个错误。在面向数据包的连接上，写入超时是十分罕见的。

### func (*UnixConn) WriteMsgUnix

    func (c *UnixConn) WriteMsgUnix(b, oob []byte, addr *UnixAddr) (n, oobn int, err error)

WriteMsgUnix通过c向地址addr发送一个数据包，b和oob分别为包有效负载和对应的带外数据，返回写入的字节数（包数据、带外数据）和可能的错误。

### func (*UnixConn) Close

    func (c *UnixConn) Close() error

Close关闭连接

### func (*UnixConn) CloseRead

    func (c *UnixConn) CloseRead() error

CloseRead关闭TCP连接的读取侧（以后不能读取），应尽量使用Close方法

### func (*UnixConn) CloseWrite

    func (c *UnixConn) CloseWrite() error

CloseWrite关闭TCP连接的写入侧（以后不能写入），应尽量使用Close方法

### func (*UnixConn) File

    func (c *UnixConn) File() (f *os.File, err error)

File方法设置下层的os.File为阻塞模式并返回其副本。

使用者有责任在用完后关闭f。关闭c不影响f，关闭f也不影响c。返回的os.File类型文件描述符和原本的网络连接是不同的。试图使用该副本修改本体的属性可能会（也可能不会）得到期望的效果。

## type TCPListener

    type TCPListener struct {
        // 内含隐藏或非导出字段
    }

TCPListener代表一个TCP网络的监听者。使用者应尽量使用Listener接口而不是假设（网络连接为）TCP。

### func ListenTCP

    func ListenTCP(net string, laddr *TCPAddr) (*TCPListener, error)

ListenTCP在本地TCP地址laddr上声明并返回一个*TCPListener，net参数必须是"tcp"、"tcp4"、"tcp6"，如果laddr的端口字段为0，函数将选择一个当前可用的端口，可以用Listener的Addr方法获得该端口。

### func (*TCPListener) Addr

    func (l *TCPListener) Addr() Addr

Addr返回l监听的的网络地址，一个*TCPAddr。

### func (*TCPListener) SetDeadline

    func (l *TCPListener) SetDeadline(t time.Time) error

设置监听器执行的期限，t为Time零值则会关闭期限限制。

### func (*TCPListener) Accept

    func (l *TCPListener) Accept() (Conn, error)

Accept用于实现Listener接口的Accept方法；他会等待下一个呼叫，并返回一个该呼叫的Conn接口。

### func (*TCPListener) AcceptTCP

    func (l *TCPListener) AcceptTCP() (*TCPConn, error)

AcceptTCP接收下一个呼叫，并返回一个新的*TCPConn。

### func (*TCPListener) Close

    func (l *TCPListener) Close() error

Close停止监听TCP地址，已经接收的连接不受影响。

### func (*TCPListener) File

    func (l *TCPListener) File() (f *os.File, err error)

File方法返回下层的os.File的副本，并将该副本设置为阻塞模式。

使用者有责任在用完后关闭f。关闭c不影响f，关闭f也不影响c。返回的os.File类型文件描述符和原本的网络连接是不同的。试图使用该副本修改本体的属性可能会（也可能不会）得到期望的效果。

## type UnixListener

    type UnixListener struct {
        // 内含隐藏或非导出字段
    }

UnixListener代表一个Unix域scoket的监听者。使用者应尽量使用Listener接口而不是假设（网络连接为）Unix域scoket。

### func ListenUnix

    func ListenUnix(net string, laddr *UnixAddr) (*UnixListener, error)

ListenTCP在Unix域scoket地址laddr上声明并返回一个*UnixListener，net参数必须是"unix"或"unixpacket"。

### func (*UnixListener) Addr

    func (l *UnixListener) Addr() Addr

Addr返回l的监听的Unix域socket地址

### func (*UnixListener) SetDeadline

    func (l *UnixListener) SetDeadline(t time.Time) (err error)

设置监听器执行的期限，t为Time零值则会关闭期限限制

### func (*UnixListener) Accept

    func (l *UnixListener) Accept() (c Conn, err error)

Accept用于实现Listener接口的Accept方法；他会等待下一个呼叫，并返回一个该呼叫的Conn接口。

### func (*UnixListener) AcceptUnix

    func (l *UnixListener) AcceptUnix() (*UnixConn, error)

AcceptUnix接收下一个呼叫，并返回一个新的*UnixConn。

### func (*UnixListener) Close

    func (l *UnixListener) Close() error

Close停止监听Unix域socket地址，已经接收的连接不受影响。

### func (*UnixListener) File

    func (l *UnixListener) File() (f *os.File, err error)

File方法返回下层的os.File的副本，并将该副本设置为阻塞模式。

使用者有责任在用完后关闭f。关闭c不影响f，关闭f也不影响c。返回的os.File类型文件描述符和原本的网络连接是不同的。试图使用该副本修改本体的属性可能会（也可能不会）得到期望的效果。

## func FileConn

    func FileConn(f *os.File) (c Conn, err error)

FileConn返回一个下层为文件f的网络连接的拷贝。调用者有责任在结束程序前关闭f。关闭c不会影响f，关闭f也不会影响c。本函数与各种实现了Conn接口的类型的File方法是对应的。

## func FilePacketConn

    func FilePacketConn(f *os.File) (c PacketConn, err error)

FilePacketConn函数返回一个下层为文件f的数据包网络连接的拷贝。调用者有责任在结束程序前关闭f。关闭c不会影响f，关闭f也不会影响c。本函数与各种实现了PacketConn接口的类型的File方法是对应的。

## func FileListener

    func FileListener(f *os.File) (l Listener, err error)

FileListener返回一个下层为文件f的网络监听器的拷贝。调用者有责任在使用结束后改变l。关闭l不会影响f，关闭f也不会影响l。本函数与各种实现了Listener接口的类型的File方法是对应的。

## type MX

    type MX struct {
        Host string
        Pref uint16
    }

MX代表一条DNS MX记录（邮件交换记录），根据收信人的地址后缀来定位邮件服务器。

## type NS

    type NS struct {
        Host string
    }

NS代表一条DNS NS记录（域名服务器记录），指定该域名由哪个DNS服务器来进行解析。

## type SRV

    type SRV struct {
        Target   string
        Port     uint16
        Priority uint16
        Weight   uint16
    }

SRV代表一条DNS SRV记录（资源记录），记录某个服务由哪台计算机提供。

## func LookupPort

    func LookupPort(network, service string) (port int, err error)

LookupPort函数查询指定网络和服务的（默认）端口。

## func LookupCNAME

    func LookupCNAME(name string) (cname string, err error)

LookupCNAME函数查询name的规范DNS名（但该域名未必可以访问）。如果调用者不关心规范名可以直接调用LookupHost或者LookupIP；这两个函数都会在查询时考虑到规范名。

## func LookupHost

    func LookupHost(host string) (addrs []string, err error)

LookupHost函数查询主机的网络地址序列。

## func LookupIP

    func LookupIP(host string) (addrs []IP, err error)

LookupIP函数查询主机的ipv4和ipv6地址序列。

## func LookupAddr

    func LookupAddr(addr string) (name []string, err error)

LookupAddr查询某个地址，返回映射到该地址的主机名序列，本函数和LookupHost不互为反函数。

## func LookupMX

    func LookupMX(name string) (mx []*MX, err error)

LookupMX函数返回指定主机的按Pref字段排好序的DNS MX记录。

## func LookupNS

    func LookupNS(name string) (ns []*NS, err error)

LookupNS函数返回指定主机的DNS NS记录。

## func LookupSRV

    func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err error)

LookupSRV函数尝试执行指定服务、协议、主机的SRV查询。协议proto为"tcp" 或"udp"。返回的记录按Priority字段排序，同一优先度按Weight字段随机排序。

LookupSRV函数按照RFC 2782的规定构建用于查询的DNS名。也就是说，它会查询_service._proto.name。为了适应将服务的SRV记录发布在非规范名下的情况，如果service和proto参数都是空字符串，函数会直接查询name。

## func LookupTXT

    func LookupTXT(name string) (txt []string, err error)

LookupTXT函数返回指定主机的DNS TXT记录。

## Bugs

☞在任何POSIX平台上，从"ip4"网络使用ReadFrom或ReadFromIP方法读取数据时，即使有足够的空间，都可能不会返回完整的IPv4数据包，包括数据包的头域。即使Read或ReadMsgIP方法可以返回完整的数据包，也有可能出现这种情况。因为对go 1的兼容性要求，这个情况无法被修正。因此，当必须获取完整数据包时，建议你不要使用这两个方法，请使用Read或ReadMsgIP代替。

☞在OpenBSD系统中，在"tcp"网络监听时不会同时监听IPv4和IPv6连接。 因为该系统中IPv4通信不会导入IPv6套接字中。请使用两个独立的监听，如果有必要的话。