#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 <ext/spl/spl_exceptions.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_object_handlers RedisCluster_handlers;

#if PHP_VERSION_ID < 80000

#include "redis_cluster_legacy_arginfo.h"

#include "zend_attributes.h"

#include "redis_cluster_arginfo.h"

static void

cluster_enqueue_response(redisCluster *c, short slot, cluster_cb cb, RedisCmdCtx ctx)

{

clusterFoldItem *item;

item = emalloc(sizeof(clusterFoldItem));

item->callback = cb;

item->slot = slot;

item->ctx = ctx;

item->next = NULL;

item->flags = c->flags->flags;

if (UNEXPECTED(c->multi_head == NULL)) {

c->multi_head = item;

c->multi_curr = item;

} else {

c->multi_curr->next = item;

c->multi_curr = item;

}

}

static void cluster_free_queue(redisCluster *c) {

clusterFoldItem *item = c->multi_head, *tmp;

while (item) {

tmp = item->next;

redis_cmd_ctx_free(item->ctx);

efree(item);

item = tmp;

}

c->multi_head = NULL;

c->multi_curr = NULL;

}

static void cluster_reset_multi(redisCluster *c) {

redisClusterNode *node;

ZEND_HASH_FOREACH_PTR(c->nodes, node) {

if (node == NULL)

continue;

node->sock->watching = 0;

node->sock->mode = ATOMIC;

} ZEND_HASH_FOREACH_END();

c->flags->watching = 0;

c->flags->mode = ATOMIC;

}

cluster_process_cmd(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c,

redis_cmd_cb cmd_cb, cluster_cb resp_cb, int readonly)

{

RedisCmdCtx ctx;

RedisCmd *cmd;

short slot;

c->readonly = readonly && cluster_is_atomic(c);

cmd = cmd_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, c->flags);

if (cmd == NULL) {

RETURN_FALSE;

}

ctx = redis_cmd_pop_ctx(cmd);

slot = cmd->slot;

if (cluster_send_rcmd(c, cmd) < 0 || c->err != NULL) {

redis_cmd_ctx_free(ctx);

redis_cmd_free(cmd);

RETURN_FALSE;

}

redis_cmd_free(cmd);

if (c->flags->mode == MULTI) {

cluster_enqueue_response(c, slot, resp_cb, ctx);

RETURN_ZVAL(getThis(), 1, 0);

}

resp_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, c, ctx);

redis_cmd_ctx_free(ctx);

}

cluster_process_kw_cmd(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c,

const char *kw, size_t kw_len, redis_kw_cmd_cb cmd_cb,

cluster_cb resp_cb, int readonly)

{

RedisCmdCtx ctx;

RedisCmd *cmd;

short slot;

c->readonly = readonly && cluster_is_atomic(c);

cmd = cmd_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, c->flags, kw, kw_len);

if (cmd == NULL) {

RETURN_FALSE;

}

ctx = redis_cmd_pop_ctx(cmd);

slot = cmd->slot;

if (cluster_send_rcmd(c, cmd) < 0 || c->err != NULL)

{

redis_cmd_ctx_free(ctx);

redis_cmd_free(cmd);

RETURN_FALSE;

}

redis_cmd_free(cmd);

if (c->flags->mode == MULTI) {

cluster_enqueue_response(c, slot, resp_cb, ctx);

RETURN_ZVAL(getThis(), 1, 0);

}

resp_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, c, ctx);

redis_cmd_ctx_free(ctx);

}

static void

redis_cluster_init_object_handlers(void)

{

memcpy(&RedisCluster_handlers, zend_get_std_object_handlers(),

sizeof(RedisCluster_handlers));

RedisCluster_handlers.offset = offsetof(redisCluster, std);

RedisCluster_handlers.free_obj = free_cluster_context;

RedisCluster_handlers.clone_obj = NULL;

}

PHP_MINIT_FUNCTION(redis_cluster)

{

redis_cluster_ce = register_class_RedisCluster();

redis_cluster_ce->create_object = create_cluster_context;

redis_class_deny_serialization(redis_cluster_ce);

redis_cluster_exception_ce = register_class_RedisClusterException(spl_ce_RuntimeException);

/* RedisCluster handlers */

redis_cluster_init_object_handlers();

return SUCCESS;

}

static void ht_free_seed(zval *data) {

RedisSock *redis_sock = Z_PTR_P(data);

if (redis_sock) redis_free_socket(redis_sock);

}

static void ht_free_node(zval *data) {

redisClusterNode *node = Z_PTR_P(data);

cluster_free_node(node);

}

