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

/*

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

| Copyright (c) 1997-2009 The PHP Group |

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

| This source file is subject to version 3.01 of the PHP license, |

| that is bundled with this package in the file LICENSE, and is |

| available through the world-wide-web at the following url: |

| http://www.php.net/license/3_01.txt |

| If you did not receive a copy of the PHP license and are unable to |

| obtain it through the world-wide-web, please send a note to |

| license@php.net so we can mail you a copy immediately. |

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

| Original author: Alfonso Jimenez <yo@alfonsojimenez.com> |

| Maintainer: Nicolas Favre-Felix <n.favre-felix@owlient.eu> |

| Maintainer: Nasreddine Bouafif <n.bouafif@owlient.eu> |

| Maintainer: Michael Grunder <michael.grunder@gmail.com> |

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

*/

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "php_redis.h"

#include "redis_array.h"

#include "redis_cluster.h"

#include "redis_commands.h"

#include "redis_sentinel.h"

#include <ext/spl/spl_exceptions.h>

#include <zend_exceptions.h>

#include <ext/standard/info.h>

#include <ext/hash/php_hash.h>

#ifdef PHP_SESSION

#include <ext/session/php_session.h>

#endif

#include "library.h"

#ifdef HAVE_REDIS_ZSTD

#include <zstd.h>

#endif

#ifdef HAVE_REDIS_LZ4

#include <lz4.h>

#endif

#ifdef PHP_SESSION

extern ps_module ps_mod_redis;

extern ps_module ps_mod_redis_cluster;

#endif

zend_class_entry *redis_ce;

zend_class_entry *redis_exception_ce;

extern RedisCmdCtx redis_empty_ctx;

#if PHP_VERSION_ID < 80000

#include "redis_legacy_arginfo.h"

#else

#include "zend_attributes.h"

#include "redis_arginfo.h"

#endif

extern int le_cluster_slot_cache;

int le_redis_pconnect;

PHP_INI_BEGIN()

/* redis arrays */

PHP_INI_ENTRY("redis.arrays.algorithm", "", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.auth", "", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.autorehash", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.connecttimeout", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.distributor", "", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.functions", "", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.hosts", "", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.index", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.lazyconnect", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.names", "", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.pconnect", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.previous", "", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.readtimeout", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.retryinterval", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.arrays.consistent", "0", PHP_INI_ALL, NULL)

/* redis cluster */

