/* -*- Mode: C; tab-width: 4 -*- */

/*

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

| 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. |

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

| Original 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 "redis_commands.h"

#include "php_network.h"

#ifndef PHP_WIN32

#include <netinet/tcp.h> /* TCP_KEEPALIVE */

#else

#include <winsock.h>

#endif

#include <zend_exceptions.h>

/* Local passthrough macro for command construction. Given that these methods

* are generic (so they work whether the caller is Redis or RedisCluster) we

* will always have redis_sock, slot*, and TSRMLS_CC */

#define REDIS_CMD_SPPRINTF(ret, kw, fmt, ...) \

redis_spprintf(redis_sock, slot TSRMLS_CC, ret, kw, fmt, ##__VA_ARGS__)

/* Generic commands based on method signature and what kind of things we're

* processing. Lots of Redis commands take something like key, value, or

* key, value long. Each unique signature like this is written only once */

/* A command that takes no arguments */

int redis_empty_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "");

return SUCCESS;

}

/* Helper to construct a raw command. Given that the cluster and non cluster

* versions are different (RedisCluster needs an additional argument to direct

* the command) we take the start of our array and count */

int redis_build_raw_cmd(zval *z_args, int argc, char **cmd, int *cmd_len TSRMLS_DC)

{

smart_string cmdstr = {0};

int i;

/* Make sure our first argument is a string */

if (Z_TYPE(z_args[0]) != IS_STRING) {

php_error_docref(NULL TSRMLS_CC, E_WARNING,

"When sending a 'raw' command, the first argument must be a string!");

return FAILURE;

}

/* Initialize our command string */

redis_cmd_init_sstr(&cmdstr, argc-1, Z_STRVAL(z_args[0]), Z_STRLEN(z_args[0]));

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

switch (Z_TYPE(z_args[i])) {

case IS_STRING:

redis_cmd_append_sstr(&cmdstr, Z_STRVAL(z_args[i]),

Z_STRLEN(z_args[i]));

break;

case IS_LONG:

redis_cmd_append_sstr_long(&cmdstr,Z_LVAL(z_args[i]));

break;

case IS_DOUBLE:

redis_cmd_append_sstr_dbl(&cmdstr,Z_DVAL(z_args[i]));

break;

default:

php_error_docref(NULL TSRMLS_CC, E_WARNING,

"Raw command arguments must be scalar values!");

efree(cmdstr.c);

return FAILURE;

}

}

/* Push command and length to caller */

*cmd = cmdstr.c;

*cmd_len = cmdstr.len;

return SUCCESS;

}

smart_string *

redis_build_script_cmd(smart_string *cmd, int argc, zval *z_args)

{

int i;

zend_string *zstr;

if (Z_TYPE(z_args[0]) != IS_STRING) {

return NULL;

}

// Branch based on the directive

if (!strcasecmp(Z_STRVAL(z_args[0]), "flush") || !strcasecmp(Z_STRVAL(z_args[0]), "kill")) {

// Simple SCRIPT FLUSH, or SCRIPT_KILL command

REDIS_CMD_INIT_SSTR_STATIC(cmd, argc, "SCRIPT");

redis_cmd_append_sstr(cmd, Z_STRVAL(z_args[0]), Z_STRLEN(z_args[0]));

} else if (!strcasecmp(Z_STRVAL(z_args[0]), "load")) {

// Make sure we have a second argument, and it's not empty. If it is

// empty, we can just return an empty array (which is what Redis does)

if (argc < 2 || Z_TYPE(z_args[1]) != IS_STRING || Z_STRLEN(z_args[1]) < 1) {

return NULL;

}

// Format our SCRIPT LOAD command

REDIS_CMD_INIT_SSTR_STATIC(cmd, argc, "SCRIPT");

redis_cmd_append_sstr(cmd, "LOAD", sizeof("LOAD") - 1);

redis_cmd_append_sstr(cmd, Z_STRVAL(z_args[1]), Z_STRLEN(z_args[1]));

} else if (!strcasecmp(Z_STRVAL(z_args[0]), "exists")) {

// Make sure we have a second argument

if (argc < 2) {

return NULL;

}

/* Construct our SCRIPT EXISTS command */

REDIS_CMD_INIT_SSTR_STATIC(cmd, argc, "SCRIPT");

redis_cmd_append_sstr(cmd, "EXISTS", sizeof("EXISTS") - 1);

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

zstr = zval_get_string(&z_args[i]);

redis_cmd_append_sstr(cmd, ZSTR_VAL(zstr), ZSTR_LEN(zstr));

zend_string_release(zstr);

}

} else {

/* Unknown directive */

return NULL;

}

