//迭代函数
void php_alinq_iterator_key(HashTable *arrht)
{
for(zend_hash_internal_pointer_reset(arrht);
zend_hash_has_more_elements(arrht) == SUCCESS;
zend_hash_move_forward(arrht))
{
if(zend_hash_has_more_elements(arrht) == SUCCESS){
php_printf("aaaa");
}else{
php_printf("bbbb");
}
}
}
PHP_COUCHBASE_LOCAL
int pcbc_ht_iter_remaining(zval *assoc)
{
ISARRAY_SANITY(assoc);
return ((zend_hash_has_more_elements(Z_ARRVAL_P(assoc)) == SUCCESS)
? 1 : 0);
}
zval* air_arr_del_index_el(zval *arr) {
HashTable *ht = Z_ARRVAL_P(arr);
zval *tmp;
MAKE_STD_ZVAL(tmp);
array_init(tmp);
for(
zend_hash_internal_pointer_reset(ht);
zend_hash_has_more_elements(ht) == SUCCESS;
zend_hash_move_forward(ht)
){
int type;
ulong idx;
char *key;
uint key_len;
zval **tmp_data;
type = zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, NULL);
if(type == HASH_KEY_IS_STRING){
if(zend_hash_get_current_data(ht, (void**)&tmp_data) != FAILURE) {
add_assoc_stringl_ex(tmp, key, key_len, Z_STRVAL_PP(tmp_data), Z_STRLEN_PP(tmp_data), 1);
}
}
}
return tmp;
}
/**
* @brief bool Phalcon\Registry::valid()
*/
PHP_METHOD(Phalcon_Registry, valid){
zval *data;
data = phalcon_read_property(getThis(), SL("_data"), PH_NOISY);
RETURN_BOOL(zend_hash_has_more_elements(Z_ARRVAL_P(data)));
}
/* {{{ proto int symbol.setpoints(array points)
Set the points of the symbol ) */
PHP_METHOD(symbolObj, setPoints)
{
zval *zpoints, **ppzval;
HashTable *points_hash = NULL;
zval *zobj = getThis();
int index = 0, flag = 0, numelements = 0;
php_symbol_object *php_symbol;
PHP_MAPSCRIPT_ERROR_HANDLING(TRUE);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a",
&zpoints) == FAILURE) {
PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);
return;
}
PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);
php_symbol = (php_symbol_object *) zend_object_store_get_object(zobj TSRMLS_CC);
points_hash = Z_ARRVAL_P(zpoints);
numelements = zend_hash_num_elements(points_hash);
if ((numelements == 0) || (numelements % 2 != 0))
{
mapscript_report_php_error(E_WARNING,
"symbol->setpoints : invalid array of %d element(s) as parameter." TSRMLS_CC, numelements);
RETURN_LONG(MS_FAILURE);
}
for(zend_hash_internal_pointer_reset(points_hash);
zend_hash_has_more_elements(points_hash) == SUCCESS;
zend_hash_move_forward(points_hash))
{
zend_hash_get_current_data(points_hash, (void **)&ppzval);
if (Z_TYPE_PP(ppzval) != IS_DOUBLE)
convert_to_double(*ppzval);
if (!flag)
{
php_symbol->symbol->points[index].x = Z_DVAL_PP(ppzval);
php_symbol->symbol->sizex = MS_MAX(php_symbol->symbol->sizex, php_symbol->symbol->points[index].x);
}
else
{
php_symbol->symbol->points[index].y = Z_DVAL_PP(ppzval);
php_symbol->symbol->sizey = MS_MAX(php_symbol->symbol->sizey, php_symbol->symbol->points[index].y);
index++;
}
flag = !flag;
}
php_symbol->symbol->numpoints = (numelements/2);
RETURN_LONG(MS_SUCCESS);
}
/**
* Convert a php Array to a map
*
* @param t the php Array to convert
* @return the created map
*/
map* php_map_from_HasTable(HashTable* t){
#ifdef DEBUG
fprintf(stderr,"mapsFromPHPArray start\n");
#endif
map* final_res=(map*)malloc(MAP_SIZE);
final_res=NULL;
char key[1024];
for(zend_hash_internal_pointer_reset(t);
zend_hash_has_more_elements(t) == SUCCESS;
zend_hash_move_forward(t)) {
char *key;
uint keylen;
ulong idx;
int type;
int len;
zval **ppzval, tmpcopy;
type = zend_hash_get_current_key_ex(t, &key, &keylen, &idx, 0, NULL);
if (zend_hash_get_current_data(t, (void**)&ppzval) == FAILURE) {
/* Should never actually fail * since the key is known to exist. */
continue;
}
/**
* Duplicate the zval so that * the orignal’s contents are not destroyed
*/
tmpcopy = **ppzval;
zval_copy_ctor(&tmpcopy);
/**
* Reset refcount & Convert
*/
INIT_PZVAL(&tmpcopy);
convert_to_string(&tmpcopy);
if(strncmp(key,"value",5)==0){
len=Z_STRLEN_P(&tmpcopy);
final_res = addToMapWithSize(final_res,key,Z_STRVAL_P(&tmpcopy),len);
}
else{
if(final_res==NULL){
#ifdef DEBUG
fprintf(stderr,"%s => %s\n",key,Z_STRVAL(tmpcopy));
#endif
final_res=createMap(key,Z_STRVAL(tmpcopy));
}
else{
#ifdef DEBUG
fprintf(stderr,"%s => %s\n",key,Z_STRVAL(tmpcopy));
#endif
addToMap(final_res,key,Z_STRVAL(tmpcopy));
}
}
/* Toss out old copy */
zval_dtor(&tmpcopy);
}
return final_res;
}
PHP_METHOD(Rows, valid)
{
cassandra_rows* self = NULL;
if (zend_parse_parameters_none() == FAILURE)
return;
self = (cassandra_rows*) zend_object_store_get_object(getThis() TSRMLS_CC);
RETURN_BOOL(zend_hash_has_more_elements(Z_ARRVAL_P(self->rows)) == SUCCESS);
}
void skyray_http_request_resolve_cookies_if_needed(skyray_http_request_t *self)
{
if (!ZVAL_IS_NULL(&self->cookie_params)) {
return;
}
zval *lines = skyray_http_message_get_header(&self->message, intern_str_cookie, 0);
if (!lines) {
return;
}
array_init(&self->cookie_params);
zend_array *ht = Z_ARR_P(lines);
zend_array *ht2;
zval tmp, *data;;
zend_hash_internal_pointer_reset(ht);
while(zend_hash_has_more_elements(ht) == SUCCESS) {
array_init(&tmp);
data = zend_hash_get_current_data(ht);
php_explode(intern_str_param_delimiter, Z_STR_P(data), &tmp, ZEND_LONG_MAX);
ht2 = Z_ARR_P(&tmp);
zend_hash_internal_pointer_reset(ht2);
while (zend_hash_has_more_elements(ht2) == SUCCESS) {
data = zend_hash_get_current_data(ht2);
char *c = strchr(Z_STR_P(data)->val, '=');
int len = c - Z_STR_P(data)->val;
add_assoc_str_ex(&self->cookie_params, Z_STR_P(data)->val, len, zend_string_init(c + 1, Z_STR_P(data)->len - len - 1, 0));
zend_hash_move_forward(ht2);
}
zval_ptr_dtor(&tmp);
zend_hash_move_forward(ht);
}
}
static PHP_METHOD(php_midgard_reflection_class, getMethods)
{
zval *filter = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &filter) == FAILURE)
return;
zval *this = getThis();
zval *class_name = NULL;
zend_call_method_with_0_params(&this, zend_reflection_class_class, NULL, "getname", &class_name);
zval *result = NULL;
if (filter) {
zend_call_method_with_1_params(&this, zend_reflection_class_class, NULL, "getmethods", &result, filter);
} else {
zend_call_method_with_0_params(&this, zend_reflection_class_class, NULL, "getmethods", &result);
}
array_init(return_value);
HashTable *parent_ht = Z_ARRVAL_P(result);
for(
zend_hash_internal_pointer_reset(parent_ht);
zend_hash_has_more_elements(parent_ht) == SUCCESS;
zend_hash_move_forward(parent_ht)
) {
zval **ppzval = NULL;
zend_hash_get_current_data(parent_ht, (void**)&ppzval);
zval *method_name = NULL;
zend_call_method_with_0_params(ppzval, zend_reflection_function_class, NULL, "getname", &method_name);
zval *new_obj = NULL;
MAKE_STD_ZVAL(new_obj);
object_init_ex(new_obj, php_midgard_reflection_method_class);
zend_call_method_with_2_params(&new_obj,
php_midgard_reflection_method_class,
&php_midgard_reflection_method_class->constructor, "__construct",
NULL, class_name, method_name
);
zval_ptr_dtor(&method_name);
add_next_index_zval(return_value, new_obj);
}
zval_ptr_dtor(&result);
zval_ptr_dtor(&class_name);
}
char *owsrequest_getenv(const char *name, void *thread_context)
{
zval **val, **ppzval;
zval *cookie_result, *key;
HashTable *cookies;
char *string_key = NULL, *cookie_tmp;
ulong num_key;
int numElements, i = 0;
TSRMLS_FETCH_FROM_CTX(thread_context);
if (STRING_EQUAL(name, "HTTP_COOKIE"))
{
cookies = PG(http_globals)[TRACK_VARS_COOKIE]->value.ht;
numElements = zend_hash_num_elements(cookies);
MAKE_STD_ZVAL(cookie_result);
ZVAL_STRING(cookie_result, "",1);
for(zend_hash_internal_pointer_reset(cookies);
zend_hash_has_more_elements(cookies) == SUCCESS;
zend_hash_move_forward(cookies), ++i)
{
zend_hash_get_current_data(cookies, (void **)&ppzval);
zend_hash_get_current_key(cookies, &string_key, &num_key, 1);
cookie_tmp = malloc((strlen(string_key)+Z_STRLEN_PP(ppzval)+3) * sizeof(char));
sprintf(cookie_tmp, "%s=%s;",string_key,Z_STRVAL_PP(ppzval));
MAKE_STD_ZVAL(key);
ZVAL_STRING(key, cookie_tmp,1);
add_string_to_string(cookie_result,cookie_result, key);
zval_dtor(key);
free(cookie_tmp);
}
return Z_STRVAL_P(cookie_result);
}
else
{
zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
if ( PG(http_globals)[TRACK_VARS_SERVER] &&
(zend_hash_find(PG(http_globals)[TRACK_VARS_SERVER]->value.ht, name, strlen(name)+1, (void **) &val) == SUCCESS) &&
(Z_TYPE_PP(val) == IS_STRING))
{
return Z_STRVAL_PP(val);
}
}
return NULL;
}
void yee_behavior_attach(zval *self, zval *owner) {
zend_class_entry *ce = Z_OBJCE_P(self);
zval *events = NULL, **handler_ptr;
char *event;
int event_size;
zend_update_property(ce, self, ZEND_STRL("owner"), owner);
zend_call_method(&self, ce, NULL, ZEND_STRL("events"), &events, 0, NULL, NULL);
if (events && Z_TYPE_P(events) == IS_ARRAY) {
HashTable *ht = Z_ARRVAL_P(events);
zend_hash_internal_pointer_reset(ht);
while(zend_hash_has_more_elements(ht) == SUCCESS) {
zend_hash_get_current_key_ex(ht, &event, &event_size, NULL, 0, NULL);
zend_hash_get_current_data(ht, (void **)&handler_ptr);
zval *zv_event, *zv_handler;
MAKE_STD_ZVAL(zv_event);
ZVAL_STRINGL(zv_event, event, event_size - 1, 0);
if (Z_TYPE_PP(handler_ptr) == IS_STRING) {
MAKE_STD_ZVAL(zv_handler);
array_init(zv_handler);
add_next_index_zval(zv_handler, self);
add_next_index_zval(zv_handler, *handler_ptr);
zval_addref_p(self);
}else {
zv_handler = *handler_ptr;
}
zend_call_method(&owner, Z_OBJCE_P(owner), NULL, ZEND_STRL("on"), NULL, 2, zv_event, zv_handler);
efree(zv_event);
if (zv_handler != *handler_ptr) {
zval_ptr_dtor(&zv_handler);
}
zend_hash_move_forward(ht);
}
}
zval_ptr_dtor(&events);
}
static PHP_FUNCTION(params_array) {
HashTable *options = NULL;
zval *v;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &v) == FAILURE) {
RETURN_FALSE;
}
options = Z_ARRVAL_P(v);//读取array类型的值
//zend_hash_internal_pointer_reset
//zend_hash_has_more_elements 判断HashTable是否有元素
//zend_hash_move_forward 移动HashTable到顶端
//zend_hash_get_current_key_ex 读取HashTable当前的key，HashTable的key有两种，一种是指定字符串，另一种是顺序的0-n下标
//zend_hash_get_current_data 读取HashTable当前的值到zval
//zend_hash_get_current_key_type 获取当前key的类型
for(zend_hash_internal_pointer_reset(options); SUCCESS == zend_hash_has_more_elements(options); zend_hash_move_forward(options)) {
char *k1;
ulong nkey = -1, keylen;
zval **z;
zend_hash_get_current_key_ex(options, &k1, &keylen, &nkey, 0, NULL);
zend_hash_get_current_data(options, (void **)&z);
php_printf(" key: ");
if (HASH_KEY_IS_STRING == zend_hash_get_current_key_type(options)) {
PHPWRITE(k1, keylen);
}else{
php_printf("%ld", nkey);
}
php_printf(" value: ");
if (Z_TYPE_P(*z) == IS_STRING) {
//php_printf("string(%d)\n", Z_STRLEN_P(*z));
PHPWRITE(Z_STRVAL_P(*z), Z_STRLEN_P(*z));
}else{
zend_print_zval_r((*z), 0 TSRMLS_CC);
}
php_printf("\n");
}
RETURN_TRUE;
}
static void call_resolved_handlers(skyray_promise_t *self, zend_array *on_fulfilled, zend_array *on_rejected)
{
skyray_promise_t *promise = skyray_promise_from_obj(Z_OBJ_P(&self->result));
zend_array *handlers;
if (instanceof_function(Z_OBJCE_P(&self->result), skyray_ce_FulfilledPromise)) {
handlers = on_fulfilled;
} else {
handlers = on_rejected;
}
zend_hash_internal_pointer_reset(handlers);
while(zend_hash_has_more_elements(handlers) == SUCCESS) {
promise_resolve_context_t *context = zend_hash_get_current_data_ptr(handlers);
promise_resolve_context_call(context, &promise->result);
zend_hash_move_forward(handlers);
}
zend_hash_destroy(&self->on_fulfilled);
zend_hash_destroy(&self->on_rejcted);
}
static int yac_add_multi_impl(char *prefix, uint prefix_len, zval *kvs, int ttl, int add TSRMLS_DC) /* {{{ */ {
HashTable *ht = Z_ARRVAL_P(kvs);
for (zend_hash_internal_pointer_reset(ht);
zend_hash_has_more_elements(ht) == SUCCESS;
zend_hash_move_forward(ht)) {
char *key;
ulong idx;
zval **value;
uint len, should_free = 0;
if (zend_hash_get_current_data(ht, (void **)&value) == FAILURE) {
continue;
}
switch (zend_hash_get_current_key_ex(ht, &key, &len, &idx, 0, NULL)) {
case HASH_KEY_IS_LONG:
len = spprintf(&key, 0, "%lu", idx) + 1;
should_free = 1;
case HASH_KEY_IS_STRING:
if (yac_add_impl(prefix, prefix_len, key, len - 1, *value, ttl, add TSRMLS_CC)) {
if (should_free) {
efree(key);
}
continue;
} else {
if (should_free) {
efree(key);
}
return 0;
}
default:
continue;
}
}
return 1;
}
static int yac_add_multi_impl(char *prefix, uint prefix_len, zval *kvs, int ttl, int add tsrmls_dc) {
HashTable *ht = z_arrval_p(kvs);
for (zend_hash_internal_pointer_reset(ht);
zend_hash_has_more_elements(ht) == success;
zend_hash_move_forward(ht)) {
char *key;
ulong idx;
zval **value;
uint len, should_free = 0;
if (zend_hash_get_current_data(ht, (void **)&value) == FAILURE) {
continue;
}
switch (zend_hash_get_current_key_ex(ht, &key, &len, &idx, 0, null)) {
case hash_key_is_long:
len = spprintf(&key, 0, "%lu", idx) + 1;
should_free = 1;
case hash_key_is_string:
if (yac_add_impl(prefix, prefix_len, key, len - 1, *value, ttl, add tsrmls_cc)) {
if (should_free) {
efree(key);
}
continue;
} else {
if (should_free) {
efree(key);
}
return 0;
}
default:
continue;
}
}
return 1;
}
void cpServer_init(zval *conf, char *ini_file)
{
size_t group_num = 0;
cpShareMemory shm = {0};
shm.size = sizeof (cpServerGS);
strncpy(shm.mmap_name, CP_SERVER_MMAP_FILE, strlen(CP_SERVER_MMAP_FILE));
if (cp_create_mmap_file(&shm) == 0)
{
CPGS = (cpServerGS*) cp_mmap_calloc_with_file(&shm);
cpKillClient();
bzero(CPGS, shm.size);
if (CPGS == NULL)
{
php_printf("calloc[1] fail\n");
return;
}
}
else
{
php_printf("calloc[1] fail\n");
return;
}
bzero(&CPGL, sizeof (cpServerG));
CPGC.backlog = CP_BACKLOG;
// CPGC.reactor_num = CP_CPU_NUM;
CPGC.reactor_num = 1;
CPGC.timeout_sec = CP_REACTOR_TIMEO_SEC;
CPGC.timeout_usec = CP_REACTOR_TIMEO_USEC;
CPGC.max_conn = CP_MAX_FDS;
CPGC.max_request = CP_MAX_REQUEST;
CPGC.idel_time = CP_IDEL_TIME;
CPGC.recycle_num = CP_RECYCLE_NUM;
CPGC.max_read_len = CP_DEF_MAX_READ_LEN;
CPGC.ser_fail_hits = 1;
CPGC.max_fail_num = 2;
strcpy(CPGC.ini_file, ini_file);
// MAKE_STD_ZVAL(CPGS->group);
// array_init(CPGS->group);
for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(conf)); zend_hash_has_more_elements(Z_ARRVAL_P(conf)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(conf)))
{
zval **config;
zend_hash_get_current_data(Z_ARRVAL_P(conf), (void**) &config);
char *name;
uint keylen;
zend_hash_get_current_key_ex(Z_ARRVAL_P(conf), &name, &keylen, NULL, 0, NULL);
if (strcmp(name, "common") == 0)
{//common config
cpServer_init_common(*config);
}
else
{
zval **v;
strcpy(CPGS->G[group_num].name, name);
if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_min"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGS->G[group_num].worker_num = CPGS->G[group_num].worker_min = Z_LVAL_PP(v);
}
if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_max"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGS->G[group_num].worker_max = Z_LVAL_PP(v);
}
CPGS->max_buffer_len = CPGC.max_read_len;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
if (pthread_mutex_init(&CPGS->G[group_num].mutex_lock, &attr) < 0)
{
cpLog("pthread_mutex_init error!. Error: %s [%d]", strerror(errno), errno);
return;
}
CPGS->G[group_num].lock = cpMutexLock;
CPGS->G[group_num].unLock = cpMutexUnLock;
CPGS->G[group_num].tryLock = cpMutexTryLock;
// CPGS->G[group_num].WaitList = CPGS->G[group_num].WaitTail = NULL;
CPGS->group_num++;
group_num++;
}
}
}
static void cpManagerReload(int sig)
{
zval *group_conf = NULL, **v;
group_conf = cpGetConfig(CPGC.ini_file);
int gid = 0;
zval **gid_ptr = NULL;
cpGroup *G = NULL;
if (!Z_BVAL_P(group_conf))
{
cpLog("parse ini file[%s] reload error!", CPGC.ini_file);
}
else
{
for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(group_conf)); zend_hash_has_more_elements(Z_ARRVAL_P(group_conf)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(group_conf)))
{
zval **config;
zend_hash_get_current_data(Z_ARRVAL_P(group_conf), (void**) &config);
char *name;
uint keylen;
zend_hash_get_current_key_ex(Z_ARRVAL_P(group_conf), &name, &keylen, NULL, 0, NULL);
if (strcmp(name, "common") != 0)
{
if (zend_hash_find(Z_ARRVAL_P(CPGS->group), name, strlen(name) + 1, (void **) &gid_ptr) == SUCCESS)
{
gid = Z_LVAL_PP(gid_ptr);
G = &CPGS->G[gid];
}
else
{
cpLog("can not add datasource when the server runing,if you want add it please restart");
return;
}
if (pthread_mutex_lock(G->mutex_lock) == 0)
{
if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_max"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
G->worker_max = (int) Z_LVAL_PP(v);
}
if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_min"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
int new_min = (int) Z_LVAL_PP(v);
if (new_min > G->worker_min)
{//增加最小
while (G->worker_num < new_min)
{
cpCreate_worker_mem(G->worker_num, gid);
G->workers_status[G->worker_num] = CP_WORKER_IDLE;
G->worker_num++; //先加 线程安全
int new_pid = cpFork_one_worker(G->worker_num - 1, gid);
if (new_pid < 0)
{
cpLog("Fork worker process failed. Error: %s [%d]", strerror(errno), errno);
}
else
{
G->workers[G->worker_num - 1].pid = new_pid;
}
}
}
G->worker_min = new_min;
}
if (pthread_mutex_unlock(G->mutex_lock) != 0)
{
cpLog("pthread_mutex_unlock. Error: %s [%d]", strerror(errno), errno);
}
}
}
else
{
if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("recycle_num"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGC.recycle_num = (int) Z_LVAL_PP(v);
}
if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("idel_time"), (void **) &v) == SUCCESS)
{
convert_to_long(*v);
CPGC.idel_time = (int) Z_LVAL_PP(v);
}
}
}
zval_ptr_dtor(&group_conf);
}
}
/** {{{ proto public Yaf_Config_Simple::valid(void)
*/
PHP_METHOD(yaf_config_simple, valid) {
zval *prop = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL);
RETURN_BOOL(zend_hash_has_more_elements(Z_ARRVAL_P(prop)) == SUCCESS);
}
static bool getMocData(zval* z_this_ptr, const char* classname, const QMetaObject* superdata, QString* meta_stringdata, uint* signature)
{
/*
// - reads all methods defined in a class
// - see zend_compile.h for types
// - case sensitive
// - types need to be matched
zend_class_entry* ce_ = Z_OBJCE_P(this_ptr);
HashTable* function_table = &Z_OBJCE_P(this_ptr)->function_table;
zend_hash_internal_pointer_reset(function_table);
zval** prop;
union _zend_function *fbc;
if (zend_hash_num_elements( function_table ) > 0) {
while(zend_hash_has_more_elements(function_table) == SUCCESS)
{
zend_hash_get_current_data(function_table,(void**)&fbc);
zend_hash_move_forward(function_table);
QByteArray name( (*fbc).common.function_name );
if( !name.contains("__destruct") &&
!name.contains("__construct") &&
!name.contains("__toString") &&
!name.contains("proxyMethod") &&
!name.contains("staticProxyMethod") &&
!name.contains("emit")
){
for( int i=0; i<(*fbc).common.num_args; i++)
{
qDebug() <<"++ "<< (*fbc).common.arg_info[i].name <<","<< (*fbc).common.arg_info[i].array_type_hint;
}
qDebug() << (*fbc).common.function_name;// << fbc->internal_function->function_name;
}
}
}
*/
/// - readout the slots table
zval **slotdata;
zval *zslot;
zslot = zend_read_property(Z_OBJCE_P(z_this_ptr),z_this_ptr,"slots",5,1);
zval *zsignal;
zsignal = zend_read_property(Z_OBJCE_P(z_this_ptr),z_this_ptr,"signals",7,1);
if((zslot)->type==IS_ARRAY && (zsignal)->type==IS_ARRAY )
{
HashTable* slots_hash = HASH_OF(zslot);
HashTable* signals_hash = HASH_OF(zsignal);
char* assocKey;
ulong numKey;
int signaturecount = 2 + strlen(classname);
#ifdef MOC_DEBUG
QString qr;
pDebug( PHPQt::Moc ) << "+== begin metaobject dump ==+\n";
pDebug( PHPQt::Moc ) << "\t" << classname << "\n\t1 0 0 0 " << zend_hash_num_elements(slots_hash)+zend_hash_num_elements(signals_hash) << " 10 0 0 0 0" << endl << endl;
#endif
/// - write class signature
signature[0] = 1;
signature[4] = zend_hash_num_elements(slots_hash)+zend_hash_num_elements(signals_hash);
signature[5] = 10;
/// - write classname
meta_stringdata->append(classname);
meta_stringdata->append(QChar::Null);
meta_stringdata->append(QChar::Null);
int i = 10;
zend_hash_internal_pointer_reset(signals_hash);
while(zend_hash_has_more_elements(signals_hash) == SUCCESS)
{
/// - read slot from hashtable
zend_hash_get_current_key(signals_hash,&assocKey,&numKey,0);
zend_hash_get_current_data(signals_hash,(void**)&slotdata);
#ifdef MOC_DEBUG
qr.append(Z_STRVAL_PP(slotdata));
qr.append(" ");
pDebug( PHPQt::Moc ) << "\t" << signaturecount << "8 8 8 0x05 ::s" << endl;
#endif
meta_stringdata->append(Z_STRVAL_PP(slotdata));
meta_stringdata->append(QChar::Null);
zend_hash_move_forward(signals_hash);
/// - write signal signature
signature[i++] = signaturecount;
signature[i++] = 8;
signature[i++] = 8;
signature[i++] = 8;
signature[i++] = 0x05;
signaturecount += strlen(Z_STRVAL_PP(slotdata)) + 1;
}
zend_hash_internal_pointer_reset(slots_hash);
while(zend_hash_has_more_elements(slots_hash) == SUCCESS)
{
/// - read slot from hashtable
zend_hash_get_current_key(slots_hash,&assocKey,&numKey,0);
zend_hash_get_current_data(slots_hash,(void**)&slotdata);
#ifdef MOC_DEBUG
qr.append(Z_STRVAL_PP(slotdata));
qr.append(" ");
pDebug( PHPQt::Moc ) << "\t" << signaturecount << "8 8 8 0x0a ::s" << endl;
#endif
meta_stringdata->append(Z_STRVAL_PP(slotdata));
meta_stringdata->append(QChar::Null);
zend_hash_move_forward(slots_hash);
/// - write slot signature
signature[i++] = signaturecount;
signature[i++] = 8;
signature[i++] = 8;
signature[i++] = 8;
signature[i++] = 0x0a;
signaturecount += strlen(Z_STRVAL_PP(slotdata)) + 1;
}
// TODO freeing this crashs
// efree( assocKey );
#ifdef MOC_DEBUG
pDebug( PHPQt::Moc ) << qr << endl;
#endif
pDebug( PHPQt::Moc ) << "+== end metaobject dump ==+" << endl;
return true;
} else {
return false;
}
} // getMocData
void dump_dot(void)
{
int x, print_header, key_type;
int *block_num;
int c = 0, len = 0, flag_ho;
long index, key_len;
char *block_name = NULL;
char *time_buff = pvt_get_time();
smart_str str_dot_func = {0};
TSRMLS_FETCH();
char *tmp_buff = NULL;
tmp_buff = pvt_sprintf(tpl_dot[0], time_buff);
fprintf(PVT_G(trace_file_f_dot), "%s", tmp_buff);
efree(time_buff);
efree(tmp_buff);
if (PVT_G(pvt_graph_fold)) {
hide_functions();
}
/* Iterate through all blocks/nodes */
for (zend_hash_internal_pointer_reset(PVT_G(block_summary));
zend_hash_has_more_elements(PVT_G(block_summary)) == SUCCESS;
zend_hash_move_forward(PVT_G(block_summary))) {
key_type = zend_hash_get_current_key(PVT_G(block_summary), &block_name, &index, 0);
if (key_type == HASH_KEY_IS_STRING) {
key_len = strlen(block_name);
}
zend_hash_get_current_data(PVT_G(block_summary), (void*) &block_num);
print_header = 1;
int flag_started = 0;
int flag_break = 0;
int flag_nop = 0;
flag_ho = 1;
size_t ret_len;
/* Iterate through all functions */
for (x = 0; x < PVT_G(funcs)->len; x++) {
if (PVT_G(funcs)->file_id[x] == *block_num) {
flag_started = 1;
if (print_header) {
if (PVT_G(funcs)->type[x] == 2 && flag_ho) {
char *ret;
php_basename(
PVT_G(funcs)->file_name[x],
strlen(PVT_G(funcs)->file_name[x]),
NULL, 0, &ret, &ret_len TSRMLS_CC
);
char *escaped_str = php_escape_html_entities(
block_name,
strlen(block_name),
&len, 0, ENT_QUOTES, NULL TSRMLS_CC
);
/* Print the block header */
fprintf(PVT_G(trace_file_f_dot),
tpl_point_func[0],
*block_num,
PVT_G(funcs)->line[x],
*block_num,
PVT_G(funcs)->file_name[x], PVT_G(funcs)->line[x],
ret,
escaped_str,
PVT_G(funcs)->func_id[x]
);
flag_ho = 0;
efree(ret);
efree(escaped_str);
}
}
}
if (PVT_G(funcs)->stack[x] <= PVT_G(dot_funcs_i)->file_id[c] && flag_started) {
if (0 == print_header) {
flag_break = 1;
} else {
flag_break = 0;
}
}
if (0 == flag_started) {
continue;
}
if ((PVT_G(funcs)->stack[x]-1) != PVT_G(dot_funcs_i)->file_id[c]) {
if (!flag_break) {
continue;
} else {
flag_nop = 1;
}
}
if (flag_nop != 1) {
flag_nop = 0;
if (print_header) {
print_header = 0;
}
if (PVT_G(dot_funcs_i)->empty[c]) {
flag_started = 0;
break;
}
/* Check if function repeats */
if (0 == PVT_G(funcs)->hide[x] || !PVT_G(pvt_graph_fold)) {
if (2 == PVT_G(funcs)->type[x]) {
/* This is USER function */
char *escaped_str = php_escape_html_entities(
PVT_G(funcs)->func_name[x],
strlen(PVT_G(funcs)->func_name[x]),
&len, 0, ENT_QUOTES, NULL TSRMLS_CC
);
fprintf(PVT_G(trace_file_f_dot),
tpl_point_func[1],
PVT_G(funcs)->line[x],
PVT_G(funcs)->line[x],
escaped_str,
PVT_G(funcs)->func_id[x]
);
efree(escaped_str);
char *tmp_buff = pvt_sprintf(
tpl_relation_func[0],
*block_num,
PVT_G(funcs)->line[x],
PVT_G(funcs)->file_id[x],
PVT_G(funcs)->file_id[x],
PVT_G(funcs)->func_id[x]
);
smart_str_appends(&str_dot_func, tmp_buff);
efree(tmp_buff);
} else {
/* This is ZEND function */
char *escaped_str = php_escape_html_entities(
PVT_G(funcs)->func_name[x],
strlen(PVT_G(funcs)->func_name[x]),
&len, 0, ENT_QUOTES, NULL TSRMLS_CC
);
fprintf(PVT_G(trace_file_f_dot),
tpl_point_func[2],
PVT_G(funcs)->line[x],
(1 == PVT_G(funcs)->is_evil[x] ? "d63333" : "e0ebcc"),
escaped_str,
PVT_G(funcs)->func_id[x]
);
efree(escaped_str);
}
} /* end if (0 ==... */
} /* end if (flag_nop... */
if (flag_break) {
if (!flag_nop) {
flag_break = 0;
flag_started = 0;
break;
}
}
} /* end for (x... */
c++;
fprintf(PVT_G(trace_file_f_dot), "</TABLE>>\n]\n");
}
smart_str_0(&str_dot_func);
if (str_dot_func.c != NULL) {
fprintf(PVT_G(trace_file_f_dot), "%s", str_dot_func.c);
}
smart_str_free(&str_dot_func);
fprintf(PVT_G(trace_file_f_dot), "\n}\n");
fclose(PVT_G(trace_file_f_dot));
}
zval *air_router_route(air_router_t *self) {
zval *return_value;
MAKE_STD_ZVAL(return_value);
ZVAL_NULL(return_value);
pcre_cache_entry *pce;
HashTable *ht_or, *ht_cr;
zval *original_rules, *compiled_rules, **entry, *r;
zval *url;
url = zend_read_property(air_router_ce, self, ZEND_STRL("_url"), 0 TSRMLS_CC);
original_rules = zend_read_property(air_router_ce, self, ZEND_STRL("_original_rules"), 0 TSRMLS_CC);
compiled_rules = zend_read_property(air_router_ce, self, ZEND_STRL("_compiled_rules"), 0 TSRMLS_CC);
ht_or = Z_ARRVAL_P(original_rules);
ht_cr = Z_ARRVAL_P(compiled_rules);
for(
/*zend_hash_internal_pointer_reset(ht_or)*/;
zend_hash_has_more_elements(ht_or) == SUCCESS;
zend_hash_move_forward(ht_or)
){
if (zend_hash_get_current_data(ht_or, (void**)&entry) == FAILURE) {
continue;
}
char *key;
uint key_len = 0;
ulong idx = 0;
smart_str ss = {0};
char *regex = NULL;
uint regex_len = 0;
//lazy compiling
zend_hash_get_current_key_ex(ht_or, &key, &key_len, &idx, 0, NULL);
r = air_arr_find(compiled_rules, key, key_len);
if (r == NULL){
MAKE_STD_ZVAL(r);
array_init(r);
regex = air_router_compile(key, key_len, ®ex_len);
char *ca = Z_STRVAL_PP(entry);
int size = 0;
while(size<Z_STRLEN_PP(entry)) {
if(ca[size] == '.'){
break;
}
size++;
}
if(size==0){
add_assoc_stringl_ex(r, ZEND_STRS(air_c_key), ZEND_STRS("index"), 1);
}else{
add_assoc_stringl_ex(r, ZEND_STRS(air_c_key), ca, size, 1);
}
if(size+1>=Z_STRLEN_PP(entry)){
add_assoc_stringl_ex(r, ZEND_STRS(air_a_key), ZEND_STRS("index"), 1);
}else{
add_assoc_stringl_ex(r, ZEND_STRS(air_a_key), ca+size+1, Z_STRLEN_PP(entry)-size-1, 1);
}
add_assoc_zval_ex(compiled_rules, key, key_len, r);
smart_str_appendc(&ss, '#');
smart_str_appendl(&ss, regex, regex_len-1);
smart_str_appendc(&ss, '#');
smart_str_0(&ss);
efree(regex);
add_assoc_stringl_ex(r, ZEND_STRS("regex"), ss.c, ss.len, 1);
}else{
zval *r_r = air_arr_find(r, ZEND_STRS("regex"));
if (r_r == NULL){
continue;
}
smart_str_appendl(&ss, Z_STRVAL_P(r_r), Z_STRLEN_P(r_r));
smart_str_0(&ss);
}
if(ss.len > 0){
zval *ret;
pce = pcre_get_compiled_regex_cache(ss.c, ss.len TSRMLS_CC);
smart_str_free(&ss);
if(pce){
zval matches, *subpats;
MAKE_STD_ZVAL(subpats);
ZVAL_NULL(subpats);
php_pcre_match_impl(pce, Z_STRVAL_P(url), Z_STRLEN_P(url), &matches, subpats/* subpats */, 0/* global */, 0/* ZEND_NUM_ARGS() >= 4 */, 0/*flags PREG_OFFSET_CAPTURE*/, 0/* start_offset */ TSRMLS_CC);
if (zend_hash_num_elements(Z_ARRVAL_P(subpats)) > 0) {
ret = air_arr_del_index_el(subpats);
air_router_route_apply_subpats(r, ret, ZEND_STRS(air_c_key), key, key_len);
air_router_route_apply_subpats(r, ret, ZEND_STRS(air_a_key), key, key_len);
ZVAL_ZVAL(return_value, ret, 1, 0);
zval_ptr_dtor(&ret);
zval_ptr_dtor(&subpats);
//move forward specially
zend_hash_move_forward(ht_or);
break;
}
zval_ptr_dtor(&subpats);
}
}
}
return return_value;
}
PHP_COUCHBASE_LOCAL
void php_couchbase_get_delayed_impl(INTERNAL_FUNCTION_PARAMETERS, int oo) /* {{{ */
{
zval *res, *akeys;
long with_cas = 0;
lcb_time_t exp = {0};
long expiry = 0;
zend_bool lock = 0;
int argflags = PHP_COUCHBASE_ARG_F_ASYNC;
php_couchbase_res *couchbase_res;
#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2
zend_fcall_info fci = {0};
zend_fcall_info_cache fci_cache = {0};
if (oo) {
argflags |= PHP_COUCHBASE_ARG_F_OO;
} else {
argflags |= PHP_COUCHBASE_ARG_F_FUNCTIONAL;
}
PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,
"a|lf!lb",
&akeys, &with_cas, &fci, &fci_cache, &expiry, &lock);
#else
if (oo) {
argflags |= PHP_COUCHBASE_ARG_F_OO;
} else {
argflags |= PHP_COUCHBASE_ARG_F_FUNCTIONAL;
}
zval *callback = NULL;
PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,
"a|lzlb", &akeys, &with_cas, &callback, &expiry, &lock);
if (callback && Z_TYPE_P(callback) != IS_NULL
&& !zend_is_callable(callback, 0, NULL)) {
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo,
cb_exception,
"third argument is expected to be a valid callback");
return;
}
#endif
{
zval **ppzval;
lcb_error_t retval;
php_couchbase_ctx *ctx;
char **keys;
long nkey, *klens, i;
nkey = zend_hash_num_elements(Z_ARRVAL_P(akeys));
keys = ecalloc(nkey, sizeof(char *));
klens = ecalloc(nkey, sizeof(long));
for (i = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys));
zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(akeys)), i++) {
if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) {
nkey--;
continue;
}
if (IS_ARRAY != Z_TYPE_PP(ppzval)) {
convert_to_string_ex(ppzval);
}
if (!Z_STRLEN_PP(ppzval)) {
nkey--;
continue;
}
if (couchbase_res->prefix_key_len) {
klens[i] = spprintf(&(keys[i]), 0, "%s_%s", couchbase_res->prefix_key, Z_STRVAL_PP(ppzval));
} else {
keys[i] = Z_STRVAL_PP(ppzval);
klens[i] = Z_STRLEN_PP(ppzval);
}
}
if (!nkey) {
efree(keys);
efree(klens);
return;
}
couchbase_res->seqno += nkey;
ctx = ecalloc(1, sizeof(php_couchbase_ctx));
ctx->res = couchbase_res;
ctx->flags = with_cas;
{
lcb_get_cmd_t **commands = ecalloc(nkey, sizeof(lcb_get_cmd_t *));
int ii;
if (expiry) {
exp = pcbc_check_expiry(expiry);
}
for (ii = 0; ii < nkey; ++ii) {
lcb_get_cmd_t *cmd = ecalloc(1, sizeof(lcb_get_cmd_t));
commands[ii] = cmd;
cmd->v.v0.key = keys[ii];
cmd->v.v0.nkey = klens[ii];
cmd->v.v0.lock = (int)lock;
cmd->v.v0.exptime = exp; /* NB: this assumes that sizeof(lcb_time_t) == sizeof(long) */
}
retval = lcb_get(couchbase_res->handle, ctx,
nkey, (const lcb_get_cmd_t * const *)commands);
for (ii = 0; ii < nkey; ++ii) {
efree(commands[ii]);
}
efree(commands);
}
if (LCB_SUCCESS != retval) {
if (couchbase_res->prefix_key_len) {
int i;
for (i = 0; i < nkey; i++) {
efree(keys[i]);
}
}
efree(keys);
efree(klens);
efree(ctx);
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo,
cb_lcb_exception,
"Failed to schedule delayed get request: %s",
lcb_strerror(couchbase_res->handle, retval));
return;
}
couchbase_res->async = 1;
couchbase_res->async_ctx = ctx;
if (couchbase_res->prefix_key_len) {
int i;
for (i = 0; i < nkey; i++) {
efree(keys[i]);
}
}
efree(keys);
efree(klens);
if (
#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2
fci.size
#else
callback
#endif
) {
zval *result, **ppzval, *retval_ptr = NULL;
zval **params[2];
MAKE_STD_ZVAL(result);
array_init(result);
ctx->rv = result;
pcbc_start_loop(couchbase_res);
couchbase_res->async = 0;
for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(result));
zend_hash_has_more_elements(Z_ARRVAL_P(result)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(result))) {
if (zend_hash_get_current_data(Z_ARRVAL_P(result), (void **)&ppzval) == FAILURE) {
continue;
}
params[0] = &res;
params[1] = ppzval;
#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2
fci.retval_ptr_ptr = &retval_ptr;
fci.param_count = 2;
fci.params = params;
zend_call_function(&fci, &fci_cache TSRMLS_CC);
#else
call_user_function_ex(EG(function_table), NULL, callback, &retval_ptr, 2, params, 0, NULL TSRMLS_CC);
#endif
if (retval_ptr != NULL) {
zval_ptr_dtor(&retval_ptr);
}
}
zval_ptr_dtor(&result);
efree(ctx);
}
}
RETURN_TRUE;
}
PHP_COUCHBASE_LOCAL
void php_couchbase_get_impl(INTERNAL_FUNCTION_PARAMETERS,
int multi,
int oo,
int lock,
int touch)
{
char *key, **keys;
long *klens, klen = 0;
int nkey = 0;
long flag = 0;
lcb_time_t exp = {0};
long expiry = 0;
zval *res, *cas_token = NULL;
int argflags;
lcb_error_t retval;
php_couchbase_res *couchbase_res;
php_couchbase_ctx *ctx;
argflags = oo ? PHP_COUCHBASE_ARG_F_OO : PHP_COUCHBASE_ARG_F_FUNCTIONAL;
if (multi) {
zval *akeys;
zval **ppzval;
zend_bool preserve_order;
int i;
if (lock) {
PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,
"az|ll",
&akeys, &cas_token,
&flag, &expiry);
} else if (touch) {
PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,
"al|z",
&akeys, &expiry, &cas_token);
} else {
PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,
"a|zl",
&akeys, &cas_token, &flag);
}
nkey = zend_hash_num_elements(Z_ARRVAL_P(akeys));
keys = ecalloc(nkey, sizeof(char *));
klens = ecalloc(nkey, sizeof(long));
preserve_order = (flag & COUCHBASE_GET_PRESERVE_ORDER);
array_init(return_value);
for (i = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys));
zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(akeys)), i++) {
if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) {
nkey--;
continue;
}
if (IS_ARRAY != Z_TYPE_PP(ppzval)) {
convert_to_string_ex(ppzval);
}
if (!Z_STRLEN_PP(ppzval)) {
nkey--;
continue;
}
if (couchbase_res->prefix_key_len) {
klens[i] = spprintf(&(keys[i]), 0, "%s_%s", couchbase_res->prefix_key, Z_STRVAL_PP(ppzval));
} else {
keys[i] = Z_STRVAL_PP(ppzval);
klens[i] = Z_STRLEN_PP(ppzval);
}
if (preserve_order) {
add_assoc_null_ex(return_value, keys[i], klens[i] + 1);
}
}
if (!nkey) {
efree(keys);
efree(klens);
return;
}
if (cas_token && IS_ARRAY != Z_TYPE_P(cas_token)) {
zval_dtor(cas_token);
array_init(cas_token);
}
} else {
if (lock) {
PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,
"sz|l", &key, &klen,
&cas_token, &expiry);
} else if (touch) {
PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,
"sl|z", &key, &klen, &expiry,
&cas_token);
} else {
PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags,
"s|z", &key, &klen,
&cas_token);
}
if (!klen) {
return;
}
nkey = 1;
if (couchbase_res->prefix_key_len) {
klen = spprintf(&key, 0, "%s_%s", couchbase_res->prefix_key, key);
}
keys = &key;
klens = &klen;
if (cas_token) {
zval_dtor(cas_token);
ZVAL_NULL(cas_token);
}
}
{
lcb_get_cmd_t **commands = ecalloc(nkey, sizeof(lcb_get_cmd_t *));
int ii;
if (expiry) {
exp = pcbc_check_expiry(expiry);
}
for (ii = 0; ii < nkey; ++ii) {
lcb_get_cmd_t *cmd = ecalloc(1, sizeof(lcb_get_cmd_t));
commands[ii] = cmd;
cmd->v.v0.key = keys[ii];
cmd->v.v0.nkey = klens[ii];
cmd->v.v0.lock = (int)lock;
cmd->v.v0.exptime = exp; /* NB: this assumes sizeof(lcb_time_t) == sizeof(long) */
}
ctx = ecalloc(1, sizeof(php_couchbase_ctx));
ctx->res = couchbase_res;
ctx->rv = return_value;
ctx->cas = cas_token;
retval = lcb_get(couchbase_res->handle, ctx,
nkey, (const lcb_get_cmd_t * const *)commands);
for (ii = 0; ii < nkey; ++ii) {
efree(commands[ii]);
}
efree(commands);
if (LCB_SUCCESS != retval) {
if (couchbase_res->prefix_key_len) {
int i;
for (i = 0; i < nkey; i++) {
efree(keys[i]);
}
}
if (multi) {
efree(keys);
efree(klens);
zval_dtor(return_value);
}
efree(ctx);
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo,
cb_lcb_exception,
"Failed to schedule get request: %s",
lcb_strerror(couchbase_res->handle, retval));
return;
}
couchbase_res->seqno += nkey;
pcbc_start_loop(couchbase_res);
if (LCB_SUCCESS != ctx->res->rc) {
if (LCB_KEY_ENOENT != ctx->res->rc) {
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo,
cb_lcb_exception,
"Failed to get a value from server: %s",
lcb_strerror(couchbase_res->handle,
ctx->res->rc));
}
}
efree(ctx);
if (couchbase_res->prefix_key_len) {
int i;
for (i = 0; i < nkey; i++) {
efree(keys[i]);
}
}
if (multi) {
efree(keys);
efree(klens);
}
}
}
PHP_METHOD(jz_data, valid) {
zval *prop = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME), 1, NULL);
RETURN_BOOL(zend_hash_has_more_elements(Z_ARRVAL_P(prop)) == SUCCESS);
}
RedisArray*
ra_load_hosts(RedisArray *ra, HashTable *hosts, long retry_interval, zend_bool b_lazy_connect TSRMLS_DC)
{
int i = 0, host_len;
zval *id;
char *host, *p;
short port;
zval *zpData, z_cons, z_ret;
RedisSock *redis_sock = NULL;
/* function calls on the Redis object */
ZVAL_STRING(&z_cons, "__construct");
/* init connections */
for (zend_hash_internal_pointer_reset(hosts);
zend_hash_has_more_elements(hosts) == SUCCESS;
zend_hash_move_forward(hosts))
{
if ((zpData = zend_hash_get_current_data(hosts)) == NULL || (Z_TYPE_P(zpData) != IS_STRING))
{
zval_dtor(&z_cons);
efree(ra);
return NULL;
}
ra->hosts[i] = estrdup(Z_STRVAL_P(zpData));
/* default values */
host = Z_STRVAL_P(zpData);
host_len = Z_STRLEN_P(zpData);
port = 6379;
if(((p = strrchr(host, ':')))) { /* found port */
host_len = p - host;
port = (short)atoi(p+1);
} else if(strchr(host,'/') != NULL) { /* unix socket */
port = -1;
}
/* create Redis object */
object_init_ex(&ra->redis[i], redis_ce);
call_user_function(&redis_ce->function_table, &ra->redis[i], &z_cons, &z_ret, 0, NULL TSRMLS_CC);
/* create socket */
redis_sock = redis_sock_create(host, host_len, port, ra->connect_timeout, ra->pconnect, NULL, retry_interval, b_lazy_connect);
if (!b_lazy_connect) {
/* connect */
redis_sock_server_open(redis_sock, 1 TSRMLS_CC);
}
/* attach */
id = zend_list_insert(redis_sock, le_redis_sock TSRMLS_CC);
add_property_resource(&ra->redis[i], "socket", Z_RES_P(id));
i++;
}
/* Cleanup constructor zval */
zval_dtor(&z_cons);
return ra;
}
PHP_COUCHBASE_LOCAL
void php_couchbase_store_impl(INTERNAL_FUNCTION_PARAMETERS, lcb_storage_t op, int multi)
{
lcb_error_t retval;
php_couchbase_res *couchbase_res;
php_couchbase_ctx *ctx;
time_t exp = {0};
unsigned int flags = 0;
char *payload, *cas = NULL;
size_t payload_len = 0;
unsigned long long cas_v = 0;
long expire = 0, cas_len = 0;
char *key = NULL;
if (!multi) {
char *key = NULL;
zval *value;
long klen = 0;
PHP_COUCHBASE_GET_PARAMS(couchbase_res,
PHP_COUCHBASE_ARG_F_FUNCTIONAL,
"sz|ls",
&key, &klen,
&value,
&expire,
&cas, &cas_len);
if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0,
expire, &exp) == -1) {
/* Incorrect expiry time */
return;
}
if (!klen) {
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0,
cb_illegal_key_exception,
"No key specified: Empty key");
return;
}
if (cas) {
char *e;
cas_v = (lcb_cas_t)strtoull(cas, &e, 10);
if (*e != '\0') {
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0,
cb_illegal_key_exception,
"Invalid CAS specified");
return;
}
}
payload = php_couchbase_zval_to_payload(value, &payload_len,
&flags,
couchbase_res->serializer,
couchbase_res->compressor
TSRMLS_CC);
if (payload == NULL) {
RETURN_FALSE;
}
if (couchbase_res->prefix_key_len) {
klen = spprintf(&key, 0, "%s_%s", couchbase_res->prefix_key, key);
}
ctx = ecalloc(1, sizeof(php_couchbase_ctx));
ctx->res = couchbase_res;
ctx->rv = return_value;
couchbase_res->seqno += 1;
{
lcb_store_cmd_t cmd;
lcb_store_cmd_t *commands[] = { &cmd };
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.operation = op;
cmd.v.v0.key = key;
cmd.v.v0.nkey = klen;
cmd.v.v0.bytes = payload;
cmd.v.v0.nbytes = payload_len;
cmd.v.v0.flags = flags;
cmd.v.v0.exptime = exp;
cmd.v.v0.cas = (uint64_t)cas_v;
retval = lcb_store(couchbase_res->handle, ctx,
1, (const lcb_store_cmd_t * const *)commands);
}
efree(payload);
if (couchbase_res->prefix_key_len) {
efree(key);
}
if (LCB_SUCCESS != retval) {
efree(ctx);
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0,
cb_lcb_exception,
"Failed to schedule set request: %s",
lcb_strerror(couchbase_res->handle, retval));
return;
}
} else { /* multi */
zval *akeys, **ppzval;
char *key = NULL;
uint klen = 0;
ulong idx;
int key_type, nkey = 0;
PHP_COUCHBASE_GET_PARAMS(couchbase_res,
PHP_COUCHBASE_ARG_F_FUNCTIONAL,
"a|l",
&akeys, &expire);
if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0,
expire, &exp) == -1) {
/* Incorrect expiry time */
return;
}
ctx = ecalloc(1, sizeof(php_couchbase_ctx));
ctx->res = couchbase_res;
ctx->rv = return_value;
array_init(ctx->rv);
for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys));
zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(akeys))) {
if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) {
continue;
}
switch ((key_type = zend_hash_get_current_key(Z_ARRVAL_P(akeys), &key, &idx, 0))) {
case HASH_KEY_IS_LONG:
spprintf(&key, 0, "%ld", idx);
break;
case HASH_KEY_IS_STRING:
break;
default:
continue;
}
if (!(klen = strlen(key))) {
continue;
}
payload = php_couchbase_zval_to_payload(*ppzval, &payload_len,
&flags,
couchbase_res->serializer,
couchbase_res->compressor
TSRMLS_CC);
if (payload == NULL) {
RETURN_FALSE;
}
if (couchbase_res->prefix_key_len) {
char *new_key;
klen = spprintf(&new_key, 0, "%s_%s", couchbase_res->prefix_key, key);
if (key_type == HASH_KEY_IS_LONG) {
efree(key);
}
key = new_key;
}
{
lcb_store_cmd_t cmd;
lcb_store_cmd_t *commands[] = { &cmd };
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.operation = op;
cmd.v.v0.key = key;
cmd.v.v0.nkey = klen;
cmd.v.v0.bytes = payload;
cmd.v.v0.nbytes = payload_len;
cmd.v.v0.flags = flags;
cmd.v.v0.exptime = exp;
retval = lcb_store(couchbase_res->handle, ctx,
1, (const lcb_store_cmd_t * const *)commands);
}
efree(payload);
if (couchbase_res->prefix_key_len || HASH_KEY_IS_LONG == key_type) {
efree(key);
}
if (LCB_SUCCESS != retval) {
efree(ctx);
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0,
cb_lcb_exception,
"Failed to schedule set request: %s",
lcb_strerror(couchbase_res->handle,
retval));
return;
}
nkey++;
}
if (!nkey) {
efree(ctx);
return;
}
couchbase_res->seqno += nkey;
}
{
pcbc_start_loop(couchbase_res);
if (IS_ARRAY != Z_TYPE_P(return_value)) {
if (LCB_SUCCESS != ctx->res->rc) {
RETVAL_FALSE;
switch (op) {
case LCB_ADD:
if (LCB_KEY_EEXISTS == ctx->res->rc) {
break;
}
case LCB_APPEND:
case LCB_PREPEND:
if (LCB_NOT_STORED == ctx->res->rc) {
break;
}
case LCB_REPLACE:
case LCB_SET:
if (LCB_KEY_ENOENT == ctx->res->rc) {
break;
}
if (cas && LCB_KEY_EEXISTS == ctx->res->rc) {
break;
}
default:
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0,
cb_lcb_exception,
"Failed to store a value to server: %s",
lcb_strerror(couchbase_res->handle,
ctx->res->rc));
break;
}
}
}
efree(ctx);
}
}
/**
* Convert a php Array to a maps
*
* @param t the php Array to convert
* @return the created maps
*/
maps* php_maps_from_Array(HashTable *t){
maps* final_res=NULL;
maps* cursor=final_res;
char key[1024];
for(zend_hash_internal_pointer_reset(t);
zend_hash_has_more_elements(t) == SUCCESS;
zend_hash_move_forward(t)) {
char *key;
uint keylen;
ulong idx;
int type;
zval **ppzval, tmpcopy;
type = zend_hash_get_current_key_ex(t, &key, &keylen, &idx, 0, NULL);
if (zend_hash_get_current_data(t, (void**)&ppzval) == FAILURE) {
/**
* Should never actually fail since the key is known to exist.
*/
continue;
}
/**
* Duplicate the zval so that * the orignal’s contents are not destroyed
*/
tmpcopy = **ppzval;
#ifdef DEBUG
fprintf(stderr,"key : %s\n",key);
#endif
zval_copy_ctor(&tmpcopy);
#ifdef DEBUG
fprintf(stderr,"key : %s\n",key);
#endif
/**
* Reset refcount & Convert
*/
INIT_PZVAL(&tmpcopy);
//convert_to_string(&tmpcopy);
if (type == HASH_KEY_IS_STRING) {
/**
* String Key / Associative
*/
cursor=createMaps(key);
#ifdef DEBUG
fprintf(stderr,"key : %s\n",key);
#endif
HashTable* t=HASH_OF(*ppzval);
#ifdef DEBUG
fprintf(stderr,"key : %s\n",key);
#endif
cursor->content=php_map_from_HasTable(t);
cursor->next=NULL;
if(final_res==NULL)
final_res=dupMaps(&cursor);
else{
addMapsToMaps(&final_res,cursor);
}
freeMaps(&cursor);
free(cursor);
}
#ifdef DEBUG
fprintf(stderr,"key : %s\n",key);
#endif
/**
* Toss out old copy
*/
zval_dtor(&tmpcopy);
}
return final_res;
}
static int yac_add_impl(char *prefix, uint prefix_len, char *key, uint len, zval *value, int ttl, int add TSRMLS_DC) /* {{{ */ {
int ret = 0, flag = Z_TYPE_P(value);
char *msg, buf[YAC_STORAGE_MAX_KEY_LEN];
time_t tv;
if ((len + prefix_len) > YAC_STORAGE_MAX_KEY_LEN) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Key%s can not be longer than %d bytes",
prefix_len? "(include prefix)" : "", YAC_STORAGE_MAX_KEY_LEN);
return ret;
}
if (prefix_len) {
len = snprintf(buf, sizeof(buf), "%s%s", prefix, key);
key = (char *)buf;
}
tv = time(NULL);
switch (Z_TYPE_P(value)) {
case IS_NULL:
ret = yac_storage_update(key, len, (char *)&flag, sizeof(int), flag, ttl, add, tv);
break;
case IS_BOOL:
case IS_LONG:
ret = yac_storage_update(key, len, (char *)&Z_LVAL_P(value), sizeof(long), flag, ttl, add, tv);
break;
case IS_DOUBLE:
ret = yac_storage_update(key, len, (char *)&Z_DVAL_P(value), sizeof(double), flag, ttl, add, tv);
break;
case IS_STRING:
case IS_CONSTANT:
{
if (Z_STRLEN_P(value) > YAC_G(compress_threshold) || Z_STRLEN_P(value) > YAC_STORAGE_MAX_ENTRY_LEN) {
int compressed_len;
char *compressed;
/* if longer than this, then we can not stored the length in flag */
if (Z_STRLEN_P(value) > YAC_ENTRY_MAX_ORIG_LEN) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Value is too long(%d bytes) to be stored", Z_STRLEN_P(value));
return ret;
}
compressed = emalloc(Z_STRLEN_P(value) * 1.05);
compressed_len = fastlz_compress(Z_STRVAL_P(value), Z_STRLEN_P(value), compressed);
if (!compressed_len || compressed_len > Z_STRLEN_P(value)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Compression failed");
efree(compressed);
return ret;
}
if (compressed_len > YAC_STORAGE_MAX_ENTRY_LEN) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Value is too long(%d bytes) to be stored", Z_STRLEN_P(value));
efree(compressed);
return ret;
}
flag |= YAC_ENTRY_COMPRESSED;
flag |= (Z_STRLEN_P(value) << YAC_ENTRY_ORIG_LEN_SHIT);
ret = yac_storage_update(key, len, compressed, compressed_len, flag, ttl, add, tv);
efree(compressed);
} else {
ret = yac_storage_update(key, len, Z_STRVAL_P(value), Z_STRLEN_P(value), flag, ttl, add, tv);
}
}
break;
case IS_ARRAY:
case IS_CONSTANT_ARRAY:
case IS_OBJECT:
{
smart_str buf = {0};
#if ENABLE_MSGPACK
if (yac_serializer_msgpack_pack(value, &buf, &msg TSRMLS_CC)) {
#else
if (yac_serializer_php_pack(value, &buf, &msg TSRMLS_CC)) {
#endif
if (buf.len > YAC_G(compress_threshold) || buf.len > YAC_STORAGE_MAX_ENTRY_LEN) {
int compressed_len;
char *compressed;
if (buf.len > YAC_ENTRY_MAX_ORIG_LEN) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Value is too big to be stored");
return ret;
}
compressed = emalloc(buf.len * 1.05);
compressed_len = fastlz_compress(buf.c, buf.len, compressed);
if (!compressed_len || compressed_len > buf.len) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Compression failed");
efree(compressed);
return ret;
}
if (compressed_len > YAC_STORAGE_MAX_ENTRY_LEN) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Value is too big to be stored");
efree(compressed);
return ret;
}
flag |= YAC_ENTRY_COMPRESSED;
flag |= (buf.len << YAC_ENTRY_ORIG_LEN_SHIT);
ret = yac_storage_update(key, len, compressed, compressed_len, flag, ttl, add, tv);
efree(compressed);
} else {
ret = yac_storage_update(key, len, buf.c, buf.len, flag, ttl, add, tv);
}
smart_str_free(&buf);
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Serialization failed");
smart_str_free(&buf);
}
}
break;
case IS_RESOURCE:
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type 'IS_RESOURCE' cannot be stored");
break;
default:
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported valued type to be stored '%d'", flag);
break;
}
return ret;
}
/* }}} */
static int yac_add_multi_impl(char *prefix, uint prefix_len, zval *kvs, int ttl, int add TSRMLS_DC) /* {{{ */ {
HashTable *ht = Z_ARRVAL_P(kvs);
for (zend_hash_internal_pointer_reset(ht);
zend_hash_has_more_elements(ht) == SUCCESS;
zend_hash_move_forward(ht)) {
char *key;
ulong idx;
zval **value;
uint len, should_free = 0;
if (zend_hash_get_current_data(ht, (void **)&value) == FAILURE) {
continue;
}
switch (zend_hash_get_current_key_ex(ht, &key, &len, &idx, 0, NULL)) {
case HASH_KEY_IS_LONG:
len = spprintf(&key, 0, "%lu", idx) + 1;
should_free = 1;
case HASH_KEY_IS_STRING:
if (yac_add_impl(prefix, prefix_len, key, len - 1, *value, ttl, add TSRMLS_CC)) {
if (should_free) {
efree(key);
}
continue;
} else {
if (should_free) {
efree(key);
}
return 0;
}
default:
continue;
}
}
return 1;
}
PHP_COUCHBASE_LOCAL
void php_couchbase_store_multi_impl_oo(INTERNAL_FUNCTION_PARAMETERS)
{
lcb_error_t retval;
php_couchbase_res *couchbase_res;
php_couchbase_ctx *ctx;
time_t exp = {0};
long expire = 0;
zval *akeys;
long persist_to = 0;
long replicate_to = 0;
struct observe_entry *entries;
int numkeys;
lcb_store_cmd_t *cmds;
lcb_store_cmd_t **commands;
int ii;
PHP_COUCHBASE_GET_PARAMS(couchbase_res, PHP_COUCHBASE_ARG_F_OO, "a|lll",
&akeys, &expire, &persist_to, &replicate_to);
if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1,
expire, &exp) == -1) {
/* Incorrect expiry time */
return;
}
if (validate_simple_observe_clause(couchbase_res->handle,
persist_to,
replicate_to TSRMLS_CC) == -1) {
/* Exception already thrown */
return;
}
numkeys = zend_hash_num_elements(Z_ARRVAL_P(akeys));
if (numkeys == 0) {
zend_throw_exception(cb_illegal_key_exception,
"No items specified",
0 TSRMLS_CC);
return ;
}
entries = ecalloc(numkeys, sizeof(struct observe_entry));
commands = ecalloc(numkeys, sizeof(lcb_store_cmd_t *));
cmds = ecalloc(numkeys, sizeof(lcb_store_cmd_t));
/* link the command pointers */
for (ii = 0; ii < numkeys; ++ii) {
commands[ii] = cmds + ii;
}
ctx = ecalloc(1, sizeof(php_couchbase_ctx));
ctx->res = couchbase_res;
ctx->rv = return_value;
array_init(ctx->rv);
for (ii = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys));
zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(akeys)), ++ii) {
char *key = NULL;
uint klen;
size_t payload_len = 0;
char *payload;
unsigned int flags = 0;
zval **ppzval;
if (zend_hash_get_current_key_type(Z_ARRVAL_P(akeys)) != HASH_KEY_IS_STRING) {
int xx;
for (xx = 0; xx < ii; ++xx) {
efree((void *)cmds[xx].v.v0.bytes);
}
efree(commands);
efree(cmds);
efree(ctx);
release_entry_array(entries, xx);
zend_throw_exception(cb_illegal_key_exception,
"Invalid key specified (not a string)",
0 TSRMLS_CC);
return ;
}
zend_hash_get_current_key(Z_ARRVAL_P(akeys), &key, NULL, 0);
if ((klen = strlen(key)) == 0) {
int xx;
for (xx = 0; xx < ii; ++xx) {
efree((void *)cmds[xx].v.v0.bytes);
}
efree(commands);
efree(cmds);
efree(ctx);
release_entry_array(entries, xx);
zend_throw_exception(cb_illegal_key_exception,
"Invalid key specified (empty string)",
0 TSRMLS_CC);
return ;
}
if (zend_hash_get_current_data(Z_ARRVAL_P(akeys),
(void **)&ppzval) == FAILURE) {
int xx;
for (xx = 0; xx < ii; ++xx) {
efree((void *)cmds[xx].v.v0.bytes);
}
efree(commands);
efree(cmds);
efree(ctx);
release_entry_array(entries, xx);
zend_throw_exception(cb_exception,
"Failed to get data for key",
0 TSRMLS_CC);
return ;
}
payload = php_couchbase_zval_to_payload(*ppzval, &payload_len, &flags,
couchbase_res->serializer,
couchbase_res->compressor
TSRMLS_CC);
if (payload == NULL) {
/* Shouldn't we call an exception? */
RETURN_FALSE;
}
if (couchbase_res->prefix_key_len) {
char *new_key;
klen = spprintf(&new_key, 0, "%s_%s", couchbase_res->prefix_key, key);
key = new_key;
}
entries[ii].nkey = klen;
entries[ii].key = emalloc(klen);
memcpy(entries[ii].key, key, klen);
cmds[ii].v.v0.operation = LCB_SET;
cmds[ii].v.v0.key = entries[ii].key;
cmds[ii].v.v0.nkey = klen;
cmds[ii].v.v0.bytes = payload;
cmds[ii].v.v0.nbytes = payload_len;
cmds[ii].v.v0.flags = flags;
cmds[ii].v.v0.exptime = exp;
if (couchbase_res->prefix_key_len) {
efree(key);
}
}
retval = lcb_store(couchbase_res->handle, ctx, numkeys,
(const lcb_store_cmd_t * const *)commands);
couchbase_res->seqno += numkeys;
pcbc_start_loop(couchbase_res);
/*
* Time to release the payloads...
*/
for (ii = 0; ii < numkeys; ++ii) {
efree((void *)cmds[ii].v.v0.bytes);
}
efree(cmds);
efree(commands);
if (LCB_SUCCESS != retval) {
efree(ctx);
couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1,
cb_lcb_exception,
"Failed to schedule set request: %s",
lcb_strerror(couchbase_res->handle, retval));
release_entry_array(entries, numkeys);
RETURN_FALSE;
}
/*
* The item was stored successfully. Did the user want to wait until
* it was persisted/replicated?
*/
if (persist_to != 0 || replicate_to != 0) {
int ii = 0;
for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(return_value));
zend_hash_has_more_elements(Z_ARRVAL_P(return_value)) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(return_value)), ++ii) {
zval **curr_cas;
zend_hash_get_current_data(Z_ARRVAL_P(return_value),
(void **)&curr_cas);
if (Z_STRLEN_PP(curr_cas)) {
entries[ii].cas = strtoull(Z_STRVAL_PP(curr_cas), 0, 10);
} else {
/* @todo what to do here? */
fprintf(stderr, "wtf!\n");
}
}
retval = simple_observe(couchbase_res->handle, entries, numkeys,
persist_to, replicate_to);
couchbase_res->rc = retval;
if (retval != LCB_SUCCESS) {
if (retval == LCB_ETIMEDOUT) {
zend_throw_exception(cb_timeout_exception,
"Timed out waiting for the objects to persist",
0 TSRMLS_CC);
} else {
char errmsg[256];
snprintf(errmsg, sizeof(errmsg),
"An error occured while waiting for the objects to persist: %s",
lcb_strerror(couchbase_res->handle, retval));
zend_throw_exception(cb_lcb_exception, errmsg, 0 TSRMLS_CC);
}
} else {
int currsize = 4096;
char *errmsg = malloc(currsize);
int offset = sprintf(errmsg, "The following documents was mutated:");
int errors = 0;
for (ii = 0; ii < numkeys; ++ii) {
if (entries[ii].mutated) {
if ((offset + entries[ii].nkey + 3) > currsize) {
char *p = realloc(errmsg, currsize * 2);
if (p) {
currsize *= 2;
errmsg = p;
}
}
if ((offset + entries[ii].nkey + 3) < currsize) {
offset += sprintf(errmsg + offset, " \"");
memcpy(errmsg + offset, entries[ii].key,
entries[ii].nkey);
offset += entries[ii].nkey;
offset += sprintf(errmsg + offset, "\"");
}
errors = 1;
}
}
if (errors) {
zend_throw_exception(cb_key_mutated_exception, errmsg,
0 TSRMLS_CC);
}
free(errmsg);
}
}
release_entry_array(entries, numkeys);
efree(ctx);
}
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);
}
