Add ParseAddr, ParsePrefix to netutilsv2

danwinship · danwinship · commit f39235b1b9d2 · 2025-07-28T20:32:29.000-04:00
diff --git a/net/v2/ipfamily_test.go b/net/v2/ipfamily_test.go
@@ -91,7 +91,7 @@ func TestIsDualStack(t *testing.T) {
 			addrs := make([]netip.Addr, len(tc.ips))
 			for i := range tc.ips {
 				netips[i], _ = ParseIP(tc.ips[i])
-				addrs[i], _ = netip.ParseAddr(tc.ips[i])
+				addrs[i], _ = ParseAddr(tc.ips[i])
 			}
 
 			dualStack := IsDualStack(tc.ips)
@@ -180,7 +180,7 @@ func TestIsDualStackCIDRs(t *testing.T) {
 			prefixes := make([]netip.Prefix, len(tc.cidrs))
 			for i := range tc.cidrs {
 				ipnets[i], _ = ParseIPNet(tc.cidrs[i])
-				prefixes[i], _ = netip.ParsePrefix(tc.cidrs[i])
+				prefixes[i], _ = ParsePrefix(tc.cidrs[i])
 			}
 
 			dualStack := IsDualStackCIDRs(tc.cidrs)
diff --git a/net/v2/ips_test.go b/net/v2/ips_test.go
@@ -50,6 +50,7 @@ type testIP struct {
 //
 // Parsing tests (unless `skipParse: true`):
 //   - Each element of .strings should parse to a value equal to .ips[0].
+//   - Each element of .strings should parse to a value equal to .addrs[0].
 //
 // Conversion tests (unless `skipConvert: true`):
 //   - Each element of .ips should convert to a value equal to .addrs[0].
@@ -184,6 +185,8 @@ var goodTestIPs = []testIP{
 		desc: "IPv4-mapped IPv6",
 		// net.IP can represent an IPv4 address internally as either a 4-byte
 		// value or a 16-byte value, but it treats the two forms as equivalent.
+		// Because IPv4-mapped IPv6 is annoying, we make our ParseAddr() behave
+		// this way too, even though that's *not* how netip.ParseAddr() behaves.
 		//
 		// This test case confirms that:
 		//   - The 4-byte and 16-byte forms of a given net.IP compare as .Equal().
@@ -377,6 +380,7 @@ type testCIDR struct {
 //
 // Parsing tests (unless `skipParse: true`):
 //   - Each element of .strings should parse to a value "equal" to .ipnets[0].
+//   - Each element of .strings should parse to a value equal to .prefixes[0].
 //
 // Conversion tests (unless `skipConvert: true`):
 //   - Each element of .ipnets should convert to a value equal to .prefixes[0].
diff --git a/net/v2/parse.go b/net/v2/parse.go
@@ -19,6 +19,7 @@ package net
 import (
 	"fmt"
 	"net"
+	"net/netip"
 
 	forkednet "k8s.io/utils/internal/third_party/forked/golang/net"
 )
@@ -28,6 +29,8 @@ import (
 // non-validated input strings. It should be used instead of net.ParseIP (which rejects
 // some strings we need to accept for backward compatibility) and the old
 // netutilsv1.ParseIPSloppy.
+//
+// Compare ParseAddr, which returns a netip.Addr but is otherwise identical.
 func ParseIP(ipStr string) (net.IP, error) {
 	// Note: if we want to get rid of forkednet, we should be able to use some
 	// invocation of regexp.ReplaceAllString to get rid of leading 0s in ipStr.
@@ -47,6 +50,25 @@ func ParseIP(ipStr string) (net.IP, error) {
 	return nil, fmt.Errorf("not a valid IP address")
 }
 
+// ParseAddr parses an IPv4 or IPv6 address to a netip.Addr. This accepts both fully-valid
+// IP addresses and irregular/ambiguous forms, making it usable for both validated and
+// non-validated input strings. As compared to netip.ParseAddr:
+//
+//   - It accepts IPv4 IPs with extra leading "0"s, for backward compatibility.
+//   - It rejects IPs with attached zone identifiers (e.g. `"fe80::1234%eth0"`).
+//   - It converts "IPv4-mapped IPv6" addresses (e.g. `"::ffff:1.2.3.4"`) to the
+//     corresponding "plain" IPv4 values (e.g. `"1.2.3.4"`). That is, it never returns an
+//     address for which `Is4In6()` would return `true`.
+//
+// Compare ParseIP, which returns a net.IP but is otherwise identical.
+func ParseAddr(ipStr string) (netip.Addr, error) {
+	// To ensure identical parsing, we use ParseIP and then convert. (If ParseIP
+	// returns a nil ip, AddrFromIP will convert that to the zero/invalid netip.Addr,
+	// which is what we want.)
+	ip, err := ParseIP(ipStr)
+	return AddrFromIP(ip), err
+}
+
 // ParseIPNet parses an IPv4 or IPv6 CIDR string representing a subnet or mask, to a
 // *net.IPNet. This accepts both fully-valid CIDR values and irregular/ambiguous forms,
 // making it usable for both validated and non-validated input strings. It should be used
@@ -56,6 +78,8 @@ func ParseIP(ipStr string) (net.IP, error) {
 // The return value is equivalent to the second return value from net.ParseCIDR. Note that
 // this means that if the CIDR string has bits set beyond the prefix length (e.g., the "5"
 // in "192.168.1.5/24"), those bits are simply discarded.
+//
+// Compare ParsePrefix, which returns a netip.Prefix but is otherwise identical.
 func ParseIPNet(cidrStr string) (*net.IPNet, error) {
 	// Note: if we want to get rid of forkednet, we should be able to use some
 	// invocation of regexp.ReplaceAllString to get rid of leading 0s in cidrStr.
@@ -73,3 +97,25 @@ func ParseIPNet(cidrStr string) (*net.IPNet, error) {
 	}
 	return nil, fmt.Errorf("not a valid CIDR value")
 }
+
+// ParsePrefix parses an IPv4 or IPv6 CIDR string representing a subnet or mask, to a
+// netip.Prefix. This accepts both fully-valid CIDR values and irregular/ambiguous forms,
+// making it usable for both validated and non-validated input strings. As compared to
+// netip.ParsePrefix:
+//
+//   - It accepts IPv4 IPs with extra leading "0"s, for backward compatibility.
+//   - It converts "IPv4-mapped IPv6" addresses (e.g. `"::ffff:1.2.3.0/120"`) to the
+//     corresponding "plain" IPv4 values (e.g. `"1.2.3.0/24"`). That is, it never returns
+//     a prefix for which `.Addr().Is4In6()` would return `true`.
+//   - When given a CIDR string with bits set beyond the prefix length, like
+//     `"192.168.1.5/24"`, it discards those extra bits (the equivalent of calling
+//     .Masked() on the return value of netip.ParsePrefix).
+//
+// Compare ParseIPNet, which returns a *net.IPNet but is otherwise identical.
+func ParsePrefix(cidrStr string) (netip.Prefix, error) {
+	// To ensure identical parsing, we use ParseIPNet and then convert. (If ParseIPNet
+	// returns nil, PrefixFromIPNet will convert that to the zero/invalid
+	// netip.Prefix, which is what we want.)
+	ipnet, err := ParseIPNet(cidrStr)
+	return PrefixFromIPNet(ipnet), err
+}
diff --git a/net/v2/parse_test.go b/net/v2/parse_test.go
@@ -71,6 +71,56 @@ func TestParseIP(t *testing.T) {
 	}
 }
 
+func TestParseAddr(t *testing.T) {
+	// See test cases in ips_test.go
+	for _, tc := range goodTestIPs {
+		if tc.skipParse {
+			continue
+		}
+		t.Run(tc.desc, func(t *testing.T) {
+			for i, str := range tc.strings {
+				addr, err := ParseAddr(str)
+				if err != nil {
+					t.Errorf("expected %q to parse, but got error %v", str, err)
+				}
+				if addr != tc.addrs[0] {
+					t.Errorf("expected string %d %q to parse equal to Addr %#v %q but got %#v (%q)", i+1, str, tc.addrs[0], tc.addrs[0].String(), addr, addr.String())
+				}
+			}
+		})
+	}
+
+	for _, tc := range badTestIPs {
+		if tc.skipParse {
+			continue
+		}
+		t.Run(tc.desc, func(t *testing.T) {
+			for i, ip := range tc.ips {
+				errStr := ip.String()
+				parsedAddr, err := ParseAddr(errStr)
+				if err == nil {
+					t.Errorf("expected IP %d %#v (%q) to not re-parse but got %#v (%q)", i+1, ip, errStr, parsedAddr, parsedAddr.String())
+				}
+			}
+
+			for i, addr := range tc.addrs {
+				errStr := addr.String()
+				parsedAddr, err := ParseAddr(errStr)
+				if err == nil {
+					t.Errorf("expected Addr %d %#v (%q) to not re-parse but got %#v (%q)", i+1, addr, errStr, parsedAddr, parsedAddr.String())
+				}
+			}
+
+			for i, str := range tc.strings {
+				addr, err := ParseAddr(str)
+				if err == nil {
+					t.Errorf("expected string %d %q to not parse but got %#v (%q)", i+1, str, addr, addr.String())
+				}
+			}
+		})
+	}
+}
+
 func TestParseIPNet(t *testing.T) {
 	// See test cases in ips_test.go
 	for _, tc := range goodTestCIDRs {
@@ -121,3 +171,54 @@ func TestParseIPNet(t *testing.T) {
 		})
 	}
 }
+
+func TestParsePrefix(t *testing.T) {
+	// See test cases in ips_test.go
+	for _, tc := range goodTestCIDRs {
+		if tc.skipParse {
+			continue
+		}
+		t.Run(tc.desc, func(t *testing.T) {
+			for i, str := range tc.strings {
+				prefix, err := ParsePrefix(str)
+				if err != nil {
+					t.Errorf("expected %q to parse, but got error %v", str, err)
+				}
+				if prefix != tc.prefixes[0] {
+					t.Errorf("expected string %d %q to parse equal to Prefix %#v %q but got %#v (%q)", i+1, str, tc.prefixes[0], tc.prefixes[0].String(), prefix, prefix.String())
+				}
+			}
+		})
+	}
+
+	// See test cases in ips_test.go
+	for _, tc := range badTestCIDRs {
+		if tc.skipParse {
+			continue
+		}
+		t.Run(tc.desc, func(t *testing.T) {
+			for i, ipnet := range tc.ipnets {
+				errStr := ipnet.String()
+				parsedPrefix, err := ParsePrefix(errStr)
+				if err == nil {
+					t.Errorf("expected IPNet %d %q to not parse but got %#v (%q)", i+1, errStr, parsedPrefix, parsedPrefix.String())
+				}
+			}
+
+			for i, prefix := range tc.prefixes {
+				errStr := prefix.String()
+				parsedPrefix, err := ParsePrefix(errStr)
+				if err == nil {
+					t.Errorf("expected Prefix %d %q to not parse but got %#v (%q)", i+1, errStr, parsedPrefix, parsedPrefix.String())
+				}
+			}
+
+			for i, str := range tc.strings {
+				prefix, err := ParsePrefix(str)
+				if err == nil {
+					t.Errorf("expected string %d %q to not parse but got %#v (%q)", i+1, str, prefix, prefix.String())
+				}
+			}
+		})
+	}
+}