PHP_INI_ENTRY("redis.clusters.cache_slots", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.clusters.auth", "", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.clusters.persistent", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.clusters.read_timeout", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.clusters.seeds", "", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.clusters.timeout", "0", PHP_INI_ALL, NULL)

/* redis pconnect */

PHP_INI_ENTRY("redis.pconnect.pooling_enabled", "1", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.pconnect.connection_limit", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.pconnect.echo_check_liveness", "1", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.pconnect.pool_detect_dirty", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.pconnect.pool_poll_timeout", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.pconnect.pool_pattern", "", PHP_INI_ALL, NULL)

/* redis session */

PHP_INI_ENTRY("redis.session.locking_enabled", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.session.lock_release_cmd", "eval", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.session.lock_expire", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.session.lock_retries", "100", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.session.lock_wait_time", "20000", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.session.lock_failure_readonly", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.session.early_refresh", "0", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.session.compression", "none", PHP_INI_ALL, NULL)

PHP_INI_ENTRY("redis.session.compression_level", "3", PHP_INI_ALL, NULL)

PHP_INI_END()

static const zend_module_dep redis_deps[] = {

#ifdef HAVE_REDIS_IGBINARY

ZEND_MOD_REQUIRED("igbinary")

#endif

#ifdef HAVE_REDIS_MSGPACK

ZEND_MOD_REQUIRED("msgpack")

#endif

#ifdef HAVE_REDIS_JSON

ZEND_MOD_REQUIRED("json")

#endif

#ifdef PHP_SESSION

ZEND_MOD_REQUIRED("session")

#endif

ZEND_MOD_END

};

ZEND_DECLARE_MODULE_GLOBALS(redis)

zend_module_entry redis_module_entry = {

STANDARD_MODULE_HEADER_EX,

NULL,

redis_deps,

"redis",

NULL,

PHP_MINIT(redis),

NULL,

NULL,

NULL,

PHP_MINFO(redis),

PHP_REDIS_VERSION,

PHP_MODULE_GLOBALS(redis),

NULL,

NULL,

NULL,

STANDARD_MODULE_PROPERTIES_EX

};

#ifdef COMPILE_DL_REDIS

ZEND_GET_MODULE(redis)

#endif

zend_object_handlers redis_object_handlers;

/* Send a static DISCARD in case we're in MULTI mode. */

static int

redis_send_discard(RedisSock *redis_sock)

{

char *resp;

int resp_len, result = FAILURE;

/* send our DISCARD command */

if (redis_sock_write(redis_sock, ZEND_STRL(RESP_DISCARD_CMD)) >= 0 &&

(resp = redis_sock_read(redis_sock,&resp_len)) != NULL)

{

/* success if we get OK */

result = (resp_len == 3 && redis_strncmp(resp, ZEND_STRL("+OK")) == 0) ? SUCCESS:FAILURE;

/* free our response */

efree(resp);

}

/* return success/failure */

return result;

}

/* Passthru for destroying cluster cache */

static void cluster_cache_dtor(zend_resource *rsrc) {

if (rsrc->ptr) {

cluster_cache_free(rsrc->ptr);

}

}

void

free_redis_object(zend_object *object)

{

redis_object *redis = PHPREDIS_GET_OBJECT(redis_object, object);

zend_object_std_dtor(&redis->std);

if (redis->sock) {

redis_sock_disconnect(redis->sock, 0, 1);

redis_free_socket(redis->sock);

}

}

zend_object *

create_redis_object(zend_class_entry *ce)

{

redis_object *redis = ecalloc(1, sizeof(redis_object) + zend_object_properties_size(ce));

redis->sock = NULL;

zend_object_std_init(&redis->std, ce);

object_properties_init(&redis->std, ce);

redis->std.handlers = &redis_object_handlers;

return &redis->std;

}

static zend_always_inline RedisSock *

redis_sock_get_instance(zval *id, int no_throw)

{

redis_object *redis;

if (Z_TYPE_P(id) == IS_OBJECT) {

redis = PHPREDIS_ZVAL_GET_OBJECT(redis_object, id);

if (redis->sock) {

return redis->sock;

}

}

// Throw an exception unless we've been requested not to

if (!no_throw) {

REDIS_THROW_EXCEPTION("Redis server went away", 0);

}

return NULL;

}

static zend_never_inline ZEND_COLD void redis_sock_throw_exception(RedisSock *redis_sock) {

char *errmsg = NULL;

if (redis_sock->status == REDIS_SOCK_STATUS_AUTHENTICATED) {

if (redis_sock->err != NULL) {

spprintf(&errmsg, 0, "Could not select database %ld '%s'", redis_sock->dbNumber, ZSTR_VAL(redis_sock->err));

} else {

spprintf(&errmsg, 0, "Could not select database %ld", redis_sock->dbNumber);

}

} else if (redis_sock->status == REDIS_SOCK_STATUS_CONNECTED) {

if (redis_sock->err != NULL) {

spprintf(&errmsg, 0, "Could not authenticate '%s'", ZSTR_VAL(redis_sock->err));

} else {

spprintf(&errmsg, 0, "Could not authenticate");

}

} else {

if (redis_sock->port < 0) {

spprintf(&errmsg, 0, "Redis server %s went away", ZSTR_VAL(redis_sock->host));

} else {

spprintf(&errmsg, 0, "Redis server %s:%d went away", ZSTR_VAL(redis_sock->host), redis_sock->port);

}

}

REDIS_THROW_EXCEPTION(errmsg, 0);

efree(errmsg);

}

/**

* redis_sock_get

*/

PHP_REDIS_API RedisSock *

redis_sock_get(zval *id, int no_throw)

{

RedisSock *redis_sock;

if ((redis_sock = redis_sock_get_instance(id, no_throw)) == NULL) {

return NULL;

}

if (UNEXPECTED(redis_sock_server_open(redis_sock) < 0)) {

if (!no_throw) {

redis_sock_throw_exception(redis_sock);

}

return NULL;

}

return redis_sock;

}

/**

* redis_sock_get_direct

* Returns our attached RedisSock pointer if we're connected

*/

PHP_REDIS_API RedisSock *redis_sock_get_connected(INTERNAL_FUNCTION_PARAMETERS) {

RedisSock *redis_sock;

// If we can't grab our object, or get a socket, or we're not connected,

// return NULL

if ((redis_sock = redis_sock_get(getThis(), 1)) == NULL ||

redis_sock->status < REDIS_SOCK_STATUS_CONNECTED)

{

return NULL;

}

/* Return our socket */

return redis_sock;

}

static ZEND_RSRC_DTOR_FUNC(redis_connections_pool_dtor)

{

if (res->ptr) {

ConnectionPool *p = res->ptr;

zend_llist_destroy(&p->list);

pefree(res->ptr, 1);

}

}

static void redis_random_hex_bytes(char *dst, size_t dstsize) {

char chunk[9], *ptr = dst;

ssize_t rem = dstsize, len, clen;

size_t bytes;

/* We need two characters per hex byte */

bytes = dstsize / 2;

zend_string *s = zend_string_alloc(bytes, 0);

/* First try to have PHP generate the bytes */

if (php_random_bytes_silent(ZSTR_VAL(s), bytes) == SUCCESS) {

zend_bin2hex(dst, (unsigned char *)ZSTR_VAL(s), bytes);

zend_string_release(s);

return;

}

/* PHP shouldn't have failed, but generate manually if it did. */

while (rem > 0) {

clen = snprintf(chunk, sizeof(chunk), "%08x", rand());

len = rem >= clen ? clen : rem;

memcpy(ptr, chunk, len);

ptr += len; rem -= len;

}

zend_string_release(s);

}

static void redis_init_object_handlers(void) {

memcpy(&redis_object_handlers, zend_get_std_object_handlers(),

sizeof(redis_object_handlers));

redis_object_handlers.offset = offsetof(redis_object, std);

redis_object_handlers.free_obj = free_redis_object;

redis_object_handlers.clone_obj = NULL;

}

/**

* PHP_MINIT_FUNCTION

*/

PHP_MINIT_FUNCTION(redis)

{

struct timeval tv;

/* Seed random generator (for RedisCluster failover) */

gettimeofday(&tv, NULL);

srand(tv.tv_usec * tv.tv_sec);

/* Generate our random salt */

redis_random_hex_bytes(REDIS_G(salt), sizeof(REDIS_G(salt)) - 1);

REDIS_G(salt)[sizeof(REDIS_G(salt)) - 1] = '\0';

REGISTER_INI_ENTRIES();

/* Redis class */

redis_ce = register_class_Redis();

redis_ce->create_object = create_redis_object;

/* Redis object handler initialization */

redis_init_object_handlers();

/* RedisArray class */

ZEND_MINIT(redis_array)(INIT_FUNC_ARGS_PASSTHRU);

/* RedisCluster class */

ZEND_MINIT(redis_cluster)(INIT_FUNC_ARGS_PASSTHRU);

/* RedisSentinel class */

ZEND_MINIT(redis_sentinel)(INIT_FUNC_ARGS_PASSTHRU);

/* Register our cluster cache list item */

le_cluster_slot_cache = zend_register_list_destructors_ex(NULL, cluster_cache_dtor,

"Redis cluster slot cache",

module_number);

/* RedisException class */

redis_exception_ce = register_class_RedisException(spl_ce_RuntimeException);

#ifdef PHP_SESSION

php_session_register_module(&ps_mod_redis);

php_session_register_module(&ps_mod_redis_cluster);

#endif

/* Register resource destructors */

le_redis_pconnect = zend_register_list_destructors_ex(NULL, redis_connections_pool_dtor,

"phpredis persistent connections pool", module_number);

return SUCCESS;

}

static const char *

get_available_serializers(void)

{

#ifdef HAVE_REDIS_JSON

#ifdef HAVE_REDIS_IGBINARY

#ifdef HAVE_REDIS_MSGPACK

return "php, json, igbinary, msgpack";

#else

return "php, json, igbinary";

#endif

#else

#ifdef HAVE_REDIS_MSGPACK

return "php, json, msgpack";

#else

return "php, json";

#endif

#endif

#else

#ifdef HAVE_REDIS_IGBINARY

#ifdef HAVE_REDIS_MSGPACK

return "php, igbinary, msgpack";

#else

return "php, igbinary";

#endif

#else

#ifdef HAVE_REDIS_MSGPACK

return "php, msgpack";

#else

return "php";

#endif

#endif

#endif

}

/**

* PHP_MINFO_FUNCTION

*/

PHP_MINFO_FUNCTION(redis)

{

smart_str names = {0,};

php_info_print_table_start();

php_info_print_table_header(2, "Redis Support", "enabled");

php_info_print_table_row(2, "Redis Version", PHP_REDIS_VERSION);

php_info_print_table_row(2, "Redis Sentinel Version", PHP_REDIS_SENTINEL_VERSION);

#ifdef GIT_REVISION

php_info_print_table_row(2, "Git revision", "$Id: " GIT_REVISION " $");

#endif

php_info_print_table_row(2, "Available serializers", get_available_serializers());

#ifdef HAVE_REDIS_LZF

smart_str_appends(&names, "lzf");

#endif

#ifdef HAVE_REDIS_ZSTD

if (names.s) {

smart_str_appends(&names, ", ");

}

smart_str_appends(&names, "zstd");

#endif

#ifdef HAVE_REDIS_LZ4

if (names.s) {

smart_str_appends(&names, ", ");

}

smart_str_appends(&names, "lz4");

#endif

if (names.s) {

smart_str_0(&names);

php_info_print_table_row(2, "Available compression", ZSTR_VAL(names.s));

}

smart_str_free(&names);

php_info_print_table_end();

DISPLAY_INI_ENTRIES();

}

PHP_METHOD(Redis, __construct)

{

HashTable *opts = NULL;

redis_object *redis;

ZEND_PARSE_PARAMETERS_START(0, 1)

Z_PARAM_OPTIONAL

Z_PARAM_ARRAY_HT_OR_NULL(opts)

ZEND_PARSE_PARAMETERS_END_EX(RETURN_THROWS());

redis = PHPREDIS_ZVAL_GET_OBJECT(redis_object, getThis());

redis->sock = redis_sock_create(REDIS_SOCK_STANDALONE, ZEND_STRL("127.0.0.1"),

6379, 0, 0, 0, NULL, 0);

if (opts != NULL && redis_sock_configure(redis->sock, opts) != SUCCESS) {

RETURN_THROWS();

}

}

PHP_METHOD(Redis, __destruct) {

if (zend_parse_parameters_none() == FAILURE) {

RETURN_FALSE;

}

// Grab our socket

RedisSock *redis_sock;

if ((redis_sock = redis_sock_get_instance(getThis(), 1)) == NULL) {

RETURN_FALSE;

}

// If we think we're in MULTI mode, send a discard

if (redis_sock_is_multi(redis_sock)) {

if (!redis_sock_is_pipeline(redis_sock) && redis_sock->stream) {

redis_send_discard(redis_sock);

}

redis_free_reply_callbacks(redis_sock);

}

}

PHP_METHOD(Redis, connect)

{

if (redis_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0) == FAILURE) {

RETURN_FALSE;

} else {

RETURN_TRUE;

}

}

PHP_METHOD(Redis, pconnect)

{

if (redis_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1) == FAILURE) {

RETURN_FALSE;

} else {

RETURN_TRUE;

}

}

PHP_REDIS_API int

redis_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)

