#ifdef HAVE_CONFIG_H

#include "config.h"

#include "common.h"

#include "php_redis.h"

#include "ext/standard/info.h"

#include "crc16.h"

#include "redis_cluster.h"

#include "redis_commands.h"

#include <zend_exceptions.h>

#include "library.h"

#include <php_variables.h>

#include <SAPI.h>

zend_class_entry *redis_cluster_ce;

zend_class_entry *redis_cluster_exception_ce;

zend_class_entry *spl_rte_ce = NULL;

ZEND_BEGIN_ARG_INFO_EX(arginfo_kscan_cl, 0, 0, 2)

ZEND_ARG_INFO(0, str_key)

ZEND_ARG_INFO(1, i_iterator)

ZEND_ARG_INFO(0, str_pattern)

ZEND_ARG_INFO(0, i_count)

ZEND_END_ARG_INFO();

ZEND_BEGIN_ARG_INFO_EX(arginfo_scan_cl, 0, 0, 2)

ZEND_ARG_INFO(1, i_iterator)

ZEND_ARG_INFO(0, str_node)

ZEND_ARG_INFO(0, str_pattern)

ZEND_ARG_INFO(0, i_count)

ZEND_END_ARG_INFO();

zend_function_entry redis_cluster_functions[] = {

PHP_ME(RedisCluster, __construct, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, close, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, get, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, set, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, mget, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, mset, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, msetnx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, del, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, setex, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, psetex, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, setnx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getset, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, exists, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, keys, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, type, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lpop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rpop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lset, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, spop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lpush, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rpush, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, blpop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, brpop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rpushx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lpushx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, linsert, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lindex, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lrem, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, brpoplpush, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rpoplpush, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, llen, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, scard, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, smembers, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sismember, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sadd, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, saddarray, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, srem, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sunion, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sunionstore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sinter, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sinterstore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sdiff, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sdiffstore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, srandmember, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, strlen, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, persist, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, ttl, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pttl, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zcard, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zcount, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zremrangebyscore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zscore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zadd, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zincrby, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hlen, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hkeys, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hvals, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hget, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hgetall, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hexists, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hincrby, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hset, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hsetnx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hmget, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hmset, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hdel, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hincrbyfloat, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, dump, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrank, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrevrank, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, incr, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, decr, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, incrby, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, decrby, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, incrbyfloat, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, expire, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pexpire, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, expireat, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pexpireat, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, append, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getbit, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, setbit, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bitop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bitpos, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bitcount, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lget, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getrange, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, ltrim, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lrange, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zremrangebyrank, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, publish, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rename, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, renamenx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pfcount, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pfadd, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pfmerge, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, setrange, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, restore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, smove, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrange, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrevrange, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrangebyscore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrevrangebyscore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrangebylex, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrevrangebylex, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zlexcount, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zremrangebylex, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zunionstore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zinterstore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrem, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sort, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, object, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, subscribe, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, psubscribe, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, unsubscribe, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, punsubscribe, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, eval, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, evalsha, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, scan, arginfo_scan_cl, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sscan, arginfo_kscan_cl, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zscan, arginfo_kscan_cl, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hscan, arginfo_kscan_cl, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getmode, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getlasterror, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, clearlasterror, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getoption, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, setoption, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, _prefix, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, _serialize, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, _unserialize, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, _masters, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, _redir, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, multi, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, exec, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, discard, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, watch, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, unwatch, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, save, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bgsave, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, flushdb, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, flushall, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, dbsize, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bgrewriteaof, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lastsave, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, info, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, role, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, time, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, randomkey, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, ping, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, echo, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, command, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rawcommand, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, cluster, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, client, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, config, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pubsub, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, script, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, slowlog, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, geoadd, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, geohash, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, geopos, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, geodist, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, georadius, NULL, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, georadiusbymember, NULL, ZEND_ACC_PUBLIC)

{NULL, NULL, NULL}

};

