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 "os" 9 "syscall" 10 "time" 11 ) 12 13 // UnixConn is an implementation of the Conn interface for connections 14 // to Unix domain sockets. 15 type UnixConn struct { 16 conn 17 } 18 19 // ReadFromUnix reads a packet from c, copying the payload into b. It 20 // returns the number of bytes copied into b and the source address of 21 // the packet. 22 // 23 // ReadFromUnix can be made to time out and return an error with 24 // Timeout() == true after a fixed time limit; see SetDeadline and 25 // SetReadDeadline. 26 func (c *UnixConn) ReadFromUnix(b []byte) (int, *UnixAddr, error) { 27 return 0, nil, &OpError{Op: "read", Net: c.fd.dir, Source: c.fd.laddr, Addr: c.fd.raddr, Err: syscall.EPLAN9} 28 } 29 30 // ReadFrom implements the PacketConn ReadFrom method. 31 func (c *UnixConn) ReadFrom(b []byte) (int, Addr, error) { 32 return 0, nil, &OpError{Op: "read", Net: c.fd.dir, Source: c.fd.laddr, Addr: c.fd.raddr, Err: syscall.EPLAN9} 33 } 34 35 // ReadMsgUnix reads a packet from c, copying the payload into b and 36 // the associated out-of-band data into oob. It returns the number of 37 // bytes copied into b, the number of bytes copied into oob, the flags 38 // that were set on the packet, and the source address of the packet. 39 func (c *UnixConn) ReadMsgUnix(b, oob []byte) (n, oobn, flags int, addr *UnixAddr, err error) { 40 return 0, 0, 0, nil, &OpError{Op: "read", Net: c.fd.dir, Source: c.fd.laddr, Addr: c.fd.raddr, Err: syscall.EPLAN9} 41 } 42 43 // WriteToUnix writes a packet to addr via c, copying the payload from b. 44 // 45 // WriteToUnix can be made to time out and return an error with 46 // Timeout() == true after a fixed time limit; see SetDeadline and 47 // SetWriteDeadline. On packet-oriented connections, write timeouts 48 // are rare. 49 func (c *UnixConn) WriteToUnix(b []byte, addr *UnixAddr) (int, error) { 50 return 0, &OpError{Op: "write", Net: c.fd.dir, Source: c.fd.laddr, Addr: addr.opAddr(), Err: syscall.EPLAN9} 51 } 52 53 // WriteTo implements the PacketConn WriteTo method. 54 func (c *UnixConn) WriteTo(b []byte, addr Addr) (int, error) { 55 return 0, &OpError{Op: "write", Net: c.fd.dir, Source: c.fd.laddr, Addr: addr, Err: syscall.EPLAN9} 56 } 57 58 // WriteMsgUnix writes a packet to addr via c, copying the payload 59 // from b and the associated out-of-band data from oob. It returns 60 // the number of payload and out-of-band bytes written. 61 func (c *UnixConn) WriteMsgUnix(b, oob []byte, addr *UnixAddr) (n, oobn int, err error) { 62 return 0, 0, &OpError{Op: "write", Net: c.fd.dir, Source: c.fd.laddr, Addr: addr.opAddr(), Err: syscall.EPLAN9} 63 } 64 65 // CloseRead shuts down the reading side of the Unix domain connection. 66 // Most callers should just use Close. 67 func (c *UnixConn) CloseRead() error { 68 return &OpError{Op: "close", Net: c.fd.dir, Source: c.fd.laddr, Addr: c.fd.raddr, Err: syscall.EPLAN9} 69 } 70 71 // CloseWrite shuts down the writing side of the Unix domain connection. 72 // Most callers should just use Close. 73 func (c *UnixConn) CloseWrite() error { 74 return &OpError{Op: "close", Net: c.fd.dir, Source: c.fd.laddr, Addr: c.fd.raddr, Err: syscall.EPLAN9} 75 } 76 77 // DialUnix connects to the remote address raddr on the network net, 78 // which must be "unix", "unixgram" or "unixpacket". If laddr is not 79 // nil, it is used as the local address for the connection. 80 func DialUnix(net string, laddr, raddr *UnixAddr) (*UnixConn, error) { 81 return dialUnix(net, laddr, raddr, noDeadline) 82 } 83 84 func dialUnix(net string, laddr, raddr *UnixAddr, deadline time.Time) (*UnixConn, error) { 85 return nil, &OpError{Op: "dial", Net: net, Source: laddr.opAddr(), Addr: raddr.opAddr(), Err: syscall.EPLAN9} 86 } 87 88 // UnixListener is a Unix domain socket listener. Clients should 89 // typically use variables of type Listener instead of assuming Unix 90 // domain sockets. 91 type UnixListener struct { 92 fd *netFD 93 } 94 95 // ListenUnix announces on the Unix domain socket laddr and returns a 96 // Unix listener. The network net must be "unix" or "unixpacket". 97 func ListenUnix(net string, laddr *UnixAddr) (*UnixListener, error) { 98 return nil, &OpError{Op: "listen", Net: net, Source: nil, Addr: laddr.opAddr(), Err: syscall.EPLAN9} 99 } 100 101 // AcceptUnix accepts the next incoming call and returns the new 102 // connection. 103 func (l *UnixListener) AcceptUnix() (*UnixConn, error) { 104 return nil, &OpError{Op: "accept", Net: l.fd.dir, Source: nil, Addr: l.fd.laddr, Err: syscall.EPLAN9} 105 } 106 107 // Accept implements the Accept method in the Listener interface; it 108 // waits for the next call and returns a generic Conn. 109 func (l *UnixListener) Accept() (Conn, error) { 110 return nil, &OpError{Op: "accept", Net: l.fd.dir, Source: nil, Addr: l.fd.laddr, Err: syscall.EPLAN9} 111 } 112 113 // Close stops listening on the Unix address. Already accepted 114 // connections are not closed. 115 func (l *UnixListener) Close() error { 116 return &OpError{Op: "close", Net: l.fd.dir, Source: nil, Addr: l.fd.laddr, Err: syscall.EPLAN9} 117 } 118 119 // Addr returns the listener's network address. 120 // The Addr returned is shared by all invocations of Addr, so 121 // do not modify it. 122 func (l *UnixListener) Addr() Addr { return nil } 123 124 // SetDeadline sets the deadline associated with the listener. 125 // A zero time value disables the deadline. 126 func (l *UnixListener) SetDeadline(t time.Time) error { 127 return &OpError{Op: "set", Net: l.fd.dir, Source: nil, Addr: l.fd.laddr, Err: syscall.EPLAN9} 128 } 129 130 // File returns a copy of the underlying os.File, set to blocking 131 // mode. It is the caller's responsibility to close f when finished. 132 // Closing l does not affect f, and closing f does not affect l. 133 // 134 // The returned os.File's file descriptor is different from the 135 // connection's. Attempting to change properties of the original 136 // using this duplicate may or may not have the desired effect. 137 func (l *UnixListener) File() (*os.File, error) { 138 return nil, &OpError{Op: "file", Net: l.fd.dir, Source: nil, Addr: l.fd.laddr, Err: syscall.EPLAN9} 139 } 140 141 // ListenUnixgram listens for incoming Unix datagram packets addressed 142 // to the local address laddr. The network net must be "unixgram". 143 // The returned connection's ReadFrom and WriteTo methods can be used 144 // to receive and send packets with per-packet addressing. 145 func ListenUnixgram(net string, laddr *UnixAddr) (*UnixConn, error) { 146 return nil, &OpError{Op: "listen", Net: net, Source: nil, Addr: laddr.opAddr(), Err: syscall.EPLAN9} 147 } 148
