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

/*

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

| PHP Version 5 |

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

| 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 "common.h"

#include "ext/standard/info.h"

#include "php_ini.h"

#include "php_redis.h"

#include "redis_array.h"

#include <zend_exceptions.h>

#ifdef PHP_SESSION

#include "ext/session/php_session.h"

#endif

#include <ext/standard/php_smart_str.h>

#include <ext/standard/php_var.h>

#include <ext/standard/php_math.h>

#include "library.h"

#define R_SUB_CALLBACK_CLASS_TYPE 1

#define R_SUB_CALLBACK_FT_TYPE 2

#define R_SUB_CLOSURE_TYPE 3

int le_redis_sock;

extern int le_redis_array;

#ifdef PHP_SESSION

extern ps_module ps_mod_redis;

#endif

extern zend_class_entry *redis_array_ce;

zend_class_entry *redis_ce;

zend_class_entry *redis_exception_ce;

zend_class_entry *spl_ce_RuntimeException = NULL;

extern zend_function_entry redis_array_functions[];

PHP_INI_BEGIN()

/* redis arrays */

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

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

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

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

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

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

PHP_INI_END()

/**

* Argument info for the SCAN proper

*/

ZEND_BEGIN_ARG_INFO_EX(arginfo_scan, 0, 0, 1)

ZEND_ARG_INFO(1, i_iterator)

ZEND_ARG_INFO(0, str_pattern)

ZEND_ARG_INFO(0, i_count)

ZEND_END_ARG_INFO();

/**

* Argument info for key scanning

*/

ZEND_BEGIN_ARG_INFO_EX(arginfo_kscan, 0, 0, 2)

ZEND_ARG_INFO(0, str_key)

ZEND_ARG_INFO(1, i_iterator)

ZEND_ARG_INFO(0, str_pattern)

ZEND_ARG_INFO(0, i_count)

ZEND_END_ARG_INFO();

#ifdef ZTS

ZEND_DECLARE_MODULE_GLOBALS(redis)

#endif

