#include "php_redis.h"

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "common.h"

#include "php_network.h"

#include <sys/types.h>

#ifdef HAVE_REDIS_IGBINARY

#include "igbinary/igbinary.h"

#endif

#ifdef HAVE_REDIS_MSGPACK

#include "msgpack/php_msgpack.h"

#endif

#ifdef HAVE_REDIS_LZF

#include <lzf.h>

#ifndef LZF_MARGIN

#define LZF_MARGIN 128

#endif

#endif

#ifdef HAVE_REDIS_ZSTD

#include <zstd.h>

#endif

#ifdef HAVE_REDIS_LZ4

#include <lz4.h>

#include <lz4hc.h>

/* uint8_t crf + int length */

#define REDIS_LZ4_HDR_SIZE (sizeof(uint8_t) + sizeof(int))

#if defined(LZ4HC_CLEVEL_MAX)

/* version >= 1.7.5 */

#define REDIS_LZ4_MAX_CLEVEL LZ4HC_CLEVEL_MAX

#elif defined (LZ4HC_MAX_CLEVEL)

/* version >= 1.7.3 */

#define REDIS_LZ4_MAX_CLEVEL LZ4HC_MAX_CLEVEL

#else

/* older versions */

#define REDIS_LZ4_MAX_CLEVEL 12

#endif

#endif

#include <zend_exceptions.h>

#include "php_redis.h"

#include "library.h"

#include "redis_commands.h"

#ifdef HAVE_REDIS_JSON

#include <ext/json/php_json.h>

#endif

#include <ext/standard/php_rand.h>

#include <ext/hash/php_hash.h>

#define UNSERIALIZE_NONE 0

#define UNSERIALIZE_KEYS 1

#define UNSERIALIZE_VALS 2

#define UNSERIALIZE_ALL 3

#define SCORE_DECODE_NONE 0

#define SCORE_DECODE_INT 1

#define SCORE_DECODE_DOUBLE 2

#ifndef PHP_WIN32

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

#include <sys/socket.h> /* SO_KEEPALIVE */

#else

#include <winsock.h>

#endif

extern zend_class_entry *redis_ce;

extern zend_class_entry *redis_exception_ce;

extern int le_redis_pconnect;

static int redis_mbulk_reply_zipped_raw_variant(RedisSock *redis_sock, zval *zret, int count);

/* Register a persistent resource in a a way that works for every PHP 7 version. */

void redis_register_persistent_resource(zend_string *id, void *ptr, int le_id) {

#if PHP_VERSION_ID < 70300

zend_resource res;

res.type = le_id;

res.ptr = ptr;

zend_hash_str_update_mem(&EG(persistent_list), ZSTR_VAL(id), ZSTR_LEN(id), &res, sizeof(res));

#else

zend_register_persistent_resource(ZSTR_VAL(id), ZSTR_LEN(id), ptr, le_id);

#endif

}

static ConnectionPool *

redis_sock_get_connection_pool(RedisSock *redis_sock)

{

ConnectionPool *pool;

zend_resource *le;

zend_string *persistent_id;

/* Generate our unique pool id depending on configuration */

persistent_id = redis_pool_spprintf(redis_sock, INI_STR("redis.pconnect.pool_pattern"));

/* Return early if we can find the pool */

if ((le = zend_hash_find_ptr(&EG(persistent_list), persistent_id))) {

zend_string_release(persistent_id);

return le->ptr;

}

/* Create the pool and store it in our persistent list */

pool = pecalloc(1, sizeof(*pool), 1);

zend_llist_init(&pool->list, sizeof(php_stream *), NULL, 1);

redis_register_persistent_resource(persistent_id, pool, le_redis_pconnect);

zend_string_release(persistent_id);

return pool;

}

/* Helper to reselect the proper DB number when we reconnect */