return cmd;

}

/* Generic command where we just take a string and do nothing to it*/

int redis_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, char *kw,

char **cmd, int *cmd_len, short *slot, void **ctx)

{

char *arg;

strlen_t arg_len;

// Parse args

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len)

==FAILURE)

{

return FAILURE;

}

// Build the command without molesting the string

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "s", arg, arg_len);

return SUCCESS;

}

/* Key, long, zval (serialized) */

int redis_key_long_val_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *key = NULL;

strlen_t key_len;

zend_long expire;

zval *z_val;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "slz", &key, &key_len,

&expire, &z_val)==FAILURE)

{

return FAILURE;

}

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "klv", key, key_len, expire, z_val);

return SUCCESS;

}

/* Generic key, long, string (unserialized) */

int redis_key_long_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *key, *val;

strlen_t key_len, val_len;

zend_long lval;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sls", &key, &key_len,

&lval, &val, &val_len)==FAILURE)

{

return FAILURE;

}

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "kds", key, key_len, (int)lval, val, val_len);

return SUCCESS;

}

/* Generic command construction when we just take a key and value */

int redis_kv_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *key;

strlen_t key_len;

zval *z_val;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &key, &key_len,

&z_val)==FAILURE)

{

return FAILURE;

}

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "kv", key, key_len, z_val);

return SUCCESS;

}

/* Generic command that takes a key and an unserialized value */

int redis_key_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *key, *val;

strlen_t key_len, val_len;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &key, &key_len,

&val, &val_len)==FAILURE)

{

return FAILURE;

}

// Construct command

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "ks", key, key_len, val, val_len);

return SUCCESS;

}

/* Key, string, string without serialization (ZCOUNT, ZREMRANGEBYSCORE) */

int redis_key_str_str_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *k, *v1, *v2;

strlen_t klen, v1len, v2len;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &k, &klen,

&v1, &v1len, &v2, &v2len)==FAILURE)

{

return FAILURE;

}

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "kss", k, klen, v1, v1len, v2, v2len);

// Success!

return SUCCESS;

}

/* Generic command that takes two keys */

int redis_key_key_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *k1, *k2;

strlen_t k1len, k2len;

int k1free, k2free;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &k1, &k1len,

&k2, &k2len)==FAILURE)

{

return FAILURE;

}

// Prefix both keys

k1free = redis_key_prefix(redis_sock, &k1, &k1len);

k2free = redis_key_prefix(redis_sock, &k2, &k2len);

// If a slot is requested, we can test that they hash the same

if(slot) {

// Slots where these keys resolve

short slot1 = cluster_hash_key(k1, k1len);

short slot2 = cluster_hash_key(k2, k2len);

// Check if Redis would give us a CROSSLOT error

if(slot1 != slot2) {

php_error_docref(0 TSRMLS_CC, E_WARNING, "Keys don't hash to the same slot");

if(k1free) efree(k1);

if(k2free) efree(k2);

return FAILURE;

}

// They're both the same

*slot = slot1;

}

/* Send keys as normal strings because we manually prefixed to check against

* cross slot error. */

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "ss", k1, k1len, k2, k2len);

/* Clean keys up if we prefixed */

if (k1free) efree(k1);

if (k2free) efree(k2);

return SUCCESS;

}

/* Generic command construction where we take a key and a long */

