mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-08 20:55:01 +00:00
191 lines
5.7 KiB
Go
191 lines
5.7 KiB
Go
// 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
|
|
}
|