sock_posix.go

Documentation: net

     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  //go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || windows
     6  // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris windows
     7  
     8  package net
     9  
    10  import (
    11  	"context"
    12  	"internal/poll"
    13  	"os"
    14  	"syscall"
    15  )
    16  
    17  // socket returns a network file descriptor that is ready for
    18  // asynchronous I/O using the network poller.
    19  func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) (fd *netFD, err error) {
    20  	s, err := sysSocket(family, sotype, proto)
    21  	if err != nil {
    22  		return nil, err
    23  	}
    24  	if err = setDefaultSockopts(s, family, sotype, ipv6only); err != nil {
    25  		poll.CloseFunc(s)
    26  		return nil, err
    27  	}
    28  	if fd, err = newFD(s, family, sotype, net); err != nil {
    29  		poll.CloseFunc(s)
    30  		return nil, err
    31  	}
    32  
    33  	// This function makes a network file descriptor for the
    34  	// following applications:
    35  	//
    36  	// - An endpoint holder that opens a passive stream
    37  	//   connection, known as a stream listener
    38  	//
    39  	// - An endpoint holder that opens a destination-unspecific
    40  	//   datagram connection, known as a datagram listener
    41  	//
    42  	// - An endpoint holder that opens an active stream or a
    43  	//   destination-specific datagram connection, known as a
    44  	//   dialer
    45  	//
    46  	// - An endpoint holder that opens the other connection, such
    47  	//   as talking to the protocol stack inside the kernel
    48  	//
    49  	// For stream and datagram listeners, they will only require
    50  	// named sockets, so we can assume that it's just a request
    51  	// from stream or datagram listeners when laddr is not nil but
    52  	// raddr is nil. Otherwise we assume it's just for dialers or
    53  	// the other connection holders.
    54  
    55  	if laddr != nil && raddr == nil {
    56  		switch sotype {
    57  		case syscall.SOCK_STREAM, syscall.SOCK_SEQPACKET:
    58  			if err := fd.listenStream(laddr, listenerBacklog(), ctrlFn); err != nil {
    59  				fd.Close()
    60  				return nil, err
    61  			}
    62  			return fd, nil
    63  		case syscall.SOCK_DGRAM:
    64  			if err := fd.listenDatagram(laddr, ctrlFn); err != nil {
    65  				fd.Close()
    66  				return nil, err
    67  			}
    68  			return fd, nil
    69  		}
    70  	}
    71  	if err := fd.dial(ctx, laddr, raddr, ctrlFn); err != nil {
    72  		fd.Close()
    73  		return nil, err
    74  	}
    75  	return fd, nil
    76  }
    77  
    78  func (fd *netFD) ctrlNetwork() string {
    79  	switch fd.net {
    80  	case "unix", "unixgram", "unixpacket":
    81  		return fd.net
    82  	}
    83  	switch fd.net[len(fd.net)-1] {
    84  	case '4', '6':
    85  		return fd.net
    86  	}
    87  	if fd.family == syscall.AF_INET {
    88  		return fd.net + "4"
    89  	}
    90  	return fd.net + "6"
    91  }
    92  
    93  func (fd *netFD) addrFunc() func(syscall.Sockaddr) Addr {
    94  	switch fd.family {
    95  	case syscall.AF_INET, syscall.AF_INET6:
    96  		switch fd.sotype {
    97  		case syscall.SOCK_STREAM:
    98  			return sockaddrToTCP
    99  		case syscall.SOCK_DGRAM:
   100  			return sockaddrToUDP
   101  		case syscall.SOCK_RAW:
   102  			return sockaddrToIP
   103  		}
   104  	case syscall.AF_UNIX:
   105  		switch fd.sotype {
   106  		case syscall.SOCK_STREAM:
   107  			return sockaddrToUnix
   108  		case syscall.SOCK_DGRAM:
   109  			return sockaddrToUnixgram
   110  		case syscall.SOCK_SEQPACKET:
   111  			return sockaddrToUnixpacket
   112  		}
   113  	}
   114  	return func(syscall.Sockaddr) Addr { return nil }
   115  }
   116  
   117  func (fd *netFD) dial(ctx context.Context, laddr, raddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) error {
   118  	if ctrlFn != nil {
   119  		c, err := newRawConn(fd)
   120  		if err != nil {
   121  			return err
   122  		}
   123  		var ctrlAddr string
   124  		if raddr != nil {
   125  			ctrlAddr = raddr.String()
   126  		} else if laddr != nil {
   127  			ctrlAddr = laddr.String()
   128  		}
   129  		if err := ctrlFn(fd.ctrlNetwork(), ctrlAddr, c); err != nil {
   130  			return err
   131  		}
   132  	}
   133  	var err error
   134  	var lsa syscall.Sockaddr
   135  	if laddr != nil {
   136  		if lsa, err = laddr.sockaddr(fd.family); err != nil {
   137  			return err
   138  		} else if lsa != nil {
   139  			if err = syscall.Bind(fd.pfd.Sysfd, lsa); err != nil {
   140  				return os.NewSyscallError("bind", err)
   141  			}
   142  		}
   143  	}
   144  	var rsa syscall.Sockaddr  // remote address from the user
   145  	var crsa syscall.Sockaddr // remote address we actually connected to
   146  	if raddr != nil {
   147  		if rsa, err = raddr.sockaddr(fd.family); err != nil {
   148  			return err
   149  		}
   150  		if crsa, err = fd.connect(ctx, lsa, rsa); err != nil {
   151  			return err
   152  		}
   153  		fd.isConnected = true
   154  	} else {
   155  		if err := fd.init(); err != nil {
   156  			return err
   157  		}
   158  	}
   159  	// Record the local and remote addresses from the actual socket.
   160  	// Get the local address by calling Getsockname.
   161  	// For the remote address, use
   162  	// 1) the one returned by the connect method, if any; or
   163  	// 2) the one from Getpeername, if it succeeds; or
   164  	// 3) the one passed to us as the raddr parameter.
   165  	lsa, _ = syscall.Getsockname(fd.pfd.Sysfd)
   166  	if crsa != nil {
   167  		fd.setAddr(fd.addrFunc()(lsa), fd.addrFunc()(crsa))
   168  	} else if rsa, _ = syscall.Getpeername(fd.pfd.Sysfd); rsa != nil {
   169  		fd.setAddr(fd.addrFunc()(lsa), fd.addrFunc()(rsa))
   170  	} else {
   171  		fd.setAddr(fd.addrFunc()(lsa), raddr)
   172  	}
   173  	return nil
   174  }
   175  
   176  func (fd *netFD) listenStream(laddr sockaddr, backlog int, ctrlFn func(string, string, syscall.RawConn) error) error {
   177  	var err error
   178  	if err = setDefaultListenerSockopts(fd.pfd.Sysfd); err != nil {
   179  		return err
   180  	}
   181  	var lsa syscall.Sockaddr
   182  	if lsa, err = laddr.sockaddr(fd.family); err != nil {
   183  		return err
   184  	}
   185  	if ctrlFn != nil {
   186  		c, err := newRawConn(fd)
   187  		if err != nil {
   188  			return err
   189  		}
   190  		if err := ctrlFn(fd.ctrlNetwork(), laddr.String(), c); err != nil {
   191  			return err
   192  		}
   193  	}
   194  	if err = syscall.Bind(fd.pfd.Sysfd, lsa); err != nil {
   195  		return os.NewSyscallError("bind", err)
   196  	}
   197  	if err = listenFunc(fd.pfd.Sysfd, backlog); err != nil {
   198  		return os.NewSyscallError("listen", err)
   199  	}
   200  	if err = fd.init(); err != nil {
   201  		return err
   202  	}
   203  	lsa, _ = syscall.Getsockname(fd.pfd.Sysfd)
   204  	fd.setAddr(fd.addrFunc()(lsa), nil)
   205  	return nil
   206  }
   207  
   208  func (fd *netFD) listenDatagram(laddr sockaddr, ctrlFn func(string, string, syscall.RawConn) error) error {
   209  	switch addr := laddr.(type) {
   210  	case *UDPAddr:
   211  		// We provide a socket that listens to a wildcard
   212  		// address with reusable UDP port when the given laddr
   213  		// is an appropriate UDP multicast address prefix.
   214  		// This makes it possible for a single UDP listener to
   215  		// join multiple different group addresses, for
   216  		// multiple UDP listeners that listen on the same UDP
   217  		// port to join the same group address.
   218  		if addr.IP != nil && addr.IP.IsMulticast() {
   219  			if err := setDefaultMulticastSockopts(fd.pfd.Sysfd); err != nil {
   220  				return err
   221  			}
   222  			addr := *addr
   223  			switch fd.family {
   224  			case syscall.AF_INET:
   225  				addr.IP = IPv4zero
   226  			case syscall.AF_INET6:
   227  				addr.IP = IPv6unspecified
   228  			}
   229  			laddr = &addr
   230  		}
   231  	}
   232  	var err error
   233  	var lsa syscall.Sockaddr
   234  	if lsa, err = laddr.sockaddr(fd.family); err != nil {
   235  		return err
   236  	}
   237  	if ctrlFn != nil {
   238  		c, err := newRawConn(fd)
   239  		if err != nil {
   240  			return err
   241  		}
   242  		if err := ctrlFn(fd.ctrlNetwork(), laddr.String(), c); err != nil {
   243  			return err
   244  		}
   245  	}
   246  	if err = syscall.Bind(fd.pfd.Sysfd, lsa); err != nil {
   247  		return os.NewSyscallError("bind", err)
   248  	}
   249  	if err = fd.init(); err != nil {
   250  		return err
   251  	}
   252  	lsa, _ = syscall.Getsockname(fd.pfd.Sysfd)
   253  	fd.setAddr(fd.addrFunc()(lsa), nil)
   254  	return nil
   255  }
   256
View as plain text