int redis_key_long_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *key;

strlen_t keylen;

zend_long lval;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &key, &keylen, &lval)

==FAILURE)

{

return FAILURE;

}

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "kl", key, keylen, lval);

// Success!

return SUCCESS;

}

/* key, long, long */

int redis_key_long_long_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *key;

strlen_t key_len;

zend_long val1, val2;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sll", &key, &key_len,

&val1, &val2)==FAILURE)

{

return FAILURE;

}

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "kll", key, key_len, val1, val2);

return SUCCESS;

}

/* Generic command where we take a single key */

int redis_key_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *key;

strlen_t key_len;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len)

==FAILURE)

{

return FAILURE;

}

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "k", key, key_len);

return SUCCESS;

}

/* Generic command where we take a key and a double */

int redis_key_dbl_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *key;

strlen_t key_len;

double val;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sd", &key, &key_len,

&val)==FAILURE)

{

return FAILURE;

}

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "kf", key, key_len, val);

return SUCCESS;

}

/* Generic to construct SCAN and variant commands */

int redis_fmt_scan_cmd(char **cmd, REDIS_SCAN_TYPE type, char *key, int key_len,

long it, char *pat, int pat_len, long count)

{

static char *kw[] = {"SCAN","SSCAN","HSCAN","ZSCAN"};

int argc;

smart_string cmdstr = {0};

// Figure out our argument count

argc = 1 + (type!=TYPE_SCAN) + (pat_len>0?2:0) + (count>0?2:0);

redis_cmd_init_sstr(&cmdstr, argc, kw[type], strlen(kw[type]));

// Append our key if it's not a regular SCAN command

if(type != TYPE_SCAN) {

redis_cmd_append_sstr(&cmdstr, key, key_len);

}

// Append cursor

redis_cmd_append_sstr_long(&cmdstr, it);

// Append count if we've got one

if(count) {

redis_cmd_append_sstr(&cmdstr,"COUNT",sizeof("COUNT")-1);

redis_cmd_append_sstr_long(&cmdstr, count);

}

// Append pattern if we've got one

if(pat_len) {

redis_cmd_append_sstr(&cmdstr,"MATCH",sizeof("MATCH")-1);

redis_cmd_append_sstr(&cmdstr,pat,pat_len);

}

// Push command to the caller, return length

*cmd = cmdstr.c;

return cmdstr.len;

}

/* ZRANGE/ZREVRANGE */

int redis_zrange_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, int *withscores,

short *slot, void **ctx)

{

char *key;

strlen_t key_len;

zend_long start, end;

zend_bool ws=0;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sll|b", &key, &key_len,

&start, &end, &ws)==FAILURE)

{

return FAILURE;

}

if(ws) {

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "kdds", key, key_len, start, end,

"WITHSCORES", sizeof("WITHSCORES") - 1);

} else {

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "kdd", key, key_len, start, end);

}

// Push out WITHSCORES option

*withscores = ws;

return SUCCESS;

}

/* ZRANGEBYSCORE/ZREVRANGEBYSCORE */

#define IS_WITHSCORES_ARG(s, l) \

(l == sizeof("withscores") - 1 && !strncasecmp(s, "withscores", l))

#define IS_LIMIT_ARG(s, l) \

(l == sizeof("limit") - 1 && !strncasecmp(s,"limit", l))

int redis_zrangebyscore_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, int *withscores,

short *slot, void **ctx)

{

char *key, *start, *end;

int has_limit=0;

long offset, count;

strlen_t key_len, start_len, end_len;

zval *z_opt=NULL, *z_ele;

zend_string *zkey;

ulong idx;

HashTable *ht_opt;

PHPREDIS_NOTUSED(idx);

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|a", &key, &key_len,

&start, &start_len, &end, &end_len, &z_opt)

==FAILURE)

{

return FAILURE;

}

// Check for an options array