static int reselect_db(RedisSock *redis_sock) {

char *cmd, *response;

int cmd_len, response_len;

cmd_len = redis_spprintf(redis_sock, NULL, &cmd, "SELECT", "d",

redis_sock->dbNumber);

if (redis_sock_write(redis_sock, cmd, cmd_len) < 0) {

efree(cmd);

return -1;

}

efree(cmd);

if ((response = redis_sock_read(redis_sock, &response_len)) == NULL) {

return -1;

}

if (strncmp(response, "+OK", 3)) {

efree(response);

return -1;

}

efree(response);

return 0;

}

/* Attempt to read a single +OK response */

static int redis_sock_read_ok(RedisSock *redis_sock) {

char buf[64];

size_t len;

if (redis_sock_read_single_line(redis_sock, buf, sizeof(buf), &len, 0) < 0)

return FAILURE;

return REDIS_STRCMP_STATIC(buf, len, "OK") ? SUCCESS : FAILURE;

}

/* Append an AUTH command to a smart string if neccessary. This will either

* append the new style AUTH <user> <password>, old style AUTH <password>, or

* append no command at all. Function returns 1 if we appended a command

* and 0 otherwise. */

static int redis_sock_append_auth(RedisSock *redis_sock, smart_string *str) {

/* We need a password at least */

if (redis_sock->pass == NULL)

return 0;

REDIS_CMD_INIT_SSTR_STATIC(str, !!redis_sock->user + !!redis_sock->pass, "AUTH");

if (redis_sock->user)

redis_cmd_append_sstr_zstr(str, redis_sock->user);

redis_cmd_append_sstr_zstr(str, redis_sock->pass);

/* We appended a command */

return 1;

}

PHP_REDIS_API void

redis_sock_copy_auth(RedisSock *dst, RedisSock *src) {

redis_sock_set_auth(dst, src->user, src->pass);

}

PHP_REDIS_API void

redis_sock_set_auth(RedisSock *redis_sock, zend_string *user, zend_string *pass)

{

/* Release existing user/pass */

redis_sock_free_auth(redis_sock);

/* Set new user/pass */

redis_sock->user = user ? zend_string_copy(user) : NULL;

redis_sock->pass = pass ? zend_string_copy(pass) : NULL;

}

PHP_REDIS_API void

redis_sock_set_auth_zval(RedisSock *redis_sock, zval *zv) {

zend_string *user, *pass;

if (redis_extract_auth_info(zv, &user, &pass) == FAILURE)

return;

redis_sock_set_auth(redis_sock, user, pass);

if (user) zend_string_release(user);

if (pass) zend_string_release(pass);

}

PHP_REDIS_API void

redis_sock_free_auth(RedisSock *redis_sock) {

if (redis_sock->user) {

zend_string_release(redis_sock->user);

redis_sock->user = NULL;

}

if (redis_sock->pass) {

zend_string_release(redis_sock->pass);

redis_sock->pass = NULL;

}

}

PHP_REDIS_API char *

redis_sock_auth_cmd(RedisSock *redis_sock, int *cmdlen) {

char *cmd;

/* AUTH requires at least a password */

if (redis_sock->pass == NULL)

return NULL;

if (redis_sock->user) {

*cmdlen = redis_spprintf(redis_sock, NULL, &cmd, "AUTH", "SS", redis_sock->user, redis_sock->pass);

} else {

*cmdlen = redis_spprintf(redis_sock, NULL, &cmd, "AUTH", "S", redis_sock->pass);

}

return cmd;

}

/* Send Redis AUTH and process response */

PHP_REDIS_API int redis_sock_auth(RedisSock *redis_sock) {

char *cmd;

int cmdlen, rv = FAILURE;

if ((cmd = redis_sock_auth_cmd(redis_sock, &cmdlen)) == NULL)

return SUCCESS;

if (redis_sock_write(redis_sock, cmd, cmdlen) < 0)

goto cleanup;

rv = redis_sock_read_ok(redis_sock) == SUCCESS ? SUCCESS : FAILURE;

cleanup:

efree(cmd);

return rv;

}

