public_html/includes/class/class.LSsession.php

   1 <?php
   2 /*******************************************************************************
   3  * Copyright (C) 2007 Easter-eggs
   4  * http://ldapsaisie.labs.libre-entreprise.org
   5  *
   6  * Author: See AUTHORS file in top-level directory.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License version 2
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21 ******************************************************************************/
  22
  23 /**
  24  * Gestion des sessions
  25  *
  26  * Cette classe gÃ¨re les sessions d'utilisateurs.
  27  *
  28  * @author Benjamin Renard <brenard@easter-eggs.com>
  29  */
  30 class LSsession {
  31
  32   // La configuration du serveur Ldap utilisé
  33   public static $ldapServer = NULL;
  34
  35   // L'id du serveur Ldap utilisé
  36   private static $ldapServerId = NULL;
  37
  38   // Le topDn courant
  39   private static $topDn = NULL;
  40
  41   // Le DN de l'utilisateur connecté
  42   private static $dn = NULL;
  43
  44   // Le RDN de l'utilisateur connecté (son identifiant)
  45   private static $rdn = NULL;
  46
  47   // Les LSprofiles de l'utilisateur
  48   private static $LSprofiles = array();
  49
  50   // Les droits d'accès de l'utilisateur
  51   private static $LSaccess = array();
  52
  53   // Les fichiers temporaires
  54   private static $tmp_file = array();
  55
  56   // Langue et encodage actuel
  57   private static $lang = NULL;
  58   private static $encoding = NULL;
  59
  60   /*
  61    * Constante de classe non stockée en session
  62    */
  63   // Le template à afficher
  64   private static $template = NULL;
  65
  66   // Les subDn des serveurs Ldap
  67   private static $_subDnLdapServer = array();
  68
  69   // Affichage Ajax
  70   private static $ajaxDisplay = false;
  71
  72   // Les fichiers JS à charger dans la page
  73   private static $JSscripts = array();
  74
  75   // Les paramètres JS à communiquer dans la page
  76   private static $_JSconfigParams = array();
  77
  78   // Les fichiers CSS à charger dans la page
  79   private static $CssFiles = array();
  80
  81   // L'objet de l'utilisateur connecté
  82   private static $LSuserObject = NULL;
  83
  84   // The LSauht object of the session
  85   private static $LSauthObject = false;
  86
  87   // User LDAP credentials
  88   private static $userLDAPcreds = false;
  89
  90  /**
  91   * Include un fichier PHP
  92   *
  93   * @author Benjamin Renard <brenard@easter-eggs.com>
  94   *
  95   * @retval true si tout c'est bien passé, false sinon
  96   */
  97   public static function includeFile($file) {
  98     if (file_exists(LS_LOCAL_DIR.'/'.$file)) {
  99       $file=LS_LOCAL_DIR.'/'.$file;
 100     }
 101     elseif (!file_exists($file)) {
 102       return;
 103     }
 104     if (defined('LSdebug') && constant('LSdebug')) {
 105       return include_once($file);
 106     }
 107     else {
 108       return @include_once($file);
 109     }
 110     return;
 111   }
 112
 113  /**
 114   * Lancement de LSconfig
 115   *
 116   * @author Benjamin Renard <brenard@easter-eggs.com>
 117   *
 118   * @retval true si tout c'est bien passÃ©, false sinon
 119   */
 120   private static function startLSconfig() {
 121     if (self :: loadLSclass('LSconfig')) {
 122       if (LSconfig :: start()) {
 123         return true;
 124       }
 125     }
 126     die("ERROR : Can't load configuration files.");
 127     return;
 128   }
 129
 130  /**
 131   * Lancement et initialisation de Smarty
 132   *
 133   * @author Benjamin Renard <brenard@easter-eggs.com>
 134   *
 135   * @retval true si tout c'est bien passÃ©, false sinon
 136   */
 137   private static function startLStemplate() {
 138     if ( self :: loadLSclass('LStemplate') ) {
 139       return LStemplate :: start(
 140         array(
 141           'smarty_path'  => LSconfig :: get('Smarty'),
 142           'template_dir' => LS_TEMPLATES_DIR,
 143           'image_dir'    => LS_IMAGES_DIR,
 144           'css_dir'    => LS_CSS_DIR,
 145           'compile_dir'  => LS_TMP_DIR,
 146           'debug'        => LSdebug,
 147           'debug_smarty' => (isset($_REQUEST['LStemplate_debug'])),
 148         )
 149       );
 150     }
 151     return False;
 152   }
 153
 154  /**
 155   * Retourne le topDn de la session
 156   *
 157   * @author Benjamin Renard <brenard@easter-eggs.com>
 158   *
 159   * @retval string le topDn de la session
 160   */
 161   public static function getTopDn() {
 162     if (!is_null(self :: $topDn)) {
 163       return self :: $topDn;
 164     }
 165     else {
 166       return self :: getRootDn();
 167     }
 168   }
 169
 170  /**
 171   * Retourne le rootDn de la session
 172   *
 173   * @author Benjamin Renard <brenard@easter-eggs.com>
 174   *
 175   * @retval string le rootDn de la session
 176   */
 177   public static function getRootDn() {
 178     return self :: $ldapServer['ldap_config']['basedn'];
 179   }
 180
 181  /**
 182   * Initialisation de la gestion des erreurs
 183   *
 184   * CrÃ©ation de l'objet LSerror
 185   *
 186   * @author Benjamin Renard <brenard@easter-eggs.com
 187   *
 188   * @retval boolean true si l'initialisation a rÃ©ussi, false sinon.
 189   */
 190   private static function startLSerror() {
 191     if(!self :: loadLSclass('LSerror')) {
 192       return;
 193     }
 194     set_error_handler(array('LSerror','errorHandler'),E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED & ~E_WARNING);
 195     self :: defineLSerrors();
 196     return true;
 197   }
 198
 199  /**
 200   * Chargement d'une classe d'LdapSaisie
 201   *
 202   * @param[in] $class Nom de la classe Ã  charger (Exemple : LSpeople)
 203   * @param[in] $type (Optionnel) Type de classe Ã  charger (Exemple : LSobjects)
 204   *
 205   * @author Benjamin Renard <brenard@easter-eggs.com
 206   *
 207   * @retval boolean true si le chargement a rÃ©ussi, false sinon.
 208   */
 209   public static function loadLSclass($class,$type='') {
 210     if (class_exists($class))
 211       return true;
 212     if($type!='')
 213       $type=$type.'.';
 214     return self :: includeFile(LS_CLASS_DIR .'class.'.$type.$class.'.php');
 215   }
 216
 217  /**
 218   * Chargement d'un object LdapSaisie
 219   *
 220   * @param[in] $object Nom de l'objet Ã  charger
 221   *
 222   * @retval boolean true si le chargement a rÃ©ussi, false sinon.
 223   */
 224   public static function loadLSobject($object) {
 225     if(class_exists($object)) {
 226       return true;
 227     }
 228     $error = 0;
 229     self :: loadLSclass('LSldapObject');
 230     if (!self :: loadLSclass($object,'LSobjects')) {
 231       $error = 1;
 232     }
 233     if (!self :: includeFile( LS_OBJECTS_DIR . 'config.LSobjects.'.$object.'.php' )) {
 234       $error = 1;
 235     }
 236     else {
 237       if (!LSconfig :: set("LSobjects.$object",$GLOBALS['LSobjects'][$object])) {
 238         $error = 1;
 239       }
 240       else if (isset($GLOBALS['LSobjects'][$object]['LSaddons'])){
 241         if (is_array($GLOBALS['LSobjects'][$object]['LSaddons'])) {
 242           foreach ($GLOBALS['LSobjects'][$object]['LSaddons'] as $addon) {
 243             if (!self :: loadLSaddon($addon)) {
 244               $error = 1;
 245             }
 246           }
 247         }
 248         else {
 249           if (!self :: loadLSaddon($GLOBALS['LSobjects'][$object]['LSaddons'])) {
 250             $error = 1;
 251           }
 252         }
 253       }
 254     }
 255     if ($error) {
 256       LSerror :: addErrorCode('LSsession_04',$object);
 257       return;
 258     }
 259     return true;
 260   }
 261
 262  /**
 263   * Chargement d'un addons d'LdapSaisie
 264   *
 265   * @param[in] $addon Nom de l'addon Ã  charger (Exemple : samba)
 266   *
 267   * @author Benjamin Renard <brenard@easter-eggs.com
 268   *
 269   * @retval boolean true si le chargement a rÃ©ussi, false sinon.
 270   */
 271   public static function loadLSaddon($addon) {
 272     if(self :: includeFile(LS_ADDONS_DIR .'LSaddons.'.$addon.'.php')) {
 273       self :: includeFile(LS_CONF_DIR."LSaddons/config.LSaddons.".$addon.".php");
 274       if (!call_user_func('LSaddon_'. $addon .'_support')) {
 275         LSerror :: addErrorCode('LSsession_02',$addon);
 276         return;
 277       }
 278       return true;
 279     }
 280     return;
 281   }
 282
 283  /**
 284   * Chargement d'une classe d'authentification d'LdapSaisie
 285   *
 286   * @author Benjamin Renard <brenard@easter-eggs.com
 287   *
 288   * @retval boolean true si le chargement a reussi, false sinon.
 289   */
 290   public static function loadLSauth() {
 291     if (self :: loadLSclass('LSauth')) {
 292       return true;
 293     }
 294     else {
 295       LSerror :: addErrorCode('LSsession_05','LSauth');
 296     }
 297     return;
 298   }
 299
 300  /**
 301   * Chargement des addons LdapSaisie
 302   *
 303   * Chargement des LSaddons contenue dans la variable
 304   * $GLOBALS['LSaddons']['loads']
 305   *
 306   * @retval boolean true si le chargement a rÃ©ussi, false sinon.
 307   */
 308   public static function loadLSaddons() {
 309     $conf=LSconfig :: get('LSaddons.loads');
 310     if(!is_array($conf)) {
 311       LSerror :: addErrorCode('LSsession_01',"LSaddons['loads']");
 312       return;
 313     }
 314
 315     foreach ($conf as $addon) {
 316       self :: loadLSaddon($addon);
 317     }
 318     return true;
 319   }
 320
 321  /**
 322   * Défini la locale
 323   *
 324   * @retval void
 325   */
 326   public static function setLocale() {
 327     if (isset($_REQUEST['lang'])) {
 328       $lang = $_REQUEST['lang'];
 329     }
 330     elseif (isset($_SESSION['LSlang'])) {
 331       $lang = $_SESSION['LSlang'];
 332     }
 333     elseif (isset(self :: $ldapServer['lang'])) {
 334       $lang = self :: $ldapServer['lang'];
 335     }
 336     else {
 337       $lang = LSconfig :: get('lang');
 338     }
 339
 340     if (isset($_REQUEST['encoding'])) {
 341       $encoding = $_REQUEST['encoding'];
 342     }
 343     elseif (isset($_SESSION['LSencoding'])) {
 344       $encoding = $_SESSION['LSencoding'];
 345     }
 346     elseif (isset(self :: $ldapServer['encoding'])) {
 347       $encoding = self :: $ldapServer['encoding'];
 348     }
 349     else {
 350       $encoding = LSconfig :: get('encoding');
 351     }
 352
 353     $_SESSION['LSlang']=$lang;
 354     self :: $lang=$lang;
 355     $_SESSION['LSencoding']=$encoding;
 356     self :: $encoding=$encoding;
 357
 358
 359     if (self :: localeExist($lang,$encoding)) {
 360       if ($encoding) {
 361         $lang.='.'.$encoding;
 362       }
 363       setlocale(LC_ALL, $lang);
 364       bindtextdomain(LS_TEXT_DOMAIN, LS_I18N_DIR);
 365       textdomain(LS_TEXT_DOMAIN);
 366
 367       self :: includeFile(LS_I18N_DIR.'/'.$lang.'/lang.php');
 368
 369       foreach (listFiles(LS_LOCAL_DIR.'/'.LS_I18N_DIR.'/'.$lang,'/^lang.+\.php$/') as $file) {
 370         include(LS_LOCAL_DIR.'/'.LS_I18N_DIR."/$lang/$file");
 371       }
 372     }
 373     else {
 374       if ($encoding && $lang) {
 375         $lang.='.'.$encoding;
 376       }
 377       LSdebug('La locale "'.$lang.'" n\'existe pas, utilisation de la locale par défaut.');
 378     }
 379   }
 380
 381  /**
 382   * Retourne la liste des langues disponibles
 383   *
 384   * @retval array Tableau/Liste des langues disponibles
 385   **/
 386   public static function getLangList() {
 387     $list=array('en_US');
 388     if (self :: $encoding) {
 389       $regex = '^([a-zA-Z_]*)\.'.self :: $encoding.'$';
 390     }
 391     else {
 392       $regex = '^([a-zA-Z_]*)$';
 393     }
 394     if ($handle = opendir(LS_I18N_DIR)) {
 395       while (false !== ($file = readdir($handle))) {
 396         if(is_dir(LS_I18N_DIR.'/'.$file)) {
 397           if (ereg($regex,$file,$regs)) {
 398             if (!in_array($regs[1],$list)) {
 399               $list[]=$regs[1];
 400             }
 401           }
 402         }
 403       }
 404     }
 405     return $list;
 406   }
 407
 408  /**
 409   * Retourne la langue courante de la session
 410   *
 411   * @param[in] boolean Si true, le code langue retourné sera court
 412   *
 413   * @retval string La langue de la session
 414   **/
 415   public static function getLang($short=false) {
 416     if ($short) {
 417       return strtolower(self :: $lang[0].self :: $lang[1]);
 418     }
 419     return self :: $lang;
 420   }
 421
 422  /**
 423   * Vérifie si une locale est disponible
 424   *
 425   * @param[in] $lang string La langue (Ex : fr_FR)
 426   * @param[in] $encoding string L'encodage de caractère (Ex : UTF8)
 427   *
 428   * @retval boolean True si la locale est disponible, False sinon
 429   **/
 430   public static function localeExist($lang,$encoding) {
 431     if ( !$lang && !$encoding ) {
 432       return;
 433     }
 434     $locale=$lang.(($encoding)?'.'.$encoding:'');
 435     if ($locale=='en_US.UTF8') {
 436       return true;
 437     }
 438     return (is_dir(LS_I18N_DIR.'/'.$locale));
 439   }
 440
 441  /**
 442   * Initialisation LdapSaisie
 443   *
 444   * @retval boolean True si l'initialisation à réussi, false sinon.
 445   */
 446   public static function initialize() {
 447     if (!self :: startLSconfig()) {
 448       return;
 449     }
 450
 451     self :: startLSerror();
 452     self :: startLStemplate();
 453
 454     session_start();
 455
 456     self :: setLocale();
 457
 458     self :: loadLSaddons();
 459     self :: loadLSauth();
 460     return true;
 461   }
 462
 463  /**
 464   * Initialisation de la session LdapSaisie
 465   *
 466   * Initialisation d'une LSsession :
 467   * - Authentification et activation du mÃ©canisme de session de LdapSaisie
 468   * - ou Chargement des paramÃ¨tres de la session Ã  partir de la variable
 469   *   $_SESSION['LSsession'].
 470   * - ou Destruction de la session en cas de $_GET['LSsession_logout'].
 471   *
 472   * @retval boolean True si l'initialisation Ã  rÃ©ussi (utilisateur authentifiÃ©), false sinon.
 473   */
 474   public static function startLSsession() {
 475     if (!self :: initialize()) {
 476       return;
 477     }
 478
 479     if(isset($_SESSION['LSsession']['dn']) && !isset($_GET['LSsession_recoverPassword'])) {
 480       LSdebug('LSsession : Session existente');
 481       // --------------------- Session existante --------------------- //
 482       self :: $topDn         = $_SESSION['LSsession']['topDn'];
 483       self :: $dn            = $_SESSION['LSsession']['dn'];
 484       self :: $rdn           = $_SESSION['LSsession']['rdn'];
 485       self :: $ldapServerId  = $_SESSION['LSsession']['ldapServerId'];
 486       self :: $tmp_file      = $_SESSION['LSsession']['tmp_file'];
 487       self :: $userLDAPcreds = $_SESSION['LSsession']['userLDAPcreds'];
 488
 489       if ( self :: cacheLSprofiles() && !isset($_REQUEST['LSsession_refresh']) ) {
 490         self :: setLdapServer(self :: $ldapServerId);
 491         if (!LSauth :: start()) {
 492           LSdebug("LSsession : can't start LSauth -> stop");
 493           return;
 494         }
 495         self :: $LSprofiles   = $_SESSION['LSsession']['LSprofiles'];
 496         self :: $LSaccess   = $_SESSION['LSsession']['LSaccess'];
 497         if (!self :: LSldapConnect())
 498           return;
 499       }
 500       else {
 501         self :: setLdapServer(self :: $ldapServerId);
 502         if (!LSauth :: start()) {
 503           LSdebug("LSsession : can't start LSauth -> stop");
 504           return;
 505         }
 506         if (!self :: LSldapConnect())
 507           return;
 508         self :: loadLSprofiles();
 509       }
 510
 511       if ( self :: cacheSudDn() && (!isset($_REQUEST['LSsession_refresh'])) ) {
 512         self :: $_subDnLdapServer = ((isset($_SESSION['LSsession_subDnLdapServer']))?$_SESSION['LSsession_subDnLdapServer']:NULL);
 513       }
 514
 515       if (!self :: loadLSobject(self :: $ldapServer['authObjectType'])) {
 516         return;
 517       }
 518
 519       if (isset($_GET['LSsession_logout'])) {
 520         LSauth :: logout();
 521         session_destroy();
 522
 523         if (is_array($_SESSION['LSsession']['tmp_file'])) {
 524           self :: $tmp_file = $_SESSION['LSsession']['tmp_file'];
 525         }
 526         self :: deleteTmpFile();
 527         unset($_SESSION['LSsession']);
 528
 529         self :: redirect('index.php');
 530         return;
 531       }
 532
 533       if ( !self :: cacheLSprofiles() || isset($_REQUEST['LSsession_refresh']) ) {
 534         self :: loadLSaccess();
 535       }
 536
 537       LStemplate :: assign('LSsession_username',self :: getLSuserObject() -> getDisplayName());
 538
 539       if (isset ($_POST['LSsession_topDn']) && $_POST['LSsession_topDn']) {
 540         if (self :: validSubDnLdapServer($_POST['LSsession_topDn'])) {
 541           self :: $topDn = $_POST['LSsession_topDn'];
 542           $_SESSION['LSsession']['topDn'] = $_POST['LSsession_topDn'];
 543         } // end if
 544       } // end if
 545
 546       return true;
 547
 548     }
 549     else {
 550       // --------------------- Session inexistante --------------------- //
 551       if (isset($_GET['LSsession_recoverPassword'])) {
 552         session_destroy();
 553       }
 554       // Session inexistante
 555       if (isset($_POST['LSsession_ldapserver'])) {
 556         self :: setLdapServer($_POST['LSsession_ldapserver']);
 557       }
 558       else {
 559         self :: setLdapServer(0);
 560       }
 561
 562       // Connexion au serveur LDAP
 563       if (self :: LSldapConnect()) {
 564
 565         // topDn
 566         if (isset($_POST['LSsession_topDn']) && $_POST['LSsession_topDn'] != '' ){
 567           self :: $topDn = $_POST['LSsession_topDn'];
 568         }
 569         else {
 570           self :: $topDn = self :: $ldapServer['ldap_config']['basedn'];
 571         }
 572         $_SESSION['LSsession_topDn']=self :: $topDn;
 573
 574         if (!LSauth :: start()) {
 575           LSdebug("LSsession : can't start LSauth -> stop");
 576           return;
 577         }
 578
 579         if (isset($_GET['LSsession_recoverPassword'])) {
 580           $recoveryPasswordInfos = self :: recoverPasswd(
 581                                       $_REQUEST['LSsession_user'],
 582                                       $_GET['recoveryHash']
 583                                    );
 584         }
 585         else {
 586           $LSuserObject = LSauth :: forceAuthentication();
 587           if ($LSuserObject) {
 588             // Authentication successful
 589             self :: $LSuserObject = $LSuserObject;
 590             self :: $dn = $LSuserObject->getValue('dn');
 591             self :: $rdn = $LSuserObject->getValue('rdn');
 592             if (isset(self :: $ldapServer['useUserCredentials']) && self :: $ldapServer['useUserCredentials']) {
 593               self :: $userLDAPcreds = LSauth :: getLDAPcredentials($LSuserObject);
 594               if (!is_array(self :: $userLDAPcreds)) {
 595                 LSerror :: addErrorCode('LSsession_14');
 596                 self :: $userLDAPcreds = false;
 597                 return;
 598               }
 599               if (!LSldap :: reconnectAs(self :: $userLDAPcreds['dn'],self :: $userLDAPcreds['pwd'])) {
 600                 LSerror :: addErrorCode('LSsession_15');
 601                 return;
 602               }
 603             }
 604             self :: loadLSprofiles();
 605             self :: loadLSaccess();
 606             LStemplate :: assign('LSsession_username',self :: getLSuserObject() -> getDisplayName());
 607             $_SESSION['LSsession']=self :: getContextInfos();
 608             return true;
 609           }
 610         }
 611       }
 612       else {
 613         LSerror :: addErrorCode('LSsession_09');
 614       }
 615
 616       if (self :: $ldapServerId) {
 617         LStemplate :: assign('ldapServerId',self :: $ldapServerId);
 618       }
 619       LStemplate :: assign('topDn',self :: $topDn);
 620       if (isset($_GET['LSsession_recoverPassword'])) {
 621         self :: displayRecoverPasswordForm($recoveryPasswordInfos);
 622       }
 623       elseif(LSauth :: displayLoginForm()) {
 624         self :: displayLoginForm();
 625       }
 626       else {
 627         self :: setTemplate('blank.tpl');
 628         LSerror :: addErrorCode('LSsession_10');
 629       }
 630       return;
 631     }
 632   }
 633
 634   /**
 635    * Do recover password
 636    *
 637    * @param[in] $username string The submited username
 638    * @param[in] $recoveryHash string The submited recoveryHash
 639    *
 640    * @retval array The recoveryPassword infos for template
 641    **/
 642   private static function recoverPasswd($username,$recoveryHash) {
 643     $recoveryPasswordInfos=array();
 644     if ( self :: loadLSobject(self :: $ldapServer['authObjectType']) ) {
 645       $authobject = new self :: $ldapServer['authObjectType']();
 646       if (!empty($recoveryHash)) {
 647         $filter=Net_LDAP2_Filter::create(
 648           self :: $ldapServer['recoverPassword']['recoveryHashAttr'],
 649           'equals',
 650           $recoveryHash
 651         );
 652         $result = $authobject -> listObjects($filter,self :: $topDn);
 653       }
 654       elseif (!empty($username)) {
 655         $result = $authobject -> searchObject(
 656                     $username,
 657                     self :: $topDn,
 658                     self :: $ldapServer['authObjectFilter']
 659                   );
 660       }
 661       else {
 662         return $recoveryPasswordInfos;
 663       }
 664
 665       $nbresult=count($result);
 666
 667       if ($nbresult==0) {
 668         LSdebug('hash/username incorrect');
 669         LSerror :: addErrorCode('LSsession_06');
 670       }
 671       elseif ($nbresult>1) {
 672         LSerror :: addErrorCode('LSsession_07');
 673       }
 674       else {
 675         $rdn = $result[0] -> getValue('rdn');
 676         $username = $rdn[0];
 677         LSdebug('Recover : Id trouvé : '.$username);
 678         if (self :: $ldapServer['recoverPassword']) {
 679           if (self :: loadLSaddon('mail')) {
 680             LSdebug('Récupération active');
 681             $user=$result[0];
 682             $emailAddress = $user -> getValue(self :: $ldapServer['recoverPassword']['mailAttr']);
 683             $emailAddress = $emailAddress[0];
 684
 685             if (checkEmail($emailAddress)) {
 686               LSdebug('Email : '.$emailAddress);
 687               self :: $dn = $user -> getDn();
 688
 689               // 1ère étape : envoie du recoveryHash
 690               if (empty($recoveryHash)) {
 691                 $hash=self :: recoverPasswdFirstStep($user);
 692                 if ($hash) {
 693                   if (self :: recoverPasswdSendMail($emailAddress,1,$hash)) {
 694                     // Mail a bien été envoyé
 695                     $recoveryPasswordInfos['recoveryHashMail']=$emailAddress;
 696                   }
 697                 }
 698               }
 699               // 2nd étape : génération du mot de passe + envoie par mail
 700               else {
 701                 $pwd=self :: recoverPasswdSecondStep($user);
 702                 if ($pwd) {
 703                   if (self :: recoverPasswdSendMail($emailAddress,2,$pwd)){
 704                     // Mail a bien été envoyé
 705                     $recoveryPasswordInfos['newPasswordMail']=$emailAddress;
 706                   }
 707                 }
 708               }
 709             }
 710             else {
 711               LSerror :: addErrorCode('LSsession_19');
 712             }
 713           }
 714         }
 715         else {
 716           LSerror :: addErrorCode('LSsession_18');
 717         }
 718       }
 719     }
 720     return $recoveryPasswordInfos;
 721   }
 722
 723   /**
 724    * Send recover password mail
 725    *
 726    * @param[in] $mail string The user's mail
 727    * @param[in] $step integer The step
 728    * @param[in] $info string The info for formatted message
 729    *
 730    * @retval boolean True on success or False
 731    **/
 732   private static function recoverPasswdSendMail($mail,$step,$info) {
 733     // Header des mails
 734     $sendParams=array();
 735     if (self :: $ldapServer['recoverPassword']['recoveryEmailSender']) {
 736       $sendParams['From']=self :: $ldapServer['recoverPassword']['recoveryEmailSender'];
 737     }
 738
 739     if ($step==1) {
 740       if ($_SERVER['HTTPS']=='on') {
 741         $recovery_url='https://';
 742       }
 743       else {
 744         $recovery_url='http://';
 745       }
 746       $recovery_url .= $_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'].'&recoveryHash='.$info;
 747
 748       $subject = self :: $ldapServer['recoverPassword']['recoveryHashMail']['subject'];
 749       $msg = getFData(
 750         self :: $ldapServer['recoverPassword']['recoveryHashMail']['msg'],
 751         $recovery_url
 752       );
 753     }
 754     else {
 755       $subject = self :: $ldapServer['recoverPassword']['newPasswordMail']['subject'];
 756       $msg = getFData(
 757         self :: $ldapServer['recoverPassword']['newPasswordMail']['msg'],
 758         $info
 759       );
 760     }
 761
 762     if (!sendMail($mail,$subject,$msg,$sendParams)) {
 763       LSdebug("Problème durant l'envoie du mail");
 764       LSerror :: addErrorCode('LSsession_20',4);
 765       return;
 766     }
 767     return true;
 768   }
 769
 770
 771   /**
 772    * Do first step of recovering password
 773    *
 774    * @param[in] $user LSldapObject The LSldapObject of the user
 775    *
 776    * @retval string|False The recory hash on success or False
 777    **/
 778   private static function recoverPasswdFirstStep($user) {
 779     // Generer un hash
 780     $rdn=$user -> getValue('rdn');
 781     $rdn = $rdn[0];
 782     $recovery_hash = md5($rdn . strval(time()) . strval(rand()));
 783
 784     $lostPasswdForm = $user -> getForm('lostPassword');
 785     $lostPasswdForm -> setPostData(
 786       array(
 787         self :: $ldapServer['recoverPassword']['recoveryHashAttr'] => $recovery_hash
 788       )
 789       ,true
 790     );
 791
 792     if($lostPasswdForm -> validate()) {
 793       if ($user -> updateData('lostPassword')) {
 794         // recoveryHash de l'utilisateur mis à jour
 795         return $recovery_hash;
 796       }
 797       else {
 798         // Erreur durant la mise à jour de l'objet
 799         LSdebug("Erreur durant la mise à jour de l'objet");
 800         LSerror :: addErrorCode('LSsession_20',6);
 801       }
 802     }
 803     else {
 804       // Erreur durant la validation du formulaire de modification de perte de password
 805       LSdebug("Erreur durant la validation du formulaire de modification de perte de password");
 806       LSerror :: addErrorCode('LSsession_20',5);
 807     }
 808     return;
 809   }
 810
 811   /**
 812    * Do second step of recovering password
 813    *
 814    * @param[in] $user LSldapObject The LSldapObject of the user
 815    *
 816    * @retval string|False The new password on success or False
 817    **/
 818   private static function recoverPasswdSecondStep($user) {
 819     $attr=$user -> attrs[self :: $ldapServer['authObjectTypeAttrPwd']];
 820     if ($attr instanceof LSattribute) {
 821       $mdp = generatePassword(
 822        $attr -> config['html_options']['chars'],
 823        $attr -> config['html_options']['lenght']
 824       );
 825       LSdebug('Nvx mpd : '.$mdp);
 826       $lostPasswdForm = $user -> getForm('lostPassword');
 827       $lostPasswdForm -> setPostData(
 828         array(
 829           self :: $ldapServer['recoverPassword']['recoveryHashAttr'] => array(''),
 830           self :: $ldapServer['authObjectTypeAttrPwd'] => array($mdp)
 831         )
 832         ,true
 833       );
 834       if($lostPasswdForm -> validate()) {
 835         if ($user -> updateData('lostPassword')) {
 836           return $mdp;
 837         }
 838         else {
 839           // Erreur durant la mise à jour de l'objet
 840           LSdebug("Erreur durant la mise à jour de l'objet");
 841           LSerror :: addErrorCode('LSsession_20',3);
 842         }
 843       }
 844       else {
 845         // Erreur durant la validation du formulaire de modification de perte de password
 846         LSdebug("Erreur durant la validation du formulaire de modification de perte de password");
 847         LSerror :: addErrorCode('LSsession_20',2);
 848       }
 849     }
 850     else {
 851       // l'attribut password n'existe pas
 852       LSdebug("L'attribut password n'existe pas");
 853       LSerror :: addErrorCode('LSsession_20',1);
 854     }
 855     return;
 856   }
 857
 858  /**
 859   * Retourne les informations du contexte
 860   *
 861   * @author Benjamin Renard <brenard@easter-eggs.com
 862   *
 863   * @retval array Tableau associatif des informations du contexte
 864   */
 865   private static function getContextInfos() {
 866     return array(
 867       'tmp_file' => self :: $tmp_file,
 868       'topDn' => self :: $topDn,
 869       'dn' => self :: $dn,
 870       'rdn' => self :: $rdn,
 871       'userLDAPcreds' => self :: $userLDAPcreds,
 872       'ldapServerId' => self :: $ldapServerId,
 873       'ldapServer' => self :: $ldapServer,
 874       'LSprofiles' => self :: $LSprofiles,
 875       'LSaccess' => self :: $LSaccess
 876     );
 877   }
 878
 879   /**
 880   * Retourne l'objet de l'utilisateur connecté
 881   *
 882   * @author Benjamin Renard <brenard@easter-eggs.com
 883   *
 884   * @retval mixed L'objet de l'utilisateur connecté ou false si il n'a pas put
 885   *               être créé
 886   */
 887   public static function getLSuserObject($dn=null) {
 888     if ($dn) {
 889       self :: $dn = $dn;
 890     }
 891     if (!self :: $LSuserObject) {
 892       if (self :: loadLSobject(self :: $ldapServer['authObjectType'])) {
 893         self :: $LSuserObject = new self :: $ldapServer['authObjectType']();
 894         self :: $LSuserObject -> loadData(self :: $dn);
 895       }
 896       else {
 897         return;
 898       }
 899     }
 900     return self :: $LSuserObject;
 901   }
 902
 903  /**
 904   * Retourne le DN de l'utilisateur connecté
 905   *
 906   * @author Benjamin Renard <brenard@easter-eggs.com
 907   *
 908   * @retval string Le DN de l'utilisateur connecté
 909   */
 910   public static function getLSuserObjectDn() {
 911     return self :: $dn;
 912   }
 913
 914  /**
 915   * Modifie l'utilisateur connecté à la volé
 916   *
 917   * @param[in] $object Mixed  L'objet Ldap du nouvel utilisateur
 918   *                           le type doit correspondre à
 919   *                           self :: $ldapServer['authObjectType']
 920   *
 921   * @retval boolean True en cas de succès, false sinon
 922   */
 923  public static function changeAuthUser($object) {
 924   if ($object instanceof self :: $ldapServer['authObjectType']) {
 925     self :: $dn = $object -> getDn();
 926     $rdn = $object -> getValue('rdn');
 927     if(is_array($rdn)) {
 928       $rdn = $rdn[0];
 929     }
 930     self :: $rdn = $rdn;
 931     self :: $LSuserObject = $object;
 932
 933     if(self :: loadLSprofiles()) {
 934       self :: loadLSaccess();
 935       $_SESSION['LSsession']=self :: getContextInfos();
 936       return true;
 937     }
 938   }
 939   return;
 940  }
 941
 942  /**
 943   * DÃ©finition du serveur Ldap de la session
 944   *
 945   * DÃ©finition du serveur Ldap de la session Ã  partir de son ID dans
 946   * le tableau LSconfig :: get('ldap_servers').
 947   *
 948   * @param[in] integer Index du serveur Ldap
 949   *
 950   * @retval boolean True sinon false.
 951   */
 952   public static function setLdapServer($id) {
 953     $conf = LSconfig :: get("ldap_servers.$id");
 954     if ( is_array($conf) ) {
 955       self :: $ldapServerId = $id;
 956       self :: $ldapServer = $conf;
 957       self :: setLocale();
 958       return true;
 959     }
 960     else {
 961       return;
 962     }
 963   }
 964
 965  /**
 966   * Connexion au serveur Ldap
 967   *
 968   * @retval boolean True sinon false.
 969   */
 970   public static function LSldapConnect() {
 971     if (self :: $ldapServer) {
 972       self :: includeFile(LSconfig :: get('NetLDAP2'));
 973       if (!self :: loadLSclass('LSldap')) {
 974         return;
 975       }
 976       if (self :: $dn && isset(self :: $ldapServer['useUserCredentials']) && self :: $ldapServer['useUserCredentials']) {
 977         LSldap :: reconnectAs(self :: $userLDAPcreds['dn'], self :: $userLDAPcreds['pwd'],self :: $ldapServer['ldap_config']);
 978       }
 979       else {
 980         LSldap :: connect(self :: $ldapServer['ldap_config']);
 981       }
 982       if (LSldap :: isConnected()) {
 983         return true;
 984       }
 985       else {
 986         return;
 987       }
 988     }
 989     else {
 990       LSerror :: addErrorCode('LSsession_03');
 991       return;
 992     }
 993   }
 994
 995   /**
 996    * Use this function to know if subDn is enabled for the curent LdapServer
 997    *
 998    * @retval boolean
 999    **/
1000   public static function subDnIsEnabled() {
1001     if (!isset(self :: $ldapServer['subDn'])) {
1002       return;
1003     }
1004     if ( !is_array(self :: $ldapServer['subDn']) ) {
1005       return;
1006     }
1007     return true;
1008   }
1009
1010  /**
1011   * Retourne les sous-dns du serveur Ldap courant
1012   *
1013   * @retval mixed Tableau des subDn, false si une erreur est survenue.
1014   */
1015   public static function getSubDnLdapServer($login=false) {
1016     $login=(bool)$login;
1017     if (self :: cacheSudDn() && isset(self :: $_subDnLdapServer[self :: $ldapServerId][$login])) {
1018       return self :: $_subDnLdapServer[self :: $ldapServerId][$login];
1019     }
1020     if (!self::subDnIsEnabled()) {
1021       return;
1022     }
1023     $return=array();
1024     foreach(self :: $ldapServer['subDn'] as $subDn_name => $subDn_config) {
1025       if ($login && isset($subDn_config['nologin']) && $subDn_config['nologin']) continue;
1026       if ($subDn_name == 'LSobject') {
1027         if (is_array($subDn_config)) {
1028           foreach($subDn_config as $LSobject_name => $LSoject_config) {
1029             if (isset($LSoject_config['basedn']) && !empty($LSoject_config['basedn'])) {
1030               $basedn = $LSoject_config['basedn'];
1031             }
1032             else {
1033               $basedn = self::getRootDn();
1034             }
1035             if (isset($LSoject_config['displayName']) && !empty($LSoject_config['displayName'])) {
1036               $displayName = $LSoject_config['displayName'];
1037             }
1038             else {
1039               $displayName = NULL;
1040             }
1041             if( self :: loadLSobject($LSobject_name) ) {
1042               if ($subdnobject = new $LSobject_name()) {
1043                 $tbl_return = $subdnobject -> getSelectArray(NULL,$basedn,$displayName);
1044                 if (is_array($tbl_return)) {
1045                   $return=array_merge($return,$tbl_return);
1046                 }
1047                 else {
1048                   LSerror :: addErrorCode('LSsession_17',3);
1049                 }
1050               }
1051               else {
1052                 LSerror :: addErrorCode('LSsession_17',2);
1053               }
1054             }
1055           }
1056         }
1057         else {
1058           LSerror :: addErrorCode('LSsession_17',1);
1059         }
1060       }
1061       else {
1062         if ((isCompatibleDNs($subDn_config['dn'],self :: $ldapServer['ldap_config']['basedn']))&&($subDn_config['dn']!="")) {
1063           $return[$subDn_config['dn']] = __($subDn_name);
1064         }
1065       }
1066     }
1067     if (self :: cacheSudDn()) {
1068       self :: $_subDnLdapServer[self :: $ldapServerId][$login]=$return;
1069       $_SESSION['LSsession_subDnLdapServer'] = self :: $_subDnLdapServer;
1070     }
1071     return $return;
1072   }
1073
1074   /**
1075    * Retourne la liste de subDn du serveur Ldap utilise
1076    * trié par la profondeur dans l'arboressence (ordre décroissant)
1077    *
1078    * @return array() Tableau des subDn trié
1079    */
1080   public static function getSortSubDnLdapServer($login=false) {
1081     $subDnLdapServer = self :: getSubDnLdapServer($login);
1082     if (!$subDnLdapServer) {
1083       return array();
1084     }
1085     uksort($subDnLdapServer,"compareDn");
1086     return $subDnLdapServer;
1087   }
1088
1089  /**
1090   * Retourne les options d'une liste dÃ©roulante pour le choix du topDn
1091   * de connexion au serveur Ldap
1092   *
1093   * Liste les subdn (self :: $ldapServer['subDn'])
1094   *
1095   * @retval string Les options (<option>) pour la sÃ©lection du topDn.
1096   */
1097   public static function getSubDnLdapServerOptions($selected=NULL,$login=false) {
1098     $list = self :: getSubDnLdapServer($login);
1099     if ($list) {
1100       asort($list);
1101       $display='';
1102       foreach($list as $dn => $txt) {
1103         if ($selected && ($selected==$dn)) {
1104           $selected_txt = ' selected';
1105         }
1106         else {
1107           $selected_txt = '';
1108         }
1109         $display.="<option value=\"".$dn."\"$selected_txt>".$txt."</option>\n";
1110       }
1111       return $display;
1112     }
1113     return;
1114   }
1115
1116  /**
1117   * Vérifie qu'un subDn est déclaré
1118   *
1119   * @param[in] string Un subDn
1120   *
1121   * @retval boolean True si le subDn existe, False sinon
1122   */
1123   public static function validSubDnLdapServer($subDn) {
1124     $listTopDn = self :: getSubDnLdapServer();
1125     if(is_array($listTopDn)) {
1126       foreach($listTopDn as $dn => $txt) {
1127         if ($subDn==$dn) {
1128           return true;
1129         } // end if
1130       } // end foreach
1131     } // end if
1132     return;
1133   }
1134
1135  /**
1136   * Test un couple LSobject/pwd
1137   *
1138   * Test un bind sur le serveur avec le dn de l'objet et le mot de passe fourni.
1139   *
1140   * @param[in] LSobject L'object "user" pour l'authentification
1141   * @param[in] string Le mot de passe Ã  tester
1142   *
1143   * @retval boolean True si l'authentification Ã  rÃ©ussi, false sinon.
1144   */
1145   public static function checkUserPwd($object,$pwd) {
1146     return LSldap :: checkBind($object -> getValue('dn'),$pwd);
1147   }
1148
1149  /**
1150   * Affiche le formulaire de login
1151   *
1152   * DÃ©fini les informations pour le template Smarty du formulaire de login.
1153   *
1154   * @retval void
1155   */
1156   public static function displayLoginForm() {
1157     LStemplate :: assign('pagetitle',_('Connection'));
1158     if (isset($_GET['LSsession_logout'])) {
1159       LStemplate :: assign('loginform_action','index.php');
1160     }
1161     else {
1162       LStemplate :: assign('loginform_action',$_SERVER['REQUEST_URI']);
1163     }
1164     if (count(LSconfig :: get('ldap_servers'))==1) {
1165       LStemplate :: assign('loginform_ldapserver_style','style="display: none"');
1166     }
1167     LStemplate :: assign('loginform_label_ldapserver',_('LDAP server'));
1168     $ldapservers_name=array();
1169     $ldapservers_index=array();
1170     foreach(LSconfig :: get('ldap_servers') as $id => $infos) {
1171       $ldapservers_index[]=$id;
1172       $ldapservers_name[]=__($infos['name']);
1173     }
1174     LStemplate :: assign('loginform_ldapservers_name',$ldapservers_name);
1175     LStemplate :: assign('loginform_ldapservers_index',$ldapservers_index);
1176
1177     LStemplate :: assign('loginform_label_level',_('Level'));
1178     LStemplate :: assign('loginform_label_user',_('Identifier'));
1179     LStemplate :: assign('loginform_label_pwd',_('Password'));
1180     LStemplate :: assign('loginform_label_submit',_('Connect'));
1181     LStemplate :: assign('loginform_label_recoverPassword',_('Forgot your password ?'));
1182
1183     self :: setTemplate('login.tpl');
1184     self :: addJSscript('LSsession_login.js');
1185   }
1186
1187  /**
1188   * Affiche le formulaire de récupération de mot de passe
1189   *
1190   * Défini les informations pour le template Smarty du formulaire de
1191   * récupération de mot de passe
1192   *
1193   * @param[in] $infos array() Information sur le status du processus de
1194   *                           recouvrement de mot de passe
1195   *
1196   * @retval void
1197   */
1198   public static function displayRecoverPasswordForm($recoveryPasswordInfos) {
1199     LStemplate :: assign('pagetitle',_('Recovery of your credentials'));
1200     LStemplate :: assign('recoverpasswordform_action','index.php?LSsession_recoverPassword');
1201
1202     if (count(LSconfig :: get('ldap_servers'))==1) {
1203       LStemplate :: assign('recoverpasswordform_ldapserver_style','style="display: none"');
1204     }
1205
1206     LStemplate :: assign('recoverpasswordform_label_ldapserver',_('LDAP server'));
1207     $ldapservers_name=array();
1208     $ldapservers_index=array();
1209     foreach(LSconfig :: get('ldap_servers') as $id => $infos) {
1210       $ldapservers_index[]=$id;
1211       $ldapservers_name[]=$infos['name'];
1212     }
1213     LStemplate :: assign('recoverpasswordform_ldapservers_name',$ldapservers_name);
1214     LStemplate :: assign('recoverpasswordform_ldapservers_index',$ldapservers_index);
1215
1216     LStemplate :: assign('recoverpasswordform_label_user',_('Identifier'));
1217     LStemplate :: assign('recoverpasswordform_label_submit',_('Validate'));
1218     LStemplate :: assign('recoverpasswordform_label_back',_('Back'));
1219
1220     $recoverpassword_msg = _('Please fill the identifier field to proceed recovery procedure');
1221
1222     if (isset($recoveryPasswordInfos['recoveryHashMail'])) {
1223       $recoverpassword_msg = getFData(
1224         _("An email has been sent to  %{mail}. " .
1225         "Please follow the instructions on it."),
1226         $recoveryPasswordInfos['recoveryHashMail']
1227       );
1228     }
1229
1230     if (isset($recoveryPasswordInfos['newPasswordMail'])) {
1231       $recoverpassword_msg = getFData(
1232         _("Your new password has been sent to %{mail}. "),
1233         $recoveryPasswordInfos['newPasswordMail']
1234       );
1235     }
1236
1237     LStemplate :: assign('recoverpassword_msg',$recoverpassword_msg);
1238
1239     self :: setTemplate('recoverpassword.tpl');
1240     self :: addJSscript('LSsession_recoverPassword.js');
1241   }
1242
1243  /**
1244   * DÃ©fini le template Smarty Ã  utiliser
1245   *
1246   * Remarque : les fichiers de templates doivent se trouver dans le dossier
1247   * templates/.
1248   *
1249   * @param[in] string Le nom du fichier de template
1250   *
1251   * @retval void
1252   */
1253   public static function setTemplate($template) {
1254     self :: $template = $template;
1255   }
1256
1257  /**
1258   * Ajoute un script JS au chargement de la page
1259   *
1260   * Remarque : les scripts doivents Ãªtre dans le dossier LS_JS_DIR.
1261   *
1262   * @param[in] $script Le nom du fichier de script Ã  charger.
1263   *
1264   * @retval void
1265   */
1266   public static function addJSscript($file,$path=NULL) {
1267     $script=array(
1268       'file' => $file,
1269       'path' => $path
1270     );
1271     self :: $JSscripts[$path.$file]=$script;
1272   }
1273
1274  /**
1275   * Ajouter un paramètre de configuration Javascript
1276   *
1277   * @param[in] $name string Nom de la variable de configuration
1278   * @param[in] $val mixed Valeur de la variable de configuration
1279   *
1280   * @retval void
1281   */
1282   public static function addJSconfigParam($name,$val) {
1283     self :: $_JSconfigParams[$name]=$val;
1284   }
1285
1286  /**
1287   * Ajoute une feuille de style au chargement de la page
1288   *
1289   * @param[in] $script Le nom du fichier css Ã  charger.
1290   *
1291   * @retval void
1292   */
1293   public static function addCssFile($file,$path=NULL) {
1294     if ($path) {
1295       $file = $path.$file;
1296     }
1297     else {
1298       $file = LStemplate :: getCSSPath($file);
1299     }
1300     self :: $CssFiles[$file]=$file;
1301   }
1302
1303  /**
1304   * Affiche le template Smarty
1305   *
1306   * Charge les dÃ©pendances et affiche le template Smarty
1307   *
1308   * @retval void
1309   */
1310   public static function displayTemplate() {
1311     // JS
1312     $JSscript_txt='';
1313     foreach ($GLOBALS['defaultJSscipts'] as $script) {
1314       $JSscript_txt.="<script src='".LS_JS_DIR.$script."' type='text/javascript'></script>\n";
1315     }
1316
1317     foreach (self :: $JSscripts as $script) {
1318       if (!$script['path']) {
1319         $script['path']=LS_JS_DIR;
1320       }
1321       else {
1322         $script['path'].='/';
1323       }
1324       $JSscript_txt.="<script src='".$script['path'].$script['file']."' type='text/javascript'></script>\n";
1325     }
1326
1327     $KAconf = LSconfig :: get('keepLSsessionActive');
1328     if (
1329           (
1330             (!isset(self :: $ldapServer['keepLSsessionActive']))
1331             &&
1332             (!($KAconf === false))
1333           )
1334           ||
1335           (self :: $ldapServer['keepLSsessionActive'])
1336         ) {
1337       self :: addJSconfigParam('keepLSsessionActive',ini_get('session.gc_maxlifetime'));
1338     }
1339
1340     LStemplate :: assign('LSjsConfig',json_encode(self :: $_JSconfigParams));
1341
1342     if (LSdebug) {
1343       $JSscript_txt.="<script type='text/javascript'>LSdebug_active = 1;</script>\n";
1344     }
1345     else {
1346       $JSscript_txt.="<script type='text/javascript'>LSdebug_active = 0;</script>\n";
1347     }
1348
1349     LStemplate :: assign('LSsession_js',$JSscript_txt);
1350
1351     // Css
1352     self :: addCssFile("LSdefault.css");
1353     $Css_txt='';
1354     foreach (self :: $CssFiles as $file) {
1355       $Css_txt.="<link rel='stylesheet' type='text/css' href='".$file."' />\n";
1356     }
1357     LStemplate :: assign('LSsession_css',$Css_txt);
1358
1359     if (isset(self :: $LSaccess[self :: $topDn])) {
1360       LStemplate :: assign('LSaccess',self :: $LSaccess[self :: $topDn]);
1361     }
1362
1363     // Niveau
1364     $listTopDn = self :: getSubDnLdapServer();
1365     if (is_array($listTopDn)) {
1366       asort($listTopDn);
1367       LStemplate :: assign('label_level',self :: getSubDnLabel());
1368       LStemplate :: assign('_refresh',_('Refresh'));
1369       $LSsession_topDn_index = array();
1370       $LSsession_topDn_name = array();
1371       foreach($listTopDn as $index => $name) {
1372         $LSsession_topDn_index[]  = $index;
1373         $LSsession_topDn_name[]   = $name;
1374       }
1375       LStemplate :: assign('LSsession_subDn_indexes',$LSsession_topDn_index);
1376       LStemplate :: assign('LSsession_subDn_names',$LSsession_topDn_name);
1377       LStemplate :: assign('LSsession_subDn',self :: $topDn);
1378       LStemplate :: assign('LSsession_subDnName',self :: getSubDnName());
1379     }
1380
1381     LStemplate :: assign('LSlanguages',self :: getLangList());
1382     LStemplate :: assign('LSlang',self :: $lang);
1383     LStemplate :: assign('LSencoding',self :: $encoding);
1384     LStemplate :: assign('lang_label',_('Language'));
1385
1386     LStemplate :: assign('displayLogoutBtn',LSauth :: displayLogoutBtn());
1387     LStemplate :: assign('displaySelfAccess',LSauth :: displaySelfAccess());
1388
1389     // Infos
1390     if((!empty($_SESSION['LSsession_infos']))&&(is_array($_SESSION['LSsession_infos']))) {
1391       $txt_infos="<ul>\n";
1392       foreach($_SESSION['LSsession_infos'] as $info) {
1393         $txt_infos.="<li>$info</li>\n";
1394       }
1395       $txt_infos.="</ul>\n";
1396       LStemplate :: assign('LSinfos',$txt_infos);
1397       $_SESSION['LSsession_infos']=array();
1398     }
1399
1400     if (self :: $ajaxDisplay) {
1401       LStemplate :: assign('LSerror_txt',LSerror :: getErrors());
1402       LStemplate :: assign('LSdebug_txt',LSdebug_print(true));
1403     }
1404     else {
1405       LSerror :: display();
1406       LSdebug_print();
1407     }
1408     if (!self :: $template)
1409       self :: setTemplate('empty.tpl');
1410
1411     LStemplate :: assign('connected_as',_("Connected as"));
1412
1413     LStemplate :: display(self :: $template);
1414   }
1415
1416  /**
1417   * Défini que l'affichage se fera ou non via un retour Ajax
1418   *
1419   * @param[in] $val boolean True pour que l'affichage se fasse par un retour
1420   *                         Ajax, false sinon
1421   * @retval void
1422   */
1423   public static function setAjaxDisplay($val=true) {
1424     self :: $ajaxDisplay = (boolean)$val;
1425   }
1426
1427  /**
1428   * Affiche un retour Ajax
1429   *
1430   * @retval void
1431   */
1432   public static function displayAjaxReturn($data=array()) {
1433     if (isset($data['LSredirect']) && (!LSdebugDefined()) ) {
1434       echo json_encode($data);
1435       return;
1436     }
1437
1438     $data['LSjsConfig'] = self :: $_JSconfigParams;
1439
1440     // Infos
1441     if((!empty($_SESSION['LSsession_infos']))&&(is_array($_SESSION['LSsession_infos']))) {
1442       $txt_infos="<ul>\n";
1443       foreach($_SESSION['LSsession_infos'] as $info) {
1444         $txt_infos.="<li>$info</li>\n";
1445       }
1446       $txt_infos.="</ul>\n";
1447       $data['LSinfos'] = $txt_infos;
1448       $_SESSION['LSsession_infos']=array();
1449     }
1450
1451     if (LSerror :: errorsDefined()) {
1452       $data['LSerror'] = LSerror :: getErrors();
1453     }
1454
1455     if (isset($_REQUEST['imgload'])) {
1456       $data['imgload'] = $_REQUEST['imgload'];
1457     }
1458
1459     if (LSdebugDefined()) {
1460       $data['LSdebug'] = LSdebug_print(true,false);
1461     }
1462
1463     echo json_encode($data);
1464   }
1465
1466  /**
1467   * Retournne un template Smarty compilé
1468   *
1469   * @param[in] string $template Le template à retourner
1470   * @param[in] array $variables Variables Smarty à assigner avant l'affichage
1471   *
1472   * @retval string Le HTML compilé du template
1473   */
1474   public static function fetchTemplate($template,$variables=array()) {
1475     foreach($variables as $name => $val) {
1476       LStemplate :: assign($name,$val);
1477     }
1478     return LStemplate :: fetch($template);
1479   }
1480
1481   /**
1482    * Charge les droits LS de l'utilisateur
1483    *
1484    * @retval boolean True si le chargement Ã  rÃ©ussi, false sinon.
1485    **/
1486   private static function loadLSprofiles() {
1487     if (is_array(self :: $ldapServer['LSprofiles'])) {
1488       foreach (self :: $ldapServer['LSprofiles'] as $profile => $profileInfos) {
1489         if (is_array($profileInfos)) {
1490           foreach ($profileInfos as $topDn => $rightsInfos) {
1491             /*
1492              * If $topDn == 'LSobject', we search for each LSobject type to find
1493              * all items on witch the user will have powers.
1494              */
1495             if ($topDn == 'LSobjects') {
1496               if (is_array($rightsInfos)) {
1497                 foreach ($rightsInfos as $LSobject => $listInfos) {
1498                   if (self :: loadLSclass('LSsearch')) {
1499                     if (isset($listInfos['filter'])) {
1500                       $filter = self :: getLSuserObject() -> getFData($listInfos['filter']);
1501                     }
1502                     else {
1503                       $filter = '('.$listInfos['attr'].'='.self :: getLSuserObject() -> getFData($listInfos['attr_value']).')';
1504                     }
1505
1506                     $params = array (
1507                       'basedn' => (isset($listInfos['basedn'])?$listInfos['basedn']:null),
1508                       'filter' => $filter
1509                     );
1510
1511                     if (isset($listInfos['params']) && is_array($listInfos['params'])) {
1512                       $params = array_merge($listInfos['params'],$params);
1513                     }
1514
1515                     $LSsearch = new LSsearch($LSobject,'LSsession :: loadLSprofiles',$params,true);
1516                     $LSsearch -> run(false);
1517
1518                     $DNs = $LSsearch -> listObjectsDn();
1519                     if (!is_array(self :: $LSprofiles[$profile])) {
1520                       self :: $LSprofiles[$profile]=$DNs;
1521                     }
1522                     else {
1523                       foreach($DNs as $dn) {
1524                         if (!in_array($dn,self :: $LSprofiles[$profile])) {
1525                           self :: $LSprofiles[$profile][] = $dn;
1526                         }
1527                       }
1528                     }
1529                   }
1530                 }
1531               }
1532               else {
1533                 LSdebug('LSobjects => [] doit etre un tableau');
1534               }
1535             }
1536             else {
1537               if (is_array($rightsInfos)) {
1538                 foreach($rightsInfos as $dn => $conf) {
1539                   if ((isset($conf['attr'])) && (isset($conf['LSobject']))) {
1540                     if( self :: loadLSobject($conf['LSobject']) ) {
1541                       if ($object = new $conf['LSobject']()) {
1542                         if ($object -> loadData($dn)) {
1543                           $listDns=$object -> getValue($conf['attr']);
1544                           $valKey = (isset($conf['attr_value']))?$conf['attr_value']:'%{dn}';
1545                           $val = self :: getLSuserObject() -> getFData($valKey);
1546                           if (is_array($listDns)) {
1547                             if (in_array($val,$listDns)) {
1548                               self :: $LSprofiles[$profile][] = $topDn;
1549                             }
1550                           }
1551                         }
1552                         else {
1553                           LSdebug('Impossible de chargÃ© le dn : '.$dn);
1554                         }
1555                       }
1556                       else {
1557                         LSdebug('Impossible de crÃ©er l\'objet de type : '.$conf['LSobject']);
1558                       }
1559                     }
1560                   }
1561                   else {
1562                     if (self :: $dn == $dn) {
1563                       self :: $LSprofiles[$profile][] = $topDn;
1564                     }
1565                   }
1566                 }
1567               }
1568               else {
1569                 if ( self :: $dn == $rightsInfos ) {
1570                   self :: $LSprofiles[$profile][] = $topDn;
1571                 }
1572               }
1573             } // fin else ($topDn == 'LSobjects')
1574           } // fin foreach($profileInfos)
1575         } // fin is_array($profileInfos)
1576       } // fin foreach LSprofiles
1577       LSdebug(self :: $LSprofiles);
1578       return true;
1579     }
1580     else {
1581       return;
1582     }
1583   }
1584
1585   /**
1586    * Charge les droits d'accÃ¨s de l'utilisateur pour construire le menu de l'interface
1587    *
1588    * @retval void
1589    */
1590   private static function loadLSaccess() {
1591     $LSaccess=array();
1592     if (isset(self :: $ldapServer['subDn']) && is_array(self :: $ldapServer['subDn'])) {
1593       foreach(self :: $ldapServer['subDn'] as $name => $config) {
1594         if ($name=='LSobject') {
1595           if (is_array($config)) {
1596
1597             // Définition des subDns
1598             foreach($config as $objectType => $objectConf) {
1599               if (self :: loadLSobject($objectType)) {
1600                 if ($subdnobject = new $objectType()) {
1601                   $tbl = $subdnobject -> getSelectArray(NULL,self::getRootDn(),NULL,NULL,false);
1602                   if (is_array($tbl)) {
1603                     // Définition des accès
1604                     $access=array();
1605                     if (is_array($objectConf['LSobjects'])) {
1606                       foreach($objectConf['LSobjects'] as $type) {
1607                         if (self :: loadLSobject($type)) {
1608                           if (self :: canAccess($type)) {
1609                             $access[$type] = LSconfig :: get('LSobjects.'.$type.'.label');
1610                           }
1611                         }
1612                       }
1613                     }
1614                     foreach($tbl as $dn => $dn_name) {
1615                       $LSaccess[$dn]=$access;
1616                     }
1617                   }
1618                 }
1619               }
1620             }
1621           }
1622         }
1623         else {
1624           if ((isCompatibleDNs(self :: $ldapServer['ldap_config']['basedn'],$config['dn']))&&($config['dn']!='')) {
1625             $access=array();
1626             if (is_array($config['LSobjects'])) {
1627               foreach($config['LSobjects'] as $objectType) {
1628                 if (self :: loadLSobject($objectType)) {
1629                   if (self :: canAccess($objectType)) {
1630                     $access[$objectType] = LSconfig :: get('LSobjects.'.$objectType.'.label');
1631                   }
1632                 }
1633               }
1634             }
1635             $LSaccess[$config['dn']]=$access;
1636           }
1637         }
1638       }
1639     }
1640     else {
1641       if(is_array(self :: $ldapServer['LSaccess'])) {
1642         $access=array();
1643         foreach(self :: $ldapServer['LSaccess'] as $objectType) {
1644           if (self :: loadLSobject($objectType)) {
1645             if (self :: canAccess($objectType)) {
1646                 $access[$objectType] = LSconfig :: get('LSobjects.'.$objectType.'.label');
1647             }
1648           }
1649         }
1650         $LSaccess[self :: $topDn] = $access;
1651       }
1652     }
1653     if (LSauth :: displaySelfAccess()) {
1654       foreach($LSaccess as $dn => $access) {
1655         $LSaccess[$dn] = array_merge(
1656           array(
1657             'SELF' => 'My account'
1658           ),
1659           $access
1660         );
1661       }
1662     }
1663     self :: $LSaccess = $LSaccess;
1664     $_SESSION['LSsession']['LSaccess'] = $LSaccess;
1665   }
1666
1667   /**
1668    * Dit si l'utilisateur est du profil pour le DN spécifié
1669    *
1670    * @param[in] string $profile de l'objet
1671    * @param[in] string $dn DN de l'objet
1672    *
1673    * @retval boolean True si l'utilisateur est du profil sur l'objet, false sinon.
1674    */
1675   public static function isLSprofile($dn,$profile) {
1676     if (is_array(self :: $LSprofiles[$profile])) {
1677       foreach(self :: $LSprofiles[$profile] as $topDn) {
1678         if($dn == $topDn) {
1679           return true;
1680         }
1681         else if ( isCompatibleDNs($dn,$topDn) ) {
1682           return true;
1683         }
1684       }
1685     }
1686     return;
1687   }
1688
1689   /**
1690    * Retourne qui est l'utilisateur par rapport Ã  l'object
1691    *
1692    * @param[in] string Le DN de l'objet
1693    *
1694    * @retval string 'admin'/'self'/'user' pour Admin , l'utilisateur lui mÃªme ou un simple utilisateur
1695    */
1696   public static function whoami($dn) {
1697     $retval = array('user');
1698
1699     foreach(self :: $LSprofiles as $profile => $infos) {
1700       if(self :: isLSprofile($dn,$profile)) {
1701        $retval[]=$profile;
1702       }
1703     }
1704
1705     if (self :: $dn == $dn) {
1706       $retval[]='self';
1707     }
1708
1709     return $retval;
1710   }
1711
1712   /**
1713    * Retourne le droit de l'utilisateur Ã  accÃ¨der Ã  un objet
1714    *
1715    * @param[in] string $LSobject Le type de l'objet
1716    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par dÃ©faut)
1717    * @param[in] string $right Le type de droit d'accÃ¨s Ã  tester ('r'/'w')
1718    * @param[in] string $attr Le nom de l'attribut auquel on test l'accÃ¨s
1719    *
1720    * @retval boolean True si l'utilisateur a accÃ¨s, false sinon
1721    */
1722   public static function canAccess($LSobject,$dn=NULL,$right=NULL,$attr=NULL) {
1723     if (!self :: loadLSobject($LSobject)) {
1724       return;
1725     }
1726     if ($dn) {
1727       $whoami = self :: whoami($dn);
1728       if ($dn==self :: getLSuserObject() -> getValue('dn')) {
1729         if (!self :: in_menu('SELF')) {
1730           return;
1731         }
1732       }
1733       else {
1734         $obj = new $LSobject();
1735         $obj -> dn = $dn;
1736         if (!self :: in_menu($LSobject,$obj -> subDnValue)) {
1737           return;
1738         }
1739       }
1740     }
1741     else {
1742       $objectdn=LSconfig :: get('LSobjects.'.$LSobject.'.container_dn').','.self :: $topDn;
1743       $whoami = self :: whoami($objectdn);
1744     }
1745
1746     // Pour un attribut particulier
1747     if ($attr) {
1748       if ($attr=='rdn') {
1749         $attr=LSconfig :: get('LSobjects.'.$LSobject.'.rdn');
1750       }
1751       if (!is_array(LSconfig :: get('LSobjects.'.$LSobject.'.attrs.'.$attr))) {
1752         return;
1753       }
1754
1755       $r = 'n';
1756       foreach($whoami as $who) {
1757         $nr = LSconfig :: get('LSobjects.'.$LSobject.'.attrs.'.$attr.'.rights.'.$who);
1758         if($nr == 'w') {
1759           $r = 'w';
1760         }
1761         else if($nr == 'r') {
1762           if ($r=='n') {
1763             $r='r';
1764           }
1765         }
1766       }
1767
1768       if (($right=='r')||($right=='w')) {
1769         if ($r==$right) {
1770           return true;
1771         }
1772         return;
1773       }
1774       else {
1775         if ( ($r=='r') || ($r=='w') ) {
1776           return true;
1777         }
1778         return;
1779       }
1780     }
1781
1782     // Pour un attribut quelconque
1783     $attrs_conf=LSconfig :: get('LSobjects.'.$LSobject.'.attrs');
1784     if (is_array($attrs_conf)) {
1785       if (($right=='r')||($right=='w')) {
1786         foreach($whoami as $who) {
1787           foreach ($attrs_conf as $attr_name => $attr_config) {
1788             if (isset($attr_config['rights'][$who]) && $attr_config['rights'][$who]==$right) {
1789               return true;
1790             }
1791           }
1792         }
1793       }
1794       else {
1795         foreach($whoami as $who) {
1796           foreach ($attrs_conf as $attr_name => $attr_config) {
1797             if ( (isset($attr_config['rights'][$who])) && ( ($attr_config['rights'][$who]=='r') || ($attr_config['rights'][$who]=='w') ) ) {
1798               return true;
1799             }
1800           }
1801         }
1802       }
1803     }
1804     return;
1805   }
1806
1807   /**
1808    * Retourne le droit de l'utilisateur Ã  editer Ã  un objet
1809    *
1810    * @param[in] string $LSobject Le type de l'objet
1811    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par dÃ©faut)
1812    * @param[in] string $attr Le nom de l'attribut auquel on test l'accÃ¨s
1813    *
1814    * @retval boolean True si l'utilisateur a accÃ¨s, false sinon
1815    */
1816   public static function canEdit($LSobject,$dn=NULL,$attr=NULL) {
1817     return self :: canAccess($LSobject,$dn,'w',$attr);
1818   }
1819
1820   /**
1821    * Retourne le droit de l'utilisateur Ã  supprimer un objet
1822    *
1823    * @param[in] string $LSobject Le type de l'objet
1824    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par dÃ©faut)
1825    *
1826    * @retval boolean True si l'utilisateur a accÃ¨s, false sinon
1827    */
1828   public static function canRemove($LSobject,$dn) {
1829     return self :: canAccess($LSobject,$dn,'w','rdn');
1830   }
1831
1832   /**
1833    * Retourne le droit de l'utilisateur Ã  crÃ©er un objet
1834    *
1835    * @param[in] string $LSobject Le type de l'objet
1836    *
1837    * @retval boolean True si l'utilisateur a accÃ¨s, false sinon
1838    */
1839   public static function canCreate($LSobject) {
1840     if (!self :: loadLSobject($LSobject)) {
1841       return;
1842     }
1843     if (LSconfig :: get("LSobjects.$LSobject.disable_creation")) {
1844       return;
1845     }
1846     return self :: canAccess($LSobject,NULL,'w','rdn');
1847   }
1848
1849   /**
1850    * Retourne le droit de l'utilisateur Ã  gÃ©rer la relation d'objet
1851    *
1852    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par dÃ©faut)
1853    * @param[in] string $LSobject Le type de l'objet
1854    * @param[in] string $relationName Le nom de la relation avec l'objet
1855    * @param[in] string $right Le type de droit a vÃ©rifier ('r' ou 'w')
1856    *
1857    * @retval boolean True si l'utilisateur a accÃ¨s, false sinon
1858    */
1859   public static function relationCanAccess($dn,$LSobject,$relationName,$right=NULL) {
1860     $relConf=LSconfig :: get('LSobjects.'.$LSobject.'.LSrelation.'.$relationName);
1861     if (!is_array($relConf))
1862       return;
1863     $whoami = self :: whoami($dn);
1864
1865     if (($right=='w') || ($right=='r')) {
1866       $r = 'n';
1867       foreach($whoami as $who) {
1868         $nr = ((isset($relConf['rights'][$who]))?$relConf['rights'][$who]:'');
1869         if($nr == 'w') {
1870           $r = 'w';
1871         }
1872         else if($nr == 'r') {
1873           if ($r=='n') {
1874             $r='r';
1875           }
1876         }
1877       }
1878
1879       if ($r == $right) {
1880         return true;
1881       }
1882     }
1883     else {
1884       foreach($whoami as $who) {
1885         if ((isset($relConf['rights'][$who])) && ( ($relConf['rights'][$who] == 'w') || ($relConf['rights'][$who] == 'r') ) ) {
1886           return true;
1887         }
1888       }
1889     }
1890     return;
1891   }
1892
1893   /**
1894    * Retourne le droit de l'utilisateur Ã  modifier la relation d'objet
1895    *
1896    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par dÃ©faut)
1897    * @param[in] string $LSobject Le type de l'objet
1898    * @param[in] string $relationName Le nom de la relation avec l'objet
1899    *
1900    * @retval boolean True si l'utilisateur a accÃ¨s, false sinon
1901    */
1902   public static function relationCanEdit($dn,$LSobject,$relationName) {
1903     return self :: relationCanAccess($dn,$LSobject,$relationName,'w');
1904   }
1905
1906   /**
1907    * Retourne le droit de l'utilisateur a executer une customAction
1908    *
1909    * @param[in] string $dn Le DN de l'objet
1910    * @param[in] string $LSobject Le type de l'objet
1911    * @param[in] string $customActionName Le nom de la customAction
1912    *
1913    * @retval boolean True si l'utilisateur peut executer cette customAction, false sinon
1914    */
1915   public static function canExecuteCustomAction($dn,$LSobject,$customActionName) {
1916     $conf=LSconfig :: get('LSobjects.'.$LSobject.'.customActions.'.$customActionName);
1917     if (!is_array($conf))
1918       return;
1919     $whoami = self :: whoami($dn);
1920
1921     if (isset($conf['rights']) && is_array($conf['rights'])) {
1922       foreach($whoami as $who) {
1923         if (in_array($who,$conf['rights'])) {
1924           return True;
1925         }
1926       }
1927     }
1928
1929     return;
1930   }
1931
1932   /**
1933    * Retourne le droit de l'utilisateur a executer une customAction
1934    * sur une recherche
1935    *
1936    * @param[in] string $LSsearch L'objet LSsearch
1937    * @param[in] string $customActionName Le nom de la customAction
1938    *
1939    * @retval boolean True si l'utilisateur peut executer cette customAction, false sinon
1940    */
1941   public static function canExecuteLSsearchCustomAction($LSsearch,$customActionName) {
1942     $conf=LSconfig :: get('LSobjects.'.$LSsearch -> LSobject.'.LSsearch.customActions.'.$customActionName);
1943     if (!is_array($conf))
1944       return;
1945     $dn=$LSsearch -> basedn;
1946     if (is_null($dn)) $dn=self::getTopDn();
1947
1948     $whoami = self :: whoami($dn);
1949
1950     if (isset($conf['rights']) && is_array($conf['rights'])) {
1951       foreach($whoami as $who) {
1952         if (in_array($who,$conf['rights'])) {
1953           return True;
1954         }
1955       }
1956     }
1957
1958     return;
1959   }
1960
1961   /**
1962    * Ajoute un fichier temporaire
1963    *
1964    * @author Benjamin Renard <brenard@easter-eggs.com>
1965    *
1966    * @retval void
1967    **/
1968   public static function addTmpFile($value,$filePath) {
1969     $hash = mhash(MHASH_MD5,$value);
1970     self :: $tmp_file[$filePath] = $hash;
1971     $_SESSION['LSsession']['tmp_file'][$filePath] = $hash;
1972   }
1973
1974   /**
1975    * Retourne le chemin du fichier temporaire si l'existe
1976    *
1977    * @author Benjamin Renard <brenard@easter-eggs.com>
1978    *
1979    * @param[in] $value La valeur du fichier
1980    *
1981    * @retval mixed
1982    **/
1983   public static function tmpFileExist($value) {
1984     $hash = mhash(MHASH_MD5,$value);
1985     foreach(self :: $tmp_file as $filePath => $contentHash) {
1986       if ($hash == $contentHash) {
1987         return $filePath;
1988       }
1989     }
1990     return false;
1991   }
1992
1993   /**
1994    * Retourne le chemin du fichier temporaire
1995    *
1996    * Retourne le chemin du fichier temporaire qu'il crÃ©era Ã  partir de la valeur
1997    * s'il n'existe pas dÃ©jÃ .
1998    *
1999    * @author Benjamin Renard <brenard@easter-eggs.com>
2000    *
2001    * @param[in] $value La valeur du fichier
2002    *
2003    * @retval mixed
2004    **/
2005   public static function getTmpFile($value) {
2006     $exist = self :: tmpFileExist($value);
2007     if (!$exist) {
2008       $img_path = LS_TMP_DIR .rand().'.tmp';
2009       $fp = fopen($img_path, "w");
2010       fwrite($fp, $value);
2011       fclose($fp);
2012       self :: addTmpFile($value,$img_path);
2013       return $img_path;
2014     }
2015     else {
2016       return $exist;
2017     }
2018   }
2019
2020   /**
2021    * Supprime les fichiers temporaires
2022    *
2023    * @author Benjamin Renard <brenard@easter-eggs.com>
2024    *
2025    * @retval void
2026    **/
2027   public static function deleteTmpFile($filePath=NULL) {
2028     if ($filePath) {
2029         @unlink($filePath);
2030         unset(self :: $tmp_file[$filePath]);
2031         unset($_SESSION['LSsession']['tmp_file'][$filePath]);
2032     }
2033     else {
2034       foreach(self :: $tmp_file as $file => $content) {
2035         @unlink($file);
2036       }
2037       self :: $tmp_file = array();
2038       $_SESSION['LSsession']['tmp_file'] = array();
2039     }
2040   }
2041
2042   /**
2043    * Retourne true si le cache des droits est activé
2044    *
2045    * @author Benjamin Renard <brenard@easter-eggs.com>
2046    *
2047    * @retval boolean True si le cache des droits est activé, false sinon.
2048    */
2049   public static function cacheLSprofiles() {
2050     return ( (LSconfig :: get('cacheLSprofiles')) || (self :: $ldapServer['cacheLSprofiles']) );
2051   }
2052
2053   /**
2054    * Retourne true si le cache des subDn est activé
2055    *
2056    * @author Benjamin Renard <brenard@easter-eggs.com>
2057    *
2058    * @retval boolean True si le cache des subDn est activé, false sinon.
2059    */
2060   public static function cacheSudDn() {
2061     return ( (LSconfig :: get('cacheSubDn')) || (self :: $ldapServer['cacheSubDn']));
2062   }
2063
2064   /**
2065    * Retourne true si le cache des recherches est activé
2066    *
2067    * @author Benjamin Renard <brenard@easter-eggs.com>
2068    *
2069    * @retval boolean True si le cache des recherches est activé, false sinon.
2070    */
2071   public static function cacheSearch() {
2072     return ( (LSconfig :: get('cacheSearch')) || (self :: $ldapServer['cacheSearch']));
2073   }
2074
2075   /**
2076    * Retourne le label des niveaux pour le serveur ldap courant
2077    *
2078    * @author Benjamin Renard <brenard@easter-eggs.com>
2079    *
2080    * @retval string Le label des niveaux pour le serveur ldap dourant
2081    */
2082   public static function getSubDnLabel() {
2083     return (self :: $ldapServer['subDnLabel']!='')?__(self :: $ldapServer['subDnLabel']):_('Level');
2084   }
2085
2086   /**
2087    * Retourne le nom du subDn
2088    *
2089    * @param[in] $subDn string subDn
2090    *
2091    * @retval string Le nom du subDn ou '' sinon
2092    */
2093   public static function getSubDnName($subDn=false) {
2094     if (!$subDn) {
2095       $subDn = self :: $topDn;
2096     }
2097     if (self :: getSubDnLdapServer(false)) {
2098       if (isset(self :: $_subDnLdapServer[self :: $ldapServerId][false][$subDn])) {
2099         return self :: $_subDnLdapServer[self :: $ldapServerId][false][$subDn];
2100       }
2101     }
2102     return '';
2103   }
2104
2105   /**
2106    * L'objet est t-il utilisé pour listé les subDnS
2107    *
2108    * @param[in] $type string Le type d'objet
2109    *
2110    * @retval boolean true si le type d'objet est un subDnObject, false sinon
2111    */
2112   public static function isSubDnLSobject($type) {
2113     $result = false;
2114     if (isset(self :: $ldapServer['subDn']['LSobject']) && is_array(self :: $ldapServer['subDn']['LSobject'])) {
2115       foreach(self :: $ldapServer['subDn']['LSobject'] as $key => $value) {
2116         if ($key==$type) {
2117           $result=true;
2118         }
2119       }
2120     }
2121     return $result;
2122   }
2123
2124   /**
2125    * Indique si un type d'objet est dans le menu courant
2126    *
2127    * @retval boolean true si le type d'objet est dans le menu, false sinon
2128    */
2129   public static function in_menu($LSobject,$topDn=NULL) {
2130     if (!$topDn) {
2131       $topDn=self :: $topDn;
2132     }
2133     return isset(self :: $LSaccess[$topDn][$LSobject]);
2134   }
2135
2136   /**
2137    * Indique si le serveur LDAP courant a des subDn
2138    *
2139    * @retval boolean true si le serveur LDAP courant a des subDn, false sinon
2140    */
2141   public static function haveSubDn() {
2142     return (isset(self :: $ldapServer['subDn']) && is_array(self :: $ldapServer['subDn']));
2143   }
2144
2145   /**
2146    * Ajoute une information à afficher
2147    *
2148    * @param[in] $msg string Le message à afficher
2149    *
2150    * @retval void
2151    */
2152   public static function addInfo($msg) {
2153     $_SESSION['LSsession_infos'][]=$msg;
2154   }
2155
2156   /**
2157    * Redirection de l'utilisateur vers une autre URL
2158    *
2159    * @param[in] $url string L'URL
2160    * @param[in] $exit boolean Si true, l'execution script s'arrête après la redirection
2161    *
2162    * @retval void
2163    */
2164   public static function redirect($url,$exit=true) {
2165     LStemplate :: assign('url',$url);
2166     LStemplate :: display('redirect.tpl');
2167     if ($exit) {
2168       exit();
2169     }
2170   }
2171
2172   /**
2173    * Retourne l'adresse mail d'emission configurée pour le serveur courant
2174    *
2175    * @retval string Adresse mail d'emission
2176    */
2177   public static function getEmailSender() {
2178     return self :: $ldapServer['emailSender'];
2179   }
2180
2181   /**
2182    * Ajout d'une information d'aide
2183    *
2184    * @param[in] $group string Le nom du groupe d'infos dans lequels ajouter
2185    *                          celle-ci
2186    * @param[in] $infos array  Tableau array(name => value) des infos
2187    *
2188    * @retval void
2189    */
2190   public static function addHelpInfos($group,$infos) {
2191     if (is_array($infos)) {
2192       if (isset(self :: $_JSconfigParams['helpInfos'][$group]) && is_array(self :: $_JSconfigParams['helpInfos'][$group])) {
2193         self :: $_JSconfigParams['helpInfos'][$group] = array_merge(self :: $_JSconfigParams['helpInfos'][$group],$infos);
2194       }
2195       else {
2196         self :: $_JSconfigParams['helpInfos'][$group] = $infos;
2197       }
2198     }
2199   }
2200
2201  /**
2202   * Défini les codes erreur relative à la classe LSsession
2203   *
2204   * @retval void
2205   */
2206   private static function defineLSerrors() {
2207     /*
2208      * Error Codes
2209      */
2210     LSerror :: defineError('LSsession_01',
2211     _("LSsession : The constant %{const} is not defined.")
2212     );
2213     LSerror :: defineError('LSsession_02',
2214     _("LSsession : The %{addon} support is uncertain. Verify system compatibility and the add-on configuration.")
2215     );
2216     LSerror :: defineError('LSsession_03',
2217     _("LSsession : LDAP server's configuration data are invalid. Can't connect.")
2218     );
2219     LSerror :: defineError('LSsession_04',
2220     _("LSsession : Failed to load LSobject type %{type} : unknon type.")
2221     );
2222     LSerror :: defineError('LSsession_05',
2223     _("LSsession : Failed to load LSclass %{class}.")
2224     );
2225     LSerror :: defineError('LSsession_06',
2226     _("LSsession : Login or password incorrect.")
2227     );
2228     LSerror :: defineError('LSsession_07',
2229     _("LSsession : Impossible to identify you : Duplication of identities.")
2230     );
2231     LSerror :: defineError('LSsession_08',
2232     _("LSsession : Can't load class of authentification (%{class}).")
2233     );
2234     LSerror :: defineError('LSsession_09',
2235     _("LSsession : Can't connect to LDAP server.")
2236     );
2237     LSerror :: defineError('LSsession_10',
2238     _("LSsession : Impossible to authenticate you.")
2239     );
2240     LSerror :: defineError('LSsession_11',
2241     _("LSsession : Your are not authorized to do this action.")
2242     );
2243     LSerror :: defineError('LSsession_12',
2244     _("LSsession : Some informations are missing to display this page.")
2245     );
2246     LSerror :: defineError('LSsession_13',
2247     _("LSsession : The function of the custom action %{name} does not exists or is not configured.")
2248     );
2249     LSerror :: defineError('LSsession_14',
2250     _("LSsession : Fail to retreive user's LDAP credentials from LSauth.")
2251     );
2252     LSerror :: defineError('LSsession_15',
2253     _("LSsession : Fail to reconnect to LDAP server with user's LDAP credentials.")
2254     );
2255     // 16 : not yet used
2256     LSerror :: defineError('LSsession_17',
2257     _("LSsession : Error during creation of list of levels. Contact administrators. (Code : %{code})")
2258     );
2259     LSerror :: defineError('LSsession_18',
2260     _("LSsession : The password recovery is disabled for this LDAP server.")
2261     );
2262     LSerror :: defineError('LSsession_19',
2263     _("LSsession : Some informations are missing to recover your password. Contact administrators.")
2264     );
2265     LSerror :: defineError('LSsession_20',
2266     _("LSsession : Error during password recovery. Contact administrators.(Step : %{step})")
2267     );
2268     // 21 : not yet used
2269     LSerror :: defineError('LSsession_22',
2270     _("LSsession : problem during initialisation.")
2271     );
2272   }
2273
2274   /**
2275    * Ajax method when change ldapserver on login form
2276    *
2277    * @param[in] $data array The return data address
2278    *
2279    * @retval void
2280    **/
2281   public static function ajax_onLdapServerChangedLogin(&$data) {
2282     if ( isset($_REQUEST['server']) ) {
2283       self :: setLdapServer($_REQUEST['server']);
2284       $data = array();
2285       if ( self :: LSldapConnect() ) {
2286         if (session_id()=="") session_start();
2287         if (isset($_SESSION['LSsession_topDn'])) {
2288           $sel = $_SESSION['LSsession_topDn'];
2289         }
2290         else {
2291           $sel = NULL;
2292         }
2293         $list = self :: getSubDnLdapServerOptions($sel,true);
2294         if (is_string($list)) {
2295           $data['list_topDn'] = "<select name='LSsession_topDn' id='LSsession_topDn'>".$list."</select>";
2296           $data['subDnLabel'] = self :: getSubDnLabel();
2297         }
2298       }
2299       $data['recoverPassword'] = isset(self :: $ldapServer['recoverPassword']);
2300     }
2301   }
2302
2303   /**
2304    * Ajax method when change ldapserver on recoverPassword form
2305    *
2306    * @param[in] $data array The return data address
2307    *
2308    * @retval void
2309    **/
2310   public static function ajax_onLdapServerChangedRecoverPassword(&$data) {
2311     if ( isset($_REQUEST['server']) ) {
2312       self :: setLdapServer($_REQUEST['server']);
2313       $data=array('recoverPassword' => isset(self :: $ldapServer['recoverPassword']));
2314     }
2315   }
2316 }
2317
2318 ?>