summaryrefslogtreecommitdiff
path: root/src/pkg/syscall/net_nacl.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/syscall/net_nacl.go')
-rw-r--r--src/pkg/syscall/net_nacl.go913
1 files changed, 0 insertions, 913 deletions
diff --git a/src/pkg/syscall/net_nacl.go b/src/pkg/syscall/net_nacl.go
deleted file mode 100644
index b5cb53030..000000000
--- a/src/pkg/syscall/net_nacl.go
+++ /dev/null
@@ -1,913 +0,0 @@
-// 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.
-
-package syscall
-
-import (
- "sync"
- "sync/atomic"
-)
-
-// Interface to timers implemented in package runtime.
-// Must be in sync with ../runtime/runtime.h:/^struct.Timer$
-// Really for use by package time, but we cannot import time here.
-
-type runtimeTimer struct {
- 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() {
- stopTimer(&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 }
-
-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
- 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)
- for q.w-q.r == 0 && !q.closed && !t.expired {
- q.canRead.Wait()
- }
- 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)
- for q.w-q.r > q.m && !q.closed && !t.expired {
- q.canWrite.Wait()
- }
- 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
- }
- _, ok := net.listener[netAddr{f.proto, f.sotype, f.addr.key()}]
- if ok {
- 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 {
- 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) 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)
- 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)
- 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 }
View Lorry Controller Status