/* Helper function and macro to test a RedisSock error prefix. */

#define REDIS_SOCK_ERRCMP_STATIC(rs, s) redis_sock_errcmp(rs, s, sizeof(s)-1)

static int redis_sock_errcmp(RedisSock *redis_sock, const char *err, size_t errlen) {

return ZSTR_LEN(redis_sock->err) >= errlen &&

memcmp(ZSTR_VAL(redis_sock->err), err, errlen) == 0;

}

/* Helper function that will throw an exception for a small number of ERR codes

* returned by Redis. Typically we just return FALSE to the caller in the event

* of an ERROR reply, but for the following error types:

* 1) MASTERDOWN

* 2) AUTH

* 3) LOADING

*/

static void

redis_error_throw(RedisSock *redis_sock)

{

/* Short circuit if we have no redis_sock or any error */

if (redis_sock == NULL || redis_sock->err == NULL)

return;

/* Redis 6 decided to add 'ERR AUTH' which has a normal 'ERR' prefix

* but is actually an authentication error that we will want to throw

* an exception for, so just short circuit if this is any other 'ERR'

* prefixed error. */

if (REDIS_SOCK_ERRCMP_STATIC(redis_sock, "ERR") &&

!REDIS_SOCK_ERRCMP_STATIC(redis_sock, "ERR AUTH")) return;

/* We may want to flip this logic and check for MASTERDOWN, AUTH,

* and LOADING but that may have side effects (esp for things like

* Disque) */

if (!REDIS_SOCK_ERRCMP_STATIC(redis_sock, "NOSCRIPT") &&

!REDIS_SOCK_ERRCMP_STATIC(redis_sock, "NOQUORUM") &&

!REDIS_SOCK_ERRCMP_STATIC(redis_sock, "NOGOODSLAVE") &&

!REDIS_SOCK_ERRCMP_STATIC(redis_sock, "WRONGTYPE") &&

!REDIS_SOCK_ERRCMP_STATIC(redis_sock, "BUSYGROUP") &&

!REDIS_SOCK_ERRCMP_STATIC(redis_sock, "NOGROUP"))

{

REDIS_THROW_EXCEPTION(ZSTR_VAL(redis_sock->err), 0);

}

}

PHP_REDIS_API int

redis_check_eof(RedisSock *redis_sock, int no_throw)

{

int count;

char *errmsg;

if (!redis_sock || !redis_sock->stream || redis_sock->status == REDIS_SOCK_STATUS_FAILED) {

if (!no_throw) {

REDIS_THROW_EXCEPTION( "Connection closed", 0);

}

return -1;

}

/* NOITCE: set errno = 0 here

*

* There is a bug in php socket stream to check liveness of a connection:

* if (0 >= recv(sock->socket, &buf, sizeof(buf), MSG_PEEK) && php_socket_errno() != EWOULDBLOCK) {

* alive = 0;

* }

* If last errno is EWOULDBLOCK and recv returns 0 because of connection closed, alive would not be

* set to 0. However, the connection is close indeed. The php_stream_eof is not reliable. This will

* cause a "read error on connection" exception when use a closed persistent connection.

*

* We work around this by set errno = 0 first.

*

* Bug fix of php: https://github.com/php/php-src/pull/1456

* */

errno = 0;

if (php_stream_eof(redis_sock->stream) == 0) {

/* Success */

return 0;

} else if (redis_sock->mode == MULTI || redis_sock->watching) {

errmsg = "Connection lost and socket is in MULTI/watching mode";

} else {

errmsg = "Connection lost";

/* TODO: configurable max retry count */

for (count = 0; count < 10; ++count) {

/* close existing stream before reconnecting */

if (redis_sock->stream) {

redis_sock_disconnect(redis_sock, 1);

}

// Wait for a while before trying to reconnect

if (redis_sock->retry_interval) {

// Random factor to avoid having several (or many) concurrent connections trying to reconnect at the same time

long retry_interval = (count ? redis_sock->retry_interval : (php_rand() % redis_sock->retry_interval));

usleep(retry_interval);

}

/* reconnect */

if (redis_sock_connect(redis_sock) == 0) {

/* check for EOF again. */

errno = 0;

if (php_stream_eof(redis_sock->stream) == 0) {

if (redis_sock_auth(redis_sock) != SUCCESS) {

errmsg = "AUTH failed while reconnecting";

break;

}

redis_sock->status = REDIS_SOCK_STATUS_READY;

/* If we're using a non-zero db, reselect it */

if (redis_sock->dbNumber && reselect_db(redis_sock) != 0) {

errmsg = "SELECT failed while reconnecting";

break;

}

/* Success */

return 0;

}

}

}

}

/* close stream and mark socket as failed */

redis_sock_disconnect(redis_sock, 1);

redis_sock->status = REDIS_SOCK_STATUS_FAILED;

if (!no_throw) {

REDIS_THROW_EXCEPTION( errmsg, 0);

}

return -1;

}