static void ht_free_seed(void *data) {

RedisSock *redis_sock = *(RedisSock**)data;

if(redis_sock) redis_free_socket(redis_sock);

}

static void ht_free_node(void *data) {

redisClusterNode *node = *(redisClusterNode**)data;

cluster_free_node(node);

}

PHPAPI zend_class_entry *rediscluster_get_exception_base(int root TSRMLS_DC) {

#if HAVE_SPL

if(!root) {

if(!spl_rte_ce) {

zend_class_entry **pce;

if(zend_hash_find(CG(class_table), "runtimeexception",

sizeof("runtimeexception"), (void**)&pce)

==SUCCESS)

{

spl_rte_ce = *pce;

return *pce;

}

} else {

return spl_rte_ce;

}

}

#if (PHP_MAJOR_VERSION == 5) && (PHP_MINOR_VERSION < 2)

return zend_exception_get_default();

return zend_exception_get_default(TSRMLS_C);

}

create_cluster_context(zend_class_entry *class_type TSRMLS_DC) {

zend_object_value retval;

redisCluster *cluster;

// Allocate our actual struct

cluster = emalloc(sizeof(redisCluster));

memset(cluster, 0, sizeof(redisCluster));

// We're not currently subscribed anywhere

cluster->subscribed_slot = -1;

// Assume we're up initially

cluster->clusterdown = 0;

// Allocate our RedisSock we'll use to store prefix/serialization flags

cluster->flags = ecalloc(1, sizeof(RedisSock));

// Allocate our hash table for seeds

ALLOC_HASHTABLE(cluster->seeds);

zend_hash_init(cluster->seeds, 0, NULL, ht_free_seed, 0);

// Allocate our hash table for connected Redis objects

ALLOC_HASHTABLE(cluster->nodes);

zend_hash_init(cluster->nodes, 0, NULL, ht_free_node, 0);

// Initialize it

zend_object_std_init(&cluster->std, class_type TSRMLS_CC);

#if PHP_VERSION_ID < 50399

zval *tmp;

zend_hash_copy(cluster->std.properties, &class_type->default_properties,

(copy_ctor_func_t)zval_add_ref, (void*)&tmp, sizeof(zval*));

retval.handle = zend_objects_store_put(cluster,

(zend_objects_store_dtor_t)zend_objects_destroy_object,

free_cluster_context, NULL TSRMLS_CC);

retval.handlers = zend_get_std_object_handlers();

return retval;

}

void free_cluster_context(void *object TSRMLS_DC) {

redisCluster *cluster;

// Grab context

cluster = (redisCluster*)object;

// Free any allocated prefix, as well as the struct

if(cluster->flags->prefix) efree(cluster->flags->prefix);

efree(cluster->flags);

// Free seeds HashTable itself

zend_hash_destroy(cluster->seeds);

efree(cluster->seeds);

// Destroy all Redis objects and free our nodes HashTable

zend_hash_destroy(cluster->nodes);

efree(cluster->nodes);

if(cluster->err) efree(cluster->err);

// Finally, free the redisCluster structure itself

efree(cluster);

}

void redis_cluster_init(redisCluster *c, HashTable *ht_seeds, double timeout,

double read_timeout, int persistent TSRMLS_DC)