{

zval *context = NULL, *ele;

char *host = NULL, *persistent_id = NULL;

zend_long port = -1, retry_interval = 0;

size_t host_len, persistent_id_len;

double timeout = 0.0, read_timeout = 0.0;

redis_object *redis;

int af_unix;

ZEND_PARSE_PARAMETERS_START(1, 7)

Z_PARAM_STRING(host, host_len)

Z_PARAM_OPTIONAL

Z_PARAM_LONG(port)

Z_PARAM_DOUBLE(timeout)

Z_PARAM_STRING_OR_NULL(persistent_id, persistent_id_len)

Z_PARAM_LONG(retry_interval)

Z_PARAM_DOUBLE(read_timeout)

Z_PARAM_ARRAY_OR_NULL(context)

ZEND_PARSE_PARAMETERS_END_EX(return FAILURE);

/* Disregard persistent_id if we're not opening a persistent connection */

if (!persistent) {

persistent_id = NULL;

}

if (timeout > INT_MAX) {

REDIS_VALUE_EXCEPTION("Invalid connect timeout");

return FAILURE;

}

if (read_timeout > INT_MAX) {

REDIS_VALUE_EXCEPTION("Invalid read timeout");

return FAILURE;

}

if (retry_interval < 0L || retry_interval > INT_MAX) {

REDIS_VALUE_EXCEPTION("Invalid retry interval");

return FAILURE;

}

/* Does the host look like a unix socket */

af_unix = (host_len > 0 && host[0] == '/') ||

(host_len > 6 && (!strncasecmp(host, "unix://", sizeof("unix://") - 1) ||

!strncasecmp(host, "file://", sizeof("file://") - 1)));

/* If it's not a unix socket, set to default */

if (port == -1 && !af_unix) {

port = 6379;

}

redis = PHPREDIS_ZVAL_GET_OBJECT(redis_object, getThis());

/* if there is a redis sock already we have to remove it */

if (redis->sock) {

redis_sock_disconnect(redis->sock, 0, 1);

redis_free_socket(redis->sock);

}

redis->sock = redis_sock_create(REDIS_SOCK_STANDALONE, host, host_len, port,

timeout, read_timeout, persistent,

persistent_id, retry_interval);

if (context) {

/* Stream context (e.g. TLS) */

if ((ele = REDIS_HASH_STR_FIND_STATIC(Z_ARRVAL_P(context), "stream"))) {

redis_sock_set_context_zval(redis->sock, ele);

}

/* AUTH */

if ((ele = REDIS_HASH_STR_FIND_STATIC(Z_ARRVAL_P(context), "auth"))) {

redis_sock_set_auth_zval(redis->sock, ele);

}

}

if (redis_sock_connect(redis->sock) != SUCCESS) {

if (redis->sock->err) {

REDIS_THROW_EXCEPTION(ZSTR_VAL(redis->sock->err), 0);

}

redis_free_socket(redis->sock);

redis->sock = NULL;

return FAILURE;

}

return SUCCESS;

}