zend_object * create_cluster_context(zend_class_entry *class_type) {

redisCluster *cluster;

// Allocate our actual struct

cluster = ecalloc(1, sizeof(redisCluster) + zend_object_properties_size(class_type));

// We're not currently subscribed anywhere

cluster->subscribed_slot = -1;

// 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);

object_properties_init(&cluster->std, class_type);

cluster->std.handlers = &RedisCluster_handlers;

return &cluster->std;

}

void free_cluster_context(zend_object *object) {

redisCluster *cluster = PHPREDIS_GET_OBJECT(redisCluster, object);

cluster_free(cluster, 0);

zend_object_std_dtor(&cluster->std);

}

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

double read_timeout, int persistent, zend_string *user,

zend_string *pass, zval *context)

{

zend_string *hash = NULL, **seeds;

redisCachedCluster *cc;

uint32_t nseeds;

const char *err;

/* Validate our arguments and get a sanitized seed array */

seeds = cluster_validate_args(timeout, read_timeout, ht_seeds, &nseeds, &err);

if (seeds == NULL) {

CLUSTER_THROW_EXCEPTION(err, 0);

return;

}

if (user && ZSTR_LEN(user))

c->flags->user = zend_string_copy(user);

if (pass && ZSTR_LEN(pass))

c->flags->pass = zend_string_copy(pass);

if (context)

redis_sock_set_context_zval(c->flags, context);

c->flags->type = REDIS_SOCK_CLUSTER;

c->flags->timeout = timeout;

c->flags->read_timeout = read_timeout;

c->flags->persistent = persistent;

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

/* Attempt to load slots from cache if caching is enabled */

if (cluster_caching_enabled()) {

/* Exit early if we can load from cache */

hash = cluster_hash_seeds(seeds, nseeds);

if ((cc = cluster_cache_load(hash))) {

cluster_init_cache(c, cc);

goto cleanup;

}

}

/* Initialize seeds and attempt to map keyspace */

cluster_init_seeds(c, seeds, nseeds);

if (cluster_map_keyspace(c) == SUCCESS && hash)

cluster_cache_store(hash, c->nodes);

cleanup:

if (hash) zend_string_release(hash);

free_seed_array(seeds, nseeds);

}

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

zval z_seeds, z_tmp, *z_value;

zend_string *user = NULL, *pass = NULL;

double timeout = 0, read_timeout = 0;

int persistent = 0;

const char *iptr;

HashTable *ht_seeds = NULL;

/* Seeds */

array_init(&z_seeds);

if ((iptr = zend_ini_string_literal("redis.clusters.seeds")) != NULL) {

sapi_module.treat_data(PARSE_STRING, estrdup(iptr), &z_seeds);

}

if ((z_value = zend_hash_str_find(Z_ARRVAL(z_seeds), name, name_len)) != NULL) {

ht_seeds = Z_ARRVAL_P(z_value);

} else {

zval_ptr_dtor_nogc(&z_seeds);

CLUSTER_THROW_EXCEPTION("Couldn't find seeds for cluster", 0);

return;

}

/* Connection timeout */

if ((iptr = zend_ini_string_literal("redis.clusters.timeout")) != NULL) {

array_init(&z_tmp);

sapi_module.treat_data(PARSE_STRING, estrdup(iptr), &z_tmp);

redis_conf_double(Z_ARRVAL(z_tmp), name, name_len, &timeout);

zval_ptr_dtor_nogc(&z_tmp);

}

/* Read timeout */

if ((iptr = zend_ini_string_literal("redis.clusters.read_timeout")) != NULL) {

array_init(&z_tmp);

sapi_module.treat_data(PARSE_STRING, estrdup(iptr), &z_tmp);

redis_conf_double(Z_ARRVAL(z_tmp), name, name_len, &read_timeout);

zval_ptr_dtor_nogc(&z_tmp);

}

/* Persistent connections */

if ((iptr = zend_ini_string_literal("redis.clusters.persistent")) != NULL) {

array_init(&z_tmp);

sapi_module.treat_data(PARSE_STRING, estrdup(iptr), &z_tmp);

redis_conf_bool(Z_ARRVAL(z_tmp), name, name_len, &persistent);

zval_ptr_dtor_nogc(&z_tmp);

}

if ((iptr = zend_ini_string_literal("redis.clusters.auth"))) {

array_init(&z_tmp);

sapi_module.treat_data(PARSE_STRING, estrdup(iptr), &z_tmp);

redis_conf_auth(Z_ARRVAL(z_tmp), name, name_len, &user, &pass);

zval_ptr_dtor_nogc(&z_tmp);

}

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

redis_cluster_init(c, ht_seeds, timeout, read_timeout, persistent, user, pass, NULL);

/* Clean up */

zval_ptr_dtor_nogc(&z_seeds);

