libvalkey 4.0.0__tar.gz → 4.0.1__tar.gz

{libvalkey-4.0.0 → libvalkey-4.0.1}/MANIFEST.in

@@ -3,6 +3,7 @@ include MANIFEST.in
 include README.md
 include src/*.[ch]
 include vendor/libvalkey/COPYING
+include vendor/libvalkey/include/valkey/*.h
 include vendor/libvalkey/src/*.[ch]
 graft tests
 global-exclude __pycache__

{libvalkey-4.0.0/libvalkey.egg-info → libvalkey-4.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libvalkey
-Version: 4.0.0
+Version: 4.0.1
 Summary: Python wrapper for libvalkey
 Home-page: https://github.com/valkey-io/libvalkey-py
 Author: libvalkey-py authors
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development
 Requires-Python: >=3.8

libvalkey-4.0.1/libvalkey/version.py

@@ -0,0 +1 @@
+__version__ = "4.0.1"

{libvalkey-4.0.0 → libvalkey-4.0.1/libvalkey.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libvalkey
-Version: 4.0.0
+Version: 4.0.1
 Summary: Python wrapper for libvalkey
 Home-page: https://github.com/valkey-io/libvalkey-py
 Author: libvalkey-py authors
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development
 Requires-Python: >=3.8

{libvalkey-4.0.0 → libvalkey-4.0.1}/libvalkey.egg-info/SOURCES.txt

@@ -20,6 +20,17 @@ src/reader.h
 tests/test_gc.py
 tests/test_pack.py
 tests/test_reader.py
+vendor/libvalkey/include/valkey/alloc.h
+vendor/libvalkey/include/valkey/async.h
+vendor/libvalkey/include/valkey/dict.h
+vendor/libvalkey/include/valkey/net.h
+vendor/libvalkey/include/valkey/read.h
+vendor/libvalkey/include/valkey/sds.h
+vendor/libvalkey/include/valkey/sockcompat.h
+vendor/libvalkey/include/valkey/valkey.h
+vendor/libvalkey/include/valkey/valkey_ssl.h
+vendor/libvalkey/include/valkey/valkeycluster.h
+vendor/libvalkey/include/valkey/valkeycluster_ssl.h
 vendor/libvalkey/src/adlist.c
 vendor/libvalkey/src/adlist.h
 vendor/libvalkey/src/alloc.c

{libvalkey-4.0.0 → libvalkey-4.0.1}/setup.py

@@ -83,6 +83,7 @@ setup(
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
         'Programming Language :: Python :: Implementation :: CPython',
         'Topic :: Software Development',
     ],

{libvalkey-4.0.0 → libvalkey-4.0.1}/src/reader.c

@@ -87,13 +87,13 @@ static void *tryParentize(const valkeyReadTask *task, PyObject *obj) {
                         Py_DECREF(obj);
                         return NULL;
                     }
-                    if (PyDict_SetItem(parent, self->pendingObject, obj) < 0) {
-                        Py_DECREF(obj);
-                        Py_DECREF(self->pendingObject);
-                        self->pendingObject = NULL;
+                    int x = PyDict_SetItem(parent, self->pendingObject, obj);
+                    Py_DECREF(obj);
+                    Py_DECREF(self->pendingObject);
+                    self->pendingObject = NULL;
+                    if (x < 0) {
                         return NULL;
                     }
-                    self->pendingObject = NULL;
                 }
                 break;
             case VALKEY_REPLY_SET:

libvalkey-4.0.1/vendor/libvalkey/include/valkey/alloc.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2020, Michael Grunder <michael dot grunder at gmail dot com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef VALKEY_ALLOC_H
+#define VALKEY_ALLOC_H
+
+#include <stddef.h> /* for size_t */
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Structure pointing to our actually configured allocators */
+typedef struct valkeyAllocFuncs {
+    void *(*mallocFn)(size_t);
+    void *(*callocFn)(size_t,size_t);
+    void *(*reallocFn)(void*,size_t);
+    char *(*strdupFn)(const char*);
+    void (*freeFn)(void*);
+} valkeyAllocFuncs;
+
+valkeyAllocFuncs valkeySetAllocators(valkeyAllocFuncs *fns);
+void valkeyResetAllocators(void);
+
+#ifndef _WIN32
+
+/* valkey' configured allocator function pointer struct */
+extern valkeyAllocFuncs valkeyAllocFns;
+
+static inline void *vk_malloc(size_t size) {
+    return valkeyAllocFns.mallocFn(size);
+}
+
+static inline void *vk_calloc(size_t nmemb, size_t size) {
+    /* Overflow check as the user can specify any arbitrary allocator */
+    if (SIZE_MAX / size < nmemb)
+        return NULL;
+
+    return valkeyAllocFns.callocFn(nmemb, size);
+}
+
+static inline void *vk_realloc(void *ptr, size_t size) {
+    return valkeyAllocFns.reallocFn(ptr, size);
+}
+
+static inline char *vk_strdup(const char *str) {
+    return valkeyAllocFns.strdupFn(str);
+}
+
+static inline void vk_free(void *ptr) {
+    valkeyAllocFns.freeFn(ptr);
+}
+
+#else
+
+void *vk_malloc(size_t size);
+void *vk_calloc(size_t nmemb, size_t size);
+void *vk_realloc(void *ptr, size_t size);
+char *vk_strdup(const char *str);
+void vk_free(void *ptr);
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* VALKEY_ALLOC_H */

