From abdd0479f7aca18ea0abc34a1c6599980ddf8c26 Mon Sep 17 00:00:00 2001 From: michael-grunder Date: Sun, 26 May 2024 12:48:27 -0700 Subject: [PATCH] Fix ISO C naming violations. --- libvalkey/async.c | 148 +++++++++++++++++++------------------- libvalkey/async_private.h | 2 +- libvalkey/net.c | 70 +++++++++--------- libvalkey/read.c | 48 ++++++------- libvalkey/ssl.c | 26 +++---- libvalkey/valkey.c | 36 +++++----- 6 files changed, 165 insertions(+), 165 deletions(-) diff --git a/libvalkey/async.c b/libvalkey/async.c index 15b72587..3c8633bd 100644 --- a/libvalkey/async.c +++ b/libvalkey/async.c @@ -52,9 +52,9 @@ #define assert(e) (void)(e) #endif -/* Forward declarations of libvalkey.c functions */ -int __valkeyAppendCommand(valkeyContext *c, const char *cmd, size_t len); -void __valkeySetError(valkeyContext *c, int type, const char *str); +/* Forward declarations of valkey.c functions */ +int valkeyAppendCmdLen(valkeyContext *c, const char *cmd, size_t len); +void valkeySetError(valkeyContext *c, int type, const char *str); /* Functions managing dictionary of callbacks for pub/sub. */ static unsigned int callbackHash(const void *key) { @@ -160,7 +160,7 @@ static valkeyAsyncContext *valkeyAsyncInitialize(valkeyContext *c) { /* We want the error field to be accessible directly instead of requiring * an indirection to the valkeyContext struct. */ -static void __valkeyAsyncCopyError(valkeyAsyncContext *ac) { +static void valkeyAsyncCopyError(valkeyAsyncContext *ac) { if (!ac) return; @@ -194,7 +194,7 @@ valkeyAsyncContext *valkeyAsyncConnectWithOptions(const valkeyOptions *options) /* Set any configured async push handler */ valkeyAsyncSetPushCallback(ac, myOptions.async_push_cb); - __valkeyAsyncCopyError(ac); + valkeyAsyncCopyError(ac); return ac; } @@ -205,7 +205,7 @@ valkeyAsyncContext *valkeyAsyncConnect(const char *ip, int port) { } valkeyAsyncContext *valkeyAsyncConnectBind(const char *ip, int port, - const char *source_addr) { + const char *source_addr) { valkeyOptions options = {0}; VALKEY_OPTIONS_SET_TCP(&options, ip, port); options.endpoint.tcp.source_addr = source_addr; @@ -213,7 +213,7 @@ valkeyAsyncContext *valkeyAsyncConnectBind(const char *ip, int port, } valkeyAsyncContext *valkeyAsyncConnectBindWithReuse(const char *ip, int port, - const char *source_addr) { + const char *source_addr) { valkeyOptions options = {0}; VALKEY_OPTIONS_SET_TCP(&options, ip, port); options.options |= VALKEY_OPT_REUSEADDR; @@ -229,7 +229,7 @@ valkeyAsyncContext *valkeyAsyncConnectUnix(const char *path) { static int valkeyAsyncSetConnectCallbackImpl(valkeyAsyncContext *ac, valkeyConnectCallback *fn, - valkeyConnectCallbackNC *fn_nc) + valkeyConnectCallbackNC *fn_nc) { /* If either are already set, this is an error */ if (ac->onConnect || ac->onConnectNC) @@ -266,7 +266,7 @@ int valkeyAsyncSetDisconnectCallback(valkeyAsyncContext *ac, valkeyDisconnectCal } /* Helper functions to push/shift callbacks */ -static int __valkeyPushCallback(valkeyCallbackList *list, valkeyCallback *source) { +static int valkeyPushCallback(valkeyCallbackList *list, valkeyCallback *source) { valkeyCallback *cb; /* Copy callback from stack to heap */ @@ -288,7 +288,7 @@ static int __valkeyPushCallback(valkeyCallbackList *list, valkeyCallback *source return VALKEY_OK; } -static int __valkeyShiftCallback(valkeyCallbackList *list, valkeyCallback *target) { +static int valkeyShiftCallback(valkeyCallbackList *list, valkeyCallback *target) { valkeyCallback *cb = list->head; if (cb != NULL) { list->head = cb->next; @@ -304,7 +304,7 @@ static int __valkeyShiftCallback(valkeyCallbackList *list, valkeyCallback *targe return VALKEY_ERR; } -static void __valkeyRunCallback(valkeyAsyncContext *ac, valkeyCallback *cb, valkeyReply *reply) { +static void valkeyRunCallback(valkeyAsyncContext *ac, valkeyCallback *cb, valkeyReply *reply) { valkeyContext *c = &(ac->c); if (cb->fn != NULL) { c->flags |= VALKEY_IN_CALLBACK; @@ -313,7 +313,7 @@ static void __valkeyRunCallback(valkeyAsyncContext *ac, valkeyCallback *cb, valk } } -static void __valkeyRunPushCallback(valkeyAsyncContext *ac, valkeyReply *reply) { +static void valkeyRunPushCallback(valkeyAsyncContext *ac, valkeyReply *reply) { if (ac->push_cb != NULL) { ac->c.flags |= VALKEY_IN_CALLBACK; ac->push_cb(ac, reply); @@ -321,7 +321,7 @@ static void __valkeyRunPushCallback(valkeyAsyncContext *ac, valkeyReply *reply) } } -static void __valkeyRunConnectCallback(valkeyAsyncContext *ac, int status) +static void valkeyRunConnectCallback(valkeyAsyncContext *ac, int status) { if (ac->onConnect == NULL && ac->onConnectNC == NULL) return; @@ -344,7 +344,7 @@ static void __valkeyRunConnectCallback(valkeyAsyncContext *ac, int status) } } -static void __valkeyRunDisconnectCallback(valkeyAsyncContext *ac, int status) +static void valkeyRunDisconnectCallback(valkeyAsyncContext *ac, int status) { if (ac->onDisconnect) { if (!(ac->c.flags & VALKEY_IN_CALLBACK)) { @@ -359,23 +359,23 @@ static void __valkeyRunDisconnectCallback(valkeyAsyncContext *ac, int status) } /* Helper function to free the context. */ -static void __valkeyAsyncFree(valkeyAsyncContext *ac) { +static void valkeyAsyncFreeInternal(valkeyAsyncContext *ac) { valkeyContext *c = &(ac->c); valkeyCallback cb; dictIterator it; dictEntry *de; /* Execute pending callbacks with NULL reply. */ - while (__valkeyShiftCallback(&ac->replies,&cb) == VALKEY_OK) - __valkeyRunCallback(ac,&cb,NULL); - while (__valkeyShiftCallback(&ac->sub.replies,&cb) == VALKEY_OK) - __valkeyRunCallback(ac,&cb,NULL); + while (valkeyShiftCallback(&ac->replies,&cb) == VALKEY_OK) + valkeyRunCallback(ac,&cb,NULL); + while (valkeyShiftCallback(&ac->sub.replies,&cb) == VALKEY_OK) + valkeyRunCallback(ac,&cb,NULL); /* Run subscription callbacks with NULL reply */ if (ac->sub.channels) { dictInitIterator(&it,ac->sub.channels); while ((de = dictNext(&it)) != NULL) - __valkeyRunCallback(ac,dictGetEntryVal(de),NULL); + valkeyRunCallback(ac,dictGetEntryVal(de),NULL); dictRelease(ac->sub.channels); } @@ -383,7 +383,7 @@ static void __valkeyAsyncFree(valkeyAsyncContext *ac) { if (ac->sub.patterns) { dictInitIterator(&it,ac->sub.patterns); while ((de = dictNext(&it)) != NULL) - __valkeyRunCallback(ac,dictGetEntryVal(de),NULL); + valkeyRunCallback(ac,dictGetEntryVal(de),NULL); dictRelease(ac->sub.patterns); } @@ -397,7 +397,7 @@ static void __valkeyAsyncFree(valkeyAsyncContext *ac) { int status = ac->err == 0 ? VALKEY_OK : VALKEY_ERR; if (c->flags & VALKEY_FREEING) status = VALKEY_OK; - __valkeyRunDisconnectCallback(ac, status); + valkeyRunDisconnectCallback(ac, status); } if (ac->dataCleanup) { @@ -420,19 +420,19 @@ void valkeyAsyncFree(valkeyAsyncContext *ac) { c->flags |= VALKEY_FREEING; if (!(c->flags & VALKEY_IN_CALLBACK)) - __valkeyAsyncFree(ac); + valkeyAsyncFreeInternal(ac); } /* Helper function to make the disconnect happen and clean up. */ -void __valkeyAsyncDisconnect(valkeyAsyncContext *ac) { +void valkeyAsyncDisconnectInternal(valkeyAsyncContext *ac) { valkeyContext *c = &(ac->c); /* Make sure error is accessible if there is any */ - __valkeyAsyncCopyError(ac); + valkeyAsyncCopyError(ac); if (ac->err == 0) { /* For clean disconnects, there should be no pending callbacks. */ - int ret = __valkeyShiftCallback(&ac->replies,NULL); + int ret = valkeyShiftCallback(&ac->replies,NULL); assert(ret == VALKEY_ERR); } else { /* Disconnection is caused by an error, make sure that pending @@ -444,10 +444,10 @@ void __valkeyAsyncDisconnect(valkeyAsyncContext *ac) { * this is safe to call multiple times */ _EL_CLEANUP(ac); - /* For non-clean disconnects, __valkeyAsyncFree() will execute pending + /* For non-clean disconnects, valkeyAsyncFreeInternal() will execute pending * callbacks with a NULL-reply. */ if (!(c->flags & VALKEY_NO_AUTO_FREE)) { - __valkeyAsyncFree(ac); + valkeyAsyncFreeInternal(ac); } } @@ -464,10 +464,10 @@ void valkeyAsyncDisconnect(valkeyAsyncContext *ac) { /** unset the auto-free flag here, because disconnect undoes this */ c->flags &= ~VALKEY_NO_AUTO_FREE; if (!(c->flags & VALKEY_IN_CALLBACK) && ac->replies.head == NULL) - __valkeyAsyncDisconnect(ac); + valkeyAsyncDisconnectInternal(ac); } -static int __valkeyGetSubscribeCallback(valkeyAsyncContext *ac, valkeyReply *reply, valkeyCallback *dstcb) { +static int valkeyGetSubscribeCallback(valkeyAsyncContext *ac, valkeyReply *reply, valkeyCallback *dstcb) { valkeyContext *c = &(ac->c); dict *callbacks; valkeyCallback *cb = NULL; @@ -526,20 +526,20 @@ static int __valkeyGetSubscribeCallback(valkeyAsyncContext *ac, valkeyReply *rep /* Move ongoing regular command callbacks. */ valkeyCallback cb; - while (__valkeyShiftCallback(&ac->sub.replies,&cb) == VALKEY_OK) { - __valkeyPushCallback(&ac->replies,&cb); + while (valkeyShiftCallback(&ac->sub.replies,&cb) == VALKEY_OK) { + valkeyPushCallback(&ac->replies,&cb); } } } sdsfree(sname); } else { /* Shift callback for pending command in subscribed context. */ - __valkeyShiftCallback(&ac->sub.replies,dstcb); + valkeyShiftCallback(&ac->sub.replies,dstcb); } return VALKEY_OK; oom: - __valkeySetError(&(ac->c), VALKEY_ERR_OOM, "Out of memory"); - __valkeyAsyncCopyError(ac); + valkeySetError(&(ac->c), VALKEY_ERR_OOM, "Out of memory"); + valkeyAsyncCopyError(ac); return VALKEY_ERR; } @@ -578,7 +578,7 @@ void valkeyProcessCallbacks(valkeyAsyncContext *ac) { * no more replies, this is the cue to really disconnect. */ if (c->flags & VALKEY_DISCONNECTING && sdslen(c->obuf) == 0 && ac->replies.head == NULL) { - __valkeyAsyncDisconnect(ac); + valkeyAsyncDisconnectInternal(ac); return; } /* When the connection is not being disconnected, simply stop @@ -594,7 +594,7 @@ void valkeyProcessCallbacks(valkeyAsyncContext *ac) { * This allows existing code to be backward compatible and work in * either RESP2 or RESP3 mode. */ if (valkeyIsSpontaneousPushReply(reply)) { - __valkeyRunPushCallback(ac, reply); + valkeyRunPushCallback(ac, reply); c->reader->fn->freeObject(reply); continue; } @@ -602,7 +602,7 @@ void valkeyProcessCallbacks(valkeyAsyncContext *ac) { /* Even if the context is subscribed, pending regular * callbacks will get a reply before pub/sub messages arrive. */ valkeyCallback cb = {NULL, NULL, 0, 0, NULL}; - if (__valkeyShiftCallback(&ac->replies,&cb) != VALKEY_OK) { + if (valkeyShiftCallback(&ac->replies,&cb) != VALKEY_OK) { /* * A spontaneous reply in a not-subscribed context can be the error * reply that is sent when a new connection exceeds the maximum @@ -622,24 +622,24 @@ void valkeyProcessCallbacks(valkeyAsyncContext *ac) { c->err = VALKEY_ERR_OTHER; snprintf(c->errstr,sizeof(c->errstr),"%s",((valkeyReply*)reply)->str); c->reader->fn->freeObject(reply); - __valkeyAsyncDisconnect(ac); + valkeyAsyncDisconnectInternal(ac); return; } /* No more regular callbacks and no errors, the context *must* be subscribed. */ assert(c->flags & VALKEY_SUBSCRIBED); if (c->flags & VALKEY_SUBSCRIBED) - __valkeyGetSubscribeCallback(ac,reply,&cb); + valkeyGetSubscribeCallback(ac,reply,&cb); } if (cb.fn != NULL) { - __valkeyRunCallback(ac,&cb,reply); + valkeyRunCallback(ac,&cb,reply); if (!(c->flags & VALKEY_NO_AUTO_FREE_REPLIES)){ c->reader->fn->freeObject(reply); } /* Proceed with free'ing when valkeyAsyncFree() was called. */ if (c->flags & VALKEY_FREEING) { - __valkeyAsyncFree(ac); + valkeyAsyncFreeInternal(ac); return; } } else { @@ -652,38 +652,38 @@ void valkeyProcessCallbacks(valkeyAsyncContext *ac) { /* If in monitor mode, repush the callback */ if (c->flags & VALKEY_MONITORING) { - __valkeyPushCallback(&ac->replies,&cb); + valkeyPushCallback(&ac->replies,&cb); } } /* Disconnect when there was an error reading the reply */ if (status != VALKEY_OK) - __valkeyAsyncDisconnect(ac); + valkeyAsyncDisconnectInternal(ac); } -static void __valkeyAsyncHandleConnectFailure(valkeyAsyncContext *ac) { - __valkeyRunConnectCallback(ac, VALKEY_ERR); - __valkeyAsyncDisconnect(ac); +static void valkeyAsyncHandleConnectFailure(valkeyAsyncContext *ac) { + valkeyRunConnectCallback(ac, VALKEY_ERR); + valkeyAsyncDisconnectInternal(ac); } /* Internal helper function to detect socket status the first time a read or * write event fires. When connecting was not successful, the connect callback * is called with a VALKEY_ERR status and the context is free'd. */ -static int __valkeyAsyncHandleConnect(valkeyAsyncContext *ac) { +static int valkeyAsyncHandleConnect(valkeyAsyncContext *ac) { int completed = 0; valkeyContext *c = &(ac->c); if (valkeyCheckConnectDone(c, &completed) == VALKEY_ERR) { /* Error! */ if (valkeyCheckSocketError(c) == VALKEY_ERR) - __valkeyAsyncCopyError(ac); - __valkeyAsyncHandleConnectFailure(ac); + valkeyAsyncCopyError(ac); + valkeyAsyncHandleConnectFailure(ac); return VALKEY_ERR; } else if (completed == 1) { /* connected! */ if (c->connection_type == VALKEY_CONN_TCP && valkeySetTcpNoDelay(c) == VALKEY_ERR) { - __valkeyAsyncHandleConnectFailure(ac); + valkeyAsyncHandleConnectFailure(ac); return VALKEY_ERR; } @@ -692,7 +692,7 @@ static int __valkeyAsyncHandleConnect(valkeyAsyncContext *ac) { * to delete the context here after callback return. */ c->flags |= VALKEY_CONNECTED; - __valkeyRunConnectCallback(ac, VALKEY_OK); + valkeyRunConnectCallback(ac, VALKEY_OK); if ((ac->c.flags & VALKEY_DISCONNECTING)) { valkeyAsyncDisconnect(ac); return VALKEY_ERR; @@ -710,7 +710,7 @@ void valkeyAsyncRead(valkeyAsyncContext *ac) { valkeyContext *c = &(ac->c); if (valkeyBufferRead(c) == VALKEY_ERR) { - __valkeyAsyncDisconnect(ac); + valkeyAsyncDisconnectInternal(ac); } else { /* Always re-schedule reads */ _EL_ADD_READ(ac); @@ -728,7 +728,7 @@ void valkeyAsyncHandleRead(valkeyAsyncContext *ac) { if (!(c->flags & VALKEY_CONNECTED)) { /* Abort connect was not successful. */ - if (__valkeyAsyncHandleConnect(ac) != VALKEY_OK) + if (valkeyAsyncHandleConnect(ac) != VALKEY_OK) return; /* Try again later when the context is still not connected. */ if (!(c->flags & VALKEY_CONNECTED)) @@ -743,7 +743,7 @@ void valkeyAsyncWrite(valkeyAsyncContext *ac) { int done = 0; if (valkeyBufferWrite(c,&done) == VALKEY_ERR) { - __valkeyAsyncDisconnect(ac); + valkeyAsyncDisconnectInternal(ac); } else { /* Continue writing when not done, stop writing otherwise */ if (!done) @@ -763,7 +763,7 @@ void valkeyAsyncHandleWrite(valkeyAsyncContext *ac) { if (!(c->flags & VALKEY_CONNECTED)) { /* Abort connect was not successful. */ - if (__valkeyAsyncHandleConnect(ac) != VALKEY_OK) + if (valkeyAsyncHandleConnect(ac) != VALKEY_OK) return; /* Try again later when the context is still not connected. */ if (!(c->flags & VALKEY_CONNECTED)) @@ -793,23 +793,23 @@ void valkeyAsyncHandleTimeout(valkeyAsyncContext *ac) { } if (!c->err) { - __valkeySetError(c, VALKEY_ERR_TIMEOUT, "Timeout"); - __valkeyAsyncCopyError(ac); + valkeySetError(c, VALKEY_ERR_TIMEOUT, "Timeout"); + valkeyAsyncCopyError(ac); } if (!(c->flags & VALKEY_CONNECTED)) { - __valkeyRunConnectCallback(ac, VALKEY_ERR); + valkeyRunConnectCallback(ac, VALKEY_ERR); } - while (__valkeyShiftCallback(&ac->replies, &cb) == VALKEY_OK) { - __valkeyRunCallback(ac, &cb, NULL); + while (valkeyShiftCallback(&ac->replies, &cb) == VALKEY_OK) { + valkeyRunCallback(ac, &cb, NULL); } /** * TODO: Don't automatically sever the connection, * rather, allow to ignore responses before the queue is clear */ - __valkeyAsyncDisconnect(ac); + valkeyAsyncDisconnectInternal(ac); } /* Sets a pointer to the first argument and its length starting at p. Returns @@ -831,7 +831,7 @@ static const char *nextArgument(const char *start, const char **str, size_t *len /* Helper function for the valkeyAsyncCommand* family of functions. Writes a * formatted command to the output buffer and registers the provided callback * function with the context. */ -static int __valkeyAsyncCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *cmd, size_t len) { +static int valkeyAsyncAppendCmdLen(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *cmd, size_t len) { valkeyContext *c = &(ac->c); valkeyCallback cb; struct dict *cbdict; @@ -943,27 +943,27 @@ static int __valkeyAsyncCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, vo } else if (strncasecmp(cstr,"monitor\r\n",9) == 0) { /* Set monitor flag and push callback */ c->flags |= VALKEY_MONITORING; - if (__valkeyPushCallback(&ac->replies,&cb) != VALKEY_OK) + if (valkeyPushCallback(&ac->replies,&cb) != VALKEY_OK) goto oom; } else { if (c->flags & VALKEY_SUBSCRIBED) { - if (__valkeyPushCallback(&ac->sub.replies,&cb) != VALKEY_OK) + if (valkeyPushCallback(&ac->sub.replies,&cb) != VALKEY_OK) goto oom; } else { - if (__valkeyPushCallback(&ac->replies,&cb) != VALKEY_OK) + if (valkeyPushCallback(&ac->replies,&cb) != VALKEY_OK) goto oom; } } - __valkeyAppendCommand(c,cmd,len); + valkeyAppendCmdLen(c,cmd,len); /* Always schedule a write when the write buffer is non-empty */ _EL_ADD_WRITE(ac); return VALKEY_OK; oom: - __valkeySetError(&(ac->c), VALKEY_ERR_OOM, "Out of memory"); - __valkeyAsyncCopyError(ac); + valkeySetError(&(ac->c), VALKEY_ERR_OOM, "Out of memory"); + valkeyAsyncCopyError(ac); return VALKEY_ERR; } @@ -977,7 +977,7 @@ int valkeyvAsyncCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *priv if (len < 0) return VALKEY_ERR; - status = __valkeyAsyncCommand(ac,fn,privdata,cmd,len); + status = valkeyAsyncAppendCmdLen(ac,fn,privdata,cmd,len); vk_free(cmd); return status; } @@ -998,13 +998,13 @@ int valkeyAsyncCommandArgv(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *p len = valkeyFormatSdsCommandArgv(&cmd,argc,argv,argvlen); if (len < 0) return VALKEY_ERR; - status = __valkeyAsyncCommand(ac,fn,privdata,cmd,len); + status = valkeyAsyncAppendCmdLen(ac,fn,privdata,cmd,len); sdsfree(cmd); return status; } int valkeyAsyncFormattedCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *cmd, size_t len) { - int status = __valkeyAsyncCommand(ac,fn,privdata,cmd,len); + int status = valkeyAsyncAppendCmdLen(ac,fn,privdata,cmd,len); return status; } @@ -1018,8 +1018,8 @@ int valkeyAsyncSetTimeout(valkeyAsyncContext *ac, struct timeval tv) { if (!ac->c.command_timeout) { ac->c.command_timeout = vk_calloc(1, sizeof(tv)); if (ac->c.command_timeout == NULL) { - __valkeySetError(&ac->c, VALKEY_ERR_OOM, "Out of memory"); - __valkeyAsyncCopyError(ac); + valkeySetError(&ac->c, VALKEY_ERR_OOM, "Out of memory"); + valkeyAsyncCopyError(ac); return VALKEY_ERR; } } diff --git a/libvalkey/async_private.h b/libvalkey/async_private.h index be2f1ea8..21b6de03 100644 --- a/libvalkey/async_private.h +++ b/libvalkey/async_private.h @@ -69,7 +69,7 @@ static inline void refreshTimeout(valkeyAsyncContext *ctx) { } } -void __valkeyAsyncDisconnect(valkeyAsyncContext *ac); +void valkeyAsyncDisconnectInternal(valkeyAsyncContext *ac); void valkeyProcessCallbacks(valkeyAsyncContext *ac); #endif /* VALKEY_ASYNC_PRIVATE_H */ diff --git a/libvalkey/net.c b/libvalkey/net.c index a3e83d14..5d92156a 100644 --- a/libvalkey/net.c +++ b/libvalkey/net.c @@ -49,7 +49,7 @@ #include "win32.h" /* Defined in valkey.c */ -void __valkeySetError(valkeyContext *c, int type, const char *str); +void valkeySetError(valkeyContext *c, int type, const char *str); int valkeyContextUpdateCommandTimeout(valkeyContext *c, const struct timeval *timeout); @@ -68,14 +68,14 @@ ssize_t valkeyNetRead(valkeyContext *c, char *buf, size_t bufcap) { return 0; } else if(errno == ETIMEDOUT && (c->flags & VALKEY_BLOCK)) { /* especially in windows */ - __valkeySetError(c, VALKEY_ERR_TIMEOUT, "recv timeout"); + valkeySetError(c, VALKEY_ERR_TIMEOUT, "recv timeout"); return -1; } else { - __valkeySetError(c, VALKEY_ERR_IO, strerror(errno)); + valkeySetError(c, VALKEY_ERR_IO, strerror(errno)); return -1; } } else if (nread == 0) { - __valkeySetError(c, VALKEY_ERR_EOF, "Server closed the connection"); + valkeySetError(c, VALKEY_ERR_EOF, "Server closed the connection"); return -1; } else { return nread; @@ -91,7 +91,7 @@ ssize_t valkeyNetWrite(valkeyContext *c) { /* Try again */ return 0; } else { - __valkeySetError(c, VALKEY_ERR_IO, strerror(errno)); + valkeySetError(c, VALKEY_ERR_IO, strerror(errno)); return -1; } } @@ -99,7 +99,7 @@ ssize_t valkeyNetWrite(valkeyContext *c) { return nwritten; } -static void __valkeySetErrorFromErrno(valkeyContext *c, int type, const char *prefix) { +static void valkeySetErrorFromErrno(valkeyContext *c, int type, const char *prefix) { int errorno = errno; /* snprintf() may change errno */ char buf[128] = { 0 }; size_t len = 0; @@ -107,13 +107,13 @@ static void __valkeySetErrorFromErrno(valkeyContext *c, int type, const char *pr if (prefix != NULL) len = snprintf(buf,sizeof(buf),"%s: ",prefix); strerror_r(errorno, (char *)(buf + len), sizeof(buf) - len); - __valkeySetError(c,type,buf); + valkeySetError(c,type,buf); } static int valkeySetReuseAddr(valkeyContext *c) { int on = 1; if (setsockopt(c->fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) { - __valkeySetErrorFromErrno(c,VALKEY_ERR_IO,NULL); + valkeySetErrorFromErrno(c,VALKEY_ERR_IO,NULL); valkeyNetClose(c); return VALKEY_ERR; } @@ -123,7 +123,7 @@ static int valkeySetReuseAddr(valkeyContext *c) { static int valkeyCreateSocket(valkeyContext *c, int type) { valkeyFD s; if ((s = socket(type, SOCK_STREAM, 0)) == VALKEY_INVALID_FD) { - __valkeySetErrorFromErrno(c,VALKEY_ERR_IO,NULL); + valkeySetErrorFromErrno(c,VALKEY_ERR_IO,NULL); return VALKEY_ERR; } c->fd = s; @@ -143,7 +143,7 @@ static int valkeySetBlocking(valkeyContext *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) { - __valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"fcntl(F_GETFL)"); + valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"fcntl(F_GETFL)"); valkeyNetClose(c); return VALKEY_ERR; } @@ -154,14 +154,14 @@ static int valkeySetBlocking(valkeyContext *c, int blocking) { flags |= O_NONBLOCK; if (fcntl(c->fd, F_SETFL, flags) == -1) { - __valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"fcntl(F_SETFL)"); + valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"fcntl(F_SETFL)"); valkeyNetClose(c); return VALKEY_ERR; } #else u_long mode = blocking ? 0 : 1; if (ioctl(c->fd, FIONBIO, &mode) == -1) { - __valkeySetErrorFromErrno(c, VALKEY_ERR_IO, "ioctl(FIONBIO)"); + valkeySetErrorFromErrno(c, VALKEY_ERR_IO, "ioctl(FIONBIO)"); valkeyNetClose(c); return VALKEY_ERR; } @@ -179,7 +179,7 @@ int valkeyKeepAlive(valkeyContext *c, int interval) { #ifndef _WIN32 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val)) == -1){ - __valkeySetError(c,VALKEY_ERR_OTHER,strerror(errno)); + valkeySetError(c,VALKEY_ERR_OTHER,strerror(errno)); return VALKEY_ERR; } @@ -187,26 +187,26 @@ int valkeyKeepAlive(valkeyContext *c, int interval) { #if defined(__APPLE__) && defined(__MACH__) if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &val, sizeof(val)) < 0) { - __valkeySetError(c,VALKEY_ERR_OTHER,strerror(errno)); + valkeySetError(c,VALKEY_ERR_OTHER,strerror(errno)); return VALKEY_ERR; } #else #if defined(__GLIBC__) && !defined(__FreeBSD_kernel__) if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &val, sizeof(val)) < 0) { - __valkeySetError(c,VALKEY_ERR_OTHER,strerror(errno)); + valkeySetError(c,VALKEY_ERR_OTHER,strerror(errno)); return VALKEY_ERR; } val = interval/3; if (val == 0) val = 1; if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &val, sizeof(val)) < 0) { - __valkeySetError(c,VALKEY_ERR_OTHER,strerror(errno)); + valkeySetError(c,VALKEY_ERR_OTHER,strerror(errno)); return VALKEY_ERR; } val = 3; if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &val, sizeof(val)) < 0) { - __valkeySetError(c,VALKEY_ERR_OTHER,strerror(errno)); + valkeySetError(c,VALKEY_ERR_OTHER,strerror(errno)); return VALKEY_ERR; } #endif @@ -216,7 +216,7 @@ int valkeyKeepAlive(valkeyContext *c, int interval) { res = win32_valkeyKeepAlive(fd, interval * 1000); if (res != 0) { - __valkeySetError(c, VALKEY_ERR_OTHER, strerror(res)); + valkeySetError(c, VALKEY_ERR_OTHER, strerror(res)); return VALKEY_ERR; } #endif @@ -226,7 +226,7 @@ int valkeyKeepAlive(valkeyContext *c, int interval) { int valkeySetTcpNoDelay(valkeyContext *c) { int yes = 1; if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1) { - __valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"setsockopt(TCP_NODELAY)"); + valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"setsockopt(TCP_NODELAY)"); valkeyNetClose(c); return VALKEY_ERR; } @@ -243,7 +243,7 @@ int valkeyContextSetTcpUserTimeout(valkeyContext *c, unsigned int timeout) { (void)timeout; #endif if (res == -1) { - __valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"setsockopt(TCP_USER_TIMEOUT)"); + valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"setsockopt(TCP_USER_TIMEOUT)"); valkeyNetClose(c); return VALKEY_ERR; } @@ -260,7 +260,7 @@ static int valkeyContextTimeoutMsec(valkeyContext *c, long *result) /* Only use timeout when not NULL. */ if (timeout != NULL) { if (timeout->tv_usec > 1000000 || timeout->tv_sec > __MAX_MSEC) { - __valkeySetError(c, VALKEY_ERR_IO, "Invalid timeout specified"); + valkeySetError(c, VALKEY_ERR_IO, "Invalid timeout specified"); *result = msec; return VALKEY_ERR; } @@ -294,7 +294,7 @@ static int valkeyContextWaitReady(valkeyContext *c, long msec) { int res; if (errno != EINPROGRESS) { - __valkeySetErrorFromErrno(c,VALKEY_ERR_IO,NULL); + valkeySetErrorFromErrno(c,VALKEY_ERR_IO,NULL); valkeyNetClose(c); return VALKEY_ERR; } @@ -305,12 +305,12 @@ static int valkeyContextWaitReady(valkeyContext *c, long msec) { while ((res = poll(&wfd, 1, msec)) <= 0) { if (res < 0 && errno != EINTR) { - __valkeySetErrorFromErrno(c, VALKEY_ERR_IO, "poll(2)"); + valkeySetErrorFromErrno(c, VALKEY_ERR_IO, "poll(2)"); valkeyNetClose(c); return VALKEY_ERR; } else if (res == 0 || (msec >= 0 && valkeyPollMillis() >= end)) { errno = ETIMEDOUT; - __valkeySetErrorFromErrno(c, VALKEY_ERR_IO, NULL); + valkeySetErrorFromErrno(c, VALKEY_ERR_IO, NULL); valkeyNetClose(c); return VALKEY_ERR; } else { @@ -367,7 +367,7 @@ int valkeyCheckSocketError(valkeyContext *c) { socklen_t errlen = sizeof(err); if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) { - __valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"getsockopt(SO_ERROR)"); + valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"getsockopt(SO_ERROR)"); return VALKEY_ERR; } @@ -377,7 +377,7 @@ int valkeyCheckSocketError(valkeyContext *c) { if (err) { errno = err; - __valkeySetErrorFromErrno(c,VALKEY_ERR_IO,NULL); + valkeySetErrorFromErrno(c,VALKEY_ERR_IO,NULL); return VALKEY_ERR; } @@ -389,15 +389,15 @@ int valkeyContextSetTimeout(valkeyContext *c, const struct timeval tv) { size_t to_sz = sizeof(tv); if (valkeyContextUpdateCommandTimeout(c, &tv) != VALKEY_OK) { - __valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); + valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); return VALKEY_ERR; } if (setsockopt(c->fd,SOL_SOCKET,SO_RCVTIMEO,to_ptr,to_sz) == -1) { - __valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"setsockopt(SO_RCVTIMEO)"); + valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"setsockopt(SO_RCVTIMEO)"); return VALKEY_ERR; } if (setsockopt(c->fd,SOL_SOCKET,SO_SNDTIMEO,to_ptr,to_sz) == -1) { - __valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"setsockopt(SO_SNDTIMEO)"); + valkeySetErrorFromErrno(c,VALKEY_ERR_IO,"setsockopt(SO_SNDTIMEO)"); return VALKEY_ERR; } return VALKEY_OK; @@ -508,7 +508,7 @@ static int _valkeyContextConnectTcp(valkeyContext *c, const char *addr, int port rv = getaddrinfo(c->tcp.host, _port, &hints, &servinfo); } if (rv != 0) { - __valkeySetError(c, VALKEY_ERR_OTHER, gai_strerror(rv)); + valkeySetError(c, VALKEY_ERR_OTHER, gai_strerror(rv)); return VALKEY_ERR; } for (p = servinfo; p != NULL; p = p->ai_next) { @@ -525,7 +525,7 @@ static int _valkeyContextConnectTcp(valkeyContext *c, const char *addr, int port 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)); - __valkeySetError(c,VALKEY_ERR_OTHER,buf); + valkeySetError(c,VALKEY_ERR_OTHER,buf); goto error; } @@ -548,7 +548,7 @@ static int _valkeyContextConnectTcp(valkeyContext *c, const char *addr, int port if (!bound) { char buf[128]; snprintf(buf,sizeof(buf),"Can't bind socket: %s",strerror(errno)); - __valkeySetError(c,VALKEY_ERR_OTHER,buf); + valkeySetError(c,VALKEY_ERR_OTHER,buf); goto error; } } @@ -599,12 +599,12 @@ static int _valkeyContextConnectTcp(valkeyContext *c, const char *addr, int port if (p == NULL) { char buf[128]; snprintf(buf,sizeof(buf),"Can't create socket: %s",strerror(errno)); - __valkeySetError(c,VALKEY_ERR_OTHER,buf); + valkeySetError(c,VALKEY_ERR_OTHER,buf); goto error; } oom: - __valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); + valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); error: rv = VALKEY_ERR; end: @@ -689,6 +689,6 @@ int valkeyContextConnectUnix(valkeyContext *c, const char *path, const struct ti return VALKEY_ERR; #endif /* _WIN32 */ oom: - __valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); + valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); return VALKEY_ERR; } diff --git a/libvalkey/read.c b/libvalkey/read.c index f1a50ebd..07f97ed1 100644 --- a/libvalkey/read.c +++ b/libvalkey/read.c @@ -50,7 +50,7 @@ /* Initial size of our nested reply stack and how much we grow it when needd */ #define VALKEY_READER_STACK_SIZE 9 -static void __valkeyReaderSetError(valkeyReader *r, int type, const char *str) { +static void valkeyReaderSetError(valkeyReader *r, int type, const char *str) { size_t len; if (r->reply != NULL && r->fn && r->fn->freeObject) { @@ -98,17 +98,17 @@ static size_t chrtos(char *buf, size_t size, char byte) { return len; } -static void __valkeyReaderSetErrorProtocolByte(valkeyReader *r, char byte) { +static void valkeyReaderSetErrorProtocolByte(valkeyReader *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); - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL,sbuf); + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL,sbuf); } -static void __valkeyReaderSetErrorOOM(valkeyReader *r) { - __valkeyReaderSetError(r,VALKEY_ERR_OOM,"Out of memory"); +static void valkeyReaderSetErrorOOM(valkeyReader *r) { + valkeyReaderSetError(r,VALKEY_ERR_OOM,"Out of memory"); } static char *readBytes(valkeyReader *r, unsigned int bytes) { @@ -277,7 +277,7 @@ static int processLineItem(valkeyReader *r) { long long v; if (string2ll(p, len, &v) == VALKEY_ERR) { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Bad integer value"); return VALKEY_ERR; } @@ -292,7 +292,7 @@ static int processLineItem(valkeyReader *r) { double d; if ((size_t)len >= sizeof(buf)) { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Double value is too large"); return VALKEY_ERR; } @@ -314,7 +314,7 @@ static int processLineItem(valkeyReader *r) { * etc. We explicity handle our two allowed infinite cases and NaN * above, so strtod() should only result in finite values. */ if (buf[0] == '\0' || eptr != &buf[len] || !isfinite(d)) { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Bad double value"); return VALKEY_ERR; } @@ -327,7 +327,7 @@ static int processLineItem(valkeyReader *r) { } } else if (cur->type == VALKEY_REPLY_NIL) { if (len != 0) { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Bad nil value"); return VALKEY_ERR; } @@ -340,7 +340,7 @@ static int processLineItem(valkeyReader *r) { int bval; if (len != 1 || !strchr("tTfF", p[0])) { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Bad bool value"); return VALKEY_ERR; } @@ -357,7 +357,7 @@ static int processLineItem(valkeyReader *r) { /* XXX Consider: Allow leading '+'? Error on leading '0's? */ if (i == 0 && p[0] == '-') continue; if (p[i] < '0' || p[i] > '9') { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Bad bignum value"); return VALKEY_ERR; } @@ -370,7 +370,7 @@ static int processLineItem(valkeyReader *r) { /* Type will be error or status. */ for (int i = 0; i < len; i++) { if (p[i] == '\r' || p[i] == '\n') { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Bad simple string value"); return VALKEY_ERR; } @@ -382,7 +382,7 @@ static int processLineItem(valkeyReader *r) { } if (obj == NULL) { - __valkeyReaderSetErrorOOM(r); + valkeyReaderSetErrorOOM(r); return VALKEY_ERR; } @@ -410,13 +410,13 @@ static int processBulkItem(valkeyReader *r) { bytelen = s-(r->buf+r->pos)+2; /* include \r\n */ if (string2ll(p, bytelen - 2, &len) == VALKEY_ERR) { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Bad bulk string length"); return VALKEY_ERR; } if (len < -1 || (LLONG_MAX > SIZE_MAX && len > (long long)SIZE_MAX)) { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Bulk string length out of range"); return VALKEY_ERR; } @@ -435,7 +435,7 @@ static int processBulkItem(valkeyReader *r) { if ((cur->type == VALKEY_REPLY_VERB && len < 4) || (cur->type == VALKEY_REPLY_VERB && s[5] != ':')) { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Verbatim string 4 bytes of content type are " "missing or incorrectly encoded."); return VALKEY_ERR; @@ -451,7 +451,7 @@ static int processBulkItem(valkeyReader *r) { /* Proceed when obj was created. */ if (success) { if (obj == NULL) { - __valkeyReaderSetErrorOOM(r); + valkeyReaderSetErrorOOM(r); return VALKEY_ERR; } @@ -488,7 +488,7 @@ static int valkeyReaderGrow(valkeyReader *r) { return VALKEY_OK; oom: - __valkeyReaderSetErrorOOM(r); + valkeyReaderSetErrorOOM(r); return VALKEY_ERR; } @@ -507,7 +507,7 @@ static int processAggregateItem(valkeyReader *r) { if ((p = readLine(r,&len)) != NULL) { if (string2ll(p, len, &elements) == VALKEY_ERR) { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Bad multi-bulk length"); return VALKEY_ERR; } @@ -517,7 +517,7 @@ static int processAggregateItem(valkeyReader *r) { if (elements < -1 || (LLONG_MAX > SIZE_MAX && elements > SIZE_MAX) || (r->maxelements > 0 && elements > r->maxelements)) { - __valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, + valkeyReaderSetError(r,VALKEY_ERR_PROTOCOL, "Multi-bulk length out of range"); return VALKEY_ERR; } @@ -529,7 +529,7 @@ static int processAggregateItem(valkeyReader *r) { obj = (void*)VALKEY_REPLY_NIL; if (obj == NULL) { - __valkeyReaderSetErrorOOM(r); + valkeyReaderSetErrorOOM(r); return VALKEY_ERR; } @@ -543,7 +543,7 @@ static int processAggregateItem(valkeyReader *r) { obj = (void*)(uintptr_t)cur->type; if (obj == NULL) { - __valkeyReaderSetErrorOOM(r); + valkeyReaderSetErrorOOM(r); return VALKEY_ERR; } @@ -622,7 +622,7 @@ static int processItem(valkeyReader *r) { cur->type = VALKEY_REPLY_BIGNUM; break; default: - __valkeyReaderSetErrorProtocolByte(r,*p); + valkeyReaderSetErrorProtocolByte(r,*p); return VALKEY_ERR; } } else { @@ -735,7 +735,7 @@ int valkeyReaderFeed(valkeyReader *r, const char *buf, size_t len) { return VALKEY_OK; oom: - __valkeyReaderSetErrorOOM(r); + valkeyReaderSetErrorOOM(r); return VALKEY_ERR; } diff --git a/libvalkey/ssl.c b/libvalkey/ssl.c index c302d99a..89a441c9 100644 --- a/libvalkey/ssl.c +++ b/libvalkey/ssl.c @@ -61,7 +61,7 @@ #define OPENSSL_1_1_0 0x10100000L -void __valkeySetError(valkeyContext *c, int type, const char *str); +void valkeySetError(valkeyContext *c, int type, const char *str); struct valkeySSLContext { /* Associated OpenSSL SSL_CTX as created by valkeyCreateSSLContext() */ @@ -354,13 +354,13 @@ valkeySSLContext *valkeyCreateSSLContextWithOptions(valkeySSLOptions *options, v static int valkeySSLConnect(valkeyContext *c, SSL *ssl) { if (c->privctx) { - __valkeySetError(c, VALKEY_ERR_OTHER, "valkeyContext was already associated"); + valkeySetError(c, VALKEY_ERR_OTHER, "valkeyContext was already associated"); return VALKEY_ERR; } valkeySSL *rssl = vk_calloc(1, sizeof(valkeySSL)); if (rssl == NULL) { - __valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); + valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); return VALKEY_ERR; } @@ -397,7 +397,7 @@ static int valkeySSLConnect(valkeyContext *c, SSL *ssl) { snprintf(err,sizeof(err)-1,"SSL_connect failed: %s", ERR_reason_error_string(e)); } - __valkeySetError(c, VALKEY_ERR_IO, err); + valkeySetError(c, VALKEY_ERR_IO, err); } vk_free(rssl); @@ -431,13 +431,13 @@ int valkeyInitiateSSLWithContext(valkeyContext *c, valkeySSLContext *valkey_ssl_ SSL *ssl = SSL_new(valkey_ssl_ctx->ssl_ctx); if (!ssl) { - __valkeySetError(c, VALKEY_ERR_OTHER, "Couldn't create new SSL instance"); + valkeySetError(c, VALKEY_ERR_OTHER, "Couldn't create new SSL instance"); goto error; } if (valkey_ssl_ctx->server_name) { if (!SSL_set_tlsext_host_name(ssl, valkey_ssl_ctx->server_name)) { - __valkeySetError(c, VALKEY_ERR_OTHER, "Failed to set server_name/SNI"); + valkeySetError(c, VALKEY_ERR_OTHER, "Failed to set server_name/SNI"); goto error; } } @@ -492,7 +492,7 @@ static ssize_t valkeySSLRead(valkeyContext *c, char *buf, size_t bufcap) { if (nread > 0) { return nread; } else if (nread == 0) { - __valkeySetError(c, VALKEY_ERR_EOF, "Server closed the connection"); + valkeySetError(c, VALKEY_ERR_EOF, "Server closed the connection"); return -1; } else { int err = SSL_get_error(rssl->ssl, nread); @@ -510,7 +510,7 @@ static ssize_t valkeySSLRead(valkeyContext *c, char *buf, size_t bufcap) { if (errno == EAGAIN) { msg = "Resource temporarily unavailable"; } - __valkeySetError(c, VALKEY_ERR_IO, msg); + valkeySetError(c, VALKEY_ERR_IO, msg); return -1; } } @@ -521,7 +521,7 @@ static ssize_t valkeySSLRead(valkeyContext *c, char *buf, size_t bufcap) { if (maybeCheckWant(rssl, err)) { return 0; } else { - __valkeySetError(c, VALKEY_ERR_IO, NULL); + valkeySetError(c, VALKEY_ERR_IO, NULL); return -1; } } @@ -542,7 +542,7 @@ static ssize_t valkeySSLWrite(valkeyContext *c) { if ((c->flags & VALKEY_BLOCK) == 0 && maybeCheckWant(rssl, err)) { return 0; } else { - __valkeySetError(c, VALKEY_ERR_IO, NULL); + valkeySetError(c, VALKEY_ERR_IO, NULL); return -1; } } @@ -563,7 +563,7 @@ static void valkeySSLAsyncRead(valkeyAsyncContext *ac) { rssl->pendingWrite = 0; rv = valkeyBufferWrite(c, &done); if (rv == VALKEY_ERR) { - __valkeyAsyncDisconnect(ac); + valkeyAsyncDisconnectInternal(ac); return; } else if (!done) { _EL_ADD_WRITE(ac); @@ -572,7 +572,7 @@ static void valkeySSLAsyncRead(valkeyAsyncContext *ac) { rv = valkeyBufferRead(c); if (rv == VALKEY_ERR) { - __valkeyAsyncDisconnect(ac); + valkeyAsyncDisconnectInternal(ac); } else { _EL_ADD_READ(ac); valkeyProcessCallbacks(ac); @@ -587,7 +587,7 @@ static void valkeySSLAsyncWrite(valkeyAsyncContext *ac) { rssl->pendingWrite = 0; rv = valkeyBufferWrite(c, &done); if (rv == VALKEY_ERR) { - __valkeyAsyncDisconnect(ac); + valkeyAsyncDisconnectInternal(ac); return; } diff --git a/libvalkey/valkey.c b/libvalkey/valkey.c index e503910f..8e9fea43 100644 --- a/libvalkey/valkey.c +++ b/libvalkey/valkey.c @@ -688,7 +688,7 @@ void valkeyFreeCommand(char *cmd) { vk_free(cmd); } -void __valkeySetError(valkeyContext *c, int type, const char *str) { +void valkeySetError(valkeyContext *c, int type, const char *str) { size_t len; c->err = type; @@ -788,7 +788,7 @@ int valkeyReconnect(valkeyContext *c) { c->reader = valkeyReaderCreate(); if (c->obuf == NULL || c->reader == NULL) { - __valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); + valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); return VALKEY_ERR; } @@ -801,7 +801,7 @@ int valkeyReconnect(valkeyContext *c) { } else { /* Something bad happened here and shouldn't have. There isn't enough information in the context to reconnect. */ - __valkeySetError(c,VALKEY_ERR_OTHER,"Not enough information to reconnect"); + valkeySetError(c,VALKEY_ERR_OTHER,"Not enough information to reconnect"); ret = VALKEY_ERR; } @@ -848,7 +848,7 @@ valkeyContext *valkeyConnectWithOptions(const valkeyOptions *options) { if (valkeyContextUpdateConnectTimeout(c, options->connect_timeout) != VALKEY_OK || valkeyContextUpdateCommandTimeout(c, options->command_timeout) != VALKEY_OK) { - __valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); + valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); return c; } @@ -990,7 +990,7 @@ int valkeyBufferRead(valkeyContext *c) { return VALKEY_ERR; } if (nread > 0 && valkeyReaderFeed(c->reader, buf, nread) != VALKEY_OK) { - __valkeySetError(c, c->reader->err, c->reader->errstr); + valkeySetError(c, c->reader->err, c->reader->errstr); return VALKEY_ERR; } return VALKEY_OK; @@ -1030,7 +1030,7 @@ int valkeyBufferWrite(valkeyContext *c, int *done) { return VALKEY_OK; oom: - __valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); + valkeySetError(c, VALKEY_ERR_OOM, "Out of memory"); return VALKEY_ERR; } @@ -1048,7 +1048,7 @@ static int valkeyHandledPushReply(valkeyContext *c, void *reply) { /* Get a reply from our reader or set an error in the context. */ int valkeyGetReplyFromReader(valkeyContext *c, void **reply) { if (valkeyReaderGetReply(c->reader, reply) == VALKEY_ERR) { - __valkeySetError(c,c->reader->err,c->reader->errstr); + valkeySetError(c,c->reader->err,c->reader->errstr); return VALKEY_ERR; } @@ -1110,12 +1110,12 @@ int valkeyGetReply(valkeyContext *c, void **reply) { * is used, you need to call valkeyGetReply yourself to retrieve * the reply (or replies in pub/sub). */ -int __valkeyAppendCommand(valkeyContext *c, const char *cmd, size_t len) { +int valkeyAppendCmdLen(valkeyContext *c, const char *cmd, size_t len) { sds newbuf; newbuf = sdscatlen(c->obuf,cmd,len); if (newbuf == NULL) { - __valkeySetError(c,VALKEY_ERR_OOM,"Out of memory"); + valkeySetError(c,VALKEY_ERR_OOM,"Out of memory"); return VALKEY_ERR; } @@ -1125,7 +1125,7 @@ int __valkeyAppendCommand(valkeyContext *c, const char *cmd, size_t len) { int valkeyAppendFormattedCommand(valkeyContext *c, const char *cmd, size_t len) { - if (__valkeyAppendCommand(c, cmd, len) != VALKEY_OK) { + if (valkeyAppendCmdLen(c, cmd, len) != VALKEY_OK) { return VALKEY_ERR; } @@ -1138,14 +1138,14 @@ int valkeyvAppendCommand(valkeyContext *c, const char *format, va_list ap) { len = valkeyvFormatCommand(&cmd,format,ap); if (len == -1) { - __valkeySetError(c,VALKEY_ERR_OOM,"Out of memory"); + valkeySetError(c,VALKEY_ERR_OOM,"Out of memory"); return VALKEY_ERR; } else if (len == -2) { - __valkeySetError(c,VALKEY_ERR_OTHER,"Invalid format string"); + valkeySetError(c,VALKEY_ERR_OTHER,"Invalid format string"); return VALKEY_ERR; } - if (__valkeyAppendCommand(c,cmd,len) != VALKEY_OK) { + if (valkeyAppendCmdLen(c,cmd,len) != VALKEY_OK) { vk_free(cmd); return VALKEY_ERR; } @@ -1170,11 +1170,11 @@ int valkeyAppendCommandArgv(valkeyContext *c, int argc, const char **argv, const len = valkeyFormatSdsCommandArgv(&cmd,argc,argv,argvlen); if (len == -1) { - __valkeySetError(c,VALKEY_ERR_OOM,"Out of memory"); + valkeySetError(c,VALKEY_ERR_OOM,"Out of memory"); return VALKEY_ERR; } - if (__valkeyAppendCommand(c,cmd,len) != VALKEY_OK) { + if (valkeyAppendCmdLen(c,cmd,len) != VALKEY_OK) { sdsfree(cmd); return VALKEY_ERR; } @@ -1194,7 +1194,7 @@ int valkeyAppendCommandArgv(valkeyContext *c, int argc, const char **argv, const * otherwise. When NULL is returned in a blocking context, the error field * in the context will be set. */ -static void *__valkeyBlockForReply(valkeyContext *c) { +static void *valkeyBlockForReply(valkeyContext *c) { void *reply; if (c->flags & VALKEY_BLOCK) { @@ -1208,7 +1208,7 @@ static void *__valkeyBlockForReply(valkeyContext *c) { void *valkeyvCommand(valkeyContext *c, const char *format, va_list ap) { if (valkeyvAppendCommand(c,format,ap) != VALKEY_OK) return NULL; - return __valkeyBlockForReply(c); + return valkeyBlockForReply(c); } void *valkeyCommand(valkeyContext *c, const char *format, ...) { @@ -1222,5 +1222,5 @@ void *valkeyCommand(valkeyContext *c, const char *format, ...) { void *valkeyCommandArgv(valkeyContext *c, int argc, const char **argv, const size_t *argvlen) { if (valkeyAppendCommandArgv(c,argc,argv,argvlen) != VALKEY_OK) return NULL; - return __valkeyBlockForReply(c); + return valkeyBlockForReply(c); }