Fix "PR c++/92804 ICE trying to use concept as a nested-name-specifier"
[official-gcc.git] / libgo / go / net / fd_unix.go
blob117f5a994fed77fde6c479210f41712f6c30b1d3
1 // Copyright 2009 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.
5 // +build aix darwin dragonfly freebsd hurd linux netbsd openbsd solaris
7 package net
9 import (
10 "context"
11 "internal/poll"
12 "os"
13 "runtime"
14 "syscall"
15 "time"
18 // Network file descriptor.
19 type netFD struct {
20 pfd poll.FD
22 // immutable until Close
23 family int
24 sotype int
25 isConnected bool // handshake completed or use of association with peer
26 net string
27 laddr Addr
28 raddr Addr
31 func newFD(sysfd, family, sotype int, net string) (*netFD, error) {
32 ret := &netFD{
33 pfd: poll.FD{
34 Sysfd: sysfd,
35 IsStream: sotype == syscall.SOCK_STREAM,
36 ZeroReadIsEOF: sotype != syscall.SOCK_DGRAM && sotype != syscall.SOCK_RAW,
38 family: family,
39 sotype: sotype,
40 net: net,
42 return ret, nil
45 func (fd *netFD) init() error {
46 return fd.pfd.Init(fd.net, true)
49 func (fd *netFD) setAddr(laddr, raddr Addr) {
50 fd.laddr = laddr
51 fd.raddr = raddr
52 runtime.SetFinalizer(fd, (*netFD).Close)
55 func (fd *netFD) name() string {
56 var ls, rs string
57 if fd.laddr != nil {
58 ls = fd.laddr.String()
60 if fd.raddr != nil {
61 rs = fd.raddr.String()
63 return fd.net + ":" + ls + "->" + rs
66 func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa syscall.Sockaddr, ret error) {
67 // Do not need to call fd.writeLock here,
68 // because fd is not yet accessible to user,
69 // so no concurrent operations are possible.
70 switch err := connectFunc(fd.pfd.Sysfd, ra); err {
71 case syscall.EINPROGRESS, syscall.EALREADY, syscall.EINTR:
72 case nil, syscall.EISCONN:
73 select {
74 case <-ctx.Done():
75 return nil, mapErr(ctx.Err())
76 default:
78 if err := fd.pfd.Init(fd.net, true); err != nil {
79 return nil, err
81 runtime.KeepAlive(fd)
82 return nil, nil
83 case syscall.EINVAL:
84 // On Solaris and illumos we can see EINVAL if the socket has
85 // already been accepted and closed by the server. Treat this
86 // as a successful connection--writes to the socket will see
87 // EOF. For details and a test case in C see
88 // https://golang.org/issue/6828.
89 if runtime.GOOS == "solaris" || runtime.GOOS == "illumos" {
90 return nil, nil
92 fallthrough
93 default:
94 return nil, os.NewSyscallError("connect", err)
96 if err := fd.pfd.Init(fd.net, true); err != nil {
97 return nil, err
99 if deadline, hasDeadline := ctx.Deadline(); hasDeadline {
100 fd.pfd.SetWriteDeadline(deadline)
101 defer fd.pfd.SetWriteDeadline(noDeadline)
104 // Start the "interrupter" goroutine, if this context might be canceled.
105 // (The background context cannot)
107 // The interrupter goroutine waits for the context to be done and
108 // interrupts the dial (by altering the fd's write deadline, which
109 // wakes up waitWrite).
110 if ctx != context.Background() {
111 // Wait for the interrupter goroutine to exit before returning
112 // from connect.
113 done := make(chan struct{})
114 interruptRes := make(chan error)
115 defer func() {
116 close(done)
117 if ctxErr := <-interruptRes; ctxErr != nil && ret == nil {
118 // The interrupter goroutine called SetWriteDeadline,
119 // but the connect code below had returned from
120 // waitWrite already and did a successful connect (ret
121 // == nil). Because we've now poisoned the connection
122 // by making it unwritable, don't return a successful
123 // dial. This was issue 16523.
124 ret = mapErr(ctxErr)
125 fd.Close() // prevent a leak
128 go func() {
129 select {
130 case <-ctx.Done():
131 // Force the runtime's poller to immediately give up
132 // waiting for writability, unblocking waitWrite
133 // below.
134 fd.pfd.SetWriteDeadline(aLongTimeAgo)
135 testHookCanceledDial()
136 interruptRes <- ctx.Err()
137 case <-done:
138 interruptRes <- nil
143 for {
144 // Performing multiple connect system calls on a
145 // non-blocking socket under Unix variants does not
146 // necessarily result in earlier errors being
147 // returned. Instead, once runtime-integrated network
148 // poller tells us that the socket is ready, get the
149 // SO_ERROR socket option to see if the connection
150 // succeeded or failed. See issue 7474 for further
151 // details.
152 if err := fd.pfd.WaitWrite(); err != nil {
153 select {
154 case <-ctx.Done():
155 return nil, mapErr(ctx.Err())
156 default:
158 return nil, err
160 nerr, err := getsockoptIntFunc(fd.pfd.Sysfd, syscall.SOL_SOCKET, syscall.SO_ERROR)
161 if err != nil {
162 return nil, os.NewSyscallError("getsockopt", err)
164 switch err := syscall.Errno(nerr); err {
165 case syscall.EINPROGRESS, syscall.EALREADY, syscall.EINTR:
166 case syscall.EISCONN:
167 return nil, nil
168 case syscall.Errno(0):
169 // The runtime poller can wake us up spuriously;
170 // see issues 14548 and 19289. Check that we are
171 // really connected; if not, wait again.
172 if rsa, err := syscall.Getpeername(fd.pfd.Sysfd); err == nil {
173 return rsa, nil
175 default:
176 return nil, os.NewSyscallError("connect", err)
178 runtime.KeepAlive(fd)
182 func (fd *netFD) Close() error {
183 runtime.SetFinalizer(fd, nil)
184 return fd.pfd.Close()
187 func (fd *netFD) shutdown(how int) error {
188 err := fd.pfd.Shutdown(how)
189 runtime.KeepAlive(fd)
190 return wrapSyscallError("shutdown", err)
193 func (fd *netFD) closeRead() error {
194 return fd.shutdown(syscall.SHUT_RD)
197 func (fd *netFD) closeWrite() error {
198 return fd.shutdown(syscall.SHUT_WR)
201 func (fd *netFD) Read(p []byte) (n int, err error) {
202 n, err = fd.pfd.Read(p)
203 runtime.KeepAlive(fd)
204 return n, wrapSyscallError("read", err)
207 func (fd *netFD) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
208 n, sa, err = fd.pfd.ReadFrom(p)
209 runtime.KeepAlive(fd)
210 return n, sa, wrapSyscallError("recvfrom", err)
213 func (fd *netFD) readMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.Sockaddr, err error) {
214 n, oobn, flags, sa, err = fd.pfd.ReadMsg(p, oob)
215 runtime.KeepAlive(fd)
216 return n, oobn, flags, sa, wrapSyscallError("recvmsg", err)
219 func (fd *netFD) Write(p []byte) (nn int, err error) {
220 nn, err = fd.pfd.Write(p)
221 runtime.KeepAlive(fd)
222 return nn, wrapSyscallError("write", err)
225 func (fd *netFD) writeTo(p []byte, sa syscall.Sockaddr) (n int, err error) {
226 n, err = fd.pfd.WriteTo(p, sa)
227 runtime.KeepAlive(fd)
228 return n, wrapSyscallError("sendto", err)
231 func (fd *netFD) writeMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oobn int, err error) {
232 n, oobn, err = fd.pfd.WriteMsg(p, oob, sa)
233 runtime.KeepAlive(fd)
234 return n, oobn, wrapSyscallError("sendmsg", err)
237 func (fd *netFD) accept() (netfd *netFD, err error) {
238 d, rsa, errcall, err := fd.pfd.Accept()
239 if err != nil {
240 if errcall != "" {
241 err = wrapSyscallError(errcall, err)
243 return nil, err
246 if netfd, err = newFD(d, fd.family, fd.sotype, fd.net); err != nil {
247 poll.CloseFunc(d)
248 return nil, err
250 if err = netfd.init(); err != nil {
251 netfd.Close()
252 return nil, err
254 lsa, _ := syscall.Getsockname(netfd.pfd.Sysfd)
255 netfd.setAddr(netfd.addrFunc()(lsa), netfd.addrFunc()(rsa))
256 return netfd, nil
259 func (fd *netFD) dup() (f *os.File, err error) {
260 ns, call, err := fd.pfd.Dup()
261 if err != nil {
262 if call != "" {
263 err = os.NewSyscallError(call, err)
265 return nil, err
268 return os.NewFile(uintptr(ns), fd.name()), nil
271 func (fd *netFD) SetDeadline(t time.Time) error {
272 return fd.pfd.SetDeadline(t)
275 func (fd *netFD) SetReadDeadline(t time.Time) error {
276 return fd.pfd.SetReadDeadline(t)
279 func (fd *netFD) SetWriteDeadline(t time.Time) error {
280 return fd.pfd.SetWriteDeadline(t)