{

// Validate timeout

if(timeout < 0L || timeout > INT_MAX) {

zend_throw_exception(redis_cluster_exception_ce,

"Invalid timeout", 0 TSRMLS_CC);

}

// Validate our read timeout

if(read_timeout < 0L || read_timeout > INT_MAX) {

zend_throw_exception(redis_cluster_exception_ce,

"Invalid read timeout", 0 TSRMLS_CC);

}

/* Make sure there are some seeds */

if(zend_hash_num_elements(ht_seeds)==0) {

zend_throw_exception(redis_cluster_exception_ce,

"Must pass seeds", 0 TSRMLS_CC);

}

/* Set our timeout and read_timeout which we'll pass through to the

c->timeout = timeout;

c->read_timeout = read_timeout;

/* Set our option to use or not use persistent connections */

c->persistent = persistent;

/* Calculate the number of miliseconds we will wait when bouncing around,

c->waitms = (long)(timeout * 1000);

// Initialize our RedisSock "seed" objects

cluster_init_seeds(c, ht_seeds);

// Create and map our key space

cluster_map_keyspace(c TSRMLS_CC);

}

void redis_cluster_load(redisCluster *c, char *name, int name_len TSRMLS_DC) {

zval *z_seeds, *z_timeout, *z_read_timeout, *z_persistent, **z_value;

char *iptr;

double timeout=0, read_timeout=0;

int persistent = 0;

HashTable *ht_seeds = NULL;

/* Seeds */

MAKE_STD_ZVAL(z_seeds);

array_init(z_seeds);

iptr = estrdup(INI_STR("redis.clusters.seeds"));

sapi_module.treat_data(PARSE_STRING, iptr, z_seeds TSRMLS_CC);

if (zend_hash_find(Z_ARRVAL_P(z_seeds), name, name_len+1, (void**)&z_value) != FAILURE) {

ht_seeds = Z_ARRVAL_PP(z_value);

} else {

zval_dtor(z_seeds);

efree(z_seeds);

zend_throw_exception(redis_cluster_exception_ce, "Couldn't find seeds for cluster", 0 TSRMLS_CC);

}

/* Connection timeout */

MAKE_STD_ZVAL(z_timeout);

array_init(z_timeout);

iptr = estrdup(INI_STR("redis.clusters.timeout"));

sapi_module.treat_data(PARSE_STRING, iptr, z_timeout TSRMLS_CC);

if (zend_hash_find(Z_ARRVAL_P(z_timeout), name, name_len+1, (void**)&z_value) != FAILURE) {

if (Z_TYPE_PP(z_value) == IS_STRING) {

timeout = atof(Z_STRVAL_PP(z_value));

} else if (Z_TYPE_PP(z_value) == IS_DOUBLE) {

timeout = Z_DVAL_PP(z_value);

}

}

/* Read timeout */

MAKE_STD_ZVAL(z_read_timeout);

array_init(z_read_timeout);

iptr = estrdup(INI_STR("redis.clusters.read_timeout"));

sapi_module.treat_data(PARSE_STRING, iptr, z_read_timeout TSRMLS_CC);

if (zend_hash_find(Z_ARRVAL_P(z_read_timeout), name, name_len+1, (void**)&z_value) != FAILURE) {

if (Z_TYPE_PP(z_value) == IS_STRING) {

read_timeout = atof(Z_STRVAL_PP(z_value));

} else if (Z_TYPE_PP(z_value) == IS_DOUBLE) {

read_timeout = Z_DVAL_PP(z_value);

}

}

/* Persistent connections */

MAKE_STD_ZVAL(z_persistent);

array_init(z_persistent);

iptr = estrdup(INI_STR("redis.clusters.persistent"));

sapi_module.treat_data(PARSE_STRING, iptr, z_persistent TSRMLS_CC);

if (zend_hash_find(Z_ARRVAL_P(z_persistent), name, name_len+1, (void**)&z_value) != FAILURE) {

if (Z_TYPE_PP(z_value) == IS_STRING) {

persistent = atoi(Z_STRVAL_PP(z_value));

} else if (Z_TYPE_PP(z_value) == IS_LONG) {

persistent = Z_LVAL_PP(z_value);

}

}

/* Attempt to create/connect to the cluster */

redis_cluster_init(c, ht_seeds, timeout, read_timeout, persistent TSRMLS_CC);

/* Clean up our arrays */

zval_dtor(z_seeds);

efree(z_seeds);

zval_dtor(z_timeout);

efree(z_timeout);

zval_dtor(z_read_timeout);

efree(z_read_timeout);

}

