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: 340 375 90.7 %
Date: 2016-08-24 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-2016 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        4312 : PHPAPI void php_url_free(php_url *theurl)
      43             : {
      44        4312 :         if (theurl->scheme)
      45        2431 :                 efree(theurl->scheme);
      46        4312 :         if (theurl->user)
      47         126 :                 efree(theurl->user);
      48        4312 :         if (theurl->pass)
      49          86 :                 efree(theurl->pass);
      50        4312 :         if (theurl->host)
      51        3906 :                 efree(theurl->host);
      52        4312 :         if (theurl->path)
      53        2530 :                 efree(theurl->path);
      54        4312 :         if (theurl->query)
      55         239 :                 efree(theurl->query);
      56        4312 :         if (theurl->fragment)
      57         107 :                 efree(theurl->fragment);
      58        4312 :         efree(theurl);
      59        4312 : }
      60             : /* }}} */
      61             : 
      62             : /* {{{ php_replace_controlchars
      63             :  */
      64        5244 : PHPAPI char *php_replace_controlchars_ex(char *str, size_t len)
      65             : {
      66        5244 :         unsigned char *s = (unsigned char *)str;
      67        5244 :         unsigned char *e = (unsigned char *)str + len;
      68             : 
      69        5244 :         if (!str) {
      70           0 :                 return (NULL);
      71             :         }
      72             : 
      73       56102 :         while (s < e) {
      74             : 
      75       45614 :                 if (iscntrl(*s)) {
      76           0 :                         *s='_';
      77             :                 }
      78       45614 :                 s++;
      79             :         }
      80             : 
      81        5244 :         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         429 : PHPAPI php_url *php_url_parse(char const *str)
      91             : {
      92         429 :         return php_url_parse_ex(str, strlen(str));
      93             : }
      94             : 
      95             : /* {{{ php_url_parse
      96             :  */
      97        3188 : PHPAPI php_url *php_url_parse_ex(char const *str, size_t length)
      98             : {
      99             :         char port_buf[6];
     100        3188 :         php_url *ret = ecalloc(1, sizeof(php_url));
     101             :         char const *s, *e, *p, *pp, *ue;
     102             : 
     103        3188 :         s = str;
     104        3188 :         ue = s + length;
     105             : 
     106             :         /* parse scheme */
     107        4331 :         if ((e = memchr(s, ':', length)) && (e - s)) {
     108             :                 /* validate scheme */
     109        2957 :                 p = s;
     110       26845 :                 while (p < e) {
     111             :                         /* scheme = 1*[ lowalpha | digit | "+" | "-" | "." ] */
     112       20950 :                         if (!isalpha(*p) && !isdigit(*p) && *p != '+' && *p != '.' && *p != '-') {
     113          19 :                                 if (e + 1 < ue && e < s + strcspn(s, "?#")) {
     114             :                                         goto parse_port;
     115             :                                 } else {
     116             :                                         goto just_path;
     117             :                                 }
     118             :                         }
     119       20931 :                         p++;
     120             :                 }
     121             : 
     122        2938 :                 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        2927 :                 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        1688 :                         p = e + 1;
     137       10159 :                         while (isdigit(*p)) {
     138        6783 :                                 p++;
     139             :                         }
     140             : 
     141        1688 :                         if ((*p == '\0' || *p == '/') && (p - e) < 7) {
     142        1633 :                                 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        1239 :                         ret->scheme = estrndup(s, (e-s));
     153        1239 :                         php_replace_controlchars_ex(ret->scheme, (e - s));
     154             : 
     155        1239 :                         if (*(e+2) == '/') {
     156        1208 :                                 s = e + 3;
     157        1208 :                                 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         231 :         } else if (e) { /* no scheme; starts with colon: look for port */
     180             :                 parse_port:
     181        1640 :                 p = e + 1;
     182        1640 :                 pp = p;
     183             : 
     184        9995 :                 while (pp-p < 6 && isdigit(*pp)) {
     185        6715 :                         pp++;
     186             :                 }
     187             : 
     188        3273 :                 if (pp - p > 0 && pp - p < 6 && (*pp == '/' || *pp == '\0')) {
     189             :                         zend_long port;
     190        1634 :                         memcpy(port_buf, p, (pp - p));
     191        1634 :                         port_buf[pp - p] = '\0';
     192        1634 :                         port = ZEND_STRTOL(port_buf, NULL, 10);
     193        3267 :                         if (port > 0 && port <= 65535) {
     194        1633 :                                 ret->port = (unsigned short) port;
     195        1633 :                                 if (*s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
     196           1 :                                     s += 2;
     197             :                                 }
     198             :                         } else {
     199           1 :                                 if (ret->scheme) efree(ret->scheme);
     200           1 :                                 efree(ret);
     201           1 :                                 return NULL;
     202             :                         }
     203           6 :                 } else if (p == pp && *pp == '\0') {
     204           1 :                         if (ret->scheme) efree(ret->scheme);
     205           1 :                         efree(ret);
     206           1 :                         return NULL;
     207           5 :                 } else if (*s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
     208           1 :                         s += 2;
     209             :                 } else {
     210             :                         goto just_path;
     211             :                 }
     212         233 :         } else if (*s == '/' && *(s + 1) == '/') { /* relative-scheme URL */
     213           3 :                 s += 2;
     214             :         } else {
     215             :                 just_path:
     216         320 :                 ue = s + length;
     217         320 :                 goto nohost;
     218             :         }
     219             : 
     220        2780 :         e = ue;
     221             : 
     222        2780 :         if (!(p = memchr(s, '/', (ue - s)))) {
     223             :                 char *query, *fragment;
     224             : 
     225        2130 :                 query = memchr(s, '?', (ue - s));
     226        2130 :                 fragment = memchr(s, '#', (ue - s));
     227             : 
     228        2130 :                 if (query && fragment) {
     229           0 :                         if (query > fragment) {
     230           0 :                                 e = fragment;
     231             :                         } else {
     232           0 :                                 e = query;
     233             :                         }
     234        2130 :                 } else if (query) {
     235          64 :                         e = query;
     236        2066 :                 } else if (fragment) {
     237          28 :                         e = fragment;
     238             :                 }
     239             :         } else {
     240         650 :                 e = p;
     241             :         }
     242             : 
     243             :         /* check for login and password */
     244        5560 :         if ((p = zend_memrchr(s, '@', (e-s)))) {
     245             :                 /* check for invalid chars inside login/pass */
     246         191 :                 pp = s;
     247        1901 :                 while (pp < p) {
     248             :                         /* http://www.rfc-editor.org/rfc/rfc3986.txt ยง3.2.1 */
     249        1548 :                         const char search_rfc3986[] = ":;=!$%_-.~&'()*+,";
     250        1548 :                         if (!isalnum(*pp) && !strchr(search_rfc3986, *pp)) {
     251          29 :                                 if (ret->scheme) {
     252          29 :                                         efree(ret->scheme);
     253             :                                 }
     254          29 :                                 efree(ret);
     255          29 :                                 return NULL;
     256             :                         }
     257        1519 :                         pp++;
     258             :                 }
     259             : 
     260         162 :                 if ((pp = memchr(s, ':', (p-s)))) {
     261          95 :                         ret->user = estrndup(s, (pp-s));
     262          95 :                         php_replace_controlchars_ex(ret->user, (pp - s));
     263             : 
     264          95 :                         pp++;
     265          95 :                         ret->pass = estrndup(pp, (p-pp));
     266          95 :                         php_replace_controlchars_ex(ret->pass, (p-pp));
     267             :                 } else {
     268          67 :                         ret->user = estrndup(s, (p-s));
     269          67 :                         php_replace_controlchars_ex(ret->user, (p-s));
     270             :                 }
     271             : 
     272         162 :                 s = p + 1;
     273             :         }
     274             : 
     275             :         /* check for port */
     276        2763 :         if (*s == '[' && *(e-1) == ']') {
     277             :                 /* Short circuit portscan,
     278             :                    we're dealing with an
     279             :                    IPv6 embedded address */
     280          12 :                 p = s;
     281             :         } else {
     282             :                 /* memrchr is a GNU specific extension
     283             :                    Emulate for wide compatibility */
     284        2739 :                 for(p = e; p >= s && *p != ':'; p--);
     285             :         }
     286             : 
     287        4892 :         if (p >= s && *p == ':') {
     288        2172 :                 if (!ret->port) {
     289         539 :                         p++;
     290         539 :                         if (e-p > 5) { /* port cannot be longer then 5 characters */
     291          18 :                                 if (ret->scheme) efree(ret->scheme);
     292          18 :                                 if (ret->user) efree(ret->user);
     293          18 :                                 if (ret->pass) efree(ret->pass);
     294          18 :                                 efree(ret);
     295          18 :                                 return NULL;
     296         521 :                         } else if (e - p > 0) {
     297             :                                 zend_long port;
     298         430 :                                 memcpy(port_buf, p, (e - p));
     299         430 :                                 port_buf[e - p] = '\0';
     300         430 :                                 port = ZEND_STRTOL(port_buf, NULL, 10);
     301         847 :                                 if (port > 0 && port <= 65535) {
     302         417 :                                         ret->port = (unsigned short)port;
     303             :                                 } else {
     304          13 :                                         if (ret->scheme) efree(ret->scheme);
     305          13 :                                         if (ret->user) efree(ret->user);
     306          13 :                                         if (ret->pass) efree(ret->pass);
     307          13 :                                         efree(ret);
     308          13 :                                         return NULL;
     309             :                                 }
     310             :                         }
     311         508 :                         p--;
     312             :                 }
     313             :         } else {
     314         579 :                 p = e;
     315             :         }
     316             : 
     317             :         /* check if we have a valid host, if we don't reject the string as url */
     318        2720 :         if ((p-s) < 1) {
     319         364 :                 if (ret->scheme) efree(ret->scheme);
     320         364 :                 if (ret->user) efree(ret->user);
     321         364 :                 if (ret->pass) efree(ret->pass);
     322         364 :                 efree(ret);
     323         364 :                 return NULL;
     324             :         }
     325             : 
     326        2356 :         ret->host = estrndup(s, (p-s));
     327        2356 :         php_replace_controlchars_ex(ret->host, (p - s));
     328             : 
     329        2356 :         if (e == ue) {
     330        1715 :                 return ret;
     331             :         }
     332             : 
     333         641 :         s = e;
     334             : 
     335             :         nohost:
     336             : 
     337        1036 :         if ((p = memchr(s, '?', (ue - s)))) {
     338         318 :                 pp = memchr(s, '#', (ue - s));
     339             : 
     340         318 :                 if (pp && pp < p) {
     341           1 :                         if (pp - s) {
     342           1 :                                 ret->path = estrndup(s, (pp-s));
     343           1 :                                 php_replace_controlchars_ex(ret->path, (pp - s));
     344             :                         }
     345           1 :                         p = pp;
     346           1 :                         goto label_parse;
     347             :                 }
     348             : 
     349         317 :                 if (p - s) {
     350         280 :                         ret->path = estrndup(s, (p-s));
     351         280 :                         php_replace_controlchars_ex(ret->path, (p - s));
     352             :                 }
     353             : 
     354         317 :                 if (pp) {
     355          96 :                         if (pp - ++p) {
     356          86 :                                 ret->query = estrndup(p, (pp-p));
     357          86 :                                 php_replace_controlchars_ex(ret->query, (pp - p));
     358             :                         }
     359          96 :                         p = pp;
     360          96 :                         goto label_parse;
     361         221 :                 } else if (++p - ue) {
     362         153 :                         ret->query = estrndup(p, (ue-p));
     363         153 :                         php_replace_controlchars_ex(ret->query, (ue - p));
     364             :                 }
     365         718 :         } else if ((p = memchr(s, '#', (ue - s)))) {
     366          29 :                 if (p - s) {
     367          10 :                         ret->path = estrndup(s, (p-s));
     368          10 :                         php_replace_controlchars_ex(ret->path, (p - s));
     369             :                 }
     370             : 
     371             :                 label_parse:
     372         126 :                 p++;
     373             : 
     374         126 :                 if (ue - p) {
     375         107 :                         ret->fragment = estrndup(p, (ue-p));
     376         107 :                         php_replace_controlchars_ex(ret->fragment, (ue - p));
     377             :                 }
     378             :         } else {
     379         689 :                 ret->path = estrndup(s, (ue-s));
     380         689 :                 php_replace_controlchars_ex(ret->path, (ue - s));
     381             :         }
     382             : end:
     383        1047 :         return ret;
     384             : }
     385             : /* }}} */
     386             : 
     387             : /* {{{ proto mixed parse_url(string url, [int url_component])
     388             :    Parse a URL and return its components */
     389        1101 : PHP_FUNCTION(parse_url)
     390             : {
     391             :         char *str;
     392             :         size_t str_len;
     393             :         php_url *resource;
     394        1101 :         zend_long key = -1;
     395             : 
     396        1101 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &str, &str_len, &key) == FAILURE) {
     397          18 :                 return;
     398             :         }
     399             : 
     400        1083 :         resource = php_url_parse_ex(str, str_len);
     401        1083 :         if (resource == NULL) {
     402             :                 /* @todo Find a method to determine why php_url_parse_ex() failed */
     403         165 :                 RETURN_FALSE;
     404             :         }
     405             : 
     406         918 :         if (key > -1) {
     407         717 :                 switch (key) {
     408             :                         case PHP_URL_SCHEME:
     409         175 :                                 if (resource->scheme != NULL) RETVAL_STRING(resource->scheme);
     410          96 :                                 break;
     411             :                         case PHP_URL_HOST:
     412         151 :                                 if (resource->host != NULL) RETVAL_STRING(resource->host);
     413          90 :                                 break;
     414             :                         case PHP_URL_PORT:
     415          88 :                                 if (resource->port != 0) RETVAL_LONG(resource->port);
     416          88 :                                 break;
     417             :                         case PHP_URL_USER:
     418          99 :                                 if (resource->user != NULL) RETVAL_STRING(resource->user);
     419          88 :                                 break;
     420             :                         case PHP_URL_PASS:
     421          95 :                                 if (resource->pass != NULL) RETVAL_STRING(resource->pass);
     422          88 :                                 break;
     423             :                         case PHP_URL_PATH:
     424         161 :                                 if (resource->path != NULL) RETVAL_STRING(resource->path);
     425          88 :                                 break;
     426             :                         case PHP_URL_QUERY:
     427         110 :                                 if (resource->query != NULL) RETVAL_STRING(resource->query);
     428          88 :                                 break;
     429             :                         case PHP_URL_FRAGMENT:
     430          97 :                                 if (resource->fragment != NULL) RETVAL_STRING(resource->fragment);
     431          88 :                                 break;
     432             :                         default:
     433           3 :                                 php_error_docref(NULL, E_WARNING, "Invalid URL component identifier " ZEND_LONG_FMT, key);
     434           3 :                                 RETVAL_FALSE;
     435             :                 }
     436         717 :                 goto done;
     437             :         }
     438             : 
     439             :         /* allocate an array for return */
     440         201 :         array_init(return_value);
     441             : 
     442             :     /* add the various elements to the array */
     443         201 :         if (resource->scheme != NULL)
     444         142 :                 add_assoc_string(return_value, "scheme", resource->scheme);
     445         201 :         if (resource->host != NULL)
     446         131 :                 add_assoc_string(return_value, "host", resource->host);
     447         201 :         if (resource->port != 0)
     448          63 :                 add_assoc_long(return_value, "port", resource->port);
     449         201 :         if (resource->user != NULL)
     450          23 :                 add_assoc_string(return_value, "user", resource->user);
     451         201 :         if (resource->pass != NULL)
     452          15 :                 add_assoc_string(return_value, "pass", resource->pass);
     453         201 :         if (resource->path != NULL)
     454         168 :                 add_assoc_string(return_value, "path", resource->path);
     455         201 :         if (resource->query != NULL)
     456          49 :                 add_assoc_string(return_value, "query", resource->query);
     457         201 :         if (resource->fragment != NULL)
     458          22 :                 add_assoc_string(return_value, "fragment", resource->fragment);
     459             : done:
     460         918 :         php_url_free(resource);
     461             : }
     462             : /* }}} */
     463             : 
     464             : /* {{{ php_htoi
     465             :  */
     466         127 : static int php_htoi(char *s)
     467             : {
     468             :         int value;
     469             :         int c;
     470             : 
     471         127 :         c = ((unsigned char *)s)[0];
     472         127 :         if (isupper(c))
     473           3 :                 c = tolower(c);
     474         127 :         value = (c >= '0' && c <= '9' ? c - '0' : c - 'a' + 10) * 16;
     475             : 
     476         127 :         c = ((unsigned char *)s)[1];
     477         127 :         if (isupper(c))
     478          51 :                 c = tolower(c);
     479         127 :         value += c >= '0' && c <= '9' ? c - '0' : c - 'a' + 10;
     480             : 
     481         127 :         return (value);
     482             : }
     483             : /* }}} */
     484             : 
     485             : /* rfc1738:
     486             : 
     487             :    ...The characters ";",
     488             :    "/", "?", ":", "@", "=" and "&" are the characters which may be
     489             :    reserved for special meaning within a scheme...
     490             : 
     491             :    ...Thus, only alphanumerics, the special characters "$-_.+!*'(),", and
     492             :    reserved characters used for their reserved purposes may be used
     493             :    unencoded within a URL...
     494             : 
     495             :    For added safety, we only leave -_. unencoded.
     496             :  */
     497             : 
     498             : static unsigned char hexchars[] = "0123456789ABCDEF";
     499             : 
     500             : /* {{{ php_url_encode
     501             :  */
     502        2383 : PHPAPI zend_string *php_url_encode(char const *s, size_t len)
     503             : {
     504             :         register unsigned char c;
     505             :         unsigned char *to;
     506             :         unsigned char const *from, *end;
     507             :         zend_string *start;
     508             : 
     509        2383 :         from = (unsigned char *)s;
     510        2383 :         end = (unsigned char *)s + len;
     511        2383 :         start = zend_string_safe_alloc(3, len, 0, 0);
     512        2383 :         to = (unsigned char*)ZSTR_VAL(start);
     513             : 
     514       28577 :         while (from < end) {
     515       23811 :                 c = *from++;
     516             : 
     517       23811 :                 if (c == ' ') {
     518          33 :                         *to++ = '+';
     519             : #ifndef CHARSET_EBCDIC
     520       26443 :                 } else if ((c < '0' && c != '-' && c != '.') ||
     521             :                                    (c < 'A' && c > '9') ||
     522             :                                    (c > 'Z' && c < 'a' && c != '_') ||
     523             :                                    (c > 'z')) {
     524        2665 :                         to[0] = '%';
     525        2665 :                         to[1] = hexchars[c >> 4];
     526        2665 :                         to[2] = hexchars[c & 15];
     527        2665 :                         to += 3;
     528             : #else /*CHARSET_EBCDIC*/
     529             :                 } else if (!isalnum(c) && strchr("_-.", c) == NULL) {
     530             :                         /* Allow only alphanumeric chars and '_', '-', '.'; escape the rest */
     531             :                         to[0] = '%';
     532             :                         to[1] = hexchars[os_toascii[c] >> 4];
     533             :                         to[2] = hexchars[os_toascii[c] & 15];
     534             :                         to += 3;
     535             : #endif /*CHARSET_EBCDIC*/
     536             :                 } else {
     537       21113 :                         *to++ = c;
     538             :                 }
     539             :         }
     540        2383 :         *to = '\0';
     541             : 
     542        4766 :         start = zend_string_truncate(start, to - (unsigned char*)ZSTR_VAL(start), 0);
     543             : 
     544        2383 :         return start;
     545             : }
     546             : /* }}} */
     547             : 
     548             : /* {{{ proto string urlencode(string str)
     549             :    URL-encodes string */
     550        1246 : PHP_FUNCTION(urlencode)
     551             : {
     552             :         zend_string *in_str;
     553             : 
     554             : #ifndef FAST_ZPP
     555             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &in_str) == FAILURE) {
     556             :                 return;
     557             :         }
     558             : #else
     559        1246 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     560        3732 :                 Z_PARAM_STR(in_str)
     561        1246 :         ZEND_PARSE_PARAMETERS_END();
     562             : #endif
     563             : 
     564        1238 :         RETURN_STR(php_url_encode(ZSTR_VAL(in_str), ZSTR_LEN(in_str)));
     565             : }
     566             : /* }}} */
     567             : 
     568             : /* {{{ proto string urldecode(string str)
     569             :    Decodes URL-encoded string */
     570          31 : PHP_FUNCTION(urldecode)
     571             : {
     572             :         zend_string *in_str, *out_str;
     573             : 
     574             : #ifndef FAST_ZPP
     575             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &in_str) == FAILURE) {
     576             :                 return;
     577             :         }
     578             : #else
     579          31 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     580          87 :                 Z_PARAM_STR(in_str)
     581          31 :         ZEND_PARSE_PARAMETERS_END();
     582             : #endif
     583             : 
     584          46 :         out_str = zend_string_init(ZSTR_VAL(in_str), ZSTR_LEN(in_str), 0);
     585          23 :         ZSTR_LEN(out_str) = php_url_decode(ZSTR_VAL(out_str), ZSTR_LEN(out_str));
     586             : 
     587          23 :     RETURN_NEW_STR(out_str);
     588             : }
     589             : /* }}} */
     590             : 
     591             : /* {{{ php_url_decode
     592             :  */
     593         840 : PHPAPI size_t php_url_decode(char *str, size_t len)
     594             : {
     595         840 :         char *dest = str;
     596         840 :         char *data = str;
     597             : 
     598       18571 :         while (len--) {
     599       16891 :                 if (*data == '+') {
     600          35 :                         *dest = ' ';
     601             :                 }
     602       17038 :                 else if (*data == '%' && len >= 2 && isxdigit((int) *(data + 1))
     603          91 :                                  && isxdigit((int) *(data + 2))) {
     604             : #ifndef CHARSET_EBCDIC
     605          91 :                         *dest = (char) php_htoi(data + 1);
     606             : #else
     607             :                         *dest = os_toebcdic[(char) php_htoi(data + 1)];
     608             : #endif
     609          91 :                         data += 2;
     610          91 :                         len -= 2;
     611             :                 } else {
     612       16765 :                         *dest = *data;
     613             :                 }
     614       16891 :                 data++;
     615       16891 :                 dest++;
     616             :         }
     617         840 :         *dest = '\0';
     618         840 :         return dest - str;
     619             : }
     620             : /* }}} */
     621             : 
     622             : /* {{{ php_raw_url_encode
     623             :  */
     624          54 : PHPAPI zend_string *php_raw_url_encode(char const *s, size_t len)
     625             : {
     626             :         register size_t x, y;
     627             :         zend_string *str;
     628             : 
     629          54 :         str = zend_string_safe_alloc(3, len, 0, 0);
     630         529 :         for (x = 0, y = 0; len--; x++, y++) {
     631         475 :                 ZSTR_VAL(str)[y] = (unsigned char) s[x];
     632             : #ifndef CHARSET_EBCDIC
     633        2142 :                 if ((ZSTR_VAL(str)[y] < '0' && ZSTR_VAL(str)[y] != '-' && ZSTR_VAL(str)[y] != '.') ||
     634         589 :                         (ZSTR_VAL(str)[y] < 'A' && ZSTR_VAL(str)[y] > '9') ||
     635         638 :                         (ZSTR_VAL(str)[y] > 'Z' && ZSTR_VAL(str)[y] < 'a' && ZSTR_VAL(str)[y] != '_') ||
     636         440 :                         (ZSTR_VAL(str)[y] > 'z' && ZSTR_VAL(str)[y] != '~')) {
     637          43 :                         ZSTR_VAL(str)[y++] = '%';
     638          43 :                         ZSTR_VAL(str)[y++] = hexchars[(unsigned char) s[x] >> 4];
     639          43 :                         ZSTR_VAL(str)[y] = hexchars[(unsigned char) s[x] & 15];
     640             : #else /*CHARSET_EBCDIC*/
     641             :                 if (!isalnum(ZSTR_VAL(str)[y]) && strchr("_-.~", ZSTR_VAL(str)[y]) != NULL) {
     642             :                         ZSTR_VAL(str)[y++] = '%';
     643             :                         ZSTR_VAL(str)[y++] = hexchars[os_toascii[(unsigned char) s[x]] >> 4];
     644             :                         ZSTR_VAL(str)[y] = hexchars[os_toascii[(unsigned char) s[x]] & 15];
     645             : #endif /*CHARSET_EBCDIC*/
     646             :                 }
     647             :         }
     648          54 :         ZSTR_VAL(str)[y] = '\0';
     649          54 :         str = zend_string_truncate(str, y, 0);
     650             : 
     651          54 :         return str;
     652             : }
     653             : /* }}} */
     654             : 
     655             : /* {{{ proto string rawurlencode(string str)
     656             :    URL-encodes string */
     657          30 : PHP_FUNCTION(rawurlencode)
     658             : {
     659             :         zend_string *in_str;
     660             : 
     661             : #ifndef FAST_ZPP
     662             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &in_str) == FAILURE) {
     663             :                 return;
     664             :         }
     665             : #else
     666          30 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     667          84 :                 Z_PARAM_STR(in_str)
     668          30 :         ZEND_PARSE_PARAMETERS_END();
     669             : #endif
     670             : 
     671          22 :         RETURN_STR(php_raw_url_encode(ZSTR_VAL(in_str), ZSTR_LEN(in_str)));
     672             : }
     673             : /* }}} */
     674             : 
     675             : /* {{{ proto string rawurldecode(string str)
     676             :    Decodes URL-encodes string */
     677          29 : PHP_FUNCTION(rawurldecode)
     678             : {
     679             :         zend_string *in_str, *out_str;
     680             : 
     681             : #ifndef FAST_ZPP
     682             :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &in_str) == FAILURE) {
     683             :                 return;
     684             :         }
     685             : #else
     686          29 :         ZEND_PARSE_PARAMETERS_START(1, 1)
     687          81 :                 Z_PARAM_STR(in_str)
     688          29 :         ZEND_PARSE_PARAMETERS_END();
     689             : #endif
     690             : 
     691          42 :         out_str = zend_string_init(ZSTR_VAL(in_str), ZSTR_LEN(in_str), 0);
     692          21 :         ZSTR_LEN(out_str) = php_raw_url_decode(ZSTR_VAL(out_str), ZSTR_LEN(out_str));
     693             : 
     694          21 :     RETURN_NEW_STR(out_str);
     695             : }
     696             : /* }}} */
     697             : 
     698             : /* {{{ php_raw_url_decode
     699             :  */
     700          21 : PHPAPI size_t php_raw_url_decode(char *str, size_t len)
     701             : {
     702          21 :         char *dest = str;
     703          21 :         char *data = str;
     704             : 
     705         195 :         while (len--) {
     706         225 :                 if (*data == '%' && len >= 2 && isxdigit((int) *(data + 1))
     707          36 :                         && isxdigit((int) *(data + 2))) {
     708             : #ifndef CHARSET_EBCDIC
     709          36 :                         *dest = (char) php_htoi(data + 1);
     710             : #else
     711             :                         *dest = os_toebcdic[(char) php_htoi(data + 1)];
     712             : #endif
     713          36 :                         data += 2;
     714          36 :                         len -= 2;
     715             :                 } else {
     716         117 :                         *dest = *data;
     717             :                 }
     718         153 :                 data++;
     719         153 :                 dest++;
     720             :         }
     721          21 :         *dest = '\0';
     722          21 :         return dest - str;
     723             : }
     724             : /* }}} */
     725             : 
     726             : /* {{{ proto array get_headers(string url[, int format[, resource context]])
     727             :    fetches all the headers sent by the server in response to a HTTP request */
     728           8 : PHP_FUNCTION(get_headers)
     729             : {
     730             :         char *url;
     731             :         size_t url_len;
     732             :         php_stream *stream;
     733           8 :         zval *prev_val, *hdr = NULL, *h;
     734             :         HashTable *hashT;
     735           8 :         zend_long format = 0;
     736           8 :         zval *zcontext = NULL;
     737             :         php_stream_context *context;
     738             : 
     739           8 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|lr!", &url, &url_len, &format, &zcontext) == FAILURE) {
     740           5 :                 return;
     741             :         }
     742             : 
     743           3 :         context = php_stream_context_from_zval(zcontext, 0);
     744             : 
     745           3 :         if (!(stream = php_stream_open_wrapper_ex(url, "r", REPORT_ERRORS | STREAM_USE_URL | STREAM_ONLY_GET_HEADERS, NULL, context))) {
     746           3 :                 RETURN_FALSE;
     747             :         }
     748             : 
     749           0 :         if (Z_TYPE(stream->wrapperdata) != IS_ARRAY) {
     750           0 :                 php_stream_close(stream);
     751           0 :                 RETURN_FALSE;
     752             :         }
     753             : 
     754           0 :         array_init(return_value);
     755             : 
     756             :         /* check for curl-wrappers that provide headers via a special "headers" element */
     757           0 :         if ((h = zend_hash_str_find(HASH_OF(&stream->wrapperdata), "headers", sizeof("headers")-1)) != NULL && Z_TYPE_P(h) == IS_ARRAY) {
     758             :                 /* curl-wrappers don't load data until the 1st read */
     759           0 :                 if (!Z_ARRVAL_P(h)->nNumOfElements) {
     760           0 :                         php_stream_getc(stream);
     761             :                 }
     762           0 :                 h = zend_hash_str_find(HASH_OF(&stream->wrapperdata), "headers", sizeof("headers")-1);
     763           0 :                 hashT = Z_ARRVAL_P(h);
     764             :         } else {
     765           0 :                 hashT = HASH_OF(&stream->wrapperdata);
     766             :         }
     767             : 
     768           0 :         ZEND_HASH_FOREACH_VAL(hashT, hdr) {
     769           0 :                 if (Z_TYPE_P(hdr) != IS_STRING) {
     770           0 :                         continue;
     771             :                 }
     772           0 :                 if (!format) {
     773             : no_name_header:
     774           0 :                         add_next_index_str(return_value, zend_string_copy(Z_STR_P(hdr)));
     775             :                 } else {
     776             :                         char c;
     777             :                         char *s, *p;
     778             : 
     779           0 :                         if ((p = strchr(Z_STRVAL_P(hdr), ':'))) {
     780           0 :                                 c = *p;
     781           0 :                                 *p = '\0';
     782           0 :                                 s = p + 1;
     783           0 :                                 while (isspace((int)*(unsigned char *)s)) {
     784           0 :                                         s++;
     785             :                                 }
     786             : 
     787           0 :                                 if ((prev_val = zend_hash_str_find(Z_ARRVAL_P(return_value), Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr)))) == NULL) {
     788           0 :                                         add_assoc_stringl_ex(return_value, Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr)), s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))));
     789             :                                 } else { /* some headers may occur more than once, therefor we need to remake the string into an array */
     790           0 :                                         convert_to_array(prev_val);
     791           0 :                                         add_next_index_stringl(prev_val, s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))));
     792             :                                 }
     793             : 
     794           0 :                                 *p = c;
     795             :                         } else {
     796           0 :                                 goto no_name_header;
     797             :                         }
     798             :                 }
     799             :         } ZEND_HASH_FOREACH_END();
     800             : 
     801           0 :         php_stream_close(stream);
     802             : }
     803             : /* }}} */
     804             : 
     805             : /*
     806             :  * Local variables:
     807             :  * tab-width: 4
     808             :  * c-basic-offset: 4
     809             :  * End:
     810             :  * vim600: sw=4 ts=4 fdm=marker
     811             :  * vim<600: sw=4 ts=4
     812             :  */

Generated by: LCOV version 1.10

Generated at Wed, 24 Aug 2016 12:20:31 +0000 (3 days ago)

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