www/ecrire/inc/distant.php

   1 <?php
   2
   3 /***************************************************************************\
   4  *  SPIP, Systeme de publication pour l'internet                           *
   5  *                                                                         *
   6  *  Copyright (c) 2001-2017                                                *
   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')) {
  19         return;
  20 }
  21
  22 if (!defined('_INC_DISTANT_VERSION_HTTP')) {
  23         define('_INC_DISTANT_VERSION_HTTP', 'HTTP/1.0');
  24 }
  25 if (!defined('_INC_DISTANT_CONTENT_ENCODING')) {
  26         define('_INC_DISTANT_CONTENT_ENCODING', 'gzip');
  27 }
  28 if (!defined('_INC_DISTANT_USER_AGENT')) {
  29         define('_INC_DISTANT_USER_AGENT', 'SPIP-' . $GLOBALS['spip_version_affichee'] . ' (' . $GLOBALS['home_server'] . ')');
  30 }
  31 if (!defined('_INC_DISTANT_MAX_SIZE')) {
  32         define('_INC_DISTANT_MAX_SIZE', 2097152);
  33 }
  34 if (!defined('_INC_DISTANT_CONNECT_TIMEOUT')) {
  35         define('_INC_DISTANT_CONNECT_TIMEOUT', 10);
  36 }
  37
  38 define('_REGEXP_COPIE_LOCALE', ','      .
  39         preg_replace(
  40                 '@^https?:@',
  41                 'https?:',
  42                 (isset($GLOBALS['meta']['adresse_site']) ? $GLOBALS['meta']['adresse_site'] : '')
  43         )
  44         . '/?spip.php[?]action=acceder_document.*file=(.*)$,');
  45
  46 //@define('_COPIE_LOCALE_MAX_SIZE',2097152); // poids (inc/utils l'a fait)
  47
  48 /**
  49  * Crée au besoin la copie locale d'un fichier distant
  50  *
  51  * Prend en argument un chemin relatif au rep racine, ou une URL
  52  * Renvoie un chemin relatif au rep racine, ou false
  53  *
  54  * @link http://www.spip.net/4155
  55  * @pipeline_appel post_edition
  56  *
  57  * @param string $source
  58  * @param string $mode
  59  *   - 'test' - ne faire que tester
  60  *   - 'auto' - charger au besoin
  61  *   - 'modif' - Si deja present, ne charger que si If-Modified-Since
  62  *   - 'force' - charger toujours (mettre a jour)
  63  * @param string $local
  64  *   permet de specifier le nom du fichier local (stockage d'un cache par exemple, et non document IMG)
  65  * @param int $taille_max
  66  *   taille maxi de la copie local, par defaut _COPIE_LOCALE_MAX_SIZE
  67  * @return bool|string
  68  */
  69 function copie_locale($source, $mode = 'auto', $local = null, $taille_max = null) {
  70
  71         // si c'est la protection de soi-meme, retourner le path
  72         if ($mode !== 'force' and preg_match(_REGEXP_COPIE_LOCALE, $source, $match)) {
  73                 $source = substr(_DIR_IMG, strlen(_DIR_RACINE)) . urldecode($match[1]);
  74
  75                 return @file_exists($source) ? $source : false;
  76         }
  77
  78         if (is_null($local)) {
  79                 $local = fichier_copie_locale($source);
  80         } else {
  81                 if (_DIR_RACINE and strncmp(_DIR_RACINE, $local, strlen(_DIR_RACINE)) == 0) {
  82                         $local = substr($local, strlen(_DIR_RACINE));
  83                 }
  84         }
  85
  86         // si $local = '' c'est un fichier refuse par fichier_copie_locale(),
  87         // par exemple un fichier qui ne figure pas dans nos documents ;
  88         // dans ce cas on n'essaie pas de le telecharger pour ensuite echouer
  89         if (!$local) {
  90                 return false;
  91         }
  92
  93         $localrac = _DIR_RACINE . $local;
  94         $t = ($mode == 'force') ? false : @file_exists($localrac);
  95
  96         // test d'existence du fichier
  97         if ($mode == 'test') {
  98                 return $t ? $local : '';
  99         }
 100
 101         // sinon voir si on doit/peut le telecharger
 102         if ($local == $source or !tester_url_absolue($source)) {
 103                 return $local;
 104         }
 105
 106         if ($mode == 'modif' or !$t) {
 107                 // passer par un fichier temporaire unique pour gerer les echecs en cours de recuperation
 108                 // et des eventuelles recuperations concurantes
 109                 include_spip('inc/acces');
 110                 if (!$taille_max) {
 111                         $taille_max = _COPIE_LOCALE_MAX_SIZE;
 112                 }
 113                 $res = recuperer_url(
 114                         $source,
 115                         array('file' => $localrac, 'taille_max' => $taille_max, 'if_modified_since' => $t ? filemtime($localrac) : '')
 116                 );
 117                 if (!$res or (!$res['length'] and $res['status'] != 304)) {
 118                         spip_log("copie_locale : Echec recuperation $source sur $localrac status : " . $res['status'], _LOG_INFO_IMPORTANTE);
 119                 }
 120                 if (!$res['length']) {
 121                         // si $t c'est sans doute juste un not-modified-since
 122                         return $t ? $local : false;
 123                 }
 124                 spip_log("copie_locale : recuperation $source sur $localrac taille " . $res['length'] . ' OK');
 125
 126                 // pour une eventuelle indexation
 127                 pipeline(
 128                         'post_edition',
 129                         array(
 130                                 'args' => array(
 131                                         'operation' => 'copie_locale',
 132                                         'source' => $source,
 133                                         'fichier' => $local,
 134                                         'http_res' => $res['length'],
 135                                 ),
 136                                 'data' => null
 137                         )
 138                 );
 139         }
 140
 141         return $local;
 142 }
 143
 144 /**
 145  * Preparer les donnes pour un POST
 146  * si $donnees est une chaine
 147  *  - charge a l'envoyeur de la boundariser, de gerer le Content-Type etc...
 148  *  - on traite les retour ligne pour les mettre au bon format
 149  *  - on decoupe en entete/corps (separes par ligne vide)
 150  * si $donnees est un tableau
 151  *  - structuration en chaine avec boundary si necessaire ou fournie et bon Content-Type
 152  *
 153  * @param string|array $donnees
 154  * @param string $boundary
 155  * @return array
 156  *   entete,corps
 157  */
 158 function prepare_donnees_post($donnees, $boundary = '') {
 159
 160         // permettre a la fonction qui a demande le post de formater elle meme ses donnees
 161         // pour un appel soap par exemple
 162         // l'entete est separe des donnees par un double retour a la ligne
 163         // on s'occupe ici de passer tous les retours lignes (\r\n, \r ou \n) en \r\n
 164         if (is_string($donnees) && strlen($donnees)) {
 165                 $entete = '';
 166                 // on repasse tous les \r\n et \r en simples \n
 167                 $donnees = str_replace("\r\n", "\n", $donnees);
 168                 $donnees = str_replace("\r", "\n", $donnees);
 169                 // un double retour a la ligne signifie la fin de l'entete et le debut des donnees
 170                 $p = strpos($donnees, "\n\n");
 171                 if ($p !== false) {
 172                         $entete = str_replace("\n", "\r\n", substr($donnees, 0, $p + 1));
 173                         $donnees = substr($donnees, $p + 2);
 174                 }
 175                 $chaine = str_replace("\n", "\r\n", $donnees);
 176         } else {
 177                 /* boundary automatique */
 178                 // Si on a plus de 500 octects de donnees, on "boundarise"
 179                 if ($boundary === '') {
 180                         $taille = 0;
 181                         foreach ($donnees as $cle => $valeur) {
 182                                 if (is_array($valeur)) {
 183                                         foreach ($valeur as $val2) {
 184                                                 $taille += strlen($val2);
 185                                         }
 186                                 } else {
 187                                         // faut-il utiliser spip_strlen() dans inc/charsets ?
 188                                         $taille += strlen($valeur);
 189                                 }
 190                         }
 191                         if ($taille > 500) {
 192                                 $boundary = substr(md5(rand() . 'spip'), 0, 8);
 193                         }
 194                 }
 195
 196                 if (is_string($boundary) and strlen($boundary)) {
 197                         // fabrique une chaine HTTP pour un POST avec boundary
 198                         $entete = "Content-Type: multipart/form-data; boundary=$boundary\r\n";
 199                         $chaine = '';
 200                         if (is_array($donnees)) {
 201                                 foreach ($donnees as $cle => $valeur) {
 202                                         if (is_array($valeur)) {
 203                                                 foreach ($valeur as $val2) {
 204                                                         $chaine .= "\r\n--$boundary\r\n";
 205                                                         $chaine .= "Content-Disposition: form-data; name=\"{$cle}[]\"\r\n";
 206                                                         $chaine .= "\r\n";
 207                                                         $chaine .= $val2;
 208                                                 }
 209                                         } else {
 210                                                 $chaine .= "\r\n--$boundary\r\n";
 211                                                 $chaine .= "Content-Disposition: form-data; name=\"$cle\"\r\n";
 212                                                 $chaine .= "\r\n";
 213                                                 $chaine .= $valeur;
 214                                         }
 215                                 }
 216                                 $chaine .= "\r\n--$boundary\r\n";
 217                         }
 218                 } else {
 219                         // fabrique une chaine HTTP simple pour un POST
 220                         $entete = 'Content-Type: application/x-www-form-urlencoded' . "\r\n";
 221                         $chaine = array();
 222                         if (is_array($donnees)) {
 223                                 foreach ($donnees as $cle => $valeur) {
 224                                         if (is_array($valeur)) {
 225                                                 foreach ($valeur as $val2) {
 226                                                         $chaine[] = rawurlencode($cle) . '[]=' . rawurlencode($val2);
 227                                                 }
 228                                         } else {
 229                                                 $chaine[] = rawurlencode($cle) . '=' . rawurlencode($valeur);
 230                                         }
 231                                 }
 232                                 $chaine = implode('&', $chaine);
 233                         } else {
 234                                 $chaine = $donnees;
 235                         }
 236                 }
 237         }
 238
 239         return array($entete, $chaine);
 240 }
 241
 242 /**
 243  * Convertir une URL dont le host est en utf8 en ascii
 244  * Utilise la librairie https://github.com/phlylabs/idna-convert/tree/v0.9.1
 245  * dans sa derniere version compatible toutes version PHP 5
 246  * La fonction PHP idn_to_ascii depend d'un package php5-intl et est rarement disponible
 247  *
 248  * @param string $url_idn
 249  * @return array|string
 250  */
 251 function url_to_ascii($url_idn) {
 252
 253         if ($parts = parse_url($url_idn)) {
 254                 $host = $parts['host'];
 255                 if (!preg_match(',^[a-z0-9_\.\-]+$,i', $host)) {
 256                         include_spip('inc/idna_convert.class');
 257                         $IDN = new idna_convert();
 258                         $host_ascii = $IDN->encode($host);
 259                         $url_idn = explode($host, $url_idn, 2);
 260                         $url_idn = implode($host_ascii, $url_idn);
 261                 }
 262         }
 263
 264         return $url_idn;
 265 }
 266
 267 /**
 268  * Récupère le contenu d'une URL
 269  * au besoin encode son contenu dans le charset local
 270  *
 271  * @uses init_http()
 272  * @uses recuperer_entetes()
 273  * @uses recuperer_body()
 274  * @uses transcoder_page()
 275  *
 276  * @param string $url
 277  * @param array $options
 278  *   bool transcoder : true si on veut transcoder la page dans le charset du site
 279  *   string methode : Type de requête HTTP à faire (HEAD, GET ou POST)
 280  *   int taille_max : Arrêter le contenu au-delà (0 = seulement les entetes ==> requête HEAD). Par defaut taille_max = 1Mo ou 16Mo si copie dans un fichier
 281  *   string|array datas : Pour envoyer des donnees (array) et/ou entetes (string) (force la methode POST si donnees non vide)
 282  *   string boundary : boundary pour formater les datas au format array
 283  *   bool refuser_gz : Pour forcer le refus de la compression (cas des serveurs orthographiques)
 284  *   int if_modified_since : Un timestamp unix pour arrêter la récuperation si la page distante n'a pas été modifiée depuis une date donnée
 285  *   string uri_referer : Pour préciser un référer différent
 286  *   string file : nom du fichier dans lequel copier le contenu
 287  *   int follow_location : nombre de redirections a suivre (0 pour ne rien suivre)
 288  *   string version_http : version du protocole HTTP a utiliser (par defaut defini par la constante _INC_DISTANT_VERSION_HTTP)
 289  * @return array|bool
 290  *   false si echec
 291  *   array sinon :
 292  *     int status : le status de la page
 293  *     string headers : les entetes de la page
 294  *     string page : le contenu de la page (vide si copie dans un fichier)
 295  *     int last_modified : timestamp de derniere modification
 296  *     string location : url de redirection envoyee par la page
 297  *     string url : url reelle de la page recuperee
 298  *     int length : taille du contenu ou du fichier
 299  *
 300  *     string file : nom du fichier si enregistre dans un fichier
 301  */
 302 function recuperer_url($url, $options = array()) {
 303         $default = array(
 304                 'transcoder' => false,
 305                 'methode' => 'GET',
 306                 'taille_max' => null,
 307                 'datas' => '',
 308                 'boundary' => '',
 309                 'refuser_gz' => false,
 310                 'if_modified_since' => '',
 311                 'uri_referer' => '',
 312                 'file' => '',
 313                 'follow_location' => 10,
 314                 'version_http' => _INC_DISTANT_VERSION_HTTP,
 315         );
 316         $options = array_merge($default, $options);
 317         // copier directement dans un fichier ?
 318         $copy = $options['file'];
 319
 320         if ($options['methode'] == 'HEAD') {
 321                 $options['taille_max'] = 0;
 322         }
 323         if (is_null($options['taille_max'])) {
 324                 $options['taille_max'] = $copy ? _COPIE_LOCALE_MAX_SIZE : _INC_DISTANT_MAX_SIZE;
 325         }
 326
 327         if (!empty($options['datas'])) {
 328                 list($head, $postdata) = prepare_donnees_post($options['datas'], $options['boundary']);
 329                 if (stripos($head, 'Content-Length:') === false) {
 330                         $head .= 'Content-Length: ' . strlen($postdata);
 331                 }
 332                 $options['datas'] = $head . "\r\n\r\n" . $postdata;
 333                 if (strlen($postdata)) {
 334                         $options['methode'] = 'POST';
 335                 }
 336         }
 337
 338         // Accepter les URLs au format feed:// ou qui ont oublie le http:// ou les urls relatives au protocole
 339         $url = preg_replace(',^feed://,i', 'http://', $url);
 340         if (!tester_url_absolue($url)) {
 341                 $url = 'http://' . $url;
 342         } elseif (strncmp($url, '//', 2) == 0) {
 343                 $url = 'http:' . $url;
 344         }
 345
 346         $url = url_to_ascii($url);
 347
 348         $result = array(
 349                 'status' => 0,
 350                 'headers' => '',
 351                 'page' => '',
 352                 'length' => 0,
 353                 'last_modified' => '',
 354                 'location' => '',
 355                 'url' => $url
 356         );
 357
 358         // si on ecrit directement dans un fichier, pour ne pas manipuler en memoire refuser gz
 359         $refuser_gz = (($options['refuser_gz'] or $copy) ? true : false);
 360
 361         // ouvrir la connexion et envoyer la requete et ses en-tetes
 362         list($handle, $fopen) = init_http(
 363                 $options['methode'],
 364                 $url,
 365                 $refuser_gz,
 366                 $options['uri_referer'],
 367                 $options['datas'],
 368                 $options['version_http'],
 369                 $options['if_modified_since']
 370         );
 371         if (!$handle) {
 372                 spip_log("ECHEC init_http $url");
 373
 374                 return false;
 375         }
 376
 377         // Sauf en fopen, envoyer le flux d'entree
 378         // et recuperer les en-tetes de reponses
 379         if (!$fopen) {
 380                 $res = recuperer_entetes_complets($handle, $options['if_modified_since']);
 381                 if (!$res) {
 382                         fclose($handle);
 383                         $t = @parse_url($url);
 384                         $host = $t['host'];
 385                         // Chinoisierie inexplicable pour contrer
 386                         // les actions liberticides de l'empire du milieu
 387                         if (!need_proxy($host)
 388                                 and $res = @file_get_contents($url)
 389                         ) {
 390                                 $result['length'] = strlen($res);
 391                                 if ($copy) {
 392                                         ecrire_fichier($copy, $res);
 393                                         $result['file'] = $copy;
 394                                 } else {
 395                                         $result['page'] = $res;
 396                                 }
 397                                 $res = array(
 398                                         'status' => 200,
 399                                 );
 400                         } else {
 401                                 return false;
 402                         }
 403                 } elseif ($res['location'] and $options['follow_location']) {
 404                         $options['follow_location']--;
 405                         fclose($handle);
 406                         include_spip('inc/filtres');
 407                         $url = suivre_lien($url, $res['location']);
 408                         spip_log("recuperer_url recommence sur $url");
 409
 410                         return recuperer_url($url, $options);
 411                 } elseif ($res['status'] !== 200) {
 412                         spip_log('HTTP status ' . $res['status'] . " pour $url");
 413                 }
 414                 $result['status'] = $res['status'];
 415                 if (isset($res['headers'])) {
 416                         $result['headers'] = $res['headers'];
 417                 }
 418                 if (isset($res['last_modified'])) {
 419                         $result['last_modified'] = $res['last_modified'];
 420                 }
 421                 if (isset($res['location'])) {
 422                         $result['location'] = $res['location'];
 423                 }
 424         }
 425
 426         // on ne veut que les entetes
 427         if (!$options['taille_max'] or $options['methode'] == 'HEAD' or $result['status'] == '304') {
 428                 return $result;
 429         }
 430
 431
 432         // s'il faut deballer, le faire via un fichier temporaire
 433         // sinon la memoire explose pour les gros flux
 434
 435         $gz = false;
 436         if (preg_match(",\bContent-Encoding: .*gzip,is", $result['headers'])) {
 437                 $gz = (_DIR_TMP . md5(uniqid(mt_rand())) . '.tmp.gz');
 438         }
 439
 440         // si on a pas deja recuperer le contenu par une methode detournee
 441         if (!$result['length']) {
 442                 $res = recuperer_body($handle, $options['taille_max'], $gz ? $gz : $copy);
 443                 fclose($handle);
 444                 if ($copy) {
 445                         $result['length'] = $res;
 446                         $result['file'] = $copy;
 447                 } elseif ($res) {
 448                         $result['page'] = &$res;
 449                         $result['length'] = strlen($result['page']);
 450                 }
 451         }
 452         if (!$result['page']) {
 453                 return $result;
 454         }
 455
 456         // Decompresser au besoin
 457         if ($gz) {
 458                 $result['page'] = implode('', gzfile($gz));
 459                 supprimer_fichier($gz);
 460         }
 461
 462         // Faut-il l'importer dans notre charset local ?
 463         if ($options['transcoder']) {
 464                 include_spip('inc/charsets');
 465                 $result['page'] = transcoder_page($result['page'], $result['headers']);
 466         }
 467
 468         return $result;
 469 }
 470
 471 /**
 472  * Récuperer une URL si on l'a pas déjà dans un cache fichier
 473  *
 474  * Le délai de cache est fourni par l'option `delai_cache`
 475  * Les autres options et le format de retour sont identiques à la fonction `recuperer_url`
 476  * @uses recuperer_url()
 477  *
 478  * @param string $url
 479  * @param array $options
 480  *   int delai_cache : anciennete acceptable pour le contenu (en seconde)
 481  * @return array|bool|mixed
 482  */
 483 function recuperer_url_cache($url, $options = array()) {
 484         if (!defined('_DELAI_RECUPERER_URL_CACHE')) {
 485                 define('_DELAI_RECUPERER_URL_CACHE', 3600);
 486         }
 487         $default = array(
 488                 'transcoder' => false,
 489                 'methode' => 'GET',
 490                 'taille_max' => null,
 491                 'datas' => '',
 492                 'boundary' => '',
 493                 'refuser_gz' => false,
 494                 'if_modified_since' => '',
 495                 'uri_referer' => '',
 496                 'file' => '',
 497                 'follow_location' => 10,
 498                 'version_http' => _INC_DISTANT_VERSION_HTTP,
 499                 'delai_cache' => _DELAI_RECUPERER_URL_CACHE,
 500         );
 501         $options = array_merge($default, $options);
 502
 503         // cas ou il n'est pas possible de cacher
 504         if (!empty($options['data']) or $options['methode'] == 'POST') {
 505                 return recuperer_url($url, $options);
 506         }
 507
 508         // ne pas tenter plusieurs fois la meme url en erreur (non cachee donc)
 509         static $errors = array();
 510         if (isset($errors[$url])) {
 511                 return $errors[$url];
 512         }
 513
 514         $sig = $options;
 515         unset($sig['if_modified_since']);
 516         unset($sig['delai_cache']);
 517         $sig['url'] = $url;
 518
 519         $dir = sous_repertoire(_DIR_CACHE, 'curl');
 520         $cache = md5(serialize($sig)) . '-' . substr(preg_replace(',\W+,', '_', $url), 0, 80);
 521         $sub = sous_repertoire($dir, substr($cache, 0, 2));
 522         $cache = "$sub$cache";
 523
 524         $res = false;
 525         $is_cached = file_exists($cache);
 526         if ($is_cached
 527                 and (filemtime($cache) > $_SERVER['REQUEST_TIME'] - $options['delai_cache'])
 528         ) {
 529                 lire_fichier($cache, $res);
 530                 if ($res = unserialize($res)) {
 531                         // mettre le last_modified et le status=304 ?
 532                 }
 533         }
 534         if (!$res) {
 535                 $res = recuperer_url($url, $options);
 536                 // ne pas recharger cette url non cachee dans le meme hit puisque non disponible
 537                 if (!$res) {
 538                         if ($is_cached) {
 539                                 // on a pas reussi a recuperer mais on avait un cache : l'utiliser
 540                                 lire_fichier($cache, $res);
 541                                 $res = unserialize($res);
 542                         }
 543
 544                         return $errors[$url] = $res;
 545                 }
 546                 ecrire_fichier($cache, serialize($res));
 547         }
 548
 549         return $res;
 550 }
 551
 552 /**
 553  * Obsolète : Récupère une page sur le net et au besoin l'encode dans le charset local
 554  *
 555  * Gère les redirections de page (301) sur l'URL demandée (maximum 10 redirections)
 556  *
 557  * @deprecated
 558  * @uses recuperer_url()
 559  *
 560  * @param string $url
 561  *     URL de la page à récupérer
 562  * @param bool|string $trans
 563  *     - chaîne longue : c'est un nom de fichier (nom pour sa copie locale)
 564  *     - true : demande d'encodage/charset
 565  *     - null : ne retourner que les headers
 566  * @param bool $get_headers
 567  *     Si on veut récupérer les entêtes
 568  * @param int|null $taille_max
 569  *     Arrêter le contenu au-delà (0 = seulement les entetes ==> requête HEAD).
 570  *     Par defaut taille_max = 1Mo.
 571  * @param string|array $datas
 572  *     Pour faire un POST de données
 573  * @param string $boundary
 574  *     Pour forcer l'envoi par cette méthode
 575  * @param bool $refuser_gz
 576  *     Pour forcer le refus de la compression (cas des serveurs orthographiques)
 577  * @param string $date_verif
 578  *     Un timestamp unix pour arrêter la récuperation si la page distante
 579  *     n'a pas été modifiée depuis une date donnée
 580  * @param string $uri_referer
 581  *     Pour préciser un référer différent
 582  * @return string|bool
 583  *     - Code de la page obtenue (avec ou sans entête)
 584  *     - false si la page n'a pu être récupérée (status different de 200)
 585  **/
 586 function recuperer_page(
 587         $url,
 588         $trans = false,
 589         $get_headers = false,
 590         $taille_max = null,
 591         $datas = '',
 592         $boundary = '',
 593         $refuser_gz = false,
 594         $date_verif = '',
 595         $uri_referer = ''
 596 ) {
 597         // $copy = copier le fichier ?
 598         $copy = (is_string($trans) and strlen($trans) > 5); // eviter "false" :-)
 599
 600         if (!is_null($taille_max) and ($taille_max == 0)) {
 601                 $get = 'HEAD';
 602         } else {
 603                 $get = 'GET';
 604         }
 605
 606         $options = array(
 607                 'transcoder' => $trans === true,
 608                 'methode' => $get,
 609                 'datas' => $datas,
 610                 'boundary' => $boundary,
 611                 'refuser_gz' => $refuser_gz,
 612                 'if_modified_since' => $date_verif,
 613                 'uri_referer' => $uri_referer,
 614                 'file' => $copy ? $trans : '',
 615                 'follow_location' => 10,
 616         );
 617         if (!is_null($taille_max)) {
 618                 $options['taille_max'] = $taille_max;
 619         }
 620         // dix tentatives maximum en cas d'entetes 301...
 621         $res = recuperer_url($url, $options);
 622         if (!$res) {
 623                 return false;
 624         }
 625         if ($res['status'] !== 200) {
 626                 return false;
 627         }
 628         if ($get_headers) {
 629                 return $res['headers'] . "\n" . $res['page'];
 630         }
 631
 632         return $res['page'];
 633 }
 634
 635
 636 /**
 637  * Obsolete Récupère une page sur le net et au besoin l'encode dans le charset local
 638  *
 639  * @deprecated
 640  *
 641  * @uses recuperer_url()
 642  *
 643  * @param string $url
 644  *     URL de la page à récupérer
 645  * @param bool|null|string $trans
 646  *     - chaîne longue : c'est un nom de fichier (nom pour sa copie locale)
 647  *     - true : demande d'encodage/charset
 648  *     - null : ne retourner que les headers
 649  * @param string $get
 650  *     Type de requête HTTP à faire (HEAD, GET ou POST)
 651  * @param int|bool $taille_max
 652  *     Arrêter le contenu au-delà (0 = seulement les entetes ==> requête HEAD).
 653  *     Par defaut taille_max = 1Mo.
 654  * @param string|array $datas
 655  *     Pour faire un POST de données
 656  * @param bool $refuser_gz
 657  *     Pour forcer le refus de la compression (cas des serveurs orthographiques)
 658  * @param string $date_verif
 659  *     Un timestamp unix pour arrêter la récuperation si la page distante
 660  *     n'a pas été modifiée depuis une date donnée
 661  * @param string $uri_referer
 662  *     Pour préciser un référer différent
 663  * @return string|array|bool
 664  *     - Retourne l'URL en cas de 301,
 665  *     - Un tableau (entête, corps) si ok,
 666  *     - false sinon
 667  **/
 668 function recuperer_lapage(
 669         $url,
 670         $trans = false,
 671         $get = 'GET',
 672         $taille_max = 1048576,
 673         $datas = '',
 674         $refuser_gz = false,
 675         $date_verif = '',
 676         $uri_referer = ''
 677 ) {
 678         // $copy = copier le fichier ?
 679         $copy = (is_string($trans) and strlen($trans) > 5); // eviter "false" :-)
 680
 681         // si on ecrit directement dans un fichier, pour ne pas manipuler
 682         // en memoire refuser gz
 683         if ($copy) {
 684                 $refuser_gz = true;
 685         }
 686
 687         $options = array(
 688                 'transcoder' => $trans === true,
 689                 'methode' => $get,
 690                 'datas' => $datas,
 691                 'refuser_gz' => $refuser_gz,
 692                 'if_modified_since' => $date_verif,
 693                 'uri_referer' => $uri_referer,
 694                 'file' => $copy ? $trans : '',
 695                 'follow_location' => false,
 696         );
 697         if (!is_null($taille_max)) {
 698                 $options['taille_max'] = $taille_max;
 699         }
 700         // dix tentatives maximum en cas d'entetes 301...
 701         $res = recuperer_url($url, $options);
 702
 703         if (!$res) {
 704                 return false;
 705         }
 706         if ($res['status'] !== 200) {
 707                 return false;
 708         }
 709
 710         return array($res['headers'], $res['page']);
 711 }
 712
 713 /**
 714  * Recuperer le contenu sur lequel pointe la resource passee en argument
 715  * $taille_max permet de tronquer
 716  * de l'url dont on a deja recupere les en-tetes
 717  *
 718  * @param resource $handle
 719  * @param int $taille_max
 720  * @param string $fichier
 721  *   fichier dans lequel copier le contenu de la resource
 722  * @return bool|int|string
 723  *   bool false si echec
 724  *   int taille du fichier si argument fichier fourni
 725  *   string contenu de la resource
 726  */
 727 function recuperer_body($handle, $taille_max = _INC_DISTANT_MAX_SIZE, $fichier = '') {
 728         $taille = 0;
 729         $result = '';
 730         $fp = false;
 731         if ($fichier) {
 732                 include_spip('inc/acces');
 733                 $tmpfile = "$fichier." . creer_uniqid() . '.tmp';
 734                 $fp = spip_fopen_lock($tmpfile, 'w', LOCK_EX);
 735                 if (!$fp and file_exists($fichier)) {
 736                         return filesize($fichier);
 737                 }
 738                 if (!$fp) {
 739                         return false;
 740                 }
 741                 $result = 0; // on renvoie la taille du fichier
 742         }
 743         while (!feof($handle) and $taille < $taille_max) {
 744                 $res = fread($handle, 16384);
 745                 $taille += strlen($res);
 746                 if ($fp) {
 747                         fwrite($fp, $res);
 748                         $result = $taille;
 749                 } else {
 750                         $result .= $res;
 751                 }
 752         }
 753         if ($fp) {
 754                 spip_fclose_unlock($fp);
 755                 spip_unlink($fichier);
 756                 @rename($tmpfile, $fichier);
 757                 if (!file_exists($fichier)) {
 758                         return false;
 759                 }
 760         }
 761
 762         return $result;
 763 }
 764
 765 /**
 766  * Lit les entetes de reponse HTTP sur la socket $handle
 767  * et retourne
 768  * false en cas d'echec,
 769  * un tableau associatif en cas de succes, contenant :
 770  * - le status
 771  * - le tableau complet des headers
 772  * - la date de derniere modif si connue
 773  * - l'url de redirection si specifiee
 774  *
 775  * @param resource $handle
 776  * @param int|bool $if_modified_since
 777  * @return bool|array
 778  *   int status
 779  *   string headers
 780  *   int last_modified
 781  *   string location
 782  */
 783 function recuperer_entetes_complets($handle, $if_modified_since = false) {
 784         $result = array('status' => 0, 'headers' => array(), 'last_modified' => 0, 'location' => '');
 785
 786         $s = @trim(fgets($handle, 16384));
 787         if (!preg_match(',^HTTP/[0-9]+\.[0-9]+ ([0-9]+),', $s, $r)) {
 788                 return false;
 789         }
 790         $result['status'] = intval($r[1]);
 791         while ($s = trim(fgets($handle, 16384))) {
 792                 $result['headers'][] = $s . "\n";
 793                 preg_match(',^([^:]*): *(.*)$,i', $s, $r);
 794                 list(, $d, $v) = $r;
 795                 if (strtolower(trim($d)) == 'location' and $result['status'] >= 300 and $result['status'] < 400) {
 796                         $result['location'] = $v;
 797                 } elseif ($d == 'Last-Modified') {
 798                         $result['last_modified'] = strtotime($v);
 799                 }
 800         }
 801         if ($if_modified_since
 802                 and $result['last_modified']
 803                 and $if_modified_since > $result['last_modified']
 804                 and $result['status'] == 200
 805         ) {
 806                 $result['status'] = 304;
 807         }
 808
 809         $result['headers'] = implode('', $result['headers']);
 810
 811         return $result;
 812 }
 813
 814 /**
 815  * Obsolete : version simplifiee de recuperer_entetes_complets
 816  * Retourne les informations d'entête HTTP d'un socket
 817  *
 818  * Lit les entêtes de reponse HTTP sur la socket $f
 819  *
 820  * @uses recuperer_entetes_complets()
 821  * @deprecated
 822  *
 823  * @param resource $f
 824  *     Socket d'un fichier (issu de fopen)
 825  * @param int|string $date_verif
 826  *     Pour tester une date de dernière modification
 827  * @return string|int|array
 828  *     - la valeur (chaîne) de l'en-tete Location si on l'a trouvée
 829  *     - la valeur (numerique) du statut si different de 200, notamment Not-Modified
 830  *     - le tableau des entetes dans tous les autres cas
 831  **/
 832 function recuperer_entetes($f, $date_verif = '') {
 833         //Cas ou la page distante n'a pas bouge depuis
 834         //la derniere visite
 835         $res = recuperer_entetes_complets($f, $date_verif);
 836         if (!$res) {
 837                 return false;
 838         }
 839         if ($res['location']) {
 840                 return $res['location'];
 841         }
 842         if ($res['status'] != 200) {
 843                 return $res['status'];
 844         }
 845
 846         return explode("\n", $res['headers']);
 847 }
 848
 849 /**
 850  * Calcule le nom canonique d'une copie local d'un fichier distant
 851  *
 852  * Si on doit conserver une copie locale des fichiers distants, autant que ca
 853  * soit à un endroit canonique
 854  *
 855  * @note
 856  *   Si ca peut être bijectif c'est encore mieux,
 857  *   mais là tout de suite je ne trouve pas l'idee, étant donné les limitations
 858  *   des filesystems
 859  *
 860  * @param string $source
 861  *     URL de la source
 862  * @param string $extension
 863  *     Extension du fichier
 864  * @return string
 865  *     Nom du fichier pour copie locale
 866  **/
 867 function nom_fichier_copie_locale($source, $extension) {
 868         include_spip('inc/documents');
 869
 870         $d = creer_repertoire_documents('distant'); # IMG/distant/
 871         $d = sous_repertoire($d, $extension); # IMG/distant/pdf/
 872
 873         // on se place tout le temps comme si on etait a la racine
 874         if (_DIR_RACINE) {
 875                 $d = preg_replace(',^' . preg_quote(_DIR_RACINE) . ',', '', $d);
 876         }
 877
 878         $m = md5($source);
 879
 880         return $d
 881         . substr(preg_replace(',[^\w-],', '', basename($source)) . '-' . $m, 0, 12)
 882         . substr($m, 0, 4)
 883         . ".$extension";
 884 }
 885
 886 /**
 887  * Donne le nom de la copie locale de la source
 888  *
 889  * Soit obtient l'extension du fichier directement de l'URL de la source,
 890  * soit tente de le calculer.
 891  *
 892  * @uses nom_fichier_copie_locale()
 893  * @uses recuperer_infos_distantes()
 894  *
 895  * @param string $source
 896  *      URL de la source distante
 897  * @return string
 898  *      Nom du fichier calculé
 899  **/
 900 function fichier_copie_locale($source) {
 901         // Si c'est deja local pas de souci
 902         if (!tester_url_absolue($source)) {
 903                 if (_DIR_RACINE) {
 904                         $source = preg_replace(',^' . preg_quote(_DIR_RACINE) . ',', '', $source);
 905                 }
 906
 907                 return $source;
 908         }
 909
 910         // optimisation : on regarde si on peut deviner l'extension dans l'url et si le fichier
 911         // a deja ete copie en local avec cette extension
 912         // dans ce cas elle est fiable, pas la peine de requeter en base
 913         $path_parts = pathinfo($source);
 914         if (!isset($path_parts['extension'])) {
 915                 $path_parts['extension'] = '';
 916         }
 917         $ext = $path_parts ? $path_parts['extension'] : '';
 918         if ($ext
 919                 and preg_match(',^\w+$,', $ext) // pas de php?truc=1&...
 920                 and $f = nom_fichier_copie_locale($source, $ext)
 921                 and file_exists(_DIR_RACINE . $f)
 922         ) {
 923                 return $f;
 924         }
 925
 926
 927         // Si c'est deja dans la table des documents,
 928         // ramener le nom de sa copie potentielle
 929         $ext = sql_getfetsel('extension', 'spip_documents', 'fichier=' . sql_quote($source) . " AND distant='oui' AND extension <> ''");
 930
 931         if ($ext) {
 932                 return nom_fichier_copie_locale($source, $ext);
 933         }
 934
 935         // voir si l'extension indiquee dans le nom du fichier est ok
 936         // et si il n'aurait pas deja ete rapatrie
 937
 938         $ext = $path_parts ? $path_parts['extension'] : '';
 939
 940         if ($ext and sql_getfetsel('extension', 'spip_types_documents', 'extension=' . sql_quote($ext))) {
 941                 $f = nom_fichier_copie_locale($source, $ext);
 942                 if (file_exists(_DIR_RACINE . $f)) {
 943                         return $f;
 944                 }
 945         }
 946
 947         // Ping  pour voir si son extension est connue et autorisee
 948         // avec mise en cache du resultat du ping
 949
 950         $cache = sous_repertoire(_DIR_CACHE, 'rid') . md5($source);
 951         if (!@file_exists($cache)
 952                 or !$path_parts = @unserialize(spip_file_get_contents($cache))
 953                 or _request('var_mode') == 'recalcul'
 954         ) {
 955                 $path_parts = recuperer_infos_distantes($source, 0, false);
 956                 ecrire_fichier($cache, serialize($path_parts));
 957         }
 958         $ext = !empty($path_parts['extension']) ? $path_parts['extension'] : '';
 959         if ($ext and sql_getfetsel('extension', 'spip_types_documents', 'extension=' . sql_quote($ext))) {
 960                 return nom_fichier_copie_locale($source, $ext);
 961         }
 962         spip_log("pas de copie locale pour $source");
 963 }
 964
 965
 966 /**
 967  * Récupérer les infos d'un document distant, sans trop le télécharger
 968  *
 969  * @param string $source
 970  *     URL de la source
 971  * @param int $max
 972  *     Taille maximum du fichier à télécharger
 973  * @param bool $charger_si_petite_image
 974  *     Pour télécharger le document s'il est petit
 975  * @return array
 976  *     Couples des informations obtenues parmis :
 977  *
 978  *     - 'body' = chaine
 979  *     - 'type_image' = booleen
 980  *     - 'titre' = chaine
 981  *     - 'largeur' = intval
 982  *     - 'hauteur' = intval
 983  *     - 'taille' = intval
 984  *     - 'extension' = chaine
 985  *     - 'fichier' = chaine
 986  *     - 'mime_type' = chaine
 987  **/
 988 function recuperer_infos_distantes($source, $max = 0, $charger_si_petite_image = true) {
 989
 990         // pas la peine de perdre son temps
 991         if (!tester_url_absolue($source)) {
 992                 return false;
 993         }
 994
 995         # charger les alias des types mime
 996         include_spip('base/typedoc');
 997
 998         $a = array();
 999         $mime_type = '';
1000         // On va directement charger le debut des images et des fichiers html,
1001         // de maniere a attrapper le maximum d'infos (titre, taille, etc). Si
1002         // ca echoue l'utilisateur devra les entrer...
1003         if ($headers = recuperer_page($source, false, true, $max, '', '', true)) {
1004                 list($headers, $a['body']) = preg_split(',\n\n,', $headers, 2);
1005
1006                 if (preg_match(",\nContent-Type: *([^[:space:];]*),i", "\n$headers", $regs)) {
1007                         $mime_type = (trim($regs[1]));
1008                 } else {
1009                         $mime_type = '';
1010                 } // inconnu
1011
1012                 // Appliquer les alias
1013                 while (isset($GLOBALS['mime_alias'][$mime_type])) {
1014                         $mime_type = $GLOBALS['mime_alias'][$mime_type];
1015                 }
1016
1017                 // Si on a un mime-type insignifiant
1018                 // text/plain,application/octet-stream ou vide
1019                 // c'est peut-etre que le serveur ne sait pas
1020                 // ce qu'il sert ; on va tenter de detecter via l'extension de l'url
1021                 // ou le Content-Disposition: attachment; filename=...
1022                 $t = null;
1023                 if (in_array($mime_type, array('text/plain', '', 'application/octet-stream'))) {
1024                         if (!$t
1025                                 and preg_match(',\.([a-z0-9]+)(\?.*)?$,i', $source, $rext)
1026                         ) {
1027                                 $t = sql_fetsel('extension', 'spip_types_documents', 'extension=' . sql_quote($rext[1], '', 'text'));
1028                         }
1029                         if (!$t
1030                                 and preg_match(',^Content-Disposition:\s*attachment;\s*filename=(.*)$,Uims', $headers, $m)
1031                                 and preg_match(',\.([a-z0-9]+)(\?.*)?$,i', $m[1], $rext)
1032                         ) {
1033                                 $t = sql_fetsel('extension', 'spip_types_documents', 'extension=' . sql_quote($rext[1], '', 'text'));
1034                         }
1035                 }
1036
1037                 // Autre mime/type (ou text/plain avec fichier d'extension inconnue)
1038                 if (!$t) {
1039                         $t = sql_fetsel('extension', 'spip_types_documents', 'mime_type=' . sql_quote($mime_type));
1040                 }
1041
1042                 // Toujours rien ? (ex: audio/x-ogg au lieu de application/ogg)
1043                 // On essaie de nouveau avec l'extension
1044                 if (!$t
1045                         and $mime_type != 'text/plain'
1046                         and preg_match(',\.([a-z0-9]+)(\?.*)?$,i', $source, $rext)
1047                 ) {
1048                         # eviter xxx.3 => 3gp (> SPIP 3)
1049                         $t = sql_fetsel('extension', 'spip_types_documents', 'extension=' . sql_quote($rext[1], '', 'text'));
1050                 }
1051
1052                 if ($t) {
1053                         spip_log("mime-type $mime_type ok, extension " . $t['extension']);
1054                         $a['extension'] = $t['extension'];
1055                 } else {
1056                         # par defaut on retombe sur '.bin' si c'est autorise
1057                         spip_log("mime-type $mime_type inconnu");
1058                         $t = sql_fetsel('extension', 'spip_types_documents', "extension='bin'");
1059                         if (!$t) {
1060                                 return false;
1061                         }
1062                         $a['extension'] = $t['extension'];
1063                 }
1064
1065                 if (preg_match(",\nContent-Length: *([^[:space:]]*),i", "\n$headers", $regs)) {
1066                         $a['taille'] = intval($regs[1]);
1067                 }
1068         }
1069
1070         // Echec avec HEAD, on tente avec GET
1071         if (!$a and !$max) {
1072                 spip_log("tenter GET $source");
1073                 $a = recuperer_infos_distantes($source, _INC_DISTANT_MAX_SIZE);
1074         }
1075
1076         // si on a rien trouve pas la peine d'insister
1077         if (!$a) {
1078                 return false;
1079         }
1080
1081         // S'il s'agit d'une image pas trop grosse ou d'un fichier html, on va aller
1082         // recharger le document en GET et recuperer des donnees supplementaires...
1083         if (preg_match(',^image/(jpeg|gif|png|swf),', $mime_type)) {
1084                 if ($max == 0
1085                         and (empty($a['taille']) or $a['taille'] < _INC_DISTANT_MAX_SIZE)
1086                         and isset($GLOBALS['meta']['formats_graphiques'])
1087                         and (strpos($GLOBALS['meta']['formats_graphiques'], $a['extension']) !== false)
1088                         and $charger_si_petite_image
1089                 ) {
1090                         $a = recuperer_infos_distantes($source, _INC_DISTANT_MAX_SIZE);
1091                 } else {
1092                         if ($a['body']) {
1093                                 $a['fichier'] = _DIR_RACINE . nom_fichier_copie_locale($source, $a['extension']);
1094                                 ecrire_fichier($a['fichier'], $a['body']);
1095                                 $size_image = @getimagesize($a['fichier']);
1096                                 $a['largeur'] = intval($size_image[0]);
1097                                 $a['hauteur'] = intval($size_image[1]);
1098                                 $a['type_image'] = true;
1099                         }
1100                 }
1101         }
1102
1103         // Fichier swf, si on n'a pas la taille, on va mettre 425x350 par defaut
1104         // ce sera mieux que 0x0
1105         if ($a and isset($a['extension']) and $a['extension'] == 'swf'
1106                 and empty($a['largeur'])
1107         ) {
1108                 $a['largeur'] = 425;
1109                 $a['hauteur'] = 350;
1110         }
1111
1112         if ($mime_type == 'text/html') {
1113                 include_spip('inc/filtres');
1114                 $page = recuperer_page($source, true, false, _INC_DISTANT_MAX_SIZE);
1115                 if (preg_match(',<title>(.*?)</title>,ims', $page, $regs)) {
1116                         $a['titre'] = corriger_caracteres(trim($regs[1]));
1117                 }
1118                 if (!isset($a['taille']) or !$a['taille']) {
1119                         $a['taille'] = strlen($page); # a peu pres
1120                 }
1121         }
1122         $a['mime_type'] = $mime_type;
1123
1124         return $a;
1125 }
1126
1127
1128 /**
1129  * Tester si un host peut etre recuperer directement ou doit passer par un proxy
1130  *
1131  * On peut passer en parametre le proxy et la liste des host exclus,
1132  * pour les besoins des tests, lors de la configuration
1133  *
1134  * @param string $host
1135  * @param string $http_proxy
1136  * @param string $http_noproxy
1137  * @return string
1138  */
1139 function need_proxy($host, $http_proxy = null, $http_noproxy = null) {
1140         if (is_null($http_proxy)) {
1141                 $http_proxy = isset($GLOBALS['meta']['http_proxy']) ? $GLOBALS['meta']['http_proxy'] : null;
1142         }
1143         if (is_null($http_noproxy)) {
1144                 $http_noproxy = isset($GLOBALS['meta']['http_noproxy']) ? $GLOBALS['meta']['http_noproxy'] : null;
1145         }
1146
1147         $domain = substr($host, strpos($host, '.'));
1148
1149         return ($http_proxy
1150                 and (strpos(" $http_noproxy ", " $host ") === false
1151                         and (strpos(" $http_noproxy ", " $domain ") === false)))
1152                 ? $http_proxy : '';
1153 }
1154
1155
1156 /**
1157  * Initialise une requete HTTP avec entetes
1158  *
1159  * Décompose l'url en son schema+host+path+port et lance la requete.
1160  * Retourne le descripteur sur lequel lire la réponse.
1161  *
1162  * @uses lance_requete()
1163  *
1164  * @param string $method
1165  *   HEAD, GET, POST
1166  * @param string $url
1167  * @param bool $refuse_gz
1168  * @param string $referer
1169  * @param string $datas
1170  * @param string $vers
1171  * @param string $date
1172  * @return array
1173  */
1174 function init_http($method, $url, $refuse_gz = false, $referer = '', $datas = '', $vers = 'HTTP/1.0', $date = '') {
1175         $user = $via_proxy = $proxy_user = '';
1176         $fopen = false;
1177
1178         $t = @parse_url($url);
1179         $host = $t['host'];
1180         if ($t['scheme'] == 'http') {
1181                 $scheme = 'http';
1182                 $noproxy = '';
1183         } elseif ($t['scheme'] == 'https') {
1184                 $scheme = 'tls';
1185                 $noproxy = 'tls://';
1186                 if (!isset($t['port']) || !($port = $t['port'])) {
1187                         $t['port'] = 443;
1188                 }
1189         } else {
1190                 $scheme = $t['scheme'];
1191                 $noproxy = $scheme . '://';
1192         }
1193         if (isset($t['user'])) {
1194                 $user = array($t['user'], $t['pass']);
1195         }
1196
1197         if (!isset($t['port']) || !($port = $t['port'])) {
1198                 $port = 80;
1199         }
1200         if (!isset($t['path']) || !($path = $t['path'])) {
1201                 $path = '/';
1202         }
1203
1204         if (!empty($t['query'])) {
1205                 $path .= '?' . $t['query'];
1206         }
1207
1208         $f = lance_requete($method, $scheme, $user, $host, $path, $port, $noproxy, $refuse_gz, $referer, $datas, $vers, $date);
1209         if (!$f or !is_resource($f)) {
1210                 // fallback : fopen si on a pas fait timeout dans lance_requete
1211                 // ce qui correspond a $f===110
1212                 if ($f !== 110
1213                         and !need_proxy($host)
1214                         and !_request('tester_proxy')
1215                         and (!isset($GLOBALS['inc_distant_allow_fopen']) or $GLOBALS['inc_distant_allow_fopen'])
1216                 ) {
1217                         $f = @fopen($url, 'rb');
1218                         spip_log("connexion vers $url par simple fopen");
1219                         $fopen = true;
1220                 } else {
1221                         // echec total
1222                         $f = false;
1223                 }
1224         }
1225
1226         return array($f, $fopen);
1227 }
1228
1229 /**
1230  * Lancer la requete proprement dite
1231  *
1232  * @param string $method
1233  *   type de la requete (GET, HEAD, POST...)
1234  * @param string $scheme
1235  *   protocole (http, tls, ftp...)
1236  * @param array $user
1237  *   couple (utilisateur, mot de passe) en cas d'authentification http
1238  * @param string $host
1239  *   nom de domaine
1240  * @param string $path
1241  *   chemin de la page cherchee
1242  * @param string $port
1243  *   port utilise pour la connexion
1244  * @param bool $noproxy
1245  *   protocole utilise si requete sans proxy
1246  * @param bool $refuse_gz
1247  *   refuser la compression GZ
1248  * @param string $referer
1249  *   referer
1250  * @param string $datas
1251  *   donnees postees
1252  * @param string $vers
1253  *   version HTTP
1254  * @param int|string $date
1255  *   timestamp pour entente If-Modified-Since
1256  * @return bool|resource
1257  *   false|int si echec
1258  *   resource socket vers l'url demandee
1259  */
1260 function lance_requete(
1261         $method,
1262         $scheme,
1263         $user,
1264         $host,
1265         $path,
1266         $port,
1267         $noproxy,
1268         $refuse_gz = false,
1269         $referer = '',
1270         $datas = '',
1271         $vers = 'HTTP/1.0',
1272         $date = ''
1273 ) {
1274
1275         $proxy_user = '';
1276         $http_proxy = need_proxy($host);
1277         if ($user) {
1278                 $user = urlencode($user[0]) . ':' . urlencode($user[1]);
1279         }
1280
1281         $connect = '';
1282         if ($http_proxy) {
1283                 if (defined('_PROXY_HTTPS_VIA_CONNECT') and $scheme == 'tls') {
1284                         $path_host = (!$user ? '' : "$user@") . $host . (($port != 80) ? ":$port" : '');
1285                         $connect = 'CONNECT ' . $path_host . " $vers\r\n"
1286                                 . "Host: $path_host\r\n"
1287                                 . "Proxy-Connection: Keep-Alive\r\n";
1288                 } else {
1289                         $path = (($scheme == 'tls') ? 'https://' : "$scheme://")
1290                                 . (!$user ? '' : "$user@")
1291                                 . "$host" . (($port != 80) ? ":$port" : '') . $path;
1292                 }
1293                 $t2 = @parse_url($http_proxy);
1294                 $first_host = $t2['host'];
1295                 if (!($port = $t2['port'])) {
1296                         $port = 80;
1297                 }
1298                 if ($t2['user']) {
1299                         $proxy_user = base64_encode($t2['user'] . ':' . $t2['pass']);
1300                 }
1301         } else {
1302                 $first_host = $noproxy . $host;
1303         }
1304
1305         if ($connect) {
1306                 $streamContext = stream_context_create(array(
1307                         'ssl' => array(
1308                                 'verify_peer' => false,
1309                                 'allow_self_signed' => true,
1310                                 'SNI_enabled' => true,
1311                                 'peer_name' => $host,
1312                         )
1313                 ));
1314                 if (version_compare(phpversion(), '5.6', '<')) {
1315                         $streamContext['SNI_server_name'] = $host;
1316                 }
1317                 $f = @stream_socket_client(
1318                         "tcp://$first_host:$port",
1319                         $errno,
1320                         $errstr,
1321                         _INC_DISTANT_CONNECT_TIMEOUT,
1322                         STREAM_CLIENT_CONNECT,
1323                         $streamContext
1324                 );
1325                 spip_log("Recuperer $path sur $first_host:$port par $f (via CONNECT)", 'connect');
1326                 if (!$f) {
1327                         spip_log("Erreur connexion $errno $errstr", _LOG_ERREUR);
1328                         return $errno;
1329                 }
1330                 stream_set_timeout($f, _INC_DISTANT_CONNECT_TIMEOUT);
1331
1332                 fputs($f, $connect);
1333                 fputs($f, "\r\n");
1334                 $res = fread($f, 1024);
1335                 if (!$res
1336                         or !count($res = explode(' ', $res))
1337                         or $res[1] !== '200'
1338                 ) {
1339                         spip_log("Echec CONNECT sur $first_host:$port", 'connect' . _LOG_INFO_IMPORTANTE);
1340                         fclose($f);
1341
1342                         return false;
1343                 }
1344                 // important, car sinon on lit trop vite et les donnees ne sont pas encore dispo
1345                 stream_set_blocking($f, true);
1346                 // envoyer le handshake
1347                 stream_socket_enable_crypto($f, true, STREAM_CRYPTO_METHOD_SSLv23_CLIENT);
1348                 spip_log("OK CONNECT sur $first_host:$port", 'connect');
1349         } else {
1350                 $ntry = 3;
1351                 do {
1352                         $f = @fsockopen($first_host, $port, $errno, $errstr, _INC_DISTANT_CONNECT_TIMEOUT);
1353                 } while (!$f and $ntry-- and $errno !== 110 and sleep(1));
1354                 spip_log("Recuperer $path sur $first_host:$port par $f");
1355                 if (!$f) {
1356                         spip_log("Erreur connexion $errno $errstr", _LOG_ERREUR);
1357
1358                         return $errno;
1359                 }
1360                 stream_set_timeout($f, _INC_DISTANT_CONNECT_TIMEOUT);
1361         }
1362
1363         $site = isset($GLOBALS['meta']['adresse_site']) ? $GLOBALS['meta']['adresse_site'] : '';
1364
1365         $req = "$method $path $vers\r\n"
1366                 . "Host: $host\r\n"
1367                 . 'User-Agent: ' . _INC_DISTANT_USER_AGENT . "\r\n"
1368                 . ($refuse_gz ? '' : ('Accept-Encoding: ' . _INC_DISTANT_CONTENT_ENCODING . "\r\n"))
1369                 . (!$site ? '' : "Referer: $site/$referer\r\n")
1370                 . (!$date ? '' : 'If-Modified-Since: ' . (gmdate('D, d M Y H:i:s', $date) . " GMT\r\n"))
1371                 . (!$user ? '' : ('Authorization: Basic ' . base64_encode($user) . "\r\n"))
1372                 . (!$proxy_user ? '' : "Proxy-Authorization: Basic $proxy_user\r\n")
1373                 . (!strpos($vers, '1.1') ? '' : "Keep-Alive: 300\r\nConnection: keep-alive\r\n");
1374
1375 #       spip_log("Requete\n$req");
1376         fputs($f, $req);
1377         fputs($f, $datas ? $datas : "\r\n");
1378
1379         return $f;
1380 }