Editando: iprawsock.go
// Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package net import ( "context" "syscall" ) // BUG(mikio): On every POSIX platform, reads from the "ip4" network // using the ReadFrom or ReadFromIP method might not return a complete // IPv4 packet, including its header, even if there is space // available. This can occur even in cases where Read or ReadMsgIP // could return a complete packet. For this reason, it is recommended // that you do not use these methods if it is important to receive a // full packet. // // The Go 1 compatibility guidelines make it impossible for us to // change the behavior of these methods; use Read or ReadMsgIP // instead. // BUG(mikio): On JS and Plan 9, methods and functions related // to IPConn are not implemented. // BUG(mikio): On Windows, the File method of IPConn is not // implemented. // IPAddr represents the address of an IP end point. type IPAddr struct { IP IP Zone string // IPv6 scoped addressing zone } // Network returns the address's network name, "ip". func (a *IPAddr) Network() string { return "ip" } func (a *IPAddr) String() string { if a == nil { return "<nil>" } ip := ipEmptyString(a.IP) if a.Zone != "" { return ip + "%" + a.Zone } return ip } func (a *IPAddr) isWildcard() bool { if a == nil || a.IP == nil { return true } return a.IP.IsUnspecified() } func (a *IPAddr) opAddr() Addr { if a == nil { return nil } return a } // ResolveIPAddr returns an address of IP end point. // // The network must be an IP network name. // // If the host in the address parameter is not a literal IP address, // ResolveIPAddr resolves the address to an address of IP end point. // Otherwise, it parses the address as a literal IP address. // The address parameter can use a host name, but this is not // recommended, because it will return at most one of the host name's // IP addresses. // // See func [Dial] for a description of the network and address // parameters. func ResolveIPAddr(network, address string) (*IPAddr, error) { if network == "" { // a hint wildcard for Go 1.0 undocumented behavior network = "ip" } afnet, _, err := parseNetwork(context.Background(), network, false) if err != nil { return nil, err } switch afnet { case "ip", "ip4", "ip6": default: return nil, UnknownNetworkError(network) } addrs, err := DefaultResolver.internetAddrList(context.Background(), afnet, address) if err != nil { return nil, err } return addrs.forResolve(network, address).(*IPAddr), nil } // IPConn is the implementation of the [Conn] and [PacketConn] interfaces // for IP network connections. type IPConn struct { conn } // SyscallConn returns a raw network connection. // This implements the [syscall.Conn] interface. func (c *IPConn) SyscallConn() (syscall.RawConn, error) { if !c.ok() { return nil, syscall.EINVAL } return newRawConn(c.fd), nil } // ReadFromIP acts like ReadFrom but returns an IPAddr. func (c *IPConn) ReadFromIP(b []byte) (int, *IPAddr, error) { if !c.ok() { return 0, nil, syscall.EINVAL } n, addr, err := c.readFrom(b) if err != nil { err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err} } return n, addr, err } // ReadFrom implements the [PacketConn] ReadFrom method. func (c *IPConn) ReadFrom(b []byte) (int, Addr, error) { if !c.ok() { return 0, nil, syscall.EINVAL } n, addr, err := c.readFrom(b) if err != nil { err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err} } if addr == nil { return n, nil, err } return n, addr, err } // 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) ReadMsgIP(b, oob []byte) (n, oobn, flags int, addr *IPAddr, err error) { if !c.ok() { return 0, 0, 0, nil, syscall.EINVAL } n, oobn, flags, addr, err = c.readMsg(b, oob) if err != nil { err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err} } return } // WriteToIP acts like [IPConn.WriteTo] but takes an [IPAddr]. func (c *IPConn) WriteToIP(b []byte, addr *IPAddr) (int, error) { if !c.ok() { return 0, syscall.EINVAL } n, err := c.writeTo(b, addr) if err != nil { err = &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: addr.opAddr(), Err: err} } return n, err } // WriteTo implements the [PacketConn] WriteTo method. func (c *IPConn) WriteTo(b []byte, addr Addr) (int, error) { if !c.ok() { return 0, syscall.EINVAL } a, ok := addr.(*IPAddr) if !ok { return 0, &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: addr, Err: syscall.EINVAL} } n, err := c.writeTo(b, a) if err != nil { err = &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: a.opAddr(), Err: err} } return n, err } // 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. func (c *IPConn) WriteMsgIP(b, oob []byte, addr *IPAddr) (n, oobn int, err error) { if !c.ok() { return 0, 0, syscall.EINVAL } n, oobn, err = c.writeMsg(b, oob, addr) if err != nil { err = &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: addr.opAddr(), Err: err} } return } func newIPConn(fd *netFD) *IPConn { return &IPConn{conn{fd}} } // DialIP acts like [Dial] for IP networks. // // The network must be an IP network name; see func Dial for details. // // If laddr is nil, a local address is automatically chosen. // If the IP field of raddr is nil or an unspecified IP address, the // local system is assumed. func DialIP(network string, laddr, raddr *IPAddr) (*IPConn, error) { if raddr == nil { return nil, &OpError{Op: "dial", Net: network, Source: laddr.opAddr(), Addr: nil, Err: errMissingAddress} } sd := &sysDialer{network: network, address: raddr.String()} c, err := sd.dialIP(context.Background(), laddr, raddr) if err != nil { return nil, &OpError{Op: "dial", Net: network, Source: laddr.opAddr(), Addr: raddr.opAddr(), Err: err} } return c, nil } // 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 ListenIP(network string, laddr *IPAddr) (*IPConn, error) { if laddr == nil { laddr = &IPAddr{} } sl := &sysListener{network: network, address: laddr.String()} c, err := sl.listenIP(context.Background(), laddr) if err != nil { return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: laddr.opAddr(), Err: err} } return c, nil }
Cancelar
Kerym Chaeceran