PHP_REDIS_API int

redis_sock_read_scan_reply(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

REDIS_SCAN_TYPE type, zend_long *iter)

{

REDIS_REPLY_TYPE reply_type;

long reply_info;

char *p_iter;

/* Our response should have two multibulk replies */

if(redis_read_reply_type(redis_sock, &reply_type, &reply_info)<0

|| reply_type != TYPE_MULTIBULK || reply_info != 2)

{

return -1;

}

/* The BULK response iterator */

if(redis_read_reply_type(redis_sock, &reply_type, &reply_info)<0

|| reply_type != TYPE_BULK)

{

return -1;

}

/* Attempt to read the iterator */

if(!(p_iter = redis_sock_read_bulk_reply(redis_sock, reply_info))) {

return -1;

}

/* Push the iterator out to the caller */

*iter = atol(p_iter);

efree(p_iter);

/* Read our actual keys/members/etc differently depending on what kind of

scan command this is. They all come back in slightly different ways */

switch(type) {

case TYPE_SCAN:

return redis_mbulk_reply_raw(INTERNAL_FUNCTION_PARAM_PASSTHRU,

redis_sock, NULL, NULL);

case TYPE_SSCAN:

return redis_sock_read_multibulk_reply(

INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, NULL);

case TYPE_ZSCAN:

return redis_mbulk_reply_zipped_keys_dbl(INTERNAL_FUNCTION_PARAM_PASSTHRU,

redis_sock, NULL, NULL);

case TYPE_HSCAN:

return redis_mbulk_reply_zipped_vals(INTERNAL_FUNCTION_PARAM_PASSTHRU,

redis_sock, NULL, NULL);

default:

return -1;

}

}

PHP_REDIS_API int redis_subscribe_response(INTERNAL_FUNCTION_PARAMETERS,

RedisSock *redis_sock, zval *z_tab,

void *ctx)

