/*

+----------------------------------------------------------------------+

| Copyright (c) The PHP Group |

+----------------------------------------------------------------------+

| This source file is subject to version 3.01 of the PHP license, |

| that is bundled with this package in the file LICENSE, and is |

| available through the world-wide-web at the following url: |

| https://www.php.net/license/3_01.txt |

| If you did not receive a copy of the PHP license and are unable to |

| obtain it through the world-wide-web, please send a note to |

| [email protected] so we can mail you a copy immediately. |

+----------------------------------------------------------------------+

| Authors: Sascha Schumann <[email protected]> |

| Andrei Zmievski <[email protected]> |

+----------------------------------------------------------------------+

*/

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "php.h"

#ifdef PHP_WIN32

# include "win32/winutil.h"

# include "win32/time.h"

#else

# include <sys/time.h>

#endif

#include <sys/stat.h>

#include <fcntl.h>

#include "php_ini.h"

#include "rfc1867.h"

#include "php_variables.h"

#include "php_session.h"

#include "session_arginfo.h"

#include "ext/standard/php_var.h"

#include "ext/date/php_date.h"

#include "ext/standard/url_scanner_ex.h"

#include "ext/standard/info.h"

#include "zend_smart_str.h"

#include "ext/standard/url.h"

#include "ext/standard/basic_functions.h"

#include "ext/standard/head.h"

#include "ext/random/php_random.h"

#include "ext/random/php_random_csprng.h"

#include "mod_files.h"

#include "mod_user.h"

#ifdef HAVE_LIBMM

#include "mod_mm.h"

#endif

#include "zend_attributes.h"

PHPAPI ZEND_DECLARE_MODULE_GLOBALS(ps)

static zend_result php_session_rfc1867_callback(unsigned int event, void *event_data, void **extra);

static zend_result (*php_session_rfc1867_orig_callback)(unsigned int event, void *event_data, void **extra);

static void php_session_track_init(void);

/* SessionHandler class */

zend_class_entry *php_session_class_entry;

/* SessionHandlerInterface */

zend_class_entry *php_session_iface_entry;

/* SessionIdInterface */

zend_class_entry *php_session_id_iface_entry;

/* SessionUpdateTimestampInterface */

zend_class_entry *php_session_update_timestamp_iface_entry;

#define PS_MAX_SID_LENGTH 256

/* ***********

* Helpers *

*********** */

#define IF_SESSION_VARS() \

if (Z_ISREF_P(&PS(http_session_vars)) && Z_TYPE_P(Z_REFVAL(PS(http_session_vars))) == IS_ARRAY)

#define SESSION_CHECK_ACTIVE_STATE \

if (PS(session_status) == php_session_active) { \

php_session_session_already_started_error(E_WARNING, "Session ini settings cannot be changed when a session is active"); \

return FAILURE; \

}

#define SESSION_CHECK_OUTPUT_STATE \

if (SG(headers_sent) && stage != ZEND_INI_STAGE_DEACTIVATE) { \

php_session_headers_already_sent_error(E_WARNING, "Session ini settings cannot be changed after headers have already been sent"); \

return FAILURE; \

}

#define SESSION_FORBIDDEN_CHARS "=,;.[ \t\r\n\013\014"

#define SESSION_FORBIDDEN_CHARS_FOR_ERROR_MSG "=,;.[ \\t\\r\\n\\013\\014"

#define APPLY_TRANS_SID (PS(use_trans_sid) && !PS(use_only_cookies))

static zend_result php_session_send_cookie(void);

static bool php_session_abort(void);

static void proposed_session_id_to_session_id(const zval *proposed_session_id);

/* Initialized in MINIT, readonly otherwise. */

static int my_module_number = 0;

/* Dispatched by RINIT and by php_session_destroy */

static inline void php_rinit_session_globals(void)

{

/* Do NOT init PS(mod_user_names) here! */

/* TODO: These could be moved to MINIT and removed. These should be initialized by php_rshutdown_session_globals() always when execution is finished. */

PS(id) = NULL;

PS(session_status) = php_session_none;

PS(in_save_handler) = false;

PS(set_handler) = false;

PS(mod_data) = NULL;

PS(mod_user_is_open) = false;

PS(mod_user_uses_object_methods_as_handlers) = false;

PS(define_sid) = true;

PS(session_vars) = NULL;

PS(module_number) = my_module_number;

ZVAL_UNDEF(&PS(http_session_vars));

}

