/** {{{ public ZeActiveString::update($oldCondition, $newCondition)
*/
PHP_METHOD(ze_activestring, update) {
zval * self = NULL;
zval * actives = NULL;
char * old_cond = NULL;
int old_cond_len = 0;
char * new_cond = NULL;
int new_cond_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss"
, &old_cond, &old_cond_len
, &new_cond, &new_cond_len
) == FAILURE) {
WRONG_PARAM_COUNT;
}
self = getThis();
actives = zend_read_property(ze_activestring_ce, self, ZEND_STRL(ZE_ACTIVES), 0 TSRMLS_CC);
zend_hash_del(Z_ARRVAL_P(actives), old_cond, old_cond_len + 1);
add_assoc_bool(actives, new_cond, 1);
zend_update_property(ze_activestring_ce, self, ZEND_STRL(ZE_ACTIVES), actives TSRMLS_CC);
RETURN_ZVAL(self, 1, 0);
}
/* {{{ MongoCursor->explain
*/
PHP_METHOD(MongoCursor, explain) {
int temp_limit;
zval *explain, *yes, *temp = 0;
mongo_cursor *cursor = (mongo_cursor*)zend_object_store_get_object(getThis() TSRMLS_CC);
MONGO_CHECK_INITIALIZED(cursor->link, MongoCursor);
MONGO_METHOD(MongoCursor, reset, return_value, getThis());
// make explain use a hard limit
temp_limit = cursor->limit;
if (cursor->limit > 0) {
cursor->limit *= -1;
}
MAKE_STD_ZVAL(explain);
ZVAL_STRING(explain, "$explain", 1);
MAKE_STD_ZVAL(yes);
ZVAL_TRUE(yes);
MONGO_METHOD2(MongoCursor, addOption, return_value, getThis(), explain, yes);
zval_ptr_dtor(&explain);
zval_ptr_dtor(&yes);
MONGO_METHOD(MongoCursor, getNext, return_value, getThis());
// reset cursor to original state
cursor->limit = temp_limit;
zend_hash_del(HASH_P(cursor->query), "$explain", strlen("$explain")+1);
MAKE_STD_ZVAL(temp);
ZVAL_NULL(temp);
MONGO_METHOD(MongoCursor, reset, temp, getThis());
zval_ptr_dtor(&temp);
}
/**
* 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;
}
inline int sw_zend_hash_del(HashTable *ht, char *k, int len) {
zval key;
ZVAL_STRING(&key, k);
return zend_hash_del(ht, Z_STR(key));
}
/**
* @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;
}
}
PDO_API void php_pdo_unregister_driver(pdo_driver_t *driver)
{
if (!zend_hash_exists(&module_registry, "pdo", sizeof("pdo"))) {
return;
}
zend_hash_del(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len);
}
static int php_pdo_connect_pool_close(cpClient *cli) {
char str[100] = {0};
CON_FORMART_KEY(str, cli->port);
if (zend_hash_del(&EG(persistent_list), str, strlen(str)) == FAILURE) {//很奇怪 用不了宏定义
zend_error(E_WARNING, "del hash error!");
return FAILURE;
}
return SUCCESS;
}
ZEND_API int zend_ts_hash_del(TsHashTable *ht, zend_string *key)
{
int retval;
begin_write(ht);
retval = zend_hash_del(TS_HASH(ht), key);
end_write(ht);
return retval;
}
PHP_COUCHBASE_LOCAL
void pcbc_ht_del(zval *assoc, const char *key, unsigned int key_len)
{
pcbc_ht_key hk = { NULL };
ISARRAY_SANITY(assoc);
pcbc_ht_key_create(key, key_len, &hk);
zend_hash_del(Z_ARRVAL_P(assoc), hk.key, hk.key_len + 1);
pcbc_ht_key_cleanup(&hk);
}
/** {{{ int yaf_response_clear_header(yaf_response_t *response, char *name, uint name_len TSRMLS_DC)
*/
int yaf_response_clear_header(yaf_response_t *response, char *name, uint name_len TSRMLS_DC) {
zval *zheader;
zheader = zend_read_property(yaf_response_ce, response, ZEND_STRL(YAF_RESPONSE_PROPERTY_NAME_HEADER), 1 TSRMLS_CC);
if (name_len) {
zend_hash_del(Z_ARRVAL_P(zheader), name, name_len + 1);
} else {
zend_hash_clean(Z_ARRVAL_P(zheader));
}
return 1;
}
/* {{{ uninstall_class */
static int uninstall_class(apc_class_t cl TSRMLS_DC)
{
int status;
status = zend_hash_del(EG(class_table),
cl.name,
cl.name_len+1);
if (status == FAILURE) {
apc_error("Cannot delete class %s" TSRMLS_CC, cl.name);
}
return status;
}
void php_mongo_io_stream_forget(mongo_con_manager *manager, mongo_connection *con)
{
zend_rsrc_list_entry *le;
TSRMLS_FETCH();
/* When we fork we need to unregister the parents hash so we don't accidentally destroy it */
if (zend_hash_find(&EG(persistent_list), con->hash, strlen(con->hash) + 1, (void*) &le) == SUCCESS) {
((php_stream *)con->socket)->in_free = 1;
zend_hash_del(&EG(persistent_list), con->hash, strlen(con->hash) + 1);
((php_stream *)con->socket)->in_free = 0;
}
}
/**
* @brief Unsets string @a index from array @a arr
* @param[in,out] arr Array
* @param index Index
* @param index_length strlen(index)+1
* @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_string(zval **arr, const char *index, uint index_length, 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_del(Z_ARRVAL_PP(arr), index, index_length);
}
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));
}
}
}
void uopz_unset_mock(zend_string *clazz) { /* {{{ */
zend_string *key = zend_string_tolower(clazz);
if (!zend_hash_exists(&UOPZ(mocks), key)) {
uopz_exception(
"the class provided (%s) has no mock set",
ZSTR_VAL(clazz));
zend_string_release(key);
return;
}
zend_hash_del(&UOPZ(mocks), key);
zend_string_release(key);
} /* }}} */
/**
* 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 string index from array
*/
int PHALCON_FASTCALL phalcon_array_unset_string(zval **arr, char *index, uint index_length, 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_del(Z_ARRVAL_PP(arr), index, index_length);
}
static void oauth_provider_apply_custom_param(HashTable *ht, HashTable *custom) /* {{{ */
{
HashPosition custompos;
zval *entry;
zend_string *key;
ulong num_key;
zend_hash_internal_pointer_reset_ex(custom, &custompos);
do {
if ((entry = zend_hash_get_current_data_ex(custom, &custompos)) != NULL && HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(custom, &key, &num_key, &custompos)) {
if (IS_NULL == Z_TYPE_P(entry)) {
zend_hash_del(ht, key);
} else {
Z_ADDREF_P(entry);
zend_hash_update(ht, key, entry);
}
}
} while (SUCCESS==zend_hash_move_forward_ex(custom, &custompos));
}
/* {{{ php_tmpl_set */
int php_tmpl_set(t_template* tmpl, zval* path, zval** data) {
zval **iteration, *cp_data, **ztag;
t_tmpl_tag *tag;
char *p;
if(FAILURE == zend_hash_find(Z_ARRVAL_P(tmpl->tags), ZV(path), ZL(path)+1, (void*)&ztag)) {
/* php_error(E_NOTICE, "Can't set value for tag/context \"%s\" which doesn't exist", ZV(path)); */
return FAILURE;
}
tag = Z_TMPL_TAG(ztag);
if(TMPL_TAG == tag->typ) {
if((iteration = (zval**)php_tmpl_get_iteration(tmpl, path, TMPL_ITERATION_CURRENT)) == NULL) {
return FAILURE;
}
} else {
for(p = ZV(path)+ZL(path); p >= ZV(path) && *p != '/'; p--);
*(p > ZV(path) ? p++ : ++p) = 0;
ZL(path) = strlen(ZV(path));
if((iteration = (zval**)php_tmpl_get_iteration(tmpl, path, TMPL_ITERATION_CURRENT)) == NULL) {
return FAILURE;
}
}
convert_to_string_ex(data);
MAKE_STD_ZVAL(cp_data);
ZVAL_STRINGL(cp_data, Z_STRVAL_PP(data), Z_STRLEN_PP(data), 1);
if(SUCCESS == zend_hash_find(Z_ARRVAL_PP(iteration), ZV(tag->name), ZL(tag->name)+1, (void*)&ztag)) {
if(IS_ARRAY == Z_TYPE_PP(ztag)) {
/* MEMORY LEAK CAUSED BY THE NEXT LINE !!! */
zend_hash_del(Z_ARRVAL_PP(iteration), ZV(tag->name), ZL(tag->name)+1);
} else {
tmpl->size -= (Z_STRLEN_PP(ztag) * tag->tag_num);
}
}
zend_hash_update(Z_ARRVAL_PP(iteration), ZV(tag->name), ZL(tag->name)+1, (void*)&cp_data, sizeof(zval**), NULL);
tmpl->size += (ZL(cp_data) * tag->tag_num);
return SUCCESS;
}
PHP_METHOD(jz_data, offsetUnset) {
zval *readonly = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME_READONLY), 1, NULL);
if (Z_TYPE_P(readonly) == IS_FALSE) {
zval *props;
zend_string *name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
return;
}
props = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME), 1, NULL);
if (UNEXPECTED(Z_TYPE_P(props) != IS_ARRAY)) {
RETURN_FALSE;
}
if (zend_hash_del(Z_ARRVAL_P(props), name) == SUCCESS) {
RETURN_TRUE;
}
}
RETURN_FALSE;
}
static int oauth_provider_remove_required_param(HashTable *ht, char *required_param) /* {{{ */
{
zval *dest_entry;
zend_string *key;
ulong num_key;
HashPosition hpos;
if((dest_entry = zend_hash_str_find(ht, required_param, strlen(required_param))) == NULL) {
return FAILURE;
} else {
zend_hash_internal_pointer_reset_ex(ht, &hpos);
do {
if(zend_hash_get_current_key_ex(ht, &key, &num_key, &hpos)!=FAILURE) {
if(!strcmp(ZSTR_VAL(key), required_param)) {
zend_hash_del(ht, key);
return SUCCESS;
}
}
} while(zend_hash_move_forward_ex(ht, &hpos)==SUCCESS);
}
return FAILURE;
}
/** {{{ public ZeActiveString::cancel($condition)
*/
PHP_METHOD(ze_activestring, cancel) {
zval * self = NULL;
zval * actives = NULL;
char * cond = NULL;
int cond_len = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s"
, &cond, &cond_len
) == FAILURE) {
WRONG_PARAM_COUNT;
}
self = getThis();
actives = zend_read_property(ze_activestring_ce, self, ZEND_STRL(ZE_ACTIVES), 0 TSRMLS_CC);
zend_hash_del(Z_ARRVAL_P(actives), cond, cond_len + 1);
zend_update_property(ze_activestring_ce, self, ZEND_STRL(ZE_ACTIVES), actives TSRMLS_CC);
RETURN_ZVAL(self, 1, 0);
}
/** {{{ proto public Yaf_Config_Simple::offsetUnset($index)
*/
PHP_METHOD(yaf_config_simple, offsetUnset) {
zval *readonly = zend_read_property(yaf_config_simple_ce,
getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME_READONLY), 1, NULL);
if (Z_TYPE_P(readonly) == IS_FALSE) {
zval *props;
zend_string *name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) {
return;
}
props = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL);
if (UNEXPECTED(Z_TYPE_P(props) != IS_ARRAY)) {
RETURN_FALSE;
}
if (zend_hash_del(Z_ARRVAL_P(props), name) == SUCCESS) {
RETURN_TRUE;
}
}
RETURN_FALSE;
}
/**
* 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 int solr_document_remove_field(zval *objptr, solr_char_t *field_name, int field_name_length TSRMLS_DC) */
static int solr_document_remove_field(zval *objptr, solr_char_t *field_name, int field_name_length TSRMLS_DC)
{
solr_document_t *doc_entry = NULL;
if (!field_name_length) {
return FAILURE;
}
/* Retrieve the document entry for the SolrDocument instance */
if (solr_fetch_document_entry(objptr, &doc_entry TSRMLS_CC) == SUCCESS) {
if (zend_hash_del(doc_entry->fields, field_name, field_name_length) == SUCCESS) {
doc_entry->field_count--;
return SUCCESS;
}
return FAILURE;
}
return FAILURE;
}
/* {{{ 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;
}
PHPAPI int php_unregister_info_logo(char *logo_string)
{
return zend_hash_del(&phpinfo_logo_hash, logo_string, strlen(logo_string));
}
static void php_swoole_aio_onComplete(swAio_event *event)
{
int isEOF = SW_FALSE;
int64_t ret;
zval *retval = NULL, *zcallback = NULL, *zwriten = NULL;
zval *zcontent = NULL;
zval **args[2];
file_request *file_req = NULL;
dns_request *dns_req = NULL;
TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);
if (event->type == SW_AIO_DNS_LOOKUP)
{
dns_req = (dns_request *) event->req;
if (dns_req->callback == NULL)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: onAsyncComplete callback not found[2]");
return;
}
zcallback = dns_req->callback;
}
else
{
if (zend_hash_find(&php_sw_aio_callback, (char *)&(event->fd), sizeof(event->fd), (void**) &file_req) != SUCCESS)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: onAsyncComplete callback not found[1]");
return;
}
if (file_req->callback == NULL && file_req->type == SW_AIO_READ)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: onAsyncComplete callback not found[2]");
return;
}
zcallback = file_req->callback;
}
ret = event->ret;
if (ret < 0)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: Aio Error: %s[%d]", strerror(event->error), event->error);
}
else if (file_req != NULL)
{
if (ret == 0)
{
bzero(event->buf, event->nbytes);
isEOF = SW_TRUE;
}
else if (file_req->once == 1 && ret < file_req->content_length)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: ret_length[%d] < req->length[%d].", (int) ret, file_req->content_length);
}
else if (event->type == SW_AIO_READ)
{
file_req->offset += event->ret;
}
}
if (event->type == SW_AIO_READ)
{
MAKE_STD_ZVAL(zcontent);
args[0] = &file_req->filename;
args[1] = &zcontent;
ZVAL_STRINGL(zcontent, event->buf, ret, 0);
}
else if (event->type == SW_AIO_WRITE)
{
MAKE_STD_ZVAL(zwriten);
args[0] = &file_req->filename;
args[1] = &zwriten;
ZVAL_LONG(zwriten, ret);
if (file_req->once != 1)
{
if (SwooleAIO.mode == SW_AIO_LINUX)
{
free(event->buf);
}
else
{
efree(event->buf);
}
}
}
else if(event->type == SW_AIO_DNS_LOOKUP)
{
MAKE_STD_ZVAL(zcontent);
args[0] = &dns_req->domain;
if (ret < 0)
{
ZVAL_STRING(zcontent, "", 0);
}
else
{
ZVAL_STRING(zcontent, event->buf, 0);
}
args[1] = &zcontent;
}
else
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: onAsyncComplete unknow event type");
return;
}
if (zcallback)
{
if (call_user_function_ex(EG(function_table), NULL, zcallback, &retval, 2, args, 0, NULL TSRMLS_CC) == FAILURE)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: onAsyncComplete handler error");
return;
}
}
//readfile/writefile
if (file_req != NULL)
{
//只操作一次,完成后释放缓存区并关闭文件
if (file_req->once == 1)
{
close_file:
zval_ptr_dtor(&file_req->callback);
zval_ptr_dtor(&file_req->filename);
if (SwooleAIO.mode == SW_AIO_LINUX)
{
free(event->buf);
}
else
{
efree(event->buf);
}
close(event->fd);
//remove from hashtable
zend_hash_del(&php_sw_aio_callback, (char *)&(event->fd), sizeof(event->fd));
}
else if(file_req->type == SW_AIO_WRITE)
{
if (retval != NULL && !Z_BVAL_P(retval))
{
swHashMap_del(php_swoole_open_files, Z_STRVAL_P(file_req->filename), Z_STRLEN_P(file_req->filename));
goto close_file;
}
}
else
{
if (!Z_BVAL_P(retval) || isEOF)
{
goto close_file;
}
else if (SwooleAIO.read(event->fd, event->buf, event->nbytes, file_req->offset) < 0)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: continue to read failed. Error: %s[%d]", strerror(event->error), event->error);
}
}
}
else if (dns_req != NULL)
{
zval_ptr_dtor(&dns_req->callback);
zval_ptr_dtor(&dns_req->domain);
efree(dns_req);
efree(event->buf);
}
if (zcontent != NULL)
{
efree(zcontent);
}
if (zwriten != NULL)
{
zval_ptr_dtor(&zwriten);
}
if (retval != NULL)
{
zval_ptr_dtor(&retval);
}
if (SwooleWG.in_client && SwooleG.main_reactor->event_num == 1 && SwooleAIO.task_num == 1)
{
SwooleG.running = 0;
}
}
/* {{{ 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;
}
/* Must prevent duplicates ... if there are duplicates, replace new by old! */
static void phpdbg_add_watch_collision(phpdbg_watchpoint_t *watch) {
phpdbg_watch_collision *cur;
/* Check for either recursive or (simple and/or implicit) */
ZEND_ASSERT(((watch->flags & PHPDBG_WATCH_RECURSIVE) == 0) ^ ((watch->flags & (PHPDBG_WATCH_IMPLICIT | PHPDBG_WATCH_SIMPLE)) == 0));
if ((cur = zend_hash_index_find_ptr(&PHPDBG_G(watch_collisions), (zend_ulong) watch->addr.ref))) {
phpdbg_watchpoint_t *old;
int flags = 0;
if ((old = zend_hash_find_ptr(&cur->watches, watch->str)) || (old = zend_hash_find_ptr(&cur->implicit_watches, watch->str))) {
if (((old->flags ^ watch->flags) & (PHPDBG_WATCH_NORMAL|PHPDBG_WATCH_IMPLICIT)) == 0) {
return; /* there was no change ... */
}
flags = old->flags;
if (flags & PHPDBG_WATCH_RECURSIVE) {
if (!(watch->flags & PHPDBG_WATCH_RECURSIVE) && !--cur->refs) {
phpdbg_delete_watchpoints_recursive(watch);
}
}
if (flags & PHPDBG_WATCH_NORMAL) {
zend_hash_del(&cur->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 {
cur->watch = Z_PTR_P(zend_hash_get_current_data_ex(&cur->implicit_watches, NULL));
}
}
if (flags & PHPDBG_WATCH_IMPLICIT) {
zend_hash_del(&cur->implicit_watches, watch->str);
}
old->flags = watch->flags;
phpdbg_free_watch(watch);
efree(watch);
watch = old;
}
if (watch->flags & PHPDBG_WATCH_RECURSIVE) {
if (!(flags & PHPDBG_WATCH_RECURSIVE) && !cur->refs++) {
phpdbg_create_recursive_zval_watch(watch->parent);
}
}
} else {
phpdbg_watch_collision coll;
coll.refs = (watch->flags & PHPDBG_WATCH_RECURSIVE) != 0;
coll.watch = watch;
zend_hash_init(&coll.watches, 8, arghs, NULL, 0);
zend_hash_init(&coll.implicit_watches, 8, ..., NULL, 0);
cur = zend_hash_index_add_mem(&PHPDBG_G(watch_collisions), (zend_ulong) watch->addr.ref, &coll, sizeof(phpdbg_watch_collision));
phpdbg_store_watchpoint(cur->watch);
phpdbg_activate_watchpoint(cur->watch);
if (coll.refs) {
phpdbg_create_recursive_zval_watch(watch->parent);
}
}
if (watch->flags & PHPDBG_WATCH_NORMAL) {
cur->watch = watch;
zend_hash_add_ptr(&cur->watches, watch->str, watch->parent);
}
if (watch->flags & PHPDBG_WATCH_IMPLICIT) {
zend_hash_add_ptr(&cur->implicit_watches, watch->str, watch->parent);
}
}