static zend_always_inline void

pipeline_enqueue_cmd_strl(RedisSock *redis_sock, const char *cmd, int len) {

smart_string_appendl(&redis_sock->pipeline_cmd, cmd, len);

}

static zend_always_inline void

pipeline_enqueue_cmd(RedisSock *redis_sock, RedisCmd *cmd) {

pipeline_enqueue_cmd_strl(redis_sock, redis_cmd_str(cmd),

redis_cmd_len(cmd));

}

static void

redis_save_callback(RedisSock *redis_sock, FailableResultCallback cb,

RedisCmdCtx ctx)

{

fold_item *fi;

fi = redis_add_reply_callback(redis_sock);

fi->fun = cb;

fi->flags = redis_sock->flags;

fi->ctx = ctx;

}

static int

redis_process_request_strl(RedisSock *redis_sock, const char *cmd, int len) {

int res = SUCCESS;

if (redis_sock_is_pipeline(redis_sock)) {

pipeline_enqueue_cmd_strl(redis_sock, cmd, len);

} else if (UNEXPECTED(redis_sock_write(redis_sock, cmd, len) < 0)) {

res = FAILURE;

}

return res;

}

static int

redis_process_request(RedisSock *redis_sock, RedisCmd *cmd) {

return redis_process_request_strl(redis_sock, redis_cmd_str(cmd),

redis_cmd_len(cmd));

}

