code review 6816116: net: support IPv6 scoped addressing zone

src/pkg/net/ip.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.
 
 // IP address manipulations
 //
 // IPv4 addresses are 4 bytes; IPv6 addresses are 16 bytes.
 // An IPv4 address can be converted to an IPv6 address by
 // adding a canonical prefix (10 zeros, 2 0xFFs).
-// This library accepts either size of byte array but always
+// This library accepts either size of byte slice but always
 // returns 16-byte addresses.
 
 package net
 
 // IP address lengths (bytes).
 const (
         IPv4len = 4
         IPv6len = 16
 )
 
-// An IP is a single IP address, an array of bytes.
+// An IP is a single IP address, a slice of bytes.
 // Functions in this package accept either 4-byte (IPv4)
-// or 16-byte (IPv6) arrays as input.
+// or 16-byte (IPv6) slices as input.
 //
 // Note that in this documentation, referring to an
 // IP address as an IPv4 address or an IPv6 address
 // is a semantic property of the address, not just the
-// length of the byte array: a 16-byte array can still
+// length of the byte slice: a 16-byte slice can still
 // be an IPv4 address.
 type IP []byte
 
 // An IP mask is an IP address.
 type IPMask []byte
 
 // An IPNet represents an IP network.
 type IPNet struct {
         IP   IP     // network number
         Mask IPMask // network mask
@@ skipping 176 matching lines @@
                 return nil
         }
         switch true {
         case ip[0] < 0x80:
                 return classAMask
         case ip[0] < 0xC0:
                 return classBMask
         default:
                 return classCMask
         }
-        return nil // not reached
 }
 
 func allFF(b []byte) bool {
         for _, c := range b {
                 if c != 0xff {
                         return false
                 }
         }
         return true
 }
@@ skipping 188 matching lines @@
         if l != len(nn) {
                 return false
         }
         for i := 0; i < l; i++ {
                 if nn[i]&m[i] != ip[i]&m[i] {
                         return false
                 }
         }
         return true
 }
+
+// Network returns the address's network name, "ip+net".
+func (n *IPNet) Network() string { return "ip+net" }
 
 // String returns the CIDR notation of n like "192.168.100.1/24"
 // or "2001:DB8::/48" as defined in RFC 4632 and RFC 4291.
 // If the mask is not in the canonical form, it returns the
 // string which consists of an IP address, followed by a slash
 // character and a mask expressed as hexadecimal form with no
 // punctuation like "192.168.100.1/c000ff00".
 func (n *IPNet) String() string {
         nn, m := networkNumberAndMask(n)
         if nn == nil || m == nil {
                 return "<nil>"
         }
         l := simpleMaskLength(m)
         if l == -1 {
                 return nn.String() + "/" + m.String()
         }
         return nn.String() + "/" + itod(uint(l))
 }
 
-// Network returns the address's network name, "ip+net".
-func (n *IPNet) Network() string { return "ip+net" }
-
 // Parse IPv4 address (d.d.d.d).
 func parseIPv4(s string) IP {
         var p [IPv4len]byte
         i := 0
         for j := 0; j < IPv4len; j++ {
                 if i >= len(s) {
                         // Missing octets.
                         return nil
                 }
                 if j > 0 {
@@ skipping 11 matching lines @@
                         return nil
                 }
                 p[j] = byte(n)
         }
         if i != len(s) {
                 return nil
         }
         return IPv4(p[0], p[1], p[2], p[3])
 }
 