static zend_function_entry redis_functions[] = {

PHP_ME(Redis, __construct, NULL, ZEND_ACC_CTOR | ZEND_ACC_PUBLIC)

PHP_ME(Redis, __destruct, NULL, ZEND_ACC_DTOR | ZEND_ACC_PUBLIC)

PHP_ME(Redis, connect, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, pconnect, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, close, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, ping, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, echo, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, get, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, set, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, setex, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, psetex, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, setnx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getSet, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, randomKey, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, renameKey, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, renameNx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getMultiple, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, exists, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, delete, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, incr, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, incrBy, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, incrByFloat, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, decr, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, decrBy, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, type, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, append, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getRange, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, setRange, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getBit, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, setBit, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, strlen, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getKeys, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sort, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sortAsc, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sortAscAlpha, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sortDesc, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sortDescAlpha, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, lPush, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, rPush, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, lPushx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, rPushx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, lPop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, rPop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, blPop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, brPop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, lSize, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, lRemove, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, listTrim, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, lGet, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, lGetRange, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, lSet, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, lInsert, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sAdd, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sSize, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sRemove, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sMove, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sPop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sRandMember, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sContains, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sMembers, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sInter, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sInterStore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sUnion, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sUnionStore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sDiff, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sDiffStore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, setTimeout, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, save, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, bgSave, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, lastSave, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, flushDB, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, flushAll, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, dbSize, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, auth, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, ttl, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, pttl, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, persist, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, info, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, resetStat, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, select, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, move, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, bgrewriteaof, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, slaveof, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, object, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, bitop, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, bitcount, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, bitpos, NULL, ZEND_ACC_PUBLIC)

/* 1.1 */

PHP_ME(Redis, mset, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, msetnx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, rpoplpush, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, brpoplpush, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zAdd, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zDelete, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zRange, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zReverseRange, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zRangeByScore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zRevRangeByScore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zCount, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zDeleteRangeByScore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zDeleteRangeByRank, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zCard, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zScore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zRank, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zRevRank, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zInter, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zUnion, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zIncrBy, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, expireAt, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, pexpire, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, pexpireAt, NULL, ZEND_ACC_PUBLIC)

/* 1.2 */

PHP_ME(Redis, hGet, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hSet, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hSetNx, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hDel, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hLen, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hKeys, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hVals, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hGetAll, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hExists, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hIncrBy, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hIncrByFloat, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hMset, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hMget, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, multi, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, discard, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, exec, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, pipeline, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, watch, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, unwatch, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, publish, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, subscribe, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, psubscribe, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, unsubscribe, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, punsubscribe, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, time, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, eval, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, evalsha, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, script, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, debug, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, dump, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, restore, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, migrate, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getLastError, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, clearLastError, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, _prefix, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, _serialize, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, _unserialize, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, client, NULL, ZEND_ACC_PUBLIC)

/* SCAN and friends */

PHP_ME(Redis, scan, arginfo_scan, ZEND_ACC_PUBLIC)

PHP_ME(Redis, hscan, arginfo_kscan, ZEND_ACC_PUBLIC)

PHP_ME(Redis, zscan, arginfo_kscan, ZEND_ACC_PUBLIC)

PHP_ME(Redis, sscan, arginfo_kscan, ZEND_ACC_PUBLIC)

/* options */

PHP_ME(Redis, getOption, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, setOption, NULL, ZEND_ACC_PUBLIC)

/* config */

PHP_ME(Redis, config, NULL, ZEND_ACC_PUBLIC)

/* slowlog */

PHP_ME(Redis, slowlog, NULL, ZEND_ACC_PUBLIC)

/* introspection */

PHP_ME(Redis, getHost, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getPort, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getDBNum, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getTimeout, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getReadTimeout, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getPersistentID, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, getAuth, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, isConnected, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, wait, NULL, ZEND_ACC_PUBLIC)

PHP_ME(Redis, pubsub, NULL, ZEND_ACC_PUBLIC)

/* aliases */

PHP_MALIAS(Redis, open, connect, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, popen, pconnect, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, lLen, lSize, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, sGetMembers, sMembers, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, mget, getMultiple, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, expire, setTimeout, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, zunionstore, zUnion, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, zinterstore, zInter, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, zRemove, zDelete, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, zRem, zDelete, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, zRemoveRangeByScore, zDeleteRangeByScore, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, zRemRangeByScore, zDeleteRangeByScore, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, zRemRangeByRank, zDeleteRangeByRank, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, zSize, zCard, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, substr, getRange, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, rename, renameKey, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, del, delete, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, keys, getKeys, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, lrem, lRemove, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, ltrim, listTrim, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, lindex, lGet, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, lrange, lGetRange, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, scard, sSize, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, srem, sRemove, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, sismember, sContains, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, zrevrange, zReverseRange, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, sendEcho, echo, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, evaluate, eval, NULL, ZEND_ACC_PUBLIC)

PHP_MALIAS(Redis, evaluateSha, evalsha, NULL, ZEND_ACC_PUBLIC)

{NULL, NULL, NULL}

};

zend_module_entry redis_module_entry = {

#if ZEND_MODULE_API_NO >= 20010901

STANDARD_MODULE_HEADER,

#endif

"redis",

NULL,

PHP_MINIT(redis),

PHP_MSHUTDOWN(redis),

PHP_RINIT(redis),

PHP_RSHUTDOWN(redis),

PHP_MINFO(redis),

#if ZEND_MODULE_API_NO >= 20010901

PHP_REDIS_VERSION,

#endif

STANDARD_MODULE_PROPERTIES

};

#ifdef COMPILE_DL_REDIS

ZEND_GET_MODULE(redis)

#endif

PHP_REDIS_API zend_class_entry *redis_get_exception_base(int root TSRMLS_DC)

{

#if HAVE_SPL

if (!root) {

if (!spl_ce_RuntimeException) {

zend_class_entry **pce;

if (zend_hash_find(CG(class_table), "runtimeexception",

sizeof("RuntimeException"), (void **) &pce) == SUCCESS) {

spl_ce_RuntimeException = *pce;

return *pce;

}

} else {

return spl_ce_RuntimeException;

}

}

#endif

#if (PHP_MAJOR_VERSION == 5) && (PHP_MINOR_VERSION < 2)

return zend_exception_get_default();

#else

return zend_exception_get_default(TSRMLS_C);

#endif

}

/**

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

*/

static int send_discard_static(RedisSock *redis_sock TSRMLS_DC) {

int result = FAILURE;

char *cmd, *response;

int response_len, cmd_len;

/* format our discard command */

cmd_len = redis_cmd_format_static(&cmd, "DISCARD", "");

/* send our DISCARD command */

if (redis_sock_write(redis_sock, cmd, cmd_len TSRMLS_CC) >= 0 &&

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

/* success if we get OK */

result = (response_len == 3 && strncmp(response,"+OK", 3) == 0) ? SUCCESS : FAILURE;

/* free our response */

efree(response);

}

/* free our command */

efree(cmd);

/* return success/failure */

return result;

}

