234 lines
6.5 KiB
Go
234 lines
6.5 KiB
Go
// 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.
|
|
|
|
// +build aix darwin dragonfly freebsd linux nacl netbsd openbsd solaris windows
|
|
|
|
package net
|
|
|
|
import (
|
|
"context"
|
|
"internal/poll"
|
|
"os"
|
|
"syscall"
|
|
)
|
|
|
|
// A sockaddr represents a TCP, UDP, IP or Unix network endpoint
|
|
// address that can be converted into a syscall.Sockaddr.
|
|
type sockaddr interface {
|
|
Addr
|
|
|
|
// family returns the platform-dependent address family
|
|
// identifier.
|
|
family() int
|
|
|
|
// isWildcard reports whether the address is a wildcard
|
|
// address.
|
|
isWildcard() bool
|
|
|
|
// 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.
|
|
sockaddr(family int) (syscall.Sockaddr, error)
|
|
|
|
// toLocal maps the zero address to a local system address (127.0.0.1 or ::1)
|
|
toLocal(net string) sockaddr
|
|
}
|
|
|
|
// socket returns a network file descriptor that is ready for
|
|
// asynchronous I/O using the network poller.
|
|
func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr) (fd *netFD, err error) {
|
|
s, err := sysSocket(family, sotype, proto)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err = setDefaultSockopts(s, family, sotype, ipv6only); err != nil {
|
|
poll.CloseFunc(s)
|
|
return nil, err
|
|
}
|
|
if fd, err = newFD(s, family, sotype, net); err != nil {
|
|
poll.CloseFunc(s)
|
|
return nil, err
|
|
}
|
|
|
|
// This function makes a network file descriptor for the
|
|
// following applications:
|
|
//
|
|
// - An endpoint holder that opens a passive stream
|
|
// connection, 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
|
|
//
|
|
// - An endpoint holder that opens the other connection, such
|
|
// as talking to the protocol stack inside the kernel
|
|
//
|
|
// 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.
|
|
|
|
if laddr != nil && raddr == nil {
|
|
switch sotype {
|
|
case syscall.SOCK_STREAM, syscall.SOCK_SEQPACKET:
|
|
if err := fd.listenStream(laddr, listenerBacklog); err != nil {
|
|
fd.Close()
|
|
return nil, err
|
|
}
|
|
return fd, nil
|
|
case syscall.SOCK_DGRAM:
|
|
if err := fd.listenDatagram(laddr); err != nil {
|
|
fd.Close()
|
|
return nil, err
|
|
}
|
|
return fd, nil
|
|
}
|
|
}
|
|
if err := fd.dial(ctx, laddr, raddr); err != nil {
|
|
fd.Close()
|
|
return nil, err
|
|
}
|
|
return fd, nil
|
|
}
|
|
|
|
func (fd *netFD) addrFunc() func(syscall.Sockaddr) Addr {
|
|
switch fd.family {
|
|
case syscall.AF_INET, syscall.AF_INET6:
|
|
switch fd.sotype {
|
|
case syscall.SOCK_STREAM:
|
|
return sockaddrToTCP
|
|
case syscall.SOCK_DGRAM:
|
|
return sockaddrToUDP
|
|
case syscall.SOCK_RAW:
|
|
return sockaddrToIP
|
|
}
|
|
case syscall.AF_UNIX:
|
|
switch fd.sotype {
|
|
case syscall.SOCK_STREAM:
|
|
return sockaddrToUnix
|
|
case syscall.SOCK_DGRAM:
|
|
return sockaddrToUnixgram
|
|
case syscall.SOCK_SEQPACKET:
|
|
return sockaddrToUnixpacket
|
|
}
|
|
}
|
|
return func(syscall.Sockaddr) Addr { return nil }
|
|
}
|
|
|
|
func (fd *netFD) dial(ctx context.Context, laddr, raddr sockaddr) 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.pfd.Sysfd, lsa); err != nil {
|
|
return os.NewSyscallError("bind", err)
|
|
}
|
|
}
|
|
}
|
|
var rsa syscall.Sockaddr // remote address from the user
|
|
var crsa syscall.Sockaddr // remote address we actually connected to
|
|
if raddr != nil {
|
|
if rsa, err = raddr.sockaddr(fd.family); err != nil {
|
|
return err
|
|
}
|
|
if crsa, err = fd.connect(ctx, lsa, rsa); err != nil {
|
|
return err
|
|
}
|
|
fd.isConnected = true
|
|
} else {
|
|
if err := fd.init(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
// Record the local and remote addresses from the actual socket.
|
|
// Get the local address by calling Getsockname.
|
|
// For the remote address, use
|
|
// 1) the one returned by the connect method, if any; or
|
|
// 2) the one from Getpeername, if it succeeds; or
|
|
// 3) the one passed to us as the raddr parameter.
|
|
lsa, _ = syscall.Getsockname(fd.pfd.Sysfd)
|
|
if crsa != nil {
|
|
fd.setAddr(fd.addrFunc()(lsa), fd.addrFunc()(crsa))
|
|
} else if rsa, _ = syscall.Getpeername(fd.pfd.Sysfd); rsa != nil {
|
|
fd.setAddr(fd.addrFunc()(lsa), fd.addrFunc()(rsa))
|
|
} else {
|
|
fd.setAddr(fd.addrFunc()(lsa), raddr)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (fd *netFD) listenStream(laddr sockaddr, backlog int) error {
|
|
if err := setDefaultListenerSockopts(fd.pfd.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.pfd.Sysfd, lsa); err != nil {
|
|
return os.NewSyscallError("bind", err)
|
|
}
|
|
}
|
|
if err := listenFunc(fd.pfd.Sysfd, backlog); err != nil {
|
|
return os.NewSyscallError("listen", err)
|
|
}
|
|
if err := fd.init(); err != nil {
|
|
return err
|
|
}
|
|
lsa, err := syscall.Getsockname(fd.pfd.Sysfd)
|
|
if err != nil {
|
|
return os.NewSyscallError("getsockname", err)
|
|
}
|
|
fd.setAddr(fd.addrFunc()(lsa), nil)
|
|
return nil
|
|
}
|
|
|
|
func (fd *netFD) listenDatagram(laddr sockaddr) 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.pfd.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
|
|
}
|
|
}
|
|
if lsa, err := laddr.sockaddr(fd.family); err != nil {
|
|
return err
|
|
} else if lsa != nil {
|
|
if err := syscall.Bind(fd.pfd.Sysfd, lsa); err != nil {
|
|
return os.NewSyscallError("bind", err)
|
|
}
|
|
}
|
|
if err := fd.init(); err != nil {
|
|
return err
|
|
}
|
|
lsa, err := syscall.Getsockname(fd.pfd.Sysfd)
|
|
if err != nil {
|
|
return os.NewSyscallError("getsockname", err)
|
|
}
|
|
fd.setAddr(fd.addrFunc()(lsa), nil)
|
|
return nil
|
|
}
|