static inline void php_session_headers_already_sent_error(int severity, const char *message) {

const char *output_start_filename = php_output_get_start_filename();

int output_start_lineno = php_output_get_start_lineno();

if (output_start_filename != NULL) {

php_error_docref(NULL, severity, "%s (sent from %s on line %d)", message, output_start_filename, output_start_lineno);

} else {

php_error_docref(NULL, severity, "%s", message);

}

}

static inline void php_session_session_already_started_error(int severity, const char *message) {

if (PS(session_started_filename) != NULL) {

php_error_docref(NULL, severity, "%s (started from %s on line %"PRIu32")", message, ZSTR_VAL(PS(session_started_filename)), PS(session_started_lineno));

} else if (PS(auto_start)) {

/* This option can't be changed at runtime, so we can assume it's because of this */

php_error_docref(NULL, severity, "%s (session started automatically)", message);

} else {

php_error_docref(NULL, severity, "%s", message);

}

}

static inline void php_session_cleanup_filename(void)

{

if (PS(session_started_filename)) {

zend_string_release(PS(session_started_filename));

PS(session_started_filename) = NULL;

PS(session_started_lineno) = 0;

}

}

/* Dispatched by RSHUTDOWN and by php_session_destroy */

static void php_rshutdown_session_globals(void)

{

/* Do NOT destroy PS(mod_user_names) here! */

if (!Z_ISUNDEF(PS(http_session_vars))) {

zval_ptr_dtor(&PS(http_session_vars));

ZVAL_UNDEF(&PS(http_session_vars));

}

if (PS(mod_data) || PS(mod_user_implemented)) {

zend_try {

PS(mod)->s_close(&PS(mod_data));

} zend_end_try();

}

if (PS(id)) {

zend_string_release_ex(PS(id), false);

PS(id) = NULL;

}

if (PS(session_vars)) {

zend_string_release_ex(PS(session_vars), false);

PS(session_vars) = NULL;

}

php_session_cleanup_filename();

/* User save handlers may end up directly here by misuse, bugs in user script, etc. */

/* Set session status to prevent error while restoring save handler INI value. */

PS(session_status) = php_session_none;

}

PHPAPI zend_result php_session_destroy(void)

{

zend_result retval = SUCCESS;

if (PS(session_status) != php_session_active) {

php_error_docref(NULL, E_WARNING, "Trying to destroy uninitialized session");

return FAILURE;

}

if (PS(id) && PS(mod)->s_destroy(&PS(mod_data), PS(id)) == FAILURE) {

retval = FAILURE;

if (!EG(exception)) {

php_error_docref(NULL, E_WARNING, "Session object destruction failed");

}

}

php_rshutdown_session_globals();

php_rinit_session_globals();

return retval;

}

PHPAPI void php_add_session_var(zend_string *name)

{

IF_SESSION_VARS() {

zval *sess_var = Z_REFVAL(PS(http_session_vars));

SEPARATE_ARRAY(sess_var);

if (!zend_hash_exists(Z_ARRVAL_P(sess_var), name)) {

zval empty_var;

ZVAL_NULL(&empty_var);

zend_hash_update(Z_ARRVAL_P(sess_var), name, &empty_var);

}

}

}

PHPAPI zval *php_set_session_var(zend_string *name, zval *state_val, php_unserialize_data_t *var_hash)

{

IF_SESSION_VARS() {

zval *sess_var = Z_REFVAL(PS(http_session_vars));

SEPARATE_ARRAY(sess_var);

return zend_hash_update(Z_ARRVAL_P(sess_var), name, state_val);

}

return NULL;

}

PHPAPI zval *php_get_session_var(zend_string *name)

{

IF_SESSION_VARS() {

return zend_hash_find(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), name);

}

return NULL;

}

PHPAPI zval *php_get_session_var_str(const char *name, size_t name_len)

{

IF_SESSION_VARS() {

return zend_hash_str_find(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), name, name_len);

}

return NULL;

}

static void php_session_track_init(void)