{

subscribeContext *sctx = (subscribeContext*)ctx;

zval *z_tmp, z_resp;

// Consume response(s) from subscribe, which will vary on argc

while(sctx->argc--) {

if (!redis_sock_read_multibulk_reply_zval(

INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, &z_resp)

) {

efree(sctx);

return -1;

}

// We'll need to find the command response

if ((z_tmp = zend_hash_index_find(Z_ARRVAL(z_resp), 0)) == NULL) {

zval_dtor(&z_resp);

efree(sctx);

return -1;

}

// Make sure the command response matches the command we called

if(strcasecmp(Z_STRVAL_P(z_tmp), sctx->kw) !=0) {

zval_dtor(&z_resp);

efree(sctx);

return -1;

}

zval_dtor(&z_resp);

}

zval z_ret, z_args[4];

sctx->cb.retval = &z_ret;

sctx->cb.params = z_args;

/* Multibulk response, {[pattern], type, channel, payload } */

while(1) {

zval *z_type, *z_chan, *z_pat = NULL, *z_data;

HashTable *ht_tab;

int tab_idx=1, is_pmsg;

if (!redis_sock_read_multibulk_reply_zval(

INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, &z_resp)) break;

ht_tab = Z_ARRVAL(z_resp);

if ((z_type = zend_hash_index_find(ht_tab, 0)) == NULL ||

Z_TYPE_P(z_type) != IS_STRING

) {

break;

}

// Check for message or pmessage

if(!strncmp(Z_STRVAL_P(z_type), "message", 7) ||

!strncmp(Z_STRVAL_P(z_type), "pmessage", 8))

{

is_pmsg = *Z_STRVAL_P(z_type)=='p';

} else {

break;

}

// Extract pattern if it's a pmessage

if(is_pmsg) {

if ((z_pat = zend_hash_index_find(ht_tab, tab_idx++)) == NULL) {

break;

}

}

// Extract channel and data

if ((z_chan = zend_hash_index_find(ht_tab, tab_idx++)) == NULL ||

(z_data = zend_hash_index_find(ht_tab, tab_idx++)) == NULL

) {

break;

}

// Different args for SUBSCRIBE and PSUBSCRIBE

z_args[0] = *getThis();

if(is_pmsg) {

z_args[1] = *z_pat;

z_args[2] = *z_chan;

z_args[3] = *z_data;

} else {

z_args[1] = *z_chan;

z_args[2] = *z_data;

}

// Set arg count

sctx->cb.param_count = tab_idx;

// Execute callback

if(zend_call_function(&(sctx->cb), &(sctx->cb_cache))

==FAILURE)

{

break;

}

// If we have a return value free it

zval_ptr_dtor(&z_ret);

zval_dtor(&z_resp);

}

// This is an error state, clean up

zval_dtor(&z_resp);

efree(sctx);

return -1;

}

PHP_REDIS_API int redis_unsubscribe_response(INTERNAL_FUNCTION_PARAMETERS,

RedisSock *redis_sock, zval *z_tab,

void *ctx)

{

subscribeContext *sctx = (subscribeContext*)ctx;

zval *z_chan, zv, *z_ret = &zv, z_resp;

int i;

array_init(z_ret);

for (i = 0; i < sctx->argc; i++) {

if (!redis_sock_read_multibulk_reply_zval(

INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, &z_resp) ||

(z_chan = zend_hash_index_find(Z_ARRVAL(z_resp), 1)) == NULL

) {

zval_dtor(z_ret);

return -1;

}

add_assoc_bool(z_ret, Z_STRVAL_P(z_chan), 1);

zval_dtor(&z_resp);

}

efree(sctx);

RETVAL_ZVAL(z_ret, 0, 1);

// Success

return 0;

}

PHP_REDIS_API zval *

redis_sock_read_multibulk_reply_zval(INTERNAL_FUNCTION_PARAMETERS,

RedisSock *redis_sock, zval *z_tab)

{

char inbuf[4096];

int numElems;

size_t len;

ZVAL_NULL(z_tab);

if (redis_sock_gets(redis_sock, inbuf, sizeof(inbuf) - 1, &len) < 0) {

return NULL;

}

if(inbuf[0] != '*') {

return NULL;

}

numElems = atoi(inbuf+1);

array_init(z_tab);

redis_mbulk_reply_loop(redis_sock, z_tab, numElems, UNSERIALIZE_ALL);

return z_tab;

}

/**

* redis_sock_read_bulk_reply

*/

PHP_REDIS_API char *

redis_sock_read_bulk_reply(RedisSock *redis_sock, int bytes)