if(z_opt && Z_TYPE_P(z_opt)==IS_ARRAY) {

ht_opt = Z_ARRVAL_P(z_opt);

ZEND_HASH_FOREACH_KEY_VAL(ht_opt, idx, zkey, z_ele) {

/* All options require a string key type */

if (!zkey) continue;

ZVAL_DEREF(z_ele);

/* Check for withscores and limit */

if (IS_WITHSCORES_ARG(ZSTR_VAL(zkey), ZSTR_LEN(zkey))) {

*withscores = zval_is_true(z_ele);

} else if (IS_LIMIT_ARG(ZSTR_VAL(zkey), ZSTR_LEN(zkey)) && Z_TYPE_P(z_ele) == IS_ARRAY) {

HashTable *htlimit = Z_ARRVAL_P(z_ele);

zval *zoff, *zcnt;

/* We need two arguments (offset and count) */

if ((zoff = zend_hash_index_find(htlimit, 0)) != NULL &&

(zcnt = zend_hash_index_find(htlimit, 1)) != NULL

) {

/* Set our limit if we can get valid longs from both args */

offset = zval_get_long(zoff);

count = zval_get_long(zcnt);

has_limit = 1;

}

}

} ZEND_HASH_FOREACH_END();

}

// Construct our command

if (*withscores) {

if (has_limit) {

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "ksssdds", key, key_len,

start, start_len, end, end_len, "LIMIT", 5, offset, count,

"WITHSCORES", 10);

} else {

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "ksss", key, key_len, start,

start_len, end, end_len, "WITHSCORES", 10);

}

} else {

if (has_limit) {

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "ksssdd", key, key_len, start,

start_len, end, end_len, "LIMIT", 5, offset, count);

} else {

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "kss", key, key_len, start,

start_len, end, end_len);

}

}

return SUCCESS;

}

/* ZUNIONSTORE, ZINTERSTORE */

int redis_zinter_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *key, *agg_op=NULL;

int key_free, argc = 2, keys_count;

strlen_t key_len, agg_op_len = 0;

zval *z_keys, *z_weights=NULL, *z_ele;

HashTable *ht_keys, *ht_weights=NULL;

smart_string cmdstr = {0};

// Parse args

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|a!s", &key,

&key_len, &z_keys, &z_weights, &agg_op,

&agg_op_len)==FAILURE)

{

return FAILURE;

}

// Grab our keys

ht_keys = Z_ARRVAL_P(z_keys);

// Nothing to do if there aren't any

if((keys_count = zend_hash_num_elements(ht_keys))==0) {

return FAILURE;

} else {

argc += keys_count;

}

// Handle WEIGHTS

if(z_weights != NULL) {

ht_weights = Z_ARRVAL_P(z_weights);

if(zend_hash_num_elements(ht_weights) != keys_count) {

php_error_docref(NULL TSRMLS_CC, E_WARNING,

"WEIGHTS and keys array should be the same size!");

return FAILURE;

}

// "WEIGHTS" + key count

argc += keys_count + 1;

}

// AGGREGATE option

if(agg_op_len != 0) {

if(strncasecmp(agg_op, "SUM", sizeof("SUM")) &&

strncasecmp(agg_op, "MIN", sizeof("MIN")) &&

strncasecmp(agg_op, "MAX", sizeof("MAX")))

{

php_error_docref(NULL TSRMLS_CC, E_WARNING,

"Invalid AGGREGATE option provided!");

return FAILURE;

}

// "AGGREGATE" + type

argc += 2;

}

// Prefix key

key_free = redis_key_prefix(redis_sock, &key, &key_len);

// Start building our command

redis_cmd_init_sstr(&cmdstr, argc, kw, strlen(kw));

redis_cmd_append_sstr(&cmdstr, key, key_len);

redis_cmd_append_sstr_int(&cmdstr, keys_count);

// Set our slot, free the key if we prefixed it

CMD_SET_SLOT(slot,key,key_len);

if(key_free) efree(key);

// Process input keys

