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

#if PHP_VERSION_ID < 80400

#include <ext/standard/php_random.h>

#else

#include <ext/random/php_random.h>

#endif

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

#if PHP_VERSION_ID < 80000

#include "redis_legacy_arginfo.h"

#else

#include "zend_attributes.h"

#include "redis_arginfo.h"

#endif

extern const zend_function_entry *redis_get_methods(void)

{

return class_Redis_methods;

}

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

memcpy(&redis_object_handlers, zend_get_std_object_handlers(), sizeof(redis_object_handlers));

redis_object_handlers.offset = XtOffsetOf(redis_object, std);

redis_object_handlers.free_obj = free_redis_object;

redis_object_handlers.clone_obj = NULL;

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

zval *object;

RedisSock *redis_sock;

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

// return NULL

if((zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O",

&object, redis_ce) == FAILURE) ||

(redis_sock = redis_sock_get(object, 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) {

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

}

/**

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

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

}

/* {{{ proto Redis Redis::__construct(array $options = null)

Public constructor */

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(ZEND_STRL("127.0.0.1"), 6379, 0, 0, 0, NULL, 0);

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

RETURN_THROWS();

}

}

/* }}} */

/* {{{ proto Redis Redis::__destruct()

Public Destructor

*/

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 (IS_MULTI(redis_sock)) {

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

// Discard any multi commands, and free any callbacks that have been

// queued

redis_send_discard(redis_sock);

}

redis_free_reply_callbacks(redis_sock);

}

}

/* {{{ proto boolean Redis::connect(string host, int port [, double timeout [, long retry_interval]])

*/

PHP_METHOD(Redis, connect)

{

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

RETURN_FALSE;

} else {

RETURN_TRUE;

}

}

/* }}} */

/* {{{ proto boolean Redis::pconnect(string host, int port [, double timeout])

*/

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

#ifdef ZTS

/* not sure how in threaded mode this works so disabled persistence at

* first */

persistent = 0;

#endif

if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(),

"Os|lds!lda!", &object, redis_ce, &host,

&host_len, &port, &timeout, &persistent_id,

&persistent_id_len, &retry_interval,

&read_timeout, &context) == FAILURE)

{

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

/* 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(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 inline void

pipeline_enqueue_command(RedisSock *redis_sock, const char *cmd, int cmd_len) {

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

}

static void

redis_save_callback(RedisSock *redis_sock, FailableResultCallback cb, void *ctx)

{

fold_item *fi;

fi = redis_add_reply_callback(redis_sock);

fi->fun = cb;

fi->flags = redis_sock->flags;

fi->ctx = ctx;

}

#define REDIS_PROCESS_RESPONSE_CLOSURE(function, closure_context) \

if (!IS_PIPELINE(redis_sock)) { \

if (redis_response_enqueued(redis_sock) != SUCCESS) { \

RETURN_FALSE; \

} \

} \

redis_save_callback(redis_sock, function, closure_context); \

RETURN_ZVAL(getThis(), 1, 0); \

static int redis_process_request(RedisSock *redis_sock, char *cmd, int cmdlen) {

int res = SUCCESS;

if (IS_PIPELINE(redis_sock)) {

pipeline_enqueue_command(redis_sock, cmd, cmdlen);

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

res = FAILURE;

}

efree(cmd);

return res;

}

static void

redis_process_cmd(INTERNAL_FUNCTION_PARAMETERS, redis_cmd_cb cmd_cb,

FailableResultCallback resp_cb)

{

RedisSock *redis_sock;

void *ctx = NULL;

int cmd_len;

char *cmd;

redis_sock = redis_sock_get(getThis(), 0);

if (UNEXPECTED(redis_sock == NULL)) {

RETURN_FALSE;

}

if (UNEXPECTED(cmd_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, &cmd,

&cmd_len, NULL, &ctx) == FAILURE))

{

RETURN_FALSE;

}

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

RETURN_FALSE;

}

if (IS_ATOMIC(redis_sock)) {

resp_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, ctx);

} else {

REDIS_PROCESS_RESPONSE_CLOSURE(resp_cb, ctx);

}

}

#define REDIS_PROCESS_CMD(cmdname, resp_func) \

redis_process_cmd(INTERNAL_FUNCTION_PARAM_PASSTHRU, \

redis_##cmdname##_cmd, resp_func)

void

redis_process_kw_cmd(INTERNAL_FUNCTION_PARAMETERS, const char *kw,

redis_kw_cmd_cb cmd_cb, FailableResultCallback resp_cb,

void *ctx)

{

RedisSock *redis_sock;

int cmd_len;

char *cmd;

redis_sock = redis_sock_get(getThis(), 0);

if (UNEXPECTED(redis_sock == NULL)) {

RETURN_FALSE;

}

if (UNEXPECTED(cmd_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, (char*)kw, &cmd,

&cmd_len, NULL, &ctx) == FAILURE))

{

RETURN_FALSE;

}

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

RETURN_FALSE;

}

if (IS_ATOMIC(redis_sock)) {

resp_cb(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, ctx);

} else {

REDIS_PROCESS_RESPONSE_CLOSURE(resp_cb, ctx);

}

}

/* {{{ proto long Redis::bitop(string op, string key, ...) */

PHP_METHOD(Redis, bitop) {

REDIS_PROCESS_CMD(bitop, redis_long_response);

}

/* }}} */

/* {{{ proto long Redis::bitcount(string key, [int start], [int end])

*/

PHP_METHOD(Redis, bitcount)

{

REDIS_PROCESS_CMD(bitcount, redis_long_response);

}

/* }}} */

/* {{{ proto integer Redis::bitpos(string key, int bit, [int start, int end]) */

PHP_METHOD(Redis, bitpos)

{

REDIS_PROCESS_CMD(bitpos, redis_long_response);

}

/* }}} */

/* {{{ proto boolean Redis::close()

*/

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;

}

