summaryrefslogtreecommitdiffstats
path: root/ldap-site-mngmt/webinterface/lib/ip_management_functions.php
diff options
context:
space:
mode:
Diffstat (limited to 'ldap-site-mngmt/webinterface/lib/ip_management_functions.php')
-rw-r--r--ldap-site-mngmt/webinterface/lib/ip_management_functions.php1385
1 files changed, 1385 insertions, 0 deletions
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
generated by cgit v1.2.3-55-g7522 (git 2.39.0) at 2024-05-26 03:24:19 +0200