diff options
| -rw-r--r-- | redis_array.c | 51 | ||||
| -rw-r--r-- | redis_array.h | 8 | ||||
| -rw-r--r-- | redis_array_impl.c | 740 | ||||
| -rw-r--r-- | redis_session.c | 22 |
4 files changed, 376 insertions, 445 deletions
diff --git a/redis_array.c b/redis_array.c index b9249488..8495b6d5 100644 --- a/redis_array.c +++ b/redis_array.c @@ -89,28 +89,28 @@ static void redis_array_free(RedisArray *ra) { /* Redis objects */ for(i=0;i<ra->count;i++) { - zval_dtor(ra->redis[i]); - efree(ra->redis[i]); - efree(ra->hosts[i]); + zval_dtor(&ra->redis[i]); + efree(&ra->redis[i]); + efree(&ra->hosts[i]); } efree(ra->redis); efree(ra->hosts); /* delete hash function */ - if(ra->z_fun) { - zval_dtor(ra->z_fun); - efree(ra->z_fun); + if(Z_TYPE(ra->z_fun) != IS_UNDEF) { + zval_dtor(&ra->z_fun); + efree(&ra->z_fun); } /* Distributor */ - if(ra->z_dist) { - zval_dtor(ra->z_dist); - efree(ra->z_dist); + if(Z_TYPE(ra->z_dist) != IS_UNDEF) { + zval_dtor(&ra->z_dist); + efree(&ra->z_dist); } /* Delete pur commands */ - zval_dtor(ra->z_pure_cmds); - efree(ra->z_pure_cmds); + zval_dtor(&ra->z_pure_cmds); + efree(&ra->z_pure_cmds); /* Free structure itself */ efree(ra); @@ -515,9 +515,8 @@ PHP_METHOD(RedisArray, _function) RETURN_FALSE; } - if(ra->z_fun) { - *return_value = *ra->z_fun; - zval_copy_ctor(return_value); + if(Z_TYPE(ra->z_fun) != IS_UNDEF) { + ZVAL_DUP(return_value, &ra->z_fun); } else { RETURN_NULL(); } @@ -537,9 +536,8 @@ PHP_METHOD(RedisArray, _distributor) RETURN_FALSE; } - if(ra->z_fun) { - *return_value = *ra->z_fun; - zval_copy_ctor(return_value); + if(Z_TYPE(ra->z_fun) != IS_UNDEF) { + ZVAL_DUP(return_value, &ra->z_fun); } else { RETURN_NULL(); } @@ -592,8 +590,7 @@ static void multihost_distribute(INTERNAL_FUNCTION_PARAMETERS, const char *metho ZVAL_UNDEF(&z_tmp); /* Call each node in turn */ - call_user_function(&redis_ce->function_table, ra->redis[i], - &z_fun, &z_tmp, 0, NULL TSRMLS_CC); + call_user_function(&redis_ce->function_table, &ra->redis[i], &z_fun, &z_tmp, 0, NULL TSRMLS_CC); add_assoc_zval(return_value, ra->hosts[i], &z_tmp); } @@ -664,7 +661,7 @@ PHP_METHOD(RedisArray, keys) ZVAL_UNDEF(&z_tmp); /* Call KEYS on each node */ - call_user_function(&redis_ce->function_table, ra->redis[i], &z_fun, &z_tmp, 1, z_args TSRMLS_CC); + call_user_function(&redis_ce->function_table, &ra->redis[i], &z_fun, &z_tmp, 1, z_args TSRMLS_CC); /* Add the result for this host */ add_assoc_zval(return_value, ra->hosts[i], &z_tmp); @@ -702,7 +699,7 @@ PHP_METHOD(RedisArray, getOption) ZVAL_UNDEF(&z_tmp); /* Call each node in turn */ - call_user_function(&redis_ce->function_table, ra->redis[i], + call_user_function(&redis_ce->function_table, &ra->redis[i], &z_fun, &z_tmp, 1, z_args TSRMLS_CC); add_assoc_zval(return_value, ra->hosts[i], &z_tmp); @@ -743,7 +740,7 @@ PHP_METHOD(RedisArray, setOption) ZVAL_UNDEF(&z_tmp); /* Call each node in turn */ - call_user_function(&redis_ce->function_table, ra->redis[i], + call_user_function(&redis_ce->function_table, &ra->redis[i], &z_fun, &z_tmp, 2, z_args TSRMLS_CC); add_assoc_zval(return_value, ra->hosts[i], &z_tmp); @@ -782,7 +779,7 @@ PHP_METHOD(RedisArray, select) ZVAL_UNDEF(&z_tmp); /* Call each node in turn */ - call_user_function(&redis_ce->function_table, ra->redis[i], + call_user_function(&redis_ce->function_table, &ra->redis[i], &z_fun, &z_tmp, 1, z_args TSRMLS_CC); add_assoc_zval(return_value, ra->hosts[i], &z_tmp); @@ -908,7 +905,7 @@ PHP_METHOD(RedisArray, mget) } /* call MGET on the node */ - call_user_function(&redis_ce->function_table, ra->redis[n], + call_user_function(&redis_ce->function_table, &ra->redis[n], &z_fun, &z_ret, 1, &z_argarray TSRMLS_CC); /* cleanup args array */ @@ -1034,7 +1031,7 @@ PHP_METHOD(RedisArray, mset) /* prepare call */ ZVAL_STRING(&z_fun, "MSET"); - redis_inst = ra->redis[n]; + redis_inst = &ra->redis[n]; /* copy args */ array_init(&z_argarray); @@ -1061,7 +1058,7 @@ PHP_METHOD(RedisArray, mset) } /* call */ - call_user_function(&redis_ce->function_table, ra->redis[n], + call_user_function(&redis_ce->function_table, &ra->redis[n], &z_fun, &z_ret, 1, &z_argarray TSRMLS_CC); if(ra->index) { @@ -1166,7 +1163,7 @@ PHP_METHOD(RedisArray, del) for(n = 0; n < ra->count; ++n) { /* for each node */ int found = 0; - redis_inst = ra->redis[n]; + redis_inst = &ra->redis[n]; /* copy args */ array_init(&z_argarray); diff --git a/redis_array.h b/redis_array.h index 199110a4..aebb994e 100644 --- a/redis_array.h +++ b/redis_array.h @@ -43,14 +43,14 @@ typedef struct RedisArray_ { int count; char **hosts; /* array of host:port strings */ - zval **redis; /* array of Redis instances */ + zval *redis; /* array of Redis instances */ zval *z_multi_exec; /* Redis instance to be used in multi-exec */ zend_bool index; /* use per-node index */ zend_bool auto_rehash; /* migrate keys on read operations */ zend_bool pconnect; /* should we use pconnect */ - zval *z_fun; /* key extractor, callable */ - zval *z_dist; /* key distributor, callable */ - zval *z_pure_cmds; /* hash table */ + zval z_fun; /* key extractor, callable */ + zval z_dist; /* key distributor, callable */ + zval z_pure_cmds; /* hash table */ double connect_timeout; /* socket connect timeout */ struct RedisArray_ *prev; diff --git a/redis_array_impl.c b/redis_array_impl.c index c90227a3..51ecc3c5 100644 --- a/redis_array_impl.c +++ b/redis_array_impl.c @@ -32,61 +32,54 @@ extern zend_class_entry *redis_ce; RedisArray* ra_load_hosts(RedisArray *ra, HashTable *hosts, long retry_interval, zend_bool b_lazy_connect TSRMLS_DC) { - int i = 0, host_len, id; + int i = 0, host_len; + zval *id; char *host, *p; short port; - zval **zpData, z_cons, z_ret; + zval *zpData, z_cons, z_ret; RedisSock *redis_sock = NULL; /* function calls on the Redis object */ - ZVAL_STRING(&z_cons, "__construct", 0); + 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 ((zend_hash_get_current_data(hosts, (void **) &zpData) == FAILURE) || (Z_TYPE_PP(zpData) != IS_STRING)) + if ((zpData = zend_hash_get_current_data(hosts)) == NULL || (Z_TYPE_P(zpData) != IS_STRING)) { efree(ra); return NULL; } - ra->hosts[i] = estrdup(Z_STRVAL_PP(zpData)); + ra->hosts[i] = estrdup(Z_STRVAL_P(zpData)); /* default values */ - host = Z_STRVAL_PP(zpData); - host_len = Z_STRLEN_PP(zpData); + host = Z_STRVAL_P(zpData); + host_len = Z_STRLEN_P(zpData); port = 6379; if((p = strchr(host, ':'))) { /* found port */ - host_len = p - host; - port = (short)atoi(p+1); + host_len = p - host; + port = (short)atoi(p+1); } else if(strchr(host,'/') != NULL) { /* unix socket */ - port = -1; - } + port = -1; + } /* create Redis object */ - MAKE_STD_ZVAL(ra->redis[i]); - object_init_ex(ra->redis[i], redis_ce); - INIT_PZVAL(ra->redis[i]); + 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); + if (!b_lazy_connect) { + /* connect */ + redis_sock_server_open(redis_sock, 1 TSRMLS_CC); } /* attach */ -#if PHP_VERSION_ID >= 50400 id = zend_list_insert(redis_sock, le_redis_sock TSRMLS_CC); -#else - id = zend_list_insert(redis_sock, le_redis_sock); -#endif - add_property_resource(ra->redis[i], "socket", id); - + add_property_resource(&ra->redis[i], "socket", Z_RES_P(id)); i++; } @@ -95,43 +88,41 @@ ra_load_hosts(RedisArray *ra, HashTable *hosts, long retry_interval, zend_bool b /* List pure functions */ void ra_init_function_table(RedisArray *ra) { - - MAKE_STD_ZVAL(ra->z_pure_cmds); - array_init(ra->z_pure_cmds); - - add_assoc_bool(ra->z_pure_cmds, "HGET", 1); - add_assoc_bool(ra->z_pure_cmds, "HGETALL", 1); - add_assoc_bool(ra->z_pure_cmds, "HKEYS", 1); - add_assoc_bool(ra->z_pure_cmds, "HLEN", 1); - add_assoc_bool(ra->z_pure_cmds, "SRANDMEMBER", 1); - add_assoc_bool(ra->z_pure_cmds, "HMGET", 1); - add_assoc_bool(ra->z_pure_cmds, "STRLEN", 1); - add_assoc_bool(ra->z_pure_cmds, "SUNION", 1); - add_assoc_bool(ra->z_pure_cmds, "HVALS", 1); - add_assoc_bool(ra->z_pure_cmds, "TYPE", 1); - add_assoc_bool(ra->z_pure_cmds, "EXISTS", 1); - add_assoc_bool(ra->z_pure_cmds, "LINDEX", 1); - add_assoc_bool(ra->z_pure_cmds, "SCARD", 1); - add_assoc_bool(ra->z_pure_cmds, "LLEN", 1); - add_assoc_bool(ra->z_pure_cmds, "SDIFF", 1); - add_assoc_bool(ra->z_pure_cmds, "ZCARD", 1); - add_assoc_bool(ra->z_pure_cmds, "ZCOUNT", 1); - add_assoc_bool(ra->z_pure_cmds, "LRANGE", 1); - add_assoc_bool(ra->z_pure_cmds, "ZRANGE", 1); - add_assoc_bool(ra->z_pure_cmds, "ZRANK", 1); - add_assoc_bool(ra->z_pure_cmds, "GET", 1); - add_assoc_bool(ra->z_pure_cmds, "GETBIT", 1); - add_assoc_bool(ra->z_pure_cmds, "SINTER", 1); - add_assoc_bool(ra->z_pure_cmds, "GETRANGE", 1); - add_assoc_bool(ra->z_pure_cmds, "ZREVRANGE", 1); - add_assoc_bool(ra->z_pure_cmds, "SISMEMBER", 1); - add_assoc_bool(ra->z_pure_cmds, "ZREVRANGEBYSCORE", 1); - add_assoc_bool(ra->z_pure_cmds, "ZREVRANK", 1); - add_assoc_bool(ra->z_pure_cmds, "HEXISTS", 1); - add_assoc_bool(ra->z_pure_cmds, "ZSCORE", 1); - add_assoc_bool(ra->z_pure_cmds, "HGET", 1); - add_assoc_bool(ra->z_pure_cmds, "OBJECT", 1); - add_assoc_bool(ra->z_pure_cmds, "SMEMBERS", 1); + array_init(&ra->z_pure_cmds); + + add_assoc_bool(&ra->z_pure_cmds, "HGET", 1); + add_assoc_bool(&ra->z_pure_cmds, "HGETALL", 1); + add_assoc_bool(&ra->z_pure_cmds, "HKEYS", 1); + add_assoc_bool(&ra->z_pure_cmds, "HLEN", 1); + add_assoc_bool(&ra->z_pure_cmds, "SRANDMEMBER", 1); + add_assoc_bool(&ra->z_pure_cmds, "HMGET", 1); + add_assoc_bool(&ra->z_pure_cmds, "STRLEN", 1); + add_assoc_bool(&ra->z_pure_cmds, "SUNION", 1); + add_assoc_bool(&ra->z_pure_cmds, "HVALS", 1); + add_assoc_bool(&ra->z_pure_cmds, "TYPE", 1); + add_assoc_bool(&ra->z_pure_cmds, "EXISTS", 1); + add_assoc_bool(&ra->z_pure_cmds, "LINDEX", 1); + add_assoc_bool(&ra->z_pure_cmds, "SCARD", 1); + add_assoc_bool(&ra->z_pure_cmds, "LLEN", 1); + add_assoc_bool(&ra->z_pure_cmds, "SDIFF", 1); + add_assoc_bool(&ra->z_pure_cmds, "ZCARD", 1); + add_assoc_bool(&ra->z_pure_cmds, "ZCOUNT", 1); + add_assoc_bool(&ra->z_pure_cmds, "LRANGE", 1); + add_assoc_bool(&ra->z_pure_cmds, "ZRANGE", 1); + add_assoc_bool(&ra->z_pure_cmds, "ZRANK", 1); + add_assoc_bool(&ra->z_pure_cmds, "GET", 1); + add_assoc_bool(&ra->z_pure_cmds, "GETBIT", 1); + add_assoc_bool(&ra->z_pure_cmds, "SINTER", 1); + add_assoc_bool(&ra->z_pure_cmds, "GETRANGE", 1); + add_assoc_bool(&ra->z_pure_cmds, "ZREVRANGE", 1); + add_assoc_bool(&ra->z_pure_cmds, "SISMEMBER", 1); + add_assoc_bool(&ra->z_pure_cmds, "ZREVRANGEBYSCORE", 1); + add_assoc_bool(&ra->z_pure_cmds, "ZREVRANK", 1); + add_assoc_bool(&ra->z_pure_cmds, "HEXISTS", 1); + add_assoc_bool(&ra->z_pure_cmds, "ZSCORE", 1); + add_assoc_bool(&ra->z_pure_cmds, "HGET", 1); + add_assoc_bool(&ra->z_pure_cmds, "OBJECT", 1); + add_assoc_bool(&ra->z_pure_cmds, "SMEMBERS", 1); } static int @@ -162,15 +153,15 @@ ra_find_name(const char *name) { /* laod array from INI settings */ RedisArray *ra_load_array(const char *name TSRMLS_DC) { - zval *z_params_hosts, **z_hosts; - zval *z_params_prev, **z_prev; - zval *z_params_funs, **z_data_pp, *z_fun = NULL, *z_dist = NULL; - zval *z_params_index; - zval *z_params_autorehash; - zval *z_params_retry_interval; - zval *z_params_pconnect; - zval *z_params_connect_timeout; - zval *z_params_lazy_connect; + zval z_params_hosts, *z_hosts; + zval z_params_prev, *z_prev; + zval z_params_funs, *z_data_p, z_fun, z_dist; + zval z_params_index; + zval z_params_autorehash; + zval z_params_retry_interval; + zval z_params_pconnect; + zval z_params_connect_timeout; + zval z_params_lazy_connect; RedisArray *ra = NULL; zend_bool b_index = 0, b_autorehash = 0, b_pconnect = 0; @@ -184,139 +175,125 @@ RedisArray *ra_load_array(const char *name TSRMLS_DC) { return ra; /* find hosts */ - MAKE_STD_ZVAL(z_params_hosts); - array_init(z_params_hosts); - sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.hosts")), z_params_hosts TSRMLS_CC); - if (zend_hash_find(Z_ARRVAL_P(z_params_hosts), name, strlen(name) + 1, (void **) &z_hosts) != FAILURE) { - hHosts = Z_ARRVAL_PP(z_hosts); + array_init(&z_params_hosts); + sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.hosts")), &z_params_hosts TSRMLS_CC); + if ((z_hosts = zend_hash_str_find(Z_ARRVAL(z_params_hosts), name, strlen(name))) != NULL) { + hHosts = Z_ARRVAL_P(z_hosts); } /* find previous hosts */ - MAKE_STD_ZVAL(z_params_prev); - array_init(z_params_prev); - sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.previous")), z_params_prev TSRMLS_CC); - if (zend_hash_find(Z_ARRVAL_P(z_params_prev), name, strlen(name) + 1, (void **) &z_prev) != FAILURE) { - hPrev = Z_ARRVAL_PP(z_prev); + array_init(&z_params_prev); + sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.previous")), &z_params_prev TSRMLS_CC); + if ((z_prev = zend_hash_str_find(Z_ARRVAL(z_params_prev), name, strlen(name))) != NULL) { + hPrev = Z_ARRVAL_P(z_prev); } /* find function */ - MAKE_STD_ZVAL(z_params_funs); - array_init(z_params_funs); - sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.functions")), z_params_funs TSRMLS_CC); - if (zend_hash_find(Z_ARRVAL_P(z_params_funs), name, strlen(name) + 1, (void **) &z_data_pp) != FAILURE) { - MAKE_STD_ZVAL(z_fun); - *z_fun = **z_data_pp; - zval_copy_ctor(z_fun); + array_init(&z_params_funs); + sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.functions")), &z_params_funs TSRMLS_CC); + if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_funs), name, strlen(name))) != NULL) { + ZVAL_DUP(&z_fun, z_data_p); } /* find distributor */ - MAKE_STD_ZVAL(z_params_funs); - array_init(z_params_funs); - sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.distributor")), z_params_funs TSRMLS_CC); - if (zend_hash_find(Z_ARRVAL_P(z_params_funs), name, strlen(name) + 1, (void **) &z_data_pp) != FAILURE) { - MAKE_STD_ZVAL(z_dist); - *z_dist = **z_data_pp; - zval_copy_ctor(z_dist); + array_init(&z_params_funs); + sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.distributor")), &z_params_funs TSRMLS_CC); + if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_funs), name, strlen(name))) != NULL) { + ZVAL_DUP(&z_dist, z_data_p); } /* find index option */ - MAKE_STD_ZVAL(z_params_index); - array_init(z_params_index); - sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.index")), z_params_index TSRMLS_CC); - if (zend_hash_find(Z_ARRVAL_P(z_params_index), name, strlen(name) + 1, (void **) &z_data_pp) != FAILURE) { - if(Z_TYPE_PP(z_data_pp) == IS_STRING && strncmp(Z_STRVAL_PP(z_data_pp), "1", 1) == 0) { + array_init(&z_params_index); + sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.index")), &z_params_index TSRMLS_CC); + if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_index), name, strlen(name))) != NULL) { + if(Z_TYPE_P(z_data_p) == IS_STRING && strncmp(Z_STRVAL_P(z_data_p), "1", 1) == 0) { b_index = 1; } } /* find autorehash option */ - MAKE_STD_ZVAL(z_params_autorehash); - array_init(z_params_autorehash); - sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.autorehash")), z_params_autorehash TSRMLS_CC); - if (zend_hash_find(Z_ARRVAL_P(z_params_autorehash), name, strlen(name) + 1, (void **) &z_data_pp) != FAILURE) { - if(Z_TYPE_PP(z_data_pp) == IS_STRING && strncmp(Z_STRVAL_PP(z_data_pp), "1", 1) == 0) { + array_init(&z_params_autorehash); + sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.autorehash")), &z_params_autorehash TSRMLS_CC); + if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_autorehash), name, strlen(name))) != NULL) { + if(Z_TYPE_P(z_data_p) == IS_STRING && strncmp(Z_STRVAL_P(z_data_p), "1", 1) == 0) { b_autorehash = 1; } } /* find retry interval option */ - MAKE_STD_ZVAL(z_params_retry_interval); - array_init(z_params_retry_interval); - sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.retryinterval")), z_params_retry_interval TSRMLS_CC); - if (zend_hash_find(Z_ARRVAL_P(z_params_retry_interval), name, strlen(name) + 1, (void **) &z_data_pp) != FAILURE) { - if (Z_TYPE_PP(z_data_pp) == IS_LONG || Z_TYPE_PP(z_data_pp) == IS_STRING) { - if (Z_TYPE_PP(z_data_pp) == IS_LONG) { - l_retry_interval = Z_LVAL_PP(z_data_pp); + array_init(&z_params_retry_interval); + sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.retryinterval")), &z_params_retry_interval TSRMLS_CC); + if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_retry_interval), name, strlen(name))) != NULL) { + if (Z_TYPE_P(z_data_p) == IS_LONG || Z_TYPE_P(z_data_p) == IS_STRING) { + if (Z_TYPE_P(z_data_p) == IS_LONG) { + l_retry_interval = Z_LVAL_P(z_data_p); } else { - l_retry_interval = atol(Z_STRVAL_PP(z_data_pp)); + l_retry_interval = atol(Z_STRVAL_P(z_data_p)); } } } /* find pconnect option */ - MAKE_STD_ZVAL(z_params_pconnect); - array_init(z_params_pconnect); - sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.pconnect")), z_params_pconnect TSRMLS_CC); - if (zend_hash_find(Z_ARRVAL_P(z_params_pconnect), name, strlen(name) + 1, (void**) &z_data_pp) != FAILURE) { - if(Z_TYPE_PP(z_data_pp) == IS_STRING && strncmp(Z_STRVAL_PP(z_data_pp), "1", 1) == 0) { + array_init(&z_params_pconnect); + sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.pconnect")), &z_params_pconnect TSRMLS_CC); + if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_pconnect), name, strlen(name))) != NULL) { + if(Z_TYPE_P(z_data_p) == IS_STRING && strncmp(Z_STRVAL_P(z_data_p), "1", 1) == 0) { b_pconnect = 1; } } - + /* find lazy connect option */ - MAKE_STD_ZVAL(z_params_lazy_connect); - array_init(z_params_lazy_connect); - sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.lazyconnect")), z_params_lazy_connect TSRMLS_CC); - if (zend_hash_find(Z_ARRVAL_P(z_params_lazy_connect), name, strlen(name) + 1, (void **) &z_data_pp) != FAILURE) { - if(Z_TYPE_PP(z_data_pp) == IS_STRING && strncmp(Z_STRVAL_PP(z_data_pp), "1", 1) == 0) { + array_init(&z_params_lazy_connect); + sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.lazyconnect")), &z_params_lazy_connect TSRMLS_CC); + if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_lazy_connect), name, strlen(name))) != NULL) { + if(Z_TYPE_P(z_data_p) == IS_STRING && strncmp(Z_STRVAL_P(z_data_p), "1", 1) == 0) { b_lazy_connect = 1; } } - + /* find connect timeout option */ - MAKE_STD_ZVAL(z_params_connect_timeout); - array_init(z_params_connect_timeout); - sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.connecttimeout")), z_params_connect_timeout TSRMLS_CC); - if (zend_hash_find(Z_ARRVAL_P(z_params_connect_timeout), name, strlen(name) + 1, (void **) &z_data_pp) != FAILURE) { - if (Z_TYPE_PP(z_data_pp) == IS_DOUBLE || - Z_TYPE_PP(z_data_pp) == IS_STRING || - Z_TYPE_PP(z_data_pp) == IS_LONG) - { - if (Z_TYPE_PP(z_data_pp) == IS_DOUBLE) { - d_connect_timeout = Z_DVAL_PP(z_data_pp); - } else if (Z_TYPE_PP(z_data_pp) == IS_LONG) { - d_connect_timeout = Z_LVAL_PP(z_data_pp); - } else { - d_connect_timeout = atof(Z_STRVAL_PP(z_data_pp)); - } + array_init(&z_params_connect_timeout); + sapi_module.treat_data(PARSE_STRING, estrdup(INI_STR("redis.arrays.connecttimeout")), &z_params_connect_timeout TSRMLS_CC); + if ((z_data_p = zend_hash_str_find(Z_ARRVAL(z_params_connect_timeout), name, strlen(name))) != NULL) { + if (Z_TYPE_P(z_data_p) == IS_DOUBLE || + Z_TYPE_P(z_data_p) == IS_STRING || + Z_TYPE_P(z_data_p) == IS_LONG) + { + if (Z_TYPE_P(z_data_p) == IS_DOUBLE) { + d_connect_timeout = Z_DVAL_P(z_data_p); + } else if (Z_TYPE_P(z_data_p) == IS_LONG) { + d_connect_timeout = Z_LVAL_P(z_data_p); + } else { + d_connect_timeout = atof(Z_STRVAL_P(z_data_p)); } + } } - + /* create RedisArray object */ - ra = ra_make_array(hHosts, z_fun, z_dist, hPrev, b_index, b_pconnect, l_retry_interval, b_lazy_connect, d_connect_timeout TSRMLS_CC); + ra = ra_make_array(hHosts, &z_fun, &z_dist, hPrev, b_index, b_pconnect, l_retry_interval, b_lazy_connect, d_connect_timeout TSRMLS_CC); ra->auto_rehash = b_autorehash; if(ra->prev) ra->prev->auto_rehash = b_autorehash; /* cleanup */ - zval_dtor(z_params_hosts); - efree(z_params_hosts); - zval_dtor(z_params_prev); - efree(z_params_prev); - zval_dtor(z_params_funs); - efree(z_params_funs); - zval_dtor(z_params_index); - efree(z_params_index); - zval_dtor(z_params_autorehash); - efree(z_params_autorehash); - zval_dtor(z_params_retry_interval); - efree(z_params_retry_interval); - zval_dtor(z_params_pconnect); - efree(z_params_pconnect); - zval_dtor(z_params_connect_timeout); - efree(z_params_connect_timeout); - zval_dtor(z_params_lazy_connect); - efree(z_params_lazy_connect); + zval_dtor(&z_params_hosts); + efree(&z_params_hosts); + zval_dtor(&z_params_prev); + efree(&z_params_prev); + zval_dtor(&z_params_funs); + efree(&z_params_funs); + zval_dtor(&z_params_index); + efree(&z_params_index); + zval_dtor(&z_params_autorehash); + efree(&z_params_autorehash); + zval_dtor(&z_params_retry_interval); + efree(&z_params_retry_interval); + zval_dtor(&z_params_pconnect); + efree(&z_params_pconnect); + zval_dtor(&z_params_connect_timeout); + efree(&z_params_connect_timeout); + zval_dtor(&z_params_lazy_connect); + efree(&z_params_lazy_connect); return ra; } @@ -329,11 +306,8 @@ ra_make_array(HashTable *hosts, zval *z_fun, zval *z_dist, HashTable *hosts_prev /* create object */ RedisArray *ra = emalloc(sizeof(RedisArray)); ra->hosts = emalloc(count * sizeof(char*)); - ra->redis = emalloc(count * sizeof(zval*)); + ra->redis = ecalloc(count, sizeof(zval)); ra->count = count; - ra->z_fun = NULL; - ra->z_dist = NULL; - ra->z_multi_exec = NULL; ra->index = b_index; ra->auto_rehash = 0; ra->pconnect = b_pconnect; @@ -348,9 +322,14 @@ ra_make_array(HashTable *hosts, zval *z_fun, zval *z_dist, HashTable *hosts_prev ra->prev = hosts_prev ? ra_make_array(hosts_prev, z_fun, z_dist, NULL, b_index, b_pconnect, retry_interval, b_lazy_connect, connect_timeout TSRMLS_CC) : NULL; /* Set hash function and distribtor if provided */ - ra->z_fun = z_fun; - ra->z_dist = z_dist; - + if (z_fun != NULL) { + ZVAL_DUP(&ra->z_fun, z_fun); + } + if (z_dist != NULL) { + ZVAL_DUP(&ra->z_dist, z_dist); + + } + return ra; } @@ -361,20 +340,19 @@ ra_call_extractor(RedisArray *ra, const char *key, int key_len, int *out_len TSR char *out; zval z_ret; - zval *z_argv0; + zval z_argv0; /* check that we can call the extractor function */ - if(!zend_is_callable_ex(ra->z_fun, NULL, 0, NULL, NULL, NULL, NULL TSRMLS_CC)) { + if(!zend_is_callable_ex(&ra->z_fun, NULL, 0, NULL, NULL, NULL)) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "Could not call extractor function"); return NULL; } /* convert_to_string(ra->z_fun); */ /* call extraction function */ - MAKE_STD_ZVAL(z_argv0); - ZVAL_STRINGL(z_argv0, key, key_len, 0); - call_user_function(EG(function_table), NULL, ra->z_fun, &z_ret, 1, &z_argv0 TSRMLS_CC); - efree(z_argv0); + ZVAL_STRINGL(&z_argv0, key, key_len); + call_user_function(EG(function_table), NULL, &ra->z_fun, &z_ret, 1, &z_argv0 TSRMLS_CC); + efree(&z_argv0); if(Z_TYPE(z_ret) != IS_STRING) { zval_dtor(&z_ret); @@ -396,7 +374,7 @@ ra_extract_key(RedisArray *ra, const char *key, int key_len, int *out_len TSRMLS char *start, *end, *out; *out_len = key_len; - if(ra->z_fun) + if(Z_TYPE(ra->z_fun) != IS_UNDEF) return ra_call_extractor(ra, key, key_len, out_len TSRMLS_CC); /* look for '{' */ @@ -421,20 +399,19 @@ zend_bool ra_call_distributor(RedisArray *ra, const char *key, int key_len, int *pos TSRMLS_DC) { zval z_ret; - zval *z_argv0; + zval z_argv0; /* check that we can call the extractor function */ - if(!zend_is_callable_ex(ra->z_dist, NULL, 0, NULL, NULL, NULL, NULL TSRMLS_CC)) { + if(!zend_is_callable_ex(&ra->z_dist, NULL, 0, NULL, NULL, NULL)) { php_error_docref(NULL TSRMLS_CC, E_ERROR, "Could not call distributor function"); return 0; } /* convert_to_string(ra->z_fun); */ /* call extraction function */ - MAKE_STD_ZVAL(z_argv0); - ZVAL_STRINGL(z_argv0, key, key_len, 0); - call_user_function(EG(function_table), NULL, ra->z_dist, &z_ret, 1, &z_argv0 TSRMLS_CC); - efree(z_argv0); + ZVAL_STRINGL(&z_argv0, key, key_len); + call_user_function(EG(function_table), NULL, &ra->z_dist, &z_ret, 1, &z_argv0 TSRMLS_CC); + efree(&z_argv0); if(Z_TYPE(z_ret) != IS_LONG) { zval_dtor(&z_ret); @@ -456,7 +433,7 @@ ra_find_node(RedisArray *ra, const char *key, int key_len, int *out_pos TSRMLS_D out = ra_extract_key(ra, key, key_len, &out_len TSRMLS_CC); if(!out) return NULL; - if(ra->z_dist) { + if(Z_TYPE(ra->z_dist) != IS_UNDEF) { if (!ra_call_distributor(ra, key, key_len, &pos TSRMLS_CC)) { efree(out); return NULL; @@ -468,7 +445,7 @@ ra_find_node(RedisArray *ra, const char *key, int key_len, int *out_pos TSRMLS_D /* hash */ hash = rcrc32(out, out_len); efree(out); - + /* get position on ring */ h64 = hash; h64 *= ra->count; @@ -477,7 +454,7 @@ ra_find_node(RedisArray *ra, const char *key, int key_len, int *out_pos TSRMLS_D } if(out_pos) *out_pos = pos; - return ra->redis[pos]; + return &ra->redis[pos]; } zval * @@ -486,7 +463,7 @@ ra_find_node_by_name(RedisArray *ra, const char *host, int host_len TSRMLS_DC) { int i; for(i = 0; i < ra->count; ++i) { if(strncmp(ra->hosts[i], host, host_len) == 0) { - return ra->redis[i]; + return &ra->redis[i]; } } return NULL; @@ -496,32 +473,31 @@ ra_find_node_by_name(RedisArray *ra, const char *host, int host_len TSRMLS_DC) { char * ra_find_key(RedisArray *ra, zval *z_args, const char *cmd, int *key_len) { - zval **zp_tmp; + zval *zp_tmp; int key_pos = 0; /* TODO: change this depending on the command */ - if( zend_hash_num_elements(Z_ARRVAL_P(z_args)) == 0 - || zend_hash_index_find(Z_ARRVAL_P(z_args), key_pos, (void**) &zp_tmp) == FAILURE - || Z_TYPE_PP(zp_tmp) != IS_STRING) { + if( zend_hash_num_elements(Z_ARRVAL_P(z_args)) == 0 || + (zp_tmp = zend_hash_index_find(Z_ARRVAL_P(z_args), key_pos)) == NULL || + Z_TYPE_P(zp_tmp) != IS_STRING) { - return NULL; + return NULL; } - *key_len = Z_STRLEN_PP(zp_tmp); - return Z_STRVAL_PP(zp_tmp); + *key_len = Z_STRLEN_P(zp_tmp); + return Z_STRVAL_P(zp_tmp); } void ra_index_multi(zval *z_redis, long multi_value TSRMLS_DC) { zval z_fun_multi, z_ret; - zval *z_args[1]; + zval z_args[1]; /* run MULTI */ - ZVAL_STRING(&z_fun_multi, "MULTI", 0); - MAKE_STD_ZVAL(z_args[0]); - ZVAL_LONG(z_args[0], multi_value); - call_user_function(&redis_ce->function_table, &z_redis, &z_fun_multi, &z_ret, 1, z_args TSRMLS_CC); - efree(z_args[0]); + ZVAL_STRING(&z_fun_multi, "MULTI"); + ZVAL_LONG(&z_args[0], multi_value); + call_user_function(&redis_ce->function_table, z_redis, &z_fun_multi, &z_ret, 1, z_args TSRMLS_CC); + efree(&z_args[0]); /* zval_dtor(&z_ret); */ } @@ -529,29 +505,28 @@ static void ra_index_change_keys(const char *cmd, zval *z_keys, zval *z_redis TSRMLS_DC) { int i, argc; - zval z_fun, z_ret, **z_args; + zval z_fun, z_ret; /* alloc */ argc = 1 + zend_hash_num_elements(Z_ARRVAL_P(z_keys)); - z_args = emalloc(argc * sizeof(zval*)); + zval z_args[argc]; /* prepare first parameters */ - ZVAL_STRING(&z_fun, cmd, 0); - MAKE_STD_ZVAL(z_args[0]); - ZVAL_STRING(z_args[0], PHPREDIS_INDEX_NAME, 0); + ZVAL_STRING(&z_fun, cmd); + ZVAL_STRING(&z_args[0], PHPREDIS_INDEX_NAME); /* prepare keys */ for(i = 0; i < argc - 1; ++i) { - zval **zpp; - zend_hash_index_find(Z_ARRVAL_P(z_keys), i, (void**)&zpp); - z_args[i+1] = *zpp; + zval *zp; + zp = zend_hash_index_find(Z_ARRVAL_P(z_keys), i); + ZVAL_DUP(&z_args[i+1], zp); } /* run cmd */ - call_user_function(&redis_ce->function_table, &z_redis, &z_fun, &z_ret, argc, z_args TSRMLS_CC); + call_user_function(&redis_ce->function_table, z_redis, &z_fun, &z_ret, argc, z_args TSRMLS_CC); /* don't dtor z_ret, since we're returning z_redis */ - efree(z_args[0]); /* free index name zval */ + efree(&z_args[0]); /* free index name zval */ efree(z_args); /* free container */ } @@ -564,88 +539,77 @@ void ra_index_keys(zval *z_pairs, zval *z_redis TSRMLS_DC) { /* Initialize key array */ - zval *z_keys, **z_entry_pp; - MAKE_STD_ZVAL(z_keys); - HashPosition pos; -#if PHP_VERSION_ID > 50300 - array_init_size(z_keys, zend_hash_num_elements(Z_ARRVAL_P(z_pairs))); -#else - array_init(z_keys); -#endif + zval z_keys, *z_entry_p; + HashPosition pos; + array_init_size(&z_keys, zend_hash_num_elements(Z_ARRVAL_P(z_pairs))); /* Go through input array and add values to the key array */ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(z_pairs), &pos); - while (zend_hash_get_current_data_ex(Z_ARRVAL_P(z_pairs), (void **)&z_entry_pp, &pos) == SUCCESS) { - char *key; - unsigned int key_len; + while ((z_entry_p = zend_hash_get_current_data_ex(Z_ARRVAL_P(z_pairs), &pos)) != NULL) { + zend_string *key; unsigned long num_key; - zval *z_new; - MAKE_STD_ZVAL(z_new); + zval z_new; - switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(z_pairs), &key, &key_len, &num_key, 1, &pos)) { + switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(z_pairs), &key, &num_key, &pos)) { case HASH_KEY_IS_STRING: - ZVAL_STRINGL(z_new, key, (int)key_len - 1, 0); - zend_hash_next_index_insert(Z_ARRVAL_P(z_keys), &z_new, sizeof(zval *), NULL); + ZVAL_STRINGL(&z_new, key->val, key->len); + zend_hash_next_index_insert(Z_ARRVAL(z_keys), &z_new); break; case HASH_KEY_IS_LONG: - Z_TYPE_P(z_new) = IS_LONG; - Z_LVAL_P(z_new) = (long)num_key; - zend_hash_next_index_insert(Z_ARRVAL_P(z_keys), &z_new, sizeof(zval *), NULL); + ZVAL_LONG(&z_new, num_key); + zend_hash_next_index_insert(Z_ARRVAL(z_keys), &z_new); break; } zend_hash_move_forward_ex(Z_ARRVAL_P(z_pairs), &pos); } /* add keys to index */ - ra_index_change_keys("SADD", z_keys, z_redis TSRMLS_CC); + ra_index_change_keys("SADD", &z_keys, z_redis TSRMLS_CC); /* cleanup */ - zval_dtor(z_keys); - efree(z_keys); + zval_dtor(&z_keys); + efree(&z_keys); } void ra_index_key(const char *key, int key_len, zval *z_redis TSRMLS_DC) { - zval z_fun_sadd, z_ret, *z_args[2]; - MAKE_STD_ZVAL(z_args[0]); - MAKE_STD_ZVAL(z_args[1]); + zval z_fun_sadd, z_ret, z_args[2]; /* prepare args */ - ZVAL_STRINGL(&z_fun_sadd, "SADD", 4, 0); + ZVAL_STRINGL(&z_fun_sadd, "SADD", 4); - ZVAL_STRING(z_args[0], PHPREDIS_INDEX_NAME, 0); - ZVAL_STRINGL(z_args[1], key, key_len, 1); + ZVAL_STRING(&z_args[0], PHPREDIS_INDEX_NAME); + ZVAL_STRINGL(&z_args[1], key, key_len); /* run SADD */ - call_user_function(&redis_ce->function_table, &z_redis, &z_fun_sadd, &z_ret, 2, z_args TSRMLS_CC); + call_user_function(&redis_ce->function_table, z_redis, &z_fun_sadd, &z_ret, 2, z_args TSRMLS_CC); /* don't dtor z_ret, since we're returning z_redis */ - efree(z_args[0]); - zval_dtor(z_args[1]); - efree(z_args[1]); + efree(&z_args[0]); + zval_dtor(&z_args[1]); + efree(&z_args[1]); } void ra_index_exec(zval *z_redis, zval *return_value, int keep_all TSRMLS_DC) { - zval z_fun_exec, z_ret, **zp_tmp; + zval z_fun_exec, z_ret, *zp_tmp; /* run EXEC */ - ZVAL_STRING(&z_fun_exec, "EXEC", 0); - call_user_function(&redis_ce->function_table, &z_redis, &z_fun_exec, &z_ret, 0, NULL TSRMLS_CC); + ZVAL_STRING(&z_fun_exec, "EXEC"); + call_user_function(&redis_ce->function_table, z_redis, &z_fun_exec, &z_ret, 0, NULL TSRMLS_CC); /* extract first element of exec array and put into return_value. */ if(Z_TYPE(z_ret) == IS_ARRAY) { if(return_value) { if(keep_all) { - *return_value = z_ret; - zval_copy_ctor(return_value); - } else if(zend_hash_index_find(Z_ARRVAL(z_ret), 0, (void**)&zp_tmp) != FAILURE) { - *return_value = **zp_tmp; - zval_copy_ctor(return_value); + ZVAL_DUP(return_value, &z_ret); + } else if((zp_tmp = zend_hash_index_find(Z_ARRVAL(z_ret), 0)) != NULL) { + ZVAL_DUP(return_value, zp_tmp); + } } zval_dtor(&z_ret); @@ -661,8 +625,8 @@ ra_index_discard(zval *z_redis, zval *return_value TSRMLS_DC) { zval z_fun_discard, z_ret; /* run DISCARD */ - ZVAL_STRING(&z_fun_discard, "DISCARD", 0); - call_user_function(&redis_ce->function_table, &z_redis, &z_fun_discard, &z_ret, 0, NULL TSRMLS_CC); + ZVAL_STRING(&z_fun_discard, "DISCARD"); + call_user_function(&redis_ce->function_table, z_redis, &z_fun_discard, &z_ret, 0, NULL TSRMLS_CC); zval_dtor(&z_ret); } @@ -673,8 +637,8 @@ ra_index_unwatch(zval *z_redis, zval *return_value TSRMLS_DC) { zval z_fun_unwatch, z_ret; /* run UNWATCH */ - ZVAL_STRING(&z_fun_unwatch, "UNWATCH", 0); - call_user_function(&redis_ce->function_table, &z_redis, &z_fun_unwatch, &z_ret, 0, NULL TSRMLS_CC); + ZVAL_STRING(&z_fun_unwatch, "UNWATCH"); + call_user_function(&redis_ce->function_table, z_redis, &z_fun_unwatch, &z_ret, 0, NULL TSRMLS_CC); zval_dtor(&z_ret); } @@ -690,7 +654,7 @@ ra_is_write_cmd(RedisArray *ra, const char *cmd, int cmd_len) { cmd_up[i] = toupper(cmd[i]); cmd_up[cmd_len] = 0; - ret = zend_hash_exists(Z_ARRVAL_P(ra->z_pure_cmds), cmd_up, cmd_len+1); + ret = zend_hash_str_exists(Z_ARRVAL(ra->z_pure_cmds), cmd_up, cmd_len+1); efree(cmd_up); return !ret; @@ -701,20 +665,19 @@ static long ra_rehash_scan(zval *z_redis, char ***keys, int **key_lens, const char *cmd, const char *arg TSRMLS_DC) { long count, i; - zval z_fun_smembers, z_ret, *z_arg, **z_data_pp; + zval z_fun_smembers, z_ret, z_arg, *z_data_p; HashTable *h_keys; HashPosition pointer; char *key; int key_len; /* arg */ - MAKE_STD_ZVAL(z_arg); - ZVAL_STRING(z_arg, arg, 0); + ZVAL_STRING(&z_arg, arg); /* run SMEMBERS */ - ZVAL_STRING(&z_fun_smembers, cmd, 0); - call_user_function(&redis_ce->function_table, &z_redis, &z_fun_smembers, &z_ret, 1, &z_arg TSRMLS_CC); - efree(z_arg); + ZVAL_STRING(&z_fun_smembers, cmd); + call_user_function(&redis_ce->function_table, z_redis, &z_fun_smembers, &z_ret, 1, &z_arg TSRMLS_CC); + efree(&z_arg); if(Z_TYPE(z_ret) != IS_ARRAY) { /* failure */ return -1; /* TODO: log error. */ } @@ -726,11 +689,11 @@ ra_rehash_scan(zval *z_redis, char ***keys, int **key_lens, const char *cmd, con *key_lens = emalloc(count * sizeof(int)); for (i = 0, zend_hash_internal_pointer_reset_ex(h_keys, &pointer); - zend_hash_get_current_data_ex(h_keys, (void**) &z_data_pp, &pointer) == SUCCESS; + (z_data_p = zend_hash_get_current_data_ex(h_keys, &pointer)) != NULL; zend_hash_move_forward_ex(h_keys, &pointer), ++i) { - key = Z_STRVAL_PP(z_data_pp); - key_len = Z_STRLEN_PP(z_data_pp); + key = Z_STRVAL_P(z_data_p); + key_len = Z_STRLEN_P(z_data_p); /* copy key and length */ (*keys)[i] = emalloc(1 + key_len); @@ -761,27 +724,26 @@ static zend_bool ra_get_key_type(zval *z_redis, const char *key, int key_len, zval *z_from, long *res TSRMLS_DC) { int i; - zval z_fun_type, z_ret, *z_arg; - zval **z_data; + zval z_fun_type, z_ret, z_arg; + zval *z_data; long success = 1; - MAKE_STD_ZVAL(z_arg); /* Pipelined */ ra_index_multi(z_from, PIPELINE TSRMLS_CC); /* prepare args */ - ZVAL_STRINGL(&z_fun_type, "TYPE", 4, 0); - ZVAL_STRINGL(z_arg, key, key_len, 0); + ZVAL_STRINGL(&z_fun_type, "TYPE", 4); + ZVAL_STRINGL(&z_arg, key, key_len); /* run TYPE */ - call_user_function(&redis_ce->function_table, &z_redis, &z_fun_type, &z_ret, 1, &z_arg TSRMLS_CC); + call_user_function(&redis_ce->function_table, z_redis, &z_fun_type, &z_ret, 1, &z_arg TSRMLS_CC); - ZVAL_STRINGL(&z_fun_type, "TTL", 3, 0); - ZVAL_STRINGL(z_arg, key, key_len, 0); + ZVAL_STRINGL(&z_fun_type, "TTL", 3); + ZVAL_STRINGL(&z_arg, key, key_len); /* run TYPE */ - call_user_function(&redis_ce->function_table, &z_redis, &z_fun_type, &z_ret, 1, &z_arg TSRMLS_CC); + call_user_function(&redis_ce->function_table, z_redis, &z_fun_type, &z_ret, 1, &z_arg TSRMLS_CC); /* cleanup */ - efree(z_arg); + efree(&z_arg); /* Get the result from the pipeline. */ ra_index_exec(z_from, &z_ret, 1 TSRMLS_CC); @@ -791,16 +753,16 @@ ra_get_key_type(zval *z_redis, const char *key, int key_len, zval *z_from, long zend_hash_has_more_elements(retHash) == SUCCESS; zend_hash_move_forward(retHash)) { - if(zend_hash_get_current_data(retHash, (void**)&z_data) == FAILURE) { + if((z_data = zend_hash_get_current_data(retHash)) == NULL) { success = 0; break; } - if(Z_TYPE_PP(z_data) != IS_LONG) { + if(Z_TYPE_P(z_data) != IS_LONG) { success = 0; break; } /* Get the result - Might change in the future to handle doubles as well */ - res[i] = Z_LVAL_PP(z_data); + res[i] = Z_LVAL_P(z_data); i++; } } @@ -812,20 +774,18 @@ ra_get_key_type(zval *z_redis, const char *key, int key_len, zval *z_from, long static void ra_remove_from_index(zval *z_redis, const char *key, int key_len TSRMLS_DC) { - zval z_fun_srem, z_ret, *z_args[2]; + zval z_fun_srem, z_ret, z_args[2]; /* run SREM on source index */ - ZVAL_STRINGL(&z_fun_srem, "SREM", 4, 0); - MAKE_STD_ZVAL(z_args[0]); - ZVAL_STRING(z_args[0], PHPREDIS_INDEX_NAME, 0); - MAKE_STD_ZVAL(z_args[1]); - ZVAL_STRINGL(z_args[1], key, key_len, 0); + ZVAL_STRINGL(&z_fun_srem, "SREM", 4); + ZVAL_STRING(&z_args[0], PHPREDIS_INDEX_NAME); + ZVAL_STRINGL(&z_args[1], key, key_len); - call_user_function(&redis_ce->function_table, &z_redis, &z_fun_srem, &z_ret, 2, z_args TSRMLS_CC); + call_user_function(&redis_ce->function_table, z_redis, &z_fun_srem, &z_ret, 2, z_args TSRMLS_CC); /* cleanup */ - efree(z_args[0]); - efree(z_args[1]); + efree(&z_args[0]); + efree(&z_args[1]); } @@ -833,17 +793,16 @@ ra_remove_from_index(zval *z_redis, const char *key, int key_len TSRMLS_DC) { static zend_bool ra_del_key(const char *key, int key_len, zval *z_from TSRMLS_DC) { - zval z_fun_del, z_ret, *z_args; + zval z_fun_del, z_ret, z_args; /* in a transaction */ ra_index_multi(z_from, MULTI TSRMLS_CC); /* run DEL on source */ - MAKE_STD_ZVAL(z_args); - ZVAL_STRINGL(&z_fun_del, "DEL", 3, 0); - ZVAL_STRINGL(z_args, key, key_len, 0); - call_user_function(&redis_ce->function_table, &z_from, &z_fun_del, &z_ret, 1, &z_args TSRMLS_CC); - efree(z_args); + ZVAL_STRINGL(&z_fun_del, "DEL", 3); + ZVAL_STRINGL(&z_args, key, key_len); + call_user_function(&redis_ce->function_table, z_from, &z_fun_del, &z_ret, 1, &z_args TSRMLS_CC); + efree(&z_args); /* remove key from index */ ra_remove_from_index(z_from, key, key_len TSRMLS_CC); @@ -857,20 +816,18 @@ ra_del_key(const char *key, int key_len, zval *z_from TSRMLS_DC) { static zend_bool ra_expire_key(const char *key, int key_len, zval *z_to, long ttl TSRMLS_DC) { - zval z_fun_expire, z_ret, *z_args[2]; + zval z_fun_expire, z_ret, z_args[2]; if (ttl > 0) { /* run EXPIRE on target */ - MAKE_STD_ZVAL(z_args[0]); - MAKE_STD_ZVAL(z_args[1]); - ZVAL_STRINGL(&z_fun_expire, "EXPIRE", 6, 0); - ZVAL_STRINGL(z_args[0], key, key_len, 0); - ZVAL_LONG(z_args[1], ttl); - call_user_function(&redis_ce->function_table, &z_to, &z_fun_expire, &z_ret, 2, z_args TSRMLS_CC); + ZVAL_STRINGL(&z_fun_expire, "EXPIRE", 6); + ZVAL_STRINGL(&z_args[0], key, key_len); + ZVAL_LONG(&z_args[1], ttl); + call_user_function(&redis_ce->function_table, z_to, &z_fun_expire, &z_ret, 2, z_args TSRMLS_CC); /* cleanup */ - efree(z_args[0]); - efree(z_args[1]); + efree(&z_args[0]); + efree(&z_args[1]); } return 1; @@ -879,28 +836,24 @@ ra_expire_key(const char *key, int key_len, zval *z_to, long ttl TSRMLS_DC) { static zend_bool ra_move_zset(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TSRMLS_DC) { - zval z_fun_zrange, z_fun_zadd, z_ret, z_ret_dest, *z_args[4], **z_zadd_args, **z_score_pp; + zval z_fun_zrange, z_fun_zadd, z_ret, z_ret_dest, z_args[4], *z_score_p; int count; HashTable *h_zset_vals; - char *val; - unsigned int val_len; + zend_string *val; int i; unsigned long idx; /* run ZRANGE key 0 -1 WITHSCORES on source */ - ZVAL_STRINGL(&z_fun_zrange, "ZRANGE", 6, 0); - for(i = 0; i < 4; ++i) { - MAKE_STD_ZVAL(z_args[i]); - } - ZVAL_STRINGL(z_args[0], key, key_len, 0); - ZVAL_STRINGL(z_args[1], "0", 1, 0); - ZVAL_STRINGL(z_args[2], "-1", 2, 0); - ZVAL_BOOL(z_args[3], 1); - call_user_function(&redis_ce->function_table, &z_from, &z_fun_zrange, &z_ret, 4, z_args TSRMLS_CC); + ZVAL_STRINGL(&z_fun_zrange, "ZRANGE", 6); + ZVAL_STRINGL(&z_args[0], key, key_len); + ZVAL_STRINGL(&z_args[1], "0", 1); + ZVAL_STRINGL(&z_args[2], "-1", 2); + ZVAL_BOOL(&z_args[3], 1); + call_user_function(&redis_ce->function_table, z_from, &z_fun_zrange, &z_ret, 4, z_args TSRMLS_CC); /* cleanup zrange args */ for(i = 0; i < 4; ++i) { - efree(z_args[i]); /* FIXME */ + zval_dtor(&z_args[i]); /* FIXME */ } if(Z_TYPE(z_ret) != IS_ARRAY) { /* key not found or replaced */ @@ -913,29 +866,27 @@ ra_move_zset(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TS /* allocate argument array for ZADD */ count = zend_hash_num_elements(h_zset_vals); - z_zadd_args = emalloc((1 + 2*count) * sizeof(zval*)); + zval z_zadd_args[ (1 + 2*count) ]; for(i = 1, zend_hash_internal_pointer_reset(h_zset_vals); zend_hash_has_more_elements(h_zset_vals) == SUCCESS; zend_hash_move_forward(h_zset_vals)) { - if(zend_hash_get_current_data(h_zset_vals, (void**)&z_score_pp) == FAILURE) { + if((z_score_p = zend_hash_get_current_data(h_zset_vals)) == NULL) { continue; } /* add score */ - convert_to_double(*z_score_pp); - MAKE_STD_ZVAL(z_zadd_args[i]); - ZVAL_DOUBLE(z_zadd_args[i], Z_DVAL_PP(z_score_pp)); + convert_to_double(z_score_p); + ZVAL_DOUBLE(&z_zadd_args[i], Z_DVAL_P(z_score_p)); /* add value */ - MAKE_STD_ZVAL(z_zadd_args[i+1]); - switch (zend_hash_get_current_key_ex(h_zset_vals, &val, &val_len, &idx, 0, NULL)) { + switch (zend_hash_get_current_key_ex(h_zset_vals, &val, &idx, 0)) { case HASH_KEY_IS_STRING: - ZVAL_STRINGL(z_zadd_args[i+1], val, (int)val_len-1, 0); /* we have to remove 1 because it is an array key. */ + ZVAL_STRINGL(&z_zadd_args[i+1], val->val, val->len - 1); /* we have to remove 1 because it is an array key. */ break; case HASH_KEY_IS_LONG: - ZVAL_LONG(z_zadd_args[i+1], (long)idx); + ZVAL_LONG(&z_zadd_args[i+1], (long)idx); break; default: return -1; /* Todo: log error */ @@ -945,17 +896,16 @@ ra_move_zset(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TS } /* run ZADD on target */ - ZVAL_STRINGL(&z_fun_zadd, "ZADD", 4, 0); - MAKE_STD_ZVAL(z_zadd_args[0]); - ZVAL_STRINGL(z_zadd_args[0], key, key_len, 0); - call_user_function(&redis_ce->function_table, &z_to, &z_fun_zadd, &z_ret_dest, 1 + 2 * count, z_zadd_args TSRMLS_CC); + ZVAL_STRINGL(&z_fun_zadd, "ZADD", 4); + ZVAL_STRINGL(&z_zadd_args[0], key, key_len); + call_user_function(&redis_ce->function_table, z_to, &z_fun_zadd, &z_ret_dest, 1 + 2 * count, z_zadd_args TSRMLS_CC); /* Expire if needed */ ra_expire_key(key, key_len, z_to, ttl TSRMLS_CC); /* cleanup */ for(i = 0; i < 1 + 2 * count; ++i) { - efree(z_zadd_args[i]); + efree(&z_zadd_args[i]); } zval_dtor(&z_ret); @@ -963,86 +913,82 @@ ra_move_zset(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TS /* Free the array itself */ efree(z_zadd_args); - return 1; + return 1; } static zend_bool ra_move_string(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TSRMLS_DC) { - zval z_fun_get, z_fun_set, z_ret, *z_args[3]; + zval z_fun_get, z_fun_set, z_ret, z_args[3]; /* run GET on source */ - MAKE_STD_ZVAL(z_args[0]); - ZVAL_STRINGL(&z_fun_get, "GET", 3, 0); - ZVAL_STRINGL(z_args[0], key, key_len, 0); - call_user_function(&redis_ce->function_table, &z_from, &z_fun_get, &z_ret, 1, z_args TSRMLS_CC); + ZVAL_STRINGL(&z_fun_get, "GET", 3); + ZVAL_STRINGL(&z_args[0], key, key_len); + call_user_function(&redis_ce->function_table, z_from, &z_fun_get, &z_ret, 1, z_args TSRMLS_CC); if(Z_TYPE(z_ret) != IS_STRING) { /* key not found or replaced */ /* TODO: report? */ - efree(z_args[0]); + efree(&z_args[0]); return 0; } /* run SET on target */ - MAKE_STD_ZVAL(z_args[1]); if (ttl > 0) { - MAKE_STD_ZVAL(z_args[2]); - ZVAL_STRINGL(&z_fun_set, "SETEX", 5, 0); - ZVAL_STRINGL(z_args[0], key, key_len, 0); - ZVAL_LONG(z_args[1], ttl); - ZVAL_STRINGL(z_args[2], Z_STRVAL(z_ret), Z_STRLEN(z_ret), 1); /* copy z_ret to arg 1 */ + ZVAL_STRINGL(&z_fun_set, "SETEX", 5); + ZVAL_STRINGL(&z_args[0], key, key_len); + ZVAL_LONG(&z_args[1], ttl); + ZVAL_STRINGL(&z_args[2], Z_STRVAL(z_ret), Z_STRLEN(z_ret)); /* copy z_ret to arg 1 */ zval_dtor(&z_ret); /* free memory from our previous call */ - call_user_function(&redis_ce->function_table, &z_to, &z_fun_set, &z_ret, 3, z_args TSRMLS_CC); + call_user_function(&redis_ce->function_table, z_to, &z_fun_set, &z_ret, 3, z_args TSRMLS_CC); /* cleanup */ - efree(z_args[1]); - zval_dtor(z_args[2]); - efree(z_args[2]); + efree(&z_args[1]); + zval_dtor(&z_args[2]); + efree(&z_args[2]); } else { - ZVAL_STRINGL(&z_fun_set, "SET", 3, 0); - ZVAL_STRINGL(z_args[0], key, key_len, 0); - ZVAL_STRINGL(z_args[1], Z_STRVAL(z_ret), Z_STRLEN(z_ret), 1); /* copy z_ret to arg 1 */ + ZVAL_STRINGL(&z_fun_set, "SET", 3); + ZVAL_STRINGL(&z_args[0], key, key_len); + ZVAL_STRINGL(&z_args[1], Z_STRVAL(z_ret), Z_STRLEN(z_ret)); /* copy z_ret to arg 1 */ zval_dtor(&z_ret); /* free memory from our previous return value */ - call_user_function(&redis_ce->function_table, &z_to, &z_fun_set, &z_ret, 2, z_args TSRMLS_CC); + call_user_function(&redis_ce->function_table, z_to, &z_fun_set, &z_ret, 2, z_args TSRMLS_CC); /* cleanup */ - zval_dtor(z_args[1]); - efree(z_args[1]); + zval_dtor(&z_args[1]); + efree(&z_args[1]); } /* cleanup */ - efree(z_args[0]); + efree(&z_args[0]); return 1; } static zend_bool ra_move_hash(const char *key, int key_len, zval *z_from, zval *z_to, long ttl TSRMLS_DC) { - zval z_fun_hgetall, z_fun_hmset, z_ret, z_ret_dest, *z_args[2]; + zval z_fun_hgetall, z_fun_hmset, z_ret, z_ret_dest, z_args[2]; /* run HGETALL on source */ - MAKE_STD_ZVAL(z_args[0]); - ZVAL_STRINGL(&z_fun_hgetall, "HGETALL", 7, 0); - ZVAL_STRINGL(z_args[0], key, key_len, 0); - call_user_function(&redis_ce->function_table, &z_from, &z_fun_hgetall, &z_ret, 1, z_args TSRMLS_CC); + ZVAL_STRINGL(&z_fun_hgetall, "HGETALL", 7); + ZVAL_STRINGL(&z_args[0], key, key_len); + call_user_function(&redis_ce->function_table, z_from, &z_fun_hgetall, &z_ret, 1, z_args TSRMLS_CC); if(Z_TYPE(z_ret) != IS_ARRAY) { /* key not found or replaced */ /* TODO: report? */ - efree(z_args[0]); + efree(&z_args[0]); return 0; } /* run HMSET on target */ - ZVAL_STRINGL(&z_fun_hmset, "HMSET", 5, 0); - ZVAL_STRINGL(z_args[0], key, key_len, 0); - z_args[1] = &z_ret; /* copy z_ret to arg 1 */ - call_user_function(&redis_ce->function_table, &z_to, &z_fun_hmset, &z_ret_dest, 2, z_args TSRMLS_CC); + ZVAL_STRINGL(&z_fun_hmset, "HMSET", 5); + ZVAL_STRINGL(&z_args[0], key, key_len); + ZVAL_DUP(&z_args[1], &z_ret); + call_user_function(&redis_ce->function_table, z_to, &z_fun_hmset, &z_ret_dest, 2, z_args TSRMLS_CC); /* Expire if needed */ ra_expire_key(key, key_len, z_to, ttl TSRMLS_CC); /* cleanup */ - efree(z_args[0]); - zval_dtor(&z_ret); + efree(&z_args[0]); + zval_dtor(&z_ret); return 1; } @@ -1052,29 +998,27 @@ ra_move_collection(const char *key, int key_len, zval *z_from, zval *z_to, int list_count, const char **cmd_list, int add_count, const char **cmd_add, long ttl TSRMLS_DC) { - zval z_fun_retrieve, z_fun_sadd, z_ret, **z_retrieve_args, **z_sadd_args, **z_data_pp; + zval z_fun_retrieve, z_fun_sadd, z_ret, *z_data_p; int count, i; HashTable *h_set_vals; /* run retrieval command on source */ - z_retrieve_args = emalloc((1+list_count) * sizeof(zval*)); - ZVAL_STRING(&z_fun_retrieve, cmd_list[0], 0); /* set the command */ + zval z_retrieve_args[1 + list_count]; + ZVAL_STRING(&z_fun_retrieve, cmd_list[0]); /* set the command */ /* set the key */ - MAKE_STD_ZVAL(z_retrieve_args[0]); - ZVAL_STRINGL(z_retrieve_args[0], key, key_len, 0); + ZVAL_STRINGL(&z_retrieve_args[0], key, key_len); /* possibly add some other args if they were provided. */ for(i = 1; i < list_count; ++i) { - MAKE_STD_ZVAL(z_retrieve_args[i]); - ZVAL_STRING(z_retrieve_args[i], cmd_list[i], 0); + ZVAL_STRING(&z_retrieve_args[i], cmd_list[i]); } - call_user_function(&redis_ce->function_table, &z_from, &z_fun_retrieve, &z_ret, list_count, z_retrieve_args TSRMLS_CC); + call_user_function(&redis_ce->function_table, z_from, &z_fun_retrieve, &z_ret, list_count, z_retrieve_args TSRMLS_CC); /* cleanup */ for(i = 0; i < list_count; ++i) { - efree(z_retrieve_args[i]); + efree(&z_retrieve_args[i]); } efree(z_retrieve_args); @@ -1086,46 +1030,43 @@ ra_move_collection(const char *key, int key_len, zval *z_from, zval *z_to, /* run SADD/RPUSH on target */ h_set_vals = Z_ARRVAL(z_ret); count = zend_hash_num_elements(h_set_vals); - z_sadd_args = emalloc((1 + count) * sizeof(zval*)); - ZVAL_STRING(&z_fun_sadd, cmd_add[0], 0); - MAKE_STD_ZVAL(z_sadd_args[0]); /* add key */ - ZVAL_STRINGL(z_sadd_args[0], key, key_len, 0); + zval z_sadd_args[1 + count]; + ZVAL_STRING(&z_fun_sadd, cmd_add[0]); + ZVAL_STRINGL(&z_sadd_args[0], key, key_len); for(i = 0, zend_hash_internal_pointer_reset(h_set_vals); zend_hash_has_more_elements(h_set_vals) == SUCCESS; zend_hash_move_forward(h_set_vals), i++) { - if(zend_hash_get_current_data(h_set_vals, (void**)&z_data_pp) == FAILURE) { + if((z_data_p = zend_hash_get_current_data(h_set_vals)) == NULL) { continue; } /* add set elements */ - MAKE_STD_ZVAL(z_sadd_args[i+1]); - *(z_sadd_args[i+1]) = **z_data_pp; - zval_copy_ctor(z_sadd_args[i+1]); + ZVAL_DUP(&z_sadd_args[i+1], z_data_p); } /* Clean up our input return value */ zval_dtor(&z_ret); - call_user_function(&redis_ce->function_table, &z_to, &z_fun_sadd, &z_ret, count+1, z_sadd_args TSRMLS_CC); + call_user_function(&redis_ce->function_table, z_to, &z_fun_sadd, &z_ret, count+1, z_sadd_args TSRMLS_CC); - /* Expire if needed */ - ra_expire_key(key, key_len, z_to, ttl TSRMLS_CC); + /* Expire if needed */ + ra_expire_key(key, key_len, z_to, ttl TSRMLS_CC); - /* cleanup */ - efree(z_sadd_args[0]); /* no dtor at [0] */ + /* cleanup */ + efree(&z_sadd_args[0]); /* no dtor at [0] */ - for(i = 0; i < count; ++i) { - zval_dtor(z_sadd_args[i + 1]); - efree(z_sadd_args[i + 1]); - } - efree(z_sadd_args); + for(i = 0; i < count; ++i) { + zval_dtor(&z_sadd_args[i + 1]); + efree(&z_sadd_args[i + 1]); + } + efree(z_sadd_args); /* Clean up our output return value */ zval_dtor(&z_ret); - return 1; + return 1; } static zend_bool @@ -1194,29 +1135,22 @@ ra_move_key(const char *key, int key_len, zval *z_from, zval *z_to TSRMLS_DC) { static void zval_rehash_callback(zend_fcall_info *z_cb, zend_fcall_info_cache *z_cb_cache, const char *hostname, long count TSRMLS_DC) { - zval *z_ret = NULL, **z_args[2]; - zval *z_host, *z_count; + zval z_ret, z_args[2]; - z_cb->retval_ptr_ptr = &z_ret; - z_cb->params = (struct _zval_struct ***)&z_args; + z_cb->retval = &z_ret; + z_cb->params = z_args; z_cb->param_count = 2; z_cb->no_separation = 0; /* run cb(hostname, count) */ - MAKE_STD_ZVAL(z_host); - ZVAL_STRING(z_host, hostname, 0); - z_args[0] = &z_host; - MAKE_STD_ZVAL(z_count); - ZVAL_LONG(z_count, count); - z_args[1] = &z_count; + ZVAL_STRING(&z_args[0], hostname); + ZVAL_LONG(&z_args[1], count); zend_call_function(z_cb, z_cb_cache TSRMLS_CC); /* cleanup */ - efree(z_host); - efree(z_count); - if(z_ret) - efree(z_ret); + if(Z_TYPE(z_ret) != IS_UNDEF) + efree(&z_ret); } static void @@ -1270,7 +1204,7 @@ ra_rehash(RedisArray *ra, zend_fcall_info *z_cb, zend_fcall_info_cache *z_cb_cac return; /* TODO: compare the two rings for equality */ for(i = 0; i < ra->prev->count; ++i) { - ra_rehash_server(ra, ra->prev->redis[i], ra->prev->hosts[i], ra->index, z_cb, z_cb_cache TSRMLS_CC); + ra_rehash_server(ra, &ra->prev->redis[i], ra->prev->hosts[i], ra->index, z_cb, z_cb_cache TSRMLS_CC); } } diff --git a/redis_session.c b/redis_session.c index ab74923a..81ca5c11 100644 --- a/redis_session.c +++ b/redis_session.c @@ -26,7 +26,7 @@ #include "config.h" #endif -#ifdef PHP_SESSION +#ifdef PHP_SESSION_NEW #include "common.h" #include "ext/standard/info.h" #include "php_redis.h" @@ -354,7 +354,7 @@ PS_READ_FUNC(redis) /* send GET command */ session = redis_session_key(rpm, key, strlen(key), &session_len); cmd_len = redis_cmd_format_static(&cmd, "GET", "s", session, session_len); - + efree(session); if(redis_sock_write(redis_sock, cmd, cmd_len TSRMLS_CC) < 0) { efree(cmd); @@ -471,14 +471,14 @@ static void session_conf_timeout(HashTable *ht_conf, const char *key, int key_le zval **z_val; if (zend_hash_find(ht_conf, key, key_len, (void**)&z_val) == SUCCESS && - Z_TYPE_PP(z_val) == IS_STRING) + Z_TYPE_PP(z_val) == IS_STRING) { *val = atof(Z_STRVAL_PP(z_val)); } } /* Simple helper to retreive a boolean (0 or 1) value from a string stored in our - * session.save_path variable. This is so the user can use 0, 1, or 'true', + * session.save_path variable. This is so the user can use 0, 1, or 'true', * 'false' */ static void session_conf_bool(HashTable *ht_conf, char *key, int keylen, int *retval) { @@ -486,7 +486,7 @@ static void session_conf_bool(HashTable *ht_conf, char *key, int keylen, char *str; int strlen; - /* See if we have the option, and it's a string */ + /* See if we have the option, and it's a string */ if (zend_hash_find(ht_conf, key, keylen, (void**)&z_val) == SUCCESS && Z_TYPE_PP(z_val) == IS_STRING) { @@ -501,7 +501,7 @@ static void session_conf_bool(HashTable *ht_conf, char *key, int keylen, } /* Prefix a session key */ -static char *cluster_session_key(redisCluster *c, const char *key, int keylen, +static char *cluster_session_key(redisCluster *c, const char *key, int keylen, int *skeylen, short *slot) { char *skey; @@ -509,7 +509,7 @@ static char *cluster_session_key(redisCluster *c, const char *key, int keylen, skey = emalloc(*skeylen); memcpy(skey, c->flags->prefix, c->flags->prefix_len); memcpy(skey + c->flags->prefix_len, key, keylen); - + *slot = cluster_hash_key(skey, *skeylen); return skey; @@ -549,7 +549,7 @@ PS_OPEN_FUNC(rediscluster) { /* Grab persistent option */ session_conf_bool(ht_conf, "persistent", sizeof("persistent"), &persistent); - + /* Sanity check on our timeouts */ if (timeout < 0 || read_timeout < 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, @@ -561,7 +561,7 @@ PS_OPEN_FUNC(rediscluster) { /* Look for a specific prefix */ if (zend_hash_find(ht_conf, "prefix", sizeof("prefix"), (void**)&z_val) == SUCCESS && - Z_TYPE_PP(z_val) == IS_STRING && Z_STRLEN_PP(z_val) > 0) + Z_TYPE_PP(z_val) == IS_STRING && Z_STRLEN_PP(z_val) > 0) { prefix = Z_STRVAL_PP(z_val); prefix_len = Z_STRLEN_PP(z_val); @@ -597,7 +597,7 @@ PS_OPEN_FUNC(rediscluster) { /* Cleanup */ zval_dtor(z_conf); efree(z_conf); - + return retval; } @@ -709,7 +709,7 @@ PS_DESTROY_FUNC(rediscluster) { reply = cluster_read_resp(c TSRMLS_CC); if (!reply || c->err) { if (reply) cluster_free_reply(reply, 1); - return FAILURE; + return FAILURE; } /* Clean up our reply */ |