{

zval session_vars;

zend_string *var_name = ZSTR_INIT_LITERAL("_SESSION", false);

/* Unconditionally destroy existing array -- possible dirty data */

zend_delete_global_variable(var_name);

if (!Z_ISUNDEF(PS(http_session_vars))) {

zval_ptr_dtor(&PS(http_session_vars));

}

array_init(&session_vars);

ZVAL_NEW_REF(&PS(http_session_vars), &session_vars);

Z_ADDREF_P(&PS(http_session_vars));

zend_hash_update_ind(&EG(symbol_table), var_name, &PS(http_session_vars));

zend_string_release_ex(var_name, false);

}

static zend_string *php_session_encode(void)

{

IF_SESSION_VARS() {

ZEND_ASSERT(PS(serializer));

return PS(serializer)->encode();

} else {

php_error_docref(NULL, E_WARNING, "Cannot encode non-existent session");

}

return NULL;

}

static ZEND_COLD void php_session_cancel_decode(void)

{

php_session_destroy();

php_session_track_init();

php_error_docref(NULL, E_WARNING, "Failed to decode session object. Session has been destroyed");

}

static zend_result php_session_decode(const zend_string *data)

{

ZEND_ASSERT(PS(serializer));

zend_result result = SUCCESS;

zend_try {

if (PS(serializer)->decode(ZSTR_VAL(data), ZSTR_LEN(data)) == FAILURE) {

php_session_cancel_decode();

result = FAILURE;

}

} zend_catch {

php_session_cancel_decode();

zend_bailout();

} zend_end_try();

return result;

}

/*

* Note that we cannot use the BASE64 alphabet here, because

* it contains "/" and "+": both are unacceptable for simple inclusion

* into URLs.

*/

static const char hexconvtab[] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ,-";

static void bin_to_readable(const unsigned char *in, size_t inlen, char *out, size_t outlen, char nbits)

{

const unsigned char *p = in;

const unsigned char *end_p = in + inlen;

unsigned short w = 0;

int have = 0;

const int mask = (1 << nbits) - 1;

while (outlen--) {

if (have < nbits) {

if (p < end_p) {

w |= *p++ << have;

have += 8;

} else {

/* Should never happen. Input must be large enough. */

ZEND_UNREACHABLE();

break;

}

}

/* consume nbits */

*out++ = hexconvtab[w & mask];

w >>= nbits;

have -= nbits;

}

*out = '\0';

}

PHPAPI zend_string *php_session_create_id(PS_CREATE_SID_ARGS)

{

unsigned char rbuf[PS_MAX_SID_LENGTH];

zend_string *outid;

/* It would be enough to read ceil(sid_length * sid_bits_per_character / 8) bytes here.

* We read sid_length bytes instead for simplicity. */

if (php_random_bytes_throw(rbuf, PS(sid_length)) == FAILURE) {

return NULL;

}

outid = zend_string_alloc(PS(sid_length), false);

bin_to_readable(

rbuf, PS(sid_length),

ZSTR_VAL(outid), ZSTR_LEN(outid),

(char)PS(sid_bits_per_character));

return outid;

}

/* Default session id char validation function allowed by ps_modules.

* If you change the logic here, please also update the error message in

* ps_modules appropriately */

PHPAPI zend_result php_session_valid_key(const char *key)

{

size_t key_len;

const char *p;

char c;

for (p = key; (c = *p); p++) {

/* valid characters are [a-z], [A-Z], [0-9], - (hyphen) and , (comma) */

if (!((c >= 'a' && c <= 'z')

|| (c >= 'A' && c <= 'Z')

|| (c >= '0' && c <= '9')

|| c == ','

|| c == '-')) {

return FAILURE;

}

}

key_len = p - key;

/* Somewhat arbitrary length limit here, but should be way more than

anyone needs and avoids file-level warnings later on if we exceed MAX_PATH */

if (key_len == 0 || key_len > PS_MAX_SID_LENGTH) {

return FAILURE;

}

return SUCCESS;

}

static zend_long php_session_gc(bool immediate)

{

zend_long sessions_deleted = -1;

bool collect = immediate;

/* GC must be done before reading session data. */

if ((PS(mod_data) || PS(mod_user_implemented))) {

/* Use probability-based GC if not forced and probability is configured */

if (!collect && PS(gc_probability) > 0) {

collect = php_random_range(PS(random), 0, PS(gc_divisor) - 1) < PS(gc_probability);

}

if (collect) {

PS(mod)->s_gc(&PS(mod_data), PS(gc_maxlifetime), &sessions_deleted);

}

}

return sessions_deleted;

}

