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