diff options
Diffstat (limited to 'ext/standard/var.c')
| -rw-r--r-- | ext/standard/var.c | 994 |
1 files changed, 994 insertions, 0 deletions
diff --git a/ext/standard/var.c b/ext/standard/var.c new file mode 100644 index 0000000..b13edf6 --- /dev/null +++ b/ext/standard/var.c @@ -0,0 +1,994 @@ +/* + +----------------------------------------------------------------------+ + | PHP Version 5 | + +----------------------------------------------------------------------+ + | Copyright (c) 1997-2013 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: | + | http://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 | + | license@php.net so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Authors: Jani Lehtimäki <jkl@njet.net> | + | Thies C. Arntzen <thies@thieso.net> | + | Sascha Schumann <sascha@schumann.cx> | + +----------------------------------------------------------------------+ +*/ + +/* $Id$ */ + +/* {{{ includes +*/ +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> +#include "php.h" +#include "php_string.h" +#include "php_var.h" +#include "php_smart_str.h" +#include "basic_functions.h" +#include "php_incomplete_class.h" + +#define COMMON (Z_ISREF_PP(struc) ? "&" : "") +/* }}} */ + +static int php_array_element_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ +{ + int level; + + level = va_arg(args, int); + + if (hash_key->nKeyLength == 0) { /* numeric key */ + php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h); + } else { /* string key */ + php_printf("%*c[\"", level + 1, ' '); + PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1); + php_printf("\"]=>\n"); + } + php_var_dump(zv, level + 2 TSRMLS_CC); + return 0; +} +/* }}} */ + +static int php_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ +{ + int level; + const char *prop_name, *class_name; + + level = va_arg(args, int); + + if (hash_key->nKeyLength == 0) { /* numeric key */ + php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h); + } else { /* string key */ + int unmangle = zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, &class_name, &prop_name); + php_printf("%*c[", level + 1, ' '); + + if (class_name && unmangle == SUCCESS) { + if (class_name[0] == '*') { + php_printf("\"%s\":protected", prop_name); + } else { + php_printf("\"%s\":\"%s\":private", prop_name, class_name); + } + } else { + php_printf("\""); + PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1); + php_printf("\""); + } + ZEND_PUTS("]=>\n"); + } + php_var_dump(zv, level + 2 TSRMLS_CC); + return 0; +} +/* }}} */ + +PHPAPI void php_var_dump(zval **struc, int level TSRMLS_DC) /* {{{ */ +{ + HashTable *myht; + const char *class_name; + zend_uint class_name_len; + int (*php_element_dump_func)(zval** TSRMLS_DC, int, va_list, zend_hash_key*); + int is_temp; + + if (level > 1) { + php_printf("%*c", level - 1, ' '); + } + + switch (Z_TYPE_PP(struc)) { + case IS_BOOL: + php_printf("%sbool(%s)\n", COMMON, Z_LVAL_PP(struc) ? "true" : "false"); + break; + case IS_NULL: + php_printf("%sNULL\n", COMMON); + break; + case IS_LONG: + php_printf("%sint(%ld)\n", COMMON, Z_LVAL_PP(struc)); + break; + case IS_DOUBLE: + php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc)); + break; + case IS_STRING: + php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc)); + PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc)); + PUTS("\"\n"); + break; + case IS_ARRAY: + myht = Z_ARRVAL_PP(struc); + if (++myht->nApplyCount > 1) { + PUTS("*RECURSION*\n"); + --myht->nApplyCount; + return; + } + php_printf("%sarray(%d) {\n", COMMON, zend_hash_num_elements(myht)); + php_element_dump_func = php_array_element_dump; + is_temp = 0; + goto head_done; + case IS_OBJECT: + myht = Z_OBJDEBUG_PP(struc, is_temp); + if (myht && ++myht->nApplyCount > 1) { + PUTS("*RECURSION*\n"); + --myht->nApplyCount; + return; + } + + if (Z_OBJ_HANDLER(**struc, get_class_name)) { + Z_OBJ_HANDLER(**struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC); + php_printf("%sobject(%s)#%d (%d) {\n", COMMON, class_name, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0); + efree((char*)class_name); + } else { + php_printf("%sobject(unknown class)#%d (%d) {\n", COMMON, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0); + } + php_element_dump_func = php_object_property_dump; +head_done: + if (myht) { + zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_element_dump_func, 1, level); + --myht->nApplyCount; + if (is_temp) { + zend_hash_destroy(myht); + efree(myht); + } + } + if (level > 1) { + php_printf("%*c", level-1, ' '); + } + PUTS("}\n"); + break; + case IS_RESOURCE: { + const char *type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(struc) TSRMLS_CC); + php_printf("%sresource(%ld) of type (%s)\n", COMMON, Z_LVAL_PP(struc), type_name ? type_name : "Unknown"); + break; + } + default: + php_printf("%sUNKNOWN:0\n", COMMON); + break; + } +} +/* }}} */ + +/* {{{ proto void var_dump(mixed var) + Dumps a string representation of variable to output */ +PHP_FUNCTION(var_dump) +{ + zval ***args; + int argc; + int i; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) { + return; + } + + for (i = 0; i < argc; i++) { + php_var_dump(args[i], 1 TSRMLS_CC); + } + efree(args); +} +/* }}} */ + +static int zval_array_element_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ +{ + int level; + + level = va_arg(args, int); + + if (hash_key->nKeyLength == 0) { /* numeric key */ + php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h); + } else { /* string key */ + /* XXX: perphaps when we are inside the class we should permit access to + * private & protected values + */ + if (va_arg(args, int) && hash_key->arKey[0] == '\0') { + return 0; + } + php_printf("%*c[\"", level + 1, ' '); + PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1); + php_printf("\"]=>\n"); + } + php_debug_zval_dump(zv, level + 2 TSRMLS_CC); + return 0; +} +/* }}} */ + +static int zval_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ +{ + int level; + const char *prop_name, *class_name; + + level = va_arg(args, int); + + if (hash_key->nKeyLength == 0) { /* numeric key */ + php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h); + } else { /* string key */ + zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, &class_name, &prop_name); + php_printf("%*c[", level + 1, ' '); + + if (class_name) { + if (class_name[0] == '*') { + php_printf("\"%s\":protected", prop_name); + } else { + php_printf("\"%s\":\"%s\":private", prop_name, class_name); + } + } else { + php_printf("\"%s\"", prop_name); + } + ZEND_PUTS("]=>\n"); + } + php_debug_zval_dump(zv, level + 2 TSRMLS_CC); + return 0; +} +/* }}} */ + +PHPAPI void php_debug_zval_dump(zval **struc, int level TSRMLS_DC) /* {{{ */ +{ + HashTable *myht = NULL; + const char *class_name; + zend_uint class_name_len; + int (*zval_element_dump_func)(zval** TSRMLS_DC, int, va_list, zend_hash_key*); + int is_temp = 0; + + if (level > 1) { + php_printf("%*c", level - 1, ' '); + } + + switch (Z_TYPE_PP(struc)) { + case IS_BOOL: + php_printf("%sbool(%s) refcount(%u)\n", COMMON, Z_LVAL_PP(struc)?"true":"false", Z_REFCOUNT_PP(struc)); + break; + case IS_NULL: + php_printf("%sNULL refcount(%u)\n", COMMON, Z_REFCOUNT_PP(struc)); + break; + case IS_LONG: + php_printf("%slong(%ld) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), Z_REFCOUNT_PP(struc)); + break; + case IS_DOUBLE: + php_printf("%sdouble(%.*G) refcount(%u)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc), Z_REFCOUNT_PP(struc)); + break; + case IS_STRING: + php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc)); + PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc)); + php_printf("\" refcount(%u)\n", Z_REFCOUNT_PP(struc)); + break; + case IS_ARRAY: + myht = Z_ARRVAL_PP(struc); + if (myht->nApplyCount > 1) { + PUTS("*RECURSION*\n"); + return; + } + php_printf("%sarray(%d) refcount(%u){\n", COMMON, zend_hash_num_elements(myht), Z_REFCOUNT_PP(struc)); + zval_element_dump_func = zval_array_element_dump; + goto head_done; + case IS_OBJECT: + myht = Z_OBJDEBUG_PP(struc, is_temp); + if (myht && myht->nApplyCount > 1) { + PUTS("*RECURSION*\n"); + return; + } + Z_OBJ_HANDLER_PP(struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC); + php_printf("%sobject(%s)#%d (%d) refcount(%u){\n", COMMON, class_name, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0, Z_REFCOUNT_PP(struc)); + efree((char*)class_name); + zval_element_dump_func = zval_object_property_dump; +head_done: + if (myht) { + zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) zval_element_dump_func, 1, level, (Z_TYPE_PP(struc) == IS_ARRAY ? 0 : 1)); + if (is_temp) { + zend_hash_destroy(myht); + efree(myht); + } + } + if (level > 1) { + php_printf("%*c", level - 1, ' '); + } + PUTS("}\n"); + break; + case IS_RESOURCE: { + const char *type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(struc) TSRMLS_CC); + php_printf("%sresource(%ld) of type (%s) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), type_name ? type_name : "Unknown", Z_REFCOUNT_PP(struc)); + break; + } + default: + php_printf("%sUNKNOWN:0\n", COMMON); + break; + } +} +/* }}} */ + +/* {{{ proto void debug_zval_dump(mixed var) + Dumps a string representation of an internal zend value to output. */ +PHP_FUNCTION(debug_zval_dump) +{ + zval ***args; + int argc; + int i; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) { + return; + } + + for (i = 0; i < argc; i++) { + php_debug_zval_dump(args[i], 1 TSRMLS_CC); + } + efree(args); +} +/* }}} */ + +#define buffer_append_spaces(buf, num_spaces) \ + do { \ + char *tmp_spaces; \ + int tmp_spaces_len; \ + tmp_spaces_len = spprintf(&tmp_spaces, 0,"%*c", num_spaces, ' '); \ + smart_str_appendl(buf, tmp_spaces, tmp_spaces_len); \ + efree(tmp_spaces); \ + } while(0); + +static int php_array_element_export(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ +{ + int level; + smart_str *buf; + + level = va_arg(args, int); + buf = va_arg(args, smart_str *); + + if (hash_key->nKeyLength == 0) { /* numeric key */ + buffer_append_spaces(buf, level+1); + smart_str_append_long(buf, (long) hash_key->h); + smart_str_appendl(buf, " => ", 4); + + } else { /* string key */ + char *key, *tmp_str; + int key_len, tmp_len; + key = php_addcslashes(hash_key->arKey, hash_key->nKeyLength - 1, &key_len, 0, "'\\", 2 TSRMLS_CC); + tmp_str = php_str_to_str_ex(key, key_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len, 0, NULL); + + buffer_append_spaces(buf, level + 1); + + smart_str_appendc(buf, '\''); + smart_str_appendl(buf, tmp_str, tmp_len); + smart_str_appendl(buf, "' => ", 5); + + efree(key); + efree(tmp_str); + } + php_var_export_ex(zv, level + 2, buf TSRMLS_CC); + + smart_str_appendc(buf, ','); + smart_str_appendc(buf, '\n'); + + return 0; +} +/* }}} */ + +static int php_object_element_export(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ +{ + int level; + smart_str *buf; + + level = va_arg(args, int); + buf = va_arg(args, smart_str *); + + buffer_append_spaces(buf, level + 2); + if (hash_key->nKeyLength != 0) { + const char *class_name; /* ignored, but must be passed to unmangle */ + const char *pname; + char *pname_esc; + int pname_esc_len; + + zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, + &class_name, &pname); + pname_esc = php_addcslashes(pname, strlen(pname), &pname_esc_len, 0, + "'\\", 2 TSRMLS_CC); + + smart_str_appendc(buf, '\''); + smart_str_appendl(buf, pname_esc, pname_esc_len); + smart_str_appendc(buf, '\''); + efree(pname_esc); + } else { + smart_str_append_long(buf, (long) hash_key->h); + } + smart_str_appendl(buf, " => ", 4); + php_var_export_ex(zv, level + 2, buf TSRMLS_CC); + smart_str_appendc(buf, ','); + smart_str_appendc(buf, '\n'); + return 0; +} +/* }}} */ + +PHPAPI void php_var_export_ex(zval **struc, int level, smart_str *buf TSRMLS_DC) /* {{{ */ +{ + HashTable *myht; + char *tmp_str, *tmp_str2; + int tmp_len, tmp_len2; + const char *class_name; + zend_uint class_name_len; + + switch (Z_TYPE_PP(struc)) { + case IS_BOOL: + if (Z_LVAL_PP(struc)) { + smart_str_appendl(buf, "true", 4); + } else { + smart_str_appendl(buf, "false", 5); + } + break; + case IS_NULL: + smart_str_appendl(buf, "NULL", 4); + break; + case IS_LONG: + smart_str_append_long(buf, Z_LVAL_PP(struc)); + break; + case IS_DOUBLE: + tmp_len = spprintf(&tmp_str, 0,"%.*H", (int) EG(precision), Z_DVAL_PP(struc)); + smart_str_appendl(buf, tmp_str, tmp_len); + efree(tmp_str); + break; + case IS_STRING: + tmp_str = php_addcslashes(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc), &tmp_len, 0, "'\\", 2 TSRMLS_CC); + tmp_str2 = php_str_to_str_ex(tmp_str, tmp_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len2, 0, NULL); + + smart_str_appendc(buf, '\''); + smart_str_appendl(buf, tmp_str2, tmp_len2); + smart_str_appendc(buf, '\''); + + efree(tmp_str2); + efree(tmp_str); + break; + case IS_ARRAY: + myht = Z_ARRVAL_PP(struc); + if(myht && myht->nApplyCount > 0){ + smart_str_appendl(buf, "NULL", 4); + zend_error(E_WARNING, "var_export does not handle circular references"); + return; + } + if (level > 1) { + smart_str_appendc(buf, '\n'); + buffer_append_spaces(buf, level - 1); + } + smart_str_appendl(buf, "array (\n", 8); + zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_array_element_export, 2, level, buf); + + if (level > 1) { + buffer_append_spaces(buf, level - 1); + } + smart_str_appendc(buf, ')'); + + break; + + case IS_OBJECT: + myht = Z_OBJPROP_PP(struc); + if(myht && myht->nApplyCount > 0){ + smart_str_appendl(buf, "NULL", 4); + zend_error(E_WARNING, "var_export does not handle circular references"); + return; + } + if (level > 1) { + smart_str_appendc(buf, '\n'); + buffer_append_spaces(buf, level - 1); + } + Z_OBJ_HANDLER(**struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC); + + smart_str_appendl(buf, class_name, class_name_len); + smart_str_appendl(buf, "::__set_state(array(\n", 21); + + efree((char*)class_name); + if (myht) { + zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_object_element_export, 1, level, buf); + } + if (level > 1) { + buffer_append_spaces(buf, level - 1); + } + smart_str_appendl(buf, "))", 2); + + break; + default: + smart_str_appendl(buf, "NULL", 4); + break; + } +} +/* }}} */ + +/* FOR BC reasons, this will always perform and then print */ +PHPAPI void php_var_export(zval **struc, int level TSRMLS_DC) /* {{{ */ +{ + smart_str buf = {0}; + php_var_export_ex(struc, level, &buf TSRMLS_CC); + smart_str_0 (&buf); + PHPWRITE(buf.c, buf.len); + smart_str_free(&buf); +} +/* }}} */ + + +/* {{{ proto mixed var_export(mixed var [, bool return]) + Outputs or returns a string representation of a variable */ +PHP_FUNCTION(var_export) +{ + zval *var; + zend_bool return_output = 0; + smart_str buf = {0}; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &var, &return_output) == FAILURE) { + return; + } + + php_var_export_ex(&var, 1, &buf TSRMLS_CC); + smart_str_0 (&buf); + + if (return_output) { + RETVAL_STRINGL(buf.c, buf.len, 1); + } else { + PHPWRITE(buf.c, buf.len); + } + smart_str_free(&buf); +} +/* }}} */ + +static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var_hash TSRMLS_DC); + +static inline int php_add_var_hash(HashTable *var_hash, zval *var, void *var_old TSRMLS_DC) /* {{{ */ +{ + ulong var_no; + char id[32], *p; + register int len; + + /* relies on "(long)" being a perfect hash function for data pointers, + * however the actual identity of an object has had to be determined + * by its object handle since 5.0. */ + if ((Z_TYPE_P(var) == IS_OBJECT) && Z_OBJ_HT_P(var)->get_class_entry) { + p = smart_str_print_long(id + sizeof(id) - 1, (long) Z_OBJ_HANDLE_P(var)); + *(--p) = 'O'; + len = id + sizeof(id) - 1 - p; + } else { + p = smart_str_print_long(id + sizeof(id) - 1, (long) var); + len = id + sizeof(id) - 1 - p; + } + + if (var_old && zend_hash_find(var_hash, p, len, var_old) == SUCCESS) { + if (!Z_ISREF_P(var)) { + /* we still need to bump up the counter, since non-refs will + * be counted separately by unserializer */ + var_no = -1; + zend_hash_next_index_insert(var_hash, &var_no, sizeof(var_no), NULL); + } +#if 0 + fprintf(stderr, "- had var (%d): %lu\n", Z_TYPE_P(var), **(ulong**)var_old); +#endif + return FAILURE; + } + + /* +1 because otherwise hash will think we are trying to store NULL pointer */ + var_no = zend_hash_num_elements(var_hash) + 1; + zend_hash_add(var_hash, p, len, &var_no, sizeof(var_no), NULL); +#if 0 + fprintf(stderr, "+ add var (%d): %lu\n", Z_TYPE_P(var), var_no); +#endif + return SUCCESS; +} +/* }}} */ + +static inline void php_var_serialize_long(smart_str *buf, long val) /* {{{ */ +{ + smart_str_appendl(buf, "i:", 2); + smart_str_append_long(buf, val); + smart_str_appendc(buf, ';'); +} +/* }}} */ + +static inline void php_var_serialize_string(smart_str *buf, char *str, int len) /* {{{ */ +{ + smart_str_appendl(buf, "s:", 2); + smart_str_append_long(buf, len); + smart_str_appendl(buf, ":\"", 2); + smart_str_appendl(buf, str, len); + smart_str_appendl(buf, "\";", 2); +} +/* }}} */ + +static inline zend_bool php_var_serialize_class_name(smart_str *buf, zval *struc TSRMLS_DC) /* {{{ */ +{ + PHP_CLASS_ATTRIBUTES; + + PHP_SET_CLASS_ATTRIBUTES(struc); + smart_str_appendl(buf, "O:", 2); + smart_str_append_long(buf, (int)name_len); + smart_str_appendl(buf, ":\"", 2); + smart_str_appendl(buf, class_name, name_len); + smart_str_appendl(buf, "\":", 2); + PHP_CLEANUP_CLASS_ATTRIBUTES(); + return incomplete_class; +} +/* }}} */ + +static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_ptr, HashTable *var_hash TSRMLS_DC) /* {{{ */ +{ + int count; + zend_bool incomplete_class; + + incomplete_class = php_var_serialize_class_name(buf, struc TSRMLS_CC); + /* count after serializing name, since php_var_serialize_class_name + * changes the count if the variable is incomplete class */ + count = zend_hash_num_elements(HASH_OF(retval_ptr)); + if (incomplete_class) { + --count; + } + smart_str_append_long(buf, count); + smart_str_appendl(buf, ":{", 2); + + if (count > 0) { + char *key; + zval **d, **name; + ulong index; + HashPosition pos; + int i; + zval nval, *nvalp; + HashTable *propers; + + ZVAL_NULL(&nval); + nvalp = &nval; + + zend_hash_internal_pointer_reset_ex(HASH_OF(retval_ptr), &pos); + + for (;; zend_hash_move_forward_ex(HASH_OF(retval_ptr), &pos)) { + i = zend_hash_get_current_key_ex(HASH_OF(retval_ptr), &key, NULL, &index, 0, &pos); + + if (i == HASH_KEY_NON_EXISTANT) { + break; + } + + if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) { + continue; + } + zend_hash_get_current_data_ex(HASH_OF(retval_ptr), (void **) &name, &pos); + + if (Z_TYPE_PP(name) != IS_STRING) { + php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize."); + /* we should still add element even if it's not OK, + * since we already wrote the length of the array before */ + smart_str_appendl(buf,"N;", 2); + continue; + } + propers = Z_OBJPROP_P(struc); + if (zend_hash_find(propers, Z_STRVAL_PP(name), Z_STRLEN_PP(name) + 1, (void *) &d) == SUCCESS) { + php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name)); + php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC); + } else { + zend_class_entry *ce; + ce = zend_get_class_entry(struc TSRMLS_CC); + if (ce) { + char *prot_name, *priv_name; + int prop_name_length; + + do { + zend_mangle_property_name(&priv_name, &prop_name_length, ce->name, ce->name_length, Z_STRVAL_PP(name), Z_STRLEN_PP(name), ce->type & ZEND_INTERNAL_CLASS); + if (zend_hash_find(propers, priv_name, prop_name_length + 1, (void *) &d) == SUCCESS) { + php_var_serialize_string(buf, priv_name, prop_name_length); + pefree(priv_name, ce->type & ZEND_INTERNAL_CLASS); + php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC); + break; + } + pefree(priv_name, ce->type & ZEND_INTERNAL_CLASS); + zend_mangle_property_name(&prot_name, &prop_name_length, "*", 1, Z_STRVAL_PP(name), Z_STRLEN_PP(name), ce->type & ZEND_INTERNAL_CLASS); + if (zend_hash_find(propers, prot_name, prop_name_length + 1, (void *) &d) == SUCCESS) { + php_var_serialize_string(buf, prot_name, prop_name_length); + pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS); + php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC); + break; + } + pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS); + php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name)); + php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC); + php_error_docref(NULL TSRMLS_CC, E_NOTICE, "\"%s\" returned as member variable from __sleep() but does not exist", Z_STRVAL_PP(name)); + } while (0); + } else { + php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name)); + php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC); + } + } + } + } + smart_str_appendc(buf, '}'); +} +/* }}} */ + +static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var_hash TSRMLS_DC) /* {{{ */ +{ + int i; + ulong *var_already; + HashTable *myht; + + if (var_hash && php_add_var_hash(var_hash, struc, (void *) &var_already TSRMLS_CC) == FAILURE) { + if (Z_ISREF_P(struc)) { + smart_str_appendl(buf, "R:", 2); + smart_str_append_long(buf, (long)*var_already); + smart_str_appendc(buf, ';'); + return; + } else if (Z_TYPE_P(struc) == IS_OBJECT) { + smart_str_appendl(buf, "r:", 2); + smart_str_append_long(buf, (long)*var_already); + smart_str_appendc(buf, ';'); + return; + } + } + + switch (Z_TYPE_P(struc)) { + case IS_BOOL: + smart_str_appendl(buf, "b:", 2); + smart_str_append_long(buf, Z_LVAL_P(struc)); + smart_str_appendc(buf, ';'); + return; + + case IS_NULL: + smart_str_appendl(buf, "N;", 2); + return; + + case IS_LONG: + php_var_serialize_long(buf, Z_LVAL_P(struc)); + return; + + case IS_DOUBLE: { + char *s; + + smart_str_appendl(buf, "d:", 2); + s = (char *) safe_emalloc(PG(serialize_precision), 1, MAX_LENGTH_OF_DOUBLE + 1); + php_gcvt(Z_DVAL_P(struc), PG(serialize_precision), '.', 'E', s); + smart_str_appends(buf, s); + smart_str_appendc(buf, ';'); + efree(s); + return; + } + + case IS_STRING: + php_var_serialize_string(buf, Z_STRVAL_P(struc), Z_STRLEN_P(struc)); + return; + + case IS_OBJECT: { + zval *retval_ptr = NULL; + zval fname; + int res; + zend_class_entry *ce = NULL; + + if (Z_OBJ_HT_P(struc)->get_class_entry) { + ce = Z_OBJCE_P(struc); + } + + if (ce && ce->serialize != NULL) { + /* has custom handler */ + unsigned char *serialized_data = NULL; + zend_uint serialized_length; + + if (ce->serialize(struc, &serialized_data, &serialized_length, (zend_serialize_data *)var_hash TSRMLS_CC) == SUCCESS) { + smart_str_appendl(buf, "C:", 2); + smart_str_append_long(buf, (int)Z_OBJCE_P(struc)->name_length); + smart_str_appendl(buf, ":\"", 2); + smart_str_appendl(buf, Z_OBJCE_P(struc)->name, Z_OBJCE_P(struc)->name_length); + smart_str_appendl(buf, "\":", 2); + + smart_str_append_long(buf, (int)serialized_length); + smart_str_appendl(buf, ":{", 2); + smart_str_appendl(buf, serialized_data, serialized_length); + smart_str_appendc(buf, '}'); + } else { + smart_str_appendl(buf, "N;", 2); + } + if (serialized_data) { + efree(serialized_data); + } + return; + } + + if (ce && ce != PHP_IC_ENTRY && zend_hash_exists(&ce->function_table, "__sleep", sizeof("__sleep"))) { + INIT_PZVAL(&fname); + ZVAL_STRINGL(&fname, "__sleep", sizeof("__sleep") - 1, 0); + BG(serialize_lock)++; + res = call_user_function_ex(CG(function_table), &struc, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC); + BG(serialize_lock)--; + + if (res == SUCCESS && !EG(exception)) { + if (retval_ptr) { + if (HASH_OF(retval_ptr)) { + php_var_serialize_class(buf, struc, retval_ptr, var_hash TSRMLS_CC); + } else { + php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize"); + /* we should still add element even if it's not OK, + * since we already wrote the length of the array before */ + smart_str_appendl(buf,"N;", 2); + } + zval_ptr_dtor(&retval_ptr); + } + return; + } + } + + if (retval_ptr) { + zval_ptr_dtor(&retval_ptr); + } + /* fall-through */ + } + case IS_ARRAY: { + zend_bool incomplete_class = 0; + if (Z_TYPE_P(struc) == IS_ARRAY) { + smart_str_appendl(buf, "a:", 2); + myht = HASH_OF(struc); + } else { + incomplete_class = php_var_serialize_class_name(buf, struc TSRMLS_CC); + myht = Z_OBJPROP_P(struc); + } + /* count after serializing name, since php_var_serialize_class_name + * changes the count if the variable is incomplete class */ + i = myht ? zend_hash_num_elements(myht) : 0; + if (i > 0 && incomplete_class) { + --i; + } + smart_str_append_long(buf, i); + smart_str_appendl(buf, ":{", 2); + if (i > 0) { + char *key; + zval **data; + ulong index; + uint key_len; + HashPosition pos; + + zend_hash_internal_pointer_reset_ex(myht, &pos); + for (;; zend_hash_move_forward_ex(myht, &pos)) { + i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos); + if (i == HASH_KEY_NON_EXISTANT) { + break; + } + if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) { + continue; + } + + switch (i) { + case HASH_KEY_IS_LONG: + php_var_serialize_long(buf, index); + break; + case HASH_KEY_IS_STRING: + php_var_serialize_string(buf, key, key_len - 1); + break; + } + + /* we should still add element even if it's not OK, + * since we already wrote the length of the array before */ + if (zend_hash_get_current_data_ex(myht, (void **) &data, &pos) != SUCCESS + || !data + || data == &struc + || (Z_TYPE_PP(data) == IS_ARRAY && Z_ARRVAL_PP(data)->nApplyCount > 1) + ) { + smart_str_appendl(buf, "N;", 2); + } else { + if (Z_TYPE_PP(data) == IS_ARRAY) { + Z_ARRVAL_PP(data)->nApplyCount++; + } + php_var_serialize_intern(buf, *data, var_hash TSRMLS_CC); + if (Z_TYPE_PP(data) == IS_ARRAY) { + Z_ARRVAL_PP(data)->nApplyCount--; + } + } + } + } + smart_str_appendc(buf, '}'); + return; + } + default: + smart_str_appendl(buf, "i:0;", 4); + return; + } +} +/* }}} */ + +PHPAPI void php_var_serialize(smart_str *buf, zval **struc, php_serialize_data_t *var_hash TSRMLS_DC) /* {{{ */ +{ + php_var_serialize_intern(buf, *struc, *var_hash TSRMLS_CC); + smart_str_0(buf); +} +/* }}} */ + +/* {{{ proto string serialize(mixed variable) + Returns a string representation of variable (which can later be unserialized) */ +PHP_FUNCTION(serialize) +{ + zval **struc; + php_serialize_data_t var_hash; + smart_str buf = {0}; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &struc) == FAILURE) { + return; + } + + Z_TYPE_P(return_value) = IS_STRING; + Z_STRVAL_P(return_value) = NULL; + Z_STRLEN_P(return_value) = 0; + + PHP_VAR_SERIALIZE_INIT(var_hash); + php_var_serialize(&buf, struc, &var_hash TSRMLS_CC); + PHP_VAR_SERIALIZE_DESTROY(var_hash); + + if (buf.c) { + RETURN_STRINGL(buf.c, buf.len, 0); + } else { + RETURN_NULL(); + } +} +/* }}} */ + +/* {{{ proto mixed unserialize(string variable_representation) + Takes a string representation of variable and recreates it */ +PHP_FUNCTION(unserialize) +{ + char *buf = NULL; + int buf_len; + const unsigned char *p; + php_unserialize_data_t var_hash; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buf, &buf_len) == FAILURE) { + RETURN_FALSE; + } + + if (buf_len == 0) { + RETURN_FALSE; + } + + p = (const unsigned char*) buf; + PHP_VAR_UNSERIALIZE_INIT(var_hash); + if (!php_var_unserialize(&return_value, &p, p + buf_len, &var_hash TSRMLS_CC)) { + PHP_VAR_UNSERIALIZE_DESTROY(var_hash); + zval_dtor(return_value); + php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Error at offset %ld of %d bytes", (long)((char*)p - buf), buf_len); + RETURN_FALSE; + } + PHP_VAR_UNSERIALIZE_DESTROY(var_hash); +} +/* }}} */ + +/* {{{ proto int memory_get_usage([real_usage]) + Returns the allocated by PHP memory */ +PHP_FUNCTION(memory_get_usage) { + zend_bool real_usage = 0; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &real_usage) == FAILURE) { + RETURN_FALSE; + } + + RETURN_LONG(zend_memory_usage(real_usage TSRMLS_CC)); +} +/* }}} */ + +/* {{{ proto int memory_get_peak_usage([real_usage]) + Returns the peak allocated by PHP memory */ +PHP_FUNCTION(memory_get_peak_usage) { + zend_bool real_usage = 0; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &real_usage) == FAILURE) { + RETURN_FALSE; + } + + RETURN_LONG(zend_memory_peak_usage(real_usage TSRMLS_CC)); +} +/* }}} */ + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * End: + * vim600: sw=4 ts=4 fdm=marker + * vim<600: sw=4 ts=4 + */ |