PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/standard - http_fopen_wrapper.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 0 479 0.0 %
Date: 2014-04-18 Functions: 0 3 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2013 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Rasmus Lerdorf <rasmus@php.net>                             |
      16             :    |          Jim Winstead <jimw@php.net>                                 |
      17             :    |          Hartmut Holzgraefe <hholzgra@php.net>                       |
      18             :    |          Wez Furlong <wez@thebrainroom.com>                          |
      19             :    |          Sara Golemon <pollita@php.net>                              |
      20             :    +----------------------------------------------------------------------+
      21             :  */
      22             : /* $Id$ */ 
      23             : 
      24             : #include "php.h"
      25             : #include "php_globals.h"
      26             : #include "php_streams.h"
      27             : #include "php_network.h"
      28             : #include "php_ini.h"
      29             : #include "ext/standard/basic_functions.h"
      30             : #include "ext/standard/php_smart_str.h"
      31             : 
      32             : #include <stdio.h>
      33             : #include <stdlib.h>
      34             : #include <errno.h>
      35             : #include <sys/types.h>
      36             : #include <sys/stat.h>
      37             : #include <fcntl.h>
      38             : 
      39             : #ifdef PHP_WIN32
      40             : #define O_RDONLY _O_RDONLY
      41             : #include "win32/param.h"
      42             : #else
      43             : #include <sys/param.h>
      44             : #endif
      45             : 
      46             : #include "php_standard.h"
      47             : 
      48             : #include <sys/types.h>
      49             : #if HAVE_SYS_SOCKET_H
      50             : #include <sys/socket.h>
      51             : #endif
      52             : 
      53             : #ifdef PHP_WIN32
      54             : #include <winsock2.h>
      55             : #elif defined(NETWARE) && defined(USE_WINSOCK)
      56             : #include <novsock2.h>
      57             : #else
      58             : #include <netinet/in.h>
      59             : #include <netdb.h>
      60             : #if HAVE_ARPA_INET_H
      61             : #include <arpa/inet.h>
      62             : #endif
      63             : #endif
      64             : 
      65             : #if defined(PHP_WIN32) || defined(__riscos__) || defined(NETWARE)
      66             : #undef AF_UNIX
      67             : #endif
      68             : 
      69             : #if defined(AF_UNIX)
      70             : #include <sys/un.h>
      71             : #endif
      72             : 
      73             : #include "php_fopen_wrappers.h"
      74             : 
      75             : #define HTTP_HEADER_BLOCK_SIZE          1024
      76             : #define PHP_URL_REDIRECT_MAX            20
      77             : #define HTTP_HEADER_USER_AGENT          1
      78             : #define HTTP_HEADER_HOST                        2
      79             : #define HTTP_HEADER_AUTH                        4
      80             : #define HTTP_HEADER_FROM                        8
      81             : #define HTTP_HEADER_CONTENT_LENGTH      16
      82             : #define HTTP_HEADER_TYPE                        32
      83             : 
      84             : #define HTTP_WRAPPER_HEADER_INIT    1
      85             : #define HTTP_WRAPPER_REDIRECTED     2
      86             : 
      87           0 : php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper, char *path, char *mode, int options, char **opened_path, php_stream_context *context, int redirect_max, int flags STREAMS_DC TSRMLS_DC) /* {{{ */
      88             : {
      89           0 :         php_stream *stream = NULL;
      90           0 :         php_url *resource = NULL;
      91             :         int use_ssl;
      92           0 :         int use_proxy = 0;
      93           0 :         char *scratch = NULL;
      94           0 :         char *tmp = NULL;
      95           0 :         char *ua_str = NULL;
      96           0 :         zval **ua_zval = NULL, **tmpzval = NULL;
      97           0 :         int scratch_len = 0;
      98           0 :         int body = 0;
      99             :         char location[HTTP_HEADER_BLOCK_SIZE];
     100           0 :         zval *response_header = NULL;
     101           0 :         int reqok = 0;
     102           0 :         char *http_header_line = NULL;
     103             :         char tmp_line[128];
     104           0 :         size_t chunk_size = 0, file_size = 0;
     105           0 :         int eol_detect = 0;
     106           0 :         char *transport_string, *errstr = NULL;
     107           0 :         int transport_len, have_header = 0, request_fulluri = 0, ignore_errors = 0;
     108           0 :         char *protocol_version = NULL;
     109           0 :         int protocol_version_len = 3; /* Default: "1.0" */
     110             :         struct timeval timeout;
     111           0 :         char *user_headers = NULL;
     112           0 :         int header_init = ((flags & HTTP_WRAPPER_HEADER_INIT) != 0);
     113           0 :         int redirected = ((flags & HTTP_WRAPPER_REDIRECTED) != 0);
     114           0 :         int follow_location = 1;
     115           0 :         php_stream_filter *transfer_encoding = NULL;
     116             : 
     117           0 :         tmp_line[0] = '\0';
     118             : 
     119           0 :         if (redirect_max < 1) {
     120           0 :                 php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Redirection limit reached, aborting");
     121           0 :                 return NULL;
     122             :         }
     123             : 
     124           0 :         resource = php_url_parse(path);
     125           0 :         if (resource == NULL) {
     126           0 :                 return NULL;
     127             :         }
     128             : 
     129           0 :         if (strncasecmp(resource->scheme, "http", sizeof("http")) && strncasecmp(resource->scheme, "https", sizeof("https"))) {
     130           0 :                 if (!context || 
     131           0 :                         php_stream_context_get_option(context, wrapper->wops->label, "proxy", &tmpzval) == FAILURE ||
     132           0 :                         Z_TYPE_PP(tmpzval) != IS_STRING ||
     133           0 :                         Z_STRLEN_PP(tmpzval) <= 0) {
     134           0 :                         php_url_free(resource);
     135           0 :                         return php_stream_open_wrapper_ex(path, mode, ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL, context);
     136             :                 }
     137             :                 /* Called from a non-http wrapper with http proxying requested (i.e. ftp) */
     138           0 :                 request_fulluri = 1;
     139           0 :                 use_ssl = 0;
     140           0 :                 use_proxy = 1;
     141             : 
     142           0 :                 transport_len = Z_STRLEN_PP(tmpzval);
     143           0 :                 transport_string = estrndup(Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval));
     144             :         } else {
     145             :                 /* Normal http request (possibly with proxy) */
     146             :         
     147           0 :                 if (strpbrk(mode, "awx+")) {
     148           0 :                         php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "HTTP wrapper does not support writeable connections");
     149           0 :                         php_url_free(resource);
     150           0 :                         return NULL;
     151             :                 }
     152             : 
     153           0 :                 use_ssl = resource->scheme && (strlen(resource->scheme) > 4) && resource->scheme[4] == 's';
     154             :                 /* choose default ports */
     155           0 :                 if (use_ssl && resource->port == 0)
     156           0 :                         resource->port = 443;
     157           0 :                 else if (resource->port == 0)
     158           0 :                         resource->port = 80;
     159             : 
     160           0 :                 if (context &&
     161           0 :                         php_stream_context_get_option(context, wrapper->wops->label, "proxy", &tmpzval) == SUCCESS &&
     162           0 :                         Z_TYPE_PP(tmpzval) == IS_STRING &&
     163           0 :                         Z_STRLEN_PP(tmpzval) > 0) {
     164           0 :                         use_proxy = 1;
     165           0 :                         transport_len = Z_STRLEN_PP(tmpzval);
     166           0 :                         transport_string = estrndup(Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval));
     167             :                 } else {
     168           0 :                         transport_len = spprintf(&transport_string, 0, "%s://%s:%d", use_ssl ? "ssl" : "tcp", resource->host, resource->port);
     169             :                 }
     170             :         }
     171             : 
     172           0 :         if (context && php_stream_context_get_option(context, wrapper->wops->label, "timeout", &tmpzval) == SUCCESS) {
     173           0 :                 SEPARATE_ZVAL(tmpzval);
     174           0 :                 convert_to_double_ex(tmpzval);
     175           0 :                 timeout.tv_sec = (time_t) Z_DVAL_PP(tmpzval);
     176           0 :                 timeout.tv_usec = (size_t) ((Z_DVAL_PP(tmpzval) - timeout.tv_sec) * 1000000);
     177             :         } else {
     178           0 :                 timeout.tv_sec = FG(default_socket_timeout);
     179           0 :                 timeout.tv_usec = 0;
     180             :         }
     181             : 
     182           0 :         stream = php_stream_xport_create(transport_string, transport_len, options,
     183             :                         STREAM_XPORT_CLIENT | STREAM_XPORT_CONNECT,
     184             :                         NULL, &timeout, context, &errstr, NULL);
     185             :     
     186           0 :         if (stream) {
     187           0 :                 php_stream_set_option(stream, PHP_STREAM_OPTION_READ_TIMEOUT, 0, &timeout);
     188             :         }
     189             :                         
     190           0 :         if (errstr) {
     191           0 :                 php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "%s", errstr);
     192           0 :                 efree(errstr);
     193           0 :                 errstr = NULL;
     194             :         }
     195             : 
     196           0 :         efree(transport_string);
     197             : 
     198           0 :         if (stream && use_proxy && use_ssl) {
     199           0 :                 smart_str header = {0};
     200             : 
     201           0 :                 smart_str_appendl(&header, "CONNECT ", sizeof("CONNECT ")-1);
     202           0 :                 smart_str_appends(&header, resource->host);
     203           0 :                 smart_str_appendc(&header, ':');
     204           0 :                 smart_str_append_unsigned(&header, resource->port);
     205           0 :                 smart_str_appendl(&header, " HTTP/1.0\r\n", sizeof(" HTTP/1.0\r\n")-1);
     206             : 
     207             :             /* check if we have Proxy-Authorization header */
     208           0 :                 if (context && php_stream_context_get_option(context, "http", "header", &tmpzval) == SUCCESS) {
     209             :                         char *s, *p;
     210             : 
     211           0 :                         if (Z_TYPE_PP(tmpzval) == IS_ARRAY) {
     212             :                                 HashPosition pos;
     213           0 :                                 zval **tmpheader = NULL;
     214             : 
     215           0 :                                 for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(tmpzval), &pos);
     216           0 :                                         SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(tmpzval), (void *)&tmpheader, &pos);
     217           0 :                                         zend_hash_move_forward_ex(Z_ARRVAL_PP(tmpzval), &pos)) {
     218           0 :                                         if (Z_TYPE_PP(tmpheader) == IS_STRING) {
     219           0 :                                                 s = Z_STRVAL_PP(tmpheader);
     220             :                                                 do {
     221           0 :                                                         while (*s == ' ' || *s == '\t') s++;
     222           0 :                                                         p = s;
     223           0 :                                                         while (*p != 0 && *p != ':' && *p != '\r' && *p !='\n') p++;
     224           0 :                                                         if (*p == ':') {
     225           0 :                                                                 p++;
     226           0 :                                                                 if (p - s == sizeof("Proxy-Authorization:") - 1 &&
     227             :                                                                     zend_binary_strcasecmp(s, sizeof("Proxy-Authorization:") - 1,
     228           0 :                                                                         "Proxy-Authorization:", sizeof("Proxy-Authorization:") - 1) == 0) {
     229           0 :                                                                         while (*p != 0 && *p != '\r' && *p !='\n') p++;
     230           0 :                                                                         smart_str_appendl(&header, s, p - s);
     231           0 :                                                                         smart_str_appendl(&header, "\r\n", sizeof("\r\n")-1);
     232           0 :                                                                         goto finish;
     233             :                                                                 } else {
     234           0 :                                                                         while (*p != 0 && *p != '\r' && *p !='\n') p++;
     235             :                                                                 }
     236             :                                                         }
     237           0 :                                                         s = p;
     238           0 :                                                         while (*s == '\r' || *s == '\n') s++;
     239           0 :                                                 } while (*s != 0);
     240             :                                         }
     241             :                                 }
     242           0 :                         } else if (Z_TYPE_PP(tmpzval) == IS_STRING && Z_STRLEN_PP(tmpzval)) {
     243           0 :                                 s = Z_STRVAL_PP(tmpzval);
     244             :                                 do {
     245           0 :                                         while (*s == ' ' || *s == '\t') s++;
     246           0 :                                         p = s;
     247           0 :                                         while (*p != 0 && *p != ':' && *p != '\r' && *p !='\n') p++;
     248           0 :                                         if (*p == ':') {
     249           0 :                                                 p++;
     250           0 :                                                 if (p - s == sizeof("Proxy-Authorization:") - 1 &&
     251             :                                                     zend_binary_strcasecmp(s, sizeof("Proxy-Authorization:") - 1,
     252           0 :                                                         "Proxy-Authorization:", sizeof("Proxy-Authorization:") - 1) == 0) {
     253           0 :                                                         while (*p != 0 && *p != '\r' && *p !='\n') p++;
     254           0 :                                                         smart_str_appendl(&header, s, p - s);
     255           0 :                                                         smart_str_appendl(&header, "\r\n", sizeof("\r\n")-1);
     256           0 :                                                         goto finish;
     257             :                                                 } else {
     258           0 :                                                         while (*p != 0 && *p != '\r' && *p !='\n') p++;
     259             :                                                 }
     260             :                                         }
     261           0 :                                         s = p;
     262           0 :                                         while (*s == '\r' || *s == '\n') s++;
     263           0 :                                 } while (*s != 0);
     264             :                         }
     265             :                 }
     266             : finish:
     267           0 :                 smart_str_appendl(&header, "\r\n", sizeof("\r\n")-1);
     268             : 
     269           0 :                 if (php_stream_write(stream, header.c, header.len) != header.len) {
     270           0 :                         php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Cannot connect to HTTPS server through proxy");
     271           0 :                         php_stream_close(stream);
     272           0 :                         stream = NULL;
     273             :                 }
     274           0 :                 smart_str_free(&header);
     275             : 
     276           0 :                 if (stream) {
     277             :                         char header_line[HTTP_HEADER_BLOCK_SIZE];
     278             : 
     279             :                         /* get response header */
     280           0 :                         while (php_stream_gets(stream, header_line, HTTP_HEADER_BLOCK_SIZE-1) != NULL) {
     281           0 :                                 if (header_line[0] == '\n' ||
     282           0 :                                     header_line[0] == '\r' ||
     283           0 :                                     header_line[0] == '\0') {
     284             :                                   break;
     285             :                                 }
     286             :                         }
     287             :                 }
     288             : 
     289             :                 /* enable SSL transport layer */
     290           0 :                 if (stream) {
     291           0 :                         if (php_stream_xport_crypto_setup(stream, STREAM_CRYPTO_METHOD_SSLv23_CLIENT, NULL TSRMLS_CC) < 0 ||
     292           0 :                             php_stream_xport_crypto_enable(stream, 1 TSRMLS_CC) < 0) {
     293           0 :                                 php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Cannot connect to HTTPS server through proxy");
     294           0 :                                 php_stream_close(stream);
     295           0 :                                 stream = NULL;
     296             :                         }
     297             :                 }
     298             :         }
     299             : 
     300           0 :         if (stream == NULL)
     301           0 :                 goto out;
     302             : 
     303             :         /* avoid buffering issues while reading header */
     304           0 :         if (options & STREAM_WILL_CAST)
     305           0 :                 chunk_size = php_stream_set_chunk_size(stream, 1);
     306             :         
     307             :         /* avoid problems with auto-detecting when reading the headers -> the headers
     308             :          * are always in canonical \r\n format */
     309           0 :         eol_detect = stream->flags & (PHP_STREAM_FLAG_DETECT_EOL | PHP_STREAM_FLAG_EOL_MAC);
     310           0 :         stream->flags &= ~(PHP_STREAM_FLAG_DETECT_EOL | PHP_STREAM_FLAG_EOL_MAC);
     311             : 
     312           0 :         php_stream_context_set(stream, context);
     313             : 
     314           0 :         php_stream_notify_info(context, PHP_STREAM_NOTIFY_CONNECT, NULL, 0);
     315             : 
     316           0 :         if (header_init && context && php_stream_context_get_option(context, "http", "max_redirects", &tmpzval) == SUCCESS) {
     317           0 :                 SEPARATE_ZVAL(tmpzval);
     318           0 :                 convert_to_long_ex(tmpzval);
     319           0 :                 redirect_max = Z_LVAL_PP(tmpzval);
     320             :         }
     321             : 
     322           0 :         if (context && php_stream_context_get_option(context, "http", "method", &tmpzval) == SUCCESS) {
     323           0 :                 if (Z_TYPE_PP(tmpzval) == IS_STRING && Z_STRLEN_PP(tmpzval) > 0) {
     324             :                         /* As per the RFC, automatically redirected requests MUST NOT use other methods than
     325             :                          * GET and HEAD unless it can be confirmed by the user */
     326           0 :                         if (!redirected
     327           0 :                                 || (Z_STRLEN_PP(tmpzval) == 3 && memcmp("GET", Z_STRVAL_PP(tmpzval), 3) == 0)
     328           0 :                                 || (Z_STRLEN_PP(tmpzval) == 4 && memcmp("HEAD",Z_STRVAL_PP(tmpzval), 4) == 0)
     329             :                         ) {
     330           0 :                                 scratch_len = strlen(path) + 29 + Z_STRLEN_PP(tmpzval);
     331           0 :                                 scratch = emalloc(scratch_len);
     332           0 :                                 strlcpy(scratch, Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval) + 1);
     333           0 :                                 strncat(scratch, " ", 1);
     334             :                         }
     335             :                 }
     336             :         }
     337             :  
     338           0 :         if (context && php_stream_context_get_option(context, "http", "protocol_version", &tmpzval) == SUCCESS) {
     339           0 :                 SEPARATE_ZVAL(tmpzval);
     340           0 :                 convert_to_double_ex(tmpzval);
     341           0 :                 protocol_version_len = spprintf(&protocol_version, 0, "%.1F", Z_DVAL_PP(tmpzval));
     342             :         }
     343             : 
     344           0 :         if (!scratch) {
     345           0 :                 scratch_len = strlen(path) + 29 + protocol_version_len;
     346           0 :                 scratch = emalloc(scratch_len);
     347           0 :                 strncpy(scratch, "GET ", scratch_len);
     348             :         }
     349             : 
     350             :         /* Should we send the entire path in the request line, default to no. */
     351           0 :         if (!request_fulluri &&
     352             :                 context &&
     353           0 :                 php_stream_context_get_option(context, "http", "request_fulluri", &tmpzval) == SUCCESS) {
     354           0 :                 zval ztmp = **tmpzval;
     355             : 
     356           0 :                 zval_copy_ctor(&ztmp);
     357           0 :                 convert_to_boolean(&ztmp);
     358           0 :                 request_fulluri = Z_BVAL(ztmp) ? 1 : 0;
     359           0 :                 zval_dtor(&ztmp);
     360             :         }
     361             : 
     362           0 :         if (request_fulluri) {
     363             :                 /* Ask for everything */
     364           0 :                 strcat(scratch, path);
     365             :         } else {
     366             :                 /* Send the traditional /path/to/file?query_string */
     367             : 
     368             :                 /* file */
     369           0 :                 if (resource->path && *resource->path) {
     370           0 :                         strlcat(scratch, resource->path, scratch_len);
     371             :                 } else {
     372           0 :                         strlcat(scratch, "/", scratch_len);
     373             :                 }
     374             : 
     375             :                 /* query string */
     376           0 :                 if (resource->query) {
     377           0 :                         strlcat(scratch, "?", scratch_len);
     378           0 :                         strlcat(scratch, resource->query, scratch_len);
     379             :                 }
     380             :         }
     381             : 
     382             :         /* protocol version we are speaking */
     383           0 :         if (protocol_version) {
     384           0 :                 strlcat(scratch, " HTTP/", scratch_len);
     385           0 :                 strlcat(scratch, protocol_version, scratch_len);
     386           0 :                 strlcat(scratch, "\r\n", scratch_len);
     387           0 :                 efree(protocol_version);
     388           0 :                 protocol_version = NULL;
     389             :         } else {
     390           0 :                 strlcat(scratch, " HTTP/1.0\r\n", scratch_len);
     391             :         }
     392             : 
     393             :         /* send it */
     394           0 :         php_stream_write(stream, scratch, strlen(scratch));
     395             : 
     396           0 :         if (context && php_stream_context_get_option(context, "http", "header", &tmpzval) == SUCCESS) {
     397           0 :                 tmp = NULL;
     398             :                 
     399           0 :                 if (Z_TYPE_PP(tmpzval) == IS_ARRAY) {
     400             :                         HashPosition pos;
     401           0 :                         zval **tmpheader = NULL;
     402           0 :                         smart_str tmpstr = {0};
     403             : 
     404           0 :                         for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(tmpzval), &pos);
     405           0 :                                 SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(tmpzval), (void *)&tmpheader, &pos);
     406           0 :                                 zend_hash_move_forward_ex(Z_ARRVAL_PP(tmpzval), &pos)
     407           0 :                         ) {
     408           0 :                                 if (Z_TYPE_PP(tmpheader) == IS_STRING) {
     409           0 :                                         smart_str_appendl(&tmpstr, Z_STRVAL_PP(tmpheader), Z_STRLEN_PP(tmpheader));
     410           0 :                                         smart_str_appendl(&tmpstr, "\r\n", sizeof("\r\n") - 1);
     411             :                                 }
     412             :                         }
     413           0 :                         smart_str_0(&tmpstr);
     414             :                         /* Remove newlines and spaces from start and end. there's at least one extra \r\n at the end that needs to go. */
     415           0 :                         if (tmpstr.c) {
     416           0 :                                 tmp = php_trim(tmpstr.c, strlen(tmpstr.c), NULL, 0, NULL, 3 TSRMLS_CC);
     417           0 :                                 smart_str_free(&tmpstr);
     418             :                         }
     419             :                 }
     420           0 :                 if (Z_TYPE_PP(tmpzval) == IS_STRING && Z_STRLEN_PP(tmpzval)) {
     421             :                         /* Remove newlines and spaces from start and end php_trim will estrndup() */
     422           0 :                         tmp = php_trim(Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval), NULL, 0, NULL, 3 TSRMLS_CC);
     423             :                 }
     424           0 :                 if (tmp && strlen(tmp) > 0) {
     425             :                         char *s;
     426             : 
     427           0 :                         if (!header_init) { /* Remove post headers for redirects */
     428           0 :                                 int l = strlen(tmp);
     429           0 :                                 char *s2, *tmp_c = estrdup(tmp);
     430             :                                 
     431           0 :                                 php_strtolower(tmp_c, l);
     432           0 :                                 if ((s = strstr(tmp_c, "content-length:"))) {
     433           0 :                                         if ((s2 = memchr(s, '\n', tmp_c + l - s))) {
     434           0 :                                                 int b = tmp_c + l - 1 - s2;
     435           0 :                                                 memmove(tmp, tmp + (s2 + 1 - tmp_c), b);
     436           0 :                                                 memmove(tmp_c, s2 + 1, b);
     437             :                                                 
     438             :                                         } else {
     439           0 :                                                 tmp[s - tmp_c] = *s = '\0';
     440             :                                         }
     441           0 :                                         l = strlen(tmp_c);
     442             :                                 }
     443           0 :                                 if ((s = strstr(tmp_c, "content-type:"))) {
     444           0 :                                         if ((s2 = memchr(s, '\n', tmp_c + l - s))) {
     445           0 :                                                 memmove(tmp, tmp + (s2 + 1 - tmp_c), tmp_c + l - 1 - s2);
     446             :                                         } else {
     447           0 :                                                 tmp[s - tmp_c] = '\0';
     448             :                                         }
     449             :                                 }
     450             : 
     451           0 :                                 efree(tmp_c);
     452           0 :                                 tmp_c = php_trim(tmp, strlen(tmp), NULL, 0, NULL, 3 TSRMLS_CC);
     453           0 :                                 efree(tmp);
     454           0 :                                 tmp = tmp_c;
     455             :                         }
     456             : 
     457           0 :                         user_headers = estrdup(tmp);
     458             : 
     459             :                         /* Make lowercase for easy comparison against 'standard' headers */
     460           0 :                         php_strtolower(tmp, strlen(tmp));
     461           0 :                         if ((s = strstr(tmp, "user-agent:")) && 
     462           0 :                             (s == tmp || *(s-1) == '\r' || *(s-1) == '\n' || 
     463           0 :                                          *(s-1) == '\t' || *(s-1) == ' ')) {
     464           0 :                                  have_header |= HTTP_HEADER_USER_AGENT;
     465             :                         }
     466           0 :                         if ((s = strstr(tmp, "host:")) &&
     467           0 :                             (s == tmp || *(s-1) == '\r' || *(s-1) == '\n' || 
     468           0 :                                          *(s-1) == '\t' || *(s-1) == ' ')) {
     469           0 :                                  have_header |= HTTP_HEADER_HOST;
     470             :                         }
     471           0 :                         if ((s = strstr(tmp, "from:")) &&
     472           0 :                             (s == tmp || *(s-1) == '\r' || *(s-1) == '\n' || 
     473           0 :                                          *(s-1) == '\t' || *(s-1) == ' ')) {
     474           0 :                                  have_header |= HTTP_HEADER_FROM;
     475             :                                 }
     476           0 :                         if ((s = strstr(tmp, "authorization:")) &&
     477           0 :                             (s == tmp || *(s-1) == '\r' || *(s-1) == '\n' || 
     478           0 :                                          *(s-1) == '\t' || *(s-1) == ' ')) {
     479           0 :                                  have_header |= HTTP_HEADER_AUTH;
     480             :                         }
     481           0 :                         if ((s = strstr(tmp, "content-length:")) &&
     482           0 :                             (s == tmp || *(s-1) == '\r' || *(s-1) == '\n' || 
     483           0 :                                          *(s-1) == '\t' || *(s-1) == ' ')) {
     484           0 :                                  have_header |= HTTP_HEADER_CONTENT_LENGTH;
     485             :                         }
     486           0 :                         if ((s = strstr(tmp, "content-type:")) &&
     487           0 :                             (s == tmp || *(s-1) == '\r' || *(s-1) == '\n' || 
     488           0 :                                          *(s-1) == '\t' || *(s-1) == ' ')) {
     489           0 :                                  have_header |= HTTP_HEADER_TYPE;
     490             :                         }
     491             :                         /* remove Proxy-Authorization header */
     492           0 :                         if (use_proxy && use_ssl && (s = strstr(tmp, "proxy-authorization:")) &&
     493           0 :                             (s == tmp || *(s-1) == '\r' || *(s-1) == '\n' || 
     494           0 :                                          *(s-1) == '\t' || *(s-1) == ' ')) {
     495           0 :                                 char *p = s + sizeof("proxy-authorization:") - 1;
     496             :                                 
     497           0 :                                 while (s > tmp && (*(s-1) == ' ' || *(s-1) == '\t')) s--;
     498           0 :                                 while (*p != 0 && *p != '\r' && *p != '\n') p++;
     499           0 :                                 while (*p == '\r' || *p == '\n') p++;
     500           0 :                                 if (*p == 0) {
     501           0 :                                         if (s == tmp) {
     502           0 :                                                 efree(user_headers);
     503           0 :                                                 user_headers = NULL;
     504             :                                         } else {
     505           0 :                                                 while (s > tmp && (*(s-1) == '\r' || *(s-1) == '\n')) s--;
     506           0 :                                                 user_headers[s - tmp] = 0;
     507             :                                         }
     508             :                                 } else {
     509           0 :                                         memmove(user_headers + (s - tmp), user_headers + (p - tmp), strlen(p) + 1);
     510             :                                 }
     511             :                         }
     512             : 
     513             :                 }
     514           0 :                 if (tmp) {
     515           0 :                         efree(tmp);
     516             :                 }
     517             :         }
     518             : 
     519             :         /* auth header if it was specified */
     520           0 :         if (((have_header & HTTP_HEADER_AUTH) == 0) && resource->user) {
     521             :                 /* decode the strings first */
     522           0 :                 php_url_decode(resource->user, strlen(resource->user));
     523             : 
     524             :                 /* scratch is large enough, since it was made large enough for the whole URL */
     525           0 :                 strcpy(scratch, resource->user);
     526           0 :                 strcat(scratch, ":");
     527             : 
     528             :                 /* Note: password is optional! */
     529           0 :                 if (resource->pass) {
     530           0 :                         php_url_decode(resource->pass, strlen(resource->pass));
     531           0 :                         strcat(scratch, resource->pass);
     532             :                 }
     533             : 
     534           0 :                 tmp = (char*)php_base64_encode((unsigned char*)scratch, strlen(scratch), NULL);
     535             :                 
     536           0 :                 if (snprintf(scratch, scratch_len, "Authorization: Basic %s\r\n", tmp) > 0) {
     537           0 :                         php_stream_write(stream, scratch, strlen(scratch));
     538           0 :                         php_stream_notify_info(context, PHP_STREAM_NOTIFY_AUTH_REQUIRED, NULL, 0);
     539             :                 }
     540             : 
     541           0 :                 efree(tmp);
     542           0 :                 tmp = NULL;
     543             :         }
     544             : 
     545             :         /* if the user has configured who they are, send a From: line */
     546             :         {
     547           0 :                 char *from_address = php_ini_string("from", sizeof("from"), 0);
     548           0 :                 if (((have_header & HTTP_HEADER_FROM) == 0) && from_address && from_address[0] != '\0') {
     549           0 :                         if (snprintf(scratch, scratch_len, "From: %s\r\n", from_address) > 0)
     550           0 :                                 php_stream_write(stream, scratch, strlen(scratch));
     551             :                 }
     552             :         }
     553             : 
     554             :         /* Send Host: header so name-based virtual hosts work */
     555           0 :         if ((have_header & HTTP_HEADER_HOST) == 0) {
     556           0 :                 if ((use_ssl && resource->port != 443 && resource->port != 0) || 
     557           0 :                         (!use_ssl && resource->port != 80 && resource->port != 0)) {
     558           0 :                         if (snprintf(scratch, scratch_len, "Host: %s:%i\r\n", resource->host, resource->port) > 0)
     559           0 :                                 php_stream_write(stream, scratch, strlen(scratch));
     560             :                 } else {
     561           0 :                         if (snprintf(scratch, scratch_len, "Host: %s\r\n", resource->host) > 0) {
     562           0 :                                 php_stream_write(stream, scratch, strlen(scratch));
     563             :                         }
     564             :                 }
     565             :         }
     566             : 
     567           0 :         if (context && 
     568           0 :             php_stream_context_get_option(context, "http", "user_agent", &ua_zval) == SUCCESS &&
     569           0 :                 Z_TYPE_PP(ua_zval) == IS_STRING) {
     570           0 :                 ua_str = Z_STRVAL_PP(ua_zval);
     571           0 :         } else if (FG(user_agent)) {
     572           0 :                 ua_str = FG(user_agent);
     573             :         }
     574             : 
     575           0 :         if (((have_header & HTTP_HEADER_USER_AGENT) == 0) && ua_str) {
     576             : #define _UA_HEADER "User-Agent: %s\r\n"
     577             :                 char *ua;
     578             :                 size_t ua_len;
     579             :                 
     580           0 :                 ua_len = sizeof(_UA_HEADER) + strlen(ua_str);
     581             :                 
     582             :                 /* ensure the header is only sent if user_agent is not blank */
     583           0 :                 if (ua_len > sizeof(_UA_HEADER)) {
     584           0 :                         ua = emalloc(ua_len + 1);
     585           0 :                         if ((ua_len = slprintf(ua, ua_len, _UA_HEADER, ua_str)) > 0) {
     586           0 :                                 ua[ua_len] = 0;
     587           0 :                                 php_stream_write(stream, ua, ua_len);
     588             :                         } else {
     589           0 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot construct User-agent header");
     590             :                         }
     591             : 
     592           0 :                         if (ua) {
     593           0 :                                 efree(ua);
     594             :                         }
     595             :                 }       
     596             :         }
     597             : 
     598           0 :         if (user_headers) {
     599             :                 /* A bit weird, but some servers require that Content-Length be sent prior to Content-Type for POST
     600             :                  * see bug #44603 for details. Since Content-Type maybe part of user's headers we need to do this check first.
     601             :                  */
     602           0 :                 if (
     603             :                                 header_init &&
     604             :                                 context &&
     605           0 :                                 !(have_header & HTTP_HEADER_CONTENT_LENGTH) &&
     606           0 :                                 php_stream_context_get_option(context, "http", "content", &tmpzval) == SUCCESS &&
     607           0 :                                 Z_TYPE_PP(tmpzval) == IS_STRING && Z_STRLEN_PP(tmpzval) > 0
     608             :                 ) {
     609           0 :                         scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRLEN_PP(tmpzval));
     610           0 :                         php_stream_write(stream, scratch, scratch_len);
     611           0 :                         have_header |= HTTP_HEADER_CONTENT_LENGTH;
     612             :                 }
     613             : 
     614           0 :                 php_stream_write(stream, user_headers, strlen(user_headers));
     615           0 :                 php_stream_write(stream, "\r\n", sizeof("\r\n")-1);
     616           0 :                 efree(user_headers);
     617             :         }
     618             : 
     619             :         /* Request content, such as for POST requests */
     620           0 :         if (header_init && context &&
     621           0 :                 php_stream_context_get_option(context, "http", "content", &tmpzval) == SUCCESS &&
     622           0 :                 Z_TYPE_PP(tmpzval) == IS_STRING && Z_STRLEN_PP(tmpzval) > 0) {
     623           0 :                 if (!(have_header & HTTP_HEADER_CONTENT_LENGTH)) {
     624           0 :                         scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRLEN_PP(tmpzval));
     625           0 :                         php_stream_write(stream, scratch, scratch_len);
     626             :                 }
     627           0 :                 if (!(have_header & HTTP_HEADER_TYPE)) {
     628           0 :                         php_stream_write(stream, "Content-Type: application/x-www-form-urlencoded\r\n",
     629             :                                 sizeof("Content-Type: application/x-www-form-urlencoded\r\n") - 1);
     630           0 :                         php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Content-type not specified assuming application/x-www-form-urlencoded");
     631             :                 }
     632           0 :                 php_stream_write(stream, "\r\n", sizeof("\r\n")-1);
     633           0 :                 php_stream_write(stream, Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval));
     634             :         } else {
     635           0 :                 php_stream_write(stream, "\r\n", sizeof("\r\n")-1);
     636             :         }
     637             : 
     638           0 :         location[0] = '\0';
     639             : 
     640           0 :         if (!EG(active_symbol_table)) {
     641           0 :                 zend_rebuild_symbol_table(TSRMLS_C);
     642             :         }
     643             : 
     644           0 :         if (header_init) {
     645             :                 zval *ztmp;
     646           0 :                 MAKE_STD_ZVAL(ztmp);
     647           0 :                 array_init(ztmp);
     648           0 :                 ZEND_SET_SYMBOL(EG(active_symbol_table), "http_response_header", ztmp);
     649             :         }
     650             : 
     651             :         {
     652             :                 zval **rh;
     653           0 :                 zend_hash_find(EG(active_symbol_table), "http_response_header", sizeof("http_response_header"), (void **) &rh);
     654           0 :                 response_header = *rh;
     655             :         }
     656             : 
     657           0 :         if (!php_stream_eof(stream)) {
     658             :                 size_t tmp_line_len;
     659             :                 /* get response header */
     660             : 
     661           0 :                 if (php_stream_get_line(stream, tmp_line, sizeof(tmp_line) - 1, &tmp_line_len) != NULL) {
     662             :                         zval *http_response;
     663             :                         int response_code;
     664             : 
     665           0 :                         if (tmp_line_len > 9) {
     666           0 :                                 response_code = atoi(tmp_line + 9);
     667             :                         } else {
     668           0 :                                 response_code = 0;
     669             :                         }
     670           0 :                         if (context && SUCCESS==php_stream_context_get_option(context, "http", "ignore_errors", &tmpzval)) {
     671           0 :                                 ignore_errors = zend_is_true(*tmpzval);
     672             :                         }
     673             :                         /* when we request only the header, don't fail even on error codes */
     674           0 :                         if ((options & STREAM_ONLY_GET_HEADERS) || ignore_errors) {
     675           0 :                                 reqok = 1;
     676             :                         }
     677             :                         /* all status codes in the 2xx range are defined by the specification as successful;
     678             :                          * all status codes in the 3xx range are for redirection, and so also should never
     679             :                          * fail */
     680           0 :                         if (response_code >= 200 && response_code < 400) {
     681           0 :                                 reqok = 1;
     682             :                         } else {
     683           0 :                                 switch(response_code) {
     684             :                                         case 403:
     685           0 :                                                 php_stream_notify_error(context, PHP_STREAM_NOTIFY_AUTH_RESULT,
     686             :                                                                 tmp_line, response_code);
     687           0 :                                                 break;
     688             :                                         default:
     689             :                                                 /* safety net in the event tmp_line == NULL */
     690           0 :                                                 if (!tmp_line_len) {
     691           0 :                                                         tmp_line[0] = '\0';
     692             :                                                 }
     693           0 :                                                 php_stream_notify_error(context, PHP_STREAM_NOTIFY_FAILURE,
     694             :                                                                 tmp_line, response_code);
     695             :                                 }
     696             :                         }
     697           0 :                         if (tmp_line[tmp_line_len - 1] == '\n') {
     698           0 :                                 --tmp_line_len;
     699           0 :                                 if (tmp_line[tmp_line_len - 1] == '\r') {
     700           0 :                                         --tmp_line_len;
     701             :                                 }
     702             :                         }
     703           0 :                         MAKE_STD_ZVAL(http_response);
     704           0 :                         ZVAL_STRINGL(http_response, tmp_line, tmp_line_len, 1);
     705           0 :                         zend_hash_next_index_insert(Z_ARRVAL_P(response_header), &http_response, sizeof(zval *), NULL);
     706             :                 }
     707             :         } else {
     708           0 :                 php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "HTTP request failed, unexpected end of socket!");
     709           0 :                 goto out;
     710             :         }
     711             :         
     712             :         /* read past HTTP headers */
     713             :         
     714           0 :         http_header_line = emalloc(HTTP_HEADER_BLOCK_SIZE);
     715             : 
     716           0 :         while (!body && !php_stream_eof(stream)) {
     717             :                 size_t http_header_line_length;
     718           0 :                 if (php_stream_get_line(stream, http_header_line, HTTP_HEADER_BLOCK_SIZE, &http_header_line_length) && *http_header_line != '\n' && *http_header_line != '\r') {
     719           0 :                         char *e = http_header_line + http_header_line_length - 1;
     720           0 :                         if (*e != '\n') {
     721             :                                 do { /* partial header */
     722           0 :                                         if (php_stream_get_line(stream, http_header_line, HTTP_HEADER_BLOCK_SIZE, &http_header_line_length) == NULL) {
     723           0 :                                                 php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Failed to read HTTP headers");
     724           0 :                                                 goto out;
     725             :                                         }
     726           0 :                                         e = http_header_line + http_header_line_length - 1;
     727           0 :                                 } while (*e != '\n');
     728           0 :                                 continue;
     729             :                         }
     730           0 :                         while (*e == '\n' || *e == '\r') {
     731           0 :                                 e--;
     732             :                         }
     733           0 :                         http_header_line_length = e - http_header_line + 1;
     734           0 :                         http_header_line[http_header_line_length] = '\0';
     735             : 
     736           0 :                         if (!strncasecmp(http_header_line, "Location: ", 10)) {
     737           0 :                                 if (context && php_stream_context_get_option(context, "http", "follow_location", &tmpzval) == SUCCESS) {
     738           0 :                                         SEPARATE_ZVAL(tmpzval);
     739           0 :                                         convert_to_long_ex(tmpzval);
     740           0 :                                         follow_location = Z_LVAL_PP(tmpzval);
     741             :                                 }
     742           0 :                                 strlcpy(location, http_header_line + 10, sizeof(location));
     743           0 :                         } else if (!strncasecmp(http_header_line, "Content-Type: ", 14)) {
     744           0 :                                 php_stream_notify_info(context, PHP_STREAM_NOTIFY_MIME_TYPE_IS, http_header_line + 14, 0);
     745           0 :                         } else if (!strncasecmp(http_header_line, "Content-Length: ", 16)) {
     746           0 :                                 file_size = atoi(http_header_line + 16);
     747           0 :                                 php_stream_notify_file_size(context, file_size, http_header_line, 0);
     748           0 :                         } else if (!strncasecmp(http_header_line, "Transfer-Encoding: chunked", sizeof("Transfer-Encoding: chunked"))) {
     749             : 
     750             :                                 /* create filter to decode response body */
     751           0 :                                 if (!(options & STREAM_ONLY_GET_HEADERS)) {
     752           0 :                                         long decode = 1;
     753             : 
     754           0 :                                         if (context && php_stream_context_get_option(context, "http", "auto_decode", &tmpzval) == SUCCESS) {
     755           0 :                                                 SEPARATE_ZVAL(tmpzval);
     756           0 :                                                 convert_to_boolean(*tmpzval);
     757           0 :                                                 decode = Z_LVAL_PP(tmpzval);
     758             :                                         }
     759           0 :                                         if (decode) {
     760           0 :                                                 transfer_encoding = php_stream_filter_create("dechunk", NULL, php_stream_is_persistent(stream) TSRMLS_CC);
     761           0 :                                                 if (transfer_encoding) {
     762             :                                                         /* don't store transfer-encodeing header */
     763           0 :                                                         continue;
     764             :                                                 }
     765             :                                         }
     766             :                                 }
     767             :                         }
     768             : 
     769           0 :                         if (http_header_line[0] == '\0') {
     770           0 :                                 body = 1;
     771             :                         } else {
     772             :                                 zval *http_header;
     773             : 
     774           0 :                                 MAKE_STD_ZVAL(http_header);
     775             : 
     776           0 :                                 ZVAL_STRINGL(http_header, http_header_line, http_header_line_length, 1);
     777             :                                 
     778           0 :                                 zend_hash_next_index_insert(Z_ARRVAL_P(response_header), &http_header, sizeof(zval *), NULL);
     779             :                         }
     780             :                 } else {
     781             :                         break;
     782             :                 }
     783             :         }
     784             : 
     785           0 :         if (!reqok || (location[0] != '\0' && follow_location)) {
     786           0 :                 if (!follow_location || (((options & STREAM_ONLY_GET_HEADERS) || ignore_errors) && redirect_max <= 1)) {
     787             :                         goto out;
     788             :                 }
     789             : 
     790           0 :                 if (location[0] != '\0')
     791           0 :                         php_stream_notify_info(context, PHP_STREAM_NOTIFY_REDIRECTED, location, 0);
     792             : 
     793           0 :                 php_stream_close(stream);
     794           0 :                 stream = NULL;
     795             : 
     796           0 :                 if (location[0] != '\0') {
     797             : 
     798             :                         char new_path[HTTP_HEADER_BLOCK_SIZE];
     799             :                         char loc_path[HTTP_HEADER_BLOCK_SIZE];
     800             : 
     801           0 :                         *new_path='\0';
     802           0 :                         if (strlen(location)<8 || (strncasecmp(location, "http://", sizeof("http://")-1) && 
     803           0 :                                                         strncasecmp(location, "https://", sizeof("https://")-1) && 
     804           0 :                                                         strncasecmp(location, "ftp://", sizeof("ftp://")-1) && 
     805           0 :                                                         strncasecmp(location, "ftps://", sizeof("ftps://")-1))) 
     806             :                         {
     807           0 :                                 if (*location != '/') {
     808           0 :                                         if (*(location+1) != '\0' && resource->path) {
     809           0 :                                                 char *s = strrchr(resource->path, '/');
     810           0 :                                                 if (!s) {
     811           0 :                                                         s = resource->path;
     812           0 :                                                         if (!s[0]) {
     813           0 :                                                                 efree(s);
     814           0 :                                                                 s = resource->path = estrdup("/");
     815             :                                                         } else {
     816           0 :                                                                 *s = '/';
     817             :                                                         }
     818             :                                                 }
     819           0 :                                                 s[1] = '\0'; 
     820           0 :                                                 if (resource->path && *(resource->path) == '/' && *(resource->path + 1) == '\0') {
     821           0 :                                                         snprintf(loc_path, sizeof(loc_path) - 1, "%s%s", resource->path, location);
     822             :                                                 } else {
     823           0 :                                                         snprintf(loc_path, sizeof(loc_path) - 1, "%s/%s", resource->path, location);
     824             :                                                 }
     825             :                                         } else {
     826           0 :                                                 snprintf(loc_path, sizeof(loc_path) - 1, "/%s", location);
     827             :                                         }
     828             :                                 } else {
     829           0 :                                         strlcpy(loc_path, location, sizeof(loc_path));
     830             :                                 }
     831           0 :                                 if ((use_ssl && resource->port != 443) || (!use_ssl && resource->port != 80)) {
     832           0 :                                         snprintf(new_path, sizeof(new_path) - 1, "%s://%s:%d%s", resource->scheme, resource->host, resource->port, loc_path);
     833             :                                 } else {
     834           0 :                                         snprintf(new_path, sizeof(new_path) - 1, "%s://%s%s", resource->scheme, resource->host, loc_path);
     835             :                                 }
     836             :                         } else {
     837           0 :                                 strlcpy(new_path, location, sizeof(new_path));
     838             :                         }
     839             : 
     840           0 :                         php_url_free(resource);
     841             :                         /* check for invalid redirection URLs */
     842           0 :                         if ((resource = php_url_parse(new_path)) == NULL) {
     843           0 :                                 php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Invalid redirect URL! %s", new_path);
     844           0 :                                 goto out;
     845             :                         }
     846             : 
     847             : #define CHECK_FOR_CNTRL_CHARS(val) { \
     848             :         if (val) { \
     849             :                 unsigned char *s, *e; \
     850             :                 int l; \
     851             :                 l = php_url_decode(val, strlen(val)); \
     852             :                 s = (unsigned char*)val; e = s + l; \
     853             :                 while (s < e) { \
     854             :                         if (iscntrl(*s)) { \
     855             :                                 php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Invalid redirect URL! %s", new_path); \
     856             :                                 goto out; \
     857             :                         } \
     858             :                         s++; \
     859             :                 } \
     860             :         } \
     861             : }
     862             :                         /* check for control characters in login, password & path */
     863           0 :                         if (strncasecmp(new_path, "http://", sizeof("http://") - 1) || strncasecmp(new_path, "https://", sizeof("https://") - 1)) {
     864           0 :                                 CHECK_FOR_CNTRL_CHARS(resource->user)
     865           0 :                                 CHECK_FOR_CNTRL_CHARS(resource->pass)
     866           0 :                                 CHECK_FOR_CNTRL_CHARS(resource->path)
     867             :                         }
     868           0 :                         stream = php_stream_url_wrap_http_ex(wrapper, new_path, mode, options, opened_path, context, --redirect_max, HTTP_WRAPPER_REDIRECTED STREAMS_CC TSRMLS_CC);
     869             :                 } else {
     870           0 :                         php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "HTTP request failed! %s", tmp_line);
     871             :                 }
     872             :         }
     873             : out:
     874           0 :         if (protocol_version) {
     875           0 :                 efree(protocol_version);
     876             :         }
     877             : 
     878           0 :         if (http_header_line) {
     879           0 :                 efree(http_header_line);
     880             :         }
     881             : 
     882           0 :         if (scratch) {
     883           0 :                 efree(scratch);
     884             :         }
     885             : 
     886           0 :         if (resource) {
     887           0 :                 php_url_free(resource);
     888             :         }
     889             : 
     890           0 :         if (stream) {
     891           0 :                 if (header_init) {
     892           0 :                         zval_add_ref(&response_header);
     893           0 :                         stream->wrapperdata = response_header;
     894             :                 }
     895           0 :                 php_stream_notify_progress_init(context, 0, file_size);
     896             :                 
     897             :                 /* Restore original chunk size now that we're done with headers */
     898           0 :                 if (options & STREAM_WILL_CAST)
     899           0 :                         php_stream_set_chunk_size(stream, chunk_size);
     900             : 
     901             :                 /* restore the users auto-detect-line-endings setting */
     902           0 :                 stream->flags |= eol_detect;
     903             :                 
     904             :                 /* as far as streams are concerned, we are now at the start of
     905             :                  * the stream */
     906           0 :                 stream->position = 0;
     907             : 
     908             :                 /* restore mode */
     909           0 :                 strlcpy(stream->mode, mode, sizeof(stream->mode));
     910             : 
     911           0 :                 if (transfer_encoding) {
     912           0 :                         php_stream_filter_append(&stream->readfilters, transfer_encoding);
     913             :                 }
     914           0 :         } else if (transfer_encoding) {
     915           0 :                 php_stream_filter_free(transfer_encoding TSRMLS_CC);
     916             :         }
     917             : 
     918           0 :         return stream;
     919             : }
     920             : /* }}} */
     921             : 
     922           0 : php_stream *php_stream_url_wrap_http(php_stream_wrapper *wrapper, char *path, char *mode, int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC) /* {{{ */
     923             : {
     924           0 :         return php_stream_url_wrap_http_ex(wrapper, path, mode, options, opened_path, context, PHP_URL_REDIRECT_MAX, HTTP_WRAPPER_HEADER_INIT STREAMS_CC TSRMLS_CC);
     925             : }
     926             : /* }}} */
     927             : 
     928           0 : static int php_stream_http_stream_stat(php_stream_wrapper *wrapper, php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC) /* {{{ */
     929             : {
     930             :         /* one day, we could fill in the details based on Date: and Content-Length:
     931             :          * headers.  For now, we return with a failure code to prevent the underlying
     932             :          * file's details from being used instead. */
     933           0 :         return -1;
     934             : }
     935             : /* }}} */
     936             : 
     937             : static php_stream_wrapper_ops http_stream_wops = {
     938             :         php_stream_url_wrap_http,
     939             :         NULL, /* stream_close */
     940             :         php_stream_http_stream_stat,
     941             :         NULL, /* stat_url */
     942             :         NULL, /* opendir */
     943             :         "http",
     944             :         NULL, /* unlink */
     945             :         NULL, /* rename */
     946             :         NULL, /* mkdir */
     947             :         NULL  /* rmdir */
     948             : };
     949             : 
     950             : PHPAPI php_stream_wrapper php_stream_http_wrapper = {
     951             :         &http_stream_wops,
     952             :         NULL,
     953             :         1 /* is_url */
     954             : };
     955             : 
     956             : /*
     957             :  * Local variables:
     958             :  * tab-width: 4
     959             :  * c-basic-offset: 4
     960             :  * End:
     961             :  * vim600: sw=4 ts=4 fdm=marker
     962             :  * vim<600: sw=4 ts=4
     963             :  */

Generated by: LCOV version 1.10

Generated at Fri, 18 Apr 2014 07:01:36 +0000 (26 hours ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.