Breaking An IPv4 Address Range Up Into CIDR Ranges In Lucee CFML 5.3.9.141

<cfscript>

	// https://www.ipaddressguide.com/cidr

	// Some IP utility classes that will help us calculate our ranges.
	// --
	// https://github.com/jgonian/commons-ip-math
	Ipv4 = javaNew( "com.github.jgonian.ipmath.Ipv4" );
	Ipv4Range = javaNew( "com.github.jgonian.ipmath.Ipv4Range" );

	// Imagine that we want to create CIDR (Classless Inter-Domain Routing) ranges that
	// encompass the given min/max IP addresses. If we tried to create a "single range"
	// to rule them all, we'd end up having to create a range larger than we wanted to
	// (which would include IPs outside this min/max). As such, we have to break this
	// range up into a set of tighter ranges that include only the IPs we have here.
	minIpAddress = Ipv4.of( "10.0.0.3" );
	maxIpAddress = Ipv4.of( "10.0.0.72" );

	// CIDR ranges work by locking down a given number of "prefix bits" in the IP address.
	// The IPs in a given range are then represented by the exhaustive combination of the
	// remaining "suffix bits". To create "tight" ranges (ie, ranges that only include the
	// IPs that we want and nothing extra) we have create segments in which the "lowest"
	// and the "highest" IPs for a given prefix fall within the range of IPs that we want
	// to target. To calculate this, I'm going to start at the lowest IP and incrementally
	// step towards the highest IP, checking to see if the sub-slice of IPs fit into a
	// tight range. If they do, they can be part of the same CIDR range; but, if they
	// don't, I have to split the sub-slice further, creating two tighter ranges.
	segment = {
		from: minIpAddress,
		to: minIpAddress
	};
	// Keep track of all the segments that go into our range.
	ranges = [ segment ];

	// Keep stepping up in the IP range while our current segment's TO IP is less than the
	// maximum IP in our desired range.
	while ( isIpLessThan( segment.to, maxIpAddress ) ) {

		next = segment.to.next();

		// To see if the "next" IP fits in the current segment, we have to get the common
		// prefix of the two IPs (ie, the number of locked-down "prefix bits" in the IP
		// address that encompasses both IPs); and, we have to make sure that said prefix
		// doesn't encompass any IPs OUTSIDE the current segment.
		commonPrefix = segment.from.getCommonPrefixLength( next );
		minPrefixIpAddress = next.lowerBoundForPrefix( commonPrefix );
		maxPrefixIpAddress = next.upperBoundForPrefix( commonPrefix );

		// If the lower-bound IP encompassed by the common prefix is smaller than our
		// current segment; or, if the upper-bound IP encompassed by the common prefix is
		// larger than our overall IP-range; then, we need to split into a new segment
		// with a tighter prefix.
		if (
			isIpLessThan( minPrefixIpAddress, segment.from ) ||
			isIpGreaterThan( maxPrefixIpAddress, maxIpAddress )
			) {

			segment = {
				from: next,
				to: next
			};
			ranges.append( segment );

		// If the lower/upper-bound IPs fall within our overall IP-range, than we can just
		// extend the current segment to include the given IP and then move onto the next
		// IP in the range.
		} else {

			segment.to = next;

		}

	}

	// ------------------------------------------------------------------------------- //
	// ------------------------------------------------------------------------------- //

	// At this point, we've taken our min/man IP-range and split it up into a set of CIDR
	// ranges that represent ONLY the IPs that we care about.
	// --
	// NOTE: I've double-checked this using the CIDR IP-Address utilities provided by
	// https://www.ipaddressguide.com/cidr
	for ( segment in ranges ) {

		segmentRange = Ipv4Range
			.from( segment.from )
			.to( segment.to )
		;

		echo( segmentRange.toStringInCidrNotation() );
		echo( " ... which contains ... " );
		echo( segmentRange.toStringInRangeNotationWithSpaces() );
		echo( "<br />" );

	}

	// ------------------------------------------------------------------------------- //
	// ------------------------------------------------------------------------------- //

	/**
	* I determine if the first Commons-Ip-Math address is smaller than the second one.
	*/
	public boolean function isIpLessThan(
		required any a,
		required any b
		) {

		return( a.compareTo( b ) < 0 );

	}


	/**
	* I determine if the first Commons-Ip-Math address is greater than the second one.
	*/
	public boolean function isIpGreaterThan(
		required any a,
		required any b
		) {

		return( a.compareTo( b ) > 0 );

	}


	/**
	* I create the Commons-Ip-Math class definition with the given name.
	*/
	public any function javaNew( required string className ) {

		var jarPaths = [
			expandPath( "/vendor/commons-ip-math-1.32.jar" )
		];

		return( createObject( "java", className, jarPaths ) );

	}

</cfscript>