ZEND_HASH_FOREACH_VAL(ht_keys, z_ele) {

zend_string *zstr = zval_get_string(z_ele);

char *key = ZSTR_VAL(zstr);

strlen_t key_len = ZSTR_LEN(zstr);

// Prefix key if necissary

int key_free = redis_key_prefix(redis_sock, &key, &key_len);

// If we're in Cluster mode, verify the slot is the same

if(slot && *slot != cluster_hash_key(key,key_len)) {

php_error_docref(NULL TSRMLS_CC, E_WARNING,

"All keys don't hash to the same slot!");

efree(cmdstr.c);

zend_string_release(zstr);

if(key_free) efree(key);

return FAILURE;

}

// Append this input set

redis_cmd_append_sstr(&cmdstr, key, key_len);

// Cleanup

zend_string_release(zstr);

if(key_free) efree(key);

} ZEND_HASH_FOREACH_END();

// Weights

if(ht_weights != NULL) {

redis_cmd_append_sstr(&cmdstr, "WEIGHTS", sizeof("WEIGHTS")-1);

// Process our weights

ZEND_HASH_FOREACH_VAL(ht_weights, z_ele) {

// Ignore non numeric args unless they're inf/-inf

ZVAL_DEREF(z_ele);

switch (Z_TYPE_P(z_ele)) {

case IS_LONG:

redis_cmd_append_sstr_long(&cmdstr, Z_LVAL_P(z_ele));

break;

case IS_DOUBLE:

redis_cmd_append_sstr_dbl(&cmdstr, Z_DVAL_P(z_ele));

break;

case IS_STRING: {

double dval;

zend_long lval;

zend_uchar type = is_numeric_string(Z_STRVAL_P(z_ele), Z_STRLEN_P(z_ele), &lval, &dval, 0);

if (type == IS_LONG) {

redis_cmd_append_sstr_long(&cmdstr, lval);

break;

} else if (type == IS_DOUBLE) {

redis_cmd_append_sstr_dbl(&cmdstr, dval);

break;

} else if (strncasecmp(Z_STRVAL_P(z_ele), "-inf", sizeof("-inf") - 1) == 0 ||

strncasecmp(Z_STRVAL_P(z_ele), "+inf", sizeof("+inf") - 1) == 0 ||

strncasecmp(Z_STRVAL_P(z_ele), "inf", sizeof("inf") - 1) == 0

) {

redis_cmd_append_sstr(&cmdstr, Z_STRVAL_P(z_ele), Z_STRLEN_P(z_ele));

break;

}

// fall through

}

default:

php_error_docref(NULL TSRMLS_CC, E_WARNING,

"Weights must be numeric or '-inf','inf','+inf'");

efree(cmdstr.c);

return FAILURE;

}

} ZEND_HASH_FOREACH_END();

}

// AGGREGATE

if(agg_op_len != 0) {

redis_cmd_append_sstr(&cmdstr, "AGGREGATE", sizeof("AGGREGATE")-1);

redis_cmd_append_sstr(&cmdstr, agg_op, agg_op_len);

}

// Push out values

*cmd = cmdstr.c;

*cmd_len = cmdstr.len;

return SUCCESS;

}

/* SUBSCRIBE/PSUBSCRIBE */

int redis_subscribe_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

zval *z_arr, *z_chan;

HashTable *ht_chan;

smart_string cmdstr = {0};

subscribeContext *sctx = emalloc(sizeof(subscribeContext));

strlen_t key_len;

int key_free;

char *key;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "af", &z_arr,

&(sctx->cb), &(sctx->cb_cache))==FAILURE)

{

efree(sctx);

return FAILURE;

}

ht_chan = Z_ARRVAL_P(z_arr);

sctx->kw = kw;

sctx->argc = zend_hash_num_elements(ht_chan);

if(sctx->argc==0) {

efree(sctx);

return FAILURE;

}

// Start command construction

redis_cmd_init_sstr(&cmdstr, sctx->argc, kw, strlen(kw));

// Iterate over channels

