calculate IP range using PHP and CIDR

Question

I\'ve seen various questions and answers around this site and I\'m still having difficulty wrapping my head around this problem (could be because I\'ve got a cold). Regardle

Answer 1

I created this php function in order to get the subnet splits of a network/range. It works with ipv4 or ipv6.
If php<5.4 then use this hex2bin function https://github.com/dompdf/dompdf/issues/1692

function divide_ip_range($cidr="2001:db8:abc:12ff::/54",$mindivs=2){ // input range 192.168.4.0/24 and returns array with the 1st range and 2nd range [0] => 192.168.4.0/25 , [1] => 192.168.4.127/25
  $outarr=array();
  list($ipaddr,$range) = explode('/', $cidr);
  for($rngsplit=1;pow(2,$rngsplit)<$mindivs;$rngsplit++){} // find to how many networks to divide
  $divs=pow(2,$rngsplit);    
  $divcidr=(int)$range+$rngsplit;
  if(preg_match("/^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$/",$ipaddr)){ // IPv4
    $ip_address_long = ip2long($ipaddr);
    $ip_nmask_long=(-1 << (32 - $range));
    $ip_net = $ip_address_long & $ip_nmask_long;
    $ip_broadcast_invert = ~$ip_nmask_long;
    $ip_last = ($ip_address_long | $ip_broadcast_invert) - 1;
    $ip_broadcast = $ip_address_long | $ip_broadcast_invert;
    $numofhosts=pow(2,32-$range)-2;
    for ($i=0;$i<$divs;$i++){
      $outarr[]=long2ip($ip_net+$i*ceil($numofhosts/$divs)+($i*ceil($numofhosts/$divs)%2) )."/$divcidr";
    }
    //echo "Net:$ipaddr/$range\nFirst:".long2ip($ip_net)."\nLast: ".long2ip($ip_last)."\nNumOfHosts:$numofhosts \n";
  } else if (preg_match("/^[0-9a-f:]+$/",$ipaddr)) { // IPv6 section 
    $ip_addr_bin = inet_pton($ipaddr);
    $ip_addr_hex = bin2hex($ip_addr_bin);
    $flexbits = 128 - $range; // Calculate the number of 'flexible' bits for first net
    $pos = 31; $addr_hex_first = $ip_addr_hex; $addr_hex_last = $ip_addr_hex;
    while ($flexbits > 0) {
      $orig_val = hexdec(substr($ip_addr_hex, $pos, 1)); // dec value of pos char. ex. f=15
      $mask = 0xf << (min(4,$flexbits)); // calculate the subnet mask. min() prevents comparison to be negative 
      $new_val_first = $orig_val & $mask;
      $addr_hex_first = substr_replace($addr_hex_first, dechex($new_val_first) , $pos, 1); // Put hex character in pos
      $segmask=(pow(2,min(4,$flexbits))-1); // Last address: OR it with (2^flexbits)-1, with flexbits limited to 4 at a time
      $new_val_last = $orig_val | $segmask;
      $addr_hex_last = substr_replace($addr_hex_last, dechex($new_val_last) , $pos, 1);
      $pos--; $flexbits -= 4; // Next nibble
    }
    $partpos=(4*floor($pos/4)); // The 4 digits that vary by the subnetting
    $partfirst=substr($addr_hex_first,$partpos,4);
    $partlast=substr($addr_hex_last,$partpos,4);
    $numofhosts=(hexdec($partlast)+1-hexdec($partfirst));
    for ($i=0;$i<$divs;$i++){
      $partdiv=dechex(hexdec($partfirst)+$i*$numofhosts/$divs);
      $addr_hex_div=substr_replace($addr_hex_first, $partdiv , $partpos, 4);
      $outarr[]=inet_ntop(hex2bin($addr_hex_div))."/$divcidr";
    }  
    //echo "Net:$ipaddr/$range\nFirst:".inet_ntop(hex2bin($addr_hex_first))."\nLast:".inet_ntop(hex2bin($addr_hex_last))."\nNumOfHosts:$numofhosts\nDivide at partpos:$partpos ($partlast+1-$partfirst)/$divs=$partdiv\n";
  }
  return $outarr;
}

Answer 2

My version to help you use variables.

<?php
$ip_address = "192.168.0.2";
$ip_nmask = "255.255.255.0";
ipv4Breakout($ip_address, $ip_nmask);

