/** * @brief Unsets @a index from array @a arr * @param[in,out] arr Array * @param index Index * @param flags Flags (@c PH_SEPARATE: separate array if its reference count is greater than 1; @c arr will contain the separated array) * @return Whether the operation succeeded * @retval @c FAILURE Failure, @a arr is not an array or @a index is of not supported type * @retval @c SUCCESS Success * @note @c index will be handled as follows: @c NULL is treated as an empty string, @c double values are cast to @c integer, @c bool or @c resource are treated as @c integer * @throw @c E_WARNING if @a offset is not a scalar */ int ZEPHIR_FASTCALL zephir_array_unset(zval **arr, zval *index, int flags) { HashTable *ht; if (Z_TYPE_PP(arr) != IS_ARRAY) { return FAILURE; } if ((flags & PH_SEPARATE) == PH_SEPARATE) { SEPARATE_ZVAL_IF_NOT_REF(arr); } ht = Z_ARRVAL_PP(arr); switch (Z_TYPE_P(index)) { case IS_NULL: return (zend_hash_del(ht, "", 1) == SUCCESS); case IS_DOUBLE: return (zend_hash_index_del(ht, (ulong)Z_DVAL_P(index)) == SUCCESS); case IS_LONG: case IS_BOOL: case IS_RESOURCE: return (zend_hash_index_del(ht, Z_LVAL_P(index)) == SUCCESS); case IS_STRING: return (zend_symtable_del(ht, Z_STRVAL_P(index), Z_STRLEN_P(index)+1) == SUCCESS); default: zend_error(E_WARNING, "Illegal offset type"); return 0; } }
/** * Unsets zval index from array */ int phalcon_array_unset(zval *arr, zval *index){ zval *copy; if (Z_TYPE_P(arr) != IS_ARRAY) { return 0; } if (Z_TYPE_P(index) == IS_NULL) { ALLOC_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_string(copy); index = copy; } else { if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) { ALLOC_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_long(copy); index = copy; } } if (Z_TYPE_P(index) == IS_STRING) { return zend_hash_del(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1); } else { return zend_hash_index_del(Z_ARRVAL_P(arr), Z_LVAL_P(index)); } return 0; }
/* {{{ mysqlnd_vio::open_pipe */ static php_stream * MYSQLND_METHOD(mysqlnd_vio, open_pipe)(MYSQLND_VIO * const vio, const MYSQLND_CSTRING scheme, const zend_bool persistent, MYSQLND_STATS * const conn_stats, MYSQLND_ERROR_INFO * const error_info) { #if PHP_API_VERSION < 20100412 unsigned int streams_options = ENFORCE_SAFE_MODE; #else unsigned int streams_options = 0; #endif dtor_func_t origin_dtor; php_stream * net_stream = NULL; DBG_ENTER("mysqlnd_vio::open_pipe"); if (persistent) { streams_options |= STREAM_OPEN_PERSISTENT; } streams_options |= IGNORE_URL; net_stream = php_stream_open_wrapper(scheme.s + sizeof("pipe://") - 1, "r+", streams_options, NULL); if (!net_stream) { SET_CLIENT_ERROR(error_info, CR_CONNECTION_ERROR, UNKNOWN_SQLSTATE, "Unknown errror while connecting"); DBG_RETURN(NULL); } /* Streams are not meant for C extensions! Thus we need a hack. Every connected stream will be registered as resource (in EG(regular_list). So far, so good. However, it won't be unregistered until the script ends. So, we need to take care of that. */ origin_dtor = EG(regular_list).pDestructor; EG(regular_list).pDestructor = NULL; zend_hash_index_del(&EG(regular_list), net_stream->res->handle); /* ToDO: should it be res->handle, do streams register with addref ?*/ EG(regular_list).pDestructor = origin_dtor; net_stream->res = NULL; DBG_RETURN(net_stream); }
PHP_MAILPARSE_API void php_mimepart_remove_from_parent(php_mimepart *part) { php_mimepart *parent = part->parent; HashPosition pos; php_mimepart *childpart; zval *childpart_z; if (parent == NULL) return; part->parent = NULL; zend_hash_internal_pointer_reset_ex(&parent->children, &pos); while((childpart_z = zend_hash_get_current_data_ex(&parent->children, &pos)) != NULL) { if ((childpart_z = zend_hash_get_current_data_ex(&parent->children, &pos)) != NULL) { mailparse_fetch_mimepart_resource(childpart, childpart_z); if (childpart == part) { ulong h; zend_hash_get_current_key_ex(&parent->children, NULL, &h, &pos); zend_hash_index_del(&parent->children, h); break; } } zend_hash_move_forward_ex(&parent->children, &pos); } }
static HashTable* spl_fixedarray_object_get_properties(zval *obj) /* {{{{ */ { spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(obj); HashTable *ht = zend_std_get_properties(obj); zend_long i = 0; if (intern->array) { zend_long j = zend_hash_num_elements(ht); for (i = 0; i < intern->array->size; i++) { if (!Z_ISUNDEF(intern->array->elements[i])) { zend_hash_index_update(ht, i, &intern->array->elements[i]); if (Z_REFCOUNTED(intern->array->elements[i])){ Z_ADDREF(intern->array->elements[i]); } } else { zend_hash_index_update(ht, i, &EG(uninitialized_zval)); } } if (j > intern->array->size) { for (i = intern->array->size; i < j; ++i) { zend_hash_index_del(ht, i); } } } return ht; }
PHP_METHOD(air_mysql_waiter, step_2) { AIR_INIT_THIS; zval *services = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_services"), 0 TSRMLS_CC); zval *responses = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_responses"), 0 TSRMLS_CC); zval *context = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_context"), 0 TSRMLS_CC); zval *m2s = air_arr_find(context, ZEND_STRS("m2s")); zval *reads = air_arr_find(context, ZEND_STRS("reads")); zval *waited = air_arr_find(context, ZEND_STRS("waited")); zval *processed = air_arr_find(context, ZEND_STRS("processed")); zval *step = air_arr_find(context, ZEND_STRS("step")); zend_class_entry *mysqli_ce = air_get_ce(ZEND_STRL("mysqli") TSRMLS_CC); ulong idx; char *key; int key_len; zval *mysqli; AIR_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(reads), idx, key, key_len, mysqli){ zval *service_id = air_arr_idx_find(m2s, air_mysqli_get_id(mysqli TSRMLS_CC)); zval *service = air_arr_idx_find(services, Z_LVAL_P(service_id)); zval *mysql = zend_read_property(air_async_service_ce, service, ZEND_STRL("_request"), 0 TSRMLS_CC); zval **trigger_params[2]; zval *event; MAKE_STD_ZVAL(event); zval *event_params; MAKE_STD_ZVAL(event_params); array_init(event_params); Z_ADDREF_P(mysqli); add_next_index_zval(event_params, mysqli); zval *mysqli_result = NULL; if(air_mysqli_get_errno(mysqli TSRMLS_CC)){ ZVAL_STRING(event, "error", 1); }else{ ZVAL_STRING(event, "success", 1); air_call_method(&mysqli, mysqli_ce, NULL, ZEND_STRL("reap_async_query"), &mysqli_result, 0, NULL TSRMLS_CC); Z_ADDREF_P(mysqli_result); add_next_index_zval(event_params, mysqli_result); } trigger_params[0] = &event; trigger_params[1] = &event_params; zval *results = NULL; air_call_method(&mysql, air_mysql_ce, NULL, ZEND_STRL("trigger"), &results, 2, trigger_params TSRMLS_CC); if(results){ add_index_zval(responses, Z_LVAL_P(service_id), results); }else{ php_error(E_WARNING, "error on trigger event %s with no results", Z_STRVAL_P(event)); } zend_hash_index_del(Z_ARRVAL_P(services), Z_LVAL_P(service_id)); zval_ptr_dtor(&event); zval_ptr_dtor(&event_params); if(mysqli_result){ zval_ptr_dtor(&mysqli_result); } zval *mysql_config = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_config"), 0 TSRMLS_CC); zval *mode = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_mode"), 0 TSRMLS_CC); zval **release_params[3] = {&mysqli, &mysql_config, &mode}; air_call_static_method(air_mysql_keeper_ce, "release", NULL, 3, release_params); }AIR_HASH_FOREACH_END();
ZEND_API int zend_ts_hash_index_del(TsHashTable *ht, zend_ulong h) { int retval; begin_write(ht); retval = zend_hash_index_del(TS_HASH(ht), h); end_write(ht); return retval; }
/* {{{ proto void SolrFunction::__destruct(void) Destructor. */ PHP_METHOD(SolrCollapseFunction, __destruct) { solr_function_t *function = NULL; /* Retrieve the document entry for this SolrDocument */ if (solr_fetch_function_entry(getThis(), &function TSRMLS_CC) == SUCCESS ) { zend_hash_index_del(SOLR_GLOBAL(functions), function->function_index); } return; }
int air_mysql_keeper_get_mysqli(zval **pp_mysqli, zval *config, int mode TSRMLS_DC){ zval *mysqli = air_new_object(ZEND_STRL("mysqli") TSRMLS_CC); air_call_method(&mysqli, Z_OBJCE_P(mysqli), NULL, ZEND_STRL("init"), NULL, 0, NULL TSRMLS_CC); zval **params[7]; zval *host, *user, *pass, *db, *port, *sock, *flag, *nil; MAKE_STD_ZVAL(nil); ZVAL_NULL(nil); zval *auth = air_arr_find(config, ZEND_STRS("auth")); zval *mode_auth = air_arr_idx_find(auth, mode); user = air_arr_find(mode_auth, ZEND_STRS("username")); pass = air_arr_find(mode_auth, ZEND_STRS("password")); params[1] = user? &user: &nil; params[2] = pass? &pass: &nil; params[3] = &nil; MAKE_STD_ZVAL(flag); ZVAL_LONG(flag, MYSQLI_FOUND_ROWS); params[6] = &flag; zval *pool = air_arr_find(config, ZEND_STRS("pool")); zval *mode_pool = air_arr_idx_find(pool, mode); zval *rand_arr[1] = {mode_pool}; zval *mode_hps; zval *ret; while(1){ zval *arr_idx = air_call_func("array_rand", 1, rand_arr); if(!arr_idx){ return -3; } mode_hps = air_arr_idx_find(mode_pool, Z_LVAL_P(arr_idx)); host = air_arr_find(mode_hps, ZEND_STRS("host")); port = air_arr_find(mode_hps, ZEND_STRS("port")); sock = air_arr_find(mode_hps, ZEND_STRS("sock")); params[0] = host? &host: &nil; params[4] = port? &port: &nil; params[5] = sock? &sock: &nil; air_call_method(&mysqli, Z_OBJCE_P(mysqli), NULL, ZEND_STRL("real_connect"), &ret, 7, params TSRMLS_CC); if(Z_LVAL_P(ret)){ zval_ptr_dtor(&arr_idx); zval_ptr_dtor(&ret); break; }else{ zval_ptr_dtor(&ret); zend_hash_index_del(Z_ARRVAL_P(mode_pool), Z_LVAL_P(arr_idx)); zval_ptr_dtor(&arr_idx); if(!zend_hash_num_elements(Z_ARRVAL_P(mode_pool))){ return -5; } } } zval_ptr_dtor(&nil); zval_ptr_dtor(&flag); *pp_mysqli = mysqli; return 0; }
/** * @brief Unsets numeric @a index from array @a arr * @param[in,out] arr Array * @param index Index * @param flags Flags (@c PH_SEPARATE: separate array if its reference count is greater than 1; @c arr will contain the separated array) * @return Whether the operation succeeded * @retval @c FAILURE Failure or @a arr is not an array * @retval @c SUCCESS Success */ int ZEPHIR_FASTCALL zephir_array_unset_long(zval **arr, unsigned long index, int flags) { if (Z_TYPE_PP(arr) != IS_ARRAY) { return 0; } if ((flags & PH_SEPARATE) == PH_SEPARATE) { SEPARATE_ZVAL_IF_NOT_REF(arr); } return zend_hash_index_del(Z_ARRVAL_PP(arr), index); }
/* {{{ */ zend_bool pthreads_globals_object_delete(void *address) { zend_bool deleted = 0; if (!address) return deleted; if (pthreads_globals_lock()) { deleted = zend_hash_index_del( &PTHREADS_G(objects), (zend_ulong) address); pthreads_globals_unlock(); } return deleted; } /* }}} */
ZEND_API int _zend_list_delete(int id TSRMLS_DC) { zend_rsrc_list_entry *le; if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) { /* printf("del(%d): %d->%d\n", id, le->refcount, le->refcount-1); */ if (--le->refcount<=0) { return zend_hash_index_del(&EG(regular_list), id); } else { return SUCCESS; } } else { return FAILURE; } }
/* {{{ proto void SolrInputDocument::__destruct(void) Destructor for SolrInputDocument */ PHP_METHOD(SolrInputDocument, __destruct) { solr_document_t *doc_entry = NULL; /* Retrieve the document entry for this SolrDocument */ if (solr_fetch_document_entry(getThis(), &doc_entry TSRMLS_CC) == SUCCESS) { zend_hash_index_del(SOLR_GLOBAL(documents), doc_entry->document_index); /* Keep track of how many SolrDocument instances we currently have */ SOLR_GLOBAL(document_count)--; return ; } }
/** * Unsets zval index from array */ int PHALCON_FASTCALL phalcon_array_unset(zval **arr, zval *index, int flags) { zval *copy; int exists, copied = 0; if (Z_TYPE_PP(arr) != IS_ARRAY) { return 0; } if (Z_TYPE_P(index) == IS_NULL) { ALLOC_INIT_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_string(copy); index = copy; copied = 1; } else { if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) { ALLOC_INIT_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_long(copy); index = copy; copied = 1; } } if ((flags & PH_SEPARATE) == PH_SEPARATE) { if (Z_REFCOUNT_PP(arr) > 1) { zval *new_zv; Z_DELREF_PP(arr); ALLOC_ZVAL(new_zv); INIT_PZVAL_COPY(new_zv, *arr); *arr = new_zv; zval_copy_ctor(new_zv); } } if (Z_TYPE_P(index) == IS_STRING) { exists = zend_hash_del(Z_ARRVAL_PP(arr), Z_STRVAL_P(index), Z_STRLEN_P(index) + 1); } else { exists = zend_hash_index_del(Z_ARRVAL_PP(arr), Z_LVAL_P(index)); } if (copied) { zval_ptr_dtor(©); } return exists; }
/** * Unsets long index from array */ int PHALCON_FASTCALL phalcon_array_unset_long(zval **arr, unsigned long index, int flags) { if (Z_TYPE_PP(arr) != IS_ARRAY) { return 0; } if ((flags & PH_SEPARATE) == PH_SEPARATE) { if (Z_REFCOUNT_PP(arr) > 1) { zval *new_zv; Z_DELREF_PP(arr); ALLOC_ZVAL(new_zv); INIT_PZVAL_COPY(new_zv, *arr); *arr = new_zv; zval_copy_ctor(new_zv); } } return zend_hash_index_del(Z_ARRVAL_PP(arr), index); }
/* {{{ php_oci_lob_free() Close LOB descriptor and free associated resources */ void php_oci_lob_free (php_oci_descriptor *descriptor) { if (!descriptor || !descriptor->connection) { return; } if (descriptor->connection->descriptors) { /* delete descriptor from the hash */ zend_hash_index_del(descriptor->connection->descriptors, descriptor->index); if (zend_hash_num_elements(descriptor->connection->descriptors) == 0) { descriptor->connection->descriptor_count = 0; } else { if (descriptor->index + 1 == descriptor->connection->descriptor_count) { /* If the descriptor being freed is the end-most one * allocated, then the descriptor_count is reduced so * a future descriptor can reuse the hash table index. * This can prevent the hash index range increasing in * the common case that each descriptor is * allocated/used/freed before another descriptor is * needed. However it is possible that a script frees * descriptors in arbitrary order which would prevent * descriptor_count ever being reduced to zero until * zend_hash_num_elements() returns 0. */ descriptor->connection->descriptor_count--; } } } /* flushing Lobs & Files with buffering enabled */ if ((descriptor->type == OCI_DTYPE_FILE || descriptor->type == OCI_DTYPE_LOB) && descriptor->buffering == PHP_OCI_LOB_BUFFER_USED) { php_oci_lob_flush(descriptor, OCI_LOB_BUFFER_FREE); } if (descriptor->type == OCI_DTYPE_LOB) { php_oci_temp_lob_close(descriptor); } PHP_OCI_CALL(OCIDescriptorFree, (descriptor->descriptor, descriptor->type)); zend_list_delete(descriptor->connection->id); efree(descriptor); }
static void phpdbg_remove_watch_collision(phpdbg_watchpoint_t *watch) { phpdbg_watch_collision *cur; if ((cur = zend_hash_index_find_ptr(&PHPDBG_G(watch_collisions), (zend_ulong) Z_COUNTED_P(watch->addr.zv)))) { if (cur->refs && !--cur->refs) { phpdbg_delete_watchpoints_recursive(watch); } zend_hash_del(&cur->watches, watch->str); zend_hash_del(&cur->implicit_watches, watch->str); if (zend_hash_num_elements(&cur->watches) > 0) { cur->watch = Z_PTR_P(zend_hash_get_current_data_ex(&cur->watches, NULL)); } else if (zend_hash_num_elements(&cur->implicit_watches) > 0) { cur->watch = Z_PTR_P(zend_hash_get_current_data_ex(&cur->implicit_watches, NULL)); } else { phpdbg_deactivate_watchpoint(cur->watch); phpdbg_remove_watchpoint(cur->watch); zend_hash_index_del(&PHPDBG_G(watch_collisions), (zend_ulong) Z_COUNTED_P(watch->addr.zv)); } } }
/** * Unsets zval index from array */ int PHALCON_FASTCALL phalcon_array_unset(zval *arr, zval *index){ zval *copy; int exists, copied = 0; if (Z_TYPE_P(arr) != IS_ARRAY) { return 0; } if (Z_TYPE_P(index) == IS_NULL) { ALLOC_INIT_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_string(copy); index = copy; copied = 1; } else { if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) { ALLOC_INIT_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_long(copy); index = copy; copied = 1; } } if (Z_TYPE_P(index) == IS_STRING) { exists = zend_hash_del(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1); } else { exists = zend_hash_index_del(Z_ARRVAL_P(arr), Z_LVAL_P(index)); } if (copied) { zval_ptr_dtor(©); } return exists; }
static zend_always_inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, zend_long elements, int objprops) { while (elements-- > 0) { zval key, *data, d, *old_data; zend_ulong idx; ZVAL_UNDEF(&key); if (!php_var_unserialize_ex(&key, p, max, NULL, classes)) { zval_dtor(&key); return 0; } data = NULL; ZVAL_UNDEF(&d); if (!objprops) { if (Z_TYPE(key) == IS_LONG) { idx = Z_LVAL(key); numeric_key: if (UNEXPECTED((old_data = zend_hash_index_find(ht, idx)) != NULL)) { //??? update hash var_push_dtor(var_hash, old_data); data = zend_hash_index_update(ht, idx, &d); } else { data = zend_hash_index_add_new(ht, idx, &d); } } else if (Z_TYPE(key) == IS_STRING) { if (UNEXPECTED(ZEND_HANDLE_NUMERIC(Z_STR(key), idx))) { goto numeric_key; } if (UNEXPECTED((old_data = zend_hash_find(ht, Z_STR(key))) != NULL)) { //??? update hash var_push_dtor(var_hash, old_data); data = zend_hash_update(ht, Z_STR(key), &d); } else { data = zend_hash_add_new(ht, Z_STR(key), &d); } } else { zval_dtor(&key); return 0; } } else { if (EXPECTED(Z_TYPE(key) == IS_STRING)) { string_key: if ((old_data = zend_hash_find(ht, Z_STR(key))) != NULL) { if (Z_TYPE_P(old_data) == IS_INDIRECT) { old_data = Z_INDIRECT_P(old_data); } var_push_dtor(var_hash, old_data); data = zend_hash_update_ind(ht, Z_STR(key), &d); } else { data = zend_hash_add_new(ht, Z_STR(key), &d); } } else if (Z_TYPE(key) == IS_LONG) { /* object properties should include no integers */ convert_to_string(&key); goto string_key; } else { zval_dtor(&key); return 0; } } if (!php_var_unserialize_ex(data, p, max, var_hash, classes)) { zval_dtor(&key); return 0; } if (UNEXPECTED(Z_ISUNDEF_P(data))) { if (Z_TYPE(key) == IS_LONG) { zend_hash_index_del(ht, Z_LVAL(key)); } else { zend_hash_del_ind(ht, Z_STR(key)); } } else { var_push_dtor(var_hash, data); } zval_dtor(&key); if (elements && *(*p-1) != ';' && *(*p-1) != '}') { (*p)--; return 0; } } return 1; }
/* {{{ php_runkit_import_functions */ static int php_runkit_import_functions(HashTable *function_table, long flags TSRMLS_DC) { HashPosition pos; int i, func_count = zend_hash_num_elements(function_table); zend_hash_internal_pointer_reset_ex(function_table, &pos); for(i = 0; i < func_count; i++) { zend_function *fe = NULL; char *key, *new_key; int key_len, new_key_len, type; long idx; zend_bool add_function = 1; zend_bool exists = 0; zend_hash_get_current_data_ex(function_table, (void**)&fe, &pos); new_key = fe->common.function_name; new_key_len = strlen(new_key) + 1; if (((type = zend_hash_get_current_key_ex(function_table, &key, &key_len, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT) && fe && fe->type == ZEND_USER_FUNCTION) { if (type == HASH_KEY_IS_STRING) { new_key = key; new_key_len = key_len; exists = zend_hash_exists(EG(function_table), new_key, new_key_len); } else { exists = zend_hash_index_exists(EG(function_table), idx); } if (exists) { if (flags & PHP_RUNKIT_IMPORT_OVERRIDE) { if (type == HASH_KEY_IS_STRING) { if (zend_hash_del(EG(function_table), new_key, new_key_len) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment"); return FAILURE; } } else { if (zend_hash_index_del(EG(function_table), idx) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment"); return FAILURE; } } } else { add_function = 0; } } } if (add_function) { if (zend_hash_add(EG(function_table), new_key, new_key_len, fe, sizeof(zend_function), NULL) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failure importing %s()", fe->common.function_name); #ifdef ZEND_ENGINE_2 destroy_zend_function(fe TSRMLS_CC); #else destroy_end_function(fe); #endif return FAILURE; } else { fe->op_array.static_variables = NULL; (*fe->op_array.refcount)++; } } zend_hash_move_forward_ex(function_table, &pos); } return SUCCESS; }
/* {{{ php_runkit_import_functions */ static int php_runkit_import_functions(HashTable *function_table, long flags TSRMLS_DC) { HashPosition pos; int i, func_count = zend_hash_num_elements(function_table); zend_hash_internal_pointer_reset_ex(function_table, &pos); for(i = 0; i < func_count; i++) { zend_function *fe = NULL; char *key; uint key_len; int type; ulong idx; zend_bool add_function = 1; zend_hash_get_current_data_ex(function_table, (void**)&fe, &pos); if (((type = zend_hash_get_current_key_ex(EG(function_table), &key, &key_len, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT) && fe && fe->type == ZEND_USER_FUNCTION) { if (flags & PHP_RUNKIT_IMPORT_OVERRIDE) { if (type == HASH_KEY_IS_STRING) { if (zend_hash_del(EG(function_table), key, key_len) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment"); return FAILURE; } } else { if (zend_hash_index_del(EG(function_table), idx) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment"); return FAILURE; } } } else { add_function = 0; } } if (add_function) { PHP_RUNKIT_FUNCTION_ADD_REF(fe); char *lcase = estrdup(fe->common.function_name); int lcase_len = strlen(lcase); php_strtolower(lcase, lcase_len); if (zend_hash_add(EG(function_table), lcase, lcase_len + 1, fe, sizeof(zend_function), NULL) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failure importing %s()", fe->common.function_name); #ifdef ZEND_ENGINE_2 destroy_zend_function(fe TSRMLS_CC); #else destroy_end_function(fe); #endif efree(lcase); return FAILURE; } efree(lcase); } zend_hash_move_forward_ex(function_table, &pos); } return SUCCESS; }
/** * Applies a format to a message before sending it to the log * * @param string $message * @param int $type * @param int $timestamp * @param array $context * @return string */ PHP_METHOD(Phalcon_Logger_Formatter_Firephp, format) { zval *message, *type, *type_str = NULL, *timestamp, *context, *interpolated = NULL; zval *payload, *body, *backtrace = NULL, *meta, *encoded; zval *show_backtrace, *enable_labels; int i_show_backtrace, i_enable_labels; smart_str result = { NULL, 0, 0 }; uint i; Bucket *p; phalcon_fetch_params(0, 4, 0, &message, &type, ×tamp, &context); /* * We intentionally do not use Phalcon's MM for better performance. * All variables allocated with ALLOC_INIT_ZVAL() will have * their reference count set to 1 and therefore they can be nicely * put into the result array; when that array will be destroyed, * all inserted variables will be automatically destroyed, too * and we will just save some time by not using Z_ADDREF_P and Z_DELREF_P */ if (Z_TYPE_P(context) == IS_ARRAY) { PHALCON_CALL_METHODW(&interpolated, this_ptr, "interpolate", message, context); } else { interpolated = message; Z_ADDREF_P(interpolated); } { zval *params[] = { type }; if (FAILURE == phalcon_call_method(&type_str, this_ptr, "gettypestring", 1, params TSRMLS_CC)) { zval_ptr_dtor(&interpolated); return; } } show_backtrace = phalcon_fetch_nproperty_this(getThis(), SL("_showBacktrace"), PH_NOISY TSRMLS_CC); enable_labels = phalcon_fetch_nproperty_this(getThis(), SL("_enableLabels"), PH_NOISY TSRMLS_CC); i_show_backtrace = zend_is_true(show_backtrace); i_enable_labels = zend_is_true(enable_labels); /* * Get the backtrace. This differs for different PHP versions. * 5.3.6+ allows us to skip the function arguments which will save some memory * For 5.4+ there is an extra argument. */ if (i_show_backtrace) { ALLOC_INIT_ZVAL(backtrace); #if PHP_VERSION_ID < 50306 zend_fetch_debug_backtrace(backtrace, 1, 0 TSRMLS_CC); #elif PHP_VERSION_ID < 50400 zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS TSRMLS_CC); #else zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS, 0 TSRMLS_CC); #endif if (Z_TYPE_P(backtrace) == IS_ARRAY) { HashPosition pos; HashTable *ht = Z_ARRVAL_P(backtrace); zval **ppzval; int found = 0; ulong idx; char *key; uint key_len; /* * At this point we know that the backtrace is the array. * Again, we intentionally do not use Phalcon's API because we know * that we are working with the array / hash table and thus we can * save some time by omitting Z_TYPE_P(x) == IS_ARRAY checks */ for ( zend_hash_internal_pointer_reset_ex(ht, &pos); zend_hash_has_more_elements_ex(ht, &pos) == SUCCESS; ) { zend_hash_get_current_data_ex(ht, (void**)&ppzval, &pos); zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, &pos); zend_hash_move_forward_ex(ht, &pos); if (Z_TYPE_PP(ppzval) == IS_ARRAY) { /* * Here we need to skip the latest calls into Phalcon's core. * Calls to Zend internal functions will have "file" index not set. * We remove these entries from the array. */ if (!found && !zend_hash_quick_exists(Z_ARRVAL_PP(ppzval), SS("file"), zend_inline_hash_func(SS("file")))) { zend_hash_index_del(ht, idx); } else { /* * Remove args and object indices. They usually give * too much information; this is not suitable to send * in the HTTP headers */ zend_hash_quick_del(Z_ARRVAL_PP(ppzval), "args", sizeof("args"), zend_inline_hash_func(SS("args"))); zend_hash_quick_del(Z_ARRVAL_PP(ppzval), "object", sizeof("object"), zend_inline_hash_func(SS("object"))); found = 1; } } } /* * Now we need to renumber the hash table because we removed several * heading elements. If we don't do this, json_encode() will convert * this array to a JavaScript object which is an unwanted side effect */ p = ht->pListHead; i = 0; while (p != NULL) { p->nKeyLength = 0; p->h = i++; p = p->pListNext; } ht->nNextFreeElement = i; zend_hash_rehash(ht); } } /* * The result will looks like this: * * array( * array('Type' => 'message type', 'Label' => 'message'), * array('backtrace' => array(backtrace goes here) * ) */ MAKE_STD_ZVAL(payload); array_init_size(payload, 2); MAKE_STD_ZVAL(meta); array_init_size(meta, 4); add_assoc_zval_ex(meta, SS("Type"), type_str); if (i_show_backtrace && Z_TYPE_P(backtrace) == IS_ARRAY) { zval **ppzval; if (likely(SUCCESS == zend_hash_index_find(Z_ARRVAL_P(backtrace), 0, (void**)&ppzval)) && likely(Z_TYPE_PP(ppzval) == IS_ARRAY)) { zval **file = NULL, **line = NULL; zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("file"), zend_inline_hash_func(SS("file")), (void**)&file); zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("line"), zend_inline_hash_func(SS("line")), (void**)&line); if (likely(file != NULL)) { Z_ADDREF_PP(file); add_assoc_zval_ex(meta, SS("File"), *file); } if (likely(line != NULL)) { Z_ADDREF_PP(line); add_assoc_zval_ex(meta, SS("Line"), *line); } } } if (i_enable_labels) { add_assoc_zval_ex(meta, SS("Label"), interpolated); } if (!i_enable_labels && !i_show_backtrace) { body = interpolated; } else if (i_enable_labels && !i_show_backtrace) { MAKE_STD_ZVAL(body); ZVAL_EMPTY_STRING(body); } else { MAKE_STD_ZVAL(body); array_init_size(body, 2); if (i_show_backtrace) { add_assoc_zval_ex(body, SS("backtrace"), backtrace); } if (!i_enable_labels) { add_assoc_zval_ex(body, SS("message"), interpolated); } } add_next_index_zval(payload, meta); add_next_index_zval(payload, body); /* Convert everything to JSON */ ALLOC_INIT_ZVAL(encoded); if (FAILURE == phalcon_json_encode(encoded, payload, 0 TSRMLS_CC)) { zval_ptr_dtor(&payload); zval_ptr_dtor(&encoded); return; } /* As promised, kill the payload and all associated elements */ zval_ptr_dtor(&payload); /* * We don't want to use Phalcon's concatenation API because it * requires the memory manager. Therefore we fall back to using smart strings. * smart_str_alloc4() will allocate all required memory amount (plus some more) * in one go and this allows us to avoid performance penalties due to * memory reallocations. */ if (Z_TYPE_P(encoded) == IS_STRING && Z_STRVAL_P(encoded) != NULL) { smart_str_alloc4(&result, (uint)(Z_STRLEN_P(encoded) + 2 + 5), 0, i); /* * The format is: * * <size>|[meta,body]| * * Meta and body are contained in encoded inside the array, as required * by the protocol specification * @see http://www.firephp.org/Wiki/Reference/Protocol */ smart_str_append_long(&result, Z_STRLEN_P(encoded)); smart_str_appendc(&result, '|'); smart_str_appendl(&result, Z_STRVAL_P(encoded), Z_STRLEN_P(encoded)); smart_str_appendc(&result, '|'); smart_str_0(&result); } /* We don't need the JSON message anymore */ zval_ptr_dtor(&encoded); /* Do not free the smart string because we steal its data for zval */ RETURN_STRINGL(result.c, result.len, 0); }
PHP_COUCHBASE_LOCAL void php_couchbase_fetch_impl(INTERNAL_FUNCTION_PARAMETERS, int multi, int oo) /* {{{ */ { php_couchbase_res *couchbase_res; int argflags; if (oo) { argflags = PHP_COUCHBASE_ARG_F_OO; } else { argflags = PHP_COUCHBASE_ARG_F_FUNCTIONAL; } argflags |= PHP_COUCHBASE_ARG_F_ASYNC; PHP_COUCHBASE_GET_PARAMS(couchbase_res, argflags, ""); { php_couchbase_ctx *ctx; if (!couchbase_res->async) { RETURN_FALSE; } ctx = couchbase_res->async_ctx; if (couchbase_res->async == 2) { fetch_one: { char *key; uint key_len; ulong index = 0; zval **ppzval; zval *stash = (zval *)ctx->extended_value; if (zend_hash_num_elements(Z_ARRVAL_P(stash)) == 0) { couchbase_res->async = 0; zval_ptr_dtor(&stash); efree(ctx); couchbase_res->async_ctx = NULL; RETURN_NULL(); } zend_hash_internal_pointer_reset(Z_ARRVAL_P(stash)); zend_hash_get_current_data(Z_ARRVAL_P(stash), (void **)&ppzval); RETVAL_ZVAL(*ppzval, 1, 0); zend_hash_get_current_key_ex(Z_ARRVAL_P(stash), &key, &key_len, &index, 0, NULL); zend_hash_index_del(Z_ARRVAL_P(stash), index); return; } } array_init(return_value); ctx->rv = return_value; pcbc_start_loop(couchbase_res); if (!multi) { zval *stash; MAKE_STD_ZVAL(stash); ZVAL_ZVAL(stash, return_value, 1, 0); ctx->extended_value = (void *)stash; zval_dtor(return_value); couchbase_res->async = 2; goto fetch_one; } else { efree(ctx); couchbase_res->async = 0; couchbase_res->async_ctx = NULL; } } }
PHP_METHOD(air_mysql_waiter, step_0) { AIR_INIT_THIS; zval *services = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_services"), 0 TSRMLS_CC); zval *responses = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_responses"), 0 TSRMLS_CC); zval *context = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_context"), 0 TSRMLS_CC); zend_class_entry *mysqli_ce = air_get_ce(ZEND_STRL("mysqli") TSRMLS_CC); zval *async; MAKE_STD_ZVAL(async); ZVAL_LONG(async, MYSQLI_ASYNC); zval *wait_pool, *m2s; MAKE_STD_ZVAL(wait_pool); array_init(wait_pool); MAKE_STD_ZVAL(m2s); array_init(m2s); zval *service; ulong idx; uint _idx, key_len; char *key; zval *mysqli = NULL; HashTable *ah = Z_ARRVAL_P(services); for(zend_hash_internal_pointer_reset(ah); zend_hash_has_more_elements(ah) == SUCCESS;){ zval **___tmp; if (zend_hash_get_current_data(ah, (void**)&___tmp) == FAILURE) { continue; } if(zend_hash_get_current_key_ex(ah, &key, &key_len, &idx, 0, NULL) != HASH_KEY_IS_STRING) { key = NULL; key_len = 0; } service = *___tmp; if(Z_TYPE_P(service) == IS_NULL){ zend_hash_index_del(ah, idx); continue; } zval *service_id = zend_read_property(air_async_service_ce, service, ZEND_STRL("_id"), 1 TSRMLS_CC); zval *mysql = zend_read_property(air_async_service_ce, service, ZEND_STRL("_request"), 1 TSRMLS_CC); zval *status = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_status"), 0 TSRMLS_CC); if(Z_LVAL_P(status)){ //ignore if the mysql's been executed zend_hash_index_del(ah, idx); continue; } zval *mysql_config = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_config"), 1 TSRMLS_CC); zval *mode = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_mode"), 1 TSRMLS_CC); if(Z_TYPE_P(mode) == IS_NULL){ air_mysql_auto_mode(mysql TSRMLS_CC); mode = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_mode"), 1 TSRMLS_CC); } zval **acquire_params[2] = {&mysql_config, &mode}; mysqli = NULL; air_call_static_method(air_mysql_keeper_ce, "acquire", &mysqli, 2, acquire_params); if(Z_TYPE_P(mysqli) != IS_NULL){ zval **build_params[1] = {&mysqli}; zval *sql = NULL; air_call_method(&mysql, air_mysql_ce, NULL, ZEND_STRL("build"), &sql, 1, build_params TSRMLS_CC); if(sql){ zval **query_params[2] = {&sql, &async}; air_call_method(&mysqli, mysqli_ce, NULL, ZEND_STRL("query"), NULL, 2, query_params TSRMLS_CC); add_next_index_zval(wait_pool, mysqli); Z_ADDREF_P(service_id); add_index_zval(m2s, air_mysqli_get_id(mysqli TSRMLS_CC), service_id); zval_ptr_dtor(&sql); }else{ //should not happen php_error(E_ERROR, "sql not found"); zval_ptr_dtor(&mysqli); } }else{ zval_ptr_dtor(&mysqli); } zend_hash_move_forward(ah); } zval_ptr_dtor(&async); add_assoc_zval(context, "pool", wait_pool); add_assoc_zval(context, "m2s", m2s); add_assoc_long(context, "waited", zend_hash_num_elements(Z_ARRVAL_P(wait_pool))); add_assoc_long(context, "processed", 0); add_assoc_long(context, "step", 1); }
/** * Unsets long index from array */ int phalcon_array_unset_long(zval *arr, ulong index){ if (Z_TYPE_P(arr) != IS_ARRAY) { return 0; } return zend_hash_index_del(Z_ARRVAL_P(arr), index); }
/* {{{ mysqlnd_vio::open_tcp_or_unix */ static php_stream * MYSQLND_METHOD(mysqlnd_vio, open_tcp_or_unix)(MYSQLND_VIO * const vio, const MYSQLND_CSTRING scheme, const zend_bool persistent, MYSQLND_STATS * const conn_stats, MYSQLND_ERROR_INFO * const error_info) { #if PHP_API_VERSION < 20100412 unsigned int streams_options = ENFORCE_SAFE_MODE; #else unsigned int streams_options = 0; #endif unsigned int streams_flags = STREAM_XPORT_CLIENT | STREAM_XPORT_CONNECT; char * hashed_details = NULL; int hashed_details_len = 0; zend_string *errstr = NULL; int errcode = 0; struct timeval tv; dtor_func_t origin_dtor; php_stream * net_stream = NULL; DBG_ENTER("mysqlnd_vio::open_tcp_or_unix"); vio->data->stream = NULL; if (persistent) { hashed_details_len = mnd_sprintf(&hashed_details, 0, "%p", vio); DBG_INF_FMT("hashed_details=%s", hashed_details); } if (vio->data->options.timeout_connect) { tv.tv_sec = vio->data->options.timeout_connect; tv.tv_usec = 0; } DBG_INF_FMT("calling php_stream_xport_create"); net_stream = php_stream_xport_create(scheme.s, scheme.l, streams_options, streams_flags, hashed_details, (vio->data->options.timeout_connect) ? &tv : NULL, NULL /*ctx*/, &errstr, &errcode); if (errstr || !net_stream) { DBG_ERR("Error"); if (hashed_details) { mnd_sprintf_free(hashed_details); } errcode = CR_CONNECTION_ERROR; SET_CLIENT_ERROR(error_info, CR_CONNECTION_ERROR, UNKNOWN_SQLSTATE, errstr? ZSTR_VAL(errstr):"Unknown error while connecting"); if (errstr) { zend_string_release(errstr); } DBG_RETURN(NULL); } if (hashed_details) { /* If persistent, the streams register it in EG(persistent_list). This is unwanted. ext/mysql or ext/mysqli are responsible to clean, whatever they have to. */ zend_resource *le; if ((le = zend_hash_str_find_ptr(&EG(persistent_list), hashed_details, hashed_details_len))) { origin_dtor = EG(persistent_list).pDestructor; /* in_free will let streams code skip destructing - big HACK, but STREAMS suck big time regarding persistent streams. Just not compatible for extensions that need persistency. */ EG(persistent_list).pDestructor = NULL; zend_hash_str_del(&EG(persistent_list), hashed_details, hashed_details_len); EG(persistent_list).pDestructor = origin_dtor; pefree(le, 1); } #if ZEND_DEBUG /* Shut-up the streams, they don't know what they are doing */ net_stream->__exposed = 1; #endif mnd_sprintf_free(hashed_details); } /* Streams are not meant for C extensions! Thus we need a hack. Every connected stream will be registered as resource (in EG(regular_list). So far, so good. However, it won't be unregistered until the script ends. So, we need to take care of that. */ origin_dtor = EG(regular_list).pDestructor; EG(regular_list).pDestructor = NULL; zend_hash_index_del(&EG(regular_list), net_stream->res->handle); /* ToDO: should it be res->handle, do streams register with addref ?*/ efree(net_stream->res); net_stream->res = NULL; EG(regular_list).pDestructor = origin_dtor; DBG_RETURN(net_stream); }
void _php_task_free(gearman_task_st *task, void *context) { gearman_task_obj *task_obj= (gearman_task_obj *) context; gearman_client_obj *cli_obj = Z_GEARMAN_CLIENT_P(&task_obj->zclient); task_obj->flags &= ~GEARMAN_TASK_OBJ_CREATED; zend_hash_index_del(Z_ARRVAL(cli_obj->task_list), task_obj->task_id); }