include/class_ldap.inc

   1 <?php
   2 /*****************************************************************************
   3   newldap.inc - version 1.0
   4   Copyright (C) 2003 Alejandro Escanero Blanco <aescanero@chaosdimension.org>
   5   Copyright (C) 2004-2006 Cajus Pollmeier <pollmeier@gonicus.de>
   6
   7   Based in code of ldap.inc of
   8   Copyright (C) 1998  Eric Kilfoil <eric@ipass.net>
   9  *****************************************************************************/
  10
  11 define("ALREADY_EXISTING_ENTRY",-10001);
  12 define("UNKNOWN_TOKEN_IN_LDIF_FILE",-10002);
  13 define("NO_FILE_UPLOADED",10003);
  14 define("INSERT_OK",10000);
  15 define("SPECIALS_OVERRIDE", TRUE);
  16
  17 class LDAP{
  18
  19   var $hascon   =false;
  20   var $hasres   =false;
  21   var $reconnect=false;
  22   var $tls      = false;
  23   var $basedn   ="";
  24   var $cid;
  25   var $error    = ""; // Any error messages to be returned can be put here
  26   var $start    = 0; // 0 if we are fetching the first entry, otherwise 1
  27   var $objectClasses = array(); // Information read from slapd.oc.conf
  28   var $binddn   = "";
  29   var $bindpw   = "";
  30   var $hostname = "";
  31   var $follow_referral = FALSE;
  32   var $referrals= array();
  33   var $max_ldap_query_time = 0;   // 0, empty or negative values will disable this check
  34
  35   function LDAP($binddn,$bindpw, $hostname, $follow_referral= FALSE, $tls= FALSE)
  36   {
  37     global $config;
  38     $this->follow_referral= $follow_referral;
  39     $this->tls=$tls;
  40     $this->binddn=$this->convert($binddn);
  41
  42     $this->bindpw=$bindpw;
  43     $this->hostname=$hostname;
  44
  45     /* Check if MAX_LDAP_QUERY_TIME is defined */
  46     if(isset($config->data['MAIN']['MAX_LDAP_QUERY_TIME'])){
  47       $str = $config->data['MAIN']['MAX_LDAP_QUERY_TIME'];
  48       $this->max_ldap_query_time = (float)($str);
  49     }
  50
  51     $this->connect();
  52   }
  53
  54
  55   /* Function to replace all problematic characters inside a DN by \001XX, where
  56      \001 is decoded to chr(1) [ctrl+a]. It is not impossible, but very unlikely
  57      that this character is inside a DN.
  58
  59      Currently used codes:
  60       ,   => CO
  61       \2C => CO
  62       (   => OB
  63       )   => CB
  64       /   => SL                                                                  */
  65   function convert($dn)
  66   {
  67     if (SPECIALS_OVERRIDE == TRUE){
  68       $tmp= preg_replace(array("/\\\\,/", "/\\\\2C/", "/\(/", "/\)/", "/\//"),
  69                            array("\001CO", "\001CO", "\001OB", "\001CB", "\001SL"),
  70                            $dn);
  71       return (preg_replace('/,\s+/', ',', $tmp));
  72     } else {
  73       return ($dn);
  74     }
  75   }
  76
  77
  78   /* Function to fix all problematic characters inside a DN by replacing \001XX
  79      codes to their original values. See "convert" for mor information.
  80      ',' characters are always expanded to \, (not \2C), since all tested LDAP
  81      servers seem to take it the correct way.                                  */
  82   function fix($dn)
  83   {
  84     if (SPECIALS_OVERRIDE == TRUE){
  85       return (preg_replace(array("/\001CO/", "/\001OB/", "/\001CB/", "/\001SL/"),
  86                            array("\,", "(", ")", "/"),
  87                            $dn));
  88     } else {
  89       return ($dn);
  90     }
  91   }
  92
  93
  94   function connect()
  95   {
  96     $this->hascon=false;
  97     $this->reconnect=false;
  98     if ($this->cid= @ldap_connect($this->hostname)) {
  99       @ldap_set_option($this->cid, LDAP_OPT_PROTOCOL_VERSION, 3);
 100       if (function_exists("ldap_set_rebind_proc") && $this->follow_referral) {
 101         @ldap_set_option($this->cid, LDAP_OPT_REFERRALS, 1);
 102         @ldap_set_rebind_proc($this->cid, array(&$this, "rebind"));
 103       }
 104       if (function_exists("ldap_start_tls") && $this->tls){
 105         @ldap_start_tls($this->cid);
 106       }
 107
 108       $this->error = "No Error";
 109       if ($bid = @ldap_bind($this->cid, $this->fix($this->binddn), $this->bindpw)) {
 110         $this->error = "Success";
 111         $this->hascon=true;
 112       } else {
 113         if ($this->reconnect){
 114           if ($this->error != "Success"){
 115             $this->error = "Could not rebind to " . $this->binddn;
 116           }
 117         } else {
 118           $this->error = "Could not bind to " . $this->binddn;
 119         }
 120       }
 121     } else {
 122       $this->error = "Could not connect to LDAP server";
 123     }
 124   }
 125
 126   function rebind($ldap, $referral)
 127   {
 128     $credentials= $this->get_credentials($referral);
 129     if (@ldap_bind($ldap, $this->fix($credentials['ADMIN']), $credentials['PASSWORD'])) {
 130       $this->error = "Success";
 131       $this->hascon=true;
 132       $this->reconnect= true;
 133       return (0);
 134     } else {
 135       $this->error = "Could not bind to " . $credentials['ADMIN'];
 136       return NULL;
 137     }
 138   }
 139
 140   function reconnect()
 141   {
 142     if ($this->reconnect){
 143       @ldap_unbind($this->cid);
 144       $this->cid = NULL;
 145     }
 146   }
 147
 148   function unbind()
 149   {
 150     @ldap_unbind($this->cid);
 151     $this->cid = NULL;
 152   }
 153
 154   function disconnect()
 155   {
 156     if($this->hascon){
 157       @ldap_close($this->cid);
 158       $this->hascon=false;
 159     }
 160   }
 161
 162   function cd($dir)
 163   {
 164     if ($dir == "..")
 165       $this->basedn = $this->getParentDir();
 166     else
 167       $this->basedn = $this->convert($dir);
 168   }
 169
 170   function getParentDir($basedn = "")
 171   {
 172     if ($basedn=="")
 173       $basedn = $this->basedn;
 174     else
 175       $basedn = $this->convert($this->basedn);
 176     return(ereg_replace("[^,]*[,]*[ ]*(.*)", "\\1", $basedn));
 177   }
 178
 179   function search($filter, $attrs= array())
 180   {
 181     if($this->hascon){
 182       if ($this->reconnect) $this->connect();
 183
 184       $start = microtime();
 185
 186       $this->clearResult();
 187       $this->sr = @ldap_search($this->cid, $this->fix($this->basedn), $filter, $attrs);
 188       $this->error = @ldap_error($this->cid);
 189       $this->resetResult();
 190       $this->hasres=true;
 191
 192       /* Check if query took longer as specified in max_ldap_query_time */
 193       if($this->max_ldap_query_time){
 194         $diff = get_MicroTimeDiff($start,microtime());
 195         if($diff > $this->max_ldap_query_time){
 196           print_red(sprintf(_("The LDAP server is slow (%.2fs for the last query). This may be responsible for performance breakdowns."),$diff)) ;
 197         }
 198       }
 199
 200       $this->log("LDAP operation: time=".get_MicroTimeDiff($start,microtime())." operation=search('".$this->fix($this->basedn)."', '$filter')");
 201       return($this->sr);
 202     }else{
 203       $this->error = "Could not connect to LDAP server";
 204       return("");
 205     }
 206   }
 207
 208   function ls($filter = "(objectclass=*)", $basedn = "",$attrs = array("*"))
 209   {
 210     if($this->hascon){
 211       if ($this->reconnect) $this->connect();
 212       $this->clearResult();
 213       if ($basedn == "")
 214         $basedn = $this->basedn;
 215       else
 216         $basedn= $this->convert($basedn);
 217
 218       $start = microtime();
 219
 220       $this->sr = @ldap_list($this->cid, $this->fix($basedn), $filter,$attrs);
 221       $this->error = @ldap_error($this->cid);
 222       $this->resetResult();
 223       $this->hasres=true;
 224
 225        /* Check if query took longer as specified in max_ldap_query_time */
 226       if($this->max_ldap_query_time){
 227         $diff = get_MicroTimeDiff($start,microtime());
 228         if($diff > $this->max_ldap_query_time){
 229           print_red(sprintf(_("The ldapserver is answering very slow (%.2f), this may be responsible for performance breakdowns."),$diff)) ;
 230         }
 231       }
 232
 233       $this->log("LDAP operation: time=".get_MicroTimeDiff($start,microtime())." operation=ls('".$this->fix($basedn)."', '$filter')");
 234
 235       return($this->sr);
 236     }else{
 237       $this->error = "Could not connect to LDAP server";
 238       return("");
 239     }
 240   }
 241
 242   function cat($dn,$attrs= array("*"))
 243   {
 244     if($this->hascon){
 245       if ($this->reconnect) $this->connect();
 246       $this->clearResult();
 247       $filter = "(objectclass=*)";
 248       $this->sr = @ldap_read($this->cid, $this->fix($dn), $filter,$attrs);
 249       $this->error = @ldap_error($this->cid);
 250       $this->resetResult();
 251       $this->hasres=true;
 252       return($this->sr);
 253     }else{
 254       $this->error = "Could not connect to LDAP server";
 255       return("");
 256     }
 257   }
 258
 259   function set_size_limit($size)
 260   {
 261     /* Ignore zero settings */
 262     if ($size == 0){
 263       @ldap_set_option($this->cid, LDAP_OPT_SIZELIMIT, 10000000);
 264     }
 265     if($this->hascon){
 266       @ldap_set_option($this->cid, LDAP_OPT_SIZELIMIT, $size);
 267     } else {
 268       $this->error = "Could not connect to LDAP server";
 269     }
 270   }
 271
 272   function fetch()
 273   {
 274     $att= array();
 275     if($this->hascon){
 276       if($this->hasres){
 277         if ($this->start == 0)
 278         {
 279           $this->start = 1;
 280           $this->re= @ldap_first_entry($this->cid, $this->sr);
 281         } else {
 282           $this->re= @ldap_next_entry($this->cid, $this->re);
 283         }
 284         if ($this->re)
 285         {
 286           $att= @ldap_get_attributes($this->cid, $this->re);
 287           $att['dn']= trim($this->convert(@ldap_get_dn($this->cid, $this->re)));
 288         }
 289         $this->error = @ldap_error($this->cid);
 290         if (!isset($att)){
 291           $att= array();
 292         }
 293         return($att);
 294       }else{
 295         $this->error = "Perform a Fetch with no Search";
 296         return("");
 297       }
 298     }else{
 299       $this->error = "Could not connect to LDAP server";
 300       return("");
 301     }
 302   }
 303
 304   function resetResult()
 305   {
 306     $this->start = 0;
 307   }
 308
 309   function clearResult()
 310   {
 311     if($this->hasres){
 312       $this->hasres = false;
 313       @ldap_free_result($this->sr);
 314     }
 315   }
 316
 317   function getDN()
 318   {
 319     if($this->hascon){
 320       if($this->hasres){
 321
 322         if(!$this->re)
 323           {
 324           $this->error = "Perform a Fetch with no valid Result";
 325           }
 326           else
 327           {
 328           $rv = @ldap_get_dn($this->cid, $this->re);
 329
 330           $this->error = @ldap_error($this->cid);
 331           return(trim($this->convert($rv)));
 332            }
 333       }else{
 334         $this->error = "Perform a Fetch with no Search";
 335         return("");
 336       }
 337     }else{
 338       $this->error = "Could not connect to LDAP server";
 339       return("");
 340     }
 341   }
 342
 343   function count()
 344   {
 345     if($this->hascon){
 346       if($this->hasres){
 347         $rv = @ldap_count_entries($this->cid, $this->sr);
 348         $this->error = @ldap_error($this->cid);
 349         return($rv);
 350       }else{
 351         $this->error = "Perform a Fetch with no Search";
 352         return("");
 353       }
 354     }else{
 355       $this->error = "Could not connect to LDAP server";
 356       return("");
 357     }
 358   }
 359
 360   function rm($attrs = "", $dn = "")
 361   {
 362     if($this->hascon){
 363       if ($this->reconnect) $this->connect();
 364       if ($dn == "")
 365         $dn = $this->basedn;
 366
 367       $r = @ldap_mod_del($this->cid, $this->fix($dn), $attrs);
 368       $this->error = @ldap_error($this->cid);
 369       return($r);
 370     }else{
 371       $this->error = "Could not connect to LDAP server";
 372       return("");
 373     }
 374   }
 375
 376   function rename($attrs, $dn = "")
 377   {
 378     if($this->hascon){
 379       if ($this->reconnect) $this->connect();
 380       if ($dn == "")
 381         $dn = $this->basedn;
 382
 383       $r = @ldap_mod_replace($this->cid, $this->fix($dn), $attrs);
 384       $this->error = @ldap_error($this->cid);
 385       return($r);
 386     }else{
 387       $this->error = "Could not connect to LDAP server";
 388       return("");
 389     }
 390   }
 391
 392   function rmdir($deletedn)
 393   {
 394     if($this->hascon){
 395       if ($this->reconnect) $this->connect();
 396       $r = @ldap_delete($this->cid, $this->fix($deletedn));
 397       $this->error = @ldap_error($this->cid);
 398       return($r ? $r : 0);
 399     }else{
 400       $this->error = "Could not connect to LDAP server";
 401       return("");
 402     }
 403   }
 404
 405   /**
 406   *  Function rmdir_recursive
 407   *
 408   *  Description: Based in recursive_remove, adding two thing: full subtree remove, and delete own node.
 409   *  Parameters:  The dn to delete
 410   *  GiveBack:    True on sucessfull , 0 in error, and "" when we don't get a ldap conection
 411   *
 412   */
 413
 414   function rmdir_recursive($deletedn)
 415   {
 416     if($this->hascon){
 417       if ($this->reconnect) $this->connect();
 418       $delarray= array();
 419
 420       /* Get sorted list of dn's to delete */
 421       $this->ls ("(objectClass=*)",$deletedn);
 422       while ($this->fetch()){
 423         $deldn= $this->getDN();
 424         $delarray[$deldn]= strlen($deldn);
 425       }
 426       arsort ($delarray);
 427       reset ($delarray);
 428
 429       /* Really Delete ALL dn's in subtree */
 430       foreach ($delarray as $key => $value){
 431         $this->rmdir_recursive($key);
 432       }
 433
 434       /* Finally Delete own Node */
 435       $r = @ldap_delete($this->cid, $this->fix($deletedn));
 436       $this->error = @ldap_error($this->cid);
 437       return($r ? $r : 0);
 438     }else{
 439       $this->error = "Could not connect to LDAP server";
 440       return("");
 441     }
 442   }
 443
 444   /* Copy given attributes and sub-dns with attributes to destination dn
 445   */
 446   function copy_FAI_resource_recursive($sourcedn,$destinationdn,$destinationName,$type="branch",$is_first = true,$depth=0)
 447   {
 448     error_reporting(E_ALL);
 449
 450     if($is_first){
 451       echo "<h2>".sprintf(_("Creating copy of %s"),"<i>".@LDAP::fix($sourcedn)."</i>")."</h2>";
 452     }else{
 453       if(preg_match("/^ou=/",$sourcedn)){
 454         echo "<h3>"._("Processing")." <i>".@LDAP::fix($destinationdn)."</i></h3>";
 455       }else{
 456         $tmp = split(",",$sourcedn);
 457
 458         echo "&nbsp;<b>"._("Object").":</b> ";
 459
 460         $deststr = @LDAP::fix($destinationdn);
 461         if(strlen($deststr) > 96){
 462           $deststr = substr($deststr,0,96)."...";
 463         }
 464
 465         echo $deststr."<br>";
 466       }
 467     }
 468
 469     flush();
 470
 471     if($this->hascon){
 472       if ($this->reconnect) $this->connect();
 473
 474       /* Save base dn */
 475       $basedn= $this->basedn;
 476       $delarray= array();
 477
 478       /* Check if destination entry already exists */
 479       $this->cat($destinationdn);
 480
 481       if($this->count()){
 482         return;
 483       }else{
 484
 485         $this->clearResult();
 486
 487         /* Get source entry */
 488         $this->cd($basedn);
 489         $this->cat($sourcedn);
 490         $attr = $this->fetch();
 491
 492         /* Error while fetching object / attribute abort*/
 493         if((!$attr) || (count($attr)) ==0) {
 494           echo _("Error while fetching source dn - aborted!");
 495           return;
 496         }
 497
 498         /* check if this is a department */
 499         if(in_array("organizationalUnit",$attr['objectClass'])){
 500           $attr['dn'] = $this->convert($destinationdn);
 501           $this->cd($basedn);
 502           $this->create_missing_trees($destinationdn);
 503           $this->cd($destinationdn);
 504
 505           /* If is first entry, append FAIbranch to department entry */
 506           if($is_first){
 507             $this->cat($destinationdn);
 508             $attr= $this->fetch();
 509
 510             /* Filter unneeded informations */
 511             foreach($attr as $key => $value){
 512               if(is_numeric($key)) unset($attr[$key]);
 513               if(isset($attr[$key]['count'])){
 514                 if(is_array($attr[$key])){
 515                   unset($attr[$key]['count']);
 516                 }
 517               }
 518             }
 519
 520             unset($attr['count']);
 521             unset($attr['dn']);
 522
 523             /* Add marking attribute */
 524             $attr['objectClass'][] = "FAIbranch";
 525
 526             /* Add this entry */
 527             $this->modify($attr);
 528           }
 529         }else{
 530
 531           /* If this is no department */
 532           foreach($attr as $key => $value){
 533             if(in_array($key ,array("FAItemplateFile","FAIscript", "gotoLogonScript", "gosaApplicationIcon","gotoMimeIcon"))){
 534               $sr= ldap_read($this->cid, $this->fix($sourcedn), "$key=*", array($key));
 535               $ei= ldap_first_entry($this->cid, $sr);
 536               if ($tmp= @ldap_get_values_len($this->cid, $ei,$key)){
 537                 $attr[$key] = $tmp;
 538               }
 539             }
 540
 541             if(is_numeric($key)) unset($attr[$key]);
 542             if(isset($attr[$key]['count'])){
 543               if(is_array($attr[$key])){
 544                 unset($attr[$key]['count']);
 545               }
 546             }
 547           }
 548           unset($attr['count']);
 549           unset($attr['dn']);
 550
 551           if((!in_array("gosaApplication" , $attr['objectClass'])) && (!in_array("gotoMimeType", $attr['objectClass']))){
 552             $attr['FAIdebianRelease'] = $destinationName;
 553             if($type=="branch"){
 554               $attr['FAIstate'] ="branch";
 555             }elseif($type=="freeze"){
 556               $attr['FAIstate'] ="freeze";
 557             }else{
 558               print_red(_("Unknown FAIstate %s"),$type);
 559             }
 560           }
 561
 562           /* Replace FAIdebianRelease with new release name */
 563           if(in_array("FAIpackageList" , $attr['objectClass'])){
 564             $attr['FAIdebianRelease'] = $destinationName;
 565           }
 566
 567           /* Add entry */
 568           $this->cd($destinationdn);
 569           $this->cat($destinationdn);
 570           $a = $this->fetch();
 571           if(!count($a)){
 572             $this->add($attr);
 573           }
 574
 575           if($this->error != "Success"){
 576             /* Some error occured */
 577             print "---------------------------------------------";
 578             print $this->get_error()."<br>";
 579             print $sourcedn."<br>";
 580             print $destinationdn."<br>";
 581             print_a( $attr);
 582             exit();
 583           }
 584         }
 585       }
 586
 587       echo "<script language=\"javascript\" type=\"text/javascript\">scrollDown2();</script>" ;
 588
 589       $this->ls ("(objectClass=*)",$sourcedn);
 590       while ($this->fetch()){
 591         $deldn= $this->getDN();
 592         $delarray[$deldn]= strlen($deldn);
 593       }
 594       asort ($delarray);
 595       reset ($delarray);
 596
 597        $depth ++;
 598       foreach($delarray as $dn => $bla){
 599         if($dn != $destinationdn){
 600           $this->cd($basedn);
 601           $item = $this->fetch($this->cat($dn));
 602           if(!in_array("FAIbranch",$item['objectClass'])){
 603             $this->copy_FAI_resource_recursive($dn,str_replace($sourcedn,$destinationdn,$dn),$destinationName,$type,false,$depth);
 604           }
 605         }
 606       }
 607     }
 608     if($is_first){
 609       echo "<p class='seperator'>&nbsp;</p>";
 610     }
 611
 612   }
 613
 614   function modify($attrs)
 615   {
 616     if(count($attrs) == 0){
 617       return (0);
 618     }
 619     if($this->hascon){
 620       if ($this->reconnect) $this->connect();
 621       $r = @ldap_modify($this->cid, $this->fix($this->basedn), $attrs);
 622       $this->error = @ldap_error($this->cid);
 623       return($r ? $r : 0);
 624     }else{
 625       $this->error = "Could not connect to LDAP server";
 626       return("");
 627     }
 628   }
 629
 630   function add($attrs)
 631   {
 632     if($this->hascon){
 633       if ($this->reconnect) $this->connect();
 634       $r = @ldap_add($this->cid, $this->fix($this->basedn), $attrs);
 635       $this->error = @ldap_error($this->cid);
 636       return($r ? $r : 0);
 637     }else{
 638       $this->error = "Could not connect to LDAP server";
 639       return("");
 640     }
 641   }
 642
 643   function create_missing_trees($target)
 644   {
 645     global $config;
 646
 647     $real_path= substr($target, 0, strlen($target) - strlen($this->basedn) -1 );
 648
 649     if ($target == $this->basedn){
 650       $l= array("dummy");
 651     } else {
 652       $l= array_reverse(gosa_ldap_explode_dn($real_path));
 653     }
 654     unset($l['count']);
 655     $cdn= $this->basedn;
 656     $tag= "";
 657
 658     /* Load schema if available... */
 659     $classes= $this->get_objectclasses();
 660
 661     foreach ($l as $part){
 662       if ($part != "dummy"){
 663         $cdn= "$part,$cdn";
 664       }
 665
 666       /* Ignore referrals */
 667       $found= false;
 668       foreach($this->referrals as $ref){
 669         $base= preg_replace('!^[^:]+://[^/]+/([^?]+).*$!', '\\1', $ref['URL']);
 670         if ($base == $cdn){
 671           $found= true;
 672           break;
 673         }
 674       }
 675       if ($found){
 676         continue;
 677       }
 678
 679       $this->cat ($cdn);
 680       $attrs= $this->fetch();
 681
 682       /* Create missing entry? */
 683       if (count ($attrs)){
 684
 685         /* Catch the tag - if present */
 686         if (isset($attrs['gosaUnitTag'][0])){
 687           $tag= $attrs['gosaUnitTag'][0];
 688         }
 689
 690       } else {
 691         $type= preg_replace('/^([^=]+)=.*$/', '\\1', $cdn);
 692         $param= preg_replace('/^[^=]+=([^,]+),.*$/', '\\1', $cdn);
 693
 694         $na= array();
 695
 696         /* Automatic or traditional? */
 697         if(count($classes)){
 698
 699           /* Get name of first matching objectClass */
 700           $ocname= "";
 701           foreach($classes as $class){
 702             if (isset($class['MUST']) && $class['MUST'] == "$type"){
 703
 704               /* Look for first classes that is structural... */
 705               if (isset($class['STRUCTURAL'])){
 706                 $ocname= $class['NAME'];
 707                 break;
 708               }
 709
 710               /* Look for classes that are auxiliary... */
 711               if (isset($class['AUXILIARY'])){
 712                 $ocname= $class['NAME'];
 713               }
 714             }
 715           }
 716
 717           /* Bail out, if we've nothing to do... */
 718           if ($ocname == ""){
 719             print_red(sprintf(_("Autocreation of subtree failed. No objectClass found for attribute '%s'."), $type));
 720             echo $_SESSION['errors'];
 721             exit;
 722           }
 723
 724           /* Assemble_entry */
 725           if ($tag != ""){
 726             $na['objectClass']= array($ocname, "gosaAdministrativeUnitTag");
 727           } else {
 728             $na['objectClass']= array($ocname);
 729           }
 730           if (isset($classes[$ocname]['AUXILIARY'])){
 731             $na['objectClass'][]= $classes[$ocname]['SUP'];
 732           }
 733           if ($type == "dc"){
 734             /* This is bad actually, but - tell me a better way? */
 735             $na['objectClass'][]= 'locality';
 736           }
 737           $na[$type]= $param;
 738           if (is_array($classes[$ocname]['MUST'])){
 739             foreach($classes[$ocname]['MUST'] as $attr){
 740               $na[$attr]= "filled";
 741             }
 742           }
 743
 744         } else {
 745
 746           /* Use alternative add... */
 747           switch ($type){
 748             case 'ou':
 749               if ($tag != ""){
 750                 $na["objectClass"]= array("organizationalUnit", "gosaAdministrativeUnitTag");
 751                 $na["gosaUnitTag"]= $tag;
 752               } else {
 753                 $na["objectClass"]= "organizationalUnit";
 754               }
 755               $na["ou"]= $param;
 756               break;
 757             case 'dc':
 758               if ($tag != ""){
 759                 $na["objectClass"]= array("dcObject", "top", "locality", "gosaAdministrativeUnitTag");
 760                 $na["gosaUnitTag"]= $tag;
 761               } else {
 762                 $na["objectClass"]= array("dcObject", "top", "locality");
 763               }
 764               $na["dc"]= $param;
 765               break;
 766             default:
 767               print_red(sprintf(_("Autocreation of type '%s' is currently not supported. Please report to the GOsa team."), $type));
 768               echo $_SESSION['errors'];
 769               exit;
 770           }
 771
 772         }
 773         $this->cd($cdn);
 774         $this->add($na);
 775         show_ldap_error($this->get_error(), sprintf(_("Creating subtree '%s' failed."),$cdn));
 776         if (!preg_match('/success/i', $this->error)){
 777           return FALSE;
 778         }
 779       }
 780     }
 781
 782     return TRUE;
 783   }
 784
 785
 786   function recursive_remove()
 787   {
 788     $delarray= array();
 789
 790     /* Get sorted list of dn's to delete */
 791     $this->search ("(objectClass=*)");
 792     while ($this->fetch()){
 793       $deldn= $this->getDN();
 794       $delarray[$deldn]= strlen($deldn);
 795     }
 796     arsort ($delarray);
 797     reset ($delarray);
 798
 799     /* Delete all dn's in subtree */
 800     foreach ($delarray as $key => $value){
 801       $this->rmdir($key);
 802     }
 803   }
 804
 805   function get_attribute($dn, $name,$r_array=0)
 806   {
 807     $data= "";
 808     if ($this->reconnect) $this->connect();
 809     $sr= @ldap_read($this->cid, $this->fix($dn), "objectClass=*", array("$name"));
 810
 811     /* fill data from LDAP */
 812     if ($sr) {
 813       $ei= @ldap_first_entry($this->cid, $sr);
 814       if ($ei) {
 815         if ($info= @ldap_get_values_len($this->cid, $ei, "$name")){
 816           $data= $info[0];
 817         }
 818
 819       }
 820     }
 821     if($r_array==0)
 822     return ($data);
 823     else
 824     return ($info);
 825
 826
 827   }
 828
 829
 830
 831   function get_additional_error()
 832   {
 833     $error= "";
 834     @ldap_get_option ($this->cid, LDAP_OPT_ERROR_STRING, $error);
 835     return ($error);
 836   }
 837
 838   function get_error()
 839   {
 840     if ($this->error == 'Success'){
 841       return $this->error;
 842     } else {
 843       $adderror= $this->get_additional_error();
 844       if ($adderror != ""){
 845         $error= $this->error." (".$this->get_additional_error().", ".sprintf(_("while operating on '%s' using LDAP server '%s'"), $this->basedn, $this->hostname).")";
 846       } else {
 847         $error= $this->error." (".sprintf(_("while operating on LDAP server %s"), $this->hostname).")";
 848       }
 849       return $error;
 850     }
 851   }
 852
 853   function get_credentials($url, $referrals= NULL)
 854   {
 855     $ret= array();
 856     $url= preg_replace('!\?\?.*$!', '', $url);
 857     $server= preg_replace('!^([^:]+://[^/]+)/.*$!', '\\1', $url);
 858
 859     if ($referrals == NULL){
 860       $referrals= $this->referrals;
 861     }
 862
 863     if (isset($referrals[$server])){
 864       return ($referrals[$server]);
 865     } else {
 866       $ret['ADMIN']= $this->fix($this->binddn);
 867       $ret['PASSWORD']= $this->bindpw;
 868     }
 869
 870     return ($ret);
 871   }
 872
 873
 874   function gen_ldif ($dn, $filter= "(objectClass=*)", $attributes= array('*'), $recursive= TRUE)
 875   {
 876     $display= "";
 877
 878     if ($recursive){
 879       $this->cd($dn);
 880       $this->ls($filter,$dn, array('dn','objectClass'));
 881       $deps = array();
 882
 883       $display .= $this->gen_one_entry($dn)."\n";
 884
 885       while ($attrs= $this->fetch()){
 886         $deps[] = $attrs['dn'];
 887       }
 888       foreach($deps as $dn){
 889         $display .= $this->gen_ldif($dn, $filter,$attributes,$recursive);
 890       }
 891     } else {
 892       $display.= $this->gen_one_entry($dn);
 893     }
 894     return ($display);
 895   }
 896
 897
 898   function gen_xls ($dn, $filter= "(objectClass=*)", $attributes= array('*'), $recursive= TRUE,$r_array=0)
 899   {
 900     $display= array();
 901
 902       $this->cd($dn);
 903       $this->search("$filter");
 904
 905       $i=0;
 906       while ($attrs= $this->fetch()){
 907         $j=0;
 908
 909         foreach ($attributes as $at){
 910           $display[$i][$j]= $this->get_attribute($attrs['dn'], $at,$r_array);
 911           $j++;
 912         }
 913
 914         $i++;
 915       }
 916
 917     return ($display);
 918   }
 919
 920
 921   function gen_one_entry($dn, $filter= "(objectClass=*)" , $name= array("*"))
 922   {
 923     $ret = "";
 924     $data = "";
 925     if($this->reconnect){
 926       $this->connect();
 927     }
 928
 929     /* Searching Ldap Tree */
 930     $sr= @ldap_read($this->cid, $this->fix($dn), $filter, $name);
 931
 932     /* Get the first entry */
 933     $entry= @ldap_first_entry($this->cid, $sr);
 934
 935     /* Get all attributes related to that Objekt */
 936     $atts = array();
 937
 938     /* Assemble dn */
 939     $atts[0]['name']  = "dn";
 940     $atts[0]['value'] = array('count' => 1, 0 => $dn);
 941
 942     /* Reset index */
 943     $i = 1 ;
 944   $identifier = array();
 945     $attribute= @ldap_first_attribute($this->cid,$entry,$identifier);
 946     while ($attribute) {
 947       $i++;
 948       $atts[$i]['name']  = $attribute;
 949       $atts[$i]['value'] = @ldap_get_values_len($this->cid, $entry, "$attribute");
 950
 951       /* Next one */
 952       $attribute= @ldap_next_attribute($this->cid,$entry,$identifier);
 953     }
 954
 955     foreach($atts as $at)
 956     {
 957       for ($i= 0; $i<$at['value']['count']; $i++){
 958
 959         /* Check if we must encode the data */
 960         if(!preg_match('/^[a-z0-9+@#.=, \/ -]+$/i', $at['value'][$i])) {
 961           $ret .= $at['name'].":: ".base64_encode($at['value'][$i])."\n";
 962         } else {
 963           $ret .= $at['name'].": ".$at['value'][$i]."\n";
 964         }
 965       }
 966     }
 967
 968     return($ret);
 969   }
 970
 971
 972   function dn_exists($dn)
 973   {
 974     return @ldap_list($this->cid, $this->fix($dn), "(objectClass=*)", array("objectClass"));
 975   }
 976
 977
 978
 979   /*  This funktion imports ldifs
 980
 981       If DeleteOldEntries is true, the destination entry will be deleted first.
 982       If JustModify is true the destination entry will only be touched by the attributes specified in the ldif.
 983       if JustMofify id false the destination dn will be overwritten by the new ldif.
 984     */
 985
 986   function import_complete_ldif($str_attr,&$error,$JustModify,$DeleteOldEntries)
 987   {
 988     if($this->reconnect) $this->connect();
 989
 990     /* First we have to splitt the string ito detect empty lines
 991        An empty line indicates an new Entry */
 992     $entries = split("\n",$str_attr);
 993
 994     $data = "";
 995     $cnt = 0;
 996     $current_line = 0;
 997
 998     /* FIX ldif */
 999     $last = "";
1000     $tmp  = "";
1001     $i = 0;
1002     foreach($entries as $entry){
1003       if(preg_match("/^ /",$entry)){
1004         $tmp[$i] .= trim($entry);
1005       }else{
1006         $i ++;
1007         $tmp[$i] = trim($entry);
1008       }
1009     }
1010
1011     /* Every single line ... */
1012     foreach($tmp as $entry) {
1013       $current_line ++;
1014
1015       /* Removing Spaces to ..
1016          .. test if a new entry begins */
1017       $tmp  = str_replace(" ","",$data );
1018
1019       /* .. prevent empty lines in an entry */
1020       $tmp2 = str_replace(" ","",$entry);
1021
1022       /* If the Block ends (Empty Line) */
1023       if((empty($entry))&&(!empty($tmp))) {
1024         /* Add collected lines as a complete block */
1025         $all[$cnt] = $data;
1026         $cnt ++;
1027         $data ="";
1028       } else {
1029
1030         /* Append lines ... */
1031         if(!empty($tmp2)) {
1032           /* check if we need base64_decode for this line */
1033           if(ereg("::",$tmp2))
1034           {
1035             $encoded = split("::",$entry);
1036             $attr  = trim($encoded[0]);
1037             $value = base64_decode(trim($encoded[1]));
1038             /* Add linenumber */
1039             $data .= $current_line."#".base64_encode($attr.":".$value)."\n";
1040           }
1041           else
1042           {
1043             /* Add Linenumber */
1044             $data .= $current_line."#".base64_encode($entry)."\n";
1045           }
1046         }
1047       }
1048     }
1049
1050     /* The Data we collected is not in the array all[];
1051        For example the Data is stored like this..
1052
1053        all[0] = "1#dn : .... \n
1054        2#ObjectType: person \n ...."
1055
1056        Now we check every insertblock and try to insert */
1057     foreach ( $all as $single) {
1058       $lineone = split("\n",$single);
1059       $ndn = split("#", $lineone[0]);
1060       $line = base64_decode($ndn[1]);
1061
1062       $dnn = split (":",$line,2);
1063       $current_line = $ndn[0];
1064       $dn    = $dnn[0];
1065       $value = $dnn[1];
1066
1067       /* Every block must begin with a dn */
1068       if($dn != "dn") {
1069         $error= sprintf(_("This is not a valid DN: '%s'. A block for import should begin with 'dn: ...' in line %s"), $line, $current_line);
1070         return -2;
1071       }
1072
1073       /* Should we use Modify instead of Add */
1074       $usemodify= false;
1075
1076       /* Delete before insert */
1077       $usermdir= false;
1078
1079       /* The dn address already exists, Don't delete destination entry, overwrite it */
1080       if (($this->dn_exists($value))&&((!$JustModify)&&(!$DeleteOldEntries))) {
1081
1082         $usermdir = $usemodify = false;
1083
1084       /* Delete old entry first, then add new */
1085       } elseif(($this->dn_exists($value))&&($DeleteOldEntries)){
1086
1087         /* Delete first, then add */
1088         $usermdir = true;
1089
1090       } elseif(($this->dn_exists($value))&&($JustModify)) {
1091
1092         /* Modify instead of Add */
1093         $usemodify = true;
1094       }
1095
1096       /* If we can't Import, return with a file error */
1097       if(!$this->import_single_entry($single,$usemodify,$usermdir) ) {
1098         $error= sprintf(_("Error while importing dn: '%s', please check your LDIF from line %s on!"), $line,
1099                         $current_line);
1100         return UNKNOWN_TOKEN_IN_LDIF_FILE;      }
1101     }
1102
1103     return (INSERT_OK);
1104   }
1105
1106
1107   /* Imports a single entry
1108       If $delete is true;  The old entry will be deleted if it exists.
1109       if $modify is true;  All variables that are not touched by the new ldif will be kept.
1110       if $modify is false; The new ldif overwrites the old entry, and all untouched attributes get lost.
1111   */
1112   function import_single_entry($str_attr,$modify,$delete)
1113   {
1114     if($this->reconnect) $this->connect();
1115
1116     $ret = false;
1117     $rows= split("\n",$str_attr);
1118     $data= false;
1119
1120     foreach($rows as $row) {
1121
1122       /* Check if we use Linenumbers (when import_complete_ldif is called we use
1123          Linenumbers) Linenumbers are use like this 123#attribute : value */
1124       if(!empty($row)) {
1125         if(strpos($row,"#")!=FALSE) {
1126
1127           /* We are using line numbers
1128              Because there is a # before a : */
1129           $tmp1= split("#",$row);
1130           $current_line= $tmp1[0];
1131           $row= base64_decode($tmp1[1]);
1132         }
1133
1134         /* Split the line into  attribute  and value */
1135         $attr   = split(":", $row,2);
1136         $attr[0]= trim($attr[0]);  /* attribute */
1137         $attr[1]= $attr[1];  /* value */
1138
1139         /* Check :: was used to indicate base64_encoded strings */
1140         if($attr[1][0] == ":"){
1141           $attr[1]=trim(preg_replace("/^:/","",$attr[1]));
1142           $attr[1]=base64_decode($attr[1]);
1143         }
1144
1145         $attr[1] = trim($attr[1]);
1146
1147         /* Check for attributes that are used more than once */
1148         if(!isset($data[$attr[0]])) {
1149           $data[$attr[0]]=$attr[1];
1150         } else {
1151           $tmp = $data[$attr[0]];
1152
1153           if(!is_array($tmp)) {
1154             $new[0]=$tmp;
1155             $new[1]=$attr[1];
1156             $datas[$attr[0]]['count']=1;
1157             $data[$attr[0]]=$new;
1158           } else {
1159             $cnt = $datas[$attr[0]]['count'];
1160             $cnt ++;
1161             $data[$attr[0]][$cnt]=$attr[1];
1162             $datas[$attr[0]]['count'] = $cnt;
1163           }
1164         }
1165       }
1166     }
1167
1168     /* If dn is an index of data, we should try to insert the data */
1169     if(isset($data['dn'])) {
1170
1171       /* Fix dn */
1172       $tmp = gosa_ldap_explode_dn($data['dn']);
1173       unset($tmp['count']);
1174       $newdn ="";
1175       foreach($tmp as $tm){
1176         $newdn.= trim($tm).",";
1177       }
1178       $newdn = preg_replace("/,$/","",$newdn);
1179       $data['dn'] = $newdn;
1180
1181       /* Creating Entry */
1182       $this->cd($data['dn']);
1183
1184       /* Delete existing entry */
1185       if($delete){
1186         $this->rmdir_recursive($data['dn']);
1187       }
1188
1189       /* Create missing trees */
1190       $this->cd ($this->basedn);
1191       $this->create_missing_trees($data['dn']);
1192       $this->cd($data['dn']);
1193
1194       $dn = $data['dn'];
1195       unset($data['dn']);
1196
1197       if(!$modify){
1198
1199         $this->cat($dn);
1200         if($this->count()){
1201
1202           /* The destination entry exists, overwrite it with the new entry */
1203           $attrs = $this->fetch();
1204           foreach($attrs as $name => $value ){
1205             if(!is_numeric($name)){
1206               if(in_array($name,array("dn","count"))) continue;
1207               if(!isset($data[$name])){
1208                 $data[$name] = array();
1209               }
1210             }
1211           }
1212           $ret = $this->modify($data);
1213
1214         }else{
1215
1216           /* The destination entry doesn't exists, create it */
1217           $ret = $this->add($data);
1218         }
1219
1220       } else {
1221
1222         /* Keep all vars that aren't touched by this ldif */
1223         $ret = $this->modify($data);
1224       }
1225     }
1226     show_ldap_error($this->get_error(), sprintf(_("Ldap import with dn '%s' failed."),$dn));
1227     return($ret);
1228   }
1229
1230
1231   function importcsv($str)
1232   {
1233     $lines = split("\n",$str);
1234     foreach($lines as $line)
1235     {
1236       /* continue if theres a comment */
1237       if(substr(trim($line),0,1)=="#"){
1238         continue;
1239       }
1240
1241       $line= str_replace ("\t\t","\t",$line);
1242       $line= str_replace ("\t"  ,"," ,$line);
1243       echo $line;
1244
1245       $cells = split(",",$line )  ;
1246       $linet= str_replace ("\t\t",",",$line);
1247       $cells = split("\t",$line);
1248       $count = count($cells);
1249     }
1250
1251   }
1252
1253   function get_objectclasses()
1254   {
1255     $objectclasses = array();
1256
1257           # Get base to look for schema
1258           $sr = @ldap_read ($this->cid, NULL, "objectClass=*", array("subschemaSubentry"));
1259     if(!$sr){
1260             $sr = @ldap_read ($this->cid, "", "objectClass=*", array("subschemaSubentry"));
1261     }
1262
1263           $attr = @ldap_get_entries($this->cid,$sr);
1264           if (!isset($attr[0]['subschemasubentry'][0])){
1265             return array();
1266           }
1267
1268           /* Get list of objectclasses and fill array */
1269           $nb= $attr[0]['subschemasubentry'][0];
1270           $objectclasses= array();
1271           $sr= ldap_read ($this->cid, $nb, "objectClass=*", array("objectclasses"));
1272           $attrs= ldap_get_entries($this->cid,$sr);
1273           if (!isset($attrs[0])){
1274             return array();
1275           }
1276           foreach ($attrs[0]['objectclasses'] as $val){
1277       if (preg_match('/^[0-9]+$/', $val)){
1278         continue;
1279       }
1280       $name= "OID";
1281       $pattern= split(' ', $val);
1282       $ocname= preg_replace("/^.* NAME\s+\(*\s*'([^']+)'\s*\)*.*$/", '\\1', $val);
1283       $objectclasses[$ocname]= array();
1284
1285       foreach($pattern as $chunk){
1286         switch($chunk){
1287
1288           case '(':
1289                     $value= "";
1290                     break;
1291
1292           case ')': if ($name != ""){
1293                       $objectclasses[$ocname][$name]= $this->value2container($value);
1294                     }
1295                     $name= "";
1296                     $value= "";
1297                     break;
1298
1299           case 'NAME':
1300           case 'DESC':
1301           case 'SUP':
1302           case 'STRUCTURAL':
1303           case 'ABSTRACT':
1304           case 'AUXILIARY':
1305           case 'MUST':
1306           case 'MAY':
1307                     if ($name != ""){
1308                       $objectclasses[$ocname][$name]= $this->value2container($value);
1309                     }
1310                     $name= $chunk;
1311                     $value= "";
1312                     break;
1313
1314           default:  $value.= $chunk." ";
1315         }
1316       }
1317
1318           }
1319
1320           return $objectclasses;
1321   }
1322
1323
1324   function value2container($value)
1325   {
1326     /* Set emtpy values to "true" only */
1327     if (preg_match('/^\s*$/', $value)){
1328       return true;
1329     }
1330
1331     /* Remove ' and " if needed */
1332     $value= preg_replace('/^[\'"]/', '', $value);
1333     $value= preg_replace('/[\'"] *$/', '', $value);
1334
1335     /* Convert to array if $ is inside... */
1336     if (preg_match('/\$/', $value)){
1337       $container= preg_split('/\s*\$\s*/', $value);
1338     } else {
1339       $container= chop($value);
1340     }
1341
1342     return ($container);
1343   }
1344
1345
1346   function log($string)
1347   {
1348     if (isset($_SESSION['config'])){
1349       $cfg= $_SESSION['config'];
1350       if (isset($cfg->current['LDAPSTATS']) && preg_match('/true/i', $cfg->current['LDAPSTATS'])){
1351         syslog (LOG_INFO, $string);
1352       }
1353     }
1354   }
1355
1356   /* added by Guido Serra aka Zeph <zeph@purotesto.it> */
1357   function getCn($dn){
1358     $simple= split(",", $dn);
1359
1360     foreach($simple as $piece) {
1361       $partial= split("=", $piece);
1362
1363       if($partial[0] == "cn"){
1364         return $partial[1];
1365       }
1366     }
1367   }
1368
1369
1370   function get_naming_contexts($server, $admin= "", $password= "")
1371   {
1372     /* Build LDAP connection */
1373     $ds= ldap_connect ($server);
1374     if (!$ds) {
1375       die ("Can't bind to LDAP. No check possible!");
1376     }
1377     ldap_set_option($ds, LDAP_OPT_PROTOCOL_VERSION, 3);
1378     $r= ldap_bind ($ds, $admin, $password);
1379
1380     /* Get base to look for naming contexts */
1381     $sr  = @ldap_read ($ds, "", "objectClass=*", array("+"));
1382     $attr= @ldap_get_entries($ds,$sr);
1383
1384     return ($attr[0]['namingcontexts']);
1385   }
1386
1387
1388   function get_root_dse($server, $admin= "", $password= "")
1389   {
1390     /* Build LDAP connection */
1391     $ds= ldap_connect ($server);
1392     if (!$ds) {
1393       die ("Can't bind to LDAP. No check possible!");
1394     }
1395     ldap_set_option($ds, LDAP_OPT_PROTOCOL_VERSION, 3);
1396     $r= ldap_bind ($ds, $admin, $password);
1397
1398     /* Get base to look for naming contexts */
1399     $sr  = @ldap_read ($ds, "", "objectClass=*", array("+"));
1400     $attr= @ldap_get_entries($ds,$sr);
1401
1402     /* Return empty array, if nothing was set */
1403     if (!isset($attr[0])){
1404       return array();
1405     }
1406
1407     /* Rework array... */
1408     $result= array();
1409     for ($i= 0; $i<$attr[0]['count']; $i++){
1410       $result[$attr[0][$i]]= $attr[0][$attr[0][$i]];
1411       unset($result[$attr[0][$i]]['count']);
1412     }
1413
1414     return ($result);
1415   }
1416
1417
1418 }
1419
1420 // vim:tabstop=2:expandtab:shiftwidth=2:filetype=php:syntax:ruler:
1421 ?>