Notation cidr des adresses ipv4

Soyez le premier à donner votre avis sur cette source.

Vue 9 339 fois - Téléchargée 292 fois

Description

cette source permet de déterminer la décomposition optimale en notation CIDR des adresses IPv4 en fournissant au programme l adresse du début et l adresse de fin du pool. Cette source est utile dans le paratge d adresse en réseau. Un programme à titre d exemple, est fait pour utiliser la source en question.
Soit :
Adresse du début du pool: 192.168.2.0
Adresse de fin du pool: 192.168.56.255

Décomposition optimale en notation CIDR du pool:

192.168.16.0/20
192.168.32.0/20
192.168.8.0/21
192.168.48.0/21
192.168.4.0/22
192.168.2.0/23
192.168.56.0/24.

---------------------
Il est possible de traiter aussi les fichiers avec les bornes des pools.

Source / Exemple :


<?php
//ce sont des extraits du programmes de determination des adresses IPv4 en notation CIDR.
// le fichier fournir.php et detection.php
//retrouver la totalité des sources du programme en téléchargeant la source

//la fonction fournir() renvoie le pool en notation cidr
function fournir($startIP,$endIP,$initial,$numero){
	if(($startIP==0)&&($endIP==255)){ //on suppose que c est un slash 8, 16 ou 24 en comparant les deux décimaux différents $startIP et $endIP
	    switch($numero){
		case 0:
			$ajout="0.0.0.0";
			$slash="0";
			break;
		case 1:
		    $ajout="0.0.0";
			$slash="8";
			break;
		case 2:
		    $ajout="0.0";
			$slash="16";
			break;
		case 3:
			$ajout="0";
			$slash="24";
			break;
		default:
			die("<br>Une eurreur est survenue dans la recherche<br>");
		}
		if($slash!=0){
		    if($ajout!="")
			$adressprefix=$initial.'.'.$ajout.'/'.$slash;
			else
			$adressprefix=$initial.'/'.$slash;
			}
			else
			$adressprefix=$ajout.'/'.$slash;
		return $adressprefix;	
		} 
		else //si ce n ect pas un slah 8, 16, ou 24
		{	
	    $startIPbin=decbin($startIP); //décomposition en bianaire des deux 
		$endIPbin=decbin($endIP);     //décimaux, $startIP et $endIP pour avoir $startIPbin et $endIPbin
		//on met les deux binaires sur 8 bits en completatnt par 0 par la gauche
		$long=strlen($startIPbin);
		$dif=8-$long;
		$tampon="";
		for($i=0;$i<$dif;$i++)
			$tampon.="0";
		$startIPbin=$tampon.$startIPbin;
		$long=strlen($endIPbin);
		$dif=8-$long;
		$tampon="";
		for($i=0;$i<$dif;$i++)
		    $tampon.="0";
		$endIPbin=$tampon.$endIPbin;
		//on cherche les bits du poids le plus fort qui sont différents en faisant la comparaison entre les deux binaires
		$poids=0;
		for($i=0;$i<8;$i++)
		if($startIPbin[$i]!=$endIPbin[$i]){
			$poids=$i;
			$i=8;
			}//fin de la recherche
		//on récupere les bits du poids plus faible que le plus le plus fort, en ce qui concerne la différence entre les bits, déterminé pour les deux adresses  et on fait une comparaison	   
		$deb=""; //c est la variable qui contient le début normal d un slash exact (du genre 000 par exemple), les bits restants sont tous à 0
		$fin="";  //c est la variable qui contient la fin d un slash exact (du genre 111 par exmple); les bits restants sont tous à 1
		$startfin=""; //variable pour récupérer les bits après le poids déterminé du binaire du $startIPbin
		$endfin=""; //variable pour récupérer les bits après le poids déterminé du binaire du $endIPbin
		for($i=$poids;$i<8;$i++){  //on récupere les elements de la comparaison
            $deb.="0";
			$fin.="1";
			$startfin.=$startIPbin[$i];
			$endfin.=$endIPbin[$i];
			}//fin de la récupération des éléments de la comparaison

		if(($deb==$startfin)&&($endfin==$fin)){ //on fait la comparaison pour voir si c est un bon slash et dans ce cas
			$initial.=".".$startIP; 					
			switch($numero){
			case 0:
				$ajout="0.0.0";
				$slash=0;
				break;
			case 1:
				$ajout="0.0";
				$slash=8;
				break;
			case 2:
				$ajout="0";
				$slash=16;
				break;
			case 3:
				$ajout="";
				$slash=24;
				break;
			default:
				die("<br>Une erreur est survenue dans la recherche de la notation CIDR du pool");
			}
		$slash+=$poids;					
        if($slash!=0){				
			if($ajout!="")
			   $adressprefix=$initial.'.'.$ajout.'/'.$slash;
			   else
			   $adressprefix=$initial.'/'.$slash;
			}
			else
			$adressprefix=$ajout.'/'.$slash;	
		return $adressprefix;	
		}
		
		if(($deb!=$startfin)||($endfin!=$fin)){
		    switch($numero){
			case 0:
				$ajout="0.0.0";
				$ajout1="255.255.255";
				$slash=8;
				break;
			case 1:
				$ajout="0.0";
				$ajout1="255.255";
				$slash=16;
				break;
			case 2:
				$ajout="0";
				$ajout1="255";
				$slash=24;
				break;
			case 3:
				$ajout="";
				$ajout1="";
				$slash=32;
				break;
			default:
				die("<br>Corriger cette erreur avant de continuer.");
			}
		$difprefix=$endIP-$startIP+1;
		$difprefixbin=decbin($difprefix);
		$lendif=strlen($difprefixbin);
		$startIP1=$startIP;
		$tptablo=array();
		for($iii=$startIP;$iii<=$endIP;$iii++)
		    $tptablo[]=$iii;	
		$adressprefix="";	
		for($pp=$lendif;$pp>0;$pp--){
			$tptablo1=array();
			$lk=0;
			for($max=0;$max<count($tptablo);$max++)
		    if($tptablo[$max]!=""){
				$tptablo1[$lk]=$tptablo[$max];
				++$lk;}
			$tptablo=$tptablo1;
			$pui=1;
			for($t=1;$t<$pp;$t++)
			    $pui*=2;
			for($tt=0;$tt<count($tptablo);$tt++){	
				$tp=$tptablo[$tt]+$pui-1;
				if($tp>$endIP)
				    break;
				$tp1=$tptablo[$tt];	
				if($tp==$tp1){ break;}
				$entre1=$initial.'.'.$tp1.'.'.$ajout;
				$entre2=$initial.'.'.$tp.'.'.$ajout1;
				$stop=$tt;
				if(detection($entre1,$entre2,$prefixadress)){
				    if($adressprefix=="")
					    $adressprefix.=$prefixadress;
						else
						$adressprefix.="<>".$prefixadress;
					for($vasty=$tt;$vasty<count($tptablo);$vasty++)
					if($tptablo[$vasty]<=$tp){
						$tptablo[$vasty]="";
						$stop=$vasty;
						}
					}
				$tt=$stop;	
				}
			}
		if(count($tptablo))
		for($pi=0;$pi<count($tptablo);$pi++){
		    if($ajout!="")
		    $adressprefix1=$initial.'.'.$tptablo[$pi].'.'.$ajout.'/'.$slash;
			else
		    $adressprefix1=$initial.'.'.$tptablo[$pi].'/'.$slash;
		    $adressprefix.="<>".$adressprefix1;	
			}
		return $adressprefix;	
		}
}
}

