/** * 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; } }