if (user) zend_string_release(user);

if (pass) zend_string_release(pass);

}

PHP_METHOD(RedisCluster, __construct) {

zval *z_seeds = NULL, *z_auth = NULL, *context = NULL;

zend_string *user = NULL, *pass = NULL;

double timeout = 0.0, read_timeout = 0.0;

size_t name_len;

zend_bool persistent = 0;

redisCluster *c = GET_CONTEXT();

char *name;

ZEND_PARSE_PARAMETERS_START(1, 7)

Z_PARAM_STRING_OR_NULL(name, name_len)

Z_PARAM_OPTIONAL

Z_PARAM_ARRAY_OR_NULL(z_seeds)

ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);

/* If we've got a string try to load from INI */

if (ZEND_NUM_ARGS() < 2 || z_seeds == NULL) {

if (name_len == 0) { // Require a name

CLUSTER_THROW_EXCEPTION("You must specify a name or pass seeds!", 0);

}

redis_cluster_load(c, name, name_len);

return;

}

/* The normal case, loading from arguments */

redis_extract_auth_info(z_auth, &user, &pass);

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

persistent, user, pass, context);

if (user) zend_string_release(user);

if (pass) zend_string_release(pass);

}

PHP_METHOD(RedisCluster, close) {

cluster_disconnect(GET_CONTEXT(), 1);

RETURN_TRUE;

}

PHP_METHOD(RedisCluster, get) {

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

}

PHP_METHOD(RedisCluster, getdel) {

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

}

PHP_METHOD(RedisCluster, getWithMeta) {

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

}

PHP_METHOD(RedisCluster, set) {

CLUSTER_PROCESS_CMD(set, cluster_set_resp, 0);

}

static void cluster_multi_ctx_dtor(void *ptr)

{

clusterMultiCtx *mctx = ptr;

if (mctx->last) {

efree(mctx->z_multi);

}

efree(mctx);

}

static int

