/*

+----------------------------------------------------------------------+

| PHP Version 5 |

+----------------------------------------------------------------------+

| Copyright (c) 1997-2009 The PHP Group |

+----------------------------------------------------------------------+

| This source file is subject to version 3.01 of the PHP license, |

| that is bundled with this package in the file LICENSE, and is |

| available through the world-wide-web at the following url: |

| http://www.php.net/license/3_01.txt |

| If you did not receive a copy of the PHP license and are unable to |

| obtain it through the world-wide-web, please send a note to |

| license@php.net so we can mail you a copy immediately. |

+----------------------------------------------------------------------+

| Author: Michael Grunder <michael.grunder@gmail.com> |

| Maintainer: Nicolas Favre-Felix <n.favre-felix@owlient.eu> |

+----------------------------------------------------------------------+

*/

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

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

int le_cluster_slot_cache;

/* Exception handler */

zend_class_entry *redis_cluster_exception_ce;

/* Handlers for RedisCluster */

zend_object_handlers RedisCluster_handlers;

ZEND_BEGIN_ARG_INFO_EX(arginfo_ctor, 0, 0, 1)

ZEND_ARG_INFO(0, name)

ZEND_ARG_ARRAY_INFO(0, seeds, 0)

ZEND_ARG_INFO(0, timeout)

ZEND_ARG_INFO(0, read_timeout)

ZEND_ARG_INFO(0, persistent)

ZEND_ARG_INFO(0, auth)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_del, 0, 0, 1)

ZEND_ARG_INFO(0, key)

ZEND_ARG_VARIADIC_INFO(0, other_keys)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_mget, 0, 0, 1)

ZEND_ARG_ARRAY_INFO(0, keys, 0)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_keys, 0, 0, 1)

ZEND_ARG_INFO(0, pattern)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_key_or_address, 0, 0, 1)

ZEND_ARG_INFO(0, key_or_address)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_key_or_address_variadic, 0, 0, 1)

ZEND_ARG_INFO(0, key_or_address)

ZEND_ARG_INFO(0, arg)

ZEND_ARG_VARIADIC_INFO(0, other_args)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_info, 0, 0, 1)

ZEND_ARG_INFO(0, key_or_address)

ZEND_ARG_INFO(0, option)

ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_flush, 0, 0, 1)

ZEND_ARG_INFO(0, key_or_address)

ZEND_ARG_INFO(0, async)

ZEND_END_ARG_INFO()

/* Argument info for HSCAN, SSCAN, HSCAN */

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

/* Argument infor for SCAN */

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

/* Function table */

