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