Update hiredis to 0.9.2

3 files changed, 145 insertions, 29 deletions

diff --git a/deps/hiredis/adapters/ae.h b/deps/hiredis/adapters/ae.h
new file mode 100644
index 000000000..b8b2228ed
--- /dev/null
+++ b/deps/hiredis/adapters/ae.h
@@ -0,0 +1,95 @@
+#include <sys/types.h>
+#include <ae.h>
+#include "../hiredis.h"
+#include "../async.h"
+
+typedef struct redisAeEvents {
+    redisAsyncContext *context;
+    aeEventLoop *loop;
+    int fd;
+    int reading, writing;
+} redisAeEvents;
+
+void redisAeReadEvent(aeEventLoop *el, int fd, void *privdata, int mask) {
+    ((void)el); ((void)fd); ((void)mask);
+
+    redisAeEvents *e = (redisAeEvents*)privdata;
+    redisAsyncHandleRead(e->context);
+}
+
+void redisAeWriteEvent(aeEventLoop *el, int fd, void *privdata, int mask) {
+    ((void)el); ((void)fd); ((void)mask);
+
+    redisAeEvents *e = (redisAeEvents*)privdata;
+    redisAsyncHandleWrite(e->context);
+}
+
+void redisAeAddRead(void *privdata) {
+    redisAeEvents *e = (redisAeEvents*)privdata;
+    aeEventLoop *loop = e->loop;
+    if (!e->reading) {
+        e->reading = 1;
+        aeCreateFileEvent(loop,e->fd,AE_READABLE,redisAeReadEvent,e);
+    }
+}
+
+void redisAeDelRead(void *privdata) {
+    redisAeEvents *e = (redisAeEvents*)privdata;
+    aeEventLoop *loop = e->loop;
+    if (e->reading) {
+        e->reading = 0;
+        aeDeleteFileEvent(loop,e->fd,AE_READABLE);
+    }
+}
+
+void redisAeAddWrite(void *privdata) {
+    redisAeEvents *e = (redisAeEvents*)privdata;
+    aeEventLoop *loop = e->loop;
+    if (!e->writing) {
+        e->writing = 1;
+        aeCreateFileEvent(loop,e->fd,AE_WRITABLE,redisAeWriteEvent,e);
+    }
+}
+
+void redisAeDelWrite(void *privdata) {
+    redisAeEvents *e = (redisAeEvents*)privdata;
+    aeEventLoop *loop = e->loop;
+    if (e->writing) {
+        e->writing = 0;
+        aeDeleteFileEvent(loop,e->fd,AE_WRITABLE);
+    }
+}
+
+void redisAeCleanup(void *privdata) {
+    redisAeEvents *e = (redisAeEvents*)privdata;
+    redisAeDelRead(privdata);
+    redisAeDelWrite(privdata);
+    free(e);
+}
+
+int redisAeAttach(aeEventLoop *loop, redisAsyncContext *ac) {
+    redisContext *c = &(ac->c);
+    redisAeEvents *e;
+
+    /* Nothing should be attached when something is already attached */
+    if (ac->_adapter_data != NULL)
+        return REDIS_ERR;
+
+    /* Create container for context and r/w events */
+    e = (redisAeEvents*)malloc(sizeof(*e));
+    e->context = ac;
+    e->loop = loop;
+    e->fd = c->fd;
+    e->reading = e->writing = 0;
+
+    /* Register functions to start/stop listening for events */
+    ac->evAddRead = redisAeAddRead;
+    ac->evDelRead = redisAeDelRead;
+    ac->evAddWrite = redisAeAddWrite;
+    ac->evDelWrite = redisAeDelWrite;
+    ac->evCleanup = redisAeCleanup;
+    ac->_adapter_data = e;
+
+    return REDIS_OK;
+}
+
diff --git a/deps/hiredis/adapters/libev.h b/deps/hiredis/adapters/libev.h
index 79c069d92..3b9ed6560 100644
--- a/deps/hiredis/adapters/libev.h
+++ b/deps/hiredis/adapters/libev.h
@@ -10,69 +10,89 @@ typedef struct redisLibevEvents {
     ev_io rev, wev;
 } redisLibevEvents;
 
