| // Copyright 2009 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 NaCl, Plan 9 and Windows, the ReadMsgUDP and |
| // WriteMsgUDP methods of UDPConn are not implemented. |
| |
| // BUG(mikio): On Windows, the File method of UDPConn is not |
| // implemented. |
| |
| // BUG(mikio): On NaCl and Plan 9, the ListenMulticastUDP function is |
| // not implemented. |
| |
| // UDPAddr represents the address of a UDP end point. |
| type UDPAddr struct { |
| IP IP |
| Port int |
| Zone string // IPv6 scoped addressing zone |
| } |
| |
| // Network returns the address's network name, "udp". |
| func (a *UDPAddr) Network() string { return "udp" } |
| |
| func (a *UDPAddr) String() string { |
| if a == nil { |
| return "<nil>" |
| } |
| ip := ipEmptyString(a.IP) |
| if a.Zone != "" { |
| return JoinHostPort(ip+"%"+a.Zone, itoa(a.Port)) |
| } |
| return JoinHostPort(ip, itoa(a.Port)) |
| } |
| |
| func (a *UDPAddr) isWildcard() bool { |
| if a == nil || a.IP == nil { |
| return true |
| } |
| return a.IP.IsUnspecified() |
| } |
| |
| func (a *UDPAddr) opAddr() Addr { |
| if a == nil { |
| return nil |
| } |
| return a |
| } |
| |
| // 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 ResolveUDPAddr(net, addr string) (*UDPAddr, error) { |
| switch net { |
| case "udp", "udp4", "udp6": |
| case "": // a hint wildcard for Go 1.0 undocumented behavior |
| net = "udp" |
| default: |
| return nil, UnknownNetworkError(net) |
| } |
| addrs, err := internetAddrList(context.Background(), net, addr) |
| if err != nil { |
| return nil, err |
| } |
| return addrs.first(isIPv4).(*UDPAddr), nil |
| } |
| |
| // UDPConn is the implementation of the Conn and PacketConn interfaces |
| // for UDP network connections. |
| type UDPConn struct { |
| conn |
| } |
| |
| // ReadFromUDP reads a UDP packet from c, copying the payload into b. |
| // It returns the number of bytes copied into b and the return address |
| // that was on the packet. |
| // |
| // ReadFromUDP can be made to time out and return an error with |
| // Timeout() == true after a fixed time limit; see SetDeadline and |
| // SetReadDeadline. |
| func (c *UDPConn) ReadFromUDP(b []byte) (int, *UDPAddr, 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 *UDPConn) 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 |
| } |
| |
| // ReadMsgUDP reads a packet 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 packet and the source address of the |
| // packet. |
| func (c *UDPConn) ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, 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 |
| } |
| |
| // WriteToUDP writes a UDP packet to addr via c, copying the payload |
| // from b. |
| // |
| // WriteToUDP 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. |
| func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (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 *UDPConn) WriteTo(b []byte, addr Addr) (int, error) { |
| if !c.ok() { |
| return 0, syscall.EINVAL |
| } |
| a, ok := addr.(*UDPAddr) |
| 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 |
| } |
| |
| // WriteMsgUDP writes a packet to addr via c if c isn't connected, or |
| // to c's remote destination 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. |
| func (c *UDPConn) WriteMsgUDP(b, oob []byte, addr *UDPAddr) (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 newUDPConn(fd *netFD) *UDPConn { return &UDPConn{conn{fd}} } |
| |
| // DialUDP connects to the remote address raddr on the network net, |
| // which must be "udp", "udp4", or "udp6". If laddr is not nil, it is |
| // used as the local address for the connection. |
| func DialUDP(net string, laddr, raddr *UDPAddr) (*UDPConn, error) { |
| switch net { |
| case "udp", "udp4", "udp6": |
| default: |
| return nil, &OpError{Op: "dial", Net: net, Source: laddr.opAddr(), Addr: raddr.opAddr(), Err: UnknownNetworkError(net)} |
| } |
| if raddr == nil { |
| return nil, &OpError{Op: "dial", Net: net, Source: laddr.opAddr(), Addr: nil, Err: errMissingAddress} |
| } |
| c, err := dialUDP(context.Background(), net, laddr, raddr) |
| if err != nil { |
| return nil, &OpError{Op: "dial", Net: net, Source: laddr.opAddr(), Addr: raddr.opAddr(), Err: err} |
| } |
| return c, nil |
| } |
| |
| // ListenUDP listens for incoming UDP packets addressed to the local |
| // address laddr. Net must be "udp", "udp4", or "udp6". If laddr has |
| // a port of 0, ListenUDP will choose an available port. |
| // The LocalAddr method of the returned UDPConn can be used to |
| // discover the port. The returned connection's ReadFrom and WriteTo |
| // methods can be used to receive and send UDP packets with per-packet |
| // addressing. |
| func ListenUDP(net string, laddr *UDPAddr) (*UDPConn, error) { |
| switch net { |
| case "udp", "udp4", "udp6": |
| default: |
| return nil, &OpError{Op: "listen", Net: net, Source: nil, Addr: laddr.opAddr(), Err: UnknownNetworkError(net)} |
| } |
| if laddr == nil { |
| laddr = &UDPAddr{} |
| } |
| c, err := listenUDP(context.Background(), net, laddr) |
| if err != nil { |
| return nil, &OpError{Op: "listen", Net: net, Source: nil, Addr: laddr.opAddr(), Err: err} |
| } |
| return c, nil |
| } |
| |
| // ListenMulticastUDP listens for incoming multicast UDP packets |
| // addressed to the group address gaddr on the interface ifi. |
| // Network must be "udp", "udp4" or "udp6". |
| // ListenMulticastUDP uses the system-assigned multicast interface |
| // when ifi is nil, although this is not recommended because the |
| // assignment depends on platforms and sometimes it might require |
| // routing configuration. |
| // |
| // 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. |
| func ListenMulticastUDP(network string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error) { |
| switch network { |
| case "udp", "udp4", "udp6": |
| default: |
| return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: gaddr.opAddr(), Err: UnknownNetworkError(network)} |
| } |
| if gaddr == nil || gaddr.IP == nil { |
| return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: gaddr.opAddr(), Err: errMissingAddress} |
| } |
| c, err := listenMulticastUDP(context.Background(), network, ifi, gaddr) |
| if err != nil { |
| return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: gaddr.opAddr(), Err: err} |
| } |
| return c, nil |
| } |