-// Parse IPv6 address.  Many forms.
-// The basic form is a sequence of eight colon-separated
-// 16-bit hex numbers separated by colons,
-// as in 0123:4567:89ab:cdef:0123:4567:89ab:cdef.
-// Two exceptions:
-//      * A run of zeros can be replaced with "::".
-//      * The last 32 bits can be in IPv4 form.
-// Thus, ::ffff:1.2.3.4 is the IPv4 address 1.2.3.4.
-func parseIPv6(s string) IP {
-        p := make(IP, IPv6len)
+// parseIPv6 parses s as a literal IPv6 address described in RFC 4291
+// and RFC 5952.  It can also parse a literal scoped IPv6 address with
+// zone identifier which is described in RFC 4007 when zoneAllowed is
+// true.
+func parseIPv6(s string, zoneAllowed bool) (ip IP, zone string) {
+        ip = make(IP, IPv6len)
         ellipsis := -1 // position of ellipsis in p
         i := 0         // index in string s
+
+        if zoneAllowed {
+                s, zone = splitHostZone(s)
+        }
 
         // Might have leading ellipsis
         if len(s) >= 2 && s[0] == ':' && s[1] == ':' {
                 ellipsis = 0
                 i = 2
                 // Might be only ellipsis
                 if i == len(s) {
-                        return p
+                        return ip, zone
                 }
         }
 
         // Loop, parsing hex numbers followed by colon.
         j := 0
         for j < IPv6len {
                 // Hex number.
                 n, i1, ok := xtoi(s, i)
                 if !ok || n > 0xFFFF {
-                        return nil
+                        return nil, zone
                 }
 
                 // If followed by dot, might be in trailing IPv4.
                 if i1 < len(s) && s[i1] == '.' {
                         if ellipsis < 0 && j != IPv6len-IPv4len {
                                 // Not the right place.
-                                return nil
+                                return nil, zone
                         }
                         if j+IPv4len > IPv6len {
                                 // Not enough room.
-                                return nil
-                        }
-                        p4 := parseIPv4(s[i:])
-                        if p4 == nil {
-                                return nil
-                        }
-                        p[j] = p4[12]
-                        p[j+1] = p4[13]
-                        p[j+2] = p4[14]
-                        p[j+3] = p4[15]
+                                return nil, zone
+                        }
+                        ip4 := parseIPv4(s[i:])
+                        if ip4 == nil {
+                                return nil, zone
+                        }
+                        ip[j] = ip4[12]
+                        ip[j+1] = ip4[13]
+                        ip[j+2] = ip4[14]
+                        ip[j+3] = ip4[15]
                         i = len(s)
                         j += IPv4len
                         break
                 }
 
                 // Save this 16-bit chunk.
-                p[j] = byte(n >> 8)
-                p[j+1] = byte(n)
+                ip[j] = byte(n >> 8)
+                ip[j+1] = byte(n)
                 j += 2
 
                 // Stop at end of string.
                 i = i1
                 if i == len(s) {
                         break
                 }
 
                 // Otherwise must be followed by colon and more.
                 if s[i] != ':' || i+1 == len(s) {
-                        return nil
+                        return nil, zone
                 }
                 i++
 
                 // Look for ellipsis.
                 if s[i] == ':' {
                         if ellipsis >= 0 { // already have one
-                                return nil
+                                return nil, zone
                         }
                         ellipsis = j
                         if i++; i == len(s) { // can be at end
                                 break
                         }
                 }
         }
 
         // Must have used entire string.
         if i != len(s) {
-                return nil
+                return nil, zone
         }
 
         // If didn't parse enough, expand ellipsis.
         if j < IPv6len {
                 if ellipsis < 0 {
-                        return nil
+                        return nil, zone
                 }
                 n := IPv6len - j
                 for k := j - 1; k >= ellipsis; k-- {
-                        p[k+n] = p[k]
+                        ip[k+n] = ip[k]
                 }
                 for k := ellipsis + n - 1; k >= ellipsis; k-- {
-                        p[k] = 0
-                }
-        }
-        return p
+                        ip[k] = 0
+                }
+        }
+        return ip, zone
 }
 
 // A ParseError represents a malformed text string and the type of string that was expected.
 type ParseError struct {
         Type string
         Text string
 }
 
 func (e *ParseError) Error() string {
         return "invalid " + e.Type + ": " + e.Text
-}
-
-func parseIP(s string) IP {
-        if p := parseIPv4(s); p != nil {
-                return p
-        }
-        if p := parseIPv6(s); p != nil {
-                return p
-        }
-        return nil
 }
 
 // ParseIP parses s as an IP address, returning the result.
 // The string s can be in dotted decimal ("74.125.19.99")
 // or IPv6 ("2001:4860:0:2001::68") form.
 // If s is not a valid textual representation of an IP address,
 // ParseIP returns nil.
 func ParseIP(s string) IP {
-        if p := parseIPv4(s); p != nil {
-                return p
-        }
-        return parseIPv6(s)
-}
-
-// ParseCIDR parses s as a CIDR notation IP address and mask, like
-// "192.168.100.1/24", "2001:DB8::/48" or "2001:DB8::%en0/48" as
-// defined in RFC 4632, RFC 4291 and RFC 4007.
+        if ip := parseIPv4(s); ip != nil {
+                return ip
+        }
+        ip, _ := parseIPv6(s, false)
+        return ip
+}
+
+// ParseCIDR parses s as a CIDR notation IP address and mask,
+// like "192.168.100.1/24" or "2001:DB8::/48", as defined in
+// RFC 4632 and RFC 4291.
 //
-// It returns the IP address and the network implied by the IP and
-// mask.  For example, ParseCIDR("192.168.100.1/16") returns the IP
-// address 192.168.100.1 and the network 192.168.0.0/16.
+// It returns the IP address and the network implied by the IP
+// and mask.  For example, ParseCIDR("192.168.100.1/16") returns
+// the IP address 192.168.100.1 and the network 192.168.0.0/16.
 func ParseCIDR(s string) (IP, *IPNet, error) {
         i := byteIndex(s, '/')
         if i < 0 {
                 return nil, nil, &ParseError{"CIDR address", s}
         }
-        ipstr, maskstr := s[:i], s[i+1:]
-        // The IPv6 scoped addressing zone identifer starts after the
-        // last percent sign.
-        if i := last(ipstr, '%'); i > 0 {
-                // Just ignore it for now.
-                ipstr = ipstr[:i]
-        }
+        addr, mask := s[:i], s[i+1:]
         iplen := IPv4len
-        ip := parseIPv4(ipstr)
+        ip := parseIPv4(addr)
         if ip == nil {
                 iplen = IPv6len
-                ip = parseIPv6(ipstr)
-        }
-        n, i, ok := dtoi(maskstr, 0)
-        if ip == nil || !ok || i != len(maskstr) || n < 0 || n > 8*iplen {
+                ip, _ = parseIPv6(addr, false)
+        }
+        n, i, ok := dtoi(mask, 0)
+        if ip == nil || !ok || i != len(mask) || n < 0 || n > 8*iplen {
                 return nil, nil, &ParseError{"CIDR address", s}
         }
         m := CIDRMask(n, 8*iplen)
-        return ip, &IPNet{ip.Mask(m), m}, nil
-}
+        return ip, &IPNet{IP: ip.Mask(m), Mask: m}, nil
+}