function ipv4Breakout ($ip_address, $ip_nmask) {
    //convert ip addresses to long form
    $ip_address_long = ip2long($ip_address);
    $ip_nmask_long = ip2long($ip_nmask);
    //caculate network address
    $ip_net = $ip_address_long & $ip_nmask_long;
    //caculate first usable address
    $ip_host_first = ((~$ip_nmask_long) & $ip_address_long);
    $ip_first = ($ip_address_long ^ $ip_host_first) + 1;
    //caculate last usable address
    $ip_broadcast_invert = ~$ip_nmask_long;
    $ip_last = ($ip_address_long | $ip_broadcast_invert) - 1;
    //caculate broadcast address
    $ip_broadcast = $ip_address_long | $ip_broadcast_invert;

    //Output
    $ip_net_short = long2ip($ip_net);
    $ip_first_short = long2ip($ip_first);
    $ip_last_short = long2ip($ip_last);
    $ip_broadcast_short = long2ip($ip_broadcast);
    echo "Network - " . $ip_net_short . "<br>";
    echo "First usable - " . $ip_first_short . "<br>";
    echo "Last usable - " . $ip_last_short . "<br>";
    echo "Broadcast - " . $ip_broadcast_short . "<br>";
}

Answer 3

As you've already noted, all IPv4 addresses can be converted to numbers using ip2long(), and converted back using long2ip(). The critical extra bit I'm not sure you've noticed is that sequential IPs correspond with sequential numbers, so you can manipulate these numbers!

Given a CIDR prefix (e.g, $prefix = 30 for your range), you can calculate the number of IPs in that range using a bit shift operator:

$ip_count = 1 << (32 - $prefix);

And then loop through all the IPs in that range using:

$start = ip2long($start_ip);
for ($i = 0; $i < $ip_count; $i++) {
    $ip = long2ip($start + $i);
    // do stuff with $ip...
}

Answer 4

Here is the actual way to calculate a true IP range based on CIDR:

The top answer is actually not correct. It gives the wrong IP range list.

function ipRange($cidr) {
   $range = array();
   $cidr = explode('/', $cidr);
   $range[0] = long2ip((ip2long($cidr[0])) & ((-1 << (32 - (int)$cidr[1]))));
   $range[1] = long2ip((ip2long($range[0])) + pow(2, (32 - (int)$cidr[1])) - 1);
   return $range;
}

 var_dump(ipRange("207.64.1.68/28"));

 //////////////////OUTPUT////////////////////////
 // array(2) {
 //   [0]=>
 //   string(12) "207.64.1.64"
 //   [1]=>
 //   string(12) "207.64.1.79"
 // }
 /////////////////////////////////////////////////

IP: 207.64.1.68

Should give me all IPs within 207.64.1.64 and 207.64.1.79

The other answers do not subtract, they only go from 207.64.1.68 - 207.64.1.83 (not correct in the IP range block)

You can check it here: https://www.ipaddressguide.com/cidr

Answer 5

I am using the following function to give me the network, 1st usable, last usable and the broadcast address along with all hosts:

function ipv4Breakout ($ip_address, $ip_nmask) {
    $hosts = array();
    //convert ip addresses to long form
    $ip_address_long = ip2long($ip_address);
    $ip_nmask_long = ip2long($ip_nmask);

    //caculate network address
    $ip_net = $ip_address_long & $ip_nmask_long;

    //caculate first usable address
    $ip_host_first = ((~$ip_nmask_long) & $ip_address_long);
    $ip_first = ($ip_address_long ^ $ip_host_first) + 1;

    //caculate last usable address
    $ip_broadcast_invert = ~$ip_nmask_long;
    $ip_last = ($ip_address_long | $ip_broadcast_invert) - 1;

    //caculate broadcast address
    $ip_broadcast = $ip_address_long | $ip_broadcast_invert;

    foreach (range($ip_first, $ip_last) as $ip) {
            array_push($hosts, $ip);
    }

    $block_info = array(array("network" => "$ip_net"),
            array("first_host" => "$ip_first"),
            array("last_host" => "$ip_last"),
            array("broadcast" => "$ip_broadcast"),
            $hosts);

    return $block_info;
}

I also noticed that you are asking to calculate based on a CIDR notation. Here is a function that I am using to convert from CIDR to dotted decimal:

function v4CIDRtoMask($cidr) {
    $cidr = explode('/', $cidr);
    return array($cidr[0], long2ip(-1 << (32 - (int)$cidr[1])));
}

I deal mainly dotted decimal and not with CIDR notation. The ipv4Breakout function returns a multidimensional array with all the information that you need via long format. You will need to use long2ip() if you want the actual dotted decimal IP Address. The function requires IP Address and a subnet mask via dotted decimal format.

Hope this helps you or anyone else out.