/**
* Decrypt a text that is coded as a base64 string
*
* @param string $text
* @param string $key
* @return string
*/
PHP_METHOD(Phalcon_Crypt, decryptBase64){
zval *text, *key = NULL, *safe = NULL, decrypt_text = {}, decrypt_value = {};
phalcon_fetch_params(0, 1, 2, &text, &key, &safe);
PHALCON_ENSURE_IS_STRING(text);
if (!key) {
key = &PHALCON_GLOBAL(z_null);
}
if (!safe) {
safe = &PHALCON_GLOBAL(z_false);
}
if (zend_is_true(safe)) {
ZVAL_NEW_STR(&decrypt_text, zend_string_dup(Z_STR_P(text), 0));
php_strtr(Z_STRVAL(decrypt_text), Z_STRLEN(decrypt_text), "-_", "+/", 2);
} else {
PHALCON_CPY_WRT_CTOR(&decrypt_text, text);
}
phalcon_base64_decode(&decrypt_value, &decrypt_text);
PHALCON_RETURN_CALL_METHODW(getThis(), "decrypt", &decrypt_value, key);
}
ZEND_API void ZEND_FASTCALL zval_copy_ctor_func(zval *zvalue)
{
if (EXPECTED(Z_TYPE_P(zvalue) == IS_ARRAY)) {
ZVAL_ARR(zvalue, zend_array_dup(Z_ARRVAL_P(zvalue)));
} else if (EXPECTED(Z_TYPE_P(zvalue) == IS_STRING)) {
ZEND_ASSERT(!ZSTR_IS_INTERNED(Z_STR_P(zvalue)));
CHECK_ZVAL_STRING(Z_STR_P(zvalue));
ZVAL_NEW_STR(zvalue, zend_string_dup(Z_STR_P(zvalue), 0));
}
}
static void copy_zend_constant(zval *zv)
{
zend_constant *c = Z_PTR_P(zv);
ZEND_ASSERT(c->flags & CONST_PERSISTENT);
Z_PTR_P(zv) = pemalloc(sizeof(zend_constant), 1);
memcpy(Z_PTR_P(zv), c, sizeof(zend_constant));
c = Z_PTR_P(zv);
c->name = zend_string_copy(c->name);
if (Z_TYPE(c->value) == IS_STRING) {
Z_STR(c->value) = zend_string_dup(Z_STR(c->value), 1);
}
}
/* {{{ proto array accelerator_get_scripts()
Get the scripts which are accelerated by ZendAccelerator */
static int accelerator_get_scripts(zval *return_value)
{
uint32_t i;
zval persistent_script_report;
zend_accel_hash_entry *cache_entry;
struct tm *ta;
struct timeval exec_time;
struct timeval fetch_time;
if (!ZCG(enabled) || !accel_startup_ok || !ZCSG(accelerator_enabled) || accelerator_shm_read_lock() != SUCCESS) {
return 0;
}
array_init(return_value);
for (i = 0; i<ZCSG(hash).max_num_entries; i++) {
for (cache_entry = ZCSG(hash).hash_table[i]; cache_entry; cache_entry = cache_entry->next) {
zend_persistent_script *script;
char *str;
size_t len;
if (cache_entry->indirect) continue;
script = (zend_persistent_script *)cache_entry->data;
array_init(&persistent_script_report);
add_assoc_str(&persistent_script_report, "full_path", zend_string_dup(script->script.filename, 0));
add_assoc_long(&persistent_script_report, "hits", (zend_long)script->dynamic_members.hits);
add_assoc_long(&persistent_script_report, "memory_consumption", script->dynamic_members.memory_consumption);
ta = localtime(&script->dynamic_members.last_used);
str = asctime(ta);
len = strlen(str);
if (len > 0 && str[len - 1] == '\n') len--;
add_assoc_stringl(&persistent_script_report, "last_used", str, len);
add_assoc_long(&persistent_script_report, "last_used_timestamp", script->dynamic_members.last_used);
if (ZCG(accel_directives).validate_timestamps) {
add_assoc_long(&persistent_script_report, "timestamp", (zend_long)script->timestamp);
}
timerclear(&exec_time);
timerclear(&fetch_time);
zend_hash_str_update(Z_ARRVAL_P(return_value), cache_entry->key, cache_entry->key_length, &persistent_script_report);
}
}
accelerator_shm_read_unlock();
return 1;
}
static zend_always_inline zend_string *zend_clone_str(zend_string *str)
{
zend_string *ret;
if (EXPECTED(IS_INTERNED(str))) {
ret = str;
} else if (GC_REFCOUNT(str) <= 1 || (ret = accel_xlat_get(str)) == NULL) {
ret = zend_string_dup(str, 0);
GC_FLAGS(ret) = GC_FLAGS(str);
if (GC_REFCOUNT(str) > 1) {
accel_xlat_set(str, ret);
}
} else {
GC_REFCOUNT(ret)++;
}
return ret;
}
int zend_optimizer_lookup_cv(zend_op_array *op_array, zend_string* name)
{
int i = 0;
zend_ulong hash_value = zend_string_hash_val(name);
while (i < op_array->last_var) {
if (op_array->vars[i] == name ||
(ZSTR_H(op_array->vars[i]) == hash_value &&
ZSTR_LEN(op_array->vars[i]) == ZSTR_LEN(name) &&
memcmp(ZSTR_VAL(op_array->vars[i]), ZSTR_VAL(name), ZSTR_LEN(name)) == 0)) {
return (int)(zend_intptr_t)ZEND_CALL_VAR_NUM(NULL, i);
}
i++;
}
i = op_array->last_var;
op_array->last_var++;
op_array->vars = erealloc(op_array->vars, op_array->last_var * sizeof(zend_string*));
op_array->vars[i] = zend_string_dup(name, 0);
/* all IS_TMP_VAR and IS_VAR variable numbers have to be adjusted */
{
zend_op *opline = op_array->opcodes;
zend_op *end = opline + op_array->last;
while (opline < end) {
if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
opline->op1.var += sizeof(zval);
}
if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
opline->op2.var += sizeof(zval);
}
if (opline->result_type & (IS_TMP_VAR|IS_VAR)) {
opline->result.var += sizeof(zval);
}
if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS ||
opline->opcode == ZEND_DECLARE_ANON_INHERITED_CLASS ||
opline->opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED) {
opline->extended_value += sizeof(zval);
}
opline++;
}
}
return (int)(zend_intptr_t)ZEND_CALL_VAR_NUM(NULL, i);
}
static zend_string *browscap_intern_str_ci(
browscap_parser_ctx *ctx, zend_string *str, zend_bool persistent) {
zend_string *lcname;
zend_string *interned;
ALLOCA_FLAG(use_heap);
ZSTR_ALLOCA_ALLOC(lcname, ZSTR_LEN(str), use_heap);
zend_str_tolower_copy(ZSTR_VAL(lcname), ZSTR_VAL(str), ZSTR_LEN(str));
interned = zend_hash_find_ptr(&ctx->str_interned, lcname);
if (interned) {
zend_string_addref(interned);
} else {
interned = zend_string_dup(lcname, persistent);
zend_hash_add_new_ptr(&ctx->str_interned, interned, interned);
}
ZSTR_ALLOCA_FREE(lcname, use_heap);
return interned;
}
/**
* Returns the called in class in the current scope
*/
void zephir_get_called_class(zval *return_value)
{
#if PHP_VERSION_ID >= 70100
zend_class_entry *called_scope = zend_get_called_scope(EG(current_execute_data));
if (called_scope) {
ZVAL_STR(return_value, zend_string_dup(called_scope->name, 0));
}
if (!zend_get_executed_scope()) {
php_error_docref(NULL, E_WARNING, "zephir_get_called_class() called from outside a class");
}
#else
if (EG(current_execute_data)->called_scope) {
zend_string *ret = EG(current_execute_data)->called_scope->name;
zend_string_addref(ret);
RETURN_STR(ret);
}
if (!EG(scope)) {
php_error_docref(NULL, E_WARNING, "zephir_get_called_class() called from outside a class");
}
#endif
}
// need efree
char * kr_regex_replace_arr (char * regex_o[], char * replace_o[], char * str_o, int regex_no) // {{{
{
zend_string * buf = NULL;
zend_string * regex;
zend_string * subject;
int i;
#if PHP_VERSION_ID < 70200
zval rep;
#else
zend_string * rep;
#endif
#if PHP_VERSION_ID < 70300
int repc = 0;
#else
size_t repc = 0;
#endif
char * sval;
subject = ze_string_init (str_o, STRLEN (str_o), 0);
for ( i=0; i<regex_no ; i++ ) {
regex = ze_string_init (regex_o[i], STRLEN (regex_o[i]), 0);
#if PHP_VERSION_ID < 70200
ZVAL_STRINGL (&rep, replace_o[i], STRLEN (replace_o[i]));
#else
rep = ze_string_init (replace_o[i], STRLEN (replace_o[i]), 0);
#endif
if ( i != 0 ) {
subject = zend_string_dup (buf, 0);
zend_string_release(buf);
buf = NULL;
}
/*
php_printf ("regex ########### %s\n", ZSTR_VAL (regex));
php_printf ("subject ######### %s\n", ZSTR_VAL (subject));
php_printf ("subjlen ######### %d\n", ZSTR_LEN (subject));
php_printf ("replace ######### %s\n", ZSTR_VAL (rep.value.str));
php_printf ("replace ######### %s\n", Z_STRVAL (rep.value.str));
*/
buf = php_pcre_replace (
regex,
subject,
ZSTR_VAL (subject),
ZSTR_LEN (subject),
#if PHP_VERSION_ID < 70200
&rep, 0,
#else
rep,
#endif
-1, &repc
);
#if PHP_VERSION_ID < 70200
zval_ptr_dtor (&rep);
#else
zend_string_release (rep);
#endif
zend_string_release (regex);
zend_string_release (subject);
}
sval = estrdup (ZSTR_VAL (buf));
zend_string_release (buf);
return sval;
} // }}}
/* Protects class' refcount, copies default properties, functions and class name */
static void zend_class_copy_ctor(zend_class_entry **pce)
{
zend_class_entry *ce = *pce;
zend_class_entry *old_ce = ce;
*pce = ce = ARENA_REALLOC(old_ce);
ce->refcount = 1;
if (old_ce->default_properties_table) {
int i;
ce->default_properties_table = emalloc(sizeof(zval) * old_ce->default_properties_count);
for (i = 0; i < old_ce->default_properties_count; i++) {
ZVAL_COPY_VALUE(&ce->default_properties_table[i], &old_ce->default_properties_table[i]);
zend_clone_zval(&ce->default_properties_table[i], 1);
}
}
zend_hash_clone_methods(&ce->function_table, &old_ce->function_table, old_ce, ce);
/* static members */
if (old_ce->default_static_members_table) {
int i;
ce->default_static_members_table = emalloc(sizeof(zval) * old_ce->default_static_members_count);
for (i = 0; i < old_ce->default_static_members_count; i++) {
ZVAL_COPY_VALUE(&ce->default_static_members_table[i], &old_ce->default_static_members_table[i]);
zend_clone_zval(&ce->default_static_members_table[i], 1);
}
}
ce->static_members_table = ce->default_static_members_table;
/* properties_info */
zend_hash_clone_prop_info(&ce->properties_info, &old_ce->properties_info, old_ce);
/* constants table */
zend_hash_clone_zval(&ce->constants_table, &old_ce->constants_table, 1);
ce->constants_table.u.flags &= ~HASH_FLAG_APPLY_PROTECTION;
ce->name = zend_clone_str(ce->name);
/* interfaces aren't really implemented, so we create a new table */
if (ce->num_interfaces) {
ce->interfaces = emalloc(sizeof(zend_class_entry *) * ce->num_interfaces);
memset(ce->interfaces, 0, sizeof(zend_class_entry *) * ce->num_interfaces);
} else {
ce->interfaces = NULL;
}
if (ZEND_CE_DOC_COMMENT(ce)) {
if (ZCG(accel_directives).load_comments) {
ZEND_CE_DOC_COMMENT(ce) = zend_string_dup(ZEND_CE_DOC_COMMENT(ce), 0);
} else {
ZEND_CE_DOC_COMMENT(ce) = NULL;
}
}
if (ce->parent) {
ce->parent = ARENA_REALLOC(ce->parent);
}
zend_update_inherited_handler(constructor);
zend_update_inherited_handler(destructor);
zend_update_inherited_handler(clone);
zend_update_inherited_handler(__get);
zend_update_inherited_handler(__set);
zend_update_inherited_handler(__call);
/* 5.1 stuff */
zend_update_inherited_handler(serialize_func);
zend_update_inherited_handler(unserialize_func);
zend_update_inherited_handler(__isset);
zend_update_inherited_handler(__unset);
/* 5.2 stuff */
zend_update_inherited_handler(__tostring);
/* 5.3 stuff */
zend_update_inherited_handler(__callstatic);
zend_update_inherited_handler(__debugInfo);
/* 5.4 traits */
if (ce->trait_aliases) {
zend_trait_alias **trait_aliases;
int i = 0;
while (ce->trait_aliases[i]) {
i++;
}
trait_aliases = emalloc(sizeof(zend_trait_alias*) * (i + 1));
i = 0;
while (ce->trait_aliases[i]) {
trait_aliases[i] = emalloc(sizeof(zend_trait_alias));
memcpy(trait_aliases[i], ce->trait_aliases[i], sizeof(zend_trait_alias));
trait_aliases[i]->trait_method = emalloc(sizeof(zend_trait_method_reference));
memcpy(trait_aliases[i]->trait_method, ce->trait_aliases[i]->trait_method, sizeof(zend_trait_method_reference));
if (trait_aliases[i]->trait_method) {
if (trait_aliases[i]->trait_method->method_name) {
trait_aliases[i]->trait_method->method_name =
zend_clone_str(trait_aliases[i]->trait_method->method_name);
}
if (trait_aliases[i]->trait_method->class_name) {
trait_aliases[i]->trait_method->class_name =
zend_clone_str(trait_aliases[i]->trait_method->class_name);
}
}
if (trait_aliases[i]->alias) {
trait_aliases[i]->alias =
zend_clone_str(trait_aliases[i]->alias);
}
i++;
}
trait_aliases[i] = NULL;
ce->trait_aliases = trait_aliases;
}
if (ce->trait_precedences) {
zend_trait_precedence **trait_precedences;
int i = 0;
while (ce->trait_precedences[i]) {
i++;
}
trait_precedences = emalloc(sizeof(zend_trait_precedence*) * (i + 1));
i = 0;
while (ce->trait_precedences[i]) {
trait_precedences[i] = emalloc(sizeof(zend_trait_precedence));
memcpy(trait_precedences[i], ce->trait_precedences[i], sizeof(zend_trait_precedence));
trait_precedences[i]->trait_method = emalloc(sizeof(zend_trait_method_reference));
memcpy(trait_precedences[i]->trait_method, ce->trait_precedences[i]->trait_method, sizeof(zend_trait_method_reference));
trait_precedences[i]->trait_method->method_name =
zend_clone_str(trait_precedences[i]->trait_method->method_name);
trait_precedences[i]->trait_method->class_name =
zend_clone_str(trait_precedences[i]->trait_method->class_name);
if (trait_precedences[i]->exclude_from_classes) {
zend_string **exclude_from_classes;
int j = 0;
while (trait_precedences[i]->exclude_from_classes[j].class_name) {
j++;
}
exclude_from_classes = emalloc(sizeof(zend_string*) * (j + 1));
j = 0;
while (trait_precedences[i]->exclude_from_classes[j].class_name) {
exclude_from_classes[j] =
zend_clone_str(trait_precedences[i]->exclude_from_classes[j].class_name);
j++;
}
exclude_from_classes[j] = NULL;
trait_precedences[i]->exclude_from_classes = (void*)exclude_from_classes;
}
i++;
}
trait_precedences[i] = NULL;
ce->trait_precedences = trait_precedences;
}
}
static void zend_hash_clone_prop_info(HashTable *ht, HashTable *source, zend_class_entry *old_ce)
{
uint idx;
Bucket *p, *q;
zend_ulong nIndex;
zend_property_info *prop_info;
ht->nTableSize = source->nTableSize;
ht->nTableMask = source->nTableMask;
ht->nNumUsed = 0;
ht->nNumOfElements = source->nNumOfElements;
ht->nNextFreeElement = source->nNextFreeElement;
ht->pDestructor = NULL;
ht->u.flags = (source->u.flags & HASH_FLAG_INITIALIZED);
ht->nInternalPointer = source->nNumOfElements ? 0 : INVALID_IDX;
if (!(ht->u.flags & HASH_FLAG_INITIALIZED)) {
ht->arHash = (uint32_t*)&uninitialized_bucket;
return;
}
ZEND_ASSERT(!(source->u.flags & HASH_FLAG_PACKED));
ht->arData = (Bucket *) emalloc(ht->nTableSize * (sizeof(Bucket) + sizeof(uint32_t)));
ht->arHash = (uint32_t*)(ht->arData + ht->nTableSize);
memset(ht->arHash, INVALID_IDX, sizeof(uint32_t) * ht->nTableSize);
for (idx = 0; idx < source->nNumUsed; idx++) {
p = source->arData + idx;
if (Z_TYPE(p->val) == IS_UNDEF) continue;
nIndex = p->h & ht->nTableMask;
/* Insert into hash collision list */
q = ht->arData + ht->nNumUsed;
Z_NEXT(q->val) = ht->arHash[nIndex];
ht->arHash[nIndex] = ht->nNumUsed++;
/* Initialize key */
q->h = p->h;
ZEND_ASSERT(p->key != NULL);
q->key = zend_clone_str(p->key);
/* Copy data */
prop_info = ARENA_REALLOC(Z_PTR(p->val));
ZVAL_PTR(&q->val, prop_info);
if (prop_info->ce == old_ce || (prop_info->flags & ZEND_ACC_SHADOW)) {
/* Copy constructor */
prop_info->name = zend_clone_str(prop_info->name);
if (prop_info->doc_comment) {
if (ZCG(accel_directives).load_comments) {
prop_info->doc_comment = zend_string_dup(prop_info->doc_comment, 0);
} else {
prop_info->doc_comment = NULL;
}
}
prop_info->ce = ARENA_REALLOC(prop_info->ce);
} else if ((void*)prop_info->ce >= ZCG(current_persistent_script)->arena_mem &&
(void*)prop_info->ce < (void*)((char*)ZCG(current_persistent_script)->arena_mem + ZCG(current_persistent_script)->arena_size)) {
prop_info->ce = ARENA_REALLOC(prop_info->ce);
}
}
}
static void php_browscap_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_type, void *arg) /* {{{ */
{
browser_data *bdata = arg;
int persistent = bdata->htab->u.flags & HASH_FLAG_PERSISTENT;
if (!arg1) {
return;
}
switch (callback_type) {
case ZEND_INI_PARSER_ENTRY:
if (Z_TYPE(bdata->current_section) != IS_UNDEF && arg2) {
zval new_property;
zend_string *new_key;
/* parent entry can not be same as current section -> causes infinite loop! */
if (!strcasecmp(Z_STRVAL_P(arg1), "parent") &&
bdata->current_section_name != NULL &&
!strcasecmp(bdata->current_section_name, Z_STRVAL_P(arg2))
) {
zend_error(E_CORE_ERROR, "Invalid browscap ini file: "
"'Parent' value cannot be same as the section name: %s "
"(in file %s)", bdata->current_section_name, INI_STR("browscap"));
return;
}
/* Set proper value for true/false settings */
if ((Z_STRLEN_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "on", sizeof("on") - 1)) ||
(Z_STRLEN_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "yes", sizeof("yes") - 1)) ||
(Z_STRLEN_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "true", sizeof("true") - 1))
) {
ZVAL_NEW_STR(&new_property, zend_string_init("1", sizeof("1")-1, persistent));
} else if (
(Z_STRLEN_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "no", sizeof("no") - 1)) ||
(Z_STRLEN_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "off", sizeof("off") - 1)) ||
(Z_STRLEN_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "none", sizeof("none") - 1)) ||
(Z_STRLEN_P(arg2) == 5 && !strncasecmp(Z_STRVAL_P(arg2), "false", sizeof("false") - 1))
) {
// TODO: USE STR_EMPTY_ALLOC()?
ZVAL_NEW_STR(&new_property, zend_string_init("", sizeof("")-1, persistent));
} else { /* Other than true/false setting */
ZVAL_STR(&new_property, zend_string_dup(Z_STR_P(arg2), persistent));
}
new_key = zend_string_dup(Z_STR_P(arg1), persistent);
zend_str_tolower(new_key->val, new_key->len);
zend_hash_update(Z_ARRVAL(bdata->current_section), new_key, &new_property);
zend_string_release(new_key);
}
break;
case ZEND_INI_PARSER_SECTION: {
zval processed;
zval unprocessed;
/*printf("'%s' (%d)\n",$1.value.str.val,$1.value.str.len + 1);*/
if (persistent) {
ZVAL_NEW_PERSISTENT_ARR(&bdata->current_section);
} else {
ZVAL_NEW_ARR(&bdata->current_section);
}
zend_hash_init(Z_ARRVAL(bdata->current_section), 0, NULL,
(dtor_func_t) (persistent?browscap_entry_dtor_persistent
:browscap_entry_dtor_request),
persistent);
if (bdata->current_section_name) {
pefree(bdata->current_section_name, persistent);
}
bdata->current_section_name = pestrndup(Z_STRVAL_P(arg1),
Z_STRLEN_P(arg1), persistent);
zend_hash_update(bdata->htab, Z_STR_P(arg1), &bdata->current_section);
ZVAL_STR(&processed, Z_STR_P(arg1));
ZVAL_STR(&unprocessed, zend_string_dup(Z_STR_P(arg1), persistent));
convert_browscap_pattern(&processed, persistent);
zend_hash_str_update(Z_ARRVAL(bdata->current_section), "browser_name_regex", sizeof("browser_name_regex")-1, &processed);
zend_hash_str_update(Z_ARRVAL(bdata->current_section), "browser_name_pattern", sizeof("browser_name_pattern")-1, &unprocessed);
}
break;
}
}
/* {{{ php_ini_parser_cb
*/
static void php_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_type, HashTable *target_hash)
{
zval *entry;
HashTable *active_hash;
char *extension_name;
if (active_ini_hash) {
active_hash = active_ini_hash;
} else {
active_hash = target_hash;
}
switch (callback_type) {
case ZEND_INI_PARSER_ENTRY: {
if (!arg2) {
/* bare string - nothing to do */
break;
}
/* PHP and Zend extensions are not added into configuration hash! */
if (!is_special_section && !strcasecmp(Z_STRVAL_P(arg1), PHP_EXTENSION_TOKEN)) { /* load PHP extension */
extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRLEN_P(arg2));
zend_llist_add_element(&extension_lists.functions, &extension_name);
} else if (!is_special_section && !strcasecmp(Z_STRVAL_P(arg1), ZEND_EXTENSION_TOKEN)) { /* load Zend extension */
extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRLEN_P(arg2));
zend_llist_add_element(&extension_lists.engine, &extension_name);
/* All other entries are added into either configuration_hash or active ini section array */
} else {
/* Store in active hash */
entry = zend_hash_update(active_hash, Z_STR_P(arg1), arg2);
Z_STR_P(entry) = zend_string_dup(Z_STR_P(entry), 1);
}
}
break;
case ZEND_INI_PARSER_POP_ENTRY: {
zval option_arr;
zval *find_arr;
if (!arg2) {
/* bare string - nothing to do */
break;
}
/* fprintf(stdout, "ZEND_INI_PARSER_POP_ENTRY: %s[%s] = %s\n",Z_STRVAL_P(arg1), Z_STRVAL_P(arg3), Z_STRVAL_P(arg2)); */
/* If option not found in hash or is not an array -> create array, otherwise add to existing array */
if ((find_arr = zend_hash_find(active_hash, Z_STR_P(arg1))) == NULL || Z_TYPE_P(find_arr) != IS_ARRAY) {
ZVAL_NEW_PERSISTENT_ARR(&option_arr);
zend_hash_init(Z_ARRVAL(option_arr), 8, NULL, config_zval_dtor, 1);
find_arr = zend_hash_update(active_hash, Z_STR_P(arg1), &option_arr);
}
/* arg3 is possible option offset name */
if (arg3 && Z_STRLEN_P(arg3) > 0) {
entry = zend_symtable_update(Z_ARRVAL_P(find_arr), Z_STR_P(arg3), arg2);
} else {
entry = zend_hash_next_index_insert(Z_ARRVAL_P(find_arr), arg2);
}
Z_STR_P(entry) = zend_string_dup(Z_STR_P(entry), 1);
}
break;
case ZEND_INI_PARSER_SECTION: { /* Create an array of entries of each section */
/* fprintf(stdout, "ZEND_INI_PARSER_SECTION: %s\n",Z_STRVAL_P(arg1)); */
char *key = NULL;
size_t key_len;
/* PATH sections */
if (!strncasecmp(Z_STRVAL_P(arg1), "PATH", sizeof("PATH") - 1)) {
key = Z_STRVAL_P(arg1);
key = key + sizeof("PATH") - 1;
key_len = Z_STRLEN_P(arg1) - sizeof("PATH") + 1;
is_special_section = 1;
has_per_dir_config = 1;
/* make the path lowercase on Windows, for case insensitivity. Does nothing for other platforms */
TRANSLATE_SLASHES_LOWER(key);
/* HOST sections */
} else if (!strncasecmp(Z_STRVAL_P(arg1), "HOST", sizeof("HOST") - 1)) {
key = Z_STRVAL_P(arg1);
key = key + sizeof("HOST") - 1;
key_len = Z_STRLEN_P(arg1) - sizeof("HOST") + 1;
is_special_section = 1;
has_per_host_config = 1;
zend_str_tolower(key, key_len); /* host names are case-insensitive. */
} else {
is_special_section = 0;
}
if (key && key_len > 0) {
/* Strip any trailing slashes */
while (key_len > 0 && (key[key_len - 1] == '/' || key[key_len - 1] == '\\')) {
key_len--;
key[key_len] = 0;
}
/* Strip any leading whitespace and '=' */
while (*key && (
*key == '=' ||
*key == ' ' ||
*key == '\t'
)) {
key++;
key_len--;
}
/* Search for existing entry and if it does not exist create one */
if ((entry = zend_hash_str_find(target_hash, key, key_len)) == NULL) {
zval section_arr;
ZVAL_NEW_PERSISTENT_ARR(§ion_arr);
zend_hash_init(Z_ARRVAL(section_arr), 8, NULL, (dtor_func_t) config_zval_dtor, 1);
entry = zend_hash_str_update(target_hash, key, key_len, §ion_arr);
}
active_ini_hash = Z_ARRVAL_P(entry);
}
}
break;
}
}