ZEND_HASH_FOREACH_VAL(ht_chan, z_chan) {

// We want to deal with strings here

zend_string *zstr = zval_get_string(z_chan);

// Grab channel name, prefix if required

key = ZSTR_VAL(zstr);

key_len = ZSTR_LEN(zstr);

key_free = redis_key_prefix(redis_sock, &key, &key_len);

// Add this channel

redis_cmd_append_sstr(&cmdstr, key, key_len);

zend_string_release(zstr);

// Free our key if it was prefixed

if(key_free) efree(key);

} ZEND_HASH_FOREACH_END();

// Push values out

*cmd_len = cmdstr.len;

*cmd = cmdstr.c;

*ctx = (void*)sctx;

// Pick a slot at random

CMD_RAND_SLOT(slot);

return SUCCESS;

}

/* UNSUBSCRIBE/PUNSUBSCRIBE */

int redis_unsubscribe_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

zval *z_arr, *z_chan;

HashTable *ht_arr;

smart_string cmdstr = {0};

subscribeContext *sctx = emalloc(sizeof(subscribeContext));

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

efree(sctx);

return FAILURE;

}

ht_arr = Z_ARRVAL_P(z_arr);

sctx->argc = zend_hash_num_elements(ht_arr);

if(sctx->argc == 0) {

efree(sctx);

return FAILURE;

}

redis_cmd_init_sstr(&cmdstr, sctx->argc, kw, strlen(kw));

ZEND_HASH_FOREACH_VAL(ht_arr, z_chan) {

char *key = Z_STRVAL_P(z_chan);

strlen_t key_len = Z_STRLEN_P(z_chan);

int key_free;

key_free = redis_key_prefix(redis_sock, &key, &key_len);

redis_cmd_append_sstr(&cmdstr, key, key_len);

if(key_free) efree(key);

} ZEND_HASH_FOREACH_END();

// Push out vals

*cmd_len = cmdstr.len;

*cmd = cmdstr.c;

*ctx = (void*)sctx;

return SUCCESS;

}

/* ZRANGEBYLEX/ZREVRANGEBYLEX */

int redis_zrangebylex_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *key, *min, *max;

strlen_t key_len, min_len, max_len;

int argc = ZEND_NUM_ARGS();

zend_long offset, count;

/* We need either 3 or 5 arguments for this to be valid */

if (argc != 3 && argc != 5) {

php_error_docref(0 TSRMLS_CC, E_WARNING, "Must pass either 3 or 5 arguments");

return FAILURE;

}

if(zend_parse_parameters(argc TSRMLS_CC, "sss|ll", &key, &key_len, &min, &min_len,

&max, &max_len, &offset, &count)==FAILURE)

{

return FAILURE;

}

/* min and max must start with '(' or '[', or be either '-' or '+' */

if (min_len < 1 || max_len < 1 ||

(min[0] != '(' && min[0] != '[' &&

(min[0] != '-' || min_len > 1) && (min[0] != '+' || min_len > 1)) ||

(max[0] != '(' && max[0] != '[' &&

(max[0] != '-' || max_len > 1) && (max[0] != '+' || max_len > 1)))

{

php_error_docref(0 TSRMLS_CC, E_WARNING,

"min and max arguments must start with '[' or '('");

return FAILURE;

}

/* Construct command */

if (argc == 3) {

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "kss", key, key_len, min, min_len,

max, max_len);

} else {

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "ksssll", key, key_len, min, min_len,

max, max_len, "LIMIT", 5, offset, count);

}

return SUCCESS;

}

/* ZLEXCOUNT/ZREMRANGEBYLEX */

int redis_gen_zlex_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

char *key, *min, *max;

strlen_t key_len, min_len, max_len;

/* Parse args */

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &key, &key_len,

&min, &min_len, &max, &max_len)==FAILURE)

{

return FAILURE;

}

/* Quick sanity check on min/max */

if(min_len<1 || max_len<1 || (min[0]!='(' && min[0]!='[') ||

(max[0]!='(' && max[0]!='['))

