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: 0 369 0.0 %
Date: 2014-04-16 Functions: 0 16 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Wed, 16 Apr 2014 12:47:58 +0000 (4 days ago)

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