#include "php_redis.h"

#ifdef HAVE_CONFIG_H

#include "config.h"

#include "common.h"

#include "php_network.h"

#include <sys/types.h>

#include <errno.h>

#include <limits.h>

#ifdef HAVE_REDIS_IGBINARY

#include "igbinary/igbinary.h"

#ifdef HAVE_REDIS_MSGPACK

#include "msgpack/php_msgpack.h"

#ifdef HAVE_REDIS_LZF

#include <lzf.h>

#ifndef LZF_MARGIN

#define LZF_MARGIN 128

#endif

#ifdef HAVE_REDIS_ZSTD

#include <zstd.h>

#ifdef HAVE_REDIS_LZ4

#include <lz4.h>

#include <lz4hc.h>

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

#if defined(LZ4HC_CLEVEL_MAX)

#define REDIS_LZ4_MAX_CLEVEL LZ4HC_CLEVEL_MAX

#elif defined (LZ4HC_MAX_CLEVEL)

#define REDIS_LZ4_MAX_CLEVEL LZ4HC_MAX_CLEVEL

#define REDIS_LZ4_MAX_CLEVEL 12

#include <zend_exceptions.h>

#include "library.h"

#include "redis_commands.h"

#ifdef HAVE_REDIS_JSON

#include <ext/json/php_json.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

#define REDIS_CALLBACKS_INIT_SIZE 8

#define REDIS_CALLBACKS_MAX_DOUBLE 32768

#define REDIS_CALLBACKS_ADD_SIZE 4096

#define REDIS_ZVAL_NULL(sock_, zv_) \

do { \

if ((sock_)->null_mbulk_as_null) { \

ZVAL_NULL((zv_)); \

} else { \

ZVAL_FALSE((zv_)); \

} \

} while (0)

#define REDIS_RESPONSE_ERROR(redis_sock, z_tab) \

do { \

if (redis_sock_is_atomic(redis_sock)) { \

RETVAL_FALSE; \

} else { \

add_next_index_bool(z_tab, 0); \

} \

} while (0)

#define REDIS_RETURN_ZVAL(redis_sock, z_tab, zval) \

do { \

if (redis_sock_is_atomic(redis_sock)) { \

/* Move value of `zval` to `return_value` */ \

ZVAL_COPY_VALUE(return_value, &zval); \

} else { \

zend_hash_next_index_insert_new(Z_ARRVAL_P(z_tab), &zval); \

} \

} while (0)

#ifndef PHP_WIN32

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

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

#include <winsock.h>

extern zend_class_entry *redis_ce;

extern zend_class_entry *redis_exception_ce;

extern int le_redis_pconnect;

RedisCmdCtx redis_empty_ctx = {0};

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

static int redis_bulk_resp_to_zval(RedisSock *redis_sock, zval *zdst,

int *dstlen) ;

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

zend_register_persistent_resource(ZSTR_VAL(persistent_id),

ZSTR_LEN(persistent_id),

pool, le_redis_pconnect);

zend_string_release(persistent_id);

return pool;

}

static int redis_sock_response_ok(RedisSock *redis_sock, char *buf, int buf_size) {

size_t len;

if (UNEXPECTED(redis_sock_gets(redis_sock, buf, buf_size - 1, &len) < 0)) {

return 0;

}

if (UNEXPECTED(redis_strncmp(buf, ZEND_STRL("+OK")))) {

if (buf[0] == '-') {

redis_sock_set_err(redis_sock, buf + 1, len - 1);

}

return 0;

}

return 1;

}

static int redis_select_db(RedisSock *redis_sock) {

char response[4096];

RedisCmd *cmd;

cmd = redis_cmd_create_literal(redis_sock, "SELECT");

redis_cmd_cat_long(cmd, redis_sock->dbNumber);

if (redis_sock_write(redis_sock, redis_cmd_str(cmd), redis_cmd_len(cmd)) < 0) {

redis_cmd_free(cmd);

return -1;

}

redis_cmd_free(cmd);

if (!redis_sock_response_ok(redis_sock, response, sizeof(response))) {

return -1;

}

return 0;

}

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

