/* parse headers */
static int multipart_buffer_headers(multipart_buffer *self, zend_llist *header)
{
char *line;
mime_header_entry entry = {0};
smart_string buf_value = {0};
char *key = NULL;
/* didn't find boundary, abort */
if (!find_boundary(self, self->boundary)) {
return 0;
}
/* get lines of text, or CRLF_CRLF */
while ((line = get_line(self)) && line[0] != '\0') {
/* add header to table */
char *value = NULL;
if (php_rfc1867_encoding_translation()) {
self->input_encoding = zend_multibyte_encoding_detector((const unsigned char *) line, strlen(line), self->detect_order, self->detect_order_size);
}
/* space in the beginning means same header */
if (!isspace(line[0])) {
value = strchr(line, ':');
}
if (value) {
if (buf_value.c && key) {
/* new entry, add the old one to the list */
smart_string_0(&buf_value);
entry.key = key;
entry.value = buf_value.c;
zend_llist_add_element(header, &entry);
buf_value.c = NULL;
key = NULL;
}
*value = '\0';
do { value++; } while (isspace(*value));
key = estrdup(line);
smart_string_appends(&buf_value, value);
} else if (buf_value.c) { /* If no ':' on the line, add to previous line */
smart_string_appends(&buf_value, line);
} else {
continue;
}
}
if (buf_value.c && key) {
/* add the last one to the list */
smart_string_0(&buf_value);
entry.key = key;
entry.value = buf_value.c;
zend_llist_add_element(header, &entry);
}
return 1;
}
static void php_config_ini_parser_cb(zval *arg1, zval *arg2, int callback_type, void *arg)
{
switch (callback_type) {
case ZEND_INI_PARSER_ENTRY: {
zval *entry;
if (!arg2) {
break;
}
if (!strcasecmp(Z_STRVAL_P(arg1), "extension")) { /* load function module */
zval copy;
copy = *arg2;
zval_copy_ctor(©);
copy.refcount = 0;
zend_llist_add_element(&extension_lists.functions, ©);
} else if (!strcasecmp(Z_STRVAL_P(arg1), ZEND_EXTENSION_TOKEN)) { /* load Zend extension */
char *extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRLEN_P(arg2));
zend_llist_add_element(&extension_lists.engine, &extension_name);
} else {
zend_hash_update(&configuration_hash, Z_STRVAL_P(arg1), Z_STRLEN_P(arg1)+1, arg2, sizeof(zval), (void **) &entry);
Z_STRVAL_P(entry) = zend_strndup(Z_STRVAL_P(entry), Z_STRLEN_P(entry));
}
}
break;
case ZEND_INI_PARSER_SECTION:
break;
}
}
static inline void *accounted_safe_ecalloc(size_t nmemb, size_t alloc_size, size_t offset, ser_context *ctx)
{
void *ret = safe_emalloc(nmemb, alloc_size, offset);
memset(ret, '\0', nmemb * alloc_size + offset);
zend_llist_add_element(&ctx->allocations, &ret);
return ret;
}
/* Generic Aggregated conversions */
static void from_zval_write_aggregation(const zval *container,
char *structure,
const field_descriptor *descriptors,
ser_context *ctx)
{
const field_descriptor *descr;
zval *elem;
if (Z_TYPE_P(container) != IS_ARRAY) {
do_from_zval_err(ctx, "%s", "expected an array here");
}
for (descr = descriptors; descr->name != NULL && !ctx->err.has_error; descr++) {
if ((elem = zend_hash_str_find(Z_ARRVAL_P(container),
descr->name, descr->name_size - 1)) != NULL) {
if (descr->from_zval == NULL) {
do_from_zval_err(ctx, "No information on how to convert value "
"of key '%s'", descr->name);
break;
}
zend_llist_add_element(&ctx->keys, (void*)&descr->name);
descr->from_zval(elem, ((char*)structure) + descr->field_offset, ctx);
zend_llist_remove_tail(&ctx->keys);
} else if (descr->required) {
do_from_zval_err(ctx, "The key '%s' is required", descr->name);
break;
}
}
}
int zend_register_extension(zend_extension *new_extension, DL_HANDLE handle)
{
#if ZEND_EXTENSIONS_SUPPORT
zend_extension extension;
extension = *new_extension;
extension.handle = handle;
zend_extension_dispatch_message(ZEND_EXTMSG_NEW_EXTENSION, &extension);
zend_llist_add_element(&zend_extensions, &extension);
if (extension.op_array_ctor) {
zend_extension_flags |= ZEND_EXTENSIONS_HAVE_OP_ARRAY_CTOR;
}
if (extension.op_array_dtor) {
zend_extension_flags |= ZEND_EXTENSIONS_HAVE_OP_ARRAY_DTOR;
}
if (extension.op_array_handler) {
zend_extension_flags |= ZEND_EXTENSIONS_HAVE_OP_ARRAY_HANDLER;
}
if (extension.op_array_persist_calc) {
zend_extension_flags |= ZEND_EXTENSIONS_HAVE_OP_ARRAY_PERSIST_CALC;
}
if (extension.op_array_persist) {
zend_extension_flags |= ZEND_EXTENSIONS_HAVE_OP_ARRAY_PERSIST;
}
/*fprintf(stderr, "Loaded %s, version %s\n", extension.name, extension.version);*/
#endif
return SUCCESS;
}
void
apd_summary_output_enter_function(int index, int filenum, int linenum)
{
apd_function_entry_t *function_entry;
apd_fcall_t *fcall;
TSRMLS_FETCH();
if (index == 1) {
return;
}
function_entry = apd_array_get(&APD_GLOBALS(summary).functions, index);
if (function_entry == NULL) {
php_error(E_WARNING, "Couldn't find function entry by index %d", index);
return;
}
fcall = find_fcall(&function_entry->coverage, filenum, linenum);
if (!fcall) {
fcall = ecalloc(1, sizeof(apd_fcall_t));
fcall->line = linenum;
fcall->file = filenum;
fcall->entry = function_entry;
append_fcall(&function_entry->coverage, fcall);
}
fcall->calls++;
zend_llist_add_element(&APD_GLOBALS(summary).call_list, &fcall);
}
static unsigned from_array_iterate(const zval *arr,
void (*func)(zval *elem, unsigned i, void **args, ser_context *ctx),
void **args,
ser_context *ctx)
{
unsigned i;
zval *elem;
char buf[sizeof("element #4294967295")];
char *bufp = buf;
/* Note i starts at 1, not 0! */
i = 1;
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(arr), elem) {
if ((size_t)snprintf(buf, sizeof(buf), "element #%u", i) >= sizeof(buf)) {
memcpy(buf, "element", sizeof("element"));
}
zend_llist_add_element(&ctx->keys, &bufp);
func(elem, i, args, ctx);
zend_llist_remove_tail(&ctx->keys);
if (ctx->err.has_error) {
break;
}
i++;
} ZEND_HASH_FOREACH_END();
return i -1;
}
/* {{{ push an item onto the work buffer */
int pthreads_stack_push(PTHREAD thread, PTHREAD work TSRMLS_DC) {
int acquire = 0;
int counted = -1;
acquire = pthread_mutex_lock(thread->lock);
if (acquire == SUCCESS || acquire == EDEADLK) {
zend_llist *stack = &thread->stack->objects;
if (stack) {
zend_llist_add_element(
stack, &work
);
counted = stack->count;
} else counted = -1;
if (acquire != EDEADLK)
pthread_mutex_unlock(thread->lock);
} else zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue: %d", acquire);
if (counted > 0) {
if (pthreads_state_isset(thread->state, PTHREADS_ST_WAITING TSRMLS_CC)) {
pthreads_unset_state(thread, PTHREADS_ST_WAITING TSRMLS_CC);
}
}
return counted;
} /* }}} */
static unsigned from_array_iterate(const zval *arr,
void (*func)(zval *elem, unsigned i, void **args, ser_context *ctx),
void **args,
ser_context *ctx)
{
HashPosition pos;
unsigned i;
zval *elem;
char buf[sizeof("element #4294967295")];
char *bufp = buf;
/* Note i starts at 1, not 0! */
for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(arr), &pos), i = 1;
!ctx->err.has_error
&& (elem = zend_hash_get_current_data_ex(Z_ARRVAL_P(arr), &pos)) != NULL;
zend_hash_move_forward_ex(Z_ARRVAL_P(arr), &pos), i++) {
if (snprintf(buf, sizeof(buf), "element #%u", i) >= sizeof(buf)) {
memcpy(buf, "element", sizeof("element"));
}
zend_llist_add_element(&ctx->keys, &bufp);
func(elem, i, args, ctx);
zend_llist_remove_tail(&ctx->keys);
}
return i -1;
}
static void to_zval_read_aggregation(const char *structure,
zval *zarr, /* initialized array */
const field_descriptor *descriptors,
res_context *ctx)
{
const field_descriptor *descr;
assert(Z_TYPE_P(zarr) == IS_ARRAY);
assert(Z_ARRVAL_P(zarr) != NULL);
for (descr = descriptors; descr->name != NULL && !ctx->err.has_error; descr++) {
zval *new_zv, tmp;
if (descr->to_zval == NULL) {
do_to_zval_err(ctx, "No information on how to convert native "
"field into value for key '%s'", descr->name);
break;
}
ZVAL_NULL(&tmp);
new_zv = zend_symtable_str_update(Z_ARRVAL_P(zarr), descr->name, descr->name_size - 1, &tmp);
zend_llist_add_element(&ctx->keys, (void*)&descr->name);
descr->to_zval(structure + descr->field_offset, new_zv, ctx);
zend_llist_remove_tail(&ctx->keys);
}
}
/* parse headers */
static int multipart_buffer_headers(multipart_buffer *self, zend_llist *header)
{
char *line;
mime_header_entry prev_entry = {0}, entry;
int prev_len, cur_len;
/* didn't find boundary, abort */
if (!find_boundary(self, self->boundary)) {
return 0;
}
/* get lines of text, or CRLF_CRLF */
while( (line = get_line(self)) && line[0] != '\0' )
{
/* add header to table */
char *key = line;
char *value = NULL;
if (php_rfc1867_encoding_translation()) {
self->input_encoding = zend_multibyte_encoding_detector(line, strlen(line), self->detect_order, self->detect_order_size);
}
/* space in the beginning means same header */
if (!isspace(line[0])) {
value = strchr(line, ':');
}
if (value) {
*value = 0;
do { value++; } while(isspace(*value));
entry.value = estrdup(value);
entry.key = estrdup(key);
} else if (zend_llist_count(header)) { /* If no ':' on the line, add to previous line */
prev_len = (int)strlen(prev_entry.value);
cur_len = (int)strlen(line);
entry.value = emalloc(prev_len + cur_len + 1);
memcpy(entry.value, prev_entry.value, prev_len);
memcpy(entry.value + prev_len, line, cur_len);
entry.value[cur_len + prev_len] = '\0';
entry.key = estrdup(prev_entry.key);
zend_llist_remove_tail(header);
} else {
continue;
}
zend_llist_add_element(header, &entry);
prev_entry = entry;
}
return 1;
}
zval * pthreads_objects_create(pthreads_objects pobjects TSRMLS_DC) {
zval * pobject;
MAKE_STD_ZVAL(pobject);
if (pobject) {
zend_llist_add_element(
&pobjects->cache, &pobject
);
}
return pobject;
}
ZEND_API void zend_llist_copy(zend_llist *dst, zend_llist *src)
{
zend_llist_element *ptr;
zend_llist_init(dst, src->size, src->dtor, src->persistent);
ptr = src->head;
while (ptr) {
zend_llist_add_element(dst, ptr->data);
ptr = ptr->next;
}
}
int zend_register_extension(zend_extension *new_extension, DL_HANDLE handle)
{
#if ZEND_EXTENSIONS_SUPPORT
zend_extension extension;
extension = *new_extension;
extension.handle = handle;
zend_extension_dispatch_message(ZEND_EXTMSG_NEW_EXTENSION, &extension);
zend_llist_add_element(&zend_extensions, &extension);
/*fprintf(stderr, "Loaded %s, version %s\n", extension.name, extension.version);*/
#endif
return SUCCESS;
}
static void sapi_header_add_op(sapi_header_op_enum op, sapi_header_struct *sapi_header)
{
if (!sapi_module.header_handler ||
(SAPI_HEADER_ADD & sapi_module.header_handler(sapi_header, op, &SG(sapi_headers)))) {
if (op == SAPI_HEADER_REPLACE) {
char *colon_offset = strchr(sapi_header->header, ':');
if (colon_offset) {
char sav = *colon_offset;
*colon_offset = 0;
sapi_remove_header(&SG(sapi_headers).headers, sapi_header->header, (int)strlen(sapi_header->header));
*colon_offset = sav;
}
}
zend_llist_add_element(&SG(sapi_headers).headers, (void *) sapi_header);
} else {
sapi_free_header(sapi_header);
}
}
/* {{{ push an item onto the work buffer */
int pthreads_stack_push(PTHREAD thread, PTHREAD work) {
int acquire = 0;
int counted = -1;
acquire = PTHREADS_LOCK(thread);
if (acquire == SUCCESS || acquire == EDEADLK) {
thread->worker = 1;
zend_llist_add_element(thread->stack, &work);
counted = thread->stack->count;
if (acquire != EDEADLK)
PTHREADS_UNLOCK(thread);
} else zend_error(E_ERROR, "pthreads has suffered an internal error and cannot continue: %d", acquire);
if (counted > 0) {
if (pthreads_state_isset(thread->state, PTHREADS_ST_WAITING)) {
PTHREADS_NOTIFY(thread);
}
}
return counted;
} /* }}} */
/* {{{ push an item onto the work buffer */
size_t pthreads_stack_push(PTHREAD thread, PTHREAD work TSRMLS_DC) {
zend_bool locked;
size_t counted = 0L;
if (pthreads_lock_acquire(thread->lock, &locked TSRMLS_CC)) {
zend_llist *stack = &thread->stack->objects;
if (stack) {
zend_llist_add_element(
stack, &work
);
counted = stack->count;
}
pthreads_lock_release(thread->lock, locked TSRMLS_CC);
if (counted > 0L) {
if (pthreads_state_isset(thread->state, PTHREADS_ST_WAITING TSRMLS_CC)) {
pthreads_unset_state(thread, PTHREADS_ST_WAITING TSRMLS_CC);
}
}
}
return counted;
} /* }}} */
/* {{{ 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;
}
}
/* {{{ php_init_config
*/
int php_init_config(void)
{
char *php_ini_file_name = NULL;
char *php_ini_search_path = NULL;
int php_ini_scanned_path_len;
char *open_basedir;
int free_ini_search_path = 0;
zend_file_handle fh;
zend_hash_init(&configuration_hash, 8, NULL, config_zval_dtor, 1);
if (sapi_module.ini_defaults) {
sapi_module.ini_defaults(&configuration_hash);
}
zend_llist_init(&extension_lists.engine, sizeof(char *), (llist_dtor_func_t) free_estring, 1);
zend_llist_init(&extension_lists.functions, sizeof(char *), (llist_dtor_func_t) free_estring, 1);
open_basedir = PG(open_basedir);
if (sapi_module.php_ini_path_override) {
php_ini_file_name = sapi_module.php_ini_path_override;
php_ini_search_path = sapi_module.php_ini_path_override;
free_ini_search_path = 0;
} else if (!sapi_module.php_ini_ignore) {
int search_path_size;
char *default_location;
char *env_location;
static const char paths_separator[] = { ZEND_PATHS_SEPARATOR, 0 };
#ifdef PHP_WIN32
char *reg_location;
char phprc_path[MAXPATHLEN];
#endif
env_location = getenv("PHPRC");
#ifdef PHP_WIN32
if (!env_location) {
char dummybuf;
int size;
SetLastError(0);
/*If the given bugger is not large enough to hold the data, the return value is
the buffer size, in characters, required to hold the string and its terminating
null character. We use this return value to alloc the final buffer. */
size = GetEnvironmentVariableA("PHPRC", &dummybuf, 0);
if (GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
/* The environment variable doesn't exist. */
env_location = "";
} else {
if (size == 0) {
env_location = "";
} else {
size = GetEnvironmentVariableA("PHPRC", phprc_path, size);
if (size == 0) {
env_location = "";
} else {
env_location = phprc_path;
}
}
}
}
#else
if (!env_location) {
env_location = "";
}
#endif
/*
* Prepare search path
*/
search_path_size = MAXPATHLEN * 4 + (int)strlen(env_location) + 3 + 1;
php_ini_search_path = (char *) emalloc(search_path_size);
free_ini_search_path = 1;
php_ini_search_path[0] = 0;
/* Add environment location */
if (env_location[0]) {
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, env_location, search_path_size);
php_ini_file_name = env_location;
}
#ifdef PHP_WIN32
/* Add registry location */
reg_location = GetIniPathFromRegistry();
if (reg_location != NULL) {
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, reg_location, search_path_size);
efree(reg_location);
}
#endif
/* Add cwd (not with CLI) */
if (!sapi_module.php_ini_ignore_cwd) {
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, ".", search_path_size);
}
if (PG(php_binary)) {
char *separator_location, *binary_location;
binary_location = estrdup(PG(php_binary));
separator_location = strrchr(binary_location, DEFAULT_SLASH);
if (separator_location && separator_location != binary_location) {
*(separator_location) = 0;
}
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, binary_location, search_path_size);
efree(binary_location);
}
/* Add default location */
#ifdef PHP_WIN32
default_location = (char *) emalloc(MAXPATHLEN + 1);
if (0 < GetWindowsDirectory(default_location, MAXPATHLEN)) {
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, default_location, search_path_size);
}
/* For people running under terminal services, GetWindowsDirectory will
* return their personal Windows directory, so lets add the system
* windows directory too */
if (0 < GetSystemWindowsDirectory(default_location, MAXPATHLEN)) {
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, default_location, search_path_size);
}
efree(default_location);
#else
default_location = PHP_CONFIG_FILE_PATH;
if (*php_ini_search_path) {
strlcat(php_ini_search_path, paths_separator, search_path_size);
}
strlcat(php_ini_search_path, default_location, search_path_size);
#endif
}
PG(open_basedir) = NULL;
/*
* Find and open actual ini file
*/
memset(&fh, 0, sizeof(fh));
/* If SAPI does not want to ignore all ini files OR an overriding file/path is given.
* This allows disabling scanning for ini files in the PHP_CONFIG_FILE_SCAN_DIR but still
* load an optional ini file. */
if (!sapi_module.php_ini_ignore || sapi_module.php_ini_path_override) {
/* Check if php_ini_file_name is a file and can be opened */
if (php_ini_file_name && php_ini_file_name[0]) {
zend_stat_t statbuf;
if (!VCWD_STAT(php_ini_file_name, &statbuf)) {
if (!((statbuf.st_mode & S_IFMT) == S_IFDIR)) {
fh.handle.fp = VCWD_FOPEN(php_ini_file_name, "r");
if (fh.handle.fp) {
fh.filename = php_ini_opened_path = expand_filepath(php_ini_file_name, NULL);
}
}
}
}
/* Otherwise search for php-%sapi-module-name%.ini file in search path */
if (!fh.handle.fp) {
const char *fmt = "php-%s.ini";
char *ini_fname;
spprintf(&ini_fname, 0, fmt, sapi_module.name);
fh.handle.fp = php_fopen_with_path(ini_fname, "r", php_ini_search_path, &php_ini_opened_path);
efree(ini_fname);
if (fh.handle.fp) {
fh.filename = php_ini_opened_path;
}
}
/* If still no ini file found, search for php.ini file in search path */
if (!fh.handle.fp) {
fh.handle.fp = php_fopen_with_path("php.ini", "r", php_ini_search_path, &php_ini_opened_path);
if (fh.handle.fp) {
fh.filename = php_ini_opened_path;
}
}
}
if (free_ini_search_path) {
efree(php_ini_search_path);
}
PG(open_basedir) = open_basedir;
if (fh.handle.fp) {
fh.type = ZEND_HANDLE_FP;
RESET_ACTIVE_INI_HASH();
zend_parse_ini_file(&fh, 1, ZEND_INI_SCANNER_NORMAL, (zend_ini_parser_cb_t) php_ini_parser_cb, &configuration_hash);
{
zval tmp;
ZVAL_NEW_STR(&tmp, zend_string_init(fh.filename, strlen(fh.filename), 1));
zend_hash_str_update(&configuration_hash, "cfg_file_path", sizeof("cfg_file_path")-1, &tmp);
if (php_ini_opened_path) {
efree(php_ini_opened_path);
}
php_ini_opened_path = zend_strndup(Z_STRVAL(tmp), Z_STRLEN(tmp));
}
}
/* Check for PHP_INI_SCAN_DIR environment variable to override/set config file scan directory */
php_ini_scanned_path = getenv("PHP_INI_SCAN_DIR");
if (!php_ini_scanned_path) {
/* Or fall back using possible --with-config-file-scan-dir setting (defaults to empty string!) */
php_ini_scanned_path = PHP_CONFIG_FILE_SCAN_DIR;
}
php_ini_scanned_path_len = (int)strlen(php_ini_scanned_path);
/* Scan and parse any .ini files found in scan path if path not empty. */
if (!sapi_module.php_ini_ignore && php_ini_scanned_path_len) {
struct dirent **namelist;
int ndir, i;
zend_stat_t sb;
char ini_file[MAXPATHLEN];
char *p;
zend_file_handle fh2;
zend_llist scanned_ini_list;
zend_llist_element *element;
int l, total_l = 0;
char *bufpath, *debpath, *endpath;
int lenpath;
zend_llist_init(&scanned_ini_list, sizeof(char *), (llist_dtor_func_t) free_estring, 1);
memset(&fh2, 0, sizeof(fh2));
bufpath = estrdup(php_ini_scanned_path);
for (debpath = bufpath ; debpath ; debpath=endpath) {
endpath = strchr(debpath, DEFAULT_DIR_SEPARATOR);
if (endpath) {
*(endpath++) = 0;
}
if (!debpath[0]) {
/* empty string means default builtin value
to allow "/foo/phd.d:" or ":/foo/php.d" */
debpath = PHP_CONFIG_FILE_SCAN_DIR;
}
lenpath = (int)strlen(debpath);
if (lenpath > 0 && (ndir = php_scandir(debpath, &namelist, 0, php_alphasort)) > 0) {
for (i = 0; i < ndir; i++) {
/* check for any file with .ini extension */
if (!(p = strrchr(namelist[i]->d_name, '.')) || (p && strcmp(p, ".ini"))) {
free(namelist[i]);
continue;
}
/* Reset active ini section */
RESET_ACTIVE_INI_HASH();
if (IS_SLASH(debpath[lenpath - 1])) {
snprintf(ini_file, MAXPATHLEN, "%s%s", debpath, namelist[i]->d_name);
} else {
snprintf(ini_file, MAXPATHLEN, "%s%c%s", debpath, DEFAULT_SLASH, namelist[i]->d_name);
}
if (VCWD_STAT(ini_file, &sb) == 0) {
if (S_ISREG(sb.st_mode)) {
if ((fh2.handle.fp = VCWD_FOPEN(ini_file, "r"))) {
fh2.filename = ini_file;
fh2.type = ZEND_HANDLE_FP;
if (zend_parse_ini_file(&fh2, 1, ZEND_INI_SCANNER_NORMAL, (zend_ini_parser_cb_t) php_ini_parser_cb, &configuration_hash) == SUCCESS) {
/* Here, add it to the list of ini files read */
l = (int)strlen(ini_file);
total_l += l + 2;
p = estrndup(ini_file, l);
zend_llist_add_element(&scanned_ini_list, &p);
}
}
}
}
free(namelist[i]);
}
free(namelist);
}
}
efree(bufpath);
if (total_l) {
int php_ini_scanned_files_len = (php_ini_scanned_files) ? (int)strlen(php_ini_scanned_files) + 1 : 0;
php_ini_scanned_files = (char *) realloc(php_ini_scanned_files, php_ini_scanned_files_len + total_l + 1);
if (!php_ini_scanned_files_len) {
*php_ini_scanned_files = '\0';
}
total_l += php_ini_scanned_files_len;
for (element = scanned_ini_list.head; element; element = element->next) {
if (php_ini_scanned_files_len) {
strlcat(php_ini_scanned_files, ",\n", total_l);
}
strlcat(php_ini_scanned_files, *(char **)element->data, total_l);
strlcat(php_ini_scanned_files, element->next ? ",\n" : "\n", total_l);
}
}
zend_llist_destroy(&scanned_ini_list);
} else {
/* Make sure an empty php_ini_scanned_path ends up as NULL */
php_ini_scanned_path = NULL;
}
if (sapi_module.ini_entries) {
/* Reset active ini section */
RESET_ACTIVE_INI_HASH();
zend_parse_ini_string(sapi_module.ini_entries, 1, ZEND_INI_SCANNER_NORMAL, (zend_ini_parser_cb_t) php_ini_parser_cb, &configuration_hash);
}
return SUCCESS;
}
PHPAPI void php_add_tick_function(void (*func)(int))
{
TSRMLS_FETCH();
zend_llist_add_element(&PG(tick_functions), (void *)&func);
}
/* parse headers */
static int multipart_buffer_headers(multipart_buffer *self, zend_llist *header)
{
char *line;
mime_header_entry entry = {0};
smart_string buf_value = {0};
char *key = NULL;
size_t newlines = 0;
/* didn't find boundary, abort */
if (!find_boundary(self, self->boundary)) {
return 0;
}
/* get lines of text, or CRLF_CRLF */
while ((line = get_line(self)) && line[0] != '\0') {
/* add header to table */
char *value = NULL;
if (php_rfc1867_encoding_translation()) {
self->input_encoding = zend_multibyte_encoding_detector((const unsigned char *) line, strlen(line), self->detect_order, self->detect_order_size);
}
/* space in the beginning means same header */
if (!isspace(line[0])) {
value = strchr(line, ':');
}
if (value) {
if (buf_value.c && key) {
/* new entry, add the old one to the list */
smart_string_0(&buf_value);
entry.key = key;
entry.value = buf_value.c;
zend_llist_add_element(header, &entry);
buf_value.c = NULL;
key = NULL;
}
*value = '\0';
do { value++; } while (isspace(*value));
key = estrdup(line);
smart_string_appends(&buf_value, value);
newlines = 0;
} else if (buf_value.c) { /* If no ':' on the line, add to previous line */
newlines++;
if (newlines > SUHOSIN7_G(upload_max_newlines)) {
SUHOSIN7_G(abort_request) = 1;
suhosin_log(S_FILES, "configured maximum number of newlines in RFC1867 MIME headers limit exceeded - dropping rest of upload");
return 0;
}
smart_string_appends(&buf_value, line);
} else {
continue;
}
}
if (buf_value.c && key) {
/* add the last one to the list */
smart_string_0(&buf_value);
entry.key = key;
entry.value = buf_value.c;
zend_llist_add_element(header, &entry);
}
return 1;
}
PHPAPI void php_add_tick_function(void (*func)(int, void*), void * arg)
{
struct st_tick_function tmp = {func, arg};
zend_llist_add_element(&PG(tick_functions), (void *)&tmp);
}
static void from_zval_write_sockaddr_aux(const zval *container,
struct sockaddr **sockaddr_ptr,
socklen_t *sockaddr_len,
ser_context *ctx)
{
int family;
zval *elem;
int fill_sockaddr;
if (Z_TYPE_P(container) != IS_ARRAY) {
do_from_zval_err(ctx, "%s", "expected an array here");
return;
}
fill_sockaddr = param_get_bool(ctx, KEY_FILL_SOCKADDR, 1);
if ((elem = zend_hash_str_find(Z_ARRVAL_P(container), "family", sizeof("family") - 1)) != NULL
&& Z_TYPE_P(elem) != IS_NULL) {
const char *node = "family";
zend_llist_add_element(&ctx->keys, &node);
from_zval_write_int(elem, (char*)&family, ctx);
zend_llist_remove_tail(&ctx->keys);
} else {
family = ctx->sock->type;
}
switch (family) {
case AF_INET:
/* though not all OSes support sockaddr_in used in IPv6 sockets */
if (ctx->sock->type != AF_INET && ctx->sock->type != AF_INET6) {
do_from_zval_err(ctx, "the specified family (number %d) is not "
"supported on this socket", family);
return;
}
*sockaddr_ptr = accounted_ecalloc(1, sizeof(struct sockaddr_in), ctx);
*sockaddr_len = sizeof(struct sockaddr_in);
if (fill_sockaddr) {
from_zval_write_sockaddr_in(container, (char*)*sockaddr_ptr, ctx);
(*sockaddr_ptr)->sa_family = AF_INET;
}
break;
#if HAVE_IPV6
case AF_INET6:
if (ctx->sock->type != AF_INET6) {
do_from_zval_err(ctx, "the specified family (AF_INET6) is not "
"supported on this socket");
return;
}
*sockaddr_ptr = accounted_ecalloc(1, sizeof(struct sockaddr_in6), ctx);
*sockaddr_len = sizeof(struct sockaddr_in6);
if (fill_sockaddr) {
from_zval_write_sockaddr_in6(container, (char*)*sockaddr_ptr, ctx);
(*sockaddr_ptr)->sa_family = AF_INET6;
}
break;
#endif /* HAVE_IPV6 */
case AF_UNIX:
if (ctx->sock->type != AF_UNIX) {
do_from_zval_err(ctx, "the specified family (AF_UNIX) is not "
"supported on this socket");
return;
}
*sockaddr_ptr = accounted_ecalloc(1, sizeof(struct sockaddr_un), ctx);
if (fill_sockaddr) {
struct sockaddr_un *sock_un = (struct sockaddr_un*)*sockaddr_ptr;
from_zval_write_sockaddr_un(container, (char*)*sockaddr_ptr, ctx);
(*sockaddr_ptr)->sa_family = AF_UNIX;
/* calculating length is more complicated here. Giving the size of
* struct sockaddr_un here and relying on the nul termination of
* sun_path does not work for paths in the abstract namespace. Note
* that we always assume the path is not empty and nul terminated */
*sockaddr_len = offsetof(struct sockaddr_un, sun_path) +
(sock_un->sun_path[0] == '\0'
? (1 + strlen(&sock_un->sun_path[1]))
: strlen(sock_un->sun_path));
} else {
*sockaddr_len = sizeof(struct sockaddr_un);
}
break;
default:
do_from_zval_err(ctx, "%s", "the only families currently supported are "
"AF_INET, AF_INET6 and AF_UNIX");
break;
}
static int _php_server_push_callback(CURL *parent_ch, CURL *easy, size_t num_headers, struct curl_pushheaders *push_headers, void *userp) /* {{{ */
{
php_curl *ch;
php_curl *parent;
php_curlm *mh = (php_curlm *)userp;
size_t rval = CURL_PUSH_DENY;
php_curlm_server_push *t = mh->handlers->server_push;
zval *pz_parent_ch = NULL;
zval pz_ch;
zval headers;
zval retval;
zend_resource *res;
char *header;
int error;
zend_fcall_info fci = empty_fcall_info;
pz_parent_ch = _php_curl_multi_find_easy_handle(mh, parent_ch);
if (pz_parent_ch == NULL) {
return rval;
}
parent = (php_curl*)zend_fetch_resource(Z_RES_P(pz_parent_ch), le_curl_name, le_curl);
ch = alloc_curl_handle();
ch->cp = easy;
_php_setup_easy_copy_handlers(ch, parent);
Z_ADDREF_P(pz_parent_ch);
res = zend_register_resource(ch, le_curl);
ZVAL_RES(&pz_ch, res);
size_t i;
array_init(&headers);
for(i=0; i<num_headers; i++) {
header = curl_pushheader_bynum(push_headers, i);
add_next_index_string(&headers, header);
}
zend_fcall_info_init(&t->func_name, 0, &fci, &t->fci_cache, NULL, NULL);
zend_fcall_info_argn(
&fci, 3,
pz_parent_ch,
&pz_ch,
&headers
);
fci.retval = &retval;
error = zend_call_function(&fci, &t->fci_cache);
zend_fcall_info_args_clear(&fci, 1);
zval_dtor(&headers);
if (error == FAILURE) {
php_error_docref(NULL, E_WARNING, "Cannot call the CURLMOPT_PUSHFUNCTION");
} else if (!Z_ISUNDEF(retval)) {
if (CURL_PUSH_DENY != zval_get_long(&retval)) {
rval = CURL_PUSH_OK;
/* we want to create a copy of this zval that we store in the multihandle structure element "easyh" */
zval tmp_val;
ZVAL_DUP(&tmp_val, &pz_ch);
zend_llist_add_element(&mh->easyh, &tmp_val);
} else {
/* libcurl will free this easy handle, avoid double free */
ch->cp = NULL;
}
}
return rval;
}
static inline void *accounted_ecalloc(size_t nmemb, size_t alloc_size, ser_context *ctx)
{
void *ret = ecalloc(nmemb, alloc_size);
zend_llist_add_element(&ctx->allocations, &ret);
return ret;
}