| // Copyright 2013 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. |
| |
| // A simulated network for use within NaCl. |
| // The simulation is not particularly tied to NaCl, |
| // but other systems have real networks. |
| |
| // All int64 times are UnixNanos. |
| |
| package syscall |
| |
| import ( |
| "sync" |
| "sync/atomic" |
| ) |
| |
| // Interface to timers implemented in package runtime. |
| // Must be in sync with ../runtime/time.go:/^type timer |
| // Really for use by package time, but we cannot import time here. |
| |
| type runtimeTimer struct { |
| tb uintptr |
| i int |
| |
| when int64 |
| period int64 |
| f func(interface{}, uintptr) // NOTE: must not be closure |
| arg interface{} |
| seq uintptr |
| } |
| |
| func startTimer(*runtimeTimer) |
| func stopTimer(*runtimeTimer) bool |
| |
| type timer struct { |
| expired bool |
| q *queue |
| r runtimeTimer |
| } |
| |
| func (t *timer) start(q *queue, deadline int64) { |
| if deadline == 0 { |
| return |
| } |
| t.q = q |
| t.r.when = deadline |
| t.r.f = timerExpired |
| t.r.arg = t |
| startTimer(&t.r) |
| } |
| |
| func (t *timer) stop() { |
| if t.r.f == nil { |
| return |
| } |
| stopTimer(&t.r) |
| } |
| |
| func (t *timer) reset(q *queue, deadline int64) { |
| t.stop() |
| if deadline == 0 { |
| return |
| } |
| if t.r.f == nil { |
| t.q = q |
| t.r.f = timerExpired |
| t.r.arg = t |
| } |
| t.r.when = deadline |
| startTimer(&t.r) |
| } |
| |
| func timerExpired(i interface{}, seq uintptr) { |
| t := i.(*timer) |
| go func() { |
| t.q.Lock() |
| defer t.q.Unlock() |
| t.expired = true |
| t.q.canRead.Broadcast() |
| t.q.canWrite.Broadcast() |
| }() |
| } |
| |
| // Network constants and data structures. These match the traditional values. |
| |
| const ( |
| AF_UNSPEC = iota |
| AF_UNIX |
| AF_INET |
| AF_INET6 |
| ) |
| |
| const ( |
| SHUT_RD = iota |
| SHUT_WR |
| SHUT_RDWR |
| ) |
| |
| const ( |
| SOCK_STREAM = 1 + iota |
| SOCK_DGRAM |
| SOCK_RAW |
| SOCK_SEQPACKET |
| ) |
| |
| const ( |
| IPPROTO_IP = 0 |
| IPPROTO_IPV4 = 4 |
| IPPROTO_IPV6 = 0x29 |
| IPPROTO_TCP = 6 |
| IPPROTO_UDP = 0x11 |
| ) |
| |
| // Misc constants expected by package net but not supported. |
| const ( |
| _ = iota |
| SOL_SOCKET |
| SO_TYPE |
| NET_RT_IFLIST |
| IFNAMSIZ |
| IFF_UP |
| IFF_BROADCAST |
| IFF_LOOPBACK |
| IFF_POINTOPOINT |
| IFF_MULTICAST |
| IPV6_V6ONLY |
| SOMAXCONN |
| F_DUPFD_CLOEXEC |
| SO_BROADCAST |
| SO_REUSEADDR |
| SO_REUSEPORT |
| SO_RCVBUF |
| SO_SNDBUF |
| SO_KEEPALIVE |
| SO_LINGER |
| SO_ERROR |
| IP_PORTRANGE |
| IP_PORTRANGE_DEFAULT |
| IP_PORTRANGE_LOW |
| IP_PORTRANGE_HIGH |
| IP_MULTICAST_IF |
| IP_MULTICAST_LOOP |
| IP_ADD_MEMBERSHIP |
| IPV6_PORTRANGE |
| IPV6_PORTRANGE_DEFAULT |
| IPV6_PORTRANGE_LOW |
| IPV6_PORTRANGE_HIGH |
| IPV6_MULTICAST_IF |
| IPV6_MULTICAST_LOOP |
| IPV6_JOIN_GROUP |
| TCP_NODELAY |
| TCP_KEEPINTVL |
| TCP_KEEPIDLE |
| |
| SYS_FCNTL = 500 // unsupported |
| ) |
| |
| var SocketDisableIPv6 bool |
| |
| // A Sockaddr is one of the SockaddrXxx structs. |
| type Sockaddr interface { |
| // copy returns a copy of the underlying data. |
| copy() Sockaddr |
| |
| // key returns the value of the underlying data, |
| // for comparison as a map key. |
| key() interface{} |
| } |
| |
| type SockaddrInet4 struct { |
| Port int |
| Addr [4]byte |
| } |
| |
| func (sa *SockaddrInet4) copy() Sockaddr { |
| sa1 := *sa |
| return &sa1 |
| } |
| |
| func (sa *SockaddrInet4) key() interface{} { return *sa } |
| |
| func isIPv4Localhost(sa Sockaddr) bool { |
| sa4, ok := sa.(*SockaddrInet4) |
| return ok && sa4.Addr == [4]byte{127, 0, 0, 1} |
| } |
| |
| type SockaddrInet6 struct { |
| Port int |
| ZoneId uint32 |
| Addr [16]byte |
| } |
| |
| func (sa *SockaddrInet6) copy() Sockaddr { |
| sa1 := *sa |
| return &sa1 |
| } |
| |
| func (sa *SockaddrInet6) key() interface{} { return *sa } |
| |
| type SockaddrUnix struct { |
| Name string |
| } |
| |
| func (sa *SockaddrUnix) copy() Sockaddr { |
| sa1 := *sa |
| return &sa1 |
| } |
| |
| func (sa *SockaddrUnix) key() interface{} { return *sa } |
| |
| type SockaddrDatalink struct { |
| Len uint8 |
| Family uint8 |
| Index uint16 |
| Type uint8 |
| Nlen uint8 |
| Alen uint8 |
| Slen uint8 |
| Data [12]int8 |
| } |
| |
| func (sa *SockaddrDatalink) copy() Sockaddr { |
| sa1 := *sa |
| return &sa1 |
| } |
| |
| func (sa *SockaddrDatalink) key() interface{} { return *sa } |
| |
| // RoutingMessage represents a routing message. |
| type RoutingMessage interface { |
| unimplemented() |
| } |
| |
| type IPMreq struct { |
| Multiaddr [4]byte /* in_addr */ |
| Interface [4]byte /* in_addr */ |
| } |
| |
| type IPv6Mreq struct { |
| Multiaddr [16]byte /* in6_addr */ |
| Interface uint32 |
| } |
| |
| type Linger struct { |
| Onoff int32 |
| Linger int32 |
| } |
| |
| type ICMPv6Filter struct { |
| Filt [8]uint32 |
| } |
| |
| // A queue is the bookkeeping for a synchronized buffered queue. |
| // We do not use channels because we need to be able to handle |
| // writes after and during close, and because a chan byte would |
| // require too many send and receive operations in real use. |
| type queue struct { |
| sync.Mutex |
| canRead sync.Cond |
| canWrite sync.Cond |
| rtimer *timer // non-nil if in read |
| wtimer *timer // non-nil if in write |
| r int // total read index |
| w int // total write index |
| m int // index mask |
| closed bool |
| } |
| |
| func (q *queue) init(size int) { |
| if size&(size-1) != 0 { |
| panic("invalid queue size - must be power of two") |
| } |
| q.canRead.L = &q.Mutex |
| q.canWrite.L = &q.Mutex |
| q.m = size - 1 |
| } |
| |
| func past(deadline int64) bool { |
| sec, nsec := now() |
| return deadline > 0 && deadline < sec*1e9+int64(nsec) |
| } |
| |
| func (q *queue) waitRead(n int, deadline int64) (int, error) { |
| if past(deadline) { |
| return 0, EAGAIN |
| } |
| var t timer |
| t.start(q, deadline) |
| q.rtimer = &t |
| for q.w-q.r == 0 && !q.closed && !t.expired { |
| q.canRead.Wait() |
| } |
| q.rtimer = nil |
| t.stop() |
| m := q.w - q.r |
| if m == 0 && t.expired { |
| return 0, EAGAIN |
| } |
| if m > n { |
| m = n |
| q.canRead.Signal() // wake up next reader too |
| } |
| q.canWrite.Signal() |
| return m, nil |
| } |
| |
| func (q *queue) waitWrite(n int, deadline int64) (int, error) { |
| if past(deadline) { |
| return 0, EAGAIN |
| } |
| var t timer |
| t.start(q, deadline) |
| q.wtimer = &t |
| for q.w-q.r > q.m && !q.closed && !t.expired { |
| q.canWrite.Wait() |
| } |
| q.wtimer = nil |
| t.stop() |
| m := q.m + 1 - (q.w - q.r) |
| if m == 0 && t.expired { |
| return 0, EAGAIN |
| } |
| if m == 0 { |
| return 0, EAGAIN |
| } |
| if m > n { |
| m = n |
| q.canWrite.Signal() // wake up next writer too |
| } |
| q.canRead.Signal() |
| return m, nil |
| } |
| |
| func (q *queue) close() { |
| q.Lock() |
| defer q.Unlock() |
| q.closed = true |
| q.canRead.Broadcast() |
| q.canWrite.Broadcast() |
| } |
| |
| // A byteq is a byte queue. |
| type byteq struct { |
| queue |
| data []byte |
| } |
| |
| func newByteq() *byteq { |
| q := &byteq{ |
| data: make([]byte, 4096), |
| } |
| q.init(len(q.data)) |
| return q |
| } |
| |
| func (q *byteq) read(b []byte, deadline int64) (int, error) { |
| q.Lock() |
| defer q.Unlock() |
| n, err := q.waitRead(len(b), deadline) |
| if err != nil { |
| return 0, err |
| } |
| b = b[:n] |
| for len(b) > 0 { |
| m := copy(b, q.data[q.r&q.m:]) |
| q.r += m |
| b = b[m:] |
| } |
| return n, nil |
| } |
| |
| func (q *byteq) write(b []byte, deadline int64) (n int, err error) { |
| q.Lock() |
| defer q.Unlock() |
| for n < len(b) { |
| nn, err := q.waitWrite(len(b[n:]), deadline) |
| if err != nil { |
| return n, err |
| } |
| bb := b[n : n+nn] |
| n += nn |
| for len(bb) > 0 { |
| m := copy(q.data[q.w&q.m:], bb) |
| q.w += m |
| bb = bb[m:] |
| } |
| } |
| return n, nil |
| } |
| |
| // A msgq is a queue of messages. |
| type msgq struct { |
| queue |
| data []interface{} |
| } |
| |
| func newMsgq() *msgq { |
| q := &msgq{ |
| data: make([]interface{}, 32), |
| } |
| q.init(len(q.data)) |
| return q |
| } |
| |
| func (q *msgq) read(deadline int64) (interface{}, error) { |
| q.Lock() |
| defer q.Unlock() |
| n, err := q.waitRead(1, deadline) |
| if err != nil { |
| return nil, err |
| } |
| if n == 0 { |
| return nil, nil |
| } |
| m := q.data[q.r&q.m] |
| q.r++ |
| return m, nil |
| } |
| |
| func (q *msgq) write(m interface{}, deadline int64) error { |
| q.Lock() |
| defer q.Unlock() |
| _, err := q.waitWrite(1, deadline) |
| if err != nil { |
| return err |
| } |
| q.data[q.w&q.m] = m |
| q.w++ |
| return nil |
| } |
| |
| // An addr is a sequence of bytes uniquely identifying a network address. |
| // It is not human-readable. |
| type addr string |
| |
| // A conn is one side of a stream-based network connection. |
| // That is, a stream-based network connection is a pair of cross-connected conns. |
| type conn struct { |
| rd *byteq |
| wr *byteq |
| local addr |
| remote addr |
| } |
| |
| // A pktconn is one side of a packet-based network connection. |
| // That is, a packet-based network connection is a pair of cross-connected pktconns. |
| type pktconn struct { |
| rd *msgq |
| wr *msgq |
| local addr |
| remote addr |
| } |
| |
| // A listener accepts incoming stream-based network connections. |
| type listener struct { |
| rd *msgq |
| local addr |
| } |
| |
| // A netFile is an open network file. |
| type netFile struct { |
| defaultFileImpl |
| proto *netproto |
| sotype int |
| listener *msgq |
| packet *msgq |
| rd *byteq |
| wr *byteq |
| rddeadline int64 |
| wrdeadline int64 |
| addr Sockaddr |
| raddr Sockaddr |
| } |
| |
| // A netAddr is a network address in the global listener map. |
| // All the fields must have defined == operations. |
| type netAddr struct { |
| proto *netproto |
| sotype int |
| addr interface{} |
| } |
| |
| // net records the state of the network. |
| // It maps a network address to the listener on that address. |
| var net = struct { |
| sync.Mutex |
| listener map[netAddr]*netFile |
| }{ |
| listener: make(map[netAddr]*netFile), |
| } |
| |
| // TODO(rsc): Some day, do a better job with port allocation. |
| // For playground programs, incrementing is fine. |
| var nextport = 2 |
| |
| // A netproto contains protocol-specific functionality |
| // (one for AF_INET, one for AF_INET6 and so on). |
| // It is a struct instead of an interface because the |
| // implementation needs no state, and I expect to |
| // add some data fields at some point. |
| type netproto struct { |
| bind func(*netFile, Sockaddr) error |
| } |
| |
| var netprotoAF_INET = &netproto{ |
| bind: func(f *netFile, sa Sockaddr) error { |
| if sa == nil { |
| f.addr = &SockaddrInet4{ |
| Port: nextport, |
| Addr: [4]byte{127, 0, 0, 1}, |
| } |
| nextport++ |
| return nil |
| } |
| addr, ok := sa.(*SockaddrInet4) |
| if !ok { |
| return EINVAL |
| } |
| addr = addr.copy().(*SockaddrInet4) |
| if addr.Port == 0 { |
| addr.Port = nextport |
| nextport++ |
| } |
| f.addr = addr |
| return nil |
| }, |
| } |
| |
| var netprotos = map[int]*netproto{ |
| AF_INET: netprotoAF_INET, |
| } |
| |
| // These functions implement the usual BSD socket operations. |
| |
| func (f *netFile) bind(sa Sockaddr) error { |
| if f.addr != nil { |
| return EISCONN |
| } |
| if err := f.proto.bind(f, sa); err != nil { |
| return err |
| } |
| if f.sotype == SOCK_DGRAM { |
| _, ok := net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] |
| if ok { |
| f.addr = nil |
| return EADDRINUSE |
| } |
| net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] = f |
| f.packet = newMsgq() |
| } |
| return nil |
| } |
| |
| func (f *netFile) listen(backlog int) error { |
| net.Lock() |
| defer net.Unlock() |
| if f.listener != nil { |
| return EINVAL |
| } |
| old, ok := net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] |
| if ok && !old.listenerClosed() { |
| return EADDRINUSE |
| } |
| net.listener[netAddr{f.proto, f.sotype, f.addr.key()}] = f |
| f.listener = newMsgq() |
| return nil |
| } |
| |
| func (f *netFile) accept() (fd int, sa Sockaddr, err error) { |
| msg, err := f.listener.read(f.readDeadline()) |
| if err != nil { |
| return -1, nil, err |
| } |
| newf, ok := msg.(*netFile) |
| if !ok { |
| // must be eof |
| return -1, nil, EAGAIN |
| } |
| return newFD(newf), newf.raddr.copy(), nil |
| } |
| |
| func (f *netFile) connect(sa Sockaddr) error { |
| if past(f.writeDeadline()) { |
| return EAGAIN |
| } |
| if f.addr == nil { |
| if err := f.bind(nil); err != nil { |
| return err |
| } |
| } |
| net.Lock() |
| if sa == nil { |
| net.Unlock() |
| return EINVAL |
| } |
| sa = sa.copy() |
| if f.raddr != nil { |
| net.Unlock() |
| return EISCONN |
| } |
| if f.sotype == SOCK_DGRAM { |
| net.Unlock() |
| f.raddr = sa |
| return nil |
| } |
| if f.listener != nil { |
| net.Unlock() |
| return EISCONN |
| } |
| l, ok := net.listener[netAddr{f.proto, f.sotype, sa.key()}] |
| if !ok { |
| // If we're dialing 127.0.0.1 but found nothing, try |
| // 0.0.0.0 also. (Issue 20611) |
| if isIPv4Localhost(sa) { |
| sa = &SockaddrInet4{Port: sa.(*SockaddrInet4).Port} |
| l, ok = net.listener[netAddr{f.proto, f.sotype, sa.key()}] |
| } |
| } |
| if !ok || l.listenerClosed() { |
| net.Unlock() |
| return ECONNREFUSED |
| } |
| f.raddr = sa |
| f.rd = newByteq() |
| f.wr = newByteq() |
| newf := &netFile{ |
| proto: f.proto, |
| sotype: f.sotype, |
| addr: f.raddr, |
| raddr: f.addr, |
| rd: f.wr, |
| wr: f.rd, |
| } |
| net.Unlock() |
| l.listener.write(newf, f.writeDeadline()) |
| return nil |
| } |
| |
| func (f *netFile) read(b []byte) (int, error) { |
| if f.rd == nil { |
| if f.raddr != nil { |
| n, _, err := f.recvfrom(b, 0) |
| return n, err |
| } |
| return 0, ENOTCONN |
| } |
| return f.rd.read(b, f.readDeadline()) |
| } |
| |
| func (f *netFile) write(b []byte) (int, error) { |
| if f.wr == nil { |
| if f.raddr != nil { |
| err := f.sendto(b, 0, f.raddr) |
| var n int |
| if err == nil { |
| n = len(b) |
| } |
| return n, err |
| } |
| return 0, ENOTCONN |
| } |
| return f.wr.write(b, f.writeDeadline()) |
| } |
| |
| type pktmsg struct { |
| buf []byte |
| addr Sockaddr |
| } |
| |
| func (f *netFile) recvfrom(p []byte, flags int) (n int, from Sockaddr, err error) { |
| if f.sotype != SOCK_DGRAM { |
| return 0, nil, EINVAL |
| } |
| if f.packet == nil { |
| return 0, nil, ENOTCONN |
| } |
| msg1, err := f.packet.read(f.readDeadline()) |
| if err != nil { |
| return 0, nil, err |
| } |
| msg, ok := msg1.(*pktmsg) |
| if !ok { |
| return 0, nil, EAGAIN |
| } |
| return copy(p, msg.buf), msg.addr, nil |
| } |
| |
| func (f *netFile) sendto(p []byte, flags int, to Sockaddr) error { |
| if f.sotype != SOCK_DGRAM { |
| return EINVAL |
| } |
| if f.packet == nil { |
| if err := f.bind(nil); err != nil { |
| return err |
| } |
| } |
| net.Lock() |
| if to == nil { |
| net.Unlock() |
| return EINVAL |
| } |
| to = to.copy() |
| l, ok := net.listener[netAddr{f.proto, f.sotype, to.key()}] |
| if !ok || l.packet == nil { |
| net.Unlock() |
| return ECONNREFUSED |
| } |
| net.Unlock() |
| msg := &pktmsg{ |
| buf: make([]byte, len(p)), |
| addr: f.addr, |
| } |
| copy(msg.buf, p) |
| l.packet.write(msg, f.writeDeadline()) |
| return nil |
| } |
| |
| func (f *netFile) listenerClosed() bool { |
| f.listener.Lock() |
| defer f.listener.Unlock() |
| return f.listener.closed |
| } |
| |
| func (f *netFile) close() error { |
| if f.listener != nil { |
| f.listener.close() |
| } |
| if f.packet != nil { |
| f.packet.close() |
| } |
| if f.rd != nil { |
| f.rd.close() |
| } |
| if f.wr != nil { |
| f.wr.close() |
| } |
| return nil |
| } |
| |
| func fdToNetFile(fd int) (*netFile, error) { |
| f, err := fdToFile(fd) |
| if err != nil { |
| return nil, err |
| } |
| impl := f.impl |
| netf, ok := impl.(*netFile) |
| if !ok { |
| return nil, EINVAL |
| } |
| return netf, nil |
| } |
| |
| func Socket(proto, sotype, unused int) (fd int, err error) { |
| p := netprotos[proto] |
| if p == nil { |
| return -1, EPROTONOSUPPORT |
| } |
| if sotype != SOCK_STREAM && sotype != SOCK_DGRAM { |
| return -1, ESOCKTNOSUPPORT |
| } |
| f := &netFile{ |
| proto: p, |
| sotype: sotype, |
| } |
| return newFD(f), nil |
| } |
| |
| func Bind(fd int, sa Sockaddr) error { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return err |
| } |
| return f.bind(sa) |
| } |
| |
| func StopIO(fd int) error { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return err |
| } |
| f.close() |
| return nil |
| } |
| |
| func Listen(fd int, backlog int) error { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return err |
| } |
| return f.listen(backlog) |
| } |
| |
| func Accept(fd int) (newfd int, sa Sockaddr, err error) { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return 0, nil, err |
| } |
| return f.accept() |
| } |
| |
| func Getsockname(fd int) (sa Sockaddr, err error) { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return nil, err |
| } |
| if f.addr == nil { |
| return nil, ENOTCONN |
| } |
| return f.addr.copy(), nil |
| } |
| |
| func Getpeername(fd int) (sa Sockaddr, err error) { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return nil, err |
| } |
| if f.raddr == nil { |
| return nil, ENOTCONN |
| } |
| return f.raddr.copy(), nil |
| } |
| |
| func Connect(fd int, sa Sockaddr) error { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return err |
| } |
| return f.connect(sa) |
| } |
| |
| func Recvfrom(fd int, p []byte, flags int) (n int, from Sockaddr, err error) { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return 0, nil, err |
| } |
| return f.recvfrom(p, flags) |
| } |
| |
| func Sendto(fd int, p []byte, flags int, to Sockaddr) error { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return err |
| } |
| return f.sendto(p, flags, to) |
| } |
| |
| func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn, recvflags int, from Sockaddr, err error) { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return |
| } |
| n, from, err = f.recvfrom(p, flags) |
| return |
| } |
| |
| func Sendmsg(fd int, p, oob []byte, to Sockaddr, flags int) error { |
| _, err := SendmsgN(fd, p, oob, to, flags) |
| return err |
| } |
| |
| func SendmsgN(fd int, p, oob []byte, to Sockaddr, flags int) (n int, err error) { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return 0, err |
| } |
| switch f.sotype { |
| case SOCK_STREAM: |
| n, err = f.write(p) |
| case SOCK_DGRAM: |
| n = len(p) |
| err = f.sendto(p, flags, to) |
| } |
| if err != nil { |
| return 0, err |
| } |
| return n, nil |
| } |
| |
| func GetsockoptInt(fd, level, opt int) (value int, err error) { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return 0, err |
| } |
| switch { |
| case level == SOL_SOCKET && opt == SO_TYPE: |
| return f.sotype, nil |
| } |
| return 0, ENOTSUP |
| } |
| |
| func SetsockoptInt(fd, level, opt int, value int) error { |
| return nil |
| } |
| |
| func SetsockoptByte(fd, level, opt int, value byte) error { |
| _, err := fdToNetFile(fd) |
| if err != nil { |
| return err |
| } |
| return ENOTSUP |
| } |
| |
| func SetsockoptLinger(fd, level, opt int, l *Linger) error { |
| return nil |
| } |
| |
| func SetReadDeadline(fd int, t int64) error { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return err |
| } |
| atomic.StoreInt64(&f.rddeadline, t) |
| if bq := f.rd; bq != nil { |
| bq.Lock() |
| if timer := bq.rtimer; timer != nil { |
| timer.reset(&bq.queue, t) |
| } |
| bq.Unlock() |
| } |
| return nil |
| } |
| |
| func (f *netFile) readDeadline() int64 { |
| return atomic.LoadInt64(&f.rddeadline) |
| } |
| |
| func SetWriteDeadline(fd int, t int64) error { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return err |
| } |
| atomic.StoreInt64(&f.wrdeadline, t) |
| if bq := f.wr; bq != nil { |
| bq.Lock() |
| if timer := bq.wtimer; timer != nil { |
| timer.reset(&bq.queue, t) |
| } |
| bq.Unlock() |
| } |
| return nil |
| } |
| |
| func (f *netFile) writeDeadline() int64 { |
| return atomic.LoadInt64(&f.wrdeadline) |
| } |
| |
| func Shutdown(fd int, how int) error { |
| f, err := fdToNetFile(fd) |
| if err != nil { |
| return err |
| } |
| switch how { |
| case SHUT_RD: |
| f.rd.close() |
| case SHUT_WR: |
| f.wr.close() |
| case SHUT_RDWR: |
| f.rd.close() |
| f.wr.close() |
| } |
| return nil |
| } |
| |
| func SetsockoptICMPv6Filter(fd, level, opt int, filter *ICMPv6Filter) error { panic("SetsockoptICMPv") } |
| func SetsockoptIPMreq(fd, level, opt int, mreq *IPMreq) error { panic("SetsockoptIPMreq") } |
| func SetsockoptIPv6Mreq(fd, level, opt int, mreq *IPv6Mreq) error { panic("SetsockoptIPv") } |
| func SetsockoptInet4Addr(fd, level, opt int, value [4]byte) error { panic("SetsockoptInet") } |
| func SetsockoptString(fd, level, opt int, s string) error { panic("SetsockoptString") } |
| func SetsockoptTimeval(fd, level, opt int, tv *Timeval) error { panic("SetsockoptTimeval") } |
| func Socketpair(domain, typ, proto int) (fd [2]int, err error) { panic("Socketpair") } |
| |
| func SetNonblock(fd int, nonblocking bool) error { return nil } |
