code review 2309043: Add SOCK_SEQPACKET support to Unix socket.

src/pkg/net/unixsock.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.
 
 // Unix domain sockets
 
 package net
 
 import (
         "os"
         "syscall"
 )
 
 func unixSocket(net string, laddr, raddr *UnixAddr, mode string) (fd *netFD, err os.Error) {
         var proto int
         switch net {
         default:
                 return nil, UnknownNetworkError(net)
         case "unix":
                 proto = syscall.SOCK_STREAM
         case "unixgram":
                 proto = syscall.SOCK_DGRAM
+        case "unixpacket":
+                proto = syscall.SOCK_SEQPACKET
         }
 
         var la, ra syscall.Sockaddr
         switch mode {
         default:
                 panic("unixSocket mode " + mode)
 
         case "dial":
                 if laddr != nil {
                         la = &syscall.SockaddrUnix{Name: laddr.Name}
                 }
                 if raddr != nil {
                         ra = &syscall.SockaddrUnix{Name: raddr.Name}
                 } else if proto != syscall.SOCK_DGRAM || laddr == nil {
                         return nil, &OpError{Op: mode, Net: net, Error: errMissingAddress}
                 }
 
         case "listen":
                 if laddr == nil {
                         return nil, &OpError{mode, net, nil, errMissingAddress}
                 }
                 la = &syscall.SockaddrUnix{Name: laddr.Name}
                 if raddr != nil {
                         return nil, &OpError{Op: mode, Net: net, Addr: raddr, Error: &AddrError{Error: "unexpected remote address", Addr: raddr.String()}}
                 }
         }
 
         f := sockaddrToUnix
-        if proto != syscall.SOCK_STREAM {
+        if proto == syscall.SOCK_DGRAM {
                 f = sockaddrToUnixgram
+        } else if proto == syscall.SOCK_SEQPACKET {
+                f = sockaddrToUnixpacket
         }
+
         fd, oserr := socket(net, syscall.AF_UNIX, proto, 0, la, ra, f)
         if oserr != nil {
                 goto Error
         }
         return fd, nil
 
 Error:
         addr := raddr
         if mode == "listen" {
                 addr = laddr
         }
         return nil, &OpError{Op: mode, Net: net, Addr: addr, Error: oserr}
 }
 
 // UnixAddr represents the address of a Unix domain socket end point.
 type UnixAddr struct {
-        Name     string
-        Datagram bool
+        Name string
+        Net  string
 }
 
 func sockaddrToUnix(sa syscall.Sockaddr) Addr {
         if s, ok := sa.(*syscall.SockaddrUnix); ok {
-                return &UnixAddr{s.Name, false}
+                return &UnixAddr{s.Name, "unix"}
         }
         return nil
 }
 
 func sockaddrToUnixgram(sa syscall.Sockaddr) Addr {
         if s, ok := sa.(*syscall.SockaddrUnix); ok {
-                return &UnixAddr{s.Name, true}
+                return &UnixAddr{s.Name, "unixgram"}
         }
         return nil
 }
 
+func sockaddrToUnixpacket(sa syscall.Sockaddr) Addr {
+        if s, ok := sa.(*syscall.SockaddrUnix); ok {
+                return &UnixAddr{s.Name, "unixpacket"}
+        }
+        return nil
+}
+
+func protoToNet(proto int) string {
+        switch proto {
+        case syscall.SOCK_STREAM:
+                return "unix"
+        case syscall.SOCK_SEQPACKET:
+                return "unixpacket"
+        case syscall.SOCK_DGRAM:
+                return "unixgram"
+        default:
+                panic("protoToNet unknown protocol")
+        }
+        return ""
+}
+
 // Network returns the address's network name, "unix" or "unixgram".
 func (a *UnixAddr) Network() string {
-        if a == nil || !a.Datagram {
-                return "unix"
-        }
-        return "unixgram"
+        return a.Net
 }
 
 func (a *UnixAddr) String() string {
         if a == nil {
                 return "<nil>"
         }
         return a.Name
 }
 
 func (a *UnixAddr) toAddr() Addr {
         if a == nil { // nil *UnixAddr
                 return nil // nil interface
         }
         return a
 }
 
 // ResolveUnixAddr parses addr as a Unix domain socket address.
-// The string net gives the network name, "unix" or "unixgram".
+// The string net gives the network name, "unix", "unixgram" or
+// "unixpacket".
 func ResolveUnixAddr(net, addr string) (*UnixAddr, os.Error) {
-        var datagram bool
         switch net {
         case "unix":
+        case "unixpacket":
         case "unixgram":
-                datagram = true
         default:
                 return nil, UnknownNetworkError(net)
         }
-        return &UnixAddr{addr, datagram}, nil
+        return &UnixAddr{addr, net}, nil
 }
 
 // UnixConn is an implementation of the Conn interface
 // for connections to Unix domain sockets.
 type UnixConn struct {
         fd *netFD
 }
 
 func newUnixConn(fd *netFD) *UnixConn { return &UnixConn{fd} }
 
@@ skipping 95 matching lines @@
 // ReadFromUnix can be made to time out and return
 // an error with Timeout() == true after a fixed time limit;
 // see SetTimeout and SetReadTimeout.
 func (c *UnixConn) ReadFromUnix(b []byte) (n int, addr *UnixAddr, err os.Error) {
         if !c.ok() {
                 return 0, nil, os.EINVAL
         }
         n, sa, err := c.fd.ReadFrom(b)
         switch sa := sa.(type) {
         case *syscall.SockaddrUnix:
-                addr = &UnixAddr{sa.Name, c.fd.proto == syscall.SOCK_DGRAM}
+                addr = &UnixAddr{sa.Name, protoToNet(c.fd.proto)}
         }
         return
 }
 
 // ReadFrom implements the net.PacketConn ReadFrom method.
 func (c *UnixConn) ReadFrom(b []byte) (n int, addr Addr, err os.Error) {
         if !c.ok() {
                 return 0, nil, os.EINVAL
         }
         n, uaddr, err := c.ReadFromUnix(b)
         return n, uaddr.toAddr(), err
 }
 
 // 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 SetTimeout and SetWriteTimeout.
 // On packet-oriented connections, write timeouts are rare.
 func (c *UnixConn) WriteToUnix(b []byte, addr *UnixAddr) (n int, err os.Error) {
         if !c.ok() {
                 return 0, os.EINVAL
         }
-        if addr.Datagram != (c.fd.proto == syscall.SOCK_DGRAM) {
+        if addr.Net != protoToNet(c.fd.proto) {
                 return 0, os.EAFNOSUPPORT
         }
         sa := &syscall.SockaddrUnix{Name: addr.Name}
         return c.fd.WriteTo(b, sa)
 }
 
 // WriteTo implements the net.PacketConn WriteTo method.
 func (c *UnixConn) WriteTo(b []byte, addr Addr) (n int, err os.Error) {
         if !c.ok() {
                 return 0, os.EINVAL
         }
         a, ok := addr.(*UnixAddr)
         if !ok {
                 return 0, &OpError{"writeto", "unix", addr, os.EINVAL}
         }
         return c.WriteToUnix(b, a)
 }
 
 func (c *UnixConn) ReadMsgUnix(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err os.Error) {
         if !c.ok() {
                 return 0, 0, 0, nil, os.EINVAL
         }
         n, oobn, flags, sa, err := c.fd.ReadMsg(b, oob)
         switch sa := sa.(type) {
         case *syscall.SockaddrUnix:
-                addr = &UnixAddr{sa.Name, c.fd.proto == syscall.SOCK_DGRAM}
+                addr = &UnixAddr{sa.Name, protoToNet(c.fd.proto)}
         }
         return
 }
 
 func (c *UnixConn) WriteMsgUnix(b, oob []byte, addr *UnixAddr) (n, oobn int, err os.Error) {
         if !c.ok() {
                 return 0, 0, os.EINVAL
         }
         if addr != nil {
-                if addr.Datagram != (c.fd.proto == syscall.SOCK_DGRAM) {
+                if addr.Net != protoToNet(c.fd.proto) {
                         return 0, 0, os.EAFNOSUPPORT
                 }
                 sa := &syscall.SockaddrUnix{Name: addr.Name}
                 return c.fd.WriteMsg(b, oob, sa)
         }
         return c.fd.WriteMsg(b, oob, nil)
 }
 
 // File returns a copy of the underlying os.File, set to blocking mode.
 // It is the caller's responsibility to close f when finished.
@@ skipping 15 matching lines @@
 // Clients should typically use variables of type Listener
 // instead of assuming Unix domain sockets.
 type UnixListener struct {
         fd   *netFD
         path string
 }
 
 // ListenUnix announces on the Unix domain socket laddr and returns a Unix listener.
 // Net must be "unix" (stream sockets).
 func ListenUnix(net string, laddr *UnixAddr) (l *UnixListener, err os.Error) {
-        if net != "unix" && net != "unixgram" {
+        if net != "unix" && net != "unixgram" && net != "unixpacket" {
                 return nil, UnknownNetworkError(net)
         }
         if laddr != nil {
-                laddr = &UnixAddr{laddr.Name, net == "unixgram"} // make our own copy
+                laddr = &UnixAddr{laddr.Name, net} // make our own copy
         }
         fd, err := unixSocket(net, laddr, nil, "listen")
         if err != nil {
                 return nil, err
         }
         e1 := syscall.Listen(fd.sysfd, 8) // listenBacklog());
         if e1 != 0 {
                 syscall.Close(fd.sysfd)
                 return nil, &OpError{Op: "listen", Net: "unix", Addr: laddr, Error: os.Errno(e1)}
         }
@@ skipping 69 matching lines @@
         }
         if laddr == nil {
                 return nil, &OpError{"listen", "unixgram", nil, errMissingAddress}
         }
         fd, e := unixSocket(net, laddr, nil, "listen")
         if e != nil {
                 return nil, e
         }
         return newUDPConn(fd), nil
 }