static zend_result php_session_initialize(void)

{

zend_string *val = NULL;

PS(session_status) = php_session_active;

if (!PS(mod)) {

PS(session_status) = php_session_disabled;

php_error_docref(NULL, E_WARNING, "No storage module chosen - failed to initialize session");

return FAILURE;

}

/* Open session handler first */

if (PS(mod)->s_open(&PS(mod_data), PS(save_path), PS(session_name)) == FAILURE

/* || PS(mod_data) == NULL */ /* FIXME: open must set valid PS(mod_data) with success */

) {

php_session_abort();

if (!EG(exception)) {

php_error_docref(NULL, E_WARNING, "Failed to initialize storage module: %s (path: %s)", PS(mod)->s_name, ZSTR_VAL(PS(save_path)));

}

return FAILURE;

}

/* If there is no ID, use session module to create one */

if (!PS(id) || !ZSTR_VAL(PS(id))[0]) {

if (PS(id)) {

zend_string_release_ex(PS(id), false);

}

PS(id) = PS(mod)->s_create_sid(&PS(mod_data));

if (!PS(id)) {

php_session_abort();

if (!EG(exception)) {

zend_throw_error(NULL, "Failed to create session ID: %s (path: %s)", PS(mod)->s_name, ZSTR_VAL(PS(save_path)));

}

return FAILURE;

}

if (PS(use_cookies)) {

PS(send_cookie) = true;

}

} else if (PS(use_strict_mode) && PS(mod)->s_validate_sid &&

PS(mod)->s_validate_sid(&PS(mod_data), PS(id)) == FAILURE

) {

if (PS(id)) {

zend_string_release_ex(PS(id), false);

}

PS(id) = PS(mod)->s_create_sid(&PS(mod_data));

if (!PS(id)) {

PS(id) = php_session_create_id(NULL);

}

if (PS(use_cookies)) {

PS(send_cookie) = true;

}

}

if (php_session_reset_id() == FAILURE) {

php_session_abort();

return FAILURE;

}

/* Read data */

php_session_track_init();

if (PS(mod)->s_read(&PS(mod_data), PS(id), &val, PS(gc_maxlifetime)) == FAILURE) {

php_session_abort();

/* FYI: Some broken save handlers return FAILURE for non-existent session ID, this is incorrect */

if (!EG(exception)) {

php_error_docref(NULL, E_WARNING, "Failed to read session data: %s (path: %s)", PS(mod)->s_name, ZSTR_VAL(PS(save_path)));

}

return FAILURE;

}

/* GC must be done after read */

php_session_gc(false);

if (PS(session_vars)) {

zend_string_release_ex(PS(session_vars), false);

PS(session_vars) = NULL;

}

if (val) {

if (PS(lazy_write)) {

PS(session_vars) = zend_string_copy(val);

}

php_session_decode(val);

zend_string_release_ex(val, false);

}

php_session_cleanup_filename();

zend_string *session_started_filename = zend_get_executed_filename_ex();

if (session_started_filename != NULL) {

PS(session_started_filename) = zend_string_copy(session_started_filename);

PS(session_started_lineno) = zend_get_executed_lineno();

}

return SUCCESS;

}

static void php_session_save_current_state(bool write)

{

zend_result ret = FAILURE;

if (write) {

IF_SESSION_VARS() {

zval *handler_function = &PS(mod_user_names).ps_write;

if (PS(mod_data) || PS(mod_user_implemented)) {

zend_string *val = php_session_encode();

/* Not being able to encode the session data means there is some kind of issue that prevents a write

* (e.g. a key containing the '|' character with the default serialization) */

if (UNEXPECTED(val == NULL)) {

return;

}

if (PS(lazy_write) && PS(session_vars)

&& PS(mod)->s_update_timestamp

&& PS(mod)->s_update_timestamp != php_session_update_timestamp

&& zend_string_equals(val, PS(session_vars))

) {

ret = PS(mod)->s_update_timestamp(&PS(mod_data), PS(id), val, PS(gc_maxlifetime));

handler_function = &PS(mod_user_names).ps_update_timestamp;

} else {

ret = PS(mod)->s_write(&PS(mod_data), PS(id), val, PS(gc_maxlifetime));

}

zend_string_release_ex(val, false);

}

if ((ret == FAILURE) && !EG(exception)) {

if (!PS(mod_user_implemented)) {

php_error_docref(NULL, E_WARNING, "Failed to write session data (%s). Please "

"verify that the current setting of session.save_path "

"is correct (%s)",

PS(mod)->s_name,

ZSTR_VAL(PS(save_path)));

} else {

zend_string *callable_name = zend_get_callable_name(handler_function);

php_error_docref(NULL, E_WARNING, "Failed to write session data using user "

"defined save handler. (session.save_path: %s, handler: %s)", ZSTR_VAL(PS(save_path)),

ZSTR_VAL(callable_name));

zend_string_release_ex(callable_name, false);

}

}

}

}

if (PS(mod_data) || PS(mod_user_implemented)) {

PS(mod)->s_close(&PS(mod_data));

}

}

