3 /***************************************************************************\
4 * SPIP, Systeme de publication pour l'internet *
6 * Copyright (c) 2001-2019 *
7 * Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
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 \***************************************************************************/
14 * Ce fichier gère l'obtention de données distantes
16 * @package SPIP\Core\Distant
18 if (!defined('_ECRIRE_INC_VERSION')) {
22 if (!defined('_INC_DISTANT_VERSION_HTTP')) {
23 define('_INC_DISTANT_VERSION_HTTP', 'HTTP/1.0');
25 if (!defined('_INC_DISTANT_CONTENT_ENCODING')) {
26 define('_INC_DISTANT_CONTENT_ENCODING', 'gzip');
28 if (!defined('_INC_DISTANT_USER_AGENT')) {
29 define('_INC_DISTANT_USER_AGENT', 'SPIP-' . $GLOBALS['spip_version_affichee'] . ' (' . $GLOBALS['home_server'] . ')');
31 if (!defined('_INC_DISTANT_MAX_SIZE')) {
32 define('_INC_DISTANT_MAX_SIZE', 2097152);
34 if (!defined('_INC_DISTANT_CONNECT_TIMEOUT')) {
35 define('_INC_DISTANT_CONNECT_TIMEOUT', 10);
38 define('_REGEXP_COPIE_LOCALE', ',' .
42 (isset($GLOBALS['meta']['adresse_site']) ?
$GLOBALS['meta']['adresse_site'] : '')
44 . '/?spip.php[?]action=acceder_document.*file=(.*)$,');
46 //@define('_COPIE_LOCALE_MAX_SIZE',2097152); // poids (inc/utils l'a fait)
49 * Crée au besoin la copie locale d'un fichier distant
51 * Prend en argument un chemin relatif au rep racine, ou une URL
52 * Renvoie un chemin relatif au rep racine, ou false
54 * @link http://www.spip.net/4155
55 * @pipeline_appel post_edition
57 * @param string $source
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
69 function copie_locale($source, $mode = 'auto', $local = null, $taille_max = null) {
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]);
75 return @file_exists
($source) ?
$source : false;
78 if (is_null($local)) {
79 $local = fichier_copie_locale($source);
81 if (_DIR_RACINE
and strncmp(_DIR_RACINE
, $local, strlen(_DIR_RACINE
)) == 0) {
82 $local = substr($local, strlen(_DIR_RACINE
));
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
93 $localrac = _DIR_RACINE
. $local;
94 $t = ($mode == 'force') ?
false : @file_exists
($localrac);
96 // test d'existence du fichier
97 if ($mode == 'test') {
98 return $t ?
$local : '';
101 // sinon voir si on doit/peut le telecharger
102 if ($local == $source or !tester_url_absolue($source)) {
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');
111 $taille_max = _COPIE_LOCALE_MAX_SIZE
;
113 $res = recuperer_url(
115 array('file' => $localrac, 'taille_max' => $taille_max, 'if_modified_since' => $t ?
filemtime($localrac) : '')
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
);
120 if (!$res['length']) {
121 // si $t c'est sans doute juste un not-modified-since
122 return $t ?
$local : false;
124 spip_log("copie_locale : recuperation $source sur $localrac taille " . $res['length'] . ' OK');
126 // pour une eventuelle indexation
131 'operation' => 'copie_locale',
134 'http_res' => $res['length'],
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
150 * @param array $known_hosts
151 * url/hosts externes connus et acceptes
152 * @return false|string
153 * url ou false en cas d'echec
155 function valider_url_distante($url, $known_hosts = array()) {
156 if (!function_exists('protocole_verifier')){
157 include_spip('inc/filtres_mini');
160 if (!protocole_verifier($url, array('http', 'https'))) {
164 $parsed_url = parse_url($url);
165 if (!$parsed_url or empty($parsed_url['host']) ) {
169 if (isset($parsed_url['user']) or isset($parsed_url['pass'])) {
173 if (false !== strpbrk($parsed_url['host'], ':#?[]')) {
177 if (!is_array($known_hosts)) {
178 $known_hosts = array($known_hosts);
180 $known_hosts[] = $GLOBALS['meta']['adresse_site'];
181 $known_hosts[] = url_de_base();
182 $known_hosts = pipeline('declarer_hosts_distants', $known_hosts);
184 $is_known_host = false;
185 foreach ($known_hosts as $known_host) {
186 $parse_known = parse_url($known_host);
188 and strtolower($parse_known['host']) === strtolower($parsed_url['host'])) {
189 $is_known_host = true;
194 if (!$is_known_host) {
195 $host = trim($parsed_url['host'], '.');
196 if (! $ip = filter_var($host, FILTER_VALIDATE_IP
)) {
197 $ip = gethostbyname($host);
199 // Error condition for gethostbyname()
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) {
217 if (! filter_var($ip, FILTER_VALIDATE_IP
, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE
)) {
223 if (empty($parsed_url['port'])) {
227 $port = $parsed_url['port'];
228 if ($port === 80 or $port === 443 or $port === 8080) {
232 if ($is_known_host) {
233 foreach ($known_hosts as $known_host) {
234 $parse_known = parse_url($known_host);
236 and !empty($parse_known['port'])
237 and strtolower($parse_known['host']) === strtolower($parsed_url['host'])
238 and $parse_known['port'] == $port) {
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
256 * @param string|array $donnees
257 * @param string $boundary
261 function prepare_donnees_post($donnees, $boundary = '') {
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)) {
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");
275 $entete = str_replace("\n", "\r\n", substr($donnees, 0, $p +
1));
276 $donnees = substr($donnees, $p +
2);
278 $chaine = str_replace("\n", "\r\n", $donnees);
280 /* boundary automatique */
281 // Si on a plus de 500 octects de donnees, on "boundarise"
282 if ($boundary === '') {
284 foreach ($donnees as $cle => $valeur) {
285 if (is_array($valeur)) {
286 foreach ($valeur as $val2) {
287 $taille +
= strlen($val2);
290 // faut-il utiliser spip_strlen() dans inc/charsets ?
291 $taille +
= strlen($valeur);
295 $boundary = substr(md5(rand() . 'spip'), 0, 8);
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";
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";
313 $chaine .= "\r\n--$boundary\r\n";
314 $chaine .= "Content-Disposition: form-data; name=\"$cle\"\r\n";
319 $chaine .= "\r\n--$boundary\r\n";
322 // fabrique une chaine HTTP simple pour un POST
323 $entete = 'Content-Type: application/x-www-form-urlencoded' . "\r\n";
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);
332 $chaine[] = rawurlencode($cle) . '=' . rawurlencode($valeur);
335 $chaine = implode('&', $chaine);
342 return array($entete, $chaine);
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
351 * @param string $url_idn
352 * @return array|string
354 function url_to_ascii($url_idn) {
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);
371 * Récupère le contenu d'une URL
372 * au besoin encode son contenu dans le charset local
375 * @uses recuperer_entetes()
376 * @uses recuperer_body()
377 * @uses transcoder_page()
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)
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
403 * string file : nom du fichier si enregistre dans un fichier
405 function recuperer_url($url, $options = array()) {
407 'transcoder' => false,
409 'taille_max' => null,
412 'refuser_gz' => false,
413 'if_modified_since' => '',
416 'follow_location' => 10,
417 'version_http' => _INC_DISTANT_VERSION_HTTP
,
419 $options = array_merge($default, $options);
420 // copier directement dans un fichier ?
421 $copy = $options['file'];
423 if ($options['methode'] == 'HEAD') {
424 $options['taille_max'] = 0;
426 if (is_null($options['taille_max'])) {
427 $options['taille_max'] = $copy ? _COPIE_LOCALE_MAX_SIZE
: _INC_DISTANT_MAX_SIZE
;
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);
435 $options['datas'] = $head . "\r\n\r\n" . $postdata;
436 if (strlen($postdata)) {
437 $options['methode'] = 'POST';
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;
449 $url = url_to_ascii($url);
456 'last_modified' => '',
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);
464 // ouvrir la connexion et envoyer la requete et ses en-tetes
465 list($handle, $fopen) = init_http(
469 $options['uri_referer'],
471 $options['version_http'],
472 $options['if_modified_since']
475 spip_log("ECHEC init_http $url");
480 // Sauf en fopen, envoyer le flux d'entree
481 // et recuperer les en-tetes de reponses
483 $res = recuperer_entetes_complets($handle, $options['if_modified_since']);
486 $t = @parse_url
($url);
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)
493 $result['length'] = strlen($res);
495 ecrire_fichier($copy, $res);
496 $result['file'] = $copy;
498 $result['page'] = $res;
506 } elseif ($res['location'] and $options['follow_location']) {
507 $options['follow_location']--;
509 include_spip('inc/filtres');
510 $url = suivre_lien($url, $res['location']);
511 spip_log("recuperer_url recommence sur $url");
513 return recuperer_url($url, $options);
514 } elseif ($res['status'] !== 200) {
515 spip_log('HTTP status ' . $res['status'] . " pour $url");
517 $result['status'] = $res['status'];
518 if (isset($res['headers'])) {
519 $result['headers'] = $res['headers'];
521 if (isset($res['last_modified'])) {
522 $result['last_modified'] = $res['last_modified'];
524 if (isset($res['location'])) {
525 $result['location'] = $res['location'];
529 // on ne veut que les entetes
530 if (!$options['taille_max'] or $options['methode'] == 'HEAD' or $result['status'] == '304') {
535 // s'il faut deballer, le faire via un fichier temporaire
536 // sinon la memoire explose pour les gros flux
539 if (preg_match(",\bContent-Encoding: .*gzip,is", $result['headers'])) {
540 $gz = (_DIR_TMP
. md5(uniqid(mt_rand())) . '.tmp.gz');
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);
548 $result['length'] = $res;
549 $result['file'] = $copy;
551 $result['page'] = &$res;
552 $result['length'] = strlen($result['page']);
554 $result['status'] = 200; // on a reussi, donc !
556 if (!$result['page']) {
560 // Decompresser au besoin
562 $result['page'] = implode('', gzfile($gz));
563 supprimer_fichier($gz);
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']);
576 * Récuperer une URL si on l'a pas déjà dans un cache fichier
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()
583 * @param array $options
584 * int delai_cache : anciennete acceptable pour le contenu (en seconde)
585 * @return array|bool|mixed
587 function recuperer_url_cache($url, $options = array()) {
588 if (!defined('_DELAI_RECUPERER_URL_CACHE')) {
589 define('_DELAI_RECUPERER_URL_CACHE', 3600);
592 'transcoder' => false,
594 'taille_max' => null,
597 'refuser_gz' => false,
598 'if_modified_since' => '',
601 'follow_location' => 10,
602 'version_http' => _INC_DISTANT_VERSION_HTTP
,
603 'delai_cache' => _DELAI_RECUPERER_URL_CACHE
,
605 $options = array_merge($default, $options);
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);
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];
619 unset($sig['if_modified_since']);
620 unset($sig['delai_cache']);
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";
629 $is_cached = file_exists($cache);
631 and (filemtime($cache) > $_SERVER['REQUEST_TIME'] - $options['delai_cache'])
633 lire_fichier($cache, $res);
634 if ($res = unserialize($res)) {
635 // mettre le last_modified et le status=304 ?
639 $res = recuperer_url($url, $options);
640 // ne pas recharger cette url non cachee dans le meme hit puisque non disponible
643 // on a pas reussi a recuperer mais on avait un cache : l'utiliser
644 lire_fichier($cache, $res);
645 $res = unserialize($res);
648 return $errors[$url] = $res;
650 ecrire_fichier($cache, serialize($res));
657 * Obsolète : Récupère une page sur le net et au besoin l'encode dans le charset local
659 * Gère les redirections de page (301) sur l'URL demandée (maximum 10 redirections)
662 * @uses recuperer_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)
690 function recuperer_page(
693 $get_headers = false,
701 // $copy = copier le fichier ?
702 $copy = (is_string($trans) and strlen($trans) > 5); // eviter "false" :-)
704 if (!is_null($taille_max) and ($taille_max == 0)) {
711 'transcoder' => $trans === true,
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,
721 if (!is_null($taille_max)) {
722 $options['taille_max'] = $taille_max;
724 // dix tentatives maximum en cas d'entetes 301...
725 $res = recuperer_url($url, $options);
729 if ($res['status'] !== 200) {
733 return $res['headers'] . "\n" . $res['page'];
741 * Obsolete Récupère une page sur le net et au besoin l'encode dans le charset local
745 * @uses recuperer_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
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,
772 function recuperer_lapage(
776 $taille_max = 1048576,
782 // $copy = copier le fichier ?
783 $copy = (is_string($trans) and strlen($trans) > 5); // eviter "false" :-)
785 // si on ecrit directement dans un fichier, pour ne pas manipuler
786 // en memoire refuser gz
792 'transcoder' => $trans === true,
795 'refuser_gz' => $refuser_gz,
796 'if_modified_since' => $date_verif,
797 'uri_referer' => $uri_referer,
798 'file' => $copy ?
$trans : '',
799 'follow_location' => false,
801 if (!is_null($taille_max)) {
802 $options['taille_max'] = $taille_max;
804 // dix tentatives maximum en cas d'entetes 301...
805 $res = recuperer_url($url, $options);
810 if ($res['status'] !== 200) {
814 return array($res['headers'], $res['page']);
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
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
831 function recuperer_body($handle, $taille_max = _INC_DISTANT_MAX_SIZE
, $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);
845 $result = 0; // on renvoie la taille du fichier
847 while (!feof($handle) and $taille < $taille_max) {
848 $res = fread($handle, 16384);
849 $taille +
= strlen($res);
858 spip_fclose_unlock($fp);
859 spip_unlink($fichier);
860 @rename
($tmpfile, $fichier);
861 if (!file_exists($fichier)) {
870 * Lit les entetes de reponse HTTP sur la socket $handle
872 * false en cas d'echec,
873 * un tableau associatif en cas de succes, contenant :
875 * - le tableau complet des headers
876 * - la date de derniere modif si connue
877 * - l'url de redirection si specifiee
879 * @param resource $handle
880 * @param int|bool $if_modified_since
887 function recuperer_entetes_complets($handle, $if_modified_since = false) {
888 $result = array('status' => 0, 'headers' => array(), 'last_modified' => 0, 'location' => '');
890 $s = @trim
(fgets($handle, 16384));
891 if (!preg_match(',^HTTP/[0-9]+\.[0-9]+ ([0-9]+),', $s, $r)) {
894 $result['status'] = intval($r[1]);
895 while ($s = trim(fgets($handle, 16384))) {
896 $result['headers'][] = $s . "\n";
897 preg_match(',^([^:]*): *(.*)$,i', $s, $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);
905 if ($if_modified_since
906 and $result['last_modified']
907 and $if_modified_since > $result['last_modified']
908 and $result['status'] == 200
910 $result['status'] = 304;
913 $result['headers'] = implode('', $result['headers']);
919 * Obsolete : version simplifiee de recuperer_entetes_complets
920 * Retourne les informations d'entête HTTP d'un socket
922 * Lit les entêtes de reponse HTTP sur la socket $f
924 * @uses recuperer_entetes_complets()
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
936 function recuperer_entetes($f, $date_verif = '') {
937 //Cas ou la page distante n'a pas bouge depuis
939 $res = recuperer_entetes_complets($f, $date_verif);
943 if ($res['location']) {
944 return $res['location'];
946 if ($res['status'] != 200) {
947 return $res['status'];
950 return explode("\n", $res['headers']);
954 * Calcule le nom canonique d'une copie local d'un fichier distant
956 * Si on doit conserver une copie locale des fichiers distants, autant que ca
957 * soit à un endroit canonique
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
964 * @param string $source
966 * @param string $extension
967 * Extension du fichier
969 * Nom du fichier pour copie locale
971 function nom_fichier_copie_locale($source, $extension) {
972 include_spip('inc/documents');
974 $d = creer_repertoire_documents('distant'); # IMG/distant/
975 $d = sous_repertoire($d, $extension); # IMG/distant/pdf/
977 // on se place tout le temps comme si on etait a la racine
979 $d = preg_replace(',^' . preg_quote(_DIR_RACINE
) . ',', '', $d);
985 . substr(preg_replace(',[^\w-],', '', basename($source)) . '-' . $m, 0, 12)
991 * Donne le nom de la copie locale de la source
993 * Soit obtient l'extension du fichier directement de l'URL de la source,
994 * soit tente de le calculer.
996 * @uses nom_fichier_copie_locale()
997 * @uses recuperer_infos_distantes()
999 * @param string $source
1000 * URL de la source distante
1002 * Nom du fichier calculé
1004 function fichier_copie_locale($source) {
1005 // Si c'est deja local pas de souci
1006 if (!tester_url_absolue($source)) {
1008 $source = preg_replace(',^' . preg_quote(_DIR_RACINE
) . ',', '', $source);
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'] = '';
1021 $ext = $path_parts ?
$path_parts['extension'] : '';
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)
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 <> ''");
1036 return nom_fichier_copie_locale($source, $ext);
1039 // voir si l'extension indiquee dans le nom du fichier est ok
1040 // et si il n'aurait pas deja ete rapatrie
1042 $ext = $path_parts ?
$path_parts['extension'] : '';
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)) {
1051 // Ping pour voir si son extension est connue et autorisee
1052 // avec mise en cache du resultat du ping
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'
1059 $path_parts = recuperer_infos_distantes($source, 0, false);
1060 ecrire_fichier($cache, serialize($path_parts));
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);
1066 spip_log("pas de copie locale pour $source");
1071 * Récupérer les infos d'un document distant, sans trop le télécharger
1073 * @param string $source
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
1080 * Couples des informations obtenues parmis :
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
1092 function recuperer_infos_distantes($source, $max = 0, $charger_si_petite_image = true) {
1094 // pas la peine de perdre son temps
1095 if (!tester_url_absolue($source)) {
1099 # charger les alias des types mime
1100 include_spip('base/typedoc');
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);
1110 if (preg_match(",\nContent-Type: *([^[:space:];]*),i", "\n$headers", $regs)) {
1111 $mime_type = (trim($regs[1]));
1116 // Appliquer les alias
1117 while (isset($GLOBALS['mime_alias'][$mime_type])) {
1118 $mime_type = $GLOBALS['mime_alias'][$mime_type];
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=...
1127 if (in_array($mime_type, array('text/plain', '', 'application/octet-stream'))) {
1129 and preg_match(',\.([a-z0-9]+)(\?.*)?$,i', $source, $rext)
1131 $t = sql_fetsel('extension', 'spip_types_documents', 'extension=' . sql_quote($rext[1], '', 'text'));
1134 and preg_match(',^Content-Disposition:\s*attachment;\s*filename=(.*)$,Uims', $headers, $m)
1135 and preg_match(',\.([a-z0-9]+)(\?.*)?$,i', $m[1], $rext)
1137 $t = sql_fetsel('extension', 'spip_types_documents', 'extension=' . sql_quote($rext[1], '', 'text'));
1141 // Autre mime/type (ou text/plain avec fichier d'extension inconnue)
1143 $t = sql_fetsel('extension', 'spip_types_documents', 'mime_type=' . sql_quote($mime_type));
1146 // Toujours rien ? (ex: audio/x-ogg au lieu de application/ogg)
1147 // On essaie de nouveau avec l'extension
1149 and $mime_type != 'text/plain'
1150 and preg_match(',\.([a-z0-9]+)(\?.*)?$,i', $source, $rext)
1152 # eviter xxx.3 => 3gp (> SPIP 3)
1153 $t = sql_fetsel('extension', 'spip_types_documents', 'extension=' . sql_quote($rext[1], '', 'text'));
1157 spip_log("mime-type $mime_type ok, extension " . $t['extension']);
1158 $a['extension'] = $t['extension'];
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'");
1166 $a['extension'] = $t['extension'];
1169 if (preg_match(",\nContent-Length: *([^[:space:]]*),i", "\n$headers", $regs)) {
1170 $a['taille'] = intval($regs[1]);
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
);
1180 // si on a rien trouve pas la peine d'insister
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)) {
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
1194 $a = recuperer_infos_distantes($source, _INC_DISTANT_MAX_SIZE
);
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;
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'])
1212 $a['largeur'] = 425;
1213 $a['hauteur'] = 350;
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]));
1222 if (!isset($a['taille']) or !$a['taille']) {
1223 $a['taille'] = strlen($page); # a peu pres
1226 $a['mime_type'] = $mime_type;
1233 * Tester si un host peut etre recuperer directement ou doit passer par un proxy
1235 * On peut passer en parametre le proxy et la liste des host exclus,
1236 * pour les besoins des tests, lors de la configuration
1238 * @param string $host
1239 * @param string $http_proxy
1240 * @param string $http_noproxy
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;
1247 // rien a faire si pas de proxy :)
1248 if (is_null($http_proxy) or !$http_proxy = trim($http_proxy)) {
1252 if (is_null($http_noproxy)) {
1253 $http_noproxy = isset($GLOBALS['meta']['http_noproxy']) ?
$GLOBALS['meta']['http_noproxy'] : null;
1255 // si pas d'exception, on retourne le proxy
1256 if (is_null($http_noproxy) or !$http_noproxy = trim($http_noproxy)) {
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 ";
1266 // si le domaine exact www.example.org est dans les exceptions
1267 if (strpos($http_noproxy, " $domain ") !== false)
1270 while (strpos($domain, '.') !== false) {
1271 $domain = explode('.', $domain);
1272 array_shift($domain);
1273 $domain = implode('.', $domain);
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) {
1281 // ok c'est pas une exception
1287 * Initialise une requete HTTP avec entetes
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.
1292 * @uses lance_requete()
1294 * @param string $method
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
1304 function init_http($method, $url, $refuse_gz = false, $referer = '', $datas = '', $vers = 'HTTP/1.0', $date = '') {
1305 $user = $via_proxy = $proxy_user = '';
1308 $t = @parse_url
($url);
1310 if ($t['scheme'] == 'http') {
1313 } elseif ($t['scheme'] == 'https') {
1315 $noproxy = 'ssl://';
1316 if (!isset($t['port']) ||
!($port = $t['port'])) {
1320 $scheme = $t['scheme'];
1321 $noproxy = $scheme . '://';
1323 if (isset($t['user'])) {
1324 $user = array($t['user'], $t['pass']);
1327 if (!isset($t['port']) ||
!($port = $t['port'])) {
1330 if (!isset($t['path']) ||
!($path = $t['path'])) {
1334 if (!empty($t['query'])) {
1335 $path .= '?' . $t['query'];
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
1343 and !need_proxy($host)
1344 and !_request('tester_proxy')
1345 and (!isset($GLOBALS['inc_distant_allow_fopen']) or $GLOBALS['inc_distant_allow_fopen'])
1347 $f = @fopen
($url, 'rb');
1348 spip_log("connexion vers $url par simple fopen");
1356 return array($f, $fopen);
1360 * Lancer la requete proprement dite
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
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
1380 * @param string $datas
1382 * @param string $vers
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
1390 function lance_requete(
1406 $http_proxy = need_proxy($host);
1408 $user = urlencode($user[0]) . ':' . urlencode($user[1]);
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";
1419 $path = (in_array($scheme , array('tls','ssl')) ?
'https://' : "$scheme://")
1420 . (!$user ?
'' : "$user@")
1421 . "$host" . (($port != 80) ?
":$port" : '') . $path;
1423 $t2 = @parse_url
($http_proxy);
1424 $first_host = $t2['host'];
1425 if (!($port = $t2['port'])) {
1429 $proxy_user = base64_encode($t2['user'] . ':' . $t2['pass']);
1432 $first_host = $noproxy . $host;
1436 $streamContext = stream_context_create(array(
1438 'verify_peer' => false,
1439 'allow_self_signed' => true,
1440 'SNI_enabled' => true,
1441 'peer_name' => $host,
1444 if (version_compare(phpversion(), '5.6', '<')) {
1445 stream_context_set_option($streamContext, 'ssl', 'SNI_server_name', $host);
1447 $f = @stream_socket_client
(
1448 "tcp://$first_host:$port",
1451 _INC_DISTANT_CONNECT_TIMEOUT
,
1452 STREAM_CLIENT_CONNECT
,
1455 spip_log("Recuperer $path sur $first_host:$port par $f (via CONNECT)", 'connect');
1457 spip_log("Erreur connexion $errno $errstr", _LOG_ERREUR
);
1460 stream_set_timeout($f, _INC_DISTANT_CONNECT_TIMEOUT
);
1462 fputs($f, $connect);
1464 $res = fread($f, 1024);
1466 or !count($res = explode(' ', $res))
1467 or $res[1] !== '200'
1469 spip_log("Echec CONNECT sur $first_host:$port", 'connect' . _LOG_INFO_IMPORTANTE
);
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');
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");
1486 spip_log("Erreur connexion $errno $errstr", _LOG_ERREUR
);
1490 stream_set_timeout($f, _INC_DISTANT_CONNECT_TIMEOUT
);
1493 $site = isset($GLOBALS['meta']['adresse_site']) ?
$GLOBALS['meta']['adresse_site'] : '';
1496 if ($port != (in_array($scheme , array('tls','ssl')) ?
443 : 80)) {
1497 $host_port .= ":$port";
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");
1509 # spip_log("Requete\n$req");
1511 fputs($f, $datas ?
$datas : "\r\n");