runtime: correct facilities names in s390 CPU support
[gcc.git] / libgo / go / net / net_fake.go
1 // Copyright 2018 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 // Fake networking for js/wasm. It is intended to allow tests of other package to pass.
6
7 // +build js,wasm
8
9 package net
10
11 import (
12 "context"
13 "internal/poll"
14 "io"
15 "os"
16 "sync"
17 "syscall"
18 "time"
19 )
20
21 var listenersMu sync.Mutex
22 var listeners = make(map[string]*netFD)
23
24 var portCounterMu sync.Mutex
25 var portCounter = 0
26
27 func nextPort() int {
28 portCounterMu.Lock()
29 defer portCounterMu.Unlock()
30 portCounter++
31 return portCounter
32 }
33
34 // Network file descriptor.
35 type netFD struct {
36 r *bufferedPipe
37 w *bufferedPipe
38 incoming chan *netFD
39
40 closedMu sync.Mutex
41 closed bool
42
43 // immutable until Close
44 listener bool
45 family int
46 sotype int
47 net string
48 laddr Addr
49 raddr Addr
50
51 // unused
52 pfd poll.FD
53 isConnected bool // handshake completed or use of association with peer
54 }
55
56 // socket returns a network file descriptor that is ready for
57 // asynchronous I/O using the network poller.
58 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) {
59 fd := &netFD{family: family, sotype: sotype, net: net}
60
61 if laddr != nil && raddr == nil { // listener
62 l := laddr.(*TCPAddr)
63 fd.laddr = &TCPAddr{
64 IP: l.IP,
65 Port: nextPort(),
66 Zone: l.Zone,
67 }
68 fd.listener = true
69 fd.incoming = make(chan *netFD, 1024)
70 listenersMu.Lock()
71 listeners[fd.laddr.(*TCPAddr).String()] = fd
72 listenersMu.Unlock()
73 return fd, nil
74 }
75
76 fd.laddr = &TCPAddr{
77 IP: IPv4(127, 0, 0, 1),
78 Port: nextPort(),
79 }
80 fd.raddr = raddr
81 fd.r = newBufferedPipe(65536)
82 fd.w = newBufferedPipe(65536)
83
84 fd2 := &netFD{family: fd.family, sotype: sotype, net: net}
85 fd2.laddr = fd.raddr
86 fd2.raddr = fd.laddr
87 fd2.r = fd.w
88 fd2.w = fd.r
89 listenersMu.Lock()
90 l, ok := listeners[fd.raddr.(*TCPAddr).String()]
91 if !ok {
92 listenersMu.Unlock()
93 return nil, syscall.ECONNREFUSED
94 }
95 l.incoming <- fd2
96 listenersMu.Unlock()
97
98 return fd, nil
99 }
100
101 func (fd *netFD) Read(p []byte) (n int, err error) {
102 return fd.r.Read(p)
103 }
104
105 func (fd *netFD) Write(p []byte) (nn int, err error) {
106 return fd.w.Write(p)
107 }
108
109 func (fd *netFD) Close() error {
110 fd.closedMu.Lock()
111 if fd.closed {
112 fd.closedMu.Unlock()
113 return nil
114 }
115 fd.closed = true
116 fd.closedMu.Unlock()
117
118 if fd.listener {
119 listenersMu.Lock()
120 delete(listeners, fd.laddr.String())
121 close(fd.incoming)
122 fd.listener = false
123 listenersMu.Unlock()
124 return nil
125 }
126
127 fd.r.Close()
128 fd.w.Close()
129 return nil
130 }
131
132 func (fd *netFD) closeRead() error {
133 fd.r.Close()
134 return nil
135 }
136
137 func (fd *netFD) closeWrite() error {
138 fd.w.Close()
139 return nil
140 }
141
142 func (fd *netFD) accept() (*netFD, error) {
143 c, ok := <-fd.incoming
144 if !ok {
145 return nil, syscall.EINVAL
146 }
147 return c, nil
148 }
149
150 func (fd *netFD) SetDeadline(t time.Time) error {
151 fd.r.SetReadDeadline(t)
152 fd.w.SetWriteDeadline(t)
153 return nil
154 }
155
156 func (fd *netFD) SetReadDeadline(t time.Time) error {
157 fd.r.SetReadDeadline(t)
158 return nil
159 }
160
161 func (fd *netFD) SetWriteDeadline(t time.Time) error {
162 fd.w.SetWriteDeadline(t)
163 return nil
164 }
165
166 func newBufferedPipe(softLimit int) *bufferedPipe {
167 p := &bufferedPipe{softLimit: softLimit}
168 p.rCond.L = &p.mu
169 p.wCond.L = &p.mu
170 return p
171 }
172
173 type bufferedPipe struct {
174 softLimit int
175 mu sync.Mutex
176 buf []byte
177 closed bool
178 rCond sync.Cond
179 wCond sync.Cond
180 rDeadline time.Time
181 wDeadline time.Time
182 }
183
184 func (p *bufferedPipe) Read(b []byte) (int, error) {
185 p.mu.Lock()
186 defer p.mu.Unlock()
187
188 for {
189 if p.closed && len(p.buf) == 0 {
190 return 0, io.EOF
191 }
192 if !p.rDeadline.IsZero() {
193 d := time.Until(p.rDeadline)
194 if d <= 0 {
195 return 0, syscall.EAGAIN
196 }
197 time.AfterFunc(d, p.rCond.Broadcast)
198 }
199 if len(p.buf) > 0 {
200 break
201 }
202 p.rCond.Wait()
203 }
204
205 n := copy(b, p.buf)
206 p.buf = p.buf[n:]
207 p.wCond.Broadcast()
208 return n, nil
209 }
210
211 func (p *bufferedPipe) Write(b []byte) (int, error) {
212 p.mu.Lock()
213 defer p.mu.Unlock()
214
215 for {
216 if p.closed {
217 return 0, syscall.ENOTCONN
218 }
219 if !p.wDeadline.IsZero() {
220 d := time.Until(p.wDeadline)
221 if d <= 0 {
222 return 0, syscall.EAGAIN
223 }
224 time.AfterFunc(d, p.wCond.Broadcast)
225 }
226 if len(p.buf) <= p.softLimit {
227 break
228 }
229 p.wCond.Wait()
230 }
231
232 p.buf = append(p.buf, b...)
233 p.rCond.Broadcast()
234 return len(b), nil
235 }
236
237 func (p *bufferedPipe) Close() {
238 p.mu.Lock()
239 defer p.mu.Unlock()
240
241 p.closed = true
242 p.rCond.Broadcast()
243 p.wCond.Broadcast()
244 }
245
246 func (p *bufferedPipe) SetReadDeadline(t time.Time) {
247 p.mu.Lock()
248 defer p.mu.Unlock()
249
250 p.rDeadline = t
251 p.rCond.Broadcast()
252 }
253
254 func (p *bufferedPipe) SetWriteDeadline(t time.Time) {
255 p.mu.Lock()
256 defer p.mu.Unlock()
257
258 p.wDeadline = t
259 p.wCond.Broadcast()
260 }
261
262 func sysSocket(family, sotype, proto int) (int, error) {
263 return 0, syscall.ENOSYS
264 }
265
266 func (fd *netFD) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
267 return 0, nil, syscall.ENOSYS
268 }
269
270 func (fd *netFD) readMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.Sockaddr, err error) {
271 return 0, 0, 0, nil, syscall.ENOSYS
272 }
273
274 func (fd *netFD) writeTo(p []byte, sa syscall.Sockaddr) (n int, err error) {
275 return 0, syscall.ENOSYS
276 }
277
278 func (fd *netFD) writeMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oobn int, err error) {
279 return 0, 0, syscall.ENOSYS
280 }
281
282 func (fd *netFD) dup() (f *os.File, err error) {
283 return nil, syscall.ENOSYS
284 }