static void php_session_normalize_vars(void)

{

IF_SESSION_VARS() {

PS_ENCODE_LOOP(

if (Z_TYPE_P(struc) == IS_PTR) {

zval *zv = (zval *)Z_PTR_P(struc);

ZVAL_COPY_VALUE(struc, zv);

ZVAL_UNDEF(zv);

}

);

}

}

/* *************************

* INI Settings/Handlers *

************************* */

static PHP_INI_MH(OnUpdateSaveHandler)

{

const ps_module *new_module;

int err_type = E_ERROR;

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

new_module = _php_find_ps_module(ZSTR_VAL(new_value));

if (stage == ZEND_INI_STAGE_RUNTIME) {

err_type = E_WARNING;

}

if (PG(modules_activated) && !new_module) {

/* Do not output error when restoring ini options. */

if (stage != ZEND_INI_STAGE_DEACTIVATE) {

php_error_docref(NULL, err_type, "Session save handler \"%s\" cannot be found", ZSTR_VAL(new_value));

}

return FAILURE;

}

/* "user" save handler should not be set by user */

if (!PS(set_handler) && new_module == ps_user_ptr) {

php_error_docref(NULL, err_type, "Session save handler \"user\" cannot be set by ini_set()");

return FAILURE;

}

PS(default_mod) = PS(mod);

PS(mod) = new_module;

return SUCCESS;

}

static PHP_INI_MH(OnUpdateSerializer)

{

const ps_serializer *new_serializer;

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

new_serializer = _php_find_ps_serializer(ZSTR_VAL(new_value));

if (PG(modules_activated) && !new_serializer) {

int err_type;

if (stage == ZEND_INI_STAGE_RUNTIME) {

err_type = E_WARNING;

} else {

err_type = E_ERROR;

}

/* Do not output error when restoring ini options. */

if (stage != ZEND_INI_STAGE_DEACTIVATE) {

php_error_docref(NULL, err_type, "Serialization handler \"%s\" cannot be found", ZSTR_VAL(new_value));

}

return FAILURE;

}

PS(serializer) = new_serializer;

return SUCCESS;

}

static PHP_INI_MH(OnUpdateSaveDir)

{

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

/* Only do the open_basedir check at runtime */

if (stage == PHP_INI_STAGE_RUNTIME || stage == PHP_INI_STAGE_HTACCESS) {

if (memchr(ZSTR_VAL(new_value), '\0', ZSTR_LEN(new_value)) != NULL) {

return FAILURE;

}

/* we do not use zend_memrchr() since path can contain ; itself */

const char *p = strchr(ZSTR_VAL(new_value), ';');

if (p) {

p++;

const char *p2 = strchr(p, ';');

if (p2) {

p = p2 + 1;

}

} else {

p = ZSTR_VAL(new_value);

}

if (PG(open_basedir) && *p && php_check_open_basedir(p)) {

return FAILURE;

}

}

return OnUpdateStr(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);

}

static PHP_INI_MH(OnUpdateName)