libvalkey-4.0.1/vendor/libvalkey/include/valkey/async.h

@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef VALKEY_ASYNC_H
+#define VALKEY_ASYNC_H
+#include "valkey.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* For the async cluster attach functions. */
+#if defined(__GNUC__) || defined(__clang__)
+#define VALKEY_UNUSED __attribute__((unused))
+#else
+#define VALKEY_UNUSED
+#endif
+
+struct valkeyAsyncContext; /* need forward declaration of valkeyAsyncContext */
+struct dict; /* dictionary header is included in async.c */
+
+/* Reply callback prototype and container */
+typedef void (valkeyCallbackFn)(struct valkeyAsyncContext*, void*, void*);
+typedef struct valkeyCallback {
+    struct valkeyCallback *next; /* simple singly linked list */
+    valkeyCallbackFn *fn;
+    int pending_subs;
+    int unsubscribe_sent;
+    void *privdata;
+} valkeyCallback;
+
+/* List of callbacks for either regular replies or pub/sub */
+typedef struct valkeyCallbackList {
+    valkeyCallback *head, *tail;
+} valkeyCallbackList;
+
+/* Connection callback prototypes */
+typedef void (valkeyDisconnectCallback)(const struct valkeyAsyncContext*, int status);
+typedef void (valkeyConnectCallback)(const struct valkeyAsyncContext*, int status);
+typedef void (valkeyConnectCallbackNC)(struct valkeyAsyncContext *, int status);
+typedef void(valkeyTimerCallback)(void *timer, void *privdata);
+
+/* Context for an async connection to Valkey */
+typedef struct valkeyAsyncContext {
+    /* Hold the regular context, so it can be realloc'ed. */
+    valkeyContext c;
+
+    /* Setup error flags so they can be used directly. */
+    int err;
+    char *errstr;
+
+    /* Not used by libvalkey */
+    void *data;
+    void (*dataCleanup)(void *privdata);
+
+    /* Event library data and hooks */
+    struct {
+        void *data;
+
+        /* Hooks that are called when the library expects to start
+         * reading/writing. These functions should be idempotent. */
+        void (*addRead)(void *privdata);
+        void (*delRead)(void *privdata);
+        void (*addWrite)(void *privdata);
+        void (*delWrite)(void *privdata);
+        void (*cleanup)(void *privdata);
+        void (*scheduleTimer)(void *privdata, struct timeval tv);
+    } ev;
+
+    /* Called when either the connection is terminated due to an error or per
+     * user request. The status is set accordingly (VALKEY_OK, VALKEY_ERR). */
+    valkeyDisconnectCallback *onDisconnect;
+
+    /* Called when the first write event was received. */
+    valkeyConnectCallback *onConnect;
+    valkeyConnectCallbackNC *onConnectNC;
+
+    /* Regular command callbacks */
+    valkeyCallbackList replies;
+
+    /* Address used for connect() */
+    struct sockaddr *saddr;
+    size_t addrlen;
+
+    /* Subscription callbacks */
+    struct {
+        valkeyCallbackList replies;
+        struct dict *channels;
+        struct dict *patterns;
+        int pending_unsubs;
+    } sub;
+
+    /* Any configured RESP3 PUSH handler */
+    valkeyAsyncPushFn *push_cb;
+} valkeyAsyncContext;
+
+/* Functions that proxy to libvalkey */
+valkeyAsyncContext *valkeyAsyncConnectWithOptions(const valkeyOptions *options);
+valkeyAsyncContext *valkeyAsyncConnect(const char *ip, int port);
+valkeyAsyncContext *valkeyAsyncConnectBind(const char *ip, int port, const char *source_addr);
+valkeyAsyncContext *valkeyAsyncConnectBindWithReuse(const char *ip, int port,
+                                                  const char *source_addr);
+valkeyAsyncContext *valkeyAsyncConnectUnix(const char *path);
+int valkeyAsyncSetConnectCallback(valkeyAsyncContext *ac, valkeyConnectCallback *fn);
+int valkeyAsyncSetConnectCallbackNC(valkeyAsyncContext *ac, valkeyConnectCallbackNC *fn);
+int valkeyAsyncSetDisconnectCallback(valkeyAsyncContext *ac, valkeyDisconnectCallback *fn);
+
+valkeyAsyncPushFn *valkeyAsyncSetPushCallback(valkeyAsyncContext *ac, valkeyAsyncPushFn *fn);
+int valkeyAsyncSetTimeout(valkeyAsyncContext *ac, struct timeval tv);
+void valkeyAsyncDisconnect(valkeyAsyncContext *ac);
+void valkeyAsyncFree(valkeyAsyncContext *ac);
+
+/* Handle read/write events */
+void valkeyAsyncHandleRead(valkeyAsyncContext *ac);
+void valkeyAsyncHandleWrite(valkeyAsyncContext *ac);
+void valkeyAsyncHandleTimeout(valkeyAsyncContext *ac);
+void valkeyAsyncRead(valkeyAsyncContext *ac);
+void valkeyAsyncWrite(valkeyAsyncContext *ac);
+
+/* Command functions for an async context. Write the command to the
+ * output buffer and register the provided callback. */
+int valkeyvAsyncCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *format, va_list ap);
+int valkeyAsyncCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *format, ...);
+int valkeyAsyncCommandArgv(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, int argc, const char **argv, const size_t *argvlen);
+int valkeyAsyncFormattedCommand(valkeyAsyncContext *ac, valkeyCallbackFn *fn, void *privdata, const char *cmd, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libvalkey-4.0.1/vendor/libvalkey/include/valkey/dict.h

@@ -0,0 +1,125 @@
+/* Hash table implementation.
+ *
+ * This file implements in memory hash tables with insert/del/replace/find/
+ * get-random-element operations. Hash tables will auto resize if needed
+ * tables of power of two in size are used, collisions are handled by
+ * chaining. See the source code for more information... :)
+ *
+ * Copyright (c) 2006-2010, Salvatore Sanfilippo <antirez at gmail dot com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DICT_H
+#define __DICT_H
+
+#define DICT_OK 0
+#define DICT_ERR 1
+
+/* Unused arguments generate annoying warnings... */
+#define DICT_NOTUSED(V) ((void) V)
+
+typedef struct dictEntry {
+    void *key;
+    void *val;
+    struct dictEntry *next;
+} dictEntry;
+
+typedef struct dictType {
+    unsigned int (*hashFunction)(const void *key);
+    void *(*keyDup)(void *privdata, const void *key);
+    void *(*valDup)(void *privdata, const void *obj);
+    int (*keyCompare)(void *privdata, const void *key1, const void *key2);
+    void (*keyDestructor)(void *privdata, void *key);
+    void (*valDestructor)(void *privdata, void *obj);
+} dictType;
+
+typedef struct dict {
+    dictEntry **table;
+    dictType *type;
+    unsigned long size;
+    unsigned long sizemask;
+    unsigned long used;
+    void *privdata;
+} dict;
+
+typedef struct dictIterator {
+    dict *ht;
+    int index;
+    dictEntry *entry, *nextEntry;
+} dictIterator;
+
+/* This is the initial size of every hash table */
+#define DICT_HT_INITIAL_SIZE     4
+
+/* ------------------------------- Macros ------------------------------------*/
+#define dictFreeEntryVal(ht, entry) \
+    if ((ht)->type->valDestructor) \
+        (ht)->type->valDestructor((ht)->privdata, (entry)->val)
+
+#define dictSetHashVal(ht, entry, _val_) do { \
+    if ((ht)->type->valDup) \
+        entry->val = (ht)->type->valDup((ht)->privdata, _val_); \
+    else \
+        entry->val = (_val_); \
+} while(0)
+
+#define dictFreeEntryKey(ht, entry) \
+    if ((ht)->type->keyDestructor) \
+        (ht)->type->keyDestructor((ht)->privdata, (entry)->key)
+
+#define dictSetHashKey(ht, entry, _key_) do { \
+    if ((ht)->type->keyDup) \
+        entry->key = (ht)->type->keyDup((ht)->privdata, _key_); \
+    else \
+        entry->key = (_key_); \
+} while(0)
+
+#define dictCompareHashKeys(ht, key1, key2) \
+    (((ht)->type->keyCompare) ? \
+        (ht)->type->keyCompare((ht)->privdata, key1, key2) : \
+        (key1) == (key2))
+
+#define dictHashKey(ht, key) (ht)->type->hashFunction(key)
+
+#define dictGetEntryKey(he) ((he)->key)
+#define dictGetEntryVal(he) ((he)->val)
+#define dictSlots(ht) ((ht)->size)
+#define dictSize(ht) ((ht)->used)
+
+/* API */
+unsigned int dictGenHashFunction(const unsigned char *buf, int len);
+dict *dictCreate(dictType *type, void *privDataPtr);
+int dictExpand(dict *ht, unsigned long size);
+int dictAdd(dict *ht, void *key, void *val);
+int dictReplace(dict *ht, void *key, void *val);
+int dictDelete(dict *ht, const void *key);
+void dictRelease(dict *ht);
+dictEntry * dictFind(dict *ht, const void *key);
+void dictInitIterator(dictIterator *iter, dict *ht);
+dictEntry *dictNext(dictIterator *iter);
+
+#endif /* __DICT_H */