int argc;

/* We need a password at least */

if (redis_sock->pass == NULL)

return 0;

argc = !!redis_sock->user + !!redis_sock->pass;

resp_str_cat_cmd_literal(str, "AUTH", argc);

if (redis_sock->user)

resp_str_cat_zstr(str, redis_sock->user);

resp_str_cat_zstr(str, redis_sock->pass);

/* We appended a command */

return 1;

}

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;

}

}

#if PHP_VERSION_ID < 80000

static void redis_array_release(HashTable *ht) {

if (!ht || (GC_FLAGS(ht) & GC_IMMUTABLE)) {

return;

}

if (GC_DELREF(ht) == 0) {

zend_array_destroy(ht);

}

}

static inline void redis_array_release(HashTable *ht) {

zend_array_release(ht);

}

void redis_sock_free_context(RedisSock *redis_sock) {

if (redis_sock->context == NULL)

return;

redis_array_release(redis_sock->context);

redis_sock->context = NULL;

}

PHP_REDIS_API zend_string *

redis_sock_auth_cmd(RedisSock *redis_sock) {

smart_str cmd = {0};

if (redis_sock_append_auth(redis_sock, &cmd) == 0) {

return NULL;

}

return cmd.s;

}

PHP_REDIS_API int redis_sock_auth(RedisSock *redis_sock) {

zend_string *cmd;

char inbuf[4096];

if ((cmd = redis_sock_auth_cmd(redis_sock)) == NULL)

return SUCCESS;

if (redis_sock_write(redis_sock, ZSTR_VAL(cmd), ZSTR_LEN(cmd)) < 0) {

zend_string_release(cmd);

return FAILURE;

}

zend_string_release(cmd);

if (!redis_sock_response_ok(redis_sock, inbuf, sizeof(inbuf))) {

return FAILURE;

}

return SUCCESS;

}

static zend_always_inline zend_bool

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;

}

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

if (redis_sock_errcmp(redis_sock, ZEND_STRL("ERR")) &&

!redis_sock_errcmp(redis_sock, ZEND_STRL("ERR AUTH"))) return;

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

if (!redis_sock_errcmp(redis_sock, ZEND_STRL("NOSCRIPT")) &&

!redis_sock_errcmp(redis_sock, ZEND_STRL("NOQUORUM")) &&

!redis_sock_errcmp(redis_sock, ZEND_STRL("NOGOODSLAVE")) &&

!redis_sock_errcmp(redis_sock, ZEND_STRL("WRONGTYPE")) &&

!redis_sock_errcmp(redis_sock, ZEND_STRL("BUSYGROUP")) &&

!redis_sock_errcmp(redis_sock, ZEND_STRL("NOGROUP")))

{

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

}

}

static int

read_mbulk_header(RedisSock *redis_sock, int *nelem)

{

char line[4096];

size_t len;

/* Throws exception on failure */

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

return FAILURE;

}

if (*line != TYPE_MULTIBULK) {

if (*line == TYPE_ERR) {

redis_sock_set_err(redis_sock, line + 1, len - 1);

}

return FAILURE;

}

{

char *endptr;

long long n;

errno = 0;

n = strtoll(line + 1, &endptr, 10);

if (endptr == line + 1 || errno == ERANGE || n < -1 || n > INT_MAX) {

return FAILURE;

}

*nelem = (int)n;

}

return SUCCESS;

}

PHP_REDIS_API int

redis_check_eof(RedisSock *redis_sock, zend_bool no_retry, zend_bool no_throw)

