www/ecrire/inc/distant.php

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