{

php_error_docref(NULL TSRMLS_CC, E_WARNING,

"Min and Max arguments must begin with '(' or '['");

return FAILURE;

}

/* Construct command */

*cmd_len = REDIS_CMD_SPPRINTF(cmd, kw, "kss", key, key_len, min, min_len,

max, max_len);

return SUCCESS;

}

/* EVAL and EVALSHA */

int redis_eval_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, char *kw,

char **cmd, int *cmd_len, short *slot, void **ctx)

{

char *lua;

int argc = 0;

zval *z_arr = NULL, *z_ele;

HashTable *ht_arr;

zend_long num_keys = 0;

smart_string cmdstr = {0};

strlen_t lua_len;

zend_string *zstr;

short prevslot = -1;

/* Parse args */

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|al", &lua, &lua_len,

&z_arr, &num_keys)==FAILURE)

{

return FAILURE;

}

/* Grab arg count */

if (z_arr != NULL) {

ht_arr = Z_ARRVAL_P(z_arr);

argc = zend_hash_num_elements(ht_arr);

}

/* EVAL[SHA] {script || sha1} {num keys} */

redis_cmd_init_sstr(&cmdstr, 2 + argc, kw, strlen(kw));

redis_cmd_append_sstr(&cmdstr, lua, lua_len);

redis_cmd_append_sstr_long(&cmdstr, num_keys);

// Iterate over our args if we have any

if (argc > 0) {

ZEND_HASH_FOREACH_VAL(ht_arr, z_ele) {

zstr = zval_get_string(z_ele);

/* If we're still on a key, prefix it check slot */

if (num_keys-- > 0) {

redis_cmd_append_sstr_key(&cmdstr, ZSTR_VAL(zstr), ZSTR_LEN(zstr), redis_sock, slot);

/* If we have been passed a slot, all keys must match */

if (slot) {

if (prevslot != -1 && prevslot != *slot) {

zend_string_release(zstr);

php_error_docref(0 TSRMLS_CC, E_WARNING, "All keys do not map to the same slot");

return FAILURE;

}

prevslot = *slot;

}

} else {

redis_cmd_append_sstr(&cmdstr, ZSTR_VAL(zstr), ZSTR_LEN(zstr));

}

zend_string_release(zstr);

} ZEND_HASH_FOREACH_END();

} else {

/* Any slot will do */

CMD_RAND_SLOT(slot);

}

*cmd = cmdstr.c;

*cmd_len = cmdstr.len;

return SUCCESS;

}

/* Commands that take a key followed by a variable list of serializable

* values (RPUSH, LPUSH, SADD, SREM, etc...) */

int redis_key_varval_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

zval *z_args;

smart_string cmdstr = {0};

strlen_t i;

int argc = ZEND_NUM_ARGS();

// We at least need a key and one value

if(argc < 2) {

return FAILURE;

}

// Make sure we at least have a key, and we can get other args

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

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

efree(z_args);

return FAILURE;

}

/* Initialize our command */

redis_cmd_init_sstr(&cmdstr, argc, kw, strlen(kw));

/* Append key */

zend_string *zstr = zval_get_string(&z_args[0]);

redis_cmd_append_sstr_key(&cmdstr, ZSTR_VAL(zstr), ZSTR_LEN(zstr), redis_sock, slot);

zend_string_release(zstr);

/* Add members */

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

redis_cmd_append_sstr_zval(&cmdstr, &z_args[i], redis_sock TSRMLS_CC);

}

// Push out values

*cmd = cmdstr.c;

*cmd_len = cmdstr.len;

// Cleanup arg array

efree(z_args);

// Success!

return SUCCESS;

}

/* Commands that take a key and then an array of values */

int redis_key_arr_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

char *kw, char **cmd, int *cmd_len, short *slot,

void **ctx)

{

zval *z_arr, *z_val;

HashTable *ht_arr;

smart_string cmdstr = {0};

int key_free, val_free, argc = 1;

strlen_t val_len, key_len;

char *key, *val;

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa", &key, &key_len,

&z_arr) == FAILURE ||