www/ecrire/inc/texte_mini.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 include_spip('inc/filtres');
  15 include_spip('inc/lang');
  16
  17 // On initialise la puce pour eviter find_in_path() a chaque rencontre de \n-
  18 // Mais attention elle depend de la direction et de X_fonctions.php, ainsi que
  19 // de l'espace choisi (public/prive)
  20 // http://doc.spip.org/@definir_puce
  21 function definir_puce() {
  22
  23         // Attention au sens, qui n'est pas defini de la meme facon dans
  24         // l'espace prive (spip_lang est la langue de l'interface, lang_dir
  25         // celle du texte) et public (spip_lang est la langue du texte)
  26         $dir = _DIR_RESTREINT ? lang_dir() : lang_dir($GLOBALS['spip_lang']);
  27
  28         $p = 'puce' . (test_espace_prive() ? '_prive' : '');
  29         if ($dir == 'rtl') $p .= '_rtl';
  30
  31         if (!isset($GLOBALS[$p])) {
  32                 $img = find_in_path($p.'.gif');
  33                 list(,,,$size) = @getimagesize($img);
  34                 $GLOBALS[$p] = '<img src="'.$img.'" '.$size.' class="puce" alt="-" />';
  35         }
  36         return $GLOBALS[$p];
  37 }
  38
  39
  40 // XHTML - Preserver les balises-bloc : on liste ici tous les elements
  41 // dont on souhaite qu'ils provoquent un saut de paragraphe
  42
  43 if (!defined('_BALISES_BLOCS')) define('_BALISES_BLOCS',
  44         'p|div|pre|ul|ol|li|blockquote|h[1-6r]|'
  45         .'t(able|[rdh]|head|body|foot|extarea)|'
  46         .'form|object|center|marquee|address|'
  47         .'applet|iframe|'
  48         .'d[ltd]|script|noscript|map|button|fieldset|style');
  49
  50 if (!defined('_BALISES_BLOCS_REGEXP'))
  51         define('_BALISES_BLOCS_REGEXP',',</?('._BALISES_BLOCS.')[>[:space:]],iS');
  52
  53 //
  54 // Echapper les elements perilleux en les passant en base64
  55 //
  56
  57 // Creer un bloc base64 correspondant a $rempl ; au besoin en marquant
  58 // une $source differente ; le script detecte automagiquement si ce qu'on
  59 // echappe est un div ou un span
  60 // http://doc.spip.org/@code_echappement
  61 function code_echappement($rempl, $source='', $no_transform=false, $mode=NULL) {
  62         if (!strlen($rempl)) return '';
  63
  64         // Tester si on echappe en span ou en div
  65         if (is_null($mode) OR !in_array($mode,array('div','span')))
  66                 $mode = preg_match(',</?('._BALISES_BLOCS.')[>[:space:]],iS', $rempl) ? 'div' : 'span';
  67
  68         // Decouper en morceaux, base64 a des probleme selon la taille de la pile
  69         $taille = 30000;
  70         $return = "";
  71         for($i = 0; $i < strlen($rempl); $i += $taille) {
  72                 // Convertir en base64 et cacher dans un attribut
  73                 // utiliser les " pour eviter le re-encodage de ' et &#8217
  74                 $base64 = base64_encode(substr($rempl, $i, $taille));
  75                 $return .= "<$mode class=\"base64$source\" title=\"$base64\"></$mode>";
  76         }
  77
  78         return $return;
  79
  80 }
  81
  82
  83 // Echapper les <html>...</ html>
  84 // http://doc.spip.org/@traiter_echap_html_dist
  85 function traiter_echap_html_dist($regs) {
  86         return $regs[3];
  87 }
  88
  89 // Echapper les <code>...</ code>
  90 // http://doc.spip.org/@traiter_echap_code_dist
  91 function traiter_echap_code_dist($regs) {
  92         list(,,$att,$corps) = $regs;
  93         $echap = spip_htmlspecialchars($corps); // il ne faut pas passer dans entites_html, ne pas transformer les &#xxx; du code !
  94
  95         // ne pas mettre le <div...> s'il n'y a qu'une ligne
  96         if (is_int(strpos($echap,"\n"))) {
  97                 // supprimer les sauts de ligne debut/fin
  98                 // (mais pas les espaces => ascii art).
  99                 $echap = preg_replace("/^[\n\r]+|[\n\r]+$/s", "", $echap);
 100                 $echap = nl2br($echap);
 101                 $echap = "<div style='text-align: left;' "
 102                 . "class='spip_code' dir='ltr'><code$att>"
 103                 .$echap."</code></div>";
 104         } else {
 105                 $echap = "<code$att class='spip_code' dir='ltr'>".$echap."</code>";
 106         }
 107
 108         $echap = str_replace("\t", "&nbsp; &nbsp; &nbsp; &nbsp; ", $echap);
 109         $echap = str_replace("  ", " &nbsp;", $echap);
 110         return $echap;
 111 }
 112
 113 // Echapper les <cadre>...</ cadre> aka <frame>...</ frame>
 114 // http://doc.spip.org/@traiter_echap_cadre_dist
 115 function traiter_echap_cadre_dist($regs) {
 116         $echap = trim(entites_html($regs[3]));
 117         // compter les lignes un peu plus finement qu'avec les \n
 118         $lignes = explode("\n",trim($echap));
 119         $n = 0;
 120         foreach($lignes as $l)
 121                 $n+=floor(strlen($l)/60)+1;
 122         $n = max($n,2);
 123         $echap = "\n<textarea readonly='readonly' cols='40' rows='$n' class='spip_cadre' dir='ltr'>$echap</textarea>";
 124         return $echap;
 125 }
 126 // http://doc.spip.org/@traiter_echap_frame_dist
 127 function traiter_echap_frame_dist($regs) {
 128         return traiter_echap_cadre_dist($regs);
 129 }
 130
 131 // http://doc.spip.org/@traiter_echap_script_dist
 132 function traiter_echap_script_dist($regs) {
 133         // rendre joli (et inactif) si c'est un script language=php
 134         if (preg_match(',<script\b[^>]+php,ims', $regs[0]))
 135                 return highlight_string($regs[0],true);
 136
 137         // Cas normal : le script passe tel quel
 138         return $regs[0];
 139 }
 140
 141 /**
 142  * Traiter les blocs <math></math> echappes par echappe_html
 143  * @param $regs
 144  * @return string
 145  */
 146 function traiter_echap_math_dist($regs) {
 147         // Gestion du TeX
 148         if (!function_exists('traiter_math'))
 149                 include_spip('inc/math');
 150
 151         $t = traiter_math($regs[0], '');
 152         return $t;
 153 }
 154
 155 define('_PROTEGE_BLOCS', ',<(html|code|cadre|frame|script)(\s[^>]*)?>(.*)</\1>,UimsS');
 156
 157 // - pour $source voir commentaire infra (echappe_retour)
 158 // - pour $no_transform voir le filtre post_autobr dans inc/filtres
 159 // http://doc.spip.org/@echappe_html
 160 function echappe_html($letexte, $source='', $no_transform=false,
 161 $preg='') {
 162         if (!is_string($letexte) or !strlen($letexte))
 163                 return $letexte;
 164
 165         // si le texte recu est long PCRE risque d'exploser, on
 166         // fait donc un mic-mac pour augmenter pcre.backtrack_limit
 167         if (($len = strlen($letexte)) > 100000) {
 168                 if (!$old = @ini_get('pcre.backtrack_limit')) $old = 100000;
 169                 if ($len > $old) {
 170                         $a = @ini_set('pcre.backtrack_limit', $len);
 171                         spip_log("ini_set pcre.backtrack_limit=$len ($old)");
 172                 }
 173         }
 174
 175         if (($preg OR strpos($letexte,"<")!==false)
 176           AND preg_match_all($preg ? $preg : _PROTEGE_BLOCS, $letexte, $matches, PREG_SET_ORDER)) {
 177                 foreach ($matches as $regs) {
 178                         // echappements tels quels ?
 179                         if ($no_transform) {
 180                                 $echap = $regs[0];
 181                         }
 182
 183                         // sinon les traiter selon le cas
 184                         else if (function_exists($f = 'traiter_echap_'.strtolower($regs[1])))
 185                                 $echap = $f($regs);
 186                         else if (function_exists($f = $f.'_dist'))
 187                                 $echap = $f($regs);
 188
 189                         $p = strpos($letexte,$regs[0]);
 190                         $letexte = substr_replace($letexte,code_echappement($echap, $source, $no_transform),$p,strlen($regs[0]));
 191                 }
 192         }
 193
 194         if ($no_transform)
 195                 return $letexte;
 196
 197         // Gestion du TeX
 198         // code mort sauf si on a personalise _PROTEGE_BLOCS sans y mettre <math>
 199         // eviter la rupture de compat en branche 3.0
 200         // a supprimer en branche 3.1
 201         if (strpos($preg ? $preg : _PROTEGE_BLOCS,'code')!==false){
 202                 if (strpos($letexte, "<math>") !== false) {
 203                         include_spip('inc/math');
 204                         $letexte = traiter_math($letexte, $source);
 205                 }
 206         }
 207
 208         // Echapper le php pour faire joli (ici, c'est pas pour la securite)
 209         // seulement si on a echappe les <script>
 210         // (derogatoire car on ne peut pas faire passer < ? ... ? >
 211         // dans une callback autonommee
 212         if (strpos($preg ? $preg : _PROTEGE_BLOCS,'script')!==false){
 213                 if (strpos($letexte,"<"."?")!==false AND preg_match_all(',<[?].*($|[?]>),UisS',
 214                 $letexte, $matches, PREG_SET_ORDER))
 215                 foreach ($matches as $regs) {
 216                         $letexte = str_replace($regs[0],
 217                                 code_echappement(highlight_string($regs[0],true), $source),
 218                                 $letexte);
 219                 }
 220         }
 221
 222         return $letexte;
 223 }
 224
 225 //
 226 // Traitement final des echappements
 227 // Rq: $source sert a faire des echappements "a soi" qui ne sont pas nettoyes
 228 // par propre() : exemple dans multi et dans typo()
 229 // http://doc.spip.org/@echappe_retour
 230 function echappe_retour($letexte, $source='', $filtre = "") {
 231         if (strpos($letexte,"base64$source")) {
 232                 # spip_log(spip_htmlspecialchars($letexte));  ## pour les curieux
 233                 $max_prof = 5;
 234                 while (strpos($letexte,"<")!==false
 235                         AND
 236                   preg_match_all(',<(span|div)\sclass=[\'"]base64'.$source.'[\'"]\s(.*)>\s*</\1>,UmsS',
 237                 $letexte, $regs, PREG_SET_ORDER)
 238                   AND $max_prof--) {
 239                         foreach ($regs as $reg) {
 240                                 $rempl = base64_decode(extraire_attribut($reg[0], 'title'));
 241                                 // recherche d'attributs supplementaires
 242                                 $at = array();
 243                                 foreach(array('lang', 'dir') as $attr) {
 244                                         if ($a = extraire_attribut($reg[0], $attr))
 245                                                 $at[$attr] = $a;
 246                                 }
 247                                 if ($at) {
 248                                         $rempl = '<'.$reg[1].'>'.$rempl.'</'.$reg[1].'>';
 249                                         foreach($at as $attr => $a)
 250                                                 $rempl = inserer_attribut($rempl, $attr, $a);
 251                                 }
 252                                 if ($filtre) $rempl = $filtre($rempl);
 253                                 $letexte = str_replace($reg[0], $rempl, $letexte);
 254                         }
 255                 }
 256         }
 257         return $letexte;
 258 }
 259
 260 // Reinserer le javascript de confiance (venant des modeles)
 261
 262 // http://doc.spip.org/@echappe_retour_modeles
 263 function echappe_retour_modeles($letexte, $interdire_scripts=false)
 264 {
 265         $letexte = echappe_retour($letexte);
 266
 267         // Dans les appels directs hors squelette, securiser aussi ici
 268         if ($interdire_scripts)
 269                 $letexte = interdire_scripts($letexte);
 270
 271         return trim($letexte);
 272 }
 273
 274
 275 // http://doc.spip.org/@couper
 276 function couper($texte, $taille=50, $suite = '&nbsp;(...)') {
 277         if (!($length=strlen($texte)) OR $taille <= 0) return '';
 278         $offset = 400 + 2*$taille;
 279         while ($offset<$length
 280                 AND strlen(preg_replace(",<[^>]+>,Uims","",substr($texte,0,$offset)))<$taille)
 281                 $offset = 2*$offset;
 282         if (    $offset<$length
 283                         && ($p_tag_ouvrant = strpos($texte,'<',$offset))!==NULL){
 284                 $p_tag_fermant = strpos($texte,'>',$offset);
 285                 if ($p_tag_fermant && ($p_tag_fermant<$p_tag_ouvrant))
 286                         $offset = $p_tag_fermant+1; // prolonger la coupe jusqu'au tag fermant suivant eventuel
 287         }
 288         $texte = substr($texte, 0, $offset); /* eviter de travailler sur 10ko pour extraire 150 caracteres */
 289
 290         // on utilise les \r pour passer entre les gouttes
 291         $texte = str_replace("\r\n", "\n", $texte);
 292         $texte = str_replace("\r", "\n", $texte);
 293
 294         // sauts de ligne et paragraphes
 295         $texte = preg_replace("/\n\n+/", "\r", $texte);
 296         $texte = preg_replace("/<(p|br)( [^>]*)?".">/", "\r", $texte);
 297
 298         // supprimer les traits, lignes etc
 299         $texte = preg_replace("/(^|\r|\n)(-[-#\*]*|_ )/", "\r", $texte);
 300
 301         // supprimer les tags
 302         $texte = supprimer_tags($texte);
 303         $texte = trim(str_replace("\n"," ", $texte));
 304         $texte .= "\n"; // marquer la fin
 305
 306         // travailler en accents charset
 307         $texte = unicode2charset(html2unicode($texte, /* secure */ true));
 308         if (!function_exists('nettoyer_raccourcis_typo'))
 309                 include_spip('inc/lien');
 310         $texte = nettoyer_raccourcis_typo($texte);
 311
 312         // corriger la longueur de coupe
 313         // en fonction de la presence de caracteres utf
 314         if ($GLOBALS['meta']['charset']=='utf-8'){
 315                 $long = charset2unicode($texte);
 316                 $long = spip_substr($long, 0, max($taille,1));
 317                 $nbcharutf = preg_match_all('/(&#[0-9]{3,5};)/S', $long, $matches);
 318                 $taille += $nbcharutf;
 319         }
 320
 321
 322         // couper au mot precedent
 323         $long = spip_substr($texte, 0, max($taille-4,1));
 324         $u = $GLOBALS['meta']['pcre_u'];
 325         $court = preg_replace("/([^\s][\s]+)[^\s]*\n?$/".$u, "\\1", $long);
 326         $points = $suite;
 327
 328         // trop court ? ne pas faire de (...)
 329         if (spip_strlen($court) < max(0.75 * $taille,2)) {
 330                 $points = '';
 331                 $long = spip_substr($texte, 0, $taille);
 332                 $texte = preg_replace("/([^\s][\s]+)[^\s]*\n?$/".$u, "\\1", $long);
 333                 // encore trop court ? couper au caractere
 334                 if (spip_strlen($texte) < 0.75 * $taille)
 335                         $texte = $long;
 336         } else
 337                 $texte = $court;
 338
 339         if (strpos($texte, "\n"))       // la fin est encore la : c'est qu'on n'a pas de texte de suite
 340                 $points = '';
 341
 342         // remettre les paragraphes
 343         $texte = preg_replace("/\r+/", "\n\n", $texte);
 344
 345         // supprimer l'eventuelle entite finale mal coupee
 346         $texte = preg_replace('/&#?[a-z0-9]*$/S', '', $texte);
 347
 348         return quote_amp(trim($texte)).$points;
 349 }
 350
 351
 352 // http://doc.spip.org/@protege_js_modeles
 353 function protege_js_modeles($t) {
 354         if (isset($GLOBALS['visiteur_session'])){
 355                 if (preg_match_all(',<script.*?($|</script.),isS', $t, $r, PREG_SET_ORDER)){
 356                         if (!defined('_PROTEGE_JS_MODELES')){
 357                                 include_spip('inc/acces');
 358                                 define('_PROTEGE_JS_MODELES',creer_uniqid());
 359                         }
 360                         foreach ($r as $regs)
 361                                 $t = str_replace($regs[0],code_echappement($regs[0],'javascript'._PROTEGE_JS_MODELES),$t);
 362                 }
 363                 if (preg_match_all(',<\?php.*?($|\?'.'>),isS', $t, $r, PREG_SET_ORDER)){
 364                         if (!defined('_PROTEGE_PHP_MODELES')){
 365                                 include_spip('inc/acces');
 366                                 define('_PROTEGE_PHP_MODELES',creer_uniqid());
 367                         }
 368                         foreach ($r as $regs)
 369                                 $t = str_replace($regs[0],code_echappement($regs[0],'php'._PROTEGE_PHP_MODELES),$t);
 370                 }
 371         }
 372         return $t;
 373 }
 374
 375
 376 function echapper_faux_tags($letexte){
 377         if (strpos($letexte,'<')===false)
 378                 return $letexte;
 379   $textMatches = preg_split (',(</?[a-z!][^<>]*>),', $letexte, null, PREG_SPLIT_DELIM_CAPTURE);
 380
 381   $letexte = "";
 382   while (count($textMatches)) {
 383         // un texte a echapper
 384         $letexte .= str_replace("<",'&lt;',array_shift($textMatches));
 385         // un tag html qui a servit a faite le split
 386                 $letexte .= array_shift($textMatches);
 387   }
 388   return $letexte;
 389 }
 390
 391 /**
 392  * Si le html contenu dans un texte ne passe pas sans transformation a travers safehtml
 393  * on l'echappe
 394  * si safehtml ne renvoie pas la meme chose on echappe les < en &lt; pour montrer le contenu brut
 395  *
 396  * @param string $texte
 397  * @return string
 398  */
 399 function echapper_html_suspect($texte){
 400         if (strpos($texte,'<')===false OR strpos($texte,'=')===false)
 401                 return $texte;
 402
 403         // on teste sur strlen car safehtml supprime le contenu dangereux
 404         // mais il peut aussi changer des ' en " sur les attributs html,
 405         // donc un test d'egalite est trop strict
 406         if (strlen(safehtml($texte))!==strlen($texte)){
 407                 $texte = str_replace("<","&lt;",$texte);
 408         }
 409
 410         return $texte;
 411 }
 412
 413
 414 /**
 415  * Sécurise un texte HTML
 416  *
 417  * Échappe le code PHP et JS.
 418  * Applique en plus safehtml si un plugin le définit dans inc/safehtml.php
 419  *
 420  * Permet de protéger les textes issus d'une origine douteuse (forums, syndications...)
 421  *
 422  * @filtre
 423  * @link http://www.spip.net/4310
 424  *
 425  * @param string $t
 426  *      Texte à sécuriser
 427  * @return string
 428  *      Texte sécurisé
 429 **/
 430 function safehtml($t) {
 431         static $safehtml;
 432
 433         if (!$t OR !is_string($t))
 434                 return $t;
 435         # attention safehtml nettoie deux ou trois caracteres de plus. A voir
 436         if (strpos($t,'<')===false)
 437                 return str_replace("\x00", '', $t);
 438
 439         $t = interdire_scripts($t); // jolifier le php
 440         $t = echappe_js($t);
 441
 442         if (!isset($safehtml))
 443                 $safehtml = charger_fonction('safehtml', 'inc', true);
 444         if ($safehtml)
 445                 $t = $safehtml($t);
 446
 447         return interdire_scripts($t); // interdire le php (2 precautions)
 448 }
 449
 450
 451 // fonction en cas de texte extrait d'un serveur distant:
 452 // on ne sait pas (encore) rapatrier les documents joints
 453 // Sert aussi a nettoyer un texte qu'on veut mettre dans un <a> etc.
 454 // TODO: gerer les modeles ?
 455 // http://doc.spip.org/@supprime_img
 456 function supprime_img($letexte, $message=NULL) {
 457         if ($message===NULL) $message = '(' . _T('img_indisponible') . ')';
 458         return preg_replace(',<(img|doc|emb)([0-9]+)(\|([^>]*))?'.'\s*/?'.'>,i',
 459                 $message, $letexte);
 460 }