PHP_METHOD(RedisCluster, __construct) {

zval *object, *z_seeds=NULL;

char *name;

long name_len;

double timeout = 0.0, read_timeout = 0.0;

zend_bool persistent = 0;

redisCluster *context = GET_CONTEXT();

// Parse arguments

if(zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(),

"Os|addb", &object, redis_cluster_ce, &name,

&name_len, &z_seeds, &timeout,

&read_timeout, &persistent)==FAILURE)

{

RETURN_FALSE;

}

// Require a name

if(name_len == 0 && ZEND_NUM_ARGS() < 2) {

zend_throw_exception(redis_cluster_exception_ce,

"You must specify a name or pass seeds!",

0 TSRMLS_CC);

}

/* If we've been passed only one argument, the user is attempting to connect

if (ZEND_NUM_ARGS() > 1) {

redis_cluster_init(context, Z_ARRVAL_P(z_seeds), timeout, read_timeout,

persistent TSRMLS_CC);

} else {

redis_cluster_load(context, name, name_len TSRMLS_CC);

}

}

PHP_METHOD(RedisCluster, close) {

cluster_disconnect(GET_CONTEXT() TSRMLS_CC);

RETURN_TRUE;

}

PHP_METHOD(RedisCluster, get) {

CLUSTER_PROCESS_KW_CMD("GET", redis_key_cmd, cluster_bulk_resp, 1);

}

PHP_METHOD(RedisCluster, set) {

CLUSTER_PROCESS_CMD(set, cluster_bool_resp, 0);

}

static int

distcmd_resp_handler(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c, short slot,

clusterMultiCmd *mc, zval *z_ret, int last, cluster_cb cb)

{

clusterMultiCtx *ctx;

// Finalize multi command

cluster_multi_fini(mc);

// Spin up multi context

ctx = emalloc(sizeof(clusterMultiCtx));

ctx->z_multi = z_ret;

ctx->count = mc->argc;

ctx->last = last;

// Attempt to send the command

if(cluster_send_command(c,slot,mc->cmd.c,mc->cmd.len TSRMLS_CC)<0 ||

c->err!=NULL)

{

cluster_multi_free(mc);

zval_dtor(z_ret);

efree(ctx);

return -1;

}

if(CLUSTER_IS_ATOMIC(c)) {

// Process response now

cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, c, (void*)ctx);

} else {

CLUSTER_ENQUEUE_RESPONSE(c, slot, cb, ctx);

}

// Clear out our command but retain allocated memory

CLUSTER_MULTI_CLEAR(mc);

return 0;

}

typedef struct clusterKeyValHT {

} clusterKeyValHT;

static int get_key_val_ht(redisCluster *c, HashTable *ht, HashPosition *ptr,

clusterKeyValHT *kv TSRMLS_DC)

{

zval **z_val;

unsigned int key_len;

ulong idx;

// Grab the key, convert it to a string using provided kbuf buffer if it's

// a LONG style key

switch(zend_hash_get_current_key_ex(ht, &(kv->key), &key_len, &idx, 0, ptr))

{

case HASH_KEY_IS_LONG:

kv->key_len = snprintf(kv->kbuf,sizeof(kv->kbuf),"%ld",(long)idx);

kv->key = kv->kbuf;

break;

case HASH_KEY_IS_STRING:

kv->key_len = (int)(key_len-1);

break;

default:

zend_throw_exception(redis_cluster_exception_ce,

"Internal Zend HashTable error", 0 TSRMLS_CC);

return -1;

}

// Prefix our key if we need to, set the slot

kv->key_free = redis_key_prefix(c->flags, &(kv->key), &(kv->key_len));

kv->slot = cluster_hash_key(kv->key, kv->key_len);

// Now grab our value

if(zend_hash_get_current_data_ex(ht, (void**)&z_val, ptr)==FAILURE) {

zend_throw_exception(redis_cluster_exception_ce,

"Internal Zend HashTable error", 0 TSRMLS_CC);

return -1;

}

// Serialize our value if required

kv->val_free = redis_serialize(c->flags,*z_val,&(kv->val),&(kv->val_len)

TSRMLS_CC);

// Success

return 0;

}

static int get_key_ht(redisCluster *c, HashTable *ht, HashPosition *ptr,

clusterKeyValHT *kv TSRMLS_DC)

{

zval **z_key;

if(zend_hash_get_current_data_ex(ht, (void**)&z_key, ptr)==FAILURE) {

// Shouldn't happen, but check anyway

zend_throw_exception(redis_cluster_exception_ce,

"Internal Zend HashTable error", 0 TSRMLS_CC);

return -1;

}

// Always want to work with strings

convert_to_string(*z_key);

kv->key = Z_STRVAL_PP(z_key);

kv->key_len = Z_STRLEN_PP(z_key);

kv->key_free = redis_key_prefix(c->flags, &(kv->key), &(kv->key_len));

// Hash our key

kv->slot = cluster_hash_key(kv->key, kv->key_len);

// Success

return 0;

}

static HashTable *method_args_to_ht(zval **z_args, int argc) {

HashTable *ht_ret;

int i;

/* Allocate our hash table */