{

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

/* Numeric session.name won't work at all */

if (

ZSTR_LEN(new_value) == 0

|| zend_str_has_nul_byte(new_value)

|| is_numeric_str_function(new_value, NULL, NULL)

|| strpbrk(ZSTR_VAL(new_value), SESSION_FORBIDDEN_CHARS) != NULL

) {

int err_type;

if (stage == ZEND_INI_STAGE_RUNTIME || stage == ZEND_INI_STAGE_ACTIVATE || stage == ZEND_INI_STAGE_STARTUP) {

err_type = E_WARNING;

} else {

err_type = E_ERROR;

}

/* Do not output error when restoring ini options. */

if (stage != ZEND_INI_STAGE_DEACTIVATE) {

php_error_docref(NULL, err_type, "session.name \"%s\" must not be numeric, empty, contain null bytes or any of the following characters \"" SESSION_FORBIDDEN_CHARS_FOR_ERROR_MSG "\"", ZSTR_VAL(new_value));

}

return FAILURE;

}

return OnUpdateStrNotEmpty(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);

}

static PHP_INI_MH(OnUpdateCookieLifetime)

{

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

#ifdef ZEND_ENABLE_ZVAL_LONG64

const zend_long maxcookie = ZEND_LONG_MAX - INT_MAX - 1;

#else

const zend_long maxcookie = ZEND_LONG_MAX / 2 - 1;

#endif

zend_long v = (zend_long)atol(ZSTR_VAL(new_value));

if (v < 0) {

php_error_docref(NULL, E_WARNING, "CookieLifetime cannot be negative");

return FAILURE;

} else if (v > maxcookie) {

return SUCCESS;

}

return OnUpdateLongGEZero(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);

}

static PHP_INI_MH(OnUpdateSessionLong)

{

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

return OnUpdateLong(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);

}

static PHP_INI_MH(OnUpdateSessionStr)

{

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

return OnUpdateStr(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);

}

static PHP_INI_MH(OnUpdateSessionBool)

{

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

return OnUpdateBool(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);

}

static PHP_INI_MH(OnUpdateSidLength)

{

zend_long val;

char *endptr = NULL;

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

val = ZEND_STRTOL(ZSTR_VAL(new_value), &endptr, 10);

if (val != 32) {

php_error_docref("session.configuration", E_DEPRECATED, "session.sid_length INI setting is deprecated");

}

if (!endptr || (*endptr != '\0') || (val < 22) || (val > PS_MAX_SID_LENGTH)) {

php_error_docref(NULL, E_WARNING, "session.configuration \"session.sid_length\" must be between 22 and 256");

return FAILURE;

}

PS(sid_length) = val;

return SUCCESS;

}

static PHP_INI_MH(OnUpdateSidBits)

{

zend_long val;

char *endptr = NULL;

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

val = ZEND_STRTOL(ZSTR_VAL(new_value), &endptr, 10);

if (val != 4) {

php_error_docref("session.configuration", E_DEPRECATED, "session.sid_bits_per_character INI setting is deprecated");

}

if (!endptr || (*endptr != '\0') || (val < 4) || (val > 6)) {

php_error_docref(NULL, E_WARNING, "session.configuration \"session.sid_bits_per_character\" must be between 4 and 6");

return FAILURE;

}

PS(sid_bits_per_character) = val;

return SUCCESS;

}

static PHP_INI_MH(OnUpdateSessionGcProbability)

{

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

zend_long new_probability = zend_ini_parse_quantity_warn(new_value, entry->name);

if (new_probability < 0) {

php_error_docref("session.gc_probability", E_WARNING, "session.gc_probability must be greater than or equal to 0");

return FAILURE;

}

zend_long *p = ZEND_INI_GET_ADDR();

*p = new_probability;

return SUCCESS;

}

static PHP_INI_MH(OnUpdateSessionDivisor)

{

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

zend_long new_divisor = zend_ini_parse_quantity_warn(new_value, entry->name);

if (new_divisor <= 0) {

php_error_docref("session.gc_divisor", E_WARNING, "session.gc_divisor must be greater than 0");

return FAILURE;

}

zend_long *p = ZEND_INI_GET_ADDR();

*p = new_divisor;

return SUCCESS;

}

static PHP_INI_MH(OnUpdateRfc1867Freq)

{

int new_freq = ZEND_ATOL(ZSTR_VAL(new_value));

if (new_freq < 0) {

php_error_docref(NULL, E_WARNING, "session.upload_progress.freq must be greater than or equal to 0");

return FAILURE;

}

if (ZSTR_LEN(new_value) > 0 && ZSTR_VAL(new_value)[ZSTR_LEN(new_value) - 1] == '%') {

if (new_freq > 100) {

php_error_docref(NULL, E_WARNING, "session.upload_progress.freq must be less than or equal to 100%%");

return FAILURE;

}

PS(rfc1867_freq) = -new_freq;

} else {

PS(rfc1867_freq) = new_freq;

}

return SUCCESS;

}

