Source file src/net/net_fake.go
1
2
3
4
5
6
7
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
35 type netFD struct {
36 r *bufferedPipe
37 w *bufferedPipe
38 incoming chan *netFD
39
40 closedMu sync.Mutex
41 closed bool
42
43
44 listener bool
45 family int
46 sotype int
47 net string
48 laddr Addr
49 raddr Addr
50
51
52 pfd poll.FD
53 isConnected bool
54 }
55
56
57
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 {
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 }
285
View as plain text