#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "common.h"

#include "php_network.h"

#include <sys/types.h>

#ifndef _MSC_VER

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

#include <sys/socket.h>

#endif

#include <ext/standard/php_smart_str.h>

#include <ext/standard/php_var.h>

#ifdef HAVE_REDIS_IGBINARY

#include "igbinary/igbinary.h"

#endif

#include <zend_exceptions.h>

#include "php_redis.h"

#include "library.h"

#include "redis_commands.h"

#include <ext/standard/php_math.h>

#include <ext/standard/php_rand.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

#ifdef PHP_WIN32

# if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION <= 4

/* This proto is available from 5.5 on only */

PHP_REDIS_API int usleep(unsigned int useconds);

# endif

#endif

extern zend_class_entry *redis_ce;

extern zend_class_entry *redis_exception_ce;

extern zend_class_entry *spl_ce_RuntimeException;

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

static int reselect_db(RedisSock *redis_sock TSRMLS_DC) {

char *cmd, *response;

int cmd_len, response_len;

cmd_len = redis_cmd_format_static(&cmd, "SELECT", "d", redis_sock->dbNumber);

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

efree(cmd);

return -1;

}

efree(cmd);

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

return -1;

}

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

efree(response);

return -1;

}

efree(response);

return 0;

}

/* Helper to resend AUTH <password> in the case of a reconnect */

static int resend_auth(RedisSock *redis_sock TSRMLS_DC) {

char *cmd, *response;

int cmd_len, response_len;

cmd_len = redis_cmd_format_static(&cmd, "AUTH", "s", redis_sock->auth,

strlen(redis_sock->auth));

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

efree(cmd);

return -1;

}

efree(cmd);

response = redis_sock_read(redis_sock, &response_len TSRMLS_CC);

if (response == NULL) {

return -1;

}

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

efree(response);

return -1;

}

efree(response);

return 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(char *err, size_t err_len TSRMLS_DC) {

/* Handle stale data error (slave syncing with master) */

if (err_len == sizeof(REDIS_ERR_SYNC_MSG) - 1 &&

!memcmp(err,REDIS_ERR_SYNC_KW,sizeof(REDIS_ERR_SYNC_KW)-1))

{

zend_throw_exception(redis_exception_ce,

"SYNC with master in progress or master down!", 0 TSRMLS_CC);

} else if (err_len == sizeof(REDIS_ERR_LOADING_MSG) - 1 &&

!memcmp(err,REDIS_ERR_LOADING_KW,sizeof(REDIS_ERR_LOADING_KW)-1))

{

zend_throw_exception(redis_exception_ce,

"Redis is LOADING the dataset", 0 TSRMLS_CC);

} else if (err_len == sizeof(REDIS_ERR_AUTH_MSG) -1 &&

!memcmp(err,REDIS_ERR_AUTH_KW,sizeof(REDIS_ERR_AUTH_KW)-1))

{

zend_throw_exception(redis_exception_ce,

"Failed to AUTH connection", 0 TSRMLS_CC);

}

}

PHP_REDIS_API void redis_stream_close(RedisSock *redis_sock TSRMLS_DC) {

if (!redis_sock->persistent) {

php_stream_close(redis_sock->stream);

} else {

php_stream_pclose(redis_sock->stream);

}

}

PHP_REDIS_API int redis_check_eof(RedisSock *redis_sock, int no_throw TSRMLS_DC)

{

int eof;

int count = 0;

if (!redis_sock->stream) {

return -1;

}

eof = php_stream_eof(redis_sock->stream);

for (; eof; count++) {

if((MULTI == redis_sock->mode) || redis_sock->watching || count == 10) {

/* too many failures */

if(redis_sock->stream) { /* close stream if still here */

redis_stream_close(redis_sock TSRMLS_CC);

redis_sock->stream = NULL;

redis_sock->mode = ATOMIC;

redis_sock->status = REDIS_SOCK_STATUS_FAILED;

redis_sock->watching = 0;

}

if(!no_throw) {

zend_throw_exception(redis_exception_ce, "Connection lost",

0 TSRMLS_CC);

}

return -1;

}

if(redis_sock->stream) { /* close existing stream before reconnecting */

redis_stream_close(redis_sock TSRMLS_CC);

redis_sock->stream = NULL;

redis_sock->mode = ATOMIC;

redis_sock->watching = 0;

}

// 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(TSRMLS_C) % redis_sock->retry_interval));

usleep(retry_interval);

}

redis_sock_connect(redis_sock TSRMLS_CC); /* reconnect */

if(redis_sock->stream) { /* check for EOF again. */

eof = php_stream_eof(redis_sock->stream);

}

}