/**

* redis_destructor_redis_sock

*/

static void redis_destructor_redis_sock(zend_rsrc_list_entry * rsrc TSRMLS_DC)

{

RedisSock *redis_sock = (RedisSock *) rsrc->ptr;

redis_sock_disconnect(redis_sock TSRMLS_CC);

redis_free_socket(redis_sock);

}

/**

* redis_sock_get

*/

PHP_REDIS_API int redis_sock_get(zval *id, RedisSock **redis_sock TSRMLS_DC, int no_throw)

{

zval **socket;

int resource_type;

if (Z_TYPE_P(id) != IS_OBJECT || zend_hash_find(Z_OBJPROP_P(id), "socket",

sizeof("socket"), (void **) &socket) == FAILURE) {

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

if(!no_throw) {

zend_throw_exception(redis_exception_ce, "Redis server went away", 0 TSRMLS_CC);

}

return -1;

}

*redis_sock = (RedisSock *) zend_list_find(Z_LVAL_PP(socket), &resource_type);

if (!*redis_sock || resource_type != le_redis_sock) {

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

if(!no_throw) {

zend_throw_exception(redis_exception_ce, "Redis server went away", 0 TSRMLS_CC);

}

return -1;

}

if ((*redis_sock)->lazy_connect)

{

(*redis_sock)->lazy_connect = 0;

if (redis_sock_server_open(*redis_sock, 1 TSRMLS_CC) < 0) {

return -1;

}

}

return Z_LVAL_PP(socket);

}

/**

* 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() TSRMLS_CC, getThis(), "O", &object, redis_ce) == FAILURE) ||

(redis_sock_get(object, &redis_sock TSRMLS_CC, 1) < 0) || redis_sock->status != REDIS_SOCK_STATUS_CONNECTED)

{

return NULL;

}

/* Return our socket */

return redis_sock;

}

/**

* PHP_MINIT_FUNCTION

*/

PHP_MINIT_FUNCTION(redis)

{

zend_class_entry redis_class_entry;

zend_class_entry redis_array_class_entry;

zend_class_entry redis_exception_class_entry;

REGISTER_INI_ENTRIES();

/* Redis class */

INIT_CLASS_ENTRY(redis_class_entry, "Redis", redis_functions);

redis_ce = zend_register_internal_class(&redis_class_entry TSRMLS_CC);

/* RedisArray class */

INIT_CLASS_ENTRY(redis_array_class_entry, "RedisArray", redis_array_functions);

redis_array_ce = zend_register_internal_class(&redis_array_class_entry TSRMLS_CC);

le_redis_array = zend_register_list_destructors_ex(

redis_destructor_redis_array,

NULL,

"Redis Array", module_number

);

/* RedisException class */

INIT_CLASS_ENTRY(redis_exception_class_entry, "RedisException", NULL);

redis_exception_ce = zend_register_internal_class_ex(

&redis_exception_class_entry,

redis_get_exception_base(0 TSRMLS_CC),

NULL TSRMLS_CC

);

le_redis_sock = zend_register_list_destructors_ex(

redis_destructor_redis_sock,

NULL,

redis_sock_name, module_number

);

add_constant_long(redis_ce, "REDIS_NOT_FOUND", REDIS_NOT_FOUND);

add_constant_long(redis_ce, "REDIS_STRING", REDIS_STRING);

add_constant_long(redis_ce, "REDIS_SET", REDIS_SET);

add_constant_long(redis_ce, "REDIS_LIST", REDIS_LIST);

add_constant_long(redis_ce, "REDIS_ZSET", REDIS_ZSET);

add_constant_long(redis_ce, "REDIS_HASH", REDIS_HASH);

add_constant_long(redis_ce, "ATOMIC", ATOMIC);

add_constant_long(redis_ce, "MULTI", MULTI);

add_constant_long(redis_ce, "PIPELINE", PIPELINE);

/* options */

add_constant_long(redis_ce, "OPT_SERIALIZER", REDIS_OPT_SERIALIZER);

add_constant_long(redis_ce, "OPT_PREFIX", REDIS_OPT_PREFIX);

add_constant_long(redis_ce, "OPT_READ_TIMEOUT", REDIS_OPT_READ_TIMEOUT);

/* serializer */

add_constant_long(redis_ce, "SERIALIZER_NONE", REDIS_SERIALIZER_NONE);

add_constant_long(redis_ce, "SERIALIZER_PHP", REDIS_SERIALIZER_PHP);

/* scan options*/

add_constant_long(redis_ce, "OPT_SCAN", REDIS_OPT_SCAN);

add_constant_long(redis_ce, "SCAN_RETRY", REDIS_SCAN_RETRY);

add_constant_long(redis_ce, "SCAN_NORETRY", REDIS_SCAN_NORETRY);

#ifdef HAVE_REDIS_IGBINARY

add_constant_long(redis_ce, "SERIALIZER_IGBINARY", REDIS_SERIALIZER_IGBINARY);

#endif

zend_declare_class_constant_stringl(redis_ce, "AFTER", 5, "after", 5 TSRMLS_CC);

zend_declare_class_constant_stringl(redis_ce, "BEFORE", 6, "before", 6 TSRMLS_CC);

#ifdef PHP_SESSION

/* declare session handler */

php_session_register_module(&ps_mod_redis);

#endif

return SUCCESS;

}

