From 59cf91925ca8da43d2427331b23e4673b0e53095 Mon Sep 17 00:00:00 2001
From: Tarik Gasmi
Date: Mon, 14 May 2007 08:03:48 +0000
Subject: Other webinterface data.

git-svn-id: http://svn.openslx.org/svn/openslx/trunk@1077 95ad53e4-c205-0410-b2fa-d234c58c8868
---
 .../webinterface/lib/ip_management_functions.php   | 1385 ++++++++++++++++++++
 1 file changed, 1385 insertions(+)
 create mode 100644 ldap-site-mngmt/webinterface/lib/ip_management_functions.php

(limited to 'ldap-site-mngmt/webinterface/lib/ip_management_functions.php')

diff --git a/ldap-site-mngmt/webinterface/lib/ip_management_functions.php b/ldap-site-mngmt/webinterface/lib/ip_management_functions.php
new file mode 100644
index 00000000..b4f4a733
--- /dev/null
+++ b/ldap-site-mngmt/webinterface/lib/ip_management_functions.php
@@ -0,0 +1,1385 @@
+<?php
+
+/**  
+* ip_management_functions.php - IP Management Funktions-Bibliothek
+* Diese Bibliothek enthält alle Funktionen für die Verwaltung der IP Adressen. 
+*
+* @param string ldapError
+* @param resource ds
+* 
+* @author Tarik Gasmi
+* @copyright Tarik Gasmi
+*/  
+
+# Konfiguration laden
+require_once("config.inc.php");
+
+$ldapError = null;
+
+
+####################################################################################
+# Basisfunktionen zur Verarbeitung von IP Ranges 
+
+/*PHP Funktionen ip2long(), long2ip() machen dasselbe und werden verwendet
+function ip_dot_to_long($ip_dot)
+{	
+	$ip_long = unpack('N*', pack('C*', preg_split('/\./',$ip_dot)));
+	return $ip_long;
+}
+
+function ip_long_to_dot($ip_long)
+{
+	$ip_dot = join('.',unpack('C*',pack('N',$ip_long)));
+	return $ip_dot;
+}*/ 
+
+/**
+* check_ip_in_iprange($iprange1, $iprange2)  
+* Prueft ob erste IP Range in zweiter IP Range enthalten ist.
+*
+* @param string iprange1 erste IP Range
+* @param string iprange2 zweite IP Range
+*
+* @return boolean Erfolg bzw. Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function check_ip_in_iprange($iprange1,$iprange2)
+{
+	$ipr1exploded = explode('_',$iprange1);
+	$ipr2exploded = explode('_',$iprange2); 
+	$ipr1s = ip2long($ipr1exploded[0]);
+	$ipr1e = ip2long($ipr1exploded[1]);
+	$ipr2s = ip2long($ipr2exploded[0]);
+	$ipr2e = ip2long($ipr2exploded[1]);
+	
+	if( $ipr1s >= $ipr2s && $ipr1e <= $ipr2e ){ return 1;}
+	else{ return 0;}
+}
+
+
+/**
+* split_iprange($iprange1, $iprange2)  
+* Entnimmt erste IP Range aus der zweiten IP Range und gibt bei Erfolg Array verbleibender 
+* IP Ranges zurueck.
+*
+* @param string iprange1 erste IP Range
+* @param string iprange2 zweite IP Range
+*
+* @return array bei Erfolg bzw. boolean 0 bei Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function split_iprange($iprange1,$iprange2)
+{  
+	$iprange3;
+	$iprange4;
+	$ipranges = array();
+	
+	if (check_ip_in_iprange($iprange1,$iprange2) == 1)
+	{		
+		$ipr1exploded = explode('_',$iprange1);
+		$ipr2exploded = explode('_',$iprange2); 
+		$ipr1s = ip2long($ipr1exploded[0]);
+		$ipr1e = ip2long($ipr1exploded[1]);
+		$ipr2s = ip2long($ipr2exploded[0]);
+		$ipr2e = ip2long($ipr2exploded[1]);
+		
+		$ipr3s = $ipr2s;
+		$ipr3e = $ipr1s - 1;
+		$ipr4s = $ipr1e + 1;
+		$ipr4e = $ipr2e;
+		
+		if ($ipr3s <= $ipr3e){$iprange3 = long2ip($ipr3s)."_".long2ip($ipr3e); $ipranges[] = $iprange3;}
+		if ($ipr4s <= $ipr4e){$iprange4 = long2ip($ipr4s)."_".long2ip($ipr4e); $ipranges[] = $iprange4;}
+		
+		return $ipranges;
+	}
+	else
+	{
+		echo "IPRange1 not in IPRange2: ";
+		return 0;
+	}
+}
+
+
+/**
+* intersect_ipranges($iprange1, $iprange2)  
+* Bildet die Schnittmenge zweier IP Ranges.
+*
+* @param string iprange1 erste IP Range
+* @param string iprange2 zweite IP Range
+*
+* @return string iprange3 Schnitt-IP-Range 
+*
+* @author Tarik Gasmi
+*/
+function intersect_ipranges($iprange1,$iprange2)
+{  
+	$ipr1exploded = explode('_',$iprange1);
+	$ipr2exploded = explode('_',$iprange2); 
+	$ipr1s = ip2long($ipr1exploded[0]);
+	$ipr1e = ip2long($ipr1exploded[1]);
+	$ipr2s = ip2long($ipr2exploded[0]);
+	$ipr2e = ip2long($ipr2exploded[1]);
+	
+	if ( $ipr1s >= $ipr2s ){$ipr3s = $ipr1s;}else{$ipr3s = $ipr2s;}
+	if ( $ipr1e <= $ipr2e ){$ipr3e = $ipr1e;}else{$ipr3e = $ipr2e;}
+	
+	if ($ipr3s <= $ipr3e){
+		$iprange3 = long2ip($ipr3s)."_".long2ip($ipr3e);
+		return $iprange3;
+	}
+	else{
+	 return ""; 
+	 echo "No Intersection<br>";
+	}
+}
+
+
+/**
+* merge_2_ipranges($iprange1, $iprange2)  
+* Vereinigt 2 IP Ranges zu einer IP Range, falls sie adjazent sind oder sich ueberschneiden.
+*
+* @param string iprange1 erste IP Range
+* @param string iprange2 zweite IP Range
+*
+* @return string iprange3 bei Erfolg bzw. boolean 0 bei Misserfolg.
+*
+* @author Tarik Gasmi
+*/
+function merge_2_ipranges($iprange1,$iprange2)
+{
+
+	$ipr1exploded = explode('_',$iprange1);
+	$ipr2exploded = explode('_',$iprange2); 
+	$ipr1s = ip2long($ipr1exploded[0]);
+	$ipr1e = ip2long($ipr1exploded[1]);
+	$ipr2s = ip2long($ipr2exploded[0]);
+	$ipr2e = ip2long($ipr2exploded[1]);
+	
+	if ( ($ipr1e + 1) >= $ipr2s && $ipr1s <= ($ipr2e + 1) ){
+		if ($ipr1s <= $ipr2s){ $ipr3s = $ipr1s; }else{ $ipr3s = $ipr2s; }
+		if ($ipr1e <= $ipr2e){ $ipr3e = $ipr2e; }else{ $ipr3e = $ipr1e; }
+		
+		if ($ipr3s <= $ipr3e){
+			$iprange3 = long2ip($ipr3s)."_".long2ip($ipr3e); 
+			printf("Merging: %s and %s -> %s<br>",$iprange1,$iprange2,$iprange3);
+			return $iprange3; 
+		}
+		else{
+			# printf("No Merging possible: %s and %s<br>",$iprange1,$iprange2); 
+			return 0; }
+	}
+	else{
+		# printf("No Merging possible: %s and %s<br>",$iprange1,$iprange2);
+		return 0;
+	}
+}
+
+
+#########################################################################################
+# IP Management LDAP Grundfunktionen 
+
+/**
+* get_freeipblocks_au($auDN)  
+* Holt die FreeIPBlocks einer AU und gibt sie in einem Array zurueck.
+*
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return array fipb_array FreeIPBlocks der AU.
+*
+* @author Tarik Gasmi
+*/
+function get_freeipblocks_au($auDN)
+{
+	global $ds, $suffix, $ldapError;
+
+	if(!($result = uniLdapSearch($ds, $auDN, "objectclass=*", array("FreeIPBlock"), "", "one", 0, 0))) {
+      # redirect(5, "", $ldapError, FALSE);
+      echo "search problem";
+      die;
+   } else {
+   	$fipb_array = array();
+   	$result = ldapArraySauber($result);
+		foreach ($result as $item){
+			if (count($item['freeipblock']) > 1){
+	   		$fipb_array = $item['freeipblock'];
+   		}
+   		else{
+   			$fipb_array[] = $item['freeipblock'];
+   		}   	
+   	}
+   }
+   return $fipb_array;
+}
+
+/**
+* get_maxipblocks_au($auDN)  
+* Holt die MaxIPBlocks einer AU und gibt sie in einem Array zurueck.
+*
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return array mipb_array MaxIPBlocks der AU.
+*
+* @author Tarik Gasmi
+*/
+function get_maxipblocks_au($auDN)
+{
+	global $ds, $suffix, $ldapError;
+
+	if(!($result = uniLdapSearch($ds, $auDN, "objectclass=*", array("MaxIPBlock"), "", "one", 0, 0))) {
+      # redirect(5, "", $ldapError, FALSE);
+      echo "search problem";
+      die;
+   } else {
+   	$result = ldapArraySauber($result);
+		foreach ($result as $item){
+			if (count($item['maxipblock']) > 1){
+	   		$mipb_array = $item['maxipblock'];
+   		}
+   		else{
+   			$mipb_array[] = $item['maxipblock']; 
+   		}
+   	}
+   }
+   return $mipb_array;
+}
+
+
+/**
+* get_host_ip($hostDN)  
+* Holt die IP Adressen eines Hosts und gibt sie in einem Array zurueck.
+*
+* @param string hostDN Distinguished Name des LDAP Host-Objektes
+*
+* @return array host_array IPs des Hosts.
+*
+* @author Tarik Gasmi
+*/
+function get_host_ip($hostDN)
+{
+	global $ds, $suffix, $ldapError;
+	
+	if(!($result = uniLdapSearch($ds, $hostDN, "(objectclass=Host)", array("hostName","IPAddress","dhcpOptFixed-address"), "hostName", "one", 0, 0))) {
+ 		# redirect(5, "", $ldapError, FALSE);
+  		echo "no search"; 
+  		die;
+  		return 0;
+	} 
+	else {
+		$result = ldapArraySauber($result);
+		$host_array = array();
+		
+		foreach ($result as $item){
+		   $host_array['hostname'] = $item['hostname'];
+		   $host_array['ipaddress'] = $item['ipaddress'];
+		   #if ( $item['dhcpoptfixed-address'] != "" ){
+		      $host_array['dhcpoptfixed-address'] = $item['dhcpoptfixed-address'];
+		   #}
+   		# $host_array = array('hostname' => $item['hostname'], 'ipaddress' => $item['ipaddress']);
+   	}
+   	return $host_array;
+	}
+}
+
+
+/**
+* get_dhcp_range($dhcpobjectDN)  
+* Holt die IP Ranges eines DHCP Subnets/Pools und gibt sie in einem Array zurueck.
+*
+* @param string dhcpobjectDN Distinguished Name des LDAP DHCP-Objektes
+*
+* @return array dhcp_array IP Ranges des Subnets/Pools.
+*
+* @author Tarik Gasmi
+*/
+function get_dhcp_range($dhcpobjectDN)
+{
+	global $ds, $suffix, $ldapError;
+	
+	if(!($result = uniLdapSearch($ds, $dhcpobjectDN, "(objectclass=*)", array("cn","dhcpRange"), "cn", "one", 0, 0))) {
+ 		# redirect(5, "", $ldapError, FALSE);
+  		echo "no search"; 
+  		die;
+  		return 0;
+	} 
+	else {
+		$result = ldapArraySauber($result);
+		$dhcp_array = array();
+		
+		foreach ($result as $item){
+		   $dhcp_array['cn'] = $item['cn'];
+		   $dhcp_array['dhcprange'] = $item['dhcprange'];
+   	}
+   	return $dhcp_array;
+	}
+}
+
+
+/**
+* merge_ipranges($auDN)  
+* Nimmt die Arrays von IP Ranges eines AU Objektes, MaxIPBlocks und FreeIPBlocks, und vereinigt 
+* rekusriv alle adjazenten/sich ueberschneidenden IP Ranges zu einer IP Range.
+*
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @author Tarik Gasmi
+*/
+function merge_ipranges($auDN)
+{
+	global $ds, $suffix, $ldapError;
+   
+   $fipb_array = get_freeipblocks_au($auDN);
+   $mipb_array = get_maxipblocks_au($auDN);
+   if ( count($fipb_array) > 1) sort($fipb_array);
+   if ( count($mipb_array) > 1) sort($mipb_array);
+   
+   $c = count($fipb_array);
+   for ($i=0; $i < $c; $i++){
+   	for ($j=$i+1; $j < $c; $j++){
+   		if ( merge_2_ipranges($fipb_array[$i],$fipb_array[$j])){
+	   		$fipb_array[$i] = merge_2_ipranges($fipb_array[$i],$fipb_array[$j]);
+   			array_splice($fipb_array, $j, 1); 
+   			$c--;
+   			$i=-1;
+   			break;
+   		}
+   	}
+   }
+   print_r($fipb_array);printf("<br>");
+   foreach ( $fipb_array as $item ){
+		 	$entry ['FreeIPBlock'][] = $item;
+		}
+	$results = ldap_mod_replace($ds,$auDN,$entry);
+	if ($results) echo "<br>FIPBs erfolgreich zusammengefasst!<br><br>" ;
+   else echo "<br>Fehler beim eintragen der FIPBs!<br><br>";	  
+	 
+	$d = count($mipb_array);
+   for ($i=0; $i < $d; $i++){
+   	for ($j=$i+1; $j < $d; $j++){
+   		if ( merge_2_ipranges($mipb_array[$i],$mipb_array[$j])){
+	   		$mipb_array[$i] = merge_2_ipranges($mipb_array[$i],$mipb_array[$j]);
+   			array_splice($mipb_array, $j, 1); 
+   			$d--;
+   			$i=-1;
+   			break;
+   		}
+   	}
+   }
+   print_r($mipb_array);printf("<br>");
+   foreach ( $mipb_array as $item ){
+		 	$entry2 ['MaxIPBlock'][] = $item;
+		}		 
+	$results = ldap_mod_replace($ds,$auDN,$entry2);
+	if ($results) echo "<br>MIPBs erfolgreich zusammengefasst!<br><br>" ;
+   else echo "<br>Fehler beim eintragen der MIPBs!<br><br>";	  
+}
+
+ 
+/**
+* new_ip_host($ip,$hostDN,$auDN)  
+* Weist einem Host eine IP Adresse neu zu, falls sie vergeben werden darf (in den FreeIPBlocks
+* enthalten ist), und passt die FreeIPBlocks der AU an.
+*
+* @param string ip IP Adresse, die zugewiesen werden soll
+* @param string hostDN Distinguished Name des LDAP Host-Objektes
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return boolean 1 bei Erfolg bzw. 0 bei Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function new_ip_host($ip,$hostDN,$auDN)
+{
+	global $ds, $suffix, $ldapError;
+   
+   $fipb_array = get_freeipblocks_au($auDN);
+   
+	for ($i=0; $i < count($fipb_array); $i++){
+		if ( split_iprange($ip,$fipb_array[$i]) != 0 ){
+			$ipranges = split_iprange($ip,$fipb_array[$i]);
+			array_splice($fipb_array, $i, 1, $ipranges);
+			break;
+		}		
+	}
+	
+	if ($i < count($fipb_array) ){	
+		# ldap_mod_replace -> Array fipb_array aktualisiert die FIPB in AU mit $auDN
+		foreach ( $fipb_array as $item ){
+		 	$entry ['FreeIPBlock'][] = $item;
+		}
+		 
+		$results = ldap_mod_replace($ds,$auDN,$entry);
+		if ($results){
+			echo "<br>Neue FIPBs erfolgreich eingetragen!<br>" ;
+			
+			# ldap_mod_add -> IPAddress = $ip , in Host mit $hostDN
+			$ipentry ['IPAddress'] = $ip;
+			$results = ldap_mod_add($ds,$hostDN,$ipentry);
+			if ($results){ 
+				echo "<br>IP Adresse erfolgreich eingetragen!<br>" ;
+				return 1;
+	   	}else{ 
+	   		echo "<br>Fehler beim eintragen der IP Adresse!<br>";
+	   		return 0;
+	   	}	 
+	   }else{
+	   	echo "<br>Fehler beim eintragen der FIPBs!<br>";
+	   	return 0;
+	   }	      
+	}
+	else{
+		printf("<br>IP Adresse %s nicht im verfuegbaren Bereich!<br>", $ip );
+		return 0;
+	}
+}
+
+/**
+* new_ip_dhcprange($ip,$dhcpobjectDN,$auDN)  
+* Weist einem DHCP Subnet/Pool eine IP Range neu zu, falls sie vergeben werden darf (in den FreeIPBlocks
+* enthalten ist), und passt die FreeIPBlocks der AU an.
+*
+* @param string ip IP Range, die zugewiesen werden soll
+* @param string dhcpobjectDN Distinguished Name des LDAP DHCP-Objektes
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return boolean 1 bei Erfolg bzw. 0 bei Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function new_ip_dhcprange($ip,$dhcpobjectDN,$auDN)
+{
+	global $ds, $suffix, $ldapError;
+   
+   $fipb_array = get_freeipblocks_au($auDN);
+   
+   print_r($fipb_array);
+   
+	for ($i=0; $i < count($fipb_array); $i++){
+		if ( split_iprange($ip,$fipb_array[$i]) != 0 ){
+			$ipranges = split_iprange($ip,$fipb_array[$i]);
+			array_splice($fipb_array, $i, 1, $ipranges);
+			break;
+		}		
+	}
+	
+	if ($i < count($fipb_array) ){	
+		# ldap_mod_replace -> Array fipb_array aktualisiert die FIPB in AU mit $auDN
+		foreach ( $fipb_array as $item ){
+		 	$entry ['FreeIPBlock'][] = $item;
+		}
+		 
+		$results = ldap_mod_replace($ds,$auDN,$entry);
+		if ($results){
+			echo "<br>Neue FIPBs erfolgreich eingetragen!<br>" ;
+			
+			# ldap_mod_add -> IPAddress = $ip , in Host mit $hostDN 
+			$ipentry ['dhcpRange'] = $ip;	
+			$results = ldap_mod_add($ds,$dhcpobjectDN,$ipentry);
+			if ($results){
+				echo "<br>IP Adresse erfolgreich eingetragen!<br>" ;
+				return 1;
+	   	}else{
+	   		echo "<br>Fehler beim eintragen der IP Adresse!<br>";
+	   		return 0;
+	   	}	    
+		}else{
+	   	echo "<br>Fehler beim eintragen der FIPBs!<br>";
+	   	return 0;
+	   }	  		
+	}else{
+		printf("<br>IP Range %s ist nicht im verfuegbaren Bereich!<br>", $ip );
+		return 0;
+	}	
+}
+
+/**
+* delete_ip_host($hostDN,$auDN)  
+* Löscht die IP Adresse eines Hosts, und passt die FreeIPBlocks der AU an.
+*
+* @param string hostDN Distinguished Name des LDAP Host-Objektes
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return boolean 1 bei Erfolg bzw. 0 bei Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function delete_ip_host($hostDN,$auDN)
+{
+	global $ds, $suffix, $ldapError;
+	
+	$host_array = get_host_ip($hostDN);
+	$old_ip = $host_array['ipaddress'];  # oder IP aus dem Formular
+	# print_r($host_array);printf("<br>");
+	# printf($old_ip);
+	$delentry ['ipaddress'] = $old_ip;
+	if ( $host_array['dhcpoptfixed-address'] != "" ){
+	   $delentry ['dhcpoptfixed-address'] = array();
+	}
+   # print_r($delentry);printf("<br>");
+	
+	$results = ldap_mod_del($ds,$hostDN,$delentry);
+	if ($results){
+		echo "<br>IP Adresse erfolgreich geloescht!<br>";	
+		$modentry['FreeIPBlock'] = $old_ip;
+   	$results = ldap_mod_add($ds,$auDN,$modentry); 
+		if ($results){
+			echo "<br>geloeschte IP Adresse erfolgreich als neuer FIPB in die AU eingetragen!<br>" ;
+			merge_ipranges($auDN);
+			return 1;
+		}
+		else{ 
+			echo "<br>Fehler beim eintragen der geloeschten IP Adresse als neuen FIPB!<br>";
+			return 0;
+		}				
+	}
+	else{ 
+		echo "<br>Fehler beim loeschen der IP Adresse!<br>";
+   	return 0;
+   }
+}
+
+/**
+* delete_ip_dhcprange($dhcpobjectDN,$auDN)  
+* Loescht die IP Range eines DHCP Subnets/Pools, und passt die FreeIPBlocks der AU an.
+*
+* @param string dhcpobjectDN Distinguished Name des LDAP DHCP-Objektes
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return boolean 1 bei Erfolg bzw. 0 bei Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function delete_ip_dhcprange($dhcpobjectDN,$auDN)
+{
+	global $ds, $suffix, $ldapError;
+	
+	$dhcp_array = get_dhcp_range($dhcpobjectDN);
+	
+	if ( $dhcp_array['dhcprange'] != "" ){
+   	$old_ip = $dhcp_array['dhcprange'];  # oder IP aus dem Formular besser da ja mehrere moeglich
+   	# print_r($dhcp_array);printf("<br>");
+   	# printf($old_ip);
+   	$delentry['dhcpRange'] = $old_ip;
+      # print_r($delentry);printf("<br>");
+   	
+   	$results = ldap_mod_del($ds,$dhcpobjectDN,$delentry);
+   	if ($results){
+   		echo "<br>DHCP IP Range erfolgreich geloescht!<br>";		
+   		$modentry['FreeIPBlock'] = $old_ip;
+      	$results = ldap_mod_add($ds,$auDN,$modentry); 
+   		if ($results){
+   			echo "<br>geloeschte IP Range erfolgreich als neuer FIPB in die AU eingetragen!<br>" ;
+   			merge_ipranges($auDN);
+   			return 1;
+   		}
+   		else{ 
+   			echo "<br>Fehler beim eintragen der geloeschten IP Range als neuen FIPB!<br>";
+   			# Transaktion simulieren und alte Range wieder eintragen ??
+   			return 0;
+   		}			
+   	}
+   	else{ 
+   		echo "<br>Fehler beim loeschen der DHCP IP Range!<br>";
+      	return 0;
+      }
+   }
+}
+
+/**
+* modify_ip_host($ip,$hostDN,$auDN)  
+* Aendert die IP Adresse eines Hosts, falls neue IP verfuegbar, und passt die FreeIPBlocks der AU an.
+*
+* @param string ip IP Adresse, die neu zugewiesen werden soll
+* @param string hostDN Distinguished Name des LDAP Host-Objektes
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return boolean 1 bei Erfolg bzw. 0 bei Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function modify_ip_host($ip,$hostDN,$auDN)
+{
+	global $ds, $suffix, $ldapError;
+	
+	if ( delete_ip_host($hostDN,$auDN) ){
+		if ( new_ip_host($ip,$hostDN,$auDN) ){
+			echo "<br>IP Adresse erfolgeich geaendert!<br>";
+			return 1;
+		}else{
+			echo "<br>Fehler beim Aendern der IP Adresse!<br>";
+			return 0;
+		}
+	}else{
+		echo "<br>Fehler beim Aendern der IP Adresse!<br>";
+		return 0;
+	}
+}
+
+/**
+* modify_ip_dhcprange($ip,$dhcpobjectDN,$auDN)  
+* Aendert IP Range eines DHCP Subnet/Pool, falls neue Range verfuegbar ist,
+* und passt die FreeIPBlocks der AU an.
+*
+* @param string ip IP Range, die neu zugewiesen werden soll
+* @param string dhcpobjectDN Distinguished Name des LDAP DHCP-Objektes
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return boolean 1 bei Erfolg bzw. 0 bei Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function modify_ip_dhcprange($ip,$dhcpobjectDN,$auDN)
+{
+	global $ds, $suffix, $ldapError;
+	
+	if ( delete_ip_dhcprange($dhcpobjectDN,$auDN) ){
+		if ( new_ip_dhcprange($ip,$dhcpobjectDN,$auDN) ){
+			echo "<br>DHCP IP Range erfolgeich geaendert!<br>";
+			return 1;
+		}else{
+			echo "<br>Fehler beim Aendern der DHCP IP Range!<br>";
+			return 0;
+		}
+	}else{
+		echo "<br>Fehler beim Aendern der DHCP IP Range!<br>";
+		return 0;
+	}
+}
+
+
+/**
+* new_ip_delegation($ip,$childauDN,$auDN)  
+* Delegiert einen neuen IP Bereich an eine untergeordnete AU, falls dieser verfuegbar ist 
+* (in den FreeIPBlocks enthalten ist), und passt die FreeIPBlocks der AU an.
+*
+* @param string ip IP Bereich, der zugewiesen werden soll
+* @param string childauDN Distinguished Name des untergeordneten (Child) LDAP AU-Objektes
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return boolean 1 bei Erfolg bzw. 0 bei Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function new_ip_delegation($ip,$childauDN,$auDN)
+{
+	global $ds, $suffix, $ldapError;
+   
+   $fipb_array = get_freeipblocks_au($auDN);
+   echo "<br>---<br>";print_r($fipb_array);echo "<br>---<br>";
+	for ($i=0; $i < count($fipb_array); $i++){
+		if ( split_iprange($ip,$fipb_array[$i]) != 0 ){
+			$ipranges = split_iprange($ip,$fipb_array[$i]);
+			array_splice($fipb_array, $i, 1, $ipranges);
+			break;
+		}		
+	}
+	
+	if ($i < count($fipb_array) ){	
+		# ldap_mod_replace -> Array fipb_array aktualisiert die FIPB in AU mit $auDN
+		foreach ( $fipb_array as $item ){
+		 	$entry ['FreeIPBlock'][] = $item;
+		}
+		 
+		$results = ldap_mod_replace($ds,$auDN,$entry);
+		if ($results){
+			echo "<br>Neue FIPBs erfolgreich eingetragen!<br>" ;
+			
+			# ldap_mod_add -> IPAddress = $ip , in Host mit $hostDN 
+			$mipbentry['MaxIPBlock'] = $ip;
+			$mipbentry['FreeIPBlock'] = $ip;
+			print_r($mipbentry);
+				
+			$results = ldap_mod_add($ds,$childauDN,$mipbentry);
+			if ($results){
+				echo "<br>IP Adressblock erfolgreich delegiert!<br>" ;
+				merge_ipranges($childauDN);
+				
+				return 1;
+			}else{
+				echo "<br>Fehler beim eintragen der IP Adresse!<br>";
+				return 0;
+			}
+		}else{
+			echo "<br>Fehler beim eintragen der FIPBs!<br>";
+			return 0;
+		}	  			    
+	}
+	else{
+		printf("<br>Zu delegierende IP Range %s ist nicht im verfuegbaren Bereich!<br>", $ip );
+	}	
+}
+
+/**
+* delete_ip_delegation($oldmipb,$childauDN,$auDN)  
+* Einen an eine untergeordnete AU delegierten IP Bereich zuruecknehmen. Diese Funktion wird rekursiv fuer
+* alle weiter-delegierten Teilbereiche abgearbeitet. FreeIPBlocks der AU und Child-AU, sowie MaxIPBlocks
+* der Child-AU werden angepasst.
+*
+* @param string oldmipb delegierter maximaler IP Bereich, der zurueckgenommen werden soll
+* @param string childauDN Distinguished Name des untergeordneten (Child) LDAP AU-Objektes
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return boolean 1 bei Erfolg bzw. 0 bei Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function delete_ip_delegation($oldmipb,$childauDN,$auDN)
+{
+	global $ds, $suffix, $ldapError;
+	
+	# Durch Reduzierung zu loeschende IP Ranges (Array)
+   $delip[] = $oldmipb;
+   print_r($delip);printf("<br><br>");
+   
+   # Finde unter allen Child-AUs diejenigen, die von Reduzierung betroffene Child-Child-AUs haben 
+	# Diese sind werden rekursiv abgearbeitet
+   $cchild_array = get_childau($childauDN,array("dn","maxipblock"));
+	# print_r($cchild_array);printf("<br><br>");
+	$cchild_todo = array();
+	foreach ($delip as $delipitem){
+		foreach ($cchild_array as $item){
+			if( count($item['maxipblock']) > 1 ){
+				foreach ($item['maxipblock'] as $item2 ){
+					if ( intersect_ipranges($delipitem,$item2) != false ){
+						$cchild_todo[] = array('coldmipb' => $item2,
+													'ccauDN' => $item['dn'],
+													'childauDN' => $childauDN );
+					}
+				}
+			}
+			elseif ( count($item['maxipblock']) == 1 ){		
+				if ( intersect_ipranges($delipitem,$item['maxipblock']) != false ){
+					$cchild_todo[] = array('coldmipb' => $item['maxipblock'],
+												'ccauDN' => $item['dn'],
+												'childauDN' => $childauDN );
+				}
+			}
+		}
+	}	
+	print_r($cchild_todo);printf("<br><br>");
+	
+	# Rekursionsaufruf (für jede Child-AU, die betroffene Child-Child-AU hat)
+	foreach ($cchild_todo as $item){
+			delete_ip_delegation($item['coldmipb'],$item['ccauDN'],$item['childauDN']);
+	}
+	
+	# Ab hier: alles was bei jedem Fkt.Aufruf zu machen ist (in Ebene AU und Child-AU) 
+   
+   # in CAU Check ob RechnerIPs oder DhcpIPs betroffen: 
+   $del_objects = objects_to_delete($delip,$childauDN,$cchild_array);
+   # print_r($del_objects);printf("<br><br>");
+   printf("<br>Host IP Addresses that will be deleted: <br>");
+   foreach ($del_objects['hostips'] as $item){
+   	printf("HostDN: %s &nbsp;&nbsp; IP Address: %s <br>",$item['dn'],$item['ip']);
+   }
+   printf("<br>Subnet IP Ranges that will be adjusted: <br>");
+   foreach ($del_objects['dhcpranges'] as $item){
+   	printf("DhcpObjectDN: %s &nbsp;&nbsp; Zu loeschende IP Range: %s <br>",$item['dn'],$item['delrange']);
+   }
+   # hier kommte Abfrage ob wirklich Aenderung ausfuehren, ja dann weiter mit loeschen 
+   # sonst Abbruch 
+   # momentan: einfach loeschen 
+   foreach ($del_objects['hostips'] as $item){
+   	delete_ip_host($item['dn'],$item['auDN']);
+   }
+   foreach ($del_objects['dhcpranges'] as $item){
+		delete_ip_dhcprange($item['dn'],$item['auDN']);
+   } 
+   
+   # in Child-AU: oldmipb loeschen 
+   $mipb_array = get_maxipblocks_au($childauDN);
+   print_r($mipb_array);printf("<br><br>");
+   foreach ($delip as $delipitem){
+   	# if ( count($mipb_array) > 1 ){
+   		for ($i=0; $i < count($mipb_array); $i++){
+   			if ( intersect_ipranges($delipitem,$mipb_array[$i]) != 0 ){
+				#$ipranges = intersect_ipranges($newmipb,$mipb_array[$i]);
+				array_splice($mipb_array, $i, 1);
+				}
+			}
+		# }else{
+		# 	if ( intersect_ipranges($delipitem,$mipb_array) != 0 ){
+		# 		# $ipranges = intersect_ipranges($newmipb,$mipb_array);
+		# 		$mipb_array = array();
+		# 	}
+		# }		
+	}
+   # print_r($mipb_array);printf("<br><br>");
+	# for ($i=0; $i < count($mipb_array); $i++){
+   #	 if ($mipb_array[$i] == false){array_splice($mipb_array, $i, 1);}
+   # }
+   print_r($mipb_array);printf("<br><br>");
+   if (count($mipb_array) == 0){
+   	$entry ['MaxIPBlock'] = array();
+   	print_r($entry);printf("<br><br>");
+   	$results = ldap_mod_del($ds,$childauDN,$entry);	
+   }else{
+	   foreach ( $mipb_array as $item ){
+		 	$entry ['MaxIPBlock'][] = $item;
+	 	}
+	 	print_r($entry);printf("<br><br>");	
+		$results = ldap_mod_replace($ds,$childauDN,$entry);
+	}	  	
+	
+	if ($results){
+		echo "<br>MIPBs in Child-AU erfolgreich geloescht!<br>" ;
+		
+		 # in Child-AU: FIPBs anpassen 
+   	$fipb_array = get_freeipblocks_au($childauDN);
+   	print_r($fipb_array);printf("<br><br>"); 
+   	foreach ($delip as $delipitem){
+   		# if ( count($fipb_array) > 1 ){
+			   for ($i=0; $i < count($fipb_array); $i++){
+					if ( intersect_ipranges($delipitem,$fipb_array[$i]) != 0 ){
+						# $ipranges = intersect_ipranges($newmipb,$fipb_array[$i]);
+						array_splice($fipb_array, $i, 1);
+					}		
+				}
+			# }
+			# else{
+			# 	if ( intersect_ipranges($delipitem,$fipb_array) != 0 ){
+			# 		# $ipranges = intersect_ipranges($newmipb,$fipb_array);
+			# 		$fipb_array = array();
+			# 	}
+			# }
+   	}
+   	# print_r($fipb_array);printf("<br><br>");
+   	# for ($i=0; $i < count($fipb_array); $i++){
+   	# 	if ($fipb_array[$i] == false){array_splice($fipb_array, $i, 1);}
+   	# }
+   	print_r($fipb_array);printf("<br><br>");
+   	if (count($fipb_array) == 0){
+   		$entry1 ['FreeIPBlock'] = array();
+   		print_r($entry1);printf("<br><br>");
+  			$results = ldap_mod_del($ds,$childauDN,$entry1);		
+   	}else{
+			foreach ( $fipb_array as $item ){
+			 	$entry1 ['FreeIPBlock'][] = $item;
+			}
+			print_r($entry1);printf("<br><br>");	
+			$results = ldap_mod_replace($ds,$childauDN,$entry1);
+		}
+		
+		if ($results){
+			echo "<br>FIPBs in Child-AU erfolgreich geloescht!<br>" ;
+			
+			# in AU: Geloeschte IP Bereiche als neue FIPBs aufnehmen
+   		foreach ($delip as $item){
+		   	$entry2 ['FreeIPBlock'][] = $item;
+   		}
+   		print_r($entry2);printf("<br><br>");
+   		$results = ldap_mod_add($ds,$auDN,$entry2);
+			if ($results){
+				echo "<br>FIPBs in AU erfolgreich aktualisiert!<br>" ;
+				
+				# IP Bloecke aufraeumen in Child-AU und AU (Merging) 	
+				merge_ipranges($auDN);
+				merge_ipranges($childauDN);
+				return 1;
+			}else{
+				echo "<br>Fehler beim aktualisieren!<br>";
+				return 0;
+			}
+		}else{
+			echo "<br>Fehler beim loeschen!<br>";
+			return 0;
+		}			
+	}else{
+		echo "<br>Fehler beim loeschen!<br>";
+		return 0;	
+   }   
+}
+
+
+/**
+* reduce_ip_delegation($oldmipb,$newmipb,$childauDN,$auDN)  
+* Einen an eine untergeordnete AU delegierten IP Bereich verkleinern. Diese Funktion wird rekursiv fuer
+* alle weiter-delegierten Teilbereiche abgearbeitet. FreeIPBlocks der AU und Child-AU, sowie MaxIPBlocks
+* der Child-AU werden angepasst.
+*
+* @param string oldmipb delegierter maximaler IP Bereich, der verkleinert werden soll
+* @param string newmipb delegierter maximaler IP Bereich nach der Verkleinerung
+* @param string childauDN Distinguished Name des untergeordneten (Child) LDAP AU-Objektes
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return boolean 1 bei Erfolg bzw. 0 bei Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function reduce_ip_delegation($oldmipb,$newmipb,$childauDN,$auDN)
+{
+	global $ds, $suffix, $ldapError;
+	
+	# Durch Reduzierung zu loeschende IP Ranges (Array)
+   $delip = split_iprange($newmipb,$oldmipb);
+   print_r($delip);printf("<br><br>");
+	
+	# Finde unter allen Child-AUs diejenigen, die von Reduzierung betroffene Child-Child-AUs haben 
+	# Diese sind werden rekursiv abgearbeitet
+   $cchild_array = get_childau($childauDN,array("dn","maxipblock"));
+	
+	$cchild_todo = array();
+	foreach ($delip as $delipitem){
+		foreach ($cchild_array as $item){
+			if( count($item['maxipblock']) > 1 ){
+				foreach ($item['maxipblock'] as $item2 ){
+					if ( intersect_ipranges($delipitem,$item2) != false ){
+						$cchild_todo[] = array('coldmipb' => $item2,
+													'cnewmipb' => intersect_ipranges($newmipb,$item2),
+													'ccauDN' => $item['dn'],
+													'childauDN' => $childauDN );
+					}
+				}
+			}
+			elseif ( count($item['maxipblock']) == 1 ){		
+				if ( intersect_ipranges($delipitem,$item['maxipblock']) != false ){
+					$cchild_todo[] = array('coldmipb' => $item['maxipblock'],
+												'cnewmipb' => intersect_ipranges($newmipb,$item['maxipblock']),
+												'ccauDN' => $item['dn'],
+												'childauDN' => $childauDN );
+				}
+			}
+		}
+	}	
+	print_r($cchild_todo);printf("<br><br>");
+	
+	
+	# Rekursionsaufruf (für jede Child-AU, die betroffene Child-Child-AU hat)
+	foreach ($cchild_todo as $item){
+		if ($item['cnewmipb'] == false ){
+			delete_ip_delegation($item['coldmipb'],$item['ccauDN'],$item['childauDN']);
+		}
+		else{
+		   reduce_ip_delegation($item['coldmipb'],$item['cnewmipb'],$item['ccauDN'],$item['childauDN']);
+		}
+	}
+	 
+   
+   # Ab hier: alles was bei jedem Fkt.Aufruf zu machen ist (auf Ebene AU und Child-AU) 
+   
+   # in CAU Check ob RechnerIPs oder DhcpIPs betroffen: 
+   # - falls ja: nochmals Abfrage (Hammermethode: diese auch loeschen) ob diese zu loeschen sind
+   #   -> ja, betreffende IPs loeschen
+   #   -> nein, Abbruch.
+   # - falls nein: fuer jedes FIPB in CAU intersect(FIPB,newmipb)-> Schnittmengen bilden die neuen FIPB
+   $del_objects = objects_to_adjust($newmipb,$delip,$childauDN,$cchild_array);
+   # print_r($del_objects);printf("<br><br>");
+   printf("<br>Host IP Addresses that will be deleted: <br>");
+   foreach ($del_objects['hostips'] as $item){
+   	printf("HostDN: %s &nbsp;&nbsp; IP Address: %s <br>",$item['dn'],$item['ip']);
+   }
+   printf("<br>Subnet IP Ranges that will be adjusted: <br>");
+   foreach ($del_objects['dhcpranges'] as $item){
+   	printf("DhcpObjectDN: %s &nbsp;&nbsp; New IP Range: %s <br>",$item['dn'],$item['newrange']);
+   }
+
+   # momentan wird einfach geloescht:
+   foreach ($del_objects['hostips'] as $item){
+   	delete_ip_host($item['dn'],$item['auDN']);
+   }
+   foreach ($del_objects['dhcpranges'] as $item){
+   	if ( count($item['newrange']) >= 1 ){
+			modify_ip_dhcprange($item['newrange'],$item['dn'],$item['auDN']);
+		}else{
+			delete_ip_dhcprange($item['dn'],$item['auDN']);
+		}
+   } 
+   
+   
+   # in Child-AU: oldmipb -> newmipb
+   $mipb_array = get_maxipblocks_au($childauDN);
+   # print_r($mipb_array);printf("<br><br>");
+   foreach ($delip as $delipitem){
+   	for ($i=0; $i < count($mipb_array); $i++){
+   		if ( intersect_ipranges($delipitem,$mipb_array[$i]) != 0 ){
+			$ipranges = intersect_ipranges($newmipb,$mipb_array[$i]);
+			array_splice($mipb_array, $i, 1, $ipranges);
+			}
+		}
+	}
+   # print_r($mipb_array);printf("<br><br>");
+	for ($i=0; $i < count($mipb_array); $i++){
+   	if ($mipb_array[$i] == false){array_splice($mipb_array, $i, 1);}
+   }
+   print_r($mipb_array);printf("<br><br>");
+   if (count($mipb_array) == 0){
+   	$entry ['MaxIPBlock'] = array();
+   	print_r($entry);printf("<br><br>");
+   	$results = ldap_mod_del($ds,$childauDN,$entry);
+   }else{
+	   foreach ( $mipb_array as $item ){
+		 	$entry ['MaxIPBlock'][] = $item;
+	 	}
+	 	print_r($entry);printf("<br><br>");	
+		$results = ldap_mod_replace($ds,$childauDN,$entry);
+	}
+	
+	if ($results){
+		echo "<br>MIPBs in Child-AU erfolgreich aktualisiert!<br>" ;
+	
+		# in Child-AU: FIPBs anpassen 
+   	$fipb_array = get_freeipblocks_au($childauDN);
+   	#print_r($fipb_array);printf("<br><br>"); 
+   	foreach ($delip as $delipitem){
+		   for ($i=0; $i < count($fipb_array); $i++){
+				if ( intersect_ipranges($delipitem,$fipb_array[$i]) != 0 ){
+					$ipranges = intersect_ipranges($newmipb,$fipb_array[$i]);
+					array_splice($fipb_array, $i, 1, $ipranges);
+				}		
+			}
+   	}
+   	# print_r($fipb_array);printf("<br><br>");
+   	for ($i=0; $i < count($fipb_array); $i++){
+   		if ($fipb_array[$i] == false){array_splice($fipb_array, $i, 1);}
+   	}
+   	print_r($fipb_array);printf("<br><br>");   
+		if (count($fipb_array) == 0){
+   		$entry1 ['FreeIPBlock'] = array();
+   		print_r($entry1);printf("<br><br>");
+  			$results = ldap_mod_del($ds,$childauDN,$entry1);
+   	}else{
+			foreach ( $fipb_array as $item ){
+			 	$entry1 ['FreeIPBlock'][] = $item;
+			}
+			print_r($entry1);printf("<br><br>");
+			$results = ldap_mod_replace($ds,$childauDN,$entry1);		
+		}
+
+		if ($results){
+			echo "<br>FIPBs in Child-AU erfolgreich aktualisiert!<br>" ;
+			
+			# in AU: Geloeschte IP Bereiche als neue FIPBs aufnehmen
+   		foreach ($delip as $item){
+	   		$entry2 ['FreeIPBlock'][] = $item;
+   		}
+   		print_r($entry2);printf("<br><br>");
+   		$results = ldap_mod_add($ds,$auDN,$entry2);
+			if ($results){
+				echo "<br>FIPBs in AU erfolgreich aktualisiert!<br>" ;
+				
+				# IP Bloecke aufraeumen in Child-AU und AU (Merging) 	
+				merge_ipranges($auDN);
+				merge_ipranges($childauDN);
+				
+				return 1;
+			}else{
+				echo "<br>Fehler beim aktualisieren!<br>";
+				return 0;
+			}	
+		}else{
+			echo "<br>Fehler beim aktualisieren!<br>";
+			return 0;
+		}		
+	}else{
+		echo "<br>Fehler beim aktualisieren!<br>";
+		return 0;
+	}	  	
+}
+
+
+/**
+* expand_ip_delegation($oldmipb,$newmipb,$childauDN,$auDN)  
+* Einen an eine untergeordnete AU delegierten IP Bereich erweitern. Diese Funktion wird rekursiv fuer
+* alle weiter-delegierten Teilbereiche abgearbeitet. FreeIPBlocks der AU und Child-AU, sowie MaxIPBlocks
+* der Child-AU werden angepasst. Entspricht einer Neu-Delegierung des erweiterten IP Bereichs.
+*
+* @param string oldmipb delegierter maximaler IP Bereich, der erweitert werden soll
+* @param string newmipb delegierter maximaler IP Bereich nach der Erweiterung
+* @param string childauDN Distinguished Name des untergeordneten (Child) LDAP AU-Objektes
+* @param string auDN Distinguished Name des LDAP AU-Objektes
+*
+* @return boolean 1 bei Erfolg bzw. 0 bei Misserfolg
+*
+* @author Tarik Gasmi
+*/
+function expand_ip_delegation($oldmipb,$newmipb,$childauDN,$auDN)
+{
+	global $ds, $suffix, $ldapError;
+	
+	$difference = split_iprange($oldmipb,$newmipb);
+	new_ip_delegation($difference[0],$childauDN,$auDN);
+}
+
+
+/**
+* objects_to_delete($delip,$childauDN,$cchild_array)  
+* Liefert die durch eine Rücknahme einer IP Delegierung betroffenen Host/DHCP-Objekte der Child-AU
+* und Child-Child-AUs in einem Array. Dieses enthaelt fuer jedes Objekt dessen Distinguished Name,
+* dessen IP Adresse(n)/Range(s) und den Distinguished Name der AU der das Objekt angehoert. Parameter 
+* die fuer die Funktionen delete_ip_host(), delete_ip_range() Benoetigt werden.
+*
+* @param string delip IP Bereich der geloescht wird
+* @param string childauDN Distinguished Name des untergeordneten (Child) LDAP AU-Objektes
+* @param array cchild_array Array von allen Child-Child-AUs (jedes Item enthaelt DN und MaxIPBlock)
+*
+* @return array objects_to_delete Array aller betroffenen Objekte (DN, IP, auDN)
+*
+* @author Tarik Gasmi
+*/
+function objects_to_delete($delip,$childauDN,$cchild_array)
+{
+	global $ds, $suffix, $ldapError;
+	
+	# Hosts von child-AU, child-child-AU
+	$chosts = get_hosts($childauDN,array("dn","ipaddress"));
+   # print_r($chosts);printf("<br><br>");
+   foreach ($cchild_array as $item){
+   	$cchostsitem = get_hosts($item['dn'],array("dn","ipaddress"));
+   	foreach ($cchostsitem as $item2){
+   	  	$cchosts[] = $item2;
+   	}
+   }
+   $chosts = array_merge($chosts,$cchosts);
+   # print_r($chosts);printf("<br><br>");
+   
+   # Subnets von child-AU, child-child-AU
+   $csubnets = get_subnets($childauDN,array("dn","dhcprange"));
+   # print_r($csubnets);printf("<br><br>");
+   foreach ($cchild_array as $item){
+   	$ccsubnetsitem = get_hosts($item['dn'],array("dn","dhcprange"));
+   	foreach ($ccsubnetsitem as $item2){
+   	  	$ccsubnets[] = $item2;
+   	}
+   }
+   $csubnets = array_merge($csubnets,$ccsubnets);
+   # print_r($csubnets);printf("<br><br>");
+   
+   # Pools von child-AU, child-child-AU
+   /*$cpools = get_pools($childauDN,array("dn","dhcprange"));
+   # print_r($cpools);printf("<br>");
+   foreach ($cchild_array as $item){
+   	$ccpoolsitem = get_hosts($item['dn'],array("dn","dhcprange"));
+   	foreach ($ccpoolsitem as $item2){
+   	  	$ccpools[] = $item2;
+   	}
+   }
+   $cpools = array_merge($cpools,$ccpools);
+   # print_r($cpools);printf("<br><br>");
+   */
+   
+   # Zu loeschende Hosts bestimmen
+   $chosts_todo = array();
+	foreach ($delip as $delipitem){
+		foreach ($chosts as $item){
+			if( count($item['ipaddress']) > 1 ){
+				foreach ($item['ipaddress'] as $item2 ){
+					if ( intersect_ipranges($delipitem,$item2) != false ){
+						$chosts_todo[] = array('dn' => $item['dn'],
+														'ip' => $item['ipaddress'],
+														'auDN' => $item['auDN']);
+					}
+				}
+			}
+			elseif ( count($item['ipaddress']) == 1 ){		
+				if ( intersect_ipranges($delipitem,$item['ipaddress']) != false ){
+					$chosts_todo[] = array('dn' => $item['dn'],
+													'ip' => $item['ipaddress'],
+													'auDN' => $item['auDN']);
+				}
+			}
+		}
+	}
+   # print_r($chosts_todo);printf("<br><br>");
+   
+   # Zu loeschende Subnets bestimmen, und wie IP Range anzupassen ist
+   $csubnets_todo = array();
+	foreach ($delip as $delipitem){
+		foreach ($csubnets as $item){
+			if( count($item['dhcprange']) > 1 ){
+				foreach ($item['dhcprange'] as $item2 ){
+					# print_r(intersect_ipranges($delipitem,$item2));
+					if ( intersect_ipranges($delipitem,$item2) != false ){
+						$csubnets_todo[] = array('dn'=> $item['dn'],
+														'delrange' => $item2['dhcprange'],
+														'auDN' => $item['auDN']);
+					}
+				}
+			}
+			elseif ( count($item['dhcprange']) == 1 ){		
+				# print_r(intersect_ipranges($delipitem,$item['dhcprange']));
+				if ( intersect_ipranges($delipitem,$item['dhcprange']) != false ){
+					$csubnets_todo[] = array('dn'=> $item['dn'],
+ 													'delrange' => $item['dhcprange'],
+ 													'auDN' => $item['auDN']);
+				}
+			}
+		}
+	}
+   # print_r($csubnets_todo);printf("<br><br>");
+   
+   # Zu loeschende Pools bestimmen, und wie IP Range anzupassen ist
+   /*$cpools_todo = array();
+	foreach ($delip as $delipitem){
+		foreach ($cpools as $item){
+			if( count($item['dhcprange']) > 1 ){
+				foreach ($item['dhcprange'] as $item2 ){
+					if ( intersect_ipranges($delipitem,$item2) != false ){
+						$cpools_todo[] = array('dn'=> $item['dn'],
+														'delrange' => $item2['dhcprange'],
+														'auDN' => $item['auDN']);
+					}
+				}
+			}
+			elseif ( count($item['dhcprange']) == 1 ){		
+				if ( intersect_ipranges($delipitem,$item['dhcprange']) != false ){
+					$cpools_todo[] = array('dn'=> $item['dn'],
+ 													'delrange' => $item['dhcprange'],
+ 													'auDN' => $item['auDN']);
+				}
+			}
+		}
+	}
+   # print_r($cpools_todo);printf("<br><br>");
+   */ 
+   
+   $dhcps_todo = array_merge($csubnets_todo,$cpools_todo);
+    
+   $objects_to_delete = array('hostips' => $chosts_todo,
+   									'dhcpranges' => $dhcps_todo);
+   return $objects_to_delete;
+}
+
+
+/**
+* objects_to_adjust($newmipb,$delip,$childauDN,$cchild_array)  
+* Liefert die durch eine Reduzierung einer IP Delegierung betroffenen Host/DHCP-Objekte der Child-AU
+* und Child-Child-AUs in einem Array. Dieses enthaelt fuer jedes Objekt dessen Distinguished Name,
+* dessen IP Adresse(n)/Range(s) und den Distinguished Name der AU der das Objekt angehoert. Parameter 
+* die fuer die Funktionen delete_ip_host(), delete_ip_dhcprange(), modify_ip_dhcprange() benoetigt werden.
+*
+* @param string newmipb IP Bereich der nach Reduzierung verbleibt
+* @param string delip IP Bereich der durch Reduzierung wegfaellt
+* @param string childauDN Distinguished Name des untergeordneten (Child) LDAP AU-Objektes
+* @param array cchild_array Array von allen Child-Child-AUs (jedes Item enthaelt DN und MaxIPBlock)
+*
+* @return array objects_to_adjust Array aller betroffenen Objekte (DN, IP, auDN)
+*
+* @author Tarik Gasmi
+*/
+function objects_to_adjust($newmipb,$delip,$childauDN,$cchild_array)
+{
+	global $ds, $suffix, $ldapError;
+	
+	# Hosts von child-AU, child-child-AU
+	$chosts = get_hosts($childauDN,array("dn","ipaddress"));
+   # print_r($chosts);printf("<br><br>");
+   foreach ($cchild_array as $item){
+   	$cchostsitem = get_hosts($item['dn'],array("dn","ipaddress"));
+   	foreach ($cchostsitem as $item2){
+   	  	$cchosts[] = $item2;
+   	}
+   }
+   $chosts = array_merge($chosts,$cchosts);
+   # print_r($chosts);printf("<br><br>");
+   
+   # Subnets von child-AU, child-child-AU
+   $csubnets = get_subnets($childauDN,array("dn","dhcprange"));
+   # print_r($csubnets);printf("<br><br>");
+   foreach ($cchild_array as $item){
+   	$ccsubnetsitem = get_hosts($item['dn'],array("dn","dhcprange"));
+   	foreach ($ccsubnetsitem as $item2){
+   	  	$ccsubnets[] = $item2;
+   	}
+   }
+   $csubnets = array_merge($csubnets,$ccsubnets);
+   # print_r($csubnets);printf("<br><br>");
+   
+   # Pools von child-AU, child-child-AU
+   /*$cpools = get_pools($childauDN,array("dn","dhcprange"));
+   # print_r($cpools);printf("<br>");
+   foreach ($cchild_array as $item){
+   	$ccpoolsitem = get_hosts($item['dn'],array("dn","dhcprange"));
+   	foreach ($ccpoolsitem as $item2){
+   	  	$ccpools[] = $item2;
+   	}
+   }
+   $cpools = array_merge($cpools,$ccpools);
+   # print_r($cpools);printf("<br><br>");
+   */
+   
+   # Zu loeschende Hosts bestimmen
+   $chosts_todo = array();
+	foreach ($delip as $delipitem){
+		foreach ($chosts as $item){
+			if( count($item['ipaddress']) > 1 ){
+				foreach ($item['ipaddress'] as $item2 ){
+					if ( intersect_ipranges($delipitem,$item2) != false ){
+						$chosts_todo[] = array('dn' => $item['dn'],
+														'ip' => $item['ipaddress'],
+														'auDN' => $item['auDN']);
+					}
+				}
+			}
+			elseif ( count($item['ipaddress']) == 1 ){		
+				if ( intersect_ipranges($delipitem,$item['ipaddress']) != false ){
+					$chosts_todo[] = array('dn' => $item['dn'],
+													'ip' => $item['ipaddress'],
+													'auDN' => $item['auDN']);
+				}
+			}
+		}
+	}
+   # print_r($chosts_todo);printf("<br><br>");
+   
+   # Zu loeschende Subnets bestimmen, und wie IP Range anzupassen ist
+   $csubnets_todo = array();
+	foreach ($delip as $delipitem){
+		foreach ($csubnets as $item){
+			if( count($item['dhcprange']) > 1 ){
+				foreach ($item['dhcprange'] as $item2 ){
+					# print_r(intersect_ipranges($delipitem,$item2));
+					if ( intersect_ipranges($delipitem,$item2) != false ){
+						$csubnets_todo[] = array('dn'=> $item['dn'],
+														'newrange' => intersect_ipranges($newmipb,$item2),
+														'auDN' => $item['auDN']);
+					}
+				}
+			}
+			elseif ( count($item['dhcprange']) == 1 ){		
+				# print_r(intersect_ipranges($delipitem,$item['dhcprange']));
+				if ( intersect_ipranges($delipitem,$item['dhcprange']) != false ){
+					$csubnets_todo[] = array('dn'=> $item['dn'],
+ 													'newrange' => intersect_ipranges($newmipb,$item['dhcprange']),
+ 													'auDN' => $item['auDN']);
+				}
+			}
+		}
+	}
+   # print_r($csubnets_todo);printf("<br><br>");
+   
+   # Zu loeschende Pools bestimmen, und wie IP Range anzupassen ist
+   /*$cpools_todo = array();
+	foreach ($delip as $delipitem){
+		foreach ($cpools as $item){
+			if( count($item['dhcprange']) > 1 ){
+				foreach ($item['dhcprange'] as $item2 ){
+					if ( intersect_ipranges($delipitem,$item2) != false ){
+						$cpools_todo[] = array('dn'=> $item['dn'],
+														'newrange' => intersect_ipranges($newmipb,$item2),
+														'auDN' => $item['auDN']);
+					}
+				}
+			}
+			elseif ( count($item['dhcprange']) == 1 ){		
+				if ( intersect_ipranges($delipitem,$item['dhcprange']) != false ){
+					$cpools_todo[] = array('dn'=> $item['dn'],
+ 													'newrange' => intersect_ipranges($newmipb,$item['dhcprange']),
+ 													'auDN' => $item['auDN']);
+				}
+			}
+		}
+	}
+   # print_r($cpools_todo);printf("<br><br>");
+   */ 
+   
+   $dhcps_todo = array_merge($csubnets_todo,$cpools_todo);
+    
+   $objects_to_adjust = array('hostips' => $chosts_todo,
+   									'dhcpranges' => $dhcps_todo);
+   return $objects_to_adjust;
+}
+
+
+?>
\ No newline at end of file
-- 
cgit v1.2.3-55-g7522