static void

redis_process_cmd(INTERNAL_FUNCTION_PARAMETERS, redis_cmd_cb *cmd_cb,

FailableResultCallback resp_cb)

{

RedisSock *redis_sock;

RedisCmdCtx ctx;

RedisCmd *cmd;

int res;

redis_sock = redis_sock_get(getThis(), 0);

if (UNEXPECTED(redis_sock == NULL)) {

RETURN_FALSE;

}

cmd = cmd_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock);

if (UNEXPECTED(cmd == NULL)) {

RETURN_FALSE;

}

ctx = redis_cmd_pop_ctx(cmd);

if (redis_sock_is_pipeline(redis_sock)) {

pipeline_enqueue_cmd(redis_sock, cmd);

res = SUCCESS;

} else {

res = redis_sock_write_cmd(redis_sock, cmd) < 0 ? FAILURE : SUCCESS;

}

redis_cmd_free(cmd);

if (UNEXPECTED(res != SUCCESS)) {

redis_cmd_ctx_free(ctx);

RETURN_FALSE;

}

if (redis_sock_is_atomic(redis_sock)) {

resp_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, ctx);

redis_cmd_ctx_free(ctx);

} else {

if (!redis_sock_is_pipeline(redis_sock)) {

if (redis_response_enqueued(redis_sock) != SUCCESS) {

redis_cmd_ctx_free(ctx);

RETURN_FALSE;

}

}

redis_save_callback(redis_sock, resp_cb, ctx);

RETURN_ZVAL(getThis(), 1, 0);

}

}

