www/ecrire/inc/distant.php

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