← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/pkg/net/sock_posix.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:
src/pkg/net/sock_posix.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
package net
 
8
 
 
9
import (
 
10
        "syscall"
 
11
        "time"
 
12
)
 
13
 
 
14
var listenerBacklog = maxListenerBacklog()
 
15
 
 
16
// Generic POSIX socket creation.
 
17
func socket(net string, f, t, p int, ipv6only bool, ulsa, ursa syscall.Sockaddr, deadline time.Time, toAddr func(syscall.Sockaddr) Addr) (fd *netFD, err error) {
 
18
        s, err := sysSocket(f, t, p)
 
19
        if err != nil {
 
20
                return nil, err
 
21
        }
 
22
 
 
23
        if err = setDefaultSockopts(s, f, t, ipv6only); err != nil {
 
24
                closesocket(s)
 
25
                return nil, err
 
26
        }
 
27
 
 
28
        // This socket is used by a listener.
 
29
        if ulsa != nil && ursa == nil {
 
30
                // We provide a socket that listens to a wildcard
 
31
                // address with reusable UDP port when the given ulsa
 
32
                // is an appropriate UDP multicast address prefix.
 
33
                // This makes it possible for a single UDP listener
 
34
                // to join multiple different group addresses, for
 
35
                // multiple UDP listeners that listen on the same UDP
 
36
                // port to join the same group address.
 
37
                if ulsa, err = listenerSockaddr(s, f, ulsa, toAddr); err != nil {
 
38
                        closesocket(s)
 
39
                        return nil, err
 
40
                }
 
41
        }
 
42
 
 
43
        if ulsa != nil {
 
44
                if err = syscall.Bind(s, ulsa); 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
        // This socket is used by a dialer.
 
56
        if ursa != nil {
 
57
                if !deadline.IsZero() {
 
58
                        setWriteDeadline(fd, deadline)
 
59
                }
 
60
                if err = fd.connect(ulsa, ursa); err != nil {
 
61
                        fd.Close()
 
62
                        return nil, err
 
63
                }
 
64
                fd.isConnected = true
 
65
                if !deadline.IsZero() {
 
66
                        setWriteDeadline(fd, time.Time{})
 
67
                }
 
68
        }
 
69
 
 
70
        lsa, _ := syscall.Getsockname(s)
 
71
        laddr := toAddr(lsa)
 
72
        rsa, _ := syscall.Getpeername(s)
 
73
        if rsa == nil {
 
74
                rsa = ursa
 
75
        }
 
76
        raddr := toAddr(rsa)
 
77
        fd.setAddr(laddr, raddr)
 
78
        return fd, nil
 
79
}