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 /**
 146  * Traiter les blocs <math></math> echappes par echappe_html
 147  * @param $regs
 148  * @return string
 149  */
 150 function traiter_echap_math_dist($regs) {
 151         // Gestion du TeX
 152         if (!function_exists('traiter_math'))
 153                 include_spip('inc/math');
 154
 155         $t = traiter_math($regs[0], '');
 156         return $t;
 157 }
 158
 159 define('_PROTEGE_BLOCS', ',<(html|code|cadre|frame|script|math)(\s[^>]*)?>(.*)</\1>,UimsS');
 160
 161 // - pour $source voir commentaire infra (echappe_retour)
 162 // - pour $no_transform voir le filtre post_autobr dans inc/filtres
 163 // http://doc.spip.org/@echappe_html
 164 function echappe_html($letexte, $source='', $no_transform=false,
 165 $preg='') {
 166         if (!is_string($letexte) or !strlen($letexte))
 167                 return $letexte;
 168
 169         // si le texte recu est long PCRE risque d'exploser, on
 170         // fait donc un mic-mac pour augmenter pcre.backtrack_limit
 171         if (($len = strlen($letexte)) > 100000) {
 172                 if (!$old = @ini_get('pcre.backtrack_limit')) $old = 100000;
 173                 if ($len > $old) {
 174                         $a = @ini_set('pcre.backtrack_limit', $len);
 175                         spip_log("ini_set pcre.backtrack_limit=$len ($old)");
 176                 }
 177         }
 178
 179         if (($preg OR strpos($letexte,"<")!==false)
 180           AND preg_match_all($preg ? $preg : _PROTEGE_BLOCS, $letexte, $matches, PREG_SET_ORDER)) {
 181                 foreach ($matches as $regs) {
 182                         // echappements tels quels ?
 183                         if ($no_transform) {
 184                                 $echap = $regs[0];
 185                         }
 186
 187                         // sinon les traiter selon le cas
 188                         else if (function_exists($f = 'traiter_echap_'.strtolower($regs[1])))
 189                                 $echap = $f($regs);
 190                         else if (function_exists($f = $f.'_dist'))
 191                                 $echap = $f($regs);
 192
 193                         $p = strpos($letexte,$regs[0]);
 194                         $letexte = substr_replace($letexte,code_echappement($echap, $source, $no_transform),$p,strlen($regs[0]));
 195                 }
 196         }
 197
 198         if ($no_transform)
 199                 return $letexte;
 200
 201         // Gestion du TeX
 202         // code mort sauf si on a personalise _PROTEGE_BLOCS sans y mettre <math>
 203         // eviter la rupture de compat en branche 3.0
 204         // a supprimer en branche 3.1
 205         if (strpos($preg ? $preg : _PROTEGE_BLOCS,'code')!==false){
 206                 if (strpos($letexte, "<math>") !== false) {
 207                         include_spip('inc/math');
 208                         $letexte = traiter_math($letexte, $source);
 209                 }
 210         }
 211
 212         // Echapper le php pour faire joli (ici, c'est pas pour la securite)
 213         // seulement si on a echappe les <script>
 214         // (derogatoire car on ne peut pas faire passer < ? ... ? >
 215         // dans une callback autonommee
 216         if (strpos($preg ? $preg : _PROTEGE_BLOCS,'script')!==false){
 217                 if (strpos($letexte,"<"."?")!==false AND preg_match_all(',<[?].*($|[?]>),UisS',
 218                 $letexte, $matches, PREG_SET_ORDER))
 219                 foreach ($matches as $regs) {
 220                         $letexte = str_replace($regs[0],
 221                                 code_echappement(highlight_string($regs[0],true), $source),
 222                                 $letexte);
 223                 }
 224         }
 225
 226         return $letexte;
 227 }
 228
 229 //
 230 // Traitement final des echappements
 231 // Rq: $source sert a faire des echappements "a soi" qui ne sont pas nettoyes
 232 // par propre() : exemple dans multi et dans typo()
 233 // http://doc.spip.org/@echappe_retour
 234 function echappe_retour($letexte, $source='', $filtre = "") {
 235         if (strpos($letexte,"base64$source")) {
 236                 # spip_log(spip_htmlspecialchars($letexte));  ## pour les curieux
 237                 $max_prof = 5;
 238                 while (strpos($letexte,"<")!==false
 239                         AND
 240                   preg_match_all(',<(span|div)\sclass=[\'"]base64'.$source.'[\'"]\s(.*)>\s*</\1>,UmsS',
 241                 $letexte, $regs, PREG_SET_ORDER)
 242                   AND $max_prof--) {
 243                         foreach ($regs as $reg) {
 244                                 $rempl = base64_decode(extraire_attribut($reg[0], 'title'));
 245                                 // recherche d'attributs supplementaires
 246                                 $at = array();
 247                                 foreach(array('lang', 'dir') as $attr) {
 248                                         if ($a = extraire_attribut($reg[0], $attr))
 249                                                 $at[$attr] = $a;
 250                                 }
 251                                 if ($at) {
 252                                         $rempl = '<'.$reg[1].'>'.$rempl.'</'.$reg[1].'>';
 253                                         foreach($at as $attr => $a)
 254                                                 $rempl = inserer_attribut($rempl, $attr, $a);
 255                                 }
 256                                 if ($filtre) $rempl = $filtre($rempl);
 257                                 $letexte = str_replace($reg[0], $rempl, $letexte);
 258                         }
 259                 }
 260         }
 261         return $letexte;
 262 }
 263
 264 // Reinserer le javascript de confiance (venant des modeles)
 265
 266 // http://doc.spip.org/@echappe_retour_modeles
 267 function echappe_retour_modeles($letexte, $interdire_scripts=false)
 268 {
 269         $letexte = echappe_retour($letexte);
 270
 271         // Dans les appels directs hors squelette, securiser aussi ici
 272         if ($interdire_scripts)
 273                 $letexte = interdire_scripts($letexte);
 274
 275         return trim($letexte);
 276 }
 277
 278
 279 // http://doc.spip.org/@couper
 280 function couper($texte, $taille=50, $suite = '&nbsp;(...)') {
 281         if (!($length=strlen($texte)) OR $taille <= 0) return '';
 282         $offset = 400 + 2*$taille;
 283         while ($offset<$length
 284                 AND strlen(preg_replace(",<[^>]+>,Uims","",substr($texte,0,$offset)))<$taille)
 285                 $offset = 2*$offset;
 286         if (    $offset<$length
 287                         && ($p_tag_ouvrant = strpos($texte,'<',$offset))!==NULL){
 288                 $p_tag_fermant = strpos($texte,'>',$offset);
 289                 if ($p_tag_fermant && ($p_tag_fermant<$p_tag_ouvrant))
 290                         $offset = $p_tag_fermant+1; // prolonger la coupe jusqu'au tag fermant suivant eventuel
 291         }
 292         $texte = substr($texte, 0, $offset); /* eviter de travailler sur 10ko pour extraire 150 caracteres */
 293
 294         // on utilise les \r pour passer entre les gouttes
 295         $texte = str_replace("\r\n", "\n", $texte);
 296         $texte = str_replace("\r", "\n", $texte);
 297
 298         // sauts de ligne et paragraphes
 299         $texte = preg_replace("/\n\n+/", "\r", $texte);
 300         $texte = preg_replace("/<(p|br)( [^>]*)?".">/", "\r", $texte);
 301
 302         // supprimer les traits, lignes etc
 303         $texte = preg_replace("/(^|\r|\n)(-[-#\*]*|_ )/", "\r", $texte);
 304
 305         // supprimer les tags
 306         $texte = supprimer_tags($texte);
 307         $texte = trim(str_replace("\n"," ", $texte));
 308         $texte .= "\n"; // marquer la fin
 309
 310         // travailler en accents charset
 311         $texte = unicode2charset(html2unicode($texte, /* secure */ true));
 312         if (!function_exists('nettoyer_raccourcis_typo'))
 313                 include_spip('inc/lien');
 314         $texte = nettoyer_raccourcis_typo($texte);
 315
 316         // corriger la longueur de coupe
 317         // en fonction de la presence de caracteres utf
 318         if ($GLOBALS['meta']['charset']=='utf-8'){
 319                 $long = charset2unicode($texte);
 320                 $long = spip_substr($long, 0, max($taille,1));
 321                 $nbcharutf = preg_match_all('/(&#[0-9]{3,5};)/S', $long, $matches);
 322                 $taille += $nbcharutf;
 323         }
 324
 325
 326         // couper au mot precedent
 327         $long = spip_substr($texte, 0, max($taille-4,1));
 328         $u = $GLOBALS['meta']['pcre_u'];
 329         $court = preg_replace("/([^\s][\s]+)[^\s]*\n?$/".$u, "\\1", $long);
 330         $points = $suite;
 331
 332         // trop court ? ne pas faire de (...)
 333         if (spip_strlen($court) < max(0.75 * $taille,2)) {
 334                 $points = '';
 335                 $long = spip_substr($texte, 0, $taille);
 336                 $texte = preg_replace("/([^\s][\s]+)[^\s]*\n?$/".$u, "\\1", $long);
 337                 // encore trop court ? couper au caractere
 338                 if (spip_strlen($texte) < 0.75 * $taille)
 339                         $texte = $long;
 340         } else
 341                 $texte = $court;
 342
 343         if (strpos($texte, "\n"))       // la fin est encore la : c'est qu'on n'a pas de texte de suite
 344                 $points = '';
 345
 346         // remettre les paragraphes
 347         $texte = preg_replace("/\r+/", "\n\n", $texte);
 348
 349         // supprimer l'eventuelle entite finale mal coupee
 350         $texte = preg_replace('/&#?[a-z0-9]*$/S', '', $texte);
 351
 352         return quote_amp(trim($texte)).$points;
 353 }
 354
 355
 356 // http://doc.spip.org/@protege_js_modeles
 357 function protege_js_modeles($t) {
 358         if (isset($GLOBALS['visiteur_session'])){
 359                 if (preg_match_all(',<script.*?($|</script.),isS', $t, $r, PREG_SET_ORDER)){
 360                         if (!defined('_PROTEGE_JS_MODELES')){
 361                                 include_spip('inc/acces');
 362                                 define('_PROTEGE_JS_MODELES',creer_uniqid());
 363                         }
 364                         foreach ($r as $regs)
 365                                 $t = str_replace($regs[0],code_echappement($regs[0],'javascript'._PROTEGE_JS_MODELES),$t);
 366                 }
 367                 if (preg_match_all(',<\?php.*?($|\?'.'>),isS', $t, $r, PREG_SET_ORDER)){
 368                         if (!defined('_PROTEGE_PHP_MODELES')){
 369                                 include_spip('inc/acces');
 370                                 define('_PROTEGE_PHP_MODELES',creer_uniqid());
 371                         }
 372                         foreach ($r as $regs)
 373                                 $t = str_replace($regs[0],code_echappement($regs[0],'php'._PROTEGE_PHP_MODELES),$t);
 374                 }
 375         }
 376         return $t;
 377 }
 378
 379
 380 function echapper_faux_tags($letexte){
 381         if (strpos($letexte,'<')===false)
 382                 return $letexte;
 383   $textMatches = preg_split (',(</?[a-z!][^<>]*>),', $letexte, null, PREG_SPLIT_DELIM_CAPTURE);
 384
 385   $letexte = "";
 386   while (count($textMatches)) {
 387         // un texte a echapper
 388         $letexte .= str_replace(array("<"),array('&lt;'),array_shift($textMatches));
 389         // un tag html qui a servit a faite le split
 390                 $letexte .= array_shift($textMatches);
 391   }
 392   return $letexte;
 393 }
 394
 395 // Securite : utiliser SafeHTML s'il est present dans ecrire/safehtml/
 396 // http://doc.spip.org/@safehtml
 397 function safehtml($t) {
 398         static $safehtml;
 399
 400         if (!$t OR !is_string($t))
 401                 return $t;
 402         # attention safehtml nettoie deux ou trois caracteres de plus. A voir
 403         if (strpos($t,'<')===false)
 404                 return str_replace("\x00", '', $t);
 405
 406         $t = interdire_scripts($t); // jolifier le php
 407         $t = echappe_js($t);
 408
 409         if (!isset($safehtml))
 410                 $safehtml = charger_fonction('safehtml', 'inc', true);
 411         if ($safehtml)
 412                 $t = $safehtml($t);
 413
 414         return interdire_scripts($t); // interdire le php (2 precautions)
 415 }
 416
 417
 418 // fonction en cas de texte extrait d'un serveur distant:
 419 // on ne sait pas (encore) rapatrier les documents joints
 420 // Sert aussi a nettoyer un texte qu'on veut mettre dans un <a> etc.
 421 // TODO: gerer les modeles ?
 422 // http://doc.spip.org/@supprime_img
 423 function supprime_img($letexte, $message=NULL) {
 424         if ($message===NULL) $message = '(' . _T('img_indisponible') . ')';
 425         return preg_replace(',<(img|doc|emb)([0-9]+)(\|([^>]*))?'.'\s*/?'.'>,i',
 426                 $message, $letexte);
 427 }