Imported Upstream version 1.1~hg20130304upstream/1.1_hg20130304

1 files changed, 132 insertions, 48 deletions

diff --git a/src/pkg/net/ipsock.go b/src/pkg/net/ipsock.go
index bfbce18a4..1ef489289 100644
--- a/src/pkg/net/ipsock.go
+++ b/src/pkg/net/ipsock.go
@@ -2,11 +2,18 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// IP sockets
+// Internet protocol family sockets
 
 package net
 
-var supportsIPv6, supportsIPv4map = probeIPv6Stack()
+import "time"
+
+var supportsIPv6, supportsIPv4map bool
+
+func init() {
+	sysInit()
+	supportsIPv6, supportsIPv4map = probeIPv6Stack()
+}
 
 func firstFavoriteAddr(filter func(IP) IP, addrs []string) (addr IP) {
 	if filter == nil {
@@ -65,25 +72,67 @@ func (e InvalidAddrError) Temporary() bool { return false }
 // "host:port" or "[host]:port" into host and port.
 // The latter form must be used when host contains a colon.
 func SplitHostPort(hostport string) (host, port string, err error) {
+	host, port, _, err = splitHostPort(hostport)
+	return
+}
+
+func splitHostPort(hostport string) (host, port, zone string, err error) {
+	j, k := 0, 0
+
 	// The port starts after the last colon.
 	i := last(hostport, ':')
 	if i < 0 {
-		err = &AddrError{"missing port in address", hostport}
-		return
+		goto missingPort
 	}
 
-	host, port = hostport[0:i], hostport[i+1:]
-
-	// Can put brackets around host ...
-	if len(host) > 0 && host[0] == '[' && host[len(host)-1] == ']' {
-		host = host[1 : len(host)-1]
+	if hostport[0] == '[' {
+		// Expect the first ']' just before the last ':'.
+		end := byteIndex(hostport, ']')
+		if end < 0 {
+			err = &AddrError{"missing ']' in address", hostport}
+			return
+		}
+		switch end + 1 {
+		case len(hostport):
+			// There can't be a ':' behind the ']' now.
+			goto missingPort
+		case i:
+			// The expected result.
+		default:
+			// Either ']' isn't followed by a colon, or it is
+			// followed by a colon that is not the last one.
+			if hostport[end+1] == ':' {
+				goto tooManyColons
+			}
+			goto missingPort
+		}
+		host = hostport[1:end]
+		j, k = 1, end+1 // there can't be a '[' resp. ']' before these positions
 	} else {
-		// ... but if there are no brackets, no colons.
+		host = hostport[:i]
+
 		if byteIndex(host, ':') >= 0 {
-			err = &AddrError{"too many colons in address", hostport}
-			return
+			goto tooManyColons
 		}
 	}
+	if byteIndex(hostport[j:], '[') >= 0 {
+		err = &AddrError{"unexpected '[' in address", hostport}
+		return
+	}
+	if byteIndex(hostport[k:], ']') >= 0 {
+		err = &AddrError{"unexpected ']' in address", hostport}
+		return
+	}
+
+	port = hostport[i+1:]
+	return
+
+missingPort:
+	err = &AddrError{"missing port in address", hostport}
+	return
+
+tooManyColons:
+	err = &AddrError{"too many colons in address", hostport}
 	return
 }
 
@@ -97,49 +146,84 @@ func JoinHostPort(host, port string) string {
 	return host + ":" + port
 }
 
-// Convert "host:port" into IP address and port.
-func hostPortToIP(net, hostport string) (ip IP, iport int, err error) {
-	host, port, err := SplitHostPort(hostport)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	var addr IP
-	if host != "" {
-		// Try as an IP address.
-		addr = ParseIP(host)
-		if addr == nil {
-			var filter func(IP) IP
-			if net != "" && net[len(net)-1] == '4' {
-				filter = ipv4only
+func resolveInternetAddr(net, addr string, deadline time.Time) (Addr, error) {
+	var (
+		err              error
+		host, port, zone string
+		portnum          int
+	)
+	switch net {
+	case "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6":
+		if addr != "" {
+			if host, port, zone, err = splitHostPort(addr); err != nil {
+				return nil, err
 			}
-			if net != "" && net[len(net)-1] == '6' {
-				filter = ipv6only
-			}
-			// Not an IP address.  Try as a DNS name.
-			addrs, err := LookupHost(host)
-			if err != nil {
-				return nil, 0, err
-			}
-			addr = firstFavoriteAddr(filter, addrs)
-			if addr == nil {
-				// should not happen
-				return nil, 0, &AddrError{"LookupHost returned no suitable address", addrs[0]}
+			if portnum, err = parsePort(net, port); err != nil {
+				return nil, err
 			}
 		}
+	case "ip", "ip4", "ip6":
+		if addr != "" {
+			host = addr
+		}
+	default:
+		return nil, UnknownNetworkError(net)
 	}
-
-	p, i, ok := dtoi(port, 0)
-	if !ok || i != len(port) {
-		p, err = LookupPort(net, port)
-		if err != nil {
-			return nil, 0, err
+	inetaddr := func(net string, ip IP, port int, zone string) Addr {
+		switch net {
+		case "tcp", "tcp4", "tcp6":
+			return &TCPAddr{IP: ip, Port: port, Zone: zone}
+		case "udp", "udp4", "udp6":
+			return &UDPAddr{IP: ip, Port: port, Zone: zone}
+		case "ip", "ip4", "ip6":
+			return &IPAddr{IP: ip, Zone: zone}
 		}
+		return nil
+	}
+	if host == "" {
+		return inetaddr(net, nil, portnum, zone), nil
 	}
-	if p < 0 || p > 0xFFFF {
-		return nil, 0, &AddrError{"invalid port", port}
+	// Try as an IP address.
+	if ip := ParseIP(host); ip != nil {
+		return inetaddr(net, ip, portnum, zone), nil
 	}
+	var filter func(IP) IP
+	if net != "" && net[len(net)-1] == '4' {
+		filter = ipv4only
+	}
+	if net != "" && net[len(net)-1] == '6' {
+		filter = ipv6only
+	}
+	// Try as a DNS name.
+	addrs, err := lookupHostDeadline(host, deadline)
+	if err != nil {
+		return nil, err
+	}
+	ip := firstFavoriteAddr(filter, addrs)
+	if ip == nil {
+		// should not happen
+		return nil, &AddrError{"LookupHost returned no suitable address", addrs[0]}
+	}
+	return inetaddr(net, ip, portnum, zone), nil
+}
 
-	return addr, p, nil
+func zoneToString(zone int) string {
+	if zone == 0 {
+		return ""
+	}
+	if ifi, err := InterfaceByIndex(zone); err == nil {
+		return ifi.Name
+	}
+	return itod(uint(zone))
+}
 
+func zoneToInt(zone string) int {
+	if zone == "" {
+		return 0
+	}
+	if ifi, err := InterfaceByName(zone); err == nil {
+		return ifi.Index
+	}
+	n, _, _ := dtoi(zone, 0)
+	return n
 }