Update to hiredis 0.13.1
parent
00ab5518c3
commit
6e6176b656
@ -1,6 +1,7 @@
|
|||||||
/hiredis-test
|
/hiredis-test
|
||||||
/hiredis-example*
|
/examples/hiredis-example*
|
||||||
/*.o
|
/*.o
|
||||||
/*.so
|
/*.so
|
||||||
/*.dylib
|
/*.dylib
|
||||||
/*.a
|
/*.a
|
||||||
|
/*.pc
|
||||||
|
@ -0,0 +1,16 @@
|
|||||||
|
language: c
|
||||||
|
compiler:
|
||||||
|
- gcc
|
||||||
|
- clang
|
||||||
|
|
||||||
|
env:
|
||||||
|
- CFLAGS="-Werror"
|
||||||
|
- PRE="valgrind --track-origins=yes --leak-check=full"
|
||||||
|
- TARGET="32bit" TARGET_VARS="32bit-vars" CFLAGS="-Werror"
|
||||||
|
- TARGET="32bit" TARGET_VARS="32bit-vars" PRE="valgrind --track-origins=yes --leak-check=full"
|
||||||
|
|
||||||
|
install:
|
||||||
|
- sudo apt-get update -qq
|
||||||
|
- sudo apt-get install libc6-dbg libc6-dev libc6-i686:i386 libc6-dev-i386 libc6-dbg:i386 valgrind -y
|
||||||
|
|
||||||
|
script: make $TARGET CFLAGS="$CFLAGS" && make check PRE="$PRE" && make $TARGET_VARS hiredis-example
|
@ -0,0 +1,90 @@
|
|||||||
|
### 0.13.1 - May 03, 2015
|
||||||
|
|
||||||
|
This is a bug fix release.
|
||||||
|
The new `reconnect` method introduced new struct members, which clashed with pre-defined names in pre-C99 code.
|
||||||
|
Another commit forced C99 compilation just to make it work, but of course this is not desirable for outside projects.
|
||||||
|
Other non-C99 code can now use hiredis as usual again.
|
||||||
|
Sorry for the inconvenience.
|
||||||
|
|
||||||
|
* Fix memory leak in async reply handling (Salvatore Sanfilippo)
|
||||||
|
* Rename struct member to avoid name clash with pre-c99 code (Alex Balashov, ncopa)
|
||||||
|
|
||||||
|
### 0.13.0 - April 16, 2015
|
||||||
|
|
||||||
|
This release adds a minimal Windows compatibility layer.
|
||||||
|
The parser, standalone since v0.12.0, can now be compiled on Windows
|
||||||
|
(and thus used in other client libraries as well)
|
||||||
|
|
||||||
|
* Windows compatibility layer for parser code (tzickel)
|
||||||
|
* Properly escape data printed to PKGCONF file (Dan Skorupski)
|
||||||
|
* Fix tests when assert() undefined (Keith Bennett, Matt Stancliff)
|
||||||
|
* Implement a reconnect method for the client context, this changes the structure of `redisContext` (Aaron Bedra)
|
||||||
|
|
||||||
|
### 0.12.1 - January 26, 2015
|
||||||
|
|
||||||
|
* Fix `make install`: DESTDIR support, install all required files, install PKGCONF in proper location
|
||||||
|
* Fix `make test` as 32 bit build on 64 bit platform
|
||||||
|
|
||||||
|
### 0.12.0 - January 22, 2015
|
||||||
|
|
||||||
|
* Add optional KeepAlive support
|
||||||
|
|
||||||
|
* Try again on EINTR errors
|
||||||
|
|
||||||
|
* Add libuv adapter
|
||||||
|
|
||||||
|
* Add IPv6 support
|
||||||
|
|
||||||
|
* Remove possiblity of multiple close on same fd
|
||||||
|
|
||||||
|
* Add ability to bind source address on connect
|
||||||
|
|
||||||
|
* Add redisConnectFd() and redisFreeKeepFd()
|
||||||
|
|
||||||
|
* Fix getaddrinfo() memory leak
|
||||||
|
|
||||||
|
* Free string if it is unused (fixes memory leak)
|
||||||
|
|
||||||
|
* Improve redisAppendCommandArgv performance 2.5x
|
||||||
|
|
||||||
|
* Add support for SO_REUSEADDR
|
||||||
|
|
||||||
|
* Fix redisvFormatCommand format parsing
|
||||||
|
|
||||||
|
* Add GLib 2.0 adapter
|
||||||
|
|
||||||
|
* Refactor reading code into read.c
|
||||||
|
|
||||||
|
* Fix errno error buffers to not clobber errors
|
||||||
|
|
||||||
|
* Generate pkgconf during build
|
||||||
|
|
||||||
|
* Silence _BSD_SOURCE warnings
|
||||||
|
|
||||||
|
* Improve digit counting for multibulk creation
|
||||||
|
|
||||||
|
|
||||||
|
### 0.11.0
|
||||||
|
|
||||||
|
* Increase the maximum multi-bulk reply depth to 7.
|
||||||
|
|
||||||
|
* Increase the read buffer size from 2k to 16k.
|
||||||
|
|
||||||
|
* Use poll(2) instead of select(2) to support large fds (>= 1024).
|
||||||
|
|
||||||
|
### 0.10.1
|
||||||
|
|
||||||
|
* Makefile overhaul. Important to check out if you override one or more
|
||||||
|
variables using environment variables or via arguments to the "make" tool.
|
||||||
|
|
||||||
|
* Issue #45: Fix potential memory leak for a multi bulk reply with 0 elements
|
||||||
|
being created by the default reply object functions.
|
||||||
|
|
||||||
|
* Issue #43: Don't crash in an asynchronous context when Redis returns an error
|
||||||
|
reply after the connection has been made (this happens when the maximum
|
||||||
|
number of connections is reached).
|
||||||
|
|
||||||
|
### 0.10.0
|
||||||
|
|
||||||
|
* See commit log.
|
||||||
|
|
@ -1,2 +0,0 @@
|
|||||||
- add redisCommandVector()
|
|
||||||
- add support for pipelining
|
|
@ -0,0 +1,153 @@
|
|||||||
|
#ifndef __HIREDIS_GLIB_H__
|
||||||
|
#define __HIREDIS_GLIB_H__
|
||||||
|
|
||||||
|
#include <glib.h>
|
||||||
|
|
||||||
|
#include "../hiredis.h"
|
||||||
|
#include "../async.h"
|
||||||
|
|
||||||
|
typedef struct
|
||||||
|
{
|
||||||
|
GSource source;
|
||||||
|
redisAsyncContext *ac;
|
||||||
|
GPollFD poll_fd;
|
||||||
|
} RedisSource;
|
||||||
|
|
||||||
|
static void
|
||||||
|
redis_source_add_read (gpointer data)
|
||||||
|
{
|
||||||
|
RedisSource *source = data;
|
||||||
|
g_return_if_fail(source);
|
||||||
|
source->poll_fd.events |= G_IO_IN;
|
||||||
|
g_main_context_wakeup(g_source_get_context(data));
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
redis_source_del_read (gpointer data)
|
||||||
|
{
|
||||||
|
RedisSource *source = data;
|
||||||
|
g_return_if_fail(source);
|
||||||
|
source->poll_fd.events &= ~G_IO_IN;
|
||||||
|
g_main_context_wakeup(g_source_get_context(data));
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
redis_source_add_write (gpointer data)
|
||||||
|
{
|
||||||
|
RedisSource *source = data;
|
||||||
|
g_return_if_fail(source);
|
||||||
|
source->poll_fd.events |= G_IO_OUT;
|
||||||
|
g_main_context_wakeup(g_source_get_context(data));
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
redis_source_del_write (gpointer data)
|
||||||
|
{
|
||||||
|
RedisSource *source = data;
|
||||||
|
g_return_if_fail(source);
|
||||||
|
source->poll_fd.events &= ~G_IO_OUT;
|
||||||
|
g_main_context_wakeup(g_source_get_context(data));
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
redis_source_cleanup (gpointer data)
|
||||||
|
{
|
||||||
|
RedisSource *source = data;
|
||||||
|
|
||||||
|
g_return_if_fail(source);
|
||||||
|
|
||||||
|
redis_source_del_read(source);
|
||||||
|
redis_source_del_write(source);
|
||||||
|
/*
|
||||||
|
* It is not our responsibility to remove ourself from the
|
||||||
|
* current main loop. However, we will remove the GPollFD.
|
||||||
|
*/
|
||||||
|
if (source->poll_fd.fd >= 0) {
|
||||||
|
g_source_remove_poll(data, &source->poll_fd);
|
||||||
|
source->poll_fd.fd = -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static gboolean
|
||||||
|
redis_source_prepare (GSource *source,
|
||||||
|
gint *timeout_)
|
||||||
|
{
|
||||||
|
RedisSource *redis = (RedisSource *)source;
|
||||||
|
*timeout_ = -1;
|
||||||
|
return !!(redis->poll_fd.events & redis->poll_fd.revents);
|
||||||
|
}
|
||||||
|
|
||||||
|
static gboolean
|
||||||
|
redis_source_check (GSource *source)
|
||||||
|
{
|
||||||
|
RedisSource *redis = (RedisSource *)source;
|
||||||
|
return !!(redis->poll_fd.events & redis->poll_fd.revents);
|
||||||
|
}
|
||||||
|
|
||||||
|
static gboolean
|
||||||
|
redis_source_dispatch (GSource *source,
|
||||||
|
GSourceFunc callback,
|
||||||
|
gpointer user_data)
|
||||||
|
{
|
||||||
|
RedisSource *redis = (RedisSource *)source;
|
||||||
|
|
||||||
|
if ((redis->poll_fd.revents & G_IO_OUT)) {
|
||||||
|
redisAsyncHandleWrite(redis->ac);
|
||||||
|
redis->poll_fd.revents &= ~G_IO_OUT;
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((redis->poll_fd.revents & G_IO_IN)) {
|
||||||
|
redisAsyncHandleRead(redis->ac);
|
||||||
|
redis->poll_fd.revents &= ~G_IO_IN;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (callback) {
|
||||||
|
return callback(user_data);
|
||||||
|
}
|
||||||
|
|
||||||
|
return TRUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
redis_source_finalize (GSource *source)
|
||||||
|
{
|
||||||
|
RedisSource *redis = (RedisSource *)source;
|
||||||
|
|
||||||
|
if (redis->poll_fd.fd >= 0) {
|
||||||
|
g_source_remove_poll(source, &redis->poll_fd);
|
||||||
|
redis->poll_fd.fd = -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static GSource *
|
||||||
|
redis_source_new (redisAsyncContext *ac)
|
||||||
|
{
|
||||||
|
static GSourceFuncs source_funcs = {
|
||||||
|
.prepare = redis_source_prepare,
|
||||||
|
.check = redis_source_check,
|
||||||
|
.dispatch = redis_source_dispatch,
|
||||||
|
.finalize = redis_source_finalize,
|
||||||
|
};
|
||||||
|
redisContext *c = &ac->c;
|
||||||
|
RedisSource *source;
|
||||||
|
|
||||||
|
g_return_val_if_fail(ac != NULL, NULL);
|
||||||
|
|
||||||
|
source = (RedisSource *)g_source_new(&source_funcs, sizeof *source);
|
||||||
|
source->ac = ac;
|
||||||
|
source->poll_fd.fd = c->fd;
|
||||||
|
source->poll_fd.events = 0;
|
||||||
|
source->poll_fd.revents = 0;
|
||||||
|
g_source_add_poll((GSource *)source, &source->poll_fd);
|
||||||
|
|
||||||
|
ac->ev.addRead = redis_source_add_read;
|
||||||
|
ac->ev.delRead = redis_source_del_read;
|
||||||
|
ac->ev.addWrite = redis_source_add_write;
|
||||||
|
ac->ev.delWrite = redis_source_del_write;
|
||||||
|
ac->ev.cleanup = redis_source_cleanup;
|
||||||
|
ac->ev.data = source;
|
||||||
|
|
||||||
|
return (GSource *)source;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif /* __HIREDIS_GLIB_H__ */
|
@ -0,0 +1,121 @@
|
|||||||
|
#ifndef __HIREDIS_LIBUV_H__
|
||||||
|
#define __HIREDIS_LIBUV_H__
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <uv.h>
|
||||||
|
#include "../hiredis.h"
|
||||||
|
#include "../async.h"
|
||||||
|
#include <string.h>
|
||||||
|
|
||||||
|
typedef struct redisLibuvEvents {
|
||||||
|
redisAsyncContext* context;
|
||||||
|
uv_poll_t handle;
|
||||||
|
int events;
|
||||||
|
} redisLibuvEvents;
|
||||||
|
|
||||||
|
|
||||||
|
static void redisLibuvPoll(uv_poll_t* handle, int status, int events) {
|
||||||
|
redisLibuvEvents* p = (redisLibuvEvents*)handle->data;
|
||||||
|
|
||||||
|
if (status != 0) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (events & UV_READABLE) {
|
||||||
|
redisAsyncHandleRead(p->context);
|
||||||
|
}
|
||||||
|
if (events & UV_WRITABLE) {
|
||||||
|
redisAsyncHandleWrite(p->context);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void redisLibuvAddRead(void *privdata) {
|
||||||
|
redisLibuvEvents* p = (redisLibuvEvents*)privdata;
|
||||||
|
|
||||||
|
p->events |= UV_READABLE;
|
||||||
|
|
||||||
|
uv_poll_start(&p->handle, p->events, redisLibuvPoll);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void redisLibuvDelRead(void *privdata) {
|
||||||
|
redisLibuvEvents* p = (redisLibuvEvents*)privdata;
|
||||||
|
|
||||||
|
p->events &= ~UV_READABLE;
|
||||||
|
|
||||||
|
if (p->events) {
|
||||||
|
uv_poll_start(&p->handle, p->events, redisLibuvPoll);
|
||||||
|
} else {
|
||||||
|
uv_poll_stop(&p->handle);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void redisLibuvAddWrite(void *privdata) {
|
||||||
|
redisLibuvEvents* p = (redisLibuvEvents*)privdata;
|
||||||
|
|
||||||
|
p->events |= UV_WRITABLE;
|
||||||
|
|
||||||
|
uv_poll_start(&p->handle, p->events, redisLibuvPoll);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void redisLibuvDelWrite(void *privdata) {
|
||||||
|
redisLibuvEvents* p = (redisLibuvEvents*)privdata;
|
||||||
|
|
||||||
|
p->events &= ~UV_WRITABLE;
|
||||||
|
|
||||||
|
if (p->events) {
|
||||||
|
uv_poll_start(&p->handle, p->events, redisLibuvPoll);
|
||||||
|
} else {
|
||||||
|
uv_poll_stop(&p->handle);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void on_close(uv_handle_t* handle) {
|
||||||
|
redisLibuvEvents* p = (redisLibuvEvents*)handle->data;
|
||||||
|
|
||||||
|
free(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static void redisLibuvCleanup(void *privdata) {
|
||||||
|
redisLibuvEvents* p = (redisLibuvEvents*)privdata;
|
||||||
|
|
||||||
|
uv_close((uv_handle_t*)&p->handle, on_close);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static int redisLibuvAttach(redisAsyncContext* ac, uv_loop_t* loop) {
|
||||||
|
redisContext *c = &(ac->c);
|
||||||
|
|
||||||
|
if (ac->ev.data != NULL) {
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
ac->ev.addRead = redisLibuvAddRead;
|
||||||
|
ac->ev.delRead = redisLibuvDelRead;
|
||||||
|
ac->ev.addWrite = redisLibuvAddWrite;
|
||||||
|
ac->ev.delWrite = redisLibuvDelWrite;
|
||||||
|
ac->ev.cleanup = redisLibuvCleanup;
|
||||||
|
|
||||||
|
redisLibuvEvents* p = (redisLibuvEvents*)malloc(sizeof(*p));
|
||||||
|
|
||||||
|
if (!p) {
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
memset(p, 0, sizeof(*p));
|
||||||
|
|
||||||
|
if (uv_poll_init(loop, &p->handle, c->fd) != 0) {
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
ac->ev.data = p;
|
||||||
|
p->handle.data = p;
|
||||||
|
p->context = ac;
|
||||||
|
|
||||||
|
return REDIS_OK;
|
||||||
|
}
|
||||||
|
#endif
|
@ -0,0 +1,73 @@
|
|||||||
|
#include <stdlib.h>
|
||||||
|
|
||||||
|
#include <hiredis.h>
|
||||||
|
#include <async.h>
|
||||||
|
#include <adapters/glib.h>
|
||||||
|
|
||||||
|
static GMainLoop *mainloop;
|
||||||
|
|
||||||
|
static void
|
||||||
|
connect_cb (const redisAsyncContext *ac G_GNUC_UNUSED,
|
||||||
|
int status)
|
||||||
|
{
|
||||||
|
if (status != REDIS_OK) {
|
||||||
|
g_printerr("Failed to connect: %s\n", ac->errstr);
|
||||||
|
g_main_loop_quit(mainloop);
|
||||||
|
} else {
|
||||||
|
g_printerr("Connected...\n");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
disconnect_cb (const redisAsyncContext *ac G_GNUC_UNUSED,
|
||||||
|
int status)
|
||||||
|
{
|
||||||
|
if (status != REDIS_OK) {
|
||||||
|
g_error("Failed to disconnect: %s", ac->errstr);
|
||||||
|
} else {
|
||||||
|
g_printerr("Disconnected...\n");
|
||||||
|
g_main_loop_quit(mainloop);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
command_cb(redisAsyncContext *ac,
|
||||||
|
gpointer r,
|
||||||
|
gpointer user_data G_GNUC_UNUSED)
|
||||||
|
{
|
||||||
|
redisReply *reply = r;
|
||||||
|
|
||||||
|
if (reply) {
|
||||||
|
g_print("REPLY: %s\n", reply->str);
|
||||||
|
}
|
||||||
|
|
||||||
|
redisAsyncDisconnect(ac);
|
||||||
|
}
|
||||||
|
|
||||||
|
gint
|
||||||
|
main (gint argc G_GNUC_UNUSED,
|
||||||
|
gchar *argv[] G_GNUC_UNUSED)
|
||||||
|
{
|
||||||
|
redisAsyncContext *ac;
|
||||||
|
GMainContext *context = NULL;
|
||||||
|
GSource *source;
|
||||||
|
|
||||||
|
ac = redisAsyncConnect("127.0.0.1", 6379);
|
||||||
|
if (ac->err) {
|
||||||
|
g_printerr("%s\n", ac->errstr);
|
||||||
|
exit(EXIT_FAILURE);
|
||||||
|
}
|
||||||
|
|
||||||
|
source = redis_source_new(ac);
|
||||||
|
mainloop = g_main_loop_new(context, FALSE);
|
||||||
|
g_source_attach(source, context);
|
||||||
|
|
||||||
|
redisAsyncSetConnectCallback(ac, connect_cb);
|
||||||
|
redisAsyncSetDisconnectCallback(ac, disconnect_cb);
|
||||||
|
redisAsyncCommand(ac, command_cb, NULL, "SET key 1234");
|
||||||
|
redisAsyncCommand(ac, command_cb, NULL, "GET key");
|
||||||
|
|
||||||
|
g_main_loop_run(mainloop);
|
||||||
|
|
||||||
|
return EXIT_SUCCESS;
|
||||||
|
}
|
@ -0,0 +1,53 @@
|
|||||||
|
#include <stdio.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#include <string.h>
|
||||||
|
#include <signal.h>
|
||||||
|
|
||||||
|
#include <hiredis.h>
|
||||||
|
#include <async.h>
|
||||||
|
#include <adapters/libuv.h>
|
||||||
|
|
||||||
|
void getCallback(redisAsyncContext *c, void *r, void *privdata) {
|
||||||
|
redisReply *reply = r;
|
||||||
|
if (reply == NULL) return;
|
||||||
|
printf("argv[%s]: %s\n", (char*)privdata, reply->str);
|
||||||
|
|
||||||
|
/* Disconnect after receiving the reply to GET */
|
||||||
|
redisAsyncDisconnect(c);
|
||||||
|
}
|
||||||
|
|
||||||
|
void connectCallback(const redisAsyncContext *c, int status) {
|
||||||
|
if (status != REDIS_OK) {
|
||||||
|
printf("Error: %s\n", c->errstr);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
printf("Connected...\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
void disconnectCallback(const redisAsyncContext *c, int status) {
|
||||||
|
if (status != REDIS_OK) {
|
||||||
|
printf("Error: %s\n", c->errstr);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
printf("Disconnected...\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
int main (int argc, char **argv) {
|
||||||
|
signal(SIGPIPE, SIG_IGN);
|
||||||
|
uv_loop_t* loop = uv_default_loop();
|
||||||
|
|
||||||
|
redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
|
||||||
|
if (c->err) {
|
||||||
|
/* Let *c leak for now... */
|
||||||
|
printf("Error: %s\n", c->errstr);
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
redisLibuvAttach(c,loop);
|
||||||
|
redisAsyncSetConnectCallback(c,connectCallback);
|
||||||
|
redisAsyncSetDisconnectCallback(c,disconnectCallback);
|
||||||
|
redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
|
||||||
|
redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
|
||||||
|
uv_run(loop, UV_RUN_DEFAULT);
|
||||||
|
return 0;
|
||||||
|
}
|
@ -1,16 +1,21 @@
|
|||||||
#ifndef __HIREDIS_FMACRO_H
|
#ifndef __HIREDIS_FMACRO_H
|
||||||
#define __HIREDIS_FMACRO_H
|
#define __HIREDIS_FMACRO_H
|
||||||
|
|
||||||
#if !defined(_BSD_SOURCE)
|
#if defined(__linux__)
|
||||||
#define _BSD_SOURCE
|
#define _BSD_SOURCE
|
||||||
|
#define _DEFAULT_SOURCE
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if defined(__sun__)
|
#if defined(__sun__)
|
||||||
#define _POSIX_C_SOURCE 200112L
|
#define _POSIX_C_SOURCE 200112L
|
||||||
#elif defined(__linux__)
|
#elif defined(__linux__) || defined(__OpenBSD__) || defined(__NetBSD__)
|
||||||
#define _XOPEN_SOURCE 600
|
#define _XOPEN_SOURCE 600
|
||||||
#else
|
#else
|
||||||
#define _XOPEN_SOURCE
|
#define _XOPEN_SOURCE
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
#if __APPLE__ && __MACH__
|
||||||
|
#define _OSX
|
||||||
|
#endif
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
@ -0,0 +1,525 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>
|
||||||
|
* Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>
|
||||||
|
*
|
||||||
|
* All rights reserved.
|
||||||
|
*
|
||||||
|
* Redistribution and use in source and binary forms, with or without
|
||||||
|
* modification, are permitted provided that the following conditions are met:
|
||||||
|
*
|
||||||
|
* * Redistributions of source code must retain the above copyright notice,
|
||||||
|
* this list of conditions and the following disclaimer.
|
||||||
|
* * Redistributions in binary form must reproduce the above copyright
|
||||||
|
* notice, this list of conditions and the following disclaimer in the
|
||||||
|
* documentation and/or other materials provided with the distribution.
|
||||||
|
* * Neither the name of Redis nor the names of its contributors may be used
|
||||||
|
* to endorse or promote products derived from this software without
|
||||||
|
* specific prior written permission.
|
||||||
|
*
|
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||||
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||||
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||||
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||||
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||||
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||||
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||||
|
* POSSIBILITY OF SUCH DAMAGE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
#include "fmacros.h"
|
||||||
|
#include <string.h>
|
||||||
|
#include <stdlib.h>
|
||||||
|
#ifndef _MSC_VER
|
||||||
|
#include <unistd.h>
|
||||||
|
#endif
|
||||||
|
#include <assert.h>
|
||||||
|
#include <errno.h>
|
||||||
|
#include <ctype.h>
|
||||||
|
|
||||||
|
#include "read.h"
|
||||||
|
#include "sds.h"
|
||||||
|
|
||||||
|
static void __redisReaderSetError(redisReader *r, int type, const char *str) {
|
||||||
|
size_t len;
|
||||||
|
|
||||||
|
if (r->reply != NULL && r->fn && r->fn->freeObject) {
|
||||||
|
r->fn->freeObject(r->reply);
|
||||||
|
r->reply = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Clear input buffer on errors. */
|
||||||
|
if (r->buf != NULL) {
|
||||||
|
sdsfree(r->buf);
|
||||||
|
r->buf = NULL;
|
||||||
|
r->pos = r->len = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Reset task stack. */
|
||||||
|
r->ridx = -1;
|
||||||
|
|
||||||
|
/* Set error. */
|
||||||
|
r->err = type;
|
||||||
|
len = strlen(str);
|
||||||
|
len = len < (sizeof(r->errstr)-1) ? len : (sizeof(r->errstr)-1);
|
||||||
|
memcpy(r->errstr,str,len);
|
||||||
|
r->errstr[len] = '\0';
|
||||||
|
}
|
||||||
|
|
||||||
|
static size_t chrtos(char *buf, size_t size, char byte) {
|
||||||
|
size_t len = 0;
|
||||||
|
|
||||||
|
switch(byte) {
|
||||||
|
case '\\':
|
||||||
|
case '"':
|
||||||
|
len = snprintf(buf,size,"\"\\%c\"",byte);
|
||||||
|
break;
|
||||||
|
case '\n': len = snprintf(buf,size,"\"\\n\""); break;
|
||||||
|
case '\r': len = snprintf(buf,size,"\"\\r\""); break;
|
||||||
|
case '\t': len = snprintf(buf,size,"\"\\t\""); break;
|
||||||
|
case '\a': len = snprintf(buf,size,"\"\\a\""); break;
|
||||||
|
case '\b': len = snprintf(buf,size,"\"\\b\""); break;
|
||||||
|
default:
|
||||||
|
if (isprint(byte))
|
||||||
|
len = snprintf(buf,size,"\"%c\"",byte);
|
||||||
|
else
|
||||||
|
len = snprintf(buf,size,"\"\\x%02x\"",(unsigned char)byte);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
return len;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void __redisReaderSetErrorProtocolByte(redisReader *r, char byte) {
|
||||||
|
char cbuf[8], sbuf[128];
|
||||||
|
|
||||||
|
chrtos(cbuf,sizeof(cbuf),byte);
|
||||||
|
snprintf(sbuf,sizeof(sbuf),
|
||||||
|
"Protocol error, got %s as reply type byte", cbuf);
|
||||||
|
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,sbuf);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void __redisReaderSetErrorOOM(redisReader *r) {
|
||||||
|
__redisReaderSetError(r,REDIS_ERR_OOM,"Out of memory");
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *readBytes(redisReader *r, unsigned int bytes) {
|
||||||
|
char *p;
|
||||||
|
if (r->len-r->pos >= bytes) {
|
||||||
|
p = r->buf+r->pos;
|
||||||
|
r->pos += bytes;
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Find pointer to \r\n. */
|
||||||
|
static char *seekNewline(char *s, size_t len) {
|
||||||
|
int pos = 0;
|
||||||
|
int _len = len-1;
|
||||||
|
|
||||||
|
/* Position should be < len-1 because the character at "pos" should be
|
||||||
|
* followed by a \n. Note that strchr cannot be used because it doesn't
|
||||||
|
* allow to search a limited length and the buffer that is being searched
|
||||||
|
* might not have a trailing NULL character. */
|
||||||
|
while (pos < _len) {
|
||||||
|
while(pos < _len && s[pos] != '\r') pos++;
|
||||||
|
if (s[pos] != '\r') {
|
||||||
|
/* Not found. */
|
||||||
|
return NULL;
|
||||||
|
} else {
|
||||||
|
if (s[pos+1] == '\n') {
|
||||||
|
/* Found. */
|
||||||
|
return s+pos;
|
||||||
|
} else {
|
||||||
|
/* Continue searching. */
|
||||||
|
pos++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Read a long long value starting at *s, under the assumption that it will be
|
||||||
|
* terminated by \r\n. Ambiguously returns -1 for unexpected input. */
|
||||||
|
static long long readLongLong(char *s) {
|
||||||
|
long long v = 0;
|
||||||
|
int dec, mult = 1;
|
||||||
|
char c;
|
||||||
|
|
||||||
|
if (*s == '-') {
|
||||||
|
mult = -1;
|
||||||
|
s++;
|
||||||
|
} else if (*s == '+') {
|
||||||
|
mult = 1;
|
||||||
|
s++;
|
||||||
|
}
|
||||||
|
|
||||||
|
while ((c = *(s++)) != '\r') {
|
||||||
|
dec = c - '0';
|
||||||
|
if (dec >= 0 && dec < 10) {
|
||||||
|
v *= 10;
|
||||||
|
v += dec;
|
||||||
|
} else {
|
||||||
|
/* Should not happen... */
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return mult*v;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *readLine(redisReader *r, int *_len) {
|
||||||
|
char *p, *s;
|
||||||
|
int len;
|
||||||
|
|
||||||
|
p = r->buf+r->pos;
|
||||||
|
s = seekNewline(p,(r->len-r->pos));
|
||||||
|
if (s != NULL) {
|
||||||
|
len = s-(r->buf+r->pos);
|
||||||
|
r->pos += len+2; /* skip \r\n */
|
||||||
|
if (_len) *_len = len;
|
||||||
|
return p;
|
||||||
|
}
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void moveToNextTask(redisReader *r) {
|
||||||
|
redisReadTask *cur, *prv;
|
||||||
|
while (r->ridx >= 0) {
|
||||||
|
/* Return a.s.a.p. when the stack is now empty. */
|
||||||
|
if (r->ridx == 0) {
|
||||||
|
r->ridx--;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
cur = &(r->rstack[r->ridx]);
|
||||||
|
prv = &(r->rstack[r->ridx-1]);
|
||||||
|
assert(prv->type == REDIS_REPLY_ARRAY);
|
||||||
|
if (cur->idx == prv->elements-1) {
|
||||||
|
r->ridx--;
|
||||||
|
} else {
|
||||||
|
/* Reset the type because the next item can be anything */
|
||||||
|
assert(cur->idx < prv->elements);
|
||||||
|
cur->type = -1;
|
||||||
|
cur->elements = -1;
|
||||||
|
cur->idx++;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static int processLineItem(redisReader *r) {
|
||||||
|
redisReadTask *cur = &(r->rstack[r->ridx]);
|
||||||
|
void *obj;
|
||||||
|
char *p;
|
||||||
|
int len;
|
||||||
|
|
||||||
|
if ((p = readLine(r,&len)) != NULL) {
|
||||||
|
if (cur->type == REDIS_REPLY_INTEGER) {
|
||||||
|
if (r->fn && r->fn->createInteger)
|
||||||
|
obj = r->fn->createInteger(cur,readLongLong(p));
|
||||||
|
else
|
||||||
|
obj = (void*)REDIS_REPLY_INTEGER;
|
||||||
|
} else {
|
||||||
|
/* Type will be error or status. */
|
||||||
|
if (r->fn && r->fn->createString)
|
||||||
|
obj = r->fn->createString(cur,p,len);
|
||||||
|
else
|
||||||
|
obj = (void*)(size_t)(cur->type);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (obj == NULL) {
|
||||||
|
__redisReaderSetErrorOOM(r);
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Set reply if this is the root object. */
|
||||||
|
if (r->ridx == 0) r->reply = obj;
|
||||||
|
moveToNextTask(r);
|
||||||
|
return REDIS_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int processBulkItem(redisReader *r) {
|
||||||
|
redisReadTask *cur = &(r->rstack[r->ridx]);
|
||||||
|
void *obj = NULL;
|
||||||
|
char *p, *s;
|
||||||
|
long len;
|
||||||
|
unsigned long bytelen;
|
||||||
|
int success = 0;
|
||||||
|
|
||||||
|
p = r->buf+r->pos;
|
||||||
|
s = seekNewline(p,r->len-r->pos);
|
||||||
|
if (s != NULL) {
|
||||||
|
p = r->buf+r->pos;
|
||||||
|
bytelen = s-(r->buf+r->pos)+2; /* include \r\n */
|
||||||
|
len = readLongLong(p);
|
||||||
|
|
||||||
|
if (len < 0) {
|
||||||
|
/* The nil object can always be created. */
|
||||||
|
if (r->fn && r->fn->createNil)
|
||||||
|
obj = r->fn->createNil(cur);
|
||||||
|
else
|
||||||
|
obj = (void*)REDIS_REPLY_NIL;
|
||||||
|
success = 1;
|
||||||
|
} else {
|
||||||
|
/* Only continue when the buffer contains the entire bulk item. */
|
||||||
|
bytelen += len+2; /* include \r\n */
|
||||||
|
if (r->pos+bytelen <= r->len) {
|
||||||
|
if (r->fn && r->fn->createString)
|
||||||
|
obj = r->fn->createString(cur,s+2,len);
|
||||||
|
else
|
||||||
|
obj = (void*)REDIS_REPLY_STRING;
|
||||||
|
success = 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Proceed when obj was created. */
|
||||||
|
if (success) {
|
||||||
|
if (obj == NULL) {
|
||||||
|
__redisReaderSetErrorOOM(r);
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
r->pos += bytelen;
|
||||||
|
|
||||||
|
/* Set reply if this is the root object. */
|
||||||
|
if (r->ridx == 0) r->reply = obj;
|
||||||
|
moveToNextTask(r);
|
||||||
|
return REDIS_OK;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int processMultiBulkItem(redisReader *r) {
|
||||||
|
redisReadTask *cur = &(r->rstack[r->ridx]);
|
||||||
|
void *obj;
|
||||||
|
char *p;
|
||||||
|
long elements;
|
||||||
|
int root = 0;
|
||||||
|
|
||||||
|
/* Set error for nested multi bulks with depth > 7 */
|
||||||
|
if (r->ridx == 8) {
|
||||||
|
__redisReaderSetError(r,REDIS_ERR_PROTOCOL,
|
||||||
|
"No support for nested multi bulk replies with depth > 7");
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((p = readLine(r,NULL)) != NULL) {
|
||||||
|
elements = readLongLong(p);
|
||||||
|
root = (r->ridx == 0);
|
||||||
|
|
||||||
|
if (elements == -1) {
|
||||||
|
if (r->fn && r->fn->createNil)
|
||||||
|
obj = r->fn->createNil(cur);
|
||||||
|
else
|
||||||
|
obj = (void*)REDIS_REPLY_NIL;
|
||||||
|
|
||||||
|
if (obj == NULL) {
|
||||||
|
__redisReaderSetErrorOOM(r);
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
moveToNextTask(r);
|
||||||
|
} else {
|
||||||
|
if (r->fn && r->fn->createArray)
|
||||||
|
obj = r->fn->createArray(cur,elements);
|
||||||
|
else
|
||||||
|
obj = (void*)REDIS_REPLY_ARRAY;
|
||||||
|
|
||||||
|
if (obj == NULL) {
|
||||||
|
__redisReaderSetErrorOOM(r);
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Modify task stack when there are more than 0 elements. */
|
||||||
|
if (elements > 0) {
|
||||||
|
cur->elements = elements;
|
||||||
|
cur->obj = obj;
|
||||||
|
r->ridx++;
|
||||||
|
r->rstack[r->ridx].type = -1;
|
||||||
|
r->rstack[r->ridx].elements = -1;
|
||||||
|
r->rstack[r->ridx].idx = 0;
|
||||||
|
r->rstack[r->ridx].obj = NULL;
|
||||||
|
r->rstack[r->ridx].parent = cur;
|
||||||
|
r->rstack[r->ridx].privdata = r->privdata;
|
||||||
|
} else {
|
||||||
|
moveToNextTask(r);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Set reply if this is the root object. */
|
||||||
|
if (root) r->reply = obj;
|
||||||
|
return REDIS_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int processItem(redisReader *r) {
|
||||||
|
redisReadTask *cur = &(r->rstack[r->ridx]);
|
||||||
|
char *p;
|
||||||
|
|
||||||
|
/* check if we need to read type */
|
||||||
|
if (cur->type < 0) {
|
||||||
|
if ((p = readBytes(r,1)) != NULL) {
|
||||||
|
switch (p[0]) {
|
||||||
|
case '-':
|
||||||
|
cur->type = REDIS_REPLY_ERROR;
|
||||||
|
break;
|
||||||
|
case '+':
|
||||||
|
cur->type = REDIS_REPLY_STATUS;
|
||||||
|
break;
|
||||||
|
case ':':
|
||||||
|
cur->type = REDIS_REPLY_INTEGER;
|
||||||
|
break;
|
||||||
|
case '$':
|
||||||
|
cur->type = REDIS_REPLY_STRING;
|
||||||
|
break;
|
||||||
|
case '*':
|
||||||
|
cur->type = REDIS_REPLY_ARRAY;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
__redisReaderSetErrorProtocolByte(r,*p);
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
/* could not consume 1 byte */
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* process typed item */
|
||||||
|
switch(cur->type) {
|
||||||
|
case REDIS_REPLY_ERROR:
|
||||||
|
case REDIS_REPLY_STATUS:
|
||||||
|
case REDIS_REPLY_INTEGER:
|
||||||
|
return processLineItem(r);
|
||||||
|
case REDIS_REPLY_STRING:
|
||||||
|
return processBulkItem(r);
|
||||||
|
case REDIS_REPLY_ARRAY:
|
||||||
|
return processMultiBulkItem(r);
|
||||||
|
default:
|
||||||
|
assert(NULL);
|
||||||
|
return REDIS_ERR; /* Avoid warning. */
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
redisReader *redisReaderCreateWithFunctions(redisReplyObjectFunctions *fn) {
|
||||||
|
redisReader *r;
|
||||||
|
|
||||||
|
r = calloc(sizeof(redisReader),1);
|
||||||
|
if (r == NULL)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
r->err = 0;
|
||||||
|
r->errstr[0] = '\0';
|
||||||
|
r->fn = fn;
|
||||||
|
r->buf = sdsempty();
|
||||||
|
r->maxbuf = REDIS_READER_MAX_BUF;
|
||||||
|
if (r->buf == NULL) {
|
||||||
|
free(r);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
r->ridx = -1;
|
||||||
|
return r;
|
||||||
|
}
|
||||||
|
|
||||||
|
void redisReaderFree(redisReader *r) {
|
||||||
|
if (r->reply != NULL && r->fn && r->fn->freeObject)
|
||||||
|
r->fn->freeObject(r->reply);
|
||||||
|
if (r->buf != NULL)
|
||||||
|
sdsfree(r->buf);
|
||||||
|
free(r);
|
||||||
|
}
|
||||||
|
|
||||||
|
int redisReaderFeed(redisReader *r, const char *buf, size_t len) {
|
||||||
|
sds newbuf;
|
||||||
|
|
||||||
|
/* Return early when this reader is in an erroneous state. */
|
||||||
|
if (r->err)
|
||||||
|
return REDIS_ERR;
|
||||||
|
|
||||||
|
/* Copy the provided buffer. */
|
||||||
|
if (buf != NULL && len >= 1) {
|
||||||
|
/* Destroy internal buffer when it is empty and is quite large. */
|
||||||
|
if (r->len == 0 && r->maxbuf != 0 && sdsavail(r->buf) > r->maxbuf) {
|
||||||
|
sdsfree(r->buf);
|
||||||
|
r->buf = sdsempty();
|
||||||
|
r->pos = 0;
|
||||||
|
|
||||||
|
/* r->buf should not be NULL since we just free'd a larger one. */
|
||||||
|
assert(r->buf != NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
newbuf = sdscatlen(r->buf,buf,len);
|
||||||
|
if (newbuf == NULL) {
|
||||||
|
__redisReaderSetErrorOOM(r);
|
||||||
|
return REDIS_ERR;
|
||||||
|
}
|
||||||
|
|
||||||
|
r->buf = newbuf;
|
||||||
|
r->len = sdslen(r->buf);
|
||||||
|
}
|
||||||
|
|
||||||
|
return REDIS_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
int redisReaderGetReply(redisReader *r, void **reply) {
|
||||||
|
/* Default target pointer to NULL. */
|
||||||
|
if (reply != NULL)
|
||||||
|
*reply = NULL;
|
||||||
|
|
||||||
|
/* Return early when this reader is in an erroneous state. */
|
||||||
|
if (r->err)
|
||||||
|
return REDIS_ERR;
|
||||||
|
|
||||||
|
/* When the buffer is empty, there will never be a reply. */
|
||||||
|
if (r->len == 0)
|
||||||
|
return REDIS_OK;
|
||||||
|
|
||||||
|
/* Set first item to process when the stack is empty. */
|
||||||
|
if (r->ridx == -1) {
|
||||||
|
r->rstack[0].type = -1;
|
||||||
|
r->rstack[0].elements = -1;
|
||||||
|
r->rstack[0].idx = -1;
|
||||||
|
r->rstack[0].obj = NULL;
|
||||||
|
r->rstack[0].parent = NULL;
|
||||||
|
r->rstack[0].privdata = r->privdata;
|
||||||
|
r->ridx = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Process items in reply. */
|
||||||
|
while (r->ridx >= 0)
|
||||||
|
if (processItem(r) != REDIS_OK)
|
||||||
|
break;
|
||||||
|
|
||||||
|
/* Return ASAP when an error occurred. */
|
||||||
|
if (r->err)
|
||||||
|
return REDIS_ERR;
|
||||||
|
|
||||||
|
/* Discard part of the buffer when we've consumed at least 1k, to avoid
|
||||||
|
* doing unnecessary calls to memmove() in sds.c. */
|
||||||
|
if (r->pos >= 1024) {
|
||||||
|
sdsrange(r->buf,r->pos,-1);
|
||||||
|
r->pos = 0;
|
||||||
|
r->len = sdslen(r->buf);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Emit a reply when there is one. */
|
||||||
|
if (r->ridx == -1) {
|
||||||
|
if (reply != NULL)
|
||||||
|
*reply = r->reply;
|
||||||
|
r->reply = NULL;
|
||||||
|
}
|
||||||
|
return REDIS_OK;
|
||||||
|
}
|
@ -0,0 +1,116 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>
|
||||||
|
* Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>
|
||||||
|
*
|
||||||
|
* All rights reserved.
|
||||||
|
*
|
||||||
|
* Redistribution and use in source and binary forms, with or without
|
||||||
|
* modification, are permitted provided that the following conditions are met:
|
||||||
|
*
|
||||||
|
* * Redistributions of source code must retain the above copyright notice,
|
||||||
|
* this list of conditions and the following disclaimer.
|
||||||
|
* * Redistributions in binary form must reproduce the above copyright
|
||||||
|
* notice, this list of conditions and the following disclaimer in the
|
||||||
|
* documentation and/or other materials provided with the distribution.
|
||||||
|
* * Neither the name of Redis nor the names of its contributors may be used
|
||||||
|
* to endorse or promote products derived from this software without
|
||||||
|
* specific prior written permission.
|
||||||
|
*
|
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||||
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||||
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||||
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||||
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||||
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||||
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||||
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||||
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||||
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||||
|
* POSSIBILITY OF SUCH DAMAGE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
#ifndef __HIREDIS_READ_H
|
||||||
|
#define __HIREDIS_READ_H
|
||||||
|
#include <stdio.h> /* for size_t */
|
||||||
|
|
||||||
|
#define REDIS_ERR -1
|
||||||
|
#define REDIS_OK 0
|
||||||
|
|
||||||
|
/* When an error occurs, the err flag in a context is set to hold the type of
|
||||||
|
* error that occured. REDIS_ERR_IO means there was an I/O error and you
|
||||||
|
* should use the "errno" variable to find out what is wrong.
|
||||||
|
* For other values, the "errstr" field will hold a description. */
|
||||||
|
#define REDIS_ERR_IO 1 /* Error in read or write */
|
||||||
|
#define REDIS_ERR_EOF 3 /* End of file */
|
||||||
|
#define REDIS_ERR_PROTOCOL 4 /* Protocol error */
|
||||||
|
#define REDIS_ERR_OOM 5 /* Out of memory */
|
||||||
|
#define REDIS_ERR_OTHER 2 /* Everything else... */
|
||||||
|
|
||||||
|
#define REDIS_REPLY_STRING 1
|
||||||
|
#define REDIS_REPLY_ARRAY 2
|
||||||
|
#define REDIS_REPLY_INTEGER 3
|
||||||
|
#define REDIS_REPLY_NIL 4
|
||||||
|
#define REDIS_REPLY_STATUS 5
|
||||||
|
#define REDIS_REPLY_ERROR 6
|
||||||
|
|
||||||
|
#define REDIS_READER_MAX_BUF (1024*16) /* Default max unused reader buffer. */
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
extern "C" {
|
||||||
|
#endif
|
||||||
|
|
||||||
|
typedef struct redisReadTask {
|
||||||
|
int type;
|
||||||
|
int elements; /* number of elements in multibulk container */
|
||||||
|
int idx; /* index in parent (array) object */
|
||||||
|
void *obj; /* holds user-generated value for a read task */
|
||||||
|
struct redisReadTask *parent; /* parent task */
|
||||||
|
void *privdata; /* user-settable arbitrary field */
|
||||||
|
} redisReadTask;
|
||||||
|
|
||||||
|
typedef struct redisReplyObjectFunctions {
|
||||||
|
void *(*createString)(const redisReadTask*, char*, size_t);
|
||||||
|
void *(*createArray)(const redisReadTask*, int);
|
||||||
|
void *(*createInteger)(const redisReadTask*, long long);
|
||||||
|
void *(*createNil)(const redisReadTask*);
|
||||||
|
void (*freeObject)(void*);
|
||||||
|
} redisReplyObjectFunctions;
|
||||||
|
|
||||||
|
typedef struct redisReader {
|
||||||
|
int err; /* Error flags, 0 when there is no error */
|
||||||
|
char errstr[128]; /* String representation of error when applicable */
|
||||||
|
|
||||||
|
char *buf; /* Read buffer */
|
||||||
|
size_t pos; /* Buffer cursor */
|
||||||
|
size_t len; /* Buffer length */
|
||||||
|
size_t maxbuf; /* Max length of unused buffer */
|
||||||
|
|
||||||
|
redisReadTask rstack[9];
|
||||||
|
int ridx; /* Index of current read task */
|
||||||
|
void *reply; /* Temporary reply pointer */
|
||||||
|
|
||||||
|
redisReplyObjectFunctions *fn;
|
||||||
|
void *privdata;
|
||||||
|
} redisReader;
|
||||||
|
|
||||||
|
/* Public API for the protocol parser. */
|
||||||
|
redisReader *redisReaderCreateWithFunctions(redisReplyObjectFunctions *fn);
|
||||||
|
void redisReaderFree(redisReader *r);
|
||||||
|
int redisReaderFeed(redisReader *r, const char *buf, size_t len);
|
||||||
|
int redisReaderGetReply(redisReader *r, void **reply);
|
||||||
|
|
||||||
|
/* Backwards compatibility, can be removed on big version bump. */
|
||||||
|
#define redisReplyReaderCreate redisReaderCreate
|
||||||
|
#define redisReplyReaderFree redisReaderFree
|
||||||
|
#define redisReplyReaderFeed redisReaderFeed
|
||||||
|
#define redisReplyReaderGetReply redisReaderGetReply
|
||||||
|
#define redisReplyReaderSetPrivdata(_r, _p) (int)(((redisReader*)(_r))->privdata = (_p))
|
||||||
|
#define redisReplyReaderGetObject(_r) (((redisReader*)(_r))->reply)
|
||||||
|
#define redisReplyReaderGetError(_r) (((redisReader*)(_r))->errstr)
|
||||||
|
|
||||||
|
#ifdef __cplusplus
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#endif
|
File diff suppressed because it is too large
Load Diff
@ -1,40 +0,0 @@
|
|||||||
/*
|
|
||||||
* Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com>
|
|
||||||
* All rights reserved.
|
|
||||||
*
|
|
||||||
* Redistribution and use in source and binary forms, with or without
|
|
||||||
* modification, are permitted provided that the following conditions are met:
|
|
||||||
*
|
|
||||||
* * Redistributions of source code must retain the above copyright notice,
|
|
||||||
* this list of conditions and the following disclaimer.
|
|
||||||
* * Redistributions in binary form must reproduce the above copyright
|
|
||||||
* notice, this list of conditions and the following disclaimer in the
|
|
||||||
* documentation and/or other materials provided with the distribution.
|
|
||||||
* * Neither the name of Redis nor the names of its contributors may be used
|
|
||||||
* to endorse or promote products derived from this software without
|
|
||||||
* specific prior written permission.
|
|
||||||
*
|
|
||||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
||||||
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
||||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
||||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
||||||
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
||||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
||||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
||||||
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
||||||
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
||||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
||||||
* POSSIBILITY OF SUCH DAMAGE.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef __UTIL_H
|
|
||||||
#define __UTIL_H
|
|
||||||
#include <stdlib.h>
|
|
||||||
|
|
||||||
/* Abort on out of memory */
|
|
||||||
static void redisOOM(void) {
|
|
||||||
fprintf(stderr,"Out of memory in hiredis");
|
|
||||||
exit(1);
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
@ -0,0 +1,42 @@
|
|||||||
|
#ifndef _WIN32_HELPER_INCLUDE
|
||||||
|
#define _WIN32_HELPER_INCLUDE
|
||||||
|
#ifdef _MSC_VER
|
||||||
|
|
||||||
|
#ifndef inline
|
||||||
|
#define inline __inline
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef va_copy
|
||||||
|
#define va_copy(d,s) ((d) = (s))
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef snprintf
|
||||||
|
#define snprintf c99_snprintf
|
||||||
|
|
||||||
|
__inline int c99_vsnprintf(char* str, size_t size, const char* format, va_list ap)
|
||||||
|
{
|
||||||
|
int count = -1;
|
||||||
|
|
||||||
|
if (size != 0)
|
||||||
|
count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
|
||||||
|
if (count == -1)
|
||||||
|
count = _vscprintf(format, ap);
|
||||||
|
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
|
||||||
|
__inline int c99_snprintf(char* str, size_t size, const char* format, ...)
|
||||||
|
{
|
||||||
|
int count;
|
||||||
|
va_list ap;
|
||||||
|
|
||||||
|
va_start(ap, format);
|
||||||
|
count = c99_vsnprintf(str, size, format, ap);
|
||||||
|
va_end(ap);
|
||||||
|
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#endif
|
||||||
|
#endif
|
Loading…
Reference in New Issue