ecrire/public/references.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2007                                                *
   7  *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
   8  *                                                                         *
   9  *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
  10  *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
  11 \***************************************************************************/
  12
  13
  14
  15 // fonctions de recherche et de reservation
  16 // dans l'arborescence des boucles
  17
  18 if (!defined("_ECRIRE_INC_VERSION")) return;
  19
  20 // index_pile retourne la position dans la pile du champ SQL $nom_champ
  21 // en prenant la boucle la plus proche du sommet de pile (indique par $idb).
  22 // Si on ne trouve rien, on considere que ca doit provenir du contexte
  23 // (par l'URL ou l'include) qui a ete recopie dans Pile[0]
  24 // (un essai d'affinage a debouche sur un bug vicieux)
  25 // Si ca reference un champ SQL, on le memorise dans la structure $boucles
  26 // afin de construire un requete SQL minimale (plutot qu'un brutal 'SELECT *')
  27
  28 // http://doc.spip.org/@index_pile
  29 function index_pile($idb, $nom_champ, &$boucles, $explicite='') {
  30   global $exceptions_des_tables, $table_des_tables, $tables_des_serveurs_sql;
  31
  32         $i = 0;
  33         if (strlen($explicite)) {
  34         // Recherche d'un champ dans un etage superieur
  35           while (($idb != $explicite) && ($idb !='')) {
  36 #               spip_log("Cherchexpl: $nom_champ '$explicite' '$idb' '$i'");
  37                         $i++;
  38                         $idb = $boucles[$idb]->id_parent;
  39                 }
  40         }
  41
  42 #       spip_log("Cherche: $nom_champ a partir de '$idb'");
  43         $nom_champ = strtolower($nom_champ);
  44         // attention: entre la boucle nommee 0, "" et le tableau vide,
  45         // il y a incoherences qu'il vaut mieux eviter
  46         while (isset($boucles[$idb])) {
  47                 list ($t, $c) = index_tables_en_pile($idb, $nom_champ, $boucles);
  48                 if ($t) {
  49                   if (!in_array($t, $boucles[$idb]->select))
  50                     $boucles[$idb]->select[] = $t;
  51                   return '$Pile[$SP' . ($i ? "-$i" : "") . '][\'' . $c . '\']';
  52                 }
  53 #               spip_log("On remonte vers $i");
  54                 // Sinon on remonte d'un cran
  55                 $idb = $boucles[$idb]->id_parent;
  56                 $i++;
  57         }
  58
  59 #       spip_log("Pas vu $nom_champ");
  60         // esperons qu'il y sera
  61         return('$Pile[0][\''. strtolower($nom_champ) . '\']');
  62 }
  63
  64 /**
  65  * retourne la description de la table associee a un type de boucle
  66  * retourne un tableau avec les entrees field et key (comme dans serial.php)
  67  * et type = type de boucle, serveur = serveur bdd associe et table = nom de
  68  * la table concernee
  69  * retourne null si on ne trouve pas la table
  70  */
  71 // http://doc.spip.org/@description_type_requete
  72 function description_type_requete($type, $serveur='') {
  73         global $table_des_tables, $tables_des_serveurs_sql;
  74
  75         if (!$serveur) {
  76                 $s = 'localhost';
  77         // indirection (pour les rares cas ou le nom de la table!=type)
  78                 $t = $table_des_tables[$type];
  79         } else $s = $serveur;
  80         // pour les tables non Spip
  81         if (!$t) {
  82                 $nom_table = $t = $type;
  83         } else {
  84                 $nom_table = 'spip_' . $t;
  85         }
  86
  87         $desc = $tables_des_serveurs_sql[$s][$nom_table];
  88         if (!isset($desc['field'])) {
  89                 $desc = $table_des_tables[$type] ?
  90                         (($GLOBALS['table_prefix'] ? $GLOBALS['table_prefix'] : 'spip')
  91                                 . '_' . $t) : $nom_table;
  92
  93                 $desc = spip_abstract_showtable($desc, $serveur);
  94                 if (!isset($desc['field']))
  95                         return null;
  96                 $tables_des_serveurs_sql[$s][$nom_table]= $desc;
  97         }
  98         $desc['serveur']= $s;
  99         $desc['type']= $t;
 100         $desc['table']= $nom_table;
 101
 102         return $desc;
 103 }
 104
 105 // http://doc.spip.org/@index_tables_en_pile
 106 function index_tables_en_pile($idb, $nom_champ, &$boucles) {
 107         global $exceptions_des_tables;
 108
 109         $r = $boucles[$idb]->type_requete;
 110         $s = $boucles[$idb]->sql_serveur;
 111
 112         $desc= description_type_requete($r, $s);
 113
 114         if(!$desc) {
 115                 erreur_squelette(_T('zbug_table_inconnue', array('table' => $r)),
 116                                    "'$idb'");
 117                 # continuer pour chercher l'erreur suivante
 118                 return  array("'#" . $r . ':' . $nom_champ . "'",'');
 119         }
 120
 121         $t= $desc['type'];
 122         $excep = isset($exceptions_des_tables[$r]) ? $exceptions_des_tables[$r] : '';
 123         if ($excep)
 124                 $excep = isset($excep[$nom_champ]) ? $excep[$nom_champ] : '';
 125
 126         if ($excep) {
 127           return index_exception($boucles[$idb], $desc, $nom_champ, $excep);
 128         } else {
 129                 if (isset($desc['field'][$nom_champ]))
 130                         return array("$t.$nom_champ", $nom_champ);
 131                 else {
 132                   if ($boucles[$idb]->jointures_explicites) {
 133                     $t = trouver_champ_exterieur($nom_champ,
 134                                                  $boucles[$idb]->jointures,
 135                                                  $boucles[$idb]);
 136                     if ($t)
 137                         return index_exception($boucles[$idb],
 138                                                $desc,
 139                                                $nom_champ,
 140                                                array($t[0], $nom_champ));
 141                   }
 142                   return array('','');
 143                 }
 144         }
 145 }
 146
 147 // Reference a une entite SPIP alias d'un champ SQL
 148 // Ca peut meme etre d'un champ dans une jointure
 149 // qu'il faut provoquer si ce n'est fait
 150
 151 // http://doc.spip.org/@index_exception
 152 function index_exception(&$boucle, $desc, $nom_champ, $excep)
 153 {
 154         global $tables_des_serveurs_sql;
 155
 156         if (is_array($excep)) {
 157                 // permettre aux plugins de gerer eux meme des jointures derogatoire ingérables
 158                 $t = NULL;
 159                 if (count($excep)==3){
 160                         $index_exception_derogatoire = array_pop($excep);
 161                         $t = $index_exception_derogatoire($boucle, $desc, $nom_champ, $excep);
 162                 }
 163                 if ($t == NULL) {
 164                         list($e, $x) = $excep;  #PHP4 affecte de gauche a droite
 165                         $excep = $x;            #PHP5 de droite a gauche !
 166                         if (!$t = array_search($e, $boucle->from)) {
 167                                 $t = 'J' . count($boucle->from);
 168                                 $boucle->from[$t] = $e;
 169                                 $j = $tables_des_serveurs_sql[$desc['serveur']][$e];
 170         # essayer ca un jour:   list($nom, $j) = trouver_def_table($e, $boucle);
 171                                 $j = $j['key']['PRIMARY KEY'];
 172                                 $boucle->where[]= array("'='", "'$boucle->id_table." . "$j'", "'$t.$j'");
 173                                 }
 174                 }
 175         }
 176         else $t = $desc['type'];
 177         // demander a SQL de gerer le synonyme
 178         // ca permet que excep soit dynamique (Cedric, 2/3/06)
 179         if ($excep != $nom_champ) $excep .= ' AS '. $nom_champ;
 180         return array("$t.$excep", $nom_champ);
 181 }
 182
 183
 184 // cette fonction sert d'API pour demander le champ '$champ' dans la pile
 185 // http://doc.spip.org/@champ_sql
 186 function champ_sql($champ, $p) {
 187         return index_pile($p->id_boucle, $champ, $p->boucles, $p->nom_boucle);
 188 }
 189
 190 // cette fonction sert d'API pour demander une balise Spip avec filtres
 191
 192 // http://doc.spip.org/@calculer_champ
 193 function calculer_champ($p) {
 194         $p = calculer_balise($p->nom_champ, $p);
 195         return applique_filtres($p);
 196 }
 197
 198 // Cette fonction sert d'API pour demander une balise SPIP sans filtres.
 199 // Pour une balise nommmee NOM, elle demande a charger_fonction de chercher
 200 // s'il existe une fonction balise_NOM ou balise_NOM_dist
 201 // eventuellement en chargeant le fichier balise/NOM.php.
 202 // Si ce n'est pas le cas, hormis le cas historique des balise LOGO_*,
 203 // elle estime que c'est une reference a une colonne de table connue.
 204 // Les surcharges via charger_fonction sont donc possibles.
 205
 206 // http://doc.spip.org/@calculer_balise
 207 function calculer_balise($nom, $p) {
 208
 209         // S'agit-t-il d'une balise_XXXX[_dist]() ?
 210         if ($f = charger_fonction($nom, 'balise', true)) {
 211                 $res = $f($p);
 212                 if ($res !== NULL)
 213                         return $res;
 214         }
 215
 216         // S'agit-il d'un logo ? Une fonction speciale les traite tous
 217         if (ereg('^LOGO_', $nom)) {
 218                 if (!function_exists($f = 'calculer_balise_logo')) $f .= '_dist';
 219                 $res = $f($p);
 220                 if ($res !== NULL)
 221                         return $res;
 222         }
 223
 224         // ca pourrait etre un champ SQL homonyme,
 225         $p->code = index_pile($p->id_boucle, $nom, $p->boucles, $p->nom_boucle);
 226
 227         // compatibilite: depuis qu'on accepte #BALISE{ses_args} sans [(...)] autour
 228         // il faut recracher {...} quand ce n'est finalement pas des args
 229         if ($p->fonctions AND (!$p->fonctions[0][0]) AND $p->fonctions[0][1]) {
 230                 $code = addslashes($p->fonctions[0][1]);
 231                 $p->code .= " . '$code'";
 232         }
 233
 234         // ne pas passer le filtre securite sur les id_xxx
 235         if (strpos($nom, 'ID_') === 0)
 236                 $p->interdire_scripts = false;
 237
 238         // Compatibilite ascendante avec les couleurs html (#FEFEFE) :
 239         // SI le champ SQL n'est pas trouve
 240         // ET si la balise a une forme de couleur
 241         // ET s'il n'y a ni filtre ni etoile
 242         // ALORS retourner la couleur.
 243         // Ca permet si l'on veut vraiment de recuperer [(#ACCEDE*)]
 244         if (preg_match("/^[A-F]{1,6}$/i", $nom)
 245         AND !$p->etoile
 246         AND !$p->fonctions) {
 247                 $p->code = "'#$nom'";
 248                 $p->interdire_scripts = false;
 249         }
 250
 251         return $p;
 252 }
 253
 254 /*
 255
 256 L'appel direct de #ARTICLE_TRADUCTIONS devient #MODELE{article_traductions}
 257
 258 // fonction speciale d'appel a un modele modeles/truc.html pour la balise #TRUC
 259 // exemples : #TRADUCTIONS, #DOC, #IMG...
 260 // http://doc.spip.org/@calculer_balise_modele_dist
 261 function calculer_balise_modele_dist($p){
 262         $nom = strtolower($p->nom_champ);
 263         $contexte = array();
 264
 265         if (isset($p->param[0])){
 266                 while (count($p->param[0])>2){
 267                         $p->param[]=array($p->param[0][0],array_pop($p->param[0]));
 268                 }
 269         }
 270 print_r($p->param);
 271         $champ = phraser_arguments_inclure($p, true);
 272         // a priori true
 273         // si false, le compilo va bloquer sur des syntaxes avec un filtre sans argument qui suit la balise
 274         // si true, les arguments simples (sans truc=chose) vont degager
 275         $code_contexte = argumenter_inclure($champ, $p->descr, $p->boucles, $p->id_boucle, false);
 276
 277         // Si le champ existe dans la pile, on le met dans le contexte
 278         // (a priori c'est du code mort ; il servait pour #LESAUTEURS dans
 279         // le cas spip_syndic_articles)
 280         #$code_contexte[] = "'$nom='.".champ_sql($nom, $p);
 281
 282         // Reserver la cle primaire de la boucle courante
 283         if ($primary = $p->boucles[$p->id_boucle]->primary) {
 284                 $id = champ_sql($primary, $p);
 285                 $code_contexte[] = "'$primary='.".$id;
 286         }
 287
 288 #print_r($code_contexte);
 289
 290         $p->code = "( ((\$recurs=(isset(\$Pile[0]['recurs'])?\$Pile[0]['recurs']:0))<5)?
 291         recuperer_fond('modeles/".$nom."',
 292                 creer_contexte_de_modele(array(".join(',', $code_contexte).",'recurs='.++\$recurs, \$GLOBALS['spip_lang']))):'')";
 293         $p->interdire_scripts = false; // securite assuree par le squelette
 294
 295 print $p->code."\n<hr/>\n";
 296
 297         return $p;
 298 }
 299 */
 300
 301 //
 302 // Traduction des balises dynamiques, notamment les "formulaire_*"
 303 // Inclusion du fichier associe a son nom.
 304 // Ca donne les arguments a chercher dans la pile,on compile leur localisation
 305 // Ensuite on delegue a une fonction generale definie dans executer_squelette
 306 // qui recevra a l'execution la valeur des arguments,
 307 // ainsi que les pseudo filtres qui ne sont donc pas traites a la compil
 308 // mais on traite le vrai parametre si present.
 309
 310 // http://doc.spip.org/@calculer_balise_dynamique
 311 function calculer_balise_dynamique($p, $nom, $l) {
 312
 313         balise_distante_interdite($p);
 314         $param = "";
 315         if ($a = $p->param) {
 316                 $c = array_shift($a);
 317                 if  (!array_shift($c)) {
 318                   $p->fonctions = $a;
 319                   array_shift( $p->param );
 320                   $param = compose_filtres_args($p, $c, ',');
 321                 }
 322         }
 323         $collecte = join(',',collecter_balise_dynamique($l, $p, $nom));
 324         $p->code = "executer_balise_dynamique('" . $nom . "',\n\tarray("
 325           . $collecte
 326           . ($collecte ? $param : substr($param,1)) # virer la virgule
 327           . "),\n\tarray("
 328           . argumenter_balise($p->param, "', '")
 329           . "), \$GLOBALS['spip_lang'],"
 330           . $p->ligne
 331           . ')';
 332         $p->interdire_scripts = false;
 333         $p->fonctions = array();
 334         $p->param = array();
 335
 336         return $p;
 337 }
 338
 339 // Construction du tableau des arguments d'une balise dynamique.
 340 // Ces arguments peuvent etre eux-meme des balises (cf FORMULAIRE_SIGNATURE)
 341 // mais gare au bouclage (on peut s'aider de $nom pour le reperer au besoin)
 342
 343 // http://doc.spip.org/@collecter_balise_dynamique
 344 function collecter_balise_dynamique($l, &$p, $nom) {
 345         $args = array();
 346         foreach($l as $c) { $x = calculer_balise($c, $p); $args[] = $x->code;}
 347         return $args;
 348 }
 349
 350
 351 // il faudrait savoir traiter les formulaires en local
 352 // tout en appelant le serveur SQL distant.
 353 // En attendant, cette fonction permet de refuser une authentification
 354 // sur qqch qui n'a rien a voir.
 355
 356 // http://doc.spip.org/@balise_distante_interdite
 357 function balise_distante_interdite($p) {
 358         $nom = $p->id_boucle;
 359         if ($nom AND $p->boucles[$nom]->sql_serveur) {
 360                 erreur_squelette($p->nom_champ .' '._T('zbug_distant_interdit'), $nom);
 361         }
 362 }
 363
 364
 365 //
 366 // Traitements standard de divers champs
 367 // definis par $table_des_traitements, cf. inc-compilo-api.php3
 368 //
 369 // http://doc.spip.org/@champs_traitements
 370 function champs_traitements ($p) {
 371         global $table_des_traitements;
 372
 373         if (!isset($table_des_traitements[$p->nom_champ]))
 374                 return $p->code;
 375         $ps = $table_des_traitements[$p->nom_champ];
 376         if (is_array($ps)) {
 377           // new style
 378
 379                 if ($p->nom_boucle)
 380                         $type = $p->boucles[$p->nom_boucle]->type_requete;
 381                 else
 382                         $type = $p->type_requete;
 383                 $ps = $ps[isset($ps[$type]) ? $type : 0];
 384         }
 385
 386         if (!$ps) return $p->code;
 387
 388         // Si une boucle sous-jacente (?) traite les documents, on insere ici
 389         // une fonction de remplissage du tableau des doublons -- mais seulement
 390         // si on rencontre le filtre propre (qui traite les
 391         // raccourcis <docXX> qui nous interessent)
 392         if (isset($p->descr['documents'])
 393         AND preg_match(',propre,', $ps))
 394                 $ps = 'traiter_doublons_documents($doublons, '.$ps.')';
 395
 396         // De meme, en cas de sql_serveur, on supprime les < IMGnnn > tant
 397         // qu'on ne rapatrie pas les documents distants joints..
 398         // il faudrait aussi corriger les raccourcis d'URL locales
 399         if ($p->id_boucle  AND $p->boucles[$p->id_boucle]->sql_serveur)
 400                 $p->code = 'supprime_img(' . $p->code . ')';
 401
 402
 403         // Passer |safehtml sur les boucles "sensibles"
 404         // sauf sur les champs dont on est surs
 405         switch ($p->type_requete) {
 406                 case 'forums':
 407                 case 'signatures':
 408                 case 'syndic_articles':
 409                         $champs_surs = array(
 410                         'date', 'date_heure', 'statut', 'ip', 'url_article', 'maj', 'idx',
 411                         'parametres_forum');
 412                         if (!in_array(strtolower($p->nom_champ), $champs_surs)
 413                         AND !preg_match(',^ID_,', $p->nom_champ))
 414                                 $ps = 'safehtml('.$ps.')';
 415                         break;
 416                 default:
 417                         break;
 418         }
 419
 420         // Remplacer enfin le placeholder %s par le vrai code de la balise
 421         return str_replace('%s', $p->code, $ps);
 422 }
 423
 424
 425 //
 426 // Appliquer les filtres a un champ [(#CHAMP|filtre1|filtre2)]
 427 // retourne un code php compile exprimant ce champ filtre et securise
 428 //  - une etoile => pas de processeurs standards
 429 //  - deux etoiles => pas de securite non plus !
 430 //
 431 // http://doc.spip.org/@applique_filtres
 432 function applique_filtres($p) {
 433
 434         // Traitements standards (cf. supra)
 435         if ($p->etoile == '')
 436                 $code = champs_traitements($p);
 437         else
 438                 $code = $p->code;
 439
 440         // Appliquer les filtres perso
 441         if ($p->param)
 442                 $code = compose_filtres($p, $code);
 443
 444         // Securite
 445         if ($p->interdire_scripts
 446         AND $p->etoile != '**')
 447                 $code = "interdire_scripts($code)";
 448
 449         return $code;
 450 }
 451
 452 // Cf. function pipeline dans ecrire/inc_utils.php
 453 // http://doc.spip.org/@compose_filtres
 454 function compose_filtres($p, $code) {
 455         foreach($p->param as $filtre) {
 456                 $fonc = array_shift($filtre);
 457                 if ($fonc) {
 458                         // recuperer les arguments du filtre, les separer par des virgules
 459                         // *sauf* dans le cas du filtre "?" qui demande un ":"
 460                         if ($fonc == '?') {
 461                                 // |?{a,b} *doit* avoir exactement 2 arguments ; on les force
 462                                 if (count($filtre) != 2)
 463                                         $filtre = array($filtre[0], $filtre[1]);
 464                                 $arglist = compose_filtres_args($p, $filtre, ':');
 465                         } else
 466                                 $arglist = compose_filtres_args($p, $filtre, ',');
 467
 468                         // le filtre est defini dans la matrice ? il faut alors l'appeler
 469                         // de maniere indirecte, pour charger au prealable sa definition
 470                         if (isset($GLOBALS['spip_matrice'][$fonc])) {
 471                                 $code = "filtrer('$fonc',$code$arglist)";
 472                         }
 473                         // le filtre est defini sous forme de fonction ou de methode
 474                         // par ex. dans inc_texte, inc_filtres ou mes_fonctions
 475                         else if (function_exists($fonc)
 476                                 OR (preg_match("/^(\w*)::(\w*)$/", $fonc, $regs)
 477                                         AND is_callable(array($regs[1], $regs[2]))
 478                         ))
 479                                 $code = "$fonc($code$arglist)";
 480                         // est-ce un test ?
 481                         else if (strpos("x < > <= >= == === != !== <> ? ", " $fonc "))
 482                                 $code = "($code $fonc " . substr($arglist,1) . ')';
 483                         else
 484                                 $code = "erreur_squelette('"
 485                                 .texte_script(_T('zbug_erreur_filtre', array('filtre'=>$fonc)))
 486                                 ."','" . $p->id_boucle . "')";
 487                 }
 488         }
 489         return $code;
 490 }
 491
 492 // http://doc.spip.org/@compose_filtres_args
 493 function compose_filtres_args($p, $args, $sep)
 494 {
 495         $arglist = "";
 496         foreach ($args as $arg) {
 497                 $arglist .= $sep .
 498                   calculer_liste($arg, $p->descr, $p->boucles, $p->id_boucle);
 499         }
 500         return $arglist;
 501 }
 502
 503 //
 504 // Reserve les champs necessaires a la comparaison avec le contexte donne par
 505 // la boucle parente ; attention en recursif il faut les reserver chez soi-meme
 506 // ET chez sa maman
 507 //
 508 // http://doc.spip.org/@calculer_argument_precedent
 509 function calculer_argument_precedent($idb, $nom_champ, &$boucles) {
 510
 511         // si recursif, forcer l'extraction du champ SQL mais ignorer le code
 512         if ($boucles[$idb]->externe)
 513                 index_pile ($idb, $nom_champ, $boucles);
 514         // retourner $Pile[$SP] et pas $Pile[0] (bug recursion en 1ere boucle)
 515         $prec = $boucles[$idb]->id_parent;
 516         return (($prec==="") ? ('$Pile[$SP][\''.$nom_champ.'\']') :
 517                 index_pile($prec, $nom_champ, $boucles));
 518 }
 519
 520 //
 521 // Rechercher dans la pile des boucles actives celle ayant un critere
 522 // comportant un certain $motif, et construire alors une reference
 523 // a l'environnement de cette boucle, qu'on indexe avec $champ.
 524 // Sert a referencer une cellule non declaree dans la table et pourtant la.
 525 // Par exemple pour la balise #POINTS on produit $Pile[$SP-n]['points']
 526 // si la n-ieme boucle a un critere "recherche", car on sait qu'il a produit
 527 // "SELECT XXXX AS points"
 528 //
 529
 530 // http://doc.spip.org/@rindex_pile
 531 function rindex_pile($p, $champ, $motif)
 532 {
 533         $n = 0;
 534         $b = $p->id_boucle;
 535         $p->code = '';
 536         while ($b != '') {
 537         if ($s = $p->boucles[$b]->param) {
 538           foreach($s as $v) {
 539                 if (strpos($v[1][0]->texte,$motif) !== false) {
 540                   $p->code = '$Pile[$SP' . (($n==0) ? "" : "-$n") .
 541                         "]['$champ']";
 542                   $b = '';
 543                   break;
 544                 }
 545           }
 546         }
 547         $n++;
 548         $b = $p->boucles[$b]->id_parent;
 549         }
 550         if (!$p->code) {
 551                 erreur_squelette(_T('zbug_champ_hors_motif',
 552                         array('champ' => '#' . strtoupper($champ),
 553                                 'motif' => $motif)
 554                 ), $p->id_boucle);
 555         }
 556         $p->interdire_scripts = false;
 557         return $p;
 558 }
 559
 560 ?>