442 lines
13 KiB
PHP
442 lines
13 KiB
PHP
<?php
|
|
|
|
/***************************************************************************\
|
|
* SPIP, Systeme de publication pour l'internet *
|
|
* *
|
|
* Copyright (c) 2001-2019 *
|
|
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
|
|
* *
|
|
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
|
|
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
|
|
\***************************************************************************/
|
|
|
|
if (!defined('_ECRIRE_INC_VERSION')) {
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Le format souhaite : tmp/cache/ab/cd
|
|
* soit au maximum 16^4 fichiers dans 256 repertoires
|
|
* Attention a modifier simultanement le sanity check de
|
|
* la fonction retire_cache() de inc/invalideur
|
|
*
|
|
* http://code.spip.net/@generer_nom_fichier_cache
|
|
*
|
|
* @param array $contexte
|
|
* @param array $page
|
|
* @return string
|
|
*/
|
|
function generer_nom_fichier_cache($contexte, $page) {
|
|
$u = md5(var_export(array($contexte, $page), true));
|
|
|
|
return $u . ".cache";
|
|
}
|
|
|
|
/**
|
|
* ecrire le cache dans un casier
|
|
*
|
|
* @param string $nom_cache
|
|
* @param $valeur
|
|
* @return bool
|
|
*/
|
|
function ecrire_cache($nom_cache, $valeur) {
|
|
$d = substr($nom_cache, 0, 2);
|
|
$u = substr($nom_cache, 2, 2);
|
|
$rep = _DIR_CACHE;
|
|
$rep = sous_repertoire($rep, '', false, true);
|
|
$rep = sous_repertoire($rep, $d, false, true);
|
|
|
|
return ecrire_fichier($rep . $u . ".cache", serialize(array("nom_cache" => $nom_cache, "valeur" => $valeur)));
|
|
}
|
|
|
|
/**
|
|
* lire le cache depuis un casier
|
|
*
|
|
* @param string $nom_cache
|
|
* @return mixed
|
|
*/
|
|
function lire_cache($nom_cache) {
|
|
$d = substr($nom_cache, 0, 2);
|
|
$u = substr($nom_cache, 2, 2);
|
|
if (file_exists($f = _DIR_CACHE . "$d/$u.cache")
|
|
and lire_fichier($f, $tmp)
|
|
and $tmp = unserialize($tmp)
|
|
and $tmp['nom_cache'] == $nom_cache
|
|
and isset($tmp['valeur'])
|
|
) {
|
|
return $tmp['valeur'];
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Parano : on signe le cache, afin d'interdire un hack d'injection
|
|
// dans notre memcache
|
|
function cache_signature(&$page) {
|
|
if (!isset($GLOBALS['meta']['cache_signature'])) {
|
|
include_spip('inc/acces');
|
|
include_spip('auth/sha256.inc');
|
|
ecrire_meta('cache_signature',
|
|
_nano_sha256($_SERVER["DOCUMENT_ROOT"] . $_SERVER["SERVER_SIGNATURE"] . creer_uniqid()), 'non');
|
|
}
|
|
|
|
return crc32($GLOBALS['meta']['cache_signature'] . $page['texte']);
|
|
}
|
|
|
|
/**
|
|
* Faut-il compresser ce cache ? A partir de 16ko ca vaut le coup
|
|
* (pas de passage par reference car on veut conserver la version non compressee
|
|
* pour l'afficher)
|
|
* on positionne un flag gz si on comprime, pour savoir si on doit decompresser ou pas
|
|
* http://code.spip.net/@gzip_page
|
|
*
|
|
* @param array $page
|
|
* @return array
|
|
*/
|
|
function gzip_page($page) {
|
|
if (function_exists('gzcompress') and strlen($page['texte']) > 16 * 1024) {
|
|
$page['gz'] = true;
|
|
$page['texte'] = gzcompress($page['texte']);
|
|
} else {
|
|
$page['gz'] = false;
|
|
}
|
|
|
|
return $page;
|
|
}
|
|
|
|
/**
|
|
* Faut-il decompresser ce cache ?
|
|
* (passage par reference pour alleger)
|
|
* on met a jour le flag gz quand on decompresse, pour ne pas risquer
|
|
* de decompresser deux fois de suite un cache (ce qui echoue)
|
|
*
|
|
* http://code.spip.net/@gunzip_page
|
|
*
|
|
* @param array $page
|
|
* @return void
|
|
*/
|
|
function gunzip_page(&$page) {
|
|
if ($page['gz']) {
|
|
$page['texte'] = gzuncompress($page['texte']);
|
|
$page['gz'] = false; // ne pas gzuncompress deux fois une meme page
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gestion des delais d'expiration du cache...
|
|
* $page passee par reference pour accelerer
|
|
*
|
|
* @param array $page
|
|
* @param int $date
|
|
* @return int
|
|
* 1 si il faut mettre le cache a jour
|
|
* 0 si le cache est valide
|
|
* -1 si il faut calculer sans stocker en cache
|
|
*/
|
|
/// http://code.spip.net/@cache_valide
|
|
function cache_valide(&$page, $date) {
|
|
$now = $_SERVER['REQUEST_TIME'];
|
|
|
|
// Apparition d'un nouvel article post-date ?
|
|
if (isset($GLOBALS['meta']['post_dates'])
|
|
and $GLOBALS['meta']['post_dates'] == 'non'
|
|
and isset($GLOBALS['meta']['date_prochain_postdate'])
|
|
and $now > $GLOBALS['meta']['date_prochain_postdate']
|
|
) {
|
|
spip_log('Un article post-date invalide le cache');
|
|
include_spip('inc/rubriques');
|
|
calculer_prochain_postdate(true);
|
|
}
|
|
|
|
if (defined('_VAR_NOCACHE') and _VAR_NOCACHE) {
|
|
return -1;
|
|
}
|
|
if (isset($GLOBALS['meta']['cache_inhib']) and $_SERVER['REQUEST_TIME'] < $GLOBALS['meta']['cache_inhib']) {
|
|
return -1;
|
|
}
|
|
if (defined('_NO_CACHE')) {
|
|
return (_NO_CACHE == 0 and !isset($page['texte'])) ? 1 : _NO_CACHE;
|
|
}
|
|
|
|
// pas de cache ? on le met a jour, sauf pour les bots (on leur calcule la page sans mise en cache)
|
|
if (!$page or !isset($page['texte']) or !isset($page['entetes']['X-Spip-Cache'])) {
|
|
return _IS_BOT ? -1 : 1;
|
|
}
|
|
|
|
// controle de la signature
|
|
if ($page['sig'] !== cache_signature($page)) {
|
|
return _IS_BOT ? -1 : 1;
|
|
}
|
|
|
|
// #CACHE{n,statique} => on n'invalide pas avec derniere_modif
|
|
// cf. ecrire/public/balises.php, balise_CACHE_dist()
|
|
if (!isset($page['entetes']['X-Spip-Statique']) or $page['entetes']['X-Spip-Statique'] !== 'oui') {
|
|
|
|
// Cache invalide par la meta 'derniere_modif'
|
|
// sauf pour les bots, qui utilisent toujours le cache
|
|
if (!_IS_BOT
|
|
and $GLOBALS['derniere_modif_invalide']
|
|
and isset($GLOBALS['meta']['derniere_modif'])
|
|
and $date < $GLOBALS['meta']['derniere_modif']
|
|
) {
|
|
return 1;
|
|
}
|
|
|
|
}
|
|
|
|
// Sinon comparer l'age du fichier a sa duree de cache
|
|
$duree = intval($page['entetes']['X-Spip-Cache']);
|
|
$cache_mark = (isset($GLOBALS['meta']['cache_mark']) ? $GLOBALS['meta']['cache_mark'] : 0);
|
|
if ($duree == 0) #CACHE{0}
|
|
{
|
|
return -1;
|
|
} // sauf pour les bots, qui utilisent toujours le cache
|
|
else {
|
|
if ((!_IS_BOT and $date + $duree < $now)
|
|
# le cache est anterieur a la derniere purge : l'ignorer, meme pour les bots
|
|
or $date < $cache_mark
|
|
) {
|
|
return _IS_BOT ? -1 : 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creer le fichier cache
|
|
* Passage par reference de $page par souci d'economie
|
|
*
|
|
* http://code.spip.net/@creer_cache
|
|
*
|
|
* @param array $page
|
|
* @param string $chemin_cache
|
|
* @return void
|
|
*/
|
|
function creer_cache(&$page, &$chemin_cache) {
|
|
|
|
// Ne rien faire si on est en preview, debug, ou si une erreur
|
|
// grave s'est presentee (compilation du squelette, MySQL, etc)
|
|
// le cas var_nocache ne devrait jamais arriver ici (securite)
|
|
// le cas spip_interdire_cache correspond a une ereur SQL grave non anticipable
|
|
if ((defined('_VAR_NOCACHE') and _VAR_NOCACHE)
|
|
or defined('spip_interdire_cache')
|
|
) {
|
|
return;
|
|
}
|
|
|
|
// Si la page c1234 a un invalideur de session 'zz', sauver dans
|
|
// 'tmp/cache/MD5(chemin_cache)_zz'
|
|
if (isset($page['invalideurs'])
|
|
and isset($page['invalideurs']['session'])
|
|
) {
|
|
// on verifie que le contenu du chemin cache indique seulement
|
|
// "cache sessionne" ; sa date indique la date de validite
|
|
// des caches sessionnes
|
|
if (!$tmp = lire_cache($chemin_cache)) {
|
|
spip_log('Creation cache sessionne ' . $chemin_cache);
|
|
$tmp = array(
|
|
'invalideurs' => array('session' => ''),
|
|
'lastmodified' => $_SERVER['REQUEST_TIME']
|
|
);
|
|
ecrire_cache($chemin_cache, $tmp);
|
|
}
|
|
$chemin_cache = generer_nom_fichier_cache(array("chemin_cache" => $chemin_cache),
|
|
array("session" => $page['invalideurs']['session']));
|
|
}
|
|
|
|
// ajouter la date de production dans le cache lui meme
|
|
// (qui contient deja sa duree de validite)
|
|
$page['lastmodified'] = $_SERVER['REQUEST_TIME'];
|
|
|
|
// compresser le contenu si besoin
|
|
$pagez = gzip_page($page);
|
|
|
|
// signer le contenu
|
|
$pagez['sig'] = cache_signature($pagez);
|
|
|
|
// l'enregistrer, compresse ou non...
|
|
$ok = ecrire_cache($chemin_cache, $pagez);
|
|
|
|
spip_log((_IS_BOT ? "Bot:" : "") . "Creation du cache $chemin_cache pour "
|
|
. $page['entetes']['X-Spip-Cache'] . " secondes" . ($ok ? '' : ' (erreur!)'), _LOG_INFO_IMPORTANTE);
|
|
|
|
// Inserer ses invalideurs
|
|
include_spip('inc/invalideur');
|
|
maj_invalideurs($chemin_cache, $page);
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* purger un petit cache (tidy ou recherche) qui ne doit pas contenir de
|
|
* vieux fichiers ; (cette fonction ne sert que dans des plugins obsoletes)
|
|
*
|
|
* http://code.spip.net/@nettoyer_petit_cache
|
|
*
|
|
* @param string $prefix
|
|
* @param int $duree
|
|
* @return void
|
|
*/
|
|
function nettoyer_petit_cache($prefix, $duree = 300) {
|
|
// determiner le repertoire a purger : 'tmp/CACHE/rech/'
|
|
$dircache = sous_repertoire(_DIR_CACHE, $prefix);
|
|
if (spip_touch($dircache . 'purger_' . $prefix, $duree, true)) {
|
|
foreach (preg_files($dircache, '[.]txt$') as $f) {
|
|
if ($_SERVER['REQUEST_TIME'] - (@file_exists($f) ? @filemtime($f) : 0) > $duree) {
|
|
spip_unlink($f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Interface du gestionnaire de cache
|
|
* Si son 3e argument est non vide, elle passe la main a creer_cache
|
|
* Sinon, elle recoit un contexte (ou le construit a partir de REQUEST_URI)
|
|
* et affecte les 4 autres parametres recus par reference:
|
|
* - use_cache qui vaut
|
|
* -1 s'il faut calculer la page sans la mettre en cache
|
|
* 0 si on peut utiliser un cache existant
|
|
* 1 s'il faut calculer la page et la mettre en cache
|
|
* - chemin_cache qui est le chemin d'acces au fichier ou vide si pas cachable
|
|
* - page qui est le tableau decrivant la page, si le cache la contenait
|
|
* - lastmodified qui vaut la date de derniere modif du fichier.
|
|
* Elle retourne '' si tout va bien
|
|
* un message d'erreur si le calcul de la page est totalement impossible
|
|
*
|
|
* http://code.spip.net/@public_cacher_dist
|
|
*
|
|
* @param array $contexte
|
|
* @param int $use_cache
|
|
* @param string $chemin_cache
|
|
* @param array $page
|
|
* @param int $lastmodified
|
|
* @return string|void
|
|
*/
|
|
function public_cacher_dist($contexte, &$use_cache, &$chemin_cache, &$page, &$lastmodified) {
|
|
|
|
# fonction de cache minimale : dire "non on ne met rien en cache"
|
|
# $use_cache = -1; return;
|
|
|
|
// Second appel, destine a l'enregistrement du cache sur le disque
|
|
if (isset($chemin_cache)) {
|
|
return creer_cache($page, $chemin_cache);
|
|
}
|
|
|
|
// Toute la suite correspond au premier appel
|
|
$contexte_implicite = $page['contexte_implicite'];
|
|
|
|
// Cas ignorant le cache car completement dynamique
|
|
if ($_SERVER['REQUEST_METHOD'] == 'POST'
|
|
or _request('connect')
|
|
) {
|
|
$use_cache = -1;
|
|
$lastmodified = 0;
|
|
$chemin_cache = "";
|
|
$page = array();
|
|
|
|
return;
|
|
}
|
|
|
|
// Controler l'existence d'un cache nous correspondant
|
|
$chemin_cache = generer_nom_fichier_cache($contexte, $page);
|
|
$lastmodified = 0;
|
|
|
|
// charger le cache s'il existe (et si il a bien le bon hash = anticollision)
|
|
if (!$page = lire_cache($chemin_cache)) {
|
|
$page = array();
|
|
}
|
|
|
|
// s'il est sessionne, charger celui correspondant a notre session
|
|
if (isset($page['invalideurs'])
|
|
and isset($page['invalideurs']['session'])
|
|
) {
|
|
$chemin_cache_session = generer_nom_fichier_cache(array("chemin_cache" => $chemin_cache),
|
|
array("session" => spip_session()));
|
|
if ($page_session = lire_cache($chemin_cache_session)
|
|
and $page_session['lastmodified'] >= $page['lastmodified']
|
|
) {
|
|
$page = $page_session;
|
|
} else {
|
|
$page = array();
|
|
}
|
|
}
|
|
|
|
|
|
// Faut-il effacer des pages invalidees (en particulier ce cache-ci) ?
|
|
if (isset($GLOBALS['meta']['invalider'])) {
|
|
// ne le faire que si la base est disponible
|
|
if (spip_connect()) {
|
|
include_spip('inc/invalideur');
|
|
retire_caches($chemin_cache); # API invalideur inutile
|
|
supprimer_fichier(_DIR_CACHE . $chemin_cache);
|
|
if (isset($chemin_cache_session) and $chemin_cache_session) {
|
|
supprimer_fichier(_DIR_CACHE . $chemin_cache_session);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Si un calcul, recalcul [ou preview, mais c'est recalcul] est demande,
|
|
// on supprime le cache
|
|
if (defined('_VAR_MODE') && _VAR_MODE &&
|
|
(isset($_COOKIE['spip_session'])
|
|
|| isset($_COOKIE['spip_admin'])
|
|
|| @file_exists(_ACCESS_FILE_NAME))
|
|
) {
|
|
$page = array('contexte_implicite' => $contexte_implicite); // ignorer le cache deja lu
|
|
include_spip('inc/invalideur');
|
|
retire_caches($chemin_cache); # API invalideur inutile
|
|
supprimer_fichier(_DIR_CACHE . $chemin_cache);
|
|
if (isset($chemin_cache_session) and $chemin_cache_session) {
|
|
supprimer_fichier(_DIR_CACHE . $chemin_cache_session);
|
|
}
|
|
}
|
|
|
|
// $delais par defaut
|
|
// pour toutes les pages sans #CACHE{} hors modeles/ et espace privé
|
|
// qui sont a cache nul par defaut
|
|
if (!isset($GLOBALS['delais'])) {
|
|
if (!defined('_DUREE_CACHE_DEFAUT')) {
|
|
define('_DUREE_CACHE_DEFAUT', 24 * 3600);
|
|
}
|
|
$GLOBALS['delais'] = _DUREE_CACHE_DEFAUT;
|
|
}
|
|
|
|
// determiner la validite de la page
|
|
if ($page) {
|
|
$use_cache = cache_valide($page, isset($page['lastmodified']) ? $page['lastmodified'] : 0);
|
|
// le contexte implicite n'est pas stocke dans le cache, mais il y a equivalence
|
|
// par le nom du cache. On le reinjecte donc ici pour utilisation eventuelle au calcul
|
|
$page['contexte_implicite'] = $contexte_implicite;
|
|
if (!$use_cache) {
|
|
// $page est un cache utilisable
|
|
gunzip_page($page);
|
|
|
|
return;
|
|
}
|
|
} else {
|
|
$page = array('contexte_implicite' => $contexte_implicite);
|
|
$use_cache = cache_valide($page, 0); // fichier cache absent : provoque le calcul
|
|
}
|
|
|
|
// Si pas valide mais pas de connexion a la base, le garder quand meme
|
|
if (!spip_connect()) {
|
|
if (isset($page['texte'])) {
|
|
gunzip_page($page);
|
|
$use_cache = 0;
|
|
} else {
|
|
spip_log("Erreur base de donnees, impossible utiliser $chemin_cache");
|
|
include_spip('inc/minipres');
|
|
|
|
return minipres(_T('info_travaux_titre'), _T('titre_probleme_technique'), array('status' => 503));
|
|
}
|
|
}
|
|
|
|
if ($use_cache < 0) {
|
|
$chemin_cache = '';
|
|
}
|
|
|
|
return;
|
|
}
|