/* {{{ php_zlib_encode() */
static zend_string *php_zlib_encode(const char *in_buf, size_t in_len, int encoding, int level)
{
int status;
z_stream Z;
zend_string *out;
memset(&Z, 0, sizeof(z_stream));
Z.zalloc = php_zlib_alloc;
Z.zfree = php_zlib_free;
if (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, encoding, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) {
out = zend_string_alloc(PHP_ZLIB_BUFFER_SIZE_GUESS(in_len), 0);
Z.next_in = (Bytef *) in_buf;
Z.next_out = (Bytef *) ZSTR_VAL(out);
Z.avail_in = in_len;
Z.avail_out = ZSTR_LEN(out);
status = deflate(&Z, Z_FINISH);
deflateEnd(&Z);
if (Z_STREAM_END == status) {
/* size buffer down to actual length */
out = zend_string_truncate(out, Z.total_out, 0);
ZSTR_VAL(out)[ZSTR_LEN(out)] = '\0';
return out;
} else {
zend_string_free(out);
}
}
php_error_docref(NULL, E_WARNING, "%s", zError(status));
return NULL;
}
static ZEND_INI_MH(OnEnable)
{
if (stage == ZEND_INI_STAGE_STARTUP ||
stage == ZEND_INI_STAGE_SHUTDOWN ||
stage == ZEND_INI_STAGE_DEACTIVATE) {
return OnUpdateBool(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
} else {
/* It may be only temporary disabled */
zend_bool *p;
#ifndef ZTS
char *base = (char *) mh_arg2;
#else
char *base = (char *) ts_resource(*((int *) mh_arg2));
#endif
p = (zend_bool *) (base+(size_t) mh_arg1);
if ((ZSTR_LEN(new_value) == 2 && strcasecmp("on", ZSTR_VAL(new_value)) == 0) ||
(ZSTR_LEN(new_value) == 3 && strcasecmp("yes", ZSTR_VAL(new_value)) == 0) ||
(ZSTR_LEN(new_value) == 4 && strcasecmp("true", ZSTR_VAL(new_value)) == 0) ||
atoi(ZSTR_VAL(new_value)) != 0) {
zend_error(E_WARNING, ACCELERATOR_PRODUCT_NAME " can't be temporary enabled (it may be only disabled till the end of request)");
return FAILURE;
} else {
*p = 0;
return SUCCESS;
}
}
}
/* error already emitted, but let's emit another more relevant */
do_from_zval_err(ctx, "could not resolve address '%s' to get an AF_INET6 "
"address", Z_STRVAL_P(zaddr_str));
}
zend_tmp_string_release(tmp_addr_str);
}
static void to_zval_read_sin6_addr(const char *data, zval *zv, res_context *ctx)
{
const struct in6_addr *addr = (const struct in6_addr *)data;
socklen_t size = INET6_ADDRSTRLEN;
zend_string *str = zend_string_alloc(size - 1, 0);
memset(ZSTR_VAL(str), '\0', size);
ZVAL_NEW_STR(zv, str);
if (inet_ntop(AF_INET6, addr, Z_STRVAL_P(zv), size) == NULL) {
do_to_zval_err(ctx, "could not convert IPv6 address to string "
"(errno %d)", errno);
return;
}
Z_STRLEN_P(zv) = strlen(Z_STRVAL_P(zv));
}
static const field_descriptor descriptors_sockaddr_in6[] = {
{"family", sizeof("family"), 0, offsetof(struct sockaddr_in6, sin6_family), from_zval_write_sa_family, to_zval_read_sa_family},
{"addr", sizeof("addr"), 0, offsetof(struct sockaddr_in6, sin6_addr), from_zval_write_sin6_addr, to_zval_read_sin6_addr},
{"port", sizeof("port"), 0, offsetof(struct sockaddr_in6, sin6_port), from_zval_write_net_uint16, to_zval_read_net_uint16},
{"flowinfo", sizeof("flowinfo"), 0, offsetof(struct sockaddr_in6, sin6_flowinfo), from_zval_write_uint32, to_zval_read_uint32},
{"scope_id", sizeof("scope_id"), 0, offsetof(struct sockaddr_in6, sin6_scope_id), from_zval_write_uint32, to_zval_read_uint32},
{0}
};
static void from_zval_write_sockaddr_in6(const zval *container, char *sockaddr6, ser_context *ctx)
{
from_zval_write_aggregation(container, sockaddr6, descriptors_sockaddr_in6, ctx);
}
static void to_zval_read_sockaddr_in6(const char *data, zval *zv, res_context *ctx)
{
to_zval_read_aggregation(data, zv, descriptors_sockaddr_in6, ctx);
}
#endif /* HAVE_IPV6 */
static void from_zval_write_sun_path(const zval *path, char *sockaddr_un_c, ser_context *ctx)
{
zend_string *path_str, *tmp_path_str;
struct sockaddr_un *saddr = (struct sockaddr_un*)sockaddr_un_c;
path_str = zval_get_tmp_string((zval *) path, &tmp_path_str);
/* code in this file relies on the path being nul terminated, even though
* this is not required, at least on linux for abstract paths. It also
* assumes that the path is not empty */
if (ZSTR_LEN(path_str) == 0) {
do_from_zval_err(ctx, "%s", "the path is cannot be empty");
zend_tmp_string_release(tmp_path_str);
return;
}
if (ZSTR_LEN(path_str) >= sizeof(saddr->sun_path)) {
do_from_zval_err(ctx, "the path is too long, the maximum permitted "
"length is %zd", sizeof(saddr->sun_path) - 1);
zend_tmp_string_release(tmp_path_str);
return;
}
memcpy(&saddr->sun_path, ZSTR_VAL(path_str), ZSTR_LEN(path_str));
saddr->sun_path[ZSTR_LEN(path_str)] = '\0';
zend_tmp_string_release(tmp_path_str);
}
/* {{{ */
static inline zend_string* php_memoize_string(zend_string *string) {
zend_string *memoized = zend_string_alloc(ZSTR_LEN(string) + sizeof("{}") - 1, 0);
memcpy(&ZSTR_VAL(memoized)[0], "{", sizeof("{")-1);
memcpy(&ZSTR_VAL(memoized)[sizeof("{")-1], ZSTR_VAL(string), ZSTR_LEN(string));
memcpy(&ZSTR_VAL(memoized)[sizeof("{")-1 + ZSTR_LEN(string)], "}", sizeof("}")-1);
ZSTR_VAL(memoized)[ZSTR_LEN(memoized)]=0;
return memoized;
} /* }}} */
static void php_intl_idn_to_46(INTERNAL_FUNCTION_PARAMETERS,
const zend_string *domain, uint32_t option, int mode, zval *idna_info)
{
UErrorCode status = U_ZERO_ERROR;
UIDNA *uts46;
int32_t len;
zend_string *buffer;
UIDNAInfo info = UIDNA_INFO_INITIALIZER;
uts46 = uidna_openUTS46(option, &status);
if (php_intl_idn_check_status(status, "failed to open UIDNA instance") == FAILURE) {
RETURN_FALSE;
}
if (mode == INTL_IDN_TO_ASCII) {
const int32_t buffer_capac = 255;
buffer = zend_string_alloc(buffer_capac, 0);
len = uidna_nameToASCII_UTF8(uts46, ZSTR_VAL(domain), ZSTR_LEN(domain),
ZSTR_VAL(buffer), buffer_capac, &info, &status);
if (len >= buffer_capac || php_intl_idn_check_status(status, "failed to convert name") == FAILURE) {
uidna_close(uts46);
zend_string_efree(buffer);
RETURN_FALSE;
}
} else {
const int32_t buffer_capac = 252*4;
buffer = zend_string_alloc(buffer_capac, 0);
len = uidna_nameToUnicodeUTF8(uts46, ZSTR_VAL(domain), ZSTR_LEN(domain),
ZSTR_VAL(buffer), buffer_capac, &info, &status);
if (len >= buffer_capac || php_intl_idn_check_status(status, "failed to convert name") == FAILURE) {
uidna_close(uts46);
zend_string_efree(buffer);
RETURN_FALSE;
}
}
ZSTR_VAL(buffer)[len] = '\0';
ZSTR_LEN(buffer) = len;
if (info.errors == 0) {
RETVAL_STR_COPY(buffer);
} else {
RETVAL_FALSE;
}
if (idna_info) {
add_assoc_str_ex(idna_info, "result", sizeof("result")-1, zend_string_copy(buffer));
add_assoc_bool_ex(idna_info, "isTransitionalDifferent",
sizeof("isTransitionalDifferent")-1, info.isTransitionalDifferent);
add_assoc_long_ex(idna_info, "errors", sizeof("errors")-1, (zend_long)info.errors);
}
zend_string_release(buffer);
uidna_close(uts46);
}
ZEND_API int zend_register_constant(zend_constant *c)
{
zend_string *lowercase_name = NULL;
zend_string *name;
int ret = SUCCESS;
#if 0
printf("Registering constant for module %d\n", c->module_number);
#endif
if (c->module_number != PHP_USER_CONSTANT) {
c->name = zend_new_interned_string(c->name);
}
if (!(c->flags & CONST_CS)) {
lowercase_name = zend_string_alloc(ZSTR_LEN(c->name), c->flags & CONST_PERSISTENT);
zend_str_tolower_copy(ZSTR_VAL(lowercase_name), ZSTR_VAL(c->name), ZSTR_LEN(c->name));
lowercase_name = zend_new_interned_string(lowercase_name);
name = lowercase_name;
} else {
char *slash = strrchr(ZSTR_VAL(c->name), '\\');
if (slash) {
lowercase_name = zend_string_init(ZSTR_VAL(c->name), ZSTR_LEN(c->name), c->flags & CONST_PERSISTENT);
zend_str_tolower(ZSTR_VAL(lowercase_name), slash - ZSTR_VAL(c->name));
lowercase_name = zend_new_interned_string(lowercase_name);
name = lowercase_name;
} else {
name = c->name;
}
}
/* Check if the user is trying to define the internal pseudo constant name __COMPILER_HALT_OFFSET__ */
if ((ZSTR_LEN(c->name) == sizeof("__COMPILER_HALT_OFFSET__")-1
&& !memcmp(ZSTR_VAL(name), "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1))
|| zend_hash_add_constant(EG(zend_constants), name, c) == NULL) {
/* The internal __COMPILER_HALT_OFFSET__ is prefixed by NULL byte */
if (ZSTR_VAL(c->name)[0] == '\0' && ZSTR_LEN(c->name) > sizeof("\0__COMPILER_HALT_OFFSET__")-1
&& memcmp(ZSTR_VAL(name), "\0__COMPILER_HALT_OFFSET__", sizeof("\0__COMPILER_HALT_OFFSET__")) == 0) {
}
zend_error(E_NOTICE,"Constant %s already defined", ZSTR_VAL(name));
zend_string_release(c->name);
if (!(c->flags & CONST_PERSISTENT)) {
zval_dtor(&c->value);
}
ret = FAILURE;
}
if (lowercase_name) {
zend_string_release(lowercase_name);
}
return ret;
}
static void _build_trace_string(smart_str *str, HashTable *ht, uint32_t num) /* {{{ */
{
zval *file, *tmp;
smart_str_appendc(str, '#');
smart_str_append_long(str, num);
smart_str_appendc(str, ' ');
file = zend_hash_find_ex(ht, ZSTR_KNOWN(ZEND_STR_FILE), 1);
if (file) {
if (Z_TYPE_P(file) != IS_STRING) {
zend_error(E_WARNING, "Function name is no string");
smart_str_appends(str, "[unknown function]");
} else{
zend_long line;
tmp = zend_hash_find_ex(ht, ZSTR_KNOWN(ZEND_STR_LINE), 1);
if (tmp) {
if (Z_TYPE_P(tmp) == IS_LONG) {
line = Z_LVAL_P(tmp);
} else {
zend_error(E_WARNING, "Line is no long");
line = 0;
}
} else {
line = 0;
}
smart_str_append(str, Z_STR_P(file));
smart_str_appendc(str, '(');
smart_str_append_long(str, line);
smart_str_appends(str, "): ");
}
} else {
smart_str_appends(str, "[internal function]: ");
}
TRACE_APPEND_KEY(ZSTR_KNOWN(ZEND_STR_CLASS));
TRACE_APPEND_KEY(ZSTR_KNOWN(ZEND_STR_TYPE));
TRACE_APPEND_KEY(ZSTR_KNOWN(ZEND_STR_FUNCTION));
smart_str_appendc(str, '(');
tmp = zend_hash_find_ex(ht, ZSTR_KNOWN(ZEND_STR_ARGS), 1);
if (tmp) {
if (Z_TYPE_P(tmp) == IS_ARRAY) {
size_t last_len = ZSTR_LEN(str->s);
zval *arg;
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(tmp), arg) {
_build_trace_args(arg, str);
} ZEND_HASH_FOREACH_END();
if (last_len != ZSTR_LEN(str->s)) {
ZSTR_LEN(str->s) -= 2; /* remove last ', ' */
}
} else {
static inline void handle_arg(STD_PARA)
{
if (ctx->arg.s) {
ZSTR_LEN(ctx->arg.s) = 0;
}
smart_str_appendl(&ctx->arg, start, YYCURSOR - start);
if (ctx->tag_type == TAG_FORM &&
strncasecmp(ZSTR_VAL(ctx->arg.s), "action", ZSTR_LEN(ctx->arg.s)) == 0) {
ctx->attr_type = ATTR_ACTION;
} else {
ctx->attr_type = ATTR_NORMAL;
}
}
SAP_UC *zend_string_to_sapuc(zend_string *str)
{
RFC_ERROR_INFO error_info;
SAP_UC *sapuc;
unsigned sapuc_size, result_length = 0;
sapuc_size = ZSTR_LEN(str) + 1;
sapuc = callocU(1, sapuc_size);
RfcUTF8ToSAPUC((RFC_BYTE *) ZSTR_VAL(str), ZSTR_LEN(str), sapuc,
&sapuc_size, &result_length, &error_info);
return sapuc;
}
static char *zend_file_cache_get_bin_file_path(zend_string *script_path)
{
size_t len;
char *filename;
len = strlen(ZCG(accel_directives).file_cache);
filename = emalloc(len + 33 + ZSTR_LEN(script_path) + sizeof(SUFFIX));
memcpy(filename, ZCG(accel_directives).file_cache, len);
#ifndef ZEND_WIN32
filename[len] = '/';
memcpy(filename + len + 1, ZCG(system_id), 32);
memcpy(filename + len + 33, ZSTR_VAL(script_path), ZSTR_LEN(script_path));
memcpy(filename + len + 33 + ZSTR_LEN(script_path), SUFFIX, sizeof(SUFFIX));
#else
filename[len] = '\\';
memcpy(filename + len + 1, ZCG(system_id), 32);
if (ZSTR_LEN(script_path) >= 2 && ':' == ZSTR_VAL(script_path)[1]) {
/* local fs */
*(filename + len + 33) = '\\';
*(filename + len + 34) = ZSTR_VAL(script_path)[0];
memcpy(filename + len + 35, ZSTR_VAL(script_path) + 2, ZSTR_LEN(script_path) - 2);
memcpy(filename + len + 35 + ZSTR_LEN(script_path) - 2, SUFFIX, sizeof(SUFFIX));
} else {
/* network path */
memcpy(filename + len + 33, ZSTR_VAL(script_path), ZSTR_LEN(script_path));
memcpy(filename + len + 33 + ZSTR_LEN(script_path), SUFFIX, sizeof(SUFFIX));
}
#endif
return filename;
}
ZEND_API zval *zend_get_constant(zend_string *name)
{
zend_constant *c = zend_hash_find_ptr(EG(zend_constants), name);
if (c) {
return &c->value;
}
c = zend_get_halt_offset_constant(ZSTR_VAL(name), ZSTR_LEN(name));
if (c) {
return &c->value;
}
return zend_get_special_const(ZSTR_VAL(name), ZSTR_LEN(name));
}
/* {{{ _php_array_to_envp */
static php_process_env_t _php_array_to_envp(zval *environment, int is_persistent)
{
zval *element;
php_process_env_t env;
zend_string *key, *str;
#ifndef PHP_WIN32
char **ep;
#endif
char *p;
size_t cnt, l, sizeenv = 0;
HashTable *env_hash;
memset(&env, 0, sizeof(env));
if (!environment) {
return env;
}
cnt = zend_hash_num_elements(Z_ARRVAL_P(environment));
if (cnt < 1) {
#ifndef PHP_WIN32
env.envarray = (char **) pecalloc(1, sizeof(char *), is_persistent);
#endif
env.envp = (char *) pecalloc(4, 1, is_persistent);
return env;
}
ALLOC_HASHTABLE(env_hash);
zend_hash_init(env_hash, cnt, NULL, NULL, 0);
/* first, we have to get the size of all the elements in the hash */
ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(environment), key, element) {
str = zval_get_string(element);
if (ZSTR_LEN(str) == 0) {
zend_string_release(str);
continue;
}
sizeenv += ZSTR_LEN(str) + 1;
if (key && ZSTR_LEN(key)) {
sizeenv += ZSTR_LEN(key) + 1;
zend_hash_add_ptr(env_hash, key, str);
} else {
zend_hash_next_index_insert_ptr(env_hash, str);
}
} ZEND_HASH_FOREACH_END();
/* {{{ php serializer */
PHP_APCU_API int APC_SERIALIZER_NAME(php) (APC_SERIALIZER_ARGS)
{
smart_str strbuf = {0};
php_serialize_data_t var_hash;
PHP_VAR_SERIALIZE_INIT(var_hash);
php_var_serialize(&strbuf, (zval*) value, &var_hash);
PHP_VAR_SERIALIZE_DESTROY(var_hash);
if(strbuf.s->val) {
*buf = (unsigned char *)estrndup(ZSTR_VAL(strbuf.s), ZSTR_LEN(strbuf.s));
*buf_len = ZSTR_LEN(strbuf.s);
smart_str_free(&strbuf);
return 1;
}
return 0;
} /* }}} */
static int real_php_log_buffer(zval *msg_buffer, char *opt, int opt_len TSRMLS_DC)
{
php_stream *stream = NULL;
HashTable *ht;
#if PHP_VERSION_ID >= 70000
zend_ulong num_key;
zend_string *str_key;
zval *entry;
#else
zval **log;
#endif
stream = process_stream(opt,opt_len TSRMLS_CC);
if (stream == NULL)
{
return FAILURE;
}
#if PHP_VERSION_ID >= 70000
ht = HASH_OF(msg_buffer);
ZEND_HASH_FOREACH_KEY_VAL(ht, num_key, str_key, entry)
{
zend_string *s = zval_get_string(entry);
php_stream_write(stream, ZSTR_VAL(s), ZSTR_LEN(s));
zend_string_release(s);
}
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;
}
/* {{{ proto boolean tidy_parse_file(string file [, mixed config_options [, string encoding [, bool use_include_path]]])
Parse markup in file or URI */
static PHP_FUNCTION(tidy_parse_file)
{
char *enc = NULL;
size_t enc_len = 0;
zend_bool use_include_path = 0;
zend_string *inputfile, *contents;
zval *options = NULL;
PHPTidyObj *obj;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "P|zsb", &inputfile,
&options, &enc, &enc_len, &use_include_path) == FAILURE) {
RETURN_FALSE;
}
tidy_instanciate(tidy_ce_doc, return_value);
obj = Z_TIDY_P(return_value);
if (!(contents = php_tidy_file_to_mem(ZSTR_VAL(inputfile), use_include_path))) {
php_error_docref(NULL, E_WARNING, "Cannot Load '%s' into memory%s", ZSTR_VAL(inputfile), (use_include_path) ? " (Using include path)" : "");
RETURN_FALSE;
}
TIDY_APPLY_CONFIG_ZVAL(obj->ptdoc->doc, options);
if (php_tidy_parse_string(obj, ZSTR_VAL(contents), ZSTR_LEN(contents), enc) == FAILURE) {
zval_ptr_dtor(return_value);
RETVAL_FALSE;
}
zend_string_release(contents);
}
zend_class_entry *yaf_dispatcher_get_controller(zend_string *app_dir, zend_string *module, zend_string *controller, int def_module) /* {{{ */ {
char *directory;
size_t directory_len;
if (def_module) {
directory_len = spprintf(&directory, 0,
"%s%c%s", ZSTR_VAL(app_dir), DEFAULT_SLASH, YAF_CONTROLLER_DIRECTORY_NAME);
} else {
directory_len = spprintf(&directory, 0,
"%s%c%s%c%s%c%s", ZSTR_VAL(app_dir), DEFAULT_SLASH, YAF_MODULE_DIRECTORY_NAME,
DEFAULT_SLASH, ZSTR_VAL(module), DEFAULT_SLASH, YAF_CONTROLLER_DIRECTORY_NAME);
}
if (EXPECTED(directory_len)) {
zend_string *class;
zend_string *class_lowercase;
zend_class_entry *ce = NULL;
if (YAF_G(name_suffix)) {
class = strpprintf(0, "%s%s%s", ZSTR_VAL(controller), YAF_G(name_separator), "Controller");
} else {
class = strpprintf(0, "%s%s%s", "Controller", YAF_G(name_separator), ZSTR_VAL(controller));
}
class_lowercase = zend_string_tolower(class);
if ((ce = zend_hash_find_ptr(EG(class_table), class_lowercase)) == NULL) {
if (!yaf_internal_autoload(ZSTR_VAL(controller), ZSTR_LEN(controller), &directory)) {
yaf_trigger_error(YAF_ERR_NOTFOUND_CONTROLLER,
"Failed opening controller script %s: %s", directory, strerror(errno));
zend_string_release(class);
zend_string_release(class_lowercase);
efree(directory);
return NULL;
} else if ((ce = zend_hash_find_ptr(EG(class_table), class_lowercase)) == NULL) {
static TIDY_DOC_METHOD(parseFile)
{
char *enc = NULL;
size_t enc_len = 0;
zend_bool use_include_path = 0;
zval *options = NULL;
zend_string *inputfile, *contents;
PHPTidyObj *obj;
TIDY_SET_CONTEXT;
obj = Z_TIDY_P(object);
if (zend_parse_parameters(ZEND_NUM_ARGS(), "P|zsb", &inputfile,
&options, &enc, &enc_len, &use_include_path) == FAILURE) {
RETURN_FALSE;
}
if (!(contents = php_tidy_file_to_mem(ZSTR_VAL(inputfile), use_include_path))) {
php_error_docref(NULL, E_WARNING, "Cannot Load '%s' into memory%s", ZSTR_VAL(inputfile), (use_include_path) ? " (Using include path)" : "");
RETURN_FALSE;
}
TIDY_APPLY_CONFIG_ZVAL(obj->ptdoc->doc, options);
if (php_tidy_parse_string(obj, ZSTR_VAL(contents), ZSTR_LEN(contents), enc) == FAILURE) {
RETVAL_FALSE;
} else {
RETVAL_TRUE;
}
zend_string_release(contents);
}
static inline void php_url_scanner_reset_vars_impl(int type) {
url_adapt_state_ex_t *url_state;
if (type) {
url_state = &BG(url_adapt_session_ex);
} else {
url_state = &BG(url_adapt_output_ex);
}
if (url_state->form_app.s) {
ZSTR_LEN(url_state->form_app.s) = 0;
}
if (url_state->url_app.s) {
ZSTR_LEN(url_state->url_app.s) = 0;
}
}
static zend_bool is_access_deprecated(const zend_constant *c, const char *access_name) {
const char *ns_sep = zend_memrchr(ZSTR_VAL(c->name), '\\', ZSTR_LEN(c->name));
if (ns_sep) {
/* Namespaces are always case-insensitive. Only compare shortname. */
size_t shortname_offset = ns_sep - ZSTR_VAL(c->name) + 1;
size_t shortname_len = ZSTR_LEN(c->name) - shortname_offset;
return memcmp(
access_name + shortname_offset,
ZSTR_VAL(c->name) + shortname_offset,
shortname_len
) != 0;
} else {
/* No namespace, compare whole name */
return memcmp(access_name, ZSTR_VAL(c->name), ZSTR_LEN(c->name)) != 0;
}
}
static int phpdbg_create_recursive_ht_watch(phpdbg_watchpoint_t *watch) {
zval *zv;
zend_string *key;
zend_long h;
ZEND_ASSERT(watch->type == WATCH_ON_HASHTABLE);
ZEND_HASH_FOREACH_KEY_VAL(HT_WATCH_HT(watch), h, key, zv) {
phpdbg_watchpoint_t *new_watch = emalloc(sizeof(phpdbg_watchpoint_t));
new_watch->flags = PHPDBG_WATCH_RECURSIVE;
new_watch->parent = watch;
new_watch->parent_container = HT_WATCH_HT(watch);
if (key) {
new_watch->name_in_parent = key;
++GC_REFCOUNT(key);
} else {
new_watch->name_in_parent = strpprintf(0, ZEND_LONG_FMT, h);
}
new_watch->str = strpprintf(0, "%.*s%s%s%s", (int) ZSTR_LEN(watch->str) - 2, ZSTR_VAL(watch->str), (watch->flags & PHPDBG_WATCH_ARRAY) ? "[" : "->", phpdbg_get_property_key(ZSTR_VAL(new_watch->name_in_parent)), (watch->flags & PHPDBG_WATCH_ARRAY) ? "]" : "");
while (Z_TYPE_P(zv) == IS_INDIRECT) {
zv = Z_INDIRECT_P(zv);
}
phpdbg_create_zval_watchpoint(zv, new_watch);
new_watch = phpdbg_create_watchpoint(new_watch);
phpdbg_create_recursive_zval_watch(new_watch);
} ZEND_HASH_FOREACH_END();
static ZEND_INI_MH(OnUpdateAssertions) /* {{{ */
{
zend_long *p, val;
#ifndef ZTS
char *base = (char *) mh_arg2;
#else
char *base;
base = (char *) ts_resource(*((int *) mh_arg2));
#endif
p = (zend_long *) (base+(size_t) mh_arg1);
val = zend_atol(ZSTR_VAL(new_value), (int)ZSTR_LEN(new_value));
if (stage != ZEND_INI_STAGE_STARTUP &&
stage != ZEND_INI_STAGE_SHUTDOWN &&
*p != val &&
(*p < 0 || val < 0)) {
zend_error(E_WARNING, "zend.assertions may be completely enabled or disabled only in php.ini");
return FAILURE;
}
*p = val;
return SUCCESS;
}
int dom_node_node_value_write(dom_object *obj, zval *newval)
{
xmlNode *nodep = dom_object_get_node(obj);
if (nodep == NULL) {
php_dom_throw_error(INVALID_STATE_ERR, 0);
return FAILURE;
}
/* Access to Element node is implemented as a convience method */
switch (nodep->type) {
case XML_ELEMENT_NODE:
case XML_ATTRIBUTE_NODE:
if (nodep->children) {
node_list_unlink(nodep->children);
php_libxml_node_free_list((xmlNodePtr) nodep->children);
nodep->children = NULL;
}
case XML_TEXT_NODE:
case XML_COMMENT_NODE:
case XML_CDATA_SECTION_NODE:
case XML_PI_NODE:
{
zend_string *str = zval_get_string(newval);
xmlNodeSetContentLen(nodep, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1);
zend_string_release_ex(str, 0);
break;
}
default:
break;
}
return SUCCESS;
}
static inline apc_cache_entry_t* apc_cache_find_internal(apc_cache_t *cache, zend_string *key, time_t t, zend_bool lock) {
apc_cache_slot_t** slot;
zend_ulong h, s;
volatile apc_cache_entry_t* value = NULL;
if (lock)
APC_RLOCK(cache->header);
/* calculate hash and slot */
apc_cache_hash_slot(cache, key, &h, &s);
/* find head */
slot = &cache->slots[s];
while (*slot) {
/* check for a matching key by has and identifier */
if ((h == ZSTR_HASH((*slot)->key.str)) &&
memcmp(ZSTR_VAL((*slot)->key.str), ZSTR_VAL(key), ZSTR_LEN(key)) == SUCCESS) {
/* Check to make sure this entry isn't expired by a hard TTL */
if((*slot)->value->ttl && (time_t) ((*slot)->ctime + (*slot)->value->ttl) < t) {
/* increment misses on cache */
ATOMIC_INC(cache, cache->header->nmisses);
if (lock)
APC_RUNLOCK(cache->header);
return NULL;
}
/* set cache num hits */
ATOMIC_INC(cache, cache->header->nhits);
/* grab value */
value = (*slot)->value;
(*slot)->atime = t;
/* Otherwise we are fine, increase counters and return the cache entry */
ATOMIC_INC(cache, (*slot)->nhits);
ATOMIC_INC(cache, (*slot)->value->ref_count);
if (lock)
APC_RUNLOCK(cache->header);
return (apc_cache_entry_t*)value;
}
/* next */
slot = &(*slot)->next;
}
/* not found, so increment misses */
ATOMIC_INC(cache, cache->header->nmisses);
if (lock)
APC_RUNLOCK(cache->header);
return NULL;
}
static int php_password_salt_to64(const char *str, const size_t str_len, const size_t out_len, char *ret) /* {{{ */
{
size_t pos = 0;
zend_string *buffer;
if ((int) str_len < 0) {
return FAILURE;
}
buffer = php_base64_encode((unsigned char*) str, str_len);
if (ZSTR_LEN(buffer) < out_len) {
/* Too short of an encoded string generated */
zend_string_release(buffer);
return FAILURE;
}
for (pos = 0; pos < out_len; pos++) {
if (ZSTR_VAL(buffer)[pos] == '+') {
ret[pos] = '.';
} else if (ZSTR_VAL(buffer)[pos] == '=') {
zend_string_free(buffer);
return FAILURE;
} else {
ret[pos] = ZSTR_VAL(buffer)[pos];
}
}
zend_string_free(buffer);
return SUCCESS;
}
/* {{{ php_autoglobal_merge
*/
static void php_autoglobal_merge(HashTable *dest, HashTable *src)
{
zval *src_entry, *dest_entry;
zend_string *string_key;
zend_ulong num_key;
int globals_check = (dest == (&EG(symbol_table)));
ZEND_HASH_FOREACH_KEY_VAL(src, num_key, string_key, src_entry) {
if (Z_TYPE_P(src_entry) != IS_ARRAY
|| (string_key && (dest_entry = zend_hash_find(dest, string_key)) == NULL)
|| (string_key == NULL && (dest_entry = zend_hash_index_find(dest, num_key)) == NULL)
|| Z_TYPE_P(dest_entry) != IS_ARRAY) {
if (Z_REFCOUNTED_P(src_entry)) {
Z_ADDREF_P(src_entry);
}
if (string_key) {
if (!globals_check || ZSTR_LEN(string_key) != sizeof("GLOBALS") - 1
|| memcmp(ZSTR_VAL(string_key), "GLOBALS", sizeof("GLOBALS") - 1)) {
zend_hash_update(dest, string_key, src_entry);
} else if (Z_REFCOUNTED_P(src_entry)) {
Z_DELREF_P(src_entry);
}
} else {
zend_hash_index_update(dest, num_key, src_entry);
}
} else {
SEPARATE_ZVAL(dest_entry);
php_autoglobal_merge(Z_ARRVAL_P(dest_entry), Z_ARRVAL_P(src_entry));
}
} ZEND_HASH_FOREACH_END();
}
static void php_object_property_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
{
const char *prop_name, *class_name;
if (key == NULL) { /* numeric key */
php_printf("%*c[" ZEND_LONG_FMT "]=>\n", level + 1, ' ', index);
} else { /* string key */
int unmangle = zend_unmangle_property_name(key, &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(ZSTR_VAL(key), ZSTR_LEN(key));
php_printf("\"");
}
ZEND_PUTS("]=>\n");
}
php_var_dump(zv, level + 2);
}
static void escape_string(smart_str *buf, zend_string *str) /* {{{ */
{
size_t str_len = ZSTR_LEN(str);
if (!str_len) {
return;
}
// preallocate
smart_str_alloc(buf, str_len + 2, 0);
char *ptr = ZSTR_VAL(str);
char *ptr_max = ptr + str_len;
char *start = ptr;
char ch = *ptr;
for (; ptr < ptr_max; ptr++, ch = *ptr) {
if ('"' == ch || '\\' == ch) {
if (ptr > start) {
smart_str_appendl(buf, start, ptr - start);
}
start = ptr;
smart_str_appendc(buf, '\\');
}
}
if (ptr > start) {
smart_str_appendl(buf, start, ptr - start);
}
}
static inline void php_is_type(INTERNAL_FUNCTION_PARAMETERS, int type)
{
zval *arg;
#ifndef FAST_ZPP
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &arg) == FAILURE) {
RETURN_FALSE;
}
ZVAL_DEREF(arg);
#else
ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_ZVAL_DEREF(arg)
ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
#endif
if (Z_TYPE_P(arg) == type) {
if (type == IS_OBJECT) {
zend_class_entry *ce = Z_OBJCE_P(arg);
if (ZSTR_LEN(ce->name) == sizeof(INCOMPLETE_CLASS) - 1
&& !memcmp(ZSTR_VAL(ce->name), INCOMPLETE_CLASS, sizeof(INCOMPLETE_CLASS) - 1)) {
RETURN_FALSE;
}
} else if (type == IS_RESOURCE) {
const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(arg));
if (!type_name) {
RETURN_FALSE;
}
}
RETURN_TRUE;
} else {
RETURN_FALSE;
}
}
// need efree
char * kr_regex_replace (char * regex_o, char * replace_o, char * str_o) // {{{
{
zend_string * buf;
zend_string * regex;
zend_string * subject;
#if PHP_VERSION_ID < 70200
zval replaces;
#else
zend_string * replaces;
#endif
#if PHP_VERSION_ID < 70300
int repc = 0;
#else
size_t repc = 0;
#endif
char * sval;
regex = ze_string_init (regex_o, STRLEN (regex_o), 0);
subject = ze_string_init (str_o, STRLEN (str_o), 0);
#if PHP_VERSION_ID < 70200
ZVAL_STRINGL (&replaces, replace_o, STRLEN (replace_o));
#else
replaces = ze_string_init (replace_o, STRLEN (replace_o), 0);
#endif
buf = php_pcre_replace (
#if PHP_VERSION_ID < 70200
regex, subject, ZSTR_VAL (subject), (int) ZSTR_LEN (subject), &replaces, 0, -1, &repc
#else
regex, subject, ZSTR_VAL (subject), ZSTR_LEN (subject), replaces, -1, &repc
#endif
);
#if PHP_VERSION_ID < 70200
zval_ptr_dtor (&replaces);
#else
zend_string_release (replaces);
#endif
zend_string_release (regex);
zend_string_release (subject);
sval = estrdup (ZSTR_VAL (buf));
zend_string_release (buf);
return sval;
} // }}}
