Your IP : 172.28.240.42
| Current Path : /usr/local/go/src/net/ |
|
|
| Current File : //usr/local/go/src/net/net_fake.go |
// 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 and wasip1/wasm. It is intended to allow tests of other package to pass.
//go:build (js && wasm) || wasip1
package net
import (
"context"
"io"
"os"
"sync"
"syscall"
"time"
)
var listenersMu sync.Mutex
var listeners = make(map[fakeNetAddr]*netFD)
var portCounterMu sync.Mutex
var portCounter = 0
func nextPort() int {
portCounterMu.Lock()
defer portCounterMu.Unlock()
portCounter++
return portCounter
}
type fakeNetAddr struct {
network string
address string
}
type fakeNetFD struct {
listener fakeNetAddr
r *bufferedPipe
w *bufferedPipe
incoming chan *netFD
closedMu sync.Mutex
closed bool
}
// 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, ctrlCtxFn func(context.Context, string, string, syscall.RawConn) error) (*netFD, error) {
fd := &netFD{family: family, sotype: sotype, net: net}
if laddr != nil && raddr == nil {
return fakelistener(fd, laddr)
}
fd2 := &netFD{family: family, sotype: sotype, net: net}
return fakeconn(fd, fd2, laddr, raddr)
}
func fakeIPAndPort(ip IP, port int) (IP, int) {
if ip == nil {
ip = IPv4(127, 0, 0, 1)
}
if port == 0 {
port = nextPort()
}
return ip, port
}
func fakeTCPAddr(addr *TCPAddr) *TCPAddr {
var ip IP
var port int
var zone string
if addr != nil {
ip, port, zone = addr.IP, addr.Port, addr.Zone
}
ip, port = fakeIPAndPort(ip, port)
return &TCPAddr{IP: ip, Port: port, Zone: zone}
}
func fakeUDPAddr(addr *UDPAddr) *UDPAddr {
var ip IP
var port int
var zone string
if addr != nil {
ip, port, zone = addr.IP, addr.Port, addr.Zone
}
ip, port = fakeIPAndPort(ip, port)
return &UDPAddr{IP: ip, Port: port, Zone: zone}
}
func fakeUnixAddr(sotype int, addr *UnixAddr) *UnixAddr {
var net, name string
if addr != nil {
name = addr.Name
}
switch sotype {
case syscall.SOCK_DGRAM:
net = "unixgram"
case syscall.SOCK_SEQPACKET:
net = "unixpacket"
default:
net = "unix"
}
return &UnixAddr{Net: net, Name: name}
}
func fakelistener(fd *netFD, laddr sockaddr) (*netFD, error) {
switch l := laddr.(type) {
case *TCPAddr:
laddr = fakeTCPAddr(l)
case *UDPAddr:
laddr = fakeUDPAddr(l)
case *UnixAddr:
if l.Name == "" {
return nil, syscall.ENOENT
}
laddr = fakeUnixAddr(fd.sotype, l)
default:
return nil, syscall.EOPNOTSUPP
}
listener := fakeNetAddr{
network: laddr.Network(),
address: laddr.String(),
}
fd.fakeNetFD = &fakeNetFD{
listener: listener,
incoming: make(chan *netFD, 1024),
}
fd.laddr = laddr
listenersMu.Lock()
defer listenersMu.Unlock()
if _, exists := listeners[listener]; exists {
return nil, syscall.EADDRINUSE
}
listeners[listener] = fd
return fd, nil
}
func fakeconn(fd *netFD, fd2 *netFD, laddr, raddr sockaddr) (*netFD, error) {
switch r := raddr.(type) {
case *TCPAddr:
r = fakeTCPAddr(r)
raddr = r
laddr = fakeTCPAddr(laddr.(*TCPAddr))
case *UDPAddr:
r = fakeUDPAddr(r)
raddr = r
laddr = fakeUDPAddr(laddr.(*UDPAddr))
case *UnixAddr:
r = fakeUnixAddr(fd.sotype, r)
raddr = r
laddr = &UnixAddr{Net: r.Net, Name: r.Name}
default:
return nil, syscall.EAFNOSUPPORT
}
fd.laddr = laddr
fd.raddr = raddr
fd.fakeNetFD = &fakeNetFD{
r: newBufferedPipe(65536),
w: newBufferedPipe(65536),
}
fd2.fakeNetFD = &fakeNetFD{
r: fd.fakeNetFD.w,
w: fd.fakeNetFD.r,
}
fd2.laddr = fd.raddr
fd2.raddr = fd.laddr
listener := fakeNetAddr{
network: fd.raddr.Network(),
address: fd.raddr.String(),
}
listenersMu.Lock()
defer listenersMu.Unlock()
l, ok := listeners[listener]
if !ok {
return nil, syscall.ECONNREFUSED
}
l.incoming <- fd2
return fd, nil
}
func (fd *fakeNetFD) Read(p []byte) (n int, err error) {
return fd.r.Read(p)
}
func (fd *fakeNetFD) Write(p []byte) (nn int, err error) {
return fd.w.Write(p)
}
func (fd *fakeNetFD) Close() error {
fd.closedMu.Lock()
if fd.closed {
fd.closedMu.Unlock()
return nil
}
fd.closed = true
fd.closedMu.Unlock()
if fd.listener != (fakeNetAddr{}) {
listenersMu.Lock()
delete(listeners, fd.listener)
close(fd.incoming)
fd.listener = fakeNetAddr{}
listenersMu.Unlock()
return nil
}
fd.r.Close()
fd.w.Close()
return nil
}
func (fd *fakeNetFD) closeRead() error {
fd.r.Close()
return nil
}
func (fd *fakeNetFD) closeWrite() error {
fd.w.Close()
return nil
}
func (fd *fakeNetFD) accept() (*netFD, error) {
c, ok := <-fd.incoming
if !ok {
return nil, syscall.EINVAL
}
return c, nil
}
func (fd *fakeNetFD) SetDeadline(t time.Time) error {
fd.r.SetReadDeadline(t)
fd.w.SetWriteDeadline(t)
return nil
}
func (fd *fakeNetFD) SetReadDeadline(t time.Time) error {
fd.r.SetReadDeadline(t)
return nil
}
func (fd *fakeNetFD) 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, os.ErrDeadlineExceeded
}
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, os.ErrDeadlineExceeded
}
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 *fakeNetFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (syscall.Sockaddr, error) {
return nil, syscall.ENOSYS
}
func (fd *fakeNetFD) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
return 0, nil, syscall.ENOSYS
}
func (fd *fakeNetFD) readFromInet4(p []byte, sa *syscall.SockaddrInet4) (n int, err error) {
return 0, syscall.ENOSYS
}
func (fd *fakeNetFD) readFromInet6(p []byte, sa *syscall.SockaddrInet6) (n int, err error) {
return 0, syscall.ENOSYS
}
func (fd *fakeNetFD) readMsg(p []byte, oob []byte, flags int) (n, oobn, retflags int, sa syscall.Sockaddr, err error) {
return 0, 0, 0, nil, syscall.ENOSYS
}
func (fd *fakeNetFD) readMsgInet4(p []byte, oob []byte, flags int, sa *syscall.SockaddrInet4) (n, oobn, retflags int, err error) {
return 0, 0, 0, syscall.ENOSYS
}
func (fd *fakeNetFD) readMsgInet6(p []byte, oob []byte, flags int, sa *syscall.SockaddrInet6) (n, oobn, retflags int, err error) {
return 0, 0, 0, syscall.ENOSYS
}
func (fd *fakeNetFD) writeMsgInet4(p []byte, oob []byte, sa *syscall.SockaddrInet4) (n int, oobn int, err error) {
return 0, 0, syscall.ENOSYS
}
func (fd *fakeNetFD) writeMsgInet6(p []byte, oob []byte, sa *syscall.SockaddrInet6) (n int, oobn int, err error) {
return 0, 0, syscall.ENOSYS
}
func (fd *fakeNetFD) writeTo(p []byte, sa syscall.Sockaddr) (n int, err error) {
return 0, syscall.ENOSYS
}
func (fd *fakeNetFD) writeToInet4(p []byte, sa *syscall.SockaddrInet4) (n int, err error) {
return 0, syscall.ENOSYS
}
func (fd *fakeNetFD) writeToInet6(p []byte, sa *syscall.SockaddrInet6) (n int, err error) {
return 0, syscall.ENOSYS
}
func (fd *fakeNetFD) writeMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oobn int, err error) {
return 0, 0, syscall.ENOSYS
}
func (fd *fakeNetFD) dup() (f *os.File, err error) {
return nil, syscall.ENOSYS
}