zend_function_entry redis_cluster_functions[] = {

PHP_ME(RedisCluster, __construct, arginfo_ctor, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, _masters, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, _prefix, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, _redir, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, _serialize, arginfo_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, _unserialize, arginfo_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, append, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bgrewriteaof, arginfo_key_or_address, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bgsave, arginfo_key_or_address, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bitcount, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bitop, arginfo_bitop, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bitpos, arginfo_bitpos, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, blpop, arginfo_blrpop, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, brpop, arginfo_blrpop, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, brpoplpush, arginfo_brpoplpush, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, clearlasterror, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bzpopmax, arginfo_blrpop, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, bzpopmin, arginfo_blrpop, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, client, arginfo_key_or_address_variadic, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, close, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, cluster, arginfo_key_or_address_variadic, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, command, arginfo_command, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, config, arginfo_key_or_address_variadic, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, dbsize, arginfo_key_or_address, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, decr, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, decrby, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, del, arginfo_del, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, discard, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, dump, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, echo, arginfo_echo, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, eval, arginfo_eval, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, evalsha, arginfo_evalsha, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, exec, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, exists, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, expire, arginfo_expire, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, expireat, arginfo_key_timestamp, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, flushall, arginfo_flush, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, flushdb, arginfo_flush, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, geoadd, arginfo_geoadd, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, geodist, arginfo_geodist, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, geohash, arginfo_key_members, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, geopos, arginfo_key_members, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, georadius, arginfo_georadius, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, georadius_ro, arginfo_georadius, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, georadiusbymember, arginfo_georadiusbymember, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, georadiusbymember_ro, arginfo_georadiusbymember, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, get, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getbit, arginfo_key_offset, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getlasterror, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getmode, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getoption, arginfo_getoption, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getrange, arginfo_key_start_end, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, getset, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hdel, arginfo_key_members, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hexists, arginfo_key_member, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hget, arginfo_key_member, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hgetall, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hincrby, arginfo_key_member_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hincrbyfloat, arginfo_key_member_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hkeys, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hlen, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hmget, arginfo_hmget, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hmset, arginfo_hmset, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hscan, arginfo_kscan_cl, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hset, arginfo_key_member_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hsetnx, arginfo_key_member_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hstrlen, arginfo_key_member, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, hvals, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, incr, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, incrby, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, incrbyfloat, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, info, arginfo_info, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, keys, arginfo_keys, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lastsave, arginfo_key_or_address, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lget, arginfo_lindex, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lindex, arginfo_lindex, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, linsert, arginfo_linsert, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, llen, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lpop, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lpush, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lpushx, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lrange, arginfo_key_start_end, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lrem, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, lset, arginfo_lset, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, ltrim, arginfo_ltrim, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, mget, arginfo_mget, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, mset, arginfo_pairs, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, msetnx, arginfo_pairs, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, multi, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, object, arginfo_object, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, persist, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pexpire, arginfo_key_timestamp, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pexpireat, arginfo_key_timestamp, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pfadd, arginfo_pfadd, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pfcount, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pfmerge, arginfo_pfmerge, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, ping, arginfo_key_or_address, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, psetex, arginfo_key_expire_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, psubscribe, arginfo_psubscribe, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pttl, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, publish, arginfo_publish, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, pubsub, arginfo_key_or_address_variadic, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, punsubscribe, arginfo_punsubscribe, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, randomkey, arginfo_key_or_address, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rawcommand, arginfo_rawcommand, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rename, arginfo_key_newkey, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, renamenx, arginfo_key_newkey, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, restore, arginfo_restore, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, role, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rpop, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rpoplpush, arginfo_rpoplpush, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rpush, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, rpushx, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sadd, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, saddarray, arginfo_sadd_array, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, save, arginfo_key_or_address, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, scan, arginfo_scan_cl, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, scard, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, script, arginfo_key_or_address_variadic, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sdiff, arginfo_nkeys, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sdiffstore, arginfo_dst_nkeys, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, set, arginfo_set, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, setbit, arginfo_key_offset_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, setex, arginfo_key_expire_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, setnx, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, setoption, arginfo_setoption, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, setrange, arginfo_key_offset_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sinter, arginfo_nkeys, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sinterstore, arginfo_dst_nkeys, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sismember, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, slowlog, arginfo_key_or_address_variadic, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, smembers, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, smove, arginfo_smove, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sort, arginfo_sort, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, spop, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, srandmember, arginfo_srand_member, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, srem, arginfo_key_value, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sscan, arginfo_kscan_cl, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, strlen, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, subscribe, arginfo_subscribe, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sunion, arginfo_nkeys, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, sunionstore, arginfo_dst_nkeys, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, time, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, ttl, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, type, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, unsubscribe, arginfo_unsubscribe, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, unlink, arginfo_del, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, unwatch, arginfo_void, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, watch, arginfo_watch, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xack, arginfo_xack, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xadd, arginfo_xadd, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xclaim, arginfo_xclaim, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xdel, arginfo_xdel, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xgroup, arginfo_xgroup, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xinfo, arginfo_xinfo, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xlen, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xpending, arginfo_xpending, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xrange, arginfo_xrange, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xread, arginfo_xread, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xreadgroup, arginfo_xreadgroup, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xrevrange, arginfo_xrange, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, xtrim, arginfo_xtrim, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zadd, arginfo_zadd, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zcard, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zcount, arginfo_key_min_max, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zincrby, arginfo_zincrby, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zinterstore, arginfo_zstore, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zlexcount, arginfo_key_min_max, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zpopmax, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zpopmin, arginfo_key, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrange, arginfo_zrange, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrangebylex, arginfo_zrangebylex, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrangebyscore, arginfo_zrangebyscore, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrank, arginfo_key_member, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrem, arginfo_key_members, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zremrangebylex, arginfo_key_min_max, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zremrangebyrank, arginfo_key_min_max, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zremrangebyscore, arginfo_key_min_max, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrevrange, arginfo_zrange, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrevrangebylex, arginfo_zrangebylex, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrevrangebyscore, arginfo_zrangebyscore, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zrevrank, arginfo_key_member, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zscan, arginfo_kscan_cl, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zscore, arginfo_key_member, ZEND_ACC_PUBLIC)

PHP_ME(RedisCluster, zunionstore, arginfo_zstore, ZEND_ACC_PUBLIC)

PHP_FE_END

};

/* Our context seeds will be a hash table with RedisSock* pointers */

static void ht_free_seed(zval *data) {

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

if (redis_sock) redis_free_socket(redis_sock);

}

/* Free redisClusterNode objects we've stored */

