v0.2.2

FIXED:
* Validations for all were missing. They aren't now.
* Fixed a busted validator for explicit net

README.adoc

@@ -39,7 +39,7 @@ A tool to assist in design of segregate/segment/split/subnet networks.
 ** For IPv4 addresses, it will be `true` if it is an APIPA (_Automatic Private IP Addressing_) address ({rfc}3927[RFC 3927^]) (in the `169.254.0.0/16` range).
 * `First` and `Last` refer to the first and last "usable" ("host"/assignable) addresses in a subnet/network.
 ** Note that for IPv6, the first address (`x::`) in a subnet *may* or *may not* be assignable/"usable". If it is assigned to a device, that device *must* be a router for anycast. See {rfc}4291#section-2.6.1[RFC 4291 § 2.6.1^] for details. In the interest of convenience, `subnetter` will report this address as *not usable/addressable* in ranges for this reason as it is technically not a "host" address.
-** Note that for IPv6, some subnetting calculators erroneously report the last address for /64's (e.g. `x:ffff:ffff:ffff:ffff/64`) as usable. They are actually reserved in strictly RFC-compliant networks for EUI-64 reasons (per {rfc}2526[RFC 2526^]). For this reason, *if and only if* a prefix is a /64 *exactly*, `subnetter` will use `x:ffff:ffff:ffff:fffe` as the last host address.
+** Note that for IPv6, some subnetting calculators erroneously report the last address as usable. They are reserved in strictly RFC-compliant networks for anycast reasons (per {rfc}2526[RFC 2526^]). Subnetter follows RFC as closely as possible, and any deviation from RFC is considered a bug -- as such, the last address of IPv6 subnets is considered *not usable/addressable*.
 ** There are additional restrictions for /64 subnets, but they fall earlier in the range. These are *not explicitly excluded* in the usable host range, nor are they excluded from the total host count.
 * Private networks ({rfc}1918[RFC 1918^]), ULA prefixes ({rfc}4193[RFC 4193^]), and documentation prefixes ({rfc}3849[RFC 3849^], {rfc}5737[RFC 5737^], {rfc}9637[RFC 9637^]) are treated as "normal" networks (in that it is allowed to subnet them).
 * Various other reserved IPv4 and IPv6 addresses/networks will print warnings with their corresponding RFC(s) (unless `-R`/`--allow-reserved` is specified) if they are specified as/included in the initial prefix/network. ({rfc}6890[RFC 6890^] and its update via {rfc}8190[RFC 8190^] are useful summaries.) Note that for checking to function, an Internet connection is required as it pulls it directly from IANA live to ensure the data is accurate to standards. This may be cached locally if `-c`/`--cache-reservations` is specified, in which case a locally-cached copy will be used if present and populated then used if not.

cmd/subnetter/args.go

