<?php

/***************************************************************************\
 *  SPIP, Systeme de publication pour l'internet                           *
 *                                                                         *
 *  Copyright (c) 2001-2016                                                *
 *  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 : "a/bout-d-url.md5" (.gz s'ajoutera pour les gros caches)
 * Attention a modifier simultanement le sanity check de
 * la fonction retire_cache() de inc/invalideur
 *
 * http://doc.spip.org/@generer_nom_fichier_cache
 *
 * @param array $contexte
 * @param array $page
 * @return string
 */
function generer_nom_fichier_cache($contexte, $page) {

	$cache = $page['contexte_implicite']['cache'] . '-';

	foreach ($contexte as $var=>$val) {
		$val = is_array($val) ? var_export($val,true) : strval($val);
		$cache .= str_replace('-', '_', $val) . '-' ;
	}

	$cache = str_replace('/', '_', rawurlencode($cache));

	if (strlen($cache) > 24) {
		$cache = preg_replace('/([a-zA-Z]{1,3})[^-_]*[-_]/', '\1-', $cache);
		$cache = substr($cache, 0, 24);
	}

	// Morceau de md5 selon HOST, $dossier_squelettes et $marqueur
	// permet de changer le nom du cache en changeant ceux-ci
	// donc, par exemple, de gerer differents dossiers de squelettes
	// en parallele, ou de la "personnalisation" via un marqueur (dont la
	// composition est totalement libre...)
	$md_cache = md5(
		var_export($page['contexte_implicite'],true) . ' '
		. var_export($contexte,true)
	);

	$cache .= '-'.substr($md_cache, 1, 32-strlen($cache));

	// Sous-repertoires 0...9a..f ; ne pas prendre la base _DIR_CACHE
	$rep = _DIR_CACHE;

	$rep = sous_repertoire($rep, '', false,true);
	$subdir = sous_repertoire($rep, substr($md_cache, 0, 1), true,true);
	return $subdir.$cache;
}

/**
 * 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://doc.spip.org/@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://doc.spip.org/@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://doc.spip.org/@cache_valide
function cache_valide(&$page, $date) {

	// Apparition d'un nouvel article post-date ?
	if ($GLOBALS['meta']['post_dates'] == 'non'
	  AND isset($GLOBALS['meta']['date_prochain_postdate'])
	  AND time() > $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;

	// #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 $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']);
	if ($duree == 0)  #CACHE{0}
		return -1;
	// sauf pour les bots, qui utilisent toujours le cache
	else if (!_IS_BOT AND $date + $duree < time())
		return 1;
	else
		return 0;
}

/**
 * Creer le fichier cache
 * Passage par reference de $page par souci d'economie
 *
 * http://doc.spip.org/@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 (!lire_fichier(_DIR_CACHE . $chemin_cache, $tmp)
		OR !$tmp = @unserialize($tmp)) {
			spip_log('Creation cache sessionne '.$chemin_cache);
			$tmp = array(
				'invalideurs' => array('session' => ''),
				'lastmodified' => time()
			);
			ecrire_fichier(_DIR_CACHE . $chemin_cache, serialize($tmp));
		}
		$chemin_cache .= '_'.$page['invalideurs']['session'];
	}

	// ajouter la date de production dans le cache lui meme
	// (qui contient deja sa duree de validite)
	$page['lastmodified'] = time();


	// l'enregistrer, compresse ou non...
	$ok = ecrire_fichier(_DIR_CACHE . $chemin_cache,
		serialize(gzip_page($page)));

	spip_log("Creation du cache $chemin_cache pour "
		. $page['entetes']['X-Spip-Cache']." secondes". ($ok?'':' (erreur!)'));

	// 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://doc.spip.org/@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 (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://doc.spip.org/@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
	if (lire_fichier(_DIR_CACHE . $chemin_cache, $page))
		$page = @unserialize($page);
	else
		$page = array();

	// s'il est sessionne, charger celui correspondant a notre session
	if (isset($page['invalideurs'])
	AND isset($page['invalideurs']['session'])) {
		$chemin_cache_session = $chemin_cache . '_' . spip_session();
		if (lire_fichier(_DIR_CACHE . $chemin_cache_session, $page_session)
		AND $page_session = @unserialize($page_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'])) {
		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'));
		}
	}

	if ($use_cache < 0) $chemin_cache = '';
	return;
}

?>
