123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190 |
- // Copyright 2020 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.
- package netip_test
- import (
- "fmt"
- . "net/netip"
- "strconv"
- "strings"
- )
- // zeros is a slice of eight stringified zeros. It's used in
- // parseIPSlow to construct slices of specific amounts of zero fields,
- // from 1 to 8.
- var zeros = []string{"0", "0", "0", "0", "0", "0", "0", "0"}
- // parseIPSlow is like ParseIP, but aims for readability above
- // speed. It's the reference implementation for correctness checking
- // and against which we measure optimized parsers.
- //
- // parseIPSlow understands the following forms of IP addresses:
- // - Regular IPv4: 1.2.3.4
- // - IPv4 with many leading zeros: 0000001.0000002.0000003.0000004
- // - Regular IPv6: 1111:2222:3333:4444:5555:6666:7777:8888
- // - IPv6 with many leading zeros: 00000001:0000002:0000003:0000004:0000005:0000006:0000007:0000008
- // - IPv6 with zero blocks elided: 1111:2222::7777:8888
- // - IPv6 with trailing 32 bits expressed as IPv4: 1111:2222:3333:4444:5555:6666:77.77.88.88
- //
- // It does not process the following IP address forms, which have been
- // varyingly accepted by some programs due to an under-specification
- // of the shapes of IPv4 addresses:
- //
- // - IPv4 as a single 32-bit uint: 4660 (same as "1.2.3.4")
- // - IPv4 with octal numbers: 0300.0250.0.01 (same as "192.168.0.1")
- // - IPv4 with hex numbers: 0xc0.0xa8.0x0.0x1 (same as "192.168.0.1")
- // - IPv4 in "class-B style": 1.2.52 (same as "1.2.3.4")
- // - IPv4 in "class-A style": 1.564 (same as "1.2.3.4")
- func parseIPSlow(s string) (Addr, error) {
- // Identify and strip out the zone, if any. There should be 0 or 1
- // '%' in the string.
- var zone string
- fs := strings.Split(s, "%")
- switch len(fs) {
- case 1:
- // No zone, that's fine.
- case 2:
- s, zone = fs[0], fs[1]
- if zone == "" {
- return Addr{}, fmt.Errorf("netaddr.ParseIP(%q): no zone after zone specifier", s)
- }
- default:
- return Addr{}, fmt.Errorf("netaddr.ParseIP(%q): too many zone specifiers", s) // TODO: less specific?
- }
- // IPv4 by itself is easy to do in a helper.
- if strings.Count(s, ":") == 0 {
- if zone != "" {
- return Addr{}, fmt.Errorf("netaddr.ParseIP(%q): IPv4 addresses cannot have a zone", s)
- }
- return parseIPv4Slow(s)
- }
- normal, err := normalizeIPv6Slow(s)
- if err != nil {
- return Addr{}, err
- }
- // At this point, we've normalized the address back into 8 hex
- // fields of 16 bits each. Parse that.
- fs = strings.Split(normal, ":")
- if len(fs) != 8 {
- return Addr{}, fmt.Errorf("netaddr.ParseIP(%q): wrong size address", s)
- }
- var ret [16]byte
- for i, f := range fs {
- a, b, err := parseWord(f)
- if err != nil {
- return Addr{}, err
- }
- ret[i*2] = a
- ret[i*2+1] = b
- }
- return AddrFrom16(ret).WithZone(zone), nil
- }
- // normalizeIPv6Slow expands s, which is assumed to be an IPv6
- // address, to its canonical text form.
- //
- // The canonical form of an IPv6 address is 8 colon-separated fields,
- // where each field should be a hex value from 0 to ffff. This
- // function does not verify the contents of each field.
- //
- // This function performs two transformations:
- // - The last 32 bits of an IPv6 address may be represented in
- // IPv4-style dotted quad form, as in 1:2:3:4:5:6:7.8.9.10. That
- // address is transformed to its hex equivalent,
- // e.g. 1:2:3:4:5:6:708:90a.
- // - An address may contain one "::", which expands into as many
- // 16-bit blocks of zeros as needed to make the address its correct
- // full size. For example, fe80::1:2 expands to fe80:0:0:0:0:0:1:2.
- //
- // Both short forms may be present in a single address,
- // e.g. fe80::1.2.3.4.
- func normalizeIPv6Slow(orig string) (string, error) {
- s := orig
- // Find and convert an IPv4 address in the final field, if any.
- i := strings.LastIndex(s, ":")
- if i == -1 {
- return "", fmt.Errorf("netaddr.ParseIP(%q): invalid IP address", orig)
- }
- if strings.Contains(s[i+1:], ".") {
- ip, err := parseIPv4Slow(s[i+1:])
- if err != nil {
- return "", err
- }
- a4 := ip.As4()
- s = fmt.Sprintf("%s:%02x%02x:%02x%02x", s[:i], a4[0], a4[1], a4[2], a4[3])
- }
- // Find and expand a ::, if any.
- fs := strings.Split(s, "::")
- switch len(fs) {
- case 1:
- // No ::, nothing to do.
- case 2:
- lhs, rhs := fs[0], fs[1]
- // Found a ::, figure out how many zero blocks need to be
- // inserted.
- nblocks := strings.Count(lhs, ":") + strings.Count(rhs, ":")
- if lhs != "" {
- nblocks++
- }
- if rhs != "" {
- nblocks++
- }
- if nblocks > 7 {
- return "", fmt.Errorf("netaddr.ParseIP(%q): address too long", orig)
- }
- fs = nil
- // Either side of the :: can be empty. We don't want empty
- // fields to feature in the final normalized address.
- if lhs != "" {
- fs = append(fs, lhs)
- }
- fs = append(fs, zeros[:8-nblocks]...)
- if rhs != "" {
- fs = append(fs, rhs)
- }
- s = strings.Join(fs, ":")
- default:
- // Too many ::
- return "", fmt.Errorf("netaddr.ParseIP(%q): invalid IP address", orig)
- }
- return s, nil
- }
- // parseIPv4Slow parses and returns an IPv4 address in dotted quad
- // form, e.g. "192.168.0.1". It is slow but easy to read, and the
- // reference implementation against which we compare faster
- // implementations for correctness.
- func parseIPv4Slow(s string) (Addr, error) {
- fs := strings.Split(s, ".")
- if len(fs) != 4 {
- return Addr{}, fmt.Errorf("netaddr.ParseIP(%q): invalid IP address", s)
- }
- var ret [4]byte
- for i := range ret {
- val, err := strconv.ParseUint(fs[i], 10, 8)
- if err != nil {
- return Addr{}, err
- }
- ret[i] = uint8(val)
- }
- return AddrFrom4([4]byte{ret[0], ret[1], ret[2], ret[3]}), nil
- }
- // parseWord converts a 16-bit hex string into its corresponding
- // two-byte value.
- func parseWord(s string) (byte, byte, error) {
- ret, err := strconv.ParseUint(s, 16, 16)
- if err != nil {
- return 0, 0, err
- }
- return uint8(ret >> 8), uint8(ret), nil
- }
|