Expand and shrink IPv4 range

Few months ago, I had written this blog post about chunking IPv4 range into multiple sub-ranges. Soon thereafter arouse requirement to have something to expand or shrink given IPv4 range. And, I came up with this code.

	<?php
	/**
	* Copyright (C) 2016 Prabhas Gupte
	*
	* This is free script: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* This script is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should also see <http://www.gnu.org/licenses/gpl.txt>
	*/
	function expand_range($r, $return_array=true) {
	// range may contain , or -
	// first explode on ,
	$output_array = array();
	$ips_array = explode(',', $r);
	foreach ($ips_array as $key => $c) {
	if (false != strpos($c, '-')) {
	list($start, $end) = explode('-', $c);
	$start = ip2long($start);
	$end = ip2long($end);
	for ($i = $start; $i <= $end; $i++) {
	$output_array[] = $i;
	}
	}
	else {
	$output_array[] = ip2long($c);
	}
	}
	asort($output_array);
	$output_array = array_unique($output_array);
	foreach ($output_array as $key => $long_ip) {
	$output_array[$key] = long2ip($long_ip);
	}
	return $return_array ? $output_array : implode(',', $output_array);
	}
	function shrink_range($ips, $return_array=false) {
	$output_array = array();
	$arr = is_array($ips);
	if (!$arr && is_string($ips)) {
	$ips_array = explode(',', $ips);
	}
	elseif ($arr) {
	$ips_array = $ips;
	}
	else {
	throw new Exception('Unsupported data type for argument "ips". It can be either string or array. Nothing else.');
	}
	$ips_count = count($ips_array);
	$preparing_range = false;
	$range_temp = '';
	for ($i=0; $i<$ips_count; $i++) {
	$ip_long = ip2long($ips_array[$i]);
	@$next_ip_long = ip2long($ips_array[$i+1]);
	$diff = $next_ip_long - $ip_long;
	if ($diff == 1) {
	if (!$preparing_range) {
	$preparing_range = true;
	$range_temp = $ips_array[$i] . '-'; // e.g. "10.10.10.10-"
	}
	// else: we are already preparing range, and this IP is part of that range.
	// we are still searching for end IP of this range
	}
	else {
	if ($preparing_range) {
	// we found end of range
	$range_temp .= $ips_array[$i];
	$output_array[] = $range_temp;
	$preparing_range = false; // reset this flag so that we can start building next range
	$range_temp = ''; // reset this string to empty, so that it can hold next range (if any)
	}
	else {
	$output_array[] = $ips_array[$i];
	}
	}
	}
	return $return_array ? $output_array : implode(',', $output_array);
	}
	// test expand_range function
	$ip_range = '10.10.10.10,10.20.30.40,10.55.45.122-10.55.46.130,100.100.100.100';
	// $ip_range = '1.1.1.1-1.1.1.10,10.1.2.3,10.10.10.10-10.10.10.15';
	echo $ip_range, "\n";
	$expanded_range = expand_range($ip_range);
	print_r($expanded_range);
	// test shrink_range function
	$shrunk_range = shrink_range($expanded_range);
	echo "\nafter shrinking $shrunk_range";
	$another_expanded = '1.1.1.1,1.1.1.2,1.1.1.3,2.2.2.2,5.4.3.2,5.4.3.3,5.4.3.4';
	echo "\nexpanded #2: $another_expanded";
	$shrunk_range = shrink_range($another_expanded);
	echo "\n#2 after shrinking: $shrunk_range";
	echo "\n";
	?>

view raw expand_shrink_ip_range.php hosted with ❤ by GitHub

There are two functions written - one expands given IPv4 range and other shrinks it. Let me explain each of them one by one.

The expand_range() function

The input IPv4 range could be a comma-separated list of IPv4 addresses or a proper range (e.g. 10.10.10.10-10.10.10.155) or a mix of both. Objective of this function is to provide a list of ALL IPv4 addresses that are part of given range.

This function starts with exploding the input based on comma. For each element in resulting array, it checks whether its a single IPv4 address or a range having a dash (-) character.

If it contains a dash, it further explodes it to get start and end IPv4 addresses, and converts them to long using ip2long(). Then, it simply runs a for loop to generate all the long values in between them and adds them into output array.

If its a single IPv4 address, that is added as it is to output array.

Finally, it sorts the output array, removes duplicates using array_unique(), and converts each element mach to IPv4 address using long2ip().

Based on optional second argument, it either returns array or a string representation of expanded IPv4 range.

The shrink_range() function

Here, the input IPv4 range could be either a string representation or an array, similar to one output by expand_range() function. Objective of this function is to shorten the given IPv4 range. So, if input is 10.10.10.10,10.10.10.11,10.10.10.12,10.10.10.13 then it should shorten it to 10.10.10.10-10.10.10.13.

The function starts with creating an array out of given IPv4 addresses. If first argument itself is array, it just copies it. And it then takes count() of array elements so that it can loop over them.

In the loop, it keeps on checking IPv4 address and current index as well as next index. It converts both of them into log and calculates difference between them by subtracting current index's long value from next index's long value.

If that difference is 1, it means the next IPv4 address is in sequence with current IPv4 address. And, that also means that we are getting into a range which can be shortened. The function then sets a flag to remember that, and starts building string for this short range.

Else, its either a standalone IPv4 address OR we have possibly reached end of short range. So it checks if the flag is still ON. If yes, it ends the short range, and copies the short range string into output array. If we aren't preparing any short range, it simply adds current IPv4 into output array.

Finally, based on optional second argument, it either returns array or string representation of shrunken IPv4 range.