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