#define REDIS_METHOD(method, cmd_cb, resp_func) \

PHP_METHOD(Redis, method) { \

redis_process_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, cmd_cb, resp_func); \

}

#define REDIS_KW_METHOD(method, kw, cmd_cb, resp_func) \

PHP_METHOD(Redis, method) { \

redis_process_kw_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, kw, \

sizeof(kw) - 1, cmd_cb, resp_func); \

}

void

redis_process_kw_cmd(INTERNAL_FUNCTION_PARAMETERS, const char *kw, size_t kw_len,

redis_kw_cmd_cb *cmd_cb, FailableResultCallback resp_cb)

{

RedisSock *redis_sock;

RedisCmdCtx ctx;

RedisCmd *cmd;

int res;

redis_sock = redis_sock_get(getThis(), 0);

if (UNEXPECTED(redis_sock == NULL)) {

RETURN_FALSE;

}

cmd = cmd_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, kw, kw_len);

if (UNEXPECTED(cmd == NULL)) {

RETURN_FALSE;

}

ctx = redis_cmd_pop_ctx(cmd);

if (redis_sock_is_pipeline(redis_sock)) {

pipeline_enqueue_cmd(redis_sock, cmd);

res = SUCCESS;

} else {

res = redis_sock_write_cmd(redis_sock, cmd) < 0 ? FAILURE : SUCCESS;

}

redis_cmd_free(cmd);

if (UNEXPECTED(res != SUCCESS)) {

redis_cmd_ctx_free(ctx);

RETURN_FALSE;

}

if (redis_sock_is_atomic(redis_sock)) {

resp_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, ctx);

redis_cmd_ctx_free(ctx);

} else {

if (!redis_sock_is_pipeline(redis_sock)) {

if (redis_response_enqueued(redis_sock) != SUCCESS) {

redis_cmd_ctx_free(ctx);

RETURN_FALSE;

}

}

redis_save_callback(redis_sock, resp_cb, ctx);

RETURN_ZVAL(getThis(), 1, 0);

}

}

PHP_METHOD(Redis, close)