-void redisLibevReadEvent(struct ev_loop *loop, ev_io *watcher, int revents) {
-    ((void)loop); ((void)revents);
-    redisLibevEvents *e = watcher->data;
+void redisLibevReadEvent(EV_P_ ev_io *watcher, int revents) {
+#if EV_MULTIPLICITY
+    ((void)loop);
+#endif
+    ((void)revents);
+
+    redisLibevEvents *e = (redisLibevEvents*)watcher->data;
     redisAsyncHandleRead(e->context);
 }
 
-void redisLibevWriteEvent(struct ev_loop *loop, ev_io *watcher, int revents) {
-    ((void)loop); ((void)revents);
-    redisLibevEvents *e = watcher->data;
+void redisLibevWriteEvent(EV_P_ ev_io *watcher, int revents) {
+#if EV_MULTIPLICITY
+    ((void)loop);
+#endif
+    ((void)revents);
+
+    redisLibevEvents *e = (redisLibevEvents*)watcher->data;
     redisAsyncHandleWrite(e->context);
 }
 
 void redisLibevAddRead(void *privdata) {
-    redisLibevEvents *e = privdata;
+    redisLibevEvents *e = (redisLibevEvents*)privdata;
+    struct ev_loop *loop = e->loop;
+    ((void)loop);
     if (!e->reading) {
         e->reading = 1;
-        ev_io_start(e->loop,&e->rev);
+        ev_io_start(EV_A_ &e->rev);
     }
 }
 
 void redisLibevDelRead(void *privdata) {
-    redisLibevEvents *e = privdata;
+    redisLibevEvents *e = (redisLibevEvents*)privdata;
+    struct ev_loop *loop = e->loop;
+    ((void)loop);
     if (e->reading) {
         e->reading = 0;
-        ev_io_stop(e->loop,&e->rev);
+        ev_io_stop(EV_A_ &e->rev);
     }
 }
 
 void redisLibevAddWrite(void *privdata) {
-    redisLibevEvents *e = privdata;
+    redisLibevEvents *e = (redisLibevEvents*)privdata;
+    struct ev_loop *loop = e->loop;
+    ((void)loop);
     if (!e->writing) {
         e->writing = 1;
-        ev_io_start(e->loop,&e->wev);
+        ev_io_start(EV_A_ &e->wev);
     }
 }
 
 void redisLibevDelWrite(void *privdata) {
-    redisLibevEvents *e = privdata;
+    redisLibevEvents *e = (redisLibevEvents*)privdata;
+    struct ev_loop *loop = e->loop;
+    ((void)loop);
     if (e->writing) {
         e->writing = 0;
-        ev_io_stop(e->loop,&e->wev);
+        ev_io_stop(EV_A_ &e->wev);
     }
 }
 
 void redisLibevCleanup(void *privdata) {
-    redisLibevEvents *e = privdata;
+    redisLibevEvents *e = (redisLibevEvents*)privdata;
     redisLibevDelRead(privdata);
     redisLibevDelWrite(privdata);
     free(e);
 }
 
-int redisLibevAttach(redisAsyncContext *ac, struct ev_loop *loop) {
+int redisLibevAttach(EV_P_ redisAsyncContext *ac) {
     redisContext *c = &(ac->c);
     redisLibevEvents *e;
 
     /* Nothing should be attached when something is already attached */
-    if (ac->data != NULL)
+    if (ac->_adapter_data != NULL)
         return REDIS_ERR;
 
     /* Create container for context and r/w events */
-    e = malloc(sizeof(*e));
+    e = (redisLibevEvents*)malloc(sizeof(*e));
     e->context = ac;
+#if EV_MULTIPLICITY
     e->loop = loop;
+#else
+    e->loop = NULL;
+#endif
     e->reading = e->writing = 0;
     e->rev.data = e;
     e->wev.data = e;
@@ -83,10 +103,11 @@ int redisLibevAttach(redisAsyncContext *ac, struct ev_loop *loop) {
     ac->evAddWrite = redisLibevAddWrite;
     ac->evDelWrite = redisLibevDelWrite;
     ac->evCleanup = redisLibevCleanup;
-    ac->data = e;
+    ac->_adapter_data = e;
 
     /* Initialize read/write events */
     ev_io_init(&e->rev,redisLibevReadEvent,c->fd,EV_READ);
     ev_io_init(&e->wev,redisLibevWriteEvent,c->fd,EV_WRITE);
     return REDIS_OK;
 }
+
diff --git a/deps/hiredis/adapters/libevent.h b/deps/hiredis/adapters/libevent.h
index 1b759c131..dc1f5c739 100644
--- a/deps/hiredis/adapters/libevent.h
+++ b/deps/hiredis/adapters/libevent.h
@@ -10,38 +10,38 @@ typedef struct redisLibeventEvents {
 
 void redisLibeventReadEvent(int fd, short event, void *arg) {
     ((void)fd); ((void)event);
-    redisLibeventEvents *e = arg;
+    redisLibeventEvents *e = (redisLibeventEvents*)arg;
     redisAsyncHandleRead(e->context);
 }
 
 void redisLibeventWriteEvent(int fd, short event, void *arg) {
     ((void)fd); ((void)event);
-    redisLibeventEvents *e = arg;
+    redisLibeventEvents *e = (redisLibeventEvents*)arg;
     redisAsyncHandleWrite(e->context);
 }
 
 void redisLibeventAddRead(void *privdata) {
-    redisLibeventEvents *e = privdata;
+    redisLibeventEvents *e = (redisLibeventEvents*)privdata;
     event_add(&e->rev,NULL);
 }
 
 void redisLibeventDelRead(void *privdata) {
-    redisLibeventEvents *e = privdata;
+    redisLibeventEvents *e = (redisLibeventEvents*)privdata;
     event_del(&e->rev);
 }
 
 void redisLibeventAddWrite(void *privdata) {
-    redisLibeventEvents *e = privdata;
+    redisLibeventEvents *e = (redisLibeventEvents*)privdata;
     event_add(&e->wev,NULL);
 }
 
 void redisLibeventDelWrite(void *privdata) {
-    redisLibeventEvents *e = privdata;
+    redisLibeventEvents *e = (redisLibeventEvents*)privdata;
     event_del(&e->wev);
 }
 
 void redisLibeventCleanup(void *privdata) {
-    redisLibeventEvents *e = privdata;
+    redisLibeventEvents *e = (redisLibeventEvents*)privdata;
     event_del(&e->rev);
     event_del(&e->wev);
     free(e);
@@ -52,11 +52,11 @@ int redisLibeventAttach(redisAsyncContext *ac, struct event_base *base) {
     redisLibeventEvents *e;
 
     /* Nothing should be attached when something is already attached */
-    if (ac->data != NULL)
+    if (ac->_adapter_data != NULL)
         return REDIS_ERR;
 
     /* Create container for context and r/w events */
-    e = malloc(sizeof(*e));
+    e = (redisLibeventEvents*)malloc(sizeof(*e));
     e->context = ac;
 
     /* Register functions to start/stop listening for events */
@@ -65,7 +65,7 @@ int redisLibeventAttach(redisAsyncContext *ac, struct event_base *base) {
     ac->evAddWrite = redisLibeventAddWrite;
     ac->evDelWrite = redisLibeventDelWrite;
     ac->evCleanup = redisLibeventCleanup;
-    ac->data = e;
+    ac->_adapter_data = e;
 
     /* Initialize and install read/write events */
     event_set(&e->rev,c->fd,EV_READ,redisLibeventReadEvent,e);