v0.2.1

FIXED:
* host splitter wasn't working quite correctly; this has been fixed.

netsplit/funcs.go

@@ -193,25 +193,26 @@ func CheckReserved(nets []*netip.Prefix, revRecursive, recursive, excludePrivate
 				reservations = make(map[netip.Prefix]*IANAAddrNetResRecord)
 			}
 			reservations[*n] = res
-			if !revRecursive && !recursive {
-				continue
-			}
-			for p, r := range reserved {
-				// This... *should* be safe? I don't think any reservations overlap.
-				// Anyways, revRecursive works because n.Addr() returns the network address, which should be the canonical boundary.
-				// recursive works for the same reason, just the other end.
-				// Math!
-				if revRecursive && p.Contains(n.Addr()) {
-					if reservations == nil {
-						reservations = make(map[netip.Prefix]*IANAAddrNetResRecord)
-					}
-					reservations[p] = r
-				} else if recursive && n.Contains(p.Addr()) {
-					if reservations == nil {
-						reservations = make(map[netip.Prefix]*IANAAddrNetResRecord)
-					}
-					reservations[p] = r
+		}
+		if !revRecursive && !recursive {
+			continue
+		}
+		for p, r := range reserved {
+			// This... *should* be safe? I don't think any reservations overlap.
+			// Anyways, revRecursive works because n.Addr() returns the network address, which should be the canonical boundary.
+			// recursive works for the same reason, just the other end.
+			// Math!
+			if revRecursive && p.Contains(n.Addr()) {
+				if reservations == nil {
+					reservations = make(map[netip.Prefix]*IANAAddrNetResRecord)
 				}
+				reservations[p] = r
+			}
+			if recursive && n.Bits() < p.Bits() && n.Contains(p.Addr()) {
+				if reservations == nil {
+					reservations = make(map[netip.Prefix]*IANAAddrNetResRecord)
+				}
+				reservations[p] = r
 			}
 		}
 	}
@@ -223,7 +224,7 @@ func CheckReserved(nets []*netip.Prefix, revRecursive, recursive, excludePrivate
 func Contain(origPfx *netip.Prefix, nets []*netip.Prefix, remaining *netipx.IPSet, splitter NetSplitter) (s *StructuredResults, err error) {
 
 	var rem []netip.Prefix
-	var reserved map[netip.Prefix]*IANAAddrNetResRecord
+	// var reserved map[netip.Prefix]*IANAAddrNetResRecord
 	var sr = StructuredResults{
 		Original: origPfx,
 	}
@@ -276,19 +277,21 @@ func Contain(origPfx *netip.Prefix, nets []*netip.Prefix, remaining *netipx.IPSe
 		}
 	}
 
-	if nets != nil {
-		if reserved, err = CheckReserved(nets, true, true, false); err != nil {
-			return
-		}
-		if reserved != nil && len(reserved) > 0 {
-			s.Reservations = make([]*IANAAddrNetResRecord, len(reserved))
-			idx := 0
-			for _, r := range reserved {
-				s.Reservations[idx] = r
-				idx++
+	/*
+		if nets != nil {
+			if reserved, err = CheckReserved(nets, true, true, false); err != nil {
+				return
+			}
+			if reserved != nil && len(reserved) > 0 {
+				s.Reservations = make([]*IANAAddrNetResRecord, len(reserved))
+				idx := 0
+				for _, r := range reserved {
+					s.Reservations[idx] = r
+					idx++
+				}
 			}
 		}
-	}
+	*/
 
 	s = &sr
 
@@ -377,27 +380,105 @@ func MaskInvert(mask net.IPMask) (inverted net.IPMask) {
 	return
 }
 
+/*
+	NumAddrsIn returns the number of addresses in a given prefix length
+	and inet family.
+
+	If isIpv6 is false, it is assumed to be IPv4 (...duh).
+
+	inclNet and inclBcast have the same meanings as in NumAddrsNet and NumAddrsPfx.
+
+	Note that for the single-host prefix (/32 for IPv4, /128 for IPv6), numAddrs will *always* be 1.
+	For point-to-point prefix (IPv4 /31, IPv6 /127), numAddrs will *ALWAYS* be 2.
+*/
+func NumAddrsIn(prefixLen uint8, isIpv6, inclNet, inclBcast bool) (numAddrs *big.Int, err error) {
+
+	var numBits uint
+	var numRemoved int64
+	var maxBitLen uint8 = maxBitsv4
+
+	if isIpv6 {
+		maxBitLen = maxBitsv6
+	}
+	if prefixLen > maxBitLen {
+		err = ErrBadPrefixLen
+		return
+	}
+	if prefixLen == maxBitLen {
+		numAddrs = big.NewInt(1)
+		return
+	}
+	if (prefixLen + 1) == maxBitLen {
+		numAddrs = big.NewInt(2)
+		return
+	}
+
+	numBits = uint(maxBitLen - prefixLen)
+
+	numAddrs = new(big.Int).Lsh(big.NewInt(1), numBits)
+
+	if !inclNet {
+		numRemoved++
+	}
+	if !inclBcast {
+		numRemoved++
+	}
+	if numRemoved > 0 {
+		_ = numAddrs.Sub(numAddrs, big.NewInt(numRemoved))
+	}
+
+	return
+}
+
 /*
 NumAddrsNet returns the number of IP addresses in a net.IPNet.
 
-# The network address is included in the count if inclNet is true, otherwise it is excluded
+The network address is included in the count if inclNet is true, otherwise it is excluded.
 
-Only assignable addresses ("hosts") are considered if hostsOnly is true,
-otherwise all addresses are counted (depending on inclNet).
+The broadcast (or reserved broadcast, in the case of IPv6) address will be included in
+the count if inclBcast is true, otherwise it is excluded.
+
+numAddrs will be nil if pfx is nil or invalid.
 */
-func NumAddrsNet(pfx *net.IPNet, inclNet, hostsOnly bool) (numAddrs *big.Int) {
+func NumAddrsNet(pfx *net.IPNet, inclNet, inclBcast bool) (numAddrs *big.Int) {
+
+	var nPfx netip.Prefix
+	var ok bool
 
 	if pfx == nil {
 		return
 	}
+	if nPfx, ok = netipx.FromStdIPNet(pfx); !ok {
+		return
+	}
 
-	// TODO
+	numAddrs = NumAddrsPfx(nPfx, inclNet, inclBcast)
 
 	return
 }
 
 // NumAddrsPfx is the exact same as NumAddrsNet but for a net/netip.Prefix instead.
-// TODO
+func NumAddrsPfx(pfx netip.Prefix, inclNet, inclBcast bool) (numAddrs *big.Int) {
+
+	var numBits uint
+	var numRemoved int64
+
+	numBits = uint(pfx.Addr().BitLen() - pfx.Bits())
+
+	numAddrs = new(big.Int).Lsh(big.NewInt(1), numBits)
+
+	if !inclNet {
+		numRemoved++
+	}
+	if !inclBcast {
+		numRemoved++
+	}
+	if numRemoved > 0 {
+		_ = numAddrs.Sub(numAddrs, big.NewInt(numRemoved))
+	}
+
+	return
+}
 
 /*
 NumNets returns the number of times prefix size subnet fits into prefix size network.