gosa-core/include/class_ldap.inc

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