2009-11-01 12:15:34 -07:00
|
|
|
// 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.
|
|
|
|
|
all: merge NaCl branch (part 1)
See golang.org/s/go13nacl for design overview.
This CL is the mostly mechanical changes from rsc's Go 1.2 based NaCl branch, specifically 39cb35750369 to 500771b477cf from https://code.google.com/r/rsc-go13nacl. This CL does not include working NaCl support, there are probably two or three more large merges to come.
CL 15750044 is not included as it involves more invasive changes to the linker which will need to be merged separately.
The exact change lists included are
15050047: syscall: support for Native Client
15360044: syscall: unzip implementation for Native Client
15370044: syscall: Native Client SRPC implementation
15400047: cmd/dist, cmd/go, go/build, test: support for Native Client
15410048: runtime: support for Native Client
15410049: syscall: file descriptor table for Native Client
15410050: syscall: in-memory file system for Native Client
15440048: all: update +build lines for Native Client port
15540045: cmd/6g, cmd/8g, cmd/gc: support for Native Client
15570045: os: support for Native Client
15680044: crypto/..., hash/crc32, reflect, sync/atomic: support for amd64p32
15690044: net: support for Native Client
15690048: runtime: support for fake time like on Go Playground
15690051: build: disable various tests on Native Client
LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/68150047
2014-02-25 07:47:42 -07:00
|
|
|
// +build darwin dragonfly freebsd linux nacl netbsd openbsd solaris windows
|
build: add build comments to core packages
The go/build package already recognizes
system-specific file names like
mycode_darwin.go
mycode_darwin_386.go
mycode_386.s
However, it is also common to write files that
apply to multiple architectures, so a recent CL added
to go/build the ability to process comments
listing a set of conditions for building. For example:
// +build darwin freebsd openbsd/386
says that this file should be compiled only on
OS X, FreeBSD, or 32-bit x86 OpenBSD systems.
These conventions are not yet documented
(hence this long CL description).
This CL adds build comments to the multi-system
files in the core library, a step toward making it
possible to use go/build to build them.
With this change go/build can handle crypto/rand,
exec, net, path/filepath, os/user, and time.
os and syscall need additional adjustments.
R=golang-dev, r, gri, r, gustavo
CC=golang-dev
https://golang.org/cl/5011046
2011-09-15 14:48:57 -06:00
|
|
|
|
2009-11-01 12:15:34 -07:00
|
|
|
package net
|
|
|
|
|
|
|
|
import (
|
2013-08-06 15:15:50 -06:00
|
|
|
"os"
|
2009-12-15 16:35:38 -07:00
|
|
|
"syscall"
|
2012-11-08 09:35:16 -07:00
|
|
|
"time"
|
2009-11-01 12:15:34 -07:00
|
|
|
)
|
|
|
|
|
2013-07-28 01:15:07 -06:00
|
|
|
// A sockaddr represents a TCP, UDP, IP or Unix network endpoint
|
|
|
|
// address that can be converted into a syscall.Sockaddr.
|
2013-07-27 21:52:30 -06:00
|
|
|
type sockaddr interface {
|
|
|
|
Addr
|
2013-07-29 08:25:39 -06:00
|
|
|
|
2013-08-29 18:09:45 -06:00
|
|
|
netaddr
|
|
|
|
|
2013-07-29 08:25:39 -06:00
|
|
|
// family returns the platform-dependent address family
|
|
|
|
// identifier.
|
2013-07-27 21:52:30 -06:00
|
|
|
family() int
|
2013-07-29 08:25:39 -06:00
|
|
|
|
|
|
|
// isWildcard reports whether the address is a wildcard
|
|
|
|
// address.
|
2013-07-27 21:52:30 -06:00
|
|
|
isWildcard() bool
|
2013-07-29 08:25:39 -06:00
|
|
|
|
|
|
|
// sockaddr returns the address converted into a syscall
|
|
|
|
// sockaddr type that implements syscall.Sockaddr
|
|
|
|
// interface. It returns a nil interface when the address is
|
|
|
|
// nil.
|
2013-07-27 21:52:30 -06:00
|
|
|
sockaddr(family int) (syscall.Sockaddr, error)
|
|
|
|
}
|
|
|
|
|
2013-08-22 22:13:43 -06:00
|
|
|
// socket returns a network file descriptor that is ready for
|
|
|
|
// asynchronous I/O using the network poller.
|
|
|
|
func socket(net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, deadline time.Time, toAddr func(syscall.Sockaddr) Addr) (fd *netFD, err error) {
|
|
|
|
s, err := sysSocket(family, sotype, proto)
|
2011-11-13 20:44:52 -07:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|
2013-08-22 22:13:43 -06:00
|
|
|
if err = setDefaultSockopts(s, family, sotype, ipv6only); err != nil {
|
2012-01-31 09:53:26 -07:00
|
|
|
closesocket(s)
|
|
|
|
return nil, err
|
|
|
|
}
|
2013-08-22 22:13:43 -06:00
|
|
|
if fd, err = newFD(s, family, sotype, net); err != nil {
|
2013-08-06 15:15:50 -06:00
|
|
|
closesocket(s)
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2013-08-22 22:13:43 -06:00
|
|
|
// This function makes a network file descriptor for the
|
|
|
|
// following applications:
|
|
|
|
//
|
|
|
|
// - An endpoint holder that opens a passive stream
|
|
|
|
// connenction, known as a stream listener
|
|
|
|
//
|
|
|
|
// - An endpoint holder that opens a destination-unspecific
|
|
|
|
// datagram connection, known as a datagram listener
|
|
|
|
//
|
|
|
|
// - An endpoint holder that opens an active stream or a
|
|
|
|
// destination-specific datagram connection, known as a
|
|
|
|
// dialer
|
2013-08-02 22:32:22 -06:00
|
|
|
//
|
2013-08-22 22:13:43 -06:00
|
|
|
// - An endpoint holder that opens the other connection, such
|
|
|
|
// as talking to the protocol stack inside the kernel
|
2013-08-02 22:32:22 -06:00
|
|
|
//
|
2013-08-22 22:13:43 -06:00
|
|
|
// For stream and datagram listeners, they will only require
|
|
|
|
// named sockets, so we can assume that it's just a request
|
|
|
|
// from stream or datagram listeners when laddr is not nil but
|
|
|
|
// raddr is nil. Otherwise we assume it's just for dialers or
|
|
|
|
// the other connection holders.
|
2013-08-02 22:32:22 -06:00
|
|
|
|
|
|
|
if laddr != nil && raddr == nil {
|
2013-08-22 22:13:43 -06:00
|
|
|
switch sotype {
|
2013-08-06 15:15:50 -06:00
|
|
|
case syscall.SOCK_STREAM, syscall.SOCK_SEQPACKET:
|
2013-08-15 01:40:33 -06:00
|
|
|
if err := fd.listenStream(laddr, listenerBacklog, toAddr); err != nil {
|
2013-08-06 15:15:50 -06:00
|
|
|
fd.Close()
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return fd, nil
|
|
|
|
case syscall.SOCK_DGRAM:
|
|
|
|
if err := fd.listenDatagram(laddr, toAddr); err != nil {
|
|
|
|
fd.Close()
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return fd, nil
|
2012-01-31 09:53:26 -07:00
|
|
|
}
|
2013-03-30 00:21:22 -06:00
|
|
|
}
|
2013-08-06 15:15:50 -06:00
|
|
|
if err := fd.dial(laddr, raddr, deadline, toAddr); err != nil {
|
2013-08-06 08:42:33 -06:00
|
|
|
fd.Close()
|
|
|
|
return nil, err
|
|
|
|
}
|
2013-08-06 15:15:50 -06:00
|
|
|
return fd, nil
|
|
|
|
}
|
2009-11-01 12:15:34 -07:00
|
|
|
|
2013-08-06 15:15:50 -06:00
|
|
|
func (fd *netFD) dial(laddr, raddr sockaddr, deadline time.Time, toAddr func(syscall.Sockaddr) Addr) error {
|
|
|
|
var err error
|
|
|
|
var lsa syscall.Sockaddr
|
|
|
|
if laddr != nil {
|
|
|
|
if lsa, err = laddr.sockaddr(fd.family); err != nil {
|
|
|
|
return err
|
|
|
|
} else if lsa != nil {
|
|
|
|
if err := syscall.Bind(fd.sysfd, lsa); err != nil {
|
|
|
|
return os.NewSyscallError("bind", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-08-02 22:32:22 -06:00
|
|
|
var rsa syscall.Sockaddr
|
|
|
|
if raddr != nil {
|
2013-08-06 15:15:50 -06:00
|
|
|
if rsa, err = raddr.sockaddr(fd.family); err != nil {
|
|
|
|
return err
|
2014-07-29 01:48:11 -06:00
|
|
|
}
|
|
|
|
if err := fd.connect(lsa, rsa, deadline); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
fd.isConnected = true
|
|
|
|
} else {
|
|
|
|
if err := fd.init(); err != nil {
|
|
|
|
return err
|
2013-08-02 22:32:22 -06:00
|
|
|
}
|
|
|
|
}
|
2013-08-06 15:15:50 -06:00
|
|
|
lsa, _ = syscall.Getsockname(fd.sysfd)
|
|
|
|
if rsa, _ = syscall.Getpeername(fd.sysfd); rsa != nil {
|
|
|
|
fd.setAddr(toAddr(lsa), toAddr(rsa))
|
|
|
|
} else {
|
|
|
|
fd.setAddr(toAddr(lsa), raddr)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2013-08-02 22:32:22 -06:00
|
|
|
|
2013-08-15 01:40:33 -06:00
|
|
|
func (fd *netFD) listenStream(laddr sockaddr, backlog int, toAddr func(syscall.Sockaddr) Addr) error {
|
2013-08-06 15:15:50 -06:00
|
|
|
if err := setDefaultListenerSockopts(fd.sysfd); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if lsa, err := laddr.sockaddr(fd.family); err != nil {
|
|
|
|
return err
|
|
|
|
} else if lsa != nil {
|
|
|
|
if err := syscall.Bind(fd.sysfd, lsa); err != nil {
|
|
|
|
return os.NewSyscallError("bind", err)
|
2013-03-07 10:44:24 -07:00
|
|
|
}
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|
2013-08-15 01:40:33 -06:00
|
|
|
if err := syscall.Listen(fd.sysfd, backlog); err != nil {
|
|
|
|
return os.NewSyscallError("listen", err)
|
|
|
|
}
|
|
|
|
if err := fd.init(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2013-08-06 15:15:50 -06:00
|
|
|
lsa, _ := syscall.Getsockname(fd.sysfd)
|
|
|
|
fd.setAddr(toAddr(lsa), nil)
|
|
|
|
return nil
|
|
|
|
}
|
2009-11-01 12:15:34 -07:00
|
|
|
|
2013-08-06 15:15:50 -06:00
|
|
|
func (fd *netFD) listenDatagram(laddr sockaddr, toAddr func(syscall.Sockaddr) Addr) error {
|
|
|
|
switch addr := laddr.(type) {
|
|
|
|
case *UDPAddr:
|
|
|
|
// We provide a socket that listens to a wildcard
|
|
|
|
// address with reusable UDP port when the given laddr
|
|
|
|
// is an appropriate UDP multicast address prefix.
|
|
|
|
// This makes it possible for a single UDP listener to
|
|
|
|
// join multiple different group addresses, for
|
|
|
|
// multiple UDP listeners that listen on the same UDP
|
|
|
|
// port to join the same group address.
|
|
|
|
if addr.IP != nil && addr.IP.IsMulticast() {
|
|
|
|
if err := setDefaultMulticastSockopts(fd.sysfd); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
addr := *addr
|
|
|
|
switch fd.family {
|
|
|
|
case syscall.AF_INET:
|
|
|
|
addr.IP = IPv4zero
|
|
|
|
case syscall.AF_INET6:
|
|
|
|
addr.IP = IPv6unspecified
|
|
|
|
}
|
|
|
|
laddr = &addr
|
|
|
|
}
|
2013-03-23 07:32:19 -06:00
|
|
|
}
|
2013-08-06 15:15:50 -06:00
|
|
|
if lsa, err := laddr.sockaddr(fd.family); err != nil {
|
|
|
|
return err
|
|
|
|
} else if lsa != nil {
|
|
|
|
if err := syscall.Bind(fd.sysfd, lsa); err != nil {
|
|
|
|
return os.NewSyscallError("bind", err)
|
|
|
|
}
|
|
|
|
}
|
2013-08-15 01:40:33 -06:00
|
|
|
if err := fd.init(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2013-08-06 15:15:50 -06:00
|
|
|
lsa, _ := syscall.Getsockname(fd.sysfd)
|
|
|
|
fd.setAddr(toAddr(lsa), nil)
|
|
|
|
return nil
|
2009-11-01 12:15:34 -07:00
|
|
|
}
|