Merge branch 'redis:master' into master
commit
c6657ef65b
|
@ -0,0 +1,182 @@
|
||||||
|
name: Build and test
|
||||||
|
on: [push, pull_request]
|
||||||
|
|
||||||
|
jobs:
|
||||||
|
ubuntu:
|
||||||
|
runs-on: ubuntu-latest
|
||||||
|
steps:
|
||||||
|
- name: Checkout code
|
||||||
|
uses: actions/checkout@v2
|
||||||
|
with:
|
||||||
|
repository: ${{ env.GITHUB_REPOSITORY }}
|
||||||
|
ref: ${{ env.GITHUB_HEAD_REF }}
|
||||||
|
|
||||||
|
- name: Install dependencies
|
||||||
|
run: |
|
||||||
|
sudo add-apt-repository -y ppa:chris-lea/redis-server
|
||||||
|
sudo apt-get update
|
||||||
|
sudo apt-get install -y redis-server valgrind libevent-dev
|
||||||
|
|
||||||
|
- name: Build using cmake
|
||||||
|
env:
|
||||||
|
EXTRA_CMAKE_OPTS: -DENABLE_EXAMPLES:BOOL=ON -DENABLE_SSL:BOOL=ON -DENABLE_SSL_TESTS:BOOL=ON -DENABLE_ASYNC_TESTS:BOOL=ON
|
||||||
|
CFLAGS: -Werror
|
||||||
|
CXXFLAGS: -Werror
|
||||||
|
run: mkdir build-ubuntu && cd build-ubuntu && cmake ..
|
||||||
|
|
||||||
|
- name: Build using makefile
|
||||||
|
run: USE_SSL=1 TEST_ASYNC=1 make
|
||||||
|
|
||||||
|
- name: Run tests
|
||||||
|
env:
|
||||||
|
SKIPS_AS_FAILS: 1
|
||||||
|
TEST_SSL: 1
|
||||||
|
run: $GITHUB_WORKSPACE/test.sh
|
||||||
|
|
||||||
|
# - name: Run tests under valgrind
|
||||||
|
# env:
|
||||||
|
# SKIPS_AS_FAILS: 1
|
||||||
|
# TEST_PREFIX: valgrind --error-exitcode=99 --track-origins=yes --leak-check=full
|
||||||
|
# run: $GITHUB_WORKSPACE/test.sh
|
||||||
|
|
||||||
|
centos7:
|
||||||
|
runs-on: ubuntu-latest
|
||||||
|
container: centos:7
|
||||||
|
steps:
|
||||||
|
- name: Checkout code
|
||||||
|
uses: actions/checkout@v2
|
||||||
|
with:
|
||||||
|
repository: ${{ env.GITHUB_REPOSITORY }}
|
||||||
|
ref: ${{ env.GITHUB_HEAD_REF }}
|
||||||
|
|
||||||
|
- name: Install dependencies
|
||||||
|
run: |
|
||||||
|
yum -y install http://rpms.remirepo.net/enterprise/remi-release-7.rpm
|
||||||
|
yum -y --enablerepo=remi install redis
|
||||||
|
yum -y install gcc gcc-c++ make openssl openssl-devel cmake3 valgrind libevent-devel
|
||||||
|
|
||||||
|
- name: Build using cmake
|
||||||
|
env:
|
||||||
|
EXTRA_CMAKE_OPTS: -DENABLE_EXAMPLES:BOOL=ON -DENABLE_SSL:BOOL=ON -DENABLE_SSL_TESTS:BOOL=ON -DENABLE_ASYNC_TESTS:BOOL=ON
|
||||||
|
CFLAGS: -Werror
|
||||||
|
CXXFLAGS: -Werror
|
||||||
|
run: mkdir build-centos7 && cd build-centos7 && cmake3 ..
|
||||||
|
|
||||||
|
- name: Build using Makefile
|
||||||
|
run: USE_SSL=1 TEST_ASYNC=1 make
|
||||||
|
|
||||||
|
- name: Run tests
|
||||||
|
env:
|
||||||
|
SKIPS_AS_FAILS: 1
|
||||||
|
TEST_SSL: 1
|
||||||
|
run: $GITHUB_WORKSPACE/test.sh
|
||||||
|
|
||||||
|
- name: Run tests under valgrind
|
||||||
|
env:
|
||||||
|
SKIPS_AS_FAILS: 1
|
||||||
|
TEST_SSL: 1
|
||||||
|
TEST_PREFIX: valgrind --error-exitcode=99 --track-origins=yes --leak-check=full
|
||||||
|
run: $GITHUB_WORKSPACE/test.sh
|
||||||
|
|
||||||
|
centos8:
|
||||||
|
runs-on: ubuntu-latest
|
||||||
|
container: centos:8
|
||||||
|
steps:
|
||||||
|
- name: Checkout code
|
||||||
|
uses: actions/checkout@v2
|
||||||
|
with:
|
||||||
|
repository: ${{ env.GITHUB_REPOSITORY }}
|
||||||
|
ref: ${{ env.GITHUB_HEAD_REF }}
|
||||||
|
|
||||||
|
- name: Install dependencies
|
||||||
|
run: |
|
||||||
|
dnf -y install https://rpms.remirepo.net/enterprise/remi-release-8.rpm
|
||||||
|
dnf -y module install redis:remi-6.0
|
||||||
|
dnf -y group install "Development Tools"
|
||||||
|
dnf -y install openssl-devel cmake valgrind libevent-devel
|
||||||
|
|
||||||
|
- name: Build using cmake
|
||||||
|
env:
|
||||||
|
EXTRA_CMAKE_OPTS: -DENABLE_EXAMPLES:BOOL=ON -DENABLE_SSL:BOOL=ON -DENABLE_SSL_TESTS:BOOL=ON -DENABLE_ASYNC_TESTS:BOOL=ON
|
||||||
|
CFLAGS: -Werror
|
||||||
|
CXXFLAGS: -Werror
|
||||||
|
run: mkdir build-centos8 && cd build-centos8 && cmake ..
|
||||||
|
|
||||||
|
- name: Build using Makefile
|
||||||
|
run: USE_SSL=1 TEST_ASYNC=1 make
|
||||||
|
|
||||||
|
- name: Run tests
|
||||||
|
env:
|
||||||
|
SKIPS_AS_FAILS: 1
|
||||||
|
TEST_SSL: 1
|
||||||
|
run: $GITHUB_WORKSPACE/test.sh
|
||||||
|
|
||||||
|
- name: Run tests under valgrind
|
||||||
|
env:
|
||||||
|
SKIPS_AS_FAILS: 1
|
||||||
|
TEST_SSL: 1
|
||||||
|
TEST_PREFIX: valgrind --error-exitcode=99 --track-origins=yes --leak-check=full
|
||||||
|
run: $GITHUB_WORKSPACE/test.sh
|
||||||
|
|
||||||
|
macos:
|
||||||
|
runs-on: macos-latest
|
||||||
|
steps:
|
||||||
|
- name: Checkout code
|
||||||
|
uses: actions/checkout@v2
|
||||||
|
with:
|
||||||
|
repository: ${{ env.GITHUB_REPOSITORY }}
|
||||||
|
ref: ${{ env.GITHUB_HEAD_REF }}
|
||||||
|
|
||||||
|
- name: Install dependencies
|
||||||
|
run: |
|
||||||
|
brew install openssl redis
|
||||||
|
|
||||||
|
- name: Build hiredis
|
||||||
|
run: USE_SSL=1 make
|
||||||
|
|
||||||
|
- name: Run tests
|
||||||
|
env:
|
||||||
|
TEST_SSL: 1
|
||||||
|
run: $GITHUB_WORKSPACE/test.sh
|
||||||
|
|
||||||
|
windows:
|
||||||
|
runs-on: windows-latest
|
||||||
|
steps:
|
||||||
|
- name: Checkout code
|
||||||
|
uses: actions/checkout@v2
|
||||||
|
with:
|
||||||
|
repository: ${{ env.GITHUB_REPOSITORY }}
|
||||||
|
ref: ${{ env.GITHUB_HEAD_REF }}
|
||||||
|
|
||||||
|
- name: Install dependencies
|
||||||
|
run: |
|
||||||
|
choco install -y ninja memurai-developer
|
||||||
|
|
||||||
|
- uses: ilammy/msvc-dev-cmd@v1
|
||||||
|
- name: Build hiredis
|
||||||
|
run: |
|
||||||
|
mkdir build && cd build
|
||||||
|
cmake .. -G Ninja -DCMAKE_BUILD_TYPE=Release -DENABLE_EXAMPLES=ON
|
||||||
|
ninja -v
|
||||||
|
|
||||||
|
- name: Run tests
|
||||||
|
run: |
|
||||||
|
./build/hiredis-test.exe
|
||||||
|
|
||||||
|
- name: Setup cygwin
|
||||||
|
uses: egor-tensin/setup-cygwin@v3
|
||||||
|
with:
|
||||||
|
platform: x64
|
||||||
|
packages: make git gcc-core
|
||||||
|
|
||||||
|
- name: Build in cygwin
|
||||||
|
env:
|
||||||
|
HIREDIS_PATH: ${{ github.workspace }}
|
||||||
|
run: |
|
||||||
|
build_hiredis() {
|
||||||
|
cd $(cygpath -u $HIREDIS_PATH)
|
||||||
|
git clean -xfd
|
||||||
|
make
|
||||||
|
}
|
||||||
|
build_hiredis
|
||||||
|
shell: C:\tools\cygwin\bin\bash.exe --login --norc -eo pipefail -o igncr '{0}'
|
19
CHANGELOG.md
19
CHANGELOG.md
|
@ -1,3 +1,22 @@
|
||||||
|
## [1.0.2](https://github.com/redis/hiredis/tree/v1.0.2) - (2021-10-07)
|
||||||
|
|
||||||
|
Announcing Hiredis v1.0.2, which fixes CVE-2021-32765 but returns the SONAME to the correct value of `1.0.0`.
|
||||||
|
|
||||||
|
- [Revert SONAME bump](https://github.com/redis/hiredis/commit/d4e6f109a064690cde64765c654e679fea1d3548)
|
||||||
|
([Michael Grunder](https://github.com/michael-grunder))
|
||||||
|
|
||||||
|
## [1.0.1](https://github.com/redis/hiredis/tree/v1.0.1) - (2021-10-04)
|
||||||
|
|
||||||
|
<span style="color:red">This release erroneously bumped the SONAME, please use [1.0.2](https://github.com/redis/hiredis/tree/v1.0.2)</span>
|
||||||
|
|
||||||
|
Announcing Hiredis v1.0.1, a security release fixing CVE-2021-32765
|
||||||
|
|
||||||
|
- Fix for [CVE-2021-32765](https://github.com/redis/hiredis/security/advisories/GHSA-hfm9-39pp-55p2)
|
||||||
|
[commit](https://github.com/redis/hiredis/commit/76a7b10005c70babee357a7d0f2becf28ec7ed1e)
|
||||||
|
([Yossi Gottlieb](https://github.com/yossigo))
|
||||||
|
|
||||||
|
_Thanks to [Yossi Gottlieb](https://github.com/yossigo) for the security fix and to [Microsoft Security Vulnerability Research](https://www.microsoft.com/en-us/msrc/msvr) for finding the bug._ :sparkling_heart:
|
||||||
|
|
||||||
## [1.0.0](https://github.com/redis/hiredis/tree/v1.0.0) - (2020-08-03)
|
## [1.0.0](https://github.com/redis/hiredis/tree/v1.0.0) - (2020-08-03)
|
||||||
|
|
||||||
Announcing Hiredis v1.0.0, which adds support for RESP3, SSL connections, allocator injection, and better Windows support! :tada:
|
Announcing Hiredis v1.0.0, which adds support for RESP3, SSL connections, allocator injection, and better Windows support! :tada:
|
||||||
|
|
|
@ -4,7 +4,8 @@ PROJECT(hiredis)
|
||||||
|
|
||||||
OPTION(ENABLE_SSL "Build hiredis_ssl for SSL support" OFF)
|
OPTION(ENABLE_SSL "Build hiredis_ssl for SSL support" OFF)
|
||||||
OPTION(DISABLE_TESTS "If tests should be compiled or not" OFF)
|
OPTION(DISABLE_TESTS "If tests should be compiled or not" OFF)
|
||||||
OPTION(ENABLE_SSL_TESTS, "Should we test SSL connections" OFF)
|
OPTION(ENABLE_SSL_TESTS "Should we test SSL connections" OFF)
|
||||||
|
OPTION(ENABLE_ASYNC_TESTS "Should we run all asynchronous API tests" OFF)
|
||||||
|
|
||||||
MACRO(getVersionBit name)
|
MACRO(getVersionBit name)
|
||||||
SET(VERSION_REGEX "^#define ${name} (.+)$")
|
SET(VERSION_REGEX "^#define ${name} (.+)$")
|
||||||
|
@ -218,11 +219,14 @@ ENDIF()
|
||||||
IF(NOT DISABLE_TESTS)
|
IF(NOT DISABLE_TESTS)
|
||||||
ENABLE_TESTING()
|
ENABLE_TESTING()
|
||||||
ADD_EXECUTABLE(hiredis-test test.c)
|
ADD_EXECUTABLE(hiredis-test test.c)
|
||||||
|
TARGET_LINK_LIBRARIES(hiredis-test hiredis)
|
||||||
IF(ENABLE_SSL_TESTS)
|
IF(ENABLE_SSL_TESTS)
|
||||||
ADD_DEFINITIONS(-DHIREDIS_TEST_SSL=1)
|
ADD_DEFINITIONS(-DHIREDIS_TEST_SSL=1)
|
||||||
TARGET_LINK_LIBRARIES(hiredis-test hiredis hiredis_ssl)
|
TARGET_LINK_LIBRARIES(hiredis-test hiredis_ssl)
|
||||||
ELSE()
|
ENDIF()
|
||||||
TARGET_LINK_LIBRARIES(hiredis-test hiredis)
|
IF(ENABLE_ASYNC_TESTS)
|
||||||
|
ADD_DEFINITIONS(-DHIREDIS_TEST_ASYNC=1)
|
||||||
|
TARGET_LINK_LIBRARIES(hiredis-test event)
|
||||||
ENDIF()
|
ENDIF()
|
||||||
ADD_TEST(NAME hiredis-test
|
ADD_TEST(NAME hiredis-test
|
||||||
COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test.sh)
|
COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/test.sh)
|
||||||
|
|
19
Makefile
19
Makefile
|
@ -73,11 +73,19 @@ USE_SSL?=0
|
||||||
|
|
||||||
# This is required for test.c only
|
# This is required for test.c only
|
||||||
ifeq ($(USE_SSL),1)
|
ifeq ($(USE_SSL),1)
|
||||||
CFLAGS+=-DHIREDIS_TEST_SSL
|
export CFLAGS+=-DHIREDIS_TEST_SSL
|
||||||
|
endif
|
||||||
|
ifeq ($(TEST_ASYNC),1)
|
||||||
|
export CFLAGS+=-DHIREDIS_TEST_ASYNC
|
||||||
endif
|
endif
|
||||||
|
|
||||||
ifeq ($(uname_S),Linux)
|
ifeq ($(uname_S),Linux)
|
||||||
SSL_LDFLAGS=-lssl -lcrypto
|
ifdef OPENSSL_PREFIX
|
||||||
|
CFLAGS+=-I$(OPENSSL_PREFIX)/include
|
||||||
|
SSL_LDFLAGS+=-L$(OPENSSL_PREFIX)/lib -lssl -lcrypto
|
||||||
|
else
|
||||||
|
SSL_LDFLAGS=-lssl -lcrypto
|
||||||
|
endif
|
||||||
else
|
else
|
||||||
OPENSSL_PREFIX?=/usr/local/opt/openssl
|
OPENSSL_PREFIX?=/usr/local/opt/openssl
|
||||||
CFLAGS+=-I$(OPENSSL_PREFIX)/include
|
CFLAGS+=-I$(OPENSSL_PREFIX)/include
|
||||||
|
@ -206,6 +214,9 @@ ifeq ($(USE_SSL),1)
|
||||||
TEST_LIBS += $(SSL_STLIBNAME)
|
TEST_LIBS += $(SSL_STLIBNAME)
|
||||||
TEST_LDFLAGS = $(SSL_LDFLAGS) -lssl -lcrypto -lpthread
|
TEST_LDFLAGS = $(SSL_LDFLAGS) -lssl -lcrypto -lpthread
|
||||||
endif
|
endif
|
||||||
|
ifeq ($(TEST_ASYNC),1)
|
||||||
|
TEST_LDFLAGS += -levent
|
||||||
|
endif
|
||||||
|
|
||||||
hiredis-test: test.o $(TEST_LIBS)
|
hiredis-test: test.o $(TEST_LIBS)
|
||||||
$(CC) -o $@ $(REAL_CFLAGS) -I. $^ $(REAL_LDFLAGS) $(TEST_LDFLAGS)
|
$(CC) -o $@ $(REAL_CFLAGS) -I. $^ $(REAL_LDFLAGS) $(TEST_LDFLAGS)
|
||||||
|
@ -294,12 +305,12 @@ gprof:
|
||||||
$(MAKE) CFLAGS="-pg" LDFLAGS="-pg"
|
$(MAKE) CFLAGS="-pg" LDFLAGS="-pg"
|
||||||
|
|
||||||
gcov:
|
gcov:
|
||||||
$(MAKE) CFLAGS="-fprofile-arcs -ftest-coverage" LDFLAGS="-fprofile-arcs"
|
$(MAKE) CFLAGS+="-fprofile-arcs -ftest-coverage" LDFLAGS="-fprofile-arcs"
|
||||||
|
|
||||||
coverage: gcov
|
coverage: gcov
|
||||||
make check
|
make check
|
||||||
mkdir -p tmp/lcov
|
mkdir -p tmp/lcov
|
||||||
lcov -d . -c -o tmp/lcov/hiredis.info
|
lcov -d . -c --exclude '/usr*' -o tmp/lcov/hiredis.info
|
||||||
genhtml --legend -o tmp/lcov/report tmp/lcov/hiredis.info
|
genhtml --legend -o tmp/lcov/report tmp/lcov/hiredis.info
|
||||||
|
|
||||||
noopt:
|
noopt:
|
||||||
|
|
19
README.md
19
README.md
|
@ -1,10 +1,11 @@
|
||||||
[![Build Status](https://travis-ci.org/redis/hiredis.png)](https://travis-ci.org/redis/hiredis)
|
|
||||||
|
[![Build Status](https://github.com/redis/hiredis/actions/workflows/build.yml/badge.svg)](https://github.com/redis/hiredis/actions/workflows/build.yml)
|
||||||
|
|
||||||
**This Readme reflects the latest changed in the master branch. See [v1.0.0](https://github.com/redis/hiredis/tree/v1.0.0) for the Readme and documentation for the latest release ([API/ABI history](https://abi-laboratory.pro/?view=timeline&l=hiredis)).**
|
**This Readme reflects the latest changed in the master branch. See [v1.0.0](https://github.com/redis/hiredis/tree/v1.0.0) for the Readme and documentation for the latest release ([API/ABI history](https://abi-laboratory.pro/?view=timeline&l=hiredis)).**
|
||||||
|
|
||||||
# HIREDIS
|
# HIREDIS
|
||||||
|
|
||||||
Hiredis is a minimalistic C client library for the [Redis](http://redis.io/) database.
|
Hiredis is a minimalistic C client library for the [Redis](https://redis.io/) database.
|
||||||
|
|
||||||
It is minimalistic because it just adds minimal support for the protocol, but
|
It is minimalistic because it just adds minimal support for the protocol, but
|
||||||
at the same time it uses a high level printf-alike API in order to make it
|
at the same time it uses a high level printf-alike API in order to make it
|
||||||
|
@ -22,6 +23,12 @@ Redis version >= 1.2.0.
|
||||||
The library comes with multiple APIs. There is the
|
The library comes with multiple APIs. There is the
|
||||||
*synchronous API*, the *asynchronous API* and the *reply parsing API*.
|
*synchronous API*, the *asynchronous API* and the *reply parsing API*.
|
||||||
|
|
||||||
|
## Upgrading to `1.0.2`
|
||||||
|
|
||||||
|
<span style="color:red">NOTE: v1.0.1 erroneously bumped SONAME, which is why it is skipped here.</span>
|
||||||
|
|
||||||
|
Version 1.0.2 is simply 1.0.0 with a fix for [CVE-2021-32765](https://github.com/redis/hiredis/security/advisories/GHSA-hfm9-39pp-55p2). They are otherwise identical.
|
||||||
|
|
||||||
## Upgrading to `1.0.0`
|
## Upgrading to `1.0.0`
|
||||||
|
|
||||||
Version 1.0.0 marks the first stable release of Hiredis.
|
Version 1.0.0 marks the first stable release of Hiredis.
|
||||||
|
@ -169,7 +176,7 @@ Hiredis also supports every new `RESP3` data type which are as follows. For mor
|
||||||
|
|
||||||
* **`REDIS_REPLY_MAP`**:
|
* **`REDIS_REPLY_MAP`**:
|
||||||
* An array with the added invariant that there will always be an even number of elements.
|
* An array with the added invariant that there will always be an even number of elements.
|
||||||
The MAP is functionally equivelant to `REDIS_REPLY_ARRAY` except for the previously mentioned invariant.
|
The MAP is functionally equivalent to `REDIS_REPLY_ARRAY` except for the previously mentioned invariant.
|
||||||
|
|
||||||
* **`REDIS_REPLY_SET`**:
|
* **`REDIS_REPLY_SET`**:
|
||||||
* An array response where each entry is unique.
|
* An array response where each entry is unique.
|
||||||
|
@ -189,7 +196,7 @@ Hiredis also supports every new `RESP3` data type which are as follows. For mor
|
||||||
|
|
||||||
* **`REDIS_REPLY_VERB`**:
|
* **`REDIS_REPLY_VERB`**:
|
||||||
* A verbatim string, intended to be presented to the user without modification.
|
* A verbatim string, intended to be presented to the user without modification.
|
||||||
The string payload is stored in the `str` memeber, and type data is stored in the `vtype` member (e.g. `txt` for raw text or `md` for markdown).
|
The string payload is stored in the `str` member, and type data is stored in the `vtype` member (e.g. `txt` for raw text or `md` for markdown).
|
||||||
|
|
||||||
Replies should be freed using the `freeReplyObject()` function.
|
Replies should be freed using the `freeReplyObject()` function.
|
||||||
Note that this function will take care of freeing sub-reply objects
|
Note that this function will take care of freeing sub-reply objects
|
||||||
|
@ -261,9 +268,9 @@ a single call to `read(2)`):
|
||||||
redisReply *reply;
|
redisReply *reply;
|
||||||
redisAppendCommand(context,"SET foo bar");
|
redisAppendCommand(context,"SET foo bar");
|
||||||
redisAppendCommand(context,"GET foo");
|
redisAppendCommand(context,"GET foo");
|
||||||
redisGetReply(context,(void *)&reply); // reply for SET
|
redisGetReply(context,(void**)&reply); // reply for SET
|
||||||
freeReplyObject(reply);
|
freeReplyObject(reply);
|
||||||
redisGetReply(context,(void *)&reply); // reply for GET
|
redisGetReply(context,(void**)&reply); // reply for GET
|
||||||
freeReplyObject(reply);
|
freeReplyObject(reply);
|
||||||
```
|
```
|
||||||
This API can also be used to implement a blocking subscriber:
|
This API can also be used to implement a blocking subscriber:
|
||||||
|
|
|
@ -66,8 +66,9 @@ static void redisLibevWriteEvent(EV_P_ ev_io *watcher, int revents) {
|
||||||
|
|
||||||
static void redisLibevAddRead(void *privdata) {
|
static void redisLibevAddRead(void *privdata) {
|
||||||
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
||||||
|
#if EV_MULTIPLICITY
|
||||||
struct ev_loop *loop = e->loop;
|
struct ev_loop *loop = e->loop;
|
||||||
((void)loop);
|
#endif
|
||||||
if (!e->reading) {
|
if (!e->reading) {
|
||||||
e->reading = 1;
|
e->reading = 1;
|
||||||
ev_io_start(EV_A_ &e->rev);
|
ev_io_start(EV_A_ &e->rev);
|
||||||
|
@ -76,8 +77,9 @@ static void redisLibevAddRead(void *privdata) {
|
||||||
|
|
||||||
static void redisLibevDelRead(void *privdata) {
|
static void redisLibevDelRead(void *privdata) {
|
||||||
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
||||||
|
#if EV_MULTIPLICITY
|
||||||
struct ev_loop *loop = e->loop;
|
struct ev_loop *loop = e->loop;
|
||||||
((void)loop);
|
#endif
|
||||||
if (e->reading) {
|
if (e->reading) {
|
||||||
e->reading = 0;
|
e->reading = 0;
|
||||||
ev_io_stop(EV_A_ &e->rev);
|
ev_io_stop(EV_A_ &e->rev);
|
||||||
|
@ -86,8 +88,9 @@ static void redisLibevDelRead(void *privdata) {
|
||||||
|
|
||||||
static void redisLibevAddWrite(void *privdata) {
|
static void redisLibevAddWrite(void *privdata) {
|
||||||
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
||||||
|
#if EV_MULTIPLICITY
|
||||||
struct ev_loop *loop = e->loop;
|
struct ev_loop *loop = e->loop;
|
||||||
((void)loop);
|
#endif
|
||||||
if (!e->writing) {
|
if (!e->writing) {
|
||||||
e->writing = 1;
|
e->writing = 1;
|
||||||
ev_io_start(EV_A_ &e->wev);
|
ev_io_start(EV_A_ &e->wev);
|
||||||
|
@ -96,8 +99,9 @@ static void redisLibevAddWrite(void *privdata) {
|
||||||
|
|
||||||
static void redisLibevDelWrite(void *privdata) {
|
static void redisLibevDelWrite(void *privdata) {
|
||||||
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
||||||
|
#if EV_MULTIPLICITY
|
||||||
struct ev_loop *loop = e->loop;
|
struct ev_loop *loop = e->loop;
|
||||||
((void)loop);
|
#endif
|
||||||
if (e->writing) {
|
if (e->writing) {
|
||||||
e->writing = 0;
|
e->writing = 0;
|
||||||
ev_io_stop(EV_A_ &e->wev);
|
ev_io_stop(EV_A_ &e->wev);
|
||||||
|
@ -106,8 +110,9 @@ static void redisLibevDelWrite(void *privdata) {
|
||||||
|
|
||||||
static void redisLibevStopTimer(void *privdata) {
|
static void redisLibevStopTimer(void *privdata) {
|
||||||
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
||||||
|
#if EV_MULTIPLICITY
|
||||||
struct ev_loop *loop = e->loop;
|
struct ev_loop *loop = e->loop;
|
||||||
((void)loop);
|
#endif
|
||||||
ev_timer_stop(EV_A_ &e->timer);
|
ev_timer_stop(EV_A_ &e->timer);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -120,6 +125,9 @@ static void redisLibevCleanup(void *privdata) {
|
||||||
}
|
}
|
||||||
|
|
||||||
static void redisLibevTimeout(EV_P_ ev_timer *timer, int revents) {
|
static void redisLibevTimeout(EV_P_ ev_timer *timer, int revents) {
|
||||||
|
#if EV_MULTIPLICITY
|
||||||
|
((void)EV_A);
|
||||||
|
#endif
|
||||||
((void)revents);
|
((void)revents);
|
||||||
redisLibevEvents *e = (redisLibevEvents*)timer->data;
|
redisLibevEvents *e = (redisLibevEvents*)timer->data;
|
||||||
redisAsyncHandleTimeout(e->context);
|
redisAsyncHandleTimeout(e->context);
|
||||||
|
@ -127,8 +135,9 @@ static void redisLibevTimeout(EV_P_ ev_timer *timer, int revents) {
|
||||||
|
|
||||||
static void redisLibevSetTimeout(void *privdata, struct timeval tv) {
|
static void redisLibevSetTimeout(void *privdata, struct timeval tv) {
|
||||||
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
redisLibevEvents *e = (redisLibevEvents*)privdata;
|
||||||
|
#if EV_MULTIPLICITY
|
||||||
struct ev_loop *loop = e->loop;
|
struct ev_loop *loop = e->loop;
|
||||||
((void)loop);
|
#endif
|
||||||
|
|
||||||
if (!ev_is_active(&e->timer)) {
|
if (!ev_is_active(&e->timer)) {
|
||||||
ev_init(&e->timer, redisLibevTimeout);
|
ev_init(&e->timer, redisLibevTimeout);
|
||||||
|
|
4
alloc.c
4
alloc.c
|
@ -68,6 +68,10 @@ void *hi_malloc(size_t size) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void *hi_calloc(size_t nmemb, size_t size) {
|
void *hi_calloc(size_t nmemb, size_t size) {
|
||||||
|
/* Overflow check as the user can specify any arbitrary allocator */
|
||||||
|
if (SIZE_MAX / size < nmemb)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
return hiredisAllocFns.callocFn(nmemb, size);
|
return hiredisAllocFns.callocFn(nmemb, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
5
alloc.h
5
alloc.h
|
@ -32,6 +32,7 @@
|
||||||
#define HIREDIS_ALLOC_H
|
#define HIREDIS_ALLOC_H
|
||||||
|
|
||||||
#include <stddef.h> /* for size_t */
|
#include <stddef.h> /* for size_t */
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#ifdef __cplusplus
|
||||||
extern "C" {
|
extern "C" {
|
||||||
|
@ -59,6 +60,10 @@ static inline void *hi_malloc(size_t size) {
|
||||||
}
|
}
|
||||||
|
|
||||||
static inline void *hi_calloc(size_t nmemb, size_t size) {
|
static inline void *hi_calloc(size_t nmemb, size_t size) {
|
||||||
|
/* Overflow check as the user can specify any arbitrary allocator */
|
||||||
|
if (SIZE_MAX / size < nmemb)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
return hiredisAllocFns.callocFn(nmemb, size);
|
return hiredisAllocFns.callocFn(nmemb, size);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
66
async.c
66
async.c
|
@ -306,7 +306,7 @@ static void __redisRunPushCallback(redisAsyncContext *ac, redisReply *reply) {
|
||||||
static void __redisAsyncFree(redisAsyncContext *ac) {
|
static void __redisAsyncFree(redisAsyncContext *ac) {
|
||||||
redisContext *c = &(ac->c);
|
redisContext *c = &(ac->c);
|
||||||
redisCallback cb;
|
redisCallback cb;
|
||||||
dictIterator *it;
|
dictIterator it;
|
||||||
dictEntry *de;
|
dictEntry *de;
|
||||||
|
|
||||||
/* Execute pending callbacks with NULL reply. */
|
/* Execute pending callbacks with NULL reply. */
|
||||||
|
@ -319,23 +319,17 @@ static void __redisAsyncFree(redisAsyncContext *ac) {
|
||||||
|
|
||||||
/* Run subscription callbacks with NULL reply */
|
/* Run subscription callbacks with NULL reply */
|
||||||
if (ac->sub.channels) {
|
if (ac->sub.channels) {
|
||||||
it = dictGetIterator(ac->sub.channels);
|
dictInitIterator(&it,ac->sub.channels);
|
||||||
if (it != NULL) {
|
while ((de = dictNext(&it)) != NULL)
|
||||||
while ((de = dictNext(it)) != NULL)
|
__redisRunCallback(ac,dictGetEntryVal(de),NULL);
|
||||||
__redisRunCallback(ac,dictGetEntryVal(de),NULL);
|
|
||||||
dictReleaseIterator(it);
|
|
||||||
}
|
|
||||||
|
|
||||||
dictRelease(ac->sub.channels);
|
dictRelease(ac->sub.channels);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (ac->sub.patterns) {
|
if (ac->sub.patterns) {
|
||||||
it = dictGetIterator(ac->sub.patterns);
|
dictInitIterator(&it,ac->sub.patterns);
|
||||||
if (it != NULL) {
|
while ((de = dictNext(&it)) != NULL)
|
||||||
while ((de = dictNext(it)) != NULL)
|
__redisRunCallback(ac,dictGetEntryVal(de),NULL);
|
||||||
__redisRunCallback(ac,dictGetEntryVal(de),NULL);
|
|
||||||
dictReleaseIterator(it);
|
|
||||||
}
|
|
||||||
|
|
||||||
dictRelease(ac->sub.patterns);
|
dictRelease(ac->sub.patterns);
|
||||||
}
|
}
|
||||||
|
@ -502,8 +496,8 @@ static int redisIsSubscribeReply(redisReply *reply) {
|
||||||
len = reply->element[0]->len - off;
|
len = reply->element[0]->len - off;
|
||||||
|
|
||||||
return !strncasecmp(str, "subscribe", len) ||
|
return !strncasecmp(str, "subscribe", len) ||
|
||||||
!strncasecmp(str, "message", len);
|
!strncasecmp(str, "message", len) ||
|
||||||
|
!strncasecmp(str, "unsubscribe", len);
|
||||||
}
|
}
|
||||||
|
|
||||||
void redisProcessCallbacks(redisAsyncContext *ac) {
|
void redisProcessCallbacks(redisAsyncContext *ac) {
|
||||||
|
@ -575,7 +569,9 @@ void redisProcessCallbacks(redisAsyncContext *ac) {
|
||||||
|
|
||||||
if (cb.fn != NULL) {
|
if (cb.fn != NULL) {
|
||||||
__redisRunCallback(ac,&cb,reply);
|
__redisRunCallback(ac,&cb,reply);
|
||||||
c->reader->fn->freeObject(reply);
|
if (!(c->flags & REDIS_NO_AUTO_FREE_REPLIES)){
|
||||||
|
c->reader->fn->freeObject(reply);
|
||||||
|
}
|
||||||
|
|
||||||
/* Proceed with free'ing when redisAsyncFree() was called. */
|
/* Proceed with free'ing when redisAsyncFree() was called. */
|
||||||
if (c->flags & REDIS_FREEING) {
|
if (c->flags & REDIS_FREEING) {
|
||||||
|
@ -610,7 +606,8 @@ static int __redisAsyncHandleConnect(redisAsyncContext *ac) {
|
||||||
|
|
||||||
if (redisCheckConnectDone(c, &completed) == REDIS_ERR) {
|
if (redisCheckConnectDone(c, &completed) == REDIS_ERR) {
|
||||||
/* Error! */
|
/* Error! */
|
||||||
redisCheckSocketError(c);
|
if (redisCheckSocketError(c) == REDIS_ERR)
|
||||||
|
__redisAsyncCopyError(ac);
|
||||||
__redisAsyncHandleConnectFailure(ac);
|
__redisAsyncHandleConnectFailure(ac);
|
||||||
return REDIS_ERR;
|
return REDIS_ERR;
|
||||||
} else if (completed == 1) {
|
} else if (completed == 1) {
|
||||||
|
@ -696,9 +693,17 @@ void redisAsyncHandleTimeout(redisAsyncContext *ac) {
|
||||||
redisContext *c = &(ac->c);
|
redisContext *c = &(ac->c);
|
||||||
redisCallback cb;
|
redisCallback cb;
|
||||||
|
|
||||||
if ((c->flags & REDIS_CONNECTED) && ac->replies.head == NULL) {
|
if ((c->flags & REDIS_CONNECTED)) {
|
||||||
/* Nothing to do - just an idle timeout */
|
if ( ac->replies.head == NULL) {
|
||||||
return;
|
/* Nothing to do - just an idle timeout */
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!ac->c.command_timeout ||
|
||||||
|
(!ac->c.command_timeout->tv_sec && !ac->c.command_timeout->tv_usec)) {
|
||||||
|
/* A belated connect timeout arriving, ignore */
|
||||||
|
return;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!c->err) {
|
if (!c->err) {
|
||||||
|
@ -802,17 +807,21 @@ static int __redisAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void
|
||||||
/* (P)UNSUBSCRIBE does not have its own response: every channel or
|
/* (P)UNSUBSCRIBE does not have its own response: every channel or
|
||||||
* pattern that is unsubscribed will receive a message. This means we
|
* pattern that is unsubscribed will receive a message. This means we
|
||||||
* should not append a callback function for this command. */
|
* should not append a callback function for this command. */
|
||||||
} else if(strncasecmp(cstr,"monitor\r\n",9) == 0) {
|
} else if (strncasecmp(cstr,"monitor\r\n",9) == 0) {
|
||||||
/* Set monitor flag and push callback */
|
/* Set monitor flag and push callback */
|
||||||
c->flags |= REDIS_MONITORING;
|
c->flags |= REDIS_MONITORING;
|
||||||
__redisPushCallback(&ac->replies,&cb);
|
if (__redisPushCallback(&ac->replies,&cb) != REDIS_OK)
|
||||||
|
goto oom;
|
||||||
} else {
|
} else {
|
||||||
if (c->flags & REDIS_SUBSCRIBED)
|
if (c->flags & REDIS_SUBSCRIBED) {
|
||||||
/* This will likely result in an error reply, but it needs to be
|
/* This will likely result in an error reply, but it needs to be
|
||||||
* received and passed to the callback. */
|
* received and passed to the callback. */
|
||||||
__redisPushCallback(&ac->sub.invalid,&cb);
|
if (__redisPushCallback(&ac->sub.invalid,&cb) != REDIS_OK)
|
||||||
else
|
goto oom;
|
||||||
__redisPushCallback(&ac->replies,&cb);
|
} else {
|
||||||
|
if (__redisPushCallback(&ac->replies,&cb) != REDIS_OK)
|
||||||
|
goto oom;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
__redisAppendCommand(c,cmd,len);
|
__redisAppendCommand(c,cmd,len);
|
||||||
|
@ -823,6 +832,7 @@ static int __redisAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void
|
||||||
return REDIS_OK;
|
return REDIS_OK;
|
||||||
oom:
|
oom:
|
||||||
__redisSetError(&(ac->c), REDIS_ERR_OOM, "Out of memory");
|
__redisSetError(&(ac->c), REDIS_ERR_OOM, "Out of memory");
|
||||||
|
__redisAsyncCopyError(ac);
|
||||||
return REDIS_ERR;
|
return REDIS_ERR;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
11
dict.c
11
dict.c
|
@ -267,16 +267,11 @@ static dictEntry *dictFind(dict *ht, const void *key) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
static dictIterator *dictGetIterator(dict *ht) {
|
static void dictInitIterator(dictIterator *iter, dict *ht) {
|
||||||
dictIterator *iter = hi_malloc(sizeof(*iter));
|
|
||||||
if (iter == NULL)
|
|
||||||
return NULL;
|
|
||||||
|
|
||||||
iter->ht = ht;
|
iter->ht = ht;
|
||||||
iter->index = -1;
|
iter->index = -1;
|
||||||
iter->entry = NULL;
|
iter->entry = NULL;
|
||||||
iter->nextEntry = NULL;
|
iter->nextEntry = NULL;
|
||||||
return iter;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static dictEntry *dictNext(dictIterator *iter) {
|
static dictEntry *dictNext(dictIterator *iter) {
|
||||||
|
@ -299,10 +294,6 @@ static dictEntry *dictNext(dictIterator *iter) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void dictReleaseIterator(dictIterator *iter) {
|
|
||||||
hi_free(iter);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* ------------------------- private functions ------------------------------ */
|
/* ------------------------- private functions ------------------------------ */
|
||||||
|
|
||||||
/* Expand the hash table if needed */
|
/* Expand the hash table if needed */
|
||||||
|
|
3
dict.h
3
dict.h
|
@ -119,8 +119,7 @@ static int dictReplace(dict *ht, void *key, void *val);
|
||||||
static int dictDelete(dict *ht, const void *key);
|
static int dictDelete(dict *ht, const void *key);
|
||||||
static void dictRelease(dict *ht);
|
static void dictRelease(dict *ht);
|
||||||
static dictEntry * dictFind(dict *ht, const void *key);
|
static dictEntry * dictFind(dict *ht, const void *key);
|
||||||
static dictIterator *dictGetIterator(dict *ht);
|
static void dictInitIterator(dictIterator *iter, dict *ht);
|
||||||
static dictEntry *dictNext(dictIterator *iter);
|
static dictEntry *dictNext(dictIterator *iter);
|
||||||
static void dictReleaseIterator(dictIterator *iter);
|
|
||||||
|
|
||||||
#endif /* __DICT_H */
|
#endif /* __DICT_H */
|
||||||
|
|
|
@ -21,7 +21,7 @@ ENDIF()
|
||||||
|
|
||||||
FIND_PATH(LIBEVENT event.h)
|
FIND_PATH(LIBEVENT event.h)
|
||||||
if (LIBEVENT)
|
if (LIBEVENT)
|
||||||
ADD_EXECUTABLE(example-libevent example-libevent)
|
ADD_EXECUTABLE(example-libevent example-libevent.c)
|
||||||
TARGET_LINK_LIBRARIES(example-libevent hiredis event)
|
TARGET_LINK_LIBRARIES(example-libevent hiredis event)
|
||||||
ENDIF()
|
ENDIF()
|
||||||
|
|
||||||
|
|
61
hiredis.c
61
hiredis.c
|
@ -96,6 +96,8 @@ void freeReplyObject(void *reply) {
|
||||||
|
|
||||||
switch(r->type) {
|
switch(r->type) {
|
||||||
case REDIS_REPLY_INTEGER:
|
case REDIS_REPLY_INTEGER:
|
||||||
|
case REDIS_REPLY_NIL:
|
||||||
|
case REDIS_REPLY_BOOL:
|
||||||
break; /* Nothing to free */
|
break; /* Nothing to free */
|
||||||
case REDIS_REPLY_ARRAY:
|
case REDIS_REPLY_ARRAY:
|
||||||
case REDIS_REPLY_MAP:
|
case REDIS_REPLY_MAP:
|
||||||
|
@ -112,6 +114,7 @@ void freeReplyObject(void *reply) {
|
||||||
case REDIS_REPLY_STRING:
|
case REDIS_REPLY_STRING:
|
||||||
case REDIS_REPLY_DOUBLE:
|
case REDIS_REPLY_DOUBLE:
|
||||||
case REDIS_REPLY_VERB:
|
case REDIS_REPLY_VERB:
|
||||||
|
case REDIS_REPLY_BIGNUM:
|
||||||
hi_free(r->str);
|
hi_free(r->str);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
@ -129,7 +132,8 @@ static void *createStringObject(const redisReadTask *task, char *str, size_t len
|
||||||
assert(task->type == REDIS_REPLY_ERROR ||
|
assert(task->type == REDIS_REPLY_ERROR ||
|
||||||
task->type == REDIS_REPLY_STATUS ||
|
task->type == REDIS_REPLY_STATUS ||
|
||||||
task->type == REDIS_REPLY_STRING ||
|
task->type == REDIS_REPLY_STRING ||
|
||||||
task->type == REDIS_REPLY_VERB);
|
task->type == REDIS_REPLY_VERB ||
|
||||||
|
task->type == REDIS_REPLY_BIGNUM);
|
||||||
|
|
||||||
/* Copy string value */
|
/* Copy string value */
|
||||||
if (task->type == REDIS_REPLY_VERB) {
|
if (task->type == REDIS_REPLY_VERB) {
|
||||||
|
@ -235,12 +239,14 @@ static void *createDoubleObject(const redisReadTask *task, double value, char *s
|
||||||
* decimal string conversion artifacts. */
|
* decimal string conversion artifacts. */
|
||||||
memcpy(r->str, str, len);
|
memcpy(r->str, str, len);
|
||||||
r->str[len] = '\0';
|
r->str[len] = '\0';
|
||||||
|
r->len = len;
|
||||||
|
|
||||||
if (task->parent) {
|
if (task->parent) {
|
||||||
parent = task->parent->obj;
|
parent = task->parent->obj;
|
||||||
assert(parent->type == REDIS_REPLY_ARRAY ||
|
assert(parent->type == REDIS_REPLY_ARRAY ||
|
||||||
parent->type == REDIS_REPLY_MAP ||
|
parent->type == REDIS_REPLY_MAP ||
|
||||||
parent->type == REDIS_REPLY_SET);
|
parent->type == REDIS_REPLY_SET ||
|
||||||
|
parent->type == REDIS_REPLY_PUSH);
|
||||||
parent->element[task->idx] = r;
|
parent->element[task->idx] = r;
|
||||||
}
|
}
|
||||||
return r;
|
return r;
|
||||||
|
@ -277,7 +283,8 @@ static void *createBoolObject(const redisReadTask *task, int bval) {
|
||||||
parent = task->parent->obj;
|
parent = task->parent->obj;
|
||||||
assert(parent->type == REDIS_REPLY_ARRAY ||
|
assert(parent->type == REDIS_REPLY_ARRAY ||
|
||||||
parent->type == REDIS_REPLY_MAP ||
|
parent->type == REDIS_REPLY_MAP ||
|
||||||
parent->type == REDIS_REPLY_SET);
|
parent->type == REDIS_REPLY_SET ||
|
||||||
|
parent->type == REDIS_REPLY_PUSH);
|
||||||
parent->element[task->idx] = r;
|
parent->element[task->idx] = r;
|
||||||
}
|
}
|
||||||
return r;
|
return r;
|
||||||
|
@ -797,6 +804,9 @@ redisContext *redisConnectWithOptions(const redisOptions *options) {
|
||||||
if (options->options & REDIS_OPT_NOAUTOFREE) {
|
if (options->options & REDIS_OPT_NOAUTOFREE) {
|
||||||
c->flags |= REDIS_NO_AUTO_FREE;
|
c->flags |= REDIS_NO_AUTO_FREE;
|
||||||
}
|
}
|
||||||
|
if (options->options & REDIS_OPT_NOAUTOFREEREPLIES) {
|
||||||
|
c->flags |= REDIS_NO_AUTO_FREE_REPLIES;
|
||||||
|
}
|
||||||
|
|
||||||
/* Set any user supplied RESP3 PUSH handler or use freeReplyObject
|
/* Set any user supplied RESP3 PUSH handler or use freeReplyObject
|
||||||
* as a default unless specifically flagged that we don't want one. */
|
* as a default unless specifically flagged that we don't want one. */
|
||||||
|
@ -825,7 +835,7 @@ redisContext *redisConnectWithOptions(const redisOptions *options) {
|
||||||
c->fd = options->endpoint.fd;
|
c->fd = options->endpoint.fd;
|
||||||
c->flags |= REDIS_CONNECTED;
|
c->flags |= REDIS_CONNECTED;
|
||||||
} else {
|
} else {
|
||||||
// Unknown type - FIXME - FREE
|
redisFree(c);
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -987,17 +997,6 @@ oom:
|
||||||
return REDIS_ERR;
|
return REDIS_ERR;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Internal helper function to try and get a reply from the reader,
|
|
||||||
* or set an error in the context otherwise. */
|
|
||||||
int redisGetReplyFromReader(redisContext *c, void **reply) {
|
|
||||||
if (redisReaderGetReply(c->reader,reply) == REDIS_ERR) {
|
|
||||||
__redisSetError(c,c->reader->err,c->reader->errstr);
|
|
||||||
return REDIS_ERR;
|
|
||||||
}
|
|
||||||
|
|
||||||
return REDIS_OK;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Internal helper that returns 1 if the reply was a RESP3 PUSH
|
/* Internal helper that returns 1 if the reply was a RESP3 PUSH
|
||||||
* message and we handled it with a user-provided callback. */
|
* message and we handled it with a user-provided callback. */
|
||||||
static int redisHandledPushReply(redisContext *c, void *reply) {
|
static int redisHandledPushReply(redisContext *c, void *reply) {
|
||||||
|
@ -1009,12 +1008,34 @@ static int redisHandledPushReply(redisContext *c, void *reply) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/* Get a reply from our reader or set an error in the context. */
|
||||||
|
int redisGetReplyFromReader(redisContext *c, void **reply) {
|
||||||
|
if (redisReaderGetReply(c->reader, reply) == REDIS_ERR) {
|
||||||
|
__redisSetError(c,c->reader->err,c->reader->errstr);
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
return REDIS_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Internal helper to get the next reply from our reader while handling
|
||||||
|
* any PUSH messages we encounter along the way. This is separate from
|
||||||
|
* redisGetReplyFromReader so as to not change its behavior. */
|
||||||
|
static int redisNextInBandReplyFromReader(redisContext *c, void **reply) {
|
||||||
|
do {
|
||||||
|
if (redisGetReplyFromReader(c, reply) == REDIS_ERR)
|
||||||
|
return REDIS_ERR;
|
||||||
|
} while (redisHandledPushReply(c, *reply));
|
||||||
|
|
||||||
|
return REDIS_OK;
|
||||||
|
}
|
||||||
|
|
||||||
int redisGetReply(redisContext *c, void **reply) {
|
int redisGetReply(redisContext *c, void **reply) {
|
||||||
int wdone = 0;
|
int wdone = 0;
|
||||||
void *aux = NULL;
|
void *aux = NULL;
|
||||||
|
|
||||||
/* Try to read pending replies */
|
/* Try to read pending replies */
|
||||||
if (redisGetReplyFromReader(c,&aux) == REDIS_ERR)
|
if (redisNextInBandReplyFromReader(c,&aux) == REDIS_ERR)
|
||||||
return REDIS_ERR;
|
return REDIS_ERR;
|
||||||
|
|
||||||
/* For the blocking context, flush output buffer and read reply */
|
/* For the blocking context, flush output buffer and read reply */
|
||||||
|
@ -1030,12 +1051,8 @@ int redisGetReply(redisContext *c, void **reply) {
|
||||||
if (redisBufferRead(c) == REDIS_ERR)
|
if (redisBufferRead(c) == REDIS_ERR)
|
||||||
return REDIS_ERR;
|
return REDIS_ERR;
|
||||||
|
|
||||||
/* We loop here in case the user has specified a RESP3
|
if (redisNextInBandReplyFromReader(c,&aux) == REDIS_ERR)
|
||||||
* PUSH handler (e.g. for client tracking). */
|
return REDIS_ERR;
|
||||||
do {
|
|
||||||
if (redisGetReplyFromReader(c,&aux) == REDIS_ERR)
|
|
||||||
return REDIS_ERR;
|
|
||||||
} while (redisHandledPushReply(c, aux));
|
|
||||||
} while (aux == NULL);
|
} while (aux == NULL);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
15
hiredis.h
15
hiredis.h
|
@ -47,8 +47,8 @@ typedef long long ssize_t;
|
||||||
|
|
||||||
#define HIREDIS_MAJOR 1
|
#define HIREDIS_MAJOR 1
|
||||||
#define HIREDIS_MINOR 0
|
#define HIREDIS_MINOR 0
|
||||||
#define HIREDIS_PATCH 1
|
#define HIREDIS_PATCH 3
|
||||||
#define HIREDIS_SONAME 1.0.1-dev
|
#define HIREDIS_SONAME 1.0.3-dev
|
||||||
|
|
||||||
/* Connection type can be blocking or non-blocking and is set in the
|
/* Connection type can be blocking or non-blocking and is set in the
|
||||||
* least significant bit of the flags field in redisContext. */
|
* least significant bit of the flags field in redisContext. */
|
||||||
|
@ -86,6 +86,9 @@ typedef long long ssize_t;
|
||||||
*/
|
*/
|
||||||
#define REDIS_NO_AUTO_FREE 0x200
|
#define REDIS_NO_AUTO_FREE 0x200
|
||||||
|
|
||||||
|
/* Flag that indicates the user does not want replies to be automatically freed */
|
||||||
|
#define REDIS_NO_AUTO_FREE_REPLIES 0x400
|
||||||
|
|
||||||
#define REDIS_KEEPALIVE_INTERVAL 15 /* seconds */
|
#define REDIS_KEEPALIVE_INTERVAL 15 /* seconds */
|
||||||
|
|
||||||
/* number of times we retry to connect in the case of EADDRNOTAVAIL and
|
/* number of times we retry to connect in the case of EADDRNOTAVAIL and
|
||||||
|
@ -112,7 +115,8 @@ typedef struct redisReply {
|
||||||
double dval; /* The double when type is REDIS_REPLY_DOUBLE */
|
double dval; /* The double when type is REDIS_REPLY_DOUBLE */
|
||||||
size_t len; /* Length of string */
|
size_t len; /* Length of string */
|
||||||
char *str; /* Used for REDIS_REPLY_ERROR, REDIS_REPLY_STRING
|
char *str; /* Used for REDIS_REPLY_ERROR, REDIS_REPLY_STRING
|
||||||
REDIS_REPLY_VERB, and REDIS_REPLY_DOUBLE (in additional to dval). */
|
REDIS_REPLY_VERB, REDIS_REPLY_DOUBLE (in additional to dval),
|
||||||
|
and REDIS_REPLY_BIGNUM. */
|
||||||
char vtype[4]; /* Used for REDIS_REPLY_VERB, contains the null
|
char vtype[4]; /* Used for REDIS_REPLY_VERB, contains the null
|
||||||
terminated 3 character content type, such as "txt". */
|
terminated 3 character content type, such as "txt". */
|
||||||
size_t elements; /* number of elements, for REDIS_REPLY_ARRAY */
|
size_t elements; /* number of elements, for REDIS_REPLY_ARRAY */
|
||||||
|
@ -152,6 +156,11 @@ struct redisSsl;
|
||||||
/* Don't automatically intercept and free RESP3 PUSH replies. */
|
/* Don't automatically intercept and free RESP3 PUSH replies. */
|
||||||
#define REDIS_OPT_NO_PUSH_AUTOFREE 0x08
|
#define REDIS_OPT_NO_PUSH_AUTOFREE 0x08
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Don't automatically free replies
|
||||||
|
*/
|
||||||
|
#define REDIS_OPT_NOAUTOFREEREPLIES 0x10
|
||||||
|
|
||||||
/* In Unix systems a file descriptor is a regular signed int, with -1
|
/* In Unix systems a file descriptor is a regular signed int, with -1
|
||||||
* representing an invalid descriptor. In Windows it is a SOCKET
|
* representing an invalid descriptor. In Windows it is a SOCKET
|
||||||
* (32- or 64-bit unsigned integer depending on the architecture), where
|
* (32- or 64-bit unsigned integer depending on the architecture), where
|
||||||
|
|
142
read.c
142
read.c
|
@ -123,29 +123,28 @@ static char *readBytes(redisReader *r, unsigned int bytes) {
|
||||||
|
|
||||||
/* Find pointer to \r\n. */
|
/* Find pointer to \r\n. */
|
||||||
static char *seekNewline(char *s, size_t len) {
|
static char *seekNewline(char *s, size_t len) {
|
||||||
int pos = 0;
|
char *ret;
|
||||||
int _len = len-1;
|
|
||||||
|
|
||||||
/* Position should be < len-1 because the character at "pos" should be
|
/* We cannot match with fewer than 2 bytes */
|
||||||
* followed by a \n. Note that strchr cannot be used because it doesn't
|
if (len < 2)
|
||||||
* allow to search a limited length and the buffer that is being searched
|
return NULL;
|
||||||
* might not have a trailing NULL character. */
|
|
||||||
while (pos < _len) {
|
/* Search up to len - 1 characters */
|
||||||
while(pos < _len && s[pos] != '\r') pos++;
|
len--;
|
||||||
if (pos==_len) {
|
|
||||||
/* Not found. */
|
/* Look for the \r */
|
||||||
return NULL;
|
while ((ret = memchr(s, '\r', len)) != NULL) {
|
||||||
} else {
|
if (ret[1] == '\n') {
|
||||||
if (s[pos+1] == '\n') {
|
/* Found. */
|
||||||
/* Found. */
|
break;
|
||||||
return s+pos;
|
|
||||||
} else {
|
|
||||||
/* Continue searching. */
|
|
||||||
pos++;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
/* Continue searching. */
|
||||||
|
ret++;
|
||||||
|
len -= ret - s;
|
||||||
|
s = ret;
|
||||||
}
|
}
|
||||||
return NULL;
|
|
||||||
|
return ret;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Convert a string into a long long. Returns REDIS_OK if the string could be
|
/* Convert a string into a long long. Returns REDIS_OK if the string could be
|
||||||
|
@ -274,60 +273,104 @@ static int processLineItem(redisReader *r) {
|
||||||
|
|
||||||
if ((p = readLine(r,&len)) != NULL) {
|
if ((p = readLine(r,&len)) != NULL) {
|
||||||
if (cur->type == REDIS_REPLY_INTEGER) {
|
if (cur->type == REDIS_REPLY_INTEGER) {
|
||||||
|
long long v;
|
||||||
|
|
||||||
|
if (string2ll(p, len, &v) == REDIS_ERR) {
|
||||||
|
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,
|
||||||
|
"Bad integer value");
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
if (r->fn && r->fn->createInteger) {
|
if (r->fn && r->fn->createInteger) {
|
||||||
long long v;
|
|
||||||
if (string2ll(p, len, &v) == REDIS_ERR) {
|
|
||||||
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,
|
|
||||||
"Bad integer value");
|
|
||||||
return REDIS_ERR;
|
|
||||||
}
|
|
||||||
obj = r->fn->createInteger(cur,v);
|
obj = r->fn->createInteger(cur,v);
|
||||||
} else {
|
} else {
|
||||||
obj = (void*)REDIS_REPLY_INTEGER;
|
obj = (void*)REDIS_REPLY_INTEGER;
|
||||||
}
|
}
|
||||||
} else if (cur->type == REDIS_REPLY_DOUBLE) {
|
} else if (cur->type == REDIS_REPLY_DOUBLE) {
|
||||||
if (r->fn && r->fn->createDouble) {
|
char buf[326], *eptr;
|
||||||
char buf[326], *eptr;
|
double d;
|
||||||
double d;
|
|
||||||
|
|
||||||
if ((size_t)len >= sizeof(buf)) {
|
if ((size_t)len >= sizeof(buf)) {
|
||||||
|
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,
|
||||||
|
"Double value is too large");
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
memcpy(buf,p,len);
|
||||||
|
buf[len] = '\0';
|
||||||
|
|
||||||
|
if (len == 3 && strcasecmp(buf,"inf") == 0) {
|
||||||
|
d = INFINITY; /* Positive infinite. */
|
||||||
|
} else if (len == 4 && strcasecmp(buf,"-inf") == 0) {
|
||||||
|
d = -INFINITY; /* Negative infinite. */
|
||||||
|
} else {
|
||||||
|
d = strtod((char*)buf,&eptr);
|
||||||
|
/* RESP3 only allows "inf", "-inf", and finite values, while
|
||||||
|
* strtod() allows other variations on infinity, NaN,
|
||||||
|
* etc. We explicity handle our two allowed infinite cases
|
||||||
|
* above, so strtod() should only result in finite values. */
|
||||||
|
if (buf[0] == '\0' || eptr != &buf[len] || !isfinite(d)) {
|
||||||
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,
|
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,
|
||||||
"Double value is too large");
|
"Bad double value");
|
||||||
return REDIS_ERR;
|
return REDIS_ERR;
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
memcpy(buf,p,len);
|
if (r->fn && r->fn->createDouble) {
|
||||||
buf[len] = '\0';
|
|
||||||
|
|
||||||
if (strcasecmp(buf,",inf") == 0) {
|
|
||||||
d = INFINITY; /* Positive infinite. */
|
|
||||||
} else if (strcasecmp(buf,",-inf") == 0) {
|
|
||||||
d = -INFINITY; /* Negative infinite. */
|
|
||||||
} else {
|
|
||||||
d = strtod((char*)buf,&eptr);
|
|
||||||
if (buf[0] == '\0' || eptr[0] != '\0' || isnan(d)) {
|
|
||||||
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,
|
|
||||||
"Bad double value");
|
|
||||||
return REDIS_ERR;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
obj = r->fn->createDouble(cur,d,buf,len);
|
obj = r->fn->createDouble(cur,d,buf,len);
|
||||||
} else {
|
} else {
|
||||||
obj = (void*)REDIS_REPLY_DOUBLE;
|
obj = (void*)REDIS_REPLY_DOUBLE;
|
||||||
}
|
}
|
||||||
} else if (cur->type == REDIS_REPLY_NIL) {
|
} else if (cur->type == REDIS_REPLY_NIL) {
|
||||||
|
if (len != 0) {
|
||||||
|
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,
|
||||||
|
"Bad nil value");
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
if (r->fn && r->fn->createNil)
|
if (r->fn && r->fn->createNil)
|
||||||
obj = r->fn->createNil(cur);
|
obj = r->fn->createNil(cur);
|
||||||
else
|
else
|
||||||
obj = (void*)REDIS_REPLY_NIL;
|
obj = (void*)REDIS_REPLY_NIL;
|
||||||
} else if (cur->type == REDIS_REPLY_BOOL) {
|
} else if (cur->type == REDIS_REPLY_BOOL) {
|
||||||
int bval = p[0] == 't' || p[0] == 'T';
|
int bval;
|
||||||
|
|
||||||
|
if (len != 1 || !strchr("tTfF", p[0])) {
|
||||||
|
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,
|
||||||
|
"Bad bool value");
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
bval = p[0] == 't' || p[0] == 'T';
|
||||||
if (r->fn && r->fn->createBool)
|
if (r->fn && r->fn->createBool)
|
||||||
obj = r->fn->createBool(cur,bval);
|
obj = r->fn->createBool(cur,bval);
|
||||||
else
|
else
|
||||||
obj = (void*)REDIS_REPLY_BOOL;
|
obj = (void*)REDIS_REPLY_BOOL;
|
||||||
|
} else if (cur->type == REDIS_REPLY_BIGNUM) {
|
||||||
|
/* Ensure all characters are decimal digits (with possible leading
|
||||||
|
* minus sign). */
|
||||||
|
for (int i = 0; i < len; i++) {
|
||||||
|
/* XXX Consider: Allow leading '+'? Error on leading '0's? */
|
||||||
|
if (i == 0 && p[0] == '-') continue;
|
||||||
|
if (p[i] < '0' || p[i] > '9') {
|
||||||
|
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,
|
||||||
|
"Bad bignum value");
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (r->fn && r->fn->createString)
|
||||||
|
obj = r->fn->createString(cur,p,len);
|
||||||
|
else
|
||||||
|
obj = (void*)REDIS_REPLY_BIGNUM;
|
||||||
} else {
|
} else {
|
||||||
/* Type will be error or status. */
|
/* Type will be error or status. */
|
||||||
|
for (int i = 0; i < len; i++) {
|
||||||
|
if (p[i] == '\r' || p[i] == '\n') {
|
||||||
|
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,
|
||||||
|
"Bad simple string value");
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
}
|
||||||
if (r->fn && r->fn->createString)
|
if (r->fn && r->fn->createString)
|
||||||
obj = r->fn->createString(cur,p,len);
|
obj = r->fn->createString(cur,p,len);
|
||||||
else
|
else
|
||||||
|
@ -453,7 +496,6 @@ static int processAggregateItem(redisReader *r) {
|
||||||
long long elements;
|
long long elements;
|
||||||
int root = 0, len;
|
int root = 0, len;
|
||||||
|
|
||||||
/* Set error for nested multi bulks with depth > 7 */
|
|
||||||
if (r->ridx == r->tasks - 1) {
|
if (r->ridx == r->tasks - 1) {
|
||||||
if (redisReaderGrow(r) == REDIS_ERR)
|
if (redisReaderGrow(r) == REDIS_ERR)
|
||||||
return REDIS_ERR;
|
return REDIS_ERR;
|
||||||
|
@ -569,6 +611,9 @@ static int processItem(redisReader *r) {
|
||||||
case '>':
|
case '>':
|
||||||
cur->type = REDIS_REPLY_PUSH;
|
cur->type = REDIS_REPLY_PUSH;
|
||||||
break;
|
break;
|
||||||
|
case '(':
|
||||||
|
cur->type = REDIS_REPLY_BIGNUM;
|
||||||
|
break;
|
||||||
default:
|
default:
|
||||||
__redisReaderSetErrorProtocolByte(r,*p);
|
__redisReaderSetErrorProtocolByte(r,*p);
|
||||||
return REDIS_ERR;
|
return REDIS_ERR;
|
||||||
|
@ -587,6 +632,7 @@ static int processItem(redisReader *r) {
|
||||||
case REDIS_REPLY_DOUBLE:
|
case REDIS_REPLY_DOUBLE:
|
||||||
case REDIS_REPLY_NIL:
|
case REDIS_REPLY_NIL:
|
||||||
case REDIS_REPLY_BOOL:
|
case REDIS_REPLY_BOOL:
|
||||||
|
case REDIS_REPLY_BIGNUM:
|
||||||
return processLineItem(r);
|
return processLineItem(r);
|
||||||
case REDIS_REPLY_STRING:
|
case REDIS_REPLY_STRING:
|
||||||
case REDIS_REPLY_VERB:
|
case REDIS_REPLY_VERB:
|
||||||
|
|
7
ssl.c
7
ssl.c
|
@ -351,7 +351,6 @@ static int redisSSLConnect(redisContext *c, SSL *ssl) {
|
||||||
}
|
}
|
||||||
|
|
||||||
hi_free(rssl);
|
hi_free(rssl);
|
||||||
SSL_free(ssl);
|
|
||||||
return REDIS_ERR;
|
return REDIS_ERR;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -393,7 +392,11 @@ int redisInitiateSSLWithContext(redisContext *c, redisSSLContext *redis_ssl_ctx)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
return redisSSLConnect(c, ssl);
|
if (redisSSLConnect(c, ssl) != REDIS_OK) {
|
||||||
|
goto error;
|
||||||
|
}
|
||||||
|
|
||||||
|
return REDIS_OK;
|
||||||
|
|
||||||
error:
|
error:
|
||||||
if (ssl)
|
if (ssl)
|
||||||
|
|
336
test.c
336
test.c
|
@ -11,12 +11,17 @@
|
||||||
#include <signal.h>
|
#include <signal.h>
|
||||||
#include <errno.h>
|
#include <errno.h>
|
||||||
#include <limits.h>
|
#include <limits.h>
|
||||||
|
#include <math.h>
|
||||||
|
|
||||||
#include "hiredis.h"
|
#include "hiredis.h"
|
||||||
#include "async.h"
|
#include "async.h"
|
||||||
#ifdef HIREDIS_TEST_SSL
|
#ifdef HIREDIS_TEST_SSL
|
||||||
#include "hiredis_ssl.h"
|
#include "hiredis_ssl.h"
|
||||||
#endif
|
#endif
|
||||||
|
#ifdef HIREDIS_TEST_ASYNC
|
||||||
|
#include "adapters/libevent.h"
|
||||||
|
#include <event2/event.h>
|
||||||
|
#endif
|
||||||
#include "net.h"
|
#include "net.h"
|
||||||
#include "win32.h"
|
#include "win32.h"
|
||||||
|
|
||||||
|
@ -58,6 +63,8 @@ struct pushCounters {
|
||||||
int str;
|
int str;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
static int insecure_calloc_calls;
|
||||||
|
|
||||||
#ifdef HIREDIS_TEST_SSL
|
#ifdef HIREDIS_TEST_SSL
|
||||||
redisSSLContext *_ssl_ctx = NULL;
|
redisSSLContext *_ssl_ctx = NULL;
|
||||||
#endif
|
#endif
|
||||||
|
@ -498,6 +505,20 @@ static void test_reply_reader(void) {
|
||||||
freeReplyObject(reply);
|
freeReplyObject(reply);
|
||||||
redisReaderFree(reader);
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Multi-bulk never overflows regardless of maxelements: ");
|
||||||
|
size_t bad_mbulk_len = (SIZE_MAX / sizeof(void *)) + 3;
|
||||||
|
char bad_mbulk_reply[100];
|
||||||
|
snprintf(bad_mbulk_reply, sizeof(bad_mbulk_reply), "*%llu\r\n+asdf\r\n",
|
||||||
|
(unsigned long long) bad_mbulk_len);
|
||||||
|
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
reader->maxelements = 0; /* Don't rely on default limit */
|
||||||
|
redisReaderFeed(reader, bad_mbulk_reply, strlen(bad_mbulk_reply));
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_ERR && strcasecmp(reader->errstr, "Out of memory") == 0);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
#if LLONG_MAX > SIZE_MAX
|
#if LLONG_MAX > SIZE_MAX
|
||||||
test("Set error when array > SIZE_MAX: ");
|
test("Set error when array > SIZE_MAX: ");
|
||||||
reader = redisReaderCreate();
|
reader = redisReaderCreate();
|
||||||
|
@ -583,6 +604,147 @@ static void test_reply_reader(void) {
|
||||||
((redisReply*)reply)->element[1]->integer == 42);
|
((redisReply*)reply)->element[1]->integer == 42);
|
||||||
freeReplyObject(reply);
|
freeReplyObject(reply);
|
||||||
redisReaderFree(reader);
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Can parse RESP3 doubles: ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader, ",3.14159265358979323846\r\n",25);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_OK &&
|
||||||
|
((redisReply*)reply)->type == REDIS_REPLY_DOUBLE &&
|
||||||
|
fabs(((redisReply*)reply)->dval - 3.14159265358979323846) < 0.00000001 &&
|
||||||
|
((redisReply*)reply)->len == 22 &&
|
||||||
|
strcmp(((redisReply*)reply)->str, "3.14159265358979323846") == 0);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Set error on invalid RESP3 double: ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader, ",3.14159\000265358979323846\r\n",26);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_ERR &&
|
||||||
|
strcasecmp(reader->errstr,"Bad double value") == 0);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Correctly parses RESP3 double INFINITY: ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader, ",inf\r\n",6);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_OK &&
|
||||||
|
((redisReply*)reply)->type == REDIS_REPLY_DOUBLE &&
|
||||||
|
isinf(((redisReply*)reply)->dval) &&
|
||||||
|
((redisReply*)reply)->dval > 0);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Set error when RESP3 double is NaN: ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader, ",nan\r\n",6);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_ERR &&
|
||||||
|
strcasecmp(reader->errstr,"Bad double value") == 0);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Can parse RESP3 nil: ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader, "_\r\n",3);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_OK &&
|
||||||
|
((redisReply*)reply)->type == REDIS_REPLY_NIL);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Set error on invalid RESP3 nil: ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader, "_nil\r\n",6);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_ERR &&
|
||||||
|
strcasecmp(reader->errstr,"Bad nil value") == 0);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Can parse RESP3 bool (true): ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader, "#t\r\n",4);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_OK &&
|
||||||
|
((redisReply*)reply)->type == REDIS_REPLY_BOOL &&
|
||||||
|
((redisReply*)reply)->integer);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Can parse RESP3 bool (false): ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader, "#f\r\n",4);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_OK &&
|
||||||
|
((redisReply*)reply)->type == REDIS_REPLY_BOOL &&
|
||||||
|
!((redisReply*)reply)->integer);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Set error on invalid RESP3 bool: ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader, "#foobar\r\n",9);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_ERR &&
|
||||||
|
strcasecmp(reader->errstr,"Bad bool value") == 0);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Can parse RESP3 map: ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader, "%2\r\n+first\r\n:123\r\n$6\r\nsecond\r\n#t\r\n",34);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_OK &&
|
||||||
|
((redisReply*)reply)->type == REDIS_REPLY_MAP &&
|
||||||
|
((redisReply*)reply)->elements == 4 &&
|
||||||
|
((redisReply*)reply)->element[0]->type == REDIS_REPLY_STATUS &&
|
||||||
|
((redisReply*)reply)->element[0]->len == 5 &&
|
||||||
|
!strcmp(((redisReply*)reply)->element[0]->str,"first") &&
|
||||||
|
((redisReply*)reply)->element[1]->type == REDIS_REPLY_INTEGER &&
|
||||||
|
((redisReply*)reply)->element[1]->integer == 123 &&
|
||||||
|
((redisReply*)reply)->element[2]->type == REDIS_REPLY_STRING &&
|
||||||
|
((redisReply*)reply)->element[2]->len == 6 &&
|
||||||
|
!strcmp(((redisReply*)reply)->element[2]->str,"second") &&
|
||||||
|
((redisReply*)reply)->element[3]->type == REDIS_REPLY_BOOL &&
|
||||||
|
((redisReply*)reply)->element[3]->integer);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Can parse RESP3 set: ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader, "~5\r\n+orange\r\n$5\r\napple\r\n#f\r\n:100\r\n:999\r\n",40);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_OK &&
|
||||||
|
((redisReply*)reply)->type == REDIS_REPLY_SET &&
|
||||||
|
((redisReply*)reply)->elements == 5 &&
|
||||||
|
((redisReply*)reply)->element[0]->type == REDIS_REPLY_STATUS &&
|
||||||
|
((redisReply*)reply)->element[0]->len == 6 &&
|
||||||
|
!strcmp(((redisReply*)reply)->element[0]->str,"orange") &&
|
||||||
|
((redisReply*)reply)->element[1]->type == REDIS_REPLY_STRING &&
|
||||||
|
((redisReply*)reply)->element[1]->len == 5 &&
|
||||||
|
!strcmp(((redisReply*)reply)->element[1]->str,"apple") &&
|
||||||
|
((redisReply*)reply)->element[2]->type == REDIS_REPLY_BOOL &&
|
||||||
|
!((redisReply*)reply)->element[2]->integer &&
|
||||||
|
((redisReply*)reply)->element[3]->type == REDIS_REPLY_INTEGER &&
|
||||||
|
((redisReply*)reply)->element[3]->integer == 100 &&
|
||||||
|
((redisReply*)reply)->element[4]->type == REDIS_REPLY_INTEGER &&
|
||||||
|
((redisReply*)reply)->element[4]->integer == 999);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
|
|
||||||
|
test("Can parse RESP3 bignum: ");
|
||||||
|
reader = redisReaderCreate();
|
||||||
|
redisReaderFeed(reader,"(3492890328409238509324850943850943825024385\r\n",46);
|
||||||
|
ret = redisReaderGetReply(reader,&reply);
|
||||||
|
test_cond(ret == REDIS_OK &&
|
||||||
|
((redisReply*)reply)->type == REDIS_REPLY_BIGNUM &&
|
||||||
|
((redisReply*)reply)->len == 43 &&
|
||||||
|
!strcmp(((redisReply*)reply)->str,"3492890328409238509324850943850943825024385"));
|
||||||
|
freeReplyObject(reply);
|
||||||
|
redisReaderFree(reader);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void test_free_null(void) {
|
static void test_free_null(void) {
|
||||||
|
@ -609,6 +771,13 @@ static void *hi_calloc_fail(size_t nmemb, size_t size) {
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void *hi_calloc_insecure(size_t nmemb, size_t size) {
|
||||||
|
(void)nmemb;
|
||||||
|
(void)size;
|
||||||
|
insecure_calloc_calls++;
|
||||||
|
return (void*)0xdeadc0de;
|
||||||
|
}
|
||||||
|
|
||||||
static void *hi_realloc_fail(void *ptr, size_t size) {
|
static void *hi_realloc_fail(void *ptr, size_t size) {
|
||||||
(void)ptr;
|
(void)ptr;
|
||||||
(void)size;
|
(void)size;
|
||||||
|
@ -616,6 +785,8 @@ static void *hi_realloc_fail(void *ptr, size_t size) {
|
||||||
}
|
}
|
||||||
|
|
||||||
static void test_allocator_injection(void) {
|
static void test_allocator_injection(void) {
|
||||||
|
void *ptr;
|
||||||
|
|
||||||
hiredisAllocFuncs ha = {
|
hiredisAllocFuncs ha = {
|
||||||
.mallocFn = hi_malloc_fail,
|
.mallocFn = hi_malloc_fail,
|
||||||
.callocFn = hi_calloc_fail,
|
.callocFn = hi_calloc_fail,
|
||||||
|
@ -635,6 +806,13 @@ static void test_allocator_injection(void) {
|
||||||
redisReader *reader = redisReaderCreate();
|
redisReader *reader = redisReaderCreate();
|
||||||
test_cond(reader == NULL);
|
test_cond(reader == NULL);
|
||||||
|
|
||||||
|
/* Make sure hiredis itself protects against a non-overflow checking calloc */
|
||||||
|
test("hiredis calloc wrapper protects against overflow: ");
|
||||||
|
ha.callocFn = hi_calloc_insecure;
|
||||||
|
hiredisSetAllocators(&ha);
|
||||||
|
ptr = hi_calloc((SIZE_MAX / sizeof(void*)) + 3, sizeof(void*));
|
||||||
|
test_cond(ptr == NULL && insecure_calloc_calls == 0);
|
||||||
|
|
||||||
// Return allocators to default
|
// Return allocators to default
|
||||||
hiredisResetAllocators();
|
hiredisResetAllocators();
|
||||||
}
|
}
|
||||||
|
@ -1269,6 +1447,151 @@ static void test_throughput(struct config config) {
|
||||||
// redisFree(c);
|
// redisFree(c);
|
||||||
// }
|
// }
|
||||||
|
|
||||||
|
#ifdef HIREDIS_TEST_ASYNC
|
||||||
|
struct event_base *base;
|
||||||
|
|
||||||
|
typedef struct TestState {
|
||||||
|
redisOptions *options;
|
||||||
|
int checkpoint;
|
||||||
|
int resp3;
|
||||||
|
} TestState;
|
||||||
|
|
||||||
|
/* Testcase timeout, will trigger a failure */
|
||||||
|
void timeout_cb(int fd, short event, void *arg) {
|
||||||
|
(void) fd; (void) event; (void) arg;
|
||||||
|
printf("Timeout in async testing!\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Unexpected call, will trigger a failure */
|
||||||
|
void unexpected_cb(redisAsyncContext *ac, void *r, void *privdata) {
|
||||||
|
(void) ac; (void) r;
|
||||||
|
printf("Unexpected call: %s\n",(char*)privdata);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Helper function to publish a message via own client. */
|
||||||
|
void publish_msg(redisOptions *options, const char* channel, const char* msg) {
|
||||||
|
redisContext *c = redisConnectWithOptions(options);
|
||||||
|
assert(c != NULL);
|
||||||
|
redisReply *reply = redisCommand(c,"PUBLISH %s %s",channel,msg);
|
||||||
|
assert(reply->type == REDIS_REPLY_INTEGER && reply->integer == 1);
|
||||||
|
freeReplyObject(reply);
|
||||||
|
disconnect(c, 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Subscribe callback for test_pubsub_handling and test_pubsub_handling_resp3:
|
||||||
|
* - a published message triggers an unsubscribe
|
||||||
|
* - an unsubscribe response triggers a disconnect */
|
||||||
|
void subscribe_cb(redisAsyncContext *ac, void *r, void *privdata) {
|
||||||
|
redisReply *reply = r;
|
||||||
|
TestState *state = privdata;
|
||||||
|
|
||||||
|
assert(reply != NULL &&
|
||||||
|
reply->type == (state->resp3 ? REDIS_REPLY_PUSH : REDIS_REPLY_ARRAY) &&
|
||||||
|
reply->elements == 3);
|
||||||
|
|
||||||
|
if (strcmp(reply->element[0]->str,"subscribe") == 0) {
|
||||||
|
assert(strcmp(reply->element[1]->str,"mychannel") == 0 &&
|
||||||
|
reply->element[2]->str == NULL);
|
||||||
|
publish_msg(state->options,"mychannel","Hello!");
|
||||||
|
} else if (strcmp(reply->element[0]->str,"message") == 0) {
|
||||||
|
assert(strcmp(reply->element[1]->str,"mychannel") == 0 &&
|
||||||
|
strcmp(reply->element[2]->str,"Hello!") == 0);
|
||||||
|
state->checkpoint++;
|
||||||
|
|
||||||
|
/* Unsubscribe after receiving the published message. Send unsubscribe
|
||||||
|
* which should call the callback registered during subscribe */
|
||||||
|
redisAsyncCommand(ac,unexpected_cb,
|
||||||
|
(void*)"unsubscribe should call subscribe_cb()",
|
||||||
|
"unsubscribe");
|
||||||
|
} else if (strcmp(reply->element[0]->str,"unsubscribe") == 0) {
|
||||||
|
assert(strcmp(reply->element[1]->str,"mychannel") == 0 &&
|
||||||
|
reply->element[2]->str == NULL);
|
||||||
|
|
||||||
|
/* Disconnect after unsubscribe */
|
||||||
|
redisAsyncDisconnect(ac);
|
||||||
|
event_base_loopbreak(base);
|
||||||
|
} else {
|
||||||
|
printf("Unexpected pubsub command: %s\n", reply->element[0]->str);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void test_pubsub_handling(struct config config) {
|
||||||
|
test("Subscribe, handle published message and unsubscribe: ");
|
||||||
|
/* Setup event dispatcher with a testcase timeout */
|
||||||
|
base = event_base_new();
|
||||||
|
struct event *timeout = evtimer_new(base, timeout_cb, NULL);
|
||||||
|
assert(timeout != NULL);
|
||||||
|
|
||||||
|
evtimer_assign(timeout,base,timeout_cb,NULL);
|
||||||
|
struct timeval timeout_tv = {.tv_sec = 10};
|
||||||
|
evtimer_add(timeout, &timeout_tv);
|
||||||
|
|
||||||
|
/* Connect */
|
||||||
|
redisOptions options = get_redis_tcp_options(config);
|
||||||
|
redisAsyncContext *ac = redisAsyncConnectWithOptions(&options);
|
||||||
|
assert(ac != NULL && ac->err == 0);
|
||||||
|
redisLibeventAttach(ac,base);
|
||||||
|
|
||||||
|
/* Start subscribe */
|
||||||
|
TestState state = {.options = &options};
|
||||||
|
redisAsyncCommand(ac,subscribe_cb,&state,"subscribe mychannel");
|
||||||
|
|
||||||
|
/* Start event dispatching loop */
|
||||||
|
test_cond(event_base_dispatch(base) == 0);
|
||||||
|
event_free(timeout);
|
||||||
|
event_base_free(base);
|
||||||
|
|
||||||
|
/* Verify test checkpoints */
|
||||||
|
assert(state.checkpoint == 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Unexpected push message, will trigger a failure */
|
||||||
|
void unexpected_push_cb(redisAsyncContext *ac, void *r) {
|
||||||
|
(void) ac; (void) r;
|
||||||
|
printf("Unexpected call to the PUSH callback!\n");
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void test_pubsub_handling_resp3(struct config config) {
|
||||||
|
test("Subscribe, handle published message and unsubscribe using RESP3: ");
|
||||||
|
/* Setup event dispatcher with a testcase timeout */
|
||||||
|
base = event_base_new();
|
||||||
|
struct event *timeout = evtimer_new(base, timeout_cb, NULL);
|
||||||
|
assert(timeout != NULL);
|
||||||
|
|
||||||
|
evtimer_assign(timeout,base,timeout_cb,NULL);
|
||||||
|
struct timeval timeout_tv = {.tv_sec = 10};
|
||||||
|
evtimer_add(timeout, &timeout_tv);
|
||||||
|
|
||||||
|
/* Connect */
|
||||||
|
redisOptions options = get_redis_tcp_options(config);
|
||||||
|
redisAsyncContext *ac = redisAsyncConnectWithOptions(&options);
|
||||||
|
assert(ac != NULL && ac->err == 0);
|
||||||
|
redisLibeventAttach(ac,base);
|
||||||
|
|
||||||
|
/* Not expecting any push messages in this test */
|
||||||
|
redisAsyncSetPushCallback(ac, unexpected_push_cb);
|
||||||
|
|
||||||
|
/* Switch protocol */
|
||||||
|
redisAsyncCommand(ac,NULL,NULL,"HELLO 3");
|
||||||
|
|
||||||
|
/* Start subscribe */
|
||||||
|
TestState state = {.options = &options, .resp3 = 1};
|
||||||
|
redisAsyncCommand(ac,subscribe_cb,&state,"subscribe mychannel");
|
||||||
|
|
||||||
|
/* Start event dispatching loop */
|
||||||
|
test_cond(event_base_dispatch(base) == 0);
|
||||||
|
event_free(timeout);
|
||||||
|
event_base_free(base);
|
||||||
|
|
||||||
|
/* Verify test checkpoints */
|
||||||
|
assert(state.checkpoint == 1);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
int main(int argc, char **argv) {
|
int main(int argc, char **argv) {
|
||||||
struct config cfg = {
|
struct config cfg = {
|
||||||
.tcp = {
|
.tcp = {
|
||||||
|
@ -1387,6 +1710,19 @@ int main(int argc, char **argv) {
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#ifdef HIREDIS_TEST_ASYNC
|
||||||
|
printf("\nTesting asynchronous API against TCP connection (%s:%d):\n", cfg.tcp.host, cfg.tcp.port);
|
||||||
|
cfg.type = CONN_TCP;
|
||||||
|
|
||||||
|
int major;
|
||||||
|
redisContext *c = do_connect(cfg);
|
||||||
|
get_redis_version(c, &major, NULL);
|
||||||
|
disconnect(c, 0);
|
||||||
|
|
||||||
|
test_pubsub_handling(cfg);
|
||||||
|
if (major >= 6) test_pubsub_handling_resp3(cfg);
|
||||||
|
#endif
|
||||||
|
|
||||||
if (test_inherit_fd) {
|
if (test_inherit_fd) {
|
||||||
printf("\nTesting against inherited fd (%s): ", cfg.unix_sock.path);
|
printf("\nTesting against inherited fd (%s): ", cfg.unix_sock.path);
|
||||||
if (test_unix_socket) {
|
if (test_unix_socket) {
|
||||||
|
|
Loading…
Reference in New Issue