@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/src/rdaddr.c

@@ -0,0 +1,255 @@
+/*
+ * librd - Rapid Development C library
+ *
+ * Copyright (c) 2012-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. 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.
+ *
+ * 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.
+ */
+
+
+
+#include "rd.h"
+#include "rdaddr.h"
+#include "rdrand.h"
+
+#ifdef _WIN32
+#include <ws2tcpip.h>
+#endif
+
+const char *rd_sockaddr2str(const void *addr, int flags) {
+        const rd_sockaddr_inx_t *a = (const rd_sockaddr_inx_t *)addr;
+        static RD_TLS char ret[32][256];
+        static RD_TLS int reti = 0;
+        char portstr[32];
+        int of      = 0;
+        int niflags = NI_NUMERICSERV;
+        int r;
+
+        reti = (reti + 1) % 32;
+
+        switch (a->sinx_family) {
+        case AF_INET:
+        case AF_INET6:
+                if (flags & RD_SOCKADDR2STR_F_FAMILY)
+                        of += rd_snprintf(&ret[reti][of],
+                                          sizeof(ret[reti]) - of, "ipv%i#",
+                                          a->sinx_family == AF_INET ? 4 : 6);
+
+                if ((flags & RD_SOCKADDR2STR_F_PORT) &&
+                    a->sinx_family == AF_INET6)
+                        ret[reti][of++] = '[';
+
+                if (!(flags & RD_SOCKADDR2STR_F_RESOLVE))
+                        niflags |= NI_NUMERICHOST;
+
+        retry:
+                if ((r = getnameinfo(
+                         (const struct sockaddr *)a, RD_SOCKADDR_INX_LEN(a),
+
+                         ret[reti] + of, sizeof(ret[reti]) - of,
+
+                         (flags & RD_SOCKADDR2STR_F_PORT) ? portstr : NULL,
+
+                         (flags & RD_SOCKADDR2STR_F_PORT) ? sizeof(portstr) : 0,
+
+                         niflags))) {
+
+                        if (r == EAI_AGAIN && !(niflags & NI_NUMERICHOST)) {
+                                /* If unable to resolve name, retry without
+                                 * name resolution. */
+                                niflags |= NI_NUMERICHOST;
+                                goto retry;
+                        }
+                        break;
+                }
+
+
+                if (flags & RD_SOCKADDR2STR_F_PORT) {
+                        size_t len = strlen(ret[reti]);
+                        rd_snprintf(
+                            ret[reti] + len, sizeof(ret[reti]) - len, "%s:%s",
+                            a->sinx_family == AF_INET6 ? "]" : "", portstr);
+                }
+
+                return ret[reti];
+        }
+
+
+        /* Error-case */
+        rd_snprintf(ret[reti], sizeof(ret[reti]), "<unsupported:%s>",
+                    rd_family2str(a->sinx_family));
+
+        return ret[reti];
+}
+
+
+const char *rd_addrinfo_prepare(const char *nodesvc, char **node, char **svc) {
+        static RD_TLS char snode[256];
+        static RD_TLS char ssvc[64];
+        const char *t;
+        const char *svct = NULL;
+        size_t nodelen   = 0;
+
+        *snode = '\0';
+        *ssvc  = '\0';
+
+        if (*nodesvc == '[') {
+                /* "[host]".. (enveloped node name) */
+                if (!(t = strchr(nodesvc, ']')))
+                        return "Missing close-']'";
+                nodesvc++;
+                nodelen = t - nodesvc;
+                svct    = t + 1;
+
+        } else if (*nodesvc == ':' && *(nodesvc + 1) != ':') {
+                /* ":"..  (port only) */
+                nodelen = 0;
+                svct    = nodesvc;
+        }
+
+        if ((svct = strrchr(svct ? svct : nodesvc, ':')) &&
+            (*(svct - 1) != ':') && *(++svct)) {
+                /* Optional ":service" definition. */
+                if (strlen(svct) >= sizeof(ssvc))
+                        return "Service name too long";
+                strcpy(ssvc, svct);
+                if (!nodelen)
+                        nodelen = svct - nodesvc - 1;
+
+        } else if (!nodelen)
+                nodelen = strlen(nodesvc);
+
+        if (nodelen) {
+                /* Truncate nodename if necessary. */
+                nodelen = RD_MIN(nodelen, sizeof(snode) - 1);
+                memcpy(snode, nodesvc, nodelen);
+                snode[nodelen] = '\0';
+        }
+
+        *node = snode;
+        *svc  = ssvc;
+
+        return NULL;
+}
+
+
+
+rd_sockaddr_list_t *
+rd_getaddrinfo(const char *nodesvc,
+               const char *defsvc,
+               int flags,
+               int family,
+               int socktype,
+               int protocol,
+               int (*resolve_cb)(const char *node,
+                                 const char *service,
+                                 const struct addrinfo *hints,
+                                 struct addrinfo **res,
+                                 void *opaque),
+               void *opaque,
+               const char **errstr) {
+        struct addrinfo hints;
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family   = family;
+        hints.ai_socktype = socktype;
+        hints.ai_protocol = protocol;
+        hints.ai_flags    = flags;
+
+        struct addrinfo *ais, *ai;
+        char *node, *svc;
+        int r;
+        int cnt = 0;
+        rd_sockaddr_list_t *rsal;
+
+        if ((*errstr = rd_addrinfo_prepare(nodesvc, &node, &svc))) {
+                errno = EINVAL;
+                return NULL;
+        }
+
+        if (*svc)
+                defsvc = svc;
+
+        if (resolve_cb) {
+                r = resolve_cb(node, defsvc, &hints, &ais, opaque);
+        } else {
+                r = getaddrinfo(node, defsvc, &hints, &ais);
+        }
+
+        if (r) {
+#ifdef EAI_SYSTEM
+                if (r == EAI_SYSTEM)
+#else
+                if (0)
+#endif
+                        *errstr = rd_strerror(errno);
+                else {
+#ifdef _WIN32
+                        *errstr = gai_strerrorA(r);
+#else
+                        *errstr = gai_strerror(r);
+#endif
+                        errno = EFAULT;
+                }
+                return NULL;
+        }
+
+        /* Count number of addresses */
+        for (ai = ais; ai != NULL; ai = ai->ai_next)
+                cnt++;
+
+        if (cnt == 0) {
+                /* unlikely? */
+                if (resolve_cb)
+                        resolve_cb(NULL, NULL, NULL, &ais, opaque);
+                else
+                        freeaddrinfo(ais);
+                errno   = ENOENT;
+                *errstr = "No addresses";
+                return NULL;
+        }
+
+
+        rsal = rd_calloc(1, sizeof(*rsal) + (sizeof(*rsal->rsal_addr) * cnt));
+
+        for (ai = ais; ai != NULL; ai = ai->ai_next)
+                memcpy(&rsal->rsal_addr[rsal->rsal_cnt++], ai->ai_addr,
+                       ai->ai_addrlen);
+
+        if (resolve_cb)
+                resolve_cb(NULL, NULL, NULL, &ais, opaque);
+        else
+                freeaddrinfo(ais);
+
+        /* Shuffle address list for proper round-robin */
+        if (!(flags & RD_AI_NOSHUFFLE))
+                rd_array_shuffle(rsal->rsal_addr, rsal->rsal_cnt,
+                                 sizeof(*rsal->rsal_addr));
+
+        return rsal;
+}
+
+
+
+void rd_sockaddr_list_destroy(rd_sockaddr_list_t *rsal) {
+        rd_free(rsal);
+}