function detection($adresse1,$adresse2,&$adressprefix){
			$initial="";
            $adresse[0]=trim($adresse1);
			$adresse[1]=trim($adresse2);
			$startIPtab=@explode('.',$adresse[0]);
            $endIPtab=@explode('.',$adresse[1]);
			for($i=0;$i<4;$i++){
			    if($startIPtab[$i]!=$endIPtab[$i]){
				   $startIP=$startIPtab[$i]; //on récupere les
				   $endIP=$endIPtab[$i];     //deux décimaux différents: $startIP et $endIP
				   $numero=$i;
				   $i=4;
				   } else
				   {
				   if($initial=="")
				     $initial=$endIPtab[$i];
					 else
					 $initial.=".".$endIPtab[$i];
					} 
				   
			    }
			
			  if(($startIP==0)&&($endIP==255)){ //on suppose que c est un slash 8, 16 ou 24 en comparant les deux décimaux différents $startIP et $endIP
			  switch($numero){
			    case 0:
				   $ajout="0.0.0.0";
				   $slash="0";
				   break;
			    case 1:
				   $ajout="0.0.0";
				   $slash="8";
				   break;
			    case 2:
				   $ajout="0.0";
				   $slash="16";
				   break;
			    case 3:
				   $ajout="0";
				   $slash="24";
				   break;
				default:
			       die("<br>Une eurreur est survenue dans la recherche<br>");
				}
              if($slash!=0){				
			    if($ajout!="")
				  $adressprefix=$initial.'.'.$ajout.'/'.$slash;
			      else
				  $adressprefix=$initial.'/'.$slash;
				}
				else
			    $adressprefix=$ajout.'/'.$slash;
		    return true;
			} 
			else //si ce n ect pas un slah 8, 16, ou 24
			    {	
			    $startIPbin=decbin($startIP); //décomposition en bianaire des deux 
				$endIPbin=decbin($endIP);     //décimaux, $startIP et $endIP pour avoir $startIPbin et $endIPbin
				//on met les deux binaires sur 8 bits en completatnt par 0 par la gauche
				$long=strlen($startIPbin);
				$dif=8-$long;
				$tampon="";
				for($i=0;$i<$dif;$i++)
				   $tampon.="0";
				$startIPbin=$tampon.$startIPbin;
				$long=strlen($endIPbin);
				$dif=8-$long;
				$tampon="";
				for($i=0;$i<$dif;$i++)
				   $tampon.="0";
				$endIPbin=$tampon.$endIPbin;
				//on cherche les bits du poids le plus fort qui sont différents en faisant la comparaison entre les deux binaires
				$poids=0;
				for($i=0;$i<8;$i++)
				    if($startIPbin[$i]!=$endIPbin[$i]){
					   $poids=$i;
					   $i=8;
					   }//fin de la recherche
				//on récupere les bits du poids plus faible que le plus le plus fort, en ce qui concerne la différence entre les bits, déterminé pour les deux adresses  et on fait une comparaison	   
				$deb=""; //c est la variable qui contient le début normal d un slash exact (du genre 000 par exemple), les bits restants sont tous à 0
				$fin="";  //c est la variable qui contient la fin d un slash exact (du genre 111 par exmple); les bits restants sont tous à 1
				$startfin=""; //variable pour récupérer les bits après le poids déterminé du binaire du $startIPbin
				$endfin=""; //variable pour récupérer les bits après le poids déterminé du binaire du $endIPbin
				for($i=$poids;$i<8;$i++){  //on récupere les elements de la comparaison
                    $deb.="0";
					$fin.="1";
					$startfin.=$startIPbin[$i];
					$endfin.=$endIPbin[$i];
					}//fin de la récupération des éléments de la comparaison

				if(($deb==$startfin)&&($endfin==$fin)){ //on fait la comparaison pour voir si c est un bon slash et dans ce cas
					$initial.=".".$startIP; 					
			        switch($numero){
						case 0:
							$ajout="0.0.0";
							$slash=0;
							break;
						case 1:
							$ajout="0.0";
							$slash=8;
							break;
						case 2:
							$ajout="0";
							$slash=16;
							break;
						case 3:
							$ajout="";
							$slash=24;
							break;
						default:
							echo "Les adresses startIP et endIP de la ligne ".$compteur." sont égales.<br>Vous aurez un /32";
							die("<br>Corriger cette erreur avant de continuer.");
							$ajout="";
							$slash=32;
							break;
							}
					$slash+=$poids;					
                    if($slash!=0){
                      if($ajout!="")					
			          $adressprefix=$initial.'.'.$ajout.'/'.$slash;
			          else
			          $adressprefix=$initial.'/'.$slash;
					  }else
			          $adressprefix=$ajout.'/'.$slash;	
			return true;
		            }
				//si le slash n est pas correct et il va faloir décomposer	
				if(($deb!=$startfin)||($endfin!=$fin)){
				return false;}
}
}			
?>

Conclusion :


Ces codes permettant de savoir si deux adresses IP sont dans un meme réseau suivant un slash donné, peuvent nous apporter d autres ouvertures.

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.