static PHP_INI_MH(OnUpdateUseOnlyCookies)

{

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

bool *p = ZEND_INI_GET_ADDR();

*p = zend_ini_parse_bool(new_value);

if (!*p) {

php_error_docref("session.configuration", E_DEPRECATED, "Disabling session.use_only_cookies INI setting is deprecated");

}

return SUCCESS;

}

static PHP_INI_MH(OnUpdateUseTransSid)

{

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

bool *p = ZEND_INI_GET_ADDR();

*p = zend_ini_parse_bool(new_value);

if (*p) {

php_error_docref("session.configuration", E_DEPRECATED, "Enabling session.use_trans_sid INI setting is deprecated");

}

return SUCCESS;

}

static PHP_INI_MH(OnUpdateRefererCheck)

{

SESSION_CHECK_ACTIVE_STATE;

SESSION_CHECK_OUTPUT_STATE;

if (ZSTR_LEN(new_value) != 0) {

php_error_docref("session.configuration", E_DEPRECATED, "Usage of session.referer_check INI setting is deprecated");

}

return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);

}

PHP_INI_BEGIN()

STD_PHP_INI_ENTRY("session.save_path", "", PHP_INI_ALL, OnUpdateSaveDir, save_path, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.name", "PHPSESSID", PHP_INI_ALL, OnUpdateName, session_name, php_ps_globals, ps_globals)

PHP_INI_ENTRY("session.save_handler", "files", PHP_INI_ALL, OnUpdateSaveHandler)

STD_PHP_INI_BOOLEAN("session.auto_start", "0", PHP_INI_PERDIR, OnUpdateBool, auto_start, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.gc_probability", "1", PHP_INI_ALL, OnUpdateSessionGcProbability, gc_probability, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.gc_divisor", "100", PHP_INI_ALL, OnUpdateSessionDivisor, gc_divisor, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.gc_maxlifetime", "1440", PHP_INI_ALL, OnUpdateSessionLong, gc_maxlifetime, php_ps_globals, ps_globals)

PHP_INI_ENTRY("session.serialize_handler", "php", PHP_INI_ALL, OnUpdateSerializer)

STD_PHP_INI_ENTRY("session.cookie_lifetime", "0", PHP_INI_ALL, OnUpdateCookieLifetime, cookie_lifetime, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.cookie_path", "/", PHP_INI_ALL, OnUpdateSessionStr, cookie_path, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.cookie_domain", "", PHP_INI_ALL, OnUpdateSessionStr, cookie_domain, php_ps_globals, ps_globals)

STD_PHP_INI_BOOLEAN("session.cookie_secure", "0", PHP_INI_ALL, OnUpdateSessionBool, cookie_secure, php_ps_globals, ps_globals)

STD_PHP_INI_BOOLEAN("session.cookie_partitioned", "0", PHP_INI_ALL, OnUpdateSessionBool, cookie_partitioned, php_ps_globals, ps_globals)

STD_PHP_INI_BOOLEAN("session.cookie_httponly", "0", PHP_INI_ALL, OnUpdateSessionBool, cookie_httponly, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.cookie_samesite", "", PHP_INI_ALL, OnUpdateSessionStr, cookie_samesite, php_ps_globals, ps_globals)

STD_PHP_INI_BOOLEAN("session.use_cookies", "1", PHP_INI_ALL, OnUpdateSessionBool, use_cookies, php_ps_globals, ps_globals)

STD_PHP_INI_BOOLEAN("session.use_only_cookies", "1", PHP_INI_ALL, OnUpdateUseOnlyCookies, use_only_cookies, php_ps_globals, ps_globals)

STD_PHP_INI_BOOLEAN("session.use_strict_mode", "0", PHP_INI_ALL, OnUpdateSessionBool, use_strict_mode, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.referer_check", "", PHP_INI_ALL, OnUpdateRefererCheck, extern_referer_chk, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.cache_limiter", "nocache", PHP_INI_ALL, OnUpdateSessionStr, cache_limiter, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.cache_expire", "180", PHP_INI_ALL, OnUpdateSessionLong, cache_expire, php_ps_globals, ps_globals)

STD_PHP_INI_BOOLEAN("session.use_trans_sid", "0", PHP_INI_ALL, OnUpdateUseTransSid, use_trans_sid, php_ps_globals, ps_globals)

PHP_INI_ENTRY("session.sid_length", "32", PHP_INI_ALL, OnUpdateSidLength)

PHP_INI_ENTRY("session.sid_bits_per_character", "4", PHP_INI_ALL, OnUpdateSidBits)

STD_PHP_INI_BOOLEAN("session.lazy_write", "1", PHP_INI_ALL, OnUpdateSessionBool, lazy_write, php_ps_globals, ps_globals)

/* Upload progress */

STD_PHP_INI_BOOLEAN("session.upload_progress.enabled",

"1", ZEND_INI_PERDIR, OnUpdateBool, rfc1867_enabled, php_ps_globals, ps_globals)

STD_PHP_INI_BOOLEAN("session.upload_progress.cleanup",

"1", ZEND_INI_PERDIR, OnUpdateBool, rfc1867_cleanup, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.upload_progress.prefix",

"upload_progress_", ZEND_INI_PERDIR, OnUpdateStr, rfc1867_prefix, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.upload_progress.name",

"PHP_SESSION_UPLOAD_PROGRESS", ZEND_INI_PERDIR, OnUpdateStr, rfc1867_name, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.upload_progress.freq", "1%", ZEND_INI_PERDIR, OnUpdateRfc1867Freq, rfc1867_freq, php_ps_globals, ps_globals)

STD_PHP_INI_ENTRY("session.upload_progress.min_freq",

"1", ZEND_INI_PERDIR, OnUpdateReal, rfc1867_min_freq,php_ps_globals, ps_globals)

/* Commented out until future discussion */

/* PHP_INI_ENTRY("session.encode_sources", "globals,track", PHP_INI_ALL, NULL) */

PHP_INI_END()

/* ***************

* Serializers *

*************** */

PS_SERIALIZER_ENCODE_FUNC(php_serialize)

{

smart_str buf = {0};

php_serialize_data_t var_hash;

IF_SESSION_VARS() {

PHP_VAR_SERIALIZE_INIT(var_hash);

php_var_serialize(&buf, Z_REFVAL(PS(http_session_vars)), &var_hash);

PHP_VAR_SERIALIZE_DESTROY(var_hash);

}

return smart_str_extract(&buf);

}

PS_SERIALIZER_DECODE_FUNC(php_serialize)

{

const char *endptr = val + vallen;

zval session_vars;

php_unserialize_data_t var_hash;

bool result;

zend_string *var_name = ZSTR_INIT_LITERAL("_SESSION", false);

ZVAL_NULL(&session_vars);

PHP_VAR_UNSERIALIZE_INIT(var_hash);

result = php_var_unserialize(

&session_vars, (const unsigned char **)&val, (const unsigned char *)endptr, &var_hash);

PHP_VAR_UNSERIALIZE_DESTROY(var_hash);

if (!result) {

zval_ptr_dtor(&session_vars);

ZVAL_NULL(&session_vars);

}

if (!Z_ISUNDEF(PS(http_session_vars))) {

zval_ptr_dtor(&PS(http_session_vars));

}

if (Z_TYPE(session_vars) == IS_NULL) {

array_init(&session_vars);

}

ZVAL_NEW_REF(&PS(http_session_vars), &session_vars);

Z_ADDREF_P(&PS(http_session_vars));

zend_hash_update_ind(&EG(symbol_table), var_name, &PS(http_session_vars));

zend_string_release_ex(var_name, false);

return result || !vallen ? SUCCESS : FAILURE;

}

#define PS_BIN_NR_OF_BITS 8

#define PS_BIN_UNDEF (1<<(PS_BIN_NR_OF_BITS-1))

#define PS_BIN_MAX (PS_BIN_UNDEF-1)

PS_SERIALIZER_ENCODE_FUNC(php_binary)

{

smart_str buf = {0};

php_serialize_data_t var_hash;

PHP_VAR_SERIALIZE_INIT(var_hash);

PS_ENCODE_LOOP(

if (ZSTR_LEN(key) > PS_BIN_MAX) continue;

smart_str_appendc(&buf, (unsigned char)ZSTR_LEN(key));

smart_str_append(&buf, key);

php_var_serialize(&buf, struc, &var_hash);