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