www/ecrire/inc/utils.php

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