- Correction bug [#1668] Variables GET non récupérées après
[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
50   /**
51    * Constructeur
52    *
53    * @author Benjamin Renard <brenard@easter-eggs.com>
54    *
55    * @retval void
56    */
57   function LSsession ($configDir=LS_DEFAULT_CONF_DIR) {
58     $this -> confDir = $configDir;
59     if ($this -> loadConfig()) {
60       $this -> startLSerror();
61     }
62     else {
63       return;
64     }
65   }
66
67  /*
68   * Chargement de la configuration
69   *
70   * Chargement des fichiers de configuration et création de l'objet Smarty.
71   *
72   * @author Benjamin Renard <brenard@easter-eggs.com>
73   *
74   * @retval true si tout c'est bien passé, false sinon
75   */
76   function loadConfig() {
77     if (loadDir($this -> confDir, '^config\..*\.php$')) {
78       if ( include_once $GLOBALS['LSconfig']['Smarty'] ) {
79         $GLOBALS['Smarty'] = new Smarty();
80         return true;
81       }
82       else {
83         die($GLOBALS['LSerror_code'][1008]['msg']);
84         return;
85       }
86       return true;
87     }
88     else {
89       return;
90     }
91   }
92
93  /*
94   * Initialisation de la gestion des erreurs
95   *
96   * Création de l'objet LSerror
97   *
98   * @author Benjamin Renard <brenard@easter-eggs.com
99   *
100   * @retval boolean true si l'initialisation a réussi, false sinon.
101   */
102   function startLSerror() {
103     if(!$this -> loadLSclass('LSerror'))
104       return;
105     $GLOBALS['LSerror'] = new LSerror();
106     return true;
107   }
108
109  /*
110   * Chargement d'une classe d'LdapSaisie
111   *
112   * @param[in] $class Nom de la classe à charger (Exemple : LSeepeople)
113   * @param[in] $type (Optionnel) Type de classe à charger (Exemple : LSobjects)
114   *
115   * @author Benjamin Renard <brenard@easter-eggs.com
116   * 
117   * @retval boolean true si le chargement a réussi, false sinon.
118   */
119   function loadLSclass($class,$type='') {
120     if (class_exists($class))
121       return true;
122     if($type!='')
123       $type=$type.'.';
124     return include_once LS_CLASS_DIR .'class.'.$type.$class.'.php';
125   }
126
127  /*
128   * Chargement d'un object LdapSaisie
129   *
130   * @param[in] $object Nom de l'objet à charger
131   *
132   * @retval boolean true si le chargement a réussi, false sinon.
133   */
134   function loadLSobject($object) {
135     $this -> loadLSclass('LSldapObject');
136     if (!$this -> loadLSclass($object,'LSobjects')) {
137       return;
138     }
139     if (!require_once( LS_OBJECTS_DIR . 'config.LSobjects.'.$object.'.php' )) {
140       return;
141     }
142     return true;
143   }
144
145  /*
146   * Chargement des objects LdapSaisie
147   *
148   * Chargement des LSobjects contenue dans la variable
149   * $this -> ldapServer['LSobjects']
150   *
151   * @retval boolean true si le chargement a réussi, false sinon.
152   */
153   function loadLSobjects() {
154
155     $this -> loadLSclass('LSldapObject');
156
157     if(!is_array($this -> ldapServer['LSobjects'])) {
158       $GLOBALS['LSerror'] -> addErrorCode(1001,"LSobjects['loads']");
159       return;
160     }
161
162     foreach ($this -> ldapServer['LSobjects'] as $object) {
163       if ( !$this -> loadLSobject($object) )
164         return;
165     }
166     return true;
167   }
168
169  /*
170   * Chargement d'un addons d'LdapSaisie
171   *
172   * @param[in] $addon Nom de l'addon à charger (Exemple : samba)
173   *
174   * @author Benjamin Renard <brenard@easter-eggs.com
175   * 
176   * @retval boolean true si le chargement a réussi, false sinon.
177   */
178   function loadLSaddon($addon) {
179     return require_once LS_ADDONS_DIR .'LSaddons.'.$addon.'.php';
180   }
181
182  /*
183   * Chargement des addons LdapSaisie
184   *
185   * Chargement des LSaddons contenue dans la variable
186   * $GLOBALS['LSaddons']['loads']
187   *
188   * @retval boolean true si le chargement a réussi, false sinon.
189   */
190   function loadLSaddons() {
191     if(!is_array($GLOBALS['LSaddons']['loads'])) {
192       $GLOBALS['LSerror'] -> addErrorCode(1001,"LSaddons['loads']");
193       return;
194     }
195
196     foreach ($GLOBALS['LSaddons']['loads'] as $addon) {
197       $this -> loadLSaddon($addon);
198       if (!call_user_func('LSaddon_'. $addon .'_support')) {
199         $GLOBALS['LSerror'] -> addErrorCode(1002,$addon);
200       }
201     }
202     return true;
203   }
204
205  /*
206   * Initialisation de la session LdapSaisie
207   *
208   * Initialisation d'une LSsession :
209   * - Authentification et activation du mécanisme de session de LdapSaisie
210   * - ou Chargement des paramètres de la session à partir de la variable 
211   *   $_SESSION['LSsession'].
212   * - ou Destruction de la session en cas de $_GET['LSsession_logout'].
213   *
214   * @retval boolean True si l'initialisation à réussi (utilisateur authentifié), false sinon.
215   */
216   function startLSsession() {
217       $this -> loadLSaddons();
218       session_start();
219
220       // Déconnexion
221       if (isset($_GET['LSsession_logout'])) {
222         session_destroy();
223         
224         if (is_array($_SESSION['LSsession']['tmp_file'])) {
225           $this -> tmp_file = $_SESSION['LSsession']['tmp_file'];
226         }
227         $this -> deleteTmpFile();
228         unset($_SESSION['LSsession']);
229       }
230       
231
232       if(isset($_SESSION['LSsession'])) {
233         // Session existante
234         $this -> confDir      = $_SESSION['LSsession']['confDir'];
235         $this -> topDn        = $_SESSION['LSsession']['topDn'];
236         $this -> dn           = $_SESSION['LSsession']['dn'];
237         $this -> rdn          = $_SESSION['LSsession']['rdn'];
238         $this -> ldapServerId = $_SESSION['LSsession']['ldapServerId'];
239         $this -> tmp_file     = $_SESSION['LSsession']['tmp_file'];
240         
241         if ( ($GLOBALS['LSconfig']['cacheLSrights']) || ($this -> ldapServer['cacheLSrights']) ) {
242           $this -> ldapServer = $_SESSION['LSsession']['ldapServer'];
243           $this -> LSrights   = $_SESSION['LSsession']['LSrights'];
244           $this -> LSaccess   = $_SESSION['LSsession']['LSaccess'];
245           if (!$this -> LSldapConnect())
246             return;
247           $this -> loadLSobjects();
248         }
249         else {
250           $this -> setLdapServer($this -> ldapServerId);
251           if (!$this -> LSldapConnect())
252             return;
253           $this -> loadLSobjects();
254           $this -> loadLSrights();
255         }
256         $this -> loadLSobject($this -> ldapServer['authobject']);
257         $this -> LSuserObject = new $this -> ldapServer['authobject']();
258         $this -> LSuserObject -> loadData($this -> dn);
259         $this -> loadLSaccess();
260         $GLOBALS['Smarty'] -> assign('LSsession_username',$this -> LSuserObject -> getDisplayValue());
261         
262         if ($_POST['LSsession_topDn']) {
263           if ($this -> validSubDnLdapServer($_POST['LSsession_topDn'])) {
264             $this -> topDn = $_POST['LSsession_topDn'];
265             $_SESSION['LSsession']['topDn'] = $_POST['LSsession_topDn'];
266           } // end if
267         } // end if
268         
269         return true;
270         
271       }
272       else {
273         // Session inexistante
274
275         if (isset($_POST['LSsession_user'])) {
276           if (isset($_POST['LSsession_ldapserver'])) {
277             $this -> setLdapServer($_POST['LSsession_ldapserver']);
278           }
279           else {
280             $this -> setLdapServer(0);
281           }
282
283           // Connexion au serveur LDAP
284               if ($this -> LSldapConnect()) {
285
286             // topDn
287             if ( $_POST['LSsession_topDn'] != '' ){
288               $this -> topDn = $_POST['LSsession_topDn'];
289             }
290             else {
291               $this -> topDn = $this -> ldapServer['ldap_config']['basedn'];
292             }
293             $_SESSION['LSsession_topDn']=$this -> topDn;
294
295             if ( $this -> loadLSobject($this -> ldapServer['authobject']) ) {
296               $authobject = new $this -> ldapServer['authobject']();
297               $result = $authobject -> searchObject($_POST['LSsession_user'],$this -> topDn);
298               $nbresult=count($result);
299               if ($nbresult==0) {
300                 // identifiant incorrect
301                 debug('identifiant incorrect');
302                 $GLOBALS['LSerror'] -> addErrorCode(1006);
303               }
304               else if ($nbresult>1) {
305                 // duplication d'authentité
306                 $GLOBALS['LSerror'] -> addErrorCode(1007);
307               }
308               else {
309                 if ( $this -> checkUserPwd($result[0],$_POST['LSsession_pwd']) ) {
310                   // Authentification réussi
311                   $this -> LSuserObject = $result[0];
312                   $this -> dn = $result[0]->getValue('dn');
313                   $this -> rdn = $_POST['LSsession_user'];
314                   $this -> loadLSrights();
315                   $this -> loadLSaccess();
316                   $GLOBALS['Smarty'] -> assign('LSsession_username',$this -> LSuserObject -> getDisplayValue());
317                   $_SESSION['LSsession']=get_object_vars($this);
318                   return true;
319                 }
320                 else {
321                   $GLOBALS['LSerror'] -> addErrorCode(1006);
322                   debug('mdp incorrect');
323                 }
324               }
325             }
326             else {
327               $GLOBALS['LSerror'] -> addErrorCode(1010);
328             }
329           }
330           else {
331             $GLOBALS['LSerror'] -> addErrorCode(1009);
332           }
333         }
334         if ($this -> ldapServerId) {
335           $GLOBALS['Smarty'] -> assign('ldapServerId',$this -> ldapServerId);
336         }
337         $GLOBALS['Smarty'] -> assign('topDn',$this -> topDn);
338         $this -> displayLoginForm();
339         return;
340       }
341   }
342
343  /*
344   * Définition du serveur Ldap de la session
345   *
346   * Définition du serveur Ldap de la session à partir de son ID dans 
347   * le tableau $GLOBALS['LSconfig']['ldap_servers'].
348   *
349   * @param[in] integer Index du serveur Ldap
350   *
351   * @retval boolean True sinon false.
352   */
353   function setLdapServer($id) {
354     if ( isset($GLOBALS['LSconfig']['ldap_servers'][$id]) ) {
355       $this -> ldapServerId = $id;
356       $this -> ldapServer=$GLOBALS['LSconfig']['ldap_servers'][$id];
357       return true;
358     }
359     else {
360       return;
361     }
362   }
363
364  /*
365   * Connexion au serveur Ldap
366   *
367   * @retval boolean True sinon false.
368   */
369   function LSldapConnect() {
370     if ($this -> ldapServer) {
371       include_once($GLOBALS['LSconfig']['NetLDAP2']);
372       if (!$this -> loadLSclass('LSldap'))
373         return;
374         $GLOBALS['LSldap'] = new LSldap($this -> ldapServer['ldap_config']);
375         if ($GLOBALS['LSldap'] -> isConnected())
376           return true;
377         else
378           return;
379       return $GLOBALS['LSldap'] = new LSldap($this -> ldapServer['ldap_config']);
380     }
381     else {
382       $GLOBALS['LSerror'] -> addErrorCode(1003);
383       return;
384     }
385   }
386
387  /*
388   * Retourne les sous-dns du serveur Ldap courant
389   *
390   * @retval mixed Tableau des subDn, false si une erreur est survenue.
391   */
392   function getSubDnLdapServer() {
393     if ( is_array($this ->ldapServer['subDn']) ) {
394       $return=array();
395       foreach($this ->ldapServer['subDn'] as $subDn_name => $subDn_config) {
396         if ($subDn_name == 'LSobject') {
397           if (is_array($subDn_config)) {
398             foreach($subDn_config as $LSobject_name => $LSoject_topDn) {
399               if ($LSoject_topDn) {
400                 $topDn = $LSoject_topDn;
401               }
402               else {
403                 $topDn = NULL;
404               }
405               if( $this -> loadLSobject($LSobject_name) ) {
406                 if ($subdnobject = new $LSobject_name()) {
407                   $tbl_return = $subdnobject -> getSelectArray($topDn);
408                   if (is_array($tbl_return)) {
409                     $return=array_merge($return,$tbl_return);
410                   }
411                   else {
412                     $GLOBALS['LSerror'] -> addErrorCode(1017);
413                   }
414                 }
415                 else {
416                   $GLOBALS['LSerror'] -> addErrorCode(1017);
417                 }
418               }
419               else {
420                 $GLOBALS['LSerror'] -> addErrorCode(1004,$LSobject_name);
421               }
422             }
423           }
424           else {
425             $GLOBALS['LSerror'] -> addErrorCode(1017);
426           }
427         }
428         else {
429           $return[$subDn_config] = $subDn_name;
430         }
431       }
432       return $return;
433     }
434     else {
435       return;
436     }
437   }
438
439  /*
440   * Retourne les options d'une liste déroulante pour le choix du topDn
441   * de connexion au serveur Ldap
442   *
443   * Liste les subdn ($this ->ldapServer['subDn'])
444   *
445   * @retval string Les options (<option>) pour la sélection du topDn.
446   */
447   function getSubDnLdapServerOptions($selected=NULL) {
448     $list = $this -> getSubDnLdapServer();
449     if ($list) {
450       $display='';
451       foreach($list as $dn => $txt) {
452         if ($selected && ($selected==$dn)) {
453           $selected_txt = ' selected';
454         }
455         else {
456           $selected_txt = '';
457         }
458         $display.="<option value=\"".$dn."\"$selected_txt>".$txt."</option>\n"; 
459       }
460       return $display;
461     }
462     return;
463   }
464
465   function validSubDnLdapServer($subDn) {
466     $listTopDn = $this -> getSubDnLdapServer();
467     if(is_array($listTopDn)) {
468       foreach($listTopDn as $dn => $txt) {
469         if ($subDn==$dn) {
470           return true;
471         } // end if
472       } // end foreach
473     } // end if
474     return;
475   }
476
477  /*
478   * Test un couple LSobject/pwd
479   *
480   * Test un bind sur le serveur avec le dn de l'objet et le mot de passe fourni.
481   *
482   * @param[in] LSobject L'object "user" pour l'authentification
483   * @param[in] string Le mot de passe à tester
484   *
485   * @retval boolean True si l'authentification à réussi, false sinon.
486   */
487   function checkUserPwd($object,$pwd) {
488     return $GLOBALS['LSldap'] -> checkBind($object -> getValue('dn'),$pwd);
489   }
490
491  /*
492   * Affiche le formulaire de login
493   *
494   * Défini les informations pour le template Smarty du formulaire de login.
495   *
496   * @retval void
497   */
498   function displayLoginForm() {
499     $GLOBALS['Smarty'] -> assign('pagetitle',_('Connexion'));
500     if (isset($_GET['LSsession_logout'])) {
501       $GLOBALS['Smarty'] -> assign('loginform_action','index.php');
502     }
503     else {
504       $GLOBALS['Smarty'] -> assign('loginform_action',$_SERVER['REQUEST_URI']);
505     }
506     if (count($GLOBALS['LSconfig']['ldap_servers'])==1) {
507       $GLOBALS['Smarty'] -> assign('loginform_ldapserver_style','style="display: none"');
508     }
509     $GLOBALS['Smarty'] -> assign('loginform_label_ldapserver',_('Serveur LDAP'));
510     $ldapservers_name=array();
511     $ldapservers_index=array();
512     foreach($GLOBALS['LSconfig']['ldap_servers'] as $id => $infos) {
513       $ldapservers_index[]=$id;
514       $ldapservers_name[]=$infos['name'];
515     }
516     $GLOBALS['Smarty'] -> assign('loginform_ldapservers_name',$ldapservers_name);
517     $GLOBALS['Smarty'] -> assign('loginform_ldapservers_index',$ldapservers_index);
518
519     $GLOBALS['Smarty'] -> assign('loginform_label_level',_('Niveau'));
520     $GLOBALS['Smarty'] -> assign('loginform_label_user',_('Identifiant'));
521     $GLOBALS['Smarty'] -> assign('loginform_label_pwd',_('Mot de passe'));
522     $GLOBALS['Smarty'] -> assign('loginform_label_submit',_('Connexion'));
523
524     $this -> addJSscript('LSsession_login.js');
525   }
526
527  /*
528   * Défini le template Smarty à utiliser
529   *
530   * Remarque : les fichiers de templates doivent se trouver dans le dossier 
531   * templates/.
532   *
533   * @param[in] string Le nom du fichier de template
534   *
535   * @retval void
536   */
537   function setTemplate($template) {
538     $this -> template = $template;
539   }
540
541  /*
542   * Ajoute un script JS au chargement de la page
543   *
544   * Remarque : les scripts doivents être dans le dossier LS_JS_DIR.
545   *
546   * @param[in] $script Le nom du fichier de script à charger.
547   *
548   * @retval void
549   */
550   function addJSscript($script) {
551     if (in_array($script, $this -> JSscripts))
552       return;
553     $this -> JSscripts[]=$script;
554   }
555
556  /*
557   * Ajoute une feuille de style au chargement de la page
558   *
559   * Remarque : les scripts doivents être dans le dossiers templates/css/.
560   *
561   * @param[in] $script Le nom du fichier css à charger.
562   *
563   * @retval void
564   */
565   function addCssFile($file) {
566     $this -> CssFiles[]=$file;
567   }
568
569  /*
570   * Affiche le template Smarty
571   *
572   * Charge les dépendances et affiche le template Smarty
573   *
574   * @retval void
575   */
576   function displayTemplate() {
577     // JS
578     $JSscript_txt='';
579     foreach ($GLOBALS['defaultJSscipts'] as $script) {
580       $JSscript_txt.="<script src='".LS_JS_DIR.$script."' type='text/javascript'></script>\n";
581     }
582
583     foreach ($this -> JSscripts as $script) {
584       $JSscript_txt.="<script src='".LS_JS_DIR.$script."' type='text/javascript'></script>\n";
585     }
586     
587     if ($GLOBALS['LSdebug']['active']) {
588       $JSscript_txt.="<script type='text/javascript'>LSdebug_active = 1;</script>\n";
589     }
590     else {
591       $JSscript_txt.="<script type='text/javascript'>LSdebug_active = 0;</script>\n";
592     }
593     
594     $GLOBALS['Smarty'] -> assign('LSsession_js',$JSscript_txt);
595
596     // Css
597     $Css_txt="<link rel='stylesheet' type='text/css' href='templates/css/LSdefault.css' />\n";
598     $Css_txt="<link rel='stylesheet' type='text/css' href='templates/css/LSdefault.css' />\n";
599     foreach ($this -> CssFiles as $file) {
600       $Css_txt.="<link rel='stylesheet' type='text/css' href='templates/css/$file' />\n";
601     }
602     $GLOBALS['Smarty'] -> assign('LSsession_css',$Css_txt);
603
604     $GLOBALS['Smarty'] -> assign('LSaccess',$this -> LSaccess);
605     
606     // Niveau
607     $listTopDn = $this -> getSubDnLdapServer();
608     if (is_array($listTopDn)) {
609       $GLOBALS['Smarty'] -> assign('label_level',_('Niveau'));
610       $LSsession_topDn_index = array();
611       $LSsession_topDn_name = array();
612       foreach($listTopDn as $index => $name) {
613         $LSsession_topDn_index[]  = $index;
614         $LSsession_topDn_name[]   = $name;
615       }
616       $GLOBALS['Smarty'] -> assign('LSsession_topDn_index',$LSsession_topDn_index);
617       $GLOBALS['Smarty'] -> assign('LSsession_topDn_name',$LSsession_topDn_name);
618       $GLOBALS['Smarty'] -> assign('LSsession_topDn',$this -> topDn);
619     }
620     
621     $GLOBALS['LSerror'] -> display();
622     debug_print();
623     if (!$this -> template)
624       $this -> setTemplate('empty.tpl');
625     $GLOBALS['Smarty'] -> display($this -> template);
626   }
627   
628   /**
629    * Charge les droits LS de l'utilisateur
630    * 
631    * @retval boolean True si le chargement à réussi, false sinon.
632    **/
633   function loadLSrights() {
634     if (is_array($this -> ldapServer['LSadmins'])) {
635       foreach ($this -> ldapServer['LSadmins'] as $topDn => $adminsInfos) {
636         if (is_array($adminsInfos)) {
637           foreach($adminsInfos as $dn => $conf) {
638             if ((isset($conf['attr'])) && (isset($conf['LSobject']))) {
639               if( $this -> loadLSobject($conf['LSobject']) ) {
640                 if ($object = new $conf['LSobject']()) {
641                   if ($object -> loadData($dn)) {
642                     $listDns=$object -> getValue($conf['attr']);
643                     if (is_array($listDns)) {
644                       if (in_array($this -> dn,$listDns)) {
645                         $this -> LSrights['topDn_admin'][] = $topDn;
646                       }
647                     }
648                   }
649                   else {
650                     debug('Impossible de chargé le dn : '.$dn);
651                   }
652                 }
653                 else {
654                   debug('Impossible de créer l\'objet de type : '.$conf['LSobject']);
655                 }
656               }
657               else {
658                 $GLOBALS['LSerror'] -> addErrorCode(1004,$conf['LSobject']);
659               }
660             }
661             else {
662               if ($this -> dn == $dn) {
663                 $this -> LSrights['topDn_admin'][] = $topDn;
664               }
665             }
666           }
667         }
668         else {
669           if ( $this -> dn == $adminsInfos ) {
670             $this -> LSrights['topDn_admin'][] = $topDn;
671           }
672         }
673       }
674       return true;
675     }
676     else {
677       return;
678     }
679   }
680   
681   /**
682    * Charge les droits d'accès de l'utilisateur pour construire le menu de l'interface
683    *
684    * @retval void
685    */
686   function loadLSaccess() {
687     if ($this -> canAccess($this -> LSuserObject -> getType(),$this -> dn)) {
688       $LSaccess = array(
689         'SELF' => array(
690           'label' => _('Mon compte'),
691           'DNs' => $this -> dn
692         )
693       );
694     }
695     else {
696       $LSaccess = array();
697     }
698     foreach ($GLOBALS['LSobjects'] as $objecttype => $objectconf) {
699       if ($this -> canAccess($objecttype) ) {
700         $LSaccess[$objecttype] = array (
701           'label' => $objectconf['label'],
702           'Dns' => 'All'
703         );
704       }
705     }
706     $this -> LSaccess = $LSaccess;
707   }
708   
709   /**
710    * Dit si l'utilisateur est admin de le DN spécifié
711    *
712    * @param[in] string DN de l'objet
713    * 
714    * @retval boolean True si l'utilisateur est admin sur l'objet, false sinon.
715    */
716   function isAdmin($dn) {
717     foreach($this -> LSrights['topDn_admin'] as $topDn_admin) {
718       if($dn == $topDn_admin) {
719         return true;
720       }
721       else if ( isCompatibleDNs($dn,$topDn_admin) ) {
722         return true;
723       }
724     }
725     return;
726   }
727   
728   /**
729    * Retourne qui est l'utilisateur par rapport à l'object
730    *
731    * @param[in] string Le DN de l'objet
732    * 
733    * @retval string 'admin'/'self'/'user' pour Admin , l'utilisateur lui même ou un simple utilisateur
734    */
735   function whoami($dn) {
736     if ($this -> isAdmin($dn)) {
737       return 'admin';
738     }
739     
740     if ($this -> dn == $dn) {
741       return 'self';
742     }
743     
744     return 'user';
745   }
746   
747   /**
748    * Retourne le droit de l'utilisateur à accèder à un objet
749    * 
750    * @param[in] string $LSobject Le type de l'objet
751    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par défaut)
752    * @param[in] string $right Le type de droit d'accès à tester ('r'/'w')
753    * @param[in] string $attr Le nom de l'attribut auquel on test l'accès
754    *
755    * @retval boolean True si l'utilisateur a accès, false sinon
756    */
757   function canAccess($LSobject,$dn=NULL,$right=NULL,$attr=NULL) {
758     if (!$this -> loadLSobject($LSobject))
759       return;
760     if ($dn) {
761       $whoami = $this -> whoami($dn);
762     }
763     else {
764       $objectdn=$GLOBALS['LSobjects'][$LSobject]['container_dn'].','.$this -> topDn;
765       $whoami = $this -> whoami($objectdn);
766     }
767     
768     // Pour un attribut particulier
769     if ($attr) {
770       if ($attr=='rdn') {
771         $attr=$GLOBALS['LSobjects'][$LSobject]['rdn'];
772       }
773       if (!isset($GLOBALS['LSobjects'][$LSobject]['attrs'][$attr])) {
774         return;
775       }
776       
777       if (($right=='r')||($right=='w')) {
778         if ($GLOBALS['LSobjects'][$LSobject]['attrs'][$attr]['rights'][$whoami]==$right) {
779           return true;
780         }
781         return;
782       }
783       else {
784         if ( ($GLOBALS['LSobjects'][$LSobject]['attrs'][$attr]['rights'][$whoami]=='r') || ($GLOBALS['LSobjects'][$LSobject]['attrs'][$attr]['rights'][$whoami]=='w') ) {
785           return true;
786         }
787         return;
788       }
789     }
790     
791     // Pour un attribut quelconque
792     if (is_array($GLOBALS['LSobjects'][$LSobject]['attrs'])) {
793       if (($right=='r')||($right=='w')) {
794         foreach ($GLOBALS['LSobjects'][$LSobject]['attrs'] as $attr_name => $attr_config) {
795           if ($attr_config['rights'][$whoami]==$right) {
796             return true;
797           }
798         }
799       }
800       else {
801         foreach ($GLOBALS['LSobjects'][$LSobject]['attrs'] as $attr_name => $attr_config) {
802           if ( ($attr_config['rights'][$whoami]=='r') || ($attr_config['rights'][$whoami]=='w') ) {
803             return true;
804           }
805         }
806       }
807     }
808     return;
809   }
810   
811   /**
812    * Retourne le droit de l'utilisateur à editer à un objet
813    * 
814    * @param[in] string $LSobject Le type de l'objet
815    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par défaut)
816    * @param[in] string $attr Le nom de l'attribut auquel on test l'accès
817    *
818    * @retval boolean True si l'utilisateur a accès, false sinon
819    */
820   function canEdit($LSobject,$dn=NULL,$attr=NULL) {
821     return $this -> canAccess($LSobject,$dn,'w',$attr);
822   }
823
824   /**
825    * Retourne le droit de l'utilisateur à supprimer un objet
826    * 
827    * @param[in] string $LSobject Le type de l'objet
828    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par défaut)
829    *
830    * @retval boolean True si l'utilisateur a accès, false sinon
831    */  
832   function canRemove($LSobject,$dn) {
833     return $this -> canAccess($LSobject,$dn,'w','rdn');
834   }
835   
836   /**
837    * Retourne le droit de l'utilisateur à créer un objet
838    * 
839    * @param[in] string $LSobject Le type de l'objet
840    *
841    * @retval boolean True si l'utilisateur a accès, false sinon
842    */    
843   function canCreate($LSobject) {
844     return $this -> canAccess($LSobject,NULL,'w','rdn');
845   }
846   
847   /**
848    * Retourne le droit de l'utilisateur à gérer la relation d'objet
849    * 
850    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par défaut)
851    * @param[in] string $relationName Le nom de la relation avec l'objet
852    * @param[in] string $right Le type de droit a vérifier ('r' ou 'w')
853    *
854    * @retval boolean True si l'utilisateur a accès, false sinon
855    */
856   function relationCanAccess($dn,$relationName,$right=NULL) {
857     $LSobject=$this -> LSuserObject -> getType();
858     if (!isset($GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]))
859       return;
860     $whoami = $this -> whoami($dn);
861
862     if (($right=='w') || ($right=='r')) {
863       if ($GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]['rights'][$whoami] == $right) {
864         return true;
865       }
866     }
867     else {
868       if (($GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]['rights'][$whoami] == 'w') || ($GLOBALS['LSobjects'][$LSobject]['relations'][$relationName]['rights'][$whoami] == 'r')) {
869         return true;
870       }
871     }
872     return;
873   }
874
875   /**
876    * Retourne le droit de l'utilisateur à modifier la relation d'objet
877    * 
878    * @param[in] string $dn Le DN de l'objet (le container_dn du type de l'objet par défaut)
879    * @param[in] string $relationName Le nom de la relation avec l'objet
880    *
881    * @retval boolean True si l'utilisateur a accès, false sinon
882    */  
883   function relationCanEdit($dn,$relationName) {
884     return $this -> relationCanAccess($dn,$relationName,'w');
885   }
886
887   /*
888    * Ajoute un fichier temporaire
889    * 
890    * @author Benjamin Renard <brenard@easter-eggs.com>
891    * 
892    * @retval void
893    **/
894   function addTmpFile($value,$filePath) {
895     $hash = mhash(MHASH_MD5,$value);
896     $this -> tmp_file[$filePath] = $hash;
897     $_SESSION['LSsession']['tmp_file'][$filePath] = $hash;
898   }
899   
900   /**
901    * Retourne le chemin du fichier temporaire si l'existe
902    * 
903    * @author Benjamin Renard <brenard@easter-eggs.com>
904    * 
905    * @param[in] $value La valeur du fichier
906    * 
907    * @retval mixed 
908    **/
909   function tmpFileExist($value) {
910     $hash = mhash(MHASH_MD5,$value);
911     foreach($this -> tmp_file as $filePath => $contentHash) {
912       if ($hash == $contentHash) {
913         return $filePath;
914       }
915     }
916     return false;
917   }
918   
919   /**
920    * Retourne le chemin du fichier temporaire
921    * 
922    * Retourne le chemin du fichier temporaire qu'il créera à partir de la valeur
923    * s'il n'existe pas déjà.
924    * 
925    * @author Benjamin Renard <brenard@easter-eggs.com>
926    * 
927    * @param[in] $value La valeur du fichier
928    * 
929    * @retval mixed 
930    **/
931   function getTmpFile($value) {
932     $exist = $this -> tmpFileExist($value);
933     if (!$exist) {
934       $img_path = LS_TMP_DIR .rand().'.tmp';
935       $fp = fopen($img_path, "w");
936       fwrite($fp, $value);
937       fclose($fp);
938       $this -> addTmpFile($value,$img_path);
939       return $img_path;
940     }
941     else {
942       return $exist;
943     }
944   }
945   
946   /*
947    * Supprime les fichiers temporaires
948    * 
949    * @author Benjamin Renard <brenard@easter-eggs.com>
950    * 
951    * @retval void
952    **/
953   function deleteTmpFile($filePath=NULL) {
954     if ($filePath) {
955         @unlink($filePath);
956         unset($this -> tmp_file[$filePath]);
957         unset($_SESSION['LSsession']['tmp_file'][$filePath]);
958     }
959     else {
960       foreach($this -> tmp_file as $file => $content) {
961         @unlink($file);
962       }
963       $this -> tmp_file = array();
964       $_SESSION['LSsession']['tmp_file'] = array();
965     }
966   }
967
968 }
969
970 ?>