github.com/dara-project/godist@v0.0.0-20200823115410-e0c80c8f0c78/src/syscall/net_nacl.go (about)

     1  // Copyright 2013 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  // A simulated network for use within NaCl.
     6  // The simulation is not particularly tied to NaCl,
     7  // but other systems have real networks.
     8  
     9  // All int64 times are UnixNanos.
    10  
    11  package syscall
    12  
    13  import (
    14  	"sync"
    15  	"sync/atomic"
    16  )
    17  
    18  // Interface to timers implemented in package runtime.
    19  // Must be in sync with ../runtime/time.go:/^type timer
    20  // Really for use by package time, but we cannot import time here.
    21  
    22  type runtimeTimer struct {
    23  	tb uintptr
    24  	i  int
    25  
    26  	when   int64
    27  	period int64
    28  	f      func(interface{}, uintptr) // NOTE: must not be closure
    29  	arg    interface{}
    30  	seq    uintptr
    31  }
    32  
    33  func startTimer(*runtimeTimer)
    34  func stopTimer(*runtimeTimer) bool
    35  
    36  type timer struct {
    37  	expired bool
    38  	q       *queue
    39  	r       runtimeTimer
    40  }
    41  
    42  func (t *timer) start(q *queue, deadline int64) {
    43  	if deadline == 0 {
    44  		return
    45  	}
    46  	t.q = q
    47  	t.r.when = deadline
    48  	t.r.f = timerExpired
    49  	t.r.arg = t
    50  	startTimer(&t.r)
    51  }
    52  
    53  func (t *timer) stop() {
    54  	if t.r.f == nil {
    55  		return
    56  	}
    57  	stopTimer(&t.r)
    58  }
    59  
    60  func (t *timer) reset(q *queue, deadline int64) {
    61  	t.stop()
    62  	if deadline == 0 {
    63  		return
    64  	}
    65  	if t.r.f == nil {
    66  		t.q = q
    67  		t.r.f = timerExpired
    68  		t.r.arg = t
    69  	}
    70  	t.r.when = deadline
    71  	startTimer(&t.r)
    72  }
    73  
    74  func timerExpired(i interface{}, seq uintptr) {
    75  	t := i.(*timer)
    76  	go func() {
    77  		t.q.Lock()
    78  		defer t.q.Unlock()
    79  		t.expired = true
    80  		t.q.canRead.Broadcast()
    81  		t.q.canWrite.Broadcast()
    82  	}()
    83  }
    84  
    85  // Network constants and data structures. These match the traditional values.
    86  
    87  const (
    88  	AF_UNSPEC = iota
    89  	AF_UNIX
    90  	AF_INET
    91  	AF_INET6
    92  )
    93  
    94  const (
    95  	SHUT_RD = iota
    96  	SHUT_WR
    97  	SHUT_RDWR
    98  )
    99  
   100  const (
   101  	SOCK_STREAM = 1 + iota
   102  	SOCK_DGRAM
   103  	SOCK_RAW
   104  	SOCK_SEQPACKET
   105  )
   106  
   107  const (
   108  	IPPROTO_IP   = 0
   109  	IPPROTO_IPV4 = 4
   110  	IPPROTO_IPV6 = 0x29
   111  	IPPROTO_TCP  = 6
   112  	IPPROTO_UDP  = 0x11
   113  )
   114  
   115  // Misc constants expected by package net but not supported.
   116  const (
   117  	_ = iota
   118  	SOL_SOCKET
   119  	SO_TYPE
   120  	NET_RT_IFLIST
   121  	IFNAMSIZ
   122  	IFF_UP
   123  	IFF_BROADCAST
   124  	IFF_LOOPBACK
   125  	IFF_POINTOPOINT
   126  	IFF_MULTICAST
   127  	IPV6_V6ONLY
   128  	SOMAXCONN
   129  	F_DUPFD_CLOEXEC
   130  	SO_BROADCAST
   131  	SO_REUSEADDR
   132  	SO_REUSEPORT
   133  	SO_RCVBUF
   134  	SO_SNDBUF
   135  	SO_KEEPALIVE
   136  	SO_LINGER
   137  	SO_ERROR
   138  	IP_PORTRANGE
   139  	IP_PORTRANGE_DEFAULT
   140  	IP_PORTRANGE_LOW
   141  	IP_PORTRANGE_HIGH
   142  	IP_MULTICAST_IF
   143  	IP_MULTICAST_LOOP
   144  	IP_ADD_MEMBERSHIP
   145  	IPV6_PORTRANGE
   146  	IPV6_PORTRANGE_DEFAULT
   147  	IPV6_PORTRANGE_LOW
   148  	IPV6_PORTRANGE_HIGH
   149  	IPV6_MULTICAST_IF
   150  	IPV6_MULTICAST_LOOP
   151  	IPV6_JOIN_GROUP
   152  	TCP_NODELAY
   153  	TCP_KEEPINTVL
   154  	TCP_KEEPIDLE
   155  
   156  	SYS_FCNTL = 500 // unsupported
   157  )
   158  
   159  var SocketDisableIPv6 bool
   160  
   161  // A Sockaddr is one of the SockaddrXxx structs.
   162  type Sockaddr interface {
   163  	// copy returns a copy of the underlying data.
   164  	copy() Sockaddr
   165  
   166  	// key returns the value of the underlying data,
   167  	// for comparison as a map key.
   168  	key() interface{}
   169  }
   170  
   171  type SockaddrInet4 struct {
   172  	Port int
   173  	Addr [4]byte
   174  }
   175  
   176  func (sa *SockaddrInet4) copy() Sockaddr {
   177  	sa1 := *sa
   178  	return &sa1
   179  }
   180  
   181  func (sa *SockaddrInet4) key() interface{} { return *sa }
   182  
   183  func isIPv4Localhost(sa Sockaddr) bool {
   184  	sa4, ok := sa.(*SockaddrInet4)
   185  	return ok && sa4.Addr == [4]byte{127, 0, 0, 1}
   186  }
   187  
   188  type SockaddrInet6 struct {
   189  	Port   int
   190  	ZoneId uint32
   191  	Addr   [16]byte
   192  }
   193  
   194  func (sa *SockaddrInet6) copy() Sockaddr {
   195  	sa1 := *sa
   196  	return &sa1
   197  }
   198  
   199  func (sa *SockaddrInet6) key() interface{} { return *sa }
   200  
   201  type SockaddrUnix struct {
   202  	Name string
   203  }
   204  
   205  func (sa *SockaddrUnix) copy() Sockaddr {
   206  	sa1 := *sa
   207  	return &sa1
   208  }
   209  
   210  func (sa *SockaddrUnix) key() interface{} { return *sa }
   211  
   212  type SockaddrDatalink struct {
   213  	Len    uint8
   214  	Family uint8
   215  	Index  uint16
   216  	Type   uint8
   217  	Nlen   uint8
   218  	Alen   uint8
   219  	Slen   uint8
   220  	Data   [12]int8
   221  }
   222  
   223  func (sa *SockaddrDatalink) copy() Sockaddr {
   224  	sa1 := *sa
   225  	return &sa1
   226  }
   227  
   228  func (sa *SockaddrDatalink) key() interface{} { return *sa }
   229  
   230  // RoutingMessage represents a routing message.
   231  type RoutingMessage interface {
   232  	unimplemented()
   233  }
   234  
   235  type IPMreq struct {
   236  	Multiaddr [4]byte /* in_addr */
   237  	Interface [4]byte /* in_addr */
   238  }
   239  
   240  type IPv6Mreq struct {
   241  	Multiaddr [16]byte /* in6_addr */
   242  	Interface uint32
   243  }
   244  
   245  type Linger struct {
   246  	Onoff  int32
   247  	Linger int32
   248  }
   249  
   250  type ICMPv6Filter struct {
   251  	Filt [8]uint32
   252  }
   253  
   254  // A queue is the bookkeeping for a synchronized buffered queue.
   255  // We do not use channels because we need to be able to handle
   256  // writes after and during close, and because a chan byte would
   257  // require too many send and receive operations in real use.
   258  type queue struct {
   259  	sync.Mutex
   260  	canRead  sync.Cond
   261  	canWrite sync.Cond
   262  	rtimer   *timer // non-nil if in read
   263  	wtimer   *timer // non-nil if in write
   264  	r        int    // total read index
   265  	w        int    // total write index
   266  	m        int    // index mask
   267  	closed   bool
   268  }
   269  
   270  func (q *queue) init(size int) {
   271  	if size&(size-1) != 0 {
   272  		panic("invalid queue size - must be power of two")
   273  	}
   274  	q.canRead.L = &q.Mutex
   275  	q.canWrite.L = &q.Mutex
   276  	q.m = size - 1
   277  }
   278  
   279  func past(deadline int64) bool {
   280  	sec, nsec := now()
   281  	return deadline > 0 && deadline < sec*1e9+int64(nsec)
   282  }
   283  
   284  func (q *queue) waitRead(n int, deadline int64) (int, error) {
   285  	if past(deadline) {
   286  		return 0, EAGAIN
   287  	}
   288  	var t timer
   289  	t.start(q, deadline)
   290  	q.rtimer = &t
   291  	for q.w-q.r == 0 && !q.closed && !t.expired {
   292  		q.canRead.Wait()
   293  	}
   294  	q.rtimer = nil
   295  	t.stop()
   296  	m := q.w - q.r
   297  	if m == 0 && t.expired {
   298  		return 0, EAGAIN
   299  	}
   300  	if m > n {
   301  		m = n
   302  		q.canRead.Signal() // wake up next reader too
   303  	}
   304  	q.canWrite.Signal()
   305  	return m, nil
   306  }
   307  
   308  func (q *queue) waitWrite(n int, deadline int64) (int, error) {
   309  	if past(deadline) {
   310  		return 0, EAGAIN
   311  	}
   312  	var t timer
   313  	t.start(q, deadline)
   314  	q.wtimer = &t
   315  	for q.w-q.r > q.m && !q.closed && !t.expired {
   316  		q.canWrite.Wait()
   317  	}
   318  	q.wtimer = nil
   319  	t.stop()
   320  	m := q.m + 1 - (q.w - q.r)
   321  	if m == 0 && t.expired {
   322  		return 0, EAGAIN
   323  	}
   324  	if m == 0 {
   325  		return 0, EAGAIN
   326  	}
   327  	if m > n {
   328  		m = n
   329  		q.canWrite.Signal() // wake up next writer too
   330  	}
   331  	q.canRead.Signal()
   332  	return m, nil
   333  }
   334  
   335  func (q *queue) close() {
   336  	q.Lock()
   337  	defer q.Unlock()
   338  	q.closed = true
   339  	q.canRead.Broadcast()
   340  	q.canWrite.Broadcast()
   341  }
   342  
   343  // A byteq is a byte queue.
   344  type byteq struct {
   345  	queue
   346  	data []byte
   347  }
   348  
   349  func newByteq() *byteq {
   350  	q := &byteq{
   351  		data: make([]byte, 4096),
   352  	}
   353  	q.init(len(q.data))
   354  	return q
   355  }
   356  
   357  func (q *byteq) read(b []byte, deadline int64) (int, error) {
   358  	q.Lock()
   359  	defer q.Unlock()
   360  	n, err := q.waitRead(len(b), deadline)
   361  	if err != nil {
   362  		return 0, err
   363  	}
   364  	b = b[:n]
   365  	for len(b) > 0 {
   366  		m := copy(b, q.data[q.r&q.m:])
   367  		q.r += m
   368  		b = b[m:]
   369  	}
   370  	return n, nil
   371  }
   372  
   373  func (q *byteq) write(b []byte, deadline int64) (n int, err error) {
   374  	q.Lock()
   375  	defer q.Unlock()
   376  	for n < len(b) {
   377  		nn, err := q.waitWrite(len(b[n:]), deadline)
   378  		if err != nil {
   379  			return n, err
   380  		}
   381  		bb := b[n : n+nn]
   382  		n += nn
   383  		for len(bb) > 0 {
   384  			m := copy(q.data[q.w&q.m:], bb)
   385  			q.w += m
   386  			bb = bb[m:]
   387  		}
   388  	}
   389  	return n, nil
   390  }
   391  
   392  // A msgq is a queue of messages.
   393  type msgq struct {
   394  	queue
   395  	data []interface{}
   396  }
   397  
   398  func newMsgq() *msgq {
   399  	q := &msgq{
   400  		data: make([]interface{}, 32),
   401  	}
   402  	q.init(len(q.data))
   403  	return q
   404  }
   405  
   406  func (q *msgq) read(deadline int64) (interface{}, error) {
   407  	q.Lock()
   408  	defer q.Unlock()
   409  	n, err := q.waitRead(1, deadline)
   410  	if err != nil {
   411  		return nil, err
   412  	}
   413  	if n == 0 {
   414  		return nil, nil
   415  	}
   416  	m := q.data[q.r&q.m]
   417  	q.r++
   418  	return m, nil
   419  }
   420  
   421  func (q *msgq) write(m interface{}, deadline int64) error {
   422  	q.Lock()
   423  	defer q.Unlock()
   424  	_, err := q.waitWrite(1, deadline)
   425  	if err != nil {
   426  		return err
   427  	}
   428  	q.data[q.w&q.m] = m
   429  	q.w++
   430  	return nil
   431  }
   432  
   433  // An addr is a sequence of bytes uniquely identifying a network address.
   434  // It is not human-readable.
   435  type addr string
   436  
   437  // A conn is one side of a stream-based network connection.
   438  // That is, a stream-based network connection is a pair of cross-connected conns.
   439  type conn struct {
   440  	rd     *byteq
   441  	wr     *byteq
   442  	local  addr
   443  	remote addr
   444  }
   445  
   446  // A pktconn is one side of a packet-based network connection.
   447  // That is, a packet-based network connection is a pair of cross-connected pktconns.
   448  type pktconn struct {
   449  	rd     *msgq
   450  	wr     *msgq
   451  	local  addr
   452  	remote addr
   453  }
   454  
   455  // A listener accepts incoming stream-based network connections.
   456  type listener struct {
   457  	rd    *msgq
   458  	local addr
   459  }
   460  
   461  // A netFile is an open network file.
   462  type netFile struct {
   463  	defaultFileImpl
   464  	proto      *netproto
   465  	sotype     int
   466  	listener   *msgq
   467  	packet     *msgq
   468  	rd         *byteq
   469  	wr         *byteq
   470  	rddeadline int64
   471  	wrdeadline int64
   472  	addr       Sockaddr
   473  	raddr      Sockaddr
   474  }
   475  
   476  // A netAddr is a network address in the global listener map.
   477  // All the fields must have defined == operations.
   478  type netAddr struct {
   479  	proto  *netproto
   480  	sotype int
   481  	addr   interface{}
   482  }
   483  
   484  // net records the state of the network.
   485  // It maps a network address to the listener on that address.
   486  var net = struct {
   487  	sync.Mutex
   488  	listener map[netAddr]*netFile
   489  }{
   490  	listener: make(map[netAddr]*netFile),
   491  }
   492  
   493  // TODO(rsc): Some day, do a better job with port allocation.
   494  // For playground programs, incrementing is fine.
   495  var nextport = 2
   496  
   497  // A netproto contains protocol-specific functionality
   498  // (one for AF_INET, one for AF_INET6 and so on).
   499  // It is a struct instead of an interface because the
   500  // implementation needs no state, and I expect to
   501  // add some data fields at some point.
   502  type netproto struct {
   503  	bind func(*netFile, Sockaddr) error
   504  }
   505  
   506  var netprotoAF_INET = &netproto{
   507  	bind: func(f *netFile, sa Sockaddr) error {
   508  		if sa == nil {
   509  			f.addr = &SockaddrInet4{
   510  				Port: nextport,
   511  				Addr: [4]byte{127, 0, 0, 1},
   512  			}
   513  			nextport++
   514  			return nil
   515  		}
   516  		addr, ok := sa.(*SockaddrInet4)
   517  		if !ok {
   518  			return EINVAL
   519  		}
   520  		addr = addr.copy().(*SockaddrInet4)
   521  		if addr.Port == 0 {
   522  			addr.Port = nextport
   523  			nextport++
   524  		}
   525  		f.addr = addr
   526  		return nil
   527  	},
   528  }
   529  
   530  var netprotos = map[int]*netproto{
   531  	AF_INET: netprotoAF_INET,
   532  }
   533  
   534  // These functions implement the usual BSD socket operations.
   535  
   536  func (f *netFile) bind(sa Sockaddr) error {
   537      println("[BIND]")
   538  	if f.addr != nil {
   539  		return EISCONN
   540  	}
   541  	if err := f.proto.bind(f, sa); err != nil {
   542  		return err
   543  	}
   544  	if f.sotype == SOCK_DGRAM {
   545  		_, ok := net.listener[netAddr{f.proto, f.sotype, f.addr.key()}]
   546  		if ok {
   547  			f.addr = nil
   548  			return EADDRINUSE
   549  		}
   550  		net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] = f
   551  		f.packet = newMsgq()
   552  	}
   553  	return nil
   554  }
   555  
   556  func (f *netFile) listen(backlog int) error {
   557      println("[LISTEN]")
   558  	net.Lock()
   559  	defer net.Unlock()
   560  	if f.listener != nil {
   561  		return EINVAL
   562  	}
   563  	old, ok := net.listener[netAddr{f.proto, f.sotype, f.addr.key()}]
   564  	if ok && !old.listenerClosed() {
   565  		return EADDRINUSE
   566  	}
   567  	net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] = f
   568  	f.listener = newMsgq()
   569  	return nil
   570  }
   571  
   572  func (f *netFile) accept() (fd int, sa Sockaddr, err error) {
   573      println("[ACCEPT]")
   574  	msg, err := f.listener.read(f.readDeadline())
   575  	if err != nil {
   576  		return -1, nil, err
   577  	}
   578  	newf, ok := msg.(*netFile)
   579  	if !ok {
   580  		// must be eof
   581  		return -1, nil, EAGAIN
   582  	}
   583  	return newFD(newf), newf.raddr.copy(), nil
   584  }
   585  
   586  func (f *netFile) connect(sa Sockaddr) error {
   587      println("[CONNECT]")
   588  	if past(f.writeDeadline()) {
   589  		return EAGAIN
   590  	}
   591  	if f.addr == nil {
   592  		if err := f.bind(nil); err != nil {
   593  			return err
   594  		}
   595  	}
   596  	net.Lock()
   597  	if sa == nil {
   598  		net.Unlock()
   599  		return EINVAL
   600  	}
   601  	sa = sa.copy()
   602  	if f.raddr != nil {
   603  		net.Unlock()
   604  		return EISCONN
   605  	}
   606  	if f.sotype == SOCK_DGRAM {
   607  		net.Unlock()
   608  		f.raddr = sa
   609  		return nil
   610  	}
   611  	if f.listener != nil {
   612  		net.Unlock()
   613  		return EISCONN
   614  	}
   615  	l, ok := net.listener[netAddr{f.proto, f.sotype, sa.key()}]
   616  	if !ok {
   617  		// If we're dialing 127.0.0.1 but found nothing, try
   618  		// 0.0.0.0 also. (Issue 20611)
   619  		if isIPv4Localhost(sa) {
   620  			sa = &SockaddrInet4{Port: sa.(*SockaddrInet4).Port}
   621  			l, ok = net.listener[netAddr{f.proto, f.sotype, sa.key()}]
   622  		}
   623  	}
   624  	if !ok || l.listenerClosed() {
   625  		net.Unlock()
   626  		return ECONNREFUSED
   627  	}
   628  	f.raddr = sa
   629  	f.rd = newByteq()
   630  	f.wr = newByteq()
   631  	newf := &netFile{
   632  		proto:  f.proto,
   633  		sotype: f.sotype,
   634  		addr:   f.raddr,
   635  		raddr:  f.addr,
   636  		rd:     f.wr,
   637  		wr:     f.rd,
   638  	}
   639  	net.Unlock()
   640  	l.listener.write(newf, f.writeDeadline())
   641  	return nil
   642  }
   643  
   644  func (f *netFile) read(b []byte) (int, error) {
   645      println("[NETFILE.READ]")
   646  	if f.rd == nil {
   647  		if f.raddr != nil {
   648  			n, _, err := f.recvfrom(b, 0)
   649  			return n, err
   650  		}
   651  		return 0, ENOTCONN
   652  	}
   653  	return f.rd.read(b, f.readDeadline())
   654  }
   655  
   656  func (f *netFile) write(b []byte) (int, error) {
   657      println("[NETFILE.WRITE]")
   658  	if f.wr == nil {
   659  		if f.raddr != nil {
   660  			err := f.sendto(b, 0, f.raddr)
   661  			var n int
   662  			if err == nil {
   663  				n = len(b)
   664  			}
   665  			return n, err
   666  		}
   667  		return 0, ENOTCONN
   668  	}
   669  	return f.wr.write(b, f.writeDeadline())
   670  }
   671  
   672  type pktmsg struct {
   673  	buf  []byte
   674  	addr Sockaddr
   675  }
   676  
   677  func (f *netFile) recvfrom(p []byte, flags int) (n int, from Sockaddr, err error) {
   678      println("[RECVFROM]")
   679  	if f.sotype != SOCK_DGRAM {
   680  		return 0, nil, EINVAL
   681  	}
   682  	if f.packet == nil {
   683  		return 0, nil, ENOTCONN
   684  	}
   685  	msg1, err := f.packet.read(f.readDeadline())
   686  	if err != nil {
   687  		return 0, nil, err
   688  	}
   689  	msg, ok := msg1.(*pktmsg)
   690  	if !ok {
   691  		return 0, nil, EAGAIN
   692  	}
   693  	return copy(p, msg.buf), msg.addr, nil
   694  }
   695  
   696  func (f *netFile) sendto(p []byte, flags int, to Sockaddr) error {
   697      println("[SENDTO]")
   698  	if f.sotype != SOCK_DGRAM {
   699  		return EINVAL
   700  	}
   701  	if f.packet == nil {
   702  		if err := f.bind(nil); err != nil {
   703  			return err
   704  		}
   705  	}
   706  	net.Lock()
   707  	if to == nil {
   708  		net.Unlock()
   709  		return EINVAL
   710  	}
   711  	to = to.copy()
   712  	l, ok := net.listener[netAddr{f.proto, f.sotype, to.key()}]
   713  	if !ok || l.packet == nil {
   714  		net.Unlock()
   715  		return ECONNREFUSED
   716  	}
   717  	net.Unlock()
   718  	msg := &pktmsg{
   719  		buf:  make([]byte, len(p)),
   720  		addr: f.addr,
   721  	}
   722  	copy(msg.buf, p)
   723  	l.packet.write(msg, f.writeDeadline())
   724  	return nil
   725  }
   726  
   727  func (f *netFile) listenerClosed() bool {
   728  	f.listener.Lock()
   729  	defer f.listener.Unlock()
   730  	return f.listener.closed
   731  }
   732  
   733  func (f *netFile) close() error {
   734  	if f.listener != nil {
   735  		f.listener.close()
   736  	}
   737  	if f.packet != nil {
   738  		f.packet.close()
   739  	}
   740  	if f.rd != nil {
   741  		f.rd.close()
   742  	}
   743  	if f.wr != nil {
   744  		f.wr.close()
   745  	}
   746  	return nil
   747  }
   748  
   749  func fdToNetFile(fd int) (*netFile, error) {
   750  	f, err := fdToFile(fd)
   751  	if err != nil {
   752  		return nil, err
   753  	}
   754  	impl := f.impl
   755  	netf, ok := impl.(*netFile)
   756  	if !ok {
   757  		return nil, EINVAL
   758  	}
   759  	return netf, nil
   760  }
   761  
   762  func Socket(proto, sotype, unused int) (fd int, err error) {
   763  	p := netprotos[proto]
   764  	if p == nil {
   765  		return -1, EPROTONOSUPPORT
   766  	}
   767  	if sotype != SOCK_STREAM && sotype != SOCK_DGRAM {
   768  		return -1, ESOCKTNOSUPPORT
   769  	}
   770  	f := &netFile{
   771  		proto:  p,
   772  		sotype: sotype,
   773  	}
   774  	return newFD(f), nil
   775  }
   776  
   777  func Bind(fd int, sa Sockaddr) error {
   778  	f, err := fdToNetFile(fd)
   779  	if err != nil {
   780  		return err
   781  	}
   782  	return f.bind(sa)
   783  }
   784  
   785  func StopIO(fd int) error {
   786  	f, err := fdToNetFile(fd)
   787  	if err != nil {
   788  		return err
   789  	}
   790  	f.close()
   791  	return nil
   792  }
   793  
   794  func Listen(fd int, backlog int) error {
   795  	f, err := fdToNetFile(fd)
   796  	if err != nil {
   797  		return err
   798  	}
   799  	return f.listen(backlog)
   800  }
   801  
   802  func Accept(fd int) (newfd int, sa Sockaddr, err error) {
   803  	f, err := fdToNetFile(fd)
   804  	if err != nil {
   805  		return 0, nil, err
   806  	}
   807  	return f.accept()
   808  }
   809  
   810  func Getsockname(fd int) (sa Sockaddr, err error) {
   811  	f, err := fdToNetFile(fd)
   812  	if err != nil {
   813  		return nil, err
   814  	}
   815  	if f.addr == nil {
   816  		return nil, ENOTCONN
   817  	}
   818  	return f.addr.copy(), nil
   819  }
   820  
   821  func Getpeername(fd int) (sa Sockaddr, err error) {
   822  	f, err := fdToNetFile(fd)
   823  	if err != nil {
   824  		return nil, err
   825  	}
   826  	if f.raddr == nil {
   827  		return nil, ENOTCONN
   828  	}
   829  	return f.raddr.copy(), nil
   830  }
   831  
   832  func Connect(fd int, sa Sockaddr) error {
   833  	f, err := fdToNetFile(fd)
   834  	if err != nil {
   835  		return err
   836  	}
   837  	return f.connect(sa)
   838  }
   839  
   840  func Recvfrom(fd int, p []byte, flags int) (n int, from Sockaddr, err error) {
   841  	f, err := fdToNetFile(fd)
   842  	if err != nil {
   843  		return 0, nil, err
   844  	}
   845  	return f.recvfrom(p, flags)
   846  }
   847  
   848  func Sendto(fd int, p []byte, flags int, to Sockaddr) error {
   849  	f, err := fdToNetFile(fd)
   850  	if err != nil {
   851  		return err
   852  	}
   853  	return f.sendto(p, flags, to)
   854  }
   855  
   856  func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn, recvflags int, from Sockaddr, err error) {
   857  	f, err := fdToNetFile(fd)
   858  	if err != nil {
   859  		return
   860  	}
   861  	n, from, err = f.recvfrom(p, flags)
   862  	return
   863  }
   864  
   865  func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) error {
   866  	_, err := SendmsgN(fd, p, oob, to, flags)
   867  	return err
   868  }
   869  
   870  func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) {
   871  	f, err := fdToNetFile(fd)
   872  	if err != nil {
   873  		return 0, err
   874  	}
   875  	switch f.sotype {
   876  	case SOCK_STREAM:
   877  		n, err = f.write(p)
   878  	case SOCK_DGRAM:
   879  		n = len(p)
   880  		err = f.sendto(p, flags, to)
   881  	}
   882  	if err != nil {
   883  		return 0, err
   884  	}
   885  	return n, nil
   886  }
   887  
   888  func GetsockoptInt(fd, level, opt int) (value int, err error) {
   889  	f, err := fdToNetFile(fd)
   890  	if err != nil {
   891  		return 0, err
   892  	}
   893  	switch {
   894  	case level == SOL_SOCKET && opt == SO_TYPE:
   895  		return f.sotype, nil
   896  	}
   897  	return 0, ENOTSUP
   898  }
   899  
   900  func SetsockoptInt(fd, level, opt int, value int) error {
   901  	return nil
   902  }
   903  
   904  func SetsockoptByte(fd, level, opt int, value byte) error {
   905  	_, err := fdToNetFile(fd)
   906  	if err != nil {
   907  		return err
   908  	}
   909  	return ENOTSUP
   910  }
   911  
   912  func SetsockoptLinger(fd, level, opt int, l *Linger) error {
   913  	return nil
   914  }
   915  
   916  func SetReadDeadline(fd int, t int64) error {
   917  	f, err := fdToNetFile(fd)
   918  	if err != nil {
   919  		return err
   920  	}
   921  	atomic.StoreInt64(&f.rddeadline, t)
   922  	if bq := f.rd; bq != nil {
   923  		bq.Lock()
   924  		if timer := bq.rtimer; timer != nil {
   925  			timer.reset(&bq.queue, t)
   926  		}
   927  		bq.Unlock()
   928  	}
   929  	return nil
   930  }
   931  
   932  func (f *netFile) readDeadline() int64 {
   933  	return atomic.LoadInt64(&f.rddeadline)
   934  }
   935  
   936  func SetWriteDeadline(fd int, t int64) error {
   937  	f, err := fdToNetFile(fd)
   938  	if err != nil {
   939  		return err
   940  	}
   941  	atomic.StoreInt64(&f.wrdeadline, t)
   942  	if bq := f.wr; bq != nil {
   943  		bq.Lock()
   944  		if timer := bq.wtimer; timer != nil {
   945  			timer.reset(&bq.queue, t)
   946  		}
   947  		bq.Unlock()
   948  	}
   949  	return nil
   950  }
   951  
   952  func (f *netFile) writeDeadline() int64 {
   953  	return atomic.LoadInt64(&f.wrdeadline)
   954  }
   955  
   956  func Shutdown(fd int, how int) error {
   957  	f, err := fdToNetFile(fd)
   958  	if err != nil {
   959  		return err
   960  	}
   961  	switch how {
   962  	case SHUT_RD:
   963  		f.rd.close()
   964  	case SHUT_WR:
   965  		f.wr.close()
   966  	case SHUT_RDWR:
   967  		f.rd.close()
   968  		f.wr.close()
   969  	}
   970  	return nil
   971  }
   972  
   973  func SetsockoptICMPv6Filter(fd, level, opt int, filter *ICMPv6Filter) error { panic("SetsockoptICMPv") }
   974  func SetsockoptIPMreq(fd, level, opt int, mreq *IPMreq) error               { panic("SetsockoptIPMreq") }
   975  func SetsockoptIPv6Mreq(fd, level, opt int, mreq *IPv6Mreq) error           { panic("SetsockoptIPv") }
   976  func SetsockoptInet4Addr(fd, level, opt int, value [4]byte) error           { panic("SetsockoptInet") }
   977  func SetsockoptString(fd, level, opt int, s string) error                   { panic("SetsockoptString") }
   978  func SetsockoptTimeval(fd, level, opt int, tv *Timeval) error               { panic("SetsockoptTimeval") }
   979  func Socketpair(domain, typ, proto int) (fd [2]int, err error)              { panic("Socketpair") }
   980  
   981  func SetNonblock(fd int, nonblocking bool) error { return nil }