Source file src/syscall/net_nacl.go

     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		if f.addr != nil {
   538			return EISCONN
   539		}
   540		if err := f.proto.bind(f, sa); err != nil {
   541			return err
   542		}
   543		if f.sotype == SOCK_DGRAM {
   544			_, ok := net.listener[netAddr{f.proto, f.sotype, f.addr.key()}]
   545			if ok {
   546				f.addr = nil
   547				return EADDRINUSE
   548			}
   549			net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] = f
   550			f.packet = newMsgq()
   551		}
   552		return nil
   553	}
   554	
   555	func (f *netFile) listen(backlog int) error {
   556		net.Lock()
   557		defer net.Unlock()
   558		if f.listener != nil {
   559			return EINVAL
   560		}
   561		old, ok := net.listener[netAddr{f.proto, f.sotype, f.addr.key()}]
   562		if ok && !old.listenerClosed() {
   563			return EADDRINUSE
   564		}
   565		net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] = f
   566		f.listener = newMsgq()
   567		return nil
   568	}
   569	
   570	func (f *netFile) accept() (fd int, sa Sockaddr, err error) {
   571		msg, err := f.listener.read(f.readDeadline())
   572		if err != nil {
   573			return -1, nil, err
   574		}
   575		newf, ok := msg.(*netFile)
   576		if !ok {
   577			// must be eof
   578			return -1, nil, EAGAIN
   579		}
   580		return newFD(newf), newf.raddr.copy(), nil
   581	}
   582	
   583	func (f *netFile) connect(sa Sockaddr) error {
   584		if past(f.writeDeadline()) {
   585			return EAGAIN
   586		}
   587		if f.addr == nil {
   588			if err := f.bind(nil); err != nil {
   589				return err
   590			}
   591		}
   592		net.Lock()
   593		if sa == nil {
   594			net.Unlock()
   595			return EINVAL
   596		}
   597		sa = sa.copy()
   598		if f.raddr != nil {
   599			net.Unlock()
   600			return EISCONN
   601		}
   602		if f.sotype == SOCK_DGRAM {
   603			net.Unlock()
   604			f.raddr = sa
   605			return nil
   606		}
   607		if f.listener != nil {
   608			net.Unlock()
   609			return EISCONN
   610		}
   611		l, ok := net.listener[netAddr{f.proto, f.sotype, sa.key()}]
   612		if !ok {
   613			// If we're dialing 127.0.0.1 but found nothing, try
   614			// 0.0.0.0 also. (Issue 20611)
   615			if isIPv4Localhost(sa) {
   616				sa = &SockaddrInet4{Port: sa.(*SockaddrInet4).Port}
   617				l, ok = net.listener[netAddr{f.proto, f.sotype, sa.key()}]
   618			}
   619		}
   620		if !ok || l.listenerClosed() {
   621			net.Unlock()
   622			return ECONNREFUSED
   623		}
   624		f.raddr = sa
   625		f.rd = newByteq()
   626		f.wr = newByteq()
   627		newf := &netFile{
   628			proto:  f.proto,
   629			sotype: f.sotype,
   630			addr:   f.raddr,
   631			raddr:  f.addr,
   632			rd:     f.wr,
   633			wr:     f.rd,
   634		}
   635		net.Unlock()
   636		l.listener.write(newf, f.writeDeadline())
   637		return nil
   638	}
   639	
   640	func (f *netFile) read(b []byte) (int, error) {
   641		if f.rd == nil {
   642			if f.raddr != nil {
   643				n, _, err := f.recvfrom(b, 0)
   644				return n, err
   645			}
   646			return 0, ENOTCONN
   647		}
   648		return f.rd.read(b, f.readDeadline())
   649	}
   650	
   651	func (f *netFile) write(b []byte) (int, error) {
   652		if f.wr == nil {
   653			if f.raddr != nil {
   654				err := f.sendto(b, 0, f.raddr)
   655				var n int
   656				if err == nil {
   657					n = len(b)
   658				}
   659				return n, err
   660			}
   661			return 0, ENOTCONN
   662		}
   663		return f.wr.write(b, f.writeDeadline())
   664	}
   665	
   666	type pktmsg struct {
   667		buf  []byte
   668		addr Sockaddr
   669	}
   670	
   671	func (f *netFile) recvfrom(p []byte, flags int) (n int, from Sockaddr, err error) {
   672		if f.sotype != SOCK_DGRAM {
   673			return 0, nil, EINVAL
   674		}
   675		if f.packet == nil {
   676			return 0, nil, ENOTCONN
   677		}
   678		msg1, err := f.packet.read(f.readDeadline())
   679		if err != nil {
   680			return 0, nil, err
   681		}
   682		msg, ok := msg1.(*pktmsg)
   683		if !ok {
   684			return 0, nil, EAGAIN
   685		}
   686		return copy(p, msg.buf), msg.addr, nil
   687	}
   688	
   689	func (f *netFile) sendto(p []byte, flags int, to Sockaddr) error {
   690		if f.sotype != SOCK_DGRAM {
   691			return EINVAL
   692		}
   693		if f.packet == nil {
   694			if err := f.bind(nil); err != nil {
   695				return err
   696			}
   697		}
   698		net.Lock()
   699		if to == nil {
   700			net.Unlock()
   701			return EINVAL
   702		}
   703		to = to.copy()
   704		l, ok := net.listener[netAddr{f.proto, f.sotype, to.key()}]
   705		if !ok || l.packet == nil {
   706			net.Unlock()
   707			return ECONNREFUSED
   708		}
   709		net.Unlock()
   710		msg := &pktmsg{
   711			buf:  make([]byte, len(p)),
   712			addr: f.addr,
   713		}
   714		copy(msg.buf, p)
   715		l.packet.write(msg, f.writeDeadline())
   716		return nil
   717	}
   718	
   719	func (f *netFile) listenerClosed() bool {
   720		f.listener.Lock()
   721		defer f.listener.Unlock()
   722		return f.listener.closed
   723	}
   724	
   725	func (f *netFile) close() error {
   726		if f.listener != nil {
   727			f.listener.close()
   728		}
   729		if f.packet != nil {
   730			f.packet.close()
   731		}
   732		if f.rd != nil {
   733			f.rd.close()
   734		}
   735		if f.wr != nil {
   736			f.wr.close()
   737		}
   738		return nil
   739	}
   740	
   741	func fdToNetFile(fd int) (*netFile, error) {
   742		f, err := fdToFile(fd)
   743		if err != nil {
   744			return nil, err
   745		}
   746		impl := f.impl
   747		netf, ok := impl.(*netFile)
   748		if !ok {
   749			return nil, EINVAL
   750		}
   751		return netf, nil
   752	}
   753	
   754	func Socket(proto, sotype, unused int) (fd int, err error) {
   755		p := netprotos[proto]
   756		if p == nil {
   757			return -1, EPROTONOSUPPORT
   758		}
   759		if sotype != SOCK_STREAM && sotype != SOCK_DGRAM {
   760			return -1, ESOCKTNOSUPPORT
   761		}
   762		f := &netFile{
   763			proto:  p,
   764			sotype: sotype,
   765		}
   766		return newFD(f), nil
   767	}
   768	
   769	func Bind(fd int, sa Sockaddr) error {
   770		f, err := fdToNetFile(fd)
   771		if err != nil {
   772			return err
   773		}
   774		return f.bind(sa)
   775	}
   776	
   777	func StopIO(fd int) error {
   778		f, err := fdToNetFile(fd)
   779		if err != nil {
   780			return err
   781		}
   782		f.close()
   783		return nil
   784	}
   785	
   786	func Listen(fd int, backlog int) error {
   787		f, err := fdToNetFile(fd)
   788		if err != nil {
   789			return err
   790		}
   791		return f.listen(backlog)
   792	}
   793	
   794	func Accept(fd int) (newfd int, sa Sockaddr, err error) {
   795		f, err := fdToNetFile(fd)
   796		if err != nil {
   797			return 0, nil, err
   798		}
   799		return f.accept()
   800	}
   801	
   802	func Getsockname(fd int) (sa Sockaddr, err error) {
   803		f, err := fdToNetFile(fd)
   804		if err != nil {
   805			return nil, err
   806		}
   807		if f.addr == nil {
   808			return nil, ENOTCONN
   809		}
   810		return f.addr.copy(), nil
   811	}
   812	
   813	func Getpeername(fd int) (sa Sockaddr, err error) {
   814		f, err := fdToNetFile(fd)
   815		if err != nil {
   816			return nil, err
   817		}
   818		if f.raddr == nil {
   819			return nil, ENOTCONN
   820		}
   821		return f.raddr.copy(), nil
   822	}
   823	
   824	func Connect(fd int, sa Sockaddr) error {
   825		f, err := fdToNetFile(fd)
   826		if err != nil {
   827			return err
   828		}
   829		return f.connect(sa)
   830	}
   831	
   832	func Recvfrom(fd int, p []byte, flags int) (n int, from Sockaddr, err error) {
   833		f, err := fdToNetFile(fd)
   834		if err != nil {
   835			return 0, nil, err
   836		}
   837		return f.recvfrom(p, flags)
   838	}
   839	
   840	func Sendto(fd int, p []byte, flags int, to Sockaddr) error {
   841		f, err := fdToNetFile(fd)
   842		if err != nil {
   843			return err
   844		}
   845		return f.sendto(p, flags, to)
   846	}
   847	
   848	func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn, recvflags int, from Sockaddr, err error) {
   849		f, err := fdToNetFile(fd)
   850		if err != nil {
   851			return
   852		}
   853		n, from, err = f.recvfrom(p, flags)
   854		return
   855	}
   856	
   857	func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) error {
   858		_, err := SendmsgN(fd, p, oob, to, flags)
   859		return err
   860	}
   861	
   862	func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) {
   863		f, err := fdToNetFile(fd)
   864		if err != nil {
   865			return 0, err
   866		}
   867		switch f.sotype {
   868		case SOCK_STREAM:
   869			n, err = f.write(p)
   870		case SOCK_DGRAM:
   871			n = len(p)
   872			err = f.sendto(p, flags, to)
   873		}
   874		if err != nil {
   875			return 0, err
   876		}
   877		return n, nil
   878	}
   879	
   880	func GetsockoptInt(fd, level, opt int) (value int, err error) {
   881		f, err := fdToNetFile(fd)
   882		if err != nil {
   883			return 0, err
   884		}
   885		switch {
   886		case level == SOL_SOCKET && opt == SO_TYPE:
   887			return f.sotype, nil
   888		}
   889		return 0, ENOTSUP
   890	}
   891	
   892	func SetsockoptInt(fd, level, opt int, value int) error {
   893		return nil
   894	}
   895	
   896	func SetsockoptByte(fd, level, opt int, value byte) error {
   897		_, err := fdToNetFile(fd)
   898		if err != nil {
   899			return err
   900		}
   901		return ENOTSUP
   902	}
   903	
   904	func SetsockoptLinger(fd, level, opt int, l *Linger) error {
   905		return nil
   906	}
   907	
   908	func SetReadDeadline(fd int, t int64) error {
   909		f, err := fdToNetFile(fd)
   910		if err != nil {
   911			return err
   912		}
   913		atomic.StoreInt64(&f.rddeadline, t)
   914		if bq := f.rd; bq != nil {
   915			bq.Lock()
   916			if timer := bq.rtimer; timer != nil {
   917				timer.reset(&bq.queue, t)
   918			}
   919			bq.Unlock()
   920		}
   921		return nil
   922	}
   923	
   924	func (f *netFile) readDeadline() int64 {
   925		return atomic.LoadInt64(&f.rddeadline)
   926	}
   927	
   928	func SetWriteDeadline(fd int, t int64) error {
   929		f, err := fdToNetFile(fd)
   930		if err != nil {
   931			return err
   932		}
   933		atomic.StoreInt64(&f.wrdeadline, t)
   934		if bq := f.wr; bq != nil {
   935			bq.Lock()
   936			if timer := bq.wtimer; timer != nil {
   937				timer.reset(&bq.queue, t)
   938			}
   939			bq.Unlock()
   940		}
   941		return nil
   942	}
   943	
   944	func (f *netFile) writeDeadline() int64 {
   945		return atomic.LoadInt64(&f.wrdeadline)
   946	}
   947	
   948	func Shutdown(fd int, how int) error {
   949		f, err := fdToNetFile(fd)
   950		if err != nil {
   951			return err
   952		}
   953		switch how {
   954		case SHUT_RD:
   955			f.rd.close()
   956		case SHUT_WR:
   957			f.wr.close()
   958		case SHUT_RDWR:
   959			f.rd.close()
   960			f.wr.close()
   961		}
   962		return nil
   963	}
   964	
   965	func SetsockoptICMPv6Filter(fd, level, opt int, filter *ICMPv6Filter) error { panic("SetsockoptICMPv") }
   966	func SetsockoptIPMreq(fd, level, opt int, mreq *IPMreq) error               { panic("SetsockoptIPMreq") }
   967	func SetsockoptIPv6Mreq(fd, level, opt int, mreq *IPv6Mreq) error           { panic("SetsockoptIPv") }
   968	func SetsockoptInet4Addr(fd, level, opt int, value [4]byte) error           { panic("SetsockoptInet") }
   969	func SetsockoptString(fd, level, opt int, s string) error                   { panic("SetsockoptString") }
   970	func SetsockoptTimeval(fd, level, opt int, tv *Timeval) error               { panic("SetsockoptTimeval") }
   971	func Socketpair(domain, typ, proto int) (fd [2]int, err error)              { panic("Socketpair") }
   972	
   973	func SetNonblock(fd int, nonblocking bool) error { return nil }
   974	

View as plain text