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 - url.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 323 365 88.5 %
Date: 2014-10-22 Functions: 15 16 93.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 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             :    | Author: Jim Winstead <jimw@php.net>                                  |
      16             :    +----------------------------------------------------------------------+
      17             :  */
      18             : /* $Id$ */
      19             : 
      20             : #include <stdlib.h>
      21             : #include <string.h>
      22             : #include <ctype.h>
      23             : #include <sys/types.h>
      24             : 
      25             : #include "php.h"
      26             : 
      27             : #include "url.h"
      28             : #include "file.h"
      29             : #ifdef _OSD_POSIX
      30             : #ifndef APACHE
      31             : #error On this EBCDIC platform, PHP is only supported as an Apache module.
      32             : #else /*APACHE*/
      33             : #ifndef CHARSET_EBCDIC
      34             : #define CHARSET_EBCDIC /* this machine uses EBCDIC, not ASCII! */
      35             : #endif
      36             : #include "ebcdic.h"
      37             : #endif /*APACHE*/
      38             : #endif /*_OSD_POSIX*/
      39             : 
      40             : /* {{{ free_url
      41             :  */
      42        3861 : PHPAPI void php_url_free(php_url *theurl)
      43             : {
      44        3861 :         if (theurl->scheme)
      45        2408 :                 efree(theurl->scheme);
      46        3861 :         if (theurl->user)
      47         137 :                 efree(theurl->user);
      48        3861 :         if (theurl->pass)
      49          87 :                 efree(theurl->pass);
      50        3861 :         if (theurl->host)
      51        3466 :                 efree(theurl->host);
      52        3861 :         if (theurl->path)
      53        2525 :                 efree(theurl->path);
      54        3861 :         if (theurl->query)
      55         244 :                 efree(theurl->query);
      56        3861 :         if (theurl->fragment)
      57         125 :                 efree(theurl->fragment);
      58        3861 :         efree(theurl);
      59        3861 : }
      60             : /* }}} */
      61             : 
      62             : /* {{{ php_replace_controlchars
      63             :  */
      64        4752 : PHPAPI char *php_replace_controlchars_ex(char *str, int len)
      65             : {
      66        4752 :         unsigned char *s = (unsigned char *)str;
      67        4752 :         unsigned char *e = (unsigned char *)str + len;
      68             :         
      69        4752 :         if (!str) {
      70           0 :                 return (NULL);
      71             :         }
      72             :         
      73       50530 :         while (s < e) {
      74             :             
      75       41026 :                 if (iscntrl(*s)) {
      76           0 :                         *s='_';
      77             :                 }       
      78       41026 :                 s++;
      79             :         }
      80             :         
      81        4752 :         return (str);
      82             : } 
      83             : /* }}} */
      84             : 
      85           0 : PHPAPI char *php_replace_controlchars(char *str)
      86             : {
      87           0 :         return php_replace_controlchars_ex(str, strlen(str));
      88             : } 
      89             : 
      90         401 : PHPAPI php_url *php_url_parse(char const *str)
      91             : {
      92         401 :         return php_url_parse_ex(str, strlen(str));
      93             : }
      94             : 
      95             : /* {{{ php_url_parse
      96             :  */
      97        2697 : PHPAPI php_url *php_url_parse_ex(char const *str, int length)
      98             : {
      99             :         char port_buf[6];
     100        2697 :         php_url *ret = ecalloc(1, sizeof(php_url));
     101             :         char const *s, *e, *p, *pp, *ue;
     102             :                 
     103        2697 :         s = str;
     104        2697 :         ue = s + length;
     105             : 
     106             :         /* parse scheme */
     107        3778 :         if ((e = memchr(s, ':', length)) && (e - s)) {
     108             :                 /* validate scheme */
     109        2474 :                 p = s;
     110       22007 :                 while (p < e) {
     111             :                         /* scheme = 1*[ lowalpha | digit | "+" | "-" | "." ] */
     112       17075 :                         if (!isalpha(*p) && !isdigit(*p) && *p != '+' && *p != '.' && *p != '-') {
     113          16 :                                 if (e + 1 < ue) {
     114          16 :                                         goto parse_port;
     115             :                                 } else {
     116           0 :                                         goto just_path;
     117             :                                 }
     118             :                         }
     119       17059 :                         p++;
     120             :                 }
     121             :         
     122        2458 :                 if (*(e + 1) == '\0') { /* only scheme is available */
     123          11 :                         ret->scheme = estrndup(s, (e - s));
     124          11 :                         php_replace_controlchars_ex(ret->scheme, (e - s));
     125          11 :                         goto end;
     126             :                 }
     127             : 
     128             :                 /* 
     129             :                  * certain schemas like mailto: and zlib: may not have any / after them
     130             :                  * this check ensures we support those.
     131             :                  */
     132        2447 :                 if (*(e+1) != '/') {
     133             :                         /* check if the data we get is a port this allows us to 
     134             :                          * correctly parse things like a.com:80
     135             :                          */
     136        1270 :                         p = e + 1;
     137        7603 :                         while (isdigit(*p)) {
     138        5063 :                                 p++;
     139             :                         }
     140             :                         
     141        1270 :                         if ((*p == '\0' || *p == '/') && (p - e) < 7) {
     142        1215 :                                 goto parse_port;
     143             :                         }
     144             :                         
     145          55 :                         ret->scheme = estrndup(s, (e-s));
     146          55 :                         php_replace_controlchars_ex(ret->scheme, (e - s));
     147             :                         
     148          55 :                         length -= ++e - s;
     149          55 :                         s = e;
     150          55 :                         goto just_path;
     151             :                 } else {
     152        1177 :                         ret->scheme = estrndup(s, (e-s));
     153        1177 :                         php_replace_controlchars_ex(ret->scheme, (e - s));
     154             :                 
     155        1177 :                         if (*(e+2) == '/') {
     156        1146 :                                 s = e + 3;
     157        1146 :                                 if (!strncasecmp("file", ret->scheme, sizeof("file"))) {
     158          76 :                                         if (*(e + 3) == '/') {
     159             :                                                 /* support windows drive letters as in:
     160             :                                                    file:///c:/somedir/file.txt
     161             :                                                 */
     162          65 :                                                 if (*(e + 5) == ':') {
     163          27 :                                                         s = e + 4;
     164             :                                                 }
     165          65 :                                                 goto nohost;
     166             :                                         }
     167             :                                 }
     168             :                         } else {
     169          31 :                                 if (!strncasecmp("file", ret->scheme, sizeof("file"))) {
     170          10 :                                         s = e + 1;
     171          10 :                                         goto nohost;
     172             :                                 } else {
     173          21 :                                         length -= ++e - s;
     174          21 :                                         s = e;
     175          21 :                                         goto just_path;
     176             :                                 }       
     177             :                         }
     178             :                 }       
     179         223 :         } else if (e) { /* no scheme; starts with colon: look for port */
     180             :                 parse_port:
     181        1232 :                 p = e + 1;
     182        1232 :                 pp = p;
     183             : 
     184        7465 :                 while (pp-p < 6 && isdigit(*pp)) {
     185        5001 :                         pp++;
     186             :                 }
     187             : 
     188        2449 :                 if (pp - p > 0 && pp - p < 6 && (*pp == '/' || *pp == '\0')) {
     189             :                         zend_long port;
     190        1217 :                         memcpy(port_buf, p, (pp - p));
     191        1217 :                         port_buf[pp - p] = '\0';
     192        1217 :                         port = ZEND_STRTOL(port_buf, NULL, 10);
     193        2434 :                         if (port > 0 && port <= 65535) {
     194        1217 :                                 ret->port = (unsigned short) port;
     195             :                         } else {
     196           0 :                                 if (ret->scheme) efree(ret->scheme);
     197           0 :                                 efree(ret);
     198           0 :                                 return NULL;
     199             :                         }
     200          15 :                 } else if (p == pp && *pp == '\0') {
     201           1 :                         if (ret->scheme) efree(ret->scheme);
     202           1 :                         efree(ret);
     203           1 :                         return NULL;
     204          14 :                 } else if (*s == '/' && *(s+1) == '/') { /* relative-scheme URL */
     205           1 :                         s += 2;
     206             :                 } else {
     207             :                         goto just_path;
     208             :                 }
     209         224 :         } else if (*s == '/' && *(s+1) == '/') { /* relative-scheme URL */
     210           2 :                 s += 2;
     211             :         } else {
     212             :                 just_path:
     213         309 :                 ue = s + length;
     214         309 :                 goto nohost;
     215             :         }
     216             :         
     217        2301 :         e = ue;
     218             :         
     219        2301 :         if (!(p = memchr(s, '/', (ue - s)))) {
     220             :                 char *query, *fragment;
     221             : 
     222        1675 :                 query = memchr(s, '?', (ue - s));
     223        1675 :                 fragment = memchr(s, '#', (ue - s));
     224             : 
     225        1675 :                 if (query && fragment) {
     226           0 :                         if (query > fragment) {
     227           0 :                                 e = fragment;
     228             :                         } else {
     229           0 :                                 e = query;
     230             :                         }
     231        1675 :                 } else if (query) {
     232          55 :                         e = query;
     233        1620 :                 } else if (fragment) {
     234          28 :                         e = fragment;
     235             :                 }
     236             :         } else {
     237         626 :                 e = p;
     238             :         }       
     239             :                 
     240             :         /* check for login and password */
     241        4602 :         if ((p = zend_memrchr(s, '@', (e-s)))) {
     242         173 :                 if ((pp = memchr(s, ':', (p-s)))) {
     243          96 :                         ret->user = estrndup(s, (pp-s));
     244          96 :                         php_replace_controlchars_ex(ret->user, (pp - s));
     245             :                 
     246          96 :                         pp++;
     247          96 :                         ret->pass = estrndup(pp, (p-pp));
     248          96 :                         php_replace_controlchars_ex(ret->pass, (p-pp));
     249             :                 } else {
     250          77 :                         ret->user = estrndup(s, (p-s));
     251          77 :                         php_replace_controlchars_ex(ret->user, (p-s));
     252             :                 }
     253             :                 
     254         173 :                 s = p + 1;
     255             :         }
     256             : 
     257             :         /* check for port */
     258        2310 :         if (*s == '[' && *(e-1) == ']') {
     259             :                 /* Short circuit portscan, 
     260             :                    we're dealing with an 
     261             :                    IPv6 embedded address */
     262           9 :                 p = s;
     263             :         } else {
     264             :                 /* memrchr is a GNU specific extension
     265             :                    Emulate for wide compatibility */
     266        2292 :                 for(p = e; p >= s && *p != ':'; p--);
     267             :         }
     268             : 
     269        4000 :         if (p >= s && *p == ':') {
     270        1730 :                 if (!ret->port) {
     271         513 :                         p++;
     272         513 :                         if (e-p > 5) { /* port cannot be longer then 5 characters */
     273          18 :                                 if (ret->scheme) efree(ret->scheme);
     274          18 :                                 if (ret->user) efree(ret->user);
     275          18 :                                 if (ret->pass) efree(ret->pass);
     276          18 :                                 efree(ret);
     277          18 :                                 return NULL;
     278         495 :                         } else if (e - p > 0) {
     279             :                                 zend_long port;
     280         404 :                                 memcpy(port_buf, p, (e - p));
     281         404 :                                 port_buf[e - p] = '\0';
     282         404 :                                 port = ZEND_STRTOL(port_buf, NULL, 10);
     283         795 :                                 if (port > 0 && port <= 65535) {
     284         391 :                                         ret->port = (unsigned short)port;
     285             :                                 } else {
     286          13 :                                         if (ret->scheme) efree(ret->scheme);
     287          13 :                                         if (ret->user) efree(ret->user);
     288          13 :                                         if (ret->pass) efree(ret->pass);
     289          13 :                                         efree(ret);
     290          13 :                                         return NULL;
     291             :                                 }
     292             :                         }
     293         482 :                         p--;
     294             :                 }       
     295             :         } else {
     296         571 :                 p = e;
     297             :         }
     298             :         
     299             :         /* check if we have a valid host, if we don't reject the string as url */
     300        2270 :         if ((p-s) < 1) {
     301         364 :                 if (ret->scheme) efree(ret->scheme);
     302         364 :                 if (ret->user) efree(ret->user);
     303         364 :                 if (ret->pass) efree(ret->pass);
     304         364 :                 efree(ret);
     305         364 :                 return NULL;
     306             :         }
     307             : 
     308        1906 :         ret->host = estrndup(s, (p-s));
     309        1906 :         php_replace_controlchars_ex(ret->host, (p - s));
     310             :         
     311        1906 :         if (e == ue) {
     312        1278 :                 return ret;
     313             :         }
     314             :         
     315         628 :         s = e;
     316             :         
     317             :         nohost:
     318             :         
     319        1012 :         if ((p = memchr(s, '?', (ue - s)))) {
     320         323 :                 pp = strchr(s, '#');
     321             : 
     322         323 :                 if (pp && pp < p) {
     323           1 :                         if (pp - s) {
     324           1 :                                 ret->path = estrndup(s, (pp-s));
     325           1 :                                 php_replace_controlchars_ex(ret->path, (pp - s));
     326             :                         }
     327           1 :                         p = pp;
     328           1 :                         goto label_parse;
     329             :                 }
     330             :         
     331         322 :                 if (p - s) {
     332         294 :                         ret->path = estrndup(s, (p-s));
     333         294 :                         php_replace_controlchars_ex(ret->path, (p - s));
     334             :                 }       
     335             :         
     336         322 :                 if (pp) {
     337         114 :                         if (pp - ++p) { 
     338         104 :                                 ret->query = estrndup(p, (pp-p));
     339         104 :                                 php_replace_controlchars_ex(ret->query, (pp - p));
     340             :                         }
     341         114 :                         p = pp;
     342         114 :                         goto label_parse;
     343         208 :                 } else if (++p - ue) {
     344         140 :                         ret->query = estrndup(p, (ue-p));
     345         140 :                         php_replace_controlchars_ex(ret->query, (ue - p));
     346             :                 }
     347         689 :         } else if ((p = memchr(s, '#', (ue - s)))) {
     348          29 :                 if (p - s) {
     349          10 :                         ret->path = estrndup(s, (p-s));
     350          10 :                         php_replace_controlchars_ex(ret->path, (p - s));
     351             :                 }       
     352             :                 
     353             :                 label_parse:
     354         144 :                 p++;
     355             :                 
     356         144 :                 if (ue - p) {
     357         125 :                         ret->fragment = estrndup(p, (ue-p));
     358         125 :                         php_replace_controlchars_ex(ret->fragment, (ue - p));
     359             :                 }       
     360             :         } else {
     361         660 :                 ret->path = estrndup(s, (ue-s));
     362         660 :                 php_replace_controlchars_ex(ret->path, (ue - s));
     363             :         }
     364             : end:
     365        1023 :         return ret;
     366             : }
     367             : /* }}} */
     368             : 
     369             : /* {{{ proto mixed parse_url(string url, [int url_component])
     370             :    Parse a URL and return its components */
     371        1077 : PHP_FUNCTION(parse_url)
     372             : {
     373             :         char *str;
     374             :         size_t str_len;
     375             :         php_url *resource;
     376        1077 :         zend_long key = -1;
     377             : 
     378        1077 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, &key) == FAILURE) {
     379          18 :                 return;
     380             :         }
     381             : 
     382        1059 :         resource = php_url_parse_ex(str, str_len);
     383        1059 :         if (resource == NULL) {
     384             :                 /* @todo Find a method to determine why php_url_parse_ex() failed */
     385         136 :                 RETURN_FALSE;
     386             :         }
     387             : 
     388         923 :         if (key > -1) {
     389         725 :                 switch (key) {
     390             :                         case PHP_URL_SCHEME:
     391         177 :                                 if (resource->scheme != NULL) RETVAL_STRING(resource->scheme);
     392          97 :                                 break;
     393             :                         case PHP_URL_HOST:
     394         153 :                                 if (resource->host != NULL) RETVAL_STRING(resource->host);
     395          91 :                                 break;
     396             :                         case PHP_URL_PORT:
     397          89 :                                 if (resource->port != 0) RETVAL_LONG(resource->port);
     398          89 :                                 break;
     399             :                         case PHP_URL_USER:
     400         101 :                                 if (resource->user != NULL) RETVAL_STRING(resource->user);
     401          89 :                                 break;
     402             :                         case PHP_URL_PASS:
     403          96 :                                 if (resource->pass != NULL) RETVAL_STRING(resource->pass);
     404          89 :                                 break;
     405             :                         case PHP_URL_PATH:
     406         164 :                                 if (resource->path != NULL) RETVAL_STRING(resource->path);
     407          89 :                                 break;
     408             :                         case PHP_URL_QUERY:
     409         112 :                                 if (resource->query != NULL) RETVAL_STRING(resource->query);
     410          89 :                                 break;
     411             :                         case PHP_URL_FRAGMENT:
     412         100 :                                 if (resource->fragment != NULL) RETVAL_STRING(resource->fragment);
     413          89 :                                 break;
     414             :                         default:
     415           3 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid URL component identifier " ZEND_LONG_FMT, key);
     416           3 :                                 RETVAL_FALSE;
     417             :                 }
     418         725 :                 goto done;
     419             :         }
     420             : 
     421             :         /* allocate an array for return */
     422         198 :         array_init(return_value);
     423             : 
     424             :     /* add the various elements to the array */
     425         198 :         if (resource->scheme != NULL)
     426         145 :                 add_assoc_string(return_value, "scheme", resource->scheme);
     427         198 :         if (resource->host != NULL)
     428         132 :                 add_assoc_string(return_value, "host", resource->host);
     429         198 :         if (resource->port != 0)
     430          63 :                 add_assoc_long(return_value, "port", resource->port);
     431         198 :         if (resource->user != NULL)
     432          26 :                 add_assoc_string(return_value, "user", resource->user);
     433         198 :         if (resource->pass != NULL)
     434          16 :                 add_assoc_string(return_value, "pass", resource->pass);
     435         198 :         if (resource->path != NULL)
     436         166 :                 add_assoc_string(return_value, "path", resource->path);
     437         198 :         if (resource->query != NULL)
     438          46 :                 add_assoc_string(return_value, "query", resource->query);
     439         198 :         if (resource->fragment != NULL)
     440          24 :                 add_assoc_string(return_value, "fragment", resource->fragment);
     441             : done:   
     442         923 :         php_url_free(resource);
     443             : }
     444             : /* }}} */
     445             : 
     446             : /* {{{ php_htoi
     447             :  */
     448         127 : static int php_htoi(char *s)
     449             : {
     450             :         int value;
     451             :         int c;
     452             : 
     453         127 :         c = ((unsigned char *)s)[0];
     454         127 :         if (isupper(c))
     455           3 :                 c = tolower(c);
     456         127 :         value = (c >= '0' && c <= '9' ? c - '0' : c - 'a' + 10) * 16;
     457             : 
     458         127 :         c = ((unsigned char *)s)[1];
     459         127 :         if (isupper(c))
     460          51 :                 c = tolower(c);
     461         127 :         value += c >= '0' && c <= '9' ? c - '0' : c - 'a' + 10;
     462             : 
     463         127 :         return (value);
     464             : }
     465             : /* }}} */
     466             : 
     467             : /* rfc1738:
     468             : 
     469             :    ...The characters ";",
     470             :    "/", "?", ":", "@", "=" and "&" are the characters which may be
     471             :    reserved for special meaning within a scheme...
     472             : 
     473             :    ...Thus, only alphanumerics, the special characters "$-_.+!*'(),", and
     474             :    reserved characters used for their reserved purposes may be used
     475             :    unencoded within a URL...
     476             : 
     477             :    For added safety, we only leave -_. unencoded.
     478             :  */
     479             : 
     480             : static unsigned char hexchars[] = "0123456789ABCDEF";
     481             : 
     482             : /* {{{ php_url_encode
     483             :  */
     484        2151 : PHPAPI zend_string *php_url_encode(char const *s, int len)
     485             : {
     486             :         register unsigned char c;
     487             :         unsigned char *to;
     488             :         unsigned char const *from, *end;
     489             :         zend_string *start;
     490             :         
     491        2151 :         from = (unsigned char *)s;
     492        2151 :         end = (unsigned char *)s + len;
     493        4302 :         start = zend_string_alloc(3 * len, 0);
     494        2151 :         to = (unsigned char*)start->val;
     495             : 
     496       24353 :         while (from < end) {
     497       20051 :                 c = *from++;
     498             : 
     499       20051 :                 if (c == ' ') {
     500          16 :                         *to++ = '+';
     501             : #ifndef CHARSET_EBCDIC
     502       22518 :                 } else if ((c < '0' && c != '-' && c != '.') ||
     503             :                                    (c < 'A' && c > '9') ||
     504             :                                    (c > 'Z' && c < 'a' && c != '_') ||
     505             :                                    (c > 'z')) {
     506        2483 :                         to[0] = '%';
     507        2483 :                         to[1] = hexchars[c >> 4];
     508        2483 :                         to[2] = hexchars[c & 15];
     509        2483 :                         to += 3;
     510             : #else /*CHARSET_EBCDIC*/
     511             :                 } else if (!isalnum(c) && strchr("_-.", c) == NULL) {
     512             :                         /* Allow only alphanumeric chars and '_', '-', '.'; escape the rest */
     513             :                         to[0] = '%';
     514             :                         to[1] = hexchars[os_toascii[c] >> 4];
     515             :                         to[2] = hexchars[os_toascii[c] & 15];
     516             :                         to += 3;
     517             : #endif /*CHARSET_EBCDIC*/
     518             :                 } else {
     519       17552 :                         *to++ = c;
     520             :                 }
     521             :         }
     522        2151 :         *to = '\0';
     523             : 
     524        4302 :         start = zend_string_realloc(start, to - (unsigned char*)start->val, 0);
     525             : 
     526        2151 :         return start;
     527             : }
     528             : /* }}} */
     529             : 
     530             : /* {{{ proto string urlencode(string str)
     531             :    URL-encodes string */
     532        1258 : PHP_FUNCTION(urlencode)
     533             : {
     534             :         zend_string *in_str;
     535             : 
     536             : #ifndef FAST_ZPP
     537             :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &in_str) == FAILURE) {
     538             :                 return;
     539             :         }
     540             : #else
     541        1258 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     542        3768 :                 Z_PARAM_STR(in_str)
     543        1258 :         ZEND_PARSE_PARAMETERS_END();
     544             : #endif
     545             : 
     546        1250 :         RETURN_STR(php_url_encode(in_str->val, in_str->len));
     547             : }
     548             : /* }}} */
     549             : 
     550             : /* {{{ proto string urldecode(string str)
     551             :    Decodes URL-encoded string */
     552          31 : PHP_FUNCTION(urldecode)
     553             : {
     554             :         zend_string *in_str, *out_str;
     555             : 
     556             : #ifndef FAST_ZPP
     557             :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &in_str) == FAILURE) {
     558             :                 return;
     559             :         }
     560             : #else
     561          31 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     562          87 :                 Z_PARAM_STR(in_str)
     563          31 :         ZEND_PARSE_PARAMETERS_END();
     564             : #endif
     565             : 
     566          46 :         out_str = zend_string_init(in_str->val, in_str->len, 0);
     567          23 :         out_str->len = php_url_decode(out_str->val, out_str->len);
     568             : 
     569          23 :     RETURN_NEW_STR(out_str);
     570             : }
     571             : /* }}} */
     572             : 
     573             : /* {{{ php_url_decode
     574             :  */
     575         807 : PHPAPI int php_url_decode(char *str, int len)
     576             : {
     577         807 :         char *dest = str;
     578         807 :         char *data = str;
     579             : 
     580       17357 :         while (len--) {
     581       15743 :                 if (*data == '+') {
     582          35 :                         *dest = ' ';
     583             :                 }
     584       15890 :                 else if (*data == '%' && len >= 2 && isxdigit((int) *(data + 1)) 
     585          91 :                                  && isxdigit((int) *(data + 2))) {
     586             : #ifndef CHARSET_EBCDIC
     587          91 :                         *dest = (char) php_htoi(data + 1);
     588             : #else
     589             :                         *dest = os_toebcdic[(char) php_htoi(data + 1)];
     590             : #endif
     591          91 :                         data += 2;
     592          91 :                         len -= 2;
     593             :                 } else {
     594       15617 :                         *dest = *data;
     595             :                 }
     596       15743 :                 data++;
     597       15743 :                 dest++;
     598             :         }
     599         807 :         *dest = '\0';
     600         807 :         return dest - str;
     601             : }
     602             : /* }}} */
     603             : 
     604             : /* {{{ php_raw_url_encode
     605             :  */
     606          28 : PHPAPI zend_string *php_raw_url_encode(char const *s, int len)
     607             : {
     608             :         register int x, y;
     609             :         zend_string *str;
     610             : 
     611          56 :         str = zend_string_alloc(3 * len, 0);
     612         269 :         for (x = 0, y = 0; len--; x++, y++) {
     613         241 :                 str->val[y] = (unsigned char) s[x];
     614             : #ifndef CHARSET_EBCDIC
     615        1053 :                 if ((str->val[y] < '0' && str->val[y] != '-' && str->val[y] != '.') ||
     616         291 :                         (str->val[y] < 'A' && str->val[y] > '9') ||
     617         315 :                         (str->val[y] > 'Z' && str->val[y] < 'a' && str->val[y] != '_') ||
     618         206 :                         (str->val[y] > 'z' && str->val[y] != '~')) {
     619          43 :                         str->val[y++] = '%';
     620          43 :                         str->val[y++] = hexchars[(unsigned char) s[x] >> 4];
     621          43 :                         str->val[y] = hexchars[(unsigned char) s[x] & 15];
     622             : #else /*CHARSET_EBCDIC*/
     623             :                 if (!isalnum(str->val[y]) && str->valchr("_-.~", str->val[y]) != NULL) {
     624             :                         str->val[y++] = '%';
     625             :                         str->val[y++] = hexchars[os_toascii[(unsigned char) s[x]] >> 4];
     626             :                         str->val[y] = hexchars[os_toascii[(unsigned char) s[x]] & 15];
     627             : #endif /*CHARSET_EBCDIC*/
     628             :                 }
     629             :         }
     630          28 :         str->val[y] = '\0';
     631          56 :         str = zend_string_realloc(str, y, 0);
     632             : 
     633          28 :         return str;
     634             : }
     635             : /* }}} */
     636             : 
     637             : /* {{{ proto string rawurlencode(string str)
     638             :    URL-encodes string */
     639          30 : PHP_FUNCTION(rawurlencode)
     640             : {
     641             :         zend_string *in_str;
     642             : 
     643             : #ifndef FAST_ZPP
     644             :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &in_str) == FAILURE) {
     645             :                 return;
     646             :         }
     647             : #else
     648          30 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     649          84 :                 Z_PARAM_STR(in_str)
     650          30 :         ZEND_PARSE_PARAMETERS_END();
     651             : #endif
     652             : 
     653          22 :         RETURN_STR(php_raw_url_encode(in_str->val, in_str->len));
     654             : }
     655             : /* }}} */
     656             : 
     657             : /* {{{ proto string rawurldecode(string str)
     658             :    Decodes URL-encodes string */
     659          29 : PHP_FUNCTION(rawurldecode)
     660             : {
     661             :         zend_string *in_str, *out_str;
     662             : 
     663             : #ifndef FAST_ZPP
     664             :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &in_str) == FAILURE) {
     665             :                 return;
     666             :         }
     667             : #else
     668          29 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     669          81 :                 Z_PARAM_STR(in_str)
     670          29 :         ZEND_PARSE_PARAMETERS_END();
     671             : #endif
     672             : 
     673          42 :         out_str = zend_string_init(in_str->val, in_str->len, 0);
     674          21 :         out_str->len = php_raw_url_decode(out_str->val, out_str->len);
     675             : 
     676          21 :     RETURN_NEW_STR(out_str);
     677             : }
     678             : /* }}} */
     679             : 
     680             : /* {{{ php_raw_url_decode
     681             :  */
     682          21 : PHPAPI int php_raw_url_decode(char *str, int len)
     683             : {
     684          21 :         char *dest = str;
     685          21 :         char *data = str;
     686             : 
     687         195 :         while (len--) {
     688         225 :                 if (*data == '%' && len >= 2 && isxdigit((int) *(data + 1)) 
     689          36 :                         && isxdigit((int) *(data + 2))) {
     690             : #ifndef CHARSET_EBCDIC
     691          36 :                         *dest = (char) php_htoi(data + 1);
     692             : #else
     693             :                         *dest = os_toebcdic[(char) php_htoi(data + 1)];
     694             : #endif
     695          36 :                         data += 2;
     696          36 :                         len -= 2;
     697             :                 } else {
     698         117 :                         *dest = *data;
     699             :                 }
     700         153 :                 data++;
     701         153 :                 dest++;
     702             :         }
     703          21 :         *dest = '\0';
     704          21 :         return dest - str;
     705             : }
     706             : /* }}} */
     707             : 
     708             : /* {{{ proto array get_headers(string url[, int format])
     709             :    fetches all the headers sent by the server in response to a HTTP request */
     710           5 : PHP_FUNCTION(get_headers)
     711             : {
     712             :         char *url;
     713             :         size_t url_len;
     714             :         php_stream_context *context;
     715             :         php_stream *stream;
     716           5 :         zval *prev_val, *hdr = NULL, *h;
     717             :         HashTable *hashT;
     718           5 :         zend_long format = 0;
     719             :                 
     720           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &url, &url_len, &format) == FAILURE) {
     721           5 :                 return;
     722             :         }
     723           0 :         context = FG(default_context) ? FG(default_context) : (FG(default_context) = php_stream_context_alloc(TSRMLS_C));
     724             : 
     725           0 :         if (!(stream = php_stream_open_wrapper_ex(url, "r", REPORT_ERRORS | STREAM_USE_URL | STREAM_ONLY_GET_HEADERS, NULL, context))) {
     726           0 :                 RETURN_FALSE;
     727             :         }
     728             : 
     729           0 :         if (Z_TYPE(stream->wrapperdata) != IS_ARRAY) {
     730           0 :                 php_stream_close(stream);
     731           0 :                 RETURN_FALSE;
     732             :         }
     733             : 
     734           0 :         array_init(return_value);
     735             : 
     736             :         /* check for curl-wrappers that provide headers via a special "headers" element */
     737           0 :         if ((h = zend_hash_str_find(HASH_OF(&stream->wrapperdata), "headers", sizeof("headers")-1)) != NULL && Z_TYPE_P(h) == IS_ARRAY) {
     738             :                 /* curl-wrappers don't load data until the 1st read */ 
     739           0 :                 if (!Z_ARRVAL_P(h)->nNumOfElements) {
     740           0 :                         php_stream_getc(stream);
     741             :                 }
     742           0 :                 h = zend_hash_str_find(HASH_OF(&stream->wrapperdata), "headers", sizeof("headers")-1);
     743           0 :                 hashT = Z_ARRVAL_P(h);  
     744             :         } else {
     745           0 :                 hashT = HASH_OF(&stream->wrapperdata);
     746             :         }
     747             : 
     748           0 :         ZEND_HASH_FOREACH_VAL(hashT, hdr) {
     749           0 :                 if (Z_TYPE_P(hdr) != IS_STRING) {
     750           0 :                         continue;
     751             :                 }
     752           0 :                 if (!format) {
     753             : no_name_header:
     754           0 :                         add_next_index_str(return_value, zend_string_copy(Z_STR_P(hdr)));
     755             :                 } else {
     756             :                         char c;
     757             :                         char *s, *p;
     758             : 
     759           0 :                         if ((p = strchr(Z_STRVAL_P(hdr), ':'))) {
     760           0 :                                 c = *p;
     761           0 :                                 *p = '\0';
     762           0 :                                 s = p + 1;
     763           0 :                                 while (isspace((int)*(unsigned char *)s)) {
     764           0 :                                         s++;
     765             :                                 }
     766             : 
     767           0 :                                 if ((prev_val = zend_hash_str_find(HASH_OF(return_value), Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr)))) == NULL) {
     768           0 :                                         add_assoc_stringl_ex(return_value, Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr) + 1), s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))));
     769             :                                 } else { /* some headers may occur more then once, therefor we need to remake the string into an array */
     770           0 :                                         convert_to_array(prev_val);
     771           0 :                                         add_next_index_stringl(prev_val, s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))));
     772             :                                 }
     773             : 
     774           0 :                                 *p = c;
     775             :                         } else {
     776           0 :                                 goto no_name_header;
     777             :                         }
     778             :                 }
     779             :         } ZEND_HASH_FOREACH_END();
     780             : 
     781           0 :         php_stream_close(stream);
     782             : }
     783             : /* }}} */
     784             : 
     785             : /*
     786             :  * Local variables:
     787             :  * tab-width: 4
     788             :  * c-basic-offset: 4
     789             :  * End:
     790             :  * vim600: sw=4 ts=4 fdm=marker
     791             :  * vim<600: sw=4 ts=4
     792             :  */

Generated by: LCOV version 1.10

Generated at Wed, 22 Oct 2014 07:24:59 +0000 (18 hours ago)

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