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