/**

* PHP_MSHUTDOWN_FUNCTION

*/

PHP_MSHUTDOWN_FUNCTION(redis)

{

return SUCCESS;

}

/**

* PHP_RINIT_FUNCTION

*/

PHP_RINIT_FUNCTION(redis)

{

return SUCCESS;

}

/**

* PHP_RSHUTDOWN_FUNCTION

*/

PHP_RSHUTDOWN_FUNCTION(redis)

{

return SUCCESS;

}

/**

* PHP_MINFO_FUNCTION

*/

PHP_MINFO_FUNCTION(redis)

{

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

}

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

Public constructor */

PHP_METHOD(Redis, __construct)

{

if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {

RETURN_FALSE;

}

}

/* }}} */

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

Public Destructor

*/

PHP_METHOD(Redis,__destruct) {

RedisSock *redis_sock;

if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {

RETURN_FALSE;

}

/* Grab our socket */

if (redis_sock_get(getThis(), &redis_sock TSRMLS_CC, 1) < 0) {

RETURN_FALSE;

}

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

if(redis_sock->mode == MULTI) {

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

send_discard_static(redis_sock TSRMLS_CC);

free_reply_callbacks(getThis(), 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 {

/* reset multi/exec state if there is one. */

RedisSock *redis_sock;

if (redis_sock_get(getThis(), &redis_sock TSRMLS_CC, 0) < 0) {

RETURN_FALSE;

}

RETURN_TRUE;

}

}

/* }}} */

PHP_REDIS_API int redis_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent) {

zval *object;

zval **socket;

int host_len, id;

char *host = NULL;

long port = -1;

long retry_interval = 0;

char *persistent_id = NULL;

int persistent_id_len = -1;

double timeout = 0.0;

RedisSock *redis_sock = NULL;

#ifdef ZTS

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

persistent = 0;

#endif

if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|ldsl",

&object, redis_ce, &host, &host_len, &port,

&timeout, &persistent_id, &persistent_id_len,

&retry_interval) == FAILURE) {

return FAILURE;

}

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

zend_throw_exception(redis_exception_ce, "Invalid timeout", 0 TSRMLS_CC);

return FAILURE;

}

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

zend_throw_exception(redis_exception_ce, "Invalid retry interval", 0 TSRMLS_CC);

return FAILURE;

}

if(port == -1 && host_len && host[0] != '/') { /* not unix socket, set to default value */

port = 6379;

}

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

if (redis_sock_get(object, &redis_sock TSRMLS_CC, 1) > 0) {

if (zend_hash_find(Z_OBJPROP_P(object), "socket",

sizeof("socket"), (void **) &socket) == FAILURE)

{

/* maybe there is a socket but the id isn't known.. what to do? */

} else {

zend_list_delete(Z_LVAL_PP(socket)); /* the refcount should be decreased and the detructor called */

}

}

redis_sock = redis_sock_create(host, host_len, port, timeout, persistent, persistent_id, retry_interval, 0);

if (redis_sock_server_open(redis_sock, 1 TSRMLS_CC) < 0) {

redis_free_socket(redis_sock);

return FAILURE;

}

#if PHP_VERSION_ID >= 50400

id = zend_list_insert(redis_sock, le_redis_sock TSRMLS_CC);

#else

id = zend_list_insert(redis_sock, le_redis_sock);

#endif

add_property_resource(object, "socket", id);

return SUCCESS;

}

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

*/

PHP_METHOD(Redis, bitop)