static void ht_free_node(zval *data) {

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

cluster_free_node(node);

}

/* Create redisCluster context */

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

memcpy(&RedisCluster_handlers, zend_get_std_object_handlers(), sizeof(RedisCluster_handlers));

RedisCluster_handlers.offset = XtOffsetOf(redisCluster, std);

RedisCluster_handlers.free_obj = free_cluster_context;

cluster->std.handlers = &RedisCluster_handlers;

return &cluster->std;

}

/* Free redisCluster context */

void free_cluster_context(zend_object *object) {

redisCluster *cluster = (redisCluster*)((char*)(object) - XtOffsetOf(redisCluster, std));

cluster_free(cluster, 0);

zend_object_std_dtor(&cluster->std);

}

/* Turn a seed array into a zend_string we can use to look up a slot cache */

static zend_string *cluster_hash_seeds(HashTable *ht) {

smart_str hash = {0};

zend_string *zstr;

zval *z_seed;

ZEND_HASH_FOREACH_VAL(ht, z_seed) {

zstr = zval_get_string(z_seed);

smart_str_appendc(&hash, '[');

smart_str_appendl(&hash, ZSTR_VAL(zstr), ZSTR_LEN(zstr));

smart_str_appendc(&hash, ']');

zend_string_release(zstr);

} ZEND_HASH_FOREACH_END();

/* Not strictly needed but null terminate anyway */

smart_str_0(&hash);

/* smart_str is a zend_string internally */

return hash.s;

}

#define SLOT_CACHING_ENABLED() (INI_INT("redis.clusters.cache_slots") == 1)

static redisCachedCluster *cluster_cache_load(HashTable *ht_seeds) {

zend_resource *le;

zend_string *h;

/* Short circuit if we're not caching slots or if our seeds don't have any

* elements, since it doesn't make sense to cache an empty string */

if (!SLOT_CACHING_ENABLED() || zend_hash_num_elements(ht_seeds) == 0)

return NULL;

/* Look for cached slot information */

h = cluster_hash_seeds(ht_seeds);

le = zend_hash_str_find_ptr(&EG(persistent_list), ZSTR_VAL(h), ZSTR_LEN(h));

zend_string_release(h);

if (le != NULL) {

/* Sanity check on our list type */

if (le->type != le_cluster_slot_cache) {

php_error_docref(0, E_WARNING, "Invalid slot cache resource");

return NULL;

}

/* Success, return the cached entry */

return le->ptr;

}

/* Not found */

return NULL;

}

/* Cache a cluster's slot information in persistent_list if it's enabled */

static int cluster_cache_store(HashTable *ht_seeds, HashTable *nodes) {

redisCachedCluster *cc;

zend_string *hash;

/* Short circuit if caching is disabled or there aren't any seeds */

if (!SLOT_CACHING_ENABLED() || zend_hash_num_elements(ht_seeds) == 0)

return !SLOT_CACHING_ENABLED() ? SUCCESS : FAILURE;

/* Construct our cache */

hash = cluster_hash_seeds(ht_seeds);

cc = cluster_cache_create(hash, nodes);

zend_string_release(hash);

/* Set up our resource */

#if PHP_VERSION_ID < 70300

zend_resource le;

le.type = le_cluster_slot_cache;

le.ptr = cc;

zend_hash_update_mem(&EG(persistent_list), cc->hash, (void*)&le, sizeof(zend_resource));

#else

zend_register_persistent_resource_ex(cc->hash, cc, le_cluster_slot_cache);

#endif

return SUCCESS;

}

/* Validate redis cluster construction arguments */

static int

cluster_validate_args(double timeout, double read_timeout, HashTable *seeds) {

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

CLUSTER_THROW_EXCEPTION("Invalid timeout", 0);

return FAILURE;

}

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

CLUSTER_THROW_EXCEPTION("Invalid read timeout", 0);

return FAILURE;

}

/* Make sure there are some seeds */

if (zend_hash_num_elements(seeds) == 0) {

CLUSTER_THROW_EXCEPTION("Must pass seeds", 0);

return FAILURE;

}

return SUCCESS;

}

/* Attempt to connect to a Redis cluster provided seeds and timeout options */

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

double read_timeout, int persistent, char *auth,

size_t auth_len)

{

redisCachedCluster *cc;

cluster_validate_args(timeout, read_timeout, ht_seeds);

if (auth && auth_len > 0) {

c->auth = zend_string_init(auth, auth_len, 0);

}

c->timeout = timeout;

c->read_timeout = read_timeout;

c->persistent = persistent;

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

* (e.g. a node goes down), which is not the same as a standard timeout. */

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

/* Attempt to load from cache */

if ((cc = cluster_cache_load(ht_seeds))) {

cluster_init_cache(c, cc);

} else if (cluster_init_seeds(c, ht_seeds) == SUCCESS &&

cluster_map_keyspace(c) == SUCCESS)

{

cluster_cache_store(ht_seeds, c->nodes);

}

}

