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