code review 6816116: net: support IPv6 scoped addressing zone

src/pkg/net/ipsock.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.
 
 // Internet protocol family sockets
 
 package net
 
 import "time"
 
@@ skipping 51 matching lines @@
         return nil
 }
 
 type InvalidAddrError string
 
 func (e InvalidAddrError) Error() string   { return string(e) }
 func (e InvalidAddrError) Timeout() bool   { return false }
 func (e InvalidAddrError) Temporary() bool { return false }
 
 // SplitHostPort splits a network address of the form "host:port",
-// "host%ipv6zoneid:port", "[host]:port" or "[host%ipv6zoneid]:port"
-// into host and port.  A literal IPv6 host address must be enclosed
-// in square brackets, as in "[::]:80" or "[fe80::1%en0]:80".
+// "[host]:port" or "[ipv6-host%zone]:port" into host or
+// ipv6-host%zone and port.  A literal address or host name for IPv6
+// must be enclosed in square brackets, as in "[::1]:80",
+// "[ipv6-host]:http" or "[ipv6-host%zone]:80".
 func SplitHostPort(hostport string) (host, port string, err error) {
-        host, _, port, err = splitHostPort(hostport)
-        return
-}
-
-func splitHostPort(hostport string) (host, id, port 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}
+                goto missingPort
+        }
+
+        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 {
+                host = hostport[:i]
+                if byteIndex(host, ':') >= 0 {
+                        goto tooManyColons
+                }
+                if byteIndex(host, '%') >= 0 {
+                        goto missingBrackets
+                }
+        }
+        if byteIndex(hostport[j:], '[') >= 0 {
+                err = &AddrError{"unexpected '[' in address", hostport}
                 return
         }
-        host, port = hostport[: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]
-        } else {
-                // ... but if there are no brackets, no colons.
-                if byteIndex(host, ':') >= 0 {
-                        err = &AddrError{"too many colons 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
+
+missingBrackets:
+        err = &AddrError{"missing brackets in address", hostport}
+        return
+}
+
+func splitHostZone(s string) (host, zone string) {
         // The IPv6 scoped addressing zone identifer starts after the
         // last percent sign.
-        if i := last(host, '%'); i > 0 {
-                host, id = host[:i], host[i+1:]
+        if i := last(s, '%'); i > 0 {
+                host, zone = s[:i], s[i+1:]
+        } else {
+                host = s
         }
         return
 }
 
 // JoinHostPort combines host and port into a network address of the
-// form "host:port".  A literal IPv6 host address must be enclosed in
-// square brackets, as in "[::]:80".
+// form "host:port" or, if host contains a colon or a percent sign,
+// "[host]:port".
 func JoinHostPort(host, port string) string {
-        // If host has colons, have to bracket it.
-        if byteIndex(host, ':') >= 0 {
+        // If host has colons or a percent sign, have to bracket it.
+        if byteIndex(host, ':') >= 0 || byteIndex(host, '%') >= 0 {
                 return "[" + host + "]:" + port
         }
         return host + ":" + port
 }
 
-func resolveInternetAddr(net, litAddr string, deadline time.Time) (Addr, error) {
+func resolveInternetAddr(net, addr string, deadline time.Time) (Addr, error) {
         var (
-                err            error
-                host, id, port string
-                portnum        int
+                err              error
+                host, port, zone string
+                portnum          int
         )
         switch net {
         case "tcp", "tcp4", "tcp6", "udp", "udp4", "udp6":
-                if litAddr != "" {
-                        if host, id, port, err = splitHostPort(litAddr); err != nil {
+                if addr != "" {
+                        if host, port, err = SplitHostPort(addr); err != nil {
                                 return nil, err
                         }
                         if portnum, err = parsePort(net, port); err != nil {
                                 return nil, err
                         }
                 }
         case "ip", "ip4", "ip6":
-                if litAddr != "" {
-                        // The IPv6 scoped addressing zone identifer
-                        // starts after the last percent sign.
-                        if i := last(litAddr, '%'); i > 0 {
-                                host, id = litAddr[:i], litAddr[i+1:]
-                        } else {
-                                host = litAddr
-                        }
+                if addr != "" {
+                        host = addr
                 }
         default:
                 return nil, UnknownNetworkError(net)
         }
-        inetaddr := func(net string, ip IP, port, id int) Addr {
+        inetaddr := func(net string, ip IP, port int, zone string) Addr {
                 switch net {
                 case "tcp", "tcp4", "tcp6":
-                        return &TCPAddr{IP: ip, Port: port, zoneId: id}
+                        return &TCPAddr{IP: ip, Port: port, Zone: zone}
                 case "udp", "udp4", "udp6":
-                        return &UDPAddr{IP: ip, Port: port, zoneId: id}
+                        return &UDPAddr{IP: ip, Port: port, Zone: zone}
                 case "ip", "ip4", "ip6":
-                        return &IPAddr{IP: ip, zoneId: id}
+                        return &IPAddr{IP: ip, Zone: zone}
                 }
                 return nil
         }
         if host == "" {
-                return inetaddr(net, nil, portnum, parseZoneId(id)), nil
+                return inetaddr(net, nil, portnum, zone), nil
         }
         // Try as an IP address.
-        if ip := ParseIP(host); ip != nil {
-                return inetaddr(net, ip, portnum, parseZoneId(id)), nil
+        if ip := parseIPv4(host); ip != nil {
+                return inetaddr(net, ip, portnum, zone), nil
+        }
+        if ip, zone := parseIPv6(host, true); ip != nil {
+                return inetaddr(net, ip, portnum, zone), nil
+        }
+        // Try as a domain name.
+        host, zone = splitHostZone(host)
+        addrs, err := lookupHostDeadline(host, deadline)
+        if err != nil {
+                return nil, err
         }
         var filter func(IP) IP
         if net != "" && net[len(net)-1] == '4' {
                 filter = ipv4only
         }
-        if net != "" && net[len(net)-1] == '6' {
+        if net != "" && net[len(net)-1] == '6' || zone != "" {
                 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, parseZoneId(id)), nil
-}
-
-func parseZoneId(id string) int {
-        if id == "" {
+        return inetaddr(net, ip, portnum, zone), 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(id); err == nil {
+        if ifi, err := InterfaceByName(zone); err == nil {
                 return ifi.Index
         }
-        n, _, _ := dtoi(id, 0)
+        n, _, _ := dtoi(zone, 0)
         return n
 }