/* Attempt to load a named cluster configured in php.ini */

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

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

char *iptr, *auth = NULL;

size_t auth_len = 0;

double timeout = 0, read_timeout = 0;

int persistent = 0;

HashTable *ht_seeds = NULL;

/* Seeds */

array_init(&z_seeds);

if ((iptr = INI_STR("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_dtor(&z_seeds);

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

return;

}

/* Connection timeout */

array_init(&z_timeout);

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

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

}

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

if (Z_TYPE_P(z_value) == IS_STRING) {

timeout = atof(Z_STRVAL_P(z_value));

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

timeout = Z_DVAL_P(z_value);

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

timeout = Z_LVAL_P(z_value);

}

}

/* Read timeout */

array_init(&z_read_timeout);

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

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

}

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

if (Z_TYPE_P(z_value) == IS_STRING) {

read_timeout = atof(Z_STRVAL_P(z_value));

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

read_timeout = Z_DVAL_P(z_value);

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

read_timeout = Z_LVAL_P(z_value);

}

}

/* Persistent connections */

array_init(&z_persistent);

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

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

}

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

if (Z_TYPE_P(z_value) == IS_STRING) {

persistent = atoi(Z_STRVAL_P(z_value));

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

persistent = Z_LVAL_P(z_value);

}

}

/* Cluster auth */

array_init(&z_auth);

if ((iptr = INI_STR("redis.clusters.auth")) != NULL) {

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

}

if ((z_value = zend_hash_str_find(Z_ARRVAL(z_auth), name, name_len)) != NULL &&

Z_TYPE_P(z_value) == IS_STRING && Z_STRLEN_P(z_value) > 0

) {

auth = Z_STRVAL_P(z_value);

auth_len = Z_STRLEN_P(z_value);

}

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

redis_cluster_init(c, ht_seeds, timeout, read_timeout, persistent, auth, auth_len);

/* Clean up our arrays */

zval_dtor(&z_seeds);

zval_dtor(&z_timeout);

zval_dtor(&z_read_timeout);

zval_dtor(&z_persistent);

zval_dtor(&z_auth);

}

/*

* PHP Methods

*/

/* Create a RedisCluster Object */

PHP_METHOD(RedisCluster, __construct) {

zval *object, *z_seeds = NULL;

char *name, *auth = NULL;

size_t name_len, auth_len = 0;

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(), getThis(),

"Os!|addbs", &object, redis_cluster_ce, &name,

&name_len, &z_seeds, &timeout, &read_timeout,

&persistent, &auth, &auth_len) == FAILURE)

{

RETURN_FALSE;

}

// Require a name

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

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

}

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

* to a named cluster, stored in php.ini, otherwise we'll need manual seeds */

if (ZEND_NUM_ARGS() > 1) {

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

persistent, auth, auth_len);

} else {

redis_cluster_load(context, name, name_len);

}

}

/*

* RedisCluster method implementation

*/

/* {{{ proto bool RedisCluster::close() */

PHP_METHOD(RedisCluster, close) {

cluster_disconnect(GET_CONTEXT(), 1);

RETURN_TRUE;

}

/* {{{ proto string RedisCluster::get(string key) */

PHP_METHOD(RedisCluster, get) {

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

}

/* }}} */

/* {{{ proto bool RedisCluster::set(string key, string value) */

PHP_METHOD(RedisCluster, set) {

CLUSTER_PROCESS_CMD(set, cluster_bool_resp, 0);

}

/* }}} */

/* Generic handler for MGET/MSET/MSETNX */

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

}

/* Container struct for a key/value pair pulled from an array */

typedef struct clusterKeyValHT {

char kbuf[22];

char *key;

size_t key_len;

int key_free;

short slot;

char *val;

size_t val_len;

int val_free;

} clusterKeyValHT;

/* Helper to pull a key/value pair from a HashTable */

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;

}

/* Helper to pull, prefix, and hash a key from a HashTable value */

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;

}

/* Turn variable arguments into a HashTable for processing */

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;

}

/* Convienience handler for commands that take multiple keys such as

* MGET, DEL, and UNLINK */

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;

}

/* Handler for both MSET and MSETNX */

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(), "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) ==-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)

{

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)

{

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;

}

/* Generic passthru for DEL and UNLINK which act identically */

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,