#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 <ext/standard/php_math.h>

#include <ext/standard/php_rand.h>

#ifdef PHP_WIN32

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

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

PHPAPI int usleep(unsigned int useconds);

# endif

#endif

#ifdef _MSC_VER

#define atoll _atoi64

#define random rand

#define usleep Sleep

#endif

#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

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

{

int eof;

int count = 0;

if (!redis_sock->stream) {

return -1;

}

eof = php_stream_eof(redis_sock->stream);

for (; eof; count++) {

/* Only try up to a certain point */

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

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;

}

zend_throw_exception(redis_exception_ce, "Connection lost", 0 TSRMLS_CC);

return -1;

}

/* Close existing stream before reconnecting */

if(redis_sock->stream) {

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 reconnected 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 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 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 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 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 '-':

/* Set the last error */

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

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;

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

char *pos, *cur;

char *key, *value, *p;

int is_numeric;

zval *z_multi_result;

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

RETURN_FALSE;

}

MAKE_STD_ZVAL(z_multi_result);

array_init(z_multi_result); /* pre-allocate array for multi's results. */

/* response :: [response_line]

* response_line :: key ':' value CRLF

*/

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_multi_result, key, atol(value));

efree(value);

} else {

add_assoc_string(z_multi_result, key, value, 0);

}

efree(key);

}

efree(response);

IF_MULTI_OR_PIPELINE() {

add_next_index_zval(z_tab, z_multi_result);

} else {

RETVAL_ZVAL(z_multi_result, 0, 1);

}

}

/*

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

int resp_len;

zval *z_result, *z_sub_result;

/* Pointers for parsing */

char *p, *lpos, *kpos = NULL, *vpos = NULL, *p2, *key, *value;

/* Key length, done flag */

int klen, done = 0, is_numeric;

/* Make sure we can read a response from Redis */

if((resp = redis_sock_read(redis_sock, &resp_len TSRMLS_CC)) == NULL) {

RETURN_FALSE;

}

/* Allocate memory for our response */

MAKE_STD_ZVAL(z_result);

array_init(z_result);

/* Allocate memory for one user (there should be at least one, namely us!) */

ALLOC_INIT_ZVAL(z_sub_result);

array_init(z_sub_result);

p = resp;

lpos = resp;

/* While we've got more to parse */

while(!done) {

/* What character are we on */

switch(*p) {

/* We're done */

case '\0':

done = 1;

break;

/* \n, ' ' mean we can pull a k/v pair */

case '\n':

case ' ':

/* Grab our value */

vpos = lpos;

/* There is some communication error or Redis bug if we don't

have a key and value, but check anyway. */

if(kpos && vpos) {

/* Allocate, copy in our key */

key = emalloc(klen + 1);

strncpy(key, kpos, klen);

key[klen] = 0;

/* Allocate, copy in our value */

value = emalloc(p-lpos+1);

strncpy(value,lpos,p-lpos+1);

value[p-lpos]=0;

/* Treat numbers as numbers, strings as strings */

is_numeric = 1;

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

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

is_numeric = 0;

break;

}

}

/* Add as a long or string, depending */

if(is_numeric == 1) {

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

efree(value);

} else {

add_assoc_string(z_sub_result, key, value, 0);

}

/* If we hit a '\n', then we can add this user to our list */

if(*p == '\n') {

/* Add our user */

add_next_index_zval(z_result, z_sub_result);

/* If we have another user, make another one */

if(*(p+1) != '\0') {

ALLOC_INIT_ZVAL(z_sub_result);

array_init(z_sub_result);

}

}

/* Free our key */

efree(key);

} else {

/* Something is wrong */

efree(resp);

RETURN_FALSE;

}

/* Move forward */

lpos = p + 1;

break;

/* We can pull the key and null terminate at our sep */

case '=':

/* Key, key length */

kpos = lpos;

klen = p - lpos;

/* Move forward */

lpos = p + 1;

break;

}

/* Increment */

p++;

}

/* Free our respoonse */

efree(resp);

IF_MULTI_OR_PIPELINE() {

add_next_index_zval(z_tab, z_result);

} else {

RETVAL_ZVAL(z_result, 0, 1);

}

}

PHP_REDIS_API void redis_boolean_response_impl(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, zval *z_tab, void *ctx, SuccessCallback success_callback) {

char *response;

int response_len;

char ret;

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

IF_MULTI_OR_PIPELINE() {

add_next_index_bool(z_tab, 0);

return;

}

RETURN_FALSE;

}

ret = response[0];

efree(response);

IF_MULTI_OR_PIPELINE() {

if (ret == '+') {

if (success_callback != NULL) {

success_callback(redis_sock);

}

add_next_index_bool(z_tab, 1);

} else {

add_next_index_bool(z_tab, 0);

}

} else {

if (ret == '+') {

if (success_callback != NULL) {

success_callback(redis_sock);

}

RETURN_TRUE;

} else {

RETURN_FALSE;

}

}

}

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

redis_boolean_response_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, z_tab, ctx, NULL);

}

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

char *response;

int response_len;

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

IF_MULTI_OR_PIPELINE() {

add_next_index_bool(z_tab, 0);

return;

} else {

RETURN_FALSE;

}

}