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
-        Zone string // IPv6 scoped addressing zone
 }
 
 // IPv4 returns the IP address (in 16-byte form) of the
 // IPv4 address a.b.c.d.
 func IPv4(a, b, c, d byte) IP {
         p := make(IP, IPv6len)
         copy(p, v4InV6Prefix)
         p[12] = a
         p[13] = b
         p[14] = c
@@ skipping 166 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 189 matching lines @@
                 return false
         }
         for i := 0; i < l; i++ {
                 if nn[i]&m[i] != ip[i]&m[i] {
                         return false
                 }
         }
         return true
 }
 
-// String returns the CIDR notation of n like "192.168.100.1/24",
-// "2001:db8::/48" or "fe80::%en0/64" as defined in RFC 4632, RFC 4291
-// and RFC 4007.  If the mask is not in the canonical form, it returns
-// the string which consists of an IP address, followed by a slash
+// 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>"
         }
-        s := nn.String()
-        if n.Zone != "" {
-                s += "%" + n.Zone
-        }
         l := simpleMaskLength(m)
         if l == -1 {
-                return s + "/" + m.String()
-        }
-        return s + "/" + itod(uint(l))
-}
-
-// Network returns the address's network name, "ip+net".
-func (n *IPNet) Network() string { return "ip+net" }
+                return nn.String() + "/" + m.String()
+        }
+        return nn.String() + "/" + itod(uint(l))
+}
 
 // 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
                 }
@@ skipping 12 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, string) {
-        // The IPv6 scoped addressing zone identifer starts after the
-        // last percent sign.
-        var zone string
-        if i := last(s, '%'); i > 0 {
-                s, zone = s[:i], s[i+1:]
-        }
-
-        ip := 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 ip, zone
                 }
         }
@@ skipping 83 matching lines @@
 // 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
 }
 
-// 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.
+// 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 ip := parseIPv4(s); ip != nil {
                 return ip
         }
-        ip, _ := parseIPv6(s)

[rsc, 2012/12/06 04:43:41]

Since we cannot return the %en0 from this function, I would like to reject it
rather than silently discard it. That is, I would like to preserve the old
behavior.

Can you pass a flag into parseIPv6 specifying whether a zone is allowed?
Or maybe, if the only place it's allowed is ParseCIDR, ParseCIDR could take care
of the zone itself.

[mikio, 2012/12/11 03:28:18]

Done.

+        ip, _ := parseIPv6(s, false)
         return ip
 }
 
-// ParseCIDR parses s as a CIDR notation IP address and mask, like
-// "192.168.100.1/24", "2001:db8::/48" or "fe80::1%en0", as defined in
-// RFC 4632, RFC 4291 and RFC 4007.  It returns the IP address and the
-// network implied by the IP, mask and IPv6 scoped addressing zone.
+// 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.
 //
-// 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}
         }
         addr, mask := s[:i], s[i+1:]
-        var zone string
         iplen := IPv4len
         ip := parseIPv4(addr)
         if ip == nil {
                 iplen = IPv6len
-                ip, zone = parseIPv6(addr)
+                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: ip.Mask(m), Mask: m, Zone: zone}, nil
-}
+        return ip, &IPNet{IP: ip.Mask(m), Mask: m}, nil
+}