- LSldapObject : Modification de la méthode searchObject() pour prendre eventuellement
[ldapsaisie.git] / trunk / includes / class / class.LSsession.php
index 4b6a5f5..f1e3411 100644 (file)
@@ -21,6 +21,7 @@
 ******************************************************************************/
 
 define('LS_DEFAULT_CONF_DIR','conf');
+require_once 'includes/functions.php';
 
 /**
  * Gestion des sessions
@@ -31,38 +32,72 @@ define('LS_DEFAULT_CONF_DIR','conf');
  */
 class LSsession {
 
-  var $confDir = NULL;
-  var $ldapServer = NULL;
-  var $ldapServerId = NULL;
-  var $topDn = NULL;
-  var $LSuserObject = NULL;
-  var $dn = NULL;
-  var $rdn = NULL;
-  var $JSscripts = array();
-  var $_JSconfigParams = array();
-  var $CssFiles = array();
-  var $template = NULL;
-  var $LSrights = array();
-  var $LSaccess = array();
-  var $tmp_file = array();
-  var $_subDnLdapServer = array();
-  var $ajaxDisplay = false;
-
-  /**
-   * Constructeur
-   *
-   * @author Benjamin Renard <brenard@easter-eggs.com>
-   *
-   * @retval void
+  // La configuration du serveur Ldap utilisé
+  public static $ldapServer = NULL;
+  
+  // L'id du serveur Ldap utilisé
+  private static $ldapServerId = NULL;
+  
+  // Le topDn courant
+  private static $topDn = NULL;
+  
+  // Le DN de l'utilisateur connecté
+  private static $dn = NULL;
+  
+  // Le RDN de l'utilisateur connecté (son identifiant)
+  private static $rdn = NULL;
+  
+  // Les LSprofiles de l'utilisateur
+  private static $LSprofiles = array();
+  
+  // Les droits d'accès de l'utilisateur
+  private static $LSaccess = array();
+  
+  // Les fichiers temporaires
+  private static $tmp_file = array();
+  
+  /*
+   * Constante de classe non stockée en session
    */
-  function LSsession ($configDir=LS_DEFAULT_CONF_DIR) {
-    $this -> confDir = $configDir;
-    if ($this -> loadConfig()) {
-      $this -> startLSerror();
+  // Le template à afficher
+  private static $template = NULL;
+  
+  // Les subDn des serveurs Ldap
+  private static $_subDnLdapServer = array();
+  
+  // Affichage Ajax
+  private static $ajaxDisplay = false;
+
+  // Les fichiers JS à charger dans la page
+  private static $JSscripts = array();
+  
+  // Les paramètres JS à communiquer dans la page
+  private static $_JSconfigParams = array();
+  
+  // Les fichiers CSS à charger dans la page
+  private static $CssFiles = array();
+
+  // L'objet de l'utilisateur connecté
+  private static $LSuserObject = NULL;
+
+ /**
+  * Include un fichier PHP
+  *
+  * @author Benjamin Renard <brenard@easter-eggs.com>
+  *
+  * @retval true si tout c'est bien passé, false sinon
+  */
+  public static function includeFile($file) {
+    if (!file_exists($file)) {
+      return;
+    }
+    if ($GLOBALS['LSdebug']['active']) {
+      return include_once($file);
     }
     else {
-      return;
+      return @include_once($file);
     }
+    return;
   }
 
  /**
@@ -74,9 +109,9 @@ class LSsession {
   *
   * @retval true si tout c'est bien passé, false sinon
   */
-  function loadConfig() {
-    if (loadDir($this -> confDir, '^config\..*\.php$')) {
-      if ( include_once $GLOBALS['LSconfig']['Smarty'] ) {
+  private static function loadConfig() {
+    if (loadDir(LS_DEFAULT_CONF_DIR, '^config\..*\.php$')) {
+      if ( self :: includeFile($GLOBALS['LSconfig']['Smarty']) ) {
         $GLOBALS['Smarty'] = new Smarty();
         $GLOBALS['Smarty'] -> template_dir = LS_TEMPLATES_DIR;
         $GLOBALS['Smarty'] -> compile_dir = LS_TMP_DIR;
@@ -84,18 +119,24 @@ class LSsession {
         $GLOBALS['Smarty'] -> assign('LS_CSS_DIR',LS_CSS_DIR);
         $GLOBALS['Smarty'] -> assign('LS_IMAGES_DIR',LS_IMAGES_DIR);
         
-        $this -> addJSconfigParam('LS_IMAGES_DIR',LS_IMAGES_DIR);
+        self :: addJSconfigParam('LS_IMAGES_DIR',LS_IMAGES_DIR);
         return true;
       }
       else {
-        die($GLOBALS['LSerror_code'][1008]['msg']);
+        die("ERROR : Can't load Smarty.");
         return;
       }
       return true;
     }
     else {
+      die("ERROR : Can't load configuration files.");
       return;
     }
+    
+  }
+  
+  public static function getTopDn() {
+    return self :: $topDn;
   }
 
  /**
@@ -107,10 +148,11 @@ class LSsession {
   *
   * @retval boolean true si l'initialisation a réussi, false sinon.
   */
-  function startLSerror() {
-    if(!$this -> loadLSclass('LSerror'))
+  private static function startLSerror() {
+    if(!self :: loadLSclass('LSerror')) {
       return;
-    $GLOBALS['LSerror'] = new LSerror();
+    }
+    self :: defineLSerrors();
     return true;
   }
 
@@ -124,12 +166,12 @@ class LSsession {
   * 
   * @retval boolean true si le chargement a réussi, false sinon.
   */
-  function loadLSclass($class,$type='') {
+  public static function loadLSclass($class,$type='') {
     if (class_exists($class))
       return true;
     if($type!='')
       $type=$type.'.';
-    return include_once LS_CLASS_DIR .'class.'.$type.$class.'.php';
+    return self :: includeFile(LS_CLASS_DIR .'class.'.$type.$class.'.php');
   }
 
  /**
@@ -139,12 +181,17 @@ class LSsession {
   *
   * @retval boolean true si le chargement a réussi, false sinon.
   */
-  function loadLSobject($object) {
-    $this -> loadLSclass('LSldapObject');
-    if (!$this -> loadLSclass($object,'LSobjects')) {
-      return;
+  public static function loadLSobject($object) {
+    $error = 0;
+    self :: loadLSclass('LSldapObject');
+    if (!self :: loadLSclass($object,'LSobjects')) {
+      $error = 1;
+    }
+    if (!self :: includeFile( LS_OBJECTS_DIR . 'config.LSobjects.'.$object.'.php' )) {
+      $error = 1;
     }
-    if (!require_once( LS_OBJECTS_DIR . 'config.LSobjects.'.$object.'.php' )) {
+    if ($error) {
+      LSerror :: addErrorCode('LSsession_04',$object);
       return;
     }
     return true;
@@ -159,10 +206,11 @@ class LSsession {
   * 
   * @retval boolean true si le chargement a réussi, false sinon.
   */
-  function loadLSaddon($addon) {
-    if(require_once LS_ADDONS_DIR .'LSaddons.'.$addon.'.php') {
+  public static function loadLSaddon($addon) {
+    if(self :: includeFile(LS_ADDONS_DIR .'LSaddons.'.$addon.'.php')) {
+      self :: includeFile(LS_CONF_DIR."LSaddons/config.LSaddons.".$addon.".php");
       if (!call_user_func('LSaddon_'. $addon .'_support')) {
-        $GLOBALS['LSerror'] -> addErrorCode(1002,$addon);
+        LSerror :: addErrorCode('LSsession_02',$addon);
         return;
       }
       return true;
@@ -178,18 +226,32 @@ class LSsession {
   *
   * @retval boolean true si le chargement a réussi, false sinon.
   */
-  function loadLSaddons() {
+  public static function loadLSaddons() {
     if(!is_array($GLOBALS['LSaddons']['loads'])) {
-      $GLOBALS['LSerror'] -> addErrorCode(1001,"LSaddons['loads']");
+      LSerror :: addErrorCode('LSsession_01',"LSaddons['loads']");
       return;
     }
 
     foreach ($GLOBALS['LSaddons']['loads'] as $addon) {
-      $this -> loadLSaddon($addon);
+      self :: loadLSaddon($addon);
     }
     return true;
   }
 
+/**
+  * Initialisation LdapSaisie
+  *
+  * @retval boolean True si l'initialisation à réussi, false sinon.
+  */
+  public static function initialize() {
+    if (!self :: loadConfig()) {
+      return;
+    }   
+    self :: startLSerror();
+    self :: loadLSaddons();
+    return true;
+  }
+
  /**
   * Initialisation de la session LdapSaisie
   *
@@ -201,302 +263,357 @@ class LSsession {
   *
   * @retval boolean True si l'initialisation Ã  réussi (utilisateur authentifié), false sinon.
   */
-  function startLSsession() {
-      $this -> loadLSaddons();
-      session_start();
+  public static function startLSsession() {
+    if (!self :: initialize()) {
+      return;
+    }   
 
-      // Déconnexion
-      if (isset($_GET['LSsession_logout'])||isset($_GET['LSsession_recoverPassword'])) {
-        session_destroy();
-        
-        if (is_array($_SESSION['LSsession']['tmp_file'])) {
-          $this -> tmp_file = $_SESSION['LSsession']['tmp_file'];
-        }
-        $this -> deleteTmpFile();
-        unset($_SESSION['LSsession']);
+    session_start();
+
+    // Déconnexion
+    if (isset($_GET['LSsession_logout'])||isset($_GET['LSsession_recoverPassword'])) {
+      session_destroy();
+      
+      if (is_array($_SESSION['LSsession']['tmp_file'])) {
+        self :: $tmp_file = $_SESSION['LSsession']['tmp_file'];
+      }
+      self :: deleteTmpFile();
+      unset($_SESSION['LSsession']);
+    }
+    
+    // Récupération de mot de passe
+    if (isset($_GET['recoveryHash'])) {
+      $_POST['LSsession_user'] = 'a determiner plus tard';
+    }
+    
+    if(isset($_SESSION['LSsession'])) {
+      // Session existante
+      self :: $topDn        = $_SESSION['LSsession']['topDn'];
+      self :: $dn           = $_SESSION['LSsession']['dn'];
+      self :: $rdn          = $_SESSION['LSsession']['rdn'];
+      self :: $ldapServerId = $_SESSION['LSsession']['ldapServerId'];
+      self :: $tmp_file     = $_SESSION['LSsession']['tmp_file'];
+      
+      if ( self :: cacheLSprofiles() && !isset($_REQUEST['LSsession_refresh']) ) {
+        self :: setLdapServer(self :: $ldapServerId);
+        self :: $LSprofiles   = $_SESSION['LSsession']['LSprofiles'];
+        self :: $LSaccess   = $_SESSION['LSsession']['LSaccess'];
+        if (!self :: LSldapConnect())
+          return;
+      }
+      else {
+        self :: setLdapServer(self :: $ldapServerId);
+        if (!self :: LSldapConnect())
+          return;
+        self :: loadLSprofiles();
       }
       
-      // Récupération de mot de passe
-      if (isset($_GET['recoveryHash'])) {
-        $_POST['LSsession_user'] = 'a determiner plus tard';
+      if ( self :: cacheSudDn() && (!isset($_REQUEST['LSsession_refresh'])) ) {
+        self :: $_subDnLdapServer = $_SESSION['LSsession_subDnLdapServer'];
       }
       
-      if(isset($_SESSION['LSsession'])) {
-        // Session existante
-        $this -> confDir      = $_SESSION['LSsession']['confDir'];
-        $this -> topDn        = $_SESSION['LSsession']['topDn'];
-        $this -> dn           = $_SESSION['LSsession']['dn'];
-        $this -> rdn          = $_SESSION['LSsession']['rdn'];
-        $this -> ldapServerId = $_SESSION['LSsession']['ldapServerId'];
-        $this -> tmp_file     = $_SESSION['LSsession']['tmp_file'];
-        
-        if ( $this -> cacheLSrights() && !isset($_REQUEST['LSsession_refresh']) ) {
-          $this -> ldapServer = $_SESSION['LSsession']['ldapServer'];
-          $this -> LSrights   = $_SESSION['LSsession']['LSrights'];
-          $this -> LSaccess   = $_SESSION['LSsession']['LSaccess'];
-          if (!$this -> LSldapConnect())
-            return;
+      if (!self :: loadLSobject(self :: $ldapServer['authObjectType'])) {
+        return;
+      }
+      
+      self :: getLSuserObject();
+      
+      if ( !self :: cacheLSprofiles() || isset($_REQUEST['LSsession_refresh']) ) {
+        self :: loadLSaccess();
+      }
+      
+      $GLOBALS['Smarty'] -> assign('LSsession_username',self :: getLSuserObject() -> getDisplayName());
+      
+      if ($_POST['LSsession_topDn']) {
+        if (self :: validSubDnLdapServer($_POST['LSsession_topDn'])) {
+          self :: $topDn = $_POST['LSsession_topDn'];
+          $_SESSION['LSsession']['topDn'] = $_POST['LSsession_topDn'];
+        } // end if
+      } // end if
+      
+      return true;
+      
+    }
+    else {
+      // Session inexistante
+      $recoveryPasswordInfos=array();
+
+      if (isset($_POST['LSsession_user'])) {
+        if (isset($_POST['LSsession_ldapserver'])) {
+          self :: setLdapServer($_POST['LSsession_ldapserver']);
         }
         else {
-          $this -> setLdapServer($this -> ldapServerId);
-          if (!$this -> LSldapConnect())
-            return;
-          $this -> loadLSrights();
+          self :: setLdapServer(0);
         }
         
-        if ( $this -> cacheSudDn() && (!isset($_REQUEST['LSsession_refresh'])) ) {
-          $this -> _subDnLdapServer = $_SESSION['LSsession_subDnLdapServer'];
-        }
-        
-        if (!$this -> loadLSobject($this -> ldapServer['authobject'])) {
-          $GLOBALS['LSerror'] -> addErrorCode(1004,$this -> ldapServer['authobject']);
-          return;
-        }
-        
-        $this -> LSuserObject = new $this -> ldapServer['authobject']();
-        $this -> LSuserObject -> loadData($this -> dn);
-        
-        if ( !$this -> cacheLSrights() || isset($_REQUEST['LSsession_refresh']) ) {
-          $this -> loadLSaccess();
-        }
-        
-        $GLOBALS['Smarty'] -> assign('LSsession_username',$this -> LSuserObject -> getDisplayValue());
-        
-        if ($_POST['LSsession_topDn']) {
-          if ($this -> validSubDnLdapServer($_POST['LSsession_topDn'])) {
-            $this -> topDn = $_POST['LSsession_topDn'];
-            $_SESSION['LSsession']['topDn'] = $_POST['LSsession_topDn'];
-          } // end if
-        } // end if
-        
-        return true;
-        
-      }
-      else {
-        // Session inexistante
-        $recoveryPasswordInfos=array();
+        // Connexion au serveur LDAP
+        if (self :: LSldapConnect()) {
 
-        if (isset($_POST['LSsession_user'])) {
-          if (isset($_POST['LSsession_ldapserver'])) {
-            $this -> setLdapServer($_POST['LSsession_ldapserver']);
+          // topDn
+          if ( $_POST['LSsession_topDn'] != '' ){
+            self :: $topDn = $_POST['LSsession_topDn'];
           }
           else {
-            $this -> setLdapServer(0);
+            self :: $topDn = self :: $ldapServer['ldap_config']['basedn'];
           }
-          
-          // Connexion au serveur LDAP
-              if ($this -> LSldapConnect()) {
+          $_SESSION['LSsession_topDn']=self :: $topDn;
 
-            // topDn
-            if ( $_POST['LSsession_topDn'] != '' ){
-              $this -> topDn = $_POST['LSsession_topDn'];
+          if ( self :: loadLSobject(self :: $ldapServer['authObjectType']) ) {
+            $authobject = new self :: $ldapServer['authObjectType']();
+            $find=true;
+            if (isset($_GET['recoveryHash'])) {
+              $filter=self :: $ldapServer['recoverPassword']['recoveryHashAttr']."=".$_GET['recoveryHash'];
+              $result = $authobject -> listObjects($filter,self :: $topDn);
+              $nbresult=count($result);
+              if ($nbresult==1) {
+                $rdn = $result[0] -> getValue('rdn');
+                $rdn = $rdn[0];
+                $_POST['LSsession_user'] = $rdn;
+                $find=false;
+              }
             }
-            else {
-              $this -> topDn = $this -> ldapServer['ldap_config']['basedn'];
+            if ($find) {
+              $result = $authobject -> searchObject($_POST['LSsession_user'],self :: $topDn,self :: $ldapServer['authObjectFilter']);
+              $nbresult=count($result);
             }
-            $_SESSION['LSsession_topDn']=$this -> topDn;
+            if ($nbresult==0) {
+              // identifiant incorrect
+              LSdebug('identifiant incorrect');
+              LSerror :: addErrorCode('LSsession_06');
+            }
+            else if ($nbresult>1) {
+              // duplication d'authentité
+              LSerror :: addErrorCode('LSsession_07');
+            }
+            else {
+              if (isset($_GET['LSsession_recoverPassword'])) {
+                LSdebug('Recover : Id trouvé');
+                if (self :: $ldapServer['recoverPassword']) {
+                  if (self :: loadLSaddon('mail')) {
+                    LSdebug('Récupération active');
+                    $user=$result[0];
+                    $emailAddress = $user -> getValue(self :: $ldapServer['recoverPassword']['mailAttr']);
+                    $emailAddress = $emailAddress[0];
+                    
+                    // Header des mails
+                    $sendParams=array();
+                    if (self :: $ldapServer['recoverPassword']['recoveryEmailSender']) {
+                      $sendParams['From']=self :: $ldapServer['recoverPassword']['recoveryEmailSender'];
+                    }
+                    
+                    if (checkEmail($emailAddress)) {
+                      LSdebug('Email : '.$emailAddress);
+                      self :: $dn = $user -> getDn();
+                      // 1ère étape : envoie du recoveryHash
+                      if (!isset($_GET['recoveryHash'])) {
+                        // Generer un hash
+                        $rdn=$user -> getValue('rdn');
+                        $rdn = $rdn[0];
+                        $recovery_hash = md5($rdn . strval(time()) . strval(rand()));
+                        
+                        $lostPasswdForm = $user -> getForm('lostPassword');
+                        $lostPasswdForm -> setPostData(
+                          array(
+                            self :: $ldapServer['recoverPassword']['recoveryHashAttr'] => $recovery_hash
+                          )
+                          ,true
+                        );
+                        
+                        if($lostPasswdForm -> validate()) {
+                          if ($user -> updateData('lostPassword')) {
+                            // recoveryHash de l'utilisateur mis à jour
+                            if ($_SERVER['HTTPS']=='on') {
+                              $recovery_url='https://';
+                            }
+                            else {
+                              $recovery_url='http://';
+                            }
+                            $recovery_url .= $_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'].'&recoveryHash='.$recovery_hash;
 
-            if ( $this -> loadLSobject($this -> ldapServer['authobject']) ) {
-              $authobject = new $this -> ldapServer['authobject']();
-              $find=true;
-              if (isset($_GET['recoveryHash'])) {
-                $filter=$this -> ldapServer['recoverPassword']['recoveryHashAttr']."=".$_GET['recoveryHash'];
-                $result = $authobject -> listObjects($filter,$this -> topDn);
-                $nbresult=count($result);
-                if ($nbresult==1) {
-                  $rdn = $result[0] -> getValue('rdn');
-                  $rdn = $rdn[0];
-                  $_POST['LSsession_user'] = $rdn;
-                  $find=false;
-                }
-              }
-              if ($find) {
-                $result = $authobject -> searchObject($_POST['LSsession_user'],$this -> topDn);
-                $nbresult=count($result);
-              }
-              if ($nbresult==0) {
-                // identifiant incorrect
-                LSdebug('identifiant incorrect');
-                $GLOBALS['LSerror'] -> addErrorCode(1006);
-              }
-              else if ($nbresult>1) {
-                // duplication d'authentité
-                $GLOBALS['LSerror'] -> addErrorCode(1007);
-              }
-              else {
-                if (isset($_GET['LSsession_recoverPassword'])) {
-                  LSdebug('Recover : Id trouvé');
-                  if ($this -> ldapServer['recoverPassword']) {
-                    if ($this -> loadLSaddon('mail')) {
-                      LSdebug('Récupération active');
-                      $user=$result[0];
-                      $emailAddress = $user -> getValue($this -> ldapServer['recoverPassword']['mailAttr']);
-                      $emailAddress = $emailAddress[0];
-                      
-                      // Header des mails
-                      $sendParams=array();
-                      if ($this -> ldapServer['recoverPassword']['recoveryEmailSender']) {
-                        $sendParams['From']=$this -> ldapServer['recoverPassword']['recoveryEmailSender'];
+                            if (
+                              sendMail(
+                                $emailAddress,
+                                self :: $ldapServer['recoverPassword']['recoveryHashMail']['subject'],
+                                getFData(self :: $ldapServer['recoverPassword']['recoveryHashMail']['msg'],$recovery_url),
+                                $sendParams
+                              )
+                            ){
+                              // Mail a bien été envoyé
+                              $recoveryPasswordInfos['recoveryHashMail']=$emailAddress;
+                            }
+                            else {
+                              // Problème durant l'envoie du mail
+                              LSdebug("Problème durant l'envoie du mail");
+                              LSerror :: addErrorCode('LSsession_20',7);
+                            }
+                          }
+                          else {
+                            // Erreur durant la mise à jour de l'objet
+                            LSdebug("Erreur durant la mise à jour de l'objet");
+                            LSerror :: addErrorCode('LSsession_20',6);
+                          }
+                        }
+                        else {
+                          // Erreur durant la validation du formulaire de modification de perte de password
+                          LSdebug("Erreur durant la validation du formulaire de modification de perte de password");
+                          LSerror :: addErrorCode('LSsession_20',5);
+                        }
                       }
-                      
-                      if (checkEmail($emailAddress)) {
-                        LSdebug('Email : '.$emailAddress);
-                        $this -> dn = $user -> getDn();
-                        // 1ère étape : envoie du recoveryHash
-                        if (!isset($_GET['recoveryHash'])) {
-                          // Generer un hash
-                          $rdn=$user -> getValue('rdn');
-                          $rdn = $rdn[0];
-                          $recovery_hash = md5($rdn . strval(time()) . strval(rand()));
-                          
+                      // 2nd étape : génération du mot de passe + envoie par mail
+                      else {
+                        $attr=$user -> attrs[self :: $ldapServer['authObjectTypeAttrPwd']];
+                        if ($attr instanceof LSattribute) {
+                          $mdp = generatePassword($attr -> config['html_options']['chars'],$attr -> config['html_options']['lenght']);
+                          LSdebug('Nvx mpd : '.$mdp);
                           $lostPasswdForm = $user -> getForm('lostPassword');
                           $lostPasswdForm -> setPostData(
                             array(
-                              $this -> ldapServer['recoverPassword']['recoveryHashAttr'] => $recovery_hash
+                              self :: $ldapServer['recoverPassword']['recoveryHashAttr'] => array(''),
+                              self :: $ldapServer['authObjectTypeAttrPwd'] => array($mdp)
                             )
                             ,true
                           );
-                          
                           if($lostPasswdForm -> validate()) {
                             if ($user -> updateData('lostPassword')) {
-                              // recoveryHash de l'utilisateur mis à jour
-                              if ($_SERVER['HTTPS']=='on') {
-                                $recovery_url='https://';
-                              }
-                              else {
-                                $recovery_url='http://';
-                              }
-                              $recovery_url .= $_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'].'&recoveryHash='.$recovery_hash;
-
                               if (
                                 sendMail(
                                   $emailAddress,
-                                  $this -> ldapServer['recoverPassword']['recoveryHashMail']['subject'],
-                                  getFData($this -> ldapServer['recoverPassword']['recoveryHashMail']['msg'],$recovery_url),
+                                  self :: $ldapServer['recoverPassword']['newPasswordMail']['subject'],
+                                  getFData(self :: $ldapServer['recoverPassword']['newPasswordMail']['msg'],$mdp),
                                   $sendParams
                                 )
                               ){
                                 // Mail a bien été envoyé
-                                $recoveryPasswordInfos['recoveryHashMail']=$emailAddress;
+                                $recoveryPasswordInfos['newPasswordMail']=$emailAddress;
                               }
                               else {
                                 // Problème durant l'envoie du mail
                                 LSdebug("Problème durant l'envoie du mail");
-                                $GLOBALS['LSerror'] -> addErrorCode(1020);
+                                LSerror :: addErrorCode('LSsession_20',4);
                               }
                             }
                             else {
                               // Erreur durant la mise à jour de l'objet
                               LSdebug("Erreur durant la mise à jour de l'objet");
-                              $GLOBALS['LSerror'] -> addErrorCode(1020);
+                              LSerror :: addErrorCode('LSsession_20',3);
                             }
                           }
                           else {
                             // Erreur durant la validation du formulaire de modification de perte de password
                             LSdebug("Erreur durant la validation du formulaire de modification de perte de password");
-                            $GLOBALS['LSerror'] -> addErrorCode(1020);
+                            LSerror :: addErrorCode('LSsession_20',2);
                           }
                         }
-                        // 2nd étape : génération du mot de passe + envoie par mail
                         else {
-                          $attr=$user -> attrs[$this -> ldapServer['authobject_pwdattr']];
-                          if ($attr instanceof LSattribute) {
-                            $mdp = generatePassword($attr -> config['html_options']['chars'],$attr -> config['html_options']['lenght']);
-                            LSdebug('Nvx mpd : '.$mdp);
-                            $lostPasswdForm = $user -> getForm('lostPassword');
-                            $lostPasswdForm -> setPostData(
-                              array(
-                                $this -> ldapServer['recoverPassword']['recoveryHashAttr'] => array(''),
-                                $this -> ldapServer['authobject_pwdattr'] => array($mdp)
-                              )
-                              ,true
-                            );
-                            if($lostPasswdForm -> validate()) {
-                              if ($user -> updateData('lostPassword')) {
-                                if (
-                                  sendMail(
-                                    $emailAddress,
-                                    $this -> ldapServer['recoverPassword']['newPasswordMail']['subject'],
-                                    getFData($this -> ldapServer['recoverPassword']['newPasswordMail']['msg'],$mdp),
-                                    $sendParams
-                                  )
-                                ){
-                                  // Mail a bien été envoyé
-                                  $recoveryPasswordInfos['newPasswordMail']=$emailAddress;
-                                }
-                                else {
-                                  // Problème durant l'envoie du mail
-                                  LSdebug("Problème durant l'envoie du mail");
-                                  $GLOBALS['LSerror'] -> addErrorCode(1020);
-                                }
-                              }
-                              else {
-                                // Erreur durant la mise à jour de l'objet
-                                LSdebug("Erreur durant la mise à jour de l'objet");
-                                $GLOBALS['LSerror'] -> addErrorCode(1020);
-                              }
-                            }
-                            else {
-                              // Erreur durant la validation du formulaire de modification de perte de password
-                              LSdebug("Erreur durant la validation du formulaire de modification de perte de password");
-                              $GLOBALS['LSerror'] -> addErrorCode(1020);
-                            }
-                          }
-                          else {
-                            // l'attribut password n'existe pas
-                            LSdebug("L'attribut password n'existe pas");
-                            $GLOBALS['LSerror'] -> addErrorCode(1020);
-                          }
+                          // l'attribut password n'existe pas
+                          LSdebug("L'attribut password n'existe pas");
+                          LSerror :: addErrorCode('LSsession_20',1);
                         }
                       }
-                      else {
-                        $GLOBALS['LSerror'] -> addErrorCode(1019);
-                      }
                     }
-                  }
-                  else {
-                    $GLOBALS['LSerror'] -> addErrorCode(1018);
+                    else {
+                      LSerror :: addErrorCode('LSsession_19');
+                    }
                   }
                 }
                 else {
-                  if ( $this -> checkUserPwd($result[0],$_POST['LSsession_pwd']) ) {
-                    // Authentification réussi
-                    $this -> LSuserObject = $result[0];
-                    $this -> dn = $result[0]->getValue('dn');
-                    $this -> rdn = $_POST['LSsession_user'];
-                    $this -> loadLSrights();
-                    $this -> loadLSaccess();
-                    $GLOBALS['Smarty'] -> assign('LSsession_username',$this -> LSuserObject -> getDisplayValue());
-                    $_SESSION['LSsession']=get_object_vars($this);
-                    return true;
-                  }
-                  else {
-                    $GLOBALS['LSerror'] -> addErrorCode(1006);
-                    LSdebug('mdp incorrect');
-                  }
+                  LSerror :: addErrorCode('LSsession_18');
+                }
+              }
+              else {
+                if ( self :: checkUserPwd($result[0],$_POST['LSsession_pwd']) ) {
+                  // Authentification réussi
+                  self :: $LSuserObject = $result[0];
+                  self :: $dn = $result[0]->getValue('dn');
+                  self :: $rdn = $result[0]->getValue('rdn');
+                  self :: loadLSprofiles();
+                  self :: loadLSaccess();
+                  $GLOBALS['Smarty'] -> assign('LSsession_username',self :: getLSuserObject() -> getDisplayName());
+                  $_SESSION['LSsession']=self :: getContextInfos();
+                  return true;
+                }
+                else {
+                  LSerror :: addErrorCode('LSsession_06');
+                  LSdebug('mdp incorrect');
                 }
               }
-            }
-            else {
-              $GLOBALS['LSerror'] -> addErrorCode(1010);
             }
           }
           else {
-            $GLOBALS['LSerror'] -> addErrorCode(1009);
+            LSerror :: addErrorCode('LSsession_10');
           }
         }
-        if ($this -> ldapServerId) {
-          $GLOBALS['Smarty'] -> assign('ldapServerId',$this -> ldapServerId);
-        }
-        $GLOBALS['Smarty'] -> assign('topDn',$this -> topDn);
-        if (isset($_GET['LSsession_recoverPassword'])) {
-          $this -> displayRecoverPasswordForm($recoveryPasswordInfos);
-        }
         else {
-          $this -> displayLoginForm();
+          LSerror :: addErrorCode('LSsession_09');
         }
+      }
+      if (self :: $ldapServerId) {
+        $GLOBALS['Smarty'] -> assign('ldapServerId',self :: $ldapServerId);
+      }
+      $GLOBALS['Smarty'] -> assign('topDn',self :: $topDn);
+      if (isset($_GET['LSsession_recoverPassword'])) {
+        self :: displayRecoverPasswordForm($recoveryPasswordInfos);
+      }
+      else {
+        self :: displayLoginForm();
+      }
+      return;
+    }
+  }
+  
+ /**
+  * Retourne les informations du contexte
+  *
+  * @author Benjamin Renard <brenard@easter-eggs.com
+  * 
+  * @retval array Tableau associatif des informations du contexte
+  */
+  private static function getContextInfos() {
+    return array(
+      'tmp_file' => self :: $tmp_file,
+      'topDn' => self :: $topDn,
+      'dn' => self :: $dn,
+      'rdn' => self :: $rdn,
+      'ldapServerId' => self :: $ldapServerId,
+      'ldapServer' => self :: $ldapServer,
+      'LSprofiles' => self :: $LSprofiles,
+      'LSaccess' => self :: $LSaccess
+    );
+  }
+  
+  /**
+  * Retourne l'objet de l'utilisateur connecté
+  *
+  * @author Benjamin Renard <brenard@easter-eggs.com
+  * 
+  * @retval mixed L'objet de l'utilisateur connecté ou false si il n'a pas put
+  *               être créé
+  */
+  public static function getLSuserObject($dn=null) {
+    if ($dn) {
+      self :: $dn = $dn;
+    }
+    if (!self :: $LSuserObject) {
+      if (self :: loadLSobject(self :: $ldapServer['authObjectType'])) {
+        self :: $LSuserObject = new self :: $ldapServer['authObjectType']();
+        self :: $LSuserObject -> loadData(self :: $dn);
+      }
+      else {
         return;
       }
+    }
+    return self :: $LSuserObject;
+  }
+  
+ /**
+  * Retourne le DN de l'utilisateur connecté
+  *
+  * @author Benjamin Renard <brenard@easter-eggs.com
+  * 
+  * @retval string Le DN de l'utilisateur connecté
+  */
+  public static function getLSuserObjectDn() {
+    return self :: $dn;
   }
 
  /**
@@ -504,23 +621,23 @@ class LSsession {
   * 
   * @param[in] $object Mixed  L'objet Ldap du nouvel utilisateur
   *                           le type doit correspondre à
-  *                           $this -> ldapServer['authobject']
+  *                           self :: $ldapServer['authObjectType']
   * 
   * @retval boolean True en cas de succès, false sinon
   */
- function changeAuthUser($object) {
-  if ($object instanceof $this -> ldapServer['authobject']) {
-    $this -> dn = $object -> getDn();
public static function changeAuthUser($object) {
+  if ($object instanceof self :: $ldapServer['authObjectType']) {
+    self :: $dn = $object -> getDn();
     $rdn = $object -> getValue('rdn');
     if(is_array($rdn)) {
       $rdn = $rdn[0];
     }
-    $this -> rdn = $rdn;
-    $this -> LSuserObject = $object;
+    self :: $rdn = $rdn;
+    self :: $LSuserObject = $object;
     
-    if($this -> loadLSrights()) {
-      $this -> loadLSaccess();
-      $_SESSION['LSsession']=get_object_vars($this);
+    if(self :: loadLSprofiles()) {
+      self :: loadLSaccess();
+      $_SESSION['LSsession']=self :: getContextInfos();
       return true;
     }
   }
@@ -537,10 +654,10 @@ class LSsession {
   *
   * @retval boolean True sinon false.
   */
-  function setLdapServer($id) {
+  public static function setLdapServer($id) {
     if ( isset($GLOBALS['LSconfig']['ldap_servers'][$id]) ) {
-      $this -> ldapServerId = $id;
-      $this -> ldapServer=$GLOBALS['LSconfig']['ldap_servers'][$id];
+      self :: $ldapServerId = $id;
+      self :: $ldapServer=$GLOBALS['LSconfig']['ldap_servers'][$id];
       return true;
     }
     else {
@@ -553,14 +670,14 @@ class LSsession {
   *
   * @retval boolean True sinon false.
   */
-  function LSldapConnect() {
-    if ($this -> ldapServer) {
-      @include_once($GLOBALS['LSconfig']['NetLDAP2']);
-      if (!$this -> loadLSclass('LSldap')) {
+  public static function LSldapConnect() {
+    if (self :: $ldapServer) {
+      self :: includeFile($GLOBALS['LSconfig']['NetLDAP2']);
+      if (!self :: loadLSclass('LSldap')) {
         return;
       }
-      $GLOBALS['LSldap'] = @new LSldap($this -> ldapServer['ldap_config']);
-      if ($GLOBALS['LSldap'] -> isConnected()) {
+      LSldap :: connect(self :: $ldapServer['ldap_config']);
+      if (LSldap :: isConnected()) {
         return true;
       }
       else {
@@ -568,7 +685,7 @@ class LSsession {
       }
     }
     else {
-      $GLOBALS['LSerror'] -> addErrorCode(1003);
+      LSerror :: addErrorCode('LSsession_03');
       return;
     }
   }
@@ -578,60 +695,64 @@ class LSsession {
   *
   * @retval mixed Tableau des subDn, false si une erreur est survenue.
   */
-  function getSubDnLdapServer() {
-    if ($this -> cacheSudDn() && isset($this -> _subDnLdapServer[$this -> ldapServerId])) {
-      return $this -> _subDnLdapServer[$this -> ldapServerId];
-    }
-    if ( is_array($this ->ldapServer['subDn']) ) {
-      $return=array();
-      foreach($this ->ldapServer['subDn'] as $subDn_name => $subDn_config) {
-        if ($subDn_name == 'LSobject') {
-          if (is_array($subDn_config)) {
-            foreach($subDn_config as $LSobject_name => $LSoject_config) {
-              if ($LSoject_config['topDn']) {
-                $topDn = $LSoject_config['topDn'];
-              }
-              else {
-                $topDn = NULL;
-              }
-              if( $this -> loadLSobject($LSobject_name) ) {
-                if ($subdnobject = new $LSobject_name()) {
-                  $tbl_return = $subdnobject -> getSelectArray(NULL,$topDn);
-                  if (is_array($tbl_return)) {
-                    $return=array_merge($return,$tbl_return);
-                  }
-                  else {
-                    $GLOBALS['LSerror'] -> addErrorCode(1017);
-                  }
+  public static function getSubDnLdapServer() {
+    if (self :: cacheSudDn() && isset(self :: $_subDnLdapServer[self :: $ldapServerId])) {
+      return self :: $_subDnLdapServer[self :: $ldapServerId];
+    }
+    if (!isset(self :: $ldapServer['subDn'])) {
+      return;
+    }
+    if ( !is_array(self :: $ldapServer['subDn']) ) {
+      return;
+    }
+    $return=array();
+    foreach(self :: $ldapServer['subDn'] as $subDn_name => $subDn_config) {
+      if ($subDn_name == 'LSobject') {
+        if (is_array($subDn_config)) {
+          foreach($subDn_config as $LSobject_name => $LSoject_config) {
+            if ($LSoject_config['basedn']) {
+              $basedn = $LSoject_config['basedn'];
+            }
+            else {
+              $basedn = NULL;
+            }
+            if ($LSoject_config['displayName']) {
+              $displayName = $LSoject_config['displayName'];
+            }
+            else {
+              $displayName = NULL;
+            }
+            if( self :: loadLSobject($LSobject_name) ) {
+              if ($subdnobject = new $LSobject_name()) {
+                $tbl_return = $subdnobject -> getSelectArray(NULL,$basedn,$displayName);
+                if (is_array($tbl_return)) {
+                  $return=array_merge($return,$tbl_return);
                 }
                 else {
-                  $GLOBALS['LSerror'] -> addErrorCode(1017);
+                  LSerror :: addErrorCode('LSsession_17',3);
                 }
               }
               else {
-                $GLOBALS['LSerror'] -> addErrorCode(1004,$LSobject_name);
+                LSerror :: addErrorCode('LSsession_17',2);
               }
             }
           }
-          else {
-            $GLOBALS['LSerror'] -> addErrorCode(1017);
-          }
         }
         else {
-          if ((isCompatibleDNs($subDn_config['dn'],$this -> ldapServer['ldap_config']['basedn']))&&($subDn_config['dn']!="")) {
-            $return[$subDn_config['dn']] = $subDn_name;
-          }
+          LSerror :: addErrorCode('LSsession_17',1);
         }
       }
-      if ($this -> cacheSudDn()) {
-        $this -> _subDnLdapServer[$this -> ldapServerId]=$return;
-        $_SESSION['LSsession_subDnLdapServer'] = $this -> _subDnLdapServer;
+      else {
+        if ((isCompatibleDNs($subDn_config['dn'],self :: $ldapServer['ldap_config']['basedn']))&&($subDn_config['dn']!="")) {
+          $return[$subDn_config['dn']] = $subDn_name;
+        }
       }
-      return $return;
     }
-    else {
-      return;
+    if (self :: cacheSudDn()) {
+      self :: $_subDnLdapServer[self :: $ldapServerId]=$return;
+      $_SESSION['LSsession_subDnLdapServer'] = self :: $_subDnLdapServer;
     }
+    return $return;
   }
   
   /**
@@ -640,8 +761,8 @@ class LSsession {
    * 
    * @return array() Tableau des subDn trié
    */  
-  function getSortSubDnLdapServer() {
-    $subDnLdapServer = $this  -> getSubDnLdapServer();
+  public static function getSortSubDnLdapServer() {
+    $subDnLdapServer = self :: getSubDnLdapServer();
     if (!$subDnLdapServer) {
       return array();
     }
@@ -653,12 +774,12 @@ class LSsession {
   * Retourne les options d'une liste déroulante pour le choix du topDn
   * de connexion au serveur Ldap
   *
-  * Liste les subdn ($this ->ldapServer['subDn'])
+  * Liste les subdn (self :: $ldapServer['subDn'])
   *
   * @retval string Les options (<option>) pour la sélection du topDn.
   */
-  function getSubDnLdapServerOptions($selected=NULL) {
-    $list = $this -> getSubDnLdapServer();
+  public static function getSubDnLdapServerOptions($selected=NULL) {
+    $list = self :: getSubDnLdapServer();
     if ($list) {
       asort($list);
       $display='';
@@ -676,8 +797,15 @@ class LSsession {
     return;
   }
 
-  function validSubDnLdapServer($subDn) {
-    $listTopDn = $this -> getSubDnLdapServer();
+ /**
+  * Vérifie qu'un subDn est déclaré
+  *
+  * @param[in] string Un subDn
+  * 
+  * @retval boolean True si le subDn existe, False sinon
+  */
+  public static function validSubDnLdapServer($subDn) {
+    $listTopDn = self :: getSubDnLdapServer();
     if(is_array($listTopDn)) {
       foreach($listTopDn as $dn => $txt) {
         if ($subDn==$dn) {
@@ -698,8 +826,8 @@ class LSsession {
   *
   * @retval boolean True si l'authentification Ã  réussi, false sinon.
   */
-  function checkUserPwd($object,$pwd) {
-    return $GLOBALS['LSldap'] -> checkBind($object -> getValue('dn'),$pwd);
+  public static function checkUserPwd($object,$pwd) {
+    return LSldap :: checkBind($object -> getValue('dn'),$pwd);
   }
 
  /**
@@ -709,8 +837,8 @@ class LSsession {
   *
   * @retval void
   */
-  function displayLoginForm() {
-    $GLOBALS['Smarty'] -> assign('pagetitle',_('Connexion'));
+  public static function displayLoginForm() {
+    $GLOBALS['Smarty'] -> assign('pagetitle',_('Connection'));
     if (isset($_GET['LSsession_logout'])) {
       $GLOBALS['Smarty'] -> assign('loginform_action','index.php');
     }
@@ -720,7 +848,7 @@ class LSsession {
     if (count($GLOBALS['LSconfig']['ldap_servers'])==1) {
       $GLOBALS['Smarty'] -> assign('loginform_ldapserver_style','style="display: none"');
     }
-    $GLOBALS['Smarty'] -> assign('loginform_label_ldapserver',_('Serveur LDAP'));
+    $GLOBALS['Smarty'] -> assign('loginform_label_ldapserver',_('LDAP server'));
     $ldapservers_name=array();
     $ldapservers_index=array();
     foreach($GLOBALS['LSconfig']['ldap_servers'] as $id => $infos) {
@@ -731,13 +859,13 @@ class LSsession {
     $GLOBALS['Smarty'] -> assign('loginform_ldapservers_index',$ldapservers_index);
 
     $GLOBALS['Smarty'] -> assign('loginform_label_level',_('Niveau'));
-    $GLOBALS['Smarty'] -> assign('loginform_label_user',_('Identifiant'));
-    $GLOBALS['Smarty'] -> assign('loginform_label_pwd',_('Mot de passe'));
-    $GLOBALS['Smarty'] -> assign('loginform_label_submit',_('Connexion'));
-    $GLOBALS['Smarty'] -> assign('loginform_label_recoverPassword',_('Mot de passe oublié ?'));
+    $GLOBALS['Smarty'] -> assign('loginform_label_user',_('Identifier'));
+    $GLOBALS['Smarty'] -> assign('loginform_label_pwd',_('Password'));
+    $GLOBALS['Smarty'] -> assign('loginform_label_submit',_('Connect'));
+    $GLOBALS['Smarty'] -> assign('loginform_label_recoverPassword',_('Forgot your password ?'));
     
-    $this -> setTemplate('login.tpl');
-    $this -> addJSscript('LSsession_login.js');
+    self :: setTemplate('login.tpl');
+    self :: addJSscript('LSsession_login.js');
   }
 
  /**
@@ -751,15 +879,15 @@ class LSsession {
   *
   * @retval void
   */
-  function displayRecoverPasswordForm($recoveryPasswordInfos) {
-    $GLOBALS['Smarty'] -> assign('pagetitle',_('Récupération de votre mot de passe'));
+  public static function displayRecoverPasswordForm($recoveryPasswordInfos) {
+    $GLOBALS['Smarty'] -> assign('pagetitle',_('Recovery of your credentials'));
     $GLOBALS['Smarty'] -> assign('recoverpasswordform_action','index.php?LSsession_recoverPassword');
     
     if (count($GLOBALS['LSconfig']['ldap_servers'])==1) {
       $GLOBALS['Smarty'] -> assign('recoverpasswordform_ldapserver_style','style="display: none"');
     }
     
-    $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_ldapserver',_('Serveur LDAP'));
+    $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_ldapserver',_('LDAP server'));
     $ldapservers_name=array();
     $ldapservers_index=array();
     foreach($GLOBALS['LSconfig']['ldap_servers'] as $id => $infos) {
@@ -769,31 +897,31 @@ class LSsession {
     $GLOBALS['Smarty'] -> assign('recoverpasswordform_ldapservers_name',$ldapservers_name);
     $GLOBALS['Smarty'] -> assign('recoverpasswordform_ldapservers_index',$ldapservers_index);
 
-    $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_user',_('Identifiant'));
-    $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_submit',_('Valider'));
-    $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_back',_('Retour'));
+    $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_user',_('Identifier'));
+    $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_submit',_('Valid'));
+    $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_back',_('Back'));
     
-    $recoverpassword_msg = _('Veuillez saisir votre identifiant pour poursuivre le processus de récupération de votre mot de passe');
+    $recoverpassword_msg = _('Please fill the identifier field to proceed recovery procedure');
     
     if (isset($recoveryPasswordInfos['recoveryHashMail'])) {
       $recoverpassword_msg = getFData(
-        _("Un mail vient de vous être envoyé à l'adresse %{mail}. " .
-        "Merci de suivre les indications contenus dans ce mail."),
+        _("An email has been sent to  %{mail}. " .
+        "Please follow the instructions on it."),
         $recoveryPasswordInfos['recoveryHashMail']
       );
     }
     
     if (isset($recoveryPasswordInfos['newPasswordMail'])) {
       $recoverpassword_msg = getFData(
-        _("Votre nouveau mot de passe vient de vous être envoyé à l'adresse %{mail}. "),
+        _("Your new password has been sent to %{mail}. "),
         $recoveryPasswordInfos['newPasswordMail']
       );
     }
     
     $GLOBALS['Smarty'] -> assign('recoverpassword_msg',$recoverpassword_msg);
     
-    $this -> setTemplate('recoverpassword.tpl');
-    $this -> addJSscript('LSsession_recoverPassword.js');
+    self :: setTemplate('recoverpassword.tpl');
+    self :: addJSscript('LSsession_recoverPassword.js');
   }
 
  /**
@@ -806,8 +934,8 @@ class LSsession {
   *
   * @retval void
   */
-  function setTemplate($template) {
-    $this -> template = $template;
+  public static function setTemplate($template) {
+    self :: $template = $template;
   }
 
  /**
@@ -819,12 +947,12 @@ class LSsession {
   *
   * @retval void
   */
-  function addJSscript($file,$path=NULL) {
+  public static function addJSscript($file,$path=NULL) {
     $script=array(
       'file' => $file,
       'path' => $path
     );
-    $this -> JSscripts[$path.$file]=$script;
+    self :: $JSscripts[$path.$file]=$script;
   }
 
  /**
@@ -835,8 +963,8 @@ class LSsession {
   *
   * @retval void
   */
-  function addJSconfigParam($name,$val) {
-    $this -> _JSconfigParams[$name]=$val;
+  public static function addJSconfigParam($name,$val) {
+    self :: $_JSconfigParams[$name]=$val;
   }
 
  /**
@@ -848,12 +976,12 @@ class LSsession {
   *
   * @retval void
   */
-  function addCssFile($file,$path=NULL) {
+  public static function addCssFile($file,$path=NULL) {
     $cssFile=array(
       'file' => $file,
       'path' => $path
     );
-    $this -> CssFiles[$path.$file]=$cssFile;
+    self :: $CssFiles[$path.$file]=$cssFile;
   }
 
  /**
@@ -863,14 +991,14 @@ class LSsession {
   *
   * @retval void
   */
-  function displayTemplate() {
+  public static function displayTemplate() {
     // JS
     $JSscript_txt='';
     foreach ($GLOBALS['defaultJSscipts'] as $script) {
       $JSscript_txt.="<script src='".LS_JS_DIR.$script."' type='text/javascript'></script>\n";
     }
 
-    foreach ($this -> JSscripts as $script) {
+    foreach (self :: $JSscripts as $script) {
       if (!$script['path']) {
         $script['path']=LS_JS_DIR;
       }
@@ -880,7 +1008,23 @@ class LSsession {
       $JSscript_txt.="<script src='".$script['path'].$script['file']."' type='text/javascript'></script>\n";
     }
 
-    $GLOBALS['Smarty'] -> assign('LSjsConfig',json_encode($this -> _JSconfigParams));
+    if ( 
+          (
+            (!isset(self :: $ldapServer['keepLSsessionActive']))
+            &&
+            ( 
+              (!isset($GLOBALS['LSconfig']['keepLSsessionActive']))
+              ||
+              ($GLOBALS['LSconfig']['keepLSsessionActive'])
+            )
+          )
+          ||
+          (self :: $ldapServer['keepLSsessionActive'])
+        ) {
+      self :: addJSconfigParam('keepLSsessionActive',ini_get('session.gc_maxlifetime'));
+    }
+
+    $GLOBALS['Smarty'] -> assign('LSjsConfig',json_encode(self :: $_JSconfigParams));
     
     if ($GLOBALS['LSdebug']['active']) {
       $JSscript_txt.="<script type='text/javascript'>LSdebug_active = 1;</script>\n";
@@ -892,8 +1036,9 @@ class LSsession {
     $GLOBALS['Smarty'] -> assign('LSsession_js',$JSscript_txt);
 
     // Css
-    $this -> addCssFile("LSdefault.css");
-    foreach ($this -> CssFiles as $file) {
+    self :: addCssFile("LSdefault.css");
+    $Css_txt='';
+    foreach (self :: $CssFiles as $file) {
       if (!$file['path']) {
         $file['path']=LS_CSS_DIR.'/';
       }
@@ -901,14 +1046,16 @@ class LSsession {
     }
     $GLOBALS['Smarty'] -> assign('LSsession_css',$Css_txt);
   
-    $GLOBALS['Smarty'] -> assign('LSaccess',$this -> LSaccess[$this -> topDn]);
+    if (isset(self :: $LSaccess[self :: $topDn])) {
+      $GLOBALS['Smarty'] -> assign('LSaccess',self :: $LSaccess[self :: $topDn]);
+    }
     
     // Niveau
-    $listTopDn = $this -> getSubDnLdapServer();
+    $listTopDn = self :: getSubDnLdapServer();
     if (is_array($listTopDn)) {
       asort($listTopDn);
-      $GLOBALS['Smarty'] -> assign('label_level',$this -> getLevelLabel());
-      $GLOBALS['Smarty'] -> assign('_refresh',_('Rafraîchir'));
+      $GLOBALS['Smarty'] -> assign('label_level',self :: getSubDnLabel());
+      $GLOBALS['Smarty'] -> assign('_refresh',_('Refresh'));
       $LSsession_topDn_index = array();
       $LSsession_topDn_name = array();
       foreach($listTopDn as $index => $name) {
@@ -917,8 +1064,8 @@ class LSsession {
       }
       $GLOBALS['Smarty'] -> assign('LSsession_subDn_indexes',$LSsession_topDn_index);
       $GLOBALS['Smarty'] -> assign('LSsession_subDn_names',$LSsession_topDn_name);
-      $GLOBALS['Smarty'] -> assign('LSsession_subDn',$this -> topDn);
-      $GLOBALS['Smarty'] -> assign('LSsession_subDnName',$this -> getSubDnName());
+      $GLOBALS['Smarty'] -> assign('LSsession_subDn',self :: $topDn);
+      $GLOBALS['Smarty'] -> assign('LSsession_subDnName',self :: getSubDnName());
     }
 
     // Infos
@@ -932,17 +1079,31 @@ class LSsession {
       $_SESSION['LSsession_infos']=array();
     }
     
-    if ($this -> ajaxDisplay) {
-      $GLOBALS['Smarty'] -> assign('LSerror_txt',$GLOBALS['LSerror']->getErrors());
+    if (self :: $ajaxDisplay) {
+      $GLOBALS['Smarty'] -> assign('LSerror_txt',LSerror :: getErrors());
       $GLOBALS['Smarty'] -> assign('LSdebug_txt',LSdebug_print(true));
     }
     else {
-      $GLOBALS['LSerror'] -> display();
+      LSerror :: display();
       LSdebug_print();
     }
-    if (!$this -> template)
-      $this -> setTemplate('empty.tpl');
-    $GLOBALS['Smarty'] -> display($this -> template);
+    if (!self :: $template)
+      self :: setTemplate('empty.tpl');
+      
+    $GLOBALS['Smarty'] -> assign('connected_as',_("Connected as"));
+    
+    $GLOBALS['Smarty'] -> display(self :: $template);
+  }
+  
+ /**
+  * Défini que l'affichage se fera ou non via un retour Ajax
+  * 
+  * @param[in] $val boolean True pour que l'affichage se fasse par un retour
+  *                         Ajax, false sinon
+  * @retval void
+  */
+  public static function setAjaxDisplay($val=true) {
+    self :: $ajaxDisplay = (boolean)$val;
   }
   
  /**
@@ -950,8 +1111,13 @@ class LSsession {
   *
   * @retval void
   */
-  function displayAjaxReturn($data=array()) {
-    $data['LSjsConfig'] = $this -> _JSconfigParams;
+  public static function displayAjaxReturn($data=array()) {
+    if (isset($data['LSredirect']) && (!LSdebugDefined()) ) {
+      echo json_encode($data);
+      return;
+    }
+    
+    $data['LSjsConfig'] = self :: $_JSconfigParams;
     
     // Infos
     if((!empty($_SESSION['LSsession_infos']))&&(is_array($_SESSION['LSsession_infos']))) {
@@ -964,8 +1130,8 @@ class LSsession {
       $_SESSION['LSsession_infos']=array();
     }
     
-    if ($GLOBALS['LSerror']->errorsDefined()) {
-      $data['LSerror'] = $GLOBALS['LSerror']->getErrors();
+    if (LSerror :: errorsDefined()) {
+      $data['LSerror'] = LSerror :: getErrors();
     }
 
     if (isset($_REQUEST['imgload'])) {
@@ -987,7 +1153,7 @@ class LSsession {
   * 
   * @retval string Le HTML compilé du template
   */
-  function fetchTemplate($template,$variables=array()) {
+  public static function fetchTemplate($template,$variables=array()) {
     foreach($variables as $name => $val) {
       $GLOBALS['Smarty'] -> assign($name,$val);
     }
@@ -999,34 +1165,35 @@ class LSsession {
    * 
    * @retval boolean True si le chargement Ã  réussi, false sinon.
    **/
-  function loadLSrights() {
-    if (is_array($this -> ldapServer['LSrights'])) {
-      foreach ($this -> ldapServer['LSrights'] as $profile => $profileInfos) {
+  private static function loadLSprofiles() {
+    if (is_array(self :: $ldapServer['LSprofiles'])) {
+      foreach (self :: $ldapServer['LSprofiles'] as $profile => $profileInfos) {
         if (is_array($profileInfos)) {
           foreach ($profileInfos as $topDn => $rightsInfos) {
+            /*
+             * If $topDn == 'LSobject', we search for each LSobject type to find
+             * all items on witch the user will have powers.
+             */
             if ($topDn == 'LSobjects') {
               if (is_array($rightsInfos)) {
                 foreach ($rightsInfos as $LSobject => $listInfos) {
-                  if ($this -> loadLSobject($LSobject)) {
+                  if (self :: loadLSobject($LSobject)) {
                     if ($object = new $LSobject()) {
                       if ($listInfos['filter']) {
-                        $filter = $this -> LSuserObject -> getFData($listInfos['filter']);
+                        $filter = self :: getLSuserObject() -> getFData($listInfos['filter']);
                       }
                       else {
-                        $filter = $listInfos['attr'].'='.$this -> LSuserObject -> getFData($listInfos['attr_value']);
+                        $filter = $listInfos['attr'].'='.self :: getLSuserObject() -> getFData($listInfos['attr_value']);
                       }
                       $list = $object -> search($filter,$listInfos['basedn'],$listInfos['params']);
                       foreach($list as $obj) {
-                        $this -> LSrights[$profile][] = $obj['dn'];
+                        self :: $LSprofiles[$profile][] = $obj['dn'];
                       }
                     }
                     else {
                       LSdebug('Impossible de créer l\'objet de type : '.$LSobject);
                     }
                   }
-                  else {
-                    $GLOBALS['LSerror'] -> addErrorCode(1004,$LSobject);
-                  }
                 }
               }
               else {
@@ -1037,15 +1204,15 @@ class LSsession {
               if (is_array($rightsInfos)) {
                 foreach($rightsInfos as $dn => $conf) {
                   if ((isset($conf['attr'])) && (isset($conf['LSobject']))) {
-                    if( $this -> loadLSobject($conf['LSobject']) ) {
+                    if( self :: loadLSobject($conf['LSobject']) ) {
                       if ($object = new $conf['LSobject']()) {
                         if ($object -> loadData($dn)) {
                           $listDns=$object -> getValue($conf['attr']);
                           $valKey = (isset($conf['attr_value']))?$conf['attr_value']:'%{dn}';
-                          $val = $this -> LSuserObject -> getFData($valKey);
+                          $val = self :: getLSuserObject() -> getFData($valKey);
                           if (is_array($listDns)) {
                             if (in_array($val,$listDns)) {
-                              $this -> LSrights[$profile][] = $topDn;
+                              self :: $LSprofiles[$profile][] = $topDn;
                             }
                           }
                         }
@@ -1057,27 +1224,24 @@ class LSsession {
                         LSdebug('Impossible de créer l\'objet de type : '.$conf['LSobject']);
                       }
                     }
-                    else {
-                      $GLOBALS['LSerror'] -> addErrorCode(1004,$conf['LSobject']);
-                    }
                   }
                   else {
-                    if ($this -> dn == $dn) {
-                      $this -> LSrights[$profile][] = $topDn;
+                    if (self :: $dn == $dn) {
+                      self :: $LSprofiles[$profile][] = $topDn;
                     }
                   }
                 }
               }
               else {
-                if ( $this -> dn == $rightsInfos ) {
-                  $this -> LSrights[$profile][] = $topDn;
+                if ( self :: $dn == $rightsInfos ) {
+                  self :: $LSprofiles[$profile][] = $topDn;
                 }
               }
             } // fin else ($topDn == 'LSobjects')
           } // fin foreach($profileInfos)
         } // fin is_array($profileInfos)
-      } // fin foreach LSrights
-      LSdebug($this -> LSrights);
+      } // fin foreach LSprofiles
+      LSdebug(self :: $LSprofiles);
       return true;
     }
     else {
@@ -1090,16 +1254,16 @@ class LSsession {
    *
    * @retval void
    */
-  function loadLSaccess() {
+  private static function loadLSaccess() {
     $LSaccess=array();
-    if (is_array($this -> ldapServer['subDn'])) {
-      foreach($this -> ldapServer['subDn'] as $name => $config) {
+    if (is_array(self :: $ldapServer['subDn'])) {
+      foreach(self :: $ldapServer['subDn'] as $name => $config) {
         if ($name=='LSobject') {
           if (is_array($config)) {
 
             // Définition des subDns 
             foreach($config as $objectType => $objectConf) {
-              if ($this -> loadLSobject($objectType)) {
+              if (self :: loadLSobject($objectType)) {
                 if ($subdnobject = new $objectType()) {
                   $tbl = $subdnobject -> getSelectArray();
                   if (is_array($tbl)) {
@@ -1107,14 +1271,11 @@ class LSsession {
                     $access=array();
                     if (is_array($objectConf['LSobjects'])) {
                       foreach($objectConf['LSobjects'] as $type) {
-                        if ($this -> loadLSobject($type)) {
-                          if ($this -> canAccess($type)) {
+                        if (self :: loadLSobject($type)) {
+                          if (self :: canAccess($type)) {
                             $access[$type] = $GLOBALS['LSobjects'][$type]['label'];
                           }
                         }
-                        else {
-                          $GLOBALS['LSerror'] -> addErrorCode(1004,$type);
-                        }
                       }
                     }
                     foreach($tbl as $dn => $dn_name) {
@@ -1123,25 +1284,19 @@ class LSsession {
                   }
                 }
               }
-              else {
-                $GLOBALS['LSerror'] -> addErrorCode(1004,$objectType);
-              }
             }
           }
         }
         else {
-          if ((isCompatibleDNs($this -> ldapServer['ldap_config']['basedn'],$config['dn']))&&($config['dn']!='')) {
+          if ((isCompatibleDNs(self :: $ldapServer['ldap_config']['basedn'],$config['dn']))&&($config['dn']!='')) {
             $access=array();
             if (is_array($config['LSobjects'])) {
               foreach($config['LSobjects'] as $objectType) {
-                if ($this -> loadLSobject($objectType)) {
-                  if ($this -> canAccess($objectType)) {
+                if (self :: loadLSobject($objectType)) {
+                  if (self :: canAccess($objectType)) {
                     $access[$objectType] = $GLOBALS['LSobjects'][$objectType]['label'];
                   }
                 }
-                else {
-                  $GLOBALS['LSerror'] -> addErrorCode(1004,$LSobject_name);
-                }
               }
             }
             $LSaccess[$config['dn']]=$access;
@@ -1150,31 +1305,28 @@ class LSsession {
       }
     }
     else {
-      if(is_array($this -> ldapServer['LSaccess'])) {
+      if(is_array(self :: $ldapServer['LSaccess'])) {
         $access=array();
-        foreach($this -> ldapServer['LSaccess'] as $objectType) {
-          if ($this -> loadLSobject($objectType)) {
-            if ($this -> canAccess($objectType)) {
+        foreach(self :: $ldapServer['LSaccess'] as $objectType) {
+          if (self :: loadLSobject($objectType)) {
+            if (self :: canAccess($objectType)) {
                 $access[$objectType] = $GLOBALS['LSobjects'][$objectType]['label'];
             }
           }
-          else {
-            $GLOBALS['LSerror'] -> addErrorCode(1004,$LSobject_name);
-          }
         }
-        $LSaccess[$this -> topDn] = $access;
+        $LSaccess[self :: $topDn] = $access;
       }
     }
     foreach($LSaccess as $dn => $access) {
       $LSaccess[$dn] = array_merge(
         array(
-          'SELF' => _('Mon compte')
+          'SELF' => _('My account')
         ),
         $access
       );
     }
     
-    $this -> LSaccess = $LSaccess;
+    self :: $LSaccess = $LSaccess;
     $_SESSION['LSsession']['LSaccess'] = $LSaccess;
   }
   
@@ -1186,9 +1338,9 @@ class LSsession {
    * 
    * @retval boolean True si l'utilisateur est du profil sur l'objet, false sinon.
    */
-  function isProfile($dn,$profile) {
-    if (is_array($this -> LSrights[$profile])) {
-      foreach($this -> LSrights[$profile] as $topDn) {
+  public static function isLSprofile($dn,$profile) {
+    if (is_array(self :: $LSprofiles[$profile])) {
+      foreach(self :: $LSprofiles[$profile] as $topDn) {
         if($dn == $topDn) {
           return true;
         }
@@ -1207,16 +1359,16 @@ class LSsession {
    * 
    * @retval string 'admin'/'self'/'user' pour Admin , l'utilisateur lui même ou un simple utilisateur
    */
-  function whoami($dn) {
+  public static function whoami($dn) {
     $retval = array('user');
     
-    foreach($this -> LSrights as $profile => $infos) {
-      if($this -> isProfile($dn,$profile)) {
+    foreach(self :: $LSprofiles as $profile => $infos) {
+      if(self :: isLSprofile($dn,$profile)) {
        $retval[]=$profile;
       }
     }
     
-    if ($this -> dn == $dn) {
+    if (self :: $dn == $dn) {
       $retval[]='self';
     }
     
@@ -1233,29 +1385,28 @@ class LSsession {
    *
    * @retval boolean True si l'utilisateur a accès, false sinon
    */
-  function canAccess($LSobject,$dn=NULL,$right=NULL,$attr=NULL) {
-    if (!$this -> loadLSobject($LSobject)) {
-      $GLOBALS['LSerror'] -> addErrorCode(1004,$LSobject);
+  public static function canAccess($LSobject,$dn=NULL,$right=NULL,$attr=NULL) {
+    if (!self :: loadLSobject($LSobject)) {
       return;
     }
     if ($dn) {
-      $whoami = $this -> whoami($dn);
-      if ($dn==$this -> LSuserObject -> getValue('dn')) {
-        if (!$this -> in_menu('SELF')) {
+      $whoami = self :: whoami($dn);
+      if ($dn==self :: getLSuserObject() -> getValue('dn')) {
+        if (!self :: in_menu('SELF')) {
           return;
         }
       }
       else {
         $obj = new $LSobject();
         $obj -> dn = $dn;
-        if (!$this -> in_menu($LSobject,$obj -> getSubDnValue())) {
+        if (!self :: in_menu($LSobject,$obj -> getSubDnValue())) {
           return;
         }
       }
     }
     else {
-      $objectdn=$GLOBALS['LSobjects'][$LSobject]['container_dn'].','.$this -> topDn;
-      $whoami = $this -> whoami($objectdn);
+      $objectdn=$GLOBALS['LSobjects'][$LSobject]['container_dn'].','.self :: $topDn;
+      $whoami = self :: whoami($objectdn);
     }
     
     // Pour un attribut particulier
@@ -1327,8 +1478,8 @@ class LSsession {
    *
    * @retval boolean True si l'utilisateur a accès, false sinon
    */
-  function canEdit($LSobject,$dn=NULL,$attr=NULL) {
-    return $this -> canAccess($LSobject,$dn,'w',$attr);
+  public static function canEdit($LSobject,$dn=NULL,$attr=NULL) {
+    return self :: canAccess($LSobject,$dn,'w',$attr);
   }
 
   /**
@@ -1339,8 +1490,8 @@ class LSsession {
    *
    * @retval boolean True si l'utilisateur a accès, false sinon
    */  
-  function canRemove($LSobject,$dn) {
-    return $this -> canAccess($LSobject,$dn,'w','rdn');
+  public static function canRemove($LSobject,$dn) {
+    return self :: canAccess($LSobject,$dn,'w','rdn');
   }
   
   /**
@@ -1350,8 +1501,8 @@ class LSsession {
    *
    * @retval boolean True si l'utilisateur a accès, false sinon
    */    
-  function canCreate($LSobject) {
-    return $this -> canAccess($LSobject,NULL,'w','rdn');
+  public static function canCreate($LSobject) {
+    return self :: canAccess($LSobject,NULL,'w','rdn');
   }
   
   /**
@@ -1364,15 +1515,15 @@ class LSsession {
    *
    * @retval boolean True si l'utilisateur a accès, false sinon
    */
-  function relationCanAccess($dn,$LSobject,$relationName,$right=NULL) {
-    if (!isset($GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]))
+  public static function relationCanAccess($dn,$LSobject,$relationName,$right=NULL) {
+    if (!isset($GLOBALS['LSobjects'][$LSobject]['LSrelation'][$relationName]))
       return;
-    $whoami = $this -> whoami($dn);
+    $whoami = self :: whoami($dn);
 
     if (($right=='w') || ($right=='r')) {
       $r = 'n';
       foreach($whoami as $who) {
-        $nr = $GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]['rights'][$who];
+        $nr = $GLOBALS['LSobjects'][$LSobject]['LSrelation'][$relationName]['rights'][$who];
         if($nr == 'w') {
           $r = 'w';
         }
@@ -1389,7 +1540,7 @@ class LSsession {
     }
     else {
       foreach($whoami as $who) {
-        if (($GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]['rights'][$who] == 'w') || ($GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]['rights'][$who] == 'r')) {
+        if (($GLOBALS['LSobjects'][$LSobject]['LSrelation'][$relationName]['rights'][$who] == 'w') || ($GLOBALS['LSobjects'][$LSobject]['LSrelation'][$relationName]['rights'][$who] == 'r')) {
           return true;
         }
       }
@@ -1406,8 +1557,8 @@ class LSsession {
    *
    * @retval boolean True si l'utilisateur a accès, false sinon
    */  
-  function relationCanEdit($dn,$LSobject,$relationName) {
-    return $this -> relationCanAccess($dn,$LSobject,$relationName,'w');
+  public static function relationCanEdit($dn,$LSobject,$relationName) {
+    return self :: relationCanAccess($dn,$LSobject,$relationName,'w');
   }
 
   /**
@@ -1417,9 +1568,9 @@ class LSsession {
    * 
    * @retval void
    **/
-  function addTmpFile($value,$filePath) {
+  public static function addTmpFile($value,$filePath) {
     $hash = mhash(MHASH_MD5,$value);
-    $this -> tmp_file[$filePath] = $hash;
+    self :: $tmp_file[$filePath] = $hash;
     $_SESSION['LSsession']['tmp_file'][$filePath] = $hash;
   }
   
@@ -1432,9 +1583,9 @@ class LSsession {
    * 
    * @retval mixed 
    **/
-  function tmpFileExist($value) {
+  public static function tmpFileExist($value) {
     $hash = mhash(MHASH_MD5,$value);
-    foreach($this -> tmp_file as $filePath => $contentHash) {
+    foreach(self :: $tmp_file as $filePath => $contentHash) {
       if ($hash == $contentHash) {
         return $filePath;
       }
@@ -1454,14 +1605,14 @@ class LSsession {
    * 
    * @retval mixed 
    **/
-  function getTmpFile($value) {
-    $exist = $this -> tmpFileExist($value);
+  public static function getTmpFile($value) {
+    $exist = self :: tmpFileExist($value);
     if (!$exist) {
       $img_path = LS_TMP_DIR .rand().'.tmp';
       $fp = fopen($img_path, "w");
       fwrite($fp, $value);
       fclose($fp);
-      $this -> addTmpFile($value,$img_path);
+      self :: addTmpFile($value,$img_path);
       return $img_path;
     }
     else {
@@ -1476,17 +1627,17 @@ class LSsession {
    * 
    * @retval void
    **/
-  function deleteTmpFile($filePath=NULL) {
+  public static function deleteTmpFile($filePath=NULL) {
     if ($filePath) {
         @unlink($filePath);
-        unset($this -> tmp_file[$filePath]);
+        unset(self :: $tmp_file[$filePath]);
         unset($_SESSION['LSsession']['tmp_file'][$filePath]);
     }
     else {
-      foreach($this -> tmp_file as $file => $content) {
+      foreach(self :: $tmp_file as $file => $content) {
         @unlink($file);
       }
-      $this -> tmp_file = array();
+      self :: $tmp_file = array();
       $_SESSION['LSsession']['tmp_file'] = array();
     }
   }
@@ -1498,8 +1649,8 @@ class LSsession {
    * 
    * @retval boolean True si le cache des droits est activé, false sinon.
    */
-  function cacheLSrights() {
-    return ( ($GLOBALS['LSconfig']['cacheLSrights']) || ($this -> ldapServer['cacheLSrights']) );
+  public static function cacheLSprofiles() {
+    return ( ($GLOBALS['LSconfig']['cacheLSprofiles']) || (self :: $ldapServer['cacheLSprofiles']) );
   }
 
   /**
@@ -1509,8 +1660,8 @@ class LSsession {
    * 
    * @retval boolean True si le cache des subDn est activé, false sinon.
    */
-  function cacheSudDn() {
-    return (($GLOBALS['LSconfig']['cacheSubDn']) || ($this -> ldapServer['cacheSubDn']));
+  public static function cacheSudDn() {
+    return (($GLOBALS['LSconfig']['cacheSubDn']) || (self :: $ldapServer['cacheSubDn']));
   }
   
   /**
@@ -1520,8 +1671,8 @@ class LSsession {
    * 
    * @retval boolean True si le cache des recherches est activé, false sinon.
    */
-  function cacheSearch() {
-    return (($GLOBALS['LSconfig']['cacheSearch']) || ($this -> ldapServer['cacheSearch']));
+  public static function cacheSearch() {
+    return (($GLOBALS['LSconfig']['cacheSearch']) || (self :: $ldapServer['cacheSearch']));
   }
   
   /**
@@ -1531,8 +1682,8 @@ class LSsession {
    * 
    * @retval string Le label des niveaux pour le serveur ldap dourant
    */
-  function getLevelLabel() {
-    return ($this -> ldapServer['levelLabel']!='')?$this -> ldapServer['levelLabel']:_('Niveau');
+  public static function getSubDnLabel() {
+    return (self :: $ldapServer['subDnLabel']!='')?self :: $ldapServer['subDnLabel']:_('Level');
   }
   
   /**
@@ -1542,13 +1693,13 @@ class LSsession {
    * 
    * @retval string Le nom du subDn ou '' sinon
    */
-  function getSubDnName($subDn=false) {
+  public static function getSubDnName($subDn=false) {
     if (!$subDn) {
-      $subDn = $this -> topDn;
+      $subDn = self :: $topDn;
     }
-    if ($this -> getSubDnLdapServer()) {
-      if (isset($this -> _subDnLdapServer[$this -> ldapServerId][$subDn])) {
-        return $this -> _subDnLdapServer[$this -> ldapServerId][$subDn];
+    if (self :: getSubDnLdapServer()) {
+      if (isset(self :: $_subDnLdapServer[self :: $ldapServerId][$subDn])) {
+        return self :: $_subDnLdapServer[self :: $ldapServerId][$subDn];
       }
     }
     return '';
@@ -1561,10 +1712,10 @@ class LSsession {
    * 
    * @retval boolean true si le type d'objet est un subDnObject, false sinon
    */
-  function isSubDnLSobject($type) {
+  public static function isSubDnLSobject($type) {
     $result = false;
-    if (is_array($this -> ldapServer['subDn']['LSobject'])) {
-      foreach($this -> ldapServer['subDn']['LSobject'] as $key => $value) {
+    if (is_array(self :: $ldapServer['subDn']['LSobject'])) {
+      foreach(self :: $ldapServer['subDn']['LSobject'] as $key => $value) {
         if ($key==$type) {
           $result=true;
         }
@@ -1578,11 +1729,11 @@ class LSsession {
    * 
    * @retval boolean true si le type d'objet est dans le menu, false sinon
    */
-  function in_menu($LSobject,$topDn=NULL) {
+  public static function in_menu($LSobject,$topDn=NULL) {
     if (!$topDn) {
-      $topDn=$this -> topDn;
+      $topDn=self :: $topDn;
     }
-    return isset($this -> LSaccess[$topDn][$LSobject]);
+    return isset(self :: $LSaccess[$topDn][$LSobject]);
   }
   
   /**
@@ -1590,8 +1741,8 @@ class LSsession {
    * 
    * @retval boolean true si le serveur LDAP courant a des subDn, false sinon
    */
-  function haveSubDn() {
-    return (is_array($this -> ldapServer['subDn']));
+  public static function haveSubDn() {
+    return (is_array(self :: $ldapServer['subDn']));
   }
 
   /**
@@ -1601,7 +1752,7 @@ class LSsession {
    * 
    * @retval void
    */
-  function addInfo($msg) {
+  public static function addInfo($msg) {
     $_SESSION['LSsession_infos'][]=$msg;
   }
   
@@ -1613,7 +1764,7 @@ class LSsession {
    * 
    * @retval void
    */  
-  function redirect($url,$exit=true) {
+  public static function redirect($url,$exit=true) {
     $GLOBALS['Smarty'] -> assign('url',$url);
     $GLOBALS['Smarty'] -> display('redirect.tpl');
     if ($exit) {
@@ -1626,8 +1777,8 @@ class LSsession {
    * 
    * @retval string Adresse mail d'emission
    */
-  function getEmailSender() {
-    return $this -> ldapServer['emailSender'];  
+  public static function getEmailSender() {
+    return self :: $ldapServer['emailSender'];  
   }
   
   /**
@@ -1639,14 +1790,126 @@ class LSsession {
    * 
    * @retval void
    */
-  function addHelpInfos($group,$infos) {
+  public static function addHelpInfos($group,$infos) {
     if (is_array($infos)) {
-      if (is_array($this -> _JSconfigParams['helpInfos'][$group])) {
-        $this -> _JSconfigParams['helpInfos'][$group] = array_merge($this -> _JSconfigParams['helpInfos'][$group],$infos);
+      if (is_array(self :: $_JSconfigParams['helpInfos'][$group])) {
+        self :: $_JSconfigParams['helpInfos'][$group] = array_merge(self :: $_JSconfigParams['helpInfos'][$group],$infos);
       }
       else {
-        $this -> _JSconfigParams['helpInfos'][$group] = $infos;
+        self :: $_JSconfigParams['helpInfos'][$group] = $infos;
+      }
+    }
+  }
+  
+ /**
+  * Défini les codes erreur relative à la classe LSsession
+  * 
+  * @retval void
+  */  
+  private static function defineLSerrors() {
+    /*
+     * Error Codes
+     */
+    LSerror :: defineError('LSsession_01',
+    _("LSsession : The constant %{const} is not defined.")
+    );
+    LSerror :: defineError('LSsession_02',
+    _("LSsession : The %{addon} support is uncertain. Verify system compatibility and the add-on configuration.")
+    );
+    LSerror :: defineError('LSsession_03',
+    _("LSsession : LDAP server's configuration data are invalid. Impossible d'établir une connexion.")
+    );
+    LSerror :: defineError('LSsession_04',
+    _("LSsession : Failed to load LSobject type %{type} : unknon type.")
+    );
+    // no longer used
+    /*LSerror :: defineError(1005,
+    _("LSsession : Object type use for authentication is unknow (%{type}).")
+    );*/
+    LSerror :: defineError('LSsession_06',
+    _("LSsession : Login or password incorrect.")
+    );
+    LSerror :: defineError('LSsession_07',
+    _("LSsession : Impossible to identify you : Duplication of identities.")
+    );
+    LSerror :: defineError('LSsession_08',
+    _("LSsession : Can't load Smarty template engine.")
+    );
+    LSerror :: defineError('LSsession_09',
+    _("LSsession : Can't connect to LDAP server.")
+    );
+    LSerror :: defineError('LSsession_10',
+    _("LSsession : Impossible to load authentification objects's class.")
+    );
+    LSerror :: defineError('LSsession_11',
+    _("LSsession : Your are not authorized to do this action.")
+    );
+    LSerror :: defineError('LSsession_12',
+    _("LSsession : Some informations are missing to display this page.")
+    );
+    // 13 -> 16 : not yet used
+    LSerror :: defineError('LSsession_17',
+    _("LSsession : Error during creation of list of levels. Contact administrators. (Code : %{code})")
+    );
+    LSerror :: defineError('LSsession_18',
+    _("LSsession : The password recovery is disabled for this LDAP server.")
+    );
+    LSerror :: defineError('LSsession_19',
+    _("LSsession : Some informations are missing to recover your password. Contact administrators.")
+    );
+    LSerror :: defineError('LSsession_20',
+    _("LSsession : Error during password recovery. Contact administrators.(Step : %{step})")
+    );
+    // 21 : not yet used
+    LSerror :: defineError('LSsession_22',
+    _("LSsession : problem during initialisation.")
+    );
+
+
+    // LSrelations
+    LSerror :: defineError('LSrelations_01',
+    _("LSrelations : The listing function for the relation %{relation} is unknow.")
+    );
+    LSerror :: defineError('LSrelations_02',
+    _("LSrelations : The update function of the relation %{relation} is unknow.")
+    );
+    LSerror :: defineError('LSrelations_03',
+    _("LSrelations : Error during relation update of the relation %{relation}.")
+    );
+    LSerror :: defineError('LSrelations_04',
+    _("LSrelations : Object type %{LSobject} unknow (Relation : %{relation}).")
+    );
+    LSerror :: defineError('LSrelations_05',
+    _("LSrelation : Some parameters are missing in the invocation of the methods of handling relations standard (Methode : %{meth}).")
+    );
+  }
+
+  public static function ajax_onLdapServerChangedLogin(&$data) {  
+    if ( isset($_REQUEST['server']) ) {
+      self :: setLdapServer($_REQUEST['server']);
+      $data = array();
+      if ( self :: LSldapConnect() ) {
+        session_start();
+        if (isset($_SESSION['LSsession_topDn'])) {
+          $sel = $_SESSION['LSsession_topDn'];
+        }
+        else {
+          $sel = NULL;
+        }
+        $list = self :: getSubDnLdapServerOptions($sel);
+        if (is_string($list)) {
+          $data['list_topDn'] = "<select name='LSsession_topDn' id='LSsession_topDn'>".$list."</select>";
+          $data['subDnLabel'] = self :: getSubDnLabel();
+        }
       }
+      $data['recoverPassword'] = isset(self :: $ldapServer['recoverPassword']);
+    }
+  }
+  
+  public static function ajax_onLdapServerChangedRecoverPassword(&$data) {  
+    if ( isset($_REQUEST['server']) ) {
+      self :: setLdapServer($_REQUEST['server']);
+      $data=array('recoverPassword' => isset(self :: $ldapServer['recoverPassword']));
     }
   }
 }