ALLOC_HASHTABLE(ht_ret);

zend_hash_init(ht_ret, argc, NULL, NULL, 0);

/* Populate our return hash table with our arguments */

for (i = 0; i < argc; i++) {

zend_hash_next_index_insert(ht_ret, &z_args[i], sizeof(zval*), NULL);

}

/* Return our hash table */

return ht_ret;

}

static int cluster_mkey_cmd(INTERNAL_FUNCTION_PARAMETERS, char *kw, int kw_len,

zval *z_ret, cluster_cb cb)

{

redisCluster *c = GET_CONTEXT();

clusterMultiCmd mc = {0};

clusterKeyValHT kv;

zval **z_args;

HashTable *ht_arr;

HashPosition ptr;

int i=1, argc = ZEND_NUM_ARGS(), ht_free=0;

short slot;

/* If we don't have any arguments we're invalid */

if (!argc) return -1;

/* Extract our arguments into an array */

z_args = emalloc(sizeof(zval*)*argc);

if (zend_get_parameters_array(ht, ZEND_NUM_ARGS(), z_args) == FAILURE) {

efree(z_args);

return -1;

}

/* Determine if we're working with a single array or variadic args */

if (argc == 1 && Z_TYPE_P(z_args[0]) == IS_ARRAY) {

ht_arr = Z_ARRVAL_P(z_args[0]);

argc = zend_hash_num_elements(ht_arr);

if (!argc) {

efree(z_args);

return -1;

}

} else {

ht_arr = method_args_to_ht(z_args, argc);

ht_free = 1;

}

/* We no longer need our array args */

efree(z_args);

/* MGET is readonly, DEL is not */

c->readonly = kw_len == 4 && CLUSTER_IS_ATOMIC(c);

// Initialize our "multi" command handler with command/len

CLUSTER_MULTI_INIT(mc, kw, kw_len);

// Process the first key outside of our loop, so we don't have to check if

// it's the first iteration every time, needlessly

zend_hash_internal_pointer_reset_ex(ht_arr, &ptr);

if(get_key_ht(c, ht_arr, &ptr, &kv TSRMLS_CC)<0) {

return -1;

}

// Process our key and add it to the command

cluster_multi_add(&mc, kv.key, kv.key_len);

// Free key if we prefixed

if(kv.key_free) efree(kv.key);

// Move to the next key

zend_hash_move_forward_ex(ht_arr, &ptr);

// Iterate over keys 2...N

slot = kv.slot;

while(zend_hash_has_more_elements_ex(ht_arr, &ptr)==SUCCESS) {

if(get_key_ht(c, ht_arr, &ptr, &kv TSRMLS_CC)<0) {

cluster_multi_free(&mc);

if (ht_free) {

zend_hash_destroy(ht_arr);

efree(ht_arr);

}

return -1;

}

// If the slots have changed, kick off the keys we've aggregated

if(slot != kv.slot) {

// Process this batch of MGET keys

if(distcmd_resp_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU, c, slot,

&mc, z_ret, i==argc, cb)<0)

{

cluster_multi_free(&mc);

if (ht_free) {

zend_hash_destroy(ht_arr);

efree(ht_arr);

}

return -1;

}

}

// Add this key to the command

cluster_multi_add(&mc, kv.key, kv.key_len);

// Free key if we prefixed

if(kv.key_free) efree(kv.key);

// Update the last slot we encountered, and the key we're on

slot = kv.slot;

i++;

zend_hash_move_forward_ex(ht_arr, &ptr);

}