libvalkey-4.0.1/vendor/libvalkey/include/valkey/net.h

@@ -0,0 +1,57 @@
+/* Extracted from anet.c to work properly with Hiredis error reporting.
+ *
+ * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2010-2014, Pieter Noordhuis <pcnoordhuis at gmail dot com>
+ * Copyright (c) 2015, Matt Stancliff <matt at genges dot com>,
+ *                     Jan-Erik Rediger <janerik at fnordig dot com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef VALKEY_NET_H
+#define VALKEY_NET_H
+
+#include "valkey.h"
+
+void valkeyNetClose(valkeyContext *c);
+ssize_t valkeyNetRead(valkeyContext *c, char *buf, size_t bufcap);
+ssize_t valkeyNetWrite(valkeyContext *c);
+
+int valkeyCheckSocketError(valkeyContext *c);
+int valkeyContextSetTimeout(valkeyContext *c, const struct timeval tv);
+int valkeyContextConnectTcp(valkeyContext *c, const char *addr, int port, const struct timeval *timeout);
+int valkeyContextConnectBindTcp(valkeyContext *c, const char *addr, int port,
+                               const struct timeval *timeout,
+                               const char *source_addr);
+int valkeyContextConnectUnix(valkeyContext *c, const char *path, const struct timeval *timeout);
+int valkeyKeepAlive(valkeyContext *c, int interval);
+int valkeyCheckConnectDone(valkeyContext *c, int *completed);
+
+int valkeySetTcpNoDelay(valkeyContext *c);
+int valkeyContextSetTcpUserTimeout(valkeyContext *c, unsigned int timeout);
+
+#endif

libvalkey-4.0.1/vendor/libvalkey/include/valkey/read.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2009-2011, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2010-2011, Pieter Noordhuis <pcnoordhuis at gmail dot com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef VALKEY_READ_H
+#define VALKEY_READ_H
+#include <stdio.h> /* for size_t */
+
+#define VALKEY_ERR -1
+#define VALKEY_OK 0
+
+/* When an error occurs, the err flag in a context is set to hold the type of
+ * error that occurred. VALKEY_ERR_IO means there was an I/O error and you
+ * should use the "errno" variable to find out what is wrong.
+ * For other values, the "errstr" field will hold a description. */
+#define VALKEY_ERR_IO 1 /* Error in read or write */
+#define VALKEY_ERR_EOF 3 /* End of file */
+#define VALKEY_ERR_PROTOCOL 4 /* Protocol error */
+#define VALKEY_ERR_OOM 5 /* Out of memory */
+#define VALKEY_ERR_TIMEOUT 6 /* Timed out */
+#define VALKEY_ERR_OTHER 2 /* Everything else... */
+
+#define VALKEY_REPLY_STRING 1
+#define VALKEY_REPLY_ARRAY 2
+#define VALKEY_REPLY_INTEGER 3
+#define VALKEY_REPLY_NIL 4
+#define VALKEY_REPLY_STATUS 5
+#define VALKEY_REPLY_ERROR 6
+#define VALKEY_REPLY_DOUBLE 7
+#define VALKEY_REPLY_BOOL 8
+#define VALKEY_REPLY_MAP 9
+#define VALKEY_REPLY_SET 10
+#define VALKEY_REPLY_ATTR 11
+#define VALKEY_REPLY_PUSH 12
+#define VALKEY_REPLY_BIGNUM 13
+#define VALKEY_REPLY_VERB 14
+
+/* Default max unused reader buffer. */
+#define VALKEY_READER_MAX_BUF (1024*16)
+
+/* Default multi-bulk element limit */
+#define VALKEY_READER_MAX_ARRAY_ELEMENTS ((1LL<<32) - 1)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct valkeyReadTask {
+    int type;
+    long long elements; /* number of elements in multibulk container */
+    int idx; /* index in parent (array) object */
+    void *obj; /* holds user-generated value for a read task */
+    struct valkeyReadTask *parent; /* parent task */
+    void *privdata; /* user-settable arbitrary field */
+} valkeyReadTask;
+
+typedef struct valkeyReplyObjectFunctions {
+    void *(*createString)(const valkeyReadTask*, char*, size_t);
+    void *(*createArray)(const valkeyReadTask*, size_t);
+    void *(*createInteger)(const valkeyReadTask*, long long);
+    void *(*createDouble)(const valkeyReadTask*, double, char*, size_t);
+    void *(*createNil)(const valkeyReadTask*);
+    void *(*createBool)(const valkeyReadTask*, int);
+    void (*freeObject)(void*);
+} valkeyReplyObjectFunctions;
+
+typedef struct valkeyReader {
+    int err; /* Error flags, 0 when there is no error */
+    char errstr[128]; /* String representation of error when applicable */
+
+    char *buf; /* Read buffer */
+    size_t pos; /* Buffer cursor */
+    size_t len; /* Buffer length */
+    size_t maxbuf; /* Max length of unused buffer */
+    long long maxelements; /* Max multi-bulk elements */
+
+    valkeyReadTask **task;
+    int tasks;
+
+    int ridx; /* Index of current read task */
+    void *reply; /* Temporary reply pointer */
+
+    valkeyReplyObjectFunctions *fn;
+    void *privdata;
+} valkeyReader;
+
+/* Public API for the protocol parser. */
+valkeyReader *valkeyReaderCreateWithFunctions(valkeyReplyObjectFunctions *fn);
+void valkeyReaderFree(valkeyReader *r);
+int valkeyReaderFeed(valkeyReader *r, const char *buf, size_t len);
+int valkeyReaderGetReply(valkeyReader *r, void **reply);
+
+#define valkeyReaderSetPrivdata(_r, _p) (int)(((valkeyReader*)(_r))->privdata = (_p))
+#define valkeyReaderGetObject(_r) (((valkeyReader*)(_r))->reply)
+#define valkeyReaderGetError(_r) (((valkeyReader*)(_r))->errstr)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif