← Back to branch summary

~ubuntu-branches/ubuntu/utopic/golang/utopic

« back to all changes in this revision

Viewing changes to .pc/001-allow_IPv4_on_IPv6_sockets.patch/src/pkg/net/sock.go

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/001-allow_IPv4_on_IPv6_sockets.patch/src/pkg/net/sock.go
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.
4
 
 
5
 
// +build darwin freebsd linux netbsd openbsd windows
6
 
 
7
 
// Sockets
8
 
 
9
 
package net
10
 
 
11
 
import (
12
 
        "io"
13
 
        "syscall"
14
 
)
15
 
 
16
 
var listenerBacklog = maxListenerBacklog()
17
 
 
18
 
// Generic socket creation.
19
 
func socket(net string, f, t, p int, ipv6only bool, la, ra syscall.Sockaddr, toAddr func(syscall.Sockaddr) Addr) (fd *netFD, err error) {
20
 
        // See ../syscall/exec.go for description of ForkLock.
21
 
        syscall.ForkLock.RLock()
22
 
        s, err := syscall.Socket(f, t, p)
23
 
        if err != nil {
24
 
                syscall.ForkLock.RUnlock()
25
 
                return nil, err
26
 
        }
27
 
        syscall.CloseOnExec(s)
28
 
        syscall.ForkLock.RUnlock()
29
 
 
30
 
        err = setDefaultSockopts(s, f, t, ipv6only)
31
 
        if err != nil {
32
 
                closesocket(s)
33
 
                return nil, err
34
 
        }
35
 
 
36
 
        var bla syscall.Sockaddr
37
 
        if la != nil {
38
 
                bla, err = listenerSockaddr(s, f, la, toAddr)
39
 
                if err != nil {
40
 
                        closesocket(s)
41
 
                        return nil, err
42
 
                }
43
 
                err = syscall.Bind(s, bla)
44
 
                if err != nil {
45
 
                        closesocket(s)
46
 
                        return nil, err
47
 
                }
48
 
        }
49
 
 
50
 
        if fd, err = newFD(s, f, t, net); err != nil {
51
 
                closesocket(s)
52
 
                return nil, err
53
 
        }
54
 
 
55
 
        if ra != nil {
56
 
                if err = fd.connect(ra); err != nil {
57
 
                        closesocket(s)
58
 
                        fd.Close()
59
 
                        return nil, err
60
 
                }
61
 
                fd.isConnected = true
62
 
        }
63
 
 
64
 
        sa, _ := syscall.Getsockname(s)
65
 
        var laddr Addr
66
 
        if la != nil && bla != la {
67
 
                laddr = toAddr(la)
68
 
        } else {
69
 
                laddr = toAddr(sa)
70
 
        }
71
 
        sa, _ = syscall.Getpeername(s)
72
 
        raddr := toAddr(sa)
73
 
 
74
 
        fd.setAddr(laddr, raddr)
75
 
        return fd, nil
76
 
}
77
 
 
78
 
type writerOnly struct {
79
 
        io.Writer
80
 
}
81
 
 
82
 
// Fallback implementation of io.ReaderFrom's ReadFrom, when sendfile isn't
83
 
// applicable.
84
 
func genericReadFrom(w io.Writer, r io.Reader) (n int64, err error) {
85
 
        // Use wrapper to hide existing r.ReadFrom from io.Copy.
86
 
        return io.Copy(writerOnly{w}, r)
87
 
}