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