Source file src/pkg/net/udpsock_posix.go

     1	// Copyright 2009 The Go Authors.  All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// +build darwin freebsd linux netbsd openbsd windows
     6	
     7	// UDP sockets
     8	
     9	package net
    10	
    11	import (
    12		"errors"
    13		"os"
    14		"syscall"
    15		"time"
    16	)
    17	
    18	var ErrWriteToConnected = errors.New("use of WriteTo with pre-connected UDP")
    19	
    20	func sockaddrToUDP(sa syscall.Sockaddr) Addr {
    21		switch sa := sa.(type) {
    22		case *syscall.SockaddrInet4:
    23			return &UDPAddr{sa.Addr[0:], sa.Port}
    24		case *syscall.SockaddrInet6:
    25			return &UDPAddr{sa.Addr[0:], sa.Port}
    26		}
    27		return nil
    28	}
    29	
    30	func (a *UDPAddr) family() int {
    31		if a == nil || len(a.IP) <= IPv4len {
    32			return syscall.AF_INET
    33		}
    34		if a.IP.To4() != nil {
    35			return syscall.AF_INET
    36		}
    37		return syscall.AF_INET6
    38	}
    39	
    40	func (a *UDPAddr) isWildcard() bool {
    41		if a == nil || a.IP == nil {
    42			return true
    43		}
    44		return a.IP.IsUnspecified()
    45	}
    46	
    47	func (a *UDPAddr) sockaddr(family int) (syscall.Sockaddr, error) {
    48		return ipToSockaddr(family, a.IP, a.Port)
    49	}
    50	
    51	func (a *UDPAddr) toAddr() sockaddr {
    52		if a == nil { // nil *UDPAddr
    53			return nil // nil interface
    54		}
    55		return a
    56	}
    57	
    58	// UDPConn is the implementation of the Conn and PacketConn
    59	// interfaces for UDP network connections.
    60	type UDPConn struct {
    61		fd *netFD
    62	}
    63	
    64	func newUDPConn(fd *netFD) *UDPConn { return &UDPConn{fd} }
    65	
    66	func (c *UDPConn) ok() bool { return c != nil && c.fd != nil }
    67	
    68	// Implementation of the Conn interface - see Conn for documentation.
    69	
    70	// Read implements the Conn Read method.
    71	func (c *UDPConn) Read(b []byte) (int, error) {
    72		if !c.ok() {
    73			return 0, syscall.EINVAL
    74		}
    75		return c.fd.Read(b)
    76	}
    77	
    78	// Write implements the Conn Write method.
    79	func (c *UDPConn) Write(b []byte) (int, error) {
    80		if !c.ok() {
    81			return 0, syscall.EINVAL
    82		}
    83		return c.fd.Write(b)
    84	}
    85	
    86	// Close closes the UDP connection.
    87	func (c *UDPConn) Close() error {
    88		if !c.ok() {
    89			return syscall.EINVAL
    90		}
    91		return c.fd.Close()
    92	}
    93	
    94	// LocalAddr returns the local network address.
    95	func (c *UDPConn) LocalAddr() Addr {
    96		if !c.ok() {
    97			return nil
    98		}
    99		return c.fd.laddr
   100	}
   101	
   102	// RemoteAddr returns the remote network address, a *UDPAddr.
   103	func (c *UDPConn) RemoteAddr() Addr {
   104		if !c.ok() {
   105			return nil
   106		}
   107		return c.fd.raddr
   108	}
   109	
   110	// SetDeadline implements the Conn SetDeadline method.
   111	func (c *UDPConn) SetDeadline(t time.Time) error {
   112		if !c.ok() {
   113			return syscall.EINVAL
   114		}
   115		return setDeadline(c.fd, t)
   116	}
   117	
   118	// SetReadDeadline implements the Conn SetReadDeadline method.
   119	func (c *UDPConn) SetReadDeadline(t time.Time) error {
   120		if !c.ok() {
   121			return syscall.EINVAL
   122		}
   123		return setReadDeadline(c.fd, t)
   124	}
   125	
   126	// SetWriteDeadline implements the Conn SetWriteDeadline method.
   127	func (c *UDPConn) SetWriteDeadline(t time.Time) error {
   128		if !c.ok() {
   129			return syscall.EINVAL
   130		}
   131		return setWriteDeadline(c.fd, t)
   132	}
   133	
   134	// SetReadBuffer sets the size of the operating system's
   135	// receive buffer associated with the connection.
   136	func (c *UDPConn) SetReadBuffer(bytes int) error {
   137		if !c.ok() {
   138			return syscall.EINVAL
   139		}
   140		return setReadBuffer(c.fd, bytes)
   141	}
   142	
   143	// SetWriteBuffer sets the size of the operating system's
   144	// transmit buffer associated with the connection.
   145	func (c *UDPConn) SetWriteBuffer(bytes int) error {
   146		if !c.ok() {
   147			return syscall.EINVAL
   148		}
   149		return setWriteBuffer(c.fd, bytes)
   150	}
   151	
   152	// UDP-specific methods.
   153	
   154	// ReadFromUDP reads a UDP packet from c, copying the payload into b.
   155	// It returns the number of bytes copied into b and the return address
   156	// that was on the packet.
   157	//
   158	// ReadFromUDP can be made to time out and return an error with Timeout() == true
   159	// after a fixed time limit; see SetDeadline and SetReadDeadline.
   160	func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err error) {
   161		if !c.ok() {
   162			return 0, nil, syscall.EINVAL
   163		}
   164		n, sa, err := c.fd.ReadFrom(b)
   165		switch sa := sa.(type) {
   166		case *syscall.SockaddrInet4:
   167			addr = &UDPAddr{sa.Addr[0:], sa.Port}
   168		case *syscall.SockaddrInet6:
   169			addr = &UDPAddr{sa.Addr[0:], sa.Port}
   170		}
   171		return
   172	}
   173	
   174	// ReadFrom implements the PacketConn ReadFrom method.
   175	func (c *UDPConn) ReadFrom(b []byte) (int, Addr, error) {
   176		if !c.ok() {
   177			return 0, nil, syscall.EINVAL
   178		}
   179		n, uaddr, err := c.ReadFromUDP(b)
   180		return n, uaddr.toAddr(), err
   181	}
   182	
   183	// WriteToUDP writes a UDP packet to addr via c, copying the payload from b.
   184	//
   185	// WriteToUDP can be made to time out and return
   186	// an error with Timeout() == true after a fixed time limit;
   187	// see SetDeadline and SetWriteDeadline.
   188	// On packet-oriented connections, write timeouts are rare.
   189	func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error) {
   190		if !c.ok() {
   191			return 0, syscall.EINVAL
   192		}
   193		if c.fd.isConnected {
   194			return 0, &OpError{"write", c.fd.net, addr, ErrWriteToConnected}
   195		}
   196		sa, err := addr.sockaddr(c.fd.family)
   197		if err != nil {
   198			return 0, &OpError{"write", c.fd.net, addr, err}
   199		}
   200		return c.fd.WriteTo(b, sa)
   201	}
   202	
   203	// WriteTo implements the PacketConn WriteTo method.
   204	func (c *UDPConn) WriteTo(b []byte, addr Addr) (int, error) {
   205		if !c.ok() {
   206			return 0, syscall.EINVAL
   207		}
   208		a, ok := addr.(*UDPAddr)
   209		if !ok {
   210			return 0, &OpError{"write", c.fd.net, addr, syscall.EINVAL}
   211		}
   212		return c.WriteToUDP(b, a)
   213	}
   214	
   215	// File returns a copy of the underlying os.File, set to blocking mode.
   216	// It is the caller's responsibility to close f when finished.
   217	// Closing c does not affect f, and closing f does not affect c.
   218	func (c *UDPConn) File() (f *os.File, err error) { return c.fd.dup() }
   219	
   220	// DialUDP connects to the remote address raddr on the network net,
   221	// which must be "udp", "udp4", or "udp6".  If laddr is not nil, it is used
   222	// as the local address for the connection.
   223	func DialUDP(net string, laddr, raddr *UDPAddr) (*UDPConn, error) {
   224		switch net {
   225		case "udp", "udp4", "udp6":
   226		default:
   227			return nil, UnknownNetworkError(net)
   228		}
   229		if raddr == nil {
   230			return nil, &OpError{"dial", net, nil, errMissingAddress}
   231		}
   232		fd, err := internetSocket(net, laddr.toAddr(), raddr.toAddr(), syscall.SOCK_DGRAM, 0, "dial", sockaddrToUDP)
   233		if err != nil {
   234			return nil, err
   235		}
   236		return newUDPConn(fd), nil
   237	}
   238	
   239	// ListenUDP listens for incoming UDP packets addressed to the
   240	// local address laddr.  The returned connection c's ReadFrom
   241	// and WriteTo methods can be used to receive and send UDP
   242	// packets with per-packet addressing.
   243	func ListenUDP(net string, laddr *UDPAddr) (*UDPConn, error) {
   244		switch net {
   245		case "udp", "udp4", "udp6":
   246		default:
   247			return nil, UnknownNetworkError(net)
   248		}
   249		if laddr == nil {
   250			return nil, &OpError{"listen", net, nil, errMissingAddress}
   251		}
   252		fd, err := internetSocket(net, laddr.toAddr(), nil, syscall.SOCK_DGRAM, 0, "listen", sockaddrToUDP)
   253		if err != nil {
   254			return nil, err
   255		}
   256		return newUDPConn(fd), nil
   257	}
   258	
   259	// ListenMulticastUDP listens for incoming multicast UDP packets
   260	// addressed to the group address gaddr on ifi, which specifies
   261	// the interface to join.  ListenMulticastUDP uses default
   262	// multicast interface if ifi is nil.
   263	func ListenMulticastUDP(net string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error) {
   264		switch net {
   265		case "udp", "udp4", "udp6":
   266		default:
   267			return nil, UnknownNetworkError(net)
   268		}
   269		if gaddr == nil || gaddr.IP == nil {
   270			return nil, &OpError{"listenmulticast", net, nil, errMissingAddress}
   271		}
   272		fd, err := internetSocket(net, gaddr.toAddr(), nil, syscall.SOCK_DGRAM, 0, "listen", sockaddrToUDP)
   273		if err != nil {
   274			return nil, err
   275		}
   276		c := newUDPConn(fd)
   277		ip4 := gaddr.IP.To4()
   278		if ip4 != nil {
   279			err := listenIPv4MulticastUDP(c, ifi, ip4)
   280			if err != nil {
   281				c.Close()
   282				return nil, err
   283			}
   284		} else {
   285			err := listenIPv6MulticastUDP(c, ifi, gaddr.IP)
   286			if err != nil {
   287				c.Close()
   288				return nil, err
   289			}
   290		}
   291		return c, nil
   292	}
   293	
   294	func listenIPv4MulticastUDP(c *UDPConn, ifi *Interface, ip IP) error {
   295		if ifi != nil {
   296			err := setIPv4MulticastInterface(c.fd, ifi)
   297			if err != nil {
   298				return err
   299			}
   300		}
   301		err := setIPv4MulticastLoopback(c.fd, false)
   302		if err != nil {
   303			return err
   304		}
   305		err = joinIPv4GroupUDP(c, ifi, ip)
   306		if err != nil {
   307			return err
   308		}
   309		return nil
   310	}
   311	
   312	func listenIPv6MulticastUDP(c *UDPConn, ifi *Interface, ip IP) error {
   313		if ifi != nil {
   314			err := setIPv6MulticastInterface(c.fd, ifi)
   315			if err != nil {
   316				return err
   317			}
   318		}
   319		err := setIPv6MulticastLoopback(c.fd, false)
   320		if err != nil {
   321			return err
   322		}
   323		err = joinIPv6GroupUDP(c, ifi, ip)
   324		if err != nil {
   325			return err
   326		}
   327		return nil
   328	}
   329	
   330	func joinIPv4GroupUDP(c *UDPConn, ifi *Interface, ip IP) error {
   331		err := joinIPv4Group(c.fd, ifi, ip)
   332		if err != nil {
   333			return &OpError{"joinipv4group", c.fd.net, &IPAddr{ip}, err}
   334		}
   335		return nil
   336	}
   337	
   338	func leaveIPv4GroupUDP(c *UDPConn, ifi *Interface, ip IP) error {
   339		err := leaveIPv4Group(c.fd, ifi, ip)
   340		if err != nil {
   341			return &OpError{"leaveipv4group", c.fd.net, &IPAddr{ip}, err}
   342		}
   343		return nil
   344	}
   345	
   346	func joinIPv6GroupUDP(c *UDPConn, ifi *Interface, ip IP) error {
   347		err := joinIPv6Group(c.fd, ifi, ip)
   348		if err != nil {
   349			return &OpError{"joinipv6group", c.fd.net, &IPAddr{ip}, err}
   350		}
   351		return nil
   352	}
   353	
   354	func leaveIPv6GroupUDP(c *UDPConn, ifi *Interface, ip IP) error {
   355		err := leaveIPv6Group(c.fd, ifi, ip)
   356		if err != nil {
   357			return &OpError{"leaveipv6group", c.fd.net, &IPAddr{ip}, err}
   358		}
   359		return nil
   360	}