code review 12916046: net: make protocol-specific Dial and Listen return cons...

src/pkg/net/unixsock_posix.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.
 
-// +build darwin freebsd linux netbsd openbsd windows
+// +build darwin dragonfly freebsd linux netbsd openbsd windows
 
 package net
 
 import (
         "errors"
         "os"
         "syscall"
         "time"
 )
 
@@ skipping 155 matching lines @@
 // WriteToUnix writes a packet to addr via c, copying the payload from b.
 //
 // WriteToUnix 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 *UnixConn) WriteToUnix(b []byte, addr *UnixAddr) (n int, err error) {
         if !c.ok() {
                 return 0, syscall.EINVAL
         }
+        if addr == nil {
+                return 0, &OpError{Op: "write", Net: c.fd.net, Addr: nil, Err: errMissingAddress}
+        }
         if addr.Net != sotypeToNet(c.fd.sotype) {
                 return 0, syscall.EAFNOSUPPORT
         }
         sa := &syscall.SockaddrUnix{Name: addr.Name}
         return c.fd.WriteTo(b, sa)
 }
 
 // WriteTo implements the PacketConn WriteTo method.
 func (c *UnixConn) WriteTo(b []byte, addr Addr) (n int, err error) {
         if !c.ok() {
@@ skipping 38 matching lines @@
         if !c.ok() {
                 return syscall.EINVAL
         }
         return c.fd.CloseWrite()
 }
 
 // DialUnix connects to the remote address raddr on the network net,
 // which must be "unix", "unixgram" or "unixpacket".  If laddr is not
 // nil, it is used as the local address for the connection.
 func DialUnix(net string, laddr, raddr *UnixAddr) (*UnixConn, error) {
-        return dialUnix(net, laddr, raddr, noDeadline)
-}
-
-func dialUnix(net string, laddr, raddr *UnixAddr, deadline time.Time) (*UnixConn, error) {
         switch net {
         case "unix", "unixgram", "unixpacket":
         default:
                 return nil, &OpError{Op: "dial", Net: net, Addr: raddr, Err: UnknownNetworkError(net)}
         }
+        return dialUnix(net, laddr, raddr, noDeadline)
+}
+
+func dialUnix(net string, laddr, raddr *UnixAddr, deadline time.Time) (*UnixConn, error) {
         fd, err := unixSocket(net, laddr, raddr, "dial", deadline)
         if err != nil {
                 return nil, &OpError{Op: "dial", Net: net, Addr: raddr, Err: err}
         }
         return newUnixConn(fd), nil
 }
 
 // UnixListener is a Unix domain socket listener.  Clients should
 // typically use variables of type Listener instead of assuming Unix
 // domain sockets.
@@ skipping 100 matching lines @@
         }
         if laddr == nil {
                 return nil, &OpError{Op: "listen", Net: net, Addr: nil, Err: errMissingAddress}
         }
         fd, err := unixSocket(net, laddr, nil, "listen", noDeadline)
         if err != nil {
                 return nil, &OpError{Op: "listen", Net: net, Addr: laddr, Err: err}
         }
         return newUnixConn(fd), nil
 }