1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
// Copyright 2009 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.
package net
import (
"io"
"os"
"syscall"
"time"
)
// Network file descritor.
type netFD struct {
proto, name, dir string
ctl, data *os.File
laddr, raddr Addr
}
var canCancelIO = true // used for testing current package
func sysInit() {
}
func dialTimeout(net, addr string, timeout time.Duration) (Conn, error) {
// On plan9, use the relatively inefficient
// goroutine-racing implementation.
return dialTimeoutRace(net, addr, timeout)
}
func newFD(proto, name string, ctl, data *os.File, laddr, raddr Addr) *netFD {
return &netFD{proto, name, "/net/" + proto + "/" + name, ctl, data, laddr, raddr}
}
func (fd *netFD) ok() bool { return fd != nil && fd.ctl != nil }
func (fd *netFD) Read(b []byte) (n int, err error) {
if !fd.ok() || fd.data == nil {
return 0, syscall.EINVAL
}
n, err = fd.data.Read(b)
if fd.proto == "udp" && err == io.EOF {
n = 0
err = nil
}
return
}
func (fd *netFD) Write(b []byte) (n int, err error) {
if !fd.ok() || fd.data == nil {
return 0, syscall.EINVAL
}
return fd.data.Write(b)
}
func (fd *netFD) CloseRead() error {
if !fd.ok() {
return syscall.EINVAL
}
return syscall.EPLAN9
}
func (fd *netFD) CloseWrite() error {
if !fd.ok() {
return syscall.EINVAL
}
return syscall.EPLAN9
}
func (fd *netFD) Close() error {
if !fd.ok() {
return syscall.EINVAL
}
err := fd.ctl.Close()
if fd.data != nil {
if err1 := fd.data.Close(); err1 != nil && err == nil {
err = err1
}
}
fd.ctl = nil
fd.data = nil
return err
}
// This method is only called via Conn.
func (fd *netFD) dup() (*os.File, error) {
if !fd.ok() || fd.data == nil {
return nil, syscall.EINVAL
}
return fd.file(fd.data, fd.dir+"/data")
}
func (l *TCPListener) dup() (*os.File, error) {
if !l.fd.ok() {
return nil, syscall.EINVAL
}
return l.fd.file(l.fd.ctl, l.fd.dir+"/ctl")
}
func (fd *netFD) file(f *os.File, s string) (*os.File, error) {
syscall.ForkLock.RLock()
dfd, err := syscall.Dup(int(f.Fd()), -1)
syscall.ForkLock.RUnlock()
if err != nil {
return nil, &OpError{"dup", s, fd.laddr, err}
}
return os.NewFile(uintptr(dfd), s), nil
}
func setDeadline(fd *netFD, t time.Time) error {
return syscall.EPLAN9
}
func setReadDeadline(fd *netFD, t time.Time) error {
return syscall.EPLAN9
}
func setWriteDeadline(fd *netFD, t time.Time) error {
return syscall.EPLAN9
}
func setReadBuffer(fd *netFD, bytes int) error {
return syscall.EPLAN9
}
func setWriteBuffer(fd *netFD, bytes int) error {
return syscall.EPLAN9
}
|