{

int offset = 0, nbytes;

char *reply;

size_t got;

if (-1 == bytes || -1 == redis_check_eof(redis_sock, 0)) {

return NULL;

}

nbytes = bytes + 2;

/* Allocate memory for string */

reply = emalloc(nbytes);

/* Consume bulk string */

while (offset < nbytes) {

got = php_stream_read(redis_sock->stream, reply + offset, nbytes - offset);

if (got == 0 && php_stream_eof(redis_sock->stream)) break;

offset += got;

}

/* Protect against reading too few bytes */

if (offset < nbytes) {

/* Error or EOF */

REDIS_THROW_EXCEPTION("socket error on read socket", 0);

efree(reply);

return NULL;

}

/* Null terminate reply string */

reply[bytes] = '\0';

return reply;

}

/**

* redis_sock_read

*/

PHP_REDIS_API char *

redis_sock_read(RedisSock *redis_sock, int *buf_len)

{

char inbuf[4096];

size_t len;

*buf_len = 0;

if (redis_sock_gets(redis_sock, inbuf, sizeof(inbuf) - 1, &len) < 0) {

return NULL;

}

switch(inbuf[0]) {

case '-':

redis_sock_set_err(redis_sock, inbuf+1, len);

/* Filter our ERROR through the few that should actually throw */

redis_error_throw(redis_sock);

return NULL;

case '$':

*buf_len = atoi(inbuf + 1);

return redis_sock_read_bulk_reply(redis_sock, *buf_len);

case '*':

/* For null multi-bulk replies (like timeouts from brpoplpush): */

if(memcmp(inbuf + 1, "-1", 2) == 0) {

return NULL;

}

/* fall through */

case '+':

case ':':

/* Single Line Reply */

/* +OK or :123 */

if (len > 1) {

*buf_len = len;

return estrndup(inbuf, *buf_len);

}

default:

zend_throw_exception_ex(redis_exception_ce, 0,

"protocol error, got '%c' as reply type byte\n",

inbuf[0]

);

}

return NULL;

}

/* A simple union to store the various arg types we might handle in our

* redis_spprintf command formatting function */

union resparg {

char *str;

zend_string *zstr;

zval *zv;

int ival;

long lval;

double dval;

};

static zend_string *redis_hash_auth(zend_string *user, zend_string *pass) {

zend_string *algo, *hex;

smart_str salted = {0};

const php_hash_ops *ops;

unsigned char *digest;

void *ctx;

/* No op if there is not username/password */

if (user == NULL && pass == NULL)

return NULL;

/* Theoretically inpossible but check anyway */

algo = zend_string_init("sha256", sizeof("sha256") - 1, 0);

if ((ops = redis_hash_fetch_ops(algo)) == NULL) {

zend_string_release(algo);

return NULL;

}

/* Hash username + password with our salt global */

smart_str_alloc(&salted, 256, 0);

if (user) smart_str_append_ex(&salted, user, 0);

if (pass) smart_str_append_ex(&salted, pass, 0);

smart_str_appendl_ex(&salted, REDIS_G(salt), sizeof(REDIS_G(salt)), 0);

ctx = emalloc(ops->context_size);

#if PHP_VERSION_ID >= 80100

ops->hash_init(ctx,NULL);

#else

ops->hash_init(ctx);

#endif

ops->hash_update(ctx, (const unsigned char *)ZSTR_VAL(salted.s), ZSTR_LEN(salted.s));

digest = emalloc(ops->digest_size);

ops->hash_final(digest, ctx);

efree(ctx);

hex = zend_string_safe_alloc(ops->digest_size, 2, 0, 0);

php_hash_bin2hex(ZSTR_VAL(hex), digest, ops->digest_size);

ZSTR_VAL(hex)[2 * ops->digest_size] = 0;

efree(digest);

zend_string_release(algo);

smart_str_free(&salted);

return hex;

}

static void append_auth_hash(smart_str *dst, zend_string *user, zend_string *pass) {

zend_string *s;

if ((s = redis_hash_auth(user, pass)) != NULL) {

smart_str_appendc(dst, ':');

smart_str_append_ex(dst, s, 0);

zend_string_release(s);

}

}

/* A printf like function to generate our connection pool hash value. */

