...
Run Format

Source file src/net/unixsock_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 dragonfly freebsd linux nacl netbsd openbsd solaris windows
     6	
     7	package net
     8	
     9	import (
    10		"errors"
    11		"os"
    12		"syscall"
    13		"time"
    14	)
    15	
    16	func unixSocket(net string, laddr, raddr sockaddr, mode string, deadline time.Time) (*netFD, error) {
    17		var sotype int
    18		switch net {
    19		case "unix":
    20			sotype = syscall.SOCK_STREAM
    21		case "unixgram":
    22			sotype = syscall.SOCK_DGRAM
    23		case "unixpacket":
    24			sotype = syscall.SOCK_SEQPACKET
    25		default:
    26			return nil, UnknownNetworkError(net)
    27		}
    28	
    29		switch mode {
    30		case "dial":
    31			if laddr != nil && laddr.isWildcard() {
    32				laddr = nil
    33			}
    34			if raddr != nil && raddr.isWildcard() {
    35				raddr = nil
    36			}
    37			if raddr == nil && (sotype != syscall.SOCK_DGRAM || laddr == nil) {
    38				return nil, errMissingAddress
    39			}
    40		case "listen":
    41		default:
    42			return nil, errors.New("unknown mode: " + mode)
    43		}
    44	
    45		fd, err := socket(net, syscall.AF_UNIX, sotype, 0, false, laddr, raddr, deadline)
    46		if err != nil {
    47			return nil, err
    48		}
    49		return fd, nil
    50	}
    51	
    52	func sockaddrToUnix(sa syscall.Sockaddr) Addr {
    53		if s, ok := sa.(*syscall.SockaddrUnix); ok {
    54			return &UnixAddr{Name: s.Name, Net: "unix"}
    55		}
    56		return nil
    57	}
    58	
    59	func sockaddrToUnixgram(sa syscall.Sockaddr) Addr {
    60		if s, ok := sa.(*syscall.SockaddrUnix); ok {
    61			return &UnixAddr{Name: s.Name, Net: "unixgram"}
    62		}
    63		return nil
    64	}
    65	
    66	func sockaddrToUnixpacket(sa syscall.Sockaddr) Addr {
    67		if s, ok := sa.(*syscall.SockaddrUnix); ok {
    68			return &UnixAddr{Name: s.Name, Net: "unixpacket"}
    69		}
    70		return nil
    71	}
    72	
    73	func sotypeToNet(sotype int) string {
    74		switch sotype {
    75		case syscall.SOCK_STREAM:
    76			return "unix"
    77		case syscall.SOCK_DGRAM:
    78			return "unixgram"
    79		case syscall.SOCK_SEQPACKET:
    80			return "unixpacket"
    81		default:
    82			panic("sotypeToNet unknown socket type")
    83		}
    84	}
    85	
    86	func (a *UnixAddr) family() int {
    87		return syscall.AF_UNIX
    88	}
    89	
    90	func (a *UnixAddr) isWildcard() bool {
    91		return a == nil || a.Name == ""
    92	}
    93	
    94	func (a *UnixAddr) sockaddr(family int) (syscall.Sockaddr, error) {
    95		if a == nil {
    96			return nil, nil
    97		}
    98		return &syscall.SockaddrUnix{Name: a.Name}, nil
    99	}
   100	
   101	// UnixConn is an implementation of the Conn interface for connections
   102	// to Unix domain sockets.
   103	type UnixConn struct {
   104		conn
   105	}
   106	
   107	func newUnixConn(fd *netFD) *UnixConn { return &UnixConn{conn{fd}} }
   108	
   109	// ReadFromUnix reads a packet from c, copying the payload into b.  It
   110	// returns the number of bytes copied into b and the source address of
   111	// the packet.
   112	//
   113	// ReadFromUnix can be made to time out and return an error with
   114	// Timeout() == true after a fixed time limit; see SetDeadline and
   115	// SetReadDeadline.
   116	func (c *UnixConn) ReadFromUnix(b []byte) (n int, addr *UnixAddr, err error) {
   117		if !c.ok() {
   118			return 0, nil, syscall.EINVAL
   119		}
   120		n, sa, err := c.fd.readFrom(b)
   121		switch sa := sa.(type) {
   122		case *syscall.SockaddrUnix:
   123			if sa.Name != "" {
   124				addr = &UnixAddr{Name: sa.Name, Net: sotypeToNet(c.fd.sotype)}
   125			}
   126		}
   127		return
   128	}
   129	
   130	// ReadFrom implements the PacketConn ReadFrom method.
   131	func (c *UnixConn) ReadFrom(b []byte) (int, Addr, error) {
   132		if !c.ok() {
   133			return 0, nil, syscall.EINVAL
   134		}
   135		n, addr, err := c.ReadFromUnix(b)
   136		return n, addr.toAddr(), err
   137	}
   138	
   139	// ReadMsgUnix reads a packet from c, copying the payload into b and
   140	// the associated out-of-band data into oob.  It returns the number of
   141	// bytes copied into b, the number of bytes copied into oob, the flags
   142	// that were set on the packet, and the source address of the packet.
   143	func (c *UnixConn) ReadMsgUnix(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error) {
   144		if !c.ok() {
   145			return 0, 0, 0, nil, syscall.EINVAL
   146		}
   147		n, oobn, flags, sa, err := c.fd.readMsg(b, oob)
   148		switch sa := sa.(type) {
   149		case *syscall.SockaddrUnix:
   150			if sa.Name != "" {
   151				addr = &UnixAddr{Name: sa.Name, Net: sotypeToNet(c.fd.sotype)}
   152			}
   153		}
   154		return
   155	}
   156	
   157	// WriteToUnix writes a packet to addr via c, copying the payload from b.
   158	//
   159	// WriteToUnix can be made to time out and return an error with
   160	// Timeout() == true after a fixed time limit; see SetDeadline and
   161	// SetWriteDeadline.  On packet-oriented connections, write timeouts
   162	// are rare.
   163	func (c *UnixConn) WriteToUnix(b []byte, addr *UnixAddr) (n int, err error) {
   164		if !c.ok() {
   165			return 0, syscall.EINVAL
   166		}
   167		if c.fd.isConnected {
   168			return 0, &OpError{Op: "write", Net: c.fd.net, Addr: addr, Err: ErrWriteToConnected}
   169		}
   170		if addr == nil {
   171			return 0, &OpError{Op: "write", Net: c.fd.net, Addr: nil, Err: errMissingAddress}
   172		}
   173		if addr.Net != sotypeToNet(c.fd.sotype) {
   174			return 0, syscall.EAFNOSUPPORT
   175		}
   176		sa := &syscall.SockaddrUnix{Name: addr.Name}
   177		return c.fd.writeTo(b, sa)
   178	}
   179	
   180	// WriteTo implements the PacketConn WriteTo method.
   181	func (c *UnixConn) WriteTo(b []byte, addr Addr) (n int, err error) {
   182		if !c.ok() {
   183			return 0, syscall.EINVAL
   184		}
   185		a, ok := addr.(*UnixAddr)
   186		if !ok {
   187			return 0, &OpError{"write", c.fd.net, addr, syscall.EINVAL}
   188		}
   189		return c.WriteToUnix(b, a)
   190	}
   191	
   192	// WriteMsgUnix writes a packet to addr via c, copying the payload
   193	// from b and the associated out-of-band data from oob.  It returns
   194	// the number of payload and out-of-band bytes written.
   195	func (c *UnixConn) WriteMsgUnix(b, oob []byte, addr *UnixAddr) (n, oobn int, err error) {
   196		if !c.ok() {
   197			return 0, 0, syscall.EINVAL
   198		}
   199		if c.fd.sotype == syscall.SOCK_DGRAM && c.fd.isConnected {
   200			return 0, 0, &OpError{Op: "write", Net: c.fd.net, Addr: addr, Err: ErrWriteToConnected}
   201		}
   202		if addr != nil {
   203			if addr.Net != sotypeToNet(c.fd.sotype) {
   204				return 0, 0, syscall.EAFNOSUPPORT
   205			}
   206			sa := &syscall.SockaddrUnix{Name: addr.Name}
   207			return c.fd.writeMsg(b, oob, sa)
   208		}
   209		return c.fd.writeMsg(b, oob, nil)
   210	}
   211	
   212	// CloseRead shuts down the reading side of the Unix domain connection.
   213	// Most callers should just use Close.
   214	func (c *UnixConn) CloseRead() error {
   215		if !c.ok() {
   216			return syscall.EINVAL
   217		}
   218		return c.fd.closeRead()
   219	}
   220	
   221	// CloseWrite shuts down the writing side of the Unix domain connection.
   222	// Most callers should just use Close.
   223	func (c *UnixConn) CloseWrite() error {
   224		if !c.ok() {
   225			return syscall.EINVAL
   226		}
   227		return c.fd.closeWrite()
   228	}
   229	
   230	// DialUnix connects to the remote address raddr on the network net,
   231	// which must be "unix", "unixgram" or "unixpacket".  If laddr is not
   232	// nil, it is used as the local address for the connection.
   233	func DialUnix(net string, laddr, raddr *UnixAddr) (*UnixConn, error) {
   234		switch net {
   235		case "unix", "unixgram", "unixpacket":
   236		default:
   237			return nil, &OpError{Op: "dial", Net: net, Addr: raddr, Err: UnknownNetworkError(net)}
   238		}
   239		return dialUnix(net, laddr, raddr, noDeadline)
   240	}
   241	
   242	func dialUnix(net string, laddr, raddr *UnixAddr, deadline time.Time) (*UnixConn, error) {
   243		fd, err := unixSocket(net, laddr, raddr, "dial", deadline)
   244		if err != nil {
   245			return nil, &OpError{Op: "dial", Net: net, Addr: raddr, Err: err}
   246		}
   247		return newUnixConn(fd), nil
   248	}
   249	
   250	// UnixListener is a Unix domain socket listener.  Clients should
   251	// typically use variables of type Listener instead of assuming Unix
   252	// domain sockets.
   253	type UnixListener struct {
   254		fd   *netFD
   255		path string
   256	}
   257	
   258	// ListenUnix announces on the Unix domain socket laddr and returns a
   259	// Unix listener.  The network net must be "unix" or "unixpacket".
   260	func ListenUnix(net string, laddr *UnixAddr) (*UnixListener, error) {
   261		switch net {
   262		case "unix", "unixpacket":
   263		default:
   264			return nil, &OpError{Op: "listen", Net: net, Addr: laddr, Err: UnknownNetworkError(net)}
   265		}
   266		if laddr == nil {
   267			return nil, &OpError{Op: "listen", Net: net, Addr: nil, Err: errMissingAddress}
   268		}
   269		fd, err := unixSocket(net, laddr, nil, "listen", noDeadline)
   270		if err != nil {
   271			return nil, &OpError{Op: "listen", Net: net, Addr: laddr, Err: err}
   272		}
   273		return &UnixListener{fd, fd.laddr.String()}, nil
   274	}
   275	
   276	// AcceptUnix accepts the next incoming call and returns the new
   277	// connection.
   278	func (l *UnixListener) AcceptUnix() (*UnixConn, error) {
   279		if l == nil || l.fd == nil {
   280			return nil, syscall.EINVAL
   281		}
   282		fd, err := l.fd.accept()
   283		if err != nil {
   284			return nil, err
   285		}
   286		c := newUnixConn(fd)
   287		return c, nil
   288	}
   289	
   290	// Accept implements the Accept method in the Listener interface; it
   291	// waits for the next call and returns a generic Conn.
   292	func (l *UnixListener) Accept() (c Conn, err error) {
   293		c1, err := l.AcceptUnix()
   294		if err != nil {
   295			return nil, err
   296		}
   297		return c1, nil
   298	}
   299	
   300	// Close stops listening on the Unix address.  Already accepted
   301	// connections are not closed.
   302	func (l *UnixListener) Close() error {
   303		if l == nil || l.fd == nil {
   304			return syscall.EINVAL
   305		}
   306	
   307		// The operating system doesn't clean up
   308		// the file that announcing created, so
   309		// we have to clean it up ourselves.
   310		// There's a race here--we can't know for
   311		// sure whether someone else has come along
   312		// and replaced our socket name already--
   313		// but this sequence (remove then close)
   314		// is at least compatible with the auto-remove
   315		// sequence in ListenUnix.  It's only non-Go
   316		// programs that can mess us up.
   317		if l.path[0] != '@' {
   318			syscall.Unlink(l.path)
   319		}
   320		return l.fd.Close()
   321	}
   322	
   323	// Addr returns the listener's network address.
   324	func (l *UnixListener) Addr() Addr { return l.fd.laddr }
   325	
   326	// SetDeadline sets the deadline associated with the listener.
   327	// A zero time value disables the deadline.
   328	func (l *UnixListener) SetDeadline(t time.Time) (err error) {
   329		if l == nil || l.fd == nil {
   330			return syscall.EINVAL
   331		}
   332		return l.fd.setDeadline(t)
   333	}
   334	
   335	// File returns a copy of the underlying os.File, set to blocking
   336	// mode.  It is the caller's responsibility to close f when finished.
   337	// Closing l does not affect f, and closing f does not affect l.
   338	//
   339	// The returned os.File's file descriptor is different from the
   340	// connection's.  Attempting to change properties of the original
   341	// using this duplicate may or may not have the desired effect.
   342	func (l *UnixListener) File() (f *os.File, err error) { return l.fd.dup() }
   343	
   344	// ListenUnixgram listens for incoming Unix datagram packets addressed
   345	// to the local address laddr.  The network net must be "unixgram".
   346	// The returned connection's ReadFrom and WriteTo methods can be used
   347	// to receive and send packets with per-packet addressing.
   348	func ListenUnixgram(net string, laddr *UnixAddr) (*UnixConn, error) {
   349		switch net {
   350		case "unixgram":
   351		default:
   352			return nil, &OpError{Op: "listen", Net: net, Addr: laddr, Err: UnknownNetworkError(net)}
   353		}
   354		if laddr == nil {
   355			return nil, &OpError{Op: "listen", Net: net, Addr: nil, Err: errMissingAddress}
   356		}
   357		fd, err := unixSocket(net, laddr, nil, "listen", noDeadline)
   358		if err != nil {
   359			return nil, &OpError{Op: "listen", Net: net, Addr: laddr, Err: err}
   360		}
   361		return newUnixConn(fd), nil
   362	}
   363	

View as plain text