www/ecrire/inc/session.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2019                                                *
   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 /**
  14  * Gestion de l'authentification par sessions
  15  * à utiliser pour valider l'accès (bloquant)
  16  * ou pour reconnaître un utilisateur (non bloquant)
  17  *
  18  * @package SPIP\Core\Session
  19  */
  20
  21 if (!defined('_ECRIRE_INC_VERSION')) {
  22         return;
  23 }
  24
  25
  26 $GLOBALS['visiteur_session'] = array(); # globale decrivant l'auteur
  27
  28 /**
  29  * 3 actions sur les sessions, selon le type de l'argument:
  30  *
  31  * - numerique: efface toutes les sessions de l'auteur (retour quelconque)
  32  * - tableau: cree une session pour l'auteur decrit et retourne l'identifiant
  33  * - bool: predicat de validite de la session indiquee par le cookie
  34  *
  35  * @uses supprimer_sessions()
  36  * @uses ajouter_session()
  37  * @uses verifier_session()
  38  *
  39  * @param int|array|bool $auteur
  40  * @return bool|null|void
  41  */
  42 function inc_session_dist($auteur = false) {
  43         if (is_numeric($auteur)) {
  44                 return supprimer_sessions($auteur, $auteur > 0);
  45         } else {
  46                 if (is_array($auteur)) {
  47                         return ajouter_session($auteur);
  48                 } else {
  49                         return verifier_session($auteur);
  50                 }
  51         }
  52 }
  53
  54
  55 /**
  56  * Supprimer toutes les vieilles sessions d'un auteur
  57  *
  58  * Cette fonction efface toutes les sessions appartenant a l'auteur
  59  * On en profite pour effacer toutes les sessions
  60  * creees il y a plus de 4*_RENOUVELLE_ALEA
  61  * Tenir compte de l'ancien format ou les noms commencaient par "session_"
  62  * et du meme coup des repertoires plats
  63  *
  64  * Attention : id_auteur peut etre negatif (cas des auteurs temporaires pendant le dump)
  65  *
  66  * @uses verifier_session()
  67  * @uses fichier_session()
  68  * @uses spip_session()
  69  *
  70  * @param int $id_auteur
  71  *     Identifiant d'auteur dont on veut supprimer les sessions
  72  * @param bool $toutes
  73  *     Supprimer aussi les vieilles sessions des autres auteurs ?
  74  * @param bool $actives
  75  *     false pour ne pas supprimer les sessions valides de $id_auteur.
  76  *     false revient donc a uniquement supprimer les vieilles sessions !
  77  */
  78 function supprimer_sessions($id_auteur, $toutes = true, $actives = true) {
  79
  80         spip_log("supprimer sessions auteur $id_auteur", "session");
  81         if ($toutes or $id_auteur !== $GLOBALS['visiteur_session']['id_auteur']) {
  82                 if ($dir = opendir(_DIR_SESSIONS)) {
  83                         $t = time() - (4 * _RENOUVELLE_ALEA);
  84                         while (($f = readdir($dir)) !== false) {
  85                                 if (preg_match(",^[^\d-]*(-?\d+)_\w{32}\.php[3]?$,", $f, $regs)) {
  86                                         $f = _DIR_SESSIONS . $f;
  87                                         if (($actives and $regs[1] == $id_auteur) or ($t > filemtime($f))) {
  88                                                 spip_unlink($f);
  89                                         }
  90                                 }
  91                         }
  92                 }
  93         } else {
  94                 verifier_session();
  95                 spip_unlink(fichier_session('alea_ephemere', true));
  96         }
  97
  98         // forcer le recalcul de la session courante
  99         spip_session(true);
 100 }
 101
 102 /**
 103  * Ajoute une session pour l'auteur décrit par un tableau issu d'un SELECT-SQL
 104  *
 105  * @uses spip_php_session_start() Lorsque session anonyme
 106  * @uses hash_env()
 107  * @uses preparer_ecriture_session()
 108  * @uses fichier_session()
 109  * @uses ecrire_fichier_session()
 110  *
 111  * @param array $auteur
 112  *     Description de la session de l'auteur. Peut contenir (par exemple)
 113  *     les clés : id_auteur, nom, login, email, statut, lang, ...
 114  * @return bool|string
 115  */
 116 function ajouter_session($auteur) {
 117         // Si le client a deja une session valide pour son id_auteur
 118         // on conserve le meme fichier
 119
 120         // Attention un visiteur peut avoir une session et un id=0,
 121         // => ne pas melanger les sessions des differents visiteurs
 122         $id_auteur = isset($auteur['id_auteur']) ? intval($auteur['id_auteur']) : 0;
 123
 124         // Si ce n'est pas un inscrit (les inscrits ont toujours des choses en session)
 125         // on va vérifier s'il y a vraiment des choses à écrire
 126         if (!$id_auteur) {
 127                 // On supprime les données de base pour voir le contenu réel de la session
 128                 $auteur_verif = $auteur;
 129                 if (isset($auteur_verif['id_auteur'])) {
 130                         unset($auteur_verif['id_auteur']);
 131                 }
 132                 if (isset($auteur_verif['hash_env'])) {
 133                         unset($auteur_verif['hash_env']);
 134                 }
 135                 if (isset($auteur_verif['ip_change'])) {
 136                         unset($auteur_verif['ip_change']);
 137                 }
 138                 if (isset($auteur_verif['date_session'])) {
 139                         unset($auteur_verif['date_session']);
 140                 }
 141
 142                 // Les variables vraiment nulle ne sont pas à prendre en compte non plus
 143                 foreach ($auteur_verif as $variable => $valeur) {
 144                         if ($valeur === null) {
 145                                 unset($auteur_verif[$variable]);
 146                         }
 147                 }
 148
 149                 // Si après ça la session est vide alors on supprime l'éventuel fichier et on arrête là
 150                 if (!$auteur_verif) {
 151                         if (isset($_COOKIE['spip_session']) and isset($_SESSION[$_COOKIE['spip_session']])) {
 152                                 unset($_SESSION[$_COOKIE['spip_session']]);
 153                         }
 154                         if (isset($_COOKIE['spip_session'])) {
 155                                 unset($_COOKIE['spip_session']);
 156                         }
 157
 158                         return false;
 159                 }
 160         }
 161
 162         if (!isset($_COOKIE['spip_session'])
 163                 or !preg_match(',^' . $id_auteur . '_,', $_COOKIE['spip_session'])
 164         ) {
 165                 $_COOKIE['spip_session'] = $id_auteur . '_' . md5(uniqid(rand(), true));
 166         }
 167
 168         // Maintenant on sait qu'on a des choses à écrire
 169         // On s'assure d'avoir au moins ces valeurs
 170         $auteur['id_auteur'] = $id_auteur;
 171         if (!isset($auteur['hash_env'])) {
 172                 $auteur['hash_env'] = hash_env();
 173         }
 174         if (!isset($auteur['ip_change'])) {
 175                 $auteur['ip_change'] = false;
 176         }
 177
 178         if (!isset($auteur['date_session'])) {
 179                 $auteur['date_session'] = time();
 180         }
 181         if (isset($auteur['prefs'])
 182                 and is_string($auteur['prefs'])
 183           and $prefs = @unserialize($auteur['prefs'])) {
 184                 $auteur['prefs'] = $prefs;
 185         }
 186
 187         $fichier_session = "";
 188
 189         // les sessions anonymes sont stockees dans $_SESSION
 190         if (!$id_auteur) {
 191                 spip_php_session_start();
 192                 $_SESSION[$_COOKIE['spip_session']] = preparer_ecriture_session($auteur);
 193         } else {
 194                 $fichier_session = fichier_session('alea_ephemere');
 195                 if (!ecrire_fichier_session($fichier_session, $auteur)) {
 196                         spip_log('Echec ecriture fichier session ' . $fichier_session, "session" . _LOG_HS);
 197                         include_spip('inc/minipres');
 198                         echo minipres();
 199                         exit;
 200                 }
 201                 // verifier et limiter le nombre maxi de sessions
 202                 // https://core.spip.net/issues/3807
 203                 lister_sessions_auteur($id_auteur);
 204         }
 205
 206         // poser le cookie de session SPIP
 207         include_spip('inc/cookie');
 208         $duree = definir_duree_cookie_session($auteur);
 209         spip_setcookie( 'spip_session', $_COOKIE['spip_session'], time() + $duree);
 210         spip_log("ajoute session $fichier_session cookie $duree", "session");
 211
 212         // Si on est admin, poser le cookie de correspondance
 213         if (!function_exists('autoriser')) {
 214                 include_spip('inc/autoriser');
 215         }
 216         if (autoriser('ecrire','','',$auteur) and _DUREE_COOKIE_ADMIN) {
 217                 spip_setcookie('spip_admin', '@' . $auteur['login'], time() + max(_DUREE_COOKIE_ADMIN, $duree));
 218         } // sinon le supprimer ...
 219         else {
 220                 spip_setcookie('spip_admin', '', 1);
 221         }
 222
 223         # on en profite pour purger les vieilles sessions anonymes abandonnees
 224         # supprimer_sessions(0, true, false);
 225
 226         return $_COOKIE['spip_session'];
 227 }
 228
 229 /**
 230  * Calcule le temps de validité en seconde du cookie de session
 231  *
 232  * Applique un coefficient multiplicateur à la durée de renouvellement de l'alea
 233  * (noté ensuite `dR`, valant 12h par défaut) pour déterminer la durée du cookie.
 234  *
 235  * - `2 * dR`, par défaut
 236  * - `20 * dR` si le visiteur a indiqué vouloir rester connecté quelques jours
 237  *    sur le formulaire de login (la clé `cookie` vaut alors `oui`)
 238  * - `c * dR`, un coeficient défini manuellement si la clé `cookie` est numérique
 239  *
 240  * @param array $auteur
 241  *     Description de l'auteur
 242  * @return int
 243  *     Durée en secondes
 244 **/
 245 function definir_duree_cookie_session($auteur) {
 246         $coef = 2;
 247         if (isset($auteur['cookie'])) {
 248                 if (is_numeric($auteur['cookie'])) {
 249                         $coef = $auteur['cookie'];
 250                 } else {
 251                         $coef = 20;
 252                 }
 253         }
 254         return (int)(_RENOUVELLE_ALEA * $coef);
 255 }
 256
 257 /**
 258  * Vérifie si le cookie spip_session indique une session valide
 259  *
 260  * Si oui, la decrit dans le tableau $visiteur_session et retourne id_auteur
 261  * La rejoue si IP change puis accepte le changement si $change=true
 262  *
 263  * Retourne false en cas d'echec, l'id_auteur de la session si defini, null sinon
 264  *
 265  * @uses spip_php_session_start() Si session anonyme
 266  * @uses fichier_session()
 267  * @uses ajouter_session()
 268  * @uses hash_env()
 269  *
 270  * @param bool $change
 271  * @return bool|int|null
 272  */
 273 function verifier_session($change = false) {
 274         // si pas de cookie, c'est fichu
 275         if (!isset($_COOKIE['spip_session'])) {
 276                 return false;
 277         }
 278
 279         $fichier_session = "";
 280
 281         // est-ce une session anonyme ?
 282         if (!intval($_COOKIE['spip_session'])) {
 283                 spip_php_session_start();
 284                 if (!isset($_SESSION[$_COOKIE['spip_session']]) or !is_array($_SESSION[$_COOKIE['spip_session']])) {
 285                         return false;
 286                 }
 287                 $GLOBALS['visiteur_session'] = $_SESSION[$_COOKIE['spip_session']];
 288         } else {
 289                 // Tester avec alea courant
 290                 $fichier_session = fichier_session('alea_ephemere', true);
 291                 if ($fichier_session and @file_exists($fichier_session)) {
 292                         include($fichier_session);
 293                 } else {
 294                         // Sinon, tester avec alea precedent
 295                         $fichier_session = fichier_session('alea_ephemere_ancien', true);
 296                         if (!$fichier_session or !@file_exists($fichier_session)) {
 297                                 return false;
 298                         }
 299
 300                         // Renouveler la session avec l'alea courant
 301                         include($fichier_session);
 302                         spip_log('renouvelle session ' . $GLOBALS['visiteur_session']['id_auteur'], "session");
 303                         spip_unlink($fichier_session);
 304                         ajouter_session($GLOBALS['visiteur_session']);
 305                 }
 306         }
 307
 308         // Compatibilite ascendante : auteur_session est visiteur_session si
 309         // c'est un auteur SPIP authentifie (tandis qu'un visiteur_session peut
 310         // n'etre qu'identifie, sans aucune authentification).
 311
 312         if (isset($GLOBALS['visiteur_session']['id_auteur']) and $GLOBALS['visiteur_session']['id_auteur']) {
 313                 $GLOBALS['auteur_session'] = &$GLOBALS['visiteur_session'];
 314         }
 315
 316
 317         // Si l'adresse IP change, inc/presentation mettra une balise image
 318         // avec un URL de rappel demandant a changer le nom de la session.
 319         // Seul celui qui a l'IP d'origine est rejoue
 320         // ainsi un eventuel voleur de cookie ne pourrait pas deconnecter
 321         // sa victime, mais se ferait deconnecter par elle.
 322         if (hash_env() != $GLOBALS['visiteur_session']['hash_env']) {
 323                 if (!$GLOBALS['visiteur_session']['ip_change']) {
 324                         define('_SESSION_REJOUER', true);
 325                         $GLOBALS['visiteur_session']['ip_change'] = true;
 326                         ajouter_session($GLOBALS['visiteur_session']);
 327                 } else {
 328                         if ($change) {
 329                                 spip_log("session non rejouee, vol de cookie ?", "session");
 330                         }
 331                 }
 332         } else {
 333                 if ($change) {
 334                         spip_log("rejoue session $fichier_session " . $_COOKIE['spip_session'], "session");
 335                         if ($fichier_session) {
 336                                 spip_unlink($fichier_session);
 337                         }
 338                         $GLOBALS['visiteur_session']['ip_change'] = false;
 339                         unset($_COOKIE['spip_session']);
 340                         ajouter_session($GLOBALS['visiteur_session']);
 341                 }
 342         }
 343
 344         // Si la session a ete initiee il y a trop longtemps, elle est annulee
 345         if (isset($GLOBALS['visiteur_session'])
 346                 and defined('_AGE_SESSION_MAX')
 347                 and _AGE_SESSION_MAX > 0
 348                 and time() - @$GLOBALS['visiteur_session']['date_session'] > _AGE_SESSION_MAX
 349         ) {
 350                 unset($GLOBALS['visiteur_session']);
 351
 352                 return false;
 353         }
 354
 355         return is_numeric($GLOBALS['visiteur_session']['id_auteur'])
 356                 ? $GLOBALS['visiteur_session']['id_auteur']
 357                 : null;
 358 }
 359
 360 /**
 361  * Lire une valeur dans la session SPIP
 362  *
 363  * @api
 364  * @example `$login = session_get('login');`
 365  *
 366  * @param string $nom
 367  *    Clé dont on souhaite la valeur
 368  * @return mixed|null
 369  *     Valeur, si trouvée, `null` sinon.
 370  */
 371 function session_get($nom) {
 372         return isset($GLOBALS['visiteur_session'][$nom]) ? $GLOBALS['visiteur_session'][$nom] : null;
 373 }
 374
 375
 376 /**
 377  * Ajouter une donnée dans la session SPIP
 378  *
 379  * @api
 380  * @uses ajouter_session()
 381  * @uses terminer_actualiser_sessions() Ajoute la fonction en fin de hit.
 382  *
 383  * @param string $nom
 384  * @param null $val
 385  * @return void|array
 386  */
 387 function session_set($nom, $val = null) {
 388         static $remove = array();
 389         static $actualiser_sessions = false;
 390         if ($nom === false) {
 391                 return $remove;
 392         }
 393         if (is_null($val)) {
 394                 // rien a faire
 395                 if (!isset($GLOBALS['visiteur_session'][$nom])) {
 396                         return;
 397                 }
 398                 unset($GLOBALS['visiteur_session'][$nom]);
 399                 $remove[] = $nom;
 400         } else {
 401                 // On ajoute la valeur dans la globale
 402                 $GLOBALS['visiteur_session'][$nom] = $val;
 403                 if ($remove) {
 404                         $remove = array_diff($remove, array($nom));
 405                 }
 406         }
 407         if (!$actualiser_sessions) {
 408                 // il faut creer la session si on en a pas, la premiere fois
 409                 ajouter_session($GLOBALS['visiteur_session']);
 410                 // in register la fonction qui mettra a jour toutes les sessions en fin de hit
 411                 register_shutdown_function('terminer_actualiser_sessions');
 412                 $actualiser_sessions = true;
 413         }
 414 }
 415
 416 /**
 417  * En fin de hit, synchroniser toutes les sessions
 418  *
 419  * @uses actualiser_sessions()
 420  */
 421 function terminer_actualiser_sessions() {
 422         // se remettre dans le dossier de travail au cas ou Apache a change
 423         chdir(_ROOT_CWD);
 424         // recuperer les variables a effacer
 425         $remove = session_set(false);
 426         // mettre a jour toutes les sessions
 427         actualiser_sessions($GLOBALS['visiteur_session'], $remove);
 428 }
 429
 430
 431 /**
 432  * Mettre à jour les sessions existantes pour un auteur
 433  *
 434  * Quand on modifie une fiche auteur on appelle cette fonction qui va
 435  * mettre à jour les fichiers de session de l'auteur en question.
 436  * (auteurs identifiés seulement)
 437  *
 438  * Ne concerne que les sessions des auteurs loges (id_auteur connu)
 439  *
 440  * @uses ajouter_session()
 441  * @uses fichier_session()
 442  * @uses preg_files()
 443  * @uses preparer_ecriture_session()
 444  * @uses ecrire_fichier_session()
 445  *
 446  * @param array $auteur
 447  * @param array $supprimer_cles
 448  *     Liste des clés à supprimer des tableaux de sessions
 449  */
 450 function actualiser_sessions($auteur, $supprimer_cles = array()) {
 451
 452         $id_auteur = isset($auteur['id_auteur']) ? intval($auteur['id_auteur']) : 0;
 453         $id_auteur_courant = isset($GLOBALS['visiteur_session']['id_auteur']) ? intval($GLOBALS['visiteur_session']['id_auteur']) : 0;
 454
 455         // si l'auteur est celui de la session courante, verifier/creer la session si besoin
 456         $fichier_session_courante = "";
 457         if ($id_auteur == $id_auteur_courant) {
 458                 $auteur = array_merge($GLOBALS['visiteur_session'], $auteur);
 459                 ajouter_session($auteur);
 460                 if ($id_auteur) {
 461                         $fichier_session_courante = fichier_session('alea_ephemere');
 462                 }
 463         }
 464
 465         // si session anonyme on ne fait rien d'autre ici : les sessions anonymes sont non partagees
 466         if (!$id_auteur) {
 467                 return;
 468         }
 469
 470         // les préférences sont désérialisées, toujours.
 471         if (isset($auteur['prefs']) and is_string($auteur['prefs'])) {
 472                 $auteur['prefs'] = unserialize($auteur['prefs']);
 473         }
 474
 475         // memoriser l'auteur courant (celui qui modifie la fiche)
 476         $sauve = $GLOBALS['visiteur_session'];
 477
 478         // .. mettre a jour les sessions de l'auteur cible
 479         // attention au $ final pour ne pas risquer d'embarquer un .php.jeton temporaire
 480         // cree par une ecriture concurente d'une session (fichier atomique temporaire)
 481         $sessions = lister_sessions_auteur($id_auteur);
 482
 483         // 1ere passe : lire et fusionner les sessions
 484         foreach ($sessions as $session) {
 485                 $GLOBALS['visiteur_session'] = array();
 486                 // a pu etre supprime entre le preg initial et le moment ou l'on arrive la (concurrence)
 487                 if ($session !== $fichier_session_courante
 488                         and @file_exists($session)
 489                 ) {
 490                         include $session; # $GLOBALS['visiteur_session'] est alors l'auteur cible
 491
 492                         $auteur = array_merge($GLOBALS['visiteur_session'], $auteur);
 493                 }
 494         }
 495
 496         // supprimer les eventuelles cles dont on ne veut plus
 497         foreach ($supprimer_cles as $cle) {
 498                 unset($auteur[$cle]);
 499         }
 500
 501         $auteur_session = preparer_ecriture_session($auteur);
 502
 503         // seconde passe : ecrire les sessions qui ne sont pas a jour
 504         foreach ($sessions as $session) {
 505                 $GLOBALS['visiteur_session'] = array();
 506                 // a pu etre supprime entre le preg initial et le moment ou l'on arrive la (concurrence)
 507                 if (@file_exists($session)) {
 508                         include $session; # $GLOBALS['visiteur_session'] est alors l'auteur cible
 509
 510                         // est-ce que cette session est a mettre a jour ?
 511                         if ($auteur_session != $GLOBALS['visiteur_session']) {
 512                                 ecrire_fichier_session($session, $auteur);
 513                         }
 514                 }
 515         }
 516
 517         if ($id_auteur == $id_auteur_courant) {
 518                 $GLOBALS['visiteur_session'] = $auteur;
 519                 $GLOBALS['auteur_session'] = &$GLOBALS['visiteur_session'];
 520         } else {
 521                 // restaurer l'auteur courant
 522                 $GLOBALS['visiteur_session'] = $sauve;
 523         }
 524
 525 }
 526
 527 /**
 528  * lister les sessions et en verifier le nombre maxi
 529  * en supprimant les plus anciennes si besoin
 530  * https://core.spip.net/issues/3807
 531  *
 532  * @param int $id_auteur
 533  * @param int $nb_max
 534  * @return array
 535  */
 536 function lister_sessions_auteur($id_auteur, $nb_max = null) {
 537
 538         if (is_null($nb_max)) {
 539                 if (!defined('_NB_SESSIONS_MAX')) {
 540                         define('_NB_SESSIONS_MAX', 100);
 541                 }
 542                 $nb_max = _NB_SESSIONS_MAX;
 543         }
 544
 545         // liste des sessions
 546         $sessions = preg_files(_DIR_SESSIONS, '/' . $id_auteur . '_.*\.php$');
 547
 548         // si on en a plus que la limite, supprimer les plus vieilles
 549         // si ce ne sont pas des sessions anonymes car elles sont alors chacune differentes
 550         if ($id_auteur
 551                 and count($sessions) > $nb_max) {
 552
 553                 // limiter le nombre de sessions ouvertes par un auteur
 554                 // filemtime sur les sessions
 555                 $sessions = array_flip($sessions);
 556
 557                 // 1ere passe : lire les filemtime
 558                 foreach ($sessions as $session => $z) {
 559                         if ($d = @filemtime($session)
 560                         ) {
 561                                 $sessions[$session] = $d;
 562                         } else {
 563                                 $sessions[$session] = 0;
 564                         }
 565                 }
 566
 567                 // les plus anciennes en premier
 568                 asort($sessions);
 569
 570                 $sessions = array_keys($sessions);
 571                 while (count($sessions) > $nb_max) {
 572                         $session = array_shift($sessions);
 573                         @unlink($session);
 574                 }
 575         }
 576
 577         return $sessions;
 578 }
 579
 580
 581 /**
 582  * Préparer le tableau de session avant écriture
 583  *
 584  * Nettoyage de quelques variables sensibles, et appel d'un pipeline
 585  *
 586  * @pipeline preparer_fichier_session
 587  * @param array $auteur
 588  * @return array
 589  */
 590 function preparer_ecriture_session($auteur) {
 591         $row = $auteur;
 592
 593         // ne pas enregistrer ces elements de securite
 594         // dans le fichier de session
 595         unset($auteur['pass']);
 596         unset($auteur['htpass']);
 597         unset($auteur['low_sec']);
 598         unset($auteur['alea_actuel']);
 599         unset($auteur['alea_futur']);
 600
 601         $auteur = pipeline('preparer_fichier_session', array('args' => array('row' => $row), 'data' => $auteur));
 602
 603         // ne pas enregistrer les valeurs vraiment nulle dans le fichier
 604         foreach ($auteur as $variable => $valeur) {
 605                 if ($valeur === null) {
 606                         unset($auteur[$variable]);
 607                 }
 608         }
 609
 610         return $auteur;
 611 }
 612
 613 /**
 614  * Ecrire le fichier d'une session
 615  *
 616  * @param string $fichier
 617  * @param array $auteur
 618  * @return bool
 619  */
 620 function ecrire_fichier_session($fichier, $auteur) {
 621
 622         $auteur = preparer_ecriture_session($auteur);
 623
 624         // enregistrer les autres donnees du visiteur
 625         $texte = "<" . "?php\n";
 626         foreach ($auteur as $var => $val) {
 627                 $texte .= '$GLOBALS[\'visiteur_session\'][\'' . $var . '\'] = '
 628                         . var_export($val, true) . ";\n";
 629         }
 630         $texte .= "?" . ">\n";
 631
 632         return ecrire_fichier($fichier, $texte);
 633 }
 634
 635
 636 /**
 637  * Calculer le nom du fichier session
 638  *
 639  * @param string $alea
 640  * @param bool $tantpis
 641  * @return string
 642  */
 643 function fichier_session($alea, $tantpis = false) {
 644
 645         include_spip('inc/acces');
 646         charger_aleas();
 647
 648         if (empty($GLOBALS['meta'][$alea])) {
 649                 if (!$tantpis) {
 650                         spip_log("fichier session ($tantpis): $alea indisponible", "session");
 651                         include_spip('inc/minipres');
 652                         echo minipres();
 653                 }
 654
 655                 return ''; // echec mais $tanpis
 656         } else {
 657                 $repertoire = sous_repertoire(_DIR_SESSIONS, '', false, $tantpis);
 658                 $c = $_COOKIE['spip_session'];
 659
 660                 return $repertoire . intval($c) . '_' . md5($c . ' ' . $GLOBALS['meta'][$alea]) . '.php';
 661         }
 662 }
 663
 664
 665 /**
 666  * Code à insérer par `inc/presentation` pour rejouer la session
 667  *
 668  * @note
 669  *   Pourquoi insère-t-on le src par js et non directement en statique dans le HTML ?
 670  *   Historiquement, inséré par une balise `<script>` en r424
 671  *   puis modifié par `<img>` statique + js en r427
 672  *
 673  * @see action_cookie_dist() qui sera appelé
 674  *
 675  * @return string
 676  */
 677 function rejouer_session() {
 678         return '<img src="' . generer_url_action('cookie', 'change_session=oui', true) . '" width="0" height="0" alt="" />';
 679 }
 680
 681
 682 /**
 683  * On verifie l'IP et le nom du navigateur
 684  *
 685  * @return string
 686  */
 687 function hash_env() {
 688         static $res = '';
 689         if ($res) {
 690                 return $res;
 691         }
 692
 693         return $res = md5($GLOBALS['ip'] . (isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : ''));
 694 }
 695
 696
 697 /**
 698  * Démarre une session PHP si ce n'est pas déjà fait.
 699  *
 700  * @link http://php.net/manual/fr/function.session-start.php
 701  * @uses is_php_session_started()
 702  * @return bool True si une session PHP est ouverte.
 703  **/
 704 function spip_php_session_start() {
 705         if (!is_php_session_started()) {
 706                 return session_start();
 707         }
 708
 709         return true;
 710 }
 711
 712 /**
 713  * Indique si une sesssion PHP est active
 714  *
 715  * @link http://php.net/manual/fr/function.session-status.php#113468
 716  * @return bool true si une session PHP est active
 717  **/
 718 function is_php_session_started() {
 719         if (php_sapi_name() !== 'cli') {
 720                 if (PHP_VERSION_ID >= 50400) {
 721                         return session_status() === PHP_SESSION_ACTIVE ? true : false;
 722                 } else {
 723                         return session_id() === '' ? false : true;
 724                 }
 725         }
 726
 727         return false;
 728 }