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 - lcov_data/ext/standard - url_scanner_ex.re (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 183 224 81.7 %
Date: 2014-10-30 Functions: 20 21 95.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :   +----------------------------------------------------------------------+
       3             :   | PHP Version 7                                                        |
       4             :   +----------------------------------------------------------------------+
       5             :   | Copyright (c) 1997-2014 The PHP Group                                |
       6             :   +----------------------------------------------------------------------+
       7             :   | This source file is subject to version 3.01 of the PHP license,      |
       8             :   | that is bundled with this package in the file LICENSE, and is        |
       9             :   | available through the world-wide-web at the following url:           |
      10             :   | http://www.php.net/license/3_01.txt                                  |
      11             :   | If you did not receive a copy of the PHP license and are unable to   |
      12             :   | obtain it through the world-wide-web, please send a note to          |
      13             :   | license@php.net so we can mail you a copy immediately.               |
      14             :   +----------------------------------------------------------------------+
      15             :   | Author: Sascha Schumann <sascha@schumann.cx>                         |
      16             :   +----------------------------------------------------------------------+
      17             : */
      18             : 
      19             : /* $Id$ */
      20             : 
      21             : #include "php.h"
      22             : 
      23             : #ifdef HAVE_UNISTD_H
      24             : #include <unistd.h>
      25             : #endif
      26             : #ifdef HAVE_LIMITS_H
      27             : #include <limits.h>
      28             : #endif
      29             : 
      30             : #include <stdio.h>
      31             : #include <stdlib.h>
      32             : #include <string.h>
      33             : 
      34             : #include "php_ini.h"
      35             : #include "php_globals.h"
      36             : #define STATE_TAG SOME_OTHER_STATE_TAG
      37             : #include "basic_functions.h"
      38             : #include "url.h"
      39             : #undef STATE_TAG
      40             : 
      41             : #define url_scanner url_scanner_ex
      42             : 
      43             : #include "zend_smart_str.h"
      44             : 
      45      102308 : static void tag_dtor(zval *zv)
      46             : {
      47      102308 :         free(Z_PTR_P(zv));
      48      102308 : }
      49             : 
      50       20427 : static PHP_INI_MH(OnUpdateTags)
      51             : {
      52             :         url_adapt_state_ex_t *ctx;
      53             :         char *key;
      54             :         char *lasts;
      55             :         char *tmp;
      56             :         
      57       20427 :         ctx = &BG(url_adapt_state_ex);
      58             :         
      59       20427 :         tmp = estrndup(new_value->val, new_value->len);
      60             :         
      61       20427 :         if (ctx->tags)
      62           4 :                 zend_hash_destroy(ctx->tags);
      63             :         else {
      64       20423 :                 ctx->tags = malloc(sizeof(HashTable));
      65       20423 :                 if (!ctx->tags) {
      66           0 :                         return FAILURE;
      67             :                 }
      68             :         }
      69             : 
      70       20427 :         zend_hash_init(ctx->tags, 0, NULL, tag_dtor, 1);
      71             :         
      72      142992 :         for (key = php_strtok_r(tmp, ",", &lasts);
      73             :                         key;
      74      102138 :                         key = php_strtok_r(NULL, ",", &lasts)) {
      75             :                 char *val;
      76             : 
      77      102138 :                 val = strchr(key, '=');
      78      102138 :                 if (val) {
      79             :                         char *q;
      80             :                         size_t keylen;
      81             :                         
      82      102138 :                         *val++ = '\0';
      83      551542 :                         for (q = key; *q; q++)
      84      449404 :                                 *q = tolower(*q);
      85      102138 :                         keylen = q - key;
      86             :                         /* key is stored withOUT NUL
      87             :                            val is stored WITH    NUL */
      88      102138 :                         zend_hash_str_add_mem(ctx->tags, key, keylen, val, strlen(val)+1);
      89             :                 }
      90             :         }
      91             : 
      92       20427 :         efree(tmp);
      93             : 
      94       20427 :         return SUCCESS;
      95             : }
      96             : 
      97             : PHP_INI_BEGIN()
      98             :         STD_PHP_INI_ENTRY("url_rewriter.tags", "a=href,area=href,frame=src,form=,fieldset=", PHP_INI_ALL, OnUpdateTags, url_adapt_state_ex, php_basic_globals, basic_globals)
      99             : PHP_INI_END()
     100             : 
     101             : /*!re2c
     102             : any = [\000-\377];
     103             : N = (any\[<]);
     104             : alpha = [a-zA-Z];
     105             : alphanamespace = [a-zA-Z:];
     106             : alphadash = ([a-zA-Z] | "-");
     107             : */
     108             : 
     109             : #define YYFILL(n) goto done
     110             : #define YYCTYPE unsigned char
     111             : #define YYCURSOR p
     112             : #define YYLIMIT q
     113             : #define YYMARKER r
     114             :         
     115          16 : static inline void append_modified_url(smart_str *url, smart_str *dest, smart_str *url_app, const char *separator)
     116             : {
     117             :         register const char *p, *q;
     118          16 :         const char *bash = NULL;
     119          16 :         const char *sep = "?";
     120             :         
     121          16 :         q = (p = url->s->val) + url->s->len;
     122             : 
     123             : scan:
     124             : /*!re2c
     125           0 :   ":"         { smart_str_append_smart_str(dest, url); return; }
     126           9 :   "?"         { sep = separator; goto scan; }
     127           0 :   "#"         { bash = p - 1; goto done; }
     128           7 :   (any\[:?#])+          { goto scan; }
     129             : */
     130             : done:
     131             :         
     132             :         /* Don't modify URLs of the format "#mark" */
     133          16 :         if (bash && bash - url->s->val == 0) {
     134             :                 smart_str_append_smart_str(dest, url);
     135           0 :                 return;
     136             :         }
     137             : 
     138          16 :         if (bash)
     139           0 :                 smart_str_appendl(dest, url->s->val, bash - url->s->val);
     140             :         else
     141             :                 smart_str_append_smart_str(dest, url);
     142             : 
     143          16 :         smart_str_appends(dest, sep);
     144             :         smart_str_append_smart_str(dest, url_app);
     145             : 
     146          16 :         if (bash)
     147           0 :                 smart_str_appendl(dest, bash, q - bash);
     148             : }
     149             : 
     150             : 
     151             : #undef YYFILL
     152             : #undef YYCTYPE
     153             : #undef YYCURSOR
     154             : #undef YYLIMIT
     155             : #undef YYMARKER
     156             : 
     157          20 : static inline void tag_arg(url_adapt_state_ex_t *ctx, char quotes, char type TSRMLS_DC)
     158             : {
     159          20 :         char f = 0;
     160             : 
     161          20 :         if (strncasecmp(ctx->arg.s->val, ctx->lookup_data, ctx->arg.s->len) == 0)
     162          16 :                 f = 1;
     163             : 
     164          20 :         if (quotes)
     165          16 :                 smart_str_appendc(&ctx->result, type);
     166          20 :         if (f) {
     167          16 :                 append_modified_url(&ctx->val, &ctx->result, &ctx->url_app, PG(arg_separator).output);
     168             :         } else {
     169           4 :                 smart_str_append_smart_str(&ctx->result, &ctx->val);
     170             :         }
     171          20 :         if (quotes)
     172          16 :                 smart_str_appendc(&ctx->result, type);
     173          20 : }
     174             : 
     175             : enum {
     176             :         STATE_PLAIN = 0,
     177             :         STATE_TAG,
     178             :         STATE_NEXT_ARG,
     179             :         STATE_ARG,
     180             :         STATE_BEFORE_VAL,
     181             :         STATE_VAL
     182             : };
     183             : 
     184             : #define YYFILL(n) goto stop
     185             : #define YYCTYPE unsigned char
     186             : #define YYCURSOR xp
     187             : #define YYLIMIT end
     188             : #define YYMARKER q
     189             : #define STATE ctx->state
     190             : 
     191             : #define STD_PARA url_adapt_state_ex_t *ctx, char *start, char *YYCURSOR TSRMLS_DC
     192             : #define STD_ARGS ctx, start, xp TSRMLS_CC
     193             : 
     194             : #if SCANNER_DEBUG
     195             : #define scdebug(x) printf x
     196             : #else
     197             : #define scdebug(x)
     198             : #endif
     199             : 
     200         197 : static inline void passthru(STD_PARA) 
     201             : {
     202             :         scdebug(("appending %d chars, starting with %c\n", YYCURSOR-start, *start));
     203         197 :         smart_str_appendl(&ctx->result, start, YYCURSOR - start);
     204         197 : }
     205             : 
     206             : /*
     207             :  * This function appends a hidden input field after a <form> or
     208             :  * <fieldset>.  The latter is important for XHTML.
     209             :  */
     210             : 
     211          22 : static void handle_form(STD_PARA) 
     212             : {
     213          22 :         int doit = 0;
     214             : 
     215          22 :         if (ctx->form_app.s->len > 0) {
     216          22 :                 switch (ctx->tag.s->len) {
     217             :                         case sizeof("form") - 1:
     218           4 :                                 if (!strncasecmp(ctx->tag.s->val, "form", sizeof("form") - 1)) {
     219           4 :                                         doit = 1;               
     220             :                                 }
     221           4 :                                 if (doit && ctx->val.s && ctx->lookup_data && *ctx->lookup_data) {
     222           0 :                                         char *e, *p = (char *)zend_memnstr(ctx->val.s->val, "://", sizeof("://") - 1, ctx->val.s->val + ctx->val.s->len);
     223           0 :                                         if (p) {
     224           0 :                                                 e = memchr(p, '/', (ctx->val.s->val + ctx->val.s->len) - p);
     225           0 :                                                 if (!e) {
     226           0 :                                                         e = ctx->val.s->val + ctx->val.s->len;
     227             :                                                 }
     228           0 :                                                 if ((e - p) && strncasecmp(p, ctx->lookup_data, (e - p))) {
     229           0 :                                                         doit = 0;
     230             :                                                 }
     231             :                                         }
     232             :                                 }
     233           4 :                                 break;
     234             : 
     235             :                         case sizeof("fieldset") - 1:
     236           2 :                                 if (!strncasecmp(ctx->tag.s->val, "fieldset", sizeof("fieldset") - 1)) {
     237           2 :                                         doit = 1;               
     238             :                                 }
     239             :                                 break;
     240             :                 }
     241             : 
     242          22 :                 if (doit)
     243           6 :                         smart_str_append_smart_str(&ctx->result, &ctx->form_app);
     244             :         }
     245          22 : }
     246             : 
     247             : /*
     248             :  *  HANDLE_TAG copies the HTML Tag and checks whether we 
     249             :  *  have that tag in our table. If we might modify it,
     250             :  *  we continue to scan the tag, otherwise we simply copy the complete
     251             :  *  HTML stuff to the result buffer.
     252             :  */
     253             : 
     254          32 : static inline void handle_tag(STD_PARA) 
     255             : {
     256          32 :         int ok = 0;
     257             :         unsigned int i;
     258             : 
     259          32 :         if (ctx->tag.s) {
     260          22 :                 ctx->tag.s->len = 0;
     261             :         }
     262          32 :         smart_str_appendl(&ctx->tag, start, YYCURSOR - start);
     263         122 :         for (i = 0; i < ctx->tag.s->len; i++)
     264          90 :                 ctx->tag.s->val[i] = tolower((int)(unsigned char)ctx->tag.s->val[i]);
     265             :     /* intentionally using str_find here, in case the hash value is set, but the string val is changed later */
     266          64 :         if ((ctx->lookup_data = zend_hash_str_find_ptr(ctx->tags, ctx->tag.s->val, ctx->tag.s->len)) != NULL)
     267          22 :                 ok = 1;
     268          32 :         STATE = ok ? STATE_NEXT_ARG : STATE_PLAIN;
     269          32 : }
     270             : 
     271          20 : static inline void handle_arg(STD_PARA) 
     272             : {
     273          20 :         if (ctx->arg.s) {
     274          11 :                 ctx->arg.s->len = 0;
     275             :         }
     276          20 :         smart_str_appendl(&ctx->arg, start, YYCURSOR - start);
     277          20 : }
     278             : 
     279          20 : static inline void handle_val(STD_PARA, char quotes, char type) 
     280             : {
     281          20 :         smart_str_setl(&ctx->val, start + quotes, YYCURSOR - start - quotes * 2);
     282          20 :         tag_arg(ctx, quotes, type TSRMLS_CC);
     283          20 : }
     284             : 
     285          14 : static inline void xx_mainloop(url_adapt_state_ex_t *ctx, const char *newdata, size_t newlen TSRMLS_DC)
     286             : {
     287             :         char *end, *q;
     288             :         char *xp;
     289             :         char *start;
     290             :         size_t rest;
     291             : 
     292          14 :         smart_str_appendl(&ctx->buf, newdata, newlen);
     293             :         
     294          14 :         YYCURSOR = ctx->buf.s->val;
     295          14 :         YYLIMIT = ctx->buf.s->val + ctx->buf.s->len;
     296             : 
     297          14 :         switch (STATE) {
     298          14 :                 case STATE_PLAIN: goto state_plain;
     299           0 :                 case STATE_TAG: goto state_tag;
     300           0 :                 case STATE_NEXT_ARG: goto state_next_arg;
     301           0 :                 case STATE_ARG: goto state_arg;
     302           0 :                 case STATE_BEFORE_VAL: goto state_before_val;
     303           0 :                 case STATE_VAL: goto state_val;
     304             :         }
     305             :         
     306             : 
     307             : state_plain_begin:
     308          32 :         STATE = STATE_PLAIN;
     309             :         
     310             : state_plain:
     311          85 :         start = YYCURSOR;
     312             : /*!re2c
     313          42 :   "<"                              { passthru(STD_ARGS); STATE = STATE_TAG; goto state_tag; }
     314          29 :   N+                            { passthru(STD_ARGS); goto state_plain; }
     315             : */
     316             : 
     317             : state_tag:      
     318          42 :         start = YYCURSOR;
     319             : /*!re2c
     320          32 :   alphanamespace+       { handle_tag(STD_ARGS); /* Sets STATE */; passthru(STD_ARGS); if (STATE == STATE_PLAIN) goto state_plain; else goto state_next_arg; }
     321          10 :   any           { passthru(STD_ARGS); goto state_plain_begin; }
     322             : */
     323             : 
     324             : state_next_arg_begin:
     325          20 :         STATE = STATE_NEXT_ARG;
     326             :         
     327             : state_next_arg:
     328          64 :         start = YYCURSOR;
     329             : /*!re2c
     330          22 :   [/]? [>]           { passthru(STD_ARGS); handle_form(STD_ARGS); goto state_plain_begin; }
     331          22 :   [ \v\r\t\n]+  { passthru(STD_ARGS); goto state_next_arg; }
     332          20 :   alpha         { --YYCURSOR; STATE = STATE_ARG; goto state_arg; }
     333           0 :   any           { passthru(STD_ARGS); goto state_plain_begin; }
     334             : */
     335             : 
     336             : state_arg:
     337          20 :         start = YYCURSOR;
     338             : /*!re2c
     339          20 :   alpha alphadash*      { passthru(STD_ARGS); handle_arg(STD_ARGS); STATE = STATE_BEFORE_VAL; goto state_before_val; }
     340           0 :   any           { passthru(STD_ARGS); STATE = STATE_NEXT_ARG; goto state_next_arg; }
     341             : */
     342             : 
     343             : state_before_val:
     344          20 :         start = YYCURSOR;
     345             : /*!re2c
     346          20 :   [ ]* "=" [ ]*               { passthru(STD_ARGS); STATE = STATE_VAL; goto state_val; }
     347           0 :   any                           { --YYCURSOR; goto state_next_arg_begin; }
     348             : */
     349             : 
     350             : 
     351             : state_val:
     352          20 :         start = YYCURSOR;
     353             : /*!re2c
     354          14 :   ["] (any\[">])* ["] { handle_val(STD_ARGS, 1, '"'); goto state_next_arg_begin; }
     355           2 :   ['] (any\['>])* [']        { handle_val(STD_ARGS, 1, '\''); goto state_next_arg_begin; }
     356           4 :   (any\[ \r\t\n>'"])+   { handle_val(STD_ARGS, 0, ' '); goto state_next_arg_begin; }
     357           0 :   any                                   { passthru(STD_ARGS); goto state_next_arg_begin; }
     358             : */
     359             : 
     360             : stop:
     361          14 :         if (YYLIMIT < start) {
     362             :                 /* XXX: Crash avoidance. Need to work with reporter to figure out what goes wrong */    
     363           0 :                 rest = 0;
     364             :         } else {
     365          14 :                 rest = YYLIMIT - start;
     366             :                 scdebug(("stopped in state %d at pos %d (%d:%c) %d\n", STATE, YYCURSOR - ctx->buf.c, *YYCURSOR, *YYCURSOR, rest));
     367             :         }
     368             :         
     369          14 :         if (rest) memmove(ctx->buf.s->val, start, rest);
     370          14 :         ctx->buf.s->len = rest;
     371          14 : }
     372             : 
     373           0 : char *php_url_scanner_adapt_single_url(const char *url, size_t urllen, const char *name, const char *value, size_t *newlen TSRMLS_DC)
     374             : {
     375             :         char *result;
     376           0 :         smart_str surl = {0};
     377           0 :         smart_str buf = {0};
     378           0 :         smart_str url_app = {0};
     379             : 
     380             :         smart_str_setl(&surl, url, urllen);
     381             : 
     382           0 :         smart_str_appends(&url_app, name);
     383             :         smart_str_appendc(&url_app, '=');
     384           0 :         smart_str_appends(&url_app, value);
     385             : 
     386           0 :         append_modified_url(&surl, &buf, &url_app, PG(arg_separator).output);
     387             : 
     388             :         smart_str_0(&buf);
     389           0 :         if (newlen) *newlen = buf.s->len;
     390           0 :         result = estrndup(buf.s->val, buf.s->len);
     391             : 
     392             :         smart_str_free(&url_app);
     393             :         smart_str_free(&buf);
     394             : 
     395           0 :         return result;
     396             : }
     397             : 
     398             : 
     399          14 : static char *url_adapt_ext(const char *src, size_t srclen, size_t *newlen, zend_bool do_flush TSRMLS_DC)
     400             : {
     401             :         url_adapt_state_ex_t *ctx;
     402             :         char *retval;
     403             : 
     404          14 :         ctx = &BG(url_adapt_state_ex);
     405             : 
     406          14 :         xx_mainloop(ctx, src, srclen TSRMLS_CC);
     407             : 
     408          14 :         if (!ctx->result.s) {
     409           1 :                 smart_str_appendl(&ctx->result, "", 0);
     410           1 :                 *newlen = 0;
     411             :         } else {
     412          13 :                 *newlen = ctx->result.s->len;
     413             :         }
     414          14 :         smart_str_0(&ctx->result);
     415          14 :         if (do_flush) {
     416          14 :                 smart_str_append(&ctx->result, ctx->buf.s);
     417          14 :                 *newlen += ctx->buf.s->len;
     418          14 :                 smart_str_free(&ctx->buf);
     419          14 :                 smart_str_free(&ctx->val);
     420             :         }
     421          14 :         retval = estrndup(ctx->result.s->val, ctx->result.s->len);
     422          14 :         smart_str_free(&ctx->result);
     423          14 :         return retval;
     424             : }
     425             : 
     426          10 : static int php_url_scanner_ex_activate(TSRMLS_D)
     427             : {
     428             :         url_adapt_state_ex_t *ctx;
     429             :         
     430          10 :         ctx = &BG(url_adapt_state_ex);
     431             : 
     432          10 :         memset(ctx, 0, ((size_t) &((url_adapt_state_ex_t *)0)->tags));
     433             : 
     434          10 :         return SUCCESS;
     435             : }
     436             : 
     437          10 : static int php_url_scanner_ex_deactivate(TSRMLS_D)
     438             : {
     439             :         url_adapt_state_ex_t *ctx;
     440             :         
     441          10 :         ctx = &BG(url_adapt_state_ex);
     442             : 
     443          10 :         smart_str_free(&ctx->result);
     444          10 :         smart_str_free(&ctx->buf);
     445          10 :         smart_str_free(&ctx->tag);
     446          10 :         smart_str_free(&ctx->arg);
     447             : 
     448          10 :         return SUCCESS;
     449             : }
     450             : 
     451          15 : static void php_url_scanner_output_handler(char *output, size_t output_len, char **handled_output, size_t *handled_output_len, int mode TSRMLS_DC)
     452             : {
     453             :         size_t len;
     454             : 
     455          15 :         if (BG(url_adapt_state_ex).url_app.s->len != 0) {
     456          14 :                 *handled_output = url_adapt_ext(output, output_len, &len, (zend_bool) (mode & (PHP_OUTPUT_HANDLER_END | PHP_OUTPUT_HANDLER_CONT | PHP_OUTPUT_HANDLER_FLUSH | PHP_OUTPUT_HANDLER_FINAL) ? 1 : 0) TSRMLS_CC);
     457             :                 if (sizeof(uint) < sizeof(size_t)) {
     458          14 :                         if (len > UINT_MAX)
     459           0 :                                 len = UINT_MAX;
     460             :                 }
     461          14 :                 *handled_output_len = len;
     462           1 :         } else if (BG(url_adapt_state_ex).url_app.s->len == 0) {
     463           1 :                 url_adapt_state_ex_t *ctx = &BG(url_adapt_state_ex);
     464           1 :                 if (ctx->buf.s && ctx->buf.s->len) {
     465           0 :                         smart_str_append(&ctx->result, ctx->buf.s);
     466           0 :                         smart_str_appendl(&ctx->result, output, output_len);
     467             : 
     468           0 :                         *handled_output = estrndup(ctx->result.s->val, ctx->result.s->len);
     469           0 :                         *handled_output_len = ctx->buf.s->len + output_len;
     470             : 
     471           0 :                         smart_str_free(&ctx->buf);
     472           0 :                         smart_str_free(&ctx->result);
     473             :                 } else {
     474           1 :                         *handled_output = estrndup(output, *handled_output_len = output_len);
     475             :                 }
     476             :         } else {
     477           0 :                 *handled_output = NULL;
     478             :         }
     479          15 : }
     480             : 
     481          11 : PHPAPI int php_url_scanner_add_var(char *name, size_t name_len, char *value, size_t value_len, int urlencode TSRMLS_DC)
     482             : {
     483          11 :         smart_str val = {0};
     484             :         zend_string *encoded;
     485             :         
     486          11 :         if (!BG(url_adapt_state_ex).active) {
     487          10 :                 php_url_scanner_ex_activate(TSRMLS_C);
     488          10 :                 php_output_start_internal(ZEND_STRL("URL-Rewriter"), php_url_scanner_output_handler, 0, PHP_OUTPUT_HANDLER_STDFLAGS TSRMLS_CC);
     489          10 :                 BG(url_adapt_state_ex).active = 1;
     490             :         }
     491             : 
     492             : 
     493          11 :         if (BG(url_adapt_state_ex).url_app.s && BG(url_adapt_state_ex).url_app.s->len != 0) {
     494           1 :                 smart_str_appends(&BG(url_adapt_state_ex).url_app, PG(arg_separator).output);
     495             :         }
     496             : 
     497          11 :         if (urlencode) {
     498          11 :                 encoded = php_url_encode(value, value_len);
     499          11 :                 smart_str_setl(&val, encoded->val, encoded->len);
     500             :         } else {
     501             :                 smart_str_setl(&val, value, value_len);
     502             :         }
     503             :         
     504             :         smart_str_appendl(&BG(url_adapt_state_ex).url_app, name, name_len);
     505             :         smart_str_appendc(&BG(url_adapt_state_ex).url_app, '=');
     506             :         smart_str_append_smart_str(&BG(url_adapt_state_ex).url_app, &val);
     507             : 
     508             :         smart_str_appends(&BG(url_adapt_state_ex).form_app, "<input type=\"hidden\" name=\""); 
     509             :         smart_str_appendl(&BG(url_adapt_state_ex).form_app, name, name_len);
     510             :         smart_str_appends(&BG(url_adapt_state_ex).form_app, "\" value=\"");
     511             :         smart_str_append_smart_str(&BG(url_adapt_state_ex).form_app, &val);
     512             :         smart_str_appends(&BG(url_adapt_state_ex).form_app, "\" />");
     513             : 
     514          11 :         if (urlencode) {
     515             :                 zend_string_free(encoded);
     516             :         }
     517             :         smart_str_free(&val);
     518             : 
     519          11 :         return SUCCESS;
     520             : }
     521             : 
     522           9 : PHPAPI int php_url_scanner_reset_vars(TSRMLS_D)
     523             : {
     524           9 :         if (BG(url_adapt_state_ex).form_app.s) {
     525           1 :                 BG(url_adapt_state_ex).form_app.s->len = 0;
     526             :         }
     527           9 :         if (BG(url_adapt_state_ex).url_app.s) {
     528           1 :                 BG(url_adapt_state_ex).url_app.s->len = 0;
     529             :         }
     530             : 
     531           9 :         return SUCCESS;
     532             : }
     533             : 
     534       20423 : PHP_MINIT_FUNCTION(url_scanner)
     535             : {
     536       20423 :         BG(url_adapt_state_ex).tags = NULL;
     537             : 
     538       20423 :         BG(url_adapt_state_ex).form_app.s = BG(url_adapt_state_ex).url_app.s = NULL;
     539             : 
     540       20423 :         REGISTER_INI_ENTRIES();
     541       20423 :         return SUCCESS;
     542             : }
     543             : 
     544       20457 : PHP_MSHUTDOWN_FUNCTION(url_scanner)
     545             : {
     546       20457 :         UNREGISTER_INI_ENTRIES();
     547             : 
     548       20457 :         return SUCCESS;
     549             : }
     550             : 
     551       20380 : PHP_RINIT_FUNCTION(url_scanner)
     552             : {
     553       20380 :         BG(url_adapt_state_ex).active = 0;
     554             :         
     555       20380 :         return SUCCESS;
     556             : }
     557             : 
     558       20416 : PHP_RSHUTDOWN_FUNCTION(url_scanner)
     559             : {
     560       20416 :         if (BG(url_adapt_state_ex).active) {
     561          10 :                 php_url_scanner_ex_deactivate(TSRMLS_C);
     562          10 :                 BG(url_adapt_state_ex).active = 0;
     563             :         }
     564             : 
     565             :         smart_str_free(&BG(url_adapt_state_ex).form_app);
     566             :         smart_str_free(&BG(url_adapt_state_ex).url_app);
     567             : 
     568       20416 :         return SUCCESS;
     569             : }

Generated by: LCOV version 1.10

Generated at Thu, 30 Oct 2014 07:41:45 +0000 (9 hours ago)

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