@@ -2,11 +2,12 @@ package main
 
 type Args struct {
 	Version         verArgs         `command:"version" alias:"v" description:"Show version information." validate:"omitempty"`
-	SplitCIDR       SplitCIDRArgs   `command:"split-cidr" alias:"se" description:"Split a network into as many equal subnets of prefix size N as possible." validate:"omitempty"`
-	SplitHost       SplitHostArgs   `command:"split-hosts" alias:"sh" description:"Split a network into N total number of hosts *per subnet* as cleanly/evenly as possible. (VERY easy to run out of memory for IPv6 prefixes; be sure to specify very small network!)" validate:"omitempty"`
+	SplitCIDR       SplitCIDRArgs   `command:"split-cidr" alias:"sc" description:"Split a network into as many equal subnets of prefix size N as possible." validate:"omitempty"`
+	SplitHost       SplitHostArgs   `command:"split-hosts" alias:"sh" description:"Split a network into N total number of hosts *per subnet* as cleanly/evenly as possible." validate:"omitempty"`
 	SplitSubnets    SplitSubnetArgs `command:"split-nets" alias:"sn" description:"Split a network into N number of subnets as cleanly as possible." validate:"omitempty"`
-	VLSM            VLSMArgs        `command:"vlsm" alias:"sv" description:"Use VLSM (Variable-Length Subnet Masks) to split a network into differently sized subnets." validate:"omitempty"`
-	ExplicitNetwork XNetArgs        `command:"net" alias:"xn" description:"Print information about an explicit network address." validate:"omitempty"`
+	VLSM            VLSMArgs        `command:"split-vlsm" alias:"sv" alias:"vlsm" description:"Use VLSM (Variable-Length Subnet Masks) to split a network into differently sized subnets." validate:"omitempty"`
+	ExplicitNetwork XNetArgs        `command:"net" alias:"xn" alias:"net" description:"Print information about an explicit network address." validate:"omitempty"`
+	NumNets         NNetArgs        `command:"num-nets" alias:"nn" alias:"nets" description:"Return the number of subnets of a given size that can fit into a given network size. This is MUCH, MUCH FASTER than splitting (if you do not need addressing)." validate:"omitempty"`
 	Parse           ParseArgs       `command:"parse" alias:"p" alias:"read" alias:"convert" description:"Parse/convert output from a previous subnetter run." validate:"omitempty"`
 	Table           TableArgs       `command:"table" alias:"t" alias:"tab" alias:"tbl" description:"Show prefix summaries (by default both IPv4 and IPv6)." validate:"omitempty"`
 	Check           CheckArgs       `command:"reserved" alias:"r" description:"Check if a subnet is reserved per IANA/RFC." validate:"omitempty"`
@@ -16,7 +17,7 @@ type verArgs struct {
 	DetailVersion bool `short:"V" long:"detail" description:"Print detailed version info and exit."`
 }
 
-type common struct {
+type commonBase struct {
 	cacheArgs
 	SuppressRemaining bool   `short:"r" long:"no-remaining" description:"Don't show leftover/unallocated/remaining space."`
 	Plain             bool   `short:"p" long:"plain" description:"Show plain output instead of unicode (only used if -f/--format=pretty)."`
@@ -26,13 +27,17 @@ type common struct {
 	AllowReserved     bool   `short:"R" long:"allow-reserved" description:"If specified, do not warn about reserved IP addresses/networks."`
 	reservedArgs
 	AllowHostNet bool `short:"H" long:"allow-host" description:"If specified, do not warn about host bits. Host bits are always removed for subnetting (as otherwise there would be errors); this is only used only for output."`
+}
+
+type common struct {
+	commonBase
 	Network Net `positional-args:"yes" required:"true" description:"The network/parent prefix to operate on." validate:"required"`
 }
 
 type reservedArgs struct {
 	NoRecursive    bool `short:"u" long:"no-recursive" description:"Don't show reservations that are children subnets of the subnet(s). Only if -f/--format=pretty, always false for other formats."`
-	NoRevRecursive bool `short:"U" long:"no-rev-recursive" description:"Don't show reservations that are parents of the subnet(s). Only if -f/--format=pretty, always false for other formats."`
-	NoPrivate      bool `short:"e" long:"no-private" description:"Consider private subnets of the subnet(s) to be reserved. If you are subnetting private address space, you probably want to leave this disabled. Only if -f/--format=pretty, always true otherwise."`
+	NoRevRecursive bool `short:"U" long:"no-rev-recursive" description:"Don't show reservations that are parents of the subnet(s) -- you almost definitely don't want to suppress this. Only if -f/--format=pretty, always false for other formats."`
+	NoPrivate      bool `short:"e" long:"no-private" description:"Consider private subnets to be reserved. If you are subnetting private address space, you probably want to leave this disabled. Only if -f/--format=pretty, always true otherwise."`
 }
 
 type splitArgs struct {
@@ -44,8 +49,17 @@ type cacheArgs struct {
 	DoResCache bool   `short:"c" long:"cache-reservations" env:"SBNTR_RSVCACHE" description:"Enable caching/cache lookup for reservation data."`
 }
 
+type NNetArgs struct {
+	Verbose   bool `short:"v" long:"verbose" description:"Be verbose (more ideal for logging)."`
+	NoV6Check bool `short:"6" long:"no-v6" description:"If specified, do not indicate if the subnetting is IPv6 only (true) or not (false; dual-stack/IPv4 supported)."`
+	Sizes     struct {
+		SubnetSize  uint8 `positional-arg-name:"<subnet prefix>" required:"1" validate:"lte=128,gtefield=NetworkSize"`
+		NetworkSize uint8 `positional-arg-name:"<parent prefix>" required:"1" validate:"lte=128,ltefield=SubnetSize"`
+	} `positional-args:"yes" required:"2" validate:"required"`
+}
+
 type ParseArgs struct {
-	splitArgs
+	commonBase
 	InFile string `short:"i" long:"input" default:"-" description:"Input file to parse. Default is '-' (for STDIN)." required:"true" validate:"required,filepath|eq=-"`
 }
 
@@ -55,6 +69,8 @@ type SplitCIDRArgs struct {
 }
 
 type SplitHostArgs struct {
+	InclNetAddr   bool `short:"N" long:"incl-net" description:"If specified, -n/--num-hosts is interpreted to include the network address in the count."`
+	InclBcastAddr bool `short:"B" long:"incl-bcast" description:"If specified, -n/--num-hosts is interpreted to include the broadcast/reserved broadcast address in the count."`
 	Strict        bool `short:"t" long:"strict" description:"If specified, an error will occur if the number of hosts/assignable addresses in a subnet is not exactly -n/--num-hosts."`
 	Hosts         uint `short:"n" long:"num-hosts" required:"true" description:"Number of hosts (usable addresses) per subnet." validate:"required"`
 	splitArgs

cmd/subnetter/funcs.go

@@ -236,7 +236,9 @@ func printNets(orig *netip.Prefix, origNet *net.IPNet, nets []*netip.Prefix, rem
 
 	if args == nil {
 		args = &common{
+			commonBase: commonBase{
 				Separator: "\n",
+			},
 		}
 	}
 	fmts = sectFmts[args.Plain]
@@ -399,7 +401,9 @@ func printNets(orig *netip.Prefix, origNet *net.IPNet, nets []*netip.Prefix, rem
 
 		// Remaining
 		if !args.SuppressRemaining {
-			if verb >= 1 {
+			if verb <= 0 {
+				fmt.Println("#")
+			} else {
 				fmt.Println()
 				fmt.Println(sectSep1)
 				fmt.Println("Remaining/Left Over/Unallocated:")
@@ -658,7 +662,7 @@ func printSplitErr(e *netsplit.SplitErr) {
 	os.Stderr.WriteString("\n!! ERROR !!!\n")
 
 	os.Stderr.WriteString("\t" + e.Wrapped.Error() + "\n")
-	os.Stderr.WriteString("\nnetwork Iteration Details\n(when error was encountered):\n\n")
+	os.Stderr.WriteString("\nNetwork Iteration Details\n(when error was encountered):\n\n")
 	if e.Nets == nil {
 		os.Stderr.WriteString("Nets:\t\t\t(N/A)\n")
 	} else {
@@ -667,7 +671,7 @@ func printSplitErr(e *netsplit.SplitErr) {
 			fmt.Fprintf(os.Stderr, "\t%s\n", n.String())
 		}
 	}
-	if e.Remaining == nil {
+	if e.Remaining == nil || e.Remaining.Prefixes() == nil || len(e.Remaining.Prefixes()) == 0 {
 		os.Stderr.WriteString("Remaining:\t\t(N/A)\n")
 	} else {
 		os.Stderr.WriteString("Remaining:\n")
@@ -676,7 +680,7 @@ func printSplitErr(e *netsplit.SplitErr) {
 		}
 	}
 	if e.LastSubnet == nil {
-		os.Stderr.WriteString("Last Subnet:\t\t(N/A)")
+		os.Stderr.WriteString("Last Subnet:\t\t(N/A)\n")
 	} else {
 		fmt.Fprintf(os.Stderr, "Last Subnet:\t\t%s\n", e.LastSubnet.String())
 	}

cmd/subnetter/main.go

@@ -33,6 +33,8 @@ func main() {
 	var remaining *netipx.IPSet
 	var buf *bytes.Buffer
 	var res *netsplit.StructuredResults
+	var numNets uint
+	var v6Only bool
 	var noStrict bool
 	var strictErr error
 	var reservations map[netip.Prefix]*netsplit.IANAAddrNetResRecord
@@ -67,6 +69,9 @@ func main() {
 			return
 		}
 	case "net":
+		if err = validate.Struct(args.ExplicitNetwork); err != nil {
+			log.Panicln(err)
+		}
 		if origPfx, err = netip.ParsePrefix(args.ExplicitNetwork.Network.Network); err != nil {
 			log.Panicln(err)
 		}
@@ -79,7 +84,34 @@ func main() {
 			log.Panicln(err)
 		}
 		return
+	case "num-nets":
+		if err = validate.Struct(args.NumNets); err != nil {
+			log.Panicln(err)
+		}
+		if numNets, v6Only, err = netsplit.NumNets(
+			args.NumNets.Sizes.SubnetSize,
+			args.NumNets.Sizes.NetworkSize,
+		); err != nil {
+			log.Panicln(err)
+		}
+		if !args.NumNets.Verbose {
+			fmt.Printf("%d\n", numNets)
+			if !args.NumNets.NoV6Check {
+				fmt.Println(v6Only)
+			}
+		} else {
+			fmt.Printf("Network Size:\t\t\t%d\n", args.NumNets.Sizes.NetworkSize)
+			fmt.Printf("Subnet Size:\t\t\t%d\n", args.NumNets.Sizes.SubnetSize)
+			fmt.Printf("Number of Subnets:\t\t%d\n", numNets)
+			if !args.NumNets.NoV6Check {
+				fmt.Printf("Subnetting is IPv6-Only:\t%v\n", v6Only)
+			}
+		}
+		return
 	case "reserved":
+		if err = validate.Struct(args.Check); err != nil {
+			log.Panicln(err)
+		}
 		if origPfx, err = netip.ParsePrefix(args.Check.Network.Network); err != nil {
 			log.Panicln(err)
 		}
@@ -100,6 +132,9 @@ func main() {
 		}
 		return
 	case "table":
+		if err = validate.Struct(args.Table); err != nil {
+			log.Panicln(err)
+		}
 		// Account for a weird redundant CLI condition.
 		if args.Table.NoIpv4 && args.Table.NoIpv6 {
 			args.Table.NoIpv6 = false
@@ -112,6 +147,9 @@ func main() {
 		os.Stdout.Write(buf.Bytes())
 		return
 	case "parse":
+		if err = validate.Struct(args.Parse); err != nil {
+			log.Panicln(err)
+		}
 		if strings.TrimSpace(args.Parse.InFile) == "-" {
 			buf = new(bytes.Buffer)
 			if _, err = io.Copy(buf, os.Stdin); err != nil {
@@ -136,7 +174,12 @@ func main() {
 			origPfx = *resPfx
 		}
 		pfx = netipx.PrefixIPNet(origPfx.Masked())
-		cmnArgs = args.Parse.common
+		cmnArgs = common{
+			commonBase: args.Parse.commonBase,
+			Network: Net{
+				Network: res.Original.String(),
+			},
+		}
 		if err = printNets(&origPfx, pfx, nets, remaining, &cmnArgs, res.GetSplitter()); err != nil {
 			log.Panicln(err)
 		}
@@ -158,6 +201,8 @@ func main() {
 			}
 			cmnArgs = args.SplitHost.common
 			splitter = &netsplit.HostSplitter{
+				InclNetAddr:   args.SplitHost.InclNetAddr,
+				InclBcastAddr: args.SplitHost.InclBcastAddr,
 				NumberHosts:   args.SplitHost.Hosts,
 				Strict:        args.SplitHost.Strict,
 				BaseSplitter:  new(netsplit.BaseSplitter),
@@ -185,7 +230,7 @@ func main() {
 				PrefixLength: args.SplitCIDR.Prefix,
 				BaseSplitter: new(netsplit.BaseSplitter),
 			}
-		case "vlsm":
+		case "split-vlsm":
 			if err = validate.Struct(args.VLSM); err != nil {
 				log.Panicln(err)
 			}

netsplit/conts.go

@@ -8,6 +8,12 @@ import (
 	`github.com/go-resty/resty/v2`
 )
 
+const (
+	maxBitsv4 uint8 = 32
+	maxBitsv6 uint8 = 128
+	maxBits   uint8 = maxBitsv6
+)
+
 const (
 	cachedirEnvName string = "SBNTR_RSVCACHE_DIR"
 	// https://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry.xhtml

netsplit/funcs.go

@@ -4,6 +4,8 @@ import (
 	"encoding/json"
 	"encoding/xml"
 	"fmt"
+	"math"
+	"math/big"
 	"net"
 	"net/netip"
 	"strings"
@@ -191,6 +193,7 @@ func CheckReserved(nets []*netip.Prefix, revRecursive, recursive, excludePrivate
 				reservations = make(map[netip.Prefix]*IANAAddrNetResRecord)
 			}
 			reservations[*n] = res
+		}
 		if !revRecursive && !recursive {
 			continue
 		}
@@ -204,7 +207,8 @@ func CheckReserved(nets []*netip.Prefix, revRecursive, recursive, excludePrivate
 					reservations = make(map[netip.Prefix]*IANAAddrNetResRecord)
 				}
 				reservations[p] = r
-				} else if recursive && n.Contains(p.Addr()) {
+			}
+			if recursive && n.Bits() < p.Bits() && n.Contains(p.Addr()) {
 				if reservations == nil {
 					reservations = make(map[netip.Prefix]*IANAAddrNetResRecord)
 				}
@@ -212,7 +216,6 @@ func CheckReserved(nets []*netip.Prefix, revRecursive, recursive, excludePrivate
 			}
 		}
 	}
-	}
 
 	return
 }
@@ -221,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,
 	}
@@ -274,6 +277,7 @@ 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
@@ -287,6 +291,7 @@ func Contain(origPfx *netip.Prefix, nets []*netip.Prefix, remaining *netipx.IPSe
 				}
 			}
 		}
+	*/
 
 	s = &sr
 
@@ -375,6 +380,136 @@ 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 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, inclBcast bool) (numAddrs *big.Int) {
+
+	var nPfx netip.Prefix
+	var ok bool
+
+	if pfx == nil {
+		return
+	}
+	if nPfx, ok = netipx.FromStdIPNet(pfx); !ok {
+		return
+	}
+
+	numAddrs = NumAddrsPfx(nPfx, inclNet, inclBcast)
+
+	return
+}
+
+// NumAddrsPfx is the exact same as NumAddrsNet but for a net/netip.Prefix instead.
+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.
+
+It will error if network is larger than 128 or if subnet is smaller than network.
+
+This is MUCH more performant than splitting out an actual network into explicit subnets,
+and does not require an actual network.
+*/
+func NumNets(subnet, network uint8) (numNets uint, ipv6Only bool, err error) {
+
+	var x float64
+
+	// network cannot be higher than 128, as that's the maximum for IPv6.
+	if network > maxBits {
+		err = ErrBadPrefixLen
+		return
+	}
+	if subnet < network {
+		err = ErrBigPrefix
+		return
+	}
+	ipv6Only = (network > maxBitsv4) || (subnet > maxBitsv4)
+
+	x = float64(subnet - network)
+
+	numNets = uint(math.Pow(2, x))
+
+	return
+}
+
 // Parse parses b for JSON/XML/YAML and tries to return a StructuredResults from it.
 func Parse(b []byte) (s *StructuredResults, err error) {
 

netsplit/funcs_hostsplitter.go

@@ -1,11 +1,9 @@
 package netsplit
 
 import (
-	`math/big`
-	`net`
+	"math/big"
 	"net/netip"
 
-	`github.com/projectdiscovery/mapcidr`
 	"go4.org/netipx"
 )
 
@@ -15,52 +13,84 @@ import (
 
 remaining may or may not be nil depending on if the number of hosts can fit cleanly within equal network sizes on boundaries.
 
-	An ErrBadNumHosts will be returned if the number of hosts does not match the *addressable* range in a prefix.
+An ErrBadNumHosts will be returned if the number of hosts does not match the *exact* number of addresses per spec in a prefix.
 */
 func (h *HostSplitter) Split() (nets []*netip.Prefix, remaining *netipx.IPSet, err error) {
 
+	var pfx netip.Prefix
 	var tgt *big.Int
+	var splitCidr int
 	var hosts *big.Int
-	var sub netip.Prefix
-	var subPtr *netip.Prefix
-	var split []*net.IPNet
-	var ipsb *netipx.IPSetBuilder = new(netipx.IPSetBuilder)
+	var found bool
+	var cs *CIDRSplitter
 
 	if h == nil || h.NumberHosts == 0 || h.BaseSplitter == nil || h.network == nil {
 		return
 	}
 
-	if split, err = mapcidr.SplitIPNetByNumber(h.network, int(h.NumberHosts)); err != nil {
+	pfx, _ = netipx.FromStdIPNet(h.network)
+	tgt = new(big.Int)
+	tgt.SetUint64(uint64(h.NumberHosts))
+
+	if NumAddrsPfx(pfx, h.InclNetAddr, h.InclBcastAddr).Cmp(tgt) < 0 {
+		// The number of hosts per-subnet exceeds the number of addresses in the specified network.
+		err = ErrNoNetSpace
+		return
+	}
+	/*
+		Iterate up through prefix lengths for the inet family's maximum length, getting larger and larger,
+		until we reach the first prefix that can contain tgt.
+		If we reach h.network.Bits(), we are forced to use that.
+		(Any case otherwise should be handled by the above checks.)
+	*/
+	for splitCidr = pfx.Addr().BitLen(); splitCidr >= pfx.Bits(); splitCidr-- {
+		if hosts, err = NumAddrsIn(uint8(splitCidr), pfx.Addr().Is6(), h.InclNetAddr, h.InclBcastAddr); err != nil {
+			return
+		}
+		if hosts.Cmp(tgt) >= 0 {
+			found = true
+			break
+		}
+	}
+	if !found {
+		// Pragmatically, we should never be able to get to this code.
+		err = ErrNoNetSpace
 		return
 	}
 
-	tgt = big.NewInt(0)
-	tgt.SetUint64(uint64(h.NumberHosts))
-
-	nets = make([]*netip.Prefix, len(split))
-	for idx, n := range split {
-		sub, _ = netipx.FromStdIPNet(n)
-		hosts = mapcidr.CountIPsInCIDR(false, false, n)
-		if hosts == nil || tgt.Cmp(hosts) != 0 {
+	// Now that we have an appropriate prefix length for splitting, we can offload a huge portion of that to a CIDRSplitter.
+	cs = &CIDRSplitter{
+		PrefixLength: uint8(splitCidr),
+		BaseSplitter: h.BaseSplitter,
+	}
+	if nets, remaining, err = cs.Split(); err != nil {
+		return
+	}
+	// If strict mode is enabled, we then need to match the number of hosts exactly in the subnet.
+	if !h.Strict {
+		return
+	}
+	// First off, if remaining is not nil/empty, that immediately fails strict.
+	if remaining != nil && remaining.Prefixes() != nil && len(remaining.Prefixes()) != 0 {
 		err = &SplitErr{
 			Wrapped:            ErrBadNumHosts,
 			Nets:               nets,
 			Remaining:          remaining,
-				LastSubnet:         &sub,
-				RequestedPrefixLen: uint8(sub.Bits()),
+			LastSubnet:         nil,
+			RequestedPrefixLen: uint8(splitCidr),
 		}
-			ipsb.AddPrefix(sub)
-		} else {
-			subPtr = new(netip.Prefix)
-			*subPtr = sub
-			nets = append(nets, subPtr)
+		return
 	}
 
-		nets[idx] = new(netip.Prefix)
-		*nets[idx] = sub
+	// Then we check the cidr we split on, and check its number of hosts.
+	if hosts.Cmp(tgt) != 0 {
+		err = &SplitErr{
+			Wrapped:            ErrBadNumHosts,
+			Nets:               nets,
+			Remaining:          remaining,
+			LastSubnet:         nil,
+			RequestedPrefixLen: uint8(splitCidr),
 		}
-
-	if remaining, err = ipsb.IPSet(); err != nil {
 		return
 	}
 

netsplit/types.go

@@ -51,6 +51,10 @@ It attempts to evenly distribute addresses amoungs subnets.
 type HostSplitter struct {
 	// NumberHosts is the number of hosts to be placed in each subnet to split out.
 	NumberHosts uint `json:"hosts" xml:"hosts,attr" yaml:"Number of Hosts Per Subnet"`
+	// InclNetAddr, if true, specifies that NumberHosts includes the network address.
+	InclNetAddr bool `json:"net_addr" xml:"netAddr,attr,omitempty" yaml:"Network Address Included,omitempty"`
+	// InclBcastAddr, if true, specifies that NumberHosts includes the broadcast address.
+	InclBcastAddr bool `json:"bcast_addr" xml:"bcast,attr,omitempty" yaml:"Broadcast Address Included,omitempty"`
 	// Strict, if true, will return an error from Split if the network cannot split into subnets of NumberHosts-addressable networks exactly.
 	Strict        bool `json:"strict" xml:"strict,attr,omitempty" yaml:"Strictly Equal Hosts Per Subnet"`
 	*BaseSplitter `json:"net" xml:"net,omitempty" yaml:"network,omitempty"`
@@ -78,14 +82,14 @@ type VLSMSplitter struct {
 		(ascending order) instead of larger networks/smaller prefixes (descending order).
 		You almost assuredly do not want to do this.
 	*/
-	Ascending bool
+	Ascending bool `json:"asc,omitempty" xml:"asc,attr,omitempty" yaml:"Ascending Order,omitempty"`
 	/*
 		Explicit, if true, will ignore Ascending completely and split in the explicit order of PrefixLengths.
 
 		This has the potential to be *extremely* wasteful of addressing space as the resulting blocks are
 		VERY unoptimized.
 	*/
-	Explicit bool
+	Explicit bool `json:"explicit,omitempty" xml:"explicit,attr,omitempty" yaml:"Explicit Ordering,omitempty"`
 	// PrefixLengths contains the prefix lengths of each subnet to split out from the network.
 	PrefixLengths []uint8 `json:"prefixes" xml:"prefixes>prefix" yaml:"Prefix Lengths"`
 	*BaseSplitter `json:"net" xml:"net,omitempty" yaml:"network,omitempty"`