@platformatic/rdkafka 4.0.0 → 4.1.0-alpha.1

package/deps/librdkafka/src/rdatomic.h

@@ -111,6 +111,10 @@ static RD_INLINE int32_t RD_UNUSED rd_atomic32_get(rd_atomic32_t *ra) {
 #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
@@ -118,15 +122,14 @@ static RD_INLINE int32_t RD_UNUSED rd_atomic32_set(rd_atomic32_t *ra,
 #elif !HAVE_ATOMICS_32
         int32_t r;
         mtx_lock(&ra->lock);
-        r = ra->val = v;
+        r       = rd->val;
+        ra->val = v;
         mtx_unlock(&ra->lock);
         return r;
 #elif HAVE_ATOMICS_32_ATOMIC
-        __atomic_store_n(&ra->val, v, __ATOMIC_SEQ_CST);
-        return v;
+        return __atomic_exchange_n(&ra->val, v, __ATOMIC_SEQ_CST);
 #elif HAVE_ATOMICS_32_SYNC
-        (void)__sync_lock_test_and_set(&ra->val, v);
-        return v;
+        return __sync_lock_test_and_set(&ra->val, v);
 #else
         return ra->val = v;  // FIXME
 #endif
@@ -200,7 +203,10 @@ static RD_INLINE int64_t RD_UNUSED rd_atomic64_get(rd_atomic64_t *ra) {
 #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
@@ -208,16 +214,14 @@ static RD_INLINE int64_t RD_UNUSED rd_atomic64_set(rd_atomic64_t *ra,
 #elif !HAVE_ATOMICS_64
         int64_t r;
         mtx_lock(&ra->lock);
-        ra->val = v;
         r       = ra->val;
+        ra->val = v;
         mtx_unlock(&ra->lock);
         return r;
 #elif HAVE_ATOMICS_64_ATOMIC
-        __atomic_store_n(&ra->val, v, __ATOMIC_SEQ_CST);
-        return v;
+        return __atomic_exchange_n(&ra->val, v, __ATOMIC_SEQ_CST);
 #elif HAVE_ATOMICS_64_SYNC
-        (void)__sync_lock_test_and_set(&ra->val, v);
-        return v;
+        return __sync_lock_test_and_set(&ra->val, v);
 #else
         return ra->val = v;  // FIXME
 #endif

package/deps/librdkafka/src/rdavg.h

@@ -45,8 +45,9 @@ typedef struct rd_avg_s {
         } ra_v;
         mtx_t ra_lock;
         int ra_enabled;
-        enum { RD_AVG_GAUGE,
-               RD_AVG_COUNTER,
+        enum {
+                RD_AVG_GAUGE,
+                RD_AVG_COUNTER,
         } ra_type;
 #if WITH_HDRHISTOGRAM
         rd_hdr_histogram_t *ra_hdr;

package/deps/librdkafka/src/rdbase64.c

@@ -32,7 +32,7 @@
 #include <openssl/ssl.h>
 #else
 
-#define conv_bin2ascii(a, table) ((table)[(a)&0x3f])
+#define conv_bin2ascii(a, table) ((table)[(a) & 0x3f])
 
 static const unsigned char data_bin2ascii[65] =
     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -119,6 +119,37 @@ char *rd_base64_encode_str(const rd_chariov_t *in) {
         return out.ptr;
 }
 
+/**
+ * @brief Base64 encode binary input \p in and return a newly allocated,
+ *        base64-encoded string with URL-safe characters.
+ * @returns a newly allocated, base64-encoded string or NULL in case of some
+ *          issue with the conversion or the conversion is not supported.
+ *
+ * @remark Returned string must be freed after use.
+ */
+char *rd_base64_encode_str_urlsafe(const rd_chariov_t *in) {
+        rd_chariov_t out;
+        char *p;
+        rd_base64_encode(in, &out);
+
+        /* Replace + with - and / with _ */
+        for (p = out.ptr; *p; p++) {
+                if (*p == '+')
+                        *p = '-';
+                else if (*p == '/')
+                        *p = '_';
+        }
+
+        /* Remove padding '=' characters */
+        int newlen = strlen(out.ptr);
+        while (newlen > 0 && out.ptr[newlen - 1] == '=') {
+                out.ptr[newlen - 1] = '\0';
+                newlen--;
+        }
+
+        out.size = newlen;
+        return out.ptr;
+}
 
 /**
  * @brief Base64 decode input string \p in. Ignores leading and trailing
@@ -166,4 +197,4 @@ int rd_base64_decode(const rd_chariov_t *in, rd_chariov_t *out) {
 #else
         return -2;
 #endif
-}
+}

package/deps/librdkafka/src/rdbase64.h

@@ -36,6 +36,8 @@ void rd_base64_encode(const rd_chariov_t *in, rd_chariov_t *out);
 
 char *rd_base64_encode_str(const rd_chariov_t *in);
 
+char *rd_base64_encode_str_urlsafe(const rd_chariov_t *in);
+
 int rd_base64_decode(const rd_chariov_t *in, rd_chariov_t *out);
 
 #endif /* _RDBASE64_H_ */

package/deps/librdkafka/src/rdendian.h

@@ -125,16 +125,17 @@
 #define be32toh(x) (x)
 #define be16toh(x) (x)
 #define le32toh(x)                                                             \
-        ((((x)&0xff) << 24) | (((x)&0xff00) << 8) | (((x)&0xff0000) >> 8) |    \
-         (((x)&0xff000000) >> 24))
+        ((((x) & 0xff) << 24) | (((x) & 0xff00) << 8) |                        \
+         (((x) & 0xff0000) >> 8) | (((x) & 0xff000000) >> 24))
 #define le64toh(x)                                                             \
-        ((((x)&0x00000000000000ffL) << 56) |                                   \
-         (((x)&0x000000000000ff00L) << 40) |                                   \
-         (((x)&0x0000000000ff0000L) << 24) |                                   \
-         (((x)&0x00000000ff000000L) << 8) | (((x)&0x000000ff00000000L) >> 8) | \
-         (((x)&0x0000ff0000000000L) >> 24) |                                   \
-         (((x)&0x00ff000000000000L) >> 40) |                                   \
-         (((x)&0xff00000000000000L) >> 56))
+        ((((x) & 0x00000000000000ffL) << 56) |                                 \
+         (((x) & 0x000000000000ff00L) << 40) |                                 \
+         (((x) & 0x0000000000ff0000L) << 24) |                                 \
+         (((x) & 0x00000000ff000000L) << 8) |                                  \
+         (((x) & 0x000000ff00000000L) >> 8) |                                  \
+         (((x) & 0x0000ff0000000000L) >> 24) |                                 \
+         (((x) & 0x00ff000000000000L) >> 40) |                                 \
+         (((x) & 0xff00000000000000L) >> 56))
 #else
 #include <endian.h>
 #endif