www/ecrire/public/cacher.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2014                                                *
   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 /**
  16  * Le format souhaite : "a/bout-d-url.md5" (.gz s'ajoutera pour les gros caches)
  17  * Attention a modifier simultanement le sanity check de
  18  * la fonction retire_cache() de inc/invalideur
  19  *
  20  * http://doc.spip.org/@generer_nom_fichier_cache
  21  *
  22  * @param array $contexte
  23  * @param array $page
  24  * @return string
  25  */
  26 function generer_nom_fichier_cache($contexte, $page) {
  27
  28         $cache = $page['contexte_implicite']['cache'] . '-';
  29
  30         foreach ($contexte as $var=>$val) {
  31                 $val = is_array($val) ? var_export($val,true) : strval($val);
  32                 $cache .= str_replace('-', '_', $val) . '-' ;
  33         }
  34
  35         $cache = str_replace('/', '_', rawurlencode($cache));
  36
  37         if (strlen($cache) > 24) {
  38                 $cache = preg_replace('/([a-zA-Z]{1,3})[^-_]*[-_]/', '\1-', $cache);
  39                 $cache = substr($cache, 0, 24);
  40         }
  41
  42         // Morceau de md5 selon HOST, $dossier_squelettes et $marqueur
  43         // permet de changer le nom du cache en changeant ceux-ci
  44         // donc, par exemple, de gerer differents dossiers de squelettes
  45         // en parallele, ou de la "personnalisation" via un marqueur (dont la
  46         // composition est totalement libre...)
  47         $md_cache = md5(
  48                 var_export($page['contexte_implicite'],true) . ' '
  49                 . var_export($contexte,true)
  50         );
  51
  52         $cache .= '-'.substr($md_cache, 1, 32-strlen($cache));
  53
  54         // Sous-repertoires 0...9a..f ; ne pas prendre la base _DIR_CACHE
  55         $rep = _DIR_CACHE;
  56
  57         $rep = sous_repertoire($rep, '', false,true);
  58         $subdir = sous_repertoire($rep, substr($md_cache, 0, 1), true,true);
  59         return $subdir.$cache;
  60 }
  61
  62 /**
  63  * Faut-il compresser ce cache ? A partir de 16ko ca vaut le coup
  64  * (pas de passage par reference car on veut conserver la version non compressee
  65  * pour l'afficher)
  66  * on positionne un flag gz si on comprime, pour savoir si on doit decompresser ou pas
  67  * http://doc.spip.org/@gzip_page
  68  *
  69  * @param array $page
  70  * @return array
  71  */
  72 function gzip_page($page) {
  73         if (function_exists('gzcompress') AND strlen($page['texte']) > 16*1024) {
  74                 $page['gz'] = true;
  75                 $page['texte'] = gzcompress($page['texte']);
  76         } else {
  77                 $page['gz'] = false;
  78         }
  79         return $page;
  80 }
  81
  82 /**
  83  * Faut-il decompresser ce cache ?
  84  * (passage par reference pour alleger)
  85  * on met a jour le flag gz quand on decompresse, pour ne pas risquer
  86  * de decompresser deux fois de suite un cache (ce qui echoue)
  87  *
  88  * http://doc.spip.org/@gunzip_page
  89  *
  90  * @param array $page
  91  * @return void
  92  */
  93 function gunzip_page(&$page) {
  94         if ($page['gz']) {
  95                 $page['texte'] = gzuncompress($page['texte']);
  96                 $page['gz'] = false; // ne pas gzuncompress deux fois une meme page
  97         }
  98 }
  99
 100 /**
 101  * gestion des delais d'expiration du cache...
 102  * $page passee par reference pour accelerer
 103  *
 104  * @param array $page
 105  * @param int $date
 106  * @return int
 107  * 1 si il faut mettre le cache a jour
 108  * 0 si le cache est valide
 109  * -1 si il faut calculer sans stocker en cache
 110  */
 111 /// http://doc.spip.org/@cache_valide
 112 function cache_valide(&$page, $date) {
 113
 114         if (defined('_VAR_NOCACHE') AND _VAR_NOCACHE) return -1;
 115         if (isset($GLOBALS['meta']['cache_inhib']) AND $_SERVER['REQUEST_TIME']<$GLOBALS['meta']['cache_inhib']) return -1;
 116         if (defined('_NO_CACHE')) return (_NO_CACHE==0 AND !isset($page['texte']))?1:_NO_CACHE;
 117
 118         // pas de cache ? on le met a jour, sauf pour les bots (on leur calcule la page sans mise en cache)
 119         if (!$page OR !isset($page['texte']) OR !isset($page['entetes']['X-Spip-Cache'])) return _IS_BOT?-1:1;
 120
 121         // #CACHE{n,statique} => on n'invalide pas avec derniere_modif
 122         // cf. ecrire/public/balises.php, balise_CACHE_dist()
 123         if (!isset($page['entetes']['X-Spip-Statique']) OR $page['entetes']['X-Spip-Statique'] !== 'oui') {
 124
 125                 // Cache invalide par la meta 'derniere_modif'
 126                 // sauf pour les bots, qui utilisent toujours le cache
 127                 if (!_IS_BOT
 128                 AND $GLOBALS['derniere_modif_invalide']
 129                 AND $date < $GLOBALS['meta']['derniere_modif'])
 130                         return 1;
 131
 132                 // Apparition d'un nouvel article post-date ?
 133                 if ($GLOBALS['meta']['post_dates'] == 'non'
 134                 AND isset($GLOBALS['meta']['date_prochain_postdate'])
 135                 AND time() > $GLOBALS['meta']['date_prochain_postdate']) {
 136                         spip_log('Un article post-date invalide le cache');
 137                         include_spip('inc/rubriques');
 138                         ecrire_meta('derniere_modif', time());
 139                         calculer_prochain_postdate();
 140                         return 1;
 141                 }
 142
 143         }
 144
 145         // Sinon comparer l'age du fichier a sa duree de cache
 146         $duree = intval($page['entetes']['X-Spip-Cache']);
 147         if ($duree == 0)  #CACHE{0}
 148                 return -1;
 149         // sauf pour les bots, qui utilisent toujours le cache
 150         else if (!_IS_BOT AND $date + $duree < time())
 151                 return 1;
 152         else
 153                 return 0;
 154 }
 155
 156 /**
 157  * Creer le fichier cache
 158  * Passage par reference de $page par souci d'economie
 159  *
 160  * http://doc.spip.org/@creer_cache
 161  *
 162  * @param array $page
 163  * @param string $chemin_cache
 164  * @return void
 165  */
 166 function creer_cache(&$page, &$chemin_cache) {
 167
 168         // Ne rien faire si on est en preview, debug, ou si une erreur
 169         // grave s'est presentee (compilation du squelette, MySQL, etc)
 170         // le cas var_nocache ne devrait jamais arriver ici (securite)
 171         // le cas spip_interdire_cache correspond a une ereur SQL grave non anticipable
 172         if ((defined('_VAR_NOCACHE') AND _VAR_NOCACHE)
 173                 OR defined('spip_interdire_cache'))
 174                 return;
 175
 176         // Si la page c1234 a un invalideur de session 'zz', sauver dans
 177         // 'tmp/cache/MD5(chemin_cache)_zz'
 178         if (isset($page['invalideurs'])
 179         AND isset($page['invalideurs']['session'])) {
 180                 // on verifie que le contenu du chemin cache indique seulement
 181                 // "cache sessionne" ; sa date indique la date de validite
 182                 // des caches sessionnes
 183                 if (!lire_fichier(_DIR_CACHE . $chemin_cache, $tmp)
 184                 OR !$tmp = @unserialize($tmp)) {
 185                         spip_log('Creation cache sessionne '.$chemin_cache);
 186                         $tmp = array(
 187                                 'invalideurs' => array('session' => ''),
 188                                 'lastmodified' => time()
 189                         );
 190                         ecrire_fichier(_DIR_CACHE . $chemin_cache, serialize($tmp));
 191                 }
 192                 $chemin_cache .= '_'.$page['invalideurs']['session'];
 193         }
 194
 195         // ajouter la date de production dans le cache lui meme
 196         // (qui contient deja sa duree de validite)
 197         $page['lastmodified'] = time();
 198
 199
 200         // l'enregistrer, compresse ou non...
 201         $ok = ecrire_fichier(_DIR_CACHE . $chemin_cache,
 202                 serialize(gzip_page($page)));
 203
 204         spip_log("Creation du cache $chemin_cache pour "
 205                 . $page['entetes']['X-Spip-Cache']." secondes". ($ok?'':' (erreur!)'));
 206
 207         // Inserer ses invalideurs
 208         include_spip('inc/invalideur');
 209         maj_invalideurs($chemin_cache, $page);
 210
 211 }
 212
 213
 214 /**
 215  * purger un petit cache (tidy ou recherche) qui ne doit pas contenir de
 216  * vieux fichiers ; (cette fonction ne sert que dans des plugins obsoletes)
 217  *
 218  * http://doc.spip.org/@nettoyer_petit_cache
 219  *
 220  * @param string $prefix
 221  * @param int $duree
 222  * @return void
 223  */
 224 function nettoyer_petit_cache($prefix, $duree = 300) {
 225         // determiner le repertoire a purger : 'tmp/CACHE/rech/'
 226         $dircache = sous_repertoire(_DIR_CACHE,$prefix);
 227         if (spip_touch($dircache.'purger_'.$prefix, $duree, true)) {
 228                 foreach (preg_files($dircache,'[.]txt$') as $f) {
 229                         if (time() - (@file_exists($f)?@filemtime($f):0) > $duree)
 230                                 spip_unlink($f);
 231                 }
 232         }
 233 }
 234
 235
 236 /**
 237  * Interface du gestionnaire de cache
 238  * Si son 3e argument est non vide, elle passe la main a creer_cache
 239  * Sinon, elle recoit un contexte (ou le construit a partir de REQUEST_URI)
 240  * et affecte les 4 autres parametres recus par reference:
 241  * - use_cache qui vaut
 242  *     -1 s'il faut calculer la page sans la mettre en cache
 243  *      0 si on peut utiliser un cache existant
 244  *      1 s'il faut calculer la page et la mettre en cache
 245  * - chemin_cache qui est le chemin d'acces au fichier ou vide si pas cachable
 246  * - page qui est le tableau decrivant la page, si le cache la contenait
 247  * - lastmodified qui vaut la date de derniere modif du fichier.
 248  * Elle retourne '' si tout va bien
 249  * un message d'erreur si le calcul de la page est totalement impossible
 250  *
 251  * http://doc.spip.org/@public_cacher_dist
 252  *
 253  * @param array $contexte
 254  * @param int $use_cache
 255  * @param string $chemin_cache
 256  * @param array $page
 257  * @param int $lastmodified
 258  * @return string|void
 259  */
 260 function public_cacher_dist($contexte, &$use_cache, &$chemin_cache, &$page, &$lastmodified) {
 261
 262         # fonction de cache minimale : dire "non on ne met rien en cache"
 263         # $use_cache = -1; return;
 264
 265         // Second appel, destine a l'enregistrement du cache sur le disque
 266         if (isset($chemin_cache)) return creer_cache($page, $chemin_cache);
 267
 268         // Toute la suite correspond au premier appel
 269         $contexte_implicite = $page['contexte_implicite'];
 270
 271         // Cas ignorant le cache car completement dynamique
 272         if ($_SERVER['REQUEST_METHOD'] == 'POST'
 273           OR _request('connect')) {
 274                 $use_cache = -1;
 275                 $lastmodified = 0;
 276                 $chemin_cache = "";
 277                 $page = array();
 278                 return;
 279         }
 280
 281         // Controler l'existence d'un cache nous correspondant
 282         $chemin_cache = generer_nom_fichier_cache($contexte, $page);
 283         $lastmodified = 0;
 284
 285         // charger le cache s'il existe
 286         if (lire_fichier(_DIR_CACHE . $chemin_cache, $page))
 287                 $page = @unserialize($page);
 288         else
 289                 $page = array();
 290
 291         // s'il est sessionne, charger celui correspondant a notre session
 292         if (isset($page['invalideurs'])
 293         AND isset($page['invalideurs']['session'])) {
 294                 $chemin_cache_session = $chemin_cache . '_' . spip_session();
 295                 if (lire_fichier(_DIR_CACHE . $chemin_cache_session, $page_session)
 296                 AND $page_session = @unserialize($page_session)
 297                 AND $page_session['lastmodified'] >= $page['lastmodified'])
 298                         $page = $page_session;
 299                 else
 300                         $page = array();
 301         }
 302
 303
 304         // Faut-il effacer des pages invalidees (en particulier ce cache-ci) ?
 305         if (isset($GLOBALS['meta']['invalider'])) {
 306                 // ne le faire que si la base est disponible
 307                 if (spip_connect()) {
 308                         include_spip('inc/invalideur');
 309                         retire_caches($chemin_cache); # API invalideur inutile
 310                         supprimer_fichier(_DIR_CACHE.$chemin_cache);
 311                         if (isset($chemin_cache_session) and $chemin_cache_session)
 312                                 supprimer_fichier(_DIR_CACHE.$chemin_cache_session);
 313                 }
 314         }
 315
 316         // Si un calcul, recalcul [ou preview, mais c'est recalcul] est demande,
 317         // on supprime le cache
 318         if (defined('_VAR_MODE') && _VAR_MODE &&
 319                 (isset($_COOKIE['spip_session'])
 320                 || isset($_COOKIE['spip_admin'])
 321                 || @file_exists(_ACCESS_FILE_NAME))
 322         ) {
 323                 $page = array('contexte_implicite'=>$contexte_implicite); // ignorer le cache deja lu
 324                 include_spip('inc/invalideur');
 325                 retire_caches($chemin_cache); # API invalideur inutile
 326                 supprimer_fichier(_DIR_CACHE.$chemin_cache);
 327                 if (isset($chemin_cache_session) and $chemin_cache_session)
 328                         supprimer_fichier(_DIR_CACHE.$chemin_cache_session);
 329         }
 330
 331         // $delais par defaut
 332         // pour toutes les pages sans #CACHE{} hors modeles/ et espace privé
 333         // qui sont a cache nul par defaut
 334         if (!isset($GLOBALS['delais'])) {
 335                 define('_DUREE_CACHE_DEFAUT', 24*3600);
 336                 $GLOBALS['delais'] = _DUREE_CACHE_DEFAUT;
 337         }
 338
 339         // determiner la validite de la page
 340         if ($page) {
 341                 $use_cache = cache_valide($page, isset($page['lastmodified']) ? $page['lastmodified'] : 0);
 342                 // le contexte implicite n'est pas stocke dans le cache, mais il y a equivalence
 343                 // par le nom du cache. On le reinjecte donc ici pour utilisation eventuelle au calcul
 344                 $page['contexte_implicite'] = $contexte_implicite;
 345                 if (!$use_cache) {
 346                         // $page est un cache utilisable
 347                         gunzip_page($page);
 348                         return;
 349                 }
 350         } else {
 351                 $page = array('contexte_implicite'=>$contexte_implicite);
 352                 $use_cache = cache_valide($page,0); // fichier cache absent : provoque le calcul
 353         }
 354
 355         // Si pas valide mais pas de connexion a la base, le garder quand meme
 356         if (!spip_connect()) {
 357                 if (isset($page['texte'])) {
 358                         gunzip_page($page);
 359                         $use_cache = 0;
 360                 }
 361                 else {
 362                         spip_log("Erreur base de donnees, impossible utiliser $chemin_cache");
 363                         include_spip('inc/minipres');
 364                         return minipres(_T('info_travaux_titre'),  _T('titre_probleme_technique'));
 365                 }
 366         }
 367
 368         if ($use_cache < 0) $chemin_cache = '';
 369         return;
 370 }
 371
 372 ?>