- LSform.js :
[ldapsaisie.git] / trunk / 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 define('LS_DEFAULT_CONF_DIR','conf');
24
25 /**
26  * Gestion des sessions
27  *
28  * Cette classe gère les sessions d'utilisateurs.
29  *
30  * @author Benjamin Renard <brenard@easter-eggs.com>
31  */
32 class LSsession {
33
34   var $confDir = NULL;
35   var $ldapServer = NULL;
36   var $ldapServerId = NULL;
37   var $topDn = NULL;
38   var $LSuserObject = NULL;
39   var $dn = NULL;
40   var $rdn = NULL;
41   var $JSscripts = array();
42   var $_JSconfigParams = array();
43   var $CssFiles = array();
44   var $template = NULL;
45   var $LSrights = array (
46     'topDn_admin' => array ()
47   );
48   var $LSaccess = array();
49   var $tmp_file = array();
50   var $_subDnLdapServer = array();
51   var $ajaxDisplay = false;
52
53   /**
54    * Constructeur
55    *
56    * @author Benjamin Renard <brenard@easter-eggs.com>
57    *
58    * @retval void
59    */
60   function LSsession ($configDir=LS_DEFAULT_CONF_DIR) {
61     $this -> confDir = $configDir;
62     if ($this -> loadConfig()) {
63       $this -> startLSerror();
64     }
65     else {
66       return;
67     }
68   }
69
70  /**
71   * Chargement de la configuration
72   *
73   * Chargement des fichiers de configuration et création de l'objet Smarty.
74   *
75   * @author Benjamin Renard <brenard@easter-eggs.com>
76   *
77   * @retval true si tout c'est bien passé, false sinon
78   */
79   function loadConfig() {
80     if (loadDir($this -> confDir, '^config\..*\.php$')) {
81       if ( include_once $GLOBALS['LSconfig']['Smarty'] ) {
82         $GLOBALS['Smarty'] = new Smarty();
83         $GLOBALS['Smarty'] -> template_dir = LS_TEMPLATES_DIR;
84         $GLOBALS['Smarty'] -> compile_dir = LS_TMP_DIR;
85         
86         $GLOBALS['Smarty'] -> assign('LS_CSS_DIR',LS_CSS_DIR);
87         $GLOBALS['Smarty'] -> assign('LS_IMAGES_DIR',LS_IMAGES_DIR);
88         
89         $this -> addJSconfigParam('LS_IMAGES_DIR',LS_IMAGES_DIR);
90         return true;
91       }
92       else {
93         die($GLOBALS['LSerror_code'][1008]['msg']);
94         return;
95       }
96       return true;
97     }
98     else {
99       return;
100     }
101   }
102
103  /**
104   * Initialisation de la gestion des erreurs
105   *
106   * Création de l'objet LSerror
107   *
108   * @author Benjamin Renard <brenard@easter-eggs.com
109   *
110   * @retval boolean true si l'initialisation a réussi, false sinon.
111   */
112   function startLSerror() {
113     if(!$this -> loadLSclass('LSerror'))
114       return;
115     $GLOBALS['LSerror'] = new LSerror();
116     return true;
117   }
118
119  /**
120   * Chargement d'une classe d'LdapSaisie
121   *
122   * @param[in] $class Nom de la classe Ã  charger (Exemple : LSeepeople)
123   * @param[in] $type (Optionnel) Type de classe Ã  charger (Exemple : LSobjects)
124   *
125   * @author Benjamin Renard <brenard@easter-eggs.com
126   * 
127   * @retval boolean true si le chargement a réussi, false sinon.
128   */
129   function loadLSclass($class,$type='') {
130     if (class_exists($class))
131       return true;
132     if($type!='')
133       $type=$type.'.';
134     return include_once LS_CLASS_DIR .'class.'.$type.$class.'.php';
135   }
136
137  /**
138   * Chargement d'un object LdapSaisie
139   *
140   * @param[in] $object Nom de l'objet Ã  charger
141   *
142   * @retval boolean true si le chargement a réussi, false sinon.
143   */
144   function loadLSobject($object) {
145     $this -> loadLSclass('LSldapObject');
146     if (!$this -> loadLSclass($object,'LSobjects')) {
147       return;
148     }
149     if (!require_once( LS_OBJECTS_DIR . 'config.LSobjects.'.$object.'.php' )) {
150       return;
151     }
152     return true;
153   }
154
155  /**
156   * Chargement d'un addons d'LdapSaisie
157   *
158   * @param[in] $addon Nom de l'addon Ã  charger (Exemple : samba)
159   *
160   * @author Benjamin Renard <brenard@easter-eggs.com
161   * 
162   * @retval boolean true si le chargement a réussi, false sinon.
163   */
164   function loadLSaddon($addon) {
165     if(require_once LS_ADDONS_DIR .'LSaddons.'.$addon.'.php') {
166       if (!call_user_func('LSaddon_'. $addon .'_support')) {
167         $GLOBALS['LSerror'] -> addErrorCode(1002,$addon);
168         return;
169       }
170       return true;
171     }
172     return;
173   }
174
175  /**
176   * Chargement des addons LdapSaisie
177   *
178   * Chargement des LSaddons contenue dans la variable
179   * $GLOBALS['LSaddons']['loads']
180   *
181   * @retval boolean true si le chargement a réussi, false sinon.
182   */
183   function loadLSaddons() {
184     if(!is_array($GLOBALS['LSaddons']['loads'])) {
185       $GLOBALS['LSerror'] -> addErrorCode(1001,"LSaddons['loads']");
186       return;
187     }
188
189     foreach ($GLOBALS['LSaddons']['loads'] as $addon) {
190       $this -> loadLSaddon($addon);
191     }
192     return true;
193   }
194
195  /**
196   * Initialisation de la session LdapSaisie
197   *
198   * Initialisation d'une LSsession :
199   * - Authentification et activation du mécanisme de session de LdapSaisie
200   * - ou Chargement des paramètres de la session Ã  partir de la variable 
201   *   $_SESSION['LSsession'].
202   * - ou Destruction de la session en cas de $_GET['LSsession_logout'].
203   *
204   * @retval boolean True si l'initialisation Ã  réussi (utilisateur authentifié), false sinon.
205   */
206   function startLSsession() {
207       $this -> loadLSaddons();
208       session_start();
209
210       // Déconnexion
211       if (isset($_GET['LSsession_logout'])||isset($_GET['LSsession_recoverPassword'])) {
212         session_destroy();
213         
214         if (is_array($_SESSION['LSsession']['tmp_file'])) {
215           $this -> tmp_file = $_SESSION['LSsession']['tmp_file'];
216         }
217         $this -> deleteTmpFile();
218         unset($_SESSION['LSsession']);
219       }
220       
221       // Récupération de mot de passe
222       if (isset($_GET['recoveryHash'])) {
223         $_POST['LSsession_user'] = 'a determiner plus tard';
224       }
225       
226       if(isset($_SESSION['LSsession'])) {
227         // Session existante
228         $this -> confDir      = $_SESSION['LSsession']['confDir'];
229         $this -> topDn        = $_SESSION['LSsession']['topDn'];
230         $this -> dn           = $_SESSION['LSsession']['dn'];
231         $this -> rdn          = $_SESSION['LSsession']['rdn'];
232         $this -> ldapServerId = $_SESSION['LSsession']['ldapServerId'];
233         $this -> tmp_file     = $_SESSION['LSsession']['tmp_file'];
234         
235         if ( $this -> cacheLSrights() && !isset($_REQUEST['LSsession_refresh']) ) {
236           $this -> ldapServer = $_SESSION['LSsession']['ldapServer'];
237           $this -> LSrights   = $_SESSION['LSsession']['LSrights'];
238           $this -> LSaccess   = $_SESSION['LSsession']['LSaccess'];
239           if (!$this -> LSldapConnect())
240             return;
241         }
242         else {
243           $this -> setLdapServer($this -> ldapServerId);
244           if (!$this -> LSldapConnect())
245             return;
246           $this -> loadLSrights();
247         }
248         
249         if ( $this -> cacheSudDn() && (!isset($_REQUEST['LSsession_refresh'])) ) {
250           $this -> _subDnLdapServer = $_SESSION['LSsession_subDnLdapServer'];
251         }
252         
253         if (!$this -> loadLSobject($this -> ldapServer['authobject'])) {
254           $GLOBALS['LSerror'] -> addErrorCode(1004,$this -> ldapServer['authobject']);
255           return;
256         }
257         
258         $this -> LSuserObject = new $this -> ldapServer['authobject']();
259         $this -> LSuserObject -> loadData($this -> dn);
260         
261         if ( !$this -> cacheLSrights() || isset($_REQUEST['LSsession_refresh']) ) {
262           $this -> loadLSaccess();
263         }
264         
265         $GLOBALS['Smarty'] -> assign('LSsession_username',$this -> LSuserObject -> getDisplayValue());
266         
267         if ($_POST['LSsession_topDn']) {
268           if ($this -> validSubDnLdapServer($_POST['LSsession_topDn'])) {
269             $this -> topDn = $_POST['LSsession_topDn'];
270             $_SESSION['LSsession']['topDn'] = $_POST['LSsession_topDn'];
271           } // end if
272         } // end if
273         
274         return true;
275         
276       }
277       else {
278         // Session inexistante
279         $recoveryPasswordInfos=array();
280
281         if (isset($_POST['LSsession_user'])) {
282           if (isset($_POST['LSsession_ldapserver'])) {
283             $this -> setLdapServer($_POST['LSsession_ldapserver']);
284           }
285           else {
286             $this -> setLdapServer(0);
287           }
288           
289           // Connexion au serveur LDAP
290               if ($this -> LSldapConnect()) {
291
292             // topDn
293             if ( $_POST['LSsession_topDn'] != '' ){
294               $this -> topDn = $_POST['LSsession_topDn'];
295             }
296             else {
297               $this -> topDn = $this -> ldapServer['ldap_config']['basedn'];
298             }
299             $_SESSION['LSsession_topDn']=$this -> topDn;
300
301             if ( $this -> loadLSobject($this -> ldapServer['authobject']) ) {
302               $authobject = new $this -> ldapServer['authobject']();
303               $find=true;
304               if (isset($_GET['recoveryHash'])) {
305                 $filter=$this -> ldapServer['recoverPassword']['recoveryHashAttr']."=".$_GET['recoveryHash'];
306                 $result = $authobject -> listObjects($filter,$this -> topDn);
307                 $nbresult=count($result);
308                 if ($nbresult==1) {
309                   $rdn = $result[0] -> getValue('rdn');
310                   $rdn = $rdn[0];
311                   $_POST['LSsession_user'] = $rdn;
312                   $find=false;
313                 }
314               }
315               if ($find) {
316                 $result = $authobject -> searchObject($_POST['LSsession_user'],$this -> topDn);
317                 $nbresult=count($result);
318               }
319               if ($nbresult==0) {
320                 // identifiant incorrect
321                 LSdebug('identifiant incorrect');
322                 $GLOBALS['LSerror'] -> addErrorCode(1006);
323               }
324               else if ($nbresult>1) {
325                 // duplication d'authentité
326                 $GLOBALS['LSerror'] -> addErrorCode(1007);
327               }
328               else {
329                 if (isset($_GET['LSsession_recoverPassword'])) {
330                   LSdebug('Recover : Id trouvé');
331                   if ($this -> ldapServer['recoverPassword']) {
332                     if ($this -> loadLSaddon('mail')) {
333                       LSdebug('Récupération active');
334                       $user=$result[0];
335                       $emailAddress = $user -> getValue($this -> ldapServer['recoverPassword']['mailAttr']);
336                       $emailAddress = $emailAddress[0];
337                       
338                       // Header des mails
339                       $sendParams=array();
340                       if ($this -> ldapServer['recoverPassword']['recoveryEmailSender']) {
341                         $sendParams['From']=$this -> ldapServer['recoverPassword']['recoveryEmailSender'];
342                       }
343                       
344                       if (checkEmail($emailAddress)) {
345                         LSdebug('Email : '.$emailAddress);
346                         $this -> dn = $user -> getDn();
347                         // 1ère étape : envoie du recoveryHash
348                         if (!isset($_GET['recoveryHash'])) {
349                           // Generer un hash
350                           $rdn=$user -> getValue('rdn');
351                           $rdn = $rdn[0];
352                           $recovery_hash = md5($rdn . strval(time()) . strval(rand()));
353                           
354                           $lostPasswdForm = $user -> getForm('lostPassword');
355                           $lostPasswdForm -> setPostData(
356                             array(
357                               $this -> ldapServer['recoverPassword']['recoveryHashAttr'] => $recovery_hash
358                             )
359                             ,true
360                           );
361                           
362                           if($lostPasswdForm -> validate()) {
363                             if ($user -> updateData('lostPassword')) {
364                               // recoveryHash de l'utilisateur mis à jour
365                               if ($_SERVER['HTTPS']=='on') {
366                                 $recovery_url='https://';
367                               }
368                               else {
369                                 $recovery_url='http://';
370                               }
371                               $recovery_url .= $_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'].'&recoveryHash='.$recovery_hash;
372
373                               if (
374                                 sendMail(
375                                   $emailAddress,
376                                   $this -> ldapServer['recoverPassword']['recoveryHashMail']['subject'],
377                                   getFData($this -> ldapServer['recoverPassword']['recoveryHashMail']['msg'],$recovery_url),
378                                   $sendParams
379                                 )
380                               ){
381                                 // Mail a bien été envoyé
382                                 $recoveryPasswordInfos['recoveryHashMail']=$emailAddress;
383                               }
384                               else {
385                                 // Problème durant l'envoie du mail
386                                 LSdebug("Problème durant l'envoie du mail");
387                                 $GLOBALS['LSerror'] -> addErrorCode(1020);
388                               }
389                             }
390                             else {
391                               // Erreur durant la mise à jour de l'objet
392                               LSdebug("Erreur durant la mise à jour de l'objet");
393                               $GLOBALS['LSerror'] -> addErrorCode(1020);
394                             }
395                           }
396                           else {
397                             // Erreur durant la validation du formulaire de modification de perte de password
398                             LSdebug("Erreur durant la validation du formulaire de modification de perte de password");
399                             $GLOBALS['LSerror'] -> addErrorCode(1020);
400                           }
401                         }
402                         // 2nd étape : génération du mot de passe + envoie par mail
403                         else {
404                           $attr=$user -> attrs[$this -> ldapServer['authobject_pwdattr']];
405                           if ($attr instanceof LSattribute) {
406                             $mdp = generatePassword($attr -> config['html_options']['chars'],$attr -> config['html_options']['lenght']);
407                             LSdebug('Nvx mpd : '.$mdp);
408                             $lostPasswdForm = $user -> getForm('lostPassword');
409                             $lostPasswdForm -> setPostData(
410                               array(
411                                 $this -> ldapServer['recoverPassword']['recoveryHashAttr'] => array(''),
412                                 $this -> ldapServer['authobject_pwdattr'] => array($mdp)
413                               )
414                               ,true
415                             );
416                             if($lostPasswdForm -> validate()) {
417                               if ($user -> updateData('lostPassword')) {
418                                 if (
419                                   sendMail(
420                                     $emailAddress,
421                                     $this -> ldapServer['recoverPassword']['newPasswordMail']['subject'],
422                                     getFData($this -> ldapServer['recoverPassword']['newPasswordMail']['msg'],$mdp),
423                                     $sendParams
424                                   )
425                                 ){
426                                   // Mail a bien été envoyé
427                                   $recoveryPasswordInfos['newPasswordMail']=$emailAddress;
428                                 }
429                                 else {
430                                   // Problème durant l'envoie du mail
431                                   LSdebug("Problème durant l'envoie du mail");
432                                   $GLOBALS['LSerror'] -> addErrorCode(1020);
433                                 }
434                               }
435                               else {
436                                 // Erreur durant la mise à jour de l'objet
437                                 LSdebug("Erreur durant la mise à jour de l'objet");
438                                 $GLOBALS['LSerror'] -> addErrorCode(1020);
439                               }
440                             }
441                             else {
442                               // Erreur durant la validation du formulaire de modification de perte de password
443                               LSdebug("Erreur durant la validation du formulaire de modification de perte de password");
444                               $GLOBALS['LSerror'] -> addErrorCode(1020);
445                             }
446                           }
447                           else {
448                             // l'attribut password n'existe pas
449                             LSdebug("L'attribut password n'existe pas");
450                             $GLOBALS['LSerror'] -> addErrorCode(1020);
451                           }
452                         }
453                       }
454                       else {
455                         $GLOBALS['LSerror'] -> addErrorCode(1019);
456                       }
457                     }
458                   }
459                   else {
460                     $GLOBALS['LSerror'] -> addErrorCode(1018);
461                   }
462                 }
463                 else {
464                   if ( $this -> checkUserPwd($result[0],$_POST['LSsession_pwd']) ) {
465                     // Authentification réussi
466                     $this -> LSuserObject = $result[0];
467                     $this -> dn = $result[0]->getValue('dn');
468                     $this -> rdn = $_POST['LSsession_user'];
469                     $this -> loadLSrights();
470                     $this -> loadLSaccess();
471                     $GLOBALS['Smarty'] -> assign('LSsession_username',$this -> LSuserObject -> getDisplayValue());
472                     $_SESSION['LSsession']=get_object_vars($this);
473                     return true;
474                   }
475                   else {
476                     $GLOBALS['LSerror'] -> addErrorCode(1006);
477                     LSdebug('mdp incorrect');
478                   }
479                 }
480               }
481             }
482             else {
483               $GLOBALS['LSerror'] -> addErrorCode(1010);
484             }
485           }
486           else {
487             $GLOBALS['LSerror'] -> addErrorCode(1009);
488           }
489         }
490         if ($this -> ldapServerId) {
491           $GLOBALS['Smarty'] -> assign('ldapServerId',$this -> ldapServerId);
492         }
493         $GLOBALS['Smarty'] -> assign('topDn',$this -> topDn);
494         if (isset($_GET['LSsession_recoverPassword'])) {
495           $this -> displayRecoverPasswordForm($recoveryPasswordInfos);
496         }
497         else {
498           $this -> displayLoginForm();
499         }
500         return;
501       }
502   }
503
504  /**
505   * Modifie l'utilisateur connecté à la volé
506   * 
507   * @param[in] $object Mixed  L'objet Ldap du nouvel utilisateur
508   *                           le type doit correspondre à
509   *                           $this -> ldapServer['authobject']
510   * 
511   * @retval boolean True en cas de succès, false sinon
512   */
513  function changeAuthUser($object) {
514   if ($object instanceof $this -> ldapServer['authobject']) {
515     $this -> dn = $object -> getDn();
516     $rdn = $object -> getValue('rdn');
517     if(is_array($rdn)) {
518       $rdn = $rdn[0];
519     }
520     $this -> rdn = $rdn;
521     $this -> LSuserObject = $object;
522     
523     if($this -> loadLSrights()) {
524       $this -> loadLSaccess();
525       $_SESSION['LSsession']=get_object_vars($this);
526       return true;
527     }
528   }
529   return;
530  }
531
532  /**
533   * Définition du serveur Ldap de la session
534   *
535   * Définition du serveur Ldap de la session Ã  partir de son ID dans 
536   * le tableau $GLOBALS['LSconfig']['ldap_servers'].
537   *
538   * @param[in] integer Index du serveur Ldap
539   *
540   * @retval boolean True sinon false.
541   */
542   function setLdapServer($id) {
543     if ( isset($GLOBALS['LSconfig']['ldap_servers'][$id]) ) {
544       $this -> ldapServerId = $id;
545       $this -> ldapServer=$GLOBALS['LSconfig']['ldap_servers'][$id];
546       return true;
547     }
548     else {
549       return;
550     }
551   }
552
553  /**
554   * Connexion au serveur Ldap
555   *
556   * @retval boolean True sinon false.
557   */
558   function LSldapConnect() {
559     if ($this -> ldapServer) {
560       include_once($GLOBALS['LSconfig']['NetLDAP2']);
561       if (!$this -> loadLSclass('LSldap'))
562         return;
563         $GLOBALS['LSldap'] = new LSldap($this -> ldapServer['ldap_config']);
564         if ($GLOBALS['LSldap'] -> isConnected())
565           return true;
566         else
567           return;
568       return $GLOBALS['LSldap'] = new LSldap($this -> ldapServer['ldap_config']);
569     }
570     else {
571       $GLOBALS['LSerror'] -> addErrorCode(1003);
572       return;
573     }
574   }
575
576  /**
577   * Retourne les sous-dns du serveur Ldap courant
578   *
579   * @retval mixed Tableau des subDn, false si une erreur est survenue.
580   */
581   function getSubDnLdapServer() {
582     if ($this -> cacheSudDn() && isset($this -> _subDnLdapServer[$this -> ldapServerId])) {
583       return $this -> _subDnLdapServer[$this -> ldapServerId];
584     }
585     if ( is_array($this ->ldapServer['subDn']) ) {
586       $return=array();
587       foreach($this ->ldapServer['subDn'] as $subDn_name => $subDn_config) {
588         if ($subDn_name == 'LSobject') {
589           if (is_array($subDn_config)) {
590             foreach($subDn_config as $LSobject_name => $LSoject_config) {
591               if ($LSoject_config['topDn']) {
592                 $topDn = $LSoject_config['topDn'];
593               }
594               else {
595                 $topDn = NULL;
596               }
597               if( $this -> loadLSobject($LSobject_name) ) {
598                 if ($subdnobject = new $LSobject_name()) {
599                   $tbl_return = $subdnobject -> getSelectArray($topDn);
600                   if (is_array($tbl_return)) {
601                     $return=array_merge($return,$tbl_return);
602                   }
603                   else {
604                     $GLOBALS['LSerror'] -> addErrorCode(1017);
605                   }
606                 }
607                 else {
608                   $GLOBALS['LSerror'] -> addErrorCode(1017);
609                 }
610               }
611               else {
612                 $GLOBALS['LSerror'] -> addErrorCode(1004,$LSobject_name);
613               }
614             }
615           }
616           else {
617             $GLOBALS['LSerror'] -> addErrorCode(1017);
618           }
619         }
620         else {
621           if ((isCompatibleDNs($subDn_config['dn'],$this -> ldapServer['ldap_config']['basedn']))&&($subDn_config['dn']!="")) {
622             $return[$subDn_config['dn']] = $subDn_name;
623           }
624         }
625       }
626       if ($this -> cacheSudDn()) {
627         $this -> _subDnLdapServer[$this -> ldapServerId]=$return;
628         $_SESSION['LSsession_subDnLdapServer'] = $this -> _subDnLdapServer;
629       }
630       return $return;
631     }
632     else {
633       return;
634     }
635   }
636   
637   /**
638    * Retourne la liste de subDn du serveur Ldap utilise
639    * trié par la profondeur dans l'arboressence (ordre décroissant)
640    * 
641    * @return array() Tableau des subDn trié
642    */  
643   function getSortSubDnLdapServer() {
644     $subDnLdapServer = $this  -> getSubDnLdapServer();
645     if (!$subDnLdapServer) {
646       return array();
647     }
648     uksort($subDnLdapServer,"compareDn");
649     return $subDnLdapServer;
650   }
651
652  /**
653   * Retourne les options d'une liste déroulante pour le choix du topDn
654   * de connexion au serveur Ldap
655   *
656   * Liste les subdn ($this ->ldapServer['subDn'])
657   *
658   * @retval string Les options (<option>) pour la sélection du topDn.
659   */
660   function getSubDnLdapServerOptions($selected=NULL) {
661     $list = $this -> getSubDnLdapServer();
662     if ($list) {
663       asort($list);
664       $display='';
665       foreach($list as $dn => $txt) {
666         if ($selected && ($selected==$dn)) {
667           $selected_txt = ' selected';
668         }
669         else {
670           $selected_txt = '';
671         }
672         $display.="<option value=\"".$dn."\"$selected_txt>".$txt."</option>\n"; 
673       }
674       return $display;
675     }
676     return;
677   }
678
679   function validSubDnLdapServer($subDn) {
680     $listTopDn = $this -> getSubDnLdapServer();
681     if(is_array($listTopDn)) {
682       foreach($listTopDn as $dn => $txt) {
683         if ($subDn==$dn) {
684           return true;
685         } // end if
686       } // end foreach
687     } // end if
688     return;
689   }
690
691  /**
692   * Test un couple LSobject/pwd
693   *
694   * Test un bind sur le serveur avec le dn de l'objet et le mot de passe fourni.
695   *
696   * @param[in] LSobject L'object "user" pour l'authentification
697   * @param[in] string Le mot de passe Ã  tester
698   *
699   * @retval boolean True si l'authentification Ã  réussi, false sinon.
700   */
701   function checkUserPwd($object,$pwd) {
702     return $GLOBALS['LSldap'] -> checkBind($object -> getValue('dn'),$pwd);
703   }
704
705  /**
706   * Affiche le formulaire de login
707   *
708   * Défini les informations pour le template Smarty du formulaire de login.
709   *
710   * @retval void
711   */
712   function displayLoginForm() {
713     $GLOBALS['Smarty'] -> assign('pagetitle',_('Connexion'));
714     if (isset($_GET['LSsession_logout'])) {
715       $GLOBALS['Smarty'] -> assign('loginform_action','index.php');
716     }
717     else {
718       $GLOBALS['Smarty'] -> assign('loginform_action',$_SERVER['REQUEST_URI']);
719     }
720     if (count($GLOBALS['LSconfig']['ldap_servers'])==1) {
721       $GLOBALS['Smarty'] -> assign('loginform_ldapserver_style','style="display: none"');
722     }
723     $GLOBALS['Smarty'] -> assign('loginform_label_ldapserver',_('Serveur LDAP'));
724     $ldapservers_name=array();
725     $ldapservers_index=array();
726     foreach($GLOBALS['LSconfig']['ldap_servers'] as $id => $infos) {
727       $ldapservers_index[]=$id;
728       $ldapservers_name[]=$infos['name'];
729     }
730     $GLOBALS['Smarty'] -> assign('loginform_ldapservers_name',$ldapservers_name);
731     $GLOBALS['Smarty'] -> assign('loginform_ldapservers_index',$ldapservers_index);
732
733     $GLOBALS['Smarty'] -> assign('loginform_label_level',_('Niveau'));
734     $GLOBALS['Smarty'] -> assign('loginform_label_user',_('Identifiant'));
735     $GLOBALS['Smarty'] -> assign('loginform_label_pwd',_('Mot de passe'));
736     $GLOBALS['Smarty'] -> assign('loginform_label_submit',_('Connexion'));
737     $GLOBALS['Smarty'] -> assign('loginform_label_recoverPassword',_('Mot de passe oublié ?'));
738     
739     $this -> setTemplate('login.tpl');
740     $this -> addJSscript('LSsession_login.js');
741   }
742
743  /**
744   * Affiche le formulaire de récupération de mot de passe
745   *
746   * Défini les informations pour le template Smarty du formulaire de 
747   * récupération de mot de passe
748   * 
749   * @param[in] $infos array() Information sur le status du processus de 
750   *                           recouvrement de mot de passe
751   *
752   * @retval void
753   */
754   function displayRecoverPasswordForm($recoveryPasswordInfos) {
755     $GLOBALS['Smarty'] -> assign('pagetitle',_('Récupération de votre mot de passe'));
756     $GLOBALS['Smarty'] -> assign('recoverpasswordform_action','index.php?LSsession_recoverPassword');
757     
758     if (count($GLOBALS['LSconfig']['ldap_servers'])==1) {
759       $GLOBALS['Smarty'] -> assign('recoverpasswordform_ldapserver_style','style="display: none"');
760     }
761     
762     $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_ldapserver',_('Serveur LDAP'));
763     $ldapservers_name=array();
764     $ldapservers_index=array();
765     foreach($GLOBALS['LSconfig']['ldap_servers'] as $id => $infos) {
766       $ldapservers_index[]=$id;
767       $ldapservers_name[]=$infos['name'];
768     }
769     $GLOBALS['Smarty'] -> assign('recoverpasswordform_ldapservers_name',$ldapservers_name);
770     $GLOBALS['Smarty'] -> assign('recoverpasswordform_ldapservers_index',$ldapservers_index);
771
772     $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_user',_('Identifiant'));
773     $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_submit',_('Valider'));
774     $GLOBALS['Smarty'] -> assign('recoverpasswordform_label_back',_('Retour'));
775     
776     $recoverpassword_msg = _('Veuillez saisir votre identifiant pour poursuivre le processus de récupération de votre mot de passe');
777     
778     if (isset($recoveryPasswordInfos['recoveryHashMail'])) {
779       $recoverpassword_msg = getFData(
780         _("Un mail vient de vous être envoyé à l'adresse %{mail}. " .
781         "Merci de suivre les indications contenus dans ce mail."),
782         $recoveryPasswordInfos['recoveryHashMail']
783       );
784     }
785     
786     if (isset($recoveryPasswordInfos['newPasswordMail'])) {
787       $recoverpassword_msg = getFData(
788         _("Votre nouveau mot de passe vient de vous être envoyé à l'adresse %{mail}. "),
789         $recoveryPasswordInfos['newPasswordMail']
790       );
791     }
792     
793     $GLOBALS['Smarty'] -> assign('recoverpassword_msg',$recoverpassword_msg);
794     
795     $this -> setTemplate('recoverpassword.tpl');
796     $this -> addJSscript('LSsession_recoverPassword.js');
797   }
798
799  /**
800   * Défini le template Smarty Ã  utiliser
801   *
802   * Remarque : les fichiers de templates doivent se trouver dans le dossier 
803   * templates/.
804   *
805   * @param[in] string Le nom du fichier de template
806   *
807   * @retval void
808   */
809   function setTemplate($template) {
810     $this -> template = $template;
811   }
812
813  /**
814   * Ajoute un script JS au chargement de la page
815   *
816   * Remarque : les scripts doivents Ãªtre dans le dossier LS_JS_DIR.
817   *
818   * @param[in] $script Le nom du fichier de script Ã  charger.
819   *
820   * @retval void
821   */
822   function addJSscript($file,$path=NULL) {
823     $script=array(
824       'file' => $file,
825       'path' => $path
826     );
827     if (in_array($script, $this -> JSscripts))
828       return;
829     $this -> JSscripts[]=$script;
830   }
831
832  /**
833   * Ajouter un paramètre de configuration Javascript
834   * 
835   * @param[in] $name string Nom de la variable de configuration
836   * @param[in] $val mixed Valeur de la variable de configuration
837   *
838   * @retval void
839   */
840   function addJSconfigParam($name,$val) {
841     $this -> _JSconfigParams[$name]=$val;
842   }
843
844  /**
845   * Ajoute une feuille de style au chargement de la page
846   *
847   * Remarque : les scripts doivents Ãªtre dans le dossier LS_CSS_DIR.
848   *
849   * @param[in] $script Le nom du fichier css Ã  charger.
850   *
851   * @retval void
852   */
853   function addCssFile($file,$path=NULL) {
854     $cssFile=array(
855       'file' => $file,
856       'path' => $path
857     );
858     $this -> CssFiles[]=$cssFile;
859   }
860
861  /**
862   * Affiche le template Smarty
863   *
864   * Charge les dépendances et affiche le template Smarty
865   *
866   * @retval void
867   */
868   function displayTemplate() {
869     // JS
870     $JSscript_txt='';
871     foreach ($GLOBALS['defaultJSscipts'] as $script) {
872       $JSscript_txt.="<script src='".LS_JS_DIR.$script."' type='text/javascript'></script>\n";
873     }
874
875     foreach ($this -> JSscripts as $script) {
876       if (!$script['path']) {
877         $script['path']=LS_JS_DIR;
878       }
879       else {
880         $script['path'].='/';
881       }
882       $JSscript_txt.="<script src='".$script['path'].$script['file']."' type='text/javascript'></script>\n";
883     }
884
885     $GLOBALS['Smarty'] -> assign('LSjsConfig',json_encode($this -> _JSconfigParams));
886     
887     if ($GLOBALS['LSdebug']['active']) {
888       $JSscript_txt.="<script type='text/javascript'>LSdebug_active = 1;</script>\n";
889     }
890     else {
891       $JSscript_txt.="<script type='text/javascript'>LSdebug_active = 0;</script>\n";
892     }
893     
894     $GLOBALS['Smarty'] -> assign('LSsession_js',$JSscript_txt);
895
896     // Css
897     $this -> addCssFile("LSdefault.css");
898     foreach ($this -> CssFiles as $file) {
899       if (!$file['path']) {
900         $file['path']=LS_CSS_DIR.'/';
901       }
902       $Css_txt.="<link rel='stylesheet' type='text/css' href='".$file['path'].$file['file']."' />\n";
903     }
904     $GLOBALS['Smarty'] -> assign('LSsession_css',$Css_txt);
905   
906     $GLOBALS['Smarty'] -> assign('LSaccess',$this -> LSaccess[$this -> topDn]);
907     
908     // Niveau
909     $listTopDn = $this -> getSubDnLdapServer();
910     if (is_array($listTopDn)) {
911       asort($listTopDn);
912       $GLOBALS['Smarty'] -> assign('label_level',$this -> getLevelLabel());
913       $GLOBALS['Smarty'] -> assign('_refresh',_('Rafraîchir'));
914       $LSsession_topDn_index = array();
915       $LSsession_topDn_name = array();
916       foreach($listTopDn as $index => $name) {
917         $LSsession_topDn_index[]  = $index;
918         $LSsession_topDn_name[]   = $name;
919       }
920       $GLOBALS['Smarty'] -> assign('LSsession_subDn_indexes',$LSsession_topDn_index);
921       $GLOBALS['Smarty'] -> assign('LSsession_subDn_names',$LSsession_topDn_name);
922       $GLOBALS['Smarty'] -> assign('LSsession_subDn',$this -> topDn);
923       $GLOBALS['Smarty'] -> assign('LSsession_subDnName',$this -> getSubDnName());
924     }
925
926     // Infos
927     if((!empty($_SESSION['LSsession_infos']))&&(is_array($_SESSION['LSsession_infos']))) {
928       $txt_infos="<ul>\n";
929       foreach($_SESSION['LSsession_infos'] as $info) {
930         $txt_infos.="<li>$info</li>\n";
931       }
932       $txt_infos.="</ul>\n";
933       $GLOBALS['Smarty'] -> assign('LSinfos',$txt_infos);
934       $_SESSION['LSsession_infos']=array();
935     }
936     
937     if ($this -> ajaxDisplay) {
938       $GLOBALS['Smarty'] -> assign('LSerror_txt',$GLOBALS['LSerror']->getErrors());
939       $GLOBALS['Smarty'] -> assign('LSdebug_txt',LSdebug_print(true));
940     }
941     else {
942       $GLOBALS['LSerror'] -> display();
943       LSdebug_print();
944     }
945     if (!$this -> template)
946       $this -> setTemplate('empty.tpl');
947     $GLOBALS['Smarty'] -> display($this -> template);
948   }
949  
950  /**
951   * Retournne un template Smarty compilé
952   *
953   * @param[in] string $template Le template à retourner
954   * @param[in] array $variables Variables Smarty à assigner avant l'affichage
955   * 
956   * @retval string Le HTML compilé du template
957   */
958   function fetchTemplate($template,$variables=array()) {
959     foreach($variables as $name => $val) {
960       $GLOBALS['Smarty'] -> assign($name,$val);
961     }
962     return $GLOBALS['Smarty'] -> fetch($template);
963   }
964   
965   /**
966    * Charge les droits LS de l'utilisateur
967    * 
968    * @retval boolean True si le chargement Ã  réussi, false sinon.
969    **/
970   function loadLSrights() {
971     if (is_array($this -> ldapServer['LSadmins'])) {
972       foreach ($this -> ldapServer['LSadmins'] as $topDn => $adminsInfos) {
973         if (is_array($adminsInfos)) {
974           foreach($adminsInfos as $dn => $conf) {
975             if ((isset($conf['attr'])) && (isset($conf['LSobject']))) {
976               if( $this -> loadLSobject($conf['LSobject']) ) {
977                 if ($object = new $conf['LSobject']()) {
978                   if ($object -> loadData($dn)) {
979                     $listDns=$object -> getValue($conf['attr']);
980                     if (is_array($listDns)) {
981                       if (in_array($this -> dn,$listDns)) {
982                         $this -> LSrights['topDn_admin'][] = $topDn;
983                       }
984                     }
985                   }
986                   else {
987                     LSdebug('Impossible de chargé le dn : '.$dn);
988                   }
989                 }
990                 else {
991                   LSdebug('Impossible de créer l\'objet de type : '.$conf['LSobject']);
992                 }
993               }
994               else {
995                 $GLOBALS['LSerror'] -> addErrorCode(1004,$conf['LSobject']);
996               }
997             }
998             else {
999               if ($this -> dn == $dn) {
1000                 $this -> LSrights['topDn_admin'][] = $topDn;
1001               }
1002             }
1003           }
1004         }
1005         else {
1006           if ( $this -> dn == $adminsInfos ) {
1007             $this -> LSrights['topDn_admin'][] = $topDn;
1008           }
1009         }
1010       }
1011       return true;
1012     }
1013     else {
1014       return;
1015     }
1016   }
1017   
1018   /**
1019    * Charge les droits d'accès de l'utilisateur pour construire le menu de l'interface
1020    *
1021    * @retval void
1022    */
1023   function loadLSaccess() {
1024     $LSaccess=array();
1025     if (is_array($this -> ldapServer['subDn'])) {
1026       foreach($this -> ldapServer['subDn'] as $name => $config) {
1027         if ($name=='LSobject') {
1028           if (is_array($config)) {
1029
1030             // Définition des subDns 
1031             foreach($config as $objectType => $objectConf) {
1032               if ($this -> loadLSobject($objectType)) {
1033                 if ($subdnobject = new $objectType()) {
1034                   $tbl = $subdnobject -> getSelectArray();
1035                   if (is_array($tbl)) {
1036                     // Définition des accès
1037                     $access=array();
1038                     if (is_array($objectConf['LSobjects'])) {
1039                       foreach($objectConf['LSobjects'] as $type) {
1040                         if ($this -> loadLSobject($type)) {
1041                           if ($this -> canAccess($type)) {
1042                             $access[$type] = $GLOBALS['LSobjects'][$type]['label'];
1043                           }
1044                         }
1045                         else {
1046                           $GLOBALS['LSerror'] -> addErrorCode(1004,$type);
1047                         }
1048                       }
1049                     }
1050                     foreach($tbl as $dn => $dn_name) {
1051                       $LSaccess[$dn]=$access;
1052                     }
1053                   }
1054                 }
1055               }
1056               else {
1057                 $GLOBALS['LSerror'] -> addErrorCode(1004,$objectType);
1058               }
1059             }
1060           }
1061         }
1062         else {
1063           if ((isCompatibleDNs($this -> ldapServer['ldap_config']['basedn'],$config['dn']))&&($config['dn']!='')) {
1064             $access=array();
1065             if (is_array($config['LSobjects'])) {
1066               foreach($config['LSobjects'] as $objectType) {
1067                 if ($this -> loadLSobject($objectType)) {
1068                   if ($this -> canAccess($objectType)) {
1069                     $access[$objectType] = $GLOBALS['LSobjects'][$objectType]['label'];
1070                   }
1071                 }
1072                 else {
1073                   $GLOBALS['LSerror'] -> addErrorCode(1004,$LSobject_name);
1074                 }
1075               }
1076             }
1077             $LSaccess[$config['dn']]=$access;
1078           }
1079         }
1080       }
1081     }
1082     else {
1083       if(is_array($this -> ldapServer['LSaccess'])) {
1084         $access=array();
1085         foreach($this -> ldapServer['LSaccess'] as $objectType) {
1086           if ($this -> loadLSobject($objectType)) {
1087             if ($this -> canAccess($objectType)) {
1088                 $access[$objectType] = $GLOBALS['LSobjects'][$objectType]['label'];
1089             }
1090           }
1091           else {
1092             $GLOBALS['LSerror'] -> addErrorCode(1004,$LSobject_name);
1093           }
1094         }
1095         $LSaccess[$this -> topDn] = $access;
1096       }
1097     }
1098     foreach($LSaccess as $dn => $access) {
1099       $LSaccess[$dn] = array_merge(
1100         array(
1101           'SELF' => _('Mon compte')
1102         ),
1103         $access
1104       );
1105     }
1106     
1107     $this -> LSaccess = $LSaccess;
1108     $_SESSION['LSsession']['LSaccess'] = $LSaccess;
1109   }
1110   
1111   /**
1112    * Dit si l'utilisateur est admin de le DN spécifié
1113    *
1114    * @param[in] string DN de l'objet
1115    * 
1116    * @retval boolean True si l'utilisateur est admin sur l'objet, false sinon.
1117    */
1118   function isAdmin($dn) {
1119     foreach($this -> LSrights['topDn_admin'] as $topDn_admin) {
1120       if($dn == $topDn_admin) {
1121         return true;
1122       }
1123       else if ( isCompatibleDNs($dn,$topDn_admin) ) {
1124         return true;
1125       }
1126     }
1127     return;
1128   }
1129   
1130   /**
1131    * Retourne qui est l'utilisateur par rapport Ã  l'object
1132    *
1133    * @param[in] string Le DN de l'objet
1134    * 
1135    * @retval string 'admin'/'self'/'user' pour Admin , l'utilisateur lui même ou un simple utilisateur
1136    */
1137   function whoami($dn) {
1138     if ($this -> isAdmin($dn)) {
1139       return 'admin';
1140     }
1141     
1142     if ($this -> dn == $dn) {
1143       return 'self';
1144     }
1145     
1146     return 'user';
1147   }
1148   
1149   /**
1150    * Retourne le droit de l'utilisateur Ã  accèder Ã  un objet
1151    * 
1152    * @param[in] string $LSobject Le type de l'objet
1153    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par défaut)
1154    * @param[in] string $right Le type de droit d'accès Ã  tester ('r'/'w')
1155    * @param[in] string $attr Le nom de l'attribut auquel on test l'accès
1156    *
1157    * @retval boolean True si l'utilisateur a accès, false sinon
1158    */
1159   function canAccess($LSobject,$dn=NULL,$right=NULL,$attr=NULL) {
1160     if (!$this -> loadLSobject($LSobject)) {
1161       $GLOBALS['LSerror'] -> addErrorCode(1004,$LSobject);
1162       return;
1163     }
1164     if ($dn) {
1165       $whoami = $this -> whoami($dn);
1166       if ($dn==$this -> LSuserObject -> getValue('dn')) {
1167         if (!$this -> in_menu('SELF')) {
1168           return;
1169         }
1170       }
1171       else {
1172         $obj = new $LSobject();
1173         $obj -> dn = $dn;
1174         if (!$this -> in_menu($LSobject,$obj -> getSubDnValue())) {
1175           return;
1176         }
1177       }
1178     }
1179     else {
1180       $objectdn=$GLOBALS['LSobjects'][$LSobject]['container_dn'].','.$this -> topDn;
1181       $whoami = $this -> whoami($objectdn);
1182     }
1183     
1184     // Pour un attribut particulier
1185     if ($attr) {
1186       if ($attr=='rdn') {
1187         $attr=$GLOBALS['LSobjects'][$LSobject]['rdn'];
1188       }
1189       if (!isset($GLOBALS['LSobjects'][$LSobject]['attrs'][$attr])) {
1190         return;
1191       }
1192       
1193       if (($right=='r')||($right=='w')) {
1194         if ($GLOBALS['LSobjects'][$LSobject]['attrs'][$attr]['rights'][$whoami]==$right) {
1195           return true;
1196         }
1197         return;
1198       }
1199       else {
1200         if ( ($GLOBALS['LSobjects'][$LSobject]['attrs'][$attr]['rights'][$whoami]=='r') || ($GLOBALS['LSobjects'][$LSobject]['attrs'][$attr]['rights'][$whoami]=='w') ) {
1201           return true;
1202         }
1203         return;
1204       }
1205     }
1206     
1207     // Pour un attribut quelconque
1208     if (is_array($GLOBALS['LSobjects'][$LSobject]['attrs'])) {
1209       if (($right=='r')||($right=='w')) {
1210         foreach ($GLOBALS['LSobjects'][$LSobject]['attrs'] as $attr_name => $attr_config) {
1211           if ($attr_config['rights'][$whoami]==$right) {
1212             return true;
1213           }
1214         }
1215       }
1216       else {
1217         foreach ($GLOBALS['LSobjects'][$LSobject]['attrs'] as $attr_name => $attr_config) {
1218           if ( ($attr_config['rights'][$whoami]=='r') || ($attr_config['rights'][$whoami]=='w') ) {
1219             return true;
1220           }
1221         }
1222       }
1223     }
1224     return;
1225   }
1226   
1227   /**
1228    * Retourne le droit de l'utilisateur Ã  editer Ã  un objet
1229    * 
1230    * @param[in] string $LSobject Le type de l'objet
1231    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par défaut)
1232    * @param[in] string $attr Le nom de l'attribut auquel on test l'accès
1233    *
1234    * @retval boolean True si l'utilisateur a accès, false sinon
1235    */
1236   function canEdit($LSobject,$dn=NULL,$attr=NULL) {
1237     return $this -> canAccess($LSobject,$dn,'w',$attr);
1238   }
1239
1240   /**
1241    * Retourne le droit de l'utilisateur Ã  supprimer un objet
1242    * 
1243    * @param[in] string $LSobject Le type de l'objet
1244    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par défaut)
1245    *
1246    * @retval boolean True si l'utilisateur a accès, false sinon
1247    */  
1248   function canRemove($LSobject,$dn) {
1249     return $this -> canAccess($LSobject,$dn,'w','rdn');
1250   }
1251   
1252   /**
1253    * Retourne le droit de l'utilisateur Ã  créer un objet
1254    * 
1255    * @param[in] string $LSobject Le type de l'objet
1256    *
1257    * @retval boolean True si l'utilisateur a accès, false sinon
1258    */    
1259   function canCreate($LSobject) {
1260     return $this -> canAccess($LSobject,NULL,'w','rdn');
1261   }
1262   
1263   /**
1264    * Retourne le droit de l'utilisateur Ã  gérer la relation d'objet
1265    * 
1266    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par défaut)
1267    * @param[in] string $LSobject Le type de l'objet
1268    * @param[in] string $relationName Le nom de la relation avec l'objet
1269    * @param[in] string $right Le type de droit a vérifier ('r' ou 'w')
1270    *
1271    * @retval boolean True si l'utilisateur a accès, false sinon
1272    */
1273   function relationCanAccess($dn,$LSobject,$relationName,$right=NULL) {
1274     if (!isset($GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]))
1275       return;
1276     $whoami = $this -> whoami($dn);
1277
1278     if (($right=='w') || ($right=='r')) {
1279       if ($GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]['rights'][$whoami] == $right) {
1280         return true;
1281       }
1282     }
1283     else {
1284       if (($GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]['rights'][$whoami] == 'w') || ($GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]['rights'][$whoami] == 'r')) {
1285         return true;
1286       }
1287     }
1288     return;
1289   }
1290
1291   /**
1292    * Retourne le droit de l'utilisateur Ã  modifier la relation d'objet
1293    * 
1294    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par défaut)
1295    * @param[in] string $LSobject Le type de l'objet
1296    * @param[in] string $relationName Le nom de la relation avec l'objet
1297    *
1298    * @retval boolean True si l'utilisateur a accès, false sinon
1299    */  
1300   function relationCanEdit($dn,$LSobject,$relationName) {
1301     return $this -> relationCanAccess($dn,$LSobject,$relationName,'w');
1302   }
1303
1304   /**
1305    * Ajoute un fichier temporaire
1306    * 
1307    * @author Benjamin Renard <brenard@easter-eggs.com>
1308    * 
1309    * @retval void
1310    **/
1311   function addTmpFile($value,$filePath) {
1312     $hash = mhash(MHASH_MD5,$value);
1313     $this -> tmp_file[$filePath] = $hash;
1314     $_SESSION['LSsession']['tmp_file'][$filePath] = $hash;
1315   }
1316   
1317   /**
1318    * Retourne le chemin du fichier temporaire si l'existe
1319    * 
1320    * @author Benjamin Renard <brenard@easter-eggs.com>
1321    * 
1322    * @param[in] $value La valeur du fichier
1323    * 
1324    * @retval mixed 
1325    **/
1326   function tmpFileExist($value) {
1327     $hash = mhash(MHASH_MD5,$value);
1328     foreach($this -> tmp_file as $filePath => $contentHash) {
1329       if ($hash == $contentHash) {
1330         return $filePath;
1331       }
1332     }
1333     return false;
1334   }
1335   
1336   /**
1337    * Retourne le chemin du fichier temporaire
1338    * 
1339    * Retourne le chemin du fichier temporaire qu'il créera Ã  partir de la valeur
1340    * s'il n'existe pas déjà.
1341    * 
1342    * @author Benjamin Renard <brenard@easter-eggs.com>
1343    * 
1344    * @param[in] $value La valeur du fichier
1345    * 
1346    * @retval mixed 
1347    **/
1348   function getTmpFile($value) {
1349     $exist = $this -> tmpFileExist($value);
1350     if (!$exist) {
1351       $img_path = LS_TMP_DIR .rand().'.tmp';
1352       $fp = fopen($img_path, "w");
1353       fwrite($fp, $value);
1354       fclose($fp);
1355       $this -> addTmpFile($value,$img_path);
1356       return $img_path;
1357     }
1358     else {
1359       return $exist;
1360     }
1361   }
1362   
1363   /**
1364    * Supprime les fichiers temporaires
1365    * 
1366    * @author Benjamin Renard <brenard@easter-eggs.com>
1367    * 
1368    * @retval void
1369    **/
1370   function deleteTmpFile($filePath=NULL) {
1371     if ($filePath) {
1372         @unlink($filePath);
1373         unset($this -> tmp_file[$filePath]);
1374         unset($_SESSION['LSsession']['tmp_file'][$filePath]);
1375     }
1376     else {
1377       foreach($this -> tmp_file as $file => $content) {
1378         @unlink($file);
1379       }
1380       $this -> tmp_file = array();
1381       $_SESSION['LSsession']['tmp_file'] = array();
1382     }
1383   }
1384
1385   /**
1386    * Retourne true si le cache des droits est activé
1387    *
1388    * @author Benjamin Renard <brenard@easter-eggs.com>
1389    * 
1390    * @retval boolean True si le cache des droits est activé, false sinon.
1391    */
1392   function cacheLSrights() {
1393     return ( ($GLOBALS['LSconfig']['cacheLSrights']) || ($this -> ldapServer['cacheLSrights']) );
1394   }
1395
1396   /**
1397    * Retourne true si le cache des subDn est activé
1398    *
1399    * @author Benjamin Renard <brenard@easter-eggs.com>
1400    * 
1401    * @retval boolean True si le cache des subDn est activé, false sinon.
1402    */
1403   function cacheSudDn() {
1404     return (($GLOBALS['LSconfig']['cacheSubDn']) || ($this -> ldapServer['cacheSubDn']));
1405   }
1406   
1407   /**
1408    * Retourne true si le cache des recherches est activé
1409    *
1410    * @author Benjamin Renard <brenard@easter-eggs.com>
1411    * 
1412    * @retval boolean True si le cache des recherches est activé, false sinon.
1413    */
1414   function cacheSearch() {
1415     return (($GLOBALS['LSconfig']['cacheSearch']) || ($this -> ldapServer['cacheSearch']));
1416   }
1417   
1418   /**
1419    * Retourne le label des niveaux pour le serveur ldap courant
1420    * 
1421    * @author Benjamin Renard <brenard@easter-eggs.com>
1422    * 
1423    * @retval string Le label des niveaux pour le serveur ldap dourant
1424    */
1425   function getLevelLabel() {
1426     return ($this -> ldapServer['levelLabel']!='')?$this -> ldapServer['levelLabel']:_('Niveau');
1427   }
1428   
1429   /**
1430    * Retourne le nom du subDn
1431    * 
1432    * @param[in] $subDn string subDn
1433    * 
1434    * @retval string Le nom du subDn ou '' sinon
1435    */
1436   function getSubDnName($subDn=false) {
1437     if (!$subDn) {
1438       $subDn = $this -> topDn;
1439     }
1440     if ($this -> getSubDnLdapServer()) {
1441       if (isset($this -> _subDnLdapServer[$this -> ldapServerId][$subDn])) {
1442         return $this -> _subDnLdapServer[$this -> ldapServerId][$subDn];
1443       }
1444     }
1445     return '';
1446   }
1447
1448   /**
1449    * L'objet est t-il utilisé pour listé les subDnS
1450    * 
1451    * @param[in] $type string Le type d'objet
1452    * 
1453    * @retval boolean true si le type d'objet est un subDnObject, false sinon
1454    */
1455   function isSubDnLSobject($type) {
1456     $result = false;
1457     if (is_array($this -> ldapServer['subDn']['LSobject'])) {
1458       foreach($this -> ldapServer['subDn']['LSobject'] as $key => $value) {
1459         if ($key==$type) {
1460           $result=true;
1461         }
1462       }
1463     }
1464     return $result;
1465   }
1466   
1467   /**
1468    * Indique si un type d'objet est dans le menu courant
1469    * 
1470    * @retval boolean true si le type d'objet est dans le menu, false sinon
1471    */
1472   function in_menu($LSobject,$topDn=NULL) {
1473     if (!$topDn) {
1474       $topDn=$this -> topDn;
1475     }
1476     return isset($this -> LSaccess[$topDn][$LSobject]);
1477   }
1478   
1479   /**
1480    * Indique si le serveur LDAP courant a des subDn
1481    * 
1482    * @retval boolean true si le serveur LDAP courant a des subDn, false sinon
1483    */
1484   function haveSubDn() {
1485     return (is_array($this -> ldapServer['subDn']));
1486   }
1487
1488   /**
1489    * Ajoute une information à afficher
1490    * 
1491    * @param[in] $msg string Le message à afficher
1492    * 
1493    * @retval void
1494    */
1495   function addInfo($msg) {
1496     $_SESSION['LSsession_infos'][]=$msg;
1497   }
1498   
1499   /**
1500    * Redirection de l'utilisateur vers une autre URL
1501    * 
1502    * @param[in] $url string L'URL
1503    * @param[in] $exit boolean Si true, l'execution script s'arrête après la redirection
1504    * 
1505    * @retval void
1506    */  
1507   function redirect($url,$exit=true) {
1508     $GLOBALS['Smarty'] -> assign('url',$url);
1509     $GLOBALS['Smarty'] -> display('redirect.tpl');
1510     if ($exit) {
1511       exit();
1512     }
1513   }
1514   
1515   /**
1516    * Retourne l'adresse mail d'emission configurée pour le serveur courant
1517    * 
1518    * @retval string Adresse mail d'emission
1519    */
1520   function getEmailSender() {
1521     return $this -> ldapServer['emailSender'];  
1522   }
1523 }
1524
1525 ?>