www/ecrire/balise/url_.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2017                                                *
   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  * Fonctions génériques pour les balises `#URL_XXXX`
  15  *
  16  * Les balises `URL_$type` sont génériques, sauf quelques cas particuliers.
  17  *
  18  * @package SPIP\Core\Compilateur\Balises
  19  **/
  20
  21 if (!defined('_ECRIRE_INC_VERSION')) {
  22         return;
  23 }
  24
  25 /**
  26  * Génère le code compilé des balises d'URL
  27  *
  28  * Utilise le premier paramètre de la balise d'URL comme identifiant d'objet
  29  * s'il est donné, sinon le prendra dans un champ d'une boucle englobante.
  30  *
  31  * @uses generer_generer_url_arg()
  32  * @param string $type
  33  *     Type d'objet
  34  * @param Champ $p
  35  *     Pile au niveau de la balise
  36  * @return string
  37  *     Code compilé
  38  **/
  39 function generer_generer_url($type, $p) {
  40         $_id = interprete_argument_balise(1, $p);
  41
  42         if (!$_id) {
  43                 $primary = id_table_objet($type);
  44                 $_id = champ_sql($primary, $p);
  45         }
  46
  47         return generer_generer_url_arg($type, $p, $_id);
  48 }
  49
  50 /**
  51  * Génère le code compilé des balises d'URL (en connaissant l'identifiant)
  52  *
  53  * - Si ces balises sont utilisées pour la base locale,
  54  *   production des appels à `generer_url_entite(id-courant, entite)`
  55  * - Si la base est externe et sous SPIP, on produit
  56  *
  57  *   - l'URL de l'objet si c'est une pièce jointe, ou sinon
  58  *   - l'URL du site local appliqué sur l'objet externe,
  59  *     ce qui permet de le voir à travers les squelettes du site local
  60  *
  61  * On communique le type-url distant à `generer_url_entite` mais il ne sert pas
  62  * car rien ne garantit que le .htaccess soit identique. À approfondir.
  63  *
  64  * @see generer_url_entite()
  65  *
  66  * @param string $type
  67  *     Type d'objet
  68  * @param Champ $p
  69  *     Pile au niveau de la balise
  70  * @param string $_id
  71  *     Code compilé permettant d'obtenir l'identifiant de l'objet
  72  * @return string
  73  *     Code compilé
  74  **/
  75 function generer_generer_url_arg($type, $p, $_id) {
  76         if ($s = trouver_nom_serveur_distant($p)) {
  77
  78                 // si une fonction de generation des url a ete definie pour ce connect l'utiliser
  79                 if (function_exists($f = 'generer_generer_url_' . $s)) {
  80                         return $f($type, $_id, $s);
  81                 }
  82                 if (!$GLOBALS['connexions'][strtolower($s)]['spip_connect_version']) {
  83                         return null;
  84                 }
  85                 $s = _q($s);
  86                 # exception des urls de documents sur un serveur distant...
  87                 if ($type == 'document') {
  88                         return
  89                                 "quete_meta('adresse_site', $s) . '/' .\n\t" .
  90                                 "quete_meta('dir_img', $s) . \n\t" .
  91                                 "quete_fichier($_id,$s)";
  92                 }
  93                 $s = ", '', '', $s, quete_meta('type_urls', $s)";
  94         } else {
  95                 $s = ", '', '', true";
  96         }
  97
  98         return "urlencode_1738(generer_url_entite($_id, '$type'$s))";
  99 }
 100
 101
 102 /**
 103  * Compile la balise générique `#URL_xxx` qui génère l'URL d'un objet
 104  *
 105  * S'il existe une fonction spécifique de calcul d'URL pour l'objet demandé,
 106  * tel que `balise_URL_ARTICLE_dist()`, la fonction l'utilisera. Sinon,
 107  * on calcule une URL de façon générique.
 108  *
 109  * @balise
 110  * @uses generer_generer_url()
 111  * @example
 112  *     ```
 113  *     #URL_ARTICLE
 114  *     #URL_ARTICLE{3}
 115  *     ```
 116  * @param Champ $p
 117  *     Pile au niveau de la balise
 118  * @return Champ
 119  *     Pile complétée par le code à générer
 120  */
 121 function balise_URL__dist($p) {
 122
 123         $nom = $p->nom_champ;
 124         if ($nom === 'URL_') {
 125                 $msg = array('zbug_balise_sans_argument', array('balise' => ' URL_'));
 126                 erreur_squelette($msg, $p);
 127                 $p->interdire_scripts = false;
 128
 129                 return $p;
 130         } elseif ($f = charger_fonction($nom, 'balise', true)) {
 131                 return $f($p);
 132         } else {
 133                 $nom = strtolower($nom);
 134                 $code = generer_generer_url(substr($nom, 4), $p);
 135                 $code = champ_sql($nom, $p, $code);
 136                 $p->code = $code;
 137                 if (!$p->etoile) {
 138                         $p->code = "vider_url($code)";
 139                 }
 140                 $p->interdire_scripts = false;
 141
 142                 return $p;
 143         }
 144 }
 145
 146 /**
 147  * Compile la balise `#URL_ARTICLE` qui génère l'URL d'un article
 148  *
 149  * Retourne l'URL (locale) d'un article mais retourne dans le cas
 150  * d'un article syndiqué (boucle SYNDIC_ARTICLES), son URL distante d'origine.
 151  *
 152  * @balise
 153  * @uses generer_generer_url()
 154  * @link http://www.spip.net/3963
 155  * @example
 156  *     ```
 157  *     #URL_ARTICLE
 158  *     #URL_ARTICLE{3}
 159  *     ```
 160  * @param Champ $p
 161  *     Pile au niveau de la balise
 162  * @return Champ
 163  *     Pile complétée par le code à générer
 164  */
 165 function balise_URL_ARTICLE_dist($p) {
 166
 167         // Cas particulier des boucles (SYNDIC_ARTICLES)
 168         if ($p->type_requete == 'syndic_articles') {
 169                 $code = champ_sql('url', $p);
 170         } else {
 171                 $code = generer_generer_url('article', $p);
 172         }
 173
 174         $p->code = $code;
 175         if (!$p->etoile) {
 176                 $p->code = "vider_url($code)";
 177         }
 178         $p->interdire_scripts = false;
 179
 180         return $p;
 181 }
 182
 183 /**
 184  * Compile la balise `#URL_SITE` qui génère l'URL d'un site ou de cas spécifiques
 185  *
 186  * Génère une URL spécifique si la colonne SQL `url_site` est trouvée
 187  * (par exemple lien hypertexte d'un article), sinon l'URL d'un site syndiqué
 188  *
 189  * @balise
 190  * @uses generer_generer_url()
 191  * @see  calculer_url()
 192  * @link http://www.spip.net/3861
 193  *
 194  * @param Champ $p
 195  *     Pile au niveau de la balise
 196  * @return Champ
 197  *     Pile complétée par le code à générer
 198  */
 199 function balise_URL_SITE_dist($p) {
 200         $code = champ_sql('url_site', $p);
 201         if (strpos($code, '@$Pile[0]') !== false) {
 202                 $code = generer_generer_url('site', $p);
 203                 if ($code === null) {
 204                         return null;
 205                 }
 206         } else {
 207                 if (!$p->etoile) {
 208                         $code = "calculer_url($code,'','url', \$connect)";
 209                 }
 210         }
 211         $p->code = $code;
 212         $p->interdire_scripts = false;
 213
 214         return $p;
 215 }
 216
 217 // Autres balises URL_*, qui ne concernent pas une table
 218 // (historique)
 219
 220 /**
 221  * Compile la balise `#URL_SITE_SPIP` qui retourne l'URL du site
 222  * telle que définie dans la configuration
 223  *
 224  * @balise
 225  * @link http://www.spip.net/4623
 226  *
 227  * @param Champ $p
 228  *     Pile au niveau de la balise
 229  * @return Champ
 230  *     Pile complétée par le code à générer
 231  */
 232 function balise_URL_SITE_SPIP_dist($p) {
 233         $p->code = "sinon(\$GLOBALS['meta']['adresse_site'],'.')";
 234         $p->code = "spip_htmlspecialchars(" . $p->code . ")";
 235         $p->interdire_scripts = false;
 236
 237         return $p;
 238 }
 239
 240
 241 /**
 242  * Compile la balise `#URL_PAGE` qui retourne une URL de type « page »
 243  *
 244  * - `#URL_PAGE{nom}` génère l'url pour la page `nom`
 245  * - `#URL_PAGE{nom,param=valeur}` génère l'url pour la page `nom` avec des paramètres
 246  * - `#URL_PAGE` sans argument retourne l'URL courante.
 247  * - `#URL_PAGE*` retourne l'URL sans convertir les `&` en `&amp;`
 248  *
 249  * @balise
 250  * @link http://www.spip.net/4630
 251  * @see generer_url_public()
 252  * @example
 253  *     ```
 254  *     #URL_PAGE{backend} produit ?page=backend
 255  *     #URL_PAGE{backend,id_rubrique=1} est équivalent à
 256  *     [(#URL_PAGE{backend}|parametre_url{id_rubrique,1})]
 257  *     ```
 258  *
 259  * @param Champ $p
 260  *     Pile au niveau de la balise
 261  * @return Champ
 262  *     Pile complétée par le code à générer
 263  */
 264 function balise_URL_PAGE_dist($p) {
 265
 266         $code = interprete_argument_balise(1, $p);
 267         $args = interprete_argument_balise(2, $p);
 268         if ($args == null) {
 269                 $args = "''";
 270         }
 271
 272         if ($s = trouver_nom_serveur_distant($p)) {
 273                 // si une fonction de generation des url a ete definie pour ce connect l'utiliser
 274                 // elle devra aussi traiter le cas derogatoire type=page
 275                 if (function_exists($f = 'generer_generer_url_' . $s)) {
 276                         if ($args and $args !== "''") {
 277                                 $code .= ", $args";
 278                         }
 279                         $code = $f('page', $code, $s);
 280
 281                         return $p;
 282                 }
 283                 $s = 'connect=' . addslashes($s);
 284                 $args = (($args and $args !== "''") ? "$args . '&$s'" : "'$s'");
 285         }
 286
 287         if (!$code) {
 288                 $noentities = $p->etoile ? "'&'" : '';
 289                 $code = "url_de_base() . preg_replace(',^./,', '', self($noentities))";
 290         } else {
 291                 if (!$args) {
 292                         $args = "''";
 293                 }
 294                 $noentities = $p->etoile ? ", true" : '';
 295                 $code = "generer_url_public($code, $args$noentities)";
 296         }
 297         $p->code = $code;
 298         spip_log("Calcul url page : connect vaut $s ca donne :" . $p->code . " args $args", _LOG_INFO);
 299
 300         #$p->interdire_scripts = true;
 301         return $p;
 302 }
 303
 304
 305 /**
 306  * Compile la balise `#URL_ECRIRE` qui retourne une URL d'une page de l'espace privé
 307  *
 308  * - `#URL_ECRIRE{nom}` génère l'url pour la page `nom` de l'espace privé
 309  * - `#URL_ECRIRE{nom,param=valeur}` génère l'url pour la page `nom` avec des paramètres
 310  * - `#URL_ECRIRE` génère l'url pour la page d'accueil de l'espace privé
 311  * - `#URL_ECRIRE*` retourne l'URL sans convertir les `&` en `&amp;`
 312  *
 313  * @balise
 314  * @link http://www.spip.net/5566
 315  * @see generer_url_ecrire()
 316  * @example
 317  *     ```
 318  *     #URL_ECRIRE{rubriques} -> ecrire/?exec=rubriques
 319  *     ```
 320  *
 321  * @param Champ $p
 322  *     Pile au niveau de la balise
 323  * @return Champ
 324  *     Pile complétée par le code à générer
 325  */
 326 function balise_URL_ECRIRE_dist($p) {
 327
 328         $code = interprete_argument_balise(1, $p);
 329         if (!$code) {
 330                 $fonc = "''";
 331         } else {
 332                 $fonc = $code;
 333                 $args = interprete_argument_balise(2, $p);
 334                 if ($args === null) {
 335                         $args = "''";
 336                 }
 337                 $noentities = $p->etoile ? ", true" : '';
 338                 if (($args != "''") or $noentities) {
 339                         $fonc .= ",$args$noentities";
 340                 }
 341         }
 342         $p->code = 'generer_url_ecrire(' . $fonc . ')';
 343         $p->interdire_scripts = false;
 344
 345         return $p;
 346 }
 347
 348
 349 /**
 350  * Compile la balise `#URL_ACTION_AUTEUR` qui retourne une URL d'action
 351  * sécurisée pour l'auteur en cours
 352  *
 353  * La balise accepte 3 paramètres. Les 2 premiers sont obligatoires :
 354  *
 355  * - le nom de l'action
 356  * - l'argument transmis à l'action (une chaîne de caractère)
 357  * - une éventuelle URL de redirection qui sert une fois l'action réalisée
 358  *
 359  * @balise
 360  * @see generer_action_auteur()
 361  * @example
 362  *     `#URL_ACTION_AUTEUR{converser,arg,redirect}` pourra produire
 363  *     `ecrire/?action=converser&arg=arg&hash=xxx&redirect=redirect`
 364  *
 365  * @param Champ $p
 366  *     Pile au niveau de la balise
 367  * @return Champ
 368  *     Pile complétée par le code à générer
 369  */
 370 function balise_URL_ACTION_AUTEUR_dist($p) {
 371         $p->descr['session'] = true;
 372
 373         $p->code = interprete_argument_balise(1, $p);
 374         $args = interprete_argument_balise(2, $p);
 375         if ($args != "''" && $args !== null) {
 376                 $p->code .= "," . $args;
 377         }
 378         $redirect = interprete_argument_balise(3, $p);
 379         if ($redirect != "''" && $redirect !== null) {
 380                 if ($args == "''" || $args === null) {
 381                         $p->code .= ",''";
 382                 }
 383                 $p->code .= "," . $redirect;
 384         }
 385
 386         $p->code = "generer_action_auteur(" . $p->code . ")";
 387         $p->interdire_scripts = false;
 388
 389         return $p;
 390 }