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/session - mod_user.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 96 109 88.1 %
Date: 2019-10-17 Functions: 10 10 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2018 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             : #include "php_session.h"
      23             : #include "mod_user.h"
      24             : 
      25             : ps_module ps_mod_user = {
      26             :         PS_MOD_UPDATE_TIMESTAMP(user)
      27             : };
      28             : 
      29             : 
      30         388 : static void ps_call_handler(zval *func, int argc, zval *argv, zval *retval)
      31             : {
      32             :         int i;
      33         388 :         if (PS(in_save_handler)) {
      34           3 :                 PS(in_save_handler) = 0;
      35           3 :                 ZVAL_UNDEF(retval);
      36           3 :                 php_error_docref(NULL, E_WARNING, "Cannot call session save handler in a recursive manner");
      37           3 :                 return;
      38             :         }
      39         385 :         PS(in_save_handler) = 1;
      40         385 :         if (call_user_function(EG(function_table), NULL, func, retval, argc, argv) == FAILURE) {
      41           5 :                 zval_ptr_dtor(retval);
      42           5 :                 ZVAL_UNDEF(retval);
      43         376 :         } else if (Z_ISUNDEF_P(retval)) {
      44           5 :                 ZVAL_NULL(retval);
      45             :         }
      46         381 :         PS(in_save_handler) = 0;
      47         809 :         for (i = 0; i < argc; i++) {
      48         428 :                 zval_ptr_dtor(&argv[i]);
      49             :         }
      50             : }
      51             : 
      52             : #define STDVARS                                                         \
      53             :         zval retval;                                                    \
      54             :         int ret = FAILURE
      55             : 
      56             : #define PSF(a) PS(mod_user_names).name.ps_##a
      57             : 
      58             : #define FINISH \
      59             :         if (Z_TYPE(retval) != IS_UNDEF) { \
      60             :                 if (Z_TYPE(retval) == IS_TRUE) { \
      61             :                         ret = SUCCESS; \
      62             :                 } else if (Z_TYPE(retval) == IS_FALSE) { \
      63             :                         ret = FAILURE; \
      64             :         }  else if ((Z_TYPE(retval) == IS_LONG) && (Z_LVAL(retval) == -1)) { \
      65             :                         /* BC for clever users - Deprecate me */ \
      66             :                         ret = FAILURE; \
      67             :                 } else if ((Z_TYPE(retval) == IS_LONG) && (Z_LVAL(retval) == 0)) { \
      68             :                         /* BC for clever users - Deprecate me */ \
      69             :                         ret = SUCCESS; \
      70             :                 } else { \
      71             :                         if (!EG(exception)) { \
      72             :                                 php_error_docref(NULL, E_WARNING, \
      73             :                                                  "Session callback expects true/false return value"); \
      74             :                         } \
      75             :                         ret = FAILURE; \
      76             :                         zval_ptr_dtor(&retval); \
      77             :                 } \
      78             :         } \
      79             :         return ret
      80             : 
      81          90 : PS_OPEN_FUNC(user)
      82             : {
      83             :         zval args[2];
      84          90 :         STDVARS;
      85             : 
      86          90 :         if (Z_ISUNDEF(PSF(open))) {
      87           0 :                 php_error_docref(NULL, E_WARNING,
      88             :                         "user session functions not defined");
      89             : 
      90           0 :                 return FAILURE;
      91             :         }
      92             : 
      93         180 :         ZVAL_STRING(&args[0], (char*)save_path);
      94         180 :         ZVAL_STRING(&args[1], (char*)session_name);
      95             : 
      96          90 :         zend_try {
      97          90 :                 ps_call_handler(&PSF(open), 2, args, &retval);
      98           0 :         } zend_catch {
      99           0 :                 PS(session_status) = php_session_none;
     100           0 :                 if (!Z_ISUNDEF(retval)) {
     101           0 :                         zval_ptr_dtor(&retval);
     102             :                 }
     103           0 :                 zend_bailout();
     104          90 :         } zend_end_try();
     105             : 
     106          90 :         PS(mod_user_implemented) = 1;
     107             : 
     108         186 :         FINISH;
     109             : }
     110             : 
     111          90 : PS_CLOSE_FUNC(user)
     112             : {
     113          90 :         zend_bool bailout = 0;
     114          90 :         STDVARS;
     115             : 
     116          90 :         if (!PS(mod_user_implemented)) {
     117             :                 /* already closed */
     118           0 :                 return SUCCESS;
     119             :         }
     120             : 
     121          90 :         zend_try {
     122          90 :                 ps_call_handler(&PSF(close), 0, NULL, &retval);
     123           1 :         } zend_catch {
     124           1 :                 bailout = 1;
     125          90 :         } zend_end_try();
     126             : 
     127          90 :         PS(mod_user_implemented) = 0;
     128             : 
     129          90 :         if (bailout) {
     130           1 :                 if (!Z_ISUNDEF(retval)) {
     131           0 :                         zval_ptr_dtor(&retval);
     132             :                 }
     133           1 :                 zend_bailout();
     134             :         }
     135             : 
     136         176 :         FINISH;
     137             : }
     138             : 
     139          87 : PS_READ_FUNC(user)
     140             : {
     141             :         zval args[1];
     142          87 :         STDVARS;
     143             : 
     144          87 :         ZVAL_STR_COPY(&args[0], key);
     145             : 
     146          87 :         ps_call_handler(&PSF(read), 1, args, &retval);
     147             : 
     148          87 :         if (!Z_ISUNDEF(retval)) {
     149          87 :                 if (Z_TYPE(retval) == IS_STRING) {
     150         164 :                         *val = zend_string_copy(Z_STR(retval));
     151          82 :                         ret = SUCCESS;
     152             :                 }
     153          87 :                 zval_ptr_dtor(&retval);
     154             :         }
     155             : 
     156          87 :         return ret;
     157             : }
     158             : 
     159          50 : PS_WRITE_FUNC(user)
     160             : {
     161             :         zval args[2];
     162          50 :         STDVARS;
     163             : 
     164          50 :         ZVAL_STR_COPY(&args[0], key);
     165          50 :         ZVAL_STR_COPY(&args[1], val);
     166             : 
     167          50 :         ps_call_handler(&PSF(write), 2, args, &retval);
     168             : 
     169         102 :         FINISH;
     170             : }
     171             : 
     172          10 : PS_DESTROY_FUNC(user)
     173             : {
     174             :         zval args[1];
     175          10 :         STDVARS;
     176             : 
     177          10 :         ZVAL_STR_COPY(&args[0], key);
     178             : 
     179          10 :         ps_call_handler(&PSF(destroy), 1, args, &retval);
     180             : 
     181          20 :         FINISH;
     182             : }
     183             : 
     184          10 : PS_GC_FUNC(user)
     185             : {
     186             :         zval args[1];
     187             :         zval retval;
     188             : 
     189          10 :         ZVAL_LONG(&args[0], maxlifetime);
     190             : 
     191          10 :         ps_call_handler(&PSF(gc), 1, args, &retval);
     192             : 
     193          10 :         if (Z_TYPE(retval) == IS_LONG) {
     194           2 :                 convert_to_long(&retval);
     195           2 :                 *nrdels = Z_LVAL(retval);
     196           8 :         } else if (Z_TYPE(retval) == IS_TRUE) {
     197             :                 /* This is for older API compatibility */
     198           8 :                 *nrdels = 1;
     199             :         } else {
     200             :                 /* Anything else is some kind of error */
     201           0 :                 *nrdels = -1; // Error
     202             :         }
     203          10 :         return *nrdels;
     204             : }
     205             : 
     206          44 : PS_CREATE_SID_FUNC(user)
     207             : {
     208             :         /* maintain backwards compatibility */
     209          44 :         if (!Z_ISUNDEF(PSF(create_sid))) {
     210          25 :                 zend_string *id = NULL;
     211             :                 zval retval;
     212             : 
     213          25 :                 ps_call_handler(&PSF(create_sid), 0, NULL, &retval);
     214             : 
     215          25 :                 if (!Z_ISUNDEF(retval)) {
     216          25 :                         if (Z_TYPE(retval) == IS_STRING) {
     217          48 :                                 id = zend_string_copy(Z_STR(retval));
     218             :                         }
     219          25 :                         zval_ptr_dtor(&retval);
     220             :                 } else {
     221           0 :                         zend_throw_error(NULL, "No session id returned by function");
     222           0 :                         return NULL;
     223             :                 }
     224             : 
     225          25 :                 if (!id) {
     226           1 :                         zend_throw_error(NULL, "Session id must be a string");
     227           1 :                         return NULL;
     228             :                 }
     229             : 
     230          24 :                 return id;
     231             :         }
     232             : 
     233             :         /* function as defined by PS_MOD */
     234          19 :         return php_session_create_id(mod_data);
     235             : }
     236             : 
     237           3 : PS_VALIDATE_SID_FUNC(user)
     238             : {
     239             :         /* maintain backwards compatibility */
     240           3 :         if (!Z_ISUNDEF(PSF(validate_sid))) {
     241             :                 zval args[1];
     242           3 :                 STDVARS;
     243             : 
     244           3 :                 ZVAL_STR_COPY(&args[0], key);
     245             : 
     246           3 :                 ps_call_handler(&PSF(validate_sid), 1, args, &retval);
     247             : 
     248           6 :                 FINISH;
     249             :         }
     250             : 
     251             :         /* dummy function defined by PS_MOD */
     252           0 :         return php_session_validate_sid(mod_data, key);
     253             : }
     254             : 
     255          23 : PS_UPDATE_TIMESTAMP_FUNC(user)
     256             : {
     257             :         zval args[2];
     258          23 :         STDVARS;
     259             : 
     260          23 :         ZVAL_STR_COPY(&args[0], key);
     261          23 :         ZVAL_STR_COPY(&args[1], val);
     262             : 
     263             :         /* maintain backwards compatibility */
     264          23 :         if (!Z_ISUNDEF(PSF(update_timestamp))) {
     265           2 :                 ps_call_handler(&PSF(update_timestamp), 2, args, &retval);
     266             :         } else {
     267          21 :                 ps_call_handler(&PSF(write), 2, args, &retval);
     268             :         }
     269             : 
     270          46 :         FINISH;
     271             : }
     272             : 
     273             : /*
     274             :  * Local variables:
     275             :  * tab-width: 4
     276             :  * c-basic-offset: 4
     277             :  * End:
     278             :  * vim600: sw=4 ts=4 fdm=marker
     279             :  * vim<600: sw=4 ts=4
     280             :  */

Generated by: LCOV version 1.10

Generated at Thu, 17 Oct 2019 23:21:25 +0000 (2 days ago)

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