/* }}} */

/* {{{ proto boolean Redis::set(string key, mixed val, long timeout,

* [array opt) */

PHP_METHOD(Redis, set) {

REDIS_PROCESS_CMD(set, redis_set_response);

}

/* {{{ proto boolean Redis::setex(string key, long expire, string value)

*/

PHP_METHOD(Redis, setex)

{

REDIS_PROCESS_KW_CMD("SETEX", redis_key_long_val_cmd, redis_boolean_response);

}

/* {{{ proto boolean Redis::psetex(string key, long expire, string value)

*/

PHP_METHOD(Redis, psetex)

{

REDIS_PROCESS_KW_CMD("PSETEX", redis_key_long_val_cmd, redis_boolean_response);

}

/* {{{ proto boolean Redis::setnx(string key, string value)

*/

PHP_METHOD(Redis, setnx)

{

REDIS_PROCESS_KW_CMD("SETNX", redis_kv_cmd, redis_1_response);

}

/* }}} */

/* {{{ proto string Redis::getSet(string key, string value)

*/

PHP_METHOD(Redis, getset)

{

REDIS_PROCESS_KW_CMD("GETSET", redis_kv_cmd, redis_string_response);

}

/* }}} */

/* {{{ proto string Redis::randomKey()

*/

PHP_METHOD(Redis, randomKey)

{

REDIS_PROCESS_KW_CMD("RANDOMKEY", redis_empty_cmd, redis_ping_response);

}

/* }}} */

/* {{{ proto string Redis::echo(string msg)

*/

PHP_METHOD(Redis, echo)

{

REDIS_PROCESS_KW_CMD("ECHO", redis_str_cmd, redis_string_response);

}

/* }}} */

/* {{{ proto string Redis::rename(string key_src, string key_dst)

*/

PHP_METHOD(Redis, rename)

{

REDIS_PROCESS_KW_CMD("RENAME", redis_key_key_cmd, redis_boolean_response);

}

/* }}} */

/* {{{ proto string Redis::renameNx(string key_src, string key_dst)

*/

PHP_METHOD(Redis, renameNx)

{

REDIS_PROCESS_KW_CMD("RENAMENX", redis_key_key_cmd, redis_1_response);

}

/* }}} */

/** {{{ proto bool Redis::reset()

*/

PHP_METHOD(Redis, reset)

{

char *response;

int response_len;

RedisSock *redis_sock;

smart_string cmd = {0};

zend_bool ret = 0;

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

RETURN_FALSE;

}

