www/ecrire/inc/distant.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 /**
  14  * Ce fichier gère l'obtention de données distantes
  15  *
  16  * @package SPIP\Core\Distant
  17 **/
  18 if (!defined('_ECRIRE_INC_VERSION')) return;
  19
  20 if (!defined('_INC_DISTANT_VERSION_HTTP')) define('_INC_DISTANT_VERSION_HTTP', "HTTP/1.0");
  21 if (!defined('_INC_DISTANT_CONTENT_ENCODING')) define('_INC_DISTANT_CONTENT_ENCODING', "gzip");
  22 if (!defined('_INC_DISTANT_USER_AGENT')) define('_INC_DISTANT_USER_AGENT', 'SPIP-' . $GLOBALS['spip_version_affichee'] . " (" . $GLOBALS['home_server'] . ")");
  23 if (!defined('_INC_DISTANT_MAX_SIZE')) define('_INC_DISTANT_MAX_SIZE',2097152);
  24 if (!defined('_INC_DISTANT_CONNECT_TIMEOUT')) define('_INC_DISTANT_CONNECT_TIMEOUT',10);
  25
  26 define('_REGEXP_COPIE_LOCALE', ',' .
  27        preg_replace('@^https?:@', 'https?:', $GLOBALS['meta']['adresse_site'])
  28        . "/?spip.php[?]action=acceder_document.*file=(.*)$,");
  29
  30 //@define('_COPIE_LOCALE_MAX_SIZE',2097152); // poids (inc/utils l'a fait)
  31
  32 /**
  33  * Crée au besoin la copie locale d'un fichier distant
  34  *
  35  * Prend en argument un chemin relatif au rep racine, ou une URL
  36  * Renvoie un chemin relatif au rep racine, ou false
  37  *
  38  * @link http://www.spip.net/4155
  39  *
  40  * @param $source
  41  * @param string $mode
  42  *   'test' - ne faire que tester
  43  *   'auto' - charger au besoin
  44  *   'modif' - Si deja present, ne charger que si If-Modified-Since
  45  *   'force' - charger toujours (mettre a jour)
  46  * @param string $local
  47  *   permet de specifier le nom du fichier local (stockage d'un cache par exemple, et non document IMG)
  48  * @param int $taille_max
  49  *   taille maxi de la copie local, par defaut _COPIE_LOCALE_MAX_SIZE
  50  * @return bool|string
  51  */
  52 function copie_locale($source, $mode='auto', $local=null, $taille_max=null){
  53
  54         // si c'est la protection de soi-meme, retourner le path
  55         if ($mode !== 'force' AND preg_match(_REGEXP_COPIE_LOCALE, $source, $match)) {
  56                 $source = substr(_DIR_IMG,strlen(_DIR_RACINE)) . urldecode($match[1]);
  57                 return @file_exists($source) ? $source : false;
  58         }
  59
  60         if (is_null($local))
  61                 $local = fichier_copie_locale($source);
  62         else {
  63                 if (_DIR_RACINE AND strncmp(_DIR_RACINE, $local, strlen(_DIR_RACINE))==0) {
  64                         $local = substr($local, strlen(_DIR_RACINE));
  65                 }
  66         }
  67
  68         // si $local = '' c'est un fichier refuse par fichier_copie_locale(),
  69         // par exemple un fichier qui ne figure pas dans nos documents ;
  70         // dans ce cas on n'essaie pas de le telecharger pour ensuite echouer
  71         if (!$local) return false;
  72
  73         $localrac = _DIR_RACINE.$local;
  74         $t = ($mode=='force') ? false  : @file_exists($localrac);
  75
  76         // test d'existence du fichier
  77         if ($mode=='test') return $t ? $local : '';
  78
  79         // sinon voir si on doit/peut le telecharger
  80         if ($local==$source OR !preg_match(',^\w+://,', $source))
  81                 return $local;
  82
  83         if ($mode=='modif' OR !$t){
  84                 // passer par un fichier temporaire unique pour gerer les echecs en cours de recuperation
  85                 // et des eventuelles recuperations concurantes
  86                 include_spip("inc/acces");
  87                 if (!$taille_max) $taille_max = _COPIE_LOCALE_MAX_SIZE;
  88                 $res = recuperer_page($source, $localrac, false, $taille_max, '', '', false, $t ? filemtime($localrac) : '');
  89                 if (!$res) {
  90                         if (!$t) // si $t c'est sans doute juste un not-modified-since qui fait renvoyer false
  91                                 spip_log("copie_locale : Echec recuperation $source sur $localrac",_LOG_INFO_IMPORTANTE);
  92                         return $t ? $local : false;
  93                 }
  94                 spip_log("copie_locale : recuperation $source sur $localrac taille $res OK");
  95
  96                 // pour une eventuelle indexation
  97                 pipeline('post_edition',
  98                         array(
  99                                 'args' => array(
 100                                         'operation' => 'copie_locale',
 101                                         'source' => $source,
 102                                         'fichier' => $local
 103                                 ),
 104                                 'data' => null
 105                         )
 106                 );
 107         }
 108
 109         return $local;
 110 }
 111
 112 // http://doc.spip.org/@prepare_donnees_post
 113 function prepare_donnees_post($donnees, $boundary = '') {
 114
 115         // permettre a la fonction qui a demande le post de formater elle meme ses donnees
 116         // pour un appel soap par exemple
 117         // l'entete est separe des donnees par un double retour a la ligne
 118         // on s'occupe ici de passer tous les retours lignes (\r\n, \r ou \n) en \r\n
 119         if (is_string($donnees) && strlen($donnees)){
 120                 $entete = "";
 121                 // on repasse tous les \r\n et \r en simples \n
 122                 $donnees = str_replace("\r\n","\n",$donnees);
 123                 $donnees = str_replace("\r","\n",$donnees);
 124                 // un double retour a la ligne signifie la fin de l'entete et le debut des donnees
 125                 $p = strpos($donnees, "\n\n");
 126                 if ($p!==FALSE){
 127                         $entete = str_replace("\n", "\r\n", substr($donnees, 0, $p+1));
 128                         $donnees = substr($donnees, $p+2);
 129                 }
 130                 $chaine = str_replace("\n", "\r\n", $donnees);
 131         }
 132         else {
 133                 /* boundary automatique */
 134                 // Si on a plus de 500 octects de donnees, on "boundarise"
 135                 if ($boundary===''){
 136                         $taille = 0;
 137                         foreach ($donnees as $cle => $valeur){
 138                                 if (is_array($valeur)){
 139                                         foreach ($valeur as $val2){
 140                                                 $taille += strlen($val2);
 141                                         }
 142                                 } else {
 143                                         // faut-il utiliser spip_strlen() dans inc/charsets ?
 144                                         $taille += strlen($valeur);
 145                                 }
 146                         }
 147                         if ($taille>500){
 148                                 $boundary = substr(md5(rand() . 'spip'), 0, 8);
 149                         }
 150                 }
 151
 152                 if (is_string($boundary) and strlen($boundary)){
 153                         // fabrique une chaine HTTP pour un POST avec boundary
 154                         $entete = "Content-Type: multipart/form-data; boundary=$boundary\r\n";
 155                         $chaine = '';
 156                         if (is_array($donnees)) {
 157                                 foreach ($donnees as $cle => $valeur) {
 158                                         if (is_array($valeur)) {
 159                                                 foreach ($valeur as $val2) {
 160                                                         $chaine .= "\r\n--$boundary\r\n";
 161                                                         $chaine .= "Content-Disposition: form-data; name=\"{$cle}[]\"\r\n";
 162                                                         $chaine .= "\r\n";
 163                                                         $chaine .= $val2;
 164                                                 }
 165                                         } else {
 166                                                 $chaine .= "\r\n--$boundary\r\n";
 167                                                 $chaine .= "Content-Disposition: form-data; name=\"$cle\"\r\n";
 168                                                 $chaine .= "\r\n";
 169                                                 $chaine .= $valeur;
 170                                         }
 171                                 }
 172                                 $chaine .= "\r\n--$boundary\r\n";
 173                         }
 174                 } else {
 175                         // fabrique une chaine HTTP simple pour un POST
 176                         $entete = 'Content-Type: application/x-www-form-urlencoded'."\r\n";
 177                         $chaine = array();
 178                         if (is_array($donnees)) {
 179                                 foreach ($donnees as $cle => $valeur) {
 180                                         if (is_array($valeur)) {
 181                                                 foreach ($valeur as $val2) {
 182                                                         $chaine[] = rawurlencode($cle).'[]='.rawurlencode($val2);
 183                                                 }
 184                                         } else {
 185                                                 $chaine[] = rawurlencode($cle).'='.rawurlencode($valeur);
 186                                         }
 187                                 }
 188                                 $chaine = implode('&', $chaine);
 189                         } else {
 190                                 $chaine = $donnees;
 191                         }
 192                 }
 193         }
 194         return array($entete, $chaine);
 195 }
 196
 197 /**
 198  * Convertir une URL dont le host est en utf8 en ascii
 199  * Utilise la librairie https://github.com/phlylabs/idna-convert/tree/v0.9.1
 200  * dans sa derniere version compatible toutes version PHP 5
 201  * La fonction PHP idn_to_ascii depend d'un package php5-intl et est rarement disponible
 202  *
 203  * @param string $url_idn
 204  * @return array|string
 205  */
 206 function url_to_ascii($url_idn) {
 207
 208         if ($parts = parse_url($url_idn)) {
 209                 $host = $parts['host'];
 210                 if (!preg_match(',^[a-z0-9_\.\-]+$,i', $host)) {
 211                         include_spip('inc/idna_convert.class');
 212                         $IDN = new idna_convert();
 213                         $host_ascii = $IDN->encode($host);
 214                         $url_idn = explode($host, $url_idn, 2);
 215                         $url_idn = implode($host_ascii, $url_idn);
 216                 }
 217         }
 218
 219         return $url_idn;
 220 }
 221
 222 //
 223 // Recupere une page sur le net
 224 // et au besoin l'encode dans le charset local
 225 //
 226 // options : get_headers si on veut recuperer les entetes
 227 // taille_max : arreter le contenu au-dela (0 = seulement les entetes ==>HEAD)
 228 // Par defaut taille_max = 1Mo.
 229 // datas, une chaine ou un tableau pour faire un POST de donnees
 230 // boundary, pour forcer l'envoi par cette methode
 231 // et refuser_gz pour forcer le refus de la compression (cas des serveurs orthographiques)
 232 // date_verif, un timestamp unix pour arreter la recuperation si la page distante n'a pas ete modifiee depuis une date donnee
 233 // uri_referer, preciser un referer different
 234 // Le second argument ($trans) :
 235 // * si c'est une chaine longue, alors c'est un nom de fichier
 236 //   dans lequel on ecrit directement la page
 237 // * si c'est true/null ca correspond a une demande d'encodage/charset
 238 // http://doc.spip.org/@recuperer_page
 239 function recuperer_page($url, $trans = false, $get_headers = false,
 240                         $taille_max = null, $datas = '', $boundary = '', $refuser_gz = false,
 241                         $date_verif = '', $uri_referer = ''){
 242         $gz = false;
 243
 244         // $copy = copier le fichier ?
 245         $copy = (is_string($trans) AND strlen($trans)>5); // eviter "false" :-)
 246
 247         if (is_null($taille_max))
 248                 $taille_max = $copy ? _COPIE_LOCALE_MAX_SIZE : _INC_DISTANT_MAX_SIZE;
 249
 250         // Accepter les URLs au format feed:// ou qui ont oublie le http://
 251         $url = preg_replace(',^feed://,i', 'http://', $url);
 252         if (!preg_match(',^[a-z]+://,i', $url)) $url = 'http://' . $url;
 253         $url = url_to_ascii($url);
 254
 255         if ($taille_max==0)
 256                 $get = 'HEAD';
 257         else
 258                 $get = 'GET';
 259
 260         if (!empty($datas)) {
 261                 $get = 'POST';
 262                 list($type, $postdata) = prepare_donnees_post($datas, $boundary);
 263                 $datas = $type . 'Content-Length: ' . strlen($postdata) . "\r\n\r\n" . $postdata;
 264         }
 265
 266         // dix tentatives maximum en cas d'entetes 301...
 267         for ($i = 0; $i<10; $i++){
 268                 $url = recuperer_lapage($url, $trans, $get, $taille_max, $datas, $refuser_gz, $date_verif, $uri_referer);
 269                 if (!$url) return false;
 270                 if (is_array($url)){
 271                         list($headers, $result) = $url;
 272                         return ($get_headers ? $headers . "\n" : '') . $result;
 273                 } else spip_log("recuperer page recommence sur $url");
 274         }
 275 }
 276
 277 // args comme ci-dessus (presque)
 278 // retourne l'URL en cas de 301, un tableau (entete, corps) si ok, false sinon
 279 // si $trans est null -> on ne veut que les headers
 280 // si $trans est une chaine, c'est un nom de fichier pour ecrire directement dedans
 281 // http://doc.spip.org/@recuperer_lapage
 282 function recuperer_lapage($url, $trans = false, $get = 'GET', $taille_max = _INC_DISTANT_MAX_SIZE, $datas = '', $refuser_gz = false, $date_verif = '', $uri_referer = ''){
 283         // $copy = copier le fichier ?
 284         $copy = (is_string($trans) AND strlen($trans)>5); // eviter "false" :-)
 285
 286         // si on ecrit directement dans un fichier, pour ne pas manipuler
 287         // en memoire refuser gz
 288         if ($copy)
 289                 $refuser_gz = true;
 290
 291         // ouvrir la connexion et envoyer la requete et ses en-tetes
 292         list($f, $fopen) = init_http($get, $url, $refuser_gz, $uri_referer, $datas, _INC_DISTANT_VERSION_HTTP, $date_verif);
 293         if (!$f){
 294                 spip_log("ECHEC init_http $url");
 295                 return false;
 296         }
 297
 298         $result = '';
 299         // Sauf en fopen, envoyer le flux d'entree
 300         // et recuperer les en-tetes de reponses
 301         if ($fopen)
 302                 $headers = '';
 303         else {
 304                 $headers = recuperer_entetes($f, $date_verif);
 305                 if (is_numeric($headers)){
 306                         fclose($f);
 307                         // Chinoisierie inexplicable pour contrer
 308                         // les actions liberticides de l'empire du milieu
 309                         if ($headers){
 310                                 spip_log("HTTP status $headers pour $url");
 311                                 return false;
 312                         }
 313                         $t = @parse_url($url);
 314                         $host = $t['host'];
 315                         if (!need_proxy($host)
 316                                 AND $result = @file_get_contents($url)){
 317                                 // on peuple les headers de vide et on continue
 318                                 $headers = array('');
 319                         }
 320                         else
 321                                 return false;
 322                 }
 323                 if (!is_array($headers)){ // cas Location
 324                         fclose($f);
 325                         include_spip('inc/filtres');
 326                         return suivre_lien($url, $headers);
 327                 }
 328                 $headers = join('', $headers);
 329         }
 330
 331         if ($trans===NULL) return array($headers, '');
 332
 333         // s'il faut deballer, le faire via un fichier temporaire
 334         // sinon la memoire explose pour les gros flux
 335
 336         $gz = preg_match(",\bContent-Encoding: .*gzip,is", $headers) ?
 337                 (_DIR_TMP . md5(uniqid(mt_rand())) . '.tmp.gz') : '';
 338
 339 #       spip_log("entete ($trans $copy $gz)\n$headers");
 340         if (!$result){
 341                 $result = recuperer_body($f, $taille_max, $gz ? $gz : ($copy ? $trans : ''));
 342                 fclose($f);
 343         }
 344         if (!$result)
 345                 return array($headers, $result);
 346
 347         // Decompresser au besoin
 348         if ($gz){
 349                 $result = join('', gzfile($gz));
 350                 supprimer_fichier($gz);
 351         }
 352         // Faut-il l'importer dans notre charset local ?
 353         if ($trans===true){
 354                 include_spip('inc/charsets');
 355                 $result = transcoder_page($result, $headers);
 356         }
 357
 358         return array($headers, $result);
 359 }
 360
 361 // http://doc.spip.org/@recuperer_body
 362 function recuperer_body($f, $taille_max = _INC_DISTANT_MAX_SIZE, $fichier = ''){
 363         $taille = 0;
 364         $result = '';
 365         $fp = false;
 366         if ($fichier){
 367                 include_spip("inc/acces");
 368                 $tmpfile = "$fichier.".creer_uniqid().".tmp";
 369                 $fp = spip_fopen_lock($tmpfile, 'w', LOCK_EX);
 370                 if (!$fp AND file_exists($fichier)){
 371                         return filesize($fichier);
 372                 }
 373                 if (!$fp)
 374                         return false;
 375                 $result = 0; // on renvoie la taille du fichier
 376         }
 377         while (!feof($f) AND $taille<$taille_max){
 378                 $res = fread($f, 16384);
 379                 $taille += strlen($res);
 380                 if ($fp){
 381                         fwrite($fp, $res);
 382                         $result = $taille;
 383                 }
 384                 else
 385                         $result .= $res;
 386         }
 387         if ($fp){
 388                 spip_fclose_unlock($fp);
 389                 spip_unlink($fichier);
 390                 @rename($tmpfile, $fichier);
 391                 if (!file_exists($fichier))
 392                         return false;
 393         }
 394         return $result;
 395 }
 396
 397 // Lit les entetes de reponse HTTP sur la socket $f et retourne:
 398 // la valeur (chaine) de l'en-tete Location si on l'a trouvee
 399 // la valeur (numerique) du statut si different de 200, notamment Not-Modified
 400 // le tableau des entetes dans tous les autres cas
 401
 402 // http://doc.spip.org/@recuperer_entetes
 403 function recuperer_entetes($f, $date_verif = ''){
 404         $s = @trim(fgets($f, 16384));
 405
 406         if (!preg_match(',^HTTP/[0-9]+\.[0-9]+ ([0-9]+),', $s, $r)){
 407                 return 0;
 408         }
 409         $status = intval($r[1]);
 410         $headers = array();
 411         $not_modif = $location = false;
 412         while ($s = trim(fgets($f, 16384))){
 413                 $headers[] = $s . "\n";
 414                 preg_match(',^([^:]*): *(.*)$,i', $s, $r);
 415                 list(, $d, $v) = $r;
 416                 if (strtolower(trim($d))=='location' AND $status>=300 AND $status<400){
 417                         $location = $v;
 418                 }
 419                 elseif ($date_verif AND ($d=='Last-Modified')) {
 420                         if ($date_verif>=strtotime($v)){
 421                                 //Cas ou la page distante n'a pas bouge depuis
 422                                 //la derniere visite
 423                                 $not_modif = true;
 424                         }
 425                 }
 426         }
 427
 428         if ($location)
 429                 return $location;
 430         if ($status!=200 or $not_modif)
 431                 return $status;
 432         return $headers;
 433 }
 434
 435 // Si on doit conserver une copie locale des fichiers distants, autant que ca
 436 // soit a un endroit canonique -- si ca peut etre bijectif c'est encore mieux,
 437 // mais la tout de suite je ne trouve pas l'idee, etant donne les limitations
 438 // des filesystems
 439 // http://doc.spip.org/@nom_fichier_copie_locale
 440 function nom_fichier_copie_locale($source, $extension){
 441         include_spip('inc/documents');
 442
 443         $d = creer_repertoire_documents('distant'); # IMG/distant/
 444         $d = sous_repertoire($d, $extension); # IMG/distant/pdf/
 445
 446         // on se place tout le temps comme si on etait a la racine
 447         if (_DIR_RACINE)
 448                 $d = preg_replace(',^' . preg_quote(_DIR_RACINE) . ',', '', $d);
 449
 450         $m = md5($source);
 451
 452         return $d
 453                 . substr(preg_replace(',[^\w-],', '', basename($source)) . '-' . $m, 0, 12)
 454                 . substr($m, 0, 4)
 455                 . ".$extension";
 456 }
 457
 458 //
 459 // Donne le nom de la copie locale de la source
 460 //
 461 // http://doc.spip.org/@fichier_copie_locale
 462 function fichier_copie_locale($source){
 463         // Si c'est deja local pas de souci
 464         if (!preg_match(',^\w+://,', $source)){
 465                 if (_DIR_RACINE)
 466                         $source = preg_replace(',^' . preg_quote(_DIR_RACINE) . ',', '', $source);
 467                 return $source;
 468         }
 469
 470         // optimisation : on regarde si on peut deviner l'extension dans l'url et si le fichier
 471         // a deja ete copie en local avec cette extension
 472         // dans ce cas elle est fiable, pas la peine de requeter en base
 473         $path_parts = pathinfo($source);
 474         $ext = $path_parts ? $path_parts['extension'] : '';
 475         if ($ext
 476         AND preg_match(',^\w+$,', $ext) // pas de php?truc=1&...
 477         AND $f = nom_fichier_copie_locale($source, $ext)
 478         AND file_exists(_DIR_RACINE . $f)
 479         )
 480                 return $f;
 481
 482
 483         // Si c'est deja dans la table des documents,
 484         // ramener le nom de sa copie potentielle
 485
 486         $ext = sql_getfetsel("extension", "spip_documents", "fichier=" . sql_quote($source) . " AND distant='oui' AND extension <> ''");
 487
 488
 489         if ($ext) return nom_fichier_copie_locale($source, $ext);
 490
 491         // voir si l'extension indiquee dans le nom du fichier est ok
 492         // et si il n'aurait pas deja ete rapatrie
 493
 494         $ext = $path_parts ? $path_parts['extension'] : '';
 495
 496         if ($ext AND sql_getfetsel("extension", "spip_types_documents", "extension=" . sql_quote($ext))){
 497                 $f = nom_fichier_copie_locale($source, $ext);
 498                 if (file_exists(_DIR_RACINE . $f))
 499                         return $f;
 500         }
 501
 502         // Ping  pour voir si son extension est connue et autorisee
 503         // avec mise en cache du resultat du ping
 504
 505         $cache = sous_repertoire(_DIR_CACHE, 'rid') . md5($source);
 506         if (!@file_exists($cache)
 507                 OR !$path_parts = @unserialize(spip_file_get_contents($cache))
 508                 OR _request('var_mode')=='recalcul'
 509         ){
 510                 $path_parts = recuperer_infos_distantes($source, 0, false);
 511                 ecrire_fichier($cache, serialize($path_parts));
 512         }
 513         $ext = $path_parts ? $path_parts['extension'] : '';
 514         if ($ext AND sql_getfetsel("extension", "spip_types_documents", "extension=" . sql_quote($ext))){
 515                 return nom_fichier_copie_locale($source, $ext);
 516         }
 517         spip_log("pas de copie locale pour $source");
 518 }
 519
 520
 521 // Recuperer les infos d'un document distant, sans trop le telecharger
 522 #$a['body'] = chaine
 523 #$a['type_image'] = booleen
 524 #$a['titre'] = chaine
 525 #$a['largeur'] = intval
 526 #$a['hauteur'] = intval
 527 #$a['taille'] = intval
 528 #$a['extension'] = chaine
 529 #$a['fichier'] = chaine
 530 #$a['mime_type'] = chaine
 531
 532 // http://doc.spip.org/@recuperer_infos_distantes
 533 function recuperer_infos_distantes($source, $max = 0, $charger_si_petite_image = true){
 534
 535         // pas la peine de perdre son temps
 536         if (!tester_url_absolue($source)) {
 537                 return false;
 538         }
 539
 540         # charger les alias des types mime
 541         include_spip('base/typedoc');
 542         global $mime_alias;
 543
 544         $a = array();
 545         $mime_type = '';
 546         // On va directement charger le debut des images et des fichiers html,
 547         // de maniere a attrapper le maximum d'infos (titre, taille, etc). Si
 548         // ca echoue l'utilisateur devra les entrer...
 549         if ($headers = recuperer_page($source, false, true, $max, '', '', true)){
 550                 list($headers, $a['body']) = preg_split(',\n\n,', $headers, 2);
 551
 552                 if (preg_match(",\nContent-Type: *([^[:space:];]*),i", "\n$headers", $regs))
 553                         $mime_type = (trim($regs[1]));
 554                 else
 555                         $mime_type = ''; // inconnu
 556
 557                 // Appliquer les alias
 558                 while (isset($mime_alias[$mime_type]))
 559                         $mime_type = $mime_alias[$mime_type];
 560
 561                 // Si on a un mime-type insignifiant
 562                 // text/plain,application/octet-stream ou vide
 563                 // c'est peut-etre que le serveur ne sait pas
 564                 // ce qu'il sert ; on va tenter de detecter via l'extension de l'url
 565                 // ou le Content-Disposition: attachment; filename=...
 566                 $t = null;
 567                 if (in_array($mime_type, array('text/plain', '', 'application/octet-stream'))){
 568                         if (!$t
 569                                 AND preg_match(',\.([a-z0-9]+)(\?.*)?$,i', $source, $rext)
 570                         ){
 571                                 $t = sql_fetsel("extension", "spip_types_documents", "extension=" . sql_quote($rext[1],'','text'));
 572                         }
 573                         if (!$t
 574                                 AND preg_match(",^Content-Disposition:\s*attachment;\s*filename=(.*)$,Uims", $headers, $m)
 575                                 AND preg_match(',\.([a-z0-9]+)(\?.*)?$,i', $m[1], $rext)
 576                         ){
 577                                 $t = sql_fetsel("extension", "spip_types_documents", "extension=" . sql_quote($rext[1],'','text'));
 578                         }
 579                 }
 580
 581                 // Autre mime/type (ou text/plain avec fichier d'extension inconnue)
 582                 if (!$t)
 583                         $t = sql_fetsel("extension", "spip_types_documents", "mime_type=" . sql_quote($mime_type));
 584
 585                 // Toujours rien ? (ex: audio/x-ogg au lieu de application/ogg)
 586                 // On essaie de nouveau avec l'extension
 587                 if (!$t
 588                         AND $mime_type!='text/plain'
 589                         AND preg_match(',\.([a-z0-9]+)(\?.*)?$,i', $source, $rext)
 590                 ){
 591                         $t = sql_fetsel("extension", "spip_types_documents", "extension=" . sql_quote($rext[1],'','text')); # eviter xxx.3 => 3gp (> SPIP 3)
 592                 }
 593
 594
 595                 if ($t){
 596                         spip_log("mime-type $mime_type ok, extension " . $t['extension']);
 597                         $a['extension'] = $t['extension'];
 598                 } else {
 599                         # par defaut on retombe sur '.bin' si c'est autorise
 600                         spip_log("mime-type $mime_type inconnu");
 601                         $t = sql_fetsel("extension", "spip_types_documents", "extension='bin'");
 602                         if (!$t) return false;
 603                         $a['extension'] = $t['extension'];
 604                 }
 605
 606                 if (preg_match(",\nContent-Length: *([^[:space:]]*),i",
 607                         "\n$headers", $regs)
 608                 )
 609                         $a['taille'] = intval($regs[1]);
 610         }
 611
 612         // Echec avec HEAD, on tente avec GET
 613         if (!$a AND !$max){
 614                 spip_log("tenter GET $source");
 615                 $a = recuperer_infos_distantes($source, _INC_DISTANT_MAX_SIZE);
 616         }
 617
 618         // si on a rien trouve pas la peine d'insister
 619         if (!$a) {
 620                 return false;
 621         }
 622
 623         // S'il s'agit d'une image pas trop grosse ou d'un fichier html, on va aller
 624         // recharger le document en GET et recuperer des donnees supplementaires...
 625         if (preg_match(',^image/(jpeg|gif|png|swf),', $mime_type)){
 626                 if ($max==0
 627                         AND $a['taille']<_INC_DISTANT_MAX_SIZE
 628                                 AND (strpos($GLOBALS['meta']['formats_graphiques'], $a['extension'])!==false)
 629                                         AND $charger_si_petite_image
 630                 ){
 631                         $a = recuperer_infos_distantes($source, _INC_DISTANT_MAX_SIZE);
 632                 }
 633                 else if ($a['body']){
 634                         $a['fichier'] = _DIR_RACINE . nom_fichier_copie_locale($source, $a['extension']);
 635                         ecrire_fichier($a['fichier'], $a['body']);
 636                         $size_image = @getimagesize($a['fichier']);
 637                         $a['largeur'] = intval($size_image[0]);
 638                         $a['hauteur'] = intval($size_image[1]);
 639                         $a['type_image'] = true;
 640                 }
 641         }
 642
 643         // Fichier swf, si on n'a pas la taille, on va mettre 425x350 par defaut
 644         // ce sera mieux que 0x0
 645         if ($a AND $a['extension']=='swf'
 646                 AND !$a['largeur']
 647         ){
 648                 $a['largeur'] = 425;
 649                 $a['hauteur'] = 350;
 650         }
 651
 652         if ($mime_type=='text/html'){
 653                 include_spip('inc/filtres');
 654                 $page = recuperer_page($source, true, false, _INC_DISTANT_MAX_SIZE);
 655                 if (preg_match(',<title>(.*?)</title>,ims', $page, $regs))
 656                         $a['titre'] = corriger_caracteres(trim($regs[1]));
 657                 if (!$a['taille']) $a['taille'] = strlen($page); # a peu pres
 658         }
 659         $a['mime_type']=$mime_type;
 660
 661         return $a;
 662 }
 663
 664
 665 /**
 666  * Tester si un host peut etre recuperer directement ou doit passer par un proxy
 667  * on peut passer en parametre le proxy et la liste des host exclus,
 668  * pour les besoins des tests, lors de la configuration
 669  *
 670  * @param string $host
 671  * @param string $http_proxy
 672  * @param string $http_noproxy
 673  * @return string
 674  */
 675 function need_proxy($host, $http_proxy = null, $http_noproxy = null){
 676         if (is_null($http_proxy))
 677                 $http_proxy = @$GLOBALS['meta']["http_proxy"];
 678         if (is_null($http_noproxy))
 679                 $http_noproxy = @$GLOBALS['meta']["http_noproxy"];
 680
 681         $domain = substr($host, strpos($host, '.'));
 682
 683         return ($http_proxy
 684                 AND (strpos(" $http_noproxy ", " $host ")===false
 685                 AND (strpos(" $http_noproxy ", " $domain ")===false)))
 686                 ? $http_proxy : '';
 687 }
 688
 689 //
 690 // Lance une requete HTTP avec entetes
 691 // retourne le descripteur sur lequel lire la reponse
 692 //
 693 // http://doc.spip.org/@init_http
 694 function init_http($method, $url, $refuse_gz = false, $referer = '', $datas = "", $vers = "HTTP/1.0", $date = ''){
 695         $user = $via_proxy = $proxy_user = '';
 696         $fopen = false;
 697
 698         $t = @parse_url($url);
 699         $host = $t['host'];
 700         if ($t['scheme']=='http'){
 701                 $scheme = 'http';
 702                 $noproxy = '';
 703         } elseif ($t['scheme']=='https') {
 704                 $scheme = 'tls';
 705                 $noproxy = 'tls://';
 706                 if (!isset($t['port']) || !($port = $t['port'])) $t['port'] = 443;
 707         }
 708         else {
 709                 $scheme = $t['scheme'];
 710                 $noproxy = $scheme . '://';
 711         }
 712         if (isset($t['user']))
 713                 $user = array($t['user'], $t['pass']);
 714
 715         if (!isset($t['port']) || !($port = $t['port'])) $port = 80;
 716         if (!isset($t['path']) || !($path = $t['path'])) $path = "/";
 717         if (@$t['query']) $path .= "?" . $t['query'];
 718
 719         $f = lance_requete($method, $scheme, $user, $host, $path, $port, $noproxy, $refuse_gz, $referer, $datas, $vers, $date);
 720         if (!$f){
 721                 // fallback : fopen
 722                 if (!need_proxy($host)
 723                   AND !_request('tester_proxy')
 724                   AND (!isset($GLOBALS['inc_distant_allow_fopen']) OR $GLOBALS['inc_distant_allow_fopen'])){
 725                         $f = @fopen($url, "rb");
 726                         spip_log("connexion vers $url par simple fopen");
 727                         $fopen = true;
 728                 }
 729                 else
 730                         $f = false;
 731                 // echec total
 732         }
 733
 734         return array($f, $fopen);
 735 }
 736
 737 // http://doc.spip.org/@lance_requete
 738 function lance_requete($method, $scheme, $user, $host, $path, $port, $noproxy, $refuse_gz = false, $referer = '', $datas = "", $vers = "HTTP/1.0", $date = ''){
 739
 740         $proxy_user = '';
 741         $http_proxy = need_proxy($host);
 742         if ($user) $user = urlencode($user[0]) . ":" . urlencode($user[1]);
 743
 744         $connect = "";
 745         if ($http_proxy){
 746                 if (defined('_PROXY_HTTPS_VIA_CONNECT') AND $scheme=="tls"){
 747                         $path_host = (!$user ? '' : "$user@") . $host . (($port!=80) ? ":$port" : "");
 748                         $connect = "CONNECT " .$path_host." $vers\r\n"
 749                                 ."Host: $path_host\r\n"
 750                                 ."Proxy-Connection: Keep-Alive\r\n";
 751                 }
 752                 else {
 753                         $path = (($scheme=='tls') ? 'https://' : "$scheme://")
 754                                 . (!$user ? '' : "$user@")
 755                                 . "$host" . (($port!=80) ? ":$port" : "") . $path;
 756                 }
 757                 $t2 = @parse_url($http_proxy);
 758                 $first_host = $t2['host'];
 759                 if (!($port = $t2['port'])) $port = 80;
 760                 if ($t2['user'])
 761                         $proxy_user = base64_encode($t2['user'] . ":" . $t2['pass']);
 762         }
 763         else
 764                 $first_host = $noproxy . $host;
 765
 766         if ($connect){
 767                 $streamContext = stream_context_create(array('ssl' => array('verify_peer' => false, 'allow_self_signed' => true)));
 768                 $f = @stream_socket_client("tcp://$first_host:$port", $nError, $sError, _INC_DISTANT_CONNECT_TIMEOUT, STREAM_CLIENT_CONNECT, $streamContext);
 769                 spip_log("Recuperer $path sur $first_host:$port par $f (via CONNECT)","connect");
 770                 if (!$f) return false;
 771                 stream_set_timeout($f, _INC_DISTANT_CONNECT_TIMEOUT);
 772
 773                 fputs($f, $connect);
 774                 fputs($f, "\r\n");
 775                 $res = fread($f, 1024);
 776                 if (!$res
 777                   OR !count($res = explode(' ',$res))
 778                   OR $res[1]!=='200'){
 779                         spip_log("Echec CONNECT sur $first_host:$port","connect"._LOG_INFO_IMPORTANTE);
 780                         fclose($f);
 781                         return false;
 782                 }
 783                 // important, car sinon on lit trop vite et les donnees ne sont pas encore dispo
 784                 stream_set_blocking($f, true);
 785                 // envoyer le handshake
 786                 stream_socket_enable_crypto($f, true,   STREAM_CRYPTO_METHOD_SSLv23_CLIENT);
 787                 spip_log("OK CONNECT sur $first_host:$port","connect");
 788         }
 789         else {
 790                 $f = @fsockopen($first_host, $port, $errno, $errstr, _INC_DISTANT_CONNECT_TIMEOUT);
 791                 spip_log("Recuperer $path sur $first_host:$port par $f");
 792                 if (!$f) {
 793                         spip_log("Erreur connexion $errno $errstr",_LOG_ERREUR);
 794                         return false;
 795                 }
 796                 stream_set_timeout($f, _INC_DISTANT_CONNECT_TIMEOUT);
 797         }
 798
 799         $site = $GLOBALS['meta']["adresse_site"];
 800
 801         $req = "$method $path $vers\r\n"
 802                 . "Host: $host\r\n"
 803                 . "User-Agent: " . _INC_DISTANT_USER_AGENT . "\r\n"
 804                 . ($refuse_gz ? '' : ("Accept-Encoding: " . _INC_DISTANT_CONTENT_ENCODING . "\r\n"))
 805                 . (!$site ? '' : "Referer: $site/$referer\r\n")
 806                 . (!$date ? '' : "If-Modified-Since: " . (gmdate("D, d M Y H:i:s", $date) . " GMT\r\n"))
 807                 . (!$user ? '' : ("Authorization: Basic " . base64_encode($user) . "\r\n"))
 808                 . (!$proxy_user ? '' : "Proxy-Authorization: Basic $proxy_user\r\n")
 809                 . (!strpos($vers, '1.1') ? '' : "Keep-Alive: 300\r\nConnection: keep-alive\r\n");
 810
 811 #       spip_log("Requete\n$req");
 812         fputs($f, $req);
 813         fputs($f, $datas ? $datas : "\r\n");
 814         return $f;
 815 }
 816