function cidr2ipRange ($ip_addr_cidr) {
  $ip_arr = explode('/', $ip_addr_cidr);
  $bin = '';
  for($i=1;$i<=32;$i++) {
     $bin .= $ip_arr[1] >= $i ? '1' : '0';
  }
  $ip_arr[1] = bindec($bin);
  $ip = ip2long($ip_arr[0]);
  $nm = ip2long($ip_arr[1]);
  $nw = ($ip & $nm);
  $bc = $nw | (~$nm);
  $ret['nbHost'] = ($bc - $nw - 1);
  $ret['range']  = long2ip($nw + 1) . " -> " . long2ip($bc - 1);
  return $ret;
}  

$cidr = array(
'10.0.0.1/28',
'10.0.0.16/29',
'10.0.0.24/30',
'10.0.0.28/31',
'10.0.0.30/32');

echo '<pre>';
foreach ($cidr as $v) {
  $ret = cidr2ipRange($v);
  echo $v . " = Range: " . $ret['range']. ' ('. $ret['nbHost'] .' hosts)' . "\n";
}
echo '</pre>';

function imask($this){
  return base_convert((pow(2,32) - pow(2, (32-$this))), 10, 16);
}

function imaxblock($ibase, $tbit){
  while ($tbit > 0){
    $im = hexdec(imask($tbit-1));
    $imand = $ibase & $im;
    if ($imand != $ibase) {
      break;
    }
    $tbit--;
  }
  return $tbit;
}

function ip2cidr ($istart, $iend) {
  $s = explode(".", $istart);
  $start = "";
  $dot = "";
  while (list($key, $val) = each($s)) {
    $start = sprintf("%s%s%d", $start, $dot, $val);
    $dot = ".";
  }
  $end = "";
  $dot = "";
  $e = explode(".", $iend);
  while (list($key,$val) = each($e)) {
    $end = sprintf("%s%s%d", $end, $dot, $val);
    $dot = ".";
  }
  $start  = ip2long($start);
  $end    = ip2long($end);
  $result = array();
  while ($end > $start) {
    $maxsize = imaxblock($start,32);
    $x = log($end - $start + 1)/log(2);
    $maxdiff = floor(32 - floor($x));
    $ip = long2ip($start);
    if ($maxsize < $maxdiff){
      $maxsize = $maxdiff;
    }
    array_push($result, "$ip/$maxsize");
    $start += pow(2, (32-$maxsize));
  }
  return $result;
}

$a = ip2cidr('192.168.0.158' , '192.168.0.255');
echo '<pre>'; print_r ($a); echo '</pre>';

6.5 Comment découper une plage réseau quelconque comme somme
de plusieurs plages ?

Nous avons vu qu'une plage réseau ne pouvait pas être
choisie n'importe comment.
Etant donné que les masques et les adresses IP se basent
sur un codage binaire, les chiffres utilisés dans les
adresses résultantes ne pourront être que des multiples de
puissances de 2 en accord avec le masque.
Ainsi, une plage 70.0.0.0 ne pourra pas avoir un masque qui
définisse plus de deux chiffres sur le premier octet, car
70 est un multiple de 2, mais pas de 4.

Ce n'est pas clair ? un exemple devrait vous aider à mieux
comprendre.

Disons que l'on veut décrire la plage d'adresses allant de
69.0.0.0 à 79.255.255.255.

La question est de savoir quel masque associé à quelle
adresse de réseau nous permettra de définir cette plage.

Le premier octet varie de 69 à 79. Il prend donc 11
valeurs.
11 n'étant pas une puissance de 2, on sait d'ores et déjà
que l'on ne pourra pas définir cette plage avec un seul
réseau, mais qu'il va falloir la découper en une somme de
plusieurs réseaux.
Le but est cependant d'optimiser cette somme de réseaux
pour en avoir le moins possible. On pourrait simplement
utiliser 11 réseaux avec des masques 255.0.0.0, mais on
doit surement pouvoir faire plus propre et regrouper
plusieurs de ces réseaux en un seul.

La première puissance de 2 inférieure à 11 est 8. Il faut
maintenant savoir si l'on peut placer un réseau, dont le
premier octet décrira 8 valeurs, dans cette plage. Le seul
multiple de 8 de cette plage est 72. On décrirait alors un
réseau dont le premier octet varierait de 72 à 79, ce qui
est bien compris dans notre plage d'origine.
Le réseau 72.0.0.0/248.0.0.0 est donc bien adapté pour
décrire notre plage, mais il reste encore à décrire les
adresses de 69.0.0.0 à 71.255.255.255.

On effectue le même raisonnement.
(Ici le premier octet prend 3 valeurs, la puissance de 2
inférieure à 3 est 2, et le multiple de 2 de cette plage
est 70)
On trouve donc le réseau 70.0.0.0/254.0.0.0

Il ne nous reste plus qu'à décrire la plage 69.0.0.0 à
69.255.255.255 qui peut être définie par
69.0.0.0/255.0.0.0.

Et voilà !!
Nous avons découpé notre plage d'origine qui allait de
69.0.0.0 à 79.255.255.255 en trois sous réseaux:
69.0.0.0/255.0.0.0
70.0.0.0/254.0.0.0
et 72.0.0.0/248.0.0.0