| // 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. |
| |
| package net |
| |
| import ( |
| "context" |
| "os" |
| "syscall" |
| "time" |
| ) |
| |
| // UnixAddr represents the address of a Unix domain socket end point. |
| type UnixAddr struct { |
| Name string |
| Net string |
| } |
| |
| // Network returns the address's network name, "unix", "unixgram" or |
| // "unixpacket". |
| func (a *UnixAddr) Network() string { |
| return a.Net |
| } |
| |
| func (a *UnixAddr) String() string { |
| if a == nil { |
| return "<nil>" |
| } |
| return a.Name |
| } |
| |
| func (a *UnixAddr) isWildcard() bool { |
| return a == nil || a.Name == "" |
| } |
| |
| func (a *UnixAddr) opAddr() Addr { |
| if a == nil { |
| return nil |
| } |
| return a |
| } |
| |
| // ResolveUnixAddr parses addr as a Unix domain socket address. |
| // The string net gives the network name, "unix", "unixgram" or |
| // "unixpacket". |
| func ResolveUnixAddr(net, addr string) (*UnixAddr, error) { |
| switch net { |
| case "unix", "unixgram", "unixpacket": |
| return &UnixAddr{Name: addr, Net: net}, nil |
| default: |
| return nil, UnknownNetworkError(net) |
| } |
| } |
| |
| // UnixConn is an implementation of the Conn interface for connections |
| // to Unix domain sockets. |
| type UnixConn struct { |
| conn |
| } |
| |
| // CloseRead shuts down the reading side of the Unix domain connection. |
| // Most callers should just use Close. |
| func (c *UnixConn) CloseRead() error { |
| if !c.ok() { |
| return syscall.EINVAL |
| } |
| if err := c.fd.closeRead(); err != nil { |
| return &OpError{Op: "close", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err} |
| } |
| return nil |
| } |
| |
| // CloseWrite shuts down the writing side of the Unix domain connection. |
| // Most callers should just use Close. |
| func (c *UnixConn) CloseWrite() error { |
| if !c.ok() { |
| return syscall.EINVAL |
| } |
| if err := c.fd.closeWrite(); err != nil { |
| return &OpError{Op: "close", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err} |
| } |
| return nil |
| } |
| |
| // ReadFromUnix reads a packet from c, copying the payload into b. It |
| // returns the number of bytes copied into b and the source address of |
| // the packet. |
| // |
| // ReadFromUnix can be made to time out and return an error with |
| // Timeout() == true after a fixed time limit; see SetDeadline and |
| // SetReadDeadline. |
| func (c *UnixConn) ReadFromUnix(b []byte) (int, *UnixAddr, error) { |
| if !c.ok() { |
| return 0, nil, syscall.EINVAL |
| } |
| n, addr, err := c.readFrom(b) |
| if err != nil { |
| err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err} |
| } |
| return n, addr, err |
| } |
| |
| // ReadFrom implements the PacketConn ReadFrom method. |
| func (c *UnixConn) ReadFrom(b []byte) (int, Addr, error) { |
| if !c.ok() { |
| return 0, nil, syscall.EINVAL |
| } |
| n, addr, err := c.readFrom(b) |
| if err != nil { |
| err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err} |
| } |
| if addr == nil { |
| return n, nil, err |
| } |
| return n, addr, err |
| } |
| |
| // ReadMsgUnix reads a packet from c, copying the payload into b and |
| // the associated out-of-band data into oob. It returns the number of |
| // bytes copied into b, the number of bytes copied into oob, the flags |
| // that were set on the packet, and the source address of the packet. |
| func (c *UnixConn) ReadMsgUnix(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error) { |
| if !c.ok() { |
| return 0, 0, 0, nil, syscall.EINVAL |
| } |
| n, oobn, flags, addr, err = c.readMsg(b, oob) |
| if err != nil { |
| err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err} |
| } |
| return |
| } |
| |
| // 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) (int, error) { |
| if !c.ok() { |
| return 0, syscall.EINVAL |
| } |
| n, err := c.writeTo(b, addr) |
| if err != nil { |
| err = &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: addr.opAddr(), Err: err} |
| } |
| return n, err |
| } |
| |
| // WriteTo implements the PacketConn WriteTo method. |
| func (c *UnixConn) WriteTo(b []byte, addr Addr) (int, error) { |
| if !c.ok() { |
| return 0, syscall.EINVAL |
| } |
| a, ok := addr.(*UnixAddr) |
| if !ok { |
| return 0, &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: addr, Err: syscall.EINVAL} |
| } |
| n, err := c.writeTo(b, a) |
| if err != nil { |
| err = &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: a.opAddr(), Err: err} |
| } |
| return n, err |
| } |
| |
| // WriteMsgUnix writes a packet to addr via c, copying the payload |
| // from b and the associated out-of-band data from oob. It returns |
| // the number of payload and out-of-band bytes written. |
| func (c *UnixConn) WriteMsgUnix(b, oob []byte, addr *UnixAddr) (n, oobn int, err error) { |
| if !c.ok() { |
| return 0, 0, syscall.EINVAL |
| } |
| n, oobn, err = c.writeMsg(b, oob, addr) |
| if err != nil { |
| err = &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: addr.opAddr(), Err: err} |
| } |
| return |
| } |
| |
| func newUnixConn(fd *netFD) *UnixConn { return &UnixConn{conn{fd}} } |
| |
| // 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) { |
| switch net { |
| case "unix", "unixgram", "unixpacket": |
| default: |
| return nil, &OpError{Op: "dial", Net: net, Source: laddr.opAddr(), Addr: raddr.opAddr(), Err: UnknownNetworkError(net)} |
| } |
| c, err := dialUnix(context.Background(), net, laddr, raddr) |
| if err != nil { |
| return nil, &OpError{Op: "dial", Net: net, Source: laddr.opAddr(), Addr: raddr.opAddr(), Err: err} |
| } |
| return c, nil |
| } |
| |
| // UnixListener is a Unix domain socket listener. Clients should |
| // typically use variables of type Listener instead of assuming Unix |
| // domain sockets. |
| type UnixListener struct { |
| fd *netFD |
| path string |
| unlink bool |
| } |
| |
| func (ln *UnixListener) ok() bool { return ln != nil && ln.fd != nil } |
| |
| // AcceptUnix accepts the next incoming call and returns the new |
| // connection. |
| func (l *UnixListener) AcceptUnix() (*UnixConn, error) { |
| if !l.ok() { |
| return nil, syscall.EINVAL |
| } |
| c, err := l.accept() |
| if err != nil { |
| return nil, &OpError{Op: "accept", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err} |
| } |
| return c, nil |
| } |
| |
| // Accept implements the Accept method in the Listener interface. |
| // Returned connections will be of type *UnixConn. |
| func (l *UnixListener) Accept() (Conn, error) { |
| if !l.ok() { |
| return nil, syscall.EINVAL |
| } |
| c, err := l.accept() |
| if err != nil { |
| return nil, &OpError{Op: "accept", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err} |
| } |
| return c, nil |
| } |
| |
| // Close stops listening on the Unix address. Already accepted |
| // connections are not closed. |
| func (l *UnixListener) Close() error { |
| if !l.ok() { |
| return syscall.EINVAL |
| } |
| if err := l.close(); err != nil { |
| return &OpError{Op: "close", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err} |
| } |
| return nil |
| } |
| |
| // Addr returns the listener's network address. |
| // The Addr returned is shared by all invocations of Addr, so |
| // do not modify it. |
| func (l *UnixListener) Addr() Addr { return l.fd.laddr } |
| |
| // SetDeadline sets the deadline associated with the listener. |
| // A zero time value disables the deadline. |
| func (l *UnixListener) SetDeadline(t time.Time) error { |
| if !l.ok() { |
| return syscall.EINVAL |
| } |
| if err := l.fd.setDeadline(t); err != nil { |
| return &OpError{Op: "set", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err} |
| } |
| return 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. |
| // Closing l does not affect f, and closing f does not affect l. |
| // |
| // The returned os.File's file descriptor is different from the |
| // connection's. Attempting to change properties of the original |
| // using this duplicate may or may not have the desired effect. |
| func (l *UnixListener) File() (f *os.File, err error) { |
| if !l.ok() { |
| return nil, syscall.EINVAL |
| } |
| f, err = l.file() |
| if err != nil { |
| err = &OpError{Op: "file", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err} |
| } |
| return |
| } |
| |
| // ListenUnix announces on the Unix domain socket laddr and returns a |
| // Unix listener. The network net must be "unix" or "unixpacket". |
| func ListenUnix(net string, laddr *UnixAddr) (*UnixListener, error) { |
| switch net { |
| case "unix", "unixpacket": |
| default: |
| return nil, &OpError{Op: "listen", Net: net, Source: nil, Addr: laddr.opAddr(), Err: UnknownNetworkError(net)} |
| } |
| if laddr == nil { |
| return nil, &OpError{Op: "listen", Net: net, Source: nil, Addr: laddr.opAddr(), Err: errMissingAddress} |
| } |
| ln, err := listenUnix(context.Background(), net, laddr) |
| if err != nil { |
| return nil, &OpError{Op: "listen", Net: net, Source: nil, Addr: laddr.opAddr(), Err: err} |
| } |
| return ln, nil |
| } |
| |
| // ListenUnixgram listens for incoming Unix datagram packets addressed |
| // to the local address laddr. The network net must be "unixgram". |
| // The returned connection's ReadFrom and WriteTo methods can be used |
| // to receive and send packets with per-packet addressing. |
| func ListenUnixgram(net string, laddr *UnixAddr) (*UnixConn, error) { |
| switch net { |
| case "unixgram": |
| default: |
| return nil, &OpError{Op: "listen", Net: net, Source: nil, Addr: laddr.opAddr(), Err: UnknownNetworkError(net)} |
| } |
| if laddr == nil { |
| return nil, &OpError{Op: "listen", Net: net, Source: nil, Addr: nil, Err: errMissingAddress} |
| } |
| c, err := listenUnixgram(context.Background(), net, laddr) |
| if err != nil { |
| return nil, &OpError{Op: "listen", Net: net, Source: nil, Addr: laddr.opAddr(), Err: err} |
| } |
| return c, nil |
| } |