code review 684041: net: implement raw sockets

src/pkg/net/udpsock.go

 // 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.
 
 // UDP sockets
 
 package net
 
 import (
         "os"
@@ skipping 59 matching lines @@
 type UDPConn struct {
         fd *netFD
 }
 
 func newUDPConn(fd *netFD) *UDPConn { return &UDPConn{fd} }
 
 func (c *UDPConn) ok() bool { return c != nil && c.fd != nil }
 
 // Implementation of the Conn interface - see Conn for documentation.
 
-// Read reads data from a single UDP packet on the connection.
-// If the slice b is smaller than the arriving packet,
-// the excess packet data may be discarded.
-//
-// Read can be made to time out and return err == os.EAGAIN
-// after a fixed time limit; see SetTimeout and SetReadTimeout.
+// Read implements the net.Conn Read method.
 func (c *UDPConn) Read(b []byte) (n int, err os.Error) {
         if !c.ok() {
                 return 0, os.EINVAL
         }
         return c.fd.Read(b)
 }
 
-// Write writes data to the connection as a single UDP packet.
-//
-// Write can be made to time out and return err == os.EAGAIN
-// after a fixed time limit; see SetTimeout and SetReadTimeout.
+// Write implements the net.Conn Write method.
 func (c *UDPConn) Write(b []byte) (n int, err os.Error) {
         if !c.ok() {
                 return 0, os.EINVAL
         }
         return c.fd.Write(b)
 }
 
 // Close closes the UDP connection.
 func (c *UDPConn) Close() os.Error {
         if !c.ok() {
@@ skipping 13 matching lines @@
 }
 
 // RemoteAddr returns the remote network address, a *UDPAddr.
 func (c *UDPConn) RemoteAddr() Addr {
         if !c.ok() {
                 return nil
         }
         return c.fd.raddr
 }
 
-// SetTimeout sets the read and write deadlines associated
-// with the connection.
+// SetTimeout implements the net.Conn SetTimeout method.
 func (c *UDPConn) SetTimeout(nsec int64) os.Error {
         if !c.ok() {
                 return os.EINVAL
         }
         return setTimeout(c.fd, nsec)
 }
 
-// SetReadTimeout sets the time (in nanoseconds) that
-// Read will wait for data before returning os.EAGAIN.
-// Setting nsec == 0 (the default) disables the deadline.
+// SetReadTimeout implements the net.Conn SetReadTimeout method.
 func (c *UDPConn) SetReadTimeout(nsec int64) os.Error {
         if !c.ok() {
                 return os.EINVAL
         }
         return setReadTimeout(c.fd, nsec)
 }
 
-// SetWriteTimeout sets the time (in nanoseconds) that
-// Write will wait to send its data before returning os.EAGAIN.
-// Setting nsec == 0 (the default) disables the deadline.
-// Even if write times out, it may return n > 0, indicating that
-// some of the data was successfully written.
+// SetWriteTimeout implements the net.Conn SetWriteTimeout method.
 func (c *UDPConn) SetWriteTimeout(nsec int64) os.Error {
         if !c.ok() {
                 return os.EINVAL
         }
         return setWriteTimeout(c.fd, nsec)
 }
 
 // SetReadBuffer sets the size of the operating system's
 // receive buffer associated with the connection.
 func (c *UDPConn) SetReadBuffer(bytes int) os.Error {
@@ skipping 11 matching lines @@
         }
         return setWriteBuffer(c.fd, bytes)
 }
 
 // UDP-specific methods.
 
 // 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 err == os.EAGAIN
+// ReadFromUDP can be made to time out and return an error with Timeout() == true
 // after a fixed time limit; see SetTimeout and SetReadTimeout.
 func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err os.Error) {
         if !c.ok() {
                 return 0, nil, os.EINVAL
         }
         n, sa, err := c.fd.ReadFrom(b)
         switch sa := sa.(type) {
         case *syscall.SockaddrInet4:
                 addr = &UDPAddr{&sa.Addr, sa.Port}
         case *syscall.SockaddrInet6:
                 addr = &UDPAddr{&sa.Addr, sa.Port}
         }
         return
 }
 
-// ReadFrom 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.
-//
-// ReadFrom can be made to time out and return err == os.EAGAIN
-// after a fixed time limit; see SetTimeout and SetReadTimeout.
+// ReadFrom implements the net.PacketConn ReadFrom method.
 func (c *UDPConn) ReadFrom(b []byte) (n int, addr Addr, err os.Error) {
         if !c.ok() {
                 return 0, nil, os.EINVAL
         }
         n, uaddr, err := c.ReadFromUDP(b)
         return n, uaddr.toAddr(), err
 }
 
 // WriteToUDP writes a UDP packet to addr via c, copying the payload from b.
 //
-// WriteToUDP can be made to time out and return err == os.EAGAIN
-// after a fixed time limit; see SetTimeout and SetWriteTimeout.
-// On packet-oriented connections such as UDP, write timeouts are rare.
+// WriteToUDP can be made to time out and return
+// an error with Timeout() == true after a fixed time limit;
+// see SetTimeout and SetWriteTimeout.
+// On packet-oriented connections, write timeouts are rare.
 func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (n int, err os.Error) {
         if !c.ok() {
                 return 0, os.EINVAL
         }
-        sa, err := addr.sockaddr(c.fd.family)
-        if err != nil {
-                return 0, err
+        sa, err1 := addr.sockaddr(c.fd.family)
+        if err1 != nil {
+                return 0, &OpError{Op: "write", Net: "udp", Addr: addr, Error: err1}
         }
         return c.fd.WriteTo(b, sa)
 }
 
-// WriteTo writes a UDP packet with payload b to addr via c.
-//
-// WriteTo can be made to time out and return err == os.EAGAIN
-// after a fixed time limit; see SetTimeout and SetWriteTimeout.
-// On packet-oriented connections such as UDP, write timeouts are rare.
+// WriteTo implements the net.PacketConn WriteTo method.
 func (c *UDPConn) WriteTo(b []byte, addr Addr) (n int, err os.Error) {
         if !c.ok() {
                 return 0, os.EINVAL
         }
         a, ok := addr.(*UDPAddr)
         if !ok {
                 return 0, &OpError{"writeto", "udp", addr, os.EINVAL}
         }
         return c.WriteToUDP(b, a)
 }
@@ skipping 29 matching lines @@
         }
         if laddr == nil {
                 return nil, &OpError{"listen", "udp", nil, errMissingAddress}
         }
         fd, e := internetSocket(net, laddr.toAddr(), nil, syscall.SOCK_DGRAM, 0, "dial", sockaddrToUDP)
         if e != nil {
                 return nil, e
         }
         return newUDPConn(fd), nil
 }