ipsock.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  package net
		 6  
		 7  import (
		 8  	"context"
		 9  	"internal/bytealg"
		10  	"runtime"
		11  	"sync"
		12  )
		13  
		14  // BUG(rsc,mikio): On DragonFly BSD and OpenBSD, listening on the
		15  // "tcp" and "udp" networks does not listen for both IPv4 and IPv6
		16  // connections. This is due to the fact that IPv4 traffic will not be
		17  // routed to an IPv6 socket - two separate sockets are required if
		18  // both address families are to be supported.
		19  // See inet6(4) for details.
		20  
		21  type ipStackCapabilities struct {
		22  	sync.Once						 // guards following
		23  	ipv4Enabled					 bool
		24  	ipv6Enabled					 bool
		25  	ipv4MappedIPv6Enabled bool
		26  }
		27  
		28  var ipStackCaps ipStackCapabilities
		29  
		30  // supportsIPv4 reports whether the platform supports IPv4 networking
		31  // functionality.
		32  func supportsIPv4() bool {
		33  	ipStackCaps.Once.Do(ipStackCaps.probe)
		34  	return ipStackCaps.ipv4Enabled
		35  }
		36  
		37  // supportsIPv6 reports whether the platform supports IPv6 networking
		38  // functionality.
		39  func supportsIPv6() bool {
		40  	ipStackCaps.Once.Do(ipStackCaps.probe)
		41  	return ipStackCaps.ipv6Enabled
		42  }
		43  
		44  // supportsIPv4map reports whether the platform supports mapping an
		45  // IPv4 address inside an IPv6 address at transport layer
		46  // protocols. See RFC 4291, RFC 4038 and RFC 3493.
		47  func supportsIPv4map() bool {
		48  	// Some operating systems provide no support for mapping IPv4
		49  	// addresses to IPv6, and a runtime check is unnecessary.
		50  	switch runtime.GOOS {
		51  	case "dragonfly", "openbsd":
		52  		return false
		53  	}
		54  
		55  	ipStackCaps.Once.Do(ipStackCaps.probe)
		56  	return ipStackCaps.ipv4MappedIPv6Enabled
		57  }
		58  
		59  // An addrList represents a list of network endpoint addresses.
		60  type addrList []Addr
		61  
		62  // isIPv4 reports whether addr contains an IPv4 address.
		63  func isIPv4(addr Addr) bool {
		64  	switch addr := addr.(type) {
		65  	case *TCPAddr:
		66  		return addr.IP.To4() != nil
		67  	case *UDPAddr:
		68  		return addr.IP.To4() != nil
		69  	case *IPAddr:
		70  		return addr.IP.To4() != nil
		71  	}
		72  	return false
		73  }
		74  
		75  // isNotIPv4 reports whether addr does not contain an IPv4 address.
		76  func isNotIPv4(addr Addr) bool { return !isIPv4(addr) }
		77  
		78  // forResolve returns the most appropriate address in address for
		79  // a call to ResolveTCPAddr, ResolveUDPAddr, or ResolveIPAddr.
		80  // IPv4 is preferred, unless addr contains an IPv6 literal.
		81  func (addrs addrList) forResolve(network, addr string) Addr {
		82  	var want6 bool
		83  	switch network {
		84  	case "ip":
		85  		// IPv6 literal (addr does NOT contain a port)
		86  		want6 = count(addr, ':') > 0
		87  	case "tcp", "udp":
		88  		// IPv6 literal. (addr contains a port, so look for '[')
		89  		want6 = count(addr, '[') > 0
		90  	}
		91  	if want6 {
		92  		return addrs.first(isNotIPv4)
		93  	}
		94  	return addrs.first(isIPv4)
		95  }
		96  
		97  // first returns the first address which satisfies strategy, or if
		98  // none do, then the first address of any kind.
		99  func (addrs addrList) first(strategy func(Addr) bool) Addr {
	 100  	for _, addr := range addrs {
	 101  		if strategy(addr) {
	 102  			return addr
	 103  		}
	 104  	}
	 105  	return addrs[0]
	 106  }
	 107  
	 108  // partition divides an address list into two categories, using a
	 109  // strategy function to assign a boolean label to each address.
	 110  // The first address, and any with a matching label, are returned as
	 111  // primaries, while addresses with the opposite label are returned
	 112  // as fallbacks. For non-empty inputs, primaries is guaranteed to be
	 113  // non-empty.
	 114  func (addrs addrList) partition(strategy func(Addr) bool) (primaries, fallbacks addrList) {
	 115  	var primaryLabel bool
	 116  	for i, addr := range addrs {
	 117  		label := strategy(addr)
	 118  		if i == 0 || label == primaryLabel {
	 119  			primaryLabel = label
	 120  			primaries = append(primaries, addr)
	 121  		} else {
	 122  			fallbacks = append(fallbacks, addr)
	 123  		}
	 124  	}
	 125  	return
	 126  }
	 127  
	 128  // filterAddrList applies a filter to a list of IP addresses,
	 129  // yielding a list of Addr objects. Known filters are nil, ipv4only,
	 130  // and ipv6only. It returns every address when the filter is nil.
	 131  // The result contains at least one address when error is nil.
	 132  func filterAddrList(filter func(IPAddr) bool, ips []IPAddr, inetaddr func(IPAddr) Addr, originalAddr string) (addrList, error) {
	 133  	var addrs addrList
	 134  	for _, ip := range ips {
	 135  		if filter == nil || filter(ip) {
	 136  			addrs = append(addrs, inetaddr(ip))
	 137  		}
	 138  	}
	 139  	if len(addrs) == 0 {
	 140  		return nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: originalAddr}
	 141  	}
	 142  	return addrs, nil
	 143  }
	 144  
	 145  // ipv4only reports whether addr is an IPv4 address.
	 146  func ipv4only(addr IPAddr) bool {
	 147  	return addr.IP.To4() != nil
	 148  }
	 149  
	 150  // ipv6only reports whether addr is an IPv6 address except IPv4-mapped IPv6 address.
	 151  func ipv6only(addr IPAddr) bool {
	 152  	return len(addr.IP) == IPv6len && addr.IP.To4() == nil
	 153  }
	 154  
	 155  // SplitHostPort splits a network address of the form "host:port",
	 156  // "host%zone:port", "[host]:port" or "[host%zone]:port" into host or
	 157  // host%zone and port.
	 158  //
	 159  // A literal IPv6 address in hostport must be enclosed in square
	 160  // brackets, as in "[::1]:80", "[::1%lo0]:80".
	 161  //
	 162  // See func Dial for a description of the hostport parameter, and host
	 163  // and port results.
	 164  func SplitHostPort(hostport string) (host, port string, err error) {
	 165  	const (
	 166  		missingPort	 = "missing port in address"
	 167  		tooManyColons = "too many colons in address"
	 168  	)
	 169  	addrErr := func(addr, why string) (host, port string, err error) {
	 170  		return "", "", &AddrError{Err: why, Addr: addr}
	 171  	}
	 172  	j, k := 0, 0
	 173  
	 174  	// The port starts after the last colon.
	 175  	i := last(hostport, ':')
	 176  	if i < 0 {
	 177  		return addrErr(hostport, missingPort)
	 178  	}
	 179  
	 180  	if hostport[0] == '[' {
	 181  		// Expect the first ']' just before the last ':'.
	 182  		end := bytealg.IndexByteString(hostport, ']')
	 183  		if end < 0 {
	 184  			return addrErr(hostport, "missing ']' in address")
	 185  		}
	 186  		switch end + 1 {
	 187  		case len(hostport):
	 188  			// There can't be a ':' behind the ']' now.
	 189  			return addrErr(hostport, missingPort)
	 190  		case i:
	 191  			// The expected result.
	 192  		default:
	 193  			// Either ']' isn't followed by a colon, or it is
	 194  			// followed by a colon that is not the last one.
	 195  			if hostport[end+1] == ':' {
	 196  				return addrErr(hostport, tooManyColons)
	 197  			}
	 198  			return addrErr(hostport, missingPort)
	 199  		}
	 200  		host = hostport[1:end]
	 201  		j, k = 1, end+1 // there can't be a '[' resp. ']' before these positions
	 202  	} else {
	 203  		host = hostport[:i]
	 204  		if bytealg.IndexByteString(host, ':') >= 0 {
	 205  			return addrErr(hostport, tooManyColons)
	 206  		}
	 207  	}
	 208  	if bytealg.IndexByteString(hostport[j:], '[') >= 0 {
	 209  		return addrErr(hostport, "unexpected '[' in address")
	 210  	}
	 211  	if bytealg.IndexByteString(hostport[k:], ']') >= 0 {
	 212  		return addrErr(hostport, "unexpected ']' in address")
	 213  	}
	 214  
	 215  	port = hostport[i+1:]
	 216  	return host, port, nil
	 217  }
	 218  
	 219  func splitHostZone(s string) (host, zone string) {
	 220  	// The IPv6 scoped addressing zone identifier starts after the
	 221  	// last percent sign.
	 222  	if i := last(s, '%'); i > 0 {
	 223  		host, zone = s[:i], s[i+1:]
	 224  	} else {
	 225  		host = s
	 226  	}
	 227  	return
	 228  }
	 229  
	 230  // JoinHostPort combines host and port into a network address of the
	 231  // form "host:port". If host contains a colon, as found in literal
	 232  // IPv6 addresses, then JoinHostPort returns "[host]:port".
	 233  //
	 234  // See func Dial for a description of the host and port parameters.
	 235  func JoinHostPort(host, port string) string {
	 236  	// We assume that host is a literal IPv6 address if host has
	 237  	// colons.
	 238  	if bytealg.IndexByteString(host, ':') >= 0 {
	 239  		return "[" + host + "]:" + port
	 240  	}
	 241  	return host + ":" + port
	 242  }
	 243  
	 244  // internetAddrList resolves addr, which may be a literal IP
	 245  // address or a DNS name, and returns a list of internet protocol
	 246  // family addresses. The result contains at least one address when
	 247  // error is nil.
	 248  func (r *Resolver) internetAddrList(ctx context.Context, net, addr string) (addrList, error) {
	 249  	var (
	 250  		err				error
	 251  		host, port string
	 252  		portnum		int
	 253  	)
	 254  	switch net {
	 255  	case "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6":
	 256  		if addr != "" {
	 257  			if host, port, err = SplitHostPort(addr); err != nil {
	 258  				return nil, err
	 259  			}
	 260  			if portnum, err = r.LookupPort(ctx, net, port); err != nil {
	 261  				return nil, err
	 262  			}
	 263  		}
	 264  	case "ip", "ip4", "ip6":
	 265  		if addr != "" {
	 266  			host = addr
	 267  		}
	 268  	default:
	 269  		return nil, UnknownNetworkError(net)
	 270  	}
	 271  	inetaddr := func(ip IPAddr) Addr {
	 272  		switch net {
	 273  		case "tcp", "tcp4", "tcp6":
	 274  			return &TCPAddr{IP: ip.IP, Port: portnum, Zone: ip.Zone}
	 275  		case "udp", "udp4", "udp6":
	 276  			return &UDPAddr{IP: ip.IP, Port: portnum, Zone: ip.Zone}
	 277  		case "ip", "ip4", "ip6":
	 278  			return &IPAddr{IP: ip.IP, Zone: ip.Zone}
	 279  		default:
	 280  			panic("unexpected network: " + net)
	 281  		}
	 282  	}
	 283  	if host == "" {
	 284  		return addrList{inetaddr(IPAddr{})}, nil
	 285  	}
	 286  
	 287  	// Try as a literal IP address, then as a DNS name.
	 288  	ips, err := r.lookupIPAddr(ctx, net, host)
	 289  	if err != nil {
	 290  		return nil, err
	 291  	}
	 292  	// Issue 18806: if the machine has halfway configured
	 293  	// IPv6 such that it can bind on "::" (IPv6unspecified)
	 294  	// but not connect back to that same address, fall
	 295  	// back to dialing 0.0.0.0.
	 296  	if len(ips) == 1 && ips[0].IP.Equal(IPv6unspecified) {
	 297  		ips = append(ips, IPAddr{IP: IPv4zero})
	 298  	}
	 299  
	 300  	var filter func(IPAddr) bool
	 301  	if net != "" && net[len(net)-1] == '4' {
	 302  		filter = ipv4only
	 303  	}
	 304  	if net != "" && net[len(net)-1] == '6' {
	 305  		filter = ipv6only
	 306  	}
	 307  	return filterAddrList(filter, ips, inetaddr, host)
	 308  }
	 309  
	 310  func loopbackIP(net string) IP {
	 311  	if net != "" && net[len(net)-1] == '6' {
	 312  		return IPv6loopback
	 313  	}
	 314  	return IP{127, 0, 0, 1}
	 315  }
	 316
View as plain text