{

RedisSock *redis_sock = redis_sock_get_connected(INTERNAL_FUNCTION_PARAM_PASSTHRU);

if (redis_sock_disconnect(redis_sock, 1, 1) == SUCCESS) {

RETURN_TRUE;

}

RETURN_FALSE;

}

PHP_METHOD(Redis, reset)

{

char *response;

int response_len;

RedisSock *redis_sock;

RedisCmd *cmd;

zend_bool ret = 0;

if ((redis_sock = redis_sock_get(getThis(), 0)) == NULL) {

RETURN_FALSE;

}

if (redis_sock_is_pipeline(redis_sock)) {

php_error_docref(NULL, E_ERROR,

"Reset isn't allowed in pipeline mode!");

RETURN_FALSE;

}

cmd = redis_cmd_create_literal(NULL, "RESET");

if (redis_process_request(redis_sock, cmd) != SUCCESS) {

redis_cmd_free(cmd);

RETURN_FALSE;

}

redis_cmd_free(cmd);

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

ret = redis_str_eq(response, response_len, ZEND_STRL("+RESET"));

efree(response);

}

if (!ret) {

if (redis_sock_is_atomic(redis_sock)) {

RETURN_FALSE;

}

REDIS_THROW_EXCEPTION("Reset failed in multi mode!", 0);

RETURN_ZVAL(getThis(), 1, 0);

}

redis_free_reply_callbacks(redis_sock);

redis_sock->status = REDIS_SOCK_STATUS_CONNECTED;

redis_sock->mode = ATOMIC;

redis_sock->dbNumber = 0;

redis_sock->watching = 0;

RETURN_TRUE;

}

PHP_REDIS_API void redis_set_watch(RedisSock *redis_sock)

{

redis_sock->watching = 1;

}

PHP_REDIS_API int

redis_watch_response(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock,

zval *z_tab, RedisCmdCtx ctx)

{

return redis_boolean_response_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU,

redis_sock, z_tab, ctx, redis_set_watch);

}

PHP_REDIS_API void redis_clear_watch(RedisSock *redis_sock)

{

redis_sock->watching = 0;

}

PHP_REDIS_API int redis_unwatch_response(INTERNAL_FUNCTION_PARAMETERS,

RedisSock *redis_sock, zval *z_tab,

RedisCmdCtx ctx)

{

return redis_boolean_response_impl(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock,

z_tab, ctx, redis_clear_watch);

}

PHP_METHOD(Redis, sPop)

{

if (ZEND_NUM_ARGS() == 1) {

REDIS_PROCESS_KW_CMD("SPOP", redis_key_cmd, redis_string_response);

} else if (ZEND_NUM_ARGS() == 2) {

REDIS_PROCESS_KW_CMD("SPOP", redis_key_long_cmd, redis_sock_read_multibulk_reply);

} else {

zend_wrong_param_count();

}

}

static RedisCmd *

generic_sort_cmd(INTERNAL_FUNCTION_PARAMETERS, RedisSock *redis_sock, int desc,

int alpha)

{

zend_string *key = NULL, *pattern = NULL, *store = NULL, *zpattern;

zval *zele, *zget = NULL;

zend_long offset = -1, count = -1;

RedisCmd *cmd;

ZEND_PARSE_PARAMETERS_START(1, 6)

Z_PARAM_STR(key)

Z_PARAM_OPTIONAL

Z_PARAM_STR_OR_NULL(pattern)

Z_PARAM_ZVAL_OR_NULL(zget)

Z_PARAM_LONG(offset)

Z_PARAM_LONG(count)

Z_PARAM_STR(store)

ZEND_PARSE_PARAMETERS_END_EX(return NULL);

/* Ensure we're sorting something, and we can get context */

if (ZSTR_LEN(key) == 0)

return NULL;

/* Start constructing final command and append key */

cmd = redis_cmd_create_literal(redis_sock, "SORT");

if (!redis_cmd_cat_key_zstr(cmd, key)) {

redis_cmd_free(cmd);

return NULL;

}

/* BY pattern */

if (pattern && ZSTR_LEN(pattern)) {

redis_cmd_cat_literal(cmd, "BY");

redis_cmd_cat_zstr(cmd, pattern);

}

/* LIMIT offset count */

if (offset >= 0 && count >= 0) {

redis_cmd_cat_literal(cmd, "LIMIT");

redis_cmd_cat_long(cmd, offset);

redis_cmd_cat_long(cmd, count);

}

/* Handle any number of GET pattern arguments we've been passed */

if (zget != NULL) {

if (Z_TYPE_P(zget) == IS_ARRAY) {

ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(zget), zele) {

zpattern = zval_get_string(zele);

redis_cmd_cat_literal(cmd, "GET");

redis_cmd_cat_zstr(cmd, zpattern);

zend_string_release(zpattern);

} ZEND_HASH_FOREACH_END();

} else {

zpattern = zval_get_string(zget);

redis_cmd_cat_literal(cmd, "GET");

redis_cmd_cat_zstr(cmd, zpattern);

zend_string_release(zpattern);

}

}

