zend_string *suhosin_encrypt_single_cookie(char *name, int name_len, char *value, int value_len, char *key)
{
int l;
name = estrndup(name, name_len);
name_len = php_url_decode(name, name_len);
suhosin_normalize_varname(name);
name_len = strlen(name);
if ((SUHOSIN7_G(cookie_plainlist) && zend_hash_str_exists(SUHOSIN7_G(cookie_plainlist), name, name_len)) ||
(SUHOSIN7_G(cookie_plainlist) == NULL && SUHOSIN7_G(cookie_cryptlist) && !zend_hash_str_exists(SUHOSIN7_G(cookie_cryptlist), name, name_len))) {
efree(name);
return zend_string_init(value, value_len, 0);
}
value = estrndup(value, value_len);
value_len = php_url_decode(value, value_len);
zend_string *d = suhosin_encrypt_string(value, value_len, name, name_len, key);
zend_string *d_url = php_url_encode(ZSTR_VAL(d), ZSTR_LEN(d));
zend_string_release(d);
efree(name);
efree(value);
return d_url;
}
/**
* Checks if property exists on object
*/
int zephir_isset_property(zval *object, const char *property_name, unsigned int property_length)
{
if (Z_TYPE_P(object) == IS_OBJECT) {
if (likely(zend_hash_str_exists(&Z_OBJCE_P(object)->properties_info, property_name, property_length))) {
return 1;
}
return zend_hash_str_exists(Z_OBJ_HT_P(object)->get_properties(object), property_name, property_length);
}
return 0;
}
/**
* Checks if string property exists on object
*/
int zephir_isset_property_zval(zval *object, const zval *property)
{
if (Z_TYPE_P(object) == IS_OBJECT) {
if (Z_TYPE_P(property) == IS_STRING) {
if (likely(zend_hash_str_exists(&Z_OBJCE_P(object)->properties_info, Z_STRVAL_P(property), Z_STRLEN_P(property)))) {
return 1;
} else {
return zend_hash_str_exists(Z_OBJ_HT_P(object)->get_properties(object), Z_STRVAL_P(property), Z_STRLEN_P(property));
}
}
}
return 0;
}
static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements)
{
zval retval;
zval fname;
HashTable *ht;
if (Z_TYPE_P(rval) != IS_OBJECT) {
return 0;
}
ht = Z_OBJPROP_P(rval);
zend_hash_extend(ht, zend_hash_num_elements(ht) + elements, (ht->u.flags & HASH_FLAG_PACKED));
if (!process_nested_data(UNSERIALIZE_PASSTHRU, ht, elements, 1)) {
return 0;
}
ZVAL_DEREF(rval);
if (Z_OBJCE_P(rval) != PHP_IC_ENTRY &&
zend_hash_str_exists(&Z_OBJCE_P(rval)->function_table, "__wakeup", sizeof("__wakeup")-1)) {
ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1);
BG(serialize_lock)++;
call_user_function_ex(CG(function_table), rval, &fname, &retval, 0, 0, 1, NULL);
BG(serialize_lock)--;
zval_dtor(&fname);
zval_dtor(&retval);
}
if (EG(exception)) {
return 0;
}
return finish_nested_data(UNSERIALIZE_PASSTHRU);
}
static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements)
{
zval retval;
zval fname;
if (Z_TYPE_P(rval) != IS_OBJECT) {
return 0;
}
//??? TODO: resize before
if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_OBJPROP_P(rval), elements, 1)) {
return 0;
}
ZVAL_DEREF(rval);
if (Z_OBJCE_P(rval) != PHP_IC_ENTRY &&
zend_hash_str_exists(&Z_OBJCE_P(rval)->function_table, "__wakeup", sizeof("__wakeup")-1)) {
ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1);
BG(serialize_lock)++;
call_user_function_ex(CG(function_table), rval, &fname, &retval, 0, 0, 1, NULL);
BG(serialize_lock)--;
zval_dtor(&fname);
zval_dtor(&retval);
}
if (EG(exception)) {
return 0;
}
return finish_nested_data(UNSERIALIZE_PASSTHRU);
}
/**
* Check if a function exists using explicit char param (using precomputed hash key)
*/
int zephir_function_quick_exists_ex(const char *method_name, unsigned int method_len)
{
if (zend_hash_str_exists(CG(function_table), method_name, method_len)) {
return SUCCESS;
}
return FAILURE;
}
PDO_API void php_pdo_unregister_driver(pdo_driver_t *driver) /* {{{ */
{
if (!zend_hash_str_exists(&module_registry, "pdo", sizeof("pdo") - 1)) {
return;
}
zend_hash_str_del(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len);
}
char *suhosin_decrypt_single_cookie(char *name, int name_len, char *value, int value_len, char *key, char **out)
{
char *name2 = estrndup(name, name_len);
int name2_len = php_url_decode(name2, name_len);
suhosin_normalize_varname(name2);
name2_len = strlen(name2);
if ((SUHOSIN7_G(cookie_plainlist) && zend_hash_str_exists(SUHOSIN7_G(cookie_plainlist), name2, name2_len)) ||
(SUHOSIN7_G(cookie_plainlist) == NULL && SUHOSIN7_G(cookie_cryptlist) && !zend_hash_str_exists(SUHOSIN7_G(cookie_cryptlist), name2, name2_len))) {
// if (1) {
efree(name2);
memcpy(*out, name, name_len);
*out += name_len;
**out = '='; *out +=1;
memcpy(*out, value, value_len);
*out += value_len;
return *out;
}
value = estrndup(value, value_len);
value_len = php_url_decode(value, value_len);
zend_string *d = suhosin_decrypt_string(value, value_len, name2, name2_len, key, SUHOSIN7_G(cookie_checkraddr));
if (d) {
zend_string *d_url = php_url_encode(ZSTR_VAL(d), ZSTR_LEN(d));
zend_string_release(d);
memcpy(*out, name, name_len);
*out += name_len;
**out = '='; *out += 1;
memcpy(*out, ZSTR_VAL(d_url), ZSTR_LEN(d_url));
*out += ZSTR_LEN(d_url);
zend_string_release(d_url);
}
efree(name2);
efree(value);
return *out;
}
/* Upgly hack to fix HTTP_PROXY issue, see bug #72573 */
static void check_http_proxy(HashTable *var_table)
{
if (zend_hash_str_exists(var_table, "HTTP_PROXY", sizeof("HTTP_PROXY")-1)) {
char *local_proxy = getenv("HTTP_PROXY");
if (!local_proxy) {
zend_hash_str_del(var_table, "HTTP_PROXY", sizeof("HTTP_PROXY")-1);
} else {
zval local_zval;
ZVAL_STRING(&local_zval, local_proxy);
zend_hash_str_update(var_table, "HTTP_PROXY", sizeof("HTTP_PROXY")-1, &local_zval);
}
}
}
PDO_API int php_pdo_register_driver(pdo_driver_t *driver) /* {{{ */
{
if (driver->api_version != PDO_DRIVER_API) {
zend_error(E_ERROR, "PDO: driver %s requires PDO API version %pd; this is PDO version %d",
driver->driver_name, driver->api_version, PDO_DRIVER_API);
return FAILURE;
}
if (!zend_hash_str_exists(&module_registry, "pdo", sizeof("pdo") - 1)) {
zend_error(E_ERROR, "You MUST load PDO before loading any PDO drivers");
return FAILURE; /* NOTREACHED */
}
return zend_hash_str_add_ptr(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len, driver) != NULL;
}
int zephir_method_exists_ex(const zval *object, const char *method_name, unsigned int method_len)
{
zend_class_entry *ce;
if (likely(Z_TYPE_P(object) == IS_OBJECT)) {
ce = Z_OBJCE_P(object);
} else {
if (Z_TYPE_P(object) == IS_STRING) {
ce = zend_fetch_class(Z_STR_P(object), ZEND_FETCH_CLASS_DEFAULT);
} else {
return FAILURE;
}
}
while (ce) {
if (zend_hash_str_exists(&ce->function_table, method_name, method_len)) {
return SUCCESS;
}
ce = ce->parent;
}
return FAILURE;
}
static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements)
{
HashTable *ht;
zend_bool has_wakeup;
if (Z_TYPE_P(rval) != IS_OBJECT) {
return 0;
}
has_wakeup = Z_OBJCE_P(rval) != PHP_IC_ENTRY
&& zend_hash_str_exists(&Z_OBJCE_P(rval)->function_table, "__wakeup", sizeof("__wakeup")-1);
ht = Z_OBJPROP_P(rval);
if (elements >= (zend_long)(HT_MAX_SIZE - zend_hash_num_elements(ht))) {
return 0;
}
zend_hash_extend(ht, zend_hash_num_elements(ht) + elements, (ht->u.flags & HASH_FLAG_PACKED));
if (!process_nested_data(UNSERIALIZE_PASSTHRU, ht, elements, 1)) {
if (has_wakeup) {
ZVAL_DEREF(rval);
GC_FLAGS(Z_OBJ_P(rval)) |= IS_OBJ_DESTRUCTOR_CALLED;
}
return 0;
}
ZVAL_DEREF(rval);
if (has_wakeup) {
/* Delay __wakeup call until end of serialization */
zval *wakeup_var = var_tmp_var(var_hash);
ZVAL_COPY(wakeup_var, rval);
Z_EXTRA_P(wakeup_var) = VAR_WAKEUP_FLAG;
}
return finish_nested_data(UNSERIALIZE_PASSTHRU);
}
static inline int phpdbg_call_register(phpdbg_param_t *stack) /* {{{ */
{
phpdbg_param_t *name = NULL;
if (stack->type == STACK_PARAM) {
char *lc_name;
name = stack->next;
if (!name || name->type != STR_PARAM) {
return FAILURE;
}
lc_name = zend_str_tolower_dup(name->str, name->len);
if (zend_hash_str_exists(&PHPDBG_G(registered), lc_name, name->len)) {
zval fretval;
zend_fcall_info fci;
memset(&fci, 0, sizeof(zend_fcall_info));
ZVAL_STRINGL(&fci.function_name, lc_name, name->len);
fci.size = sizeof(zend_fcall_info);
fci.function_table = &PHPDBG_G(registered);
fci.symbol_table = zend_rebuild_symbol_table();
fci.object = NULL;
fci.retval = &fretval;
fci.no_separation = 1;
if (name->next) {
zval params;
phpdbg_param_t *next = name->next;
array_init(¶ms);
while (next) {
char *buffered = NULL;
switch (next->type) {
case OP_PARAM:
case COND_PARAM:
case STR_PARAM:
add_next_index_stringl(¶ms, next->str, next->len);
break;
case NUMERIC_PARAM:
add_next_index_long(¶ms, next->num);
break;
case METHOD_PARAM:
spprintf(&buffered, 0, "%s::%s", next->method.class, next->method.name);
add_next_index_string(¶ms, buffered);
break;
case NUMERIC_METHOD_PARAM:
spprintf(&buffered, 0, "%s::%s#%ld", next->method.class, next->method.name, next->num);
add_next_index_string(¶ms, buffered);
break;
case NUMERIC_FUNCTION_PARAM:
spprintf(&buffered, 0, "%s#%ld", next->str, next->num);
add_next_index_string(¶ms, buffered);
break;
case FILE_PARAM:
spprintf(&buffered, 0, "%s:%ld", next->file.name, next->file.line);
add_next_index_string(¶ms, buffered);
break;
case NUMERIC_FILE_PARAM:
spprintf(&buffered, 0, "%s:#%ld", next->file.name, next->file.line);
add_next_index_string(¶ms, buffered);
break;
default: {
/* not yet */
}
}
next = next->next;
}
zend_fcall_info_args(&fci, ¶ms);
} else {
static void phar_file_stat(const char *filename, php_stat_len filename_length, int type, void (*orig_stat_func)(INTERNAL_FUNCTION_PARAMETERS), INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
{
if (!filename_length) {
RETURN_FALSE;
}
if (!IS_ABSOLUTE_PATH(filename, filename_length) && !strstr(filename, "://")) {
char *arch, *entry, *fname;
int arch_len, entry_len, fname_len;
zend_stat_t sb = {0};
phar_entry_info *data = NULL;
phar_archive_data *phar;
fname = (char*)zend_get_executed_filename();
/* we are checking for existence of a file within the relative path. Chances are good that this is
retrieving something from within the phar archive */
if (strncasecmp(fname, "phar://", 7)) {
goto skip_phar;
}
fname_len = strlen(fname);
if (PHAR_G(last_phar) && fname_len - 7 >= PHAR_G(last_phar_name_len) && !memcmp(fname + 7, PHAR_G(last_phar_name), PHAR_G(last_phar_name_len))) {
arch = estrndup(PHAR_G(last_phar_name), PHAR_G(last_phar_name_len));
arch_len = PHAR_G(last_phar_name_len);
entry = estrndup(filename, filename_length);
/* fopen within phar, if :// is not in the url, then prepend phar://<archive>/ */
entry_len = (int) filename_length;
phar = PHAR_G(last_phar);
goto splitted;
}
if (SUCCESS == phar_split_fname(fname, fname_len, &arch, &arch_len, &entry, &entry_len, 2, 0)) {
efree(entry);
entry = estrndup(filename, filename_length);
/* fopen within phar, if :// is not in the url, then prepend phar://<archive>/ */
entry_len = (int) filename_length;
if (FAILURE == phar_get_archive(&phar, arch, arch_len, NULL, 0, NULL)) {
efree(arch);
efree(entry);
goto skip_phar;
}
splitted:
entry = phar_fix_filepath(entry, &entry_len, 1);
if (entry[0] == '/') {
if (NULL != (data = zend_hash_str_find_ptr(&(phar->manifest), entry + 1, entry_len - 1))) {
efree(entry);
goto stat_entry;
}
goto notfound;
}
if (NULL != (data = zend_hash_str_find_ptr(&(phar->manifest), entry, entry_len))) {
efree(entry);
goto stat_entry;
}
if (zend_hash_str_exists(&(phar->virtual_dirs), entry, entry_len)) {
efree(entry);
efree(arch);
if (IS_EXISTS_CHECK(type)) {
RETURN_TRUE;
}
sb.st_size = 0;
sb.st_mode = 0777;
sb.st_mode |= S_IFDIR; /* regular directory */
#ifdef NETWARE
sb.st_mtime.tv_sec = phar->max_timestamp;
sb.st_atime.tv_sec = phar->max_timestamp;
sb.st_ctime.tv_sec = phar->max_timestamp;
#else
sb.st_mtime = phar->max_timestamp;
sb.st_atime = phar->max_timestamp;
sb.st_ctime = phar->max_timestamp;
#endif
goto statme_baby;
} else {
char *save;
int save_len;
notfound:
efree(entry);
save = PHAR_G(cwd);
save_len = PHAR_G(cwd_len);
/* this file is not in the current directory, use the original path */
entry = estrndup(filename, filename_length);
entry_len = filename_length;
PHAR_G(cwd) = "/";
PHAR_G(cwd_len) = 0;
/* clean path without cwd */
entry = phar_fix_filepath(entry, &entry_len, 1);
if (NULL != (data = zend_hash_str_find_ptr(&(phar->manifest), entry + 1, entry_len - 1))) {
PHAR_G(cwd) = save;
PHAR_G(cwd_len) = save_len;
efree(entry);
if (IS_EXISTS_CHECK(type)) {
efree(arch);
RETURN_TRUE;
}
goto stat_entry;
}
if (zend_hash_str_exists(&(phar->virtual_dirs), entry + 1, entry_len - 1)) {
PHAR_G(cwd) = save;
PHAR_G(cwd_len) = save_len;
efree(entry);
efree(arch);
if (IS_EXISTS_CHECK(type)) {
RETURN_TRUE;
}
sb.st_size = 0;
sb.st_mode = 0777;
sb.st_mode |= S_IFDIR; /* regular directory */
#ifdef NETWARE
sb.st_mtime.tv_sec = phar->max_timestamp;
sb.st_atime.tv_sec = phar->max_timestamp;
sb.st_ctime.tv_sec = phar->max_timestamp;
#else
sb.st_mtime = phar->max_timestamp;
sb.st_atime = phar->max_timestamp;
sb.st_ctime = phar->max_timestamp;
#endif
goto statme_baby;
}
PHAR_G(cwd) = save;
PHAR_G(cwd_len) = save_len;
efree(entry);
efree(arch);
/* Error Occurred */
if (!IS_EXISTS_CHECK(type)) {
php_error_docref(NULL, E_WARNING, "%sstat failed for %s", IS_LINK_OPERATION(type) ? "L" : "", filename);
}
RETURN_FALSE;
}
stat_entry:
efree(arch);
if (!data->is_dir) {
sb.st_size = data->uncompressed_filesize;
sb.st_mode = data->flags & PHAR_ENT_PERM_MASK;
if (data->link) {
sb.st_mode |= S_IFREG|S_IFLNK; /* regular file */
} else {
sb.st_mode |= S_IFREG; /* regular file */
}
/* timestamp is just the timestamp when this was added to the phar */
#ifdef NETWARE
sb.st_mtime.tv_sec = data->timestamp;
sb.st_atime.tv_sec = data->timestamp;
sb.st_ctime.tv_sec = data->timestamp;
#else
sb.st_mtime = data->timestamp;
sb.st_atime = data->timestamp;
sb.st_ctime = data->timestamp;
#endif
} else {
sb.st_size = 0;
sb.st_mode = data->flags & PHAR_ENT_PERM_MASK;
sb.st_mode |= S_IFDIR; /* regular directory */
if (data->link) {
sb.st_mode |= S_IFLNK;
}
/* timestamp is just the timestamp when this was added to the phar */
#ifdef NETWARE
sb.st_mtime.tv_sec = data->timestamp;
sb.st_atime.tv_sec = data->timestamp;
sb.st_ctime.tv_sec = data->timestamp;
#else
sb.st_mtime = data->timestamp;
sb.st_atime = data->timestamp;
sb.st_ctime = data->timestamp;
#endif
}
statme_baby:
if (!phar->is_writeable) {
sb.st_mode = (sb.st_mode & 0555) | (sb.st_mode & ~0777);
}
sb.st_nlink = 1;
sb.st_rdev = -1;
/* this is only for APC, so use /dev/null device - no chance of conflict there! */
sb.st_dev = 0xc;
/* generate unique inode number for alias/filename, so no phars will conflict */
if (data) {
sb.st_ino = data->inode;
}
#ifndef PHP_WIN32
sb.st_blksize = -1;
sb.st_blocks = -1;
#endif
phar_fancy_stat(&sb, type, return_value);
return;
}
}
skip_phar:
orig_stat_func(INTERNAL_FUNCTION_PARAM_PASSTHRU);
return;
}
php_stream_filter_status_t userfilter_filter(
php_stream *stream,
php_stream_filter *thisfilter,
php_stream_bucket_brigade *buckets_in,
php_stream_bucket_brigade *buckets_out,
size_t *bytes_consumed,
int flags
)
{
int ret = PSFS_ERR_FATAL;
zval *obj = &thisfilter->abstract;
zval func_name;
zval retval;
zval args[4];
zval zpropname;
int call_result;
/* the userfilter object probably doesn't exist anymore */
if (CG(unclean_shutdown)) {
return ret;
}
if (!zend_hash_str_exists(Z_OBJPROP_P(obj), "stream", sizeof("stream")-1)) {
zval tmp;
/* Give the userfilter class a hook back to the stream */
php_stream_to_zval(stream, &tmp);
zval_copy_ctor(&tmp);
add_property_zval(obj, "stream", &tmp);
/* add_property_zval increments the refcount which is unwanted here */
zval_ptr_dtor(&tmp);
}
ZVAL_STRINGL(&func_name, "filter", sizeof("filter")-1);
/* Setup calling arguments */
ZVAL_RES(&args[0], zend_register_resource(buckets_in, le_bucket_brigade));
ZVAL_RES(&args[1], zend_register_resource(buckets_out, le_bucket_brigade));
if (bytes_consumed) {
ZVAL_LONG(&args[2], *bytes_consumed);
} else {
ZVAL_NULL(&args[2]);
}
ZVAL_BOOL(&args[3], flags & PSFS_FLAG_FLUSH_CLOSE);
call_result = call_user_function_ex(NULL,
obj,
&func_name,
&retval,
4, args,
0, NULL);
zval_ptr_dtor(&func_name);
if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
convert_to_long(&retval);
ret = (int)Z_LVAL(retval);
} else if (call_result == FAILURE) {
php_error_docref(NULL, E_WARNING, "failed to call filter function");
}
if (bytes_consumed) {
*bytes_consumed = zval_get_long(&args[2]);
}
if (buckets_in->head) {
php_stream_bucket *bucket = buckets_in->head;
php_error_docref(NULL, E_WARNING, "Unprocessed filter buckets remaining on input brigade");
while ((bucket = buckets_in->head)) {
/* Remove unconsumed buckets from the brigade */
php_stream_bucket_unlink(bucket);
php_stream_bucket_delref(bucket);
}
}
if (ret != PSFS_PASS_ON) {
php_stream_bucket *bucket = buckets_out->head;
while (bucket != NULL) {
php_stream_bucket_unlink(bucket);
php_stream_bucket_delref(bucket);
bucket = buckets_out->head;
}
}
/* filter resources are cleaned up by the stream destructor,
* keeping a reference to the stream resource here would prevent it
* from being destroyed properly */
ZVAL_STRINGL(&zpropname, "stream", sizeof("stream")-1);
Z_OBJ_HANDLER_P(obj, unset_property)(obj, &zpropname, NULL);
zval_ptr_dtor(&zpropname);
zval_ptr_dtor(&args[3]);
zval_ptr_dtor(&args[2]);
zval_ptr_dtor(&args[1]);
zval_ptr_dtor(&args[0]);
return ret;
}
static zend_bool is_protected_variable(char *varname) /* {{{ */
{
normalize_protected_variable(varname);
return zend_hash_str_exists(&PG(rfc1867_protected_variables), varname, strlen(varname));
}
static inline int msgpack_convert_long_to_properties(HashTable *ht, zval *object, HashTable **properties, HashPosition *prop_pos, uint key_index, zval *val, HashTable *var) /* {{{ */ {
zval key_zv;
HashTable *props = *properties;
if (props != NULL) {
zval *data, tplval, *dataval, prop_key_zv;
zend_string *prop_key;
ulong prop_key_index;
const char *class_name, *prop_name;
size_t prop_len;
for (;; zend_hash_move_forward_ex(props, prop_pos)) {
if (zend_hash_get_current_key_ex(props, &prop_key, &prop_key_index, prop_pos) == HASH_KEY_IS_STRING) {
zend_unmangle_property_name_ex(prop_key, &class_name, &prop_name, &prop_len);
ZVAL_NEW_STR(&prop_key_zv, prop_key);
if (var == NULL || !zend_hash_str_exists(var, prop_name, prop_len)) {
if ((data = zend_hash_find(ht, prop_key)) != NULL) {
switch (Z_TYPE_P(data)) {
case IS_ARRAY:
{
HashTable *dataht;
dataht = HASH_OF(val);
if ((dataval = zend_hash_index_find(dataht, prop_key_index)) == NULL) {
MSGPACK_WARNING("[msgpack] (%s) "
"can't get data value by index",
__FUNCTION__);
return FAILURE;
}
if (msgpack_convert_array(&tplval, data, dataval) == SUCCESS) {
zend_hash_move_forward_ex(props, prop_pos);
zend_update_property(Z_OBJCE_P(object), object, prop_name, prop_len, &tplval);
return SUCCESS;
}
return FAILURE;
}
case IS_OBJECT:
{
if (msgpack_convert_object(&tplval, data, val) == SUCCESS) {
zend_hash_move_forward_ex(props, prop_pos);
zend_update_property(Z_OBJCE_P(object), object, prop_name, prop_len, &tplval);
return SUCCESS;
}
return FAILURE;
}
default:
zend_hash_move_forward_ex(props, prop_pos);
zend_update_property(Z_OBJCE_P(object), object, prop_name, prop_len, val);
return SUCCESS;
}
}
}
} else {
break;
}
}
*properties = NULL;
}
ZVAL_LONG(&key_zv, key_index);
zend_std_write_property(object, &key_zv, val, NULL);
return SUCCESS;
}