{

unsigned int retry_index;

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

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

redis_backoff_reset(&redis_sock->backoff);

for (retry_index = 0; !no_retry && retry_index < redis_sock->max_retries; ++retry_index) {

/* close existing stream before reconnecting */

if (redis_sock->stream) {

/* reconnect no need to reset mode, it will cause pipeline mode socket exception */

redis_sock_disconnect(redis_sock, 1, 0);

}

/* Sleep based on our backoff algorithm */

zend_ulong delay = redis_backoff_compute(&redis_sock->backoff, retry_index);

if (delay != 0)

usleep(delay);

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

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

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

errmsg = "SELECT failed while reconnecting";

break;

}

redis_sock->status = REDIS_SOCK_STATUS_READY;

/* Success */

return 0;

}

}

}

}

/* close stream and mark socket as failed */

redis_sock_disconnect(redis_sock, 1, 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, uint64_t *cursor)

{

REDIS_REPLY_TYPE reply_type;

char err[4096], *p_iter;

RedisCmdCtx ctx = {0};

long reply_info;

size_t errlen;

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

{

if (reply_type == TYPE_ERR) {

if (redis_sock_gets(redis_sock, err, sizeof(err), &errlen) == 0) {

redis_sock_set_err(redis_sock, err, errlen);

}

}

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

*cursor = strtoull(p_iter, NULL, 10);

efree(p_iter);

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

switch(type) {

case TYPE_SCAN:

return redis_mbulk_reply_raw(INTERNAL_FUNCTION_PARAM_PASSTHRU,

redis_sock, NULL, ctx);

case TYPE_SSCAN:

return redis_sock_read_multibulk_reply(

INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, ctx);

case TYPE_ZSCAN:

return redis_mbulk_reply_zipped_keys_dbl(INTERNAL_FUNCTION_PARAM_PASSTHRU,

redis_sock, NULL, ctx);

case TYPE_HSCAN:

return redis_mbulk_reply_zipped_vals(INTERNAL_FUNCTION_PARAM_PASSTHRU,

redis_sock, NULL, ctx);

default:

return -1;

}

}

PHP_REDIS_API int

redis_pubsub_response(INTERNAL_FUNCTION_PARAMETERS,

RedisSock *redis_sock, zval *z_tab, RedisCmdCtx ctx)

{

switch (ctx.mode) {

case REDIS_CTX_LONG:

return redis_long_response(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock,

z_tab, redis_empty_ctx);

case REDIS_CTX_VARIANT:

return redis_read_variant_reply(INTERNAL_FUNCTION_PARAM_PASSTHRU,

redis_sock, z_tab, redis_empty_ctx);

case REDIS_CTX_ZIPPED_INT:

return redis_mbulk_reply_zipped_keys_int(INTERNAL_FUNCTION_PARAM_PASSTHRU,

redis_sock, z_tab, redis_empty_ctx);

default:

ZEND_UNREACHABLE();

}

}

static void

ht_free_subs(zval *data)

{

efree(Z_PTR_P(data));

}

PHP_REDIS_API int

redis_subscribe_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

zval *z_tab, RedisCmdCtx ctx)

{

HashTable *subs;

subscribeCallback *cb;

subscribeContext *sctx = ctx.ptr;

zval *z_tmp, z_resp;

int i;

ALLOC_HASHTABLE(subs);

zend_hash_init(subs, 0, NULL, ht_free_subs, 0);

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

while(sctx->argc--) {

ZVAL_NULL(&z_resp);

if (!redis_sock_read_multibulk_reply_zval(redis_sock, &z_resp)) {

goto error;

}

// We'll need to find the command response

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

goto error;

}

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

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

goto error;

}

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

goto error;

}

zend_hash_str_update_mem(subs, Z_STRVAL_P(z_tmp), Z_STRLEN_P(z_tmp),

&sctx->cb, sizeof(sctx->cb));

zval_ptr_dtor_nogc(&z_resp);

}

if (strcasecmp(sctx->kw, "ssubscribe") == 0) {

i = REDIS_SSUBSCRIBE_IDX;

} else if (strcasecmp(sctx->kw, "psubscribe") == 0) {

i = REDIS_PSUBSCRIBE_IDX;

} else {

i = REDIS_SUBSCRIBE_IDX;

}

