all: rename redis -> redict symbols and commentsmaster

Signed-off-by: Anna (navi) Figueiredo Gomes <navi@vlhl.dev>

1 files changed, 170 insertions, 170 deletions

diff --git a/net.c b/net.c
index 9eac6bb..96cfa0e 100644
--- a/net.c
+++ b/net.c
@@ -1,4 +1,4 @@
-/* Extracted from anet.c to work properly with Hiredis error reporting.
+/* Extracted from anet.c to work properly with Hiredict error reporting.
  *
  * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>
  * Copyright (c) 2010-2014, Pieter Noordhuis <pcnoordhuis at gmail dot com>
@@ -32,50 +32,50 @@
 #include "sockcompat.h"
 #include "win32.h"
 
-/* Defined in hiredis.c */
-void __redisSetError(redisContext *c, int type, const char *str);
+/* Defined in hiredict.c */
+void __redictSetError(redictContext *c, int type, const char *str);
 
-int redisContextUpdateCommandTimeout(redisContext *c, const struct timeval *timeout);
+int redictContextUpdateCommandTimeout(redictContext *c, const struct timeval *timeout);
 
-void redisNetClose(redisContext *c) {
-    if (c && c->fd != REDIS_INVALID_FD) {
+void redictNetClose(redictContext *c) {
+    if (c && c->fd != REDICT_INVALID_FD) {
         close(c->fd);
-        c->fd = REDIS_INVALID_FD;
+        c->fd = REDICT_INVALID_FD;
     }
 }
 
-ssize_t redisNetRead(redisContext *c, char *buf, size_t bufcap) {
+ssize_t redictNetRead(redictContext *c, char *buf, size_t bufcap) {
     ssize_t nread = recv(c->fd, buf, bufcap, 0);
     if (nread == -1) {
-        if ((errno == EWOULDBLOCK && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {
+        if ((errno == EWOULDBLOCK && !(c->flags & REDICT_BLOCK)) || (errno == EINTR)) {
             /* Try again later */
             return 0;
-        } else if(errno == ETIMEDOUT && (c->flags & REDIS_BLOCK)) {
+        } else if(errno == ETIMEDOUT && (c->flags & REDICT_BLOCK)) {
             /* especially in windows */
-            __redisSetError(c, REDIS_ERR_TIMEOUT, "recv timeout");
+            __redictSetError(c, REDICT_ERR_TIMEOUT, "recv timeout");
             return -1;
         } else {
-            __redisSetError(c, REDIS_ERR_IO, strerror(errno));
+            __redictSetError(c, REDICT_ERR_IO, strerror(errno));
             return -1;
         }
     } else if (nread == 0) {
-        __redisSetError(c, REDIS_ERR_EOF, "Server closed the connection");
+        __redictSetError(c, REDICT_ERR_EOF, "Server closed the connection");
         return -1;
     } else {
         return nread;
     }
 }
 
-ssize_t redisNetWrite(redisContext *c) {
+ssize_t redictNetWrite(redictContext *c) {
     ssize_t nwritten;
 
     nwritten = send(c->fd, c->obuf, sdslen(c->obuf), 0);
     if (nwritten < 0) {
-        if ((errno == EWOULDBLOCK && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {
+        if ((errno == EWOULDBLOCK && !(c->flags & REDICT_BLOCK)) || (errno == EINTR)) {
             /* Try again */
             return 0;
         } else {
-            __redisSetError(c, REDIS_ERR_IO, strerror(errno));
+            __redictSetError(c, REDICT_ERR_IO, strerror(errno));
             return -1;
         }
     }
@@ -83,7 +83,7 @@ ssize_t redisNetWrite(redisContext *c) {
     return nwritten;
 }
 
-static void __redisSetErrorFromErrno(redisContext *c, int type, const char *prefix) {
+static void __redictSetErrorFromErrno(redictContext *c, int type, const char *prefix) {
     int errorno = errno;  /* snprintf() may change errno */
     char buf[128] = { 0 };
     size_t len = 0;
@@ -91,35 +91,35 @@ static void __redisSetErrorFromErrno(redisContext *c, int type, const char *pref
     if (prefix != NULL)
         len = snprintf(buf,sizeof(buf),"%s: ",prefix);
     strerror_r(errorno, (char *)(buf + len), sizeof(buf) - len);
-    __redisSetError(c,type,buf);
+    __redictSetError(c,type,buf);
 }
 
-static int redisSetReuseAddr(redisContext *c) {
+static int redictSetReuseAddr(redictContext *c) {
     int on = 1;
     if (setsockopt(c->fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
-        redisNetClose(c);
-        return REDIS_ERR;
+        __redictSetErrorFromErrno(c,REDICT_ERR_IO,NULL);
+        redictNetClose(c);
+        return REDICT_ERR;
     }
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-static int redisCreateSocket(redisContext *c, int type) {
-    redisFD s;
-    if ((s = socket(type, SOCK_STREAM, 0)) == REDIS_INVALID_FD) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
-        return REDIS_ERR;
+static int redictCreateSocket(redictContext *c, int type) {
+    redictFD s;
+    if ((s = socket(type, SOCK_STREAM, 0)) == REDICT_INVALID_FD) {
+        __redictSetErrorFromErrno(c,REDICT_ERR_IO,NULL);
+        return REDICT_ERR;
     }
     c->fd = s;
     if (type == AF_INET) {
-        if (redisSetReuseAddr(c) == REDIS_ERR) {
-            return REDIS_ERR;
+        if (redictSetReuseAddr(c) == REDICT_ERR) {
+            return REDICT_ERR;
         }
     }
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-static int redisSetBlocking(redisContext *c, int blocking) {
+static int redictSetBlocking(redictContext *c, int blocking) {
 #ifndef _WIN32
     int flags;
 
@@ -127,9 +127,9 @@ static int redisSetBlocking(redisContext *c, int blocking) {
      * Note that fcntl(2) for F_GETFL and F_SETFL can't be
      * interrupted by a signal. */
     if ((flags = fcntl(c->fd, F_GETFL)) == -1) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_GETFL)");
-        redisNetClose(c);
-        return REDIS_ERR;
+        __redictSetErrorFromErrno(c,REDICT_ERR_IO,"fcntl(F_GETFL)");
+        redictNetClose(c);
+        return REDICT_ERR;
     }
 
     if (blocking)
@@ -138,86 +138,86 @@ static int redisSetBlocking(redisContext *c, int blocking) {
         flags |= O_NONBLOCK;
 
     if (fcntl(c->fd, F_SETFL, flags) == -1) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_SETFL)");
-        redisNetClose(c);
-        return REDIS_ERR;
+        __redictSetErrorFromErrno(c,REDICT_ERR_IO,"fcntl(F_SETFL)");
+        redictNetClose(c);
+        return REDICT_ERR;
     }
 #else
     u_long mode = blocking ? 0 : 1;
     if (ioctl(c->fd, FIONBIO, &mode) == -1) {
-        __redisSetErrorFromErrno(c, REDIS_ERR_IO, "ioctl(FIONBIO)");
-        redisNetClose(c);
-        return REDIS_ERR;
+        __redictSetErrorFromErrno(c, REDICT_ERR_IO, "ioctl(FIONBIO)");
+        redictNetClose(c);
+        return REDICT_ERR;
     }
 #endif /* _WIN32 */
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-int redisKeepAlive(redisContext *c, int interval) {
+int redictKeepAlive(redictContext *c, int interval) {
     int val = 1;
-    redisFD fd = c->fd;
+    redictFD fd = c->fd;
 
     /* TCP_KEEPALIVE makes no sense with AF_UNIX connections */
-    if (c->connection_type == REDIS_CONN_UNIX)
-        return REDIS_ERR;
+    if (c->connection_type == REDICT_CONN_UNIX)
+        return REDICT_ERR;
 
 #ifndef _WIN32
     if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val)) == -1){
-        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
-        return REDIS_ERR;
+        __redictSetError(c,REDICT_ERR_OTHER,strerror(errno));
+        return REDICT_ERR;
     }
 
     val = interval;
 
 #if defined(__APPLE__) && defined(__MACH__)
     if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &val, sizeof(val)) < 0) {
-        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
-        return REDIS_ERR;
+        __redictSetError(c,REDICT_ERR_OTHER,strerror(errno));
+        return REDICT_ERR;
     }
 #else
 #if defined(__GLIBC__) && !defined(__FreeBSD_kernel__)
     if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &val, sizeof(val)) < 0) {
-        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
-        return REDIS_ERR;
+        __redictSetError(c,REDICT_ERR_OTHER,strerror(errno));
+        return REDICT_ERR;
     }
 
     val = interval/3;
     if (val == 0) val = 1;
     if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &val, sizeof(val)) < 0) {
-        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
-        return REDIS_ERR;
+        __redictSetError(c,REDICT_ERR_OTHER,strerror(errno));
+        return REDICT_ERR;
     }
 
     val = 3;
     if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &val, sizeof(val)) < 0) {
-        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
-        return REDIS_ERR;
+        __redictSetError(c,REDICT_ERR_OTHER,strerror(errno));
+        return REDICT_ERR;
     }
 #endif
 #endif
 #else
     int res;
 
-    res = win32_redisKeepAlive(fd, interval * 1000);
+    res = win32_redictKeepAlive(fd, interval * 1000);
     if (res != 0) {
-        __redisSetError(c, REDIS_ERR_OTHER, strerror(res));
-        return REDIS_ERR;
+        __redictSetError(c, REDICT_ERR_OTHER, strerror(res));
+        return REDICT_ERR;
     }
 #endif
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-int redisSetTcpNoDelay(redisContext *c) {
+int redictSetTcpNoDelay(redictContext *c) {
     int yes = 1;
     if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(TCP_NODELAY)");
-        redisNetClose(c);
-        return REDIS_ERR;
+        __redictSetErrorFromErrno(c,REDICT_ERR_IO,"setsockopt(TCP_NODELAY)");
+        redictNetClose(c);
+        return REDICT_ERR;
     }
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-int redisContextSetTcpUserTimeout(redisContext *c, unsigned int timeout) {
+int redictContextSetTcpUserTimeout(redictContext *c, unsigned int timeout) {
     int res;
 #ifdef TCP_USER_TIMEOUT
     res = setsockopt(c->fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &timeout, sizeof(timeout));
@@ -227,16 +227,16 @@ int redisContextSetTcpUserTimeout(redisContext *c, unsigned int timeout) {
     (void)timeout;
 #endif
     if (res == -1) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(TCP_USER_TIMEOUT)");
-        redisNetClose(c);
-        return REDIS_ERR;
+        __redictSetErrorFromErrno(c,REDICT_ERR_IO,"setsockopt(TCP_USER_TIMEOUT)");
+        redictNetClose(c);
+        return REDICT_ERR;
     }
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
 #define __MAX_MSEC (((LONG_MAX) - 999) / 1000)
 
-static int redisContextTimeoutMsec(redisContext *c, long *result)
+static int redictContextTimeoutMsec(redictContext *c, long *result)
 {
     const struct timeval *timeout = c->connect_timeout;
     long msec = -1;
@@ -244,9 +244,9 @@ static int redisContextTimeoutMsec(redisContext *c, long *result)
     /* Only use timeout when not NULL. */
     if (timeout != NULL) {
         if (timeout->tv_usec > 1000000 || timeout->tv_sec > __MAX_MSEC) {
-            __redisSetError(c, REDIS_ERR_IO, "Invalid timeout specified");
+            __redictSetError(c, REDICT_ERR_IO, "Invalid timeout specified");
             *result = msec;
-            return REDIS_ERR;
+            return REDICT_ERR;
         }
 
         msec = (timeout->tv_sec * 1000) + ((timeout->tv_usec + 999) / 1000);
@@ -257,10 +257,10 @@ static int redisContextTimeoutMsec(redisContext *c, long *result)
     }
 
     *result = msec;
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-static long redisPollMillis(void) {
+static long redictPollMillis(void) {
 #ifndef _MSC_VER
     struct timespec now;
     clock_gettime(CLOCK_MONOTONIC, &now);
@@ -272,49 +272,49 @@ static long redisPollMillis(void) {
 #endif
 }
 
-static int redisContextWaitReady(redisContext *c, long msec) {
+static int redictContextWaitReady(redictContext *c, long msec) {
     struct pollfd wfd;
     long end;
     int res;
 
     if (errno != EINPROGRESS) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
-        redisNetClose(c);
-        return REDIS_ERR;
+        __redictSetErrorFromErrno(c,REDICT_ERR_IO,NULL);
+        redictNetClose(c);
+        return REDICT_ERR;
     }
 
     wfd.fd = c->fd;
     wfd.events = POLLOUT;
-    end = msec >= 0 ? redisPollMillis() + msec : 0;
+    end = msec >= 0 ? redictPollMillis() + msec : 0;
 
     while ((res = poll(&wfd, 1, msec)) <= 0) {
         if (res < 0 && errno != EINTR) {
-            __redisSetErrorFromErrno(c, REDIS_ERR_IO, "poll(2)");
-            redisNetClose(c);
-            return REDIS_ERR;
-        } else if (res == 0 || (msec >= 0 && redisPollMillis() >= end)) {
+            __redictSetErrorFromErrno(c, REDICT_ERR_IO, "poll(2)");
+            redictNetClose(c);
+            return REDICT_ERR;
+        } else if (res == 0 || (msec >= 0 && redictPollMillis() >= end)) {
             errno = ETIMEDOUT;
-            __redisSetErrorFromErrno(c, REDIS_ERR_IO, NULL);
-            redisNetClose(c);
-            return REDIS_ERR;
+            __redictSetErrorFromErrno(c, REDICT_ERR_IO, NULL);
+            redictNetClose(c);
+            return REDICT_ERR;
         } else {
             /* res < 0 && errno == EINTR, try again */
         }
     }
 
-    if (redisCheckConnectDone(c, &res) != REDIS_OK || res == 0) {
-        redisCheckSocketError(c);
-        return REDIS_ERR;
+    if (redictCheckConnectDone(c, &res) != REDICT_OK || res == 0) {
+        redictCheckSocketError(c);
+        return REDICT_ERR;
     }
 
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-int redisCheckConnectDone(redisContext *c, int *completed) {
+int redictCheckConnectDone(redictContext *c, int *completed) {
     int rc = connect(c->fd, (const struct sockaddr *)c->saddr, c->addrlen);
     if (rc == 0) {
         *completed = 1;
-        return REDIS_OK;
+        return REDICT_OK;
     }
     int error = errno;
     if (error == EINPROGRESS) {
@@ -326,7 +326,7 @@ int redisCheckConnectDone(redisContext *c, int *completed) {
             if (so_error == 0) {
                 /* Socket is connected! */
                 *completed = 1;
-                return REDIS_OK;
+                return REDICT_OK;
             }
             /* connection error; */
             errno = so_error;
@@ -336,23 +336,23 @@ int redisCheckConnectDone(redisContext *c, int *completed) {
     switch (error) {
     case EISCONN:
         *completed = 1;
-        return REDIS_OK;
+        return REDICT_OK;
     case EALREADY:
     case EWOULDBLOCK:
         *completed = 0;
-        return REDIS_OK;
+        return REDICT_OK;
     default:
-        return REDIS_ERR;
+        return REDICT_ERR;
     }
 }
 
-int redisCheckSocketError(redisContext *c) {
+int redictCheckSocketError(redictContext *c) {
     int err = 0, errno_saved = errno;
     socklen_t errlen = sizeof(err);
 
     if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"getsockopt(SO_ERROR)");
-        return REDIS_ERR;
+        __redictSetErrorFromErrno(c,REDICT_ERR_IO,"getsockopt(SO_ERROR)");
+        return REDICT_ERR;
     }
 
     if (err == 0) {
@@ -361,78 +361,78 @@ int redisCheckSocketError(redisContext *c) {
 
     if (err) {
         errno = err;
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
-        return REDIS_ERR;
+        __redictSetErrorFromErrno(c,REDICT_ERR_IO,NULL);
+        return REDICT_ERR;
     }
 
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-int redisContextSetTimeout(redisContext *c, const struct timeval tv) {
+int redictContextSetTimeout(redictContext *c, const struct timeval tv) {
     const void *to_ptr = &tv;
     size_t to_sz = sizeof(tv);
 
-    if (redisContextUpdateCommandTimeout(c, &tv) != REDIS_OK) {
-        __redisSetError(c, REDIS_ERR_OOM, "Out of memory");
-        return REDIS_ERR;
+    if (redictContextUpdateCommandTimeout(c, &tv) != REDICT_OK) {
+        __redictSetError(c, REDICT_ERR_OOM, "Out of memory");
+        return REDICT_ERR;
     }
     if (setsockopt(c->fd,SOL_SOCKET,SO_RCVTIMEO,to_ptr,to_sz) == -1) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(SO_RCVTIMEO)");
-        return REDIS_ERR;
+        __redictSetErrorFromErrno(c,REDICT_ERR_IO,"setsockopt(SO_RCVTIMEO)");
+        return REDICT_ERR;
     }
     if (setsockopt(c->fd,SOL_SOCKET,SO_SNDTIMEO,to_ptr,to_sz) == -1) {
-        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(SO_SNDTIMEO)");
-        return REDIS_ERR;
+        __redictSetErrorFromErrno(c,REDICT_ERR_IO,"setsockopt(SO_SNDTIMEO)");
+        return REDICT_ERR;
     }
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-int redisContextUpdateConnectTimeout(redisContext *c, const struct timeval *timeout) {
+int redictContextUpdateConnectTimeout(redictContext *c, const struct timeval *timeout) {
     /* Same timeval struct, short circuit */
     if (c->connect_timeout == timeout)
-        return REDIS_OK;
+        return REDICT_OK;
 
     /* Allocate context timeval if we need to */
     if (c->connect_timeout == NULL) {
         c->connect_timeout = hi_malloc(sizeof(*c->connect_timeout));
         if (c->connect_timeout == NULL)
-            return REDIS_ERR;
+            return REDICT_ERR;
     }
 
     memcpy(c->connect_timeout, timeout, sizeof(*c->connect_timeout));
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-int redisContextUpdateCommandTimeout(redisContext *c, const struct timeval *timeout) {
+int redictContextUpdateCommandTimeout(redictContext *c, const struct timeval *timeout) {
     /* Same timeval struct, short circuit */
     if (c->command_timeout == timeout)
-        return REDIS_OK;
+        return REDICT_OK;
 
     /* Allocate context timeval if we need to */
     if (c->command_timeout == NULL) {
         c->command_timeout = hi_malloc(sizeof(*c->command_timeout));
         if (c->command_timeout == NULL)
-            return REDIS_ERR;
+            return REDICT_ERR;
     }
 
     memcpy(c->command_timeout, timeout, sizeof(*c->command_timeout));
-    return REDIS_OK;
+    return REDICT_OK;
 }
 
-static int _redisContextConnectTcp(redisContext *c, const char *addr, int port,
+static int _redictContextConnectTcp(redictContext *c, const char *addr, int port,
                                    const struct timeval *timeout,
                                    const char *source_addr) {
-    redisFD s;
+    redictFD s;
     int rv, n;
     char _port[6];  /* strlen("65535"); */
     struct addrinfo hints, *servinfo, *bservinfo, *p, *b;
-    int blocking = (c->flags & REDIS_BLOCK);
-    int reuseaddr = (c->flags & REDIS_REUSEADDR);
+    int blocking = (c->flags & REDICT_BLOCK);
+    int reuseaddr = (c->flags & REDICT_REUSEADDR);
     int reuses = 0;
     long timeout_msec = -1;
 
     servinfo = NULL;
-    c->connection_type = REDIS_CONN_TCP;
+    c->connection_type = REDICT_CONN_TCP;
     c->tcp.port = port;
 
     /* We need to take possession of the passed parameters
@@ -451,14 +451,14 @@ static int _redisContextConnectTcp(redisContext *c, const char *addr, int port,
     }
 
     if (timeout) {
-        if (redisContextUpdateConnectTimeout(c, timeout) == REDIS_ERR)
+        if (redictContextUpdateConnectTimeout(c, timeout) == REDICT_ERR)
             goto oom;
     } else {
         hi_free(c->connect_timeout);
         c->connect_timeout = NULL;
     }
 
-    if (redisContextTimeoutMsec(c, &timeout_msec) != REDIS_OK) {
+    if (redictContextTimeoutMsec(c, &timeout_msec) != REDICT_OK) {
         goto error;
     }
 
@@ -478,9 +478,9 @@ static int _redisContextConnectTcp(redisContext *c, const char *addr, int port,
     /* DNS lookup. To use dual stack, set both flags to prefer both IPv4 and
      * IPv6. By default, for historical reasons, we try IPv4 first and then we
      * try IPv6 only if no IPv4 address was found. */
-    if (c->flags & REDIS_PREFER_IPV6 && c->flags & REDIS_PREFER_IPV4)
+    if (c->flags & REDICT_PREFER_IPV6 && c->flags & REDICT_PREFER_IPV4)
         hints.ai_family = AF_UNSPEC;
-    else if (c->flags & REDIS_PREFER_IPV6)
+    else if (c->flags & REDICT_PREFER_IPV6)
         hints.ai_family = AF_INET6;
     else
         hints.ai_family = AF_INET;
@@ -492,16 +492,16 @@ static int _redisContextConnectTcp(redisContext *c, const char *addr, int port,
         rv = getaddrinfo(c->tcp.host, _port, &hints, &servinfo);
     }
     if (rv != 0) {
-        __redisSetError(c, REDIS_ERR_OTHER, gai_strerror(rv));
-        return REDIS_ERR;
+        __redictSetError(c, REDICT_ERR_OTHER, gai_strerror(rv));
+        return REDICT_ERR;
     }
     for (p = servinfo; p != NULL; p = p->ai_next) {
 addrretry:
-        if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == REDIS_INVALID_FD)
+        if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == REDICT_INVALID_FD)
             continue;
 
         c->fd = s;
-        if (redisSetBlocking(c,0) != REDIS_OK)
+        if (redictSetBlocking(c,0) != REDICT_OK)
             goto error;
         if (c->tcp.source_addr) {
             int bound = 0;
@@ -509,7 +509,7 @@ addrretry:
             if ((rv = getaddrinfo(c->tcp.source_addr, NULL, &hints, &bservinfo)) != 0) {
                 char buf[128];
                 snprintf(buf,sizeof(buf),"Can't get addr: %s",gai_strerror(rv));
-                __redisSetError(c,REDIS_ERR_OTHER,buf);
+                __redictSetError(c,REDICT_ERR_OTHER,buf);
                 goto error;
             }
 
@@ -532,7 +532,7 @@ addrretry:
             if (!bound) {
                 char buf[128];
                 snprintf(buf,sizeof(buf),"Can't bind socket: %s",strerror(errno));
-                __redisSetError(c,REDIS_ERR_OTHER,buf);
+                __redictSetError(c,REDICT_ERR_OTHER,buf);
                 goto error;
             }
         }
@@ -548,7 +548,7 @@ addrretry:
 
         if (connect(s,p->ai_addr,p->ai_addrlen) == -1) {
             if (errno == EHOSTUNREACH) {
-                redisNetClose(c);
+                redictNetClose(c);
                 continue;
             } else if (errno == EINPROGRESS) {
                 if (blocking) {
@@ -559,69 +559,69 @@ addrretry:
                  * for `connect()`
                  */
             } else if (errno == EADDRNOTAVAIL && reuseaddr) {
-                if (++reuses >= REDIS_CONNECT_RETRIES) {
+                if (++reuses >= REDICT_CONNECT_RETRIES) {
                     goto error;
                 } else {
-                    redisNetClose(c);
+                    redictNetClose(c);
                     goto addrretry;
                 }
             } else {
                 wait_for_ready:
-                if (redisContextWaitReady(c,timeout_msec) != REDIS_OK)
+                if (redictContextWaitReady(c,timeout_msec) != REDICT_OK)
                     goto error;
-                if (redisSetTcpNoDelay(c) != REDIS_OK)
+                if (redictSetTcpNoDelay(c) != REDICT_OK)
                     goto error;
             }
         }
-        if (blocking && redisSetBlocking(c,1) != REDIS_OK)
+        if (blocking && redictSetBlocking(c,1) != REDICT_OK)
             goto error;
 
-        c->flags |= REDIS_CONNECTED;
-        rv = REDIS_OK;
+        c->flags |= REDICT_CONNECTED;
+        rv = REDICT_OK;
         goto end;
     }
     if (p == NULL) {
         char buf[128];
         snprintf(buf,sizeof(buf),"Can't create socket: %s",strerror(errno));
-        __redisSetError(c,REDIS_ERR_OTHER,buf);
+        __redictSetError(c,REDICT_ERR_OTHER,buf);
         goto error;
     }
 
 oom:
-    __redisSetError(c, REDIS_ERR_OOM, "Out of memory");
+    __redictSetError(c, REDICT_ERR_OOM, "Out of memory");
 error:
-    rv = REDIS_ERR;
+    rv = REDICT_ERR;
 end:
     if(servinfo) {
         freeaddrinfo(servinfo);
     }
 
-    return rv;  // Need to return REDIS_OK if alright
+    return rv;  // Need to return REDICT_OK if alright
 }
 
-int redisContextConnectTcp(redisContext *c, const char *addr, int port,
+int redictContextConnectTcp(redictContext *c, const char *addr, int port,
                            const struct timeval *timeout) {
-    return _redisContextConnectTcp(c, addr, port, timeout, NULL);
+    return _redictContextConnectTcp(c, addr, port, timeout, NULL);
 }
 
-int redisContextConnectBindTcp(redisContext *c, const char *addr, int port,
+int redictContextConnectBindTcp(redictContext *c, const char *addr, int port,
                                const struct timeval *timeout,
                                const char *source_addr) {
-    return _redisContextConnectTcp(c, addr, port, timeout, source_addr);
+    return _redictContextConnectTcp(c, addr, port, timeout, source_addr);
 }
 
-int redisContextConnectUnix(redisContext *c, const char *path, const struct timeval *timeout) {
+int redictContextConnectUnix(redictContext *c, const char *path, const struct timeval *timeout) {
 #ifndef _WIN32
-    int blocking = (c->flags & REDIS_BLOCK);
+    int blocking = (c->flags & REDICT_BLOCK);
     struct sockaddr_un *sa;
     long timeout_msec = -1;
 
-    if (redisCreateSocket(c,AF_UNIX) < 0)
-        return REDIS_ERR;
-    if (redisSetBlocking(c,0) != REDIS_OK)
-        return REDIS_ERR;
+    if (redictCreateSocket(c,AF_UNIX) < 0)
+        return REDICT_ERR;
+    if (redictSetBlocking(c,0) != REDICT_OK)
+        return REDICT_ERR;
 
-    c->connection_type = REDIS_CONN_UNIX;
+    c->connection_type = REDICT_CONN_UNIX;
     if (c->unix_sock.path != path) {
         hi_free(c->unix_sock.path);
 
@@ -631,15 +631,15 @@ int redisContextConnectUnix(redisContext *c, const char *path, const struct time
     }
 
     if (timeout) {
-        if (redisContextUpdateConnectTimeout(c, timeout) == REDIS_ERR)
+        if (redictContextUpdateConnectTimeout(c, timeout) == REDICT_ERR)
             goto oom;
     } else {
         hi_free(c->connect_timeout);
         c->connect_timeout = NULL;
     }
 
-    if (redisContextTimeoutMsec(c,&timeout_msec) != REDIS_OK)
-        return REDIS_ERR;
+    if (redictContextTimeoutMsec(c,&timeout_msec) != REDICT_OK)
+        return REDICT_ERR;
 
     /* Don't leak sockaddr if we're reconnecting */
     if (c->saddr) hi_free(c->saddr);
@@ -655,24 +655,24 @@ int redisContextConnectUnix(redisContext *c, const char *path, const struct time
         if (errno == EINPROGRESS && !blocking) {
             /* This is ok. */
         } else {
-            if (redisContextWaitReady(c,timeout_msec) != REDIS_OK)
-                return REDIS_ERR;
+            if (redictContextWaitReady(c,timeout_msec) != REDICT_OK)
+                return REDICT_ERR;
         }
     }
 
     /* Reset socket to be blocking after connect(2). */
-    if (blocking && redisSetBlocking(c,1) != REDIS_OK)
-        return REDIS_ERR;
+    if (blocking && redictSetBlocking(c,1) != REDICT_OK)
+        return REDICT_ERR;
 
-    c->flags |= REDIS_CONNECTED;
-    return REDIS_OK;
+    c->flags |= REDICT_CONNECTED;
+    return REDICT_OK;
 #else
     /* We currently do not support Unix sockets for Windows. */
     /* TODO(m): https://devblogs.microsoft.com/commandline/af_unix-comes-to-windows/ */
     errno = EPROTONOSUPPORT;
-    return REDIS_ERR;
+    return REDICT_ERR;
 #endif /* _WIN32 */
 oom:
-    __redisSetError(c, REDIS_ERR_OOM, "Out of memory");
-    return REDIS_ERR;
+    __redictSetError(c, REDICT_ERR_OOM, "Out of memory");
+    return REDICT_ERR;
 }