/* We've connected if we have a count */

if (count) {

/* If we're using a password, attempt a reauthorization */

if (redis_sock->auth && resend_auth(redis_sock TSRMLS_CC) != 0) {

return -1;

}

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

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

return -1;

}

}

/* Success */

return 0;

}

PHP_REDIS_API int

redis_sock_read_scan_reply(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

REDIS_SCAN_TYPE type, long *iter)

{

REDIS_REPLY_TYPE reply_type;

int reply_info;

char *p_iter;

/* Our response should have two multibulk replies */

if(redis_read_reply_type(redis_sock, &reply_type, &reply_info TSRMLS_CC)<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 TSRMLS_CC)<0

|| reply_type != TYPE_BULK)

{

return -1;

}

/* Attempt to read the iterator */

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

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_ret, **z_args[4];

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

while(sctx->argc--) {

z_tab = redis_sock_read_multibulk_reply_zval(

INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock);

if(!z_tab) {

efree(sctx);

return -1;

}

// We'll need to find the command response

if(zend_hash_index_find(Z_ARRVAL_P(z_tab), 0, (void**)&z_tmp)

==FAILURE)

{

zval_dtor(z_tab);

efree(z_tab);

efree(sctx);

return -1;

}

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

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

zval_dtor(z_tab);

efree(z_tab);

efree(sctx);

return -1;

}

zval_dtor(z_tab);

efree(z_tab);

}

sctx->cb.retval_ptr_ptr = &z_ret;

sctx->cb.params = z_args;

sctx->cb.no_separation = 0;

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

while(1) {

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

HashTable *ht_tab;

int tab_idx=1, is_pmsg;

z_tab = redis_sock_read_multibulk_reply_zval(

INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock);

if(z_tab == NULL) break;

ht_tab = Z_ARRVAL_P(z_tab);

if(zend_hash_index_find(ht_tab, 0, (void**)&z_type)==FAILURE ||

Z_TYPE_PP(z_type) != IS_STRING)

{

break;

}

// Check for message or pmessage

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

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

{

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

} else {

break;

}

// Extract pattern if it's a pmessage

if(is_pmsg) {

if(zend_hash_index_find(ht_tab, tab_idx++, (void**)&z_pat)

==FAILURE)

{

break;

}

}

// Extract channel and data

if(zend_hash_index_find(ht_tab, tab_idx++, (void**)&z_chan)==FAILURE ||

zend_hash_index_find(ht_tab, tab_idx++, (void**)&z_data)==FAILURE)

{

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

==FAILURE)

{

break;

}

// If we have a return value free it

if(z_ret) zval_ptr_dtor(&z_ret);

zval_dtor(z_tab);

efree(z_tab);

}

// This is an error state, clean up

if(z_tab) {

zval_dtor(z_tab);

efree(z_tab);

}

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, *z_ret;

int i=0;

MAKE_STD_ZVAL(z_ret);

array_init(z_ret);

while(i<sctx->argc) {

z_tab = redis_sock_read_multibulk_reply_zval(

INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock);

if(!z_tab || zend_hash_index_find(Z_ARRVAL_P(z_tab), 1,

(void**)&z_chan)==FAILURE)

{

zval_dtor(z_ret);

efree(z_ret);

return -1;

}

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

zval_dtor(z_tab);

efree(z_tab);

i++;

}

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

char inbuf[1024];

int numElems;

zval *z_tab;

if(-1 == redis_check_eof(redis_sock, 0 TSRMLS_CC)) {

return NULL;

}

if(php_stream_gets(redis_sock->stream, inbuf, 1024) == NULL) {

redis_stream_close(redis_sock TSRMLS_CC);

redis_sock->stream = NULL;

redis_sock->status = REDIS_SOCK_STATUS_FAILED;

redis_sock->mode = ATOMIC;

redis_sock->watching = 0;

zend_throw_exception(redis_exception_ce,

"read error on connection", 0 TSRMLS_CC);

return NULL;

}

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

return NULL;

}

numElems = atoi(inbuf+1);

MAKE_STD_ZVAL(z_tab);

array_init(z_tab);

