www/ecrire/inc/texte_mini.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2014                                                *
   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                 . ((!$no_transform AND $mode == 'div')
  80                         ? "\n\n"
  81                         : ''
  82                 );
  83 ;
  84 }
  85
  86
  87 // Echapper les <html>...</ html>
  88 // http://doc.spip.org/@traiter_echap_html_dist
  89 function traiter_echap_html_dist($regs) {
  90         return $regs[3];
  91 }
  92
  93 // Echapper les <code>...</ code>
  94 // http://doc.spip.org/@traiter_echap_code_dist
  95 function traiter_echap_code_dist($regs) {
  96         list(,,$att,$corps) = $regs;
  97         $echap = spip_htmlspecialchars($corps); // il ne faut pas passer dans entites_html, ne pas transformer les &#xxx; du code !
  98
  99         // ne pas mettre le <div...> s'il n'y a qu'une ligne
 100         if (is_int(strpos($echap,"\n"))) {
 101                 // supprimer les sauts de ligne debut/fin
 102                 // (mais pas les espaces => ascii art).
 103                 $echap = preg_replace("/^[\n\r]+|[\n\r]+$/s", "", $echap);
 104                 $echap = nl2br($echap);
 105                 $echap = "<div style='text-align: left;' "
 106                 . "class='spip_code' dir='ltr'><code$att>"
 107                 .$echap."</code></div>";
 108         } else {
 109                 $echap = "<code$att class='spip_code' dir='ltr'>".$echap."</code>";
 110         }
 111
 112         $echap = str_replace("\t", "&nbsp; &nbsp; &nbsp; &nbsp; ", $echap);
 113         $echap = str_replace("  ", " &nbsp;", $echap);
 114         return $echap;
 115 }
 116
 117 // Echapper les <cadre>...</ cadre> aka <frame>...</ frame>
 118 // http://doc.spip.org/@traiter_echap_cadre_dist
 119 function traiter_echap_cadre_dist($regs) {
 120         $echap = trim(entites_html($regs[3]));
 121         // compter les lignes un peu plus finement qu'avec les \n
 122         $lignes = explode("\n",trim($echap));
 123         $n = 0;
 124         foreach($lignes as $l)
 125                 $n+=floor(strlen($l)/60)+1;
 126         $n = max($n,2);
 127         $echap = "\n<textarea readonly='readonly' cols='40' rows='$n' class='spip_cadre' dir='ltr'>$echap</textarea>";
 128         return $echap;
 129 }
 130 // http://doc.spip.org/@traiter_echap_frame_dist
 131 function traiter_echap_frame_dist($regs) {
 132         return traiter_echap_cadre_dist($regs);
 133 }
 134
 135 // http://doc.spip.org/@traiter_echap_script_dist
 136 function traiter_echap_script_dist($regs) {
 137         // rendre joli (et inactif) si c'est un script language=php
 138         if (preg_match(',<script\b[^>]+php,ims', $regs[0]))
 139                 return highlight_string($regs[0],true);
 140
 141         // Cas normal : le script passe tel quel
 142         return $regs[0];
 143 }
 144
 145 define('_PROTEGE_BLOCS', ',<(html|code|cadre|frame|script)(\s[^>]*)?>(.*)</\1>,UimsS');
 146
 147 // - pour $source voir commentaire infra (echappe_retour)
 148 // - pour $no_transform voir le filtre post_autobr dans inc/filtres
 149 // http://doc.spip.org/@echappe_html
 150 function echappe_html($letexte, $source='', $no_transform=false,
 151 $preg='') {
 152         if (!is_string($letexte) or !strlen($letexte))
 153                 return $letexte;
 154
 155         // si le texte recu est long PCRE risque d'exploser, on
 156         // fait donc un mic-mac pour augmenter pcre.backtrack_limit
 157         if (($len = strlen($letexte)) > 100000) {
 158                 if (!$old = @ini_get('pcre.backtrack_limit')) $old = 100000;
 159                 if ($len > $old) {
 160                         $a = @ini_set('pcre.backtrack_limit', $len);
 161                         spip_log("ini_set pcre.backtrack_limit=$len ($old)");
 162                 }
 163         }
 164
 165         if (($preg OR strpos($letexte,"<")!==false)
 166           AND preg_match_all($preg ? $preg : _PROTEGE_BLOCS, $letexte, $matches, PREG_SET_ORDER))
 167                 foreach ($matches as $regs) {
 168                         // echappements tels quels ?
 169                         if ($no_transform) {
 170                                 $echap = $regs[0];
 171                         }
 172
 173                         // sinon les traiter selon le cas
 174                         else if (function_exists($f = 'traiter_echap_'.strtolower($regs[1])))
 175                                 $echap = $f($regs);
 176                         else if (function_exists($f = $f.'_dist'))
 177                                 $echap = $f($regs);
 178
 179                         $p = strpos($letexte,$regs[0]);
 180                         $letexte = substr_replace($letexte,code_echappement($echap, $source, $no_transform),$p,strlen($regs[0]));
 181                 }
 182
 183         if ($no_transform)
 184                 return $letexte;
 185
 186         // Gestion du TeX
 187         if (strpos($letexte, "<math>") !== false) {
 188                 include_spip('inc/math');
 189                 $letexte = traiter_math($letexte, $source);
 190         }
 191
 192         // Echapper le php pour faire joli (ici, c'est pas pour la securite)
 193         if (strpos($letexte,"<"."?")!==false AND preg_match_all(',<[?].*($|[?]>),UisS',
 194         $letexte, $matches, PREG_SET_ORDER))
 195         foreach ($matches as $regs) {
 196                 $letexte = str_replace($regs[0],
 197                         code_echappement(highlight_string($regs[0],true), $source),
 198                         $letexte);
 199         }
 200
 201         return $letexte;
 202 }
 203
 204 //
 205 // Traitement final des echappements
 206 // Rq: $source sert a faire des echappements "a soi" qui ne sont pas nettoyes
 207 // par propre() : exemple dans multi et dans typo()
 208 // http://doc.spip.org/@echappe_retour
 209 function echappe_retour($letexte, $source='', $filtre = "") {
 210         if (strpos($letexte,"base64$source")) {
 211                 # spip_log(spip_htmlspecialchars($letexte));  ## pour les curieux
 212                 $max_prof = 5;
 213                 while (strpos($letexte,"<")!==false
 214                         AND
 215                   preg_match_all(',<(span|div)\sclass=[\'"]base64'.$source.'[\'"]\s(.*)>\s*</\1>,UmsS',
 216                 $letexte, $regs, PREG_SET_ORDER)
 217                   AND $max_prof--) {
 218                         foreach ($regs as $reg) {
 219                                 $rempl = base64_decode(extraire_attribut($reg[0], 'title'));
 220                                 // recherche d'attributs supplementaires
 221                                 $at = array();
 222                                 foreach(array('lang', 'dir') as $attr) {
 223                                         if ($a = extraire_attribut($reg[0], $attr))
 224                                                 $at[$attr] = $a;
 225                                 }
 226                                 if ($at) {
 227                                         $rempl = '<'.$reg[1].'>'.$rempl.'</'.$reg[1].'>';
 228                                         foreach($at as $attr => $a)
 229                                                 $rempl = inserer_attribut($rempl, $attr, $a);
 230                                 }
 231                                 if ($filtre) $rempl = $filtre($rempl);
 232                                 $letexte = str_replace($reg[0], $rempl, $letexte);
 233                         }
 234                 }
 235         }
 236         return $letexte;
 237 }
 238
 239 // Reinserer le javascript de confiance (venant des modeles)
 240
 241 // http://doc.spip.org/@echappe_retour_modeles
 242 function echappe_retour_modeles($letexte, $interdire_scripts=false)
 243 {
 244         $letexte = echappe_retour($letexte);
 245
 246         // Dans les appels directs hors squelette, securiser aussi ici
 247         if ($interdire_scripts)
 248                 $letexte = interdire_scripts($letexte);
 249
 250         return trim($letexte);
 251 }
 252
 253
 254 // http://doc.spip.org/@couper
 255 function couper($texte, $taille=50, $suite = '&nbsp;(...)') {
 256         if (!($length=strlen($texte)) OR $taille <= 0) return '';
 257         $offset = 400 + 2*$taille;
 258         while ($offset<$length
 259                 AND strlen(preg_replace(",<[^>]+>,Uims","",substr($texte,0,$offset)))<$taille)
 260                 $offset = 2*$offset;
 261         if (    $offset<$length
 262                         && ($p_tag_ouvrant = strpos($texte,'<',$offset))!==NULL){
 263                 $p_tag_fermant = strpos($texte,'>',$offset);
 264                 if ($p_tag_fermant && ($p_tag_fermant<$p_tag_ouvrant))
 265                         $offset = $p_tag_fermant+1; // prolonger la coupe jusqu'au tag fermant suivant eventuel
 266         }
 267         $texte = substr($texte, 0, $offset); /* eviter de travailler sur 10ko pour extraire 150 caracteres */
 268
 269         // on utilise les \r pour passer entre les gouttes
 270         $texte = str_replace("\r\n", "\n", $texte);
 271         $texte = str_replace("\r", "\n", $texte);
 272
 273         // sauts de ligne et paragraphes
 274         $texte = preg_replace("/\n\n+/", "\r", $texte);
 275         $texte = preg_replace("/<(p|br)( [^>]*)?".">/", "\r", $texte);
 276
 277         // supprimer les traits, lignes etc
 278         $texte = preg_replace("/(^|\r|\n)(-[-#\*]*|_ )/", "\r", $texte);
 279
 280         // supprimer les tags
 281         $texte = supprimer_tags($texte);
 282         $texte = trim(str_replace("\n"," ", $texte));
 283         $texte .= "\n"; // marquer la fin
 284
 285         // travailler en accents charset
 286         $texte = unicode2charset(html2unicode($texte, /* secure */ true));
 287         if (!function_exists('nettoyer_raccourcis_typo'))
 288                 include_spip('inc/lien');
 289         $texte = nettoyer_raccourcis_typo($texte);
 290
 291         // corriger la longueur de coupe
 292         // en fonction de la presence de caracteres utf
 293         if ($GLOBALS['meta']['charset']=='utf-8'){
 294                 $long = charset2unicode($texte);
 295                 $long = spip_substr($long, 0, max($taille,1));
 296                 $nbcharutf = preg_match_all('/(&#[0-9]{3,5};)/S', $long, $matches);
 297                 $taille += $nbcharutf;
 298         }
 299
 300
 301         // couper au mot precedent
 302         $long = spip_substr($texte, 0, max($taille-4,1));
 303         $u = $GLOBALS['meta']['pcre_u'];
 304         $court = preg_replace("/([^\s][\s]+)[^\s]*\n?$/".$u, "\\1", $long);
 305         $points = $suite;
 306
 307         // trop court ? ne pas faire de (...)
 308         if (spip_strlen($court) < max(0.75 * $taille,2)) {
 309                 $points = '';
 310                 $long = spip_substr($texte, 0, $taille);
 311                 $texte = preg_replace("/([^\s][\s]+)[^\s]*\n?$/".$u, "\\1", $long);
 312                 // encore trop court ? couper au caractere
 313                 if (spip_strlen($texte) < 0.75 * $taille)
 314                         $texte = $long;
 315         } else
 316                 $texte = $court;
 317
 318         if (strpos($texte, "\n"))       // la fin est encore la : c'est qu'on n'a pas de texte de suite
 319                 $points = '';
 320
 321         // remettre les paragraphes
 322         $texte = preg_replace("/\r+/", "\n\n", $texte);
 323
 324         // supprimer l'eventuelle entite finale mal coupee
 325         $texte = preg_replace('/&#?[a-z0-9]*$/S', '', $texte);
 326
 327         return quote_amp(trim($texte)).$points;
 328 }
 329
 330
 331 // http://doc.spip.org/@protege_js_modeles
 332 function protege_js_modeles($t) {
 333         if (isset($GLOBALS['visiteur_session'])){
 334                 if (preg_match_all(',<script.*?($|</script.),isS', $t, $r, PREG_SET_ORDER)){
 335                         if (!defined('_PROTEGE_JS_MODELES')){
 336                                 include_spip('inc/acces');
 337                                 define('_PROTEGE_JS_MODELES',creer_uniqid());
 338                         }
 339                         foreach ($r as $regs)
 340                                 $t = str_replace($regs[0],code_echappement($regs[0],'javascript'._PROTEGE_JS_MODELES),$t);
 341                 }
 342                 if (preg_match_all(',<\?php.*?($|\?'.'>),isS', $t, $r, PREG_SET_ORDER)){
 343                         if (!defined('_PROTEGE_PHP_MODELES')){
 344                                 include_spip('inc/acces');
 345                                 define('_PROTEGE_PHP_MODELES',creer_uniqid());
 346                         }
 347                         foreach ($r as $regs)
 348                                 $t = str_replace($regs[0],code_echappement($regs[0],'php'._PROTEGE_PHP_MODELES),$t);
 349                 }
 350         }
 351         return $t;
 352 }
 353
 354
 355 function echapper_faux_tags($letexte){
 356         if (strpos($letexte,'<')===false)
 357                 return $letexte;
 358   $textMatches = preg_split (',(</?[a-z!][^<>]*>),', $letexte, null, PREG_SPLIT_DELIM_CAPTURE);
 359
 360   $letexte = "";
 361   while (count($textMatches)) {
 362         // un texte a echapper
 363         $letexte .= str_replace(array("<"),array('&lt;'),array_shift($textMatches));
 364         // un tag html qui a servit a faite le split
 365                 $letexte .= array_shift($textMatches);
 366   }
 367   return $letexte;
 368 }
 369
 370 // Securite : utiliser SafeHTML s'il est present dans ecrire/safehtml/
 371 // http://doc.spip.org/@safehtml
 372 function safehtml($t) {
 373         static $safehtml;
 374
 375         if (!$t OR !is_string($t))
 376                 return $t;
 377         # attention safehtml nettoie deux ou trois caracteres de plus. A voir
 378         if (strpos($t,'<')===false)
 379                 return str_replace("\x00", '', $t);
 380
 381         $t = interdire_scripts($t); // jolifier le php
 382         $t = echappe_js($t);
 383
 384         if (!isset($safehtml))
 385                 $safehtml = charger_fonction('safehtml', 'inc', true);
 386         if ($safehtml)
 387                 $t = $safehtml($t);
 388
 389         return interdire_scripts($t); // interdire le php (2 precautions)
 390 }
 391
 392
 393 // fonction en cas de texte extrait d'un serveur distant:
 394 // on ne sait pas (encore) rapatrier les documents joints
 395 // Sert aussi a nettoyer un texte qu'on veut mettre dans un <a> etc.
 396 // TODO: gerer les modeles ?
 397 // http://doc.spip.org/@supprime_img
 398 function supprime_img($letexte, $message=NULL) {
 399         if ($message===NULL) $message = '(' . _T('img_indisponible') . ')';
 400         return preg_replace(',<(img|doc|emb)([0-9]+)(\|([^>]*))?'.'\s*/?'.'>,i',
 401                 $message, $letexte);
 402 }