blob: 0c48dd5c03bb47ead18b5571a1c635865ca83dd4 [file] [log] [blame]
// Copyright 2018 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.
// Fake networking for js/wasm. It is intended to allow tests of other package to pass.
// +build js,wasm
package net
import (
"context"
"internal/poll"
"io"
"os"
"sync"
"syscall"
"time"
)
var listenersMu sync.Mutex
var listeners = make(map[string]*netFD)
var portCounterMu sync.Mutex
var portCounter = 0
func nextPort() int {
portCounterMu.Lock()
defer portCounterMu.Unlock()
portCounter++
return portCounter
}
// Network file descriptor.
type netFD struct {
r *bufferedPipe
w *bufferedPipe
incoming chan *netFD
closedMu sync.Mutex
closed bool
// immutable until Close
listener bool
family int
sotype int
net string
laddr Addr
raddr Addr
// unused
pfd poll.FD
isConnected bool // handshake completed or use of association with peer
}
// socket returns a network file descriptor that is ready for
// asynchronous I/O using the network poller.
func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) (*netFD, error) {
fd := &netFD{family: family, sotype: sotype, net: net}
if laddr != nil && raddr == nil { // listener
l := laddr.(*TCPAddr)
fd.laddr = &TCPAddr{
IP: l.IP,
Port: nextPort(),
Zone: l.Zone,
}
fd.listener = true
fd.incoming = make(chan *netFD, 1024)
listenersMu.Lock()
listeners[fd.laddr.(*TCPAddr).String()] = fd
listenersMu.Unlock()
return fd, nil
}
fd.laddr = &TCPAddr{
IP: IPv4(127, 0, 0, 1),
Port: nextPort(),
}
fd.raddr = raddr
fd.r = newBufferedPipe(65536)
fd.w = newBufferedPipe(65536)
fd2 := &netFD{family: fd.family, sotype: sotype, net: net}
fd2.laddr = fd.raddr
fd2.raddr = fd.laddr
fd2.r = fd.w
fd2.w = fd.r
listenersMu.Lock()
l, ok := listeners[fd.raddr.(*TCPAddr).String()]
if !ok {
listenersMu.Unlock()
return nil, syscall.ECONNREFUSED
}
l.incoming <- fd2
listenersMu.Unlock()
return fd, nil
}
func (fd *netFD) Read(p []byte) (n int, err error) {
return fd.r.Read(p)
}
func (fd *netFD) Write(p []byte) (nn int, err error) {
return fd.w.Write(p)
}
func (fd *netFD) Close() error {
fd.closedMu.Lock()
if fd.closed {
fd.closedMu.Unlock()
return nil
}
fd.closed = true
fd.closedMu.Unlock()
if fd.listener {
listenersMu.Lock()
delete(listeners, fd.laddr.String())
close(fd.incoming)
fd.listener = false
listenersMu.Unlock()
return nil
}
fd.r.Close()
fd.w.Close()
return nil
}
func (fd *netFD) closeRead() error {
fd.r.Close()
return nil
}
func (fd *netFD) closeWrite() error {
fd.w.Close()
return nil
}
func (fd *netFD) accept() (*netFD, error) {
c, ok := <-fd.incoming
if !ok {
return nil, syscall.EINVAL
}
return c, nil
}
func (fd *netFD) SetDeadline(t time.Time) error {
fd.r.SetReadDeadline(t)
fd.w.SetWriteDeadline(t)
return nil
}
func (fd *netFD) SetReadDeadline(t time.Time) error {
fd.r.SetReadDeadline(t)
return nil
}
func (fd *netFD) SetWriteDeadline(t time.Time) error {
fd.w.SetWriteDeadline(t)
return nil
}
func newBufferedPipe(softLimit int) *bufferedPipe {
p := &bufferedPipe{softLimit: softLimit}
p.rCond.L = &p.mu
p.wCond.L = &p.mu
return p
}
type bufferedPipe struct {
softLimit int
mu sync.Mutex
buf []byte
closed bool
rCond sync.Cond
wCond sync.Cond
rDeadline time.Time
wDeadline time.Time
}
func (p *bufferedPipe) Read(b []byte) (int, error) {
p.mu.Lock()
defer p.mu.Unlock()
for {
if p.closed && len(p.buf) == 0 {
return 0, io.EOF
}
if !p.rDeadline.IsZero() {
d := time.Until(p.rDeadline)
if d <= 0 {
return 0, syscall.EAGAIN
}
time.AfterFunc(d, p.rCond.Broadcast)
}
if len(p.buf) > 0 {
break
}
p.rCond.Wait()
}
n := copy(b, p.buf)
p.buf = p.buf[n:]
p.wCond.Broadcast()
return n, nil
}
func (p *bufferedPipe) Write(b []byte) (int, error) {
p.mu.Lock()
defer p.mu.Unlock()
for {
if p.closed {
return 0, syscall.ENOTCONN
}
if !p.wDeadline.IsZero() {
d := time.Until(p.wDeadline)
if d <= 0 {
return 0, syscall.EAGAIN
}
time.AfterFunc(d, p.wCond.Broadcast)
}
if len(p.buf) <= p.softLimit {
break
}
p.wCond.Wait()
}
p.buf = append(p.buf, b...)
p.rCond.Broadcast()
return len(b), nil
}
func (p *bufferedPipe) Close() {
p.mu.Lock()
defer p.mu.Unlock()
p.closed = true
p.rCond.Broadcast()
p.wCond.Broadcast()
}
func (p *bufferedPipe) SetReadDeadline(t time.Time) {
p.mu.Lock()
defer p.mu.Unlock()
p.rDeadline = t
p.rCond.Broadcast()
}
func (p *bufferedPipe) SetWriteDeadline(t time.Time) {
p.mu.Lock()
defer p.mu.Unlock()
p.wDeadline = t
p.wCond.Broadcast()
}
func sysSocket(family, sotype, proto int) (int, error) {
return 0, syscall.ENOSYS
}
func (fd *netFD) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
return 0, nil, syscall.ENOSYS
}
func (fd *netFD) readMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.Sockaddr, err error) {
return 0, 0, 0, nil, syscall.ENOSYS
}
func (fd *netFD) writeTo(p []byte, sa syscall.Sockaddr) (n int, err error) {
return 0, syscall.ENOSYS
}
func (fd *netFD) writeMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oobn int, err error) {
return 0, 0, syscall.ENOSYS
}
func (fd *netFD) dup() (f *os.File, err error) {
return nil, syscall.ENOSYS
}