libgo/go/net/unixsock.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 package net
   6
   7 import (
   8         "context"
   9         "os"
  10         "sync"
  11         "syscall"
  12         "time"
  13 )
  14
  15 // BUG(mikio): On JS and Plan 9, methods and functions related
  16 // to UnixConn and UnixListener are not implemented.
  17
  18 // BUG(mikio): On Windows, methods and functions related to UnixConn
  19 // and UnixListener don't work for "unixgram" and "unixpacket".
  20
  21 // UnixAddr represents the address of a Unix domain socket end point.
  22 type UnixAddr struct {
  23         Name string
  24         Net  string
  25 }
  26
  27 // Network returns the address's network name, "unix", "unixgram" or
  28 // "unixpacket".
  29 func (a *UnixAddr) Network() string {
  30         return a.Net
  31 }
  32
  33 func (a *UnixAddr) String() string {
  34         if a == nil {
  35                 return "<nil>"
  36         }
  37         return a.Name
  38 }
  39
  40 func (a *UnixAddr) isWildcard() bool {
  41         return a == nil || a.Name == ""
  42 }
  43
  44 func (a *UnixAddr) opAddr() Addr {
  45         if a == nil {
  46                 return nil
  47         }
  48         return a
  49 }
  50
  51 // ResolveUnixAddr returns an address of Unix domain socket end point.
  52 //
  53 // The network must be a Unix network name.
  54 //
  55 // See func Dial for a description of the network and address
  56 // parameters.
  57 func ResolveUnixAddr(network, address string) (*UnixAddr, error) {
  58         switch network {
  59         case "unix", "unixgram", "unixpacket":
  60                 return &UnixAddr{Name: address, Net: network}, nil
  61         default:
  62                 return nil, UnknownNetworkError(network)
  63         }
  64 }
  65
  66 // UnixConn is an implementation of the Conn interface for connections
  67 // to Unix domain sockets.
  68 type UnixConn struct {
  69         conn
  70 }
  71
  72 // SyscallConn returns a raw network connection.
  73 // This implements the syscall.Conn interface.
  74 func (c *UnixConn) SyscallConn() (syscall.RawConn, error) {
  75         if !c.ok() {
  76                 return nil, syscall.EINVAL
  77         }
  78         return newRawConn(c.fd)
  79 }
  80
  81 // CloseRead shuts down the reading side of the Unix domain connection.
  82 // Most callers should just use Close.
  83 func (c *UnixConn) CloseRead() error {
  84         if !c.ok() {
  85                 return syscall.EINVAL
  86         }
  87         if err := c.fd.closeRead(); err != nil {
  88                 return &OpError{Op: "close", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
  89         }
  90         return nil
  91 }
  92
  93 // CloseWrite shuts down the writing side of the Unix domain connection.
  94 // Most callers should just use Close.
  95 func (c *UnixConn) CloseWrite() error {
  96         if !c.ok() {
  97                 return syscall.EINVAL
  98         }
  99         if err := c.fd.closeWrite(); err != nil {
 100                 return &OpError{Op: "close", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
 101         }
 102         return nil
 103 }
 104
 105 // ReadFromUnix acts like ReadFrom but returns a UnixAddr.
 106 func (c *UnixConn) ReadFromUnix(b []byte) (int, *UnixAddr, error) {
 107         if !c.ok() {
 108                 return 0, nil, syscall.EINVAL
 109         }
 110         n, addr, err := c.readFrom(b)
 111         if err != nil {
 112                 err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
 113         }
 114         return n, addr, err
 115 }
 116
 117 // ReadFrom implements the PacketConn ReadFrom method.
 118 func (c *UnixConn) ReadFrom(b []byte) (int, Addr, error) {
 119         if !c.ok() {
 120                 return 0, nil, syscall.EINVAL
 121         }
 122         n, addr, err := c.readFrom(b)
 123         if err != nil {
 124                 err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
 125         }
 126         if addr == nil {
 127                 return n, nil, err
 128         }
 129         return n, addr, err
 130 }
 131
 132 // ReadMsgUnix reads a message from c, copying the payload into b and
 133 // the associated out-of-band data into oob. It returns the number of
 134 // bytes copied into b, the number of bytes copied into oob, the flags
 135 // that were set on the message and the source address of the message.
 136 //
 137 // Note that if len(b) == 0 and len(oob) > 0, this function will still
 138 // read (and discard) 1 byte from the connection.
 139 func (c *UnixConn) ReadMsgUnix(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error) {
 140         if !c.ok() {
 141                 return 0, 0, 0, nil, syscall.EINVAL
 142         }
 143         n, oobn, flags, addr, err = c.readMsg(b, oob)
 144         if err != nil {
 145                 err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
 146         }
 147         return
 148 }
 149
 150 // WriteToUnix acts like WriteTo but takes a UnixAddr.
 151 func (c *UnixConn) WriteToUnix(b []byte, addr *UnixAddr) (int, error) {
 152         if !c.ok() {
 153                 return 0, syscall.EINVAL
 154         }
 155         n, err := c.writeTo(b, addr)
 156         if err != nil {
 157                 err = &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: addr.opAddr(), Err: err}
 158         }
 159         return n, err
 160 }
 161
 162 // WriteTo implements the PacketConn WriteTo method.
 163 func (c *UnixConn) WriteTo(b []byte, addr Addr) (int, error) {
 164         if !c.ok() {
 165                 return 0, syscall.EINVAL
 166         }
 167         a, ok := addr.(*UnixAddr)
 168         if !ok {
 169                 return 0, &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: addr, Err: syscall.EINVAL}
 170         }
 171         n, err := c.writeTo(b, a)
 172         if err != nil {
 173                 err = &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: a.opAddr(), Err: err}
 174         }
 175         return n, err
 176 }
 177
 178 // WriteMsgUnix writes a message to addr via c, copying the payload
 179 // from b and the associated out-of-band data from oob. It returns the
 180 // number of payload and out-of-band bytes written.
 181 //
 182 // Note that if len(b) == 0 and len(oob) > 0, this function will still
 183 // write 1 byte to the connection.
 184 func (c *UnixConn) WriteMsgUnix(b, oob []byte, addr *UnixAddr) (n, oobn int, err error) {
 185         if !c.ok() {
 186                 return 0, 0, syscall.EINVAL
 187         }
 188         n, oobn, err = c.writeMsg(b, oob, addr)
 189         if err != nil {
 190                 err = &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: addr.opAddr(), Err: err}
 191         }
 192         return
 193 }
 194
 195 func newUnixConn(fd *netFD) *UnixConn { return &UnixConn{conn{fd}} }
 196
 197 // DialUnix acts like Dial for Unix networks.
 198 //
 199 // The network must be a Unix network name; see func Dial for details.
 200 //
 201 // If laddr is non-nil, it is used as the local address for the
 202 // connection.
 203 func DialUnix(network string, laddr, raddr *UnixAddr) (*UnixConn, error) {
 204         switch network {
 205         case "unix", "unixgram", "unixpacket":
 206         default:
 207                 return nil, &OpError{Op: "dial", Net: network, Source: laddr.opAddr(), Addr: raddr.opAddr(), Err: UnknownNetworkError(network)}
 208         }
 209         sd := &sysDialer{network: network, address: raddr.String()}
 210         c, err := sd.dialUnix(context.Background(), laddr, raddr)
 211         if err != nil {
 212                 return nil, &OpError{Op: "dial", Net: network, Source: laddr.opAddr(), Addr: raddr.opAddr(), Err: err}
 213         }
 214         return c, nil
 215 }
 216
 217 // UnixListener is a Unix domain socket listener. Clients should
 218 // typically use variables of type Listener instead of assuming Unix
 219 // domain sockets.
 220 type UnixListener struct {
 221         fd         *netFD
 222         path       string
 223         unlink     bool
 224         unlinkOnce sync.Once
 225 }
 226
 227 func (ln *UnixListener) ok() bool { return ln != nil && ln.fd != nil }
 228
 229 // SyscallConn returns a raw network connection.
 230 // This implements the syscall.Conn interface.
 231 //
 232 // The returned RawConn only supports calling Control. Read and
 233 // Write return an error.
 234 func (l *UnixListener) SyscallConn() (syscall.RawConn, error) {
 235         if !l.ok() {
 236                 return nil, syscall.EINVAL
 237         }
 238         return newRawListener(l.fd)
 239 }
 240
 241 // AcceptUnix accepts the next incoming call and returns the new
 242 // connection.
 243 func (l *UnixListener) AcceptUnix() (*UnixConn, error) {
 244         if !l.ok() {
 245                 return nil, syscall.EINVAL
 246         }
 247         c, err := l.accept()
 248         if err != nil {
 249                 return nil, &OpError{Op: "accept", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err}
 250         }
 251         return c, nil
 252 }
 253
 254 // Accept implements the Accept method in the Listener interface.
 255 // Returned connections will be of type *UnixConn.
 256 func (l *UnixListener) Accept() (Conn, error) {
 257         if !l.ok() {
 258                 return nil, syscall.EINVAL
 259         }
 260         c, err := l.accept()
 261         if err != nil {
 262                 return nil, &OpError{Op: "accept", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err}
 263         }
 264         return c, nil
 265 }
 266
 267 // Close stops listening on the Unix address. Already accepted
 268 // connections are not closed.
 269 func (l *UnixListener) Close() error {
 270         if !l.ok() {
 271                 return syscall.EINVAL
 272         }
 273         if err := l.close(); err != nil {
 274                 return &OpError{Op: "close", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err}
 275         }
 276         return nil
 277 }
 278
 279 // Addr returns the listener's network address.
 280 // The Addr returned is shared by all invocations of Addr, so
 281 // do not modify it.
 282 func (l *UnixListener) Addr() Addr { return l.fd.laddr }
 283
 284 // SetDeadline sets the deadline associated with the listener.
 285 // A zero time value disables the deadline.
 286 func (l *UnixListener) SetDeadline(t time.Time) error {
 287         if !l.ok() {
 288                 return syscall.EINVAL
 289         }
 290         if err := l.fd.pfd.SetDeadline(t); err != nil {
 291                 return &OpError{Op: "set", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err}
 292         }
 293         return nil
 294 }
 295
 296 // File returns a copy of the underlying os.File.
 297 // It is the caller's responsibility to close f when finished.
 298 // Closing l does not affect f, and closing f does not affect l.
 299 //
 300 // The returned os.File's file descriptor is different from the
 301 // connection's. Attempting to change properties of the original
 302 // using this duplicate may or may not have the desired effect.
 303 func (l *UnixListener) File() (f *os.File, err error) {
 304         if !l.ok() {
 305                 return nil, syscall.EINVAL
 306         }
 307         f, err = l.file()
 308         if err != nil {
 309                 err = &OpError{Op: "file", Net: l.fd.net, Source: nil, Addr: l.fd.laddr, Err: err}
 310         }
 311         return
 312 }
 313
 314 // ListenUnix acts like Listen for Unix networks.
 315 //
 316 // The network must be "unix" or "unixpacket".
 317 func ListenUnix(network string, laddr *UnixAddr) (*UnixListener, error) {
 318         switch network {
 319         case "unix", "unixpacket":
 320         default:
 321                 return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: laddr.opAddr(), Err: UnknownNetworkError(network)}
 322         }
 323         if laddr == nil {
 324                 return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: laddr.opAddr(), Err: errMissingAddress}
 325         }
 326         sl := &sysListener{network: network, address: laddr.String()}
 327         ln, err := sl.listenUnix(context.Background(), laddr)
 328         if err != nil {
 329                 return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: laddr.opAddr(), Err: err}
 330         }
 331         return ln, nil
 332 }
 333
 334 // ListenUnixgram acts like ListenPacket for Unix networks.
 335 //
 336 // The network must be "unixgram".
 337 func ListenUnixgram(network string, laddr *UnixAddr) (*UnixConn, error) {
 338         switch network {
 339         case "unixgram":
 340         default:
 341                 return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: laddr.opAddr(), Err: UnknownNetworkError(network)}
 342         }
 343         if laddr == nil {
 344                 return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: nil, Err: errMissingAddress}
 345         }
 346         sl := &sysListener{network: network, address: laddr.String()}
 347         c, err := sl.listenUnixgram(context.Background(), laddr)
 348         if err != nil {
 349                 return nil, &OpError{Op: "listen", Net: network, Source: nil, Addr: laddr.opAddr(), Err: err}
 350         }
 351         return c, nil
 352 }