if (redis_sock->subs[i]) {

zend_string *zkey;

ZEND_HASH_FOREACH_STR_KEY_PTR(subs, zkey, cb) {

zend_hash_update_mem(redis_sock->subs[i], zkey, cb, sizeof(*cb));

} ZEND_HASH_FOREACH_END();

zend_hash_destroy(subs);

efree(subs);

RETVAL_TRUE;

return SUCCESS;

}

redis_sock->subs[i] = subs;

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

while (redis_sock->subs[i]) {

zval z_ret, z_args[4], *z_type, *z_chan, *z_pat = NULL, *z_data;

int tab_idx = 1, is_pmsg = 0;

HashTable *ht_tab;

zend_string *zs;

ZVAL_NULL(&z_resp);

if (!redis_sock_read_multibulk_reply_zval(redis_sock, &z_resp)) {

goto failure;

}

ht_tab = Z_ARRVAL(z_resp);

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

Z_TYPE_P(z_type) != IS_STRING

) {

goto failure;

}

// Check for message or pmessage

if (zend_string_equals_literal_ci(Z_STR_P(z_type), "message") ||

zend_string_equals_literal_ci(Z_STR_P(z_type), "pmessage") ||

zend_string_equals_literal_ci(Z_STR_P(z_type), "smessage")

) {

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

} else {

zval_ptr_dtor_nogc(&z_resp);

continue;

}

// Extract pattern if it's a pmessage

if (is_pmsg) {

z_pat = zend_hash_index_find(ht_tab, tab_idx++);

if (z_pat == NULL || Z_TYPE_P(z_pat) != IS_STRING)

goto failure;

}

/* Extract channel */

z_chan = zend_hash_index_find(ht_tab, tab_idx++);

if (z_chan == NULL || Z_TYPE_P(z_chan) != IS_STRING)

goto failure;

/* Finally, extract data */

z_data = zend_hash_index_find(ht_tab, tab_idx++);

if (z_data == NULL)

goto failure;

/* Find our callback, either by channel or pattern string */

zs = z_pat != NULL ? Z_STR_P(z_pat) : Z_STR_P(z_chan);

if ((cb = zend_hash_find_ptr(redis_sock->subs[i], zs)) == NULL)

goto failure;

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

cb->fci.param_count = tab_idx;

cb->fci.retval = &z_ret;

cb->fci.params = z_args;

// Execute callback

if (zend_call_function(&cb->fci, &cb->fci_cache) != SUCCESS) {

goto failure;

}

// If we have a return value free it

zval_ptr_dtor(&z_ret);

zval_ptr_dtor_nogc(&z_resp);

}

RETVAL_TRUE;

return SUCCESS;

// This is an error state, clean up

error:

zend_hash_destroy(subs);

efree(subs);

failure:

zval_ptr_dtor_nogc(&z_resp);

RETVAL_FALSE;

return FAILURE;

}

PHP_REDIS_API int redis_unsubscribe_response(INTERNAL_FUNCTION_PARAMETERS,

RedisSock *redis_sock, zval *z_tab,

RedisCmdCtx ctx)