{

char *cmd;

int cmd_len;

zval **z_args;

char **keys;

int *keys_len;

int argc = ZEND_NUM_ARGS(), i;

RedisSock *redis_sock = NULL;

smart_str buf = {0};

int key_free = 0;

/* get redis socket */

if (redis_sock_get(getThis(), &redis_sock TSRMLS_CC, 0) < 0) {

RETURN_FALSE;

}

/* fetch args */

z_args = emalloc(argc * sizeof(zval*));

if(zend_get_parameters_array(ht, argc, z_args) == FAILURE

|| argc < 3 /* 3 args min. */

|| Z_TYPE_P(z_args[0]) != IS_STRING /* operation must be a string. */

) {

efree(z_args);

RETURN_FALSE;

}

keys = emalloc(argc * sizeof(char*));

keys_len = emalloc(argc * sizeof(int));

/* prefix keys */

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

convert_to_string(z_args[i]);

keys[i] = Z_STRVAL_P(z_args[i]);

keys_len[i] = Z_STRLEN_P(z_args[i]);

if(i != 0)

key_free = redis_key_prefix(redis_sock, &keys[i], &keys_len[i] TSRMLS_CC);

}

/* start building the command */

smart_str_appendc(&buf, '*');

smart_str_append_long(&buf, argc + 1); /* +1 for BITOP command */

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

/* add command name */

smart_str_appendc(&buf, '$');

smart_str_append_long(&buf, 5);

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

smart_str_appendl(&buf, "BITOP", 5);

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

/* add keys */

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

smart_str_appendc(&buf, '$');

smart_str_append_long(&buf, keys_len[i]);

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

smart_str_appendl(&buf, keys[i], keys_len[i]);

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

}

/* end string */

smart_str_0(&buf);

cmd = buf.c;

cmd_len = buf.len;

/* cleanup */

if(key_free)

for(i = 1; i < argc; ++i) {

efree(keys[i]);

}

efree(keys);

efree(keys_len);

efree(z_args);

/* send */

REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len);

IF_ATOMIC() {

redis_long_response(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, NULL);

}

REDIS_PROCESS_RESPONSE(redis_long_response);

}

/* }}} */

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

*/

PHP_METHOD(Redis, bitcount)

{

zval *object;

RedisSock *redis_sock;

char *key = NULL, *cmd;

int key_len, cmd_len, key_free;

long start = 0, end = -1;

if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|ll",

&object, redis_ce,

&key, &key_len, &start, &end) == FAILURE) {

RETURN_FALSE;

}

if (redis_sock_get(object, &redis_sock TSRMLS_CC, 0) < 0) {

RETURN_FALSE;

}

/* BITCOUNT key start end */

key_free = redis_key_prefix(redis_sock, &key, &key_len TSRMLS_CC);

cmd_len = redis_cmd_format_static(&cmd, "BITCOUNT", "sdd", key, key_len, (int)start, (int)end);

if(key_free) efree(key);

REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len);

IF_ATOMIC() {

redis_long_response(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, NULL);

}

REDIS_PROCESS_RESPONSE(redis_long_response);

}

/* }}} */

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

PHP_METHOD(Redis, bitpos)

{

zval *object;

RedisSock *redis_sock;

char *key, *cmd;

int key_len, cmd_len, argc, key_free=0;

long bit, start, end;

argc = ZEND_NUM_ARGS();

if(zend_parse_method_parameters(argc TSRMLS_CC, getThis(), "Osl|ll",

&object, redis_ce, &key, &key_len, &bit,

&start, &end)==FAILURE)

{

RETURN_FALSE;

}

if(redis_sock_get(object, &redis_sock TSRMLS_CC, 0) < 0) {

RETURN_FALSE;

}

/* We can prevalidate the first argument */

if(bit != 0 && bit != 1) {

RETURN_FALSE;

}

/* Prefix our key */

key_free = redis_key_prefix(redis_sock, &key, &key_len TSRMLS_CC);

/* Various command semantics */

if(argc == 2) {

cmd_len = redis_cmd_format_static(&cmd, "BITPOS", "sd", key, key_len,

bit);

} else if(argc == 3) {

cmd_len = redis_cmd_format_static(&cmd, "BITPOS", "sdd", key, key_len,

bit, start);

} else {

cmd_len = redis_cmd_format_static(&cmd, "BITPOS", "sddd", key, key_len,

bit, start, end);

}

/* Free our key if it was prefixed */

if(key_free) efree(key);

REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len);

IF_ATOMIC() {

redis_long_response(INTERNAL_FUNCTION_PARAM_PASSTHRU, redis_sock, NULL, NULL);

}