package/deps/librdkafka/src/rdaddr.h

@@ -0,0 +1,202 @@
+/*
+ * librd - Rapid Development C library
+ *
+ * Copyright (c) 2012-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. 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.
+ *
+ * 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 _RDADDR_H_
+#define _RDADDR_H_
+
+#ifndef _WIN32
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#else
+#define WIN32_MEAN_AND_LEAN
+#include <winsock2.h>
+#include <ws2ipdef.h>
+#endif
+
+#if defined(__FreeBSD__) || defined(_AIX) || defined(__OpenBSD__)
+#include <sys/socket.h>
+#endif
+
+/**
+ * rd_sockaddr_inx_t is a union for either ipv4 or ipv6 sockaddrs.
+ * It provides conveniant abstraction of AF_INET* agnostic operations.
+ */
+typedef union {
+        struct sockaddr_in in;
+        struct sockaddr_in6 in6;
+} rd_sockaddr_inx_t;
+#define sinx_family in.sin_family
+#define sinx_addr   in.sin_addr
+#define RD_SOCKADDR_INX_LEN(sinx)                                              \
+        ((sinx)->sinx_family == AF_INET    ? sizeof(struct sockaddr_in)        \
+         : (sinx)->sinx_family == AF_INET6 ? sizeof(struct sockaddr_in6)       \
+                                           : sizeof(rd_sockaddr_inx_t))
+#define RD_SOCKADDR_INX_PORT(sinx)                                             \
+        ((sinx)->sinx_family == AF_INET    ? (sinx)->in.sin_port               \
+         : (sinx)->sinx_family == AF_INET6 ? (sinx)->in6.sin6_port             \
+                                           : 0)
+
+#define RD_SOCKADDR_INX_PORT_SET(sinx, port)                                   \
+        do {                                                                   \
+                if ((sinx)->sinx_family == AF_INET)                            \
+                        (sinx)->in.sin_port = port;                            \
+                else if ((sinx)->sinx_family == AF_INET6)                      \
+                        (sinx)->in6.sin6_port = port;                          \
+        } while (0)
+
+
+
+/**
+ * Returns a thread-local temporary string (may be called up to 32 times
+ * without buffer wrapping) containing the human string representation
+ * of the sockaddr (which should be AF_INET or AF_INET6 at this point).
+ * If the RD_SOCKADDR2STR_F_PORT is provided the port number will be
+ * appended to the string.
+ * IPv6 address enveloping ("[addr]:port") will also be performed
+ * if .._F_PORT is set.
+ */
+#define RD_SOCKADDR2STR_F_PORT 0x1 /* Append the port. */
+#define RD_SOCKADDR2STR_F_RESOLVE                                              \
+        0x2                          /* Try to resolve address to hostname.    \
+                                      */
+#define RD_SOCKADDR2STR_F_FAMILY 0x4 /* Prepend address family. */
+#define RD_SOCKADDR2STR_F_NICE       /* Nice and friendly output */            \
+        (RD_SOCKADDR2STR_F_PORT | RD_SOCKADDR2STR_F_RESOLVE)
+const char *rd_sockaddr2str(const void *addr, int flags);
+
+
+/**
+ * Splits a node:service definition up into their node and svc counterparts
+ * suitable for passing to getaddrinfo().
+ * Returns NULL on success (and temporarily available pointers in '*node'
+ * and '*svc') or error string on failure.
+ *
+ * Thread-safe but returned buffers in '*node' and '*svc' are only
+ * usable until the next call to rd_addrinfo_prepare() in the same thread.
+ */
+const char *rd_addrinfo_prepare(const char *nodesvc, char **node, char **svc);
+
+
+
+typedef struct rd_sockaddr_list_s {
+        int rsal_cnt;
+        int rsal_curr;
+        rd_sockaddr_inx_t rsal_addr[];
+} rd_sockaddr_list_t;
+
+
+/**
+ * Returns the next address from a sockaddr list and updates
+ * the current-index to point to it.
+ *
+ * Typical usage is for round-robin connection attempts or similar:
+ *   while (1) {
+ *       rd_sockaddr_inx_t *sinx = rd_sockaddr_list_next(my_server_list);
+ *       if (do_connect((struct sockaddr *)sinx) == -1) {
+ *          sleep(1);
+ *          continue;
+ *       }
+ *       ...
+ *   }
+ *
+ */
+
+static RD_INLINE rd_sockaddr_inx_t *
+rd_sockaddr_list_next(rd_sockaddr_list_t *rsal) RD_UNUSED;
+static RD_INLINE rd_sockaddr_inx_t *
+rd_sockaddr_list_next(rd_sockaddr_list_t *rsal) {
+        rsal->rsal_curr = (rsal->rsal_curr + 1) % rsal->rsal_cnt;
+        return &rsal->rsal_addr[rsal->rsal_curr];
+}
+
+
+#define RD_SOCKADDR_LIST_FOREACH(sinx, rsal)                                   \
+        for ((sinx) = &(rsal)->rsal_addr[0];                                   \
+             (sinx) < &(rsal)->rsal_addr[(rsal)->rsal_cnt]; (sinx)++)
+
+/**
+ * Wrapper for getaddrinfo(3) that performs these additional tasks:
+ *  - Input is a combined "<node>[:<svc>]" string, with support for
+ *    IPv6 enveloping ("[addr]:port").
+ *  - Returns a rd_sockaddr_list_t which must be freed with
+ *    rd_sockaddr_list_destroy() when done with it.
+ *  - Automatically shuffles the returned address list to provide
+ *    round-robin (unless RD_AI_NOSHUFFLE is provided in 'flags').
+ *
+ * Thread-safe.
+ */
+#define RD_AI_NOSHUFFLE                                                        \
+        0x10000000 /* Dont shuffle returned address list.                      \
+                    * FIXME: Guessing non-used bits like this                  \
+                    *        is a bad idea. */
+
+struct addrinfo;
+
+rd_sockaddr_list_t *
+rd_getaddrinfo(const char *nodesvc,
+               const char *defsvc,
+               int flags,
+               int family,
+               int socktype,
+               int protocol,
+               int (*resolve_cb)(const char *node,
+                                 const char *service,
+                                 const struct addrinfo *hints,
+                                 struct addrinfo **res,
+                                 void *opaque),
+               void *opaque,
+               const char **errstr);
+
+
+
+/**
+ * Frees a sockaddr list.
+ *
+ * Thread-safe.
+ */
+void rd_sockaddr_list_destroy(rd_sockaddr_list_t *rsal);
+
+
+
+/**
+ * Returns the human readable name of a socket family.
+ */
+static const char *rd_family2str(int af) RD_UNUSED;
+static const char *rd_family2str(int af) {
+        switch (af) {
+        case AF_INET:
+                return "inet";
+        case AF_INET6:
+                return "inet6";
+        default:
+                return "af?";
+        };
+}
+
+#endif /* _RDADDR_H_ */

