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     /* Ignore create_missing trees if the base equals target */
 648     if ($target == $this->basedn){
 649      return;
 650     }
 651
 652     $real_path= substr($target, 0, strlen($target) - strlen($this->basedn) -1 );
 653     $l= array_reverse(gosa_ldap_explode_dn($real_path));
 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       $cdn= "$part,$cdn";
 663
 664       /* Ignore referrals */
 665       $found= false;
 666       foreach($this->referrals as $ref){
 667         $base= preg_replace('!^[^:]+://[^/]+/([^?]+).*$!', '\\1', $ref['URL']);
 668         if ($base == $cdn){
 669           $found= true;
 670           break;
 671         }
 672       }
 673       if ($found){
 674         continue;
 675       }
 676
 677       $this->cat ($cdn);
 678       $attrs= $this->fetch();
 679
 680       /* Create missing entry? */
 681       if (count ($attrs)){
 682
 683         /* Catch the tag - if present */
 684         if (isset($attrs['gosaUnitTag'][0])){
 685           $tag= $attrs['gosaUnitTag'][0];
 686         }
 687
 688       } else {
 689         $type= preg_replace('/^([^=]+)=.*$/', '\\1', $cdn);
 690         $param= preg_replace('/^[^=]+=([^,]+),.*$/', '\\1', $cdn);
 691
 692         $na= array();
 693
 694         /* Automatic or traditional? */
 695         if(count($classes)){
 696
 697           /* Get name of first matching objectClass */
 698           $ocname= "";
 699           foreach($classes as $class){
 700             if (isset($class['MUST']) && $class['MUST'] == "$type"){
 701
 702               /* Look for first classes that is structural... */
 703               if (isset($class['STRUCTURAL'])){
 704                 $ocname= $class['NAME'];
 705                 break;
 706               }
 707
 708               /* Look for classes that are auxiliary... */
 709               if (isset($class['AUXILIARY'])){
 710                 $ocname= $class['NAME'];
 711               }
 712             }
 713           }
 714
 715           /* Bail out, if we've nothing to do... */
 716           if ($ocname == ""){
 717             print_red(sprintf(_("Autocreation of subtree failed. No objectClass found for attribute '%s'."), $type));
 718             echo $_SESSION['errors'];
 719             exit;
 720           }
 721
 722           /* Assemble_entry */
 723           if ($tag != ""){
 724             $na['objectClass']= array($ocname, "gosaAdministrativeUnitTag");
 725           } else {
 726             $na['objectClass']= array($ocname);
 727           }
 728           if (isset($classes[$ocname]['AUXILIARY'])){
 729             $na['objectClass'][]= $classes[$ocname]['SUP'];
 730           }
 731           if ($type == "dc"){
 732             /* This is bad actually, but - tell me a better way? */
 733             $na['objectClass'][]= 'locality';
 734           }
 735           $na[$type]= $param;
 736           if (is_array($classes[$ocname]['MUST'])){
 737             foreach($classes[$ocname]['MUST'] as $attr){
 738               $na[$attr]= "filled";
 739             }
 740           }
 741
 742         } else {
 743
 744           /* Use alternative add... */
 745           switch ($type){
 746             case 'ou':
 747               if ($tag != ""){
 748                 $na["objectClass"]= array("organizationalUnit", "gosaAdministrativeUnitTag");
 749                 $na["gosaUnitTag"]= $tag;
 750               } else {
 751                 $na["objectClass"]= "organizationalUnit";
 752               }
 753               $na["ou"]= $param;
 754               break;
 755             case 'dc':
 756               if ($tag != ""){
 757                 $na["objectClass"]= array("dcObject", "top", "locality", "gosaAdministrativeUnitTag");
 758                 $na["gosaUnitTag"]= $tag;
 759               } else {
 760                 $na["objectClass"]= array("dcObject", "top", "locality");
 761               }
 762               $na["dc"]= $param;
 763               break;
 764             default:
 765               print_red(sprintf(_("Autocreation of type '%s' is currently not supported. Please report to the GOsa team."), $type));
 766               echo $_SESSION['errors'];
 767               exit;
 768           }
 769
 770         }
 771         $this->cd($cdn);
 772         $this->add($na);
 773         show_ldap_error($this->get_error(), sprintf(_("Creating subtree '%s' failed."),$cdn));
 774       }
 775     }
 776   }
 777
 778
 779   function recursive_remove()
 780   {
 781     $delarray= array();
 782
 783     /* Get sorted list of dn's to delete */
 784     $this->search ("(objectClass=*)");
 785     while ($this->fetch()){
 786       $deldn= $this->getDN();
 787       $delarray[$deldn]= strlen($deldn);
 788     }
 789     arsort ($delarray);
 790     reset ($delarray);
 791
 792     /* Delete all dn's in subtree */
 793     foreach ($delarray as $key => $value){
 794       $this->rmdir($key);
 795     }
 796   }
 797
 798   function get_attribute($dn, $name,$r_array=0)
 799   {
 800     $data= "";
 801     if ($this->reconnect) $this->connect();
 802     $sr= @ldap_read($this->cid, $this->fix($dn), "objectClass=*", array("$name"));
 803
 804     /* fill data from LDAP */
 805     if ($sr) {
 806       $ei= @ldap_first_entry($this->cid, $sr);
 807       if ($ei) {
 808         if ($info= @ldap_get_values_len($this->cid, $ei, "$name")){
 809           $data= $info[0];
 810         }
 811
 812       }
 813     }
 814     if($r_array==0)
 815     return ($data);
 816     else
 817     return ($info);
 818
 819
 820   }
 821
 822
 823
 824   function get_additional_error()
 825   {
 826     $error= "";
 827     @ldap_get_option ($this->cid, LDAP_OPT_ERROR_STRING, $error);
 828     return ($error);
 829   }
 830
 831   function get_error()
 832   {
 833     if ($this->error == 'Success'){
 834       return $this->error;
 835     } else {
 836       $adderror= $this->get_additional_error();
 837       if ($adderror != ""){
 838         $error= $this->error." (".$this->get_additional_error().", ".sprintf(_("while operating on '%s' using LDAP server '%s'"), $this->basedn, $this->hostname).")";
 839       } else {
 840         $error= $this->error." (".sprintf(_("while operating on LDAP server %s"), $this->hostname).")";
 841       }
 842       return $error;
 843     }
 844   }
 845
 846   function get_credentials($url, $referrals= NULL)
 847   {
 848     $ret= array();
 849     $url= preg_replace('!\?\?.*$!', '', $url);
 850     $server= preg_replace('!^([^:]+://[^/]+)/.*$!', '\\1', $url);
 851
 852     if ($referrals == NULL){
 853       $referrals= $this->referrals;
 854     }
 855
 856     if (isset($referrals[$server])){
 857       return ($referrals[$server]);
 858     } else {
 859       $ret['ADMIN']= $this->fix($this->binddn);
 860       $ret['PASSWORD']= $this->bindpw;
 861     }
 862
 863     return ($ret);
 864   }
 865
 866
 867   function gen_ldif ($dn, $filter= "(objectClass=*)", $attributes= array('*'), $recursive= TRUE)
 868   {
 869     $display= "";
 870
 871     if ($recursive){
 872       $this->cd($dn);
 873       $this->ls($filter,$dn, array('dn','objectClass'));
 874       $deps = array();
 875
 876       $display .= $this->gen_one_entry($dn)."\n";
 877
 878       while ($attrs= $this->fetch()){
 879         $deps[] = $attrs['dn'];
 880       }
 881       foreach($deps as $dn){
 882         $display .= $this->gen_ldif($dn, $filter,$attributes,$recursive);
 883       }
 884     } else {
 885       $display.= $this->gen_one_entry($dn);
 886     }
 887     return ($display);
 888   }
 889
 890
 891   function gen_xls ($dn, $filter= "(objectClass=*)", $attributes= array('*'), $recursive= TRUE,$r_array=0)
 892   {
 893     $display= array();
 894
 895       $this->cd($dn);
 896       $this->search("$filter");
 897
 898       $i=0;
 899       while ($attrs= $this->fetch()){
 900         $j=0;
 901
 902         foreach ($attributes as $at){
 903           $display[$i][$j]= $this->get_attribute($attrs['dn'], $at,$r_array);
 904           $j++;
 905         }
 906
 907         $i++;
 908       }
 909
 910     return ($display);
 911   }
 912
 913
 914   function gen_one_entry($dn, $filter= "(objectClass=*)" , $name= array("*"))
 915   {
 916     $ret = "";
 917     $data = "";
 918     if($this->reconnect){
 919       $this->connect();
 920     }
 921
 922     /* Searching Ldap Tree */
 923     $sr= @ldap_read($this->cid, $this->fix($dn), $filter, $name);
 924
 925     /* Get the first entry */
 926     $entry= @ldap_first_entry($this->cid, $sr);
 927
 928     /* Get all attributes related to that Objekt */
 929     $atts = array();
 930
 931     /* Assemble dn */
 932     $atts[0]['name']  = "dn";
 933     $atts[0]['value'] = array('count' => 1, 0 => $dn);
 934
 935     /* Reset index */
 936     $i = 1 ;
 937   $identifier = array();
 938     $attribute= @ldap_first_attribute($this->cid,$entry,$identifier);
 939     while ($attribute) {
 940       $i++;
 941       $atts[$i]['name']  = $attribute;
 942       $atts[$i]['value'] = @ldap_get_values_len($this->cid, $entry, "$attribute");
 943
 944       /* Next one */
 945       $attribute= @ldap_next_attribute($this->cid,$entry,$identifier);
 946     }
 947
 948     foreach($atts as $at)
 949     {
 950       for ($i= 0; $i<$at['value']['count']; $i++){
 951
 952         /* Check if we must encode the data */
 953         if(!preg_match('/^[a-z0-9+@#.=, \/ -]+$/i', $at['value'][$i])) {
 954           $ret .= $at['name'].":: ".base64_encode($at['value'][$i])."\n";
 955         } else {
 956           $ret .= $at['name'].": ".$at['value'][$i]."\n";
 957         }
 958       }
 959     }
 960
 961     return($ret);
 962   }
 963
 964
 965   function dn_exists($dn)
 966   {
 967     return @ldap_list($this->cid, $this->fix($dn), "(objectClass=*)", array("objectClass"));
 968   }
 969
 970
 971
 972   /*  This funktion imports ldifs
 973
 974       If DeleteOldEntries is true, the destination entry will be deleted first.
 975       If JustModify is true the destination entry will only be touched by the attributes specified in the ldif.
 976       if JustMofify id false the destination dn will be overwritten by the new ldif.
 977     */
 978
 979   function import_complete_ldif($str_attr,&$error,$JustModify,$DeleteOldEntries)
 980   {
 981     if($this->reconnect) $this->connect();
 982
 983     /* First we have to splitt the string ito detect empty lines
 984        An empty line indicates an new Entry */
 985     $entries = split("\n",$str_attr);
 986
 987     $data = "";
 988     $cnt = 0;
 989     $current_line = 0;
 990
 991     /* FIX ldif */
 992     $last = "";
 993     $tmp  = "";
 994     $i = 0;
 995     foreach($entries as $entry){
 996       if(preg_match("/^ /",$entry)){
 997         $tmp[$i] .= trim($entry);
 998       }else{
 999         $i ++;
1000         $tmp[$i] = trim($entry);
1001       }
1002     }
1003
1004     /* Every single line ... */
1005     foreach($tmp as $entry) {
1006       $current_line ++;
1007
1008       /* Removing Spaces to ..
1009          .. test if a new entry begins */
1010       $tmp  = str_replace(" ","",$data );
1011
1012       /* .. prevent empty lines in an entry */
1013       $tmp2 = str_replace(" ","",$entry);
1014
1015       /* If the Block ends (Empty Line) */
1016       if((empty($entry))&&(!empty($tmp))) {
1017         /* Add collected lines as a complete block */
1018         $all[$cnt] = $data;
1019         $cnt ++;
1020         $data ="";
1021       } else {
1022
1023         /* Append lines ... */
1024         if(!empty($tmp2)) {
1025           /* check if we need base64_decode for this line */
1026           if(ereg("::",$tmp2))
1027           {
1028             $encoded = split("::",$entry);
1029             $attr  = trim($encoded[0]);
1030             $value = base64_decode(trim($encoded[1]));
1031             /* Add linenumber */
1032             $data .= $current_line."#".base64_encode($attr.":".$value)."\n";
1033           }
1034           else
1035           {
1036             /* Add Linenumber */
1037             $data .= $current_line."#".base64_encode($entry)."\n";
1038           }
1039         }
1040       }
1041     }
1042
1043     /* The Data we collected is not in the array all[];
1044        For example the Data is stored like this..
1045
1046        all[0] = "1#dn : .... \n
1047        2#ObjectType: person \n ...."
1048
1049        Now we check every insertblock and try to insert */
1050     foreach ( $all as $single) {
1051       $lineone = split("\n",$single);
1052       $ndn = split("#", $lineone[0]);
1053       $line = base64_decode($ndn[1]);
1054
1055       $dnn = split (":",$line,2);
1056       $current_line = $ndn[0];
1057       $dn    = $dnn[0];
1058       $value = $dnn[1];
1059
1060       /* Every block must begin with a dn */
1061       if($dn != "dn") {
1062         $error= sprintf(_("This is not a valid DN: '%s'. A block for import should begin with 'dn: ...' in line %s"), $line, $current_line);
1063         return -2;
1064       }
1065
1066       /* Should we use Modify instead of Add */
1067       $usemodify= false;
1068
1069       /* Delete before insert */
1070       $usermdir= false;
1071
1072       /* The dn address already exists, Don't delete destination entry, overwrite it */
1073       if (($this->dn_exists($value))&&((!$JustModify)&&(!$DeleteOldEntries))) {
1074
1075         $usermdir = $usemodify = false;
1076
1077       /* Delete old entry first, then add new */
1078       } elseif(($this->dn_exists($value))&&($DeleteOldEntries)){
1079
1080         /* Delete first, then add */
1081         $usermdir = true;
1082
1083       } elseif(($this->dn_exists($value))&&($JustModify)) {
1084
1085         /* Modify instead of Add */
1086         $usemodify = true;
1087       }
1088
1089       /* If we can't Import, return with a file error */
1090       if(!$this->import_single_entry($single,$usemodify,$usermdir) ) {
1091         $error= sprintf(_("Error while importing dn: '%s', please check your LDIF from line %s on!"), $line,
1092                         $current_line);
1093         return UNKNOWN_TOKEN_IN_LDIF_FILE;      }
1094     }
1095
1096     return (INSERT_OK);
1097   }
1098
1099
1100   /* Imports a single entry
1101       If $delete is true;  The old entry will be deleted if it exists.
1102       if $modify is true;  All variables that are not touched by the new ldif will be kept.
1103       if $modify is false; The new ldif overwrites the old entry, and all untouched attributes get lost.
1104   */
1105   function import_single_entry($str_attr,$modify,$delete)
1106   {
1107     if($this->reconnect) $this->connect();
1108
1109     $ret = false;
1110     $rows= split("\n",$str_attr);
1111     $data= false;
1112
1113     foreach($rows as $row) {
1114
1115       /* Check if we use Linenumbers (when import_complete_ldif is called we use
1116          Linenumbers) Linenumbers are use like this 123#attribute : value */
1117       if(!empty($row)) {
1118         if(strpos($row,"#")!=FALSE) {
1119
1120           /* We are using line numbers
1121              Because there is a # before a : */
1122           $tmp1= split("#",$row);
1123           $current_line= $tmp1[0];
1124           $row= base64_decode($tmp1[1]);
1125         }
1126
1127         /* Split the line into  attribute  and value */
1128         $attr   = split(":", $row,2);
1129         $attr[0]= trim($attr[0]);  /* attribute */
1130         $attr[1]= $attr[1];  /* value */
1131
1132         /* Check :: was used to indicate base64_encoded strings */
1133         if($attr[1][0] == ":"){
1134           $attr[1]=trim(preg_replace("/^:/","",$attr[1]));
1135           $attr[1]=base64_decode($attr[1]);
1136         }
1137
1138         $attr[1] = trim($attr[1]);
1139
1140         /* Check for attributes that are used more than once */
1141         if(!isset($data[$attr[0]])) {
1142           $data[$attr[0]]=$attr[1];
1143         } else {
1144           $tmp = $data[$attr[0]];
1145
1146           if(!is_array($tmp)) {
1147             $new[0]=$tmp;
1148             $new[1]=$attr[1];
1149             $datas[$attr[0]]['count']=1;
1150             $data[$attr[0]]=$new;
1151           } else {
1152             $cnt = $datas[$attr[0]]['count'];
1153             $cnt ++;
1154             $data[$attr[0]][$cnt]=$attr[1];
1155             $datas[$attr[0]]['count'] = $cnt;
1156           }
1157         }
1158       }
1159     }
1160
1161     /* If dn is an index of data, we should try to insert the data */
1162     if(isset($data['dn'])) {
1163
1164       /* Fix dn */
1165       $tmp = gosa_ldap_explode_dn($data['dn']);
1166       unset($tmp['count']);
1167       $newdn ="";
1168       foreach($tmp as $tm){
1169         $newdn.= trim($tm).",";
1170       }
1171       $newdn = preg_replace("/,$/","",$newdn);
1172       $data['dn'] = $newdn;
1173
1174       /* Creating Entry */
1175       $this->cd($data['dn']);
1176
1177       /* Delete existing entry */
1178       if($delete){
1179         $this->rmdir_recursive($data['dn']);
1180       }
1181
1182       /* Create missing trees */
1183       $this->cd ($this->basedn);
1184       $this->create_missing_trees($data['dn']);
1185       $this->cd($data['dn']);
1186
1187       $dn = $data['dn'];
1188       unset($data['dn']);
1189
1190       if(!$modify){
1191
1192         $this->cat($dn);
1193         if($this->count()){
1194
1195           /* The destination entry exists, overwrite it with the new entry */
1196           $attrs = $this->fetch();
1197           foreach($attrs as $name => $value ){
1198             if(!is_numeric($name)){
1199               if(in_array($name,array("dn","count"))) continue;
1200               if(!isset($data[$name])){
1201                 $data[$name] = array();
1202               }
1203             }
1204           }
1205           $ret = $this->modify($data);
1206
1207         }else{
1208
1209           /* The destination entry doesn't exists, create it */
1210           $ret = $this->add($data);
1211         }
1212
1213       } else {
1214
1215         /* Keep all vars that aren't touched by this ldif */
1216         $ret = $this->modify($data);
1217       }
1218     }
1219     show_ldap_error($this->get_error(), sprintf(_("Ldap import with dn '%s' failed."),$dn));
1220     return($ret);
1221   }
1222
1223
1224   function importcsv($str)
1225   {
1226     $lines = split("\n",$str);
1227     foreach($lines as $line)
1228     {
1229       /* continue if theres a comment */
1230       if(substr(trim($line),0,1)=="#"){
1231         continue;
1232       }
1233
1234       $line= str_replace ("\t\t","\t",$line);
1235       $line= str_replace ("\t"  ,"," ,$line);
1236       echo $line;
1237
1238       $cells = split(",",$line )  ;
1239       $linet= str_replace ("\t\t",",",$line);
1240       $cells = split("\t",$line);
1241       $count = count($cells);
1242     }
1243
1244   }
1245
1246   function get_objectclasses()
1247   {
1248     $objectclasses = array();
1249
1250           # Get base to look for schema
1251           $sr = @ldap_read ($this->cid, NULL, "objectClass=*", array("subschemaSubentry"));
1252     if(!$sr){
1253             $sr = @ldap_read ($this->cid, "", "objectClass=*", array("subschemaSubentry"));
1254     }
1255
1256           $attr = @ldap_get_entries($this->cid,$sr);
1257           if (!isset($attr[0]['subschemasubentry'][0])){
1258             return array();
1259           }
1260
1261           /* Get list of objectclasses and fill array */
1262           $nb= $attr[0]['subschemasubentry'][0];
1263           $objectclasses= array();
1264           $sr= ldap_read ($this->cid, $nb, "objectClass=*", array("objectclasses"));
1265           $attrs= ldap_get_entries($this->cid,$sr);
1266           if (!isset($attrs[0])){
1267             return array();
1268           }
1269           foreach ($attrs[0]['objectclasses'] as $val){
1270       if (preg_match('/^[0-9]+$/', $val)){
1271         continue;
1272       }
1273       $name= "OID";
1274       $pattern= split(' ', $val);
1275       $ocname= preg_replace("/^.* NAME\s+\(*\s*'([^']+)'\s*\)*.*$/", '\\1', $val);
1276       $objectclasses[$ocname]= array();
1277
1278       foreach($pattern as $chunk){
1279         switch($chunk){
1280
1281           case '(':
1282                     $value= "";
1283                     break;
1284
1285           case ')': if ($name != ""){
1286                       $objectclasses[$ocname][$name]= $this->value2container($value);
1287                     }
1288                     $name= "";
1289                     $value= "";
1290                     break;
1291
1292           case 'NAME':
1293           case 'DESC':
1294           case 'SUP':
1295           case 'STRUCTURAL':
1296           case 'ABSTRACT':
1297           case 'AUXILIARY':
1298           case 'MUST':
1299           case 'MAY':
1300                     if ($name != ""){
1301                       $objectclasses[$ocname][$name]= $this->value2container($value);
1302                     }
1303                     $name= $chunk;
1304                     $value= "";
1305                     break;
1306
1307           default:  $value.= $chunk." ";
1308         }
1309       }
1310
1311           }
1312
1313           return $objectclasses;
1314   }
1315
1316
1317   function value2container($value)
1318   {
1319     /* Set emtpy values to "true" only */
1320     if (preg_match('/^\s*$/', $value)){
1321       return true;
1322     }
1323
1324     /* Remove ' and " if needed */
1325     $value= preg_replace('/^[\'"]/', '', $value);
1326     $value= preg_replace('/[\'"] *$/', '', $value);
1327
1328     /* Convert to array if $ is inside... */
1329     if (preg_match('/\$/', $value)){
1330       $container= preg_split('/\s*\$\s*/', $value);
1331     } else {
1332       $container= chop($value);
1333     }
1334
1335     return ($container);
1336   }
1337
1338
1339   function log($string)
1340   {
1341     if (isset($_SESSION['config'])){
1342       $cfg= $_SESSION['config'];
1343       if (isset($cfg->current['LDAPSTATS']) && preg_match('/true/i', $cfg->current['LDAPSTATS'])){
1344         syslog (LOG_INFO, $string);
1345       }
1346     }
1347   }
1348
1349   /* added by Guido Serra aka Zeph <zeph@purotesto.it> */
1350   function getCn($dn){
1351     $simple= split(",", $dn);
1352
1353     foreach($simple as $piece) {
1354       $partial= split("=", $piece);
1355
1356       if($partial[0] == "cn"){
1357         return $partial[1];
1358       }
1359     }
1360   }
1361
1362
1363   function get_naming_contexts($server, $admin= "", $password= "")
1364   {
1365     /* Build LDAP connection */
1366     $ds= ldap_connect ($server);
1367     if (!$ds) {
1368       die ("Can't bind to LDAP. No check possible!");
1369     }
1370     ldap_set_option($ds, LDAP_OPT_PROTOCOL_VERSION, 3);
1371     $r= ldap_bind ($ds, $admin, $password);
1372
1373     /* Get base to look for naming contexts */
1374     $sr  = @ldap_read ($ds, "", "objectClass=*", array("namingContexts", ));
1375     $attr= @ldap_get_entries($ds,$sr);
1376
1377     return ($attr[0]['namingcontexts']);
1378   }
1379
1380
1381   function get_root_dse($server, $admin= "", $password= "")
1382   {
1383     /* Build LDAP connection */
1384     $ds= ldap_connect ($server);
1385     if (!$ds) {
1386       die ("Can't bind to LDAP. No check possible!");
1387     }
1388     ldap_set_option($ds, LDAP_OPT_PROTOCOL_VERSION, 3);
1389     $r= ldap_bind ($ds, $admin, $password);
1390
1391     /* Get base to look for naming contexts */
1392     $sr  = @ldap_read ($ds, "", "objectClass=*", array("+"));
1393     $attr= @ldap_get_entries($ds,$sr);
1394
1395     print_a($attr);
1396
1397     return ($attr);
1398   }
1399
1400
1401 }
1402
1403 // vim:tabstop=2:expandtab:shiftwidth=2:filetype=php:syntax:ruler:
1404 ?>