redis_mbulk_reply_loop(INTERNAL_FUNCTION_PARAM_PASSTHRU, 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 TSRMLS_DC)

{

int offset = 0;

size_t got;

char * reply;

if(-1 == redis_check_eof(redis_sock, 0 TSRMLS_CC)) {

return NULL;

}

if (bytes == -1) {

return NULL;

} else {

char c;

int i;

reply = emalloc(bytes+1);

while(offset < bytes) {

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

bytes-offset);

if (got <= 0) {

/* Error or EOF */

zend_throw_exception(redis_exception_ce,

"socket error on read socket", 0 TSRMLS_CC);

break;

}

offset += got;

}

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

php_stream_read(redis_sock->stream, &c, 1);

}

}

reply[bytes] = 0;

return reply;

}

/**

* redis_sock_read

*/

PHP_REDIS_API char *redis_sock_read(RedisSock *redis_sock, int *buf_len TSRMLS_DC)

{

char inbuf[1024];

char *resp = NULL;

size_t err_len;

if(-1 == redis_check_eof(redis_sock, 0 TSRMLS_CC)) {

return NULL;

}

if(php_stream_gets(redis_sock->stream, inbuf, 1024) == NULL) {

redis_stream_close(redis_sock TSRMLS_CC);

redis_sock->stream = NULL;

redis_sock->status = REDIS_SOCK_STATUS_FAILED;

redis_sock->mode = ATOMIC;

redis_sock->watching = 0;

zend_throw_exception(redis_exception_ce, "read error on connection",

0 TSRMLS_CC);

return NULL;

}

switch(inbuf[0]) {

case '-':

err_len = strlen(inbuf+1) - 2;

redis_sock_set_err(redis_sock, inbuf+1, err_len);

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

redis_error_throw(inbuf + 1, err_len TSRMLS_CC);

/* Handle stale data error */

if(memcmp(inbuf + 1, "-ERR SYNC ", 10) == 0) {

zend_throw_exception(redis_exception_ce,

"SYNC with master in progress", 0 TSRMLS_CC);

}

return NULL;

case '$':

*buf_len = atoi(inbuf + 1);

resp = redis_sock_read_bulk_reply(redis_sock, *buf_len TSRMLS_CC);

return resp;

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

/* :123\r\n */

*buf_len = strlen(inbuf) - 2;

if(*buf_len >= 2) {

resp = emalloc(1+*buf_len);

memcpy(resp, inbuf, *buf_len);

resp[*buf_len] = 0;

return resp;

}

default:

zend_throw_exception_ex(

redis_exception_ce,

0 TSRMLS_CC,

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

inbuf[0]

);

}

return NULL;

}

void add_constant_long(zend_class_entry *ce, char *name, int value) {

zval *constval;

constval = pemalloc(sizeof(zval), 1);

INIT_PZVAL(constval);

ZVAL_LONG(constval, value);

zend_hash_add(&ce->constants_table, name, 1 + strlen(name),

(void*)&constval, sizeof(zval*), NULL);

}

int

integer_length(int i) {

int sz = 0;

int ci = abs(i);

while (ci > 0) {

ci /= 10;

sz++;

}

if (i == 0) { /* log 0 doesn't make sense. */

sz = 1;

} else if (i < 0) { /* allow for neg sign as well. */

sz++;

}

return sz;

}

int

redis_cmd_format_header(char **ret, char *keyword, int arg_count) {

/* Our return buffer */

smart_str buf = {0};

/* Keyword length */

int l = strlen(keyword);

smart_str_appendc(&buf, '*');

smart_str_append_long(&buf, arg_count + 1);

smart_str_appendl(&buf, _NL, sizeof(_NL) -1);

smart_str_appendc(&buf, '$');

smart_str_append_long(&buf, l);

smart_str_appendl(&buf, _NL, sizeof(_NL) -1);

smart_str_appendl(&buf, keyword, l);

smart_str_appendl(&buf, _NL, sizeof(_NL) - 1);

/* Set our return pointer */

*ret = buf.c;

/* Return the length */

return buf.len;

}

int

redis_cmd_format_static(char **ret, char *keyword, char *format, ...)