if (IS_PIPELINE(redis_sock)) {

php_error_docref(NULL, E_ERROR, "Reset isn't allowed in pipeline mode!");

RETURN_FALSE;

}

redis_cmd_init_sstr(&cmd, 0, ZEND_STRL("RESET"));

if (redis_process_request(redis_sock, cmd.c, cmd.len) != SUCCESS) {

RETURN_FALSE;

}

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

ret = REDIS_STRCMP_STATIC(response, response_len, "+RESET");

efree(response);

}

if (!ret) {

if (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;

}

/* }}} */

/* {{{ proto string Redis::get(string key)

*/

PHP_METHOD(Redis, get)

{

REDIS_PROCESS_KW_CMD("GET", redis_key_cmd, redis_string_response);

}

/* }}} */

/* {{{ proto Redis|array|false Redis::getWithMeta(string key)

*/

PHP_METHOD(Redis, getWithMeta)

{

REDIS_PROCESS_KW_CMD("GET", redis_key_cmd, redis_bulk_withmeta_response);

}

/* }}} */

/* {{{ proto string Redis::getDel(string key)

*/

PHP_METHOD(Redis, getDel)

{

REDIS_PROCESS_KW_CMD("GETDEL", redis_key_cmd, redis_string_response);

}

/* }}} */

/* {{{ proto string Redis::getEx(string key [, array $options = []])

*/

PHP_METHOD(Redis, getEx)

{

REDIS_PROCESS_CMD(getex, redis_string_response);

}

/* }}} */

/* {{{ proto string Redis::ping()

*/

PHP_METHOD(Redis, ping)

{

REDIS_PROCESS_KW_CMD("PING", redis_opt_str_cmd, redis_read_variant_reply);

}

/* }}} */

/* {{{ proto boolean Redis::incr(string key [,int value])

*/

PHP_METHOD(Redis, incr){

REDIS_PROCESS_CMD(incr, redis_long_response);

}

/* }}} */

/* {{{ proto boolean Redis::incrBy(string key ,int value)

*/

PHP_METHOD(Redis, incrBy){

REDIS_PROCESS_KW_CMD("INCRBY", redis_key_long_cmd, redis_long_response);

}

/* }}} */

/* {{{ proto float Redis::incrByFloat(string key, float value)

*/

PHP_METHOD(Redis, incrByFloat) {

REDIS_PROCESS_KW_CMD("INCRBYFLOAT", redis_key_dbl_cmd, redis_bulk_double_response);

}

/* }}} */

/* {{{ proto boolean Redis::decr(string key) */

PHP_METHOD(Redis, decr)

{

REDIS_PROCESS_CMD(decr, redis_long_response);

}

/* }}} */

/* {{{ proto boolean Redis::decrBy(string key ,int value)

*/

PHP_METHOD(Redis, decrBy){

REDIS_PROCESS_KW_CMD("DECRBY", redis_key_long_cmd, redis_long_response);

}

/* }}} */

/* {{{ proto array Redis::mget(array keys)

*/

PHP_METHOD(Redis, mget) {

REDIS_PROCESS_CMD(mget, redis_sock_read_multibulk_reply);

}

/* {{{ proto boolean Redis::exists(string $key, string ...$more_keys)

*/

PHP_METHOD(Redis, exists) {

REDIS_PROCESS_KW_CMD("EXISTS", redis_varkey_cmd, redis_long_response);

}

/* }}} */

/* {{{ proto boolean Redis::touch(string $key, string ...$more_keys)

*/

PHP_METHOD(Redis, touch) {

REDIS_PROCESS_KW_CMD("TOUCH", redis_varkey_cmd, redis_long_response);

}

/* }}} */

/* {{{ proto boolean Redis::del(string key)

*/

PHP_METHOD(Redis, del) {

REDIS_PROCESS_KW_CMD("DEL", redis_varkey_cmd, redis_long_response);

}

/* }}} */

PHP_METHOD(Redis, delex) {

REDIS_PROCESS_CMD(delex, redis_long_response);

}

PHP_METHOD(Redis, delifeq) {

REDIS_PROCESS_KW_CMD("DELIFEQ", redis_kv_cmd, redis_long_response);

}