distcmd_resp_handler(INTERNAL_FUNCTION_PARAMETERS, redisCluster *c, short slot,

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

{

clusterMultiCtx *mctx;

RedisCmdCtx ctx = {0};

// Finalize multi command

cluster_multi_fini(mc);

// Spin up multi context

mctx = emalloc(sizeof(clusterMultiCtx));

mctx->z_multi = z_ret;

mctx->count = mc->argc;

mctx->last = last;

// Attempt to send the command

if (cluster_send_rcmd_ex(c, slot, mc->cmd) < 0 || c->err != NULL)

{

efree(mctx);

return -1;

}

ctx.ptr = mctx;

ctx.dtor = cluster_multi_ctx_dtor;

if (cluster_is_atomic(c)) {

// Process response now

cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, c, ctx);

redis_cmd_ctx_free(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)

{

zval *z_val;

zend_ulong idx;

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

// a LONG style key

zend_string *zkey;

switch (zend_hash_get_current_key_ex(ht, &zkey, &idx, ptr)) {

case HASH_KEY_IS_STRING:

kv->key_len = ZSTR_LEN(zkey);

kv->key = ZSTR_VAL(zkey);

break;

case HASH_KEY_IS_LONG:

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

kv->key = kv->kbuf;

break;

default:

CLUSTER_THROW_EXCEPTION("Internal Zend HashTable error", 0);

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 ((z_val = zend_hash_get_current_data_ex(ht, ptr)) == NULL) {

CLUSTER_THROW_EXCEPTION("Internal Zend HashTable error", 0);

return -1;

}

// Serialize our value if required

kv->val_free = redis_pack(c->flags,z_val,&(kv->val),&(kv->val_len));

// Success

return 0;

}

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

clusterKeyValHT *kv)

{

zval *z_key;

if ((z_key = zend_hash_get_current_data_ex(ht, ptr)) == NULL) {

// Shouldn't happen, but check anyway

CLUSTER_THROW_EXCEPTION("Internal Zend HashTable error", 0);

return -1;

}

// Always want to work with strings

convert_to_string(z_key);

kv->key = Z_STRVAL_P(z_key);

kv->key_len = Z_STRLEN_P(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]);

}

/* 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 = ecalloc(argc, sizeof(zval));

if (zend_get_parameters_array(ht, argc, 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(z_args[0]) == IS_ARRAY) {

ht_arr = Z_ARRVAL(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;

}

/* 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) < 0) {

efree(z_args);

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) < 0) {

cluster_multi_free(&mc);

if (ht_free) {

zend_hash_destroy(ht_arr);

efree(ht_arr);

}

efree(z_args);

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);

}

efree(z_args);

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);

}

efree(z_args);

// 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;

ZEND_PARSE_PARAMETERS_START(1, 1)

Z_PARAM_ARRAY(z_arr)

ZEND_PARSE_PARAMETERS_END_EX(return FAILURE);

// 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) ==-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) efree(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) ==-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)

{

cluster_multi_free(&mc);

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) efree(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)

{

cluster_multi_free(&mc);

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;

}

static void cluster_generic_delete(INTERNAL_FUNCTION_PARAMETERS,

char *kw, int kw_len)

{

zval *z_ret = emalloc(sizeof(*z_ret));

// Initialize a LONG value to zero for our return

ZVAL_LONG(z_ret, 0);

// Parse args, process

if (cluster_mkey_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, kw, kw_len, z_ret,

cluster_del_resp) < 0)

{

efree(z_ret);

RETURN_FALSE;

}

}

PHP_METHOD(RedisCluster, del) {

cluster_generic_delete(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_STRL("DEL"));

}

PHP_METHOD(RedisCluster, delex) {

CLUSTER_PROCESS_CMD(delex, cluster_long_resp, 0);

}

PHP_METHOD(RedisCluster, delifeq) {

CLUSTER_PROCESS_KW_CMD("DELIFEQ", redis_kv_cmd, cluster_long_resp, 0);

}

PHP_METHOD(RedisCluster, unlink) {

cluster_generic_delete(INTERNAL_FUNCTION_PARAM_PASSTHRU, "UNLINK", sizeof("UNLINK") - 1);

}

PHP_METHOD(RedisCluster, msetex) {

CLUSTER_PROCESS_CMD(msetex, cluster_long_resp, 0);

}

PHP_METHOD(RedisCluster, mget) {

zval *z_ret = emalloc(sizeof(*z_ret));

array_init(z_ret);

// Parse args, process

if (cluster_mkey_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, ZEND_STRL("MGET"),

z_ret, cluster_mbulk_mget_resp) < 0)

{

zval_ptr_dtor_nogc(z_ret);

efree(z_ret);

RETURN_FALSE;

}

}

PHP_METHOD(RedisCluster, mset) {

zval *z_ret = emalloc(sizeof(*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, ZEND_STRL("MSET"),

z_ret, cluster_mset_resp) == -1)

{

efree(z_ret);

RETURN_FALSE;

}

}

PHP_METHOD(RedisCluster, msetnx) {

zval *z_ret = emalloc(sizeof(*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, ZEND_STRL("MSETNX"),

z_ret, cluster_msetnx_resp) ==-1)

{

zval_ptr_dtor_nogc(z_ret);

efree(z_ret);

RETURN_FALSE;

}

}

PHP_METHOD(RedisCluster, getex) {

CLUSTER_PROCESS_CMD(getex, cluster_bulk_resp, 0);

}

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_varkey_cmd, cluster_long_resp, 1);

}

PHP_METHOD(RedisCluster, touch) {

CLUSTER_PROCESS_KW_CMD("TOUCH", redis_varkey_cmd, cluster_long_resp, 0);

}

static zend_always_inline int

cluster_send_slot_cmd(redisCluster *c, short slot, RedisCmd *cmd,

REDIS_REPLY_TYPE type)

{

const char *str;

size_t len;

cmd->slot = slot;

str = redis_cmd_str(cmd);

len = redis_cmd_len(cmd);

return cluster_send_slot(c, slot, str, len, type);

}

PHP_METHOD(RedisCluster, keys) {

redisCluster *c = GET_CONTEXT();

redisClusterNode *node;

clusterReply *resp;

zend_string *pat;

RedisCmd *cmd;

int i;

ZEND_PARSE_PARAMETERS_START(1, 1)

Z_PARAM_STR(pat)

ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);

/* Prefix and then build our command */

cmd = redis_cmd_create_literal(c->flags, "KEYS");

redis_cmd_cat_key_zstr(cmd, pat);

array_init(return_value);

/* Treat as readonly */

c->readonly = cluster_is_atomic(c);

/* Iterate over our known nodes */

ZEND_HASH_FOREACH_PTR(c->nodes, node) {

if (node == NULL) continue;

if (cluster_send_slot_cmd(c, node->slot, cmd, TYPE_MULTIBULK) < 0) {

php_error_docref(0, E_ERROR, "Can't send KEYS to %s:%d",

ZSTR_VAL(node->sock->host), node->sock->port);

zval_ptr_dtor_nogc(return_value);

redis_cmd_free(cmd);

RETURN_FALSE;

}

/* Ensure we can get a response */

resp = cluster_read_resp(c, 0);

if (!resp) {

php_error_docref(0, E_WARNING,

"Can't read response from %s:%d", ZSTR_VAL(node->sock->host),

node->sock->port);

continue;

}