package/deps/librdkafka/src/rdatomic.h

@@ -0,0 +1,230 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2014-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. 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.
+ *
+ * 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 _RDATOMIC_H_
+#define _RDATOMIC_H_
+
+#include "tinycthread.h"
+
+typedef struct {
+        int32_t val;
+#if !defined(_WIN32) && !HAVE_ATOMICS_32
+        mtx_t lock;
+#endif
+} rd_atomic32_t;
+
+typedef struct {
+        int64_t val;
+#if !defined(_WIN32) && !HAVE_ATOMICS_64
+        mtx_t lock;
+#endif
+} rd_atomic64_t;
+
+
+static RD_INLINE RD_UNUSED void rd_atomic32_init(rd_atomic32_t *ra, int32_t v) {
+        ra->val = v;
+#if !defined(_WIN32) && !HAVE_ATOMICS_32
+        mtx_init(&ra->lock, mtx_plain);
+#endif
+}
+
+
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_add(rd_atomic32_t *ra,
+                                                   int32_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_32_nv(&ra->val, v);
+#elif defined(_WIN32)
+        return InterlockedAdd((LONG *)&ra->val, v);
+#elif !HAVE_ATOMICS_32
+        int32_t r;
+        mtx_lock(&ra->lock);
+        ra->val += v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP32(add, fetch, &ra->val, v);
+#endif
+}
+
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_sub(rd_atomic32_t *ra,
+                                                   int32_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_32_nv(&ra->val, -v);
+#elif defined(_WIN32)
+        return InterlockedAdd((LONG *)&ra->val, -v);
+#elif !HAVE_ATOMICS_32
+        int32_t r;
+        mtx_lock(&ra->lock);
+        ra->val -= v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP32(sub, fetch, &ra->val, v);
+#endif
+}
+
+/**
+ * @warning The returned value is the nominal value and will be outdated
+ *          by the time the application reads it.
+ *          It should not be used for exact arithmetics, any correlation
+ *          with other data is unsynchronized, meaning that two atomics,
+ *          or one atomic and a mutex-protected piece of data have no
+ *          common synchronization and can't be relied on.
+ */
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_get(rd_atomic32_t *ra) {
+#if defined(_WIN32) || defined(__SUNPRO_C)
+        return ra->val;
+#elif !HAVE_ATOMICS_32
+        int32_t r;
+        mtx_lock(&ra->lock);
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP32(fetch, add, &ra->val, 0);
+#endif
+}
+
+/**
+ * @brief Set the atomic value to \p v and return the previous value to
+ *        that can be used to determine if the value was changed.
+ */
+static RD_INLINE int32_t RD_UNUSED rd_atomic32_set(rd_atomic32_t *ra,
+                                                   int32_t v) {
+#ifdef _WIN32
+        return InterlockedExchange((LONG *)&ra->val, v);
+#elif !HAVE_ATOMICS_32
+        int32_t r;
+        mtx_lock(&ra->lock);
+        r       = rd->val;
+        ra->val = v;
+        mtx_unlock(&ra->lock);
+        return r;
+#elif HAVE_ATOMICS_32_ATOMIC
+        return __atomic_exchange_n(&ra->val, v, __ATOMIC_SEQ_CST);
+#elif HAVE_ATOMICS_32_SYNC
+        return __sync_lock_test_and_set(&ra->val, v);
+#else
+        return ra->val = v;  // FIXME
+#endif
+}
+
+
+
+static RD_INLINE RD_UNUSED void rd_atomic64_init(rd_atomic64_t *ra, int64_t v) {
+        ra->val = v;
+#if !defined(_WIN32) && !HAVE_ATOMICS_64
+        mtx_init(&ra->lock, mtx_plain);
+#endif
+}
+
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_add(rd_atomic64_t *ra,
+                                                   int64_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_64_nv(&ra->val, v);
+#elif defined(_WIN32)
+        return InterlockedAdd64(&ra->val, v);
+#elif !HAVE_ATOMICS_64
+        int64_t r;
+        mtx_lock(&ra->lock);
+        ra->val += v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP64(add, fetch, &ra->val, v);
+#endif
+}
+
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_sub(rd_atomic64_t *ra,
+                                                   int64_t v) {
+#ifdef __SUNPRO_C
+        return atomic_add_64_nv(&ra->val, -v);
+#elif defined(_WIN32)
+        return InterlockedAdd64(&ra->val, -v);
+#elif !HAVE_ATOMICS_64
+        int64_t r;
+        mtx_lock(&ra->lock);
+        ra->val -= v;
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP64(sub, fetch, &ra->val, v);
+#endif
+}
+
+/**
+ * @warning The returned value is the nominal value and will be outdated
+ *          by the time the application reads it.
+ *          It should not be used for exact arithmetics, any correlation
+ *          with other data is unsynchronized, meaning that two atomics,
+ *          or one atomic and a mutex-protected piece of data have no
+ *          common synchronization and can't be relied on.
+ *          Use with care.
+ */
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_get(rd_atomic64_t *ra) {
+#if defined(_WIN32) || defined(__SUNPRO_C)
+        return InterlockedCompareExchange64(&ra->val, 0, 0);
+#elif !HAVE_ATOMICS_64
+        int64_t r;
+        mtx_lock(&ra->lock);
+        r = ra->val;
+        mtx_unlock(&ra->lock);
+        return r;
+#else
+        return ATOMIC_OP64(fetch, add, &ra->val, 0);
+#endif
+}
+
+/**
+ * @brief Set the atomic value to \p v and return the previous value to
+ *        that can be used to determine if the value was changed.
+ */
+static RD_INLINE int64_t RD_UNUSED rd_atomic64_set(rd_atomic64_t *ra,
+                                                   int64_t v) {
+#ifdef _WIN32
+        return InterlockedExchange64(&ra->val, v);
+#elif !HAVE_ATOMICS_64
+        int64_t r;
+        mtx_lock(&ra->lock);
+        r       = ra->val;
+        ra->val = v;
+        mtx_unlock(&ra->lock);
+        return r;
+#elif HAVE_ATOMICS_64_ATOMIC
+        return __atomic_exchange_n(&ra->val, v, __ATOMIC_SEQ_CST);
+#elif HAVE_ATOMICS_64_SYNC
+        return __sync_lock_test_and_set(&ra->val, v);
+#else
+        return ra->val = v;  // FIXME
+#endif
+}
+
+#endif /* _RDATOMIC_H_ */