// If we've got straggler(s) process them

if(mc.argc > 0) {

if(distcmd_resp_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU, c, slot,

&mc, z_ret, 1, cb)<0)

{

cluster_multi_free(&mc);

if (ht_free) {

zend_hash_destroy(ht_arr);

efree(ht_arr);

}

return -1;

}

}

// Free our command

cluster_multi_free(&mc);

/* Clean up our hash table if we constructed it from variadic args */

if (ht_free) {

zend_hash_destroy(ht_arr);

efree(ht_arr);

}

/* Return our object if we're in MULTI mode */

if (!CLUSTER_IS_ATOMIC(c))

RETVAL_ZVAL(getThis(), 1, 0);

// Success

return 0;

}

static int cluster_mset_cmd(INTERNAL_FUNCTION_PARAMETERS, char *kw, int kw_len,

zval *z_ret, cluster_cb cb)

{

redisCluster *c = GET_CONTEXT();

clusterKeyValHT kv;

clusterMultiCmd mc = {0};

zval *z_arr;

HashTable *ht_arr;

HashPosition ptr;

int i=1, argc;

short slot;

// Parse our arguments

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &z_arr)==FAILURE) {

return -1;

}

// No reason to send zero args

ht_arr = Z_ARRVAL_P(z_arr);

if((argc = zend_hash_num_elements(ht_arr))==0) {

return -1;

}

/* This is a write command */

c->readonly = 0;

// Set up our multi command handler

CLUSTER_MULTI_INIT(mc, kw, kw_len);

// Process the first key/value pair outside of our loop

zend_hash_internal_pointer_reset_ex(ht_arr, &ptr);

if(get_key_val_ht(c, ht_arr, &ptr, &kv TSRMLS_CC)==-1) return -1;

zend_hash_move_forward_ex(ht_arr, &ptr);

// Add this to our multi cmd, set slot, free key if we prefixed

cluster_multi_add(&mc, kv.key, kv.key_len);

cluster_multi_add(&mc, kv.val, kv.val_len);

if(kv.key_free) efree(kv.key);

if(kv.val_free) STR_FREE(kv.val);

// While we've got more keys to set

slot = kv.slot;

while(zend_hash_has_more_elements_ex(ht_arr, &ptr)==SUCCESS) {

// Pull the next key/value pair

if(get_key_val_ht(c, ht_arr, &ptr, &kv TSRMLS_CC)==-1) {

return -1;

}

// If the slots have changed, process responses

if(slot != kv.slot) {

if(distcmd_resp_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU, c,

slot, &mc, z_ret, i==argc, cb)<0)

{

return -1;

}

}

// Add this key and value to our command

cluster_multi_add(&mc, kv.key, kv.key_len);

cluster_multi_add(&mc, kv.val, kv.val_len);

// Free our key and value if we need to

if(kv.key_free) efree(kv.key);

if(kv.val_free) STR_FREE(kv.val);

// Update our slot, increment position

slot = kv.slot;

