source: spip-zone/_plugins_/cachefix/trunk/inc/utils.fix.3.1.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: 95.7 KB
Line 
1<?php
2
3/***************************************************************************\
4 *  SPIP, Systeme de publication pour l'internet                           *
5 *                                                                         *
6 *  Copyright (c) 2001-2019                                                *
7 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
8 *                                                                         *
9 *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
10 *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
11\***************************************************************************/
12
13/**
14 * Utilitaires indispensables autour du serveur Http.
15 *
16 * @package SPIP\Core\Utilitaires
17 **/
18
19if (!defined('_ECRIRE_INC_VERSION')) {
20        return;
21}
22
23
24/**
25 * Cherche une fonction surchargeable et en retourne le nom exact,
26 * après avoir chargé le fichier la contenant si nécessaire.
27 *
28 * Charge un fichier (suivant les chemins connus) et retourne si elle existe
29 * le nom de la fonction homonyme `$dir_$nom`, ou suffixé `$dir_$nom_dist`
30 *
31 * Peut être appelé plusieurs fois, donc optimisé.
32 *
33 * @api
34 * @uses include_spip() Pour charger le fichier
35 * @example
36 *     ```
37 *     $envoyer_mail = charger_fonction('envoyer_mail', 'inc');
38 *     $envoyer_mail($email, $sujet, $texte);
39 *     ```
40 *
41 * @param string $nom
42 *     Nom de la fonction (et du fichier)
43 * @param string $dossier
44 *     Nom du dossier conteneur
45 * @param bool $continue
46 *     true pour ne pas râler si la fonction n'est pas trouvée
47 * @return string
48 *     Nom de la fonction, ou false.
49 */
50function charger_fonction($nom, $dossier = 'exec', $continue = false) {
51        static $echecs = array();
52
53        if (strlen($dossier) and substr($dossier, -1) != '/') {
54                $dossier .= '/';
55        }
56        $f = str_replace('/', '_', $dossier) . $nom;
57
58        if (function_exists($f)) {
59                return $f;
60        }
61        if (function_exists($g = $f . '_dist')) {
62                return $g;
63        }
64
65        if (isset($echecs[$f])) {
66                return $echecs[$f];
67        }
68        // Sinon charger le fichier de declaration si plausible
69
70        if (!preg_match(',^\w+$,', $f)) {
71                if ($continue) {
72                        return false;
73                } //appel interne, on passe
74                include_spip('inc/minipres');
75                echo minipres();
76                exit;
77        }
78
79        // passer en minuscules (cf les balises de formulaires)
80        // et inclure le fichier
81        if (!$inc = include_spip($dossier . ($d = strtolower($nom)))
82                // si le fichier truc/machin/nom.php n'existe pas,
83                // la fonction peut etre definie dans truc/machin.php qui regroupe plusieurs petites fonctions
84                and strlen(dirname($dossier)) and dirname($dossier) != '.'
85        ) {
86                include_spip(substr($dossier, 0, -1));
87        }
88        if (function_exists($f)) {
89                return $f;
90        }
91        if (function_exists($g)) {
92                return $g;
93        }
94
95        if ($continue) {
96                return $echecs[$f] = false;
97        }
98
99        // Echec : message d'erreur
100        spip_log("fonction $nom ($f ou $g) indisponible" .
101                ($inc ? "" : " (fichier $d absent de $dossier)"));
102
103        include_spip('inc/minipres');
104        echo minipres(_T('forum_titre_erreur'),
105                _T('fichier_introuvable', array('fichier' => '<b>' . spip_htmlentities($d) . '</b>')),
106                array('all_inline'=>true,'status'=>404));
107        exit;
108}
109
110/**
111 * Inclusion unique avec verification d'existence du fichier + log en crash sinon
112 *
113 * @param string $file
114 * @return bool
115 */
116function include_once_check($file) {
117        if (file_exists($file)) {
118                include_once $file;
119
120                return true;
121        }
122        $crash = (isset($GLOBALS['meta']['message_crash_plugins']) ? unserialize($GLOBALS['meta']['message_crash_plugins']) : '');
123        $crash = ($crash ? $crash : array());
124        $crash[$file] = true;
125        ecrire_meta('message_crash_plugins', serialize($crash));
126
127        return false;
128}
129
130
131/**
132 * Inclut un fichier PHP (en le cherchant dans les chemins)
133 *
134 * @api
135 * @uses find_in_path()
136 * @example
137 *     ```
138 *     include_spip('inc/texte');
139 *     ```
140 *
141 * @param string $f
142 *     Nom du fichier (sans l'extension)
143 * @param bool $include
144 *     - true pour inclure le fichier,
145 *     - false ne fait que le chercher
146 * @return string|bool
147 *     - false : fichier introuvable
148 *     - string : chemin du fichier trouvé
149 **/
150function include_spip($f, $include = true) {
151        return find_in_path($f . '.php', '', $include);
152}
153
154/**
155 * Requiert un fichier PHP (en le cherchant dans les chemins)
156 *
157 * @uses find_in_path()
158 * @see  include_spip()
159 * @example
160 *     ```
161 *     require_spip('inc/texte');
162 *     ```
163 *
164 * @param string $f
165 *     Nom du fichier (sans l'extension)
166 * @return string|bool
167 *     - false : fichier introuvable
168 *     - string : chemin du fichier trouvé
169 **/
170function require_spip($f) {
171        return find_in_path($f . '.php', '', 'required');
172}
173
174/**
175 * Exécute une fonction (appellée par un pipeline) avec la donnée transmise.
176 *
177 * Un pipeline est lie a une action et une valeur
178 * chaque element du pipeline est autorise a modifier la valeur
179 * le pipeline execute les elements disponibles pour cette action,
180 * les uns apres les autres, et retourne la valeur finale
181 *
182 * Cf. compose_filtres dans references.php, qui est la
183 * version compilee de cette fonctionnalite
184 * appel unitaire d'une fonction du pipeline
185 * utilisee dans le script pipeline precompile
186 *
187 * on passe $val par reference pour limiter les allocations memoire
188 *
189 * @param string $fonc
190 *     Nom de la fonction appelée par le pipeline
191 * @param string|array $val
192 *     Les paramètres du pipeline, son environnement
193 * @return string|array $val
194 *     Les paramètres du pipeline modifiés
195 **/
196function minipipe($fonc, &$val) {
197        // fonction
198        if (function_exists($fonc)) {
199                $val = call_user_func($fonc, $val);
200        } // Class::Methode
201        else {
202                if (preg_match("/^(\w*)::(\w*)$/S", $fonc, $regs)
203                        and $methode = array($regs[1], $regs[2])
204                        and is_callable($methode)
205                ) {
206                        $val = call_user_func($methode, $val);
207                } else {
208                        spip_log("Erreur - '$fonc' non definie !");
209                }
210        }
211
212        return $val;
213}
214
215// chargement du pipeline sous la forme d'un fichier php prepare
216// http://code.spip.net/@pipeline
217function pipeline($action, $val = null) {
218        static $charger;
219
220        // chargement initial des fonctions mises en cache, ou generation du cache
221        if (!$charger) {
222                if (!($ok = @is_readable($charger = _CACHE_PIPELINES))) {
223                        include_spip('inc/plugin');
224                        // generer les fichiers php precompiles
225                        // de chargement des plugins et des pipelines
226                        actualise_plugins_actifs();
227                        if (!($ok = @is_readable($charger))) {
228                                spip_log("fichier $charger pas cree");
229                        }
230                }
231
232                if ($ok) {
233                        include_once $charger;
234                }
235        }
236
237        // appliquer notre fonction si elle existe
238        $fonc = 'execute_pipeline_' . strtolower($action);
239        if (function_exists($fonc)) {
240                $val = $fonc($val);
241        } // plantage ?
242        else {
243                spip_log("fonction $fonc absente : pipeline desactive", _LOG_ERREUR);
244        }
245
246        // si le flux est une table avec 2 cle args&data
247        // on ne ressort du pipe que les donnees dans 'data'
248        // array_key_exists pour php 4.1.0
249        if (is_array($val)
250                and count($val) == 2
251                and (array_key_exists('data', $val))
252        ) {
253                $val = $val['data'];
254        }
255
256        return $val;
257}
258
259/**
260 * Enregistrement des événements
261 *
262 * Signature : `spip_log(message[,niveau|type|type.niveau])`
263 *
264 * Le niveau de log par défaut est la valeur de la constante `_LOG_INFO`
265 *
266 * Les différents niveaux possibles sont :
267 *
268 * - `_LOG_HS` : écrira 'HS' au début de la ligne logguée
269 * - `_LOG_ALERTE_ROUGE` : 'ALERTE'
270 * - `_LOG_CRITIQUE` :  'CRITIQUE'
271 * - `_LOG_ERREUR` : 'ERREUR'
272 * - `_LOG_AVERTISSEMENT` : 'WARNING'
273 * - `_LOG_INFO_IMPORTANTE` : '!INFO'
274 * - `_LOG_INFO` : 'info'
275 * - `_LOG_DEBUG` : 'debug'
276 *
277 * @example
278 *   ```
279 *   spip_log($message)
280 *   spip_log($message, 'recherche')
281 *   spip_log($message, _LOG_DEBUG)
282 *   spip_log($message, 'recherche.'._LOG_DEBUG)
283 *   ```
284 *
285 * @api
286 * @link http://programmer.spip.net/spip_log
287 * @uses inc_log_dist()
288 *
289 * @param string $message
290 *     Message à loger
291 * @param string|int $name
292 *
293 *     - int indique le niveau de log, tel que `_LOG_DEBUG`
294 *     - string indique le type de log
295 *     - `string.int` indique les 2 éléments.
296 *     Cette dernière notation est controversée mais le 3ème
297 *     paramètre est planté pour cause de compatibilité ascendante.
298 */
299function spip_log($message = null, $name = null) {
300        static $pre = array();
301        static $log;
302        preg_match('/^([a-z_]*)\.?(\d)?$/iS', (string)$name, $regs);
303        if (!isset($regs[1]) or !$logname = $regs[1]) {
304                $logname = null;
305        }
306        if (!isset($regs[2]) or !$niveau = $regs[2]) {
307                $niveau = _LOG_INFO;
308        }
309
310        if ($niveau <= (defined('_LOG_FILTRE_GRAVITE') ? _LOG_FILTRE_GRAVITE : _LOG_INFO_IMPORTANTE)) {
311                if (!$pre) {
312                        $pre = array(
313                                _LOG_HS => 'HS:',
314                                _LOG_ALERTE_ROUGE => 'ALERTE:',
315                                _LOG_CRITIQUE => 'CRITIQUE:',
316                                _LOG_ERREUR => 'ERREUR:',
317                                _LOG_AVERTISSEMENT => 'WARNING:',
318                                _LOG_INFO_IMPORTANTE => '!INFO:',
319                                _LOG_INFO => 'info:',
320                                _LOG_DEBUG => 'debug:'
321                        );
322                        $log = charger_fonction('log', 'inc');
323                }
324                if (!is_string($message)) {
325                        $message = print_r($message, true);
326                }
327                $log($pre[$niveau] . ' ' . $message, $logname);
328        }
329}
330
331/**
332 * Enregistrement des journaux
333 *
334 * @uses inc_journal_dist()
335 * @param string $phrase Texte du journal
336 * @param array $opt Tableau d'options
337 **/
338function journal($phrase, $opt = array()) {
339        $journal = charger_fonction('journal', 'inc');
340        $journal($phrase, $opt);
341}
342
343
344/**
345 * Renvoie le `$_GET` ou le `$_POST` émis par l'utilisateur
346 * ou pioché dans un tableau transmis
347 *
348 * @api
349 * @param string $var
350 *     Clé souhaitée
351 * @param bool|array $c
352 *     Tableau transmis (sinon cherche dans GET ou POST)
353 * @return mixed|null
354 *     - null si la clé n'a pas été trouvée
355 *     - la valeur de la clé sinon.
356 **/
357function _request($var, $c = false) {
358
359        if (is_array($c)) {
360                return isset($c[$var]) ? $c[$var] : null;
361        }
362
363        if (isset($_GET[$var])) {
364                $a = $_GET[$var];
365        } elseif (isset($_POST[$var])) {
366                $a = $_POST[$var];
367        } else {
368                return null;
369        }
370
371        // Si on est en ajax et en POST tout a ete encode
372        // via encodeURIComponent, il faut donc repasser
373        // dans le charset local...
374        if (defined('_AJAX')
375                and _AJAX
376                and isset($GLOBALS['meta']['charset'])
377                and $GLOBALS['meta']['charset'] != 'utf-8'
378                and is_string($a)
379                // check rapide mais pas fiable
380                and preg_match(',[\x80-\xFF],', $a)
381                // check fiable
382                and include_spip('inc/charsets')
383                and is_utf8($a)
384        ) {
385                return importer_charset($a, 'utf-8');
386        }
387
388        return $a;
389}
390
391
392/**
393 * Affecte une valeur à une clé (pour usage avec `_request()`)
394 *
395 * @see _request() Pour obtenir la valeur
396 * @note Attention au cas ou l'on fait `set_request('truc', NULL);`
397 *
398 * @param string $var Nom de la clé
399 * @param string $val Valeur à affecter
400 * @param bool|array $c Tableu de données (sinon utilise `$_GET` et `$_POST`)
401 * @return array|bool
402 *     - array $c complété si un $c est transmis,
403 *     - false sinon
404 **/
405function set_request($var, $val = null, $c = false) {
406        if (is_array($c)) {
407                unset($c[$var]);
408                if ($val !== null) {
409                        $c[$var] = $val;
410                }
411
412                return $c;
413        }
414
415        unset($_GET[$var]);
416        unset($_POST[$var]);
417        if ($val !== null) {
418                $_GET[$var] = $val;
419        }
420
421        return false; # n'affecte pas $c
422}
423
424
425/**
426 * Tester si une URL est absolue
427 *
428 * On est sur le web, on exclut certains protocoles,
429 * notamment 'file://', 'php://' et d'autres…
430
431 * @param string $url
432 * @return bool
433 */
434function tester_url_absolue($url) {
435        $url = trim($url);
436        if (preg_match(";^([a-z]{3,7}:)?//;Uims", $url, $m)) {
437                if (
438                        isset($m[1])
439                        and $p = strtolower(rtrim($m[1], ':'))
440                        and in_array($p, array('file', 'php', 'zlib', 'glob', 'phar', 'ssh2', 'rar', 'ogg', 'expect', 'zip'))
441                  ) {
442                        return false;
443                }
444                return true;
445        }
446        return false;
447}
448
449/**
450 * Prend une URL et lui ajoute/retire un paramètre
451 *
452 * @filtre
453 * @link http://www.spip.net/4255
454 * @example
455 *     ```
456 *     [(#SELF|parametre_url{suite,18})] (ajout)
457 *     [(#SELF|parametre_url{suite,''})] (supprime)
458 *     [(#SELF|parametre_url{suite[],1})] (tableaux valeurs multiples)
459 *     ```
460 *
461 * @param string $url URL
462 * @param string $c Nom du paramètre
463 * @param string|array|null $v Valeur du paramètre
464 * @param string $sep Séparateur entre les paramètres
465 * @return string URL
466 */
467function parametre_url($url, $c, $v = null, $sep = '&amp;') {
468        // requete erronnee : plusieurs variable dans $c et aucun $v
469        if (strpos($c, "|") !== false and is_null($v)) {
470                return null;
471        }
472
473        // lever l'#ancre
474        if (preg_match(',^([^#]*)(#.*)$,', $url, $r)) {
475                $url = $r[1];
476                $ancre = $r[2];
477        } else {
478                $ancre = '';
479        }
480
481        // eclater
482        $url = preg_split(',[?]|&amp;|&,', $url);
483
484        // recuperer la base
485        $a = array_shift($url);
486        if (!$a) {
487                $a = './';
488        }
489
490        $regexp = ',^(' . str_replace('[]', '\[\]', $c) . '[[]?[]]?)(=.*)?$,';
491        $ajouts = array_flip(explode('|', $c));
492        $u = is_array($v) ? $v : rawurlencode($v);
493        $testv = (is_array($v) ? count($v) : strlen($v));
494        $v_read = null;
495        // lire les variables et agir
496        foreach ($url as $n => $val) {
497                if (preg_match($regexp, urldecode($val), $r)) {
498                        $r = array_pad($r, 3, null);
499                        if ($v === null) {
500                                // c'est un tableau, on memorise les valeurs
501                                if (substr($r[1], -2) == "[]") {
502                                        if (!$v_read) {
503                                                $v_read = array();
504                                        }
505                                        $v_read[] = $r[2] ? substr($r[2], 1) : '';
506                                } // c'est un scalaire, on retourne direct
507                                else {
508                                        return $r[2] ? substr($r[2], 1) : '';
509                                }
510                        } // suppression
511                        elseif (!$testv) {
512                                unset($url[$n]);
513                        }
514                        // Ajout. Pour une variable, remplacer au meme endroit,
515                        // pour un tableau ce sera fait dans la prochaine boucle
516                        elseif (substr($r[1], -2) != '[]') {
517                                $url[$n] = $r[1] . '=' . $u;
518                                unset($ajouts[$r[1]]);
519                        }
520                        // Pour les tableaux on laisse tomber les valeurs de
521                        // départ, on remplira à l'étape suivante
522                        else {
523                                unset($url[$n]);
524                        }
525                }
526        }
527
528        // traiter les parametres pas encore trouves
529        if ($v === null
530                and $args = func_get_args()
531                and count($args) == 2
532        ) {
533                return $v_read; // rien trouve ou un tableau
534        } elseif ($testv) {
535                foreach ($ajouts as $k => $n) {
536                        if (!is_array($v)) {
537                                $url[] = $k . '=' . $u;
538                        } else {
539                                $id = (substr($k, -2) == '[]') ? $k : ($k . "[]");
540                                foreach ($v as $w) {
541                                        $url[] = $id . '=' . (is_array($w) ? 'Array' : $w);
542                                }
543                        }
544                }
545        }
546
547        // eliminer les vides
548        $url = array_filter($url);
549
550        // recomposer l'adresse
551        if ($url) {
552                $a .= '?' . join($sep, $url);
553        }
554
555        return $a . $ancre;
556}
557
558// Prend une URL et lui ajoute/retire une ancre apres l'avoir nettoyee
559// pour l'ancre on translitere, vire les non alphanum du debut,
560// et on remplace ceux a l'interieur ou au bout par -
561// http://code.spip.net/@ancre_url
562function ancre_url($url, $ancre) {
563        // lever l'#ancre
564        if (preg_match(',^([^#]*)(#.*)$,', $url, $r)) {
565                $url = $r[1];
566        }
567        if (preg_match('/[^-_a-zA-Z0-9]+/S', $ancre)) {
568                if (!function_exists('translitteration')) {
569                        include_spip('inc/charsets');
570                }
571                $ancre = preg_replace(array('/^[^-_a-zA-Z0-9]+/', '/[^-_a-zA-Z0-9]/'), array('', '-'),
572                        translitteration($ancre));
573        }
574
575        return $url . (strlen($ancre) ? '#' . $ancre : '');
576}
577
578/**
579 * Pour le nom du cache, les `types_urls` et `self`
580 *
581 * @param string|null $reset
582 * @return string
583 */
584function nettoyer_uri($reset = null) {
585        static $done = false;
586        static $propre = '';
587        if (!is_null($reset)) {
588                return $propre = $reset;
589        }
590        if ($done) {
591                return $propre;
592        }
593        $done = true;
594
595        $uri1 = $GLOBALS['REQUEST_URI'];
596        do {
597                $uri = $uri1;
598                $uri1 = preg_replace(',([?&])(PHPSESSID|(var_[^=&]*))=[^&]*(&|$),i',
599                        '\1', $uri);
600        } while ($uri <> $uri1);
601
602        return $propre = (preg_replace(',[?&]$,', '', $uri1));
603}
604
605
606/**
607 * Donner l'URL de base d'un lien vers "soi-meme", modulo les trucs inutiles
608 *
609 * @param string $amp
610 *    Style des esperluettes
611 * @param bool $root
612 * @return string
613 *    URL vers soi-même
614 **/
615function self($amp = '&amp;', $root = false) {
616        $url = nettoyer_uri();
617        if (!$root
618                and (
619                        // si pas de profondeur on peut tronquer
620                        $GLOBALS['profondeur_url'] < (_DIR_RESTREINT ? 1 : 2)
621                        // sinon c'est OK si _SET_HTML_BASE a ete force a false
622                        or (defined('_SET_HTML_BASE') and !_SET_HTML_BASE))
623        ) {
624                $url = preg_replace(',^[^?]*/,', '', $url);
625        }
626        // ajouter le cas echeant les variables _POST['id_...']
627        foreach ($_POST as $v => $c) {
628                if (substr($v, 0, 3) == 'id_') {
629                        $url = parametre_url($url, $v, $c, '&');
630                }
631        }
632
633        // supprimer les variables sans interet
634        if (test_espace_prive()) {
635                $url = preg_replace(',([?&])('
636                        . 'lang|show_docs|'
637                        . 'changer_lang|var_lang|action)=[^&]*,i', '\1', $url);
638                $url = preg_replace(',([?&])[&]+,', '\1', $url);
639                $url = preg_replace(',[&]$,', '\1', $url);
640        }
641
642        // eviter les hacks
643        include_spip('inc/filtres_mini');
644        $url = spip_htmlspecialchars($url);
645       
646        $url = str_replace(array("'", '"', '<', '[', ']'), array('%27', '%22', '%3C', '%5B', '%5D'), $url);
647
648        // &amp; ?
649        if ($amp != '&amp;') {
650                $url = str_replace('&amp;', $amp, $url);
651        }
652
653        // Si ca demarre par ? ou vide, donner './'
654        $url = preg_replace(',^([?].*)?$,', './\1', $url);
655
656        return $url;
657}
658
659
660/**
661 * Indique si on est dans l'espace prive
662 *
663 * @return bool
664 *     true si c'est le cas, false sinon.
665 */
666function test_espace_prive() {
667        return defined('_ESPACE_PRIVE') ? _ESPACE_PRIVE : false;
668}
669
670/**
671 * Vérifie la présence d'un plugin actif, identifié par son préfixe
672 *
673 * @param string $plugin
674 * @return bool
675 */
676function test_plugin_actif($plugin) {
677        return ($plugin and defined('_DIR_PLUGIN_' . strtoupper($plugin))) ? true : false;
678}
679
680/**
681 * Traduction des textes de SPIP
682 *
683 * Traduit une clé de traduction en l'obtenant dans les fichiers de langues.
684 *
685 * @api
686 * @uses inc_traduire_dist()
687 * @uses _L()
688 * @example
689 *     ```
690 *     _T('bouton_enregistrer')
691 *     _T('medias:image_tourner_droite')
692 *     _T('medias:erreurs', array('nb'=>3))
693 *     _T("email_sujet", array('spip_lang'=>$lang_usager))
694 *     ```
695 *
696 * @param string $texte
697 *     Clé de traduction
698 * @param array $args
699 *     Couples (variable => valeur) pour passer des variables à la chaîne traduite. la variable spip_lang permet de forcer la langue
700 * @param array $options
701 *     - string class : nom d'une classe a ajouter sur un span pour encapsuler la chaine
702 *     - bool force : forcer un retour meme si la chaine n'a pas de traduction
703 *     - bool sanitize : nettoyer le html suspect dans les arguments
704 * @return string
705 *     Texte
706 */
707function _T($texte, $args = array(), $options = array()) {
708        static $traduire = false;
709        $o = array('class' => '', 'force' => true, 'sanitize' => true);
710        if ($options) {
711                // support de l'ancien argument $class
712                if (is_string($options)) {
713                        $options = array('class' => $options);
714                }
715                $o = array_merge($o, $options);
716        }
717
718        if (!$traduire) {
719                $traduire = charger_fonction('traduire', 'inc');
720                include_spip('inc/lang');
721        }
722
723        // On peut passer explicitement la langue dans le tableau
724        // On utilise le même nom de variable que la globale
725        if (isset($args['spip_lang'])) {
726                $lang = $args['spip_lang'];
727                // On l'enleve pour ne pas le passer au remplacement
728                unset($args['spip_lang']);
729        } // Sinon on prend la langue du contexte
730        else {
731                $lang = $GLOBALS['spip_lang'];
732        }
733        $text = $traduire($texte, $lang);
734
735        if (!strlen($text)) {
736                if (!$o['force']) {
737                        return '';
738                }
739
740                $text = $texte;
741
742                // pour les chaines non traduites, assurer un service minimum
743                if (!$GLOBALS['test_i18n'] and (_request('var_mode') != 'traduction')) {
744                        $text = str_replace('_', ' ',
745                                (($n = strpos($text, ':')) === false ? $texte :
746                                        substr($texte, $n + 1)));
747                }
748                $o['class'] = null;
749
750        }
751
752        return _L($text, $args, $o);
753
754}
755
756
757/**
758 * Remplace les variables `@...@` par leur valeur dans une chaîne de langue.
759 *
760 * Cette fonction est également appelée dans le code source de SPIP quand une
761 * chaîne n'est pas encore dans les fichiers de langue.
762 *
763 * @see _T()
764 * @example
765 *     ```
766 *     _L('Texte avec @nb@ ...', array('nb'=>3)
767 *     ```
768 *
769 * @param string $text
770 *     Texte
771 * @param array $args
772 *     Couples (variable => valeur) à transformer dans le texte
773 * @param array $options
774 *     - string class : nom d'une classe a ajouter sur un span pour encapsuler la chaine
775 *     - bool sanitize : nettoyer le html suspect dans les arguments
776 * @return string
777 *     Texte
778 */
779function _L($text, $args = array(), $options = array()) {
780        $f = $text;
781        $defaut_options = array(
782                'class' => null,
783                'sanitize' => true,
784        );
785        // support de l'ancien argument $class
786        if ($options and is_string($options)) {
787                $options = array('class' => $options);
788        }
789        if (is_array($options)) {
790                $options += $defaut_options;
791        } else {
792                $options = $defaut_options;
793        }
794
795        if (is_array($args)) {
796                if (!function_exists('interdire_scripts')) {
797                        include_spip('inc/texte');
798                }
799                if (!function_exists('echapper_html_suspect')) {
800                        include_spip('inc/texte_mini');
801                }
802                foreach ($args as $name => $value) {
803                        if ($options['sanitize']) {
804                                $value = echapper_html_suspect($value);
805                                $value = interdire_scripts($value, -1);
806                        }
807                        if (!empty($options['class'])) {
808                                $value = "<span class='".$options['class']."'>$value</span>";
809                        }
810                        $t = str_replace("@$name@", $value, $text);
811                        if ($text !== $t) {
812                                unset($args[$name]);
813                                $text = $t;
814                        }
815                }
816                // Si des variables n'ont pas ete inserees, le signaler
817                // (chaines de langues pas a jour)
818                if ($args) {
819                        spip_log("$f:  variables inutilisees " . join(', ', array_keys($args)), _LOG_DEBUG);
820                }
821        }
822
823        if (($GLOBALS['test_i18n'] or (_request('var_mode') == 'traduction')) and is_null($options['class'])) {
824                return "<span class=debug-traduction-erreur>$text</span>";
825        } else {
826                return $text;
827        }
828}
829
830// Afficher "ecrire/data/" au lieu de "data/" dans les messages
831// ou tmp/ au lieu de ../tmp/
832// http://code.spip.net/@joli_repertoire
833function joli_repertoire($rep) {
834        $a = substr($rep, 0, 1);
835        if ($a <> '.' and $a <> '/') {
836                $rep = (_DIR_RESTREINT ? '' : _DIR_RESTREINT_ABS) . $rep;
837        }
838        $rep = preg_replace(',(^\.\.\/),', '', $rep);
839
840        return $rep;
841}
842
843
844//
845// spip_timer : on l'appelle deux fois et on a la difference, affichable
846//
847// http://code.spip.net/@spip_timer
848function spip_timer($t = 'rien', $raw = false) {
849        static $time;
850        $a = time();
851        $b = microtime();
852        // microtime peut contenir les microsecondes et le temps
853        $b = explode(' ', $b);
854        if (count($b) == 2) {
855                $a = end($b);
856        } // plus precis !
857        $b = reset($b);
858        if (!isset($time[$t])) {
859                $time[$t] = $a + $b;
860        } else {
861                $p = ($a + $b - $time[$t]) * 1000;
862                unset($time[$t]);
863#                       echo "'$p'";exit;
864                if ($raw) {
865                        return $p;
866                }
867                if ($p < 1000) {
868                        $s = '';
869                } else {
870                        $s = sprintf("%d ", $x = floor($p / 1000));
871                        $p -= ($x * 1000);
872                }
873
874                return $s . sprintf($s ? "%07.3f ms" : "%.3f ms", $p);
875        }
876}
877
878
879// Renvoie False si un fichier n'est pas plus vieux que $duree secondes,
880// sinon renvoie True et le date sauf si ca n'est pas souhaite
881// http://code.spip.net/@spip_touch
882function spip_touch($fichier, $duree = 0, $touch = true) {
883        if ($duree) {
884                clearstatcache();
885                if ((@$f = filemtime($fichier)) and ($f >= time() - $duree)) {
886                        return false;
887                }
888        }
889        if ($touch !== false) {
890                if (!@touch($fichier)) {
891                        spip_unlink($fichier);
892                        @touch($fichier);
893                };
894                @chmod($fichier, _SPIP_CHMOD & ~0111);
895        }
896
897        return true;
898}
899
900
901/**
902 * Action qui déclenche une tache de fond
903 *
904 * @see  queue_affichage_cron()
905 * @see  action_super_cron_dist()
906 * @uses cron()
907 **/
908function action_cron() {
909        include_spip('inc/headers');
910        http_status(204); // No Content
911        header("Connection: close");
912        define('_DIRECT_CRON_FORCE', true);
913        cron();
914}
915
916/**
917 * Exécution des tâches de fond
918 *
919 * @uses inc_genie_dist()
920 *
921 * @param array $taches
922 *     Tâches forcées
923 * @param array $taches_old
924 *     Tâches forcées, pour compat avec ancienne syntaxe
925 * @return bool
926 *     True si la tache a pu être effectuée
927 */
928function cron($taches = array(), $taches_old = array()) {
929        // si pas en mode cron force, laisser tomber.
930        if (!defined('_DIRECT_CRON_FORCE')) {
931                return false;
932        }
933        if (!is_array($taches)) {
934                $taches = $taches_old;
935        } // compat anciens appels
936        // si taches a inserer en base et base inaccessible, laisser tomber
937        // sinon on ne verifie pas la connexion tout de suite, car si ca se trouve
938        // queue_sleep_time_to_next_job() dira qu'il n'y a rien a faire
939        // et on evite d'ouvrir une connexion pour rien (utilisation de _DIRECT_CRON_FORCE dans mes_options.php)
940        if ($taches and count($taches) and !spip_connect()) {
941                return false;
942        }
943        spip_log("cron !", 'jq' . _LOG_DEBUG);
944        if ($genie = charger_fonction('genie', 'inc', true)) {
945                return $genie($taches);
946        }
947
948        return false;
949}
950
951/**
952 * Ajout d'une tache dans la file d'attente
953 *
954 * @param string $function
955 *     The function name to call.
956 * @param string $description
957 *     A human-readable description of the queued job.
958 * @param array $arguments
959 *     Optional array of arguments to pass to the function.
960 * @param string $file
961 *     Optional file path which needs to be included for $function.
962 *     if ends with '/', will do charger_fonction($function,$file);
963 * @param bool $no_duplicate
964 *     If TRUE, do not add the job to the queue if one with the same function and
965 *     arguments already exists.
966 * @param int $time
967 *     time for starting the job. If 0, job will start as soon as possible
968 * @param int $priority
969 *     -10 (low priority) to +10 (high priority), 0 is the default
970 * @return int
971 *     id of the job
972 */
973function job_queue_add(
974        $function,
975        $description,
976        $arguments = array(),
977        $file = '',
978        $no_duplicate = false,
979        $time = 0,
980        $priority = 0
981) {
982        include_spip('inc/queue');
983
984        return queue_add_job($function, $description, $arguments, $file, $no_duplicate, $time, $priority);
985}
986
987/**
988 * Supprimer une tache de la file d'attente
989 *
990 * @param int $id_job
991 *  id of jonb to delete
992 * @return bool
993 */
994function job_queue_remove($id_job) {
995        include_spip('inc/queue');
996
997        return queue_remove_job($id_job);
998}
999
1000/**
1001 * Associer une tache a un/des objets de SPIP
1002 *
1003 * @param int $id_job
1004 *     id of job to link
1005 * @param array $objets
1006 *     can be a simple array('objet'=>'article', 'id_objet'=>23)
1007 *     or an array of simple array to link multiples objet in one time
1008 */
1009function job_queue_link($id_job, $objets) {
1010        include_spip('inc/queue');
1011
1012        return queue_link_job($id_job, $objets);
1013}
1014
1015
1016/**
1017 * Renvoyer le temps de repos restant jusqu'au prochain job
1018 *
1019 * @staticvar int $queue_next_job_time
1020 * @see queue_set_next_job_time()
1021 * @param int|bool $force
1022 *    Utilisée par `queue_set_next_job_time()` pour mettre à jour la valeur :
1023 *
1024 *    - si `true`, force la relecture depuis le fichier
1025 *    - si int, affecte la static directement avec la valeur
1026 * @return int
1027 *
1028 *  - `0` si un job est à traiter
1029 *  - `null` si la queue n'est pas encore initialisée
1030 */
1031function queue_sleep_time_to_next_job($force = null) {
1032        static $queue_next_job_time = -1;
1033        if ($force === true) {
1034                $queue_next_job_time = -1;
1035        } elseif ($force) {
1036                $queue_next_job_time = $force;
1037        }
1038
1039        if ($queue_next_job_time == -1) {
1040                if (!defined('_JQ_NEXT_JOB_TIME_FILENAME')) {
1041                        define('_JQ_NEXT_JOB_TIME_FILENAME', _DIR_TMP . "job_queue_next.txt");
1042                }
1043                // utiliser un cache memoire si dispo
1044                if (function_exists("cache_get") and defined('_MEMOIZE_MEMORY') and _MEMOIZE_MEMORY) {
1045                        $queue_next_job_time = cache_get(_JQ_NEXT_JOB_TIME_FILENAME);
1046                } else {
1047                        $queue_next_job_time = null;
1048                        if (lire_fichier(_JQ_NEXT_JOB_TIME_FILENAME, $contenu)) {
1049                                $queue_next_job_time = intval($contenu);
1050                        }
1051                }
1052        }
1053
1054        if (is_null($queue_next_job_time)) {
1055                return null;
1056        }
1057        if (!$_SERVER['REQUEST_TIME']) {
1058                $_SERVER['REQUEST_TIME'] = time();
1059        }
1060
1061        return $queue_next_job_time - $_SERVER['REQUEST_TIME'];
1062}
1063
1064
1065// transformation XML des "&" en "&amp;"
1066// http://code.spip.net/@quote_amp
1067function quote_amp($u) {
1068        return preg_replace(
1069                "/&(?![a-z]{0,4}\w{2,3};|#x?[0-9a-f]{2,6};)/i",
1070                "&amp;", $u);
1071}
1072
1073
1074/**
1075 * Produit une balise `<script>` valide
1076 *
1077 * @example
1078 *     ```
1079 *     echo http_script('alert("ok");');
1080 *     echo http_script('','js/jquery.js');
1081 *     ```
1082 *
1083 * @param string $script
1084 *     Code source du script
1085 * @param string $src
1086 *     Permet de faire appel à un fichier javascript distant
1087 * @param string $noscript
1088 *     Contenu de la balise  `<noscript>`
1089 * @return string
1090 *     Balise HTML `<script>` et son contenu
1091 **/
1092function http_script($script, $src = '', $noscript = '') {
1093        static $done = array();
1094
1095        if ($src && !isset($done[$src])) {
1096                $done[$src] = true;
1097                $src = find_in_path($src, _JAVASCRIPT);
1098                $src = " src='$src'";
1099        } else {
1100                $src = '';
1101        }
1102        if ($script) {
1103                $script = ("/*<![CDATA[*/\n" .
1104                        preg_replace(',</([^>]*)>,', '<\/\1>', $script) .
1105                        "/*]]>*/");
1106        }
1107        if ($noscript) {
1108                $noscript = "<noscript>\n\t$noscript\n</noscript>\n";
1109        }
1110
1111        return ($src or $script or $noscript)
1112                ? "<script type='text/javascript'$src>$script</script>$noscript"
1113                : '';
1114}
1115
1116
1117/**
1118 * Sécurise du texte à écrire dans du PHP ou du Javascript.
1119 *
1120 * Transforme n'importe quel texte en une chaîne utilisable
1121 * en PHP ou Javascript en toute sécurité, à l'intérieur d'apostrophes
1122 * simples (`'` uniquement ; pas `"`)
1123 *
1124 * Utile particulièrement en filtre dans un squelettes
1125 * pour écrire un contenu dans une variable JS ou PHP.
1126 *
1127 * Échappe les apostrophes (') du contenu transmis.
1128 *
1129 * @link http://www.spip.net/4281
1130 * @example
1131 *     PHP dans un squelette
1132 *     ```
1133 *     $x = '[(#TEXTE|texte_script)]';
1134 *     ```
1135 *
1136 *     JS dans un squelette (transmettre une chaîne de langue)
1137 *     ```
1138 *     $x = '<:afficher_calendrier|texte_script:>';
1139 *     ```
1140 *
1141 * @filtre
1142 * @param string $texte
1143 *     Texte à échapper
1144 * @return string
1145 *     Texte échappé
1146 **/
1147function texte_script($texte) {
1148        return str_replace('\'', '\\\'', str_replace('\\', '\\\\', $texte));
1149}
1150
1151
1152/**
1153 * Gestion des chemins (ou path) de recherche de fichiers par SPIP
1154 *
1155 * Empile de nouveaux chemins (à la suite de ceux déjà présents, mais avant
1156 * le répertoire `squelettes` ou les dossiers squelettes), si un répertoire
1157 * (ou liste de répertoires séparés par `:`) lui est passé en paramètre.
1158 *
1159 * Ainsi, si l'argument est de la forme `dir1:dir2:dir3`, ces 3 chemins sont placés
1160 * en tête du path, dans cet ordre (hormis `squelettes` & la globale
1161 * `$dossier_squelette` si définie qui resteront devant)
1162 *
1163 * Retourne dans tous les cas la liste des chemins.
1164 *
1165 * @note
1166 *     Cette fonction est appelée à plusieurs endroits et crée une liste
1167 *     de chemins finale à peu près de la sorte :
1168 *
1169 *     - dossiers squelettes (si globale précisée)
1170 *     - squelettes/
1171 *     - plugins (en fonction de leurs dépendances) : ceux qui dépendent
1172 *       d'un plugin sont devant eux (ils peuvent surcharger leurs fichiers)
1173 *     - racine du site
1174 *     - squelettes-dist/
1175 *     - prive/
1176 *     - ecrire/
1177 *
1178 * @param string $dir_path
1179 *     - Répertoire(s) à empiler au path
1180 *     - '' provoque un recalcul des chemins.
1181 * @return array
1182 *     Liste des chemins, par ordre de priorité.
1183 **/
1184function _chemin($dir_path = null) {
1185        static $path_base = null;
1186        static $path_full = null;
1187        if ($path_base == null) {
1188                // Chemin standard depuis l'espace public
1189                $path = defined('_SPIP_PATH') ? _SPIP_PATH :
1190                        _DIR_RACINE . ':' .
1191                        _DIR_RACINE . 'squelettes-dist/:' .
1192                        _DIR_RACINE . 'prive/:' .
1193                        _DIR_RESTREINT;
1194                // Ajouter squelettes/
1195                if (@is_dir(_DIR_RACINE . 'squelettes')) {
1196                        $path = _DIR_RACINE . 'squelettes/:' . $path;
1197                }
1198                foreach (explode(':', $path) as $dir) {
1199                        if (strlen($dir) and substr($dir, -1) != '/') {
1200                                $dir .= "/";
1201                        }
1202                        $path_base[] = $dir;
1203                }
1204                $path_full = $path_base;
1205                // Et le(s) dossier(s) des squelettes nommes
1206                if (strlen($GLOBALS['dossier_squelettes'])) {
1207                        foreach (array_reverse(explode(':', $GLOBALS['dossier_squelettes'])) as $d) {
1208                                array_unshift($path_full, ($d[0] == '/' ? '' : _DIR_RACINE) . $d . '/');
1209                        }
1210                }
1211                $GLOBALS['path_sig'] = md5(serialize($path_full));
1212        }
1213        if ($dir_path === null) {
1214                return $path_full;
1215        }
1216
1217        if (strlen($dir_path)) {
1218                $tete = "";
1219                if (reset($path_base) == _DIR_RACINE . 'squelettes/') {
1220                        $tete = array_shift($path_base);
1221                }
1222                $dirs = array_reverse(explode(':', $dir_path));
1223                foreach ($dirs as $dir_path) {
1224                        #if ($dir_path{0}!='/')
1225                        #       $dir_path = $dir_path;
1226                        if (substr($dir_path, -1) != '/') {
1227                                $dir_path .= "/";
1228                        }
1229                        if (!in_array($dir_path, $path_base)) {
1230                                array_unshift($path_base, $dir_path);
1231                        }
1232                }
1233                if (strlen($tete)) {
1234                        array_unshift($path_base, $tete);
1235                }
1236        }
1237        $path_full = $path_base;
1238        // Et le(s) dossier(s) des squelettes nommes
1239        if (strlen($GLOBALS['dossier_squelettes'])) {
1240                foreach (array_reverse(explode(':', $GLOBALS['dossier_squelettes'])) as $d) {
1241                        array_unshift($path_full, ((isset($d[0]) and $d[0] == '/') ? '' : _DIR_RACINE) . $d . '/');
1242                }
1243        }
1244
1245        $GLOBALS['path_sig'] = md5(serialize($path_full));
1246
1247        return $path_full;
1248}
1249
1250/**
1251 * Retourne la liste des chemins connus de SPIP, dans l'ordre de priorité
1252 *
1253 * Recalcule la liste si le nom ou liste de dossier squelettes a changé.
1254 *
1255 * @uses _chemin()
1256 *
1257 * @return array Liste de chemins
1258 **/
1259function creer_chemin() {
1260        $path_a = _chemin();
1261        static $c = '';
1262
1263        // on calcule le chemin si le dossier skel a change
1264        if ($c != $GLOBALS['dossier_squelettes']) {
1265                // assurer le non plantage lors de la montee de version :
1266                $c = $GLOBALS['dossier_squelettes'];
1267                $path_a = _chemin(''); // forcer un recalcul du chemin
1268        }
1269
1270        return $path_a;
1271}
1272
1273
1274function lister_themes_prives() {
1275        static $themes = null;
1276        if (is_null($themes)) {
1277                // si pas encore definie
1278                if (!defined('_SPIP_THEME_PRIVE')) {
1279                        define('_SPIP_THEME_PRIVE', 'spip');
1280                }
1281                $themes = array(_SPIP_THEME_PRIVE);
1282                // lors d'une installation neuve, prefs n'est pas definie.
1283                if (isset($GLOBALS['visiteur_session']['prefs'])) {
1284                        $prefs = $GLOBALS['visiteur_session']['prefs'];
1285                } else {
1286                        $prefs = array();
1287                }
1288                if (is_string($prefs)) {
1289                        $prefs = unserialize($GLOBALS['visiteur_session']['prefs']);
1290                }
1291                if (
1292                        ((isset($prefs['theme']) and $theme = $prefs['theme'])
1293                                or (isset($GLOBALS['theme_prive_defaut']) and $theme = $GLOBALS['theme_prive_defaut']))
1294                        and $theme != _SPIP_THEME_PRIVE
1295                ) {
1296                        array_unshift($themes, $theme);
1297                } // placer le theme choisi en tete
1298        }
1299
1300        return $themes;
1301}
1302
1303function find_in_theme($file, $subdir = '', $include = false) {
1304        static $themefiles = array();
1305        if (isset($themefiles["$subdir$file"])) {
1306                return $themefiles["$subdir$file"];
1307        }
1308        $themes = lister_themes_prives();
1309        foreach ($themes as $theme) {
1310                if ($f = find_in_path($file, "prive/themes/$theme/$subdir", $include)) {
1311                        return $themefiles["$subdir$file"] = $f;
1312                }
1313        }
1314        spip_log("$file introuvable dans le theme prive " . reset($themes), 'theme');
1315
1316        return $themefiles["$subdir$file"] = "";
1317}
1318
1319
1320/**
1321 * Cherche une image dans les dossiers d'images
1322 *
1323 * Cherche en priorité dans les thèmes d'image (prive/themes/X/images)
1324 * et si la fonction n'en trouve pas, gère le renommage des icones (ex: 'supprimer' => 'del')
1325 * de facon temporaire le temps de la migration, et cherche de nouveau.
1326 *
1327 * Si l'image n'est toujours pas trouvée, on la cherche dans les chemins,
1328 * dans le répertoire défini par la constante `_NOM_IMG_PACK`
1329 *
1330 * @see find_in_theme()
1331 * @see inc_icone_renommer_dist()
1332 *
1333 * @param string $icone
1334 *     Nom de l'icone cherchée
1335 * @return string
1336 *     Chemin complet de l'icone depuis la racine si l'icone est trouée,
1337 *     sinon chaîne vide.
1338 **/
1339function chemin_image($icone) {
1340        static $icone_renommer;
1341        // gerer le cas d'un double appel en evitant de refaire le travail inutilement
1342        if (strpos($icone, "/") !== false and file_exists($icone)) {
1343                return $icone;
1344        }
1345
1346        // si c'est un nom d'image complet (article-24.png) essayer de le renvoyer direct
1347        if (preg_match(',[.](png|gif|jpg)$,', $icone) and $f = find_in_theme("images/$icone")) {
1348                return $f;
1349        }
1350        // sinon passer par le module de renommage
1351        if (is_null($icone_renommer)) {
1352                $icone_renommer = charger_fonction('icone_renommer', 'inc', true);
1353        }
1354        if ($icone_renommer) {
1355                list($icone, $fonction) = $icone_renommer($icone, "");
1356                if (file_exists($icone)) {
1357                        return $icone;
1358                }
1359        }
1360
1361        return find_in_path($icone, _NOM_IMG_PACK);
1362}
1363
1364//
1365// chercher un fichier $file dans le SPIP_PATH
1366// si on donne un sous-repertoire en 2e arg optionnel, il FAUT le / final
1367// si 3e arg vrai, on inclut si ce n'est fait.
1368$GLOBALS['path_sig'] = '';
1369$GLOBALS['path_files'] = null;
1370
1371/**
1372 * Recherche un fichier dans les chemins de SPIP (squelettes, plugins, core)
1373 *
1374 * Retournera le premier fichier trouvé (ayant la plus haute priorité donc),
1375 * suivant l'ordre des chemins connus de SPIP.
1376 *
1377 * @api
1378 * @see  charger_fonction()
1379 * @uses creer_chemin() Pour la liste des chemins.
1380 * @example
1381 *     ```
1382 *     $f = find_in_path('css/perso.css');
1383 *     $f = find_in_path('perso.css', 'css');
1384 *     ```
1385 *
1386 * @param string $file
1387 *     Fichier recherché
1388 * @param string $dirname
1389 *     Répertoire éventuel de recherche (est aussi extrait automatiquement de $file)
1390 * @param bool|string $include
1391 *     - false : ne fait rien de plus
1392 *     - true : inclut le fichier (include_once)
1393 *     - 'require' : idem, mais tue le script avec une erreur si le fichier n'est pas trouvé.
1394 * @return string|bool
1395 *     - string : chemin du fichier trouvé
1396 *     - false : fichier introuvable
1397 **/
1398function find_in_path($file, $dirname = '', $include = false) {
1399        static $dirs = array();
1400        static $inc = array(); # cf http://trac.rezo.net/trac/spip/changeset/14743
1401        static $c = '';
1402
1403        // on calcule le chemin si le dossier skel a change
1404        if ($c != $GLOBALS['dossier_squelettes']) {
1405                // assurer le non plantage lors de la montee de version :
1406                $c = $GLOBALS['dossier_squelettes'];
1407                creer_chemin(); // forcer un recalcul du chemin et la mise a jour de path_sig
1408        }
1409
1410        if (isset($GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file])) {
1411                if (!$GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file]) {
1412                        return false;
1413                }
1414                if ($include and !isset($inc[$dirname][$file])) {
1415                        include_once _ROOT_CWD . $GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file];
1416                        $inc[$dirname][$file] = $inc[''][$dirname . $file] = true;
1417                }
1418
1419                return $GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file];
1420        }
1421
1422        $a = strrpos($file, '/');
1423        if ($a !== false) {
1424                $dirname .= substr($file, 0, ++$a);
1425                $file = substr($file, $a);
1426        }
1427
1428        foreach (creer_chemin() as $dir) {
1429                if (!isset($dirs[$a = $dir . $dirname])) {
1430                        $dirs[$a] = (is_dir(_ROOT_CWD . $a) || !$a);
1431                }
1432                if ($dirs[$a]) {
1433                        if (file_exists(_ROOT_CWD . ($a .= $file))) {
1434                                if ($include and !isset($inc[$dirname][$file])) {
1435                                        include_once _ROOT_CWD . $a;
1436                                        $inc[$dirname][$file] = $inc[''][$dirname . $file] = true;
1437                                }
1438                                if (!defined('_SAUVER_CHEMIN')) {
1439                                        // si le chemin n'a pas encore ete charge, ne pas lever le flag, ne pas cacher
1440                                        if (is_null($GLOBALS['path_files'])) {
1441                                                return $a;
1442                                        }
1443                                        define('_SAUVER_CHEMIN', true);
1444                                }
1445
1446                                return $GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file] = $GLOBALS['path_files'][$GLOBALS['path_sig']][''][$dirname . $file] = $a;
1447                        }
1448                }
1449        }
1450
1451        if ($include) {
1452                spip_log("include_spip $dirname$file non trouve");
1453                if ($include === 'required') {
1454                        echo '<pre>',
1455                        "<strong>Erreur Fatale</strong><br />";
1456                        if (function_exists('debug_print_backtrace')) {
1457                                echo debug_print_backtrace();
1458                        }
1459                        echo '</pre>';
1460                        die("Erreur interne: ne peut inclure $dirname$file");
1461                }
1462        }
1463
1464        if (!defined('_SAUVER_CHEMIN')) {
1465                // si le chemin n'a pas encore ete charge, ne pas lever le flag, ne pas cacher
1466                if (is_null($GLOBALS['path_files'])) {
1467                        return false;
1468                }
1469                define('_SAUVER_CHEMIN', true);
1470        }
1471
1472        return $GLOBALS['path_files'][$GLOBALS['path_sig']][$dirname][$file] = $GLOBALS['path_files'][$GLOBALS['path_sig']][''][$dirname . $file] = false;
1473}
1474
1475function clear_path_cache() {
1476        $GLOBALS['path_files'] = array();
1477        spip_unlink(_CACHE_CHEMIN);
1478}
1479
1480function load_path_cache() {
1481        // charger le path des plugins
1482        if (@is_readable(_CACHE_PLUGINS_PATH)) {
1483                include_once(_CACHE_PLUGINS_PATH);
1484        }
1485        $GLOBALS['path_files'] = array();
1486        // si le visiteur est admin,
1487        // on ne recharge pas le cache pour forcer sa mise a jour
1488        if (
1489                // la session n'est pas encore chargee a ce moment, on ne peut donc pas s'y fier
1490                //AND (!isset($GLOBALS['visiteur_session']['statut']) OR $GLOBALS['visiteur_session']['statut']!='0minirezo')
1491                // utiliser le cookie est un pis aller qui marche 'en general'
1492                // on blinde par un second test au moment de la lecture de la session
1493                // !isset($_COOKIE[$GLOBALS['cookie_prefix'].'_admin'])
1494                // et en ignorant ce cache en cas de recalcul explicite
1495        !_request('var_mode')
1496        ) {
1497                // on essaye de lire directement sans verrou pour aller plus vite
1498                if ($contenu = spip_file_get_contents(_CACHE_CHEMIN)) {
1499                        // mais si semble corrompu on relit avec un verrou
1500                        if (!$GLOBALS['path_files'] = unserialize($contenu)) {
1501                                lire_fichier(_CACHE_CHEMIN, $contenu);
1502                                if (!$GLOBALS['path_files'] = unserialize($contenu)) {
1503                                        $GLOBALS['path_files'] = array();
1504                                }
1505                        }
1506                }
1507        }
1508}
1509
1510function save_path_cache() {
1511        if (defined('_SAUVER_CHEMIN')
1512                and _SAUVER_CHEMIN
1513        ) {
1514                ecrire_fichier(_CACHE_CHEMIN, serialize($GLOBALS['path_files']));
1515        }
1516}
1517
1518
1519/**
1520 * Trouve tous les fichiers du path correspondants à un pattern
1521 *
1522 * Pour un nom de fichier donné, ne retourne que le premier qui sera trouvé
1523 * par un `find_in_path()`
1524 *
1525 * @api
1526 * @uses creer_chemin()
1527 * @uses preg_files()
1528 *
1529 * @param string $dir
1530 * @param string $pattern
1531 * @param bool $recurs
1532 * @return array
1533 */
1534function find_all_in_path($dir, $pattern, $recurs = false) {
1535        $liste_fichiers = array();
1536        $maxfiles = 10000;
1537
1538        // cas borderline si dans mes_options on appelle redirige_par_entete qui utilise _T et charge un fichier de langue
1539        // on a pas encore inclus flock.php
1540        if (!function_exists('preg_files')) {
1541                include_once _ROOT_RESTREINT . 'inc/flock.php';
1542        }
1543
1544        // Parcourir le chemin
1545        foreach (creer_chemin() as $d) {
1546                $f = $d . $dir;
1547                if (@is_dir($f)) {
1548                        $liste = preg_files($f, $pattern, $maxfiles - count($liste_fichiers), $recurs === true ? array() : $recurs);
1549                        foreach ($liste as $chemin) {
1550                                $nom = basename($chemin);
1551                                // ne prendre que les fichiers pas deja trouves
1552                                // car find_in_path prend le premier qu'il trouve,
1553                                // les autres sont donc masques
1554                                if (!isset($liste_fichiers[$nom])) {
1555                                        $liste_fichiers[$nom] = $chemin;
1556                                }
1557                        }
1558                }
1559        }
1560
1561        return $liste_fichiers;
1562}
1563
1564// predicat sur les scripts de ecrire qui n'authentifient pas par cookie
1565
1566// http://code.spip.net/@autoriser_sans_cookie
1567function autoriser_sans_cookie($nom) {
1568        static $autsanscookie = array('install', 'base_repair');
1569        $nom = preg_replace('/.php[3]?$/', '', basename($nom));
1570
1571        return in_array($nom, $autsanscookie);
1572}
1573
1574/**
1575 * Fonction codant et décodant les URLs des objets SQL mis en page par SPIP
1576 *
1577 * @api
1578 * @param string $id
1579 *   numero de la cle primaire si nombre, URL a decoder si pas numerique
1580 * @param string $entite
1581 *   surnom de la table SQL (donne acces au nom de cle primaire)
1582 * @param string $args
1583 *   query_string a placer apres cle=$id&....
1584 * @param string $ancre
1585 *   ancre a mettre a la fin de l'URL a produire
1586 * @param bool|string $public
1587 *   produire l'URL publique ou privee (par defaut: selon espace)
1588 *   si string : serveur de base de donnee (nom du connect)
1589 * @param string $type
1590 *   fichier dans le repertoire ecrire/urls determinant l'apparence
1591 * @return string|array
1592 *   url codee ou fonction de decodage
1593 *   array : derogatoire, la fonction d'url retourne (objet,id_objet) utilises par nettoyer_raccourcis_typo() pour generer un lien titre
1594 *           (cas des raccourcis personalises [->spip20] : il faut implementer une fonction generer_url_spip et une fonction generer_url_ecrire_spip)
1595 */
1596function generer_url_entite($id = '', $entite = '', $args = '', $ancre = '', $public = null, $type = null) {
1597        if ($public === null) {
1598                $public = !test_espace_prive();
1599        }
1600        $entite = objet_type($entite); // cas particulier d'appels sur objet/id_objet...
1601
1602        if (!$public) {
1603                if (!$entite) {
1604                        return '';
1605                }
1606                if (!function_exists('generer_url_ecrire_objet')) {
1607                        include_spip('inc/urls');
1608                }
1609                $res = generer_url_ecrire_objet($entite, $id, $args, $ancre, false);
1610        } else {
1611                if ($type === null) {
1612                        $type = (isset($GLOBALS['type_urls']))
1613                                ? $GLOBALS['type_urls'] // pour surcharge via fichier d'options
1614                                : ((isset($GLOBALS['meta']['type_urls'])) // sinon la config url_etendues
1615                                        ? ($GLOBALS['meta']['type_urls']) : "page"); // sinon type "page" par défaut
1616                }
1617
1618                $f = charger_fonction($type, 'urls', true);
1619                // se rabattre sur les urls page si les urls perso non dispo
1620                if (!$f) {
1621                        $f = charger_fonction('page', 'urls', true);
1622                }
1623
1624                // si $entite='', on veut la fonction de passage URL ==> id
1625                // sinon on veut effectuer le passage id ==> URL
1626                if (!$entite) {
1627                        return $f;
1628                }
1629
1630                // mais d'abord il faut tester le cas des urls sur une
1631                // base distante
1632                if (is_string($public)
1633                        and $g = charger_fonction('connect', 'urls', true)
1634                ) {
1635                        $f = $g;
1636                }
1637
1638                $res = $f(intval($id), $entite, $args, $ancre, $public);
1639
1640        }
1641        if ($res) {
1642                return $res;
1643        }
1644        // Sinon c'est un raccourci ou compat SPIP < 2
1645        if (!function_exists($f = 'generer_url_' . $entite)) {
1646                if (!function_exists($f .= '_dist')) {
1647                        $f = '';
1648                }
1649        }
1650        if ($f) {
1651                $url = $f($id, $args, $ancre);
1652                if (strlen($args)) {
1653                        $url .= strstr($url, '?')
1654                                ? '&amp;' . $args
1655                                : '?' . $args;
1656                }
1657
1658                return $url;
1659        }
1660        // On a ete gentil mais la ....
1661        spip_log("generer_url_entite: entite $entite ($f) inconnue $type $public");
1662
1663        return '';
1664}
1665
1666function generer_url_ecrire_entite_edit($id, $entite, $args = '', $ancre = '') {
1667        $exec = objet_info($entite, 'url_edit');
1668        $url = generer_url_ecrire($exec, $args);
1669        if (intval($id)) {
1670                $url = parametre_url($url, id_table_objet($entite), $id);
1671        } else {
1672                $url = parametre_url($url, 'new', 'oui');
1673        }
1674        if ($ancre) {
1675                $url = ancre_url($url, $ancre);
1676        }
1677
1678        return $url;
1679}
1680
1681// http://code.spip.net/@urls_connect_dist
1682function urls_connect_dist($i, &$entite, $args = '', $ancre = '', $public = null) {
1683        include_spip('base/connect_sql');
1684        $id_type = id_table_objet($entite, $public);
1685
1686        return _DIR_RACINE . get_spip_script('./')
1687        . "?" . _SPIP_PAGE . "=$entite&$id_type=$i&connect=$public"
1688        . (!$args ? '' : "&$args")
1689        . (!$ancre ? '' : "#$ancre");
1690}
1691
1692
1693/**
1694 * Transformer les caractères utf8 d'une URL (farsi par exemple) selon la RFC 1738
1695 *
1696 * @param string $url
1697 * @return string
1698 */
1699function urlencode_1738($url) {
1700        if (preg_match(',[^\x00-\x7E],sS', $url)) {
1701                $uri = '';
1702                for ($i = 0; $i < strlen($url); $i++) {
1703                        if (ord($a = $url[$i]) > 127) {
1704                                $a = rawurlencode($a);
1705                        }
1706                        $uri .= $a;
1707                }
1708                $url = $uri;
1709        }
1710
1711        return quote_amp($url);
1712}
1713
1714// http://code.spip.net/@generer_url_entite_absolue
1715function generer_url_entite_absolue($id = '', $entite = '', $args = '', $ancre = '', $connect = null) {
1716        if (!$connect) {
1717                $connect = true;
1718        }
1719        $h = generer_url_entite($id, $entite, $args, $ancre, $connect);
1720        if (!preg_match(',^\w+:,', $h)) {
1721                include_spip('inc/filtres_mini');
1722                $h = url_absolue($h);
1723        }
1724
1725        return $h;
1726}
1727
1728
1729/**
1730 * Tester qu'une variable d'environnement est active
1731 *
1732 * Sur certains serveurs, la valeur 'Off' tient lieu de false dans certaines
1733 * variables d'environnement comme $_SERVER[HTTPS] ou ini_get(register_globals)
1734 *
1735 * @param string|bool $truc
1736 *     La valeur de la variable d'environnement
1737 * @return bool
1738 *     true si la valeur est considérée active ; false sinon.
1739 **/
1740function test_valeur_serveur($truc) {
1741        if (!$truc) {
1742                return false;
1743        }
1744
1745        return (strtolower($truc) !== 'off');
1746}
1747
1748//
1749// Fonctions de fabrication des URL des scripts de Spip
1750//
1751/**
1752 * Calcule l'url de base du site
1753 *
1754 * Calcule l'URL de base du site, en priorité sans se fier à la méta (adresse_site) qui
1755 * peut être fausse (sites avec plusieurs noms d’hôtes, déplacements, erreurs).
1756 * En dernier recours, lorsqu'on ne trouve rien, on utilise adresse_site comme fallback.
1757 *
1758 * @note
1759 *     La globale `$profondeur_url` doit être initialisée de manière à
1760 *     indiquer le nombre de sous-répertoires de l'url courante par rapport à la
1761 *     racine de SPIP : par exemple, sur ecrire/ elle vaut 1, sur sedna/ 1, et à
1762 *     la racine 0. Sur url/perso/ elle vaut 2
1763 *
1764 * @param int|boo|array $profondeur
1765 *    - si non renseignée : retourne l'url pour la profondeur $GLOBALS['profondeur_url']
1766 *    - si int : indique que l'on veut l'url pour la profondeur indiquée
1767 *    - si bool : retourne le tableau static complet
1768 *    - si array : réinitialise le tableau static complet avec la valeur fournie
1769 * @return string|array
1770 */
1771function url_de_base($profondeur = null) {
1772
1773        static $url = array();
1774        if (is_array($profondeur)) {
1775                return $url = $profondeur;
1776        }
1777        if ($profondeur === false) {
1778                return $url;
1779        }
1780
1781        if (is_null($profondeur)) {
1782                $profondeur = $GLOBALS['profondeur_url'];
1783        }
1784
1785        if (isset($url[$profondeur])) {
1786                return $url[$profondeur];
1787        }
1788
1789        $http = 'http';
1790        if (
1791                isset($_SERVER["SCRIPT_URI"])
1792                and substr($_SERVER["SCRIPT_URI"], 0, 5) == 'https'
1793        ) {
1794                $http = 'https';
1795        } elseif (
1796                isset($_SERVER['HTTPS'])
1797                and test_valeur_serveur($_SERVER['HTTPS'])
1798        ) {
1799                $http = 'https';
1800        } 
1801
1802        // note : HTTP_HOST contient le :port si necessaire
1803        $host = isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : null;
1804        // si on n'a pas trouvé d'hôte du tout, en dernier recours on utilise adresse_site comme fallback
1805        if (is_null($host) and isset($GLOBALS['meta']['adresse_site'])) {
1806                $host = $GLOBALS['meta']['adresse_site'];
1807                if ($scheme = parse_url($host, PHP_URL_SCHEME)) {
1808                        $http = $scheme;
1809                        $host = str_replace("{$scheme}://", '', $host);
1810                }
1811        }
1812        if (isset($_SERVER['SERVER_PORT'])
1813                and $port = $_SERVER['SERVER_PORT']
1814                and strpos($host, ":") == false
1815        ) {
1816                if (!defined('_PORT_HTTP_STANDARD')) {
1817                        define('_PORT_HTTP_STANDARD', '80');
1818                }
1819                if (!defined('_PORT_HTTPS_STANDARD')) {
1820                        define('_PORT_HTTPS_STANDARD', '443');
1821                }
1822                if ($http == "http" and !in_array($port, explode(',', _PORT_HTTP_STANDARD))) {
1823                        $host .= ":$port";
1824                }
1825                if ($http == "https" and !in_array($port, explode(',', _PORT_HTTPS_STANDARD))) {
1826                        $host .= ":$port";
1827                }
1828        }
1829
1830        if (!$GLOBALS['REQUEST_URI']) {
1831                if (isset($_SERVER['REQUEST_URI'])) {
1832                        $GLOBALS['REQUEST_URI'] = $_SERVER['REQUEST_URI'];
1833                } else {
1834                        $GLOBALS['REQUEST_URI'] = (php_sapi_name() !== 'cli') ? $_SERVER['PHP_SELF'] : '';
1835                        if (!empty($_SERVER['QUERY_STRING'])
1836                                and !strpos($_SERVER['REQUEST_URI'], '?')
1837                        ) {
1838                                $GLOBALS['REQUEST_URI'] .= '?' . $_SERVER['QUERY_STRING'];
1839                        }
1840                }
1841        }
1842
1843        $url[$profondeur] = url_de_($http, $host, $GLOBALS['REQUEST_URI'], $profondeur);
1844
1845        return $url[$profondeur];
1846}
1847
1848/**
1849 * fonction testable de construction d'une url appelee par url_de_base()
1850 *
1851 * @param string $http
1852 * @param string $host
1853 * @param string $request
1854 * @param int $prof
1855 * @return string
1856 */
1857function url_de_($http, $host, $request, $prof = 0) {
1858        $prof = max($prof, 0);
1859
1860        $myself = ltrim($request, '/');
1861        # supprimer la chaine de GET
1862        list($myself) = explode('?', $myself);
1863        // vieux mode HTTP qui envoie après le nom de la methode l'URL compléte
1864        // protocole, "://", nom du serveur avant le path dans _SERVER["REQUEST_URI"]
1865        if (strpos($myself,'://') !== false) {
1866                $myself = explode('://',$myself);
1867                array_shift($myself);
1868                $myself = implode('://',$myself);
1869                $myself = explode('/',$myself);
1870                array_shift($myself);
1871                $myself = implode('/',$myself);
1872        }
1873        $url = join('/', array_slice(explode('/', $myself), 0, -1 - $prof)) . '/';
1874
1875        $url = $http . '://' . rtrim($host, '/') . '/' . ltrim($url, '/');
1876
1877        return $url;
1878}
1879
1880
1881// Pour une redirection, la liste des arguments doit etre separee par "&"
1882// Pour du code XHTML, ca doit etre &amp;
1883// Bravo au W3C qui n'a pas ete capable de nous eviter ca
1884// faute de separer proprement langage et meta-langage
1885
1886// Attention, X?y=z et "X/?y=z" sont completement differents!
1887// http://httpd.apache.org/docs/2.0/mod/mod_dir.html
1888
1889/**
1890 * Crée une URL vers un script de l'espace privé
1891 *
1892 * @example
1893 *     ```
1894 *     generer_url_ecrire('admin_plugin')
1895 *     ```
1896 *
1897 * @param string $script
1898 *     Nom de la page privée (xx dans exec=xx)
1899 * @param string $args
1900 *     Arguments à transmettre, tel que `arg1=yy&arg2=zz`
1901 * @param bool $no_entities
1902 *     Si false : transforme les `&` en `&amp;`
1903 * @param bool|string $rel
1904 *     URL relative ?
1905 *
1906 *     - false : l’URL sera complète et contiendra l’URL du site
1907 *     - true : l’URL sera relavive.
1908 *     - string : on transmet l'url à la fonction
1909 * @return string URL
1910 **/
1911function generer_url_ecrire($script = '', $args = "", $no_entities = false, $rel = false) {
1912        if (!$rel) {
1913                $rel = url_de_base() . _DIR_RESTREINT_ABS . _SPIP_ECRIRE_SCRIPT;
1914        } else {
1915                if (!is_string($rel)) {
1916                        $rel = _DIR_RESTREINT ? _DIR_RESTREINT :
1917                                ('./' . _SPIP_ECRIRE_SCRIPT);
1918                }
1919        }
1920
1921        list($script, $ancre) = array_pad(explode('#', $script), 2, null);
1922        if ($script and ($script <> 'accueil' or $rel)) {
1923                $args = "?exec=$script" . (!$args ? '' : "&$args");
1924        } elseif ($args) {
1925                $args = "?$args";
1926        }
1927        if ($ancre) {
1928                $args .= "#$ancre";
1929        }
1930
1931        return $rel . ($no_entities ? $args : str_replace('&', '&amp;', $args));
1932}
1933
1934// http://code.spip.net/@generer_url_retour
1935function generer_url_retour($script, $args = "") {
1936        return rawurlencode(generer_url_ecrire($script, $args, true, true));
1937}
1938
1939//
1940// Adresse des scripts publics (a passer dans inc-urls...)
1941//
1942
1943
1944/**
1945 * Retourne le nom du fichier d'exécution de SPIP
1946 *
1947 * @see _SPIP_SCRIPT
1948 * @note
1949 *   Detecter le fichier de base, a la racine, comme etant spip.php ou ''
1950 *   dans le cas de '', un $default = './' peut servir (comme dans urls/page.php)
1951 *
1952 * @param string $default
1953 *     Script par défaut
1954 * @return string
1955 *     Nom du fichier (constante _SPIP_SCRIPT), sinon nom par défaut
1956 **/
1957function get_spip_script($default = '') {
1958        # cas define('_SPIP_SCRIPT', '');
1959        if (_SPIP_SCRIPT) {
1960                return _SPIP_SCRIPT;
1961        } else {
1962                return $default;
1963        }
1964}
1965
1966/**
1967 * Crée une URL vers une page publique de SPIP
1968 *
1969 * @example
1970 *     ```
1971 *     generer_url_public("rubrique","id_rubrique=$id_rubrique")
1972 *     ```
1973 *
1974 * @param string $script
1975 *     Nom de la page
1976 * @param string|array $args
1977 *     Arguments à transmettre a l'URL,
1978 *      soit sous la forme d'un string tel que `arg1=yy&arg2=zz`
1979 *      soit sous la forme d'un array tel que array( `arg1` => `yy`, `arg2` => `zz` )
1980 * @param bool $no_entities
1981 *     Si false : transforme les `&` en `&amp;`
1982 * @param bool $rel
1983 *     URL relative ?
1984 *
1985 *     - false : l’URL sera complète et contiendra l’URL du site
1986 *     - true : l’URL sera relavive.
1987 * @param string $action
1988 *     - Fichier d'exécution public (spip.php par défaut)
1989 * @return string URL
1990 **/
1991function generer_url_public($script = '', $args = "", $no_entities = false, $rel = true, $action = '') {
1992        // si le script est une action (spip_pass, spip_inscription),
1993        // standardiser vers la nouvelle API
1994
1995        if (!$action) {
1996                $action = get_spip_script();
1997        }
1998        if ($script) {
1999                $action = parametre_url($action, _SPIP_PAGE, $script, '&');
2000        }
2001
2002        if ($args) {
2003                if (is_array($args)) {
2004                        $r = '';
2005                        foreach ($args as $k => $v) {
2006                                $r .= '&' . $k . '=' . $v;
2007                        }
2008                        $args = substr($r, 1);
2009                }
2010                $action .=
2011                        (strpos($action, '?') !== false ? '&' : '?') . $args;
2012        }
2013        if (!$no_entities) {
2014                $action = quote_amp($action);
2015        }
2016
2017        // ne pas generer une url avec /./?page= en cas d'url absolue et de _SPIP_SCRIPT vide
2018        return ($rel ? _DIR_RACINE . $action : rtrim(url_de_base(), '/') . preg_replace(",^/[.]/,", "/", "/$action"));
2019}
2020
2021// http://code.spip.net/@generer_url_prive
2022function generer_url_prive($script, $args = "", $no_entities = false) {
2023
2024        return generer_url_public($script, $args, $no_entities, false, _DIR_RESTREINT_ABS . 'prive.php');
2025}
2026
2027// Pour les formulaires en methode POST,
2028// mettre le nom du script a la fois en input-hidden et dans le champ action:
2029// 1) on peut ainsi memoriser le signet comme si c'etait un GET
2030// 2) ca suit http://en.wikipedia.org/wiki/Representational_State_Transfer
2031
2032/**
2033 * Retourne un formulaire (POST par défaut) vers un script exec
2034 * de l’interface privée
2035 *
2036 * @param string $script
2037 *     Nom de la page exec
2038 * @param string $corps
2039 *     Contenu du formulaire
2040 * @param string $atts
2041 *     Si présent, remplace les arguments par défaut (method=post) par ceux indiqués
2042 * @param string $submit
2043 *     Si indiqué, un bouton de soumission est créé avec texte sa valeur.
2044 * @return string
2045 *     Code HTML du formulaire
2046 **/
2047function generer_form_ecrire($script, $corps, $atts = '', $submit = '') {
2048
2049        $script1 = explode('&', $script);
2050        $script1 = reset($script1);
2051
2052        return "<form action='"
2053        . ($script ? generer_url_ecrire($script) : '')
2054        . "' "
2055        . ($atts ? $atts : " method='post'")
2056        . "><div>\n"
2057        . "<input type='hidden' name='exec' value='$script1' />"
2058        . $corps
2059        . (!$submit ? '' :
2060                ("<div style='text-align: " . $GLOBALS['spip_lang_right'] . "'><input class='fondo' type='submit' value=\"" . entites_html($submit) . "\" /></div>"))
2061        . "</div></form>\n";
2062}
2063
2064/**
2065 * Générer un formulaire pour lancer une action vers $script
2066 *
2067 * Attention, JS/Ajax n'aime pas le melange de param GET/POST
2068 * On n'applique pas la recommandation ci-dessus pour les scripts publics
2069 * qui ne sont pas destines a etre mis en signets
2070 * http://code.spip.net/@generer_form_action
2071 *
2072 * @param string $script
2073 * @param string $corps
2074 * @param string $atts
2075 * @param bool $public
2076 * @return string
2077 */
2078function generer_form_action($script, $corps, $atts = '', $public = false) {
2079        // si l'on est dans l'espace prive, on garde dans l'url
2080        // l'exec a l'origine de l'action, qui permet de savoir si il est necessaire
2081        // ou non de proceder a l'authentification (cas typique de l'install par exemple)
2082        $h = (_DIR_RACINE and !$public)
2083                ? generer_url_ecrire(_request('exec'))
2084                : generer_url_public();
2085
2086        return "\n<form action='" .
2087        $h .
2088        "'" .
2089        $atts .
2090        ">\n" .
2091        "<div>" .
2092        "\n<input type='hidden' name='action' value='$script' />" .
2093        $corps .
2094        "</div></form>";
2095}
2096
2097/**
2098 * Créer une URL
2099 *
2100 * @param  string $script
2101 *     Nom du script à exécuter
2102 * @param  string|array $args
2103 *     Arguments à transmettre a l'URL, soit sous la forme d'un string
2104 *     tel que `arg1=yy&arg2=zz` soit sous la forme d'un array tel que
2105 *    `array( arg1 => yy, arg2 => zz )`
2106 * @param bool $no_entities
2107 *     Si false : transforme les & en &amp;
2108 * @param boolean $public
2109 *     URL relative ? false : l’URL sera complète et contiendra l’URL du site.
2110 *     true : l’URL sera relative.
2111 * @return string
2112 *     URL
2113 */
2114function generer_url_action($script, $args = "", $no_entities = false, $public = false) {
2115        // si l'on est dans l'espace prive, on garde dans l'url
2116        // l'exec a l'origine de l'action, qui permet de savoir si il est necessaire
2117        // ou non de proceder a l'authentification (cas typique de l'install par exemple)
2118        $url = (_DIR_RACINE and !$public)
2119                ? generer_url_ecrire(_request('exec'))
2120                : generer_url_public('', '', false, false);
2121        $url = parametre_url($url, 'action', $script);
2122        if ($args) {
2123                $url .= quote_amp('&' . $args);
2124        }
2125
2126        if ($no_entities) {
2127                $url = str_replace('&amp;', '&', $url);
2128        }
2129
2130        return $url;
2131}
2132
2133
2134/**
2135 * Fonction d'initialisation groupée pour compatibilité ascendante
2136 *
2137 * @param string $pi Répertoire permanent inaccessible
2138 * @param string $pa Répertoire permanent accessible
2139 * @param string $ti Répertoire temporaire inaccessible
2140 * @param string $ta Répertoire temporaire accessible
2141 */
2142function spip_initialisation($pi = null, $pa = null, $ti = null, $ta = null) {
2143        spip_initialisation_core($pi, $pa, $ti, $ta);
2144        spip_initialisation_suite();
2145}
2146
2147/**
2148 * Fonction d'initialisation, appellée dans inc_version ou mes_options
2149 *
2150 * Elle définit les répertoires et fichiers non partageables
2151 * et indique dans $test_dirs ceux devant être accessibles en écriture
2152 * mais ne touche pas à cette variable si elle est déjà définie
2153 * afin que mes_options.php puisse en spécifier d'autres.
2154 *
2155 * Elle définit ensuite les noms des fichiers et les droits.
2156 * Puis simule un register_global=on sécurisé.
2157 *
2158 * @param string $pi Répertoire permanent inaccessible
2159 * @param string $pa Répertoire permanent accessible
2160 * @param string $ti Répertoire temporaire inaccessible
2161 * @param string $ta Répertoire temporaire accessible
2162 */
2163function spip_initialisation_core($pi = null, $pa = null, $ti = null, $ta = null) {
2164        static $too_late = 0;
2165        if ($too_late++) {
2166                return;
2167        }
2168
2169        // Declaration des repertoires
2170
2171        // le nom du repertoire plugins/ activables/desactivables
2172        if (!defined('_DIR_PLUGINS')) {
2173                define('_DIR_PLUGINS', _DIR_RACINE . "plugins/");
2174        }
2175
2176        // le nom du repertoire des extensions/ permanentes du core, toujours actives
2177        if (!defined('_DIR_PLUGINS_DIST')) {
2178                define('_DIR_PLUGINS_DIST', _DIR_RACINE . "plugins-dist/");
2179        }
2180
2181        // le nom du repertoire des librairies
2182        if (!defined('_DIR_LIB')) {
2183                define('_DIR_LIB', _DIR_RACINE . "lib/");
2184        }
2185
2186        if (!defined('_DIR_IMG')) {
2187                define('_DIR_IMG', $pa);
2188        }
2189        if (!defined('_DIR_LOGOS')) {
2190                define('_DIR_LOGOS', $pa);
2191        }
2192        if (!defined('_DIR_IMG_ICONES')) {
2193                define('_DIR_IMG_ICONES', _DIR_LOGOS . "icones/");
2194        }
2195
2196        if (!defined('_DIR_DUMP')) {
2197                define('_DIR_DUMP', $ti . "dump/");
2198        }
2199        if (!defined('_DIR_SESSIONS')) {
2200                define('_DIR_SESSIONS', $ti . "sessions/");
2201        }
2202        if (!defined('_DIR_TRANSFERT')) {
2203                define('_DIR_TRANSFERT', $ti . "upload/");
2204        }
2205        if (!defined('_DIR_CACHE')) {
2206                define('_DIR_CACHE', $ti . "cache/");
2207        }
2208        if (!defined('_DIR_CACHE_XML')) {
2209                define('_DIR_CACHE_XML', _DIR_CACHE . "xml/");
2210        }
2211        if (!defined('_DIR_SKELS')) {
2212                define('_DIR_SKELS', _DIR_CACHE . "skel/");
2213        }
2214        if (!defined('_DIR_AIDE')) {
2215                define('_DIR_AIDE', _DIR_CACHE . "aide/");
2216        }
2217        if (!defined('_DIR_TMP')) {
2218                define('_DIR_TMP', $ti);
2219        }
2220
2221        if (!defined('_DIR_VAR')) {
2222                define('_DIR_VAR', $ta);
2223        }
2224
2225        if (!defined('_DIR_ETC')) {
2226                define('_DIR_ETC', $pi);
2227        }
2228        if (!defined('_DIR_CONNECT')) {
2229                define('_DIR_CONNECT', $pi);
2230        }
2231        if (!defined('_DIR_CHMOD')) {
2232                define('_DIR_CHMOD', $pi);
2233        }
2234
2235        if (!isset($GLOBALS['test_dirs']))
2236                // Pas $pi car il est bon de le mettre hors ecriture apres intstall
2237                // il sera rajoute automatiquement si besoin a l'etape 2 de l'install
2238        {
2239                $GLOBALS['test_dirs'] = array($pa, $ti, $ta);
2240        }
2241
2242        // Declaration des fichiers
2243
2244        if (!defined('_CACHE_PLUGINS_PATH')) {
2245                define('_CACHE_PLUGINS_PATH', _DIR_CACHE . "charger_plugins_chemins.php");
2246        }
2247        if (!defined('_CACHE_PLUGINS_OPT')) {
2248                define('_CACHE_PLUGINS_OPT', _DIR_CACHE . "charger_plugins_options.php");
2249        }
2250        if (!defined('_CACHE_PLUGINS_FCT')) {
2251                define('_CACHE_PLUGINS_FCT', _DIR_CACHE . "charger_plugins_fonctions.php");
2252        }
2253        if (!defined('_CACHE_PIPELINES')) {
2254                define('_CACHE_PIPELINES', _DIR_CACHE . "charger_pipelines.php");
2255        }
2256        if (!defined('_CACHE_CHEMIN')) {
2257                define('_CACHE_CHEMIN', _DIR_CACHE . "chemin.txt");
2258        }
2259
2260        # attention .php obligatoire pour ecrire_fichier_securise
2261        if (!defined('_FILE_META')) {
2262                define('_FILE_META', $ti . 'meta_cache.php');
2263        }
2264        if (!defined('_DIR_LOG')) {
2265                define('_DIR_LOG', _DIR_TMP . 'log/');
2266        }
2267        if (!defined('_FILE_LOG')) {
2268                define('_FILE_LOG', 'spip');
2269        }
2270        if (!defined('_FILE_LOG_SUFFIX')) {
2271                define('_FILE_LOG_SUFFIX', '.log');
2272        }
2273
2274        // Le fichier de connexion a la base de donnees
2275        // tient compte des anciennes versions (inc_connect...)
2276        if (!defined('_FILE_CONNECT_INS')) {
2277                define('_FILE_CONNECT_INS', 'connect');
2278        }
2279        if (!defined('_FILE_CONNECT')) {
2280                define('_FILE_CONNECT',
2281                (@is_readable($f = _DIR_CONNECT . _FILE_CONNECT_INS . '.php') ? $f
2282                        : (@is_readable($f = _DIR_RESTREINT . 'inc_connect.php') ? $f
2283                                : false)));
2284        }
2285
2286        // Le fichier de reglages des droits
2287        if (!defined('_FILE_CHMOD_INS')) {
2288                define('_FILE_CHMOD_INS', 'chmod');
2289        }
2290        if (!defined('_FILE_CHMOD')) {
2291                define('_FILE_CHMOD',
2292                (@is_readable($f = _DIR_CHMOD . _FILE_CHMOD_INS . '.php') ? $f
2293                        : false));
2294        }
2295
2296        if (!defined('_FILE_LDAP')) {
2297                define('_FILE_LDAP', 'ldap.php');
2298        }
2299
2300        if (!defined('_FILE_TMP_SUFFIX')) {
2301                define('_FILE_TMP_SUFFIX', '.tmp.php');
2302        }
2303        if (!defined('_FILE_CONNECT_TMP')) {
2304                define('_FILE_CONNECT_TMP', _DIR_CONNECT . _FILE_CONNECT_INS . _FILE_TMP_SUFFIX);
2305        }
2306        if (!defined('_FILE_CHMOD_TMP')) {
2307                define('_FILE_CHMOD_TMP', _DIR_CHMOD . _FILE_CHMOD_INS . _FILE_TMP_SUFFIX);
2308        }
2309
2310        // Definition des droits d'acces en ecriture
2311        if (!defined('_SPIP_CHMOD') and _FILE_CHMOD) {
2312                include_once _FILE_CHMOD;
2313        }
2314
2315        // Se mefier des fichiers mal remplis!
2316        if (!defined('_SPIP_CHMOD')) {
2317                define('_SPIP_CHMOD', 0777);
2318        }
2319
2320        if (!defined('_DEFAULT_CHARSET')) {
2321                /** Le charset par défaut lors de l'installation */
2322                define('_DEFAULT_CHARSET', 'utf-8');
2323        }
2324        if (!defined('_ROOT_PLUGINS')) {
2325                define('_ROOT_PLUGINS', _ROOT_RACINE . "plugins/");
2326        }
2327        if (!defined('_ROOT_PLUGINS_DIST')) {
2328                define('_ROOT_PLUGINS_DIST', _ROOT_RACINE . "plugins-dist/");
2329        }
2330        if (!defined('_ROOT_PLUGINS_SUPPL') && defined('_DIR_PLUGINS_SUPPL') && _DIR_PLUGINS_SUPPL) {
2331                define('_ROOT_PLUGINS_SUPPL', _ROOT_RACINE . str_replace(_DIR_RACINE, '', _DIR_PLUGINS_SUPPL));
2332        }
2333
2334        // La taille des Log
2335        if (!defined('_MAX_LOG')) {
2336                define('_MAX_LOG', 100);
2337        }
2338
2339        // Sommes-nous dans l'empire du Mal ?
2340        // (ou sous le signe du Pingouin, ascendant GNU ?)
2341        if (isset($_SERVER['SERVER_SOFTWARE']) and strpos($_SERVER['SERVER_SOFTWARE'], '(Win') !== false) {
2342                if (!defined('_OS_SERVEUR')) {
2343                        define('_OS_SERVEUR', 'windows');
2344                }
2345                if (!defined('_SPIP_LOCK_MODE')) {
2346                        define('_SPIP_LOCK_MODE', 1);
2347                } // utiliser le flock php
2348        } else {
2349                if (!defined('_OS_SERVEUR')) {
2350                        define('_OS_SERVEUR', '');
2351                }
2352                if (!defined('_SPIP_LOCK_MODE')) {
2353                        define('_SPIP_LOCK_MODE', 1);
2354                } // utiliser le flock php
2355                #if (!defined('_SPIP_LOCK_MODE')) define('_SPIP_LOCK_MODE',2); // utiliser le nfslock de spip mais link() est tres souvent interdite
2356        }
2357
2358        // Langue par defaut
2359        if (!defined('_LANGUE_PAR_DEFAUT')) {
2360                define('_LANGUE_PAR_DEFAUT', 'fr');
2361        }
2362
2363        // PHP_VERSION_ID dispo depuis PHP 5.2.7
2364        if (!defined('PHP_VERSION_ID')) {
2365           $version = explode('.',PHP_VERSION);
2366           define('PHP_VERSION_ID', ($version[0] * 10000 + $version[1] * 100 + $version[2]));
2367        }
2368
2369        //
2370        // Module de lecture/ecriture/suppression de fichiers utilisant flock()
2371        // (non surchargeable en l'etat ; attention si on utilise include_spip()
2372        // pour le rendre surchargeable, on va provoquer un reecriture
2373        // systematique du noyau ou une baisse de perfs => a etudier)
2374        include_once _ROOT_RESTREINT . 'inc/flock.php';
2375
2376        // charger tout de suite le path et son cache
2377        load_path_cache();
2378
2379        // *********** traiter les variables ************
2380
2381        //
2382        // Securite
2383        //
2384
2385        // Ne pas se faire manger par un bug php qui accepte ?GLOBALS[truc]=toto
2386        if (isset($_REQUEST['GLOBALS'])) {
2387                die();
2388        }
2389        // nettoyer les magic quotes \' et les caracteres nuls %00
2390        spip_desinfecte($_GET);
2391        spip_desinfecte($_POST);
2392        spip_desinfecte($_COOKIE);
2393        spip_desinfecte($_REQUEST);
2394
2395        // Par ailleurs on ne veut pas de magic_quotes au cours de l'execution
2396        if (PHP_VERSION_ID<50300) {
2397                set_magic_quotes_runtime(0);
2398        }
2399
2400        // Si les variables sont passees en global par le serveur,
2401        // il faut faire quelques verifications de base
2402        // Todo: test à supprimer lorsque version PHP minimum >= 5.4.
2403        $avertir_register_globals = false;
2404        if (test_valeur_serveur(@ini_get('register_globals'))) {
2405                // ne pas desinfecter les globales en profondeur car elle contient aussi les
2406                // precedentes, qui seraient desinfectees 2 fois.
2407                spip_desinfecte($GLOBALS, false);
2408                // plugin grenier
2409                if (include_spip('inc/php3')) {
2410                        spip_register_globals(true);
2411                }
2412
2413                $avertir_register_globals = true;
2414        }
2415
2416        // appliquer le cookie_prefix
2417        if ($GLOBALS['cookie_prefix'] != 'spip') {
2418                include_spip('inc/cookie');
2419                recuperer_cookies_spip($GLOBALS['cookie_prefix']);
2420        }
2421
2422        //
2423        // Capacites php (en fonction de la version)
2424        //
2425        $GLOBALS['flag_ob'] = (function_exists("ob_start")
2426                && function_exists("ini_get")
2427                && !strstr(@ini_get('disable_functions'), 'ob_'));
2428        $GLOBALS['flag_sapi_name'] = function_exists("php_sapi_name");
2429        $GLOBALS['flag_get_cfg_var'] = (@get_cfg_var('error_reporting') != "");
2430        $GLOBALS['flag_upload'] = (!$GLOBALS['flag_get_cfg_var'] ||
2431                (get_cfg_var('upload_max_filesize') > 0));
2432
2433
2434        // Compatibilite avec serveurs ne fournissant pas $REQUEST_URI
2435        if (isset($_SERVER['REQUEST_URI'])) {
2436                $GLOBALS['REQUEST_URI'] = $_SERVER['REQUEST_URI'];
2437        } else {
2438                $GLOBALS['REQUEST_URI'] = (php_sapi_name() !== 'cli') ? $_SERVER['PHP_SELF'] : '';
2439                if (!empty($_SERVER['QUERY_STRING'])
2440                        and !strpos($_SERVER['REQUEST_URI'], '?')
2441                ) {
2442                        $GLOBALS['REQUEST_URI'] .= '?' . $_SERVER['QUERY_STRING'];
2443                }
2444        }
2445
2446        // Duree de validite de l'alea pour les cookies et ce qui s'ensuit.
2447        if (!defined('_RENOUVELLE_ALEA')) {
2448                define('_RENOUVELLE_ALEA', 12 * 3600);
2449        }
2450
2451        // charger les meta si possible et renouveller l'alea au besoin
2452        // charge aussi effacer_meta et ecrire_meta
2453        $inc_meta = charger_fonction('meta', 'inc');
2454        $inc_meta();
2455
2456        // on a pas pu le faire plus tot
2457        if ($avertir_register_globals) {
2458                avertir_auteurs("register_globals",
2459                        _L("Probl&egrave;me de s&eacute;curit&eacute; : register_globals=on; dans php.ini &agrave; corriger."));
2460        }
2461
2462        // nombre de repertoires depuis la racine
2463        // on compare a l'adresse de spip.php : $_SERVER["SCRIPT_NAME"]
2464        // ou a defaut celle donnee en meta ; (mais si celle-ci est fausse
2465        // le calcul est faux)
2466        if (!_DIR_RESTREINT) {
2467                $GLOBALS['profondeur_url'] = 1;
2468        } else {
2469                $uri = isset($_SERVER['REQUEST_URI']) ? explode('?', $_SERVER['REQUEST_URI']) : '';
2470                $uri_ref = $_SERVER["SCRIPT_NAME"];
2471                if (!$uri_ref
2472                        // si on est appele avec un autre ti, on est sans doute en mutu
2473                        // si jamais c'est de la mutu avec sous rep, on est perdu si on se fie
2474                        // a spip.php qui est a la racine du spip, et vue qu'on sait pas se reperer
2475                        // s'en remettre a l'adresse du site. alea jacta est.
2476                        or $ti !== _NOM_TEMPORAIRES_INACCESSIBLES
2477                ) {
2478
2479                        if (isset($GLOBALS['meta']['adresse_site'])) {
2480                                $uri_ref = parse_url($GLOBALS['meta']['adresse_site']);
2481                                $uri_ref = $uri_ref['path'] . '/';
2482                        } else {
2483                                $uri_ref = "";
2484                        }
2485                }
2486                if (!$uri or !$uri_ref) {
2487                        $GLOBALS['profondeur_url'] = 0;
2488                } else {
2489                        $GLOBALS['profondeur_url'] = max(0,
2490                                substr_count($uri[0], '/')
2491                                - substr_count($uri_ref, '/'));
2492                }
2493        }
2494        // s'il y a un cookie ou PHP_AUTH, initialiser visiteur_session
2495        if (_FILE_CONNECT) {
2496                if (verifier_visiteur() == '0minirezo'
2497                        // si c'est un admin sans cookie admin, il faut ignorer le cache chemin !
2498                        and !isset($_COOKIE['spip_admin'])
2499                ) {
2500                        clear_path_cache();
2501                }
2502        }
2503
2504}
2505
2506/**
2507 * Complements d'initialisation non critiques pouvant etre realises
2508 * par les plugins
2509 *
2510 */
2511function spip_initialisation_suite() {
2512        static $too_late = 0;
2513        if ($too_late++) {
2514                return;
2515        }
2516
2517        // taille mini des login
2518        if (!defined('_LOGIN_TROP_COURT')) {
2519                define('_LOGIN_TROP_COURT', 4);
2520        }
2521
2522        // la taille maxi des logos (0 : pas de limite) (pas de define par defaut, ce n'est pas utile)
2523        #if (!defined('_LOGO_MAX_SIZE')) define('_LOGO_MAX_SIZE', 0); # poids en ko
2524        #if (!defined('_LOGO_MAX_WIDTH')) define('_LOGO_MAX_WIDTH', 0); # largeur en pixels
2525        #if (!defined('_LOGO_MAX_HEIGHT')) define('_LOGO_MAX_HEIGHT', 0); # hauteur en pixels
2526
2527        // la taille maxi des images (0 : pas de limite) (pas de define par defaut, ce n'est pas utile)
2528        #if (!defined('_DOC_MAX_SIZE')) define('_DOC_MAX_SIZE', 0); # poids en ko
2529        #if (!defined('_IMG_MAX_SIZE')) define('_IMG_MAX_SIZE', 0); # poids en ko
2530        #if (!defined('_IMG_MAX_WIDTH')) define('_IMG_MAX_WIDTH', 0); # largeur en pixels
2531        #if (!defined('_IMG_MAX_HEIGHT')) define('_IMG_MAX_HEIGHT', 0); # hauteur en pixels
2532
2533        if (!defined('_PASS_LONGUEUR_MINI')) {
2534                define('_PASS_LONGUEUR_MINI', 6);
2535        }
2536
2537
2538        // Qualite des images calculees automatiquement. C'est un nombre entre 0 et 100, meme pour imagick (on ramene a 0..1 par la suite)
2539        if (!defined('_IMG_QUALITE')) {
2540                define('_IMG_QUALITE', 85);
2541        } # valeur par defaut
2542        if (!defined('_IMG_GD_QUALITE')) {
2543                define('_IMG_GD_QUALITE', _IMG_QUALITE);
2544        } # surcharge pour la lib GD
2545        if (!defined('_IMG_CONVERT_QUALITE')) {
2546                define('_IMG_CONVERT_QUALITE', _IMG_QUALITE);
2547        } # surcharge pour imagick en ligne de commande
2548        // Historiquement la valeur pour imagick semble differente. Si ca n'est pas necessaire, il serait preferable de garder _IMG_QUALITE
2549        if (!defined('_IMG_IMAGICK_QUALITE')) {
2550                define('_IMG_IMAGICK_QUALITE', 75);
2551        } # surcharge pour imagick en PHP
2552
2553        if (!defined('_COPIE_LOCALE_MAX_SIZE')) {
2554                define('_COPIE_LOCALE_MAX_SIZE', 33554432);
2555        } // poids en octet
2556
2557        // qq chaines standard
2558        if (!defined('_ACCESS_FILE_NAME')) {
2559                define('_ACCESS_FILE_NAME', '.htaccess');
2560        }
2561        if (!defined('_AUTH_USER_FILE')) {
2562                define('_AUTH_USER_FILE', '.htpasswd');
2563        }
2564        if (!defined('_SPIP_DUMP')) {
2565                define('_SPIP_DUMP', 'dump@nom_site@@stamp@.xml');
2566        }
2567        if (!defined('_CACHE_RUBRIQUES')) {
2568                /** Fichier cache pour le navigateur de rubrique du bandeau */
2569                define('_CACHE_RUBRIQUES', _DIR_TMP . 'menu-rubriques-cache.txt');
2570        }
2571        if (!defined('_CACHE_RUBRIQUES_MAX')) {
2572                /** Nombre maxi de rubriques enfants affichées pour chaque rubrique du navigateur de rubrique du bandeau */
2573                define('_CACHE_RUBRIQUES_MAX', 500);
2574        }
2575
2576        if (!defined('_EXTENSION_SQUELETTES')) {
2577                define('_EXTENSION_SQUELETTES', 'html');
2578        }
2579
2580        if (!defined('_DOCTYPE_ECRIRE')) {
2581                define('_DOCTYPE_ECRIRE',
2582                        // "<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.01 Transitional//EN' 'http://www.w3.org/TR/html4/loose.dtd'>\n");
2583                        //"<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>\n");
2584                        //"<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Strict//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>\n");
2585                        // "<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.1 //EN' 'http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd'>\n");
2586                "<!DOCTYPE html>\n");
2587        }
2588        if (!defined('_DOCTYPE_AIDE')) {
2589                define('_DOCTYPE_AIDE',
2590                "<!DOCTYPE html PUBLIC '-//W3C//DTD HTML 4.01 Frameset//EN' 'http://www.w3.org/TR/1999/REC-html401-19991224/frameset.dtd'>");
2591        }
2592
2593        /** L'adresse de base du site ; on peut mettre '' si la racine est gerée par
2594         * le script de l'espace public, alias index.php */
2595        if (!defined('_SPIP_SCRIPT')) {
2596                define('_SPIP_SCRIPT', 'spip.php');
2597        }
2598        /** Argument page, personalisable en cas de conflit avec un autre script */
2599        if (!defined('_SPIP_PAGE')) {
2600                define('_SPIP_PAGE', 'page');
2601        }
2602
2603        // le script de l'espace prive
2604        // Mettre a "index.php" si DirectoryIndex ne le fait pas ou pb connexes:
2605        // les anciens IIS n'acceptent pas les POST sur ecrire/ (#419)
2606        // meme pb sur thttpd cf. http://forum.spip.net/fr_184153.html
2607        if (!defined('_SPIP_ECRIRE_SCRIPT')) {
2608                define('_SPIP_ECRIRE_SCRIPT', (empty($_SERVER['SERVER_SOFTWARE']) ? '' :
2609                        preg_match(',IIS|thttpd,', $_SERVER['SERVER_SOFTWARE']) ?
2610                                'index.php' : ''));
2611        }
2612
2613
2614        if (!defined('_SPIP_AJAX')) {
2615                define('_SPIP_AJAX', ((!isset($_COOKIE['spip_accepte_ajax']))
2616                        ? 1
2617                        : (($_COOKIE['spip_accepte_ajax'] != -1) ? 1 : 0)));
2618        }
2619
2620        // La requete est-elle en ajax ?
2621        if (!defined('_AJAX')) {
2622                define('_AJAX',
2623                        (isset($_SERVER['HTTP_X_REQUESTED_WITH']) # ajax jQuery
2624                                or !empty($_REQUEST['var_ajax_redir']) # redirection 302 apres ajax jQuery
2625                                or !empty($_REQUEST['var_ajaxcharset']) # compat ascendante pour plugins
2626                                or !empty($_REQUEST['var_ajax']) # forms ajax & inclure ajax de spip
2627                        )
2628                        and empty($_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
2629                );
2630        }
2631
2632        # nombre de pixels maxi pour calcul de la vignette avec gd
2633        # au dela de 5500000 on considere que php n'est pas limite en memoire pour cette operation
2634        # les configurations limitees en memoire ont un seuil plutot vers 1MPixel
2635        if (!defined('_IMG_GD_MAX_PIXELS')) {
2636                define('_IMG_GD_MAX_PIXELS',
2637                (isset($GLOBALS['meta']['max_taille_vignettes']) and $GLOBALS['meta']['max_taille_vignettes'])
2638                        ? $GLOBALS['meta']['max_taille_vignettes']
2639                        : 0);
2640        }
2641
2642        if (!defined('_MEMORY_LIMIT_MIN')) {
2643                define('_MEMORY_LIMIT_MIN', 16);
2644        } // en Mo
2645        // si on est dans l'espace prive et si le besoin est superieur a 8Mo (qui est vraiment le standard)
2646        // on verifie que la memoire est suffisante pour le compactage css+js pour eviter la page blanche
2647        // il y aura d'autres problemes et l'utilisateur n'ira pas tres loin, mais ce sera plus comprehensible qu'une page blanche
2648        if (test_espace_prive() and _MEMORY_LIMIT_MIN > 8) {
2649                if ($memory = trim(ini_get('memory_limit')) and $memory != -1) {
2650                        $unit = strtolower(substr($memory, strlen($memory / 1), 1));
2651                        switch ($unit) {
2652                                // Le modifieur 'G' est disponible depuis PHP 5.1.0
2653                                case 'g':
2654                                        $memory *= 1024;
2655                                case 'm':
2656                                        $memory *= 1024;
2657                                case 'k':
2658                                        $memory *= 1024;
2659                        }
2660                        if ($memory < _MEMORY_LIMIT_MIN * 1024 * 1024) {
2661                                @ini_set('memory_limit', $m = _MEMORY_LIMIT_MIN . 'M');
2662                                if (trim(ini_get('memory_limit')) != $m) {
2663                                        if (!defined('_INTERDIRE_COMPACTE_HEAD_ECRIRE')) {
2664                                                define('_INTERDIRE_COMPACTE_HEAD_ECRIRE', true);
2665                                        } // evite une page blanche car on ne saura pas calculer la css dans ce hit
2666                                }
2667                        }
2668                } else {
2669                        if (!defined('_INTERDIRE_COMPACTE_HEAD_ECRIRE')) {
2670                                define('_INTERDIRE_COMPACTE_HEAD_ECRIRE', true);
2671                        }
2672                } // evite une page blanche car on ne saura pas calculer la css dans ce hit
2673        }
2674        // Protocoles a normaliser dans les chaines de langues
2675        if (!defined('_PROTOCOLES_STD')) {
2676                define('_PROTOCOLES_STD', 'http|https|ftp|mailto|webcal');
2677        }
2678
2679        init_var_mode();
2680}
2681
2682// Reperer les variables d'URL qui conditionnent la perennite du cache, des urls
2683// ou d'autres petit caches (trouver_table, css et js compactes ...)
2684// http://code.spip.net/@init_var_mode
2685function init_var_mode() {
2686        static $done = false;
2687        if (!$done) {
2688
2689                if (isset($_GET['var_mode'])) {
2690                        $var_mode = explode(',', $_GET['var_mode']);
2691                        // tout le monde peut calcul/recalcul
2692                        if (!defined('_VAR_MODE')) {
2693                                if (in_array('recalcul', $var_mode)) {
2694                                        define('_VAR_MODE', 'recalcul');
2695                                } elseif (in_array('calcul', $var_mode)) {
2696                                        define('_VAR_MODE', 'calcul');
2697                                }
2698                        }
2699                        $var_mode = array_diff($var_mode, array('calcul', 'recalcul'));
2700                        if ($var_mode) {
2701                                include_spip('inc/autoriser');
2702                                // autoriser preview si preview seulement, et sinon autoriser debug
2703                                if (autoriser(
2704                                        ($_GET['var_mode'] == 'preview')
2705                                                ? 'previsualiser'
2706                                                : 'debug'
2707                                )) {
2708                                        if (in_array('traduction', $var_mode)) {
2709                                                // forcer le calcul pour passer dans traduire
2710                                                if (!defined('_VAR_MODE')) {
2711                                                        define('_VAR_MODE', 'calcul');
2712                                                }
2713                                                // et ne pas enregistrer de cache pour ne pas trainer les surlignages sur d'autres pages
2714                                                if (!defined('_VAR_NOCACHE')) {
2715                                                        define('_VAR_NOCACHE', true);
2716                                                }
2717                                                $var_mode = array_diff($var_mode, array('traduction'));
2718                                        }
2719                                        if (in_array('preview', $var_mode)) {
2720                                                // basculer sur les criteres de preview dans les boucles
2721                                                if (!defined('_VAR_PREVIEW')) {
2722                                                        define('_VAR_PREVIEW', true);
2723                                                }
2724                                                // forcer le calcul
2725                                                if (!defined('_VAR_MODE')) {
2726                                                        define('_VAR_MODE', 'calcul');
2727                                                }
2728                                                // et ne pas enregistrer de cache
2729                                                if (!defined('_VAR_NOCACHE')) {
2730                                                        define('_VAR_NOCACHE', true);
2731                                                }
2732                                                $var_mode = array_diff($var_mode, array('preview'));
2733                                        }
2734                                        if (in_array('inclure', $var_mode)) {
2735                                                // forcer le compilo et ignorer les caches existants
2736                                                if (!defined('_VAR_MODE')) {
2737                                                        define('_VAR_MODE', 'calcul');
2738                                                }
2739                                                if (!defined('_VAR_INCLURE')) {
2740                                                        define('_VAR_INCLURE', true);
2741                                                }
2742                                                // et ne pas enregistrer de cache
2743                                                if (!defined('_VAR_NOCACHE')) {
2744                                                        define('_VAR_NOCACHE', true);
2745                                                }
2746                                                $var_mode = array_diff($var_mode, array('inclure'));
2747                                        }
2748                                        if (in_array('urls', $var_mode)) {
2749                                                // forcer le compilo et ignorer les caches existants
2750                                                if (!defined('_VAR_MODE')) {
2751                                                        define('_VAR_MODE', 'calcul');
2752                                                }
2753                                                if (!defined('_VAR_URLS')) {
2754                                                        define('_VAR_URLS', true);
2755                                                }
2756                                                $var_mode = array_diff($var_mode, array('urls'));
2757                                        }
2758                                        if (in_array('images', $var_mode)) {
2759                                                // forcer le compilo et ignorer les caches existants
2760                                                if (!defined('_VAR_MODE')) {
2761                                                        define('_VAR_MODE', 'calcul');
2762                                                }
2763                                                // indiquer qu'on doit recalculer les images
2764                                                if (!defined('_VAR_IMAGES')) {
2765                                                        define('_VAR_IMAGES', true);
2766                                                }
2767                                                $var_mode = array_diff($var_mode, array('images'));
2768                                        }
2769                                        if (in_array('debug', $var_mode)) {
2770                                                if (!defined('_VAR_MODE')) {
2771                                                        define('_VAR_MODE', 'debug');
2772                                                }
2773                                                // et ne pas enregistrer de cache
2774                                                if (!defined('_VAR_NOCACHE')) {
2775                                                        define('_VAR_NOCACHE', true);
2776                                                }
2777                                                $var_mode = array_diff($var_mode, array('debug'));
2778                                        }
2779                                        if (count($var_mode) and !defined('_VAR_MODE')) {
2780                                                define('_VAR_MODE', reset($var_mode));
2781                                        }
2782                                        if (isset($GLOBALS['visiteur_session']['nom'])) {
2783                                                spip_log($GLOBALS['visiteur_session']['nom']
2784                                                        . " " . _VAR_MODE);
2785                                        }
2786                                } // pas autorise ?
2787                                else {
2788                                        // si on n'est pas connecte on se redirige
2789                                        if (!$GLOBALS['visiteur_session']) {
2790                                                include_spip('inc/headers');
2791                                                redirige_par_entete(generer_url_public('login',
2792                                                        'url=' . rawurlencode(
2793                                                                parametre_url(self(), 'var_mode', $_GET['var_mode'], '&')
2794                                                        ), true));
2795                                        }
2796                                        // sinon tant pis
2797                                }
2798                        }
2799                }
2800                if (!defined('_VAR_MODE')) {
2801                        define('_VAR_MODE', false);
2802                }
2803                $done = true;
2804        }
2805}
2806
2807// Annuler les magic quotes \' sur GET POST COOKIE et GLOBALS ;
2808// supprimer aussi les eventuels caracteres nuls %00, qui peuvent tromper
2809// la commande is_readable('chemin/vers/fichier/interdit%00truc_normal')
2810// http://code.spip.net/@spip_desinfecte
2811function spip_desinfecte(&$t, $deep = true) {
2812        static $magic_quotes;
2813        if (!isset($magic_quotes)) {
2814                $magic_quotes = @get_magic_quotes_gpc();
2815        }
2816
2817        foreach ($t as $key => $val) {
2818                if (is_string($t[$key])) {
2819                        if ($magic_quotes) {
2820                                $t[$key] = stripslashes($t[$key]);
2821                        }
2822                        $t[$key] = str_replace(chr(0), '-', $t[$key]);
2823                } // traiter aussi les "texte_plus" de article_edit
2824                else {
2825                        if ($deep and is_array($t[$key]) and $key !== 'GLOBALS') {
2826                                spip_desinfecte($t[$key], $deep);
2827                        }
2828                }
2829        }
2830}
2831
2832//  retourne le statut du visiteur s'il s'annonce
2833
2834// http://code.spip.net/@verifier_visiteur
2835function verifier_visiteur() {
2836        // Rq: pour que cette fonction marche depuis mes_options
2837        // il faut forcer l'init si ce n'est fait
2838        // mais on risque de perturber des plugins en initialisant trop tot
2839        // certaines constantes
2840        @spip_initialisation_core(
2841                (_DIR_RACINE . _NOM_PERMANENTS_INACCESSIBLES),
2842                (_DIR_RACINE . _NOM_PERMANENTS_ACCESSIBLES),
2843                (_DIR_RACINE . _NOM_TEMPORAIRES_INACCESSIBLES),
2844                (_DIR_RACINE . _NOM_TEMPORAIRES_ACCESSIBLES)
2845        );
2846
2847        // Demarrer une session NON AUTHENTIFIEE si on donne son nom
2848        // dans un formulaire sans login (ex: #FORMULAIRE_FORUM)
2849        // Attention on separe bien session_nom et nom, pour eviter
2850        // les melanges entre donnees SQL et variables plus aleatoires
2851        $variables_session = array('session_nom', 'session_email');
2852        foreach ($variables_session as $var) {
2853                if (_request($var) !== null) {
2854                        $init = true;
2855                        break;
2856                }
2857        }
2858        if (isset($init)) {
2859                #@spip_initialisation_suite();
2860                $session = charger_fonction('session', 'inc');
2861                $session();
2862                include_spip('inc/texte');
2863                foreach ($variables_session as $var) {
2864                        if (($a = _request($var)) !== null) {
2865                                $GLOBALS['visiteur_session'][$var] = safehtml($a);
2866                        }
2867                }
2868                if (!isset($GLOBALS['visiteur_session']['id_auteur'])) {
2869                        $GLOBALS['visiteur_session']['id_auteur'] = 0;
2870                }
2871                $session($GLOBALS['visiteur_session']);
2872
2873                return 0;
2874        }
2875
2876        $h = (isset($_SERVER['PHP_AUTH_USER']) and !$GLOBALS['ignore_auth_http']);
2877        if ($h or isset($_COOKIE['spip_session']) or isset($_COOKIE[$GLOBALS['cookie_prefix'] . '_session'])) {
2878
2879                $session = charger_fonction('session', 'inc');
2880                if ($session()) {
2881                        return $GLOBALS['visiteur_session']['statut'];
2882                }
2883                if ($h and isset($_SERVER['PHP_AUTH_PW'])) {
2884                        include_spip('inc/auth');
2885                        $h = lire_php_auth($_SERVER['PHP_AUTH_USER'], $_SERVER['PHP_AUTH_PW']);
2886                }
2887                if ($h) {
2888                        $GLOBALS['visiteur_session'] = $h;
2889
2890                        return $GLOBALS['visiteur_session']['statut'];
2891                }
2892        }
2893
2894        // au moins son navigateur nous dit la langue preferee de cet inconnu
2895        include_spip('inc/lang');
2896        utiliser_langue_visiteur();
2897
2898        return false;
2899}
2900
2901
2902/**
2903 * Sélectionne la langue donnée en argument et mémorise la courante
2904 *
2905 * Restaure l'ancienne langue si appellée sans argument.
2906 *
2907 * @note
2908 *     On pourrait économiser l'empilement en cas de non changemnt
2909 *     et lui faire retourner `False` pour prevenir l'appelant
2910 *     Le noyau de Spip sait le faire, mais pour assurer la compatibilité
2911 *     cette fonction retourne toujours non `False`
2912 *
2913 * @uses changer_langue()
2914 * @param null|string $lang
2915 *     - string : Langue à appliquer,
2916 *     - null : Pour restituer la dernière langue mémorisée.
2917 * @return string
2918 *     - string Langue utilisée.
2919 **/
2920function lang_select($lang = null) {
2921        static $pile_langues = array();
2922        if (!function_exists('changer_langue')) {
2923                include_spip('inc/lang');
2924        }
2925        if ($lang === null) {
2926                $lang = array_pop($pile_langues);
2927        } else {
2928                array_push($pile_langues, $GLOBALS['spip_lang']);
2929        }
2930        if (isset($GLOBALS['spip_lang']) and $lang == $GLOBALS['spip_lang']) {
2931                return $lang;
2932        }
2933        changer_langue($lang);
2934
2935        return $lang;
2936}
2937
2938/**
2939 * Renvoie une chaîne qui identifie la session courante
2940 *
2941 * Permet de savoir si on peut utiliser un cache enregistré pour cette session.
2942 * Cette chaîne est courte (8 cars) pour pouvoir être utilisée dans un nom
2943 * de fichier cache.
2944 *
2945 * @pipeline_appel definir_session
2946 *
2947 * @param bool $force
2948 * @return string
2949 *     Identifiant de la session
2950 **/
2951function spip_session($force = false) {
2952        static $session;
2953        if ($force or !isset($session)) {
2954                $s = pipeline('definir_session',
2955                        $GLOBALS['visiteur_session']
2956                                ? serialize($GLOBALS['visiteur_session'])
2957                                . '_' . @$_COOKIE['spip_session']
2958                                : ''
2959                );
2960                $session = $s ? substr(md5($s), 0, 8) : '';
2961        }
2962
2963        #spip_log('session: '.$session);
2964        return $session;
2965}
2966
2967
2968/**
2969 * Retourne un lien vers une aide
2970 *
2971 * Aide, aussi depuis l'espace privé à présent.
2972 * Surchargeable mais pas d'erreur fatale si indisponible.
2973 *
2974 * @param string $aide
2975 *    Cle d'identification de l'aide desiree
2976 * @param bool $distante
2977 *    Generer une url locale (par defaut)
2978 *    ou une url distante [directement sur spip.net]
2979 * @return Lien sur une icone d'aide
2980 **/
2981function aide($aide = '', $distante = false) {
2982        $aider = charger_fonction('aider', 'inc', true);
2983
2984        return $aider ? $aider($aide, '', array(), $distante) : '';
2985}
2986
2987/**
2988 * Page `exec=info` : retourne le contenu de la fonction php `phpinfo()`
2989 *
2990 * Si l’utiliseur est un webmestre.
2991 */
2992function exec_info_dist() {
2993
2994        if ($GLOBALS['connect_statut'] == '0minirezo' and $GLOBALS['visiteur_session']['webmestre'] == 'oui') {
2995                phpinfo();
2996        } else {
2997                echo "pas webmestre";
2998        }
2999}
3000
3001/**
3002 * Génère une erreur de squelette
3003 *
3004 * Génère une erreur de squelette qui sera bien visible par un
3005 * administrateur authentifié lors d'une visite de la page en erreur
3006 *
3007 * @param bool|string|array $message
3008 *     - Message d'erreur (string|array)
3009 *     - false pour retourner le texte des messages d'erreurs
3010 *     - vide pour afficher les messages d'erreurs
3011 * @param string|array|object $lieu
3012 *     Lieu d'origine de l'erreur
3013 * @return null|string
3014 *     - Rien dans la plupart des cas
3015 *     - string si $message à false.
3016 **/
3017function erreur_squelette($message = '', $lieu = '') {
3018        $debusquer = charger_fonction('debusquer', 'public');
3019        if (is_array($lieu)) {
3020                include_spip('public/compiler');
3021                $lieu = reconstruire_contexte_compil($lieu);
3022        }
3023
3024        return $debusquer($message, $lieu);
3025}
3026
3027/**
3028 * Calcule un squelette avec un contexte et retourne son contenu
3029 *
3030 * La fonction de base de SPIP : un squelette + un contexte => une page.
3031 * $fond peut etre un nom de squelette, ou une liste de squelette au format array.
3032 * Dans ce dernier cas, les squelettes sont tous evalues et mis bout a bout
3033 * $options permet de selectionner les options suivantes :
3034 *
3035 * - trim => true (valeur par defaut) permet de ne rien renvoyer si le fond ne produit que des espaces ;
3036 * - raw  => true permet de recuperer la strucure $page complete avec entetes et invalideurs
3037 *          pour chaque $fond fourni.
3038 *
3039 * @api
3040 * @param string /array $fond
3041 *     - Le ou les squelettes à utiliser, sans l'extension, {@example prive/liste/auteurs}
3042 *     - Le fichier sera retrouvé dans la liste des chemins connus de SPIP (squelettes, plugins, spip)
3043 * @param array $contexte
3044 *     - Informations de contexte envoyées au squelette, {@example array('id_rubrique' => 8)}
3045 *     - La langue est transmise automatiquement (sauf option étoile).
3046 * @param array $options
3047 *     Options complémentaires :
3048 *
3049 *     - trim   : applique un trim sur le résultat (true par défaut)
3050 *     - raw    : retourne un tableau d'information sur le squelette (false par défaut)
3051 *     - etoile : ne pas transmettre la langue au contexte automatiquement (false par défaut),
3052 *                équivalent de INCLURE*
3053 *     - ajax   : gere les liens internes du squelette en ajax (équivalent du paramètre {ajax})
3054 * @param string $connect
3055 *     Non du connecteur de bdd a utiliser
3056 * @return string|array
3057 *     - Contenu du squelette calculé
3058 *     - ou tableau d'information sur le squelette.
3059 */
3060function recuperer_fond($fond, $contexte = array(), $options = array(), $connect = '') {
3061        if (!function_exists('evaluer_fond')) {
3062                include_spip('public/assembler');
3063        }
3064        // assurer la compat avec l'ancienne syntaxe
3065        // (trim etait le 3eme argument, par defaut a true)
3066        if (!is_array($options)) {
3067                $options = array('trim' => $options);
3068        }
3069        if (!isset($options['trim'])) {
3070                $options['trim'] = true;
3071        }
3072
3073        if (isset($contexte['connect'])) {
3074                $connect = ($connect ? $connect : $contexte['connect']);
3075                unset($contexte['connect']);
3076        }
3077
3078        $texte = "";
3079        $pages = array();
3080        $lang_select = '';
3081        if (!isset($options['etoile']) or !$options['etoile']) {
3082                // Si on a inclus sans fixer le critere de lang, on prend la langue courante
3083                if (!isset($contexte['lang'])) {
3084                        $contexte['lang'] = $GLOBALS['spip_lang'];
3085                }
3086
3087                if ($contexte['lang'] != $GLOBALS['meta']['langue_site']) {
3088                        $lang_select = lang_select($contexte['lang']);
3089                }
3090        }
3091
3092        if (!isset($GLOBALS['_INC_PUBLIC'])) {
3093                $GLOBALS['_INC_PUBLIC'] = 0;
3094        }
3095
3096        $GLOBALS['_INC_PUBLIC']++;
3097
3098        // fix #4235  On mémorise l'état initial du sessionnement du contexte incluant
3099        $cache_utilise_session_appelant = (isset($GLOBALS['cache_utilise_session']) ? $GLOBALS['cache_utilise_session'] : null);
3100
3101        foreach (is_array($fond) ? $fond : array($fond) as $f) {
3102                unset($GLOBALS['cache_utilise_session']); // fix #4235 : Chaque inclusion commence sans sessionnement préallable
3103               
3104                $page = evaluer_fond($f, $contexte, $connect);
3105                if ($page === '') {
3106                        $c = isset($options['compil']) ? $options['compil'] : '';
3107                        $a = array('fichier' => $fond);
3108                        $erreur = _T('info_erreur_squelette2', $a); // squelette introuvable
3109                        erreur_squelette($erreur, $c);
3110                        // eviter des erreurs strictes ensuite sur $page['cle'] en PHP >= 5.4
3111                        $page = array('texte' => '', 'erreur' => $erreur);
3112                }
3113
3114                $page = pipeline('recuperer_fond', array(
3115                        'args' => array('fond' => $f, 'contexte' => $contexte, 'options' => $options, 'connect' => $connect),
3116                        'data' => $page
3117                ));
3118                if (isset($options['ajax']) and $options['ajax']) {
3119                        if (!function_exists('encoder_contexte_ajax')) {
3120                                include_spip('inc/filtres');
3121                        }
3122                        $page['texte'] = encoder_contexte_ajax(array_merge($contexte, array('fond' => $f)), '', $page['texte'],
3123                                $options['ajax']);
3124                }
3125
3126                if (isset($options['raw']) and $options['raw']) {
3127                        $pages[] = $page;
3128                } else {
3129                        $texte .= $options['trim'] ? rtrim($page['texte']) : $page['texte'];
3130                }
3131               
3132                // fix #4235 : contamination de la session appelante, pour les inclusions statiques
3133                if (isset($options['sessionnement_contaminant'])
3134                    and isset($page['invalideurs']['session']))
3135                        $cache_utilise_session_appelant = $page['invalideurs']['session'];
3136        }
3137
3138        // fix #4235 : restaurer le sessionnement du contexte appelant,
3139        // éventuellement contaminé si on vient de récupérer une inclusion statique sessionnée
3140        $GLOBALS['cache_utilise_session']
3141                = (isset($cache_utilise_session_appelant) ? $cache_utilise_session_appelant : null);
3142
3143        $GLOBALS['_INC_PUBLIC']--;
3144
3145        if ($lang_select) {
3146                lang_select();
3147        }
3148        if (isset($options['raw']) and $options['raw']) {
3149                return is_array($fond) ? $pages : reset($pages);
3150        } else {
3151                return $options['trim'] ? ltrim($texte) : $texte;
3152        }
3153}
3154
3155/**
3156 * Trouve un squelette dans le repertoire modeles/
3157 *
3158 * @param  $nom
3159 * @return string
3160 */
3161function trouve_modele($nom) {
3162        return trouver_fond($nom, 'modeles/');
3163}
3164
3165/**
3166 * Trouver un squelette dans le chemin
3167 * on peut specifier un sous-dossier dans $dir
3168 * si $pathinfo est a true, retourne un tableau avec
3169 * les composantes du fichier trouve
3170 * + le chemin complet sans son extension dans fond
3171 *
3172 * @param string $nom
3173 * @param string $dir
3174 * @param bool $pathinfo
3175 * @return array|string
3176 */
3177function trouver_fond($nom, $dir = '', $pathinfo = false) {
3178        $f = find_in_path($nom . '.' . _EXTENSION_SQUELETTES, $dir ? rtrim($dir, '/') . '/' : '');
3179        if (!$pathinfo) {
3180                return $f;
3181        }
3182        // renvoyer un tableau detaille si $pathinfo==true
3183        $p = pathinfo($f);
3184        if (!isset($p['extension']) or !$p['extension']) {
3185                $p['extension'] = _EXTENSION_SQUELETTES;
3186        }
3187        if (!isset($p['extension']) or !$p['filename']) {
3188                $p['filename'] = ($p['basename'] ? substr($p['basename'], 0, -strlen($p['extension']) - 1) : '');
3189        }
3190        $p['fond'] = ($f ? substr($f, 0, -strlen($p['extension']) - 1) : '');
3191
3192        return $p;
3193}
3194
3195/**
3196 * Teste, pour un nom de page de l'espace privé, s'il est possible
3197 * de générer son contenu.
3198 *
3199 * Dans ce cas, on retourne la fonction d'exécution correspondante à utiliser
3200 * (du répertoire `ecrire/exec`). Deux cas particuliers et prioritaires :
3201 * `fond` ou `fond_monobloc` sont retournés si des squelettes existent.
3202 *
3203 * - `fond` : pour des squelettes de `prive/squelettes/contenu`
3204 *          ou pour des objets éditoriaux dont les suqelettes seront échaffaudés
3205 * - `fond_monobloc` (compatibilité avec SPIP 2.1) : pour des squelettes de `prive/exec`
3206 *
3207 * @param string $nom
3208 *     Nom de la page
3209 * @return string
3210 *     Nom de l'exec, sinon chaîne vide.
3211 **/
3212function tester_url_ecrire($nom) {
3213        static $exec = array();
3214        if (isset($exec[$nom])) {
3215                return $exec[$nom];
3216        }
3217        // tester si c'est une page en squelette
3218        if (trouver_fond($nom, 'prive/squelettes/contenu/')) {
3219                return $exec[$nom] = 'fond';
3220        } // compat skels orthogonaux version precedente
3221        elseif (trouver_fond($nom, 'prive/exec/')) {
3222                return $exec[$nom] = 'fond_monobloc';
3223        } // echafaudage d'un fond !
3224        elseif (include_spip('public/styliser_par_z') and z_echafaudable($nom)) {
3225                return $exec[$nom] = 'fond';
3226        }
3227        // attention, il ne faut pas inclure l'exec ici
3228        // car sinon #URL_ECRIRE provoque des inclusions
3229        // et des define intrusifs potentiels
3230        return $exec[$nom] = ((find_in_path("{$nom}.php", 'exec/') or charger_fonction($nom, 'exec', true)) ? $nom : '');
3231}
3232
3233
3234/**
3235 * Tente de charger dynamiquement une extension PHP
3236 *
3237 * @example
3238 *     ```
3239 *     $ok = charger_php_extension('sqlite');
3240 *     ```
3241 * @uses inc_charger_php_extension_dist() Si la librairie n'est pas déjà charchée
3242 *
3243 * @param string $module Nom du module à charger
3244 * @return bool true si le module est chargé
3245 **/
3246function charger_php_extension($module) {
3247        if (extension_loaded($module)) {
3248                return true;
3249        } else {
3250                $charger_php_extension = charger_fonction('charger_php_extension', 'inc');
3251
3252                return $charger_php_extension($module);
3253        }
3254}
3255
3256
3257/**
3258 * Indique si le code HTML5 est permis sur le site public
3259 *
3260 * @return bool
3261 *     true si et seulement si la configuration autorise le code HTML5 sur le site public
3262 **/
3263function html5_permis() {
3264        return (isset($GLOBALS['meta']['version_html_max'])
3265                and ('html5' == $GLOBALS['meta']['version_html_max']));
3266}
3267
3268/*
3269 * Bloc de compatibilite : quasiment tous les plugins utilisent ces fonctions
3270 * desormais depreciees ; plutot que d'obliger tout le monde a charger
3271 * vieilles_defs, on va assumer l'histoire de ces 3 fonctions ubiquitaires
3272 */
3273
3274/**
3275 * lire_meta : fonction dépréciée
3276 *
3277 * @deprecated Utiliser `$GLOBALS['meta'][$nom]` ou `lire_config('nom')`
3278 * @see lire_config()
3279 * @param string $nom Clé de meta à lire
3280 * @return mixed Valeur de la meta.
3281 **/
3282function lire_meta($nom) {
3283        return isset($GLOBALS['meta'][$nom]) ? $GLOBALS['meta'][$nom] : null;
3284}
3285
3286
3287/**
3288 * ecrire_metas : fonction dépréciée
3289 *
3290 * @deprecated
3291 **/
3292function ecrire_metas() { }
3293
3294/**
3295 * Retourne une ligne d'un résultat de requête mysql (déprécié)
3296 *
3297 * @see sql_fetch()
3298 * @deprecated Utiliser sql_fetch()
3299 * @param Ressource $r Ressource mysql
3300 * @param int|null $t Type de retour
3301 * @return array|void|bool Tableau de la ligne SQL
3302 **/
3303function spip_fetch_array($r, $t = null) {
3304        if (!isset($t)) {
3305                if ($r) {
3306                        return sql_fetch($r);
3307                }
3308        } else {
3309                if ($t == 'SPIP_NUM') {
3310                        $t = MYSQLI_NUM;
3311                }
3312                if ($t == 'SPIP_BOTH') {
3313                        $t = MYSQLI_BOTH;
3314                }
3315                if ($t == 'SPIP_ASSOC') {
3316                        $t = MYSQLI_ASSOC;
3317                }
3318                spip_log("appel deprecie de spip_fetch_array(..., $t)", 'vieilles_defs');
3319                if ($r) {
3320                        return mysqli_fetch_array($r, $t);
3321                }
3322        }
3323}
3324
3325/**
3326 * Poser une alerte qui sera affiche aux auteurs de bon statut ('' = tous)
3327 * au prochain passage dans l'espace prive
3328 * chaque alerte doit avoir un nom pour eviter duplication a chaque hit
3329 * les alertes affichees une fois sont effacees
3330 *
3331 * @param string $nom
3332 * @param string $message
3333 * @param string $statut
3334 */
3335function avertir_auteurs($nom, $message, $statut = '') {
3336        $alertes = $GLOBALS['meta']['message_alertes_auteurs'];
3337        if (!$alertes
3338                or !is_array($alertes = unserialize($alertes))
3339        ) {
3340                $alertes = array();
3341        }
3342
3343        if (!isset($alertes[$statut])) {
3344                $alertes[$statut] = array();
3345        }
3346        $alertes[$statut][$nom] = $message;
3347        ecrire_meta("message_alertes_auteurs", serialize($alertes));
3348}
Note: See TracBrowser for help on using the repository browser.