diff options
Diffstat (limited to 'hiredict.c')
| -rw-r--r-- | hiredict.c | 590 |
1 files changed, 295 insertions, 295 deletions
@@ -28,29 +28,29 @@ #include "async.h" #include "win32.h" -extern int redisContextUpdateConnectTimeout(redisContext *c, const struct timeval *timeout); -extern int redisContextUpdateCommandTimeout(redisContext *c, const struct timeval *timeout); +extern int redictContextUpdateConnectTimeout(redictContext *c, const struct timeval *timeout); +extern int redictContextUpdateCommandTimeout(redictContext *c, const struct timeval *timeout); -static redisContextFuncs redisContextDefaultFuncs = { - .close = redisNetClose, +static redictContextFuncs redictContextDefaultFuncs = { + .close = redictNetClose, .free_privctx = NULL, - .async_read = redisAsyncRead, - .async_write = redisAsyncWrite, - .read = redisNetRead, - .write = redisNetWrite + .async_read = redictAsyncRead, + .async_write = redictAsyncWrite, + .read = redictNetRead, + .write = redictNetWrite }; -static redisReply *createReplyObject(int type); -static void *createStringObject(const redisReadTask *task, char *str, size_t len); -static void *createArrayObject(const redisReadTask *task, size_t elements); -static void *createIntegerObject(const redisReadTask *task, long long value); -static void *createDoubleObject(const redisReadTask *task, double value, char *str, size_t len); -static void *createNilObject(const redisReadTask *task); -static void *createBoolObject(const redisReadTask *task, int bval); +static redictReply *createReplyObject(int type); +static void *createStringObject(const redictReadTask *task, char *str, size_t len); +static void *createArrayObject(const redictReadTask *task, size_t elements); +static void *createIntegerObject(const redictReadTask *task, long long value); +static void *createDoubleObject(const redictReadTask *task, double value, char *str, size_t len); +static void *createNilObject(const redictReadTask *task); +static void *createBoolObject(const redictReadTask *task, int bval); /* Default set of functions to build the reply. Keep in mind that such a * function returning NULL is interpreted as OOM. */ -static redisReplyObjectFunctions defaultFunctions = { +static redictReplyObjectFunctions defaultFunctions = { createStringObject, createArrayObject, createIntegerObject, @@ -61,8 +61,8 @@ static redisReplyObjectFunctions defaultFunctions = { }; /* Create a reply object */ -static redisReply *createReplyObject(int type) { - redisReply *r = hi_calloc(1,sizeof(*r)); +static redictReply *createReplyObject(int type) { + redictReply *r = hi_calloc(1,sizeof(*r)); if (r == NULL) return NULL; @@ -73,56 +73,56 @@ static redisReply *createReplyObject(int type) { /* Free a reply object */ void freeReplyObject(void *reply) { - redisReply *r = reply; + redictReply *r = reply; size_t j; if (r == NULL) return; switch(r->type) { - case REDIS_REPLY_INTEGER: - case REDIS_REPLY_NIL: - case REDIS_REPLY_BOOL: + case REDICT_REPLY_INTEGER: + case REDICT_REPLY_NIL: + case REDICT_REPLY_BOOL: break; /* Nothing to free */ - case REDIS_REPLY_ARRAY: - case REDIS_REPLY_MAP: - case REDIS_REPLY_ATTR: - case REDIS_REPLY_SET: - case REDIS_REPLY_PUSH: + case REDICT_REPLY_ARRAY: + case REDICT_REPLY_MAP: + case REDICT_REPLY_ATTR: + case REDICT_REPLY_SET: + case REDICT_REPLY_PUSH: if (r->element != NULL) { for (j = 0; j < r->elements; j++) freeReplyObject(r->element[j]); hi_free(r->element); } break; - case REDIS_REPLY_ERROR: - case REDIS_REPLY_STATUS: - case REDIS_REPLY_STRING: - case REDIS_REPLY_DOUBLE: - case REDIS_REPLY_VERB: - case REDIS_REPLY_BIGNUM: + case REDICT_REPLY_ERROR: + case REDICT_REPLY_STATUS: + case REDICT_REPLY_STRING: + case REDICT_REPLY_DOUBLE: + case REDICT_REPLY_VERB: + case REDICT_REPLY_BIGNUM: hi_free(r->str); break; } hi_free(r); } -static void *createStringObject(const redisReadTask *task, char *str, size_t len) { - redisReply *r, *parent; +static void *createStringObject(const redictReadTask *task, char *str, size_t len) { + redictReply *r, *parent; char *buf; r = createReplyObject(task->type); if (r == NULL) return NULL; - assert(task->type == REDIS_REPLY_ERROR || - task->type == REDIS_REPLY_STATUS || - task->type == REDIS_REPLY_STRING || - task->type == REDIS_REPLY_VERB || - task->type == REDIS_REPLY_BIGNUM); + assert(task->type == REDICT_REPLY_ERROR || + task->type == REDICT_REPLY_STATUS || + task->type == REDICT_REPLY_STRING || + task->type == REDICT_REPLY_VERB || + task->type == REDICT_REPLY_BIGNUM); /* Copy string value */ - if (task->type == REDIS_REPLY_VERB) { + if (task->type == REDICT_REPLY_VERB) { buf = hi_malloc(len-4+1); /* Skip 4 bytes of verbatim type header. */ if (buf == NULL) goto oom; @@ -143,11 +143,11 @@ static void *createStringObject(const redisReadTask *task, char *str, size_t len if (task->parent) { parent = task->parent->obj; - assert(parent->type == REDIS_REPLY_ARRAY || - parent->type == REDIS_REPLY_MAP || - parent->type == REDIS_REPLY_ATTR || - parent->type == REDIS_REPLY_SET || - parent->type == REDIS_REPLY_PUSH); + assert(parent->type == REDICT_REPLY_ARRAY || + parent->type == REDICT_REPLY_MAP || + parent->type == REDICT_REPLY_ATTR || + parent->type == REDICT_REPLY_SET || + parent->type == REDICT_REPLY_PUSH); parent->element[task->idx] = r; } return r; @@ -157,15 +157,15 @@ oom: return NULL; } -static void *createArrayObject(const redisReadTask *task, size_t elements) { - redisReply *r, *parent; +static void *createArrayObject(const redictReadTask *task, size_t elements) { + redictReply *r, *parent; r = createReplyObject(task->type); if (r == NULL) return NULL; if (elements > 0) { - r->element = hi_calloc(elements,sizeof(redisReply*)); + r->element = hi_calloc(elements,sizeof(redictReply*)); if (r->element == NULL) { freeReplyObject(r); return NULL; @@ -176,20 +176,20 @@ static void *createArrayObject(const redisReadTask *task, size_t elements) { if (task->parent) { parent = task->parent->obj; - assert(parent->type == REDIS_REPLY_ARRAY || - parent->type == REDIS_REPLY_MAP || - parent->type == REDIS_REPLY_ATTR || - parent->type == REDIS_REPLY_SET || - parent->type == REDIS_REPLY_PUSH); + assert(parent->type == REDICT_REPLY_ARRAY || + parent->type == REDICT_REPLY_MAP || + parent->type == REDICT_REPLY_ATTR || + parent->type == REDICT_REPLY_SET || + parent->type == REDICT_REPLY_PUSH); parent->element[task->idx] = r; } return r; } -static void *createIntegerObject(const redisReadTask *task, long long value) { - redisReply *r, *parent; +static void *createIntegerObject(const redictReadTask *task, long long value) { + redictReply *r, *parent; - r = createReplyObject(REDIS_REPLY_INTEGER); + r = createReplyObject(REDICT_REPLY_INTEGER); if (r == NULL) return NULL; @@ -197,23 +197,23 @@ static void *createIntegerObject(const redisReadTask *task, long long value) { if (task->parent) { parent = task->parent->obj; - assert(parent->type == REDIS_REPLY_ARRAY || - parent->type == REDIS_REPLY_MAP || - parent->type == REDIS_REPLY_ATTR || - parent->type == REDIS_REPLY_SET || - parent->type == REDIS_REPLY_PUSH); + assert(parent->type == REDICT_REPLY_ARRAY || + parent->type == REDICT_REPLY_MAP || + parent->type == REDICT_REPLY_ATTR || + parent->type == REDICT_REPLY_SET || + parent->type == REDICT_REPLY_PUSH); parent->element[task->idx] = r; } return r; } -static void *createDoubleObject(const redisReadTask *task, double value, char *str, size_t len) { - redisReply *r, *parent; +static void *createDoubleObject(const redictReadTask *task, double value, char *str, size_t len) { + redictReply *r, *parent; if (len == SIZE_MAX) // Prevents hi_malloc(0) if len equals to SIZE_MAX return NULL; - r = createReplyObject(REDIS_REPLY_DOUBLE); + r = createReplyObject(REDICT_REPLY_DOUBLE); if (r == NULL) return NULL; @@ -226,7 +226,7 @@ static void *createDoubleObject(const redisReadTask *task, double value, char *s /* The double reply also has the original protocol string representing a * double as a null terminated string. This way the caller does not need - * to format back for string conversion, especially since Redis does efforts + * to format back for string conversion, especially since Redict does efforts * to make the string more human readable avoiding the calssical double * decimal string conversion artifacts. */ memcpy(r->str, str, len); @@ -235,39 +235,39 @@ static void *createDoubleObject(const redisReadTask *task, double value, char *s if (task->parent) { parent = task->parent->obj; - assert(parent->type == REDIS_REPLY_ARRAY || - parent->type == REDIS_REPLY_MAP || - parent->type == REDIS_REPLY_ATTR || - parent->type == REDIS_REPLY_SET || - parent->type == REDIS_REPLY_PUSH); + assert(parent->type == REDICT_REPLY_ARRAY || + parent->type == REDICT_REPLY_MAP || + parent->type == REDICT_REPLY_ATTR || + parent->type == REDICT_REPLY_SET || + parent->type == REDICT_REPLY_PUSH); parent->element[task->idx] = r; } return r; } -static void *createNilObject(const redisReadTask *task) { - redisReply *r, *parent; +static void *createNilObject(const redictReadTask *task) { + redictReply *r, *parent; - r = createReplyObject(REDIS_REPLY_NIL); + r = createReplyObject(REDICT_REPLY_NIL); if (r == NULL) return NULL; if (task->parent) { parent = task->parent->obj; - assert(parent->type == REDIS_REPLY_ARRAY || - parent->type == REDIS_REPLY_MAP || - parent->type == REDIS_REPLY_ATTR || - parent->type == REDIS_REPLY_SET || - parent->type == REDIS_REPLY_PUSH); + assert(parent->type == REDICT_REPLY_ARRAY || + parent->type == REDICT_REPLY_MAP || + parent->type == REDICT_REPLY_ATTR || + parent->type == REDICT_REPLY_SET || + parent->type == REDICT_REPLY_PUSH); parent->element[task->idx] = r; } return r; } -static void *createBoolObject(const redisReadTask *task, int bval) { - redisReply *r, *parent; +static void *createBoolObject(const redictReadTask *task, int bval) { + redictReply *r, *parent; - r = createReplyObject(REDIS_REPLY_BOOL); + r = createReplyObject(REDICT_REPLY_BOOL); if (r == NULL) return NULL; @@ -275,18 +275,18 @@ static void *createBoolObject(const redisReadTask *task, int bval) { if (task->parent) { parent = task->parent->obj; - assert(parent->type == REDIS_REPLY_ARRAY || - parent->type == REDIS_REPLY_MAP || - parent->type == REDIS_REPLY_ATTR || - parent->type == REDIS_REPLY_SET || - parent->type == REDIS_REPLY_PUSH); + assert(parent->type == REDICT_REPLY_ARRAY || + parent->type == REDICT_REPLY_MAP || + parent->type == REDICT_REPLY_ATTR || + parent->type == REDICT_REPLY_SET || + parent->type == REDICT_REPLY_PUSH); parent->element[task->idx] = r; } return r; } /* Return the number of digits of 'v' when converted to string in radix 10. - * Implementation borrowed from link in redis/src/util.c:string2ll(). */ + * Implementation borrowed from link in redict/src/util.c:string2ll(). */ static uint32_t countDigits(uint64_t v) { uint32_t result = 1; for (;;) { @@ -304,7 +304,7 @@ static size_t bulklen(size_t len) { return 1+countDigits(len)+2+len+2; } -int redisvFormatCommand(char **target, const char *format, va_list ap) { +int redictvFormatCommand(char **target, const char *format, va_list ap) { const char *c = format; char *cmd = NULL; /* final command */ int pos; /* position in final command */ @@ -541,7 +541,7 @@ cleanup: return error_type; } -/* Format a command according to the Redis protocol. This function +/* Format a command according to the Redict protocol. This function * takes a format similar to printf: * * %s represents a C null terminated string you want to interpolate @@ -550,14 +550,14 @@ cleanup: * When using %b you need to provide both the pointer to the string * and the length in bytes as a size_t. Examples: * - * len = redisFormatCommand(target, "GET %s", mykey); - * len = redisFormatCommand(target, "SET %s %b", mykey, myval, myvallen); + * len = redictFormatCommand(target, "GET %s", mykey); + * len = redictFormatCommand(target, "SET %s %b", mykey, myval, myvallen); */ -int redisFormatCommand(char **target, const char *format, ...) { +int redictFormatCommand(char **target, const char *format, ...) { va_list ap; int len; va_start(ap,format); - len = redisvFormatCommand(target,format,ap); + len = redictvFormatCommand(target,format,ap); va_end(ap); /* The API says "-1" means bad result, but we now also return "-2" in some @@ -568,13 +568,13 @@ int redisFormatCommand(char **target, const char *format, ...) { return len; } -/* Format a command according to the Redis protocol using an sds string and +/* Format a command according to the Redict protocol using an sds string and * sdscatfmt for the processing of arguments. This function takes the * number of arguments, an array with arguments and an array with their * lengths. If the latter is set to NULL, strlen will be used to compute the * argument lengths. */ -long long redisFormatSdsCommandArgv(sds *target, int argc, const char **argv, +long long redictFormatSdsCommandArgv(sds *target, int argc, const char **argv, const size_t *argvlen) { sds cmd, aux; @@ -621,16 +621,16 @@ long long redisFormatSdsCommandArgv(sds *target, int argc, const char **argv, return totlen; } -void redisFreeSdsCommand(sds cmd) { +void redictFreeSdsCommand(sds cmd) { sdsfree(cmd); } -/* Format a command according to the Redis protocol. This function takes the +/* Format a command according to the Redict protocol. This function takes the * number of arguments, an array with arguments and an array with their * lengths. If the latter is set to NULL, strlen will be used to compute the * argument lengths. */ -long long redisFormatCommandArgv(char **target, int argc, const char **argv, const size_t *argvlen) { +long long redictFormatCommandArgv(char **target, int argc, const char **argv, const size_t *argvlen) { char *cmd = NULL; /* final command */ size_t pos; /* position in final command */ size_t len, totlen; @@ -668,11 +668,11 @@ long long redisFormatCommandArgv(char **target, int argc, const char **argv, con return totlen; } -void redisFreeCommand(char *cmd) { +void redictFreeCommand(char *cmd) { hi_free(cmd); } -void __redisSetError(redisContext *c, int type, const char *str) { +void __redictSetError(redictContext *c, int type, const char *str) { size_t len; c->err = type; @@ -682,43 +682,43 @@ void __redisSetError(redisContext *c, int type, const char *str) { memcpy(c->errstr,str,len); c->errstr[len] = '\0'; } else { - /* Only REDIS_ERR_IO may lack a description! */ - assert(type == REDIS_ERR_IO); + /* Only REDICT_ERR_IO may lack a description! */ + assert(type == REDICT_ERR_IO); strerror_r(errno, c->errstr, sizeof(c->errstr)); } } -redisReader *redisReaderCreate(void) { - return redisReaderCreateWithFunctions(&defaultFunctions); +redictReader *redictReaderCreate(void) { + return redictReaderCreateWithFunctions(&defaultFunctions); } -static void redisPushAutoFree(void *privdata, void *reply) { +static void redictPushAutoFree(void *privdata, void *reply) { (void)privdata; freeReplyObject(reply); } -static redisContext *redisContextInit(void) { - redisContext *c; +static redictContext *redictContextInit(void) { + redictContext *c; c = hi_calloc(1, sizeof(*c)); if (c == NULL) return NULL; - c->funcs = &redisContextDefaultFuncs; + c->funcs = &redictContextDefaultFuncs; c->obuf = sdsempty(); - c->reader = redisReaderCreate(); - c->fd = REDIS_INVALID_FD; + c->reader = redictReaderCreate(); + c->fd = REDICT_INVALID_FD; if (c->obuf == NULL || c->reader == NULL) { - redisFree(c); + redictFree(c); return NULL; } return c; } -void redisFree(redisContext *c) { +void redictFree(redictContext *c) { if (c == NULL) return; @@ -727,7 +727,7 @@ void redisFree(redisContext *c) { } sdsfree(c->obuf); - redisReaderFree(c->reader); + redictReaderFree(c->reader); hi_free(c->tcp.host); hi_free(c->tcp.source_addr); hi_free(c->unix_sock.path); @@ -745,14 +745,14 @@ void redisFree(redisContext *c) { hi_free(c); } -redisFD redisFreeKeepFd(redisContext *c) { - redisFD fd = c->fd; - c->fd = REDIS_INVALID_FD; - redisFree(c); +redictFD redictFreeKeepFd(redictContext *c) { + redictFD fd = c->fd; + c->fd = REDICT_INVALID_FD; + redictFree(c); return fd; } -int redisReconnect(redisContext *c) { +int redictReconnect(redictContext *c) { c->err = 0; memset(c->errstr, '\0', strlen(c->errstr)); @@ -766,192 +766,192 @@ int redisReconnect(redisContext *c) { } sdsfree(c->obuf); - redisReaderFree(c->reader); + redictReaderFree(c->reader); c->obuf = sdsempty(); - c->reader = redisReaderCreate(); + c->reader = redictReaderCreate(); if (c->obuf == NULL || c->reader == NULL) { - __redisSetError(c, REDIS_ERR_OOM, "Out of memory"); - return REDIS_ERR; + __redictSetError(c, REDICT_ERR_OOM, "Out of memory"); + return REDICT_ERR; } - int ret = REDIS_ERR; - if (c->connection_type == REDIS_CONN_TCP) { - ret = redisContextConnectBindTcp(c, c->tcp.host, c->tcp.port, + int ret = REDICT_ERR; + if (c->connection_type == REDICT_CONN_TCP) { + ret = redictContextConnectBindTcp(c, c->tcp.host, c->tcp.port, c->connect_timeout, c->tcp.source_addr); - } else if (c->connection_type == REDIS_CONN_UNIX) { - ret = redisContextConnectUnix(c, c->unix_sock.path, c->connect_timeout); + } else if (c->connection_type == REDICT_CONN_UNIX) { + ret = redictContextConnectUnix(c, c->unix_sock.path, c->connect_timeout); } else { /* Something bad happened here and shouldn't have. There isn't enough information in the context to reconnect. */ - __redisSetError(c,REDIS_ERR_OTHER,"Not enough information to reconnect"); - ret = REDIS_ERR; + __redictSetError(c,REDICT_ERR_OTHER,"Not enough information to reconnect"); + ret = REDICT_ERR; } - if (c->command_timeout != NULL && (c->flags & REDIS_BLOCK) && c->fd != REDIS_INVALID_FD) { - redisContextSetTimeout(c, *c->command_timeout); + if (c->command_timeout != NULL && (c->flags & REDICT_BLOCK) && c->fd != REDICT_INVALID_FD) { + redictContextSetTimeout(c, *c->command_timeout); } return ret; } -redisContext *redisConnectWithOptions(const redisOptions *options) { - redisContext *c = redisContextInit(); +redictContext *redictConnectWithOptions(const redictOptions *options) { + redictContext *c = redictContextInit(); if (c == NULL) { return NULL; } - if (!(options->options & REDIS_OPT_NONBLOCK)) { - c->flags |= REDIS_BLOCK; + if (!(options->options & REDICT_OPT_NONBLOCK)) { + c->flags |= REDICT_BLOCK; } - if (options->options & REDIS_OPT_REUSEADDR) { - c->flags |= REDIS_REUSEADDR; + if (options->options & REDICT_OPT_REUSEADDR) { + c->flags |= REDICT_REUSEADDR; } - if (options->options & REDIS_OPT_NOAUTOFREE) { - c->flags |= REDIS_NO_AUTO_FREE; + if (options->options & REDICT_OPT_NOAUTOFREE) { + c->flags |= REDICT_NO_AUTO_FREE; } - if (options->options & REDIS_OPT_NOAUTOFREEREPLIES) { - c->flags |= REDIS_NO_AUTO_FREE_REPLIES; + if (options->options & REDICT_OPT_NOAUTOFREEREPLIES) { + c->flags |= REDICT_NO_AUTO_FREE_REPLIES; } - if (options->options & REDIS_OPT_PREFER_IPV4) { - c->flags |= REDIS_PREFER_IPV4; + if (options->options & REDICT_OPT_PREFER_IPV4) { + c->flags |= REDICT_PREFER_IPV4; } - if (options->options & REDIS_OPT_PREFER_IPV6) { - c->flags |= REDIS_PREFER_IPV6; + if (options->options & REDICT_OPT_PREFER_IPV6) { + c->flags |= REDICT_PREFER_IPV6; } /* Set any user supplied RESP3 PUSH handler or use freeReplyObject * as a default unless specifically flagged that we don't want one. */ if (options->push_cb != NULL) - redisSetPushCallback(c, options->push_cb); - else if (!(options->options & REDIS_OPT_NO_PUSH_AUTOFREE)) - redisSetPushCallback(c, redisPushAutoFree); + redictSetPushCallback(c, options->push_cb); + else if (!(options->options & REDICT_OPT_NO_PUSH_AUTOFREE)) + redictSetPushCallback(c, redictPushAutoFree); c->privdata = options->privdata; c->free_privdata = options->free_privdata; - if (redisContextUpdateConnectTimeout(c, options->connect_timeout) != REDIS_OK || - redisContextUpdateCommandTimeout(c, options->command_timeout) != REDIS_OK) { - __redisSetError(c, REDIS_ERR_OOM, "Out of memory"); + if (redictContextUpdateConnectTimeout(c, options->connect_timeout) != REDICT_OK || + redictContextUpdateCommandTimeout(c, options->command_timeout) != REDICT_OK) { + __redictSetError(c, REDICT_ERR_OOM, "Out of memory"); return c; } - if (options->type == REDIS_CONN_TCP) { - redisContextConnectBindTcp(c, options->endpoint.tcp.ip, + if (options->type == REDICT_CONN_TCP) { + redictContextConnectBindTcp(c, options->endpoint.tcp.ip, options->endpoint.tcp.port, options->connect_timeout, options->endpoint.tcp.source_addr); - } else if (options->type == REDIS_CONN_UNIX) { - redisContextConnectUnix(c, options->endpoint.unix_socket, + } else if (options->type == REDICT_CONN_UNIX) { + redictContextConnectUnix(c, options->endpoint.unix_socket, options->connect_timeout); - } else if (options->type == REDIS_CONN_USERFD) { + } else if (options->type == REDICT_CONN_USERFD) { c->fd = options->endpoint.fd; - c->flags |= REDIS_CONNECTED; + c->flags |= REDICT_CONNECTED; } else { - redisFree(c); + redictFree(c); return NULL; } - if (c->err == 0 && c->fd != REDIS_INVALID_FD && - options->command_timeout != NULL && (c->flags & REDIS_BLOCK)) + if (c->err == 0 && c->fd != REDICT_INVALID_FD && + options->command_timeout != NULL && (c->flags & REDICT_BLOCK)) { - redisContextSetTimeout(c, *options->command_timeout); + redictContextSetTimeout(c, *options->command_timeout); } return c; } -/* Connect to a Redis instance. On error the field error in the returned +/* Connect to a Redict instance. On error the field error in the returned * context will be set to the return value of the error function. * When no set of reply functions is given, the default set will be used. */ -redisContext *redisConnect(const char *ip, int port) { - redisOptions options = {0}; - REDIS_OPTIONS_SET_TCP(&options, ip, port); - return redisConnectWithOptions(&options); +redictContext *redictConnect(const char *ip, int port) { + redictOptions options = {0}; + REDICT_OPTIONS_SET_TCP(&options, ip, port); + return redictConnectWithOptions(&options); } -redisContext *redisConnectWithTimeout(const char *ip, int port, const struct timeval tv) { - redisOptions options = {0}; - REDIS_OPTIONS_SET_TCP(&options, ip, port); +redictContext *redictConnectWithTimeout(const char *ip, int port, const struct timeval tv) { + redictOptions options = {0}; + REDICT_OPTIONS_SET_TCP(&options, ip, port); options.connect_timeout = &tv; - return redisConnectWithOptions(&options); + return redictConnectWithOptions(&options); } -redisContext *redisConnectNonBlock(const char *ip, int port) { - redisOptions options = {0}; - REDIS_OPTIONS_SET_TCP(&options, ip, port); - options.options |= REDIS_OPT_NONBLOCK; - return redisConnectWithOptions(&options); +redictContext *redictConnectNonBlock(const char *ip, int port) { + redictOptions options = {0}; + REDICT_OPTIONS_SET_TCP(&options, ip, port); + options.options |= REDICT_OPT_NONBLOCK; + return redictConnectWithOptions(&options); } -redisContext *redisConnectBindNonBlock(const char *ip, int port, +redictContext *redictConnectBindNonBlock(const char *ip, int port, const char *source_addr) { - redisOptions options = {0}; - REDIS_OPTIONS_SET_TCP(&options, ip, port); + redictOptions options = {0}; + REDICT_OPTIONS_SET_TCP(&options, ip, port); options.endpoint.tcp.source_addr = source_addr; - options.options |= REDIS_OPT_NONBLOCK; - return redisConnectWithOptions(&options); + options.options |= REDICT_OPT_NONBLOCK; + return redictConnectWithOptions(&options); } -redisContext *redisConnectBindNonBlockWithReuse(const char *ip, int port, +redictContext *redictConnectBindNonBlockWithReuse(const char *ip, int port, const char *source_addr) { - redisOptions options = {0}; - REDIS_OPTIONS_SET_TCP(&options, ip, port); + redictOptions options = {0}; + REDICT_OPTIONS_SET_TCP(&options, ip, port); options.endpoint.tcp.source_addr = source_addr; - options.options |= REDIS_OPT_NONBLOCK|REDIS_OPT_REUSEADDR; - return redisConnectWithOptions(&options); + options.options |= REDICT_OPT_NONBLOCK|REDICT_OPT_REUSEADDR; + return redictConnectWithOptions(&options); } -redisContext *redisConnectUnix(const char *path) { - redisOptions options = {0}; - REDIS_OPTIONS_SET_UNIX(&options, path); - return redisConnectWithOptions(&options); +redictContext *redictConnectUnix(const char *path) { + redictOptions options = {0}; + REDICT_OPTIONS_SET_UNIX(&options, path); + return redictConnectWithOptions(&options); } -redisContext *redisConnectUnixWithTimeout(const char *path, const struct timeval tv) { - redisOptions options = {0}; - REDIS_OPTIONS_SET_UNIX(&options, path); +redictContext *redictConnectUnixWithTimeout(const char *path, const struct timeval tv) { + redictOptions options = {0}; + REDICT_OPTIONS_SET_UNIX(&options, path); options.connect_timeout = &tv; - return redisConnectWithOptions(&options); + return redictConnectWithOptions(&options); } -redisContext *redisConnectUnixNonBlock(const char *path) { - redisOptions options = {0}; - REDIS_OPTIONS_SET_UNIX(&options, path); - options.options |= REDIS_OPT_NONBLOCK; - return redisConnectWithOptions(&options); +redictContext *redictConnectUnixNonBlock(const char *path) { + redictOptions options = {0}; + REDICT_OPTIONS_SET_UNIX(&options, path); + options.options |= REDICT_OPT_NONBLOCK; + return redictConnectWithOptions(&options); } -redisContext *redisConnectFd(redisFD fd) { - redisOptions options = {0}; - options.type = REDIS_CONN_USERFD; +redictContext *redictConnectFd(redictFD fd) { + redictOptions options = {0}; + options.type = REDICT_CONN_USERFD; options.endpoint.fd = fd; - return redisConnectWithOptions(&options); + return redictConnectWithOptions(&options); } /* Set read/write timeout on a blocking socket. */ -int redisSetTimeout(redisContext *c, const struct timeval tv) { - if (c->flags & REDIS_BLOCK) - return redisContextSetTimeout(c,tv); - return REDIS_ERR; +int redictSetTimeout(redictContext *c, const struct timeval tv) { + if (c->flags & REDICT_BLOCK) + return redictContextSetTimeout(c,tv); + return REDICT_ERR; } -int redisEnableKeepAliveWithInterval(redisContext *c, int interval) { - return redisKeepAlive(c, interval); +int redictEnableKeepAliveWithInterval(redictContext *c, int interval) { + return redictKeepAlive(c, interval); } /* Enable connection KeepAlive. */ -int redisEnableKeepAlive(redisContext *c) { - return redisKeepAlive(c, REDIS_KEEPALIVE_INTERVAL); +int redictEnableKeepAlive(redictContext *c) { + return redictKeepAlive(c, REDICT_KEEPALIVE_INTERVAL); } /* Set the socket option TCP_USER_TIMEOUT. */ -int redisSetTcpUserTimeout(redisContext *c, unsigned int timeout) { - return redisContextSetTcpUserTimeout(c, timeout); +int redictSetTcpUserTimeout(redictContext *c, unsigned int timeout) { + return redictContextSetTcpUserTimeout(c, timeout); } /* Set a user provided RESP3 PUSH handler and return any old one set. */ -redisPushFn *redisSetPushCallback(redisContext *c, redisPushFn *fn) { - redisPushFn *old = c->push_cb; +redictPushFn *redictSetPushCallback(redictContext *c, redictPushFn *fn) { + redictPushFn *old = c->push_cb; c->push_cb = fn; return old; } @@ -959,46 +959,46 @@ redisPushFn *redisSetPushCallback(redisContext *c, redisPushFn *fn) { /* Use this function to handle a read event on the descriptor. It will try * and read some bytes from the socket and feed them to the reply parser. * - * After this function is called, you may use redisGetReplyFromReader to + * After this function is called, you may use redictGetReplyFromReader to * see if there is a reply available. */ -int redisBufferRead(redisContext *c) { +int redictBufferRead(redictContext *c) { char buf[1024*16]; int nread; /* Return early when the context has seen an error. */ if (c->err) - return REDIS_ERR; + return REDICT_ERR; nread = c->funcs->read(c, buf, sizeof(buf)); if (nread < 0) { - return REDIS_ERR; + return REDICT_ERR; } - if (nread > 0 && redisReaderFeed(c->reader, buf, nread) != REDIS_OK) { - __redisSetError(c, c->reader->err, c->reader->errstr); - return REDIS_ERR; + if (nread > 0 && redictReaderFeed(c->reader, buf, nread) != REDICT_OK) { + __redictSetError(c, c->reader->err, c->reader->errstr); + return REDICT_ERR; } - return REDIS_OK; + return REDICT_OK; } /* Write the output buffer to the socket. * - * Returns REDIS_OK when the buffer is empty, or (a part of) the buffer was + * Returns REDICT_OK when the buffer is empty, or (a part of) the buffer was * successfully written to the socket. When the buffer is empty after the * write operation, "done" is set to 1 (if given). * - * Returns REDIS_ERR if an unrecoverable error occurred in the underlying + * Returns REDICT_ERR if an unrecoverable error occurred in the underlying * c->funcs->write function. */ -int redisBufferWrite(redisContext *c, int *done) { +int redictBufferWrite(redictContext *c, int *done) { /* Return early when the context has seen an error. */ if (c->err) - return REDIS_ERR; + return REDICT_ERR; if (sdslen(c->obuf) > 0) { ssize_t nwritten = c->funcs->write(c); if (nwritten < 0) { - return REDIS_ERR; + return REDICT_ERR; } else if (nwritten > 0) { if (nwritten == (ssize_t)sdslen(c->obuf)) { sdsfree(c->obuf); @@ -1011,17 +1011,17 @@ int redisBufferWrite(redisContext *c, int *done) { } } if (done != NULL) *done = (sdslen(c->obuf) == 0); - return REDIS_OK; + return REDICT_OK; oom: - __redisSetError(c, REDIS_ERR_OOM, "Out of memory"); - return REDIS_ERR; + __redictSetError(c, REDICT_ERR_OOM, "Out of memory"); + return REDICT_ERR; } /* Internal helper that returns 1 if the reply was a RESP3 PUSH * message and we handled it with a user-provided callback. */ -static int redisHandledPushReply(redisContext *c, void *reply) { - if (reply && c->push_cb && redisIsPushReply(reply)) { +static int redictHandledPushReply(redictContext *c, void *reply) { + if (reply && c->push_cb && redictIsPushReply(reply)) { c->push_cb(c->privdata, reply); return 1; } @@ -1030,50 +1030,50 @@ static int redisHandledPushReply(redisContext *c, void *reply) { } /* 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; +int redictGetReplyFromReader(redictContext *c, void **reply) { + if (redictReaderGetReply(c->reader, reply) == REDICT_ERR) { + __redictSetError(c,c->reader->err,c->reader->errstr); + return REDICT_ERR; } - return REDIS_OK; + return REDICT_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) { + * redictGetReplyFromReader so as to not change its behavior. */ +static int redictNextInBandReplyFromReader(redictContext *c, void **reply) { do { - if (redisGetReplyFromReader(c, reply) == REDIS_ERR) - return REDIS_ERR; - } while (redisHandledPushReply(c, *reply)); + if (redictGetReplyFromReader(c, reply) == REDICT_ERR) + return REDICT_ERR; + } while (redictHandledPushReply(c, *reply)); - return REDIS_OK; + return REDICT_OK; } -int redisGetReply(redisContext *c, void **reply) { +int redictGetReply(redictContext *c, void **reply) { int wdone = 0; void *aux = NULL; /* Try to read pending replies */ - if (redisNextInBandReplyFromReader(c,&aux) == REDIS_ERR) - return REDIS_ERR; + if (redictNextInBandReplyFromReader(c,&aux) == REDICT_ERR) + return REDICT_ERR; /* For the blocking context, flush output buffer and read reply */ - if (aux == NULL && c->flags & REDIS_BLOCK) { + if (aux == NULL && c->flags & REDICT_BLOCK) { /* Write until done */ do { - if (redisBufferWrite(c,&wdone) == REDIS_ERR) - return REDIS_ERR; + if (redictBufferWrite(c,&wdone) == REDICT_ERR) + return REDICT_ERR; } while (!wdone); /* Read until there is a reply */ do { - if (redisBufferRead(c) == REDIS_ERR) - return REDIS_ERR; + if (redictBufferRead(c) == REDICT_ERR) + return REDICT_ERR; - if (redisNextInBandReplyFromReader(c,&aux) == REDIS_ERR) - return REDIS_ERR; + if (redictNextInBandReplyFromReader(c,&aux) == REDICT_ERR) + return REDICT_ERR; } while (aux == NULL); } @@ -1084,90 +1084,90 @@ int redisGetReply(redisContext *c, void **reply) { freeReplyObject(aux); } - return REDIS_OK; + return REDICT_OK; } -/* Helper function for the redisAppendCommand* family of functions. +/* Helper function for the redictAppendCommand* family of functions. * * Write a formatted command to the output buffer. When this family - * is used, you need to call redisGetReply yourself to retrieve + * is used, you need to call redictGetReply yourself to retrieve * the reply (or replies in pub/sub). */ -int __redisAppendCommand(redisContext *c, const char *cmd, size_t len) { +int __redictAppendCommand(redictContext *c, const char *cmd, size_t len) { sds newbuf; newbuf = sdscatlen(c->obuf,cmd,len); if (newbuf == NULL) { - __redisSetError(c,REDIS_ERR_OOM,"Out of memory"); - return REDIS_ERR; + __redictSetError(c,REDICT_ERR_OOM,"Out of memory"); + return REDICT_ERR; } c->obuf = newbuf; - return REDIS_OK; + return REDICT_OK; } -int redisAppendFormattedCommand(redisContext *c, const char *cmd, size_t len) { +int redictAppendFormattedCommand(redictContext *c, const char *cmd, size_t len) { - if (__redisAppendCommand(c, cmd, len) != REDIS_OK) { - return REDIS_ERR; + if (__redictAppendCommand(c, cmd, len) != REDICT_OK) { + return REDICT_ERR; } - return REDIS_OK; + return REDICT_OK; } -int redisvAppendCommand(redisContext *c, const char *format, va_list ap) { +int redictvAppendCommand(redictContext *c, const char *format, va_list ap) { char *cmd; int len; - len = redisvFormatCommand(&cmd,format,ap); + len = redictvFormatCommand(&cmd,format,ap); if (len == -1) { - __redisSetError(c,REDIS_ERR_OOM,"Out of memory"); - return REDIS_ERR; + __redictSetError(c,REDICT_ERR_OOM,"Out of memory"); + return REDICT_ERR; } else if (len == -2) { - __redisSetError(c,REDIS_ERR_OTHER,"Invalid format string"); - return REDIS_ERR; + __redictSetError(c,REDICT_ERR_OTHER,"Invalid format string"); + return REDICT_ERR; } - if (__redisAppendCommand(c,cmd,len) != REDIS_OK) { + if (__redictAppendCommand(c,cmd,len) != REDICT_OK) { hi_free(cmd); - return REDIS_ERR; + return REDICT_ERR; } hi_free(cmd); - return REDIS_OK; + return REDICT_OK; } -int redisAppendCommand(redisContext *c, const char *format, ...) { +int redictAppendCommand(redictContext *c, const char *format, ...) { va_list ap; int ret; va_start(ap,format); - ret = redisvAppendCommand(c,format,ap); + ret = redictvAppendCommand(c,format,ap); va_end(ap); return ret; } -int redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen) { +int redictAppendCommandArgv(redictContext *c, int argc, const char **argv, const size_t *argvlen) { sds cmd; long long len; - len = redisFormatSdsCommandArgv(&cmd,argc,argv,argvlen); + len = redictFormatSdsCommandArgv(&cmd,argc,argv,argvlen); if (len == -1) { - __redisSetError(c,REDIS_ERR_OOM,"Out of memory"); - return REDIS_ERR; + __redictSetError(c,REDICT_ERR_OOM,"Out of memory"); + return REDICT_ERR; } - if (__redisAppendCommand(c,cmd,len) != REDIS_OK) { + if (__redictAppendCommand(c,cmd,len) != REDICT_OK) { sdsfree(cmd); - return REDIS_ERR; + return REDICT_ERR; } sdsfree(cmd); - return REDIS_OK; + return REDICT_OK; } -/* Helper function for the redisCommand* family of functions. +/* Helper function for the redictCommand* family of functions. * * Write a formatted command to the output buffer. If the given context is * blocking, immediately read the reply into the "reply" pointer. When the @@ -1178,33 +1178,33 @@ int redisAppendCommandArgv(redisContext *c, int argc, const char **argv, const s * otherwise. When NULL is returned in a blocking context, the error field * in the context will be set. */ -static void *__redisBlockForReply(redisContext *c) { +static void *__redictBlockForReply(redictContext *c) { void *reply; - if (c->flags & REDIS_BLOCK) { - if (redisGetReply(c,&reply) != REDIS_OK) + if (c->flags & REDICT_BLOCK) { + if (redictGetReply(c,&reply) != REDICT_OK) return NULL; return reply; } return NULL; } -void *redisvCommand(redisContext *c, const char *format, va_list ap) { - if (redisvAppendCommand(c,format,ap) != REDIS_OK) +void *redictvCommand(redictContext *c, const char *format, va_list ap) { + if (redictvAppendCommand(c,format,ap) != REDICT_OK) return NULL; - return __redisBlockForReply(c); + return __redictBlockForReply(c); } -void *redisCommand(redisContext *c, const char *format, ...) { +void *redictCommand(redictContext *c, const char *format, ...) { va_list ap; va_start(ap,format); - void *reply = redisvCommand(c,format,ap); + void *reply = redictvCommand(c,format,ap); va_end(ap); return reply; } -void *redisCommandArgv(redisContext *c, int argc, const char **argv, const size_t *argvlen) { - if (redisAppendCommandArgv(c,argc,argv,argvlen) != REDIS_OK) +void *redictCommandArgv(redictContext *c, int argc, const char **argv, const size_t *argvlen) { + if (redictAppendCommandArgv(c,argc,argv,argvlen) != REDICT_OK) return NULL; - return __redisBlockForReply(c); + return __redictBlockForReply(c); } |