PHP_REDIS_API zend_string *

redis_pool_spprintf(RedisSock *redis_sock, char *fmt, ...) {

smart_str str = {0};

smart_str_alloc(&str, 128, 0);

/* We always include phpredis_<host>:<port> */

smart_str_appendl(&str, "phpredis_", sizeof("phpredis_") - 1);

smart_str_append_ex(&str, redis_sock->host, 0);

smart_str_appendc(&str, ':');

smart_str_append_long(&str, (zend_long)redis_sock->port);

/* Short circuit if we don't have a pattern */

if (fmt == NULL) {

smart_str_0(&str);

return str.s;

}

while (*fmt) {

switch (*fmt) {

case 'i':

if (redis_sock->persistent_id) {

smart_str_appendc(&str, ':');

smart_str_append_ex(&str, redis_sock->persistent_id, 0);

}

break;

case 'u':

smart_str_appendc(&str, ':');

if (redis_sock->user) {

smart_str_append_ex(&str, redis_sock->user, 0);

}

break;

case 'p':

append_auth_hash(&str, NULL, redis_sock->pass);

break;

case 'a':

append_auth_hash(&str, redis_sock->user, redis_sock->pass);

break;

default:

/* Maybe issue a php_error_docref? */

break;

}

fmt++;

}

smart_str_0(&str);

return str.s;

}

/* A printf like method to construct a Redis RESP command. It has been extended

* to take a few different format specifiers that are convenient to phpredis.

*

* s - C string followed by length as a

* S - Pointer to a zend_string

* k - Same as 's' but the value will be prefixed if phpredis is set up do do

* that and the working slot will be set if it has been passed.

* v - A z_val which will be serialized if phpredis is configured to serialize.

* f - A double value

* F - Alias to 'f'

* i - An integer

* d - Alias to 'i'

* l - A long

* L - Alias to 'l'

*/

PHP_REDIS_API int

redis_spprintf(RedisSock *redis_sock, short *slot, char **ret, char *kw, char *fmt, ...) {

smart_string cmd = {0};

va_list ap;

union resparg arg;

char *dup;

int argfree;

size_t arglen;

va_start(ap, fmt);

/* Header */

redis_cmd_init_sstr(&cmd, strlen(fmt), kw, strlen(kw));

while (*fmt) {

switch (*fmt) {

case 's':

arg.str = va_arg(ap, char*);

arglen = va_arg(ap, size_t);

redis_cmd_append_sstr(&cmd, arg.str, arglen);

break;

case 'S':

arg.zstr = va_arg(ap, zend_string*);

redis_cmd_append_sstr(&cmd, ZSTR_VAL(arg.zstr), ZSTR_LEN(arg.zstr));

break;

case 'k':

arg.str = va_arg(ap, char*);

arglen = va_arg(ap, size_t);

argfree = redis_key_prefix(redis_sock, &arg.str, &arglen);

redis_cmd_append_sstr(&cmd, arg.str, arglen);

if (slot) *slot = cluster_hash_key(arg.str, arglen);

if (argfree) efree(arg.str);

break;

case 'v':

arg.zv = va_arg(ap, zval*);

argfree = redis_pack(redis_sock, arg.zv, &dup, &arglen);

redis_cmd_append_sstr(&cmd, dup, arglen);

if (argfree) efree(dup);

break;

case 'f':

case 'F':

arg.dval = va_arg(ap, double);

redis_cmd_append_sstr_dbl(&cmd, arg.dval);

break;

case 'i':

case 'd':

arg.ival = va_arg(ap, int);

redis_cmd_append_sstr_int(&cmd, arg.ival);

break;

case 'l':

case 'L':

arg.lval = va_arg(ap, long);

redis_cmd_append_sstr_long(&cmd, arg.lval);

break;

}

fmt++;

}

/* varargs cleanup */

va_end(ap);

/* Null terminate */

smart_string_0(&cmd);

/* Push command string, return length */

*ret = cmd.c;

return cmd.len;

}

/*

* Given a smart string, number of arguments, a keyword, and the length of the keyword

* initialize our smart string with the proper Redis header for the command to follow

*/

int redis_cmd_init_sstr(smart_string *str, int num_args, char *keyword, int keyword_len) {

smart_string_appendc(str, '*');

smart_string_append_long(str, num_args + 1);

smart_string_appendl(str, _NL, sizeof(_NL) -1);

smart_string_appendc(str, '$');

smart_string_append_long(str, keyword_len);

smart_string_appendl(str, _NL, sizeof(_NL) - 1);

smart_string_appendl(str, keyword, keyword_len);

smart_string_appendl(str, _NL, sizeof(_NL) - 1);

return str->len;

}

/*

* Append a command sequence to a smart_string

*/

int redis_cmd_append_sstr(smart_string *str, char *append, int append_len) {

smart_string_appendc(str, '$');

smart_string_append_long(str, append_len);

smart_string_appendl(str, _NL, sizeof(_NL) - 1);

smart_string_appendl(str, append, append_len);

smart_string_appendl(str, _NL, sizeof(_NL) - 1);

/* Return our new length */

return str->len;

}

/*

* Append an integer to a smart string command

*/

int redis_cmd_append_sstr_int(smart_string *str, int append) {

char int_buf[32];

int int_len = snprintf(int_buf, sizeof(int_buf), "%d", append);

return redis_cmd_append_sstr(str, int_buf, int_len);

}

/*

* Append a long to a smart string command

*/

int redis_cmd_append_sstr_long(smart_string *str, long append) {

char long_buf[32];

int long_len = snprintf(long_buf, sizeof(long_buf), "%ld", append);

return redis_cmd_append_sstr(str, long_buf, long_len);

}

/*

* Append a 64-bit integer to our command

*/

int redis_cmd_append_sstr_i64(smart_string *str, int64_t append) {

char nbuf[64];

int len = snprintf(nbuf, sizeof(nbuf), "%" PRId64, append);

return redis_cmd_append_sstr(str, nbuf, len);

}

/*

* Append a double to a smart string command

*/

int

redis_cmd_append_sstr_dbl(smart_string *str, double value)

{

char tmp[64], *p;

int len;

/* Convert to string */

len = snprintf(tmp, sizeof(tmp), "%.17g", value);

/* snprintf depends on locale, replace comma with point */

if ((p = strchr(tmp, ',')) != NULL) *p = '.';

// Append the string

return redis_cmd_append_sstr(str, tmp, len);

}

/* Append a zval to a redis command. The value will be serialized if we are

* configured to do that */

int redis_cmd_append_sstr_zval(smart_string *str, zval *z, RedisSock *redis_sock) {

char *val;

size_t vallen;

int valfree, retval;

valfree = redis_pack(redis_sock, z, &val, &vallen);

retval = redis_cmd_append_sstr(str, val, vallen);

if (valfree) efree(val);

return retval;

}

int redis_cmd_append_sstr_zstr(smart_string *str, zend_string *zstr) {

return redis_cmd_append_sstr(str, ZSTR_VAL(zstr), ZSTR_LEN(zstr));

}

/* Append a string key to a redis command. This function takes care of prefixing the key

* for the caller and setting the slot argument if it is passed non null */

int redis_cmd_append_sstr_key(smart_string *str, char *key, size_t len, RedisSock *redis_sock, short *slot) {

int valfree, retval;

valfree = redis_key_prefix(redis_sock, &key, &len);

if (slot) *slot = cluster_hash_key(key, len);

retval = redis_cmd_append_sstr(str, key, len);

if (valfree) efree(key);

return retval;

}

/* Append an array key to a redis smart string command. This function

* handles the boilerplate conditionals around string or integer keys */

int redis_cmd_append_sstr_arrkey(smart_string *cmd, zend_string *kstr, zend_ulong idx)