REDIS_PROCESS_RESPONSE(redis_long_response);

}

/* }}} */

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

*/

PHP_METHOD(Redis, close)

{

zval *object;

RedisSock *redis_sock = NULL;

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

&object, redis_ce) == FAILURE) {

RETURN_FALSE;

}

if (redis_sock_get(object, &redis_sock TSRMLS_CC, 0) < 0) {

RETURN_FALSE;

}

if (redis_sock_disconnect(redis_sock TSRMLS_CC)) {

RETURN_TRUE;

}

RETURN_FALSE;

}

/* }}} */

/* {{{ proto boolean Redis::set(string key, mixed value, long timeout | array options) */

PHP_METHOD(Redis, set) {

zval *object;

RedisSock *redis_sock;

char *key = NULL, *val = NULL, *cmd, *exp_type = NULL, *set_type = NULL;

int key_len, val_len, cmd_len;

long expire = -1;

int val_free = 0, key_free = 0;

zval *z_value, *z_opts = NULL;

/* Make sure the arguments are correct */

if(zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Osz|z",

&object, redis_ce, &key, &key_len, &z_value,

&z_opts) == FAILURE)

{

RETURN_FALSE;

}

/* Ensure we can grab our redis socket */

if(redis_sock_get(object, &redis_sock TSRMLS_CC, 0) < 0) {

RETURN_FALSE;

}

/* Our optional argument can either be a long (to support legacy SETEX */

/* redirection), or an array with Redis >= 2.6.12 set options */

if(z_opts && Z_TYPE_P(z_opts) != IS_LONG && Z_TYPE_P(z_opts) != IS_ARRAY

&& Z_TYPE_P(z_opts) != IS_NULL)

{

RETURN_FALSE;

}

/* Serialization, key prefixing */

val_free = redis_serialize(redis_sock, z_value, &val, &val_len TSRMLS_CC);

key_free = redis_key_prefix(redis_sock, &key, &key_len TSRMLS_CC);

if(z_opts && Z_TYPE_P(z_opts) == IS_ARRAY) {

HashTable *kt = Z_ARRVAL_P(z_opts);

int type;

unsigned int ht_key_len;

unsigned long idx;

char *k;

zval **v;

/* Iterate our option array */

for(zend_hash_internal_pointer_reset(kt);

zend_hash_has_more_elements(kt) == SUCCESS;

zend_hash_move_forward(kt))

{

/* Grab key and value */

type = zend_hash_get_current_key_ex(kt, &k, &ht_key_len, &idx, 0, NULL);

zend_hash_get_current_data(kt, (void**)&v);

if(type == HASH_KEY_IS_STRING && (Z_TYPE_PP(v) == IS_LONG) &&

(Z_LVAL_PP(v) > 0) && IS_EX_PX_ARG(k))

{

exp_type = k;

expire = Z_LVAL_PP(v);

} else if(Z_TYPE_PP(v) == IS_STRING && IS_NX_XX_ARG(Z_STRVAL_PP(v))) {

set_type = Z_STRVAL_PP(v);

}

}

} else if(z_opts && Z_TYPE_P(z_opts) == IS_LONG) {

expire = Z_LVAL_P(z_opts);

}

/* Now let's construct the command we want */

if(exp_type && set_type) {

/* SET <key> <value> NX|XX PX|EX <timeout> */

cmd_len = redis_cmd_format_static(&cmd, "SET", "ssssl", key, key_len,

val, val_len, set_type, 2, exp_type,

2, expire);

} else if(exp_type) {

/* SET <key> <value> PX|EX <timeout> */

cmd_len = redis_cmd_format_static(&cmd, "SET", "sssl", key, key_len,

val, val_len, exp_type, 2, expire);

} else if(set_type) {

/* SET <key> <value> NX|XX */

cmd_len = redis_cmd_format_static(&cmd, "SET", "sss", key, key_len,

val, val_len, set_type, 2);

} else if(expire > 0) {

/* Backward compatible SETEX redirection */

cmd_len = redis_cmd_format_static(&cmd, "SETEX", "sls", key, key_len,

expire, val, val_len);

} else {

/* SET <key> <value> */

cmd_len = redis_cmd_format_static(&cmd, "SET", "ss", key, key_len,

val, val_len);

}

/* Free our key or value if we prefixed/serialized */

if(key_free) efree(key);

if(val_free) STR_FREE(val);

/* Kick off the command */

REDIS_PROCESS_REQUEST(redis_sock, cmd, cmd_len);