{

subscribeContext *sctx = ctx.ptr;

zval *z_chan, z_ret, z_resp;

int i;

if (strcasecmp(sctx->kw, "sunsubscribe") == 0) {

i = REDIS_SSUBSCRIBE_IDX;

} else if (strcasecmp(sctx->kw, "punsubscribe") == 0) {

i = REDIS_PSUBSCRIBE_IDX;

} else {

i = REDIS_SUBSCRIBE_IDX;

}

if (!sctx->argc && redis_sock->subs[i]) {

sctx->argc = zend_hash_num_elements(redis_sock->subs[i]);

}

array_init_size(&z_ret, sctx->argc);

while (sctx->argc--) {

ZVAL_NULL(&z_resp);

if (!redis_sock_read_multibulk_reply_zval(redis_sock, &z_resp) ||

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

) {

zval_ptr_dtor_nogc(&z_resp);

zval_ptr_dtor_nogc(&z_ret);

RETVAL_FALSE;

return FAILURE;

}

if (!redis_sock->subs[i] ||

!zend_hash_str_exists(redis_sock->subs[i], Z_STRVAL_P(z_chan), Z_STRLEN_P(z_chan))

) {

add_assoc_bool_ex(&z_ret, Z_STRVAL_P(z_chan), Z_STRLEN_P(z_chan), 0);

} else {

zend_hash_str_del(redis_sock->subs[i], Z_STRVAL_P(z_chan), Z_STRLEN_P(z_chan));

add_assoc_bool_ex(&z_ret, Z_STRVAL_P(z_chan), Z_STRLEN_P(z_chan), 1);

}

zval_ptr_dtor_nogc(&z_resp);

}

if (redis_sock->subs[i] && !zend_hash_num_elements(redis_sock->subs[i])) {

zend_hash_destroy(redis_sock->subs[i]);

efree(redis_sock->subs[i]);

redis_sock->subs[i] = NULL;

}

RETVAL_ZVAL(&z_ret, 0, 1);

return SUCCESS;

}

PHP_REDIS_API zval *

redis_sock_read_multibulk_reply_zval(RedisSock *redis_sock, zval *z_tab)

{

int numElems;

if (read_mbulk_header(redis_sock, &numElems) < 0) {

ZVAL_NULL(z_tab);

return NULL;

}

array_init_size(z_tab, numElems > 0 ? numElems : 0);

redis_mbulk_reply_loop(redis_sock, z_tab, numElems, UNSERIALIZE_ALL);

return z_tab;

}

PHP_REDIS_API char *

redis_sock_read_bulk_reply(RedisSock *redis_sock, int bytes)

{

int offset = 0, nbytes;

char *reply;

ssize_t got;

if (bytes < -1 || bytes > INT_MAX - 2) {

zend_throw_exception_ex(redis_exception_ce, 0,

"protocol error, invalid bulk length: %d", bytes);

return NULL;

}

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

return NULL;

}

/* + 2 for \r\n */

nbytes = bytes + 2;

/* Allocate memory for string */

reply = emalloc(nbytes);

/* Consume bulk string */

while (offset < nbytes) {

got = redis_sock_read_raw(redis_sock, reply + offset, nbytes - offset);

if (got <= 0)

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;

}

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

return NULL;

}

switch(inbuf[0]) {

case '-':

redis_sock_set_err(redis_sock, inbuf + 1, len - 1);

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

redis_error_throw(redis_sock);

return NULL;

case '$':

{

char *endptr;

long long n;

errno = 0;

n = strtoll(inbuf + 1, &endptr, 10);

if (endptr == inbuf + 1 || errno == ERANGE || n < -1 || n > INT_MAX) {

return NULL;

}

*buf_len = (int)n;

}

return redis_sock_read_bulk_reply(redis_sock, *buf_len);

case '*':

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

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

return NULL;

}

REDIS_FALLTHROUGH;

case '+':

case ':':

/* Single Line Reply */

/* +OK or :123 */

if (len > 1) {

*buf_len = len;

return estrndup(inbuf, *buf_len);

}

REDIS_FALLTHROUGH;

default:

zend_throw_exception_ex(redis_exception_ce, 0,

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

inbuf[0]

);

}

return NULL;

}

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

ops->hash_init(ctx);

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

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

}

}

PHP_REDIS_API zend_string *

redis_pool_spprintf(RedisSock *redis_sock, const 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;

}

PHP_REDIS_API int

redis_bulk_double_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

zval *z_tab, RedisCmdCtx ctx)

{

char *response;

int response_len;

double ret;

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

REDIS_RESPONSE_ERROR(redis_sock, z_tab);