i++;

// Move on

zend_hash_move_forward_ex(ht_arr, &ptr);

}

// If we've got stragglers, process them too

if(mc.argc > 0) {

if(distcmd_resp_handler(INTERNAL_FUNCTION_PARAM_PASSTHRU, c, slot, &mc,

z_ret, 1, cb)<0)

{

return -1;

}

}

// Free our command

cluster_multi_free(&mc);

/* Return our object if we're in MULTI mode */

if (!CLUSTER_IS_ATOMIC(c))

RETVAL_ZVAL(getThis(), 1, 0);

// Success

return 0;

}

PHP_METHOD(RedisCluster, del) {

zval *z_ret;

// Initialize a LONG value to zero for our return

MAKE_STD_ZVAL(z_ret);

ZVAL_LONG(z_ret, 0);

// Parse args, process

if(cluster_mkey_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, "DEL",

sizeof("DEL")-1, z_ret, cluster_del_resp)<0)

{

efree(z_ret);

RETURN_FALSE;

}

}

PHP_METHOD(RedisCluster, mget) {

zval *z_ret;

// Array response

MAKE_STD_ZVAL(z_ret);

array_init(z_ret);

// Parse args, process

if(cluster_mkey_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, "MGET",

sizeof("MGET")-1, z_ret, cluster_mbulk_mget_resp)<0)

{

zval_dtor(z_ret);

efree(z_ret);

RETURN_FALSE;

}

}

PHP_METHOD(RedisCluster, mset) {

zval *z_ret;

// Response, defaults to TRUE

MAKE_STD_ZVAL(z_ret);

ZVAL_TRUE(z_ret);

// Parse args and process. If we get a failure, free zval and return FALSE.

if(cluster_mset_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, "MSET",

sizeof("MSET")-1, z_ret, cluster_mset_resp)==-1)

{

efree(z_ret);

RETURN_FALSE;

}

}

PHP_METHOD(RedisCluster, msetnx) {

zval *z_ret;

// Array response

MAKE_STD_ZVAL(z_ret);

array_init(z_ret);

// Parse args and process. If we get a failure, free mem and return FALSE

if(cluster_mset_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, "MSETNX",

sizeof("MSETNX")-1, z_ret, cluster_msetnx_resp)==-1)

{

zval_dtor(z_ret);

efree(z_ret);

RETURN_FALSE;

}

}

PHP_METHOD(RedisCluster, setex) {

CLUSTER_PROCESS_KW_CMD("SETEX", redis_key_long_val_cmd, cluster_bool_resp, 0);

}

PHP_METHOD(RedisCluster, psetex) {

CLUSTER_PROCESS_KW_CMD("PSETEX", redis_key_long_val_cmd, cluster_bool_resp, 0);

}

PHP_METHOD(RedisCluster, setnx) {

CLUSTER_PROCESS_KW_CMD("SETNX", redis_kv_cmd, cluster_1_resp, 0);

}

PHP_METHOD(RedisCluster, getset) {

CLUSTER_PROCESS_KW_CMD("GETSET", redis_kv_cmd, cluster_bulk_resp, 0);

}

PHP_METHOD(RedisCluster, exists) {

CLUSTER_PROCESS_KW_CMD("EXISTS", redis_key_cmd, cluster_1_resp, 1);

}

PHP_METHOD(RedisCluster, keys) {

redisCluster *c = GET_CONTEXT();

redisClusterNode **node;

int pat_len, pat_free, cmd_len;

char *pat, *cmd;

clusterReply *resp;

zval *z_ret;

int i;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &pat, &pat_len)

==FAILURE)

{

RETURN_FALSE;

}

/* Prefix and then build our command */

pat_free = redis_key_prefix(c->flags, &pat, &pat_len);

cmd_len = redis_cmd_format_static(&cmd, "KEYS", "s", pat, pat_len);

if(pat_free) efree(pat);