source: spip-zone/_plugins_/cachefix/trunk/inc/utils.fix.3.0.php @ 113542

Last change on this file since 113542 was 113542, checked in by jluc@…, 4 months ago

Fix le bug de sessionnement des caches SPIP https://core.spip.net/issues/4235
À tester en vérifiant et pour vérifier que les caches devant être sessionnés le sont bien
Regarder la taille du cache avec fix / sans fix donne la mesure des caches multipliés à tort et inutilement calculés

Ce fixe détecte la version SPIP pour surcharger les fichiers du core public/assembler et public/balises avec la version de la bonne branche.
! le fix pour inc/utils est aussi livré, mais ce fichier ne peut être surchargé par un plugin. Il faut donc copier la version de ecrire/inc dans ecrire/inc/utils.php.sav et écraser avec la version livrée dans le plugin !
Testé pour SPIP3.3 dev
Retours bienvenus

File size: 79.0 KB
Line 
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
13if (!defined('_ECRIRE_INC_VERSION')) return;
14
15//
16// Utilitaires indispensables autour du serveur Http.
17//
18
19/**
20 * charge un fichier perso ou, a defaut, standard
21 * et retourne si elle existe le nom de la fonction homonyme (exec_$nom),
22 * ou de suffixe _dist
23 * Peut etre appelee plusieurs fois, donc optimiser
24 *
25 * http://doc.spip.org/@charger_fonction
26 *
27 * @param string $nom
28 * @param string $dossier
29 * @param bool $continue
30 * @return string
31 */
32function charger_fonction($nom, $dossier='exec', $continue=false) {
33        static $echecs = array();
34
35        if (strlen($dossier) AND substr($dossier,-1) != '/') $dossier .= '/';
36        $f = str_replace('/','_',$dossier) . $nom;
37
38        if (function_exists($f))
39                return $f;
40        if (function_exists($g = $f . '_dist'))
41                return $g;
42
43        if (isset($echecs[$f])) return $echecs[$f];
44        // Sinon charger le fichier de declaration si plausible
45
46        if (!preg_match(',^\w+$,', $f)){
47                if ($continue) return false; //appel interne, on passe
48                include_spip('inc/minipres');
49                echo minipres();
50                exit;
51        }
52
53        // passer en minuscules (cf les balises de formulaires)
54        // et inclure le fichier
55        if (!$inc = include_spip($dossier.($d = strtolower($nom)))
56                // si le fichier truc/machin/nom.php n'existe pas,
57                // la fonction peut etre definie dans truc/machin.php qui regroupe plusieurs petites fonctions
58                AND strlen(dirname($dossier)) AND dirname($dossier)!='.')
59                include_spip(substr($dossier,0,-1));
60        if (function_exists($f)) return $f;
61        if (function_exists($g)) return $g;
62
63        if ($continue) return $echecs[$f] = false;
64
65        // Echec : message d'erreur
66        spip_log("fonction $nom ($f ou $g) indisponible" .
67                ($inc ? "" : " (fichier $d absent de $dossier)"));
68
69        include_spip('inc/minipres');
70        echo minipres(_T('forum_titre_erreur'),
71                 _T('fichier_introuvable', array('fichier'=> '<b>'.spip_htmlentities($d).'</b>')),
72                array('all_inline'=>true,'status'=>404));
73        exit;
74}
75
76/**
77 * Inclusion unique avec verification d'existence du fichier + log en crash sinon
78 * @param string $file
79 * @return bool
80 */
81function include_once_check($file){
82        if (file_exists($file)) {include_once $file;return true;}
83        $crash = (isset($GLOBALS['meta']['message_crash_plugins'])?unserialize($GLOBALS['meta']['message_crash_plugins']):'');
84        $crash = ($crash?$crash:array());
85        $crash[$file] = true;
86        ecrire_meta('message_crash_plugins',serialize($crash));
87        return false;
88}
89
90//
91// la fonction cherchant un fichier PHP dans le SPIP_PATH
92//
93// http://doc.spip.org/@include_spip
94function include_spip($f, $include = true) {
95        return find_in_path($f . '.php', '', $include);
96}
97
98
99function require_spip($f) {
100        return find_in_path($f . '.php', '', 'required');
101}
102
103// un pipeline est lie a une action et une valeur
104// chaque element du pipeline est autorise a modifier la valeur
105//
106// le pipeline execute les elements disponibles pour cette action,
107// les uns apres les autres, et retourne la valeur finale
108//
109// Cf. compose_filtres dans references.php, qui est la
110// version compilee de cette fonctionnalite
111
112// appel unitaire d'une fonction du pipeline
113// utilisee dans le script pipeline precompile
114// on passe $val par reference pour limiter les allocations memoire
115// http://doc.spip.org/@minipipe
116function minipipe($fonc,&$val){
117        // fonction
118        if (function_exists($fonc))
119                $val = call_user_func($fonc, $val);
120        // Class::Methode
121        else if (preg_match("/^(\w*)::(\w*)$/S", $fonc, $regs)
122        AND $methode = array($regs[1], $regs[2])
123        AND is_callable($methode))
124                $val = call_user_func($methode, $val);
125        else {
126                spip_log("Erreur - '$fonc' non definie !");
127        }
128        return $val;
129}
130
131// chargement du pipeline sous la forme d'un fichier php prepare
132// http://doc.spip.org/@pipeline
133function pipeline($action, $val=null) {
134        static $charger;
135
136        // chargement initial des fonctions mises en cache, ou generation du cache
137        if (!$charger) {
138                if (!($ok = @is_readable($charger = _CACHE_PIPELINES))) {
139                        include_spip('inc/plugin');
140                        // generer les fichiers php precompiles
141                        // de chargement des plugins et des pipelines
142                        actualise_plugins_actifs();
143                        if (!($ok = @is_readable($charger)))
144                                spip_log("fichier $charger pas cree");
145                }
146
147                if ($ok) {
148                        include_once $charger;
149                }
150        }
151
152        // appliquer notre fonction si elle existe
153        $fonc = 'execute_pipeline_'.strtolower($action);
154        if (function_exists($fonc)) {
155                $val = $fonc($val);
156        }
157        // plantage ?
158        else {
159                spip_log("fonction $fonc absente : pipeline desactive",_LOG_ERREUR);
160        }
161
162        // si le flux est une table avec 2 cle args&data
163        // on ne ressort du pipe que les donnees dans 'data'
164        // array_key_exists pour php 4.1.0
165        if (is_array($val)
166          AND count($val)==2
167          AND (array_key_exists('data',$val)))
168                $val = $val['data'];
169        return $val;
170}
171
172/**
173 * Enregistrement des evenements
174 * spip_log($message)
175 * spip_log($message,'recherche')
176 * spip_log($message,_LOG_DEBUG)
177 * spip_log($message,'recherche.'._LOG_DEBUG)
178 *  cette derniere notation est controversee mais le 3eme
179 *  parametre est plante pour cause de compat ascendante.
180 * le niveau par defaut est _LOG_INFO
181 *
182 * http://doc.spip.org/@spip_log
183 *
184 * @param string $message
185 * @param string|int $name
186 * @param string $logdir  ## inutile !! a supprimer ?
187 * @param string $logsuf  ## inutile !! a supprimer ?
188 */
189function spip_log($message=NULL, $name=NULL) {
190        static $pre = array();
191        static $log;
192        preg_match('/^([a-z_]*)\.?(\d)?$/iS', (string) $name, $regs);
193        if (!isset($regs[1]) OR !$logname = $regs[1])
194                $logname = null;
195        if (!isset($regs[2]) OR !$niveau = $regs[2])
196                $niveau = _LOG_INFO;
197
198        if ($niveau <= (defined('_LOG_FILTRE_GRAVITE') ? _LOG_FILTRE_GRAVITE : _LOG_INFO_IMPORTANTE)) {
199                if (!$pre){
200                        $pre = array(
201                                _LOG_HS=>'HS:',
202                                _LOG_ALERTE_ROUGE=>'ALERTE:',
203                                _LOG_CRITIQUE=>'CRITIQUE:',
204                                _LOG_ERREUR=>'ERREUR:',
205                                _LOG_AVERTISSEMENT=>'WARNING:',
206                                _LOG_INFO_IMPORTANTE=>'!INFO:',
207                                _LOG_INFO=>'info:',
208                                _LOG_DEBUG=>'debug:');
209                        $log = charger_fonction('log', 'inc');
210                }
211                if (!is_string($message)) $message = var_export($message, true);
212                $log($pre[$niveau].' '.$message, $logname);
213        }
214}
215
216//
217// Enregistrement des journaux
218//
219function journal($phrase, $opt = array()) {
220        $journal = charger_fonction('journal', 'inc');
221        $journal($phrase, $opt);
222}
223
224// Renvoie le _GET ou le _POST emis par l'utilisateur
225// ou pioche dans $c si c'est un array()
226// http://doc.spip.org/@_request
227function _request($var, $c=false) {
228
229        if (is_array($c))
230                return isset($c[$var]) ? $c[$var] : NULL;
231
232        if (isset($_GET[$var])) $a = $_GET[$var];
233        elseif (isset($_POST[$var])) $a = $_POST[$var];
234        else return NULL;
235
236        // Si on est en ajax et en POST tout a ete encode
237        // via encodeURIComponent, il faut donc repasser
238        // dans le charset local...
239        if (defined('_AJAX')
240        AND _AJAX
241        AND isset($GLOBALS['meta']['charset'])
242        AND $GLOBALS['meta']['charset'] != 'utf-8'
243        AND is_string($a)
244        // check rapide mais pas fiable
245        AND preg_match(',[\x80-\xFF],', $a)
246        // check fiable
247        AND include_spip('inc/charsets')
248        AND is_utf8($a)
249        ) {
250                return importer_charset($a, 'utf-8');
251        }
252
253        return $a;
254}
255
256// Methode set de la fonction _request()
257// Attention au cas ou l'on fait set_request('truc', NULL);
258// http://doc.spip.org/@set_request
259function set_request($var, $val = NULL, $c=false) {
260        if (is_array($c)) {
261                unset($c[$var]);
262                if ($val !== NULL)
263                        $c[$var] = $val;
264                return $c;
265        }
266
267        unset($_GET[$var]);
268        unset($_POST[$var]);
269        if ($val !== NULL)
270                $_GET[$var] = $val;
271
272        return false; # n'affecte pas $c
273}
274
275
276/**
277 * Tester si une URL est absolue
278 *
279 * On est sur le web, on exclut certains protocoles,
280 * notamment 'file://', 'php://' et d'autres…
281
282 * @param string $url
283 * @return bool
284 */
285function tester_url_absolue($url) {
286        $url = trim($url);
287        if (preg_match(";^([a-z]{3,7}:)?//;Uims", $url, $m)) {
288                if (
289                        isset($m[1])
290                        and $p = strtolower(rtrim($m[1], ':'))
291                        and in_array($p, array('file', 'php', 'zlib', 'glob', 'phar', 'ssh2', 'rar', 'ogg', 'expect', 'zip'))
292                  ) {
293                        return false;
294                }
295                return true;
296        }
297        return false;
298}
299
300/**
301 * Prend une URL et lui ajoute/retire un parametre.
302 * Exemples : [(#SELF|parametre_url{suite,18})] (ajout)
303 *            [(#SELF|parametre_url{suite,''})] (supprime)
304 *            [(#SELF|parametre_url{suite})]    (prend $suite dans la _request)
305 *            [(#SELF|parametre_url{suite[],1})] (tableaux valeurs multiples)
306 *
307 * http://doc.spip.org/@parametre_url
308 *
309 * @param string $url
310 * @param string $c
311 * @param string|array $v
312 * @param string $sep
313 * @return string
314 */
315function parametre_url($url, $c, $v=NULL, $sep='&amp;') {
316        // requete erronnee : plusieurs variable dans $c et aucun $v
317        if (strpos($c,"|")!==false AND is_null($v))
318                return null;
319
320        // lever l'#ancre
321        if (preg_match(',^([^#]*)(#.*)$,', $url, $r)) {
322                $url = $r[1];
323                $ancre = $r[2];
324        } else
325                $ancre = '';
326
327        // eclater
328        $url = preg_split(',[?]|&amp;|&,', $url);
329
330        // recuperer la base
331        $a = array_shift($url);
332        if (!$a) $a= './';
333
334        $regexp = ',^(' . str_replace('[]','\[\]',$c) . '[[]?[]]?)(=.*)?$,';
335        $ajouts = array_flip(explode('|',$c));
336        $u = is_array($v) ? $v : rawurlencode($v);
337        $testv = (is_array($v)?count($v):strlen($v));
338        // lire les variables et agir
339        foreach ($url as $n => $val) {
340                if (preg_match($regexp, urldecode($val), $r)) {
341                        if ($v === NULL) {
342                                return $r[2]?substr($r[2],1):'';
343                        }
344                        // suppression
345                        elseif (!$testv) {
346                                unset($url[$n]);
347                        }
348        // Ajout. Pour une variable, remplacer au meme endroit,
349        // pour un tableau ce sera fait dans la prochaine boucle
350                        elseif (substr($r[1],-2) != '[]') {
351                                $url[$n] = $r[1].'='.$u;
352                                unset($ajouts[$r[1]]);
353                        }
354                }
355        }
356
357        // traiter les parametres pas encore trouves
358        if ($v === NULL
359        AND $args = func_get_args()
360        AND count($args)==2)
361                return $v;
362        elseif ($testv) {
363                foreach($ajouts as $k => $n) {
364                  if (!is_array($v))
365                    $url[] = $k .'=' . $u;
366                  else {
367                        $id = (substr($k,-2) == '[]') ? $k : ($k ."[]");
368                    foreach ($v as $w) $url[]= $id .'=' . $w;
369                  }
370                }
371        }
372
373        // eliminer les vides
374        $url = array_filter($url);
375
376        // recomposer l'adresse
377        if ($url)
378                $a .= '?' . join($sep, $url);
379
380        return $a . $ancre;
381}
382
383// Prend une URL et lui ajoute/retire une ancre apres l'avoir nettoyee
384// pour l'ancre on translitere, vire les non alphanum du debut,
385// et on remplace ceux a l'interieur ou au bout par -
386// http://doc.spip.org/@ancre_url
387function ancre_url($url, $ancre) {
388        // lever l'#ancre
389        if (preg_match(',^([^#]*)(#.*)$,', $url, $r)) {
390                $url = $r[1];
391        }
392        if (preg_match('/[^-_a-zA-Z0-9]+/S',$ancre)){
393                if (!function_exists('translitteration'))
394                        include_spip('inc/charsets');
395                $ancre = preg_replace(array('/^[^-_a-zA-Z0-9]+/', '/[^-_a-zA-Z0-9]/'), array('', '-'),
396                                                translitteration($ancre));
397        }
398        return $url . (strlen($ancre) ? '#'. $ancre : '');
399}
400
401/**
402 * pour le nom du cache, les types_urls et self
403 * http://doc.spip.org/@nettoyer_uri
404 *
405 * @param string|null $reset
406 * @return string
407 */
408function nettoyer_uri($reset = null)
409{
410        static $done = false;
411        static $propre = '';
412        if (!is_null($reset)) return $propre=$reset;
413        if ($done) return $propre;
414        $done = true;
415
416        $uri1 = $GLOBALS['REQUEST_URI'];
417        do {
418                $uri = $uri1;
419                $uri1 = preg_replace
420                        (',([?&])(PHPSESSID|(var_[^=&]*))=[^&]*(&|$),i',
421                        '\1', $uri);
422        } while ($uri<>$uri1);
423
424        return $propre = (preg_replace(',[?&]$,', '', $uri1));
425}
426
427
428/**
429 * Donner l'URL de base d'un lien vers "soi-meme", modulo les trucs inutiles
430 *
431 * @param string $amp
432 *    Style des esperluettes
433 * @param bool $root
434 * @return string
435 *    URL vers soi-même
436**/
437function self($amp = '&amp;', $root = false) {
438        $url = nettoyer_uri();
439        if (!$root
440                AND (
441                        // si pas de profondeur on peut tronquer
442                        $GLOBALS['profondeur_url']<(_DIR_RESTREINT?1:2)
443                        // sinon c'est OK si _SET_HTML_BASE a ete force a false
444                        OR (defined('_SET_HTML_BASE') AND !_SET_HTML_BASE))
445                )
446                $url = preg_replace(',^[^?]*/,', '', $url);
447        // ajouter le cas echeant les variables _POST['id_...']
448        foreach ($_POST as $v => $c)
449                if (substr($v,0,3) == 'id_')
450                        $url = parametre_url($url, $v, $c, '&');
451
452        // supprimer les variables sans interet
453        if (test_espace_prive()) {
454                $url = preg_replace (',([?&])('
455                .'lang|show_docs|'
456                .'changer_lang|var_lang|action)=[^&]*,i', '\1', $url);
457                $url = preg_replace(',([?&])[&]+,', '\1', $url);
458                $url = preg_replace(',[&]$,', '\1', $url);
459        }
460
461        // eviter les hacks
462        include_spip('inc/filtres_mini');
463        $url = spip_htmlspecialchars($url);
464       
465        $url = str_replace(array("'", '"', '<', '[', ']'), array('%27', '%22', '%3C', '%5B', '%5D'), $url);
466
467        // &amp; ?
468        if ($amp != '&amp;')
469                $url = str_replace('&amp;', $amp, $url);
470
471        // Si ca demarre par ? ou vide, donner './'
472        $url = preg_replace(',^([?].*)?$,', './\1', $url);
473
474        return $url;
475}
476
477// Indique si on est dans l'espace prive
478// http://doc.spip.org/@test_espace_prive
479function test_espace_prive() {
480        return defined('_ESPACE_PRIVE') ? _ESPACE_PRIVE : false;
481}
482
483/**
484 * Verifie la presence d'un plugin active, identifie par son prefix
485 *
486 *
487 * @param string $plugin
488 * @return bool
489 */
490function test_plugin_actif($plugin){
491        return ($plugin AND defined('_DIR_PLUGIN_'.strtoupper($plugin)))? true:false;
492}
493
494/**
495 * Traduction des textes de SPIP
496 * http://doc.spip.org/@_T
497 *
498 * @param string $texte
499 * @param array $args
500 * @param array $options
501 *   string class : nom d'une classe a ajouter sur un span pour encapsuler la chaine
502 *   bool force : forcer un retour meme si la chaine n'a pas de traduction
503 * @return mixed|string
504 */
505function _T($texte, $args=array(), $options=array()) {
506        static $traduire=false ;
507        $o = array('class'=>'', 'force'=>true);
508        if ($options){
509                // support de l'ancien argument $class
510                if (is_string($options))
511                        $options = array('class'=>$options);
512                $o = array_merge($o,$options);
513        }
514
515        if (!$traduire) {
516                $traduire = charger_fonction('traduire', 'inc');
517                include_spip('inc/lang');
518        }
519       
520        // On peut passer explicitement la langue dans le tableau
521        // On utilise le même nom de variable que la globale
522        if (isset($args['spip_lang'])){
523                $lang = $args['spip_lang'];
524                // On l'enleve pour ne pas le passer au remplacement
525                unset($args['spip_lang']);
526        }
527        // Sinon on prend la langue du contexte
528        else {
529                $lang = $GLOBALS['spip_lang'];
530        }
531        $text = $traduire($texte, $lang);
532
533        if (!strlen($text)){
534                if (!$o['force'])
535                        return '';
536
537                $text = $texte;
538
539                // pour les chaines non traduites, assurer un service minimum
540                if (!$GLOBALS['test_i18n'] AND (_request('var_mode') != 'traduction'))
541                        $text = str_replace('_', ' ',
542                                 (($n = strpos($text,':')) === false ? $texte :
543                                        substr($texte, $n+1)));
544                $o['class'] = null;
545
546        }
547
548        return _L($text, $args, $o['class']);
549
550}
551
552// Remplacer les variables @....@ par leur valeur dans une chaine de langue.
553// Aussi appelee quand une chaine n'est pas encore dans les fichiers de langue
554// http://doc.spip.org/@_L
555function _L($text, $args=array(), $class=null) {
556        $f = $text;
557        if (is_array($args)) {
558                foreach ($args as $name => $value) {
559                        if ($class)
560                                $value = "<span class='$class'>$value</span>";
561                        $t = str_replace ("@$name@", $value, $text);
562                        if ($text !== $t) {unset($args[$name]); $text = $t;}
563                }
564                // Si des variables n'ont pas ete inserees, le signaler
565                // (chaines de langues pas a jour)
566                if ($args) spip_log("$f:  variables inutilisees " . join(', ', array_keys($args)),_LOG_DEBUG);
567        }
568
569        if (($GLOBALS['test_i18n'] OR (_request('var_mode') == 'traduction')) AND $class===null)
570                return "<span class=debug-traduction-erreur>$text</span>";
571        else
572                return $text;
573}
574
575// Afficher "ecrire/data/" au lieu de "data/" dans les messages
576// ou tmp/ au lieu de ../tmp/
577// http://doc.spip.org/@joli_repertoire
578function joli_repertoire($rep) {
579        $a = substr($rep,0,1);
580        if ($a<>'.' AND $a<>'/')
581                $rep = (_DIR_RESTREINT?'':_DIR_RESTREINT_ABS).$rep;
582        $rep = preg_replace(',(^\.\.\/),', '', $rep);
583        return $rep;
584}
585
586
587//
588// spip_timer : on l'appelle deux fois et on a la difference, affichable
589//
590// http://doc.spip.org/@spip_timer
591function spip_timer($t='rien', $raw = false) {
592        static $time;
593        $a=time(); $b=microtime();
594        // microtime peut contenir les microsecondes et le temps
595        $b=explode(' ',$b);
596        if (count($b)==2) $a = end($b); // plus precis !
597        $b = reset($b);
598        if (!isset($time[$t])) {
599                $time[$t] = $a + $b;
600        } else {
601                $p = ($a + $b - $time[$t]) * 1000;
602                unset($time[$t]);
603#                       echo "'$p'";exit;
604                if ($raw) return $p;
605                if ($p < 1000)
606                        $s = '';
607                else {
608                        $s = sprintf("%d ", $x = floor($p/1000));
609                        $p -= ($x*1000);
610                }
611                return $s . sprintf($s?"%07.3f ms":"%.3f ms", $p);
612        }
613}
614
615
616// Renvoie False si un fichier n'est pas plus vieux que $duree secondes,
617// sinon renvoie True et le date sauf si ca n'est pas souhaite
618// http://doc.spip.org/@spip_touch
619function spip_touch($fichier, $duree=0, $touch=true) {
620        if ($duree) {
621                clearstatcache();
622                if ((@$f=filemtime($fichier)) AND ($f >= time() - $duree))
623                        return false;
624        }
625        if ($touch!==false) {
626                if (!@touch($fichier)) { spip_unlink($fichier); @touch($fichier); };
627                @chmod($fichier, _SPIP_CHMOD & ~0111);
628        }
629        return true;
630}
631
632// Ce declencheur de tache de fond, de l'espace prive (cf inc_presentation)
633// et de l'espace public (cf #SPIP_CRON dans inc_balise), est appelee
634// par un background-image  car contrairement a un iframe vide,
635// les navigateurs ne diront pas qu'ils n'ont pas fini de charger,
636// c'est plus rassurant.
637// C'est aussi plus discret qu'un <img> sous un navigateur non graphique.
638
639// http://doc.spip.org/@action_cron
640function action_cron() {
641        include_spip('inc/headers');
642        http_status(204); // No Content
643        header("Connection: close");
644        define('_DIRECT_CRON_FORCE',true);
645        cron();
646}
647
648/**
649 * cron() : execution des taches de fond
650 * On peut lui passer en 1er (ou 2e arg pour compat)
651 * le tableau de taches attendu par inc_genie()
652 * Retourne Vrai si un tache a pu etre effectuee
653 * pas de verrou ici : les verrous sont geres sur chaque tache
654 * a chaque execution
655 *
656 * http://doc.spip.org/@cron
657 *
658 * @param array $taches
659 *   taches forcees
660 * @param array $taches_old
661 *   taches forcees, pour compat avec ancienne syntaxe
662 * @return bool
663 */
664function cron ($taches=array(), $taches_old= array()) {
665        // si pas en mode cron force, laisser tomber.
666        if (!defined('_DIRECT_CRON_FORCE')) return false;
667        if (!is_array($taches)) $taches = $taches_old; // compat anciens appels
668        // si taches a inserer en base et base inaccessible, laisser tomber
669        // sinon on ne verifie pas la connexion tout de suite, car si ca se trouve
670        // queue_sleep_time_to_next_job() dira qu'il n'y a rien a faire
671        // et on evite d'ouvrir une connexion pour rien (utilisation de _DIRECT_CRON_FORCE dans mes_options.php)
672        if ($taches AND count($taches) AND !spip_connect())  return false;
673        spip_log("cron !",'jq'._LOG_DEBUG);
674        if ($genie = charger_fonction('genie', 'inc', true)) {
675                return $genie($taches);
676        }
677        return false;
678}
679
680/**
681 * Ajout d'une tache dans la file d'attente
682 *
683 * @param $function
684 *   The function name to call.
685 * @param $description
686 *   A human-readable description of the queued job.
687 * @param $arguments
688 *   Optional array of arguments to pass to the function.
689 * @param $file
690 *   Optional file path which needs to be included for $function.
691 *   if ends with '/', will do charger_fonction($function,$file);
692 * @param $no_duplicate
693 *   If TRUE, do not add the job to the queue if one with the same function and
694 *   arguments already exists.
695 * @param $time
696 *              time for starting the job. If 0, job will start as soon as possible
697 * @param $priority
698 *              -10 (low priority) to +10 (high priority), 0 is the default
699 * @return int
700 *      id of job
701 */
702function job_queue_add($function, $description, $arguments = array(), $file = '', $no_duplicate = FALSE, $time=0, $priority=0) {
703        include_spip('inc/queue');
704        return queue_add_job($function, $description, $arguments, $file, $no_duplicate, $time, $priority);
705}
706
707/**
708 * Supprimer une tache de la file d'attente
709 * @param int $id_job
710 *  id of jonb to delete
711 * @return bool
712 */
713function job_queue_remove($id_job){
714        include_spip('inc/queue');
715        return queue_remove_job($id_job);
716}
717
718/**
719 * Associer une tache a un/des objets de SPIP
720 * @param int $id_job
721 *      id of job to link
722 * @param array $objets
723 *  can be a simple array('objet'=>'article','id_objet'=>23)
724 *  or an array of simple array to link multiples objet in one time
725 */
726function job_queue_link($id_job,$objets){
727        include_spip('inc/queue');
728        return queue_link_job($id_job,$objets);
729}
730
731
732/**
733 * Renvoyer le temps de repos restant jusqu'au prochain job
734 * 0 si un job est a traiter
735 * null si la queue n'est pas encore initialise
736 * $force est utilisee par queue_set_next_job_time() pour maj la valeur
737 *  - si true, force la relecture depuis le fichier
738 *  - si int, affecte la static directement avec la valeur
739 *
740 * @staticvar int $queue_next_job_time
741 * @param int/bool $force_next
742 * @return int
743 */
744function queue_sleep_time_to_next_job($force=null) {
745        static $queue_next_job_time = -1;
746        if ($force===true)
747                $queue_next_job_time = -1;
748        elseif ($force)
749                $queue_next_job_time = $force;
750
751        if ($queue_next_job_time==-1) {
752                define('_JQ_NEXT_JOB_TIME_FILENAME',_DIR_TMP . "job_queue_next.txt");
753                // utiliser un cache memoire si dispo
754                if (include_spip('inc/memoization') AND defined('_MEMOIZE_MEMORY') AND _MEMOIZE_MEMORY) {
755                        $queue_next_job_time = cache_get(_JQ_NEXT_JOB_TIME_FILENAME);
756                }
757                else {
758                        $queue_next_job_time = null;
759                        if (lire_fichier(_JQ_NEXT_JOB_TIME_FILENAME, $contenu))
760                                $queue_next_job_time = intval($contenu);
761                }
762        }
763
764        if (is_null($queue_next_job_time))
765                return null;
766        if (!$_SERVER['REQUEST_TIME'])
767                $_SERVER['REQUEST_TIME'] = time();
768        return $queue_next_job_time-$_SERVER['REQUEST_TIME'];
769}
770
771
772// transformation XML des "&" en "&amp;"
773// http://doc.spip.org/@quote_amp
774function quote_amp($u) {
775        return preg_replace(
776                "/&(?![a-z]{0,4}\w{2,3};|#x?[0-9a-f]{2,5};)/i",
777                "&amp;",$u);
778}
779
780// Production d'une balise Script valide
781// http://doc.spip.org/@http_script
782function http_script($script, $src='', $noscript='') {
783        static $done = array();
784
785        if ($src && !isset($done[$src])){
786                $done[$src] = true;
787                $src = find_in_path($src, _JAVASCRIPT);
788                $src = " src='$src'";
789        }
790        else $src = '';
791        if ($script)
792                $script = ("/*<![CDATA[*/\n" .
793                preg_replace(',</([^>]*)>,','<\/\1>', $script) .
794                "/*]]>*/");
795        if ($noscript)
796                $noscript = "<noscript>\n\t$noscript\n</noscript>\n";
797
798        return ($src OR $script OR $noscript)
799        ? "<script type='text/javascript'$src>$script</script>$noscript"
800        : '';
801}
802
803// Transforme n'importe quel champ en une chaine utilisable
804// en PHP ou Javascript en toute securite
805// < ? php $x = '[(#TEXTE|texte_script)]'; ? >
806// http://doc.spip.org/@texte_script
807function texte_script($texte) {
808        return str_replace('\'', '\\\'', str_replace('\\', '\\\\', $texte));
809}
810
811// Chaque appel a cette fonction ajoute un repertoire en tete du chemin courant (path)
812// si un repertoire lui est passe en parametre
813// retourne le chemin courant sinon, sous forme de array.
814// Si l'argument est de la forme dir1:dir2:dir3, ces 3 chemins sont places en tete
815// du path, dans cet ordre.
816// Exception: si un $dossier_squelette est defini, il reste en tete, pour raison historique
817// http://doc.spip.org/@_chemin
818function _chemin($dir_path=NULL){
819        static $path_base = NULL;
820        static $path_full = NULL;
821        if ($path_base==NULL){
822                // Chemin standard depuis l'espace public
823                $path = defined('_SPIP_PATH') ? _SPIP_PATH :
824                        _DIR_RACINE.':'.
825                        _DIR_RACINE.'squelettes-dist/:'.
826                        _DIR_RACINE.'prive/:'.
827                        _DIR_RESTREINT;
828                // Ajouter squelettes/
829                if (@is_dir(_DIR_RACINE.'squelettes'))
830                        $path = _DIR_RACINE.'squelettes/:' . $path;
831                foreach (explode(':', $path) as $dir) {
832                        if (strlen($dir) AND substr($dir,-1) != '/')
833                                $dir .= "/";
834                        $path_base[] = $dir;
835                }
836                $path_full = $path_base;
837                // Et le(s) dossier(s) des squelettes nommes
838                if (strlen($GLOBALS['dossier_squelettes']))
839                        foreach (array_reverse(explode(':', $GLOBALS['dossier_squelettes'])) as $d)
840                                array_unshift($path_full, ($d[0] == '/' ? '' : _DIR_RACINE) . $d . '/');
841                $GLOBALS['path_sig'] = md5(serialize($path_full));
842        }
843        if ($dir_path===NULL) return $path_full;
844
845        if (strlen($dir_path)){
846                $tete = "";
847                if (reset($path_base)==_DIR_RACINE.'squelettes/')
848                        $tete = array_shift($path_base);
849                $dirs = array_reverse(explode(':',$dir_path));
850                foreach($dirs as $dir_path){
851                                #if ($dir_path{0}!='/')
852                                #       $dir_path = $dir_path;
853                                if (substr($dir_path,-1) != '/')
854                                        $dir_path .= "/";
855                                if (!in_array($dir_path,$path_base))
856                                        array_unshift($path_base,$dir_path);
857                }
858                if (strlen($tete))
859                        array_unshift($path_base,$tete);
860        }
861        $path_full = $path_base;
862        // Et le(s) dossier(s) des squelettes nommes
863        if (strlen($GLOBALS['dossier_squelettes']))
864                foreach (array_reverse(explode(':', $GLOBALS['dossier_squelettes'])) as $d)
865                        array_unshift($path_full, ($d[0] == '/' ? '' : _DIR_RACINE) . $d . '/');
866
867        $GLOBALS['path_sig'] = md5(serialize($path_full));
868        return $path_full;
869}
870
871// http://doc.spip.org/@creer_chemin
872function creer_chemin() {
873        $path_a = _chemin();
874        static $c = '';
875
876        // on calcule le chemin si le dossier skel a change
877        if ($c != $GLOBALS['dossier_squelettes']) {
878                // assurer le non plantage lors de la montee de version :
879                $c = $GLOBALS['dossier_squelettes'];
880                $path_a = _chemin(''); // forcer un recalcul du chemin
881        }
882        return $path_a;
883}
884
885
886function lister_themes_prives(){
887        static $themes = null;
888        if (is_null($themes)){
889                // si pas encore definie
890                if (!defined('_SPIP_THEME_PRIVE'))
891                        define('_SPIP_THEME_PRIVE', 'spip');
892                $themes = array(_SPIP_THEME_PRIVE);
893                // lors d'une installation neuve, prefs n'est pas definie.
894                if (isset($GLOBALS['visiteur_session']['prefs'])) {
895                        $prefs = $GLOBALS['visiteur_session']['prefs'];
896                } else {
897                        $prefs = array();
898                }
899                if (is_string($prefs))
900                        $prefs = unserialize($GLOBALS['visiteur_session']['prefs']);
901                if (
902                        ((isset($prefs['theme']) AND $theme = $prefs['theme'])
903                        OR (isset($GLOBALS['theme_prive_defaut']) AND $theme = $GLOBALS['theme_prive_defaut']))
904                        AND $theme != _SPIP_THEME_PRIVE)
905                        array_unshift($themes,$theme); // placer le theme choisi en tete
906        }
907        return $themes;
908}
909
910function find_in_theme($file, $subdir='', $include=false){
911        static $themefiles=array();
912        if (isset($themefiles["$subdir$file"])) return $themefiles["$subdir$file"];
913        $themes = lister_themes_prives();
914        foreach($themes as $theme){
915                if ($f = find_in_path($file,"prive/themes/$theme/$subdir",$include))
916                        return $themefiles["$subdir$file"] = $f;
917        }
918        spip_log("$file introuvable dans le theme prive ".reset($themes),'theme');
919        return $themefiles["$subdir$file"] = "";
920}
921
922// Cherche une image dans les dossiers images
923// gere le renommage des icones de facon temporaire (le temps de la migration)
924// definis par _NOM_IMG_PACK et _DIR_IMG_PACK
925// peut se trouver dans un dossier plugin, donc on passe par un find_in_path si elle n'est pas
926// dans _DIR_IMG_PACK
927// http://doc.spip.org/@chemin_image
928function chemin_image($icone){
929        static $icone_renommer;
930        // gerer le cas d'un double appel en evitant de refaire le travail inutilement
931        if (strpos($icone,"/")!==false AND file_exists($icone)) return $icone;
932       
933        // si c'est un nom d'image complet (article-24.png) essayer de le renvoyer direct
934        if (preg_match(',[.](png|gif|jpg)$,',$icone) AND $f = find_in_theme("images/$icone"))
935                return $f;
936        // sinon passer par le module de renommage
937        if (is_null($icone_renommer))
938                $icone_renommer = charger_fonction('icone_renommer','inc',true);
939        if ($icone_renommer){
940                list($icone,$fonction) = $icone_renommer($icone,"");
941                if (file_exists($icone))
942                        return $icone;
943        }
944        return find_in_path ($icone, _NOM_IMG_PACK);
945}
946
947//
948// chercher un fichier $file dans le SPIP_PATH
949// si on donne un sous-repertoire en 2e arg optionnel, il FAUT le / final
950// si 3e arg vrai, on inclut si ce n'est fait.
951$GLOBALS['path_sig'] = '';
952$GLOBALS['path_files'] = null;
953
954// http://doc.spip.org/@find_in_path
955function find_in_path ($file, $dirname='', $include=false) {
956        static $dirs=array();
957        static $inc = array(); # cf http://trac.rezo.net/trac/spip/changeset/14743
958        static $c = '';
959
960        // on calcule le chemin si le dossier skel a change
961        if ($c != $GLOBALS['dossier_squelettes']){
962                // assurer le non plantage lors de la montee de version :
963                $c = $GLOBALS['dossier_squelettes'];
964                creer_chemin(); // forcer un recalcul du chemin et la mise a jour de path_sig
965        }
966
967        if (isset($GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file])) {
968                if (!$GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file])
969                        return false;
970                if ($include AND !isset($inc[$dirname][$file])) {
971                        include_once _ROOT_CWD . $GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file];
972                        $inc[$dirname][$file] = $inc[''][$dirname . $file] = true;
973                }
974                return $GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file];
975        }
976
977        $a = strrpos($file,'/');
978        if ($a !== false) {
979                $dirname .= substr($file, 0, ++$a);
980                $file = substr($file, $a);
981        }
982
983        foreach(creer_chemin() as $dir) {
984                if (!isset($dirs[$a = $dir . $dirname]))
985                        $dirs[$a] = (is_dir(_ROOT_CWD . $a) || !$a) ;
986                if ($dirs[$a]) {
987                        if (file_exists(_ROOT_CWD . ($a .= $file))) {
988                                if ($include AND !isset($inc[$dirname][$file])) {
989                                        include_once _ROOT_CWD . $a;
990                                        $inc[$dirname][$file] = $inc[''][$dirname . $file] = true;
991                                }
992                                if (!defined('_SAUVER_CHEMIN')){
993                                        // si le chemin n'a pas encore ete charge, ne pas lever le flag, ne pas cacher
994                                        if (is_null($GLOBALS['path_files'])) return $a;
995                                        define('_SAUVER_CHEMIN', true);
996                                }
997                                return $GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file] = $GLOBALS['path_files'][$GLOBALS['path_sig']][''][$dirname . $file] = $a;
998                        }
999                }
1000        }
1001
1002        if ($include){
1003                spip_log("include_spip $dirname$file non trouve");
1004                if ($include==='required'){
1005                        echo '<pre>',
1006                        "<strong>Erreur Fatale</strong><br />";
1007                        if (function_exists('debug_print_backtrace'))
1008                                echo debug_print_backtrace();
1009                        echo '</pre>';
1010                        die("Erreur interne: ne peut inclure $dirname$file");
1011                }
1012        }
1013
1014        if (!defined('_SAUVER_CHEMIN')){
1015                // si le chemin n'a pas encore ete charge, ne pas lever le flag, ne pas cacher
1016                if (is_null($GLOBALS['path_files'])) return false;
1017                define('_SAUVER_CHEMIN', true);
1018        }
1019        return $GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file] = $GLOBALS['path_files'][$GLOBALS['path_sig']][''][$dirname . $file] = false;
1020}
1021
1022function clear_path_cache(){
1023        $GLOBALS['path_files'] = array();
1024        spip_unlink(_CACHE_CHEMIN);
1025}
1026function load_path_cache(){
1027        // charger le path des plugins
1028        if (@is_readable(_CACHE_PLUGINS_PATH)){
1029                include_once(_CACHE_PLUGINS_PATH);
1030        }
1031        $GLOBALS['path_files'] = array();
1032        // si le visiteur est admin,
1033        // on ne recharge pas le cache pour forcer sa mise a jour
1034        if (
1035                // la session n'est pas encore chargee a ce moment, on ne peut donc pas s'y fier
1036                //AND (!isset($GLOBALS['visiteur_session']['statut']) OR $GLOBALS['visiteur_session']['statut']!='0minirezo')
1037                // utiliser le cookie est un pis aller qui marche 'en general'
1038                // on blinde par un second test au moment de la lecture de la session
1039                // !isset($_COOKIE[$GLOBALS['cookie_prefix'].'_admin'])
1040                // et en ignorant ce cache en cas de recalcul explicite
1041                !_request('var_mode')
1042                ){
1043                // on essaye de lire directement sans verrou pour aller plus vite
1044                if ($contenu = spip_file_get_contents(_CACHE_CHEMIN)){
1045                        // mais si semble corrompu on relit avec un verrou
1046                        if (!$GLOBALS['path_files']=unserialize($contenu)){
1047                                lire_fichier(_CACHE_CHEMIN,$contenu);
1048                                if (!$GLOBALS['path_files']=unserialize($contenu))
1049                                        $GLOBALS['path_files'] = array();
1050                        }
1051                }
1052        }
1053}
1054
1055function save_path_cache(){
1056        if (defined('_SAUVER_CHEMIN')
1057                AND _SAUVER_CHEMIN)
1058                ecrire_fichier(_CACHE_CHEMIN,serialize($GLOBALS['path_files']));
1059}
1060
1061
1062/**
1063 * Trouve tous les fichiers du path correspondants a un pattern
1064 * pour un nom de fichier donne, ne retourne que le premier qui sera trouve
1065 * par un find_in_path
1066 *
1067 * @param string $dir
1068 * @param string $pattern
1069 * @param bool $recurs
1070 * @return array
1071 */
1072// http://doc.spip.org/@find_all_in_path
1073function find_all_in_path($dir,$pattern, $recurs=false){
1074        $liste_fichiers=array();
1075        $maxfiles = 10000;
1076
1077        // Parcourir le chemin
1078        foreach (creer_chemin() as $d) {
1079                $f = $d.$dir;
1080                if (@is_dir($f)){
1081                        $liste = preg_files($f,$pattern,$maxfiles-count($liste_fichiers),$recurs===true?array():$recurs);
1082                        foreach($liste as $chemin){
1083                                $nom = basename($chemin);
1084                                // ne prendre que les fichiers pas deja trouves
1085                                // car find_in_path prend le premier qu'il trouve,
1086                                // les autres sont donc masques
1087                                if (!isset($liste_fichiers[$nom]))
1088                                        $liste_fichiers[$nom] = $chemin;
1089                        }
1090                }
1091        }
1092        return $liste_fichiers;
1093}
1094
1095// predicat sur les scripts de ecrire qui n'authentifient pas par cookie
1096
1097// http://doc.spip.org/@autoriser_sans_cookie
1098function autoriser_sans_cookie($nom)
1099{
1100  static $autsanscookie = array('install', 'base_repair');
1101  $nom = preg_replace('/.php[3]?$/', '', basename($nom));
1102  return in_array($nom, $autsanscookie);
1103}
1104
1105/**
1106 * Fonction codant et decodant les URLS des objets SQL mis en page par SPIP
1107 *
1108 * http://doc.spip.org/@generer_url_entite
1109 *
1110 *
1111 * @param string $id
1112 *   numero de la cle primaire si nombre, URL a decoder si pas numerique
1113 * @param string $entite
1114 *   surnom de la table SQL (donne acces au nom de cle primaire)
1115 * @param string $args
1116 *   query_string a placer apres cle=$id&....
1117 * @param string $ancre
1118 *   ancre a mettre a la fin de l'URL a produire
1119 * @param bool|string $public
1120 *   produire l'URL publique ou privee (par defaut: selon espace)
1121 *   si string : serveur de base de donnee (nom du connect)
1122 * @param string $type
1123 *   fichier dans le repertoire ecrire/urls determinant l'apparence
1124 * @return string|array
1125 *   url codee ou fonction de decodage
1126 *   array : derogatoire, la fonction d'url retourne (objet,id_objet) utilises par nettoyer_raccourcis_typo() pour generer un lien titre
1127 *           (cas des raccourcis personalises [->spip20] : il faut implementer une fonction generer_url_spip et une fonction generer_url_ecrire_spip)
1128 */
1129function generer_url_entite($id='', $entite='', $args='', $ancre='', $public=NULL, $type=NULL)
1130{
1131        if ($public === NULL) $public = !test_espace_prive();
1132        $entite = objet_type($entite); // cas particulier d'appels sur objet/id_objet...
1133
1134        if (!$public) {
1135                if (!$entite) return '';
1136                if (!function_exists('generer_url_ecrire_objet'))
1137                        include_spip('inc/urls');
1138                $res = generer_url_ecrire_objet($entite,$id, $args, $ancre, false);
1139        } else {
1140                if ($type === NULL) {
1141                        $type = ($GLOBALS['type_urls'] === 'page'
1142                                AND $GLOBALS['meta']['type_urls'])
1143                        ?  $GLOBALS['meta']['type_urls']
1144                        :  $GLOBALS['type_urls']; // pour SPIP <2
1145                }
1146
1147                $f = charger_fonction($type, 'urls', true);
1148                // se rabattre sur les urls page si les urls perso non dispo
1149                if (!$f) $f = charger_fonction('page', 'urls', true);
1150
1151                // si $entite='', on veut la fonction de passage URL ==> id
1152                // sinon on veut effectuer le passage id ==> URL
1153                if (!$entite) return $f;
1154
1155                // mais d'abord il faut tester le cas des urls sur une
1156                // base distante
1157                if (is_string($public)
1158                AND $g = charger_fonction('connect', 'urls', true))
1159                        $f = $g;
1160
1161                $res = $f(intval($id), $entite, $args, $ancre, $public);
1162
1163        }
1164        if ($res) return $res;
1165        // Sinon c'est un raccourci ou compat SPIP < 2
1166        if (!function_exists($f = 'generer_url_' . $entite)) {
1167                if (!function_exists($f .= '_dist')) $f = '';
1168        }
1169        if ($f) {
1170                $url = $f($id, $args, $ancre);
1171                if (strlen($args))
1172                        $url .= strstr($url, '?')
1173                                ? '&amp;'.$args
1174                                : '?'.$args;
1175                return $url;
1176        }
1177        // On a ete gentil mais la ....
1178        spip_log("generer_url_entite: entite $entite ($f) inconnue $type $public");
1179        return '';
1180}
1181
1182function generer_url_ecrire_entite_edit($id, $entite, $args='', $ancre=''){
1183        $exec = objet_info($entite,'url_edit');
1184        $url = generer_url_ecrire($exec,$args);
1185        if (intval($id))
1186                $url = parametre_url($url,id_table_objet($entite),$id);
1187        else
1188                $url = parametre_url($url,'new','oui');
1189        if ($ancre)
1190                $url = ancre_url($url,$ancre);
1191        return $url;
1192}
1193
1194// http://doc.spip.org/@urls_connect_dist
1195function urls_connect_dist($i, &$entite, $args='', $ancre='', $public=null) {
1196        include_spip('base/connect_sql');
1197        $id_type = id_table_objet($entite,$public);
1198        return _DIR_RACINE . get_spip_script('./')
1199          . "?"._SPIP_PAGE."=$entite&$id_type=$i&connect=$public"
1200          . (!$args ? '' : "&$args")
1201          . (!$ancre ? '' : "#$ancre");
1202}
1203
1204
1205// Transformer les caracteres utf8 d'une URL (farsi par ex) selon la RFC 1738
1206function urlencode_1738($url) {
1207        if (preg_match(',[^\x00-\x7E],sS', $url)){
1208                $uri = '';
1209                for ($i=0; $i < strlen($url); $i++) {
1210                        if (ord($a = $url[$i]) > 127)
1211                                $a = rawurlencode($a);
1212                        $uri .= $a;
1213                }
1214                $url = $uri;
1215        }
1216        return quote_amp($url);
1217}
1218
1219// http://doc.spip.org/@generer_url_entite_absolue
1220function generer_url_entite_absolue($id='', $entite='', $args='', $ancre='', $connect=NULL)
1221{
1222        if (!$connect) $connect = true;
1223        $h = generer_url_entite($id, $entite, $args, $ancre, $connect);
1224        if (!preg_match(',^\w+:,', $h)) {
1225                include_spip('inc/filtres_mini');
1226                $h = url_absolue($h);
1227        }
1228        return  $h;
1229}
1230
1231// Sur certains serveurs, la valeur 'Off' tient lieu de false dans certaines
1232// variables d'environnement comme $_SERVER[HTTPS] ou ini_get(register_globals)
1233// http://doc.spip.org/@test_valeur_serveur
1234function test_valeur_serveur($truc) {
1235        if (!$truc) return false;
1236        return (strtolower($truc) !== 'off');
1237}
1238
1239//
1240// Fonctions de fabrication des URL des scripts de Spip
1241//
1242/**
1243 * L'URL de base du site, en priorité sans se fier a meta(adresse_site) qui
1244 * peut etre fausse (sites a plusieurs noms d'hotes, deplacements, erreurs).
1245 * En dernier recours, lorsqu'on ne trouve rien, on utilise adresse_site comme fallback.
1246 * Note : la globale $profondeur_url doit etre initialisee de maniere a
1247 * indiquer le nombre de sous-repertoires de l'url courante par rapport a la
1248 * racine de SPIP : par exemple, sur ecrire/ elle vaut 1, sur sedna/ 1, et a
1249 * la racine 0. Sur url/perso/ elle vaut 2
1250 * http://doc.spip.org/@url_de_base
1251 *
1252 * @param int|boo|array $profondeur
1253 *    si non renseignee : retourne l'url pour la profondeur $GLOBALS['profondeur_url']
1254 *    si int : indique que l'on veut l'url pour la prondeur indiquee
1255 *    si bool : retourne le tableau static complet
1256 *    si array : reinitialise le tableau static complet avec la valeur fournie
1257 * @return string|array
1258 */
1259function url_de_base($profondeur=null) {
1260
1261        static $url = array();
1262        if (is_array($profondeur)) return $url = $profondeur;
1263        if ($profondeur===false) return $url;
1264
1265        if (is_null($profondeur)) $profondeur = $GLOBALS['profondeur_url'];
1266
1267        if (isset($url[$profondeur]))
1268                return $url[$profondeur];
1269
1270        $http = (
1271                (isset($_SERVER["SCRIPT_URI"]) AND
1272                        substr($_SERVER["SCRIPT_URI"],0,5) == 'https')
1273                OR (isset($_SERVER['HTTPS']) AND
1274                    test_valeur_serveur($_SERVER['HTTPS']))
1275        ) ? 'https' : 'http';
1276        // note : HTTP_HOST contient le :port si necessaire
1277        $host = $_SERVER['HTTP_HOST'];
1278        // si on n'a pas trouvé d'hôte du tout, en dernier recours on utilise adresse_site comme fallback
1279        if (is_null($host) and isset($GLOBALS['meta']['adresse_site'])) {
1280                $host = $GLOBALS['meta']['adresse_site'];
1281                if ($scheme = parse_url($host, PHP_URL_SCHEME)) {
1282                        $http = $scheme;
1283                        $host = str_replace("{$scheme}://", '', $host);
1284                }
1285        }
1286        if (isset($_SERVER['SERVER_PORT'])
1287                AND $port=$_SERVER['SERVER_PORT']
1288                AND strpos($host,":")==false){
1289                if ($http=="http" AND $port!=80) $host.=":$port";
1290                if ($http=="https" AND $port!=443) $host.=":$port";
1291        }
1292        if (!$GLOBALS['REQUEST_URI']){
1293                if (isset($_SERVER['REQUEST_URI'])) {
1294                        $GLOBALS['REQUEST_URI'] = $_SERVER['REQUEST_URI'];
1295                } else {
1296                        $GLOBALS['REQUEST_URI'] = $_SERVER['PHP_SELF'];
1297                        if ($_SERVER['QUERY_STRING']
1298                        AND !strpos($_SERVER['REQUEST_URI'], '?'))
1299                                $GLOBALS['REQUEST_URI'] .= '?'.$_SERVER['QUERY_STRING'];
1300                }
1301        }
1302
1303        $url[$profondeur] = url_de_($http,$host,$GLOBALS['REQUEST_URI'],$profondeur);
1304
1305        return $url[$profondeur];
1306}
1307/**
1308 * fonction testable de construction d'une url appelee par url_de_base()
1309 * @param string $http
1310 * @param string $host
1311 * @param string $request
1312 * @param int $prof
1313 * @return string
1314 */
1315function url_de_($http,$host,$request,$prof=0){
1316        $prof = max($prof,0);
1317
1318        $myself = ltrim($request,'/');
1319        # supprimer la chaine de GET
1320        list($myself) = explode('?', $myself);
1321        // vieux mode HTTP qui envoie après le nom de la methode l'URL compléte
1322        // protocole, "://", nom du serveur avant le path dans _SERVER["REQUEST_URI"]
1323        if (strpos($myself,'://') !== false) {
1324                $myself = explode('://',$myself);
1325                array_shift($myself);
1326                $myself = implode('://',$myself);
1327                $myself = explode('/',$myself);
1328                array_shift($myself);
1329                $myself = implode('/',$myself);
1330        }
1331        $url = join('/', array_slice(explode('/', $myself), 0, -1-$prof)).'/';
1332
1333        $url = $http.'://'.rtrim($host,'/').'/'.ltrim($url,'/');
1334        return $url;
1335}
1336
1337
1338// Pour une redirection, la liste des arguments doit etre separee par "&"
1339// Pour du code XHTML, ca doit etre &amp;
1340// Bravo au W3C qui n'a pas ete capable de nous eviter ca
1341// faute de separer proprement langage et meta-langage
1342
1343// Attention, X?y=z et "X/?y=z" sont completement differents!
1344// http://httpd.apache.org/docs/2.0/mod/mod_dir.html
1345
1346// http://doc.spip.org/@generer_url_ecrire
1347function generer_url_ecrire($script='', $args="", $no_entities=false, $rel=false) {
1348        if (!$rel)
1349                $rel = url_de_base() . _DIR_RESTREINT_ABS . _SPIP_ECRIRE_SCRIPT;
1350        else if (!is_string($rel))
1351                $rel = _DIR_RESTREINT ? _DIR_RESTREINT :
1352                        ('./'  . _SPIP_ECRIRE_SCRIPT);
1353
1354        @list($script, $ancre) = explode('#', $script);
1355        if ($script AND ($script<>'accueil' OR $rel))
1356                $args = "?exec=$script" . (!$args ? '' : "&$args");
1357        elseif ($args)
1358                $args ="?$args";
1359        if ($ancre) $args .= "#$ancre";
1360        return $rel . ($no_entities ? $args : str_replace('&', '&amp;', $args));
1361}
1362
1363// http://doc.spip.org/@generer_url_retour
1364function generer_url_retour($script, $args="")
1365{
1366        return rawurlencode(generer_url_ecrire($script, $args, true, true));
1367}
1368
1369//
1370// Adresse des scripts publics (a passer dans inc-urls...)
1371//
1372
1373// Detecter le fichier de base, a la racine, comme etant spip.php ou ''
1374// dans le cas de '', un $default = './' peut servir (comme dans urls/page.php)
1375// http://doc.spip.org/@get_spip_script
1376function get_spip_script($default='') {
1377        # cas define('_SPIP_SCRIPT', '');
1378        if (_SPIP_SCRIPT)
1379                return _SPIP_SCRIPT;
1380        else
1381                return $default;
1382}
1383
1384// http://doc.spip.org/@generer_url_public
1385function generer_url_public($script='', $args="", $no_entities=false, $rel=true, $action='') {
1386        // si le script est une action (spip_pass, spip_inscription),
1387        // standardiser vers la nouvelle API
1388
1389        if (!$action) $action = get_spip_script();
1390        if ($script)
1391                $action = parametre_url($action, _SPIP_PAGE, $script, '&');
1392
1393        if ($args) {
1394                if (is_array($args)) {
1395                        $r = '';
1396                        foreach($args as $k => $v) $r .= '&' . $k . '=' . $v;
1397                        $args = substr($r,1);
1398                }
1399                $action .=
1400                        (strpos($action, '?') !== false ? '&' : '?') . $args;
1401        }
1402        if (!$no_entities)
1403                $action = quote_amp($action);
1404
1405        // ne pas generer une url avec /./?page= en cas d'url absolue et de _SPIP_SCRIPT vide
1406        return ($rel ? _DIR_RACINE . $action : rtrim(url_de_base(),'/') . preg_replace(",^/[.]/,","/","/$action"));
1407}
1408
1409// http://doc.spip.org/@generer_url_prive
1410function generer_url_prive($script, $args="", $no_entities=false) {
1411
1412        return generer_url_public($script, $args, $no_entities, false, _DIR_RESTREINT_ABS .  'prive.php');
1413}
1414
1415// Pour les formulaires en methode POST,
1416// mettre le nom du script a la fois en input-hidden et dans le champ action:
1417// 1) on peut ainsi memoriser le signet comme si c'etait un GET
1418// 2) ca suit http://en.wikipedia.org/wiki/Representational_State_Transfer
1419
1420// http://doc.spip.org/@generer_form_ecrire
1421function generer_form_ecrire($script, $corps, $atts='', $submit='') {
1422        global $spip_lang_right;
1423
1424        $script1 = explode('&', $script);
1425        $script1 = reset($script1);
1426
1427        return "<form action='"
1428        . ($script ? generer_url_ecrire($script) : '')
1429        . "' "
1430        . ($atts ? $atts : " method='post'")
1431        .  "><div>\n"
1432        . "<input type='hidden' name='exec' value='$script1' />"
1433        . $corps
1434        . (!$submit ? '' :
1435             ("<div style='text-align: $spip_lang_right'><input class='fondo' type='submit' value=\"".entites_html($submit)."\" /></div>"))
1436        . "</div></form>\n";
1437}
1438
1439/**
1440 * Generer un formulaire pour lancer une action vers $script
1441 *
1442 * Attention, JS/Ajax n'aime pas le melange de param GET/POST
1443 * On n'applique pas la recommandation ci-dessus pour les scripts publics
1444 * qui ne sont pas destines a etre mis en signets
1445 * http://doc.spip.org/@generer_form_action
1446 *
1447 * @param string $script
1448 * @param string $corps
1449 * @param string $atts
1450 * @param bool $public
1451 * @return string
1452 */
1453function generer_form_action($script, $corps, $atts='', $public=false) {
1454        // si l'on est dans l'espace prive, on garde dans l'url
1455        // l'exec a l'origine de l'action, qui permet de savoir si il est necessaire
1456        // ou non de proceder a l'authentification (cas typique de l'install par exemple)
1457        $h = (_DIR_RACINE AND !$public)
1458        ? generer_url_ecrire(_request('exec'))
1459        : generer_url_public();
1460
1461        return "\n<form action='" .
1462          $h .
1463          "'" .
1464          $atts .
1465          ">\n" .
1466          "<div>" .
1467          "\n<input type='hidden' name='action' value='$script' />" .
1468          $corps .
1469          "</div></form>";
1470}
1471
1472// http://doc.spip.org/@generer_url_action
1473function generer_url_action($script, $args="", $no_entities=false , $public = false) {
1474        // si l'on est dans l'espace prive, on garde dans l'url
1475        // l'exec a l'origine de l'action, qui permet de savoir si il est necessaire
1476        // ou non de proceder a l'authentification (cas typique de l'install par exemple)
1477        $url = (_DIR_RACINE  AND !$public)
1478          ? generer_url_ecrire(_request('exec'))
1479          :  generer_url_public('','',false,false);
1480        $url = parametre_url($url,'action',$script);
1481        if ($args) $url .= quote_amp('&'.$args);
1482
1483        if ($no_entities) $url = str_replace('&amp;','&',$url);
1484        return $url;
1485}
1486
1487
1488/**
1489 * Fonction d'initialisation groupee pour compatibilite ascendante
1490 *
1491 * @param string $pi
1492 * @param string $pa
1493 * @param string $ti
1494 * @param string $ta
1495 */
1496function spip_initialisation($pi=NULL, $pa=NULL, $ti=NULL, $ta=NULL) {
1497        spip_initialisation_core($pi,$pa,$ti,$ta);
1498        spip_initialisation_suite();
1499}
1500
1501/**
1502 * Fonction d'initialisation, appellee dans inc_version ou mes_options
1503 * Elle definit les repertoires et fichiers non partageables
1504 * et indique dans $test_dirs ceux devant etre accessibles en ecriture
1505 * mais ne touche pas a cette variable si elle est deja definie
1506 * afin que mes_options.php puisse en specifier d'autres.
1507 * Elle definit ensuite les noms des fichiers et les droits.
1508 * Puis simule un register_global=on securise.
1509 *
1510 * @param string $pi
1511 * @param string $pa
1512 * @param string $ti
1513 * @param string $ta
1514 */
1515function spip_initialisation_core($pi=NULL, $pa=NULL, $ti=NULL, $ta=NULL) {
1516        static $too_late = 0;
1517        if ($too_late++) return;
1518       
1519        // Declaration des repertoires
1520
1521        // le nom du repertoire plugins/ activables/desactivables
1522        if (!defined('_DIR_PLUGINS')) define('_DIR_PLUGINS', _DIR_RACINE . "plugins/");
1523
1524        // le nom du repertoire des extensions/ permanentes du core, toujours actives
1525        if (!defined('_DIR_PLUGINS_DIST')) define('_DIR_PLUGINS_DIST', _DIR_RACINE . "plugins-dist/");
1526
1527        // le nom du repertoire des librairies
1528        if (!defined('_DIR_LIB')) define('_DIR_LIB', _DIR_RACINE . "lib/");
1529       
1530        if (!defined('_DIR_IMG')) define('_DIR_IMG', $pa);
1531        if (!defined('_DIR_LOGOS')) define('_DIR_LOGOS', $pa);
1532        if (!defined('_DIR_IMG_ICONES')) define('_DIR_IMG_ICONES', _DIR_LOGOS . "icones/");
1533
1534        if (!defined('_DIR_DUMP')) define('_DIR_DUMP', $ti . "dump/");
1535        if (!defined('_DIR_SESSIONS')) define('_DIR_SESSIONS', $ti . "sessions/");
1536        if (!defined('_DIR_TRANSFERT')) define('_DIR_TRANSFERT', $ti . "upload/");
1537        if (!defined('_DIR_CACHE')) define('_DIR_CACHE', $ti . "cache/");
1538        if (!defined('_DIR_CACHE_XML')) define('_DIR_CACHE_XML', _DIR_CACHE . "xml/");
1539        if (!defined('_DIR_SKELS')) define('_DIR_SKELS',  _DIR_CACHE . "skel/");
1540        if (!defined('_DIR_AIDE')) define('_DIR_AIDE',  _DIR_CACHE . "aide/");
1541        if (!defined('_DIR_TMP')) define('_DIR_TMP', $ti);
1542
1543        if (!defined('_DIR_VAR')) define('_DIR_VAR', $ta);
1544
1545        if (!defined('_DIR_ETC')) define('_DIR_ETC', $pi);
1546        if (!defined('_DIR_CONNECT')) define('_DIR_CONNECT', $pi);
1547        if (!defined('_DIR_CHMOD')) define('_DIR_CHMOD', $pi);
1548
1549        if (!isset($GLOBALS['test_dirs']))
1550          // Pas $pi car il est bon de le mettre hors ecriture apres intstall
1551          // il sera rajoute automatiquement si besoin a l'etape 2 de l'install
1552                $GLOBALS['test_dirs'] =  array($pa, $ti, $ta);
1553
1554        // Declaration des fichiers
1555
1556        if (!defined('_CACHE_PLUGINS_PATH')) define('_CACHE_PLUGINS_PATH', _DIR_CACHE . "charger_plugins_chemins.php");
1557        if (!defined('_CACHE_PLUGINS_OPT')) define('_CACHE_PLUGINS_OPT', _DIR_CACHE . "charger_plugins_options.php");
1558        if (!defined('_CACHE_PLUGINS_FCT')) define('_CACHE_PLUGINS_FCT', _DIR_CACHE . "charger_plugins_fonctions.php");
1559        if (!defined('_CACHE_PIPELINES')) define('_CACHE_PIPELINES',  _DIR_CACHE."charger_pipelines.php");
1560        if (!defined('_CACHE_CHEMIN')) define('_CACHE_CHEMIN',  _DIR_CACHE."chemin.txt");
1561
1562        # attention .php obligatoire pour ecrire_fichier_securise
1563        if (!defined('_FILE_META')) define('_FILE_META', $ti . 'meta_cache.php');
1564        if (!defined('_DIR_LOG')) define('_DIR_LOG', _DIR_TMP . 'log/');
1565        if (!defined('_FILE_LOG')) define('_FILE_LOG', 'spip');
1566        if (!defined('_FILE_LOG_SUFFIX')) define('_FILE_LOG_SUFFIX', '.log');
1567
1568        // Le fichier de connexion a la base de donnees
1569        // tient compte des anciennes versions (inc_connect...)
1570        if (!defined('_FILE_CONNECT_INS')) define('_FILE_CONNECT_INS', 'connect');
1571        if (!defined('_FILE_CONNECT')) define('_FILE_CONNECT',
1572                (@is_readable($f = _DIR_CONNECT . _FILE_CONNECT_INS . '.php') ? $f
1573        :       (@is_readable($f = _DIR_RESTREINT . 'inc_connect.php') ? $f
1574        :       false)));
1575
1576        // Le fichier de reglages des droits
1577        if (!defined('_FILE_CHMOD_INS')) define('_FILE_CHMOD_INS', 'chmod');
1578        if (!defined('_FILE_CHMOD')) define('_FILE_CHMOD',
1579                (@is_readable($f = _DIR_CHMOD . _FILE_CHMOD_INS . '.php') ? $f
1580        :       false));
1581
1582        if (!defined('_FILE_LDAP')) define('_FILE_LDAP', 'ldap.php');
1583
1584        if (!defined('_FILE_TMP_SUFFIX')) define('_FILE_TMP_SUFFIX', '.tmp.php');
1585        if (!defined('_FILE_CONNECT_TMP')) define('_FILE_CONNECT_TMP', _DIR_CONNECT . _FILE_CONNECT_INS . _FILE_TMP_SUFFIX);
1586        if (!defined('_FILE_CHMOD_TMP')) define('_FILE_CHMOD_TMP', _DIR_CHMOD . _FILE_CHMOD_INS . _FILE_TMP_SUFFIX);
1587
1588        // Definition des droits d'acces en ecriture
1589        if (!defined('_SPIP_CHMOD') AND _FILE_CHMOD)
1590                include_once _FILE_CHMOD;
1591
1592        // Se mefier des fichiers mal remplis!
1593        if (!defined('_SPIP_CHMOD')) define('_SPIP_CHMOD', 0777);
1594
1595        // Le charset par defaut lors de l'installation
1596        if (!defined('_DEFAULT_CHARSET')) define('_DEFAULT_CHARSET', 'utf-8');
1597        if (!defined('_ROOT_PLUGINS')) define('_ROOT_PLUGINS', _ROOT_RACINE . "plugins/");
1598        if (!defined('_ROOT_PLUGINS_DIST')) define('_ROOT_PLUGINS_DIST', _ROOT_RACINE . "plugins-dist/");
1599        if (!defined('_ROOT_PLUGINS_SUPPL') && defined('_DIR_PLUGINS_SUPPL') && _DIR_PLUGINS_SUPPL) define('_ROOT_PLUGINS_SUPPL', _ROOT_RACINE . str_replace(_DIR_RACINE,'',_DIR_PLUGINS_SUPPL));
1600
1601        // La taille des Log
1602        if (!defined('_MAX_LOG')) define('_MAX_LOG', 100);
1603
1604        // Sommes-nous dans l'empire du Mal ?
1605        // (ou sous le signe du Pingouin, ascendant GNU ?)
1606        if (strpos($_SERVER['SERVER_SOFTWARE'], '(Win') !== false){
1607                if (!defined('_OS_SERVEUR')) define('_OS_SERVEUR', 'windows');
1608                if (!defined('_SPIP_LOCK_MODE')) define('_SPIP_LOCK_MODE',1); // utiliser le flock php
1609        }
1610        else {
1611                if (!defined('_OS_SERVEUR')) define('_OS_SERVEUR', '');
1612                if (!defined('_SPIP_LOCK_MODE')) define('_SPIP_LOCK_MODE',1); // utiliser le flock php
1613                #if (!defined('_SPIP_LOCK_MODE')) define('_SPIP_LOCK_MODE',2); // utiliser le nfslock de spip mais link() est tres souvent interdite
1614        }
1615
1616        // Langue par defaut
1617        if (!defined('_LANGUE_PAR_DEFAUT')) define('_LANGUE_PAR_DEFAUT','fr');
1618
1619        // PHP_VERSION_ID dispo depuis PHP 5.2.7
1620        if (!defined('PHP_VERSION_ID')) {
1621           $version = explode('.',PHP_VERSION);
1622           define('PHP_VERSION_ID', ($version[0] * 10000 + $version[1] * 100 + $version[2]));
1623        }
1624
1625        //
1626        // Module de lecture/ecriture/suppression de fichiers utilisant flock()
1627        // (non surchargeable en l'etat ; attention si on utilise include_spip()
1628        // pour le rendre surchargeable, on va provoquer un reecriture
1629        // systematique du noyau ou une baisse de perfs => a etudier)
1630        include_once _ROOT_RESTREINT . 'inc/flock.php';
1631
1632        // charger tout de suite le path et son cache
1633        load_path_cache();
1634
1635        // *********** traiter les variables ************
1636
1637        //
1638        // Securite
1639        //
1640
1641        // Ne pas se faire manger par un bug php qui accepte ?GLOBALS[truc]=toto
1642        if (isset($_REQUEST['GLOBALS'])) die();
1643        // nettoyer les magic quotes \' et les caracteres nuls %00
1644        spip_desinfecte($_GET);
1645        spip_desinfecte($_POST);
1646        spip_desinfecte($_COOKIE);
1647        spip_desinfecte($_REQUEST);
1648
1649        // Par ailleurs on ne veut pas de magic_quotes au cours de l'execution
1650        if (PHP_VERSION_ID<50300) {
1651                @set_magic_quotes_runtime(0);
1652        }
1653
1654        // Si les variables sont passees en global par le serveur,
1655        // il faut faire quelques verifications de base
1656        $avertir_register_globals = false;
1657        if (test_valeur_serveur(@ini_get('register_globals'))) {
1658                // ne pas desinfecter les globales en profondeur car elle contient aussi les
1659                // precedentes, qui seraient desinfectees 2 fois.
1660                spip_desinfecte($GLOBALS,false);
1661                if (include_spip('inc/php3'))
1662                        spip_register_globals(true);
1663
1664                $avertir_register_globals = true;
1665        }
1666
1667        // appliquer le cookie_prefix
1668        if ($GLOBALS['cookie_prefix'] != 'spip') {
1669                include_spip('inc/cookie');
1670                recuperer_cookies_spip($GLOBALS['cookie_prefix']);
1671        }
1672
1673        //
1674        // Capacites php (en fonction de la version)
1675        //
1676        $GLOBALS['flag_ob'] = (function_exists("ob_start")
1677                && function_exists("ini_get")
1678                && !strstr(@ini_get('disable_functions'), 'ob_'));
1679        $GLOBALS['flag_sapi_name'] = function_exists("php_sapi_name");
1680        $GLOBALS['flag_get_cfg_var'] = (@get_cfg_var('error_reporting') != "");
1681        $GLOBALS['flag_upload'] = (!$GLOBALS['flag_get_cfg_var'] ||
1682                (get_cfg_var('upload_max_filesize') > 0));
1683
1684
1685        // Compatibilite avec serveurs ne fournissant pas $REQUEST_URI
1686        if (isset($_SERVER['REQUEST_URI'])) {
1687                $GLOBALS['REQUEST_URI'] = $_SERVER['REQUEST_URI'];
1688        } else {
1689                $GLOBALS['REQUEST_URI'] = $_SERVER['PHP_SELF'];
1690                if ($_SERVER['QUERY_STRING']
1691                AND !strpos($_SERVER['REQUEST_URI'], '?'))
1692                        $GLOBALS['REQUEST_URI'] .= '?'.$_SERVER['QUERY_STRING'];
1693        }
1694
1695        // Duree de validite de l'alea pour les cookies et ce qui s'ensuit.
1696        if (!defined('_RENOUVELLE_ALEA')) define('_RENOUVELLE_ALEA', 12 * 3600);
1697
1698        // charger les meta si possible et renouveller l'alea au besoin
1699        // charge aussi effacer_meta et ecrire_meta
1700        $inc_meta = charger_fonction('meta', 'inc');
1701        $inc_meta();
1702
1703        // on a pas pu le faire plus tot
1704        if  ($avertir_register_globals)
1705                avertir_auteurs("register_globals",_L("Probl&egrave;me de s&eacute;curit&eacute; : register_globals=on; dans php.ini &agrave; corriger."));
1706
1707        // nombre de repertoires depuis la racine
1708        // on compare a l'adresse de spip.php : $_SERVER["SCRIPT_NAME"]
1709        // ou a defaut celle donnee en meta ; (mais si celle-ci est fausse
1710        // le calcul est faux)
1711        if (!_DIR_RESTREINT)
1712                $GLOBALS['profondeur_url'] = 1;
1713        else {
1714                $uri = isset($_SERVER['REQUEST_URI']) ? explode('?', $_SERVER['REQUEST_URI']) : '';
1715                $uri_ref = $_SERVER["SCRIPT_NAME"];
1716                if (!$uri_ref
1717                        // si on est appele avec un autre ti, on est sans doute en mutu
1718                        // si jamais c'est de la mutu avec sous rep, on est perdu si on se fie
1719                        // a spip.php qui est a la racine du spip, et vue qu'on sait pas se reperer
1720                        // s'en remettre a l'adresse du site. alea jacta est.
1721                        OR $ti!==_NOM_TEMPORAIRES_INACCESSIBLES){
1722
1723                        if (isset($GLOBALS['meta']['adresse_site'])) {
1724                                $uri_ref = parse_url($GLOBALS['meta']['adresse_site']);
1725                                $uri_ref = $uri_ref['path'].'/';
1726                        }
1727                  else
1728                          $uri_ref = "";
1729                }
1730                if (!$uri OR !$uri_ref)
1731                        $GLOBALS['profondeur_url'] = 0;
1732                else {
1733                        $GLOBALS['profondeur_url'] = max(0,
1734                                substr_count($uri[0], '/')
1735                                - substr_count($uri_ref,'/'));
1736                }
1737        }
1738        // s'il y a un cookie ou PHP_AUTH, initialiser visiteur_session
1739        if (_FILE_CONNECT) {
1740                if (verifier_visiteur()=='0minirezo'
1741                        // si c'est un admin sans cookie admin, il faut ignorer le cache chemin !
1742                  AND !isset($_COOKIE['spip_admin']))
1743                        clear_path_cache();
1744        }
1745
1746}
1747
1748/**
1749 * Complements d'initialisation non critiques pouvant etre realises
1750 * par les plugins
1751 *
1752 */
1753function spip_initialisation_suite() {
1754        static $too_late = 0;
1755        if ($too_late++) return;
1756
1757        // taille mini des login
1758        if (!defined('_LOGIN_TROP_COURT')) define('_LOGIN_TROP_COURT', 4);
1759
1760        // la taille maxi des logos (0 : pas de limite)
1761        if (!defined('_LOGO_MAX_SIZE')) define('_LOGO_MAX_SIZE', 0); # poids en ko
1762        if (!defined('_LOGO_MAX_WIDTH')) define('_LOGO_MAX_WIDTH', 0); # largeur en pixels
1763        if (!defined('_LOGO_MAX_HEIGHT')) define('_LOGO_MAX_HEIGHT', 0); # hauteur en pixels
1764
1765        if (!defined('_DOC_MAX_SIZE')) define('_DOC_MAX_SIZE', 0); # poids en ko
1766
1767        if (!defined('_IMG_MAX_SIZE')) define('_IMG_MAX_SIZE', 0); # poids en ko
1768        if (!defined('_IMG_MAX_WIDTH')) define('_IMG_MAX_WIDTH', 0); # largeur en pixels
1769        if (!defined('_IMG_MAX_HEIGHT')) define('_IMG_MAX_HEIGHT', 0); # hauteur en pixels
1770        if (!defined('_PASS_LONGUEUR_MINI')) define('_PASS_LONGUEUR_MINI',6);
1771
1772
1773        // Qualite des images calculees automatiquement. C'est un nombre entre 0 et 100, meme pour imagick (on ramene a 0..1 par la suite)
1774        if (!defined('_IMG_QUALITE')) define('_IMG_QUALITE', 85); # valeur par defaut
1775        if (!defined('_IMG_GD_QUALITE')) define('_IMG_GD_QUALITE', _IMG_QUALITE); # surcharge pour la lib GD
1776        if (!defined('_IMG_CONVERT_QUALITE')) define('_IMG_CONVERT_QUALITE', _IMG_QUALITE); # surcharge pour imagick en ligne de commande
1777        // Historiquement la valeur pour imagick semble differente. Si ca n'est pas necessaire, il serait preferable de garder _IMG_QUALITE
1778        if (!defined('_IMG_IMAGICK_QUALITE')) define('_IMG_IMAGICK_QUALITE', 75); # surcharge pour imagick en PHP
1779
1780        if (!defined('_COPIE_LOCALE_MAX_SIZE')) define('_COPIE_LOCALE_MAX_SIZE',16777216); // poids en octet
1781
1782        // qq chaines standard
1783        if (!defined('_ACCESS_FILE_NAME')) define('_ACCESS_FILE_NAME', '.htaccess');
1784        if (!defined('_AUTH_USER_FILE')) define('_AUTH_USER_FILE', '.htpasswd');
1785        if (!defined('_SPIP_DUMP')) define('_SPIP_DUMP', 'dump@nom_site@@stamp@.xml');
1786        if (!defined('_CACHE_RUBRIQUES')) define('_CACHE_RUBRIQUES', _DIR_TMP.'menu-rubriques-cache.txt');
1787        if (!defined('_CACHE_RUBRIQUES_MAX')) define('_CACHE_RUBRIQUES_MAX', 500);
1788
1789        if (!defined('_EXTENSION_SQUELETTES')) define('_EXTENSION_SQUELETTES', 'html');
1790
1791        if (!defined('_DOCTYPE_ECRIRE')) define('_DOCTYPE_ECRIRE',
1792                // "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01 Transitional//EN' 'http://www.w3.org/TR/html4/loose.dtd'>\n");
1793                //"<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>\n");
1794                //"<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Strict//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>\n");
1795               // "<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.1 //EN' 'http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd'>\n");
1796                "<!DOCTYPE html>\n");
1797        if (!defined('_DOCTYPE_AIDE')) define('_DOCTYPE_AIDE',
1798               "<!DOCTYPE html PUBLIC '-//W3C//DTD HTML 4.01 Frameset//EN' 'http://www.w3.org/TR/1999/REC-html401-19991224/frameset.dtd'>");
1799
1800        // L'adresse de base du site ; on peut mettre '' si la racine est geree par
1801        // le script de l'espace public, alias  index.php
1802        if (!defined('_SPIP_SCRIPT')) define('_SPIP_SCRIPT', 'spip.php');
1803        // argument page, personalisable en cas de conflit avec un autre script
1804        if (!defined('_SPIP_PAGE')) define('_SPIP_PAGE', 'page');
1805
1806        // le script de l'espace prive
1807        // Mettre a "index.php" si DirectoryIndex ne le fait pas ou pb connexes:
1808        // les anciens IIS n'acceptent pas les POST sur ecrire/ (#419)
1809        // meme pb sur thttpd cf. http://forum.spip.org/fr_184153.html
1810
1811        if (!defined('_SPIP_ECRIRE_SCRIPT')) define('_SPIP_ECRIRE_SCRIPT', // true ? #decommenter ici et commenter la
1812               preg_match(',IIS|thttpd,',$_SERVER['SERVER_SOFTWARE']) ?
1813               'index.php' : '');
1814
1815
1816        if (!defined('_SPIP_AJAX'))
1817                define('_SPIP_AJAX', ((!isset($_COOKIE['spip_accepte_ajax']))
1818                        ? 1
1819                       : (($_COOKIE['spip_accepte_ajax'] != -1) ? 1 : 0)));
1820
1821        // La requete est-elle en ajax ?
1822        if (!defined('_AJAX')) define('_AJAX',
1823                (isset($_SERVER['HTTP_X_REQUESTED_WITH']) # ajax jQuery
1824                OR @$_REQUEST['var_ajax_redir'] # redirection 302 apres ajax jQuery
1825                OR @$_REQUEST['var_ajaxcharset'] # compat ascendante pour plugins
1826                OR @$_REQUEST['var_ajax'] # forms ajax & inclure ajax de spip
1827                )
1828                AND !@$_REQUEST['var_noajax'] # horrible exception, car c'est pas parce que la requete est ajax jquery qu'il faut tuer tous les formulaires ajax qu'elle contient
1829        );
1830
1831        # nombre de pixels maxi pour calcul de la vignette avec gd
1832        # au dela de 5500000 on considere que php n'est pas limite en memoire pour cette operation
1833        # les configurations limitees en memoire ont un seuil plutot vers 1MPixel
1834        if (!defined('_IMG_GD_MAX_PIXELS')) define('_IMG_GD_MAX_PIXELS',
1835                (isset($GLOBALS['meta']['max_taille_vignettes'])&&$GLOBALS['meta']['max_taille_vignettes']<5500000)
1836                 ? $GLOBALS['meta']['max_taille_vignettes']
1837                 : 0);
1838
1839        if (!defined('_MEMORY_LIMIT_MIN')) define('_MEMORY_LIMIT_MIN',10); // en Mo
1840        // si on est dans l'espace prive et si le besoin est superieur a 8Mo (qui est vraiment le standard)
1841        // on verifie que la memoire est suffisante pour le compactage css+js pour eviter la page blanche
1842        // il y aura d'autres problemes et l'utilisateur n'ira pas tres loin, mais ce sera plus comprehensible qu'une page blanche
1843        if (test_espace_prive() AND _MEMORY_LIMIT_MIN>8){
1844                if ($memory = trim(ini_get('memory_limit')) and $memory != -1) {
1845                        $unit = strtolower(substr($memory,strlen($memory/1),1));
1846                        switch($unit) {
1847                                // Le modifieur 'G' est disponible depuis PHP 5.1.0
1848                                case 'g': $memory *= 1024;
1849                                case 'm': $memory *= 1024;
1850                                case 'k': $memory *= 1024;
1851                        }
1852                        if ($memory<_MEMORY_LIMIT_MIN*1024*1024){
1853                                ini_set('memory_limit',$m=_MEMORY_LIMIT_MIN.'M');
1854                                if (trim(ini_get('memory_limit'))!=$m){
1855                                        if (!defined('_INTERDIRE_COMPACTE_HEAD_ECRIRE')) define('_INTERDIRE_COMPACTE_HEAD_ECRIRE',true); // evite une page blanche car on ne saura pas calculer la css dans ce hit
1856                                }
1857                        }
1858                }
1859                else
1860                        if (!defined('_INTERDIRE_COMPACTE_HEAD_ECRIRE')) define('_INTERDIRE_COMPACTE_HEAD_ECRIRE',true); // evite une page blanche car on ne saura pas calculer la css dans ce hit
1861        }
1862        // Protocoles a normaliser dans les chaines de langues
1863        if (!defined('_PROTOCOLES_STD'))
1864                define('_PROTOCOLES_STD', 'http|https|ftp|mailto|webcal');
1865
1866        init_var_mode();
1867}
1868
1869// Reperer les variables d'URL qui conditionnent la perennite du cache, des urls
1870// ou d'autres petit caches (trouver_table, css et js compactes ...)
1871// http://doc.spip.org/@init_var_mode
1872function init_var_mode(){
1873        static $done = false;
1874        if (!$done) {
1875
1876                if (isset($_GET['var_mode'])) {
1877                        // tout le monde peut calcul/recalcul
1878                        if ($_GET['var_mode'] == 'calcul'
1879                        OR $_GET['var_mode'] == 'recalcul') {
1880                                if (!defined('_VAR_MODE')) define('_VAR_MODE',$_GET['var_mode']);
1881                        }
1882                        // preview, debug, blocs, urls et images necessitent une autorisation
1883                        else if (in_array($_GET['var_mode'],array('preview','debug','inclure','urls','images','traduction'))) {
1884                                include_spip('inc/autoriser');
1885                                if (autoriser(
1886                                        ($_GET['var_mode'] == 'preview')
1887                                                ? 'previsualiser'
1888                                                : 'debug'
1889                                )) {
1890                                        switch($_GET['var_mode']){
1891                                                case 'traduction':
1892                                                        // forcer le calcul pour passer dans traduire
1893                                                        if (!defined('_VAR_MODE')) define('_VAR_MODE','calcul');
1894                                                        // et ne pas enregistrer de cache pour ne pas trainer les surlignages sur d'autres pages
1895                                                        if (!defined('_VAR_NOCACHE')) define('_VAR_NOCACHE',true);
1896                                                        break;
1897                                                case 'preview':
1898                                                        // basculer sur les criteres de preview dans les boucles
1899                                                        if (!defined('_VAR_PREVIEW')) define('_VAR_PREVIEW',true);
1900                                                        // forcer le calcul
1901                                                        if (!defined('_VAR_MODE')) define('_VAR_MODE','calcul');
1902                                                        // et ne pas enregistrer de cache
1903                                                        if (!defined('_VAR_NOCACHE')) define('_VAR_NOCACHE',true);
1904                                                        break;
1905                                                case 'inclure':
1906                                                        // forcer le compilo et ignorer les caches existants
1907                                                        if (!defined('_VAR_MODE')) define('_VAR_MODE','calcul');
1908                                                        if (!defined('_VAR_INCLURE')) define('_VAR_INCLURE',true);
1909                                                        // et ne pas enregistrer de cache
1910                                                        if (!defined('_VAR_NOCACHE')) define('_VAR_NOCACHE',true);
1911                                                        break;
1912                                                case 'urls':
1913                                                        // forcer le compilo et ignorer les caches existants
1914                                                        if (!defined('_VAR_MODE')) define('_VAR_MODE','calcul');
1915                                                        if (!defined('_VAR_URLS')) define('_VAR_URLS',true);
1916                                                        break;
1917                                                case 'images':
1918                                                        // forcer le compilo et ignorer les caches existants
1919                                                        if (!defined('_VAR_MODE')) define('_VAR_MODE','calcul');
1920                                                        // indiquer qu'on doit recalculer les images
1921                                                        if (!defined('_VAR_IMAGES')) define('_VAR_IMAGES',true);
1922                                                        break;
1923                                                case 'debug':
1924                                                        if (!defined('_VAR_MODE')) define('_VAR_MODE','debug');
1925                                                        // et ne pas enregistrer de cache
1926                                                        if (!defined('_VAR_NOCACHE')) define('_VAR_NOCACHE',true);
1927                                                        break;
1928                                                default :
1929                                                        if (!defined('_VAR_MODE')) define('_VAR_MODE',$_GET['var_mode']);
1930                                                        break;
1931                                        }
1932          if (isset($GLOBALS['visiteur_session']['nom']))
1933                                        spip_log($GLOBALS['visiteur_session']['nom']
1934                                                . " "._VAR_MODE);
1935                                }
1936                                // pas autorise ?
1937                                else {
1938                                        // si on n'est pas connecte on se redirige
1939                                        if (!$GLOBALS['visiteur_session']) {
1940                                                include_spip('inc/headers');
1941                                                redirige_par_entete(generer_url_public('login',
1942                                                'url='.rawurlencode(
1943                                                parametre_url(self(), 'var_mode', $_GET['var_mode'], '&')
1944                                                ), true));
1945                                        }
1946                                        // sinon tant pis
1947                                }
1948                        }
1949                        if (!defined('_VAR_MODE')) define('_VAR_MODE',false);
1950                }
1951                $done = true;
1952        }
1953}
1954
1955// Annuler les magic quotes \' sur GET POST COOKIE et GLOBALS ;
1956// supprimer aussi les eventuels caracteres nuls %00, qui peuvent tromper
1957// la commande is_readable('chemin/vers/fichier/interdit%00truc_normal')
1958// http://doc.spip.org/@spip_desinfecte
1959function spip_desinfecte(&$t,$deep = true) {
1960        static $magic_quotes;
1961        if (!isset($magic_quotes))
1962                $magic_quotes = @get_magic_quotes_gpc();
1963
1964        foreach ($t as $key => $val) {
1965                if (is_string($t[$key])) {
1966                        if ($magic_quotes)
1967                                $t[$key] = stripslashes($t[$key]);
1968                        $t[$key] = str_replace(chr(0), '-', $t[$key]);
1969                }
1970                // traiter aussi les "texte_plus" de article_edit
1971                else if ($deep AND is_array($t[$key]) AND $key!=='GLOBALS')
1972                        spip_desinfecte($t[$key],$deep);
1973        }
1974}
1975
1976//  retourne le statut du visiteur s'il s'annonce
1977
1978// http://doc.spip.org/@verifier_visiteur
1979function verifier_visiteur() {
1980        // Rq: pour que cette fonction marche depuis mes_options
1981        // il faut forcer l'init si ce n'est fait
1982        // mais on risque de perturber des plugins en initialisant trop tot
1983        // certaines constantes
1984        @spip_initialisation_core(
1985                (_DIR_RACINE  . _NOM_PERMANENTS_INACCESSIBLES),
1986                (_DIR_RACINE  . _NOM_PERMANENTS_ACCESSIBLES),
1987                (_DIR_RACINE  . _NOM_TEMPORAIRES_INACCESSIBLES),
1988                (_DIR_RACINE  . _NOM_TEMPORAIRES_ACCESSIBLES)
1989        );
1990
1991        // Demarrer une session NON AUTHENTIFIEE si on donne son nom
1992        // dans un formulaire sans login (ex: #FORMULAIRE_FORUM)
1993        // Attention on separe bien session_nom et nom, pour eviter
1994        // les melanges entre donnees SQL et variables plus aleatoires
1995        $variables_session = array('session_nom', 'session_email');
1996        foreach($variables_session as $var) {
1997                if (_request($var) !== null) {
1998                        $init = true;
1999                        break;
2000                }
2001        }
2002        if (isset($init)) {
2003                #@spip_initialisation_suite();
2004                $session = charger_fonction('session', 'inc');
2005                $session();
2006                include_spip('inc/texte');
2007                foreach($variables_session as $var)
2008                        if (($a = _request($var)) !== null)
2009                                $GLOBALS['visiteur_session'][$var] = safehtml($a);
2010                if (!isset($GLOBALS['visiteur_session']['id_auteur']))
2011                        $GLOBALS['visiteur_session']['id_auteur'] = 0;
2012                $session($GLOBALS['visiteur_session']);
2013                return 0;
2014        }
2015
2016        $h = (isset($_SERVER['PHP_AUTH_USER'])  AND !$GLOBALS['ignore_auth_http']);
2017        if ($h OR isset($_COOKIE['spip_session']) OR isset($_COOKIE[$GLOBALS['cookie_prefix'].'_session'])) {
2018
2019                $session = charger_fonction('session', 'inc');
2020                if ($session()) {
2021                        return $GLOBALS['visiteur_session']['statut'];
2022                }
2023                if ($h  AND isset($_SERVER['PHP_AUTH_PW'])) {
2024                        include_spip('inc/auth');
2025                        $h = lire_php_auth($_SERVER['PHP_AUTH_USER'], $_SERVER['PHP_AUTH_PW']);
2026                }
2027                if ($h) {
2028                        $GLOBALS['visiteur_session'] = $h;
2029                        return $GLOBALS['visiteur_session']['statut'];
2030                }
2031        }
2032
2033        // au moins son navigateur nous dit la langue preferee de cet inconnu
2034        include_spip('inc/lang');
2035        utiliser_langue_visiteur();
2036
2037        return false;
2038}
2039
2040// selectionne la langue donnee en argument et memorise la courante
2041// ou restaure l'ancienne si appel sans argument
2042// On pourrait economiser l'empilement en cas de non changemnt
2043// et lui faire retourner False pour prevenir l'appelant
2044// Le noyau de Spip sait le faire, mais pour assurer la compatibilite
2045// cette fonction retourne toujours non False
2046
2047// http://doc.spip.org/@lang_select
2048function lang_select ($lang=NULL) {
2049        static $pile_langues = array();
2050        if (!function_exists('changer_langue'))
2051                include_spip('inc/lang');
2052        if ($lang === NULL)
2053                $lang = array_pop($pile_langues);
2054        else {
2055                array_push($pile_langues, $GLOBALS['spip_lang']);
2056        }
2057        if (isset($GLOBALS['spip_lang']) AND $lang == $GLOBALS['spip_lang'])
2058                return $lang;
2059        changer_langue($lang);
2060        return $lang;
2061}
2062
2063
2064// Renvoie une chaine qui decrit la session courante pour savoir si on peut
2065// utiliser un cache enregistre pour cette session.
2066// Par convention cette chaine ne doit pas contenir de caracteres [^0-9A-Za-z]
2067// Attention on ne peut *pas* inferer id_auteur a partir de la session, qui
2068// est une chaine arbitraire
2069// Cette chaine est courte (8 cars) pour pouvoir etre utilisee dans un nom
2070// de fichier cache
2071// http://doc.spip.org/@spip_session
2072function spip_session($force = false) {
2073        static $session;
2074        if ($force OR !isset($session)) {
2075                $s = pipeline('definir_session',
2076                        $GLOBALS['visiteur_session']
2077                        ? serialize($GLOBALS['visiteur_session'])
2078                                . '_' . @$_COOKIE['spip_session']
2079                        : ''
2080                );
2081                $session = $s ? substr(md5($s), 0, 8) : '';
2082        }
2083        #spip_log('session: '.$session);
2084        return $session;
2085}
2086
2087
2088/**
2089 * Aide, aussi depuis l'espace prive a present.
2090 * Surchargeable mais pas d'erreur fatale si indisponible.
2091 *
2092 * @param string $aide
2093 *              Cle d'identification de l'aide desiree
2094 * @param bool $distante
2095 *              Generer une url locale (par defaut)
2096 *              ou une url distante [directement sur spip.net]
2097 * @return Lien sur une icone d'aide
2098**/
2099// http://doc.spip.org/@aide
2100function aide($aide='', $distante = false) {
2101                $aider = charger_fonction('aider', 'inc', true);
2102        return $aider ?  $aider($aide, '', array(), $distante) : '';
2103}
2104
2105// normalement il faudrait creer exec/info.php, mais pour mettre juste ca:
2106// http://doc.spip.org/@exec_info_dist
2107function exec_info_dist() {
2108        global $connect_statut;
2109        if ($connect_statut == '0minirezo')
2110                phpinfo();
2111        else
2112                echo "pas admin";
2113}
2114
2115/**
2116 * Génère une erreur de squelette
2117 *
2118 * Génère une erreur de squelette qui sera bien visible par un
2119 * administrateur authentifié lors d'une visite de la page en erreur
2120 *
2121 * @param bool|string|array $message
2122 *              - Message d'erreur (string|array)
2123 *              - false pour retourner le texte des messages d'erreurs
2124 *              - vide pour afficher les messages d'erreurs
2125 * @param string|array|object $lieu
2126 *              Lieu d'origine de l'erreur
2127 * @return null|string
2128 *              Rien dans la plupart des cas
2129 *              - string si $message à false.
2130**/
2131function erreur_squelette($message='', $lieu='') {
2132        $debusquer = charger_fonction('debusquer', 'public');
2133        if (is_array($lieu)) {
2134                include_spip('public/compiler');
2135                $lieu = reconstruire_contexte_compil($lieu);
2136        }
2137        return $debusquer($message, $lieu);
2138}
2139
2140/**
2141 * Calcule un squelette avec un contexte et retourne son contenu
2142 *
2143 * La fonction de base de SPIP : un squelette + un contexte => une page.
2144 * $fond peut etre un nom de squelette, ou une liste de squelette au format array.
2145 * Dans ce dernier cas, les squelettes sont tous evalues et mis bout a bout
2146 * $options permet de selectionner les options suivantes :
2147 *      trim => true (valeur par defaut) permet de ne rien renvoyer si le fond ne produit que des espaces ;
2148 *      raw  => true permet de recuperer la strucure $page complete avec entetes et invalideurs
2149 *          pour chaque $fond fourni.
2150 *
2151 * @api
2152 * @param string/array $fond
2153 *              Le ou les squelettes à utiliser, sans l'extension, {@example prive/liste/auteurs}
2154 *              Le fichier sera retrouvé dans la liste des chemins connus de SPIP (squelettes, plugins, spip)
2155 * @param array $contexte
2156 *              Informations de contexte envoyées au squelette, {@example array('id_rubrique' => 8)}
2157 *              La langue est transmise automatiquement (sauf option étoile).
2158 * @param array $options
2159 *              Options complémentaires :
2160 *              - trim   : applique un trim sur le résultat (true par défaut)
2161 *              - raw    : retourne un tableau d'information sur le squelette (false par défaut)
2162 *              - etoile : ne pas transmettre la langue au contexte automatiquement (false par défaut),
2163 *                         équivalent de INCLURE*
2164 *              - ajax   : gere les liens internes du squelette en ajax (équivalent du paramètre {ajax})
2165 * @param string $connect
2166 *              Non du connecteur de bdd a utiliser
2167 * @return string|array
2168 *              Contenu du squelette calculé
2169 *              ou tableau d'information sur le squelette.
2170 */
2171function recuperer_fond($fond, $contexte=array(), $options = array(), $connect='') {
2172        if (!function_exists('evaluer_fond'))
2173                include_spip('public/assembler');
2174        // assurer la compat avec l'ancienne syntaxe
2175        // (trim etait le 3eme argument, par defaut a true)
2176        if (!is_array($options)) $options = array('trim'=>$options);
2177        if (!isset($options['trim'])) $options['trim']=true;
2178
2179        if (isset($contexte['connect'])){
2180                $connect = ($connect ? $connect : $contexte['connect']);
2181                unset($contexte['connect']);
2182        }
2183
2184        $texte = "";
2185        $pages = array();
2186        $lang_select = '';
2187        if (!isset($options['etoile']) OR !$options['etoile']){
2188                // Si on a inclus sans fixer le critere de lang, on prend la langue courante
2189                if (!isset($contexte['lang']))
2190                        $contexte['lang'] = $GLOBALS['spip_lang'];
2191
2192                if ($contexte['lang'] != $GLOBALS['meta']['langue_site']) {
2193                        $lang_select = lang_select($contexte['lang']);
2194                }
2195        }
2196
2197        @$GLOBALS['_INC_PUBLIC']++;
2198
2199        // fix #4235 : on mémorise l'état initial du sessionnement du contexte incluant
2200        $cache_utilise_session_appelant = (isset($GLOBALS['cache_utilise_session']) ? $GLOBALS['cache_utilise_session'] : null);
2201
2202        foreach(is_array($fond) ? $fond : array($fond) as $f){
2203
2204                // fix #4235 :
2205                unset($GLOBALS['cache_utilise_session']); // fix #4235 : Chaque inclusion commence sans sessionnement préallable
2206
2207                $page = evaluer_fond($f, $contexte, $connect);
2208                if ($page === '') {
2209                        $c = isset($options['compil']) ? $options['compil'] :'';
2210                        $a = array('fichier'=>$fond);
2211                        $erreur = _T('info_erreur_squelette2', $a); // squelette introuvable
2212                        erreur_squelette($erreur, $c);
2213                        // eviter des erreurs strictes ensuite sur $page['cle'] en PHP >= 5.4
2214                        $page = array('texte' => '', 'erreur' => $erreur);
2215                }
2216
2217                $page = pipeline('recuperer_fond',array(
2218                        'args'=>array('fond'=>$f,'contexte'=>$contexte,'options'=>$options,'connect'=>$connect),
2219                        'data'=>$page
2220                ));
2221                if (isset($options['ajax']) AND $options['ajax']){
2222                        if (!function_exists('encoder_contexte_ajax'))
2223                                include_spip('inc/filtres');
2224                        $page['texte'] = encoder_contexte_ajax(array_merge($contexte,array('fond'=>$f)),'',$page['texte'], $options['ajax']);
2225                }
2226
2227                if (isset($options['raw']) AND $options['raw'])
2228                        $pages[] = $page;
2229                else
2230                        $texte .= $options['trim'] ? rtrim($page['texte']) : $page['texte'];
2231
2232                // fix #4235 : contamination de la session appelante, pour les inclusions statiques
2233                if (isset($options['sessionnement_contaminant'])
2234                        and isset($page['invalideurs']['session']))
2235                        $cache_utilise_session_appelant = $page['invalideurs']['session'];
2236
2237        }
2238
2239        // fix #4235 : restaurer le sessionnement du contexte appelant,
2240        // éventuellement contaminé si on vient de récupérer une inclusion statique sessionnée
2241        $GLOBALS['cache_utilise_session']
2242                = (isset($cache_utilise_session_appelant) ? $cache_utilise_session_appelant : null);
2243
2244        $GLOBALS['_INC_PUBLIC']--;
2245
2246        if ($lang_select) lang_select();
2247        if (isset($options['raw']) AND $options['raw'])
2248                return is_array($fond)?$pages:reset($pages);
2249        else
2250                return $options['trim'] ? ltrim($texte) : $texte;
2251}
2252
2253/**
2254 * Trouve un squelette dans le repertoire modeles/
2255 *
2256 * @param  $nom
2257 * @return string
2258 */
2259function trouve_modele($nom) {
2260        return trouver_fond($nom,'modeles/');
2261}
2262
2263/**
2264 * Trouver un squelette dans le chemin
2265 * on peut specifier un sous-dossier dans $dir
2266 * si $pathinfo est a true, retourne un tableau avec
2267 * les composantes du fichier trouve
2268 * + le chemin complet sans son extension dans fond
2269 *
2270 * @param string $nom
2271 * @param string $dir
2272 * @param bool $pathinfo
2273 * @return array|string
2274 */
2275function trouver_fond($nom, $dir='', $pathinfo = false) {
2276        $f = find_in_path($nom.'.'. _EXTENSION_SQUELETTES, $dir?rtrim($dir,'/').'/':'');
2277        if (!$pathinfo) return $f;
2278        // renvoyer un tableau detaille si $pathinfo==true
2279        $p = pathinfo($f);
2280        if (!isset($p['extension']) OR !$p['extension']) {
2281                $p['extension'] = _EXTENSION_SQUELETTES;
2282        }
2283        if (!isset($p['extension']) OR !$p['filename']) {
2284                $p['filename'] = ($p['basename']?substr($p['basename'],0,-strlen($p['extension'])-1):'');
2285        }
2286        $p['fond'] = ($f?substr($f,0,-strlen($p['extension'])-1):'');
2287        return $p;
2288}
2289
2290function tester_url_ecrire($nom){
2291        static $exec=array();
2292        if (isset($exec[$nom])) return $exec[$nom];
2293        // tester si c'est une page en squelette
2294        if (trouver_fond($nom, 'prive/squelettes/contenu/'))
2295                return $exec[$nom] = 'fond';
2296        // compat skels orthogonaux version precedente
2297        elseif (trouver_fond($nom, 'prive/exec/'))
2298                return $exec[$nom] = 'fond_monobloc';
2299        // echafaudage d'un fond !
2300        elseif(include_spip('public/styliser_par_z') AND z_echafaudable($nom))
2301                return $exec[$nom] = 'fond';
2302        // attention, il ne faut pas inclure l'exec ici
2303        // car sinon #URL_ECRIRE provoque des inclusions
2304        // et des define intrusifs potentiels
2305        return $exec[$nom] = ((find_in_path("{$nom}.php",'exec/') OR charger_fonction($nom,'exec',true))?$nom:'');
2306}
2307
2308// Charger dynamiquement une extension php
2309// http://doc.spip.org/@charger_php_extension
2310function charger_php_extension($module) {
2311        if (extension_loaded($module)) {
2312                return true;
2313        } else {
2314                $charger_php_extension = charger_fonction('charger_php_extension','inc');
2315                return $charger_php_extension($module);
2316        }
2317}
2318
2319// Renvoie TRUE si et seulement si la configuration autorise
2320// le code HTML5 sur le site public
2321function html5_permis() {
2322        return (isset($GLOBALS['meta']['version_html_max'])
2323                AND ('html5' == $GLOBALS['meta']['version_html_max']));
2324}
2325
2326/*
2327 * Bloc de compatibilite : quasiment tous les plugins utilisent ces fonctions
2328 * desormais depreciees ; plutot que d'obliger tout le monde a charger
2329 * vieilles_defs, on va assumer l'histoire de ces 3 fonctions ubiquitaires
2330 */
2331// Fonction depreciee
2332// http://doc.spip.org/@lire_meta
2333function lire_meta($nom) {
2334        return $GLOBALS['meta'][$nom];
2335}
2336
2337// Fonction depreciee
2338// http://doc.spip.org/@ecrire_metas
2339function ecrire_metas() {}
2340
2341// Fonction depreciee, cf. http://doc.spip.org/@sql_fetch
2342// http://doc.spip.org/@spip_fetch_array
2343function spip_fetch_array($r, $t=NULL) {
2344        if (!isset($t)) {
2345                if ($r) return sql_fetch($r);
2346        } else {
2347                if ($t=='SPIP_NUM') $t = MYSQL_NUM;
2348                if ($t=='SPIP_BOTH') $t = MYSQL_BOTH;
2349                if ($t=='SPIP_ASSOC') $t = MYSQL_ASSOC;
2350                spip_log("appel deprecie de spip_fetch_array(..., $t)", 'vieilles_defs');
2351                if ($r) return mysql_fetch_array($r, $t);
2352        }
2353}
2354
2355/**
2356 * Poser une alerte qui sera affiche aux auteurs de bon statut ('' = tous)
2357 * au prochain passage dans l'espace prive
2358 * chaque alerte doit avoir un nom pour eviter duplication a chaque hit
2359 * les alertes affichees une fois sont effacees
2360 *
2361 * @param string $nom
2362 * @param string $message
2363 * @param string $statut
2364 */
2365function avertir_auteurs($nom,$message, $statut=''){
2366        $alertes = $GLOBALS['meta']['message_alertes_auteurs'];
2367        if (!$alertes
2368                OR !is_array($alertes = unserialize($alertes)))
2369                $alertes = array();
2370
2371        if (!isset($alertes[$statut]))
2372                $alertes[$statut] = array();
2373        $alertes[$statut][$nom] = $message;
2374        ecrire_meta("message_alertes_auteurs",serialize($alertes));
2375}
2376?>
Note: See TracBrowser for help on using the repository browser.