diff options
Diffstat (limited to 'ldap-site-mngmt/webinterface/lib')
| -rw-r--r-- | ldap-site-mngmt/webinterface/lib/au_management_functions.php | 1186 | ||||
| -rw-r--r-- | ldap-site-mngmt/webinterface/lib/commonlib.inc.php | 552 | ||||
| -rw-r--r-- | ldap-site-mngmt/webinterface/lib/config.inc.php | 27 | ||||
| -rw-r--r-- | ldap-site-mngmt/webinterface/lib/dhcp_management_functions.php | 625 | ||||
| -rw-r--r-- | ldap-site-mngmt/webinterface/lib/host_management_functions.php | 385 | ||||
| -rw-r--r-- | ldap-site-mngmt/webinterface/lib/ip_management_functions.php | 1385 | ||||
| -rw-r--r-- | ldap-site-mngmt/webinterface/lib/ldap.inc.php | 996 | ||||
| -rw-r--r-- | ldap-site-mngmt/webinterface/lib/ldap2.inc.php | 350 | ||||
| -rw-r--r-- | ldap-site-mngmt/webinterface/lib/rbs_management_functions.php | 591 | ||||
| -rw-r--r-- | ldap-site-mngmt/webinterface/lib/syntax_check.php | 268 |
10 files changed, 6365 insertions, 0 deletions
diff --git a/ldap-site-mngmt/webinterface/lib/au_management_functions.php b/ldap-site-mngmt/webinterface/lib/au_management_functions.php new file mode 100644 index 00000000..e6f46cfc --- /dev/null +++ b/ldap-site-mngmt/webinterface/lib/au_management_functions.php @@ -0,0 +1,1186 @@ +<?php + +/** +* au_management_functions.php - Administrative Unit Management Funktions-Bibliothek +* Diese Bibliothek enthält alle Funktionen für die Verwaltung von AUs, deren DNS Domains, sowie +* zum Rollen-Management +* +* @param string ldapError +* @param resource ds +* +* @author Tarik Gasmi +* @copyright Tarik Gasmi +*/ + +# Konfiguration laden +require_once("config.inc.php"); + +$ldapError = null; + +######################################################################################################## + + + +############################################################################### +# Funktionen zur Verwaltung der AU (und Child-AUs) +# + + +# Ändern des DN der AU, d.h. beim Ändern des Attributes 'ou' +function modify_au_dn($auDN, $newauDN){ + + global $ds, $suffix, $ldapError; + + if (move_subtree($auDN,$newauDN)){ + adjust_dn_entries($auDN,$newauDN);} +} + + + +# Anlegen neue untergeordnete AU +function new_childau($childDN,$childou,$childcn,$childdesc,$mainadmin){ + + global $ds, $suffix, $auDN, $ldapError; + + $entryAU ["objectclass"][0] = "administrativeunit"; + $entryAU ["objectclass"][1] = "organizationalunit"; + $entryAU ["objectclass"][2] = "top"; + $entryAU ["ou"] = $childou; + if ($childcn != ""){$entryAU ["cn"] = $childcn;} + if ($childdesc != ""){$entryAU ["description"] = $childdesc;} + + if ($resultAU = ldap_add($ds,$childDN,$entryAU)){ + + # alle Au Container anlegen + $containers = array("computers","dhcp","groups","rbs","roles"); + foreach ($containers as $cont){ + $entryCont = array(); + $entryCont ['objectclass'] = "AUContainer"; + $entryCont ['cn'] = $cont; + #print_r($entryRolesCont); echo "<br><br>"; + $resultC = ldap_add($ds,"cn=".$cont.",".$childDN,$entryCont); + if (!($resultC)) break; + } + + # MainAdmin anlegen + $entryMA ['objectclass'] = "groupOfNames"; + $entryMA ['cn'] = "MainAdmin"; + $entryMA ['member'] = $mainadmin; + if ($resultMA = ldap_add($ds,"cn=MainAdmin,cn=roles,".$childDN,$entryMA)){ + $admins = array("HostAdmin","DhcpAdmin","ZoneAdmin"); + foreach ($admins as $admin){ + $entryAdmin ['objectclass'] = "Admins"; + $entryAdmin ['cn'] = $admin; + ldap_add($ds,"cn=".$admin.",cn=roles,".$childDN,$entryAdmin); + } + return 1; + } + else{ + return 0; + } + } + else{ + return 0; + } +} + + + +# Löschen untergeordnete AU (d.h. deren untergeordnete AUs werden als neue uAUs integriert) +function delete_childau($childDN,$childou,$delmodus){ + + global $ds, $suffix, $auDN, $domDN, $assocdom, $ldapError; + + if ( $delmodus == "integrate"){ + + # Associated DNS Domain integrieren + $childdc = get_domain_data($childDN,array("dn","associatedname")); + print_r($childdc); echo "<br>"; + # wenn einzige AU dann einfach in Parentdomain aufnehmen und betroffene Einträge löschen + if (count($childdc[0]['associatedname']) == 1 ){ + echo "einzige AU<br>"; + # dc Childs verschieben + $dcchilds = get_dc_childs($childdc[0]['dn'],array("dn","dc")); + # print_r($dcchilds); echo "<br>"; + if (count($dcchilds) != 0){ + foreach ($dcchilds as $dcc){ + # print_r($dcc['dn']); echo " >> "; print_r("dc=".$dcc['dc'].",".$domDN); echo "<br>"; + if(move_subtree($dcc['dn'],"dc=".$dcc['dc'].",".$domDN)){ + $newdom = $dcc['dc'].".".$assocdom; + #print_r($newdom); echo "<br><br>"; + dive_into_dctree_adapt("dc=".$dcc['dc'].",".$domDN,$newdom); + } + } + } + + # alten dc-Knoten löschen + dive_into_tree_del($childdc[0]['dn'],""); + + } + # wenn noch andere AUs in der Domain, dann nur betroffene Einträge entfernen + if (count($childdc[0]['associatedname']) > 1 ){ + echo "mehrere AUs<br>"; + # ChildAU-Rollen unterhalb dc-Knoten löschen (nur diese)(oder übernehmen: MA zu HA, HA zu HA) + $roles = get_roles($childDN); + #print_r($roles); echo "<br>"; + if(count($roles['MainAdmin']) != 0){ + $mainadmins = $roles['MainAdmin']; + for ($i=0; $i<count($mainadmins); $i++){ + $entryRoleMain ['member'][$i] = $mainadmins[$i]; + } + #print_r($entryRoleHost); echo "<br>"; + $resultMA = ldap_mod_del($ds,"cn=MainAdmin,cn=roles,".$childdc[0]['dn'],$entryRoleMain); + } + if(count($roles['HostAdmin']) != 0){ + $hostadmins = $roles['HostAdmin']; + for ($i=0; $i<count($hostadmins); $i++){ + $entryRoleHost ['member'][$i] = $hostadmins[$i]; + } + #print_r($entryRoleHost); echo "<br>"; + $resultHA = ldap_mod_del($ds,"cn=HostAdmin,cn=roles,".$childdc[0]['dn'],$entryRoleHost); + } + if(count($roles['ZoneAdmin']) != 0){ + $zoneadmins = $roles['ZoneAdmin']; + for ($i=0; $i<count($zoneadmins); $i++){ + $entryRoleZone ['member'][$i] = $zoneadmins[$i]; + } + $resultZA = ldap_mod_del($ds,"cn=ZoneAdmin,cn=roles,".$childdc[0]['dn'],$entryRoleZone); + } + + $entrydel ['associatedname'] = $childDN; + # print_r($entrydel); echo "<br>"; + ldap_mod_del($ds, $childdc[0]['dn'], $entrydel); + $zentries = get_zone_entries_assocname($childdc[0]['dn'],array("dn"),$childDN); + # print_r($zentries); echo "<br>"; + foreach ($zentries as $ze){ + # print_r($ze['dn']); echo "<br>"; + ldap_delete($ds, $ze['dn']); + } + } + + # Rechner (mit IP) + dranhängende MCs, PXEs verschieben + $hosts = get_hosts($childDN,array("dn","hostname")); + if (count($hosts) != 0){ + foreach ($hosts as $host){ + # print_r($host['dn']); echo "<br>"; + # print_r($host['hostname']); echo "<br>"; + # print_r("hostname=".$host['hostname']."-int-".$childou.",cn=computers,".$auDN); echo "<br><br>"; + if (move_subtree($host['dn'], "hostname=".$host['hostname']."-ex-".$childou.",cn=computers,".$auDN)){ + $newhostDN = "hostname=".$host['hostname']."-ex-".$childou.",cn=computers,".$auDN; + $dhcp = get_node_data($newhostDN, array("dhcphlpcont")); + # print_r($dhcp); echo "<br>"; + if ($dhcp['dhcphlpcont'] != ""){ + $entrydel ['dhcphlpcont'] = array(); + $entrydel ['objectclass'] = "dhcpHost"; + # print_r($dhcphlpcont); + ldap_mod_del($ds, $newhostDN, $entrydel); + } + } + } + } + # DHCP Objekte IP Ranges löschen + $subnets = get_subnets($childDN,array("dn")); + # print_r($subnets); echo "<br>"; + if (count($subnets) != 0){ + foreach ($subnets as $subnet){ + # print_r($subnet['dn']); echo "<br>"; + delete_ip_dhcprange($subnet['dn'],$childDN); + } + } # DHCP Pools auch noch + + # Freie IP Bereiche zurücknehmen + $fipb_array = get_freeipblocks_au($childDN); + # print_r($fipb_array); echo "<br>"; + # print_r(count($fipb_array)); echo "<br>"; + if (count($fipb_array) == 1 && $fipb_array[0] != ""){ + $entry_ipblock ['freeipblock'] = $fipb_array[0]; + # print_r($entry_ipblock); echo "<br>"; + ldap_mod_add($ds,$auDN,$entry_ipblock); + } + if (count($fipb_array) > 1 ){ + foreach ($fipb_array as $fipb){ + $entry_ipblock ['FreeIPBlock'][] = $fipb; + # print_r($entry_ipblock); echo "<br>"; + ldap_mod_add($ds,$auDN,$entry_ipblock); + } + } + merge_ipranges($auDN); + + + # Verschieben der Childs an neue Stelle + $child_childs = get_childau($childDN,array("dn","ou")); + # print_r($child_childs); echo "<br>"; + if (count($child_childs) != 0){ + foreach ($child_childs as $cc){ + $child_childDN = $cc['dn']; + $newccDN = "ou=".$cc['ou'].",".$auDN; + # print_r($child_childDN); echo " >> "; + # print_r($newccDN); echo "<br>"; + if (move_subtree($child_childDN,$newccDN)){ + adjust_dn_entries($child_childDN,$newccDN); + } + } + } + + # Löschen des AU Knotens + dive_into_tree_del($childDN,""); + + $mesg = "<br>Erfolgreich gelöscht mit Integration<br>"; + return $mesg; + } + + if ( $delmodus == "complete" ){ + # IP Bereiche zurück + # DNS Teilbaum Objekte löschen + # alles rekursive löschen + + /*if (dive_into_tree_del($dcDN,"")){ + $delentry ['objectclass'] = "domainrelatedobject"; + $delentry ['associateddomain'] = $domsuffix; + #print_r($delentry); echo "<br>"; + $delresult = ldap_mod_del($ds,$childDN,$delentry); + if ($delresult){ + $mesg = "Domain komplett gelöscht<br>"; + }else{$mesg = "Fehler! ldap_mod_del<br>";} + }else{$mesg = "Fehler! dive_into_tree_del<br>";} + */ + $mesg = "Komplettes löschen mometan noch nicht unterstützt.<br> + Nur eine Ebene mit Integration ...<br>"; + return $mesg; + } +} + + + + +############################################################################### +# Funktionen zur Verwaltung von Domains +# + + +# Anlegen Domain beim Anlegen einer Child-AU +function new_child_domain($childdomain, $childDN, $assocdom, $domDN){ + + global $ds, $suffix, $domprefix, $domsuffix, $ldapError; + $domsuffix_actual = $domsuffix; + + # ChildAU in gleicher Domain wie AU + if ( $childdomain == "" || $childdomain == $domprefix ){ + + $entryDC ["associatedname"] = $childDN; + $resultDC = ldap_mod_add($ds,$domDN,$entryDC); + if ($resultDC){ + # HostAdmins übernehmen, welche Admins noch? MainAdmin? + $roles = get_roles($childDN); + if(count($roles['MainAdmin']) != 0){ + $mainadmins = $roles['MainAdmin']; + for ($i=0; $i<count($mainadmins); $i++){ + $entryRoleMain ['member'][$i] = $mainadmins[$i]; + } + #print_r($entryRoleHost); echo "<br>"; + $resultMA = ldap_mod_add($ds,"cn=MainAdmin,cn=roles,".$domDN,$entryRoleMain); + } + if(count($roles['HostAdmin']) != 0){ + $hostadmins = $roles['HostAdmin']; + for ($i=0; $i<count($hostadmins); $i++){ + $entryRoleHost ['member'][$i] = $hostadmins[$i]; + } + #print_r($entryRoleHost); echo "<br>"; + $resultHA = ldap_mod_add($ds,"cn=HostAdmin,cn=roles,".$domDN,$entryRoleHost); + } + # Domainname zu associatedDomain der ChildAU + $entryAD['objectclass'] = "domainRelatedObject"; + $entryAD['associateddomain'] = $assocdom; + $resultAD = ldap_mod_add($ds,$childDN,$entryAD); + if($resultAD){return 1;}else{return 0;} + } + else{return 0;} + } + + # ChildAU in eigner Domain (inklusive Subdomain von AU Domain) + if ( $childdomain != "" && $childdomain != $domprefix ){ + + # entsprechenden DC Knoten anlegen, sowie Roles (MainAdmin, HostAdmin) + $dc_array = explode('.',$childdomain); + $dc_array = array_reverse($dc_array); + $dcDN = "ou=DNS,".$suffix; + # $childdomainfull = $childdomain.".".$domsuffix; + #print_r($dc_array); + foreach ($dc_array as $dc){ + $resultsum = false; + if (check_for_dc($dcDN,$dc)){ + echo "dc <b>".$dc."</b> schon vorhanden ... nächster dc<br>"; + $domsuffix_actual = $dc.".".$domsuffix_actual; + $dcDN = "dc=".$dc.",".$dcDN; + } + else{ + $dcDN = "dc=".$dc.",".$dcDN; + + $entryDC ["objectclass"][0] = "dnsdomain"; + $entryDC ["objectclass"][1] = "domainrelatedobject"; + $entryDC ["objectclass"][2] = "top"; + $entryDC ["dc"] = $dc; + $entryDC ["associatedname"] = $childDN; + $entryDC ["associateddomain"] = $dc.".".$domsuffix_actual; + #print_r($entryDC); echo "<br>"; + #print_r($dcDN); echo "<br><br>"; + $resultDC = ldap_add($ds,$dcDN,$entryDC); + if ($resultDC){ + $domsuffix_actual = $dc.".".$domsuffix_actual; + + #print_r($dcDN); echo"<br><br>"; + + $entryRolesCont ['objectclass'] = "AUContainer"; + $entryRolesCont ['cn'] = "roles"; + #print_r($entryRolesCont); echo "<br><br>"; + $resultRC = ldap_add($ds,"cn=roles,".$dcDN,$entryRolesCont); + if ($resultRC){ + # Rollen eintragen + $roles = get_roles($childDN); + #print_r($roles); echo "<br><br>"; + $mainadmins = $roles['MainAdmin']; + $entryRoleMain ['objectclass'] = "groupOfNames"; + $entryRoleMain ['cn'] = "MainAdmin"; + for ($i=0; $i<count($mainadmins); $i++){ + $entryRoleMain ['member'][$i] = $mainadmins[$i]; + } + #print_r($entryRoleMain); echo "<br>"; + $resultMA = ldap_add($ds,"cn=MainAdmin,cn=roles,".$dcDN,$entryRoleMain); + + $entryRoleHost ['objectclass'] = "Admins"; + $entryRoleHost ['cn'] = "HostAdmin"; + if(count($roles['HostAdmin']) != 0){ + $hostadmins = $roles['HostAdmin']; + for ($i=0; $i<count($hostadmins); $i++){ + $entryRoleHost ['member'][$i] = $hostadmins[$i]; + } + #print_r($entryRoleHost); echo "<br>"; + } + $resultHA = ldap_add($ds,"cn=HostAdmin,cn=roles,".$dcDN,$entryRoleHost); + + $entryRoleZone ['objectclass'] = "Admins"; + $entryRoleZone ['cn'] = "ZoneAdmin"; + $resultZA = ldap_add($ds,"cn=ZoneAdmin,cn=roles,".$dcDN,$entryRoleZone); + + if ($resultMA){$resultsum = true;} + } + } + break; # damit dc-Zuwachs immer nur um eine neue Ebene moeglich + } + } + # Domainname zu associatedDomain der ChildAU + if ($resultsum == true){ + $entryAD['objectclass'] = "domainRelatedObject"; + $entryAD['associateddomain'] = $domsuffix_actual; + $resultAD = ldap_mod_add($ds,$childDN,$entryAD); + } + # fixme: fehlt noch anlegen der INCLUDE-Direktive in der parentdomain + if($resultAD){return 1;} + else{return 0;} + } +} + + +# Domain einer Child-AU ändern +function change_child_domain($childdomain, $oldchilddomain, $childDN, $assocdom, $domDN, $domprefix){ + + global $ds, $suffix, $domsuffix, $ldapError; + #print_r($oldchilddomain); echo "<br>"; + #print_r($domprefix); echo "<br>"; + # dcDNnew + $dcDN = "ou=DNS,".$suffix; + $dc_array = explode('.',$childdomain); + $dc_array = array_reverse($dc_array); + $dcDNnew = ""; + foreach ($dc_array as $dc){ + if (check_for_dc($dcDN,$dc)){ + $dcDN = "dc=".$dc.",".$dcDN; + } + else{ + $dcDN = "dc=".$dc.",".$dcDN; + $dcDNnew .= $dcDN; + break; + } + } + # dcDNold + $dcDNold = "ou=DNS,".$suffix; + $dcold_array = explode('.',$oldchilddomain); + $dcold_array = array_reverse($dcold_array); + foreach ($dcold_array as $dc){ + $dcDNold = "dc=".$dc.",".$dcDNold; + } + + #print_r($dcDNnew); echo "<br>"; + #print_r($dcDNold); echo "<br>"; + # Aus eigener AU Domain heraus in neue nicht AU Domain, d.h. dcDNold = domDN + # Subdomain oder neue Domain anlegen + if ($oldchilddomain == $domprefix){ + + # associatedDomain aus ChildAU entfernen + $entryAD['objectclass'] = "domainRelatedObject"; + $entryAD['associateddomain'] = $assocdom; + #print_r($entryAD); echo "<br>"; + if ($resultAD = ldap_mod_del($ds,$childDN,$entryAD)){ + + # neuen dc Knoten anlegen mit Rollen ... + if(new_child_domain($childdomain, $childDN, $assocdom, $domDN)){ + + # associatedName ChildDN aus altem dc-Knoten entfernen + $entryAN ['associatedname'] = $childDN; + #print_r($entryAN); echo "<br>"; + $result = ldap_mod_del($ds,$domDN,$entryAN); + + # Eigene Rollen aus dc-Knoten enrfernen + $roles = get_roles($childDN); + if(count($roles['MainAdmin']) != 0){ + $mainadmins = $roles['MainAdmin']; + if (count($mainadmins) > 1){ + for ($i=0; $i<count($mainadmins); $i++){ + $entryRoleMain ['member'][$i] = $mainadmins[$i]; + } + }else{ + $entryRoleMain ['member'] = $mainadmins[0]; + } + #print_r($entryRoleMain); echo "<br>"; + $resultMA = ldap_mod_del($ds,"cn=MainAdmin,cn=roles,".$dcDNold,$entryRoleMain); + } + if(count($roles['HostAdmin']) != 0){ + $hostadmins = $roles['HostAdmin']; + if (count($hostadmins) > 1){ + for ($i=0; $i<count($hostadmins); $i++){ + $entryRoleHost ['member'][$i] = $hostadmins[$i]; + } + }else{ + $entryRoleHost ['member'] = $hostadmins[0]; + } + #print_r($entryRoleHost); echo "<br>"; + $resultHA = ldap_mod_del($ds,"cn=HostAdmin,cn=roles,".$dcDNold,$entryRoleHost); + } + if(count($roles['ZoneAdmin']) != 0){ + $zoneadmins = $roles['ZoneAdmin']; + if (count($zoneadmins) > 1){ + for ($i=0; $i<count($zoneadmins); $i++){ + $entryRoleZone ['member'][$i] = $zoneadmins[$i]; + } + }else{ + $entryRoleZone ['member'] = $zoneadmins[0]; + } + #print_r($entryRoleZone); echo "<br>"; + $resultZA = ldap_mod_del($ds,"cn=ZoneAdmin,cn=roles,".$dcDNold,$entryRoleZone); + } + + + # DNS Einträge mit associatedName ChildDN verschieben + $zone_entries = get_zone_entries_assocname($domDN,array("dn","relativedomainname"),$childDN); + #echo "<br>"; print_r($zone_entries); echo "<br>"; + if (count($zone_entries) >= 1){ + foreach ($zone_entries as $ze){ + #print_r($ze['relativedomainname']); echo "<br>"; + #print_r($dcDNnew); echo "<br>"; + move_subtree($ze['dn'], "relativedomainname=".$ze['relativedomainname'].",".$dcDNnew); + $domsuffix = "uni-freiburg.de"; # neu setzen da es beim new_child_domain schon mal hochgezählt wurde + $newassocdom = $childdomain.".".$domsuffix; + $entryZE ['zonename'] = $newassocdom; + #print_r($entryZE); echo "<br>"; + $resultZE = ldap_mod_replace($ds,"relativedomainname=".$ze['relativedomainname'].",".$dcDNnew,$entryZE); + } + } + # fixme: fehlt noch anpassen der INCLUDE-Direktive in der parentdomain + return 1; + } + else{ + return 0; + } + } + else{ + return 0; + } + } + # Aus nicht AU Domain (aber eventuell Subdomain) in nicht AU Domain + # Verschieben des dc-Teilbaumes + if ($oldchilddomain != $domprefix){ + # Verschiebe dc-Baum von dcDNold nach dcDNnew + # dcDNnew + $dcDN = "ou=DNS,".$suffix; + $dc_array = explode('.',$childdomain); + $dc_array = array_reverse($dc_array); + $dcDNnew = ""; + foreach ($dc_array as $dc){ + if (check_for_dc($dcDN,$dc)){ + $dcDN = "dc=".$dc.",".$dcDN; + } + else{ + $dcDN = "dc=".$dc.",".$dcDN; + $dcDNnew .= $dcDN; + break; + } + } + + # dcDNold + $dcDNold = "ou=DNS,".$suffix; + $dcold_array = explode('.',$oldchilddomain); + $dcold_array = array_reverse($dcold_array); + foreach ($dcold_array as $dc){ + $dcDNold = "dc=".$dc.",".$dcDNold; + } + + # dc Baum verschieben + if ($dcDNnew != ""){ + if (move_subtree($dcDNold, $dcDNnew)){ + # rekursives anpassen im neue dc-Baum: + # associatedDomain, zoneName, includeFilename, includeOrigin + $newassocdom = $childdomain.".".$domsuffix; + if(dive_into_dctree_adapt($dcDNnew,$newassocdom)){ + return 1; + # fixme: fehlt noch anpassen der INCLUDE-Direktive in der parentdomain + } + else{ + return 0; + } + } + else{ + return 0; + } + }else{ + echo "Domain existiert schon, bitte anderen Domainnamen wählen!"; + return 0; + } + } +} + +function dive_into_dctree_adapt($dcDNnew,$newassocdom){ + + global $ds, $suffix, $domprefix, $domsuffix, $ldapError; + print_r($dcDNnew); echo "<br>"; + print_r($newassocdom); echo "<br><br>"; + + # associatedDomain in dc-Knoten und in allen (mehrere) associatedName-ou-Knoten + $entryAD['associateddomain'] = $newassocdom; + print_r($entryAD); echo "<br>"; + $resultAD = ldap_mod_replace($ds,$dcDNnew,$entryAD); + #$top_dcDN = str_replace("ou=DNS,","",$dcDNnew); + #print_r($top_dcDN); echo "<br>"; + $assocnames = get_dc_data($dcDNnew,array("associatedname")); # funkt nicht bei uni-freiburg.de + echo "<br>"; print_r($assocnames); echo "<br>"; + if (count($assocnames['associatedname']) > 1){ + foreach ($assocnames['associatedname'] as $aname){ + print_r($aname); echo "<br>"; + $resultAU = ldap_mod_replace($ds,$aname,$entryAD); + } + }else{ + $aname = $assocnames['associatedname']; + print_r($aname); echo "<br>"; + $resultAU = ldap_mod_replace($ds,$aname,$entryAD); + } + + # ZoneName in allen Knoten eine Ebene tiefer + $zone_entries = get_zone_entries($dcDNnew,array("dn","zonename")); + echo "<br>"; print_r($zone_entries); echo "<br>"; + foreach ($zone_entries as $ze){ + $entryZE ['zonename'] = $newassocdom; + print_r($entryZE); echo "<br>"; + $resultZE = ldap_mod_replace($ds,$ze['dn'],$entryZE); + } + + # Zonenamen in Reversezones ... Fehlt noch + + # Rekursion + # child dc für Rekursion + $dcchilds = get_dc_childs($dcDNnew,array("dn","dc")); + echo "<br>"; print_r($dcchilds); echo "<br>"; + foreach ($dcchilds as $dcc){ + $newassocdom = $dcc['dc'].".".$newassocdom; + print_r($dcc['dn']); echo " >> "; print_r($newassocdom); echo "<br>"; + dive_into_dctree_adapt($dcc['dn'],$newassocdom); + } + +} + + +function delete_child_domain($oldchilddomain,$assocdom,$childDN, $domDN, $delmodus){ + + global $ds, $suffix, $domprefix, $domsuffix, $ldapError; + #print_r($domDN); echo "<br>"; + + # dcDNold + $dcDNold = "ou=DNS,".$suffix; + $dcold_array = explode('.',$oldchilddomain); + $dcold_array = array_reverse($dcold_array); + foreach ($dcold_array as $dc){ + $dcDNold = "dc=".$dc.",".$dcDNold; + } + #print_r($dcDNold); echo "<br>"; + # dcDNnew = domDN + + if ( $delmodus == "integrate" ){ + + # associatedNames zu neuem dc-Knoten hinzufügen + $assocnames = get_dc_data($dcDNold,array("associatedname")); # funkt nicht bei uni-freiburg.de + # echo "<br>"; print_r($assocnames); echo "<br>"; + if (count($assocnames['associatedname']) > 1){ + foreach ($assocnames['associatedname'] as $aname){ + #print_r($aname); echo "<br>"; + $entryAN['associatedname'][] = $aname; + } + }else{ + $entryAN['associatedname'] = $assocnames['associatedname']; + $assocname = $assocnames['associatedname']; + $assocnames ['associatedname'] = array($assocname); + } + #print_r($entryAN); echo "<br>"; + $resultAN = ldap_mod_add($ds,$domDN,$entryAN); + if($resultAN){ + + # DNS Einträge verschieben und an neue Domain anpassen + $zone_entries = get_zone_entries($dcDNold,array("dn","relativedomainname")); + #echo "<br>"; print_r($zone_entries); echo "<br>"; + if (count($zone_entries) >= 1){ + foreach ($zone_entries as $ze){ + #print_r($ze['relativedomainname']); echo "<br>"; + #print_r($domDN); echo "<br>"; + move_subtree($ze['dn'], "relativedomainname=".$ze['relativedomainname'].",".$domDN); + $entryZE ['zonename'] = $assocdom; + print_r($entryZE); echo "<br>"; + $resultZE = ldap_mod_replace($ds,"relativedomainname=".$ze['relativedomainname'].",".$domDN,$entryZE); + } + } + + # Rollenmembers kopieren für jeden associatedName (ohne Duplikate zu generieren) + $newdom_roles = get_roles_dns($domDN); + #print_r($newdom_roles); echo "<br>"; + if (count($newdom_roles['MainAdmin']) != 0){$newmainadmins = $newdom_roles['MainAdmin'];}else{$newmainadmins = array();} + if (count($newdom_roles['HostAdmin']) != 0){$newhostadmins = $newdom_roles['HostAdmin'];}else{$newhostadmins = array();} + if (count($newdom_roles['ZoneAdmin']) != 0){$newzoneadmins = $newdom_roles['ZoneAdmin'];}else{$newzoneadmins = array();} + #print_r($newmainadmins); echo "<br>"; + #print_r($newhostadmins); echo "<br>"; + #print_r($newzoneadmins); echo "<br><br>"; + foreach ($assocnames['associatedname'] as $aname){ + #echo "_________________________________________<br>"; + #print_r($aname); echo "<br>"; + $roles = get_roles($aname); + #print_r($roles); echo "<br>"; + $mainadmins = $roles['MainAdmin']; + #print_r($mainadmins); echo "<br>"; + #print_r($newmainadmins); echo "<br>"; + $mainadmins = array_diff($mainadmins, $newmainadmins); + $mainadmins = array_merge($newmainadmins,$mainadmins); + #print_r($mainadmins); echo "<br>"; + if (count($mainadmins) > 1){ + for ($i=0; $i<count($mainadmins); $i++){ + $entryRoleMain ['member'][$i] = $mainadmins[$i]; + } + }else{ + $entryRoleMain ['member'] = $mainadmins[0]; + } + #print_r($entryRoleMain); echo "<br><br>"; + $resultMA = ldap_mod_replace($ds,"cn=MainAdmin,cn=roles,".$domDN,$entryRoleMain); + + if(count($roles['HostAdmin']) != 0){ + $hostadmins = $roles['HostAdmin']; + #print_r($hostadmins); echo "<br>"; + #print_r($newhostadmins); echo "<br>"; + $hostadmins = array_diff($hostadmins, $newhostadmins); + $hostadmins = array_merge($newhostadmins,$hostadmins); + #print_r($hostadmins); echo "<br>"; + if (count($hostadmins) > 1){ + for ($i=0; $i<count($hostadmins); $i++){ + $entryRoleHost ['member'][$i] = $hostadmins[$i]; + } + }else{ + $entryRoleHost ['member'] = $hostadmins[0]; + } + + #print_r($entryRoleHost); echo "<br><br>"; + $resultHA = ldap_mod_replace($ds,"cn=HostAdmin,cn=roles,".$domDN,$entryRoleHost); + + } + if(count($roles['ZoneAdmin']) != 0){ + $zoneadmins = $roles['ZoneAdmin']; + #print_r($zoneadmins); echo "<br>"; + #print_r($newzoneadmins); echo "<br>"; + $zoneadmins = array_diff($zoneadmins, $newzoneadmins); + $zoneadmins = array_merge($newzoneadmins,$zoneadmins); + #print_r($zoneadmins); echo "<br>"; + if (count($zoneadmins) > 1){ + for ($i=0; $i<count($zoneadmins); $i++){ + $entryRoleZone ['member'][$i] = $zoneadmins[$i]; + } + }else{ + $entryRoleZone ['member'] = $zoneadmins[0]; + } + #print_r($entryRoleZone); echo "<br><br>"; + $resultZA = ldap_mod_replace($ds,"cn=ZoneAdmin,cn=roles,".$domDN,$entryRoleZone); + + } + + # associatedDomain anpassen in allen AUs von $assocnames (alt) + $entryAD ['associateddomain'] = $assocdom; + #print_r($entryAD); echo "<br>"; + $resultAD = ldap_mod_replace($ds,$aname,$entryAD); + + #echo "_________________________________________<br>"; + } + + # Falls alter dc-Knoten noch Subdomains, d.h. dc-Teilbäume hat, diese verschieben mit + # rekursivem Anpassen aller Einträge + $dcchilds = get_dc_childs($dcDNold,array("dn","dc")); + #echo "<br><br>"; print_r($dcchilds); echo "<br>"; + if (count($dcchilds) != 0){ + foreach ($dcchilds as $dcc){ + print_r($dcc['dn']); echo " >> "; print_r("dc=".$dcc['dc'].",".$domDN); echo "<br>"; + if(move_subtree($dcc['dn'],"dc=".$dcc['dc'].",".$domDN)){ + $newdom = $dcc['dc'].".".$assocdom; + #print_r($newdom); echo "<br><br>"; + dive_into_dctree_adapt("dc=".$dcc['dc'].",".$domDN,$newdom); + } + } + } + + # alten dc-Knoten entfernen + dive_into_tree_del($dcDNold,""); + + # fixme: fehlt noch löschen der INCLUDE-Direktive in der parentdomain + + } + else{ + return 0; + } + } + + + if ( $delmodus == "complete" ){ + # if (dive_into_tree_del($dcDNold,"")){ + $delentry ['objectclass'] = "domainrelatedobject"; + $delentry ['associateddomain'] = $oldchilddomain.".".$domsuffix; + print_r($delentry); echo "<br>"; + # $delresult = ldap_mod_del($ds,$childDN,$delentry); + # if ($delresult){ + # $mesg = "Domain komplett gelöscht<br>"; + # }else{$mesg = "Fehler! ldap_mod_del<br>";} + # }else{$mesg = "Fehler! dive_into_tree_del<br>";} + } + + # return $mesg; +} + + +/* +function modify_childau_domain($childdomain, $oldchilddomain, $childDN){ + + global $ds, $suffix, $domsuffix, $ldapError; + $dcDN = "ou=DNS,".$suffix; + $dcoldDN = "ou=DNS,".$suffix; + + $dc_array = explode('.',$childdomain); + $dc_array = array_reverse($dc_array); + $dcold_array = explode('.',$oldchilddomain); + $dcold_array = array_reverse($dcold_array); + + foreach ($dcold_array as $dc){ + $dcoldDN = "dc=".$dc.",".$dcoldDN; + $aname = get_dc_data($dcoldDN,array("associatedname")); + if ($aname == $childDN){ + break; + } + } + #print_r($dcoldDN); echo "<br>"; + #print_r($domsuffix); echo "<br>"; + + $dcnewDN = ""; + foreach ($dc_array as $dc){ + if (check_for_dc($dc)){ + # echo "dc <b>".$dc."</b> schon vorhanden ... nächster dc<br>"; + $domsuffix = $dc.".".$domsuffix; + $dcDN = "dc=".$dc.",".$dcDN; + } + else{ + $dcDN = "dc=".$dc.",".$dcDN; + $domsuffix = $dc.".".$domsuffix; + $dcnewDN .= $dcDN; + break; + } + } + #print_r($dcnewDN); echo "<br>"; + #print_r($domsuffix); echo "<br>"; + + if ($dcnewDN != ""){ + if (move_subtree($dcoldDN,$dcnewDN)){ + $entryAD['associateddomain'] = $childdomain.".".$domsuffix; + $resultAD = ldap_mod_replace($ds,$childDN,$entryAD); + $resultAD2 = ldap_mod_replace($ds,$dcnewDN,$entryAD); + if ($resultAD && $resultAD2){return 1;}else{return 0;} + } + }else{ + echo "Domain existiert schon, bitte anderen Domainnamen wählen!"; + } + +} + + +function same_domain($assocdom, $dcDN, $childDN){ + + global $ds, $suffix, $domsuffix, $ldapError; + + $entryDC ["associatedname"] = $childDN; + $resultDC = ldap_mod_add($ds,$dcDN,$entryDC); + if ($resultDC){ + # HostAdmins übernehmen, welche Admins noch? MainAdmin? + $roles = get_roles($childDN); + if(count($roles['HostAdmin']) != 0){ + $hostadmins = $roles['HostAdmin']; + for ($i=0; $i<count($hostadmins); $i++){ + $entryRoleHost ['member'][$i] = $hostadmins[$i]; + } + #print_r($entryRoleHost); echo "<br>"; + $resultHA = ldap_mod_add($ds,"cn=HostAdmin,cn=roles,".$dcDN,$entryRoleHost); + } + # Domainname zu associatedDomain der ChildAU + $entryAD['objectclass'] = "domainRelatedObject"; + $entryAD['associateddomain'] = $assocdom; + $resultAD = ldap_mod_add($ds,$childDN,$entryAD); + if($resultAD){return 1;}else{return 0;} + } + else{return 0;} +} + + +function new_childau_domain($childdomain, $childDN){ + + global $ds, $suffix, $domsuffix, $ldapError; + + # entsprechenden DC Knoten anlegen, sowie Roles (MainAdmin, HostAdmin) + $dc_array = explode('.',$childdomain); + $dc_array = array_reverse($dc_array); + $dcDN = "ou=DNS,".$suffix; + # $childdomainfull = $childdomain.".".$domsuffix; + #print_r($dc_array); + foreach ($dc_array as $dc){ + $resultsum = false; + if (check_for_dc($dc)){ + echo "dc <b>".$dc."</b> schon vorhanden ... nächster dc<br>"; + $domsuffix = $dc.".".$domsuffix; + $dcDN = "dc=".$dc.",".$dcDN; + } + else{ + $dcDN = "dc=".$dc.",".$dcDN; + + $entryDC ["objectclass"][0] = "dnsdomain"; + $entryDC ["objectclass"][1] = "domainrelatedobject"; + $entryDC ["objectclass"][2] = "top"; + $entryDC ["dc"] = $dc; + $entryDC ["associatedname"] = $childDN; + $entryDC ["associateddomain"] = $dc.".".$domsuffix; + #print_r($entryDC); echo "<br>"; + #print_r($dcDN); echo "<br><br>"; + $resultDC = ldap_add($ds,$dcDN,$entryDC); + if ($resultDC){ + $domsuffix = $dc.".".$domsuffix; + + #print_r($dcDN); echo"<br><br>"; + + $entryRolesCont ['objectclass'] = "AUContainer"; + $entryRolesCont ['cn'] = "roles"; + #print_r($entryRolesCont); echo "<br><br>"; + $resultRC = ldap_add($ds,"cn=roles,".$dcDN,$entryRolesCont); + if ($resultRC){ + $roles = get_roles($childDN); + print_r($roles); echo "<br><br>"; + $mainadmins = $roles['MainAdmin']; + $entryRoleMain ['objectclass'] = "groupOfNames"; + $entryRoleMain ['cn'] = "MainAdmin"; + for ($i=0; $i<count($mainadmins); $i++){ + $entryRoleMain ['member'][$i] = $mainadmins[$i]; + } + #print_r($entryRoleMain); echo "<br>"; + $resultMA = ldap_add($ds,"cn=MainAdmin,cn=roles,".$dcDN,$entryRoleMain); + + if(count($roles['HostAdmin']) != 0){ + $hostadmins = $roles['HostAdmin']; + $entryRoleHost ['objectclass'] = "groupOfNames"; + $entryRoleHost ['cn'] = "HostAdmin"; + for ($i=0; $i<count($hostadmins); $i++){ + $entryRoleHost ['member'][$i] = $hostadmins[$i]; + } + #print_r($entryRoleHost); echo "<br>"; + $resultHA = ldap_add($ds,"cn=HostAdmin,cn=roles,".$dcDN,$entryRoleHost); + } + if ($resultMA){$resultsum = true;} + } + } + break; # damit dc-Zuwachs immer nur um eine neue Ebene moeglich + } + } + # Domainname zu associatedDomain der ChildAU + if ($resultsum == true){ + $entryAD['objectclass'] = "domainRelatedObject"; + $entryAD['associateddomain'] = $domsuffix; + $resultAD = ldap_mod_add($ds,$childDN,$entryAD); + } + if($resultAD){return 1;} + else{return 0;} + +} + + + +function delete_childau_domain($oldchilddomain,$childDN,$delmodus){ + + global $ds, $suffix, $domsuffix, $ldapError; + + $dcold_array = explode('.',$oldchilddomain); + $dcold_array = array_reverse($dcold_array); + $dcDN = "ou=DNS,".$suffix; + + foreach ($dcold_array as $dc){ + $dcDN = "dc=".$dc.",".$dcDN; + $aname = get_dc_data($dcDN,array("associatedname")); + $domsuffix = $dc.".".$domsuffix; + + if ($aname == $childDN){ + break; + } + } + #print_r($dcDN); echo "<br>"; + #print_r($domsuffix); echo "<br>"; + + if ( $delmodus == "complete" ){ + if (dive_into_tree_del($dcDN,"")){ + $delentry ['objectclass'] = "domainrelatedobject"; + $delentry ['associateddomain'] = $domsuffix; + #print_r($delentry); echo "<br>"; + $delresult = ldap_mod_del($ds,$childDN,$delentry); + if ($delresult){ + $mesg = "Domain komplett gelöscht<br>"; + }else{$mesg = "Fehler! ldap_mod_del<br>";} + }else{$mesg = "Fehler! dive_into_tree_del<br>";} + } + + if ( $delmodus == "integrate"){ + $mesg = "DNS Integration, noch nicht fertiggestellt"; + } + + return $mesg; +} +*/ + + + + +############################################################################### +# Funktionen für das Rollen Management +# + + +function new_role_member($userDN,$role,$auDN,$domDN){ + + global $ds, $suffix, $ldapError; + + $entry['member'] = $userDN; + + if ($domDN != ""){ + switch ($role){ + case 'MainAdmin': + $roleDN1 = "cn=".$role.",cn=roles,".$auDN; + $roleDN2 = "cn=".$role.",cn=roles,".$domDN; + $results1 = ldap_mod_add($ds,$roleDN1,$entry); + $results2 = ldap_mod_add($ds,$roleDN2,$entry); + if ($results1 && $results2){ + return 1; + }else{ + return 0; + } + break; + case 'HostAdmin': + $roleDN1 = "cn=".$role.",cn=roles,".$auDN; + $roleDN2 = "cn=".$role.",cn=roles,".$domDN; + $results1 = ldap_mod_add($ds,$roleDN1,$entry); + $results2 = ldap_mod_add($ds,$roleDN2,$entry); + if ($results1 && $results2){ + return 1; + }else{ + return 0; + } + break; + case 'DhcpAdmin': + $roleDN = "cn=".$role.",cn=roles,".$auDN; + $results = ldap_mod_add($ds,$roleDN,$entry); + if ($results){ + return 1; + }else{ + return 0; + } + break; + case 'ZoneAdmin': + $roleDN1 = "cn=".$role.",cn=roles,".$auDN; + $roleDN2 = "cn=".$role.",cn=roles,".$domDN; + $results1 = ldap_mod_add($ds,$roleDN1,$entry); + $results2 = ldap_mod_add($ds,$roleDN2,$entry); + if ($results1 && $results2){ + return 1; + }else{ + return 0; + } + break; + } + }else{ + switch ($role){ + case 'MainAdmin': + $roleDN = "cn=".$role.",cn=roles,".$auDN; + $results = ldap_mod_add($ds,$roleDN,$entry); + if ($results){ + return 1; + }else{ + return 0; + } + break; + case 'HostAdmin': + $roleDN = "cn=".$role.",cn=roles,".$auDN; + $results = ldap_mod_add($ds,$roleDN,$entry); + if ($results){ + return 1; + }else{ + return 0; + } + break; + case 'DhcpAdmin': + $roleDN = "cn=".$role.",cn=roles,".$auDN; + $results = ldap_mod_add($ds,$roleDN,$entry); + if ($results){ + return 1; + }else{ + return 0; + } + break; + case 'ZoneAdmin': + $roleDN = "cn=".$role.",cn=roles,".$auDN; + $results = ldap_mod_add($ds,$roleDN,$entry); + if ($results){ + return 1; + }else{ + return 0; + } + break; + } + } +} + + +function delete_role_member($userDN,$role,$auDN,$domDN){ + + global $ds, $suffix, $ldapError; + + $entry['member'] = $userDN; + + if ($domDN != ""){ + switch ($role){ + case 'MainAdmin': + $roleDN1 = "cn=".$role.",cn=roles,".$auDN; + $roleDN2 = "cn=".$role.",cn=roles,".$domDN; + $results1 = ldap_mod_del($ds,$roleDN1,$entry); + $results2 = ldap_mod_del($ds,$roleDN2,$entry); + if ($results1 && $results2){ + return 1; + }else{ + return 0; + } + break; + case 'HostAdmin': + $roleDN1 = "cn=".$role.",cn=roles,".$auDN; + $roleDN2 = "cn=".$role.",cn=roles,".$domDN; + $results1 = ldap_mod_del($ds,$roleDN1,$entry); + $results2 = ldap_mod_del($ds,$roleDN2,$entry); + if ($results1 && $results2){ + return 1; + }else{ + return 0; + } + break; + case 'DhcpAdmin': + $roleDN = "cn=".$role.",cn=roles,".$auDN; + $results = ldap_mod_del($ds,$roleDN,$entry); + if ($results){ + return 1; + }else{ + return 0; + } + break; + case 'ZoneAdmin': + $roleDN1 = "cn=".$role.",cn=roles,".$auDN; + $roleDN2 = "cn=".$role.",cn=roles,".$domDN; + $results1 = ldap_mod_del($ds,$roleDN1,$entry); + $results2 = ldap_mod_del($ds,$roleDN2,$entry); + if ($results1 && $results2){ + return 1; + }else{ + return 0; + } + break; + } + }else{ + switch ($role){ + case 'MainAdmin': + $roleDN = "cn=".$role.",cn=roles,".$auDN; + $results = ldap_mod_del($ds,$roleDN,$entry); + if ($results){ + return 1; + }else{ + return 0; + } + break; + case 'HostAdmin': + $roleDN = "cn=".$role.",cn=roles,".$auDN; + $results = ldap_mod_del($ds,$roleDN,$entry); + if ($results){ + return 1; + }else{ + return 0; + } + break; + case 'DhcpAdmin': + $roleDN = "cn=".$role.",cn=roles,".$auDN; + $results = ldap_mod_del($ds,$roleDN,$entry); + if ($results){ + return 1; + }else{ + return 0; + } + break; + case 'ZoneAdmin': + $roleDN = "cn=".$role.",cn=roles,".$auDN; + $results = ldap_mod_del($ds,$roleDN,$entry); + if ($results){ + return 1; + }else{ + return 0; + } + break; + } + } +} + + +function get_role_members($roleDN) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $roleDN, "objectclass=*", array("member"), "", "one", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "search problem"; + die; + } else { + $members_array = array(); + $result = ldapArraySauber($result); + foreach ($result as $item){ + if (count($item['member']) > 1){ + $members_array = $item['member']; + } + else{ + $members_array[] = $item['member']; + } + } + } + return $members_array; +} + + +?>
\ No newline at end of file diff --git a/ldap-site-mngmt/webinterface/lib/commonlib.inc.php b/ldap-site-mngmt/webinterface/lib/commonlib.inc.php new file mode 100644 index 00000000..32df2a1c --- /dev/null +++ b/ldap-site-mngmt/webinterface/lib/commonlib.inc.php @@ -0,0 +1,552 @@ +<?php + + +/** +* attributesToString($entry, $name, $delemiter = "", $pattern = "", $empty = " ") - +* Gibt die Attribute eines LDAP-Eintrages formatiert aus +* +* Gibt die Attribute des Schlüssels $name des LDAP-Eintraes $entry aus. Mehrere Werte werden mit $delemiter +* voneinander getrennt. Für jeden Wert des Attributes wird in $pattern an die Stelle "$name" (Dallarzeichen plus die Bezeichnung) +* das aktuelle Attribut eingefügt - ähnlich (aber nicht gleich!) der String-Interpretation von PHP. Falls $pattern = "" wird +* einfach der Wert zurück gegeben. Falls für den Schlüssel keine Attribut-Werte definiert sind, wird $empty zurück gegeben +* +* @param array entry LDAP-Array +* @param string name Hashbezeichnung +* @param string delimiter Trennzeichen +* @param string pattern Muster +* @param string empty Zeichen für leere Felder +* +* @return string Array-Werte als String +* +* @author Timothy Burk, lt. Musterlösung +* +*/ + + function attributesToString($entry, $name, $delimiter = "", $pattern = "", $empty = "") { + $buffer = ""; + $name=strtolower($name); + if (isset($entry[$name])) { + $count = $entry[$name]['count']; + for ($i = 0; $i < $count; $i++) { + if ($pattern) { + $tmp = $pattern; + $buffer .= str_replace('$' . $name, $entry[$name][$i], $tmp); + } else { + $buffer .= $entry[$name][$i]; + } + if ($delimiter && ($i + 1) < $count) { + $buffer .= $delimiter; + } + } + } + + if ("" == $buffer && $empty) { + $buffer = $empty; + } + return $buffer; + } + +/* + * oneAttribute($entry, $name, $empty = "", $i = 0) { + * liefert den ($i-ten) Wert des Attributes $name aus $entry + * Eingabe ist entweder ein Datensatz aus dem ldapsearch-Ergebnis, oder + * ein um die Meta-Infos (count) bereinigtes Ergebnis + * sorry für die mangelhafte Doku - Thomas + */ + + function oneAttribute($entry, $name, $empty = "", $i = 0) { + $buffer = ""; + if (isset($entry[$name][$i])) { + $buffer = $entry[$name]; + } else if (isset($entry[$name])) { + $buffer = $entry[$name]; + } + + if ("" == $buffer && $empty) { + $buffer = $empty; + } + return $buffer; + } + + + /** + * redirect($seconds, $url, $msg = "", $addSessionId = TRUE) - leitet den Benutzer auf eine andere Seite weiter + * + * Leitet den Benuzter nach $seconds Sekunden auf die Seite $url weiter. Während der Wartezeit bekommt der Benutzer + * die Information $msg mitgeteilt (Achtung: keine automatische Formatierung der $msg). Wenn $addSessionId TRUE ist, + * dann wird an den URL die SessionId angehängt. + * + * @author Timothy Burk, lt. Musterlösung + */ + + function redirect($seconds, $url, $msg = "", $addSessionId = TRUE) { + if ($addSessionId) { + if (strpos($url, "?") === FALSE) { + $url .= "?"; + } else { + $url .= "&"; + } + $url .= SID; + } + + echo "<html>\n" . + " <head>\n" . + ' <meta http-equiv="refresh" content="' . $seconds . "; URL=$url" . '">' . "\n" . + " </head>\n"; + if ($msg) { + echo " <body>\n" . + $msg . + " </body>\n"; + } + echo "</html>\n"; + } + + + +/** +* getRights($ds, $userDn) - ermittelt die Rechte eines Users. +* +* Die Funktion erwartet ein Directory-Handle und den vollständigen Distiguished Name des +* Users. Rückgabewert ist ein numerisches eindimensionales Array, welches die Rechte enthält. +* +* @param resource ds LDAP Directory Handle +* @param string userDn Distinguishedname des Users +* +* @return array rechte +* +* @author Timothy Burk +*/ + +function getRoles($ds, $userDN) { + global $ldapError, $suffix, $uid; + + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, "(&(member=$userDN)(cn=*))", array("dn","cn"), "dn", "sub", 0, 0))) { + redirect(5, "index.php", $ldapError, FALSE); + die; + } + $result = ldapArraySauber($result); + $clean = array(); + + foreach($result as $item) { + $dn = ldap_explode_dn($item['dn'], 0); + $dnsub = array_slice($dn,3); + $auDN = implode(',',$dnsub); + $element['au'] = $auDN; + $element['role'] = $item['cn']; + $clean[] = $element; + } + + $res = array(); + foreach($clean as $item){ + $au = $item['au']; + $role = $item['role']; + if(array_key_exists($au,$res)){ + $res[$au][] = $role; + } + else{ + $res[$au] = array($role); + } + } + $i=0; + foreach (array_keys($res) as $key){ + $au_roles[$i]['au'] = $key; + $au_roles[$i]['role'] = $res[$key]; + $i++; + } + return $au_roles; +} + + +/** +* createMenu($rechte) - erstellt die Menuleiste abhängig von der Rechten des Users. +* +* Die Navigationsleiste wird dynamisch erzeugt und von dieser Funktion direkt in das +* entsprechende Template geparst. Dabei werden nur die Schaltflächen zur Verfügung +* gestellt, die der User mit seinen Rechten anzeigen darf. +* +* @param array rechte Eindimensionales Array mit den Rechten des Users +* @param int mainnr Nummer des aktiven Hauptmenus +* +* @author Timothy Burk +*/ + +function createMainMenu($rollen , $mainnr) { + global $template; + global $START_PATH; + + # pre-checks + if ( check_if_max_networks() ){ + $dhcplink = "dhcp/dhcp.php"; + }else{ + $dhcplink = "dhcp/no_dhcp.php"; + } + + # Struktur der Registerkartenleiste + $mainmenu = array(array("link" => "au/au.php", + "text" => "AU Home", + "zugriff" => "alle"), + array("link" => "roles/roles.php", + "text" => "Admin Rollen", + "zugriff" => array("MainAdmin")), + array("link" => "ip/ip.php", + "text" => "IP Management", + "zugriff" => array("MainAdmin","HostAdmin","DhcpAdmin")), + array("link" => "computers/computers.php", + "text" => "Rechner", + "zugriff" => array("MainAdmin","HostAdmin","DhcpAdmin")), + array("link" => "rbs/rbs.php", + "text" => "RemoteBoot/PXE", + "zugriff" => array("MainAdmin","HostAdmin")), + array("link" => $dhcplink, + "text" => "DHCP", + "zugriff" => array("MainAdmin","DhcpAdmin")), + array("link" => "dns/dns.php", + "text" => "DNS", + "zugriff" => array("MainAdmin","ZoneAdmin","HostAdmin"))); + + + # Zusammenstellen der Menuleiste + $template->define_dynamic("Mainmenu", "Mmenu"); + $i=0; + foreach($mainmenu as $item) { + if($item['zugriff'] === "alle" || vergleicheArrays($rollen , $item['zugriff'])) { + if ($i==0) { + if ($mainnr==0) { + $zwisch=""; + $lastaktive=true; + $farb="#505050"; + } + else { + $zwisch=""; + $farb="#A0A0A0"; + $lastaktive=false; + } + } + else { + if ($mainnr==$i) { + $zwisch=""; + $lastaktive=true; + $farb="#505050"; + } + else { + $farb="#A0A0A0"; + if ($lastaktive) {$zwisch="";} + else {$zwisch="";} + $lastaktive=false; + } + } + $template->assign(array("MZWISCHEN" => $zwisch, + "MFARBE" => $farb, + "MLINK_M" => $START_PATH.$item["link"], + "MTEXT_M" => $item["text"])); + $template->parse("MAINMENU_LIST", ".Mainmenu"); + } + $i=$i+1; + } + if ($lastaktive) {$template->assign(array("MENDE" => ""));} + else { + $template->assign(array("MENDE" => "")); + } + +} + + + +/** +* vergleicheArrays($a, $b) - Ermitteln der Schnittmenge zweier Arrays +* +* @param array a +* @param array b +* +* @return boolean TRUE, wenn die Schnittmenge von a und b nicht leer ist, sonst FALSE +* +* @author Timothy Burk +*/ + +function vergleicheArrays($a, $b) { + if((sizeof(array_unique($a)) + sizeof($b)) > sizeof(array_unique(array_merge($a, $b)))) { + return TRUE; + } else { + return FALSE; + } +} + + +/** +* inputArraySauber($Array) +* +* Löscht aus einem Array, welches POST-Daten enthält leere Felder. Nötig für die Formatierung +* vor dem Anlegen neuer Objekte. +* +* @param array _POST-Array +* +* @return array Bereinigtes Array. +* +* @author Timothy Burk +*/ +function inputArraySauber($Array) { + $b = array(); + foreach($Array as $key => $a) { + if(!is_array($a)) { + trim($a); + } + if (!$a == "") { + if(is_array($a)) { + $b[$key] = $a; + } else { + $b[$key] = htmlentities($a); + } + } + } + return $b; +} + + +/** +* numArraySauber($Array) +* +* Löscht aus einemn numerischen Array leere Felder. +* +* @param array Numerisches Array +* +* @return array Bereinigtes Array. +* +* @author Timothy Burk +*/ +function numArraySauber($Array) { + $b = array(); + $arr = array(); + if(!(is_array($Array))) { + $arr[] = $Array; + } else { + $arr = $Array; + } + foreach($arr as $key => $a) { + if (!$a == "") { + $b[] = $a; + } + } + return $b; +} + +/** +* ldapArraySauber($Array, [$delEmpty]) +* +* Bereinigt ein dreidimensionales Array, so wie es aus der Funktion uniLdapSearch kommt. +* Dabei werden alle count-Felder sowie alle numerischen Felder in denen der Schlüssel +* gespeichert ist entfernt. Attributarrays mit nur einem Element werden gelöscht, das Element +* wir als Skalar gespeichert. +* Wenn $delEmpty = TRUE ist, werden nur nichtleere Felder gespeichert. +* +* @param array $Array uniLdapSearch()-Ausgabe +* @param boolean $delEmpty (Standard: $delEmpty = FALSE) +* +* @return array Bereinigtes Array. +* +* @author Timothy Burk +*/ +function ldapArraySauber($Array, $delEmpty = FALSE) { + $b = array(); + foreach($Array as $key => $item) { + if(is_array($item)) { + foreach($item as $key_attr => $attr) { + if(!is_int($key_attr)) { + if(is_array($attr)) { + if($attr['count'] == 1) { + $attr[0] = str_replace(chr(160),"",trim($attr[0])); + if(($delEmpty && $attr[0] != "") || !($delEmpty)) { + $b[$key][$key_attr] = $attr[0]; + } + } else { + for($i=0; $i < $attr['count']; $i++) { + $attr[$i] = str_replace(chr(160),"",trim($attr[$i])); + if(($delEmpty && $attr[$i] != "") || !($delEmpty)) { + $b[$key][$key_attr][$i] = $attr[$i]; + } + } + } + } else { + $attr = str_replace(chr(160),"",trim($attr)); + if(($delEmpty && $attr != "") || !($delEmpty)) { + $b[$key][$key_attr] = $attr; + } + } + } + } + } else { + if(is_int($key)) { + $item = str_replace(chr(160),"",trim($item)); + if(($delEmpty && $item != "") || !($delEmpty)) { + $b[$key] = $item; + } + } + } + } + return $b; +} + +/** +* personOptionen($rechte) +* +* Enthält die möglichen Optionen, die auf einen User angewandt werden können als +* zweidimensionales Array mit folgenden Attributen: +* [ziel]: Aufzurufendes PHP-Skript +* [text]: Beschriftung der Schaltfläche +* [desc]: Beschreibung der Funktion +* [rechte][]: Array mit den erforderlichen Rechten für die jeweilige Option. array("alle") steht für "ohne Einschränkung". +* +* Dieses in dieser Funktion gespeicherte Array wird abhängig von den übergebenen +* Rechten um nicht erlaubte Optionen reduziert und dann ausgegeben. +* +* @param array $rechte Eindimensionales Array $_SESSION['rechte'] +* +* @return array Zweidimensionales Array mit den erlaubten Optionen. +* +* @author Timothy Burk +*/ +function personOptionen($rechte) { + global $utc_uid, $utc_cn, $START_PATH; + $optionen = array(); + $optionen[] = array("ziel" => $START_PATH."person/datensatz.php?aktion=edit", + "text" => "Userdaten bearbeiten", + "desc" => "Anzeigen und Ändern der persönlichen Daten des Users.", + "rechte" => array("writeMitarbeiter"), + "hidden" => array("aktion" => "edit")); + $optionen[] = array("ziel" => $START_PATH."person/datensatz.php", + "text" => "Datensatz löschen", + "desc" => "Der User wird vollständig mit allen Daten aus der Datenbank gelöscht.", + "rechte" => array("writeMitarbeiter"), + "hidden" => array("aktion" => "delete")); + $optionen[] = array("ziel" => $START_PATH."person/datensatz.php", + "text" => "User (de)aktivieren", + "desc" => "Diese Funktion legt einen User durch die Deaktivierung im Archiv ab. Von dort kann der Datensatz weiterhin eingesehen und ggf. reaktiviert werden.", + "rechte" => array("writeMitarbeiter"), + "hidden" => array("aktion" => "archiv")); + $optionen[] = array("ziel" => $START_PATH."person/vertrag_show.php", + "text" => "Verträge bearbeiten", + "desc" => "Bearbeiten oder Anlegen eines Vertrages. Sie können dabei zwischen verschiedenen Vertragsarten wählen.", + "rechte" => array("writeVertrag", "readVertrag")); + $optionen[] = array("ziel" => $START_PATH."urlaub/krank_angabe.php", + "text" => "Krankheitstage", + "desc" => "Krankheitsdaten bearbeiten.", + "rechte" => array("writeKrankheitUrlaub"), + "hidden" => array("uidToChange" => $utc_uid, "GName" => $utc_cn)); + $optionen[] = array("ziel" => $START_PATH."urlaub/liste.php", + "text" => "Urlaubstage anzeigen", + "desc" => "Urlaubstage des Users in grafischer Übersicht anzeigen.", + "rechte" => array("readKrankheitUrlaub"), + "hidden" => array("wer" => $utc_uid, "wann" => "g", "sub" => $utc_cn)); + $optionen[] = array("ziel" => $START_PATH."person/rechte_show.php", + "text" => "Rechte vergeben", + "desc" => "Diese Option dient dazu, dem User bestimmte Rechte zuzuweisen, beispielsweise das Recht Urlaub zu beantragen, Vertragsdaten andere User zu bearbeiten oder einzusehen usw..", + "rechte" => array("writeRechte")); + $optionen[] = array("ziel" => $START_PATH."person/suchen.php", + "text" => "Abbrechen", + "desc" => " ", + "rechte" => array("alle")); + + $opt_reduced = array(); + foreach($optionen as $option) { + if(in_array("alle",$option['rechte']) || vergleicheArrays($option['rechte'],$rechte)) { + array_push($opt_reduced, $option); + } + } + return $opt_reduced; +} + + +/** +* makeArrFromAttribute($a, $attribute) +* +* Ein zweidimensionales Array wird nach der ersten Dimension durchlaufen. +* Dabei werden die Werte des angegebenen Attributes $attribute für alle +* Einträge extrahiert und in einem neuen Array gespeichert, welches +* anschließend zurückgegeben wird. +* +* @param array $a Zweidimensionales Array +* @param string $attribute Schlüsselname der zweiten Dimension +* +* @return array Eindimensionales numerisches Array mit den Attributwerten. +* +* @author Timothy Burk +*/ +function makeArrFromAttribute($a, $attribute) { + $c = array(); + foreach($a as $b) { + $c[] = $b[$attribute]; + } + return $c; +} +?> + +<?php + + +/** +* sortArrayByKey sortiert die 1.Dimension von bis zu 5-dimensionalen Arrays +* nach den Werten in einem beliebigen Schlüssel in beliebiger Dimension +* +* PS: die Funktion sortArrayByKey ist nur sinnvoll, wenn sich die Array-Einträge +* der 1.Dim sehr ähnlich sind, sprich bei Suchergebnissen!! +* +* @param array $array : das zu sortierende Array +* @param string $sortKey : der Schlüssel, nach dem sortiert werden soll +* Bsp.: +* es soll nach $array[$i][$j][$k]['sortkey'] sortiert werden +* => $sortKey = "$j#$k#sortkey" +* @param string $sortDirection : die Sortierrichtung, gültige Werte sind "up", "down" +* +* +* @author Daniel Höfler +*/ +function sortArrayByKey($array, $sortKey, $sortDirection = "up") { + $sortKeyArray = explode("#", $sortKey); + $count = count($sortKeyArray); + if($count < 5) { + switch($count) { + case 0: + foreach($array as $key => $item) { + $toSortKeys[$key] = $item; + } + break; + case 1: + foreach($array as $key => $item) { + $toSortKeys[$key] = $item[$sortKeyArray[0]]; + } + break; + case 2: + foreach($array as $key => $item) { + $toSortKeys[$key] = $item[$sortKeyArray[0]][$sortKeyArray[1]]; + } + break; + case 3: + foreach($array as $key => $item) { + $toSortKeys[$key] = $item[$sortKeyArray[0]][$sortKeyArray[1]][$sortKeyArray[2]]; + } + break; + case 4: + foreach($array as $key => $item) { + $toSortKeys[$key] = $item[$sortKeyArray[0]][$sortKeyArray[1]][$sortKeyArray[2]][$sortKeyArray[3]]; + } + break; + } + } else { + echo "zu viele Dimensionen!! Höchstens 4 Dimensionen möglich"; + return false; + } + if($sortDirection == "up") { + asort($toSortKeys); + } elseif($sortDirection == "down") { + arsort($toSortKeys); + } else { + echo "Keine gültige Sortierrichtung!! Wählen sie \"up\" oder \"down\"\n"; + return false; + } + $sortArray = array(); + foreach($toSortKeys as $key => $item) { + $sortArray[$key] = $array[$key]; + } + return($sortArray); +} + +?>
\ No newline at end of file diff --git a/ldap-site-mngmt/webinterface/lib/config.inc.php b/ldap-site-mngmt/webinterface/lib/config.inc.php new file mode 100644 index 00000000..50d7e465 --- /dev/null +++ b/ldap-site-mngmt/webinterface/lib/config.inc.php @@ -0,0 +1,27 @@ +<?php + + #Pfad festlegen wo die Anwendungsskripte sich befinden + #$START_PATH="http://132.230.4.150/test/"; + #$START_PATH="https://132.230.9.56/lsm/"; + $START_PATH="https://dhcp.uni-freiburg.de/lsm/"; + + # Anlegen einer Variablen für den Speicherort von den CSVs + # $TMPPATH_CSV="/home/gruppe1/public_html/htdocs/"; + + // einige LDAP-Angaben: + // der Anwendungs-LDAP + define('LDAP_HOST', '132.230.9.56'); + define('LDAP_PORT', 389); + $suffix = "dc=uni-freiburg,dc=de"; + $domsuffix = "uni-freiburg.de"; + // der LDAP-Server für die Authentisierung der User + #define('LDAP_HOST_RZ', '132.230.1.61'); + #define('LDAP_PORT_RZ', 636); + #$suffix_rz = "dc=uni-freiburg,dc=de"; + + // einige Sachen, die aus Sicherheitsgründen in produktiven Umgebungen geändert werden sollten!!! + #$dummyUid = "rz-ldap"; // Dummy-User für einige Aktionen - muss angelegt werden!!! + #$dummyPassword = "dummy"; + + #$standardPassword = "dipman02"; // das Passwort mit dem alle User im Anwendungsldap angelegt werden!!! +?> diff --git a/ldap-site-mngmt/webinterface/lib/dhcp_management_functions.php b/ldap-site-mngmt/webinterface/lib/dhcp_management_functions.php new file mode 100644 index 00000000..4194a1b3 --- /dev/null +++ b/ldap-site-mngmt/webinterface/lib/dhcp_management_functions.php @@ -0,0 +1,625 @@ +<?php + +/** +* dhcp_management_functions.php - DHCP Management Funktions-Bibliothek +* Diese Bibliothek enthält alle Funktionen für die Verwaltung des DHCP Dienstes +* +* @param string ldapError +* @param resource ds +* +* @author Tarik Gasmi +* @copyright Tarik Gasmi +*/ + +# Konfiguration laden +require_once("config.inc.php"); + +$ldapError = null; + +################################################################################################### + +# freie x.x.x.0/24 Netzwerke einer AU holen +function get_networks(){ + + global $ds, $suffix, $auDN, $ldapError; + + $networks = array(); + $fipb_array = get_freeipblocks_au($auDN); + foreach ( $fipb_array as $fipb ){ + $exp = explode('_',$fipb); + $fs = explode('.',$exp[0]); + $fe = explode('.',$exp[1]); + #print_r($fs); echo "<br>"; + #print_r($fe); echo "<br>"; + + if ($fs[3] == 0){$networks [] = $exp[0];} + $fs[2] = $fs[2] + 1; + $fs[3] = 0; + + while ( $fs[2] <= $fe[2] ){ + $iprange = implode('_',array(implode('.',$fs),implode('.',$fs))); + if (check_ip_in_iprange($iprange,$fipb)){ + $networks [] = implode('.',$fs); + if ($fs[2] == 255){ $fs[1] = $fs[1] + 1; $fs[2] = 0; } + else{ $fs[2] = $fs[2] + 1; } + } + } + } + #print_r($networks); echo "<br>"; + return $networks; +} + +# Check ob AU über noch freie x.x.x.0/24 Netzwerke verfügt (freie IP Blöcke) +function check_if_free_networks(){ + + global $ds, $suffix, $auDN, $ldapError; + + $networks = 0; + $fipb_array = get_freeipblocks_au($auDN); + if ( $fipb_array[0] != "" ){ + foreach ( $fipb_array as $fipb ){ + $exp = explode('_',$fipb); + $fs = explode('.',$exp[0]); + $fe = explode('.',$exp[1]); + + if ($fs[3] == 0){return 1; break;} + else{ + $fs[2] = $fs[2] + 1; + $fs[3] = 0; + + while ( $fs[2] <= $fe[2] ){ + $iprange = implode('_',array(implode('.',$fs),implode('.',$fs))); + if (check_ip_in_iprange($iprange,$fipb)){ + return 1; break 2; + } + if ($fs[2] == 255){ $fs[1] = $fs[1] + 1; $fs[2] = 0; } + else{ $fs[2] = $fs[2] + 1; } + } + } + } + } + return $networks; +} + +# Check ob AU über x.x.x.0/24 Netzwerke insgesamt verfügt (maximale IP Blöcke) +function check_if_max_networks(){ + + global $ds, $suffix, $auDN, $ldapError; + + $networks = 0; + $mipb_array = get_maxipblocks_au($auDN); + if ( $mipb_array[0] != "" ){ + foreach ( $mipb_array as $mipb ){ + $exp = explode('_',$mipb); + $fs = explode('.',$exp[0]); + $fe = explode('.',$exp[1]); + + if ($fs[3] == 0){return 1; break;} + else{ + $fs[2] = $fs[2] + 1; + $fs[3] = 0; + + while ( $fs[2] <= $fe[2] ){ + $iprange = implode('_',array(implode('.',$fs),implode('.',$fs))); + if (check_ip_in_iprange($iprange,$mipb)){ + return 1; break 2; + } + if ($fs[2] == 255){ $fs[1] = $fs[1] + 1; $fs[2] = 0; } + else{ $fs[2] = $fs[2] + 1; } + } + } + } + } + return $networks; +} + +################################################################################################### + +function get_dhcpoffers($auDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $attribs = array("dn","dhcpofferdn"); + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, "(objectclass=dhcpService)", $attribs, "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else{ + $result = ldapArraySauber($result); + #print_r($result);echo "<br><br>"; + + $dhcp_offers = array(); + foreach ($result as $dhcp){ + if ( strpos($auDN, $dhcp['dhcpofferdn']) !== false ) # && $dhcp['dn'] != $dhcpserviceDN + $dhcp_offers [] = $dhcp['dn']; + } + } + #print_r($dhcp_offers);echo "<br><br>"; + return $dhcp_offers; +} + +function alternative_dhcpservices($dhcpserviceDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $alt_dhcp = array(); + + $dhcparray = get_dhcpoffers($auDN); + # print_r($dhcparray); echo "<br>"; + if (count($dhcparray) != 0){ + for ($i=0; $i < count($dhcparray); $i++){ + if ($dhcparray[$i] != $dhcpserviceDN){ + $exp = ldap_explode_dn ( $dhcparray[$i], 1 ); + $alt = array ("dn" => $dhcparray[$i], "cn" => $exp[0], "au" => " / ".$exp[2]); + $alt_dhcp[] = $alt; + } + } + } + + return $alt_dhcp; +} + +function alternative_dhcpsubnets($dhcpsubnetDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $alt_subnet = array(); + $dhcpservices = get_dhcpoffers($auDN); + #print_r($dhcpservices); echo "<br>"; + if (count($dhcpservices) != 0){ + foreach ($dhcpservices as $servDN){ + $attribs = array("dn","cn","dhcphlpcont"); + #$servDN = $item['dn']; + #print_r($servDN); echo "<br>"; + $filter = "(&(objectclass=dhcpSubnet)(dhcphlpcont=$servDN))"; + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, $filter, $attribs, "cn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + }else{ + $result = ldapArraySauber($result); + #print_r($result); echo "<br>"; + foreach ($result as $subnet){ + if ( check_subnet_mipb($subnet['cn']) && $subnet['dn'] != $dhcpsubnetDN){ + $exp = ldap_explode_dn ( $subnet['dn'], 1 ); + $alt = array ("dn" => $subnet['dn'], "cn" => $exp[0], "au" => " / ".$exp[2]); + $alt_subnet[] = $alt; + } + } + } + + } + } + + return $alt_subnet; +} + +function check_subnet_mipb($subnet){ + + global $ds, $suffix, $auDN, $ldapError; + + $subexp = explode('.',$subnet); + $ret = 0; + $mipb_array = get_maxipblocks_au($auDN); + if ( $mipb_array[0] != "" ){ + foreach ( $mipb_array as $mipb ){ + $exp = explode('_',$mipb); + $ms = explode('.',$exp[0]); + $me = explode('.',$exp[1]); + if ( $subexp[2] >= $ms[2] && $subexp[2] <= $me[2] ){ + $ret = 1; + break; + } + } + } + if ($ret){return 1;} + else{return 0;} + +} + +############################################################################### +# Funktionen zur Verwaltung von DHCP Service Objekten +# + +function add_dhcpservice ($dhcpserviceName,$dhcpoffer,$atts){ + + global $ds, $suffix, $auDN, $ldapError; + + #$dnarray = ldap_explode_dn ( $dhcpserviceDN, 1 ); + $dhcpserviceDN = "cn=".$dhcpserviceName.",cn=dhcp,".$auDN; + + $entrydhcp ['objectclass'][0] = "dhcpService"; + $entrydhcp ['objectclass'][1] = "dhcpOptions"; + $entrydhcp ['objectclass'][2] = "top"; + $entrydhcp ['cn'] = $dhcpserviceName; + $entrydhcp ['dhcpofferdn'] = $dhcpoffer; + + # weitere Attribute + foreach (array_keys($atts) as $key){ + if ($atts[$key] != ""){ + $entrydhcp[$key] = $atts[$key]; + } + } + print_r($entrydhcp); echo "<br>"; + print_r($dhcpserviceDN); echo "<br>"; + + if ($result = ldap_add($ds, $dhcpserviceDN, $entrydhcp)){ + return 1; + } + else{ + $mesg = "Fehler beim eintragen des neuen DHCP Service Objekts!"; + return 0; + } +} + + + +function cleanup_del_dhcpservice ($dhcpserviceDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $filter = "(&(|(objectClass=dhcpSubnet)(objectclass=dhcpHost))(dhcphlpcont=$dhcpserviceDN))"; + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, $filter, array("dn"), "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + $delentry ['dhcphlpcont'] = $dhcpserviceDN; + foreach ($result as $item){ + ldap_mod_del($ds, $item['dn'], $delentry); + } +} + + + +function adjust_dhcpservice_dn ($newdhcpserviceDN,$dhcpserviceDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $filter = "(&(|(objectClass=dhcpSubnet)(objectclass=dhcpHost))(dhcphlpcont=$dhcpserviceDN))"; + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, $filter, array("dn"), "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + $modentry ['dhcphlpcont'] = $newdhcpserviceDN; + foreach ($result as $item){ + ldap_mod_replace($ds, $item['dn'], $modentry); + } + +} + + + +function alternative_dhcpobjects($objecttype,$objectDN,$ip){ + + global $ds, $suffix, $auDN, $assocdom, $ldapError; + + $alt_dhcp = array(); + $expip = explode('.',$ip); + $subnetDN = ""; + + if ($objecttype == "subnet"){ + # alternative DHCP Dienstobjekte eigene AU/übergeordnete AUs + $servarray = alternative_dhcpservices(""); + #print_r($servarray); echo "<br>"; + if (count($servarray) != 0){ + for ($i=0; $i < count($servarray); $i++){ + $alt_dhcp[] = $servarray[$i]; + } + } + if ($ip == ""){ + # alternative DHCP Subnetzobjekte eigene AU/übergeordnete AUs hinzufügen + $subarray = alternative_dhcpsubnets($objectDN); + #print_r($subarray); + if (count($subarray) != 0){ + for ($i=0; $i < count($subarray); $i++){ + $alt_dhcp[] = $subarray[$i]; + } + } + } + } + + if ($objecttype == "service"){ + # alternative DHCP Dienstobjekte eigene AU/übergeordnete AUs + $servarray = alternative_dhcpservices($objectDN); + #print_r($servarray); echo "<br>"; + if (count($servarray) != 0){ + for ($i=0; $i < count($servarray); $i++){ + $alt_dhcp[] = $servarray[$i]; + } + } + # Subnetz entsprechend IP + $subarray = alternative_dhcpsubnets($objectDN); + #print_r($subarray); + if (count($subarray) != 0){ + for ($i=0; $i < count($subarray); $i++){ + $expsub = explode('.', $subarray[$i]['cn']); + if ($expip[0] == $expsub[0] && $expip[1] == $expsub[1] && $expip[2] == $expsub[2]){ + $alt_dhcp[] = $subarray[$i]; + $subnetDN = $subarray[$i]['dn']; + break; + } + } + } + # falls keine IP weitere Subnetze hinzufügen + #print_r($subarray); + if ( $ip == "" && count($subarray) != 0 ){ + for ($i=0; $i < count($subarray); $i++){ + if ($subnetDN != $subarray[$i]['dn']){ + $alt_dhcp[] = $subarray[$i]; + } + } + } + } + + if ($objecttype == "nodhcp"){ + # alternative DHCP Dienstobjekte eigene AU/übergeordnete AUs + $servarray = alternative_dhcpservices(""); + #print_r($servarray); echo "<br>"; + if (count($servarray) != 0){ + for ($i=0; $i < count($servarray); $i++){ + $alt_dhcp[] = $servarray[$i]; + } + } + # Subnetz entsprechend IP + $subarray = alternative_dhcpsubnets($objectDN); + #print_r($subarray); + if (count($subarray) != 0){ + for ($i=0; $i < count($subarray); $i++){ + $expsub = explode('.', $subarray[$i]['cn']); + if ($expip[0] == $expsub[0] && $expip[1] == $expsub[1] && $expip[2] == $expsub[2]){ + $alt_dhcp[] = $subarray[$i]; + $subnetDN = $subarray[$i]['dn']; + break; + } + } + } + # falls keine IP weitere Subnetze hinzufügen + #print_r($subarray); echo "<br>";print_r($subnetDN); + if ( $ip == "" && count($subarray) != 0 ){ + for ($i=0; $i < count($subarray); $i++){ + if ($subnetDN != $subarray[$i]['dn']){ + $alt_dhcp[] = $subarray[$i]; + } + } + } + } + #echo "<br>";print_r($alt_dhcp); + return $alt_dhcp; +} + + +############################################################################### +# Funktionen zur Verwaltung von DHCP Subnet Objekten +# + +function add_dhcpsubnet ($cn,$dhcpservice,$netmask,$range1,$range2,$atts){ + + global $ds, $suffix, $auDN, $ldapError; + + $cnarray = array($cn,$cn); + $subnet = implode('_',$cnarray); + + # IP checken und FIBS anpassen + $fipb_array = get_freeipblocks_au($auDN); + + for ($i=0; $i < count($fipb_array); $i++){ + if ( split_iprange($subnet,$fipb_array[$i]) != 0 ){ + $ipranges = split_iprange($subnet,$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>" ; + + $dhcpsubnetDN = "cn=".$cn.",cn=dhcp,".$auDN; + + $entrydhcp ['objectclass'][0] = "dhcpSubnet"; + $entrydhcp ['objectclass'][1] = "dhcpOptions"; + $entrydhcp ['objectclass'][2] = "top"; + $entrydhcp ['cn'] = $cn; + $entrydhcp ['dhcpoptnetmask'] = $netmask; + if ( $dhcpservice != "none" ){ + $entrydhcp ['dhcphlpcont'] = $dhcpservice; + } + # weitere Attribute + foreach (array_keys($atts) as $key){ + if ($atts[$key] != ""){ + $entrydhcp[$key] = $atts[$key]; + } + } + print_r($entrydhcp); echo "<br>"; + print_r($dhcpsubnetDN); echo "<br>"; + + if ($result = ldap_add($ds, $dhcpsubnetDN, $entrydhcp)){ + if ( check_ip_in_subnet($range1,$cn) && check_ip_in_subnet($range2,$cn)){ + $dhcprange = implode('_',array($range1,$range2)); + if ( $range = new_ip_dhcprange($dhcprange,$dhcpsubnetDN,$auDN) ){ + echo "DHCP Range <b>".$range1." - ".$range2."</b> erfolgreich im Subnetobjekt eingetragen"; + }else{ + echo "DHCP Range <b>".$range1." - ".$range2."</b> konnte nicht im Subnetobjekt eingetragen werden!"; + } + return 1; + }else{ + echo "DHCP Range nicht in Subnetz ".$cn." enthalten.<br>Keine DHCP Range angelegt.<br>"; + return 1; + } + }else{ + echo "<br>Fehler beim anlegen des DHCP Subnet Objekts!<br>"; + return 0; + } + }else{ + echo "<br>Fehler beim eintragen der FIPBs!<br>"; + return 0; + } + } + else{ + printf("<br>Subnet %s nicht im verfuegbaren IP Bereich!<br>", $subnet ); + return 0; + } + +} + +function delete_dhcpsubnet($subnetDN,$cn){ + + global $ds, $suffix, $auDN, $ldapError; + + delete_ip_dhcprange($subnetDN,$auDN); + if ( dive_into_tree_del($subnetDN,"") ){ + cleanup_del_dhcpsubnet($subnetDN); + $oldsubnetip = implode("_",array($cn,$cn)); + $entry ['FreeIPBlock'] = $oldsubnetip; + $results = ldap_mod_add($ds,$auDN,$entry); + if ($results){ + merge_ipranges($auDN); + return 1; + }else{ + return 0; + } + }else{ + return 0; + } + +} + +function modify_subnet_dn($subnetDN,$newsubnetDN){ + + global $ds, $suffix, $auDN, $ldapError; + + # check IP-Net-Syntax ... + + # Subnet CNs (IP) in internes Range ".._.." Format bringen + $newcn = ldap_explode_dn($newsubnetDN,1); + $newcnarray = array($newcn[0],$newcn[0]); + $newsubnetip = implode("_",$newcnarray); + $oldcn = ldap_explode_dn($subnetDN,1); + $oldcnarray = array($oldcn[0],$oldcn[0]); + $oldsubnetip = implode("_",$oldcnarray); + + # IP checken und FIBS anpassen + $fipb_array = get_freeipblocks_au($auDN); + for ($i=0; $i < count($fipb_array); $i++){ + if ( split_iprange($newsubnetip,$fipb_array[$i]) != 0 ){ + $ipranges = split_iprange($newsubnetip,$fipb_array[$i]); + array_splice($fipb_array, $i, 1, $ipranges); + break; + } + } + + if ($i < count($fipb_array) ){ + + # zunächst alte DHCP Ranges löschen + delete_ip_dhcprange($subnetDN,$auDN); + # Move Subtree + if(move_subtree($subnetDN, $newsubnetDN)){ + adjust_dhcpsubnet_dn($newsubnetDN, $subnetDN); + printf("<br>Subnet Name (IP) erfolgreich von %s zu %s geändert!<br>", $oldcn[0], $newcn[0]); + # neue Subnetz-IP aus FIPBs entfernen + foreach ( $fipb_array as $item ){ + $entry ['FreeIPBlock'][] = $item; + } + # alte Subnetz-IP in FIPBs integrieren + $entry ['FreeIPBlock'][] = $oldsubnetip; + $results = ldap_mod_replace($ds,$auDN,$entry); + if ($results){ + merge_ipranges($auDN); + echo "<br>FIPBs erfolgreich angepasst!<br>" ; + return 1; + }else{ + echo "<br>Fehler beim Anpassen der FIPBs!<br>" ; + } + }else{ + echo "<br>Fehler beim ändern des Subnet Namens (IP)!<br>" ; + } + }else{ + printf("<br>Neues Subnet %s nicht im verfuegbaren IP Bereich!<br>", $newcn[0] ); + return 0; + } +} + + +function cleanup_del_dhcpsubnet ($dhcpsubnetDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $filter = "(&(objectclass=dhcpHost)(dhcphlpcont=$dhcpsubnetDN))"; + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, $filter, array("dn"), "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + $delentry ['dhcphlpcont'] = $dhcpsubnetDN; + foreach ($result as $item){ + ldap_mod_del($ds, $item['dn'], $delentry); + } +} + + + +function adjust_dhcpsubnet_dn ($newdhcpsubnetDN,$dhcpsubnetDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $filter = "(&(objectclass=dhcpHost)(dhcphlpcont=$dhcpsubnetDN))"; + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, $filter, array("dn"), "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + $modentry ['dhcphlpcont'] = $newdhcpsubnetDN; + foreach ($result as $item){ + ldap_mod_replace($ds, $item['dn'], $modentry); + } +} + + +# Nach Änderung der Host IP Adresse, überprüfen ob neue IP noch mit Subnet übereinstimmt +# Falls keine Ãœbereinstimmung mehr, dann Subnetzuordnung aus Host löschen. +function adjust_hostip_dhcpsubnet($ip,$hostDN,$dhcphlpcont) { + + global $ds, $suffix, $auDN, $ldapError; + + $subnet = ldap_explode_dn($dhcphlpcont, 1); + $expsub = explode('.', $subnet[0]); + print_r($expsub); echo "<br>"; + $expip = explode('.', $ip); + print_r($expsip); echo "<br>"; + if ($expip[0] != $expsub[0] || $expip[1] != $expsub[1] || $expip[2] != $expsub[2]){ + $entrydhcp ['dhcphlpcont'] = array(); + ldap_mod_del($ds,$hostDN,$entrydhcp); + echo "Host mit neuer IP <b>".$ip."</b> wurde aus DHCP Subnet <b>".$subnet[0]."</b> entfernt<br><br>"; + } +} + +function check_ip_in_subnet($ip,$subnet) { + + global $ds, $suffix, $auDN, $ldapError; + $ipchunks = explode('.',$ip); + $netchunks = explode('.',$subnet); + $return = 0; + for ($i=1; $i<4; $i++){ + if ( $netchunks[$i] == "0" ){ + if ( $ipchunks[$i-1] == $netchunks[$i-1] ){ + $return = 1; + } + break; + } + } + if ($return) { return 1; }else{ return 0; } +} +?>
\ No newline at end of file diff --git a/ldap-site-mngmt/webinterface/lib/host_management_functions.php b/ldap-site-mngmt/webinterface/lib/host_management_functions.php new file mode 100644 index 00000000..31f358b8 --- /dev/null +++ b/ldap-site-mngmt/webinterface/lib/host_management_functions.php @@ -0,0 +1,385 @@ +<?php + +/** +* host_management_functions.php - Rechner und Gruppen Management Funktions-Bibliothek +* Diese Bibliothek enthält alle Funktionen für die Verwaltung von Rechnern und Rechnergruppen, +* sowie von MachineConfig-Objekten +* +* @param string ldapError +* @param resource ds +* +* @author Tarik Gasmi +* @copyright Tarik Gasmi +*/ + +# Konfiguration laden +require_once("config.inc.php"); + +$ldapError = null; + +################################################################################################### + +############################################################################### +# Funktionen zur Verwaltung von Rechnern +# + +# Ändern des DN des Rechners, d.h. beim Ändern des Attributes 'hostname' +function modify_host_dn($hostDN, $newhostDN){ + + global $ds, $suffix, $auDN, $ldapError; + + if (move_subtree($hostDN,$newhostDN)){ + adjust_dn_entries($hostDN,$newhostDN); + + # Gruppen anpassen in denen Host Member ist + $groups = get_groups_member($auDN,array("dn","member"),$hostDN); + # print_r($groups); echo "<br>"; + if (count($groups != 0)){ + + foreach ($groups as $group){ + #$entry = array("member"); + if ( count($group['member']) > 1 ){ + for($i=0; $i<count($group['member']); $i++){ + if ($hostDN == $group['member'][$i]){ + $entry ['member'][$i] = $newhostDN; + }else{ + $entry ['member'][$i] = $group['member'][$i]; + } + } + # print_r($entry); echo "<br>"; + ldap_mod_replace($ds,$group['dn'],$entry); + } + if ( count($group['member']) == 1 && $group['member'] == $hostDN ){ + $entry['member'] = $newhostDN; + # print_r($entry); echo ""; + ldap_mod_replace($ds,$group['dn'],$entry); + } + } + } + + } +} + + +# Rechner neu anlegen +function add_host($hostDN,$hostname,$hostdesc,$mac,$ip,$atts){ + + global $ds, $suffix, $auDN, $assocdom, $ldapError; + + $entryhost ['objectclass'][0] = "Host"; + $entryhost ['objectclass'][1] = "dhcpHost"; + $entryhost ['objectclass'][2] = "dhcpOptions"; + $entryhost ['objectclass'][3] = "top"; + $entryhost ["hostname"] = $hostname; + $entryhost ["domainname"] = $assocdom; + if ($hostdesc != ""){$entryhost ["description"] = $hostdesc;} + if ($mac != ""){$entryhost ["hwaddress"] = $mac;} + foreach (array_keys($atts) as $key){ + if ($atts[$key] != ""){ + $entryhost[$key] = $atts[$key]; + } + } + + print_r($entryhost); echo "<br>"; + if ($result = ldap_add($ds, $hostDN, $entryhost)){ + + if($ip != ""){ + $syntax = new Syntaxcheck; + if( $syntax->check_ip_syntax($ip) ){ + $newip_array = array($ip,$ip); + $newip = implode('_',$newip_array); + print_r($newip); echo "<br><br>"; + if (new_ip_host($newip,$hostDN,$auDN)){ + echo "IP erfolgreich eingetragen<br><br>"; + }else{ + echo "Fehler beim eintragen der IP<br><br>"; + } + }else{ + echo "Falsche IP Syntax! IP nicht eingetragen"; + } + } + + return 1; + } + else{ + $mesg = "Fehler beim eintragen des neuen Rechners!"; + return 0; + } +} + + +# Rechner löschen +function delete_host($hostDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $hostdata = get_node_data($hostDN,array("hwaddress","ipaddress")); + + # IP Adresse freigeben + if ($hostdata['ipaddress'] != ""){ + delete_ip_host($hostDN,$auDN); + } + + if (dive_into_tree_del($hostDN,"")){ + + # alle DN Objekte in denen Rechner stand ebenfalls löschen + # Member in Groups + $groups = get_groups_member($auDN,array("dn","cn"),$hostDN); + # echo "Rechner aus den Gruppen entfernen: <br>"; print_r($groups); echo "<br>"; + if (count($groups) != 0){ + $entrydel ['member'] = $hostDN; + foreach ($groups as $group){ + echo "Entferne gelöschten Rechner aus Gruppe <b>".$group['cn']."</b> <br>"; + $resultG = ldap_mod_del($ds, $group['dn'], $entrydel); + + # Filename in Gruppen-PXEs + $pxes = get_pxeconfigs($group['dn'],array("dn","cn")); + if ( count($pxes) != 0 && $hostdata['hwaddress'] != ""){ + foreach ($pxes as $pxe){ + $delfilename ['filename'] = "01-".$hostdata['hwaddress']; + $resultP = ldap_mod_del($ds,$pxe['dn'],$delfilename); + echo "Entferne MAC des gelöschten Rechners aus Gruppen-PXE <b>".$pxe['cn']."</b> <br>"; + } + } + } + } + + # DHCP, DNS, RBS Server ... noch todo + # ... + return 1; + } + else{ + return 0; + } +} + + +############################################################################### +# Funktionen zur Verwaltung von Rechnergruppen +# + +# Gruppen DN ändern +function modify_group_dn($groupDN, $newgroupDN){ + + global $ds, $suffix, $ldapError; + + if (move_subtree($groupDN,$newgroupDN)){ + adjust_dn_entries($groupDN,$newgroupDN);} +} + + +# Gruppe neu anlegen +function add_group($groupDN,$groupcn,$groupdesc,$addmember){ + + global $ds, $suffix, $auDN, $assocdom, $ldapError; + + $entrygroup ['objectclass'][0] = "groupOfComputers"; + $entrygroup ['objectclass'][1] = "top"; + $entrygroup ["cn"] = $groupcn; + if ($groupdesc != ""){$entrygroup ["description"] = $groupdesc;} + + # Members anlegen (zuerst 'none' rausnehmen) + $n = array_search('none',$addmember); + if ($n === 0 ){array_splice($addmember, $n, 1);} + + if (count($addmember) != 0){ + $i = 0; + foreach ($addmember as $member){ + $exp = explode('_',$member); + $entrygroup['member'][$i] = $exp[0]; + $i++; + } + } + print_r($entrygroup); echo "<br>"; + + if ($result = ldap_add($ds, $groupDN, $entrygroup)){ + return 1; + } + else{ + return 0; + } +} + + +# Gruppe löschen +function delete_group($groupDN){ + + global $ds, $suffix, $auDN, $ldapError; + + if (dive_into_tree_del($groupDN,"")){ + + # alle DN Objekte in denen Gruppe stand ebenfalls löschen + # DHCP ... noch todo + + return 1; + } + else{ + return 0; + } +} + + +function add_groupmember($groupDN,$member){ + + global $ds, $suffix, $auDN, $ldapError; + +} + + +function delete_groupmember($groupDN,$member){ + + global $ds, $suffix, $auDN, $ldapError; + +} + + +############################################################################### +# Funktionen zur Verwaltung von MachineConfigs +# + +function check_timerange($mcday,$mcbeg,$mcend,$nodeDN,$excepttimerange){ + + global $ds, $suffix, $auDN, $ldapError; + + $brothers = get_machineconfigs($nodeDN,array("timerange")); + # keine Ãœberschneidungen pro Spez.Ebene zulassen + #print_r($brothers); echo "<br><br>"; + if (count($brothers) != 0){ + + $intersect = 0; + foreach ($brothers as $item){ + + # Fall, dass Brother mehrere TimeRanges hat + if (count($item['timerange']) > 1){ + foreach ($item['timerange'] as $tr){ + + if($tr != $excepttimerange){ + $exptime = explode('_',$tr); + $bmcday = $exptime[0]; + $bmcbeg = $exptime[1]; + $bmcend = $exptime[2]; + #echo "mcday:"; print_r($mcday); echo "<br>"; + #echo "bmcday:"; print_r($bmcday); echo "<br>"; + #echo "mcbeg:"; print_r($mcbeg); echo "<br>"; + #echo "bmcbeg:"; print_r($bmcbeg); echo "<br>"; + #echo "mcend:"; print_r($mcend); echo "<br>"; + #echo "bmcend:"; print_r($bmcend); echo "<br>"; + + if ($mcday == $bmcday){ + if ( $mcbeg > $bmcend || $mcend < $bmcbeg ){ + # keine Ãœberschneidung in der Uhrzeit + }else{ + # Uhrzeit Ãœberschneidung + $intersect = 1; + $intersecttr = $bmcday."_".$bmcbeg."_".$bmcend; + break; + } + } + } + + } + } + # Fall, dass Brother nur eine TimeRange hat + elseif (count($item['timerange']) == 1){ + + if($item['timerange'] != $excepttimerange){ + $exptime = explode('_',$item['timerange']); + $bmcday = $exptime[0]; + $bmcbeg = $exptime[1]; + $bmcend = $exptime[2]; + #echo "mcday:"; print_r($mcday); echo "<br>"; + #echo "bmcday:"; print_r($bmcday); echo "<br>"; + #echo "mcbeg:"; print_r($mcbeg); echo "<br>"; + #echo "bmcbeg:"; print_r($bmcbeg); echo "<br>"; + #echo "mcend:"; print_r($mcend); echo "<br>"; + #echo "bmcend:"; print_r($bmcend); echo "<br>"; + + if ($mcday == $bmcday){ + if ( $mcbeg > $bmcend || $mcend < $bmcbeg ){ + # keine Ãœberschneidung in der Uhrzeit + }else{ + # Uhrzeit Ãœberschneidung + $intersect = 1; + $intersecttr = $bmcday."_".$bmcbeg."_".$bmcend; + break; + } + } + } + } + } + #echo "intersect: "; print_r($intersect); echo "<br>"; + if ($intersect == 1){ + echo "<b>[".$mcday."_".$mcbeg."_".$mcend."]</b> überschneidet sich mit der + bereits existierende <b>Time Range [".$intersecttr."]</b> !"; + return 0; + }else{ + return 1; + } + }else{ + return 1; + } +} + + + +function add_mc($mcDN,$mccn,$mctimerange,$mcdesc,$mcattribs){ + + global $ds, $suffix, $auDN, $ldapError; + + $mcentry ['objectclass'][0] = "MachineConfig"; + $mcentry ['objectclass'][1] = "top"; + $mcentry ['cn'] = $mccn; + if ($mctimerange != ""){$mcentry ['timerange'] = $mctimerange;} + if ($mcdesc != ""){$mcentry ['description'] = $mcdesc;} + if ($mcdesc == ""){$mcentry ['description'] = $mccn;} + foreach (array_keys($mcattribs) as $key){ + if ($mcattribs[$key] != ""){ + $mcentry[$key] = $mcattribs[$key]; + } + } + + #print_r($mcentry); echo "<br>"; + #print_r($mcDN); echo "<br>"; + if (ldap_add($ds,$mcDN,$mcentry)){ + return 1; + } + else{ + return 0; + } +} + +# MachineConfig CN (DN) ändern +function modify_mc_dn($mcDN, $newmcDN){ + + global $ds, $suffix, $ldapError; + + if (move_subtree($mcDN,$newmcDN)){ + return 1; + }else{ + return 0; + } +} + +function change_mc_timerange($mcDN,$newmcDN,$mctimerange){ + + global $ds, $suffix, $auDN, $ldapError; + + # move tree + if (move_subtree($mcDN,$newmcDN)){ + # timerange ändern + $entrymc ['timerange'] = $mctimerange; + if (ldap_mod_replace($ds,$newmcDN,$entrymc)){ + return 1; + } + else{ + return 0; + } + } + else{ + return 0; + } +} + + + +?>
\ No newline at end of file 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 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 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 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 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 diff --git a/ldap-site-mngmt/webinterface/lib/ldap.inc.php b/ldap-site-mngmt/webinterface/lib/ldap.inc.php new file mode 100644 index 00000000..204e3e3c --- /dev/null +++ b/ldap-site-mngmt/webinterface/lib/ldap.inc.php @@ -0,0 +1,996 @@ +<?php +/** +* ldap.inc.php - LDAP-Bibliothek +* Diese Bibliothek enthält alle Funktionen für den Zugriff auf den LDAP-Server. +* +* @param string ldapError +* @param resource ds +* +* @author Timothy Burk, Mahir Yildirim, Johannes Sprenger, Daniel Höfler +* @copyright Timothy Burk, Mahir Yildirim, Johannes Sprenger, Daniel Höfler +*/ +//Konfiguration laden +require_once("config.inc.php"); + +$ldapError = null; + +/** +* uniLdapConnect($userRdn, $userPwd) - Führt den Bind am Gruppe1-LDAP-Server durch +* +* @param string userRdn UID für den Login +* @param string userPwd Loginpasswort +* +* @return boolean Erfolg bzw. Misserfolg +* +* @author Timothy Burk +*/ +function uniLdapConnect($userRdn = "", $userPwd = "") { + global $ldapError, $suffix; + if(!(defined("LDAP_HOST") && defined("LDAP_PORT"))) { + $ldapError = "Hostname und/oder Port des LDAP-Servers wurden nicht angegeben!"; + return FALSE; + } + if($ds = ldap_connect(LDAP_HOST, LDAP_PORT)) { + # Connect zum LDAP-Server OK + if(ldap_set_option($ds, LDAP_OPT_PROTOCOL_VERSION, 3)) { + # Optionen gesetzt + if($userRdn != "" && $userPwd != "") { + # Anmeldung als User. + if($result = @ldap_bind($ds, "uid=".$userRdn.",ou=people,".$suffix, $userPwd)) { + # Bind erfolgreich ausgeführt + return $ds; + } else { + # Bind nicht erfolreich. + if(ldap_error($ds) == "Invalid credentials") { + $ldapError .= "Bind nicht erfolgreich: die Zugangsdaten sind nicht korrekt.<br>\n"; + } else { + $ldapError .= "Bind als User nicht erfolgreich: ".ldap_error($ds)."<br>\n"; + } + return false; + } + } else { + # Anonymer Bind. + if($result = ldap_bind($ds)) { + # Anonymer Bind erfolgreich ausgeführt + return $ds; + } else { + # Anonymer Bind nicht erfolreich. + $ldapError .= "Anonymer Bind nicht erfolgreich: ".ldap_error($ds)."<br>\n"; + return false; + } + } + } else { + # Optionen setzen fehlgeschlagen + $ldapError .= "Protokollversion setzen fehlgeschlagen: ".ldap_error($ds)."<br>\n"; + } + } else { + # Connect fehlgeschlagen. + $ldapError .= "Connect fehlgeschlagen: ".ldap_error($ds)."<br>\n"; + } +} + + +/** +* rzLdapConnect($userRdn, $userPwd) - Führt den Bind am RZ-LDAP-Server durch +* +* @param string userRdn UID für den Login +* @param string userPwd Loginpasswort +* +* @return boolean Erfolg bzw. Misserfolg +* +* @author Timothy Burk +*/ +function rzLdapConnect($userRdn = "", $userPwd = "") { + global $ldapError, $suffix_rz; + if(!(defined("LDAP_HOST_RZ") && defined("LDAP_PORT_RZ"))) { + $ldapError = "Hostname und/oder Port des LDAP-Servers wurden nicht angegeben!"; + return FALSE; + } + if($ds = ldap_connect(LDAP_HOST_RZ, LDAP_PORT_RZ)) { + # Connect zum LDAP-Server OK + if(ldap_set_option($ds, LDAP_OPT_PROTOCOL_VERSION, 3)) { + # Optionen gesetzt + if($userRdn != "" && $userPwd != "") { + # Anmeldung als User. + if($result = @ldap_bind($ds, "uid=".$userRdn.",ou=people,".$suffix_rz, $userPwd)) { + # Bind erfolgreich ausgeführt + return $ds; + } else { + # Bind nicht erfolreich. + if(ldap_error($ds) == "Invalid credentials") { + $ldapError .= "Bind nicht erfolgreich: die Zugangsdaten sind nicht korrekt.<br>\n"; + } else { + $ldapError .= "Bind als User nicht erfolgreich: ".ldap_error($ds)."<br>\n"; + } + return false; + } + } else { + # Anonymer Bind. + if($result = ldap_bind($ds)) { + # Anonymer Bind erfolgreich ausgeführt + return $ds; + } else { + # Anonymer Bind nicht erfolreich. + $ldapError .= "Anonymer Bind nicht erfolgreich: ".ldap_error($ds)."<br>\n"; + return false; + } + } + } else { + # Optionen setzen fehlgeschlagen + $ldapError .= "Protokollversion setzen fehlgeschlagen: ".ldap_error($ds)."<br>\n"; + } + } else { + # Connect fehlgeschlagen. + $ldapError .= "Connect fehlgeschlagen: ".ldap_error($ds)."<br>\n"; + } +} + + /** + * uniLdapSearch($ds, $base, $filter, $attributes, $sort, $mode, $resultLimit, $timeout) + * Sucht Einträge im LDAP-Server. + * + * Durchsucht den LDAP-Server vom Punkt $base ab nach Einträgen, die $filter entsprechen. Falls in $sort ein Feldname angegeben + * wurde, so wird danach sortiert. (ACHTUNG: die Funktion ldap_sort() ist nicht dokumentiert! Ich weiß nicht ob sie Sortierung + * nach mehreren Feldern zulässt und wie sie sich verhält, wenn zu einem Attribut mehrere Werte existieren.) $mode definiert die + * Art der Suche, wohingegen $resultLimit und $timeout die Anzahl der Ergebnis-Einträge bzw. die maximalen Suchdauer einschränken. + * Zurückgegeben werden die Attribute, die im Array $attributes aufgeführt sind. Im Erfolgsfalle wird ein multidimensionales Array + * zurückgeliefert, im Fehlerfalle FALSE. Dann steht die Fehlermeldung in der Variablen $ldapError. + * + * @param string $base die DN, das Verzeichnis, in dem die Suche startet + * + * @param string $filter die Suchbedingungen + * + * @param array attributes die Attributnamen, deren Werte im Ergebnis enthalten sein sollen. + * + * @param string $sort Sortiert die Ergebnis-Einträge nach dem angegebenen Feldnamen (undokumentiert! s.o.) + * + * @param string $mode Der Modus: "one" liefert einen Eintrag, "list" alle Einträge des Verzeichnisses und "sub" + * schließt alle Untervezeichnisse mit ein. + * + * @param int $resultLimit die maximale Anzahl zurückgegebener Einträge + * + * @param int $timeout die maximale Suchzeit, bevor der LDAP-Server abbrechen soll + * + * @return mixed multidimensionales array mit den Einträgen im Erfolgsfall, FALSE wenn ein Fehler auftrat + * + * @see ldap_read() + * @see ldap_list() + * @see ldap_search() + * @see ldap_sort() + * @see ldap_get_entries() + * @see ldap_free_result() + * + * @author Timothy Burk + */ +function uniLdapSearch($ds, $base, $filter, $attributes, $sort, $mode, $resultLimit, $timeout) { + global $ldapError; + $abfrage = false; + if($mode == "one") { + if($resource = ldap_read($ds, $base, $filter, $attributes, 0, $resultLimit, $timeout)) { + # Abfrage erfolgreich! + $abfrage = true; + } else { + # Abfrage fehlgeschlagen. + $ldapError .= "Abfrage mit Mode $mode ist fehlgeschlagen: ".ldap_error($ds)."<br>\n"; + return false; + } + } else if($mode == "list") { + if($resource = ldap_list($ds, $base, $filter, $attributes, 0, $resultLimit, $timeout)) { + # Abfrage erfolgreich! + ldap_sort($ds,$resource,$sort); + $abfrage = true; + } else { + # Abfrage fehlgeschlagen. + $ldapError .= "Abfrage mit Mode $mode ist fehlgeschlagen: ".ldap_error($ds)."<br>\n"; + return false; + } + } else if($mode == "sub") { + if($resource = ldap_search($ds, $base, $filter, $attributes, 0, $resultLimit, $timeout)) { + # Abfrage erfolgreich! + ldap_sort($ds,$resource,$sort); + $abfrage = true; + } else { + # Abfrage fehlgeschlagen. + $ldapError .= "Abfrage mit Mode $mode ist fehlgeschlagen: ".ldap_error($ds)."<br>\n"; + return false; + } + } else { + # Kein gültiger Modus angegeben. + $ldapError .= "Es wurde kein gültiger Modus angegeben."; + return false; + } + if($abfrage && ($entries = ldap_get_entries($ds, $resource))) { + # Auslesen des Verzeichnisses erfolgreich. + ldap_free_result($resource); + return $entries; + } else { + # Auslesen des Verzeichnisses nicht erfolgreich. + $ldapError .= "Auslesen des Verzeichnisses nicht erfolgreich: ".ldap_error($ds)."<br>\n"; + return false; + } +} +/** +* uniLdapAdd($ds, $dn, $daten, [$objectclass]) +* +* Fügt ein neues Objekt in die LDAP-Datenbank ein. +* +* @param resource $ds Datenbankhandler +* @param string $dn Distinguished Name des neuen Eintrages +* @param array $daten Assoziatives Array mit den gewünschten Attributen +* @param string $objectclass Objektklasse des neuen Eintrages (Standard = "") +* +* @return boolean TRUE wenn Eintrag erfolgreich, FALSE wenn ein Fehler aufgetreten ist. +* +* @see ldap_add() +* +* @author Timothy Burk +*/ +function uniLdapAdd($ds, $dn, $daten, $objectclass = "") { + if($objectclass != "") { + $daten['objectclass'] = $objectclass; + } + if(ldap_add($ds, $dn, $daten)) { + return true; + } else { + return false; + } +} + +/** +* uniLdapModify($ds, $dn, $daten_alt, $daten_neu, [$i]) +* +* Universalfunktion zum Ändern von Attributen und Werten. +* Bei Änderungsskripten muss zuerst ein Formular mit den alten Daten gefüllt werden. Die hierfür +* durchgeführte Suche wird in einem unbehandelten Array in der SESSION gespeichert und wieder +* ausgelesen, sobald die Änderungen gespeichert werden sollen. Es wird anschließend an diese Funktion +* (als $daten_alt)gegeben, die das Array mit ldapArraySauber von allen unnötigen Einträgen befreit. +* $daten_alt entspricht dann strukturell dem POST-Array des Änderungsformulars ($daten_neu). +* Letzteres wird nun durch laufen, alle Einträge werden mit ihrer Entsprechnung aus $daten_alt verglichen +* und ggf. werden dann Attribute geändert, gelöscht oder hinzugefügt. +* +* @param resource $ds Datenbankhandler +* @param string $dn Distinguished Name des Eintrages +* @param array $daten_alt Dreidimensionales mixed Array der Form $array[int][string][int], so wie es von uniLdapSearch zurückgeliefert wird. +* @param array $daten_neu Zweidimensionales mixed Array der Form $array[string][int], so wie ein Formular in $_POST gespeichert ist. +* @param int $i Gibt an, welcher Eintrag der ersten Dimension von $daten_alt verwendet werden soll. (Standard: $i=0) +* +* @return boolean TRUE wenn Änderung erfolgreich, FALSE wenn ein Fehler aufgetreten ist. +* +* @see ldap_mod_replace() +* @see ldap_mod_add() +* @see ldap_mod_del() +* @see ldapArraySauber() +* @see numArraySauber() +* +* @author Timothy Burk +*/ +function uniLdapModify($ds, $dn, $daten_alt, $daten_neu, $i = 0) { + $meldung = ""; + $daten_alt = ldapArraySauber($daten_alt, FALSE); + $daten_alt = $daten_alt[$i]; + foreach($daten_neu as $key => $value_neu) { + $key = strtolower($key); + if(!(is_array($value_neu))) { + # Wenn $value_neu ein Skalar ist... + # (d.h., das Attribut $key darf nur einen Wert annehmen) + $value_neu = htmlentities(str_replace(chr(160),"",trim($value_neu))); // ungewollte Leerzeichen und löschen + if (isset($daten_alt[$key])) { + $daten_alt[$key] = str_replace(chr(160),"",trim($daten_alt[$key])); // ungewollte Leerzeichen und löschen + } else { + $daten_alt[$key] = ""; + } + if($daten_alt[$key] == "" && $value_neu != "") { + # FALL 1: + # Alter Wert ist leer, neuer Wert ist nicht leer. + # Füge neues Attribut hinzu. + if(ldap_mod_add($ds, $dn, array($key => $value_neu))) { + $meldung .= "Add successfull: ".$key." -> ".$value_neu."<br>"; + } else { + $meldung .= "Add error: ".$key." -> ".$value_neu."<br>"; + } + + } else if($daten_alt[$key] != "" && $value_neu == "") { + # FALL 2: + # Alter Wert ist nicht leer, neuer Wert ist leer. + # Lösche Attribut. + if(ldap_mod_del($ds, $dn, array($key => $daten_alt[$key]))) { + $meldung .= "Delete successfull: ".$key." -> ".$daten_alt[$key]."<br>"; + } else { + $meldung .= "Delete error: ".$key." -> ".$daten_alt[$key]."<br>"; + } + + } else if($daten_alt[$key] != "" && $value_neu != "" && $daten_alt[$key] != $value_neu) { + # FALL 3: + # Alter und neuer Wert sind nicht leer und beide sind ungleich. + # Ändere das Attribut. Der bisherige Wert wird überschrieben. + if(ldap_mod_replace($ds, $dn, array($key => $value_neu))) { + $meldung .= "Replace successfull: ".$key." -> ".$value_neu."<br>"; + } else { + $meldung .= "Replace error: ".$key." -> ".$value_neu."<br>"; + } + + } else { + # In allen anderen Fällen ist keine Änderung nötig + } + } else { + # Wenn $value_neu ein Array ist... + # (d.h., das Attribut $key darf mehrere Werte annehmen) + $value_neu = numArraySauber($value_neu); + if (isset($daten_alt[$key])) { + $value_alt = numArraySauber($daten_alt[$key]); + foreach($value_alt as $item) { + #$item = htmlentities($item); + # Lösche alle alten Werte des Attributes $key. + if(ldap_mod_del($ds, $dn, array($key => $item))) { + $meldung .= "Delete successfull: ".$key." -> ".$item."<br>"; + } else { + $meldung .= "Delete error: ".$key." -> ".$item."<br>"; + } + } + } + foreach($value_neu as $item) { + $item = htmlentities($item); + # Füge alle neuen Werte des Attributes $key ein. + if(ldap_mod_add($ds, $dn, array($key => $item))) { + $meldung .= "Add successfull: ".$key." -> ".$item."<br>"; + } else { + $meldung .= "Add error: ".$key." -> ".$item."<br>"; + } + + } + } + } + #return $meldung; + if(eregi("error",$meldung)) { + return FALSE; + } else { + return TRUE; + } +} + +/** +* uniLdapDelete löscht beliebige Einträge mit dessen Subtree aus der Datenbank. +* Dabei wird der wird der Baum ab dem Eintrag $dn zu allen Blättern durchlaufen (Es +* können nur Blätter gelöscht werden!!) und die Einträge von hinten her bis einschließlich +* $dn gelöscht +* +* @param resource ds LDAP Directory Handle +* @param string dn Distiguished Name +* +* @return boolean +* +* @author Daniel Höfler +*/ + +function uniLdapDelete($ds, $dn) { + # Überprüfung, ob zu löschender Eintrag vorhanden ist + if(!uniLdapSearch($ds, $dn, "objectclass=*", array("*"), "", "one", 0, 0)) { + $ldapError .= "Löschen fehlgeschlagen: Eintrag nicht gefunden".ldap_error($ds)."<br>\n"; + return false; + } + # Auslesen der Daten unterhalb von $dn + $daten = uniLdapSearch($ds, $dn, "objectclass=*", array("*"), "", "list", 0, 0); + # for-Schleife wird nur ausgeführt, falls sich unterhalb von $dn Einträge befinden + for($i = 0; $i < $daten['count']; $i++){ + uniLdapDelete($ds, $daten[$i]['dn']); + } + # löschen der Blätter + if(ldap_delete($ds, $dn)) { + return true; + } else { + $ldapError .= "Löschen fehlgeschlagen".ldap_error($ds)."<br>\n"; + return false; + } +} + +############################################################################################ +# +# Ab hier LDAP Funktionen (Tarik Gasmi) nutzen die zuvor definierten Funktionen +# von Timothy Burk, u.A. +# +############################################################################################ +# Weitere LDAP Funktionen + +# +# LDAP Funktionen um alle Objekte der AU eines bestimmten Typs mit gewählten Attributen zu holen +# +function get_hosts($auDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, "cn=computers,".$auDN, "(objectclass=Host)", $attributes, "hostname", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else{ + $result = ldapArraySauber($result); + # print_r($result);printf("<br><br>"); + $host_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['auDN'] = $auDN; + $host_array[] = $atts; + } + if($attributes != false ){return $host_array;} + else{return $result;} + } +} + +function get_groups($auDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, "cn=groups,".$auDN, "(objectclass=groupOfComputers)", $attributes, "cn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else{ + $result = ldapArraySauber($result); + # print_r($result);printf("<br><br>"); + $group_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['auDN'] = $auDN; + $group_array[] = $atts; + } + if($attributes != false ){return $group_array;} + else{return $result;} + } +} + +function get_groups_member($auDN,$attributes,$member) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, "cn=groups,".$auDN, "(&(objectclass=groupOfComputers)(member=$member))", $attributes, "cn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else{ + $result = ldapArraySauber($result); + # print_r($result);printf("<br><br>"); + $group_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['auDN'] = $auDN; + $group_array[] = $atts; + } + if($attributes != false ){return $group_array;} + else{return $result;} + } +} + +function get_machineconfigs($baseDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $baseDN, "(objectclass=MachineConfig)", $attributes, "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + elseif(count($result) == 0){return $result;} + else{ + $result = ldapArraySauber($result); + # print_r($result);printf("<br><br>"); + $mc_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['baseDN'] = $baseDN; + $atts['auDN'] = $auDN; + $mc_array[] = $atts; + } + if($attributes != false ){return $mc_array;} + else{return $result;} + } +} + +function get_pxeconfigs($baseDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $baseDN, "(objectclass=PxeConfig)", $attributes, "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + elseif(count($result) == 0){return $result;} + else{ + $result = ldapArraySauber($result); + # print_r($result);printf("<br><br>"); + $pxe_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['baseDN'] = $baseDN; + $atts['auDN'] = $auDN; + $pxe_array[] = $atts; + } + if($attributes != false ){return $pxe_array;} + else{return $result;} + } +} + +function get_menuentries($baseDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $baseDN, "(objectclass=MenuEntry)", $attributes, "menuposition", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + elseif(count($result) == 0){return $result;} + else{ + $result = ldapArraySauber($result); + # print_r($result);printf("<br><br>"); + $menent_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['baseDN'] = $baseDN; + $atts['auDN'] = $auDN; + $menent_array[] = $atts; + } + if($attributes != false ){return $menent_array;} + else{return $result;} + } +} + +function get_rbservices($auDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, "cn=rbs,".$auDN, "(objectclass=RBService)", $attributes, "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + elseif(count($result) == 0){return $result;} + else{ + $result = ldapArraySauber($result); + # print_r($result);printf("<br><br>"); + $rbs_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['auDN'] = $auDN; + $rbs_array[] = $atts; + } + if($attributes != false ){return $rbs_array;} + else{return $result;} + } +} + +function get_subnets($auDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, "cn=dhcp,".$auDN, "(objectclass=dhcpSubnet)", $attributes, "cn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else { + $result = ldapArraySauber($result); + $subnet_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['auDN'] = $auDN; + $subnet_array[] = $atts; + } + if($attributes != false ){return $subnet_array;} + else{return $result;} + } +} + +function get_dhcppools($auDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, "cn=dhcp,".$auDN, "(objectclass=dhcpPool)", $attributes, "cn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else { + $result = ldapArraySauber($result); + + $pool_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['auDN'] = $auDN; + $pool_array[] = $atts; + } + if($attributes != false ){return $pool_array;} + else{return $result;} + } +} + +function get_childau($auDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $auDN, "(objectclass=AdministrativeUnit)", $attributes, "ou", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else { + $result = ldapArraySauber($result); + + $childau_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['auDN'] = $auDN; + $childau_array[] = $atts; + } + if($attributes != false ){return $childau_array;} + else{return $result;} + } +} + +function get_au_data($auDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $auDN, "(objectclass=AdministrativeUnit)", $attributes, "ou", "one", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else { + $result = ldapArraySauber($result); + + $au_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['auDN'] = $auDN; + $au_array[] = $atts; + } + if($attributes != false ){return $au_array;} + else{return $result;} + } +} + +function get_domain_data($auDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $suffix, "(&(objectclass=dnsdomain)(associatedname=$auDN))", $attributes, "", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else { + $result = ldapArraySauber($result); + + $domain_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['auDN'] = $auDN; + $domain_array[] = $atts; + } + if($attributes != false ){return $domain_array;} + else{return $result;} + } +} + + +function get_roles($auDN) +{ + global $ds, $suffix, $domDN, $ldapError; + + if(!($result = uniLdapSearch($ds, "cn=roles,".$auDN, "(|(objectclass=GroupOfNames)(objectclass=Admins))", array("cn","member"), "cn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else{ + $result = ldapArraySauber($result); + $roles_array = array(); + #print_r($result); + foreach ($result as $item){ + if ( count($item['member']) > 1 ){ + foreach ($item['member'] as $member){ + $roles_array[$item['cn']][] = $member; + } + } + if ( count($item['member']) == 1 ){ + $roles_array[$item['cn']][] = $item['member']; + } + } + return $roles_array; + } +} + +function get_roles_dns($domDN) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, "cn=roles,".$domDN, "(objectclass=GroupOfNames)", array("cn","member"), "cn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else{ + $result = ldapArraySauber($result); + $roles_array = array(); + foreach ($result as $item){ + if ( count($item['member']) > 1){ + foreach ($item['member'] as $member){ + $roles_array[$item['cn']][] = $member; + } + }else{ + $roles_array[$item['cn']][] = $item['member']; + } + } + return $roles_array; + } +} + + +function get_users(){ + + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, "ou=people,".$suffix, "(objectclass=inetOrgPerson)", array("dn","cn","sn","uid"), "", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else{ + $result = ldapArraySauber($result); + $users_array = array(); + # foreach ($result as $item){ + # $users_array[$item['cn']] = $item['member']; + # } + # return $users_array; + return $result; + } +} + +function get_user_data($userDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $userDN, "(objectclass=inetOrgPerson)", $attributes, "", "one", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else { + $result = ldapArraySauber($result); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $user_data = $atts; + } + if($attributes != false ){return $user_data;} + else{return $result;} + } +} + + +function get_dc_data($dcDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $dcDN, "(objectclass=dnsdomain)", $attributes, "", "one", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else { + $result = ldapArraySauber($result); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $dc_data = $atts; + } + if($attributes != false ){return $dc_data;} + else{return $result;} + } +} + +function get_node_data($nodeDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + $node_data = array(); + + if(!($result = uniLdapSearch($ds, $nodeDN, "(objectclass=*)", $attributes, "", "one", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else { + $result = ldapArraySauber($result); + foreach ($result as $item){ + foreach ($attributes as $att){ + $node_data[$att] = $item[$att]; + } + } + if($attributes != false ){return $node_data;} + else{return $result;} + } +} + + + +function get_zone_entries($dcDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $dcDN, "(|(objectclass=dNSZone)(objectclass=dNSZoneIncludeDirective))", $attributes, "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else{ + $result = ldapArraySauber($result); + # print_r($result);printf("<br><br>"); + $zone_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['dcDN'] = $dcDN; + $zone_array[] = $atts; + } + if($attributes != false ){return $zone_array;} + else{return $result;} + } +} + + +function get_zone_entries_assocname($dcDN,$attributes,$assocname) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $dcDN, "(&(|(objectclass=dNSZone)(objectclass=dNSZoneIncludeDirective))(associatedname=$assocname))", $attributes, "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else{ + $result = ldapArraySauber($result); + # print_r($result);printf("<br><br>"); + $zone_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['dcDN'] = $dcDN; + $zone_array[] = $atts; + } + if($attributes != false ){return $zone_array;} + else{return $result;} + } +} + +function get_dn_menuposition($pxeDN,$pos) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $pxeDN, "(menuposition=$pos)", array("dn"), "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else { + $result = ldapArraySauber($result); + return $result[0]['dn']; + } +} + +function get_dhcpservices($auDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, "cn=dhcp,".$auDN, "(objectclass=dhcpService)", $attributes, "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + elseif(count($result) == 0){return $result;} + else{ + $result = ldapArraySauber($result); + # print_r($result);printf("<br><br>"); + $dhcp_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['auDN'] = $auDN; + $dhcp_array[] = $atts; + } + if($attributes != false ){return $dhcp_array;} + else{return $result;} + } +} + +function get_dhcpsubnets($auDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, "cn=dhcp,".$auDN, "(objectclass=dhcpSubnet)", $attributes, "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + elseif(count($result) == 0){return $result;} + else{ + $result = ldapArraySauber($result); + # print_r($result);printf("<br><br>"); + $dhcp_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $atts['auDN'] = $auDN; + $dhcp_array[] = $atts; + } + if($attributes != false ){return $dhcp_array;} + else{return $result;} + } +} + +function get_service_subnets($dhcpserviceDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + $filter = "(&(dhcphlpcont=".$dhcpserviceDN.")(objectclass=dhcpSubnet))"; + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, $filter, $attributes, "", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + elseif(count($result) == 0){return $result;} + else{ + $result = ldapArraySauber($result); + # print_r($result); + $dhcpsubnets = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $expdn = ldap_explode_dn($item['dn'],1); + $au = array_slice($expdn, 3, 1); + $atts['auDN'] = implode ( ',', $au ); + $dhcpsubnets [] = $atts; + } + #print_r($dhcpsubnets); + if($attributes != false ){ + return $dhcpsubnets; + } + else{return $result;} + } +} +?> diff --git a/ldap-site-mngmt/webinterface/lib/ldap2.inc.php b/ldap-site-mngmt/webinterface/lib/ldap2.inc.php new file mode 100644 index 00000000..3d0b26d9 --- /dev/null +++ b/ldap-site-mngmt/webinterface/lib/ldap2.inc.php @@ -0,0 +1,350 @@ +<?php +/** +* ldap2.inc.php - LDAP-Bibliothek +* Diese Bibliothek enthält weitere LDAP Hilfs-Funktionen +* +* @param string ldapError +* @param resource ds +* +* @author Tarik Gasmi +* @copyright Tarik Gasmi +*/ +//Konfiguration laden +require_once("config.inc.php"); + +$ldapError = null; + + +# Liefert Array aller Child-Knoten mit bestimmten ausgwählten Attributen +function get_childs($baseDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $baseDN, "(objectclass=*)", $attributes, "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else { + $result = ldapArraySauber($result); + + $childau_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $childau_array[] = $atts; + } + if($attributes != false ){return $childau_array;} + else{return $result;} + } +} + +# Liefert die RDNs aller Child-Knoten +function get_childs_rdn($baseDN){ + + $childs = get_childs($baseDN,array("dn")); + # print_r($childs); echo "<br><br>"; + + $childs_rdn = array(); + foreach ($childs as $item){ + $exp = explode(',',$item['dn']); + $rdn = $exp[0]; + $childs_rdn[] = $rdn; + } + + # print_r($childs_rdn); + return $childs_rdn; +} + + +# Attribute eines Knotens (Vorsicht Array enthält noch DN und COUNT) +# in einem Array wie er z.B. von ldap_add verwendet wird +function get_node_attributes($nodeDN){ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $nodeDN, "(objectclass=*)", array(), "", "one", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + # print_r($result); + foreach ($result as $item){ + foreach (array_keys($item) as $merkmal) + $attrs[$merkmal] = $item[$merkmal]; + } + return $attrs; +} + +# Rekursives Kopieren +function dive_into_tree_cp($baseDN,$new_baseDN){ + + global $ds, $suffix, $ldapError; + + $expldn = ldap_explode_dn($new_baseDN,0); + $new_node_rdn = $expldn[0]; + $exp = explode('=',$new_node_rdn); + $new_node_rdn_merk = $exp[0]; + $new_node_rdn_val = $exp[1]; + $new_node_rdn_merk = strtolower($new_node_rdn_merk); + + $childs_rdn = get_childs_rdn($baseDN); + + $attrs = get_node_attributes($baseDN); + # print_r($attrs); echo "<br>"; + unset($attrs['dn']); + unset($attrs['count']); + $attrs["$new_node_rdn_merk"] = $new_node_rdn_val; + # print_r($attrs); echo "<br>"; + + $result = ldap_add($ds,$new_baseDN,$attrs); + + + //recursivly do dive for each child + foreach($childs_rdn as $rdn){ + dive_into_tree_cp( $rdn.",".$baseDN , $rdn.",".$new_baseDN); + } + return $result; +} + + +# +# Rekursives Loeschen +function dive_into_tree_del($baseDN,$except){ + + global $ds, $suffix, $ldapError; + + $childs_rdn = get_childs_rdn($baseDN); + //recursivly do dive for each child + foreach($childs_rdn as $rdn){ + dive_into_tree_del( $rdn.",".$baseDN , $except); + } + if($baseDN != $except){ + $result = ldap_delete($ds,$baseDN); + } + + return $result; +} + +# Rekursives Verschieben +function move_subtree($oldDN,$newDN){ + + if(dive_into_tree_cp($oldDN,$newDN)) + { + dive_into_tree_del($oldDN,""); + echo "Moved subtree<br>"; + return 1; + } + else echo "Moving subtree not possible!!!<br>"; +} + + +function adjust_dn_entries($oldDN,$newDN){ + + global $ds, $suffix, $ldapError; + + # single Attributes: + if(!($result = uniLdapSearch($ds, $newDN, "(objectclass=host)", array("dn","dhcphlpcont"), "", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + #print_r($result); echo "<br><br>"; + foreach ($result as $item){ + if (strpos($item['dhcphlpcont'],$oldDN) != false){ + $newvalue = str_replace($oldDN,$newDN,$item['dhcphlpcont']); + $entry['dhcphlpcont'] = $newvalue; + ldap_mod_replace($ds,$item['dn'],$entry); + } + } + + if(!($result = uniLdapSearch($ds, $newDN, "(objectclass=PXEConfig)", array("dn","rbservicedn"), "", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + #print_r($result); echo "<br><br>"; + foreach ($result as $item2){ + if (strpos($item2['rbservicedn'],$oldDN) != false){ + $newvalue = str_replace($oldDN,$newDN,$item2['rbservicedn']); + $entry2['rbservicedn'] = $newvalue; + ldap_mod_replace($ds,$item2['dn'],$entry2); + } + } + + if(!($result = uniLdapSearch($ds, $newDN, "(objectclass=dhcpService)", array("dn","dhcpprimarydn","dhcpsecondarydn"), "", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + #print_r($result); echo "<br><br>"; + foreach ($result as $item3){ + if (strpos($item3['dhcpprimarydn'],$oldDN) != false){ + $newvalue = str_replace($oldDN,$newDN,$item3['dhcpprimarydn']); + $entry3['dhcpprimarydn'] = $newvalue; + ldap_mod_replace($ds,$item3['dn'],$entry3); + } + if (strpos($item3['dhcpsecondarydn'],$oldDN) != false){ + $newvalue = str_replace($oldDN,$newDN,$item3['dhcpsecondarydn']); + $entry4['dhcpsecondarydn'] = $newvalue; + ldap_mod_replace($ds,$item3['dn'],$entry4); + } + } + + if(!($result = uniLdapSearch($ds, $newDN, "(objectclass=MenuEntry)", array("dn","genericmenuentrydn","ldapuri"), "", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + #print_r($result); echo "<br><br>"; + foreach ($result as $item4){ + if (strpos($item4['genericmenuentrydn'],$oldDN) != false){ + $newvalue = str_replace($oldDN,$newDN,$item4['genericmenuentrydn']); + $entry5['genericmenuentrydn'] = $newvalue; + ldap_mod_replace($ds,$item4['dn'],$entry5); + } + if (strpos($item4['ldapuri'],$oldDN) != false){ + $newvalue = str_replace($oldDN,$newDN,$item4['ldapuri']); + $entry6['ldapuri'] = $newvalue; + ldap_mod_replace($ds,$item4['dn'],$entry6); + } + } + + # Multi-Attribut member + if(!($result = uniLdapSearch($ds, $newDN, "(objectclass=groupOfComputers)", array("dn","member","dhcphlpcont"), "", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + #print_r($result); echo "<br><br>"; + foreach ($result as $item5){ + for ($i=0; $i<count($item5['member']); $i++){ + if (strpos($item5['member'][$i],$oldDN) != false){ + $newvalue = str_replace($oldDN,$newDN,$item5['member'][$i]); + $entry7['member'][$i] = $newvalue; + }else{ + $entry7['member'][$i] = $item5['member'][$i]; + } + ldap_mod_replace($ds,$item5['dn'],$entry7); + } + if (strpos($item5['dhcphlpcont'],$oldDN) != false){ + $newvalue = str_replace($oldDN,$newDN,$item5['dhcphlpcont']); + $entry8['dhcphlpcont'] = $newvalue; + ldap_mod_replace($ds,$item5['dn'],$entry8); + } + + } + + # Attribut AssociatedName in DNS Teilbaum + if(!($result = uniLdapSearch($ds, "ou=DNS,".$suffix , "(associatedname=$oldDN)", array("dn","associatedname"), "", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + #print_r($result); echo "<br><br>"; + foreach ($result as $item6){ + $newvalue = str_replace($oldDN,$newDN,$item6['associatedname']); + $entry9['associatedname'] = $newvalue; + ldap_mod_replace($ds,$item6['dn'],$entry9); + } + + # Attribut RelativeDomainName in DNS Teilbaum ... noch nicht fertig + $hostdnexpold = ldap_explode_dn($oldDN, 0); + $hostdnexpnew = ldap_explode_dn($newDN, 0); + $oldhostname = $hostdnexpold[0]; + $newhostname = $hostdnexpnew[0]; + if(!($result = uniLdapSearch($ds, "ou=DNS,".$suffix , "(relativedomainname=$oldhostname)", array("dn","relativedomainname"), "", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + #print_r($result); echo "<br><br>"; + foreach ($result as $item7){ + $newvalue = str_replace($oldhostname,$newhostname,$item7['relativedomainname']); + $entry10['relativedomainname'] = $newvalue; + ldap_mod_replace($ds,$item7['dn'],$entry10); + } + +} + + + +function check_for_dc($dn, $dc){ + global $ds, $suffix, $ldapError; + if(!($result = uniLdapSearch($ds, $dn, "(dc=$dc)", array("dc"), "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + if (count($result[0]['dc']) == 0 ) {return 0;} + elseif ($result[0]['dc'] == $dc){return 1;} +} + + +function get_dc_childs($baseDN,$attributes) +{ + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $baseDN, "(objectclass=dnsdomain)", $attributes, "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else { + $result = ldapArraySauber($result); + + $childau_array = array(); + foreach ($result as $item){ + foreach ($attributes as $att){ + $atts[$att] = $item[$att]; + } + $childau_array[] = $atts; + } + if($attributes != false ){return $childau_array;} + else{return $result;} + } +} + +# Liefert die RDNs aller dc-Child-Knoten +function get_dc_childs_rdn($baseDN){ + + global $ds, $suffix, $ldapError; + + $childs = get_dc_childs($baseDN,array("dn")); + # print_r($childs); echo "<br><br>"; + + $childs_rdn = array(); + foreach ($childs as $item){ + $exp = explode(',',$item['dn']); + $rdn = $exp[0]; + $childs_rdn[] = $rdn; + } + + # print_r($childs_rdn); + return $childs_rdn; +} + +function get_entry_number($entryDN,$entryobjectclass){ + + global $ds, $suffix, $ldapError; + + if(!($result = uniLdapSearch($ds, $entryDN, "(objectclass=machineconfig)", array("count"), "", "one", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + print_r ($result); + +} + +?>
\ No newline at end of file diff --git a/ldap-site-mngmt/webinterface/lib/rbs_management_functions.php b/ldap-site-mngmt/webinterface/lib/rbs_management_functions.php new file mode 100644 index 00000000..6b1f42fd --- /dev/null +++ b/ldap-site-mngmt/webinterface/lib/rbs_management_functions.php @@ -0,0 +1,591 @@ +<?php + +/** +* rbs_management_functions.php - Remote Boot Services Management Funktions-Bibliothek +* Diese Bibliothek enthält alle Funktionen für die Verwaltung von RBS Diensten, +* PXE Konfigurationsdateien ihren Menüeinträgen und ihren Genersichen Bootmenüeinträgen +* +* @param string ldapError +* @param resource ds +* +* @author Tarik Gasmi +* @copyright Tarik Gasmi +*/ + + +# Konfiguration laden +require_once("config.inc.php"); + +$ldapError = null; + + +####################################################################### +# Funktionen zur Verwaltung von RBS Diensten +# + +# +# Neues RBS Dienst-Objekt anlegen +# +function add_rbs($rbsDN,$rbscn,$rbsoffer,$server,$atts){ + + global $ds, $suffix, $auDN, $ldapError; + + $rbsentry ['objectclass'][0] = "RBService"; + $rbsentry ['objectclass'][1] = "top"; + $rbsentry ['cn'] = $rbscn; + $rbsentry ['rbsofferdn'] = $rbsoffer; + if (count($atts) != 0){ + foreach (array_keys($atts) as $key){ + if ($atts[$key] != ""){ + $rbsentry[$key] = $atts[$key]; + } + } + } + if (count($server) != 0){ + if ($server['tftp'] != ""){$rbsentry ['tftpserverip'] = $server['tftp'];} + if ($server['nfs'] != ""){$rbsentry ['nfsserverip'] = $server['nfs'];} + if ($server['nbd'] != ""){$rbsentry ['nbdserverip'] = $server['nbd'];} + } + # print_r($rbsentry); echo "<br>"; + print_r($rbsDN); echo "<br>"; + + # Standard Fallback Menü anlegen + $pxecn = "PXE_Fallback-No-Config"; + $pxeDN = "cn=".$pxecn.",".$rbsDN; + $filename = array("fallback-nopxe"); + $ldapuri = LDAP_HOST."/dn=cn=computers,".$auDN; # wirklich nötig?? + $mecn = "Fallback-Text"; + $meDN = "cn=".$mecn.",".$pxeDN; + $meattribs = array("label" => "Keine PXE Boot-Konfiguration fuer die aktuelle Zeit definiert", + "kernel" => "menu.c32", + "submenulink" => "fallback-nopxe"); + + if (ldap_add($ds,$rbsDN,$rbsentry)){ + if (add_pxe($pxeDN,$pxecn,$rbsDN,"",array(),$filename,$ldapuri)){ + if (add_me($meDN,$mecn,"","01",$meattribs,$pxeDN)){ + return 1; + } + else{ + return 0; + } + } + else{ + return 0; + } + } + else{ + return 0; + } +} + +# +# "RBS-Angebote" im Verzeichnis suchen, die die AU ($auDN) nutzen darf, +# Suche nach passenden RBS-Offer-DNs +# +function get_rbsoffers($auDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $attribs = array("dn","rbsofferdn"); + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, "(objectclass=RBService)", $attribs, "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + else{ + $result = ldapArraySauber($result); + #print_r($result);echo "<br><br>"; + + $rbs_offers = array(); + foreach ($result as $rbs){ + #print_r(strpos($auDN, $rbs['rbsofferdn']));echo "<br>"; + if ( strpos($auDN, $rbs['rbsofferdn']) !== false ) + $rbs_offers [] = $rbs['dn']; + } + } + #print_r($rbs_offers);echo "<br><br>"; + return $rbs_offers; +} + + +# +# Beim Löschen von RBS-Objekten muss dafür gesorgt werden dass keine PXEs mehr auf +# diese zeigen, Ref. Abhängigkeiten +# +function clean_up_del_rbs($rbsDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $attribs = array("dn"); + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, "(&(objectclass=PXEConfig)(rbservicedn=$rbsDN))", $attribs, "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + #print_r($result); echo "<br><br>"; + $delentry ['rbservicedn'] = $rbsDN; + foreach ($result as $item){ + #print_r($item['dn']); echo "<br>"; + ldap_mod_del($ds, $item['dn'], $delentry); + } + + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, "(&(objectclass=Host)(hlprbservice=$rbsDN))", $attribs, "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + #print_r($result); echo "<br><br>"; + $delentry2 ['hlprbservice'] = $rbsDN; + foreach ($result as $item){ + #print_r($item['dn']); echo "<br>"; + ldap_mod_del($ds, $item['dn'], $delentry2); + } + +} + +# +# beim ändern des CN (DN) des RBS muss dieses in allen referenzierenden PXEConfig-Objekten +# nachvollzogen werden, Ref. Abhängigkeiten +# +function adjust_rbs_dn($newrbsDN, $rbsDN){ + + global $ds, $suffix, $auDN, $ldapError; + + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, "(&(objectclass=PXEConfig)(rbservicedn=$rbsDN))", array("dn"), "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + $modentry ['rbservicedn'] = $newrbsDN; + foreach ($result as $item){ + ldap_mod_replace($ds, $item['dn'], $modentry); + } + + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, "(&(objectclass=Host)(hlprbservice=$rbsDN))", array("dn"), "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + $modentry2 ['hlprbservice'] = $newrbsDN; + foreach ($result as $item){ + ldap_mod_replace($ds, $item['dn'], $modentry2); + } +} + +function rbs_adjust_host($hostDN, $rbs){ + + global $ds, $suffix, $ldapError; + + $modentry ['rbservicedn'] = $rbs; + + $pxearray = get_pxeconfigs($hostDN,array("dn")); + if ( count($pxearray) != 0 ){ + foreach ( $pxearray as $item ){ + if ($result = ldap_mod_replace($ds,$item['dn'],$modentry)){ + return 1; + }else{ + return 0; + } + } + } +} + + +# +# Sucht den Hostname zu einer IP im Rechnerteilbaum der AU +# Verwaltung der am RBS beteiligten Server +# +function get_hostname_from_ip($ip,$auDN){ + + global $ds, $suffix, $ldapError; + + $ipp = array($ip,$ip); + $ipaddress = implode('_',$ipp); + + if(!($result = uniLdapSearch($ds, "cn=computers,".$auDN, "(&(objectclass=Host)(ipaddress=$ipaddress))", array("hostname"), "", "list", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + elseif(count($result) == 0){echo "kein Rechner mit dieser IP"; return "";} + else{ + $result = ldapArraySauber($result); + #print_r($result); + $host ['hostname'] = $result[0]['hostname']; + $host ['dn'] = $result[0]['dn']; + return $host; + } +} + + +############################################################################### +# Funktionen zur Verwaltung von PXE Bootmenüs + +# +# Ãœberprüft, ob sich die angegebene Timerange auf einer der 4 Spezifikationsstufen mit anderen +# Timeranges des Objkets überschneidet +# +function check_timerange_pxe($pxeday,$pxebeg,$pxeend,$nodeDN,$excepttimerange){ + + global $ds, $suffix, $auDN, $ldapError; + + $brothers = get_pxeconfigs($nodeDN,array("timerange")); + # keine Ãœberschneidungen pro Spez.Ebene zulassen + # print_r($brothers); echo "<br><br>"; + if (count($brothers) != 0){ + + $intersect = 0; + foreach ($brothers as $item){ + + # Fall das Brother mehrere TimeRanges hat + if (count($item['timerange']) > 1){ + foreach ($item['timerange'] as $tr){ + + if($tr != $excepttimerange){ + $exptime = explode('_',$tr); + $bpxeday = $exptime[0]; + $bpxebeg = $exptime[1]; + $bpxeend = $exptime[2]; + #echo "pxeday:"; print_r($pxeday); echo "<br>"; + #echo "bpxeday:"; print_r($bpxeday); echo "<br>"; + #echo "pxebeg:"; print_r($pxebeg); echo "<br>"; + #echo "bpxebeg:"; print_r($bpxebeg); echo "<br>"; + #echo "pxeend:"; print_r($pxeend); echo "<br>"; + #echo "bpxeend:"; print_r($bpxeend); echo "<br>"; + + if ($pxeday == $bpxeday){ + if ( $pxebeg > $bpxeend || $pxeend < $bpxebeg ){ + # keine Ãœberschneidung in der Uhrzeit + }else{ + # Uhrzeit Ãœberschneidung + $intersect = 1; + $intersecttr = $bpxeday."_".$bpxebeg."_".$bpxeend; + break; + } + } + } + + } + } + # Fall das Brother nur eine TimeRange hat + elseif (count($item['timerange']) == 1){ + + if($item['timerange'] != $excepttimerange){ + $exptime = explode('_',$item['timerange']); + $bpxeday = $exptime[0]; + $bpxebeg = $exptime[1]; + $bpxeend = $exptime[2]; + #echo "pxeday:"; print_r($pxeday); echo "<br>"; + #echo "bpxeday:"; print_r($bpxeday); echo "<br>"; + #echo "pxebeg:"; print_r($pxebeg); echo "<br>"; + #echo "bpxebeg:"; print_r($bpxebeg); echo "<br>"; + #echo "pxeend:"; print_r($pxeend); echo "<br>"; + #echo "bmcend:"; print_r($bpxeend); echo "<br>"; + + if ($pxeday == $bpxeday){ + if ( $pxebeg > $bpxeend || $pxeend < $bpxebeg ){ + # keine Ãœberschneidung in der Uhrzeit + }else{ + # Uhrzeit Ãœberschneidung + $intersect = 1; + $intersecttr = $bpxeday."_".$bpxebeg."_".$bpxeend; + break; + } + } + } + } + } + #echo "intersect: "; print_r($intersect); echo "<br>"; + if ($intersect == 1){ + echo "<b>[".$pxeday."_".$pxebeg."_".$pxeend."]</b> überschneidet sich mit der + bereits existierende <b>Time Range [".$intersecttr."]</b> !<br><br>"; + return 0; + }else{ + return 1; + } + }else{ + return 1; + } +} + + +# +# Neues PXE Bootmenü anlegen +# +function add_pxe($pxeDN,$pxecn,$rbsDN,$pxetimerange,$pxeattribs,$filenames,$conffile){ + + global $ds, $suffix, $auDN, $ldapError; + + $pxeentry ['objectclass'][0] = "PXEConfig"; + $pxeentry ['objectclass'][1] = "top"; + $pxeentry ['cn'] = $pxecn; + $pxeentry ['rbservicedn'] = $rbsDN; + #$pxeentry ['ldapuri'] = $ldapuri; + if ($conffile != ""){$pxeentry ['fileuri'] = $conffile;} + if (count($filenames) > 1 ){ + for ($i=0; $i<count($filenames); $i++){ + $pxeentry ['filename'][$i] = $filenames[$i]; + } + } + if (count($filenames) == 1){ + $pxeentry ['filename'] = $filenames[0]; + } + if ($pxetimerange != ""){$pxeentry ['timerange'] = $pxetimerange;} + if (count($pxeattribs) != 0){ + foreach (array_keys($pxeattribs) as $key){ + if ($pxeattribs[$key] != ""){ + $pxeentry[$key] = $pxeattribs[$key]; + } + } + } + #print_r($pxeentry); echo "<br>"; + print_r($pxeDN); echo "<br>"; + if (ldap_add($ds,$pxeDN,$pxeentry)){ + return 1; + } + else{ + return 0; + } +} + + +# +# PXE CN (DN) ändern, Teilbaum verschieben +# +function modify_pxe_dn($pxeDN, $newpxeDN){ + + global $ds, $suffix, $ldapError; + + if (move_subtree($pxeDN,$newpxeDN)){ + return 1; + }else{ + return 0; + } +} + + +# +# Timerange eines PXEConfig-Objekts ändern +# +function change_pxe_timerange($pxeDN,$newpxeDN,$pxetimerange){ + + global $ds, $suffix, $auDN, $ldapError; + + # move tree + if (move_subtree($pxeDN,$newpxeDN)){ + # timerange ändern + $entrypxe ['timerange'] = $pxetimerange; + if (ldap_mod_replace($ds,$newpxeDN,$entrypxe)){ + return 1; + } + else{ + return 0; + } + } + else{ + return 0; + } +} + +# +# nach dem Löschen von PXEConfig Menueinträgen müssen Menüpositionen in der PXEConfig +# angepasst werden (Lücken schließen) +# +function cleanup_menupositions($pxeDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $me = get_menuentries($pxeDN,array("dn","menuposition")); + if (count($me) != 0){ + foreach ($me as $item){ + $pos = $item['menuposition']; + $pos = preg_replace ( '/0([0-9])/', '$1', $pos); + $menpos[$pos] = $item['dn']; + ksort($menpos); + } + $p = 1; + foreach ($menpos as $item){ + if (strlen($p) == 1){ + $p = "0".$p; + } + $entry ['menuposition'] = $p; + ldap_mod_replace($ds,$item,$entry); + $p++; + } + } +} + +# +# Hilfsfunktion zur Verarbeitung von Menüpositionen in PXEConfigs +# +function increment_menupositions($pxeDN,$menpos){ + + global $ds, $suffix, $auDN, $ldapError; + + if (strlen($menpos) == 1){ + $menpos = "0".$menpos; + } + $meDN = get_dn_menuposition($pxeDN,$menpos); + if ($meDN != ""){ + # zur Berechnung erst führende Nullen weg + $menpos = preg_replace ( '/0([0-9])/', '$1', $menpos); + $newpos = $menpos+1; + increment_menupositions($pxeDN,$newpos); + # zum Eintragen führenden Nullen wieder dazu + if (strlen($newpos) == 1){ + $newpos = "0".$newpos; + } + $entry ['menuposition'] = $newpos; + ldap_mod_replace($ds,$meDN,$entry); + } +} + +# +# Neuen Menüeintrag anlegen +# +function add_me($meDN,$mecn,$gbmDN,$menpos,$meattribs,$pxeDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $mentry ['objectclass'][0] = "MenuEntry"; + $mentry ['objectclass'][1] = "top"; + $mentry ['cn'] = $mecn; + if($gbmDN != ""){$mentry ['genericmenuentrydn'] = $gbmDN;} + $mentry ['menuposition'] = $menpos; + if (count($meattribs) != 0){ + foreach (array_keys($meattribs) as $key){ + if ($meattribs[$key] != ""){ + $mentry[$key] = $meattribs[$key]; + } + } + } + print_r($mentry); echo "<br>"; + print_r($meDN); echo "<br>"; + increment_menupositions($pxeDN,$menpos); # andere jeweils um 1 erhöhen + if (ldap_add($ds,$meDN,$mentry)){ + return 1; + } + else{ + return 0; + } +} + + +# +# Menu Entry CN (DN) ändern +# +function modify_me_dn($meDN, $newmeDN){ + + global $ds, $suffix, $ldapError; + + if (move_subtree($meDN,$newmeDN)){ + return 1; + }else{ + return 0; + } +} + + + +##################################################################### +# Verwaltung von GBM +# + +function add_gbm($gbmDN,$gbmcn,$attribs){ + + global $ds, $suffix, $auDN, $ldapError; + + $entry ['objectclass'][0] = "MenuEntry"; + $entry ['objectclass'][1] = "top"; + $entry ['cn'] = $gbmcn; + if (count($attribs) != 0){ + foreach (array_keys($attribs) as $key){ + if ($attribs[$key] != ""){ + $entry[$key] = $attribs[$key]; + } + } + } + print_r($entry); echo "<br>"; + print_r($gbmDN); echo "<br>"; + if (ldap_add($ds,$gbmDN,$entry)){ + return 1; + } + else{ + return 0; + } +} + + +# +# beim löschen von GBMs muss dafür gesorgt werden, dass keine MEs mehr auf diese zeigen, +# Ref.Abhängigkeiten (sonst gibts Fehler beim PXE-Perlskript und die Nutzer wissen nicht dass ihr PXE Menü nicht +# mehr funktioniert, so kann man durch Fehlen des gbmDN wissen das es kein GBM mehr zu diesem ME gibt +# +function clean_up_del_gbm($gbmDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $attribs = array("dn","genericmenuentrydn"); + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, "(&(objectclass=MenuEntry)(genericmenuentrydn=$gbmDN))", $attribs, "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + #print_r($result); echo "<br><br>"; + $delentry ['genericmenuentrydn'] = $gbmDN; + foreach ($result as $item){ + #print_r($item['dn']); echo "<br>"; + ldap_mod_del($ds, $item['dn'], $delentry); + } + +} + + +# +# beim ändern des CN (DN) des GBM, Meüeinträge anpassen, Ref. Abhängigkeiten +# +function adjust_gbm_dn($newgbmDN, $gbmDN){ + + global $ds, $suffix, $auDN, $ldapError; + + if(!($result = uniLdapSearch($ds, "ou=RIPM,".$suffix, "(&(objectclass=MenuEntry)(genericmenuentrydn=$gbmDN))", array("dn"), "dn", "sub", 0, 0))) { + # redirect(5, "", $ldapError, FALSE); + echo "no search"; + die; + } + $result = ldapArraySauber($result); + $modentry ['genericmenuentrydn'] = $newgbmDN; + foreach ($result as $item){ + ldap_mod_replace($ds, $item['dn'], $modentry); + } +} + + + +function alternative_rbservices($rbsDN){ + + global $ds, $suffix, $auDN, $ldapError; + + $alt_rbs = array(); + + $rbsarray = get_rbsoffers($auDN); + # print_r($rbsarray); echo "<br>"; + if (count($rbsarray) != 0){ + for ($i=0; $i < count($rbsarray); $i++){ + if ($rbsarray[$i] != $rbsDN){ + $exp = ldap_explode_dn ( $rbsarray[$i], 1 ); + $alt = array ("dn" => $rbsarray[$i], "cn" => $exp[0], "au" => " / ".$exp[2]); + $alt_rbs[] = $alt; + } + } + } + + return $alt_rbs; +} + +?>
\ No newline at end of file diff --git a/ldap-site-mngmt/webinterface/lib/syntax_check.php b/ldap-site-mngmt/webinterface/lib/syntax_check.php new file mode 100644 index 00000000..35924e3c --- /dev/null +++ b/ldap-site-mngmt/webinterface/lib/syntax_check.php @@ -0,0 +1,268 @@ +<?php +/* + Syntaxcheck 1.2 2006/08/08 + + A class for checking syntax of forms data + Copyright (c) Tarik Gasmi, All Rights Reserved +*/ + + +class Syntaxcheck +{ + + var $ERROR = ""; + var $CLEAR = false; + + function Syntaxcheck () + { + return; + } + + function clear_error () + { + $this->ERROR = ""; + } + + + + + +# Ist "dotted quad IPAddress" in gueltigem Bereich? true or false +# Ueberprueft Format, fuehrende Nullen, und Werte > 255 +# +# Ueberprueft nicht nach reservierten oder nicht-route-baren IPs. +# +function check_ip_syntax($IP) +{ + if($this->CLEAR) { $this->clear_error();} + + $len = strlen($IP); + if( $len > 15 ){ + $this->ERROR = "check_ip_syntax: too long [$IP][$len]"; + return false; + } + + $badcharacter = eregi_replace("([0-9\.]+)","",$IP); + if(!empty($badcharacter)){ + $this->ERROR = "check_ip_syntax: Bad data in IP address [$badcharacter]"; + return false; + } + + $chunks = explode(".",$IP); + $count = count($chunks); + if ($count != 4){ + $this->ERROR = "check_ip_syntax: not a dotted quad [$IP]"; + return false; + } + + while ( list ($key,$val) = each ($chunks) ){ + if(ereg("^0",$val)){ + $this->ERROR = "check_ip_syntax: Invalid IP segment [$val]"; + return false; + } + $Num = $val; + settype($Num,"integer"); + if($Num > 255){ + $this->ERROR = "check_ip_syntax: Segment out of range [$Num]"; + return false; + } + } + + return true; + +} + +# Netzwerkaddresse +function check_netip_syntax($IP) +{ + if($this->CLEAR) { $this->clear_error();} + + if ( !($this->check_ip_syntax($IP)) ){ + return false; + } + $chunks = explode(".",$IP); + if ( $chunks[3] != "0" ){ + return false; + } + return true; +} + +# MAC Adresse + +# Domainname + +# Hostname +function is_hostname ($hostname = ""){ + + if($this->CLEAR) { $this->clear_error(); } + + $web = false; + + if(empty($hostname)) + { + $this->ERROR = "is_hostname: No hostname submitted"; + return false; + } + + // Only a-z, 0-9, and "-" or "." are permitted in a hostname + + // Patch for POSIX regex lib by Sascha Schumann sas@schell.de + $Bad = eregi_replace("[-A-Z0-9\.]","",$hostname); + + if(!empty($Bad)) + { + $this->ERROR = "is_hostname: invalid chars [$Bad]"; + return false; + } + + // See if we're doing www.hostname.tld or hostname.tld + if(eregi("^www\.",$hostname)) + { + $web = true; + } + + // double "." is a not permitted + if(ereg("\.\.",$hostname)) + { + $this->ERROR = "is_hostname: Double dot in [$hostname]"; + return false; + } + if(ereg("^\.",$hostname)) + { + $this->ERROR = "is_hostname: leading dot in [$hostname]"; + return false; + } + + $chunks = explode(".",$hostname); + + if( (gettype($chunks)) != "array") + { + $this->ERROR = "is_hostname: Invalid hostname, no dot seperator [$hostname]"; + return false; + } + + $count = ( (count($chunks)) - 1); + + if($count < 1) + { + $this->ERROR = "is_hostname: Invalid hostname [$count] [$hostname]\n"; + return false; + } + + // Bug that can't be killed without doing an is_host, + // something.something will return TRUE, even if it's something + // stupid like NS.SOMETHING (with no tld), because SOMETHING is + // construed to BE the tld. The is_bigfour and is_country + // checks should help eliminate this inconsistancy. To really + // be sure you've got a valid hostname, do an is_host() on it. + + if( ($web) and ($count < 2) ) + { + $this->ERROR = "is_hostname: Invalid hostname [$count] [$hostname]\n"; + return false; + } + + $tld = $chunks[$count]; + + if(empty($tld)) + { + $this->ERROR = "is_hostname: No TLD found in [$hostname]"; + return false; + } + + if(!$this->is_bigfour($tld)) + { + if(!$this->is_country($tld)) + { + $this->ERROR = "is_hostname: Unrecognized TLD [$tld]"; + return false; + } + } + + + return true; +} + + +# Syntax Check für die Eingaben: Uhrzeit, Wochentag, Monatstag, Monatstag.Monat +function check_timerange_syntax($mcday,$mcbeg,$mcend){ + + if($this->CLEAR) { $this->clear_error();} + + $badcharacter = eregi_replace("([a-z0-9\.]+)","",$mcday); + if(!empty($badcharacter)){ + $this->ERROR = "check_ip_syntax: Bad data in MC Day [$badcharacter]"; + return false; + } + $badcharacter = eregi_replace("([x0-9]+)","",$mcbeg); + if(!empty($badcharacter)){ + $this->ERROR = "check_ip_syntax: Bad data in MC Begin [$badcharacter]"; + return false; + } + $badcharacter = eregi_replace("([x0-9]+)","",$mcend); + if(!empty($badcharacter)){ + $this->ERROR = "check_ip_syntax: Bad data in MC End [$badcharacter]"; + return false; + } + + $lenmcday = strlen($mcday); + if (eregi("([a-z]+)",$mcday)){ + if ($lenmcday > 2){$this->ERROR = "WOTAG > 2"; return false;} + if (eregi("([0-9\.]+)",$mcday)){$this->ERROR = "WOTAG enthaelt (0-9.)"; return false;} + #if (!(eregi("[mdsfx][aiorx]",$mcday))){return false;} + if (!(eregi("(m[io]|d[io]|s[ao]|fr|x)",$mcday))){$this->ERROR = "WOTAG falscher String"; return false;} + } + if (eregi("([0-9]+)",$mcday)){ + if (eregi("[\.]",$mcday)){ + preg_match("/[\.]/",$mcday,$treffer); + if (count($treffer) > 1){$this->ERROR = "mehr als 2 Punkte"; return false;}; + $exp = explode('.',$mcday); + $day = $exp[0]; + $lenday = strlen($day); + if ($lenday > 2){$this->ERROR = "TAG > 2"; return false;} + if (!(eregi("(0[1-9]|[0-2][0-9]|3[01])",$day))){$this->ERROR = "TAG nicht korrekt"; return false;} + $month = $exp[1]; + $lenmonth = strlen($month); + if ($lenmonth > 2){$this->ERROR = "MONAT > 2"; return false;} + if (!(eregi("(0[0-9]|0[0-9]|1[0-2])",$month))){$this->ERROR = "Monat nicht korrekt"; return false;} + + } + else{ + if ($lenmcday > 2){$this->ERROR = "TAG > 2"; return false;} + if (!(eregi("(0[0-9]|[0-2][0-9]|3[01])",$mcday))){$this->ERROR = "Tag nicht korrekt"; return false;} + } + } + + $lenmcbeg = strlen($mcbeg); + if ($lenmcbeg == 2){ + if (!(eregi("(0[0-9]|1[0-9]|2[0-3]|x)",$mcbeg))){$this->ERROR = "Uhrzeit nicht korrekt"; return false;} + } + if ($lenmcbeg == 1){ + if (!(eregi("([0-9]|x)",$mcbeg))){$this->ERROR = "Uhrzeit nicht korrekt"; return false;} + } + $lenmcend = strlen($mcend); + if ($lenmcend == 2){ + if (!(eregi("(0[0-9]|1[0-9]|2[0-3]|x)",$mcend))){$this->ERROR = "Uhrzeit nicht korrekt"; return false;} + } + if ($lenmcend == 1){ + if (!(eregi("([0-9]|x)",$mcend))){$this->ERROR = "Uhrzeit nicht korrekt"; return false;} + } + + return true; +} + + +# Überprüft ob Menuposition ein Zahl ist +function check_menuposition($menpos){ + + if($this->CLEAR) { $this->clear_error();} + + $badcharacter = eregi_replace("([0-9]+)","",$menpos); + if(!empty($badcharacter)){ + $this->ERROR = "check_menupostion: Bad data in Menu Position [$badcharacter]"; + return false; + } +} + +} +?>
\ No newline at end of file |