← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/pkg/net/fd_unix.go

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-11-18 15:12:26 UTC
  • mfrom: (14.2.12 vivid-proposed)
  • Revision ID: package-import@ubuntu.com-20141118151226-zug7vn93mn3dtiz3
Tags: 2:1.3.2-1ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - Support co-installability with gccgo-go tool:
    - d/rules,golang-go.install: Rename bin/go -> bin/golang-go
    - d/golang-go.{postinst,prerm}: Install/remove /usr/bin/go using
      alternatives.
  - d/copyright: Amendments for full compiliance with copyright format.
  - d/control: Demote golang-go.tools to Suggests to support Ubuntu MIR.
  - dropped patches (now upstream):
    - d/p/issue27650045_40001_50001.diff
    - d/p/issue28050043_60001_70001.diff
    - d/p/issue54790044_100001_110001.diff

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/net/fd_unix.go
2
2
// Use of this source code is governed by a BSD-style
3
3
// license that can be found in the LICENSE file.
4
4
 
5
 
// +build darwin dragonfly freebsd linux netbsd openbsd
 
5
// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris
6
6
 
7
7
package net
8
8
 
68
68
        return fd.net + ":" + ls + "->" + rs
69
69
}
70
70
 
71
 
func (fd *netFD) connect(la, ra syscall.Sockaddr) error {
 
71
func (fd *netFD) connect(la, ra syscall.Sockaddr, deadline time.Time) error {
72
72
        // Do not need to call fd.writeLock here,
73
73
        // because fd is not yet accessible to user,
74
74
        // so no concurrent operations are possible.
75
 
        if err := fd.pd.PrepareWrite(); err != nil {
76
 
                return err
 
75
        switch err := syscall.Connect(fd.sysfd, ra); err {
 
76
        case syscall.EINPROGRESS, syscall.EALREADY, syscall.EINTR:
 
77
        case nil, syscall.EISCONN:
 
78
                if !deadline.IsZero() && deadline.Before(time.Now()) {
 
79
                        return errTimeout
 
80
                }
 
81
                if err := fd.init(); err != nil {
 
82
                        return err
 
83
                }
 
84
                return nil
 
85
        case syscall.EINVAL:
 
86
                // On Solaris we can see EINVAL if the socket has
 
87
                // already been accepted and closed by the server.
 
88
                // Treat this as a successful connection--writes to
 
89
                // the socket will see EOF.  For details and a test
 
90
                // case in C see http://golang.org/issue/6828.
 
91
                if runtime.GOOS == "solaris" {
 
92
                        return nil
 
93
                }
 
94
                fallthrough
 
95
        default:
 
96
                return err
 
97
        }
 
98
        if err := fd.init(); err != nil {
 
99
                return err
 
100
        }
 
101
        if !deadline.IsZero() {
 
102
                fd.setWriteDeadline(deadline)
 
103
                defer fd.setWriteDeadline(noDeadline)
77
104
        }
78
105
        for {
79
 
                err := syscall.Connect(fd.sysfd, ra)
80
 
                if err == nil || err == syscall.EISCONN {
81
 
                        break
82
 
                }
83
 
                if err != syscall.EINPROGRESS && err != syscall.EALREADY && err != syscall.EINTR {
84
 
                        return err
85
 
                }
86
 
                if err = fd.pd.WaitWrite(); err != nil {
 
106
                // Performing multiple connect system calls on a
 
107
                // non-blocking socket under Unix variants does not
 
108
                // necessarily result in earlier errors being
 
109
                // returned. Instead, once runtime-integrated network
 
110
                // poller tells us that the socket is ready, get the
 
111
                // SO_ERROR socket option to see if the connection
 
112
                // succeeded or failed. See issue 7474 for further
 
113
                // details.
 
114
                if err := fd.pd.WaitWrite(); err != nil {
 
115
                        return err
 
116
                }
 
117
                nerr, err := syscall.GetsockoptInt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_ERROR)
 
118
                if err != nil {
 
119
                        return err
 
120
                }
 
121
                switch err := syscall.Errno(nerr); err {
 
122
                case syscall.EINPROGRESS, syscall.EALREADY, syscall.EINTR:
 
123
                case syscall.Errno(0), syscall.EISCONN:
 
124
                        return nil
 
125
                default:
87
126
                        return err
88
127
                }
89
128
        }
90
 
        return nil
91
129
}
92
130
 
93
131
func (fd *netFD) destroy() {
180
218
        return nil
181
219
}
182
220
 
183
 
func (fd *netFD) CloseRead() error {
 
221
func (fd *netFD) closeRead() error {
184
222
        return fd.shutdown(syscall.SHUT_RD)
185
223
}
186
224
 
187
 
func (fd *netFD) CloseWrite() error {
 
225
func (fd *netFD) closeWrite() error {
188
226
        return fd.shutdown(syscall.SHUT_WR)
189
227
}
190
228
 
215
253
        return
216
254
}
217
255
 
218
 
func (fd *netFD) ReadFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
 
256
func (fd *netFD) readFrom(p []byte) (n int, sa syscall.Sockaddr, err error) {
219
257
        if err := fd.readLock(); err != nil {
220
258
                return 0, nil, err
221
259
        }
242
280
        return
243
281
}
244
282
 
245
 
func (fd *netFD) ReadMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.Sockaddr, err error) {
 
283
func (fd *netFD) readMsg(p []byte, oob []byte) (n, oobn, flags int, sa syscall.Sockaddr, err error) {
246
284
        if err := fd.readLock(); err != nil {
247
285
                return 0, 0, 0, nil, err
248
286
        }
313
351
        return nn, err
314
352
}
315
353
 
316
 
func (fd *netFD) WriteTo(p []byte, sa syscall.Sockaddr) (n int, err error) {
 
354
func (fd *netFD) writeTo(p []byte, sa syscall.Sockaddr) (n int, err error) {
317
355
        if err := fd.writeLock(); err != nil {
318
356
                return 0, err
319
357
        }
338
376
        return
339
377
}
340
378
 
341
 
func (fd *netFD) WriteMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oobn int, err error) {
 
379
func (fd *netFD) writeMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oobn int, err error) {
342
380
        if err := fd.writeLock(); err != nil {
343
381
                return 0, 0, err
344
382
        }
347
385
                return 0, 0, &OpError{"write", fd.net, fd.raddr, err}
348
386
        }
349
387
        for {
350
 
                err = syscall.Sendmsg(fd.sysfd, p, oob, sa, 0)
 
388
                n, err = syscall.SendmsgN(fd.sysfd, p, oob, sa, 0)
351
389
                if err == syscall.EAGAIN {
352
390
                        if err = fd.pd.WaitWrite(); err == nil {
353
391
                                continue
356
394
                break
357
395
        }
358
396
        if err == nil {
359
 
                n = len(p)
360
397
                oobn = len(oob)
361
398
        } else {
362
399
                err = &OpError{"write", fd.net, fd.raddr, err}
455
492
func (fd *netFD) dup() (f *os.File, err error) {
456
493
        ns, err := dupCloseOnExec(fd.sysfd)
457
494
        if err != nil {
458
 
                syscall.ForkLock.RUnlock()
459
495
                return nil, &OpError{"dup", fd.net, fd.laddr, err}
460
496
        }
461
497