www/ecrire/inc/auth.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2016                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13 if (!defined('_ECRIRE_INC_VERSION')) return;
  14
  15 include_spip('base/abstract_sql');
  16
  17
  18
  19
  20 /**
  21  * Fonction d'authentification. Retourne:
  22  *  - URL de connexion  si on ne sait rien (pas de cookie, pas Auth_user);
  23  *  - URL de connexion  si on ne sait rien (pas de cookie, pas Auth_user);
  24  *  - un tableau si visiteur sans droit (tableau = sa ligne SQL)
  25  *  - code numerique d'erreur SQL
  26  *  - une chaine vide si autorisation a penetrer dans l'espace prive.
  27  *
  28  *
  29  * http://doc.spip.org/@inc_auth_dist
  30  *
  31  * @return array|int|string
  32  */
  33 function inc_auth_dist() {
  34
  35         global $connect_login ;
  36
  37         $row = auth_mode();
  38
  39         if ($row) return auth_init_droits($row);
  40
  41         if (!$connect_login) return auth_a_loger();
  42
  43         // Cas ou l'auteur a ete identifie mais on n'a pas d'info sur lui
  44         // C'est soit parce que la base est inutilisable,
  45         // soit parce que la table des auteurs a changee (restauration etc)
  46         // Pas la peine d'insister.
  47         // Renvoyer le nom fautif et une URL de remise a zero
  48
  49         if (spip_connect())
  50                 return array('login' => $connect_login,
  51                         'site' => generer_url_public('', "action=logout&amp;logout=prive"));
  52
  53         $n = intval(sql_errno());
  54         spip_log("Erreur base de donnees $n " . sql_error());
  55         return $n ? $n : 1;
  56 }
  57
  58 /**
  59  * fonction appliquee par ecrire/index sur le resultat de la precedente
  60  * en cas de refus de connexion.
  61  * Retourne un message a afficher ou redirige illico.
  62  *
  63  * @param  $raison
  64  * @return array|string
  65  */
  66 function auth_echec($raison)
  67 {
  68         include_spip('inc/minipres');
  69         include_spip('inc/headers');
  70         // pas authentifie. Pourquoi ?
  71         if (is_string($raison)) {
  72                 // redirection vers une page d'authentification
  73                 // on ne revient pas de cette fonction
  74                 // sauf si pb de header
  75                 $raison = redirige_formulaire($raison);
  76         } elseif (is_int($raison)) {
  77                 // erreur SQL a afficher
  78                 $raison = minipres(_T('info_travaux_titre'), _T('titre_probleme_technique'). "<p><tt>".sql_errno()." ".sql_error()."</tt></p>");
  79         } elseif (@$raison['statut']) {
  80                 // un simple visiteur n'a pas acces a l'espace prive
  81                 spip_log("connexion refusee a " . @$raison['id_auteur']);
  82                 $raison = minipres(_T('avis_erreur_connexion'),_T('avis_erreur_visiteur'));
  83         } else {
  84                 // auteur en fin de droits ...
  85                 $h = $raison['site'];
  86                 $raison = minipres(_T('avis_erreur_connexion'),
  87                                 "<br /><br /><p>"
  88                                 . _T('texte_inc_auth_1',
  89                                 array('auth_login' => $raison['login']))
  90                                 . " <a href='$h'>"
  91                                 .  _T('texte_inc_auth_2')
  92                                 . "</a>"
  93                                 . _T('texte_inc_auth_3'));
  94         }
  95         return $raison;
  96 }
  97
  98 /**
  99  * Retourne la description d'un authentifie par cookie ou http_auth
 100  * Et affecte la globale $connect_login
 101  *
 102  * @return array|bool|string
 103  */
 104 function auth_mode()
 105 {
 106         global $auth_can_disconnect, $ignore_auth_http, $ignore_remote_user;
 107         global $connect_login ;
 108
 109         //
 110         // Initialiser variables (eviter hacks par URL)
 111         //
 112
 113         $connect_login = '';
 114         $id_auteur = NULL;
 115         $auth_can_disconnect = false;
 116
 117         //
 118         // Recuperer les donnees d'identification
 119         //
 120
 121         // Session valide en cours ?
 122         if (isset($_COOKIE['spip_session'])) {
 123                 $session = charger_fonction('session', 'inc');
 124                 if ($id_auteur = $session()
 125                 OR $id_auteur===0 // reprise sur restauration
 126                 ) {
 127                         $auth_can_disconnect = true;
 128                         $connect_login = $GLOBALS['visiteur_session']['login'];
 129                 } else unset($_COOKIE['spip_session']);
 130         }
 131
 132         // Essayer auth http si significatif
 133         // (ignorer les login d'intranet independants de spip)
 134         if (!$ignore_auth_http) {
 135                 if (
 136                         (isset($_SERVER['PHP_AUTH_USER']) AND isset($_SERVER['PHP_AUTH_PW'])
 137                                                 AND $r = lire_php_auth($_SERVER['PHP_AUTH_USER'], $_SERVER['PHP_AUTH_PW']))
 138                         OR
 139                         // Si auth http differtente de basic, PHP_AUTH_PW
 140                         // est indisponible mais tentons quand meme pour
 141                         // autocreation via LDAP
 142                         (isset($_SERVER['REMOTE_USER'])
 143                                                 AND $r = lire_php_auth($_SERVER['PHP_AUTH_USER'] = $_SERVER['REMOTE_USER'], ''))
 144                         ) {
 145                                 if (!$id_auteur) {
 146                                         $_SERVER['PHP_AUTH_PW'] = '';
 147                                         $auth_can_disconnect = true;
 148                                         $GLOBALS['visiteur_session'] = $r;
 149                                         $connect_login = $GLOBALS['visiteur_session']['login'];
 150                                         $id_auteur = $r['id_auteur'];
 151                                 } else {
 152                                   // cas de la session en plus de PHP_AUTH
 153                                   /*                              if ($id_auteur != $r['id_auteur']){
 154                                     spip_log("vol de session $id_auteur" . join(', ', $r));
 155                                         unset($_COOKIE['spip_session']);
 156                                         $id_auteur = '';
 157                                         } */
 158                                 }
 159                 }
 160                 // Authentification .htaccess old style, car .htaccess semble
 161                 // souvent definir *aussi* PHP_AUTH_USER et PHP_AUTH_PW
 162                 else if (isset($_SERVER['REMOTE_USER']))
 163                         $connect_login = $_SERVER['REMOTE_USER'];
 164         }
 165
 166         $where = (is_numeric($id_auteur)
 167         /*AND $id_auteur>0*/ // reprise lors des restaurations
 168         ) ?
 169           "id_auteur=$id_auteur" :
 170           (!strlen($connect_login) ? '' : "login=" . sql_quote($connect_login,'','text'));
 171
 172         if (!$where) return '';
 173
 174         // Trouver les autres infos dans la table auteurs.
 175         // le champ 'quand' est utilise par l'agenda
 176
 177         return sql_fetsel("*, en_ligne AS quand", "spip_auteurs", "$where AND statut!='5poubelle'");
 178 }
 179
 180 /**
 181  * Init des globales pour tout l'espace prive si visiteur connu
 182  * Le tableau global visiteur_session contient toutes les infos pertinentes et
 183  * a jour (tandis que $visiteur_session peut avoir des valeurs un peu datees
 184  * s'il est pris dans le fichier de session)
 185  * Les plus utiles sont aussi dans les variables simples ci-dessus
 186  * si la globale est vide ce n'est pas un tableau, on la force pour empecher un warning
 187  *
 188  * @param array $row
 189  * @return array|string
 190  */
 191 function auth_init_droits($row)
 192 {
 193         global $connect_statut, $connect_toutes_rubriques, $connect_id_rubrique, $connect_login, $connect_id_auteur;
 194
 195         if ($row['statut']=='nouveau'){
 196                 include_spip('action/inscrire_auteur');
 197                 $row = confirmer_statut_inscription($row);
 198         }
 199
 200         $connect_id_auteur = $row['id_auteur'];
 201         $connect_login = $row['login'];
 202         $connect_statut = $row['statut'];
 203
 204         $GLOBALS['visiteur_session'] = array_merge((array)$GLOBALS['visiteur_session'], $row);
 205
 206         // au cas ou : ne pas memoriser les champs sensibles
 207         unset($GLOBALS['visiteur_session']['pass']);
 208         unset($GLOBALS['visiteur_session']['htpass']);
 209         unset($GLOBALS['visiteur_session']['alea_actuel']);
 210         unset($GLOBALS['visiteur_session']['alea_futur']);
 211
 212         // creer la session au besoin
 213         if (!isset($_COOKIE['spip_session'])) {
 214                 $session = charger_fonction('session', 'inc');
 215                 $spip_session = $session($row);
 216         }
 217
 218         // reinjecter les preferences_auteur apres le reset de spip_session
 219         // car utilisees au retour par auth_loger()
 220         $r = @unserialize($row['prefs']);
 221         $GLOBALS['visiteur_session']['prefs'] = ($r ? $r : array());
 222         // si prefs pas definies, les definir par defaut
 223         if (!isset($GLOBALS['visiteur_session']['prefs']['couleur'])){
 224                 $GLOBALS['visiteur_session']['prefs']['couleur'] = 1;
 225                 $GLOBALS['visiteur_session']['prefs']['display'] = 2;
 226                 $GLOBALS['visiteur_session']['prefs']["display_navigation"] = "navigation_avec_icones";
 227                 $GLOBALS['visiteur_session']['prefs']["display_outils"] = "oui";
 228         }
 229
 230         $GLOBALS['visiteur_session'] = pipeline('preparer_visiteur_session',array('args'=>array('row'=>$row),'data'=>$GLOBALS['visiteur_session']));
 231
 232         // Etablir les droits selon le codage attendu
 233         // dans ecrire/index.php ecrire/prive.php
 234
 235         // Pas autorise a acceder a ecrire ? renvoyer le tableau
 236         // A noter : le premier appel a autoriser() a le bon gout
 237         // d'initialiser $GLOBALS['visiteur_session']['restreint'],
 238         // qui ne figure pas dans le fichier de session
 239         include_spip('inc/autoriser');
 240
 241         if (!autoriser('ecrire'))
 242                 return $row;
 243
 244         // autoriser('ecrire') ne laisse passer que les Admin et les Redac
 245
 246         auth_trace($row);
 247
 248         // Administrateurs
 249         if (in_array($connect_statut, explode(',', _STATUT_AUTEUR_RUBRIQUE))) {
 250                 if (is_array($GLOBALS['visiteur_session']['restreint'])) {
 251                         $connect_id_rubrique = $GLOBALS['visiteur_session']['restreint'];
 252                 }
 253                 if ($connect_statut == '0minirezo') {
 254                         $connect_toutes_rubriques = !$connect_id_rubrique;
 255                 }
 256         }
 257         // Pour les redacteurs, inc_version a fait l'initialisation minimale
 258
 259         return ''; // i.e. pas de pb.
 260 }
 261
 262 /**
 263  * Retourne l'url de connexion
 264  *
 265  * @return string
 266  */
 267 function auth_a_loger()
 268 {
 269         $redirect = generer_url_public('login',
 270         "url=" . rawurlencode(self('&',true)), '&');
 271
 272         // un echec au "bonjour" (login initial) quand le statut est
 273         // inconnu signale sans doute un probleme de cookies
 274         if (isset($_GET['bonjour']))
 275                 $redirect = parametre_url($redirect,
 276                         'var_erreur',
 277                         (!isset($GLOBALS['visiteur_session']['statut'])
 278                                         ? 'cookie'
 279                                         : 'statut'
 280                          ),
 281                                           '&'
 282                                           );
 283         return $redirect;
 284 }
 285
 286 /**
 287  * Tracer en base la date de derniere connexion de l'auteur
 288  * http://doc.spip.org/@auth_trace
 289  *
 290  * @param array $row
 291  * @param null|string $date
 292  */
 293 function auth_trace($row, $date=null)
 294 {
 295         // Indiquer la connexion. A la minute pres ca suffit.
 296         if (!is_numeric($connect_quand = $row['quand']))
 297                 $connect_quand = strtotime($connect_quand);
 298
 299         if (is_null($date))
 300                 $date = date('Y-m-d H:i:s');
 301
 302         if (abs(strtotime($date) - $connect_quand)  >= 60) {
 303                 sql_updateq("spip_auteurs", array("en_ligne" => $date), "id_auteur=" .$row['id_auteur']);
 304                 $row['en_ligne'] = $date;
 305         }
 306
 307         pipeline('trig_auth_trace',array('args'=>array('row'=>$row,'date'=>$date)));
 308 }
 309
 310
 311 /** ----------------------------------------------------------------------------
 312  * API Authentification, gestion des identites centralisees
 313  */
 314
 315 /**
 316  * Fonction aiguillage, privee
 317  * @param string $fonction
 318  * @param array $args
 319  * @param mixed $defaut
 320  * @return mixed
 321  */
 322 function auth_administrer($fonction,$args,$defaut=false){
 323         $auth_methode = array_shift($args);
 324         $auth_methode = $auth_methode ? $auth_methode : 'spip'; // valeur par defaut au cas ou
 325         if ($auth = charger_fonction($auth_methode,'auth',true)
 326                 AND function_exists($f="auth_{$auth_methode}_$fonction")
 327         )
 328                 $res = call_user_func_array($f, $args);
 329         else
 330                 $res = $defaut;
 331         $res = pipeline('auth_administrer',array(
 332                 'args' => array(
 333                         'fonction' => $fonction,
 334                         'methode' => $auth_methode,
 335                         'args' => $args
 336                 ),
 337                 'data' => $res
 338         ));
 339         return $res;
 340 }
 341
 342 /**
 343  * Pipeline pour inserer du contenu dans le formulaire de login
 344  *
 345  * @param array $flux
 346  * @return array
 347  */
 348 function auth_formulaire_login($flux){
 349         foreach ($GLOBALS['liste_des_authentifications'] as $methode)
 350                 $flux = auth_administrer('formulaire_login',array($methode,$flux),$flux);
 351         return $flux;
 352 }
 353
 354
 355
 356 /**
 357  * Retrouver le login interne lie a une info login saisie
 358  * la saisie peut correspondre a un login delegue
 359  * qui sera alors converti en login interne apres verification
 360  *
 361  * @param string $login
 362  * @param string $serveur
 363  * @return string/bool
 364  */
 365 function auth_retrouver_login($login, $serveur=''){
 366         if (!spip_connect($serveur)) {
 367                 include_spip('inc/minipres');
 368                 echo minipres(_T('info_travaux_titre'),
 369                               _T('titre_probleme_technique'));
 370                 exit;
 371         }
 372
 373         foreach ($GLOBALS['liste_des_authentifications'] as $methode) {
 374                 if ($auteur = auth_administrer('retrouver_login',array($methode, $login, $serveur))) {
 375                         return $auteur;
 376                 }
 377         }
 378         return false;
 379 }
 380
 381
 382 /**
 383  * informer sur un login
 384  * Ce dernier transmet le tableau ci-dessous a la fonction JS informer_auteur
 385  * Il est invoque par la fonction JS actualise_auteur via la globale JS
 386  * page_auteur=#URL_PAGE{informer_auteur} dans le squelette login
 387  * N'y aurait-il pas plus simple ?
 388  *
 389  * @param string $login
 390  * @param string $serveur
 391  * @return array
 392  */
 393 function auth_informer_login($login, $serveur=''){
 394         if (!$login
 395                 OR !$login = auth_retrouver_login($login, $serveur)
 396                 OR !$row = sql_fetsel('*','spip_auteurs','login='.sql_quote($login,$serveur,'text'),'','','','',$serveur)
 397                 )
 398                 return array();
 399
 400         $prefs = unserialize($row['prefs']);
 401         $infos = array(
 402                 'id_auteur'=>$row['id_auteur'],
 403                 'login'=>$row['login'],
 404                 'cnx' => ($prefs['cnx'] == 'perma') ? '1' : '0',
 405                 'logo' => recuperer_fond('formulaires/inc-logo_auteur', $row),
 406         );
 407
 408         // desactiver le hash md5 si pas auteur spip ?
 409         if ($row['source']!=='spip'){
 410                 $row['alea_actuel']= '';
 411                 $row['alea_futur']= '';
 412         }
 413         verifier_visiteur();
 414
 415         return auth_administrer('informer_login',array($row['source'],$infos, $row, $serveur),$infos);
 416 }
 417
 418
 419 /**
 420  * Essayer les differentes sources d'authenfication dans l'ordre specifie.
 421  * S'en souvenir dans visiteur_session['auth']
 422  *
 423  * @param string $login
 424  * @param string $password
 425  * @param string $serveur
 426  * @return mixed
 427  */
 428 function auth_identifier_login($login, $password, $serveur=''){
 429         $erreur = "";
 430         foreach ($GLOBALS['liste_des_authentifications'] as $methode) {
 431                 if ($auth = charger_fonction($methode, 'auth',true)){
 432                         $auteur = $auth($login, $password, $serveur);
 433                         if (is_array($auteur) AND count($auteur)) {
 434                                 spip_log("connexion de $login par methode $methode");
 435                                 $auteur['auth'] = $methode;
 436                                 return $auteur;
 437                         }
 438                         elseif (is_string($auteur))
 439                                 $erreur .= "$auteur ";
 440                 }
 441         }
 442         return $erreur;
 443 }
 444
 445 /**
 446  * Fournir une url de retour apres login par un SSO
 447  * pour finir l'authentification
 448  *
 449  * @param string $auth_methode
 450  * @param string $login
 451  * @param string $redirect
 452  * @param string $serveur
 453  * @return string
 454  */
 455 function auth_url_retour_login($auth_methode, $login, $redirect='', $serveur=''){
 456         $securiser_action = charger_fonction('securiser_action','inc');
 457         return $securiser_action('auth', "$auth_methode/$login", $redirect, true);
 458 }
 459
 460 function auth_terminer_identifier_login($auth_methode, $login, $serveur=''){
 461         $args = func_get_args();
 462         $auteur = auth_administrer('terminer_identifier_login',$args);
 463         return $auteur;
 464 }
 465
 466 /**
 467  * Loger un auteur suite a son identification
 468  *
 469  * @param array $auteur
 470  * @return bool
 471  */
 472 function auth_loger($auteur){
 473         if (!is_array($auteur) OR !count($auteur))
 474                 return false;
 475
 476         // initialiser et poser le cookie de session
 477         unset($_COOKIE['spip_session']);
 478         auth_init_droits($auteur);
 479
 480         // initialiser les prefs
 481         $p = $GLOBALS['visiteur_session']['prefs'];
 482         $p['cnx'] = ($auteur['cookie'] == 'oui') ? 'perma' : '';
 483
 484         sql_updateq('spip_auteurs',
 485                     array('prefs' => serialize($p)),
 486                     "id_auteur=" . $auteur['id_auteur']);
 487
 488         // Si on est admin, poser le cookie de correspondance
 489         include_spip('inc/cookie');
 490         if ($auteur['statut'] == '0minirezo') {
 491                 spip_setcookie('spip_admin', '@'.$auteur['login'],
 492                 time() + 7 * 24 * 3600);
 493         }
 494         // sinon le supprimer ...
 495         else {
 496                 spip_setcookie('spip_admin', '',1);
 497         }
 498
 499         //  bloquer ici le visiteur qui tente d'abuser de ses droits
 500         verifier_visiteur();
 501         return true;
 502 }
 503
 504
 505 function auth_deloger(){
 506         $logout = charger_fonction('logout','action');
 507         $logout();
 508 }
 509
 510 /**
 511  * Tester la possibilite de modifier le login d'authentification
 512  * pour la methode donnee
 513  *
 514  * @param string $auth_methode
 515  * @param string $serveur
 516  * @return bool
 517  */
 518 function auth_autoriser_modifier_login($auth_methode, $serveur=''){
 519         $args = func_get_args();
 520         return auth_administrer('autoriser_modifier_login',$args);
 521 }
 522
 523 /**
 524  * Verifier la validite d'un nouveau login pour modification
 525  * pour la methode donnee
 526  *
 527  * @param string $auth_methode
 528  * @param string $new_login
 529  * @param int $id_auteur
 530  * @param string $serveur
 531  * @return string
 532  *  message d'erreur ou chaine vide si pas d'erreur
 533  */
 534 function auth_verifier_login($auth_methode, $new_login, $id_auteur=0, $serveur=''){
 535         $args = func_get_args();
 536         return auth_administrer('verifier_login',$args,'');
 537 }
 538
 539 /**
 540  * Modifier le login d'un auteur pour la methode donnee
 541  *
 542  * @param string $auth_methode
 543  * @param string $new_login
 544  * @param int $id_auteur
 545  * @param string $serveur
 546  * @return bool
 547  */
 548 function auth_modifier_login($auth_methode, $new_login, $id_auteur, $serveur=''){
 549         $args = func_get_args();
 550         return auth_administrer('modifier_login',$args);
 551 }
 552
 553 /**
 554  * Tester la possibilite de modifier le pass
 555  * pour la methode donnee
 556  *
 557  * @param string $auth_methode
 558  * @param string $serveur
 559  * @return bool
 560  *      succes ou echec
 561  */
 562 function auth_autoriser_modifier_pass($auth_methode, $serveur=''){
 563         $args = func_get_args();
 564         return auth_administrer('autoriser_modifier_pass',$args);
 565 }
 566
 567 /**
 568  * Verifier la validite d'un pass propose pour modification
 569  * pour la methode donnee
 570  *
 571  * @param string $auth_methode
 572  * @param string $login
 573  * @param string $new_pass
 574  * @param int $id_auteur
 575  * @param string $serveur
 576  * @return string
 577  *      message d'erreur ou chaine vide si pas d'erreur
 578  */
 579 function auth_verifier_pass($auth_methode, $login, $new_pass, $id_auteur=0, $serveur=''){
 580         $args = func_get_args();
 581         return auth_administrer('verifier_pass',$args,'');
 582 }
 583
 584 /**
 585  * Modifier le mot de passe d'un auteur
 586  * pour la methode donnee
 587  *
 588  * @param string $auth_methode
 589  * @param string $login
 590  * @param string $new_pass
 591  * @param int $id_auteur
 592  * @param string $serveur
 593  * @return bool
 594  *      succes ou echec
 595  */
 596 function auth_modifier_pass($auth_methode, $login, $new_pass, $id_auteur, $serveur=''){
 597         $args = func_get_args();
 598         return auth_administrer('modifier_pass',$args);
 599 }
 600
 601 /**
 602  * Synchroniser un compte sur une base distante pour la methode
 603  * donnee lorsque des modifications sont faites dans la base auteur
 604  *
 605  * @param string|bool $auth_methode
 606  *   ici true permet de forcer la synchronisation de tous les acces pour toutes les methodes
 607  * @param int $id_auteur
 608  * @param array $champs
 609  * @param array $options
 610  * @param string $serveur
 611  * @return void
 612  */
 613 function auth_synchroniser_distant($auth_methode=true, $id_auteur=0, $champs=array(), $options = array(), $serveur=''){
 614         $args = func_get_args();
 615         if ($auth_methode===true OR (isset($options['all']) AND $options['all']==true)){
 616                 $options['all'] = true; // ajouter une option all=>true pour chaque auth
 617                 $args = array(true, $id_auteur, $champs, $options, $serveur);
 618                 foreach ($GLOBALS['liste_des_authentifications'] as $methode) {
 619                         array_shift($args);
 620                         array_unshift($args,$methode);
 621                         auth_administrer('synchroniser_distant',$args);
 622                 }
 623         }
 624         else
 625                 auth_administrer('synchroniser_distant',$args);
 626 }
 627
 628
 629 /**
 630  *
 631  * @param string $login
 632  * @param string $pw
 633  * @param string $serveur
 634  * @return array
 635  */
 636 function lire_php_auth($login, $pw, $serveur=''){
 637
 638         $row = sql_fetsel('*', 'spip_auteurs', 'login=' . sql_quote($login,$serveur,'text'),'','','','',$serveur);
 639
 640         if (!$row) {
 641                 if (spip_connect_ldap($serveur)
 642                 AND $auth_ldap = charger_fonction('ldap', 'auth', true))
 643                         return $auth_ldap($login, $pw, $serveur, true);
 644                 return false;
 645         }
 646         // su pas de source definie
 647         // ou auth/xxx introuvable, utiliser 'spip'
 648         if (!$auth_methode = $row['source']
 649                 OR !$auth = charger_fonction($auth_methode, 'auth', true))
 650                 $auth = charger_fonction('spip', 'auth', true);
 651
 652         $auteur='';
 653         if ($auth)
 654                 $auteur = $auth($login, $pw, $serveur, true);
 655         // verifier que ce n'est pas un message d'erreur
 656         if (is_array($auteur) AND count($auteur))
 657                 return $auteur;
 658         return false;
 659 }
 660
 661 /**
 662  * entete php_auth (est-encore utilise ?)
 663  *
 664  * @param string $pb
 665  * @param string $raison
 666  * @param string $retour
 667  * @param string $url
 668  * @param string $re
 669  * @param string $lien
 670  */
 671 function ask_php_auth($pb, $raison, $retour='', $url='', $re='', $lien='') {
 672         @Header("WWW-Authenticate: Basic realm=\"espace prive\"");
 673         @Header("HTTP/1.0 401 Unauthorized");
 674         $corps = "";
 675         $public = generer_url_public();
 676         $ecrire = generer_url_ecrire();
 677         $retour = $retour?$retour:_T('icone_retour');
 678         $corps .= "<p>$raison</p>[<a href='$public'>$retour</a>] ";
 679         if ($url) {
 680                 $corps .= "[<a href='" . generer_url_action('cookie',"essai_auth_http=oui&$url") . "'>$re</a>]";
 681         }
 682
 683         if ($lien)
 684                 $corps .= " [<a href='$ecrire'>"._T('login_espace_prive')."</a>]";
 685         include_spip('inc/minipres');
 686         echo minipres($pb,$corps);
 687         exit;
 688 }
 689 ?>