/* Append optional DESC and ALPHA modifiers */

if (desc) redis_cmd_cat_literal(cmd, "DESC");

if (alpha) redis_cmd_cat_literal(cmd, "ALPHA");

/* Finally append STORE if we've got it */

if (store && ZSTR_LEN(store)) {

redis_cmd_cat_literal(cmd, "STORE");

if (!redis_cmd_cat_key_zstr(cmd, store)) {

redis_cmd_free(cmd);

return NULL;

}

}

return cmd;

}

PHP_METHOD(Redis, zPopMax)

{

if (ZEND_NUM_ARGS() == 1) {

REDIS_PROCESS_KW_CMD("ZPOPMAX", redis_key_cmd, redis_mbulk_reply_zipped_keys_dbl);

} else if (ZEND_NUM_ARGS() == 2) {

REDIS_PROCESS_KW_CMD("ZPOPMAX", redis_key_long_cmd, redis_mbulk_reply_zipped_keys_dbl);

} else {

zend_wrong_param_count();

}

}

PHP_METHOD(Redis, zPopMin)

{

if (ZEND_NUM_ARGS() == 1) {

REDIS_PROCESS_KW_CMD("ZPOPMIN", redis_key_cmd, redis_mbulk_reply_zipped_keys_dbl);

} else if (ZEND_NUM_ARGS() == 2) {

REDIS_PROCESS_KW_CMD("ZPOPMIN", redis_key_long_cmd, redis_mbulk_reply_zipped_keys_dbl);

} else {

zend_wrong_param_count();

}

}

/* flag : get, set {ATOMIC, MULTI, PIPELINE} */

PHP_METHOD(Redis, multi)

{

RedisSock *redis_sock;

char *resp;

int resp_len;

zend_long multi_value = MULTI;

ZEND_PARSE_PARAMETERS_START(0, 1)

Z_PARAM_OPTIONAL

Z_PARAM_LONG(multi_value)

ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);

/* if the flag is activated, send the command, the reply will be "QUEUED"

* or -ERR */

if ((redis_sock = redis_sock_get(getThis(), 0)) == NULL) {

RETURN_FALSE;

}

if (multi_value == PIPELINE) {

/* Cannot enter pipeline mode in a MULTI block */

if (redis_sock_is_multi(redis_sock)) {

php_error_docref(NULL, E_ERROR, "Can't activate pipeline in multi mode!");

RETURN_FALSE;

}

/* Enable PIPELINE if we're not already in one */

if (redis_sock_is_atomic(redis_sock)) {

redis_sock->mode |= PIPELINE;

}

} else if (multi_value == MULTI) {

/* Don't want to do anything if we're already in MULTI mode */

if (!redis_sock_is_multi(redis_sock)) {

if (redis_sock_is_pipeline(redis_sock)) {

pipeline_enqueue_cmd_strl(redis_sock, ZEND_STRL(RESP_MULTI_CMD));

redis_save_callback(redis_sock, NULL, redis_empty_ctx);

redis_sock->mode |= MULTI;