{

char *p = format;

va_list ap;

smart_str buf = {0};

int l = strlen(keyword);

char *dbl_str;

int dbl_len;

va_start(ap, format);

/* add header */

smart_str_appendc(&buf, '*');

smart_str_append_long(&buf, strlen(format) + 1);

smart_str_appendl(&buf, _NL, sizeof(_NL) - 1);

smart_str_appendc(&buf, '$');

smart_str_append_long(&buf, l);

smart_str_appendl(&buf, _NL, sizeof(_NL) - 1);

smart_str_appendl(&buf, keyword, l);

smart_str_appendl(&buf, _NL, sizeof(_NL) - 1);

while (*p) {

smart_str_appendc(&buf, '$');

switch(*p) {

case 's': {

char *val = va_arg(ap, char*);

int val_len = va_arg(ap, int);

smart_str_append_long(&buf, val_len);

smart_str_appendl(&buf, _NL, sizeof(_NL) - 1);

smart_str_appendl(&buf, val, val_len);

}

break;

case 'f':

case 'F': {

double d = va_arg(ap, double);

REDIS_DOUBLE_TO_STRING(dbl_str, dbl_len, d)

smart_str_append_long(&buf, dbl_len);

smart_str_appendl(&buf, _NL, sizeof(_NL) - 1);

smart_str_appendl(&buf, dbl_str, dbl_len);

efree(dbl_str);

}

break;

case 'i':

case 'd': {

int i = va_arg(ap, int);

char tmp[32];

int tmp_len = snprintf(tmp, sizeof(tmp), "%d", i);

smart_str_append_long(&buf, tmp_len);

smart_str_appendl(&buf, _NL, sizeof(_NL) - 1);

smart_str_appendl(&buf, tmp, tmp_len);

}

break;

case 'l':

case 'L': {

long l = va_arg(ap, long);

char tmp[32];

int tmp_len = snprintf(tmp, sizeof(tmp), "%ld", l);

smart_str_append_long(&buf, tmp_len);

smart_str_appendl(&buf, _NL, sizeof(_NL) -1);

smart_str_appendl(&buf, tmp, tmp_len);

}

break;

}

p++;

smart_str_appendl(&buf, _NL, sizeof(_NL) - 1);

}

smart_str_0(&buf);

*ret = buf.c;

return buf.len;

}

/**

* This command behave somehow like printf, except that strings need 2

* arguments:

* Their data and their size (strlen).

* Supported formats are: %d, %i, %s, %l

*/

int

redis_cmd_format(char **ret, char *format, ...) {

smart_str buf = {0};

va_list ap;

char *p = format;

char *dbl_str;

int dbl_len;

va_start(ap, format);

while (*p) {

if (*p == '%') {

switch (*(++p)) {

case 's': {

char *tmp = va_arg(ap, char*);

int tmp_len = va_arg(ap, int);

smart_str_appendl(&buf, tmp, tmp_len);

}

break;

case 'F':

case 'f': {

double d = va_arg(ap, double);

REDIS_DOUBLE_TO_STRING(dbl_str, dbl_len, d)

smart_str_append_long(&buf, dbl_len);

smart_str_appendl(&buf, _NL, sizeof(_NL) - 1);

smart_str_appendl(&buf, dbl_str, dbl_len);

efree(dbl_str);

}

break;

case 'd':

case 'i': {

int i = va_arg(ap, int);

char tmp[32];

int tmp_len = snprintf(tmp, sizeof(tmp), "%d", i);

smart_str_appendl(&buf, tmp, tmp_len);

}

break;

}

} else {

smart_str_appendc(&buf, *p);

}

p++;

}

smart_str_0(&buf);

*ret = buf.c;

return buf.len;

}

/*

* Append a command sequence to a Redis command

*/

int redis_cmd_append_str(char **cmd, int cmd_len, char *append, int append_len) {

/* Smart string buffer */

smart_str buf = {0};

/* Append the current command to our smart_str */

smart_str_appendl(&buf, *cmd, cmd_len);

/* Append our new command sequence */

smart_str_appendc(&buf, '$');

smart_str_append_long(&buf, append_len);

smart_str_appendl(&buf, _NL, sizeof(_NL) -1);

smart_str_appendl(&buf, append, append_len);

smart_str_appendl(&buf, _NL, sizeof(_NL) -1);

/* Free our old command */

efree(*cmd);

/* Set our return pointer */

*cmd = buf.c;

/* Return new command length */

return buf.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_str *str, int num_args, char *keyword, int keyword_len) {

smart_str_appendc(str, '*');

smart_str_append_long(str, num_args + 1);

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

smart_str_appendc(str, '$');

smart_str_append_long(str, keyword_len);

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

smart_str_appendl(str, keyword, keyword_len);

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

return str->len;

}

/*

* Append a command sequence to a smart_str

*/

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

smart_str_appendc(str, '$');

smart_str_append_long(str, append_len);

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

smart_str_appendl(str, append, append_len);

smart_str_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_str *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_str *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 double to a smart string command

*/

int redis_cmd_append_sstr_dbl(smart_str *str, double value) {

char *dbl_str;

int dbl_len, retval;

/* Convert to double */

REDIS_DOUBLE_TO_STRING(dbl_str, dbl_len, value);

// Append the string

retval = redis_cmd_append_sstr(str, dbl_str, dbl_len);

/* Free our double string */

efree(dbl_str);

/* Return new length */

return retval;

}

/*

* Append an integer command to a Redis command

*/

int redis_cmd_append_int(char **cmd, int cmd_len, int append) {

char int_buf[32];

int int_len;

// Conver to an int, capture length

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

/* Return the new length */

return redis_cmd_append_str(cmd, cmd_len, int_buf, int_len);

}

PHP_REDIS_API void redis_bulk_double_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, zval *z_tab, void *ctx) {

char *response;

int response_len;

double ret;

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

IF_MULTI_OR_PIPELINE() {

add_next_index_bool(z_tab, 0);

} else {

RETURN_FALSE;

}

return;

}

ret = atof(response);

efree(response);

IF_MULTI_OR_PIPELINE() {

add_next_index_double(z_tab, ret);

} else {

RETURN_DOUBLE(ret);

}

}

PHP_REDIS_API void redis_type_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, zval *z_tab, void *ctx) {

char *response;

int response_len;

long l;

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

IF_MULTI_OR_PIPELINE() {

add_next_index_bool(z_tab, 0);

} else {

RETURN_FALSE;

}

}

if (strncmp(response, "+string", 7) == 0) {

l = REDIS_STRING;

} else if (strncmp(response, "+set", 4) == 0){

l = REDIS_SET;

} else if (strncmp(response, "+list", 5) == 0){

l = REDIS_LIST;

} else if (strncmp(response, "+zset", 5) == 0){

l = REDIS_ZSET;

} else if (strncmp(response, "+hash", 5) == 0){

l = REDIS_HASH;

} else {

l = REDIS_NOT_FOUND;

}

efree(response);

IF_MULTI_OR_PIPELINE() {

add_next_index_long(z_tab, l);

} else {

RETURN_LONG(l);

}

}

PHP_REDIS_API void redis_info_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, zval *z_tab, void *ctx) {

char *response;

int response_len;

zval *z_ret;

/* Read bulk response */

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

RETURN_FALSE;

}

/* Parse it into a zval array */

z_ret = redis_parse_info_response(response);

/* Free source response */

efree(response);

IF_MULTI_OR_PIPELINE() {

add_next_index_zval(z_tab, z_ret);

} else {

RETVAL_ZVAL(z_ret, 0, 1);

}

}

PHP_REDIS_API zval *redis_parse_info_response(char *response) {

zval *z_ret;

char *key, *value, *p, *cur, *pos;

int is_numeric;

MAKE_STD_ZVAL(z_ret);

array_init(z_ret);

cur = response;

while(1) {

/* skip comments and empty lines */

if(*cur == '#' || *cur == '\r') {

if(!(cur = strchr(cur, '\n')))

break;

cur++;

continue;

}

/* key */

pos = strchr(cur, ':');

if(pos == NULL) {

break;

}

key = emalloc(pos - cur + 1);

memcpy(key, cur, pos-cur);

key[pos-cur] = 0;

/* value */

cur = pos + 1;

pos = strchr(cur, '\r');

if(pos == NULL) {

break;

}

value = emalloc(pos - cur + 1);

memcpy(value, cur, pos-cur);

value[pos-cur] = 0;

pos += 2; /* \r, \n */

cur = pos;

is_numeric = 1;

for(p = value; *p; ++p) {

if(*p < '0' || *p > '9') {

is_numeric = 0;

break;

}

}

if(is_numeric == 1) {

add_assoc_long(z_ret, key, atol(value));

efree(value);

} else {

add_assoc_string(z_ret, key, value, 0);

}

efree(key);

}

return z_ret;

}

/*

* Specialized handling of the CLIENT LIST output so it comes out in a simple way for PHP userland code

* to handle.

*/

PHP_REDIS_API void redis_client_list_reply(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, zval *z_tab) {

char *resp;