Add IPFamilyOf(), etc

Often you want to test whether two IPs/CIDRs are of the same family,
without actually caring which family they are. While you can do this
by checking:

  if utilsnet.IsIPv6(ip) == utilsnet.IsIPv6CIDR(cidr) {

this is somewhat confusing to read and can look like it is checking
that they are both IPv6 if you read it quickly.

So add new functions so that you can do

  if utilsnet.IPFamilyOf(ip) == utilsnet.IPFamilyOfCIDR(cidr) {

Author: danwinship

net/ipfamily.go

@@ -106,62 +106,84 @@ func IsDualStackCIDRStrings(cidrs []string) (bool, error) {
 	return IsDualStackCIDRs(parsedCIDRs)
 }
 
-// IsIPv6 returns true if ip is IPv6, or false if it is IPv4, nil, or invalid.
-func IsIPv6(ip net.IP) bool {
-	return ip.To16() != nil && ip.To4() == nil
+// IPFamilyOf returns the IP family of ip, or IPFamilyUnknown if it is invalid.
+func IPFamilyOf(ip net.IP) IPFamily {
+	switch {
+	case ip.To4() != nil:
+		return IPv4
+	case ip.To16() != nil:
+		return IPv6
+	default:
+		return IPFamilyUnknown
+	}
+}
+
+// IPFamilyOfString returns the IP family of ip, or IPFamilyUnknown if ip cannot
+// be parsed as an IP.
+func IPFamilyOfString(ip string) IPFamily {
+	return IPFamilyOf(ParseIPSloppy(ip))
+}
+
+// IPFamilyOfCIDR returns the IP family of cidr.
+func IPFamilyOfCIDR(cidr *net.IPNet) IPFamily {
+	if cidr == nil {
+		return IPFamilyUnknown
+	}
+	return IPFamilyOf(cidr.IP)
+}
+
+// IPFamilyOfCIDRString returns the IP family of cidr.
+func IPFamilyOfCIDRString(cidr string) IPFamily {
+	ip, _, _ := ParseCIDRSloppy(cidr)
+	return IPFamilyOf(ip)
+}
+
+// IsIPv6 returns true if netIP is IPv6 (and false if it is IPv4, nil, or invalid).
+func IsIPv6(netIP net.IP) bool {
+	return IPFamilyOf(netIP) == IPv6
 }
 
 // IsIPv6String returns true if ip contains a single IPv6 address and nothing else. It
 // returns false if ip is an empty string, an IPv4 address, or anything else that is not a
 // single IPv6 address.
 func IsIPv6String(ip string) bool {
-	return IsIPv6(ParseIPSloppy(ip))
+	return IPFamilyOfString(ip) == IPv6
+}
+
+// IsIPv6CIDR returns true if a cidr is a valid IPv6 CIDR. It returns false if cidr is
+// nil or an IPv4 CIDR. Its behavior is not defined if cidr is invalid.
+func IsIPv6CIDR(cidr *net.IPNet) bool {
+	return IPFamilyOfCIDR(cidr) == IPv6
 }
 
 // IsIPv6CIDRString returns true if cidr contains a single IPv6 CIDR and nothing else. It
 // returns false if cidr is an empty string, an IPv4 CIDR, or anything else that is not a
 // single valid IPv6 CIDR.
 func IsIPv6CIDRString(cidr string) bool {
-	ip, _, _ := ParseCIDRSloppy(cidr)
-	return IsIPv6(ip)
-}
-
-// IsIPv6CIDR returns true if a cidr is a valid IPv6 CIDR. It returns false if cidr is
-// nil or an IPv4 CIDR. Its behavior is not defined if cidr is invalid.
-func IsIPv6CIDR(cidr *net.IPNet) bool {
-	if cidr == nil {
-		return false
-	}
-	ip := cidr.IP
-	return IsIPv6(ip)
+	return IPFamilyOfCIDRString(cidr) == IPv6
 }
 
-// IsIPv4 returns true if ip is IPv4, or false if it is IPv6, nil, or invalid.
-func IsIPv4(ip net.IP) bool {
-	return ip.To4() != nil
+// IsIPv4 returns true if netIP is IPv4 (and false if it is IPv6, nil, or invalid).
+func IsIPv4(netIP net.IP) bool {
+	return IPFamilyOf(netIP) == IPv4
 }
 
 // IsIPv4String returns true if ip contains a single IPv4 address and nothing else. It
 // returns false if ip is an empty string, an IPv6 address, or anything else that is not a
 // single IPv4 address.
 func IsIPv4String(ip string) bool {
-	return IsIPv4(ParseIPSloppy(ip))
+	return IPFamilyOfString(ip) == IPv4
 }
 
 // IsIPv4CIDR returns true if cidr is a valid IPv4 CIDR. It returns false if cidr is nil
 // or an IPv6 CIDR. Its behavior is not defined if cidr is invalid.
 func IsIPv4CIDR(cidr *net.IPNet) bool {
-	if cidr == nil {
-		return false
-	}
-	ip := cidr.IP
-	return IsIPv4(ip)
+	return IPFamilyOfCIDR(cidr) == IPv4
 }
 
 // IsIPv4CIDRString returns true if cidr contains a single IPv4 CIDR and nothing else. It
 // returns false if cidr is an empty string, an IPv6 CIDR, or anything else that is not a
 // single valid IPv4 CIDR.
 func IsIPv4CIDRString(cidr string) bool {
-	ip, _, _ := ParseCIDRSloppy(cidr)
-	return IsIPv4(ip)
+	return IPFamilyOfCIDRString(cidr) == IPv4
 }

net/ipfamily_test.go

@@ -228,7 +228,7 @@ func TestDualStackCIDRs(t *testing.T) {
 	}
 }
 
-func TestIsIPvXString(t *testing.T) {
+func TestIPFamilyOfString(t *testing.T) {
 	testCases := []struct {
 		desc   string
 		ip     string
@@ -352,9 +352,13 @@ func TestIsIPvXString(t *testing.T) {
 	}
 	for _, tc := range testCases {
 		t.Run(tc.desc, func(t *testing.T) {
+			family := IPFamilyOfString(tc.ip)
 			isIPv4 := IsIPv4String(tc.ip)
 			isIPv6 := IsIPv6String(tc.ip)
 
+			if family != tc.family {
+				t.Errorf("Expect %q family %q, got %q", tc.ip, tc.family, family)
+			}
 			if isIPv4 != (tc.family == IPv4) {
 				t.Errorf("Expect %q ipv4 %v, got %v", tc.ip, tc.family == IPv4, isIPv6)
 			}
@@ -392,7 +396,7 @@ func mustParseCIDRMask(cidrstr string) net.IPMask {
 	return cidr.Mask
 }
 
-func TestIsIPvX(t *testing.T) {
+func TestIsIPFamilyOf(t *testing.T) {
 	testCases := []struct {
 		desc   string
 		ip     net.IP
@@ -506,9 +510,13 @@ func TestIsIPvX(t *testing.T) {
 	}
 	for _, tc := range testCases {
 		t.Run(tc.desc, func(t *testing.T) {
+			family := IPFamilyOf(tc.ip)
 			isIPv4 := IsIPv4(tc.ip)
 			isIPv6 := IsIPv6(tc.ip)
 
+			if family != tc.family {
+				t.Errorf("Expect family %q, got %q", tc.family, family)
+			}
 			if isIPv4 != (tc.family == IPv4) {
 				t.Errorf("Expect ipv4 %v, got %v", tc.family == IPv4, isIPv6)
 			}
@@ -519,7 +527,7 @@ func TestIsIPvX(t *testing.T) {
 	}
 }
 
-func TestIsIPvXCIDR(t *testing.T) {
+func TestIPFamilyOfCIDR(t *testing.T) {
 	testCases := []struct {
 		desc   string
 		cidr   string
@@ -619,9 +627,13 @@ func TestIsIPvXCIDR(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.desc, func(t *testing.T) {
+			family := IPFamilyOfCIDRString(tc.cidr)
 			isIPv4 := IsIPv4CIDRString(tc.cidr)
 			isIPv6 := IsIPv6CIDRString(tc.cidr)
 
+			if family != tc.family {
+				t.Errorf("Expect family %v, got %v", tc.family, family)
+			}
 			if isIPv4 != (tc.family == IPv4) {
 				t.Errorf("Expect %q ipv4 %v, got %v", tc.cidr, tc.family == IPv4, isIPv6)
 			}
@@ -630,8 +642,12 @@ func TestIsIPvXCIDR(t *testing.T) {
 			}
 
 			_, parsed, _ := ParseCIDRSloppy(tc.cidr)
+			familyParsed := IPFamilyOfCIDR(parsed)
 			isIPv4Parsed := IsIPv4CIDR(parsed)
 			isIPv6Parsed := IsIPv6CIDR(parsed)
+			if familyParsed != family {
+				t.Errorf("%q gives different results for IPFamilyOfCIDR (%v) and IPFamilyOfCIDRString (%v)", tc.cidr, familyParsed, family)
+			}
 			if isIPv4Parsed != isIPv4 {
 				t.Errorf("%q gives different results for IsIPv4CIDR (%v) and IsIPv4CIDRString (%v)", tc.cidr, isIPv4Parsed, isIPv4)
 			}

net/port.go

@@ -58,17 +58,18 @@ func NewLocalPort(desc, ip string, ipFamily IPFamily, port int, protocol Protoco
 	if protocol != TCP && protocol != UDP {
 		return nil, fmt.Errorf("Unsupported protocol %s", protocol)
 	}
-	if ipFamily != "" && ipFamily != "4" && ipFamily != "6" {
+	if ipFamily != IPFamilyUnknown && ipFamily != IPv4 && ipFamily != IPv6 {
 		return nil, fmt.Errorf("Invalid IP family %s", ipFamily)
 	}
 	if ip != "" {
 		parsedIP := ParseIPSloppy(ip)
 		if parsedIP == nil {
 			return nil, fmt.Errorf("invalid ip address %s", ip)
 		}
-		asIPv4 := parsedIP.To4()
-		if asIPv4 == nil && ipFamily == IPv4 || asIPv4 != nil && ipFamily == IPv6 {
-			return nil, fmt.Errorf("ip address and family mismatch %s, %s", ip, ipFamily)
+		if ipFamily != IPFamilyUnknown {
+			if IPFamily(parsedIP) != ipFamily {
+				return nil, fmt.Errorf("ip address and family mismatch %s, %s", ip, ipFamily)
+			}
 		}
 	}
 	return &LocalPort{Description: desc, IP: ip, IPFamily: ipFamily, Port: port, Protocol: protocol}, nil