@ohos-ports/confluentinc-kafka-javascript 1.10.0-beta.1

package/deps/librdkafka/src/rdports.c

@@ -0,0 +1,61 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2016-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.
+ */
+
+/**
+ * System portability
+ */
+
+#include "rd.h"
+
+
+#include <stdlib.h>
+
+/**
+ * qsort_r substitute
+ * This nicely explains why we wont bother with the native implementation
+ * on Win32 (qsort_s), OSX/FreeBSD (qsort_r with diff args):
+ * http://forum.theorex.tech/t/different-declarations-of-qsort-r-on-mac-and-linux/93/2
+ */
+static RD_TLS int (*rd_qsort_r_cmp)(const void *, const void *, void *);
+static RD_TLS void *rd_qsort_r_arg;
+
+static RD_UNUSED int rd_qsort_r_trampoline(const void *a, const void *b) {
+        return rd_qsort_r_cmp(a, b, rd_qsort_r_arg);
+}
+
+void rd_qsort_r(void *base,
+                size_t nmemb,
+                size_t size,
+                int (*compar)(const void *, const void *, void *),
+                void *arg) {
+        rd_qsort_r_cmp = compar;
+        rd_qsort_r_arg = arg;
+        qsort(base, nmemb, size, rd_qsort_r_trampoline);
+        rd_qsort_r_cmp = NULL;
+        rd_qsort_r_arg = NULL;
+}

package/deps/librdkafka/src/rdports.h

@@ -0,0 +1,38 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2016-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 _RDPORTS_H_
+#define _RDPORTS_H_
+
+
+void rd_qsort_r(void *base,
+                size_t nmemb,
+                size_t size,
+                int (*compar)(const void *, const void *, void *),
+                void *arg);
+
+#endif /* _RDPORTS_H_ */

package/deps/librdkafka/src/rdposix.h

@@ -0,0 +1,250 @@
+/*
+ * librdkafka - Apache Kafka 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.
+ */
+
+/**
+ * POSIX system support
+ */
+#ifndef _RDPOSIX_H_
+#define _RDPOSIX_H_
+
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/time.h>
+#include <inttypes.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+
+/**
+ * Types
+ */
+
+
+/**
+ * Annotations, attributes, optimizers
+ */
+#ifndef likely
+#define likely(x) __builtin_expect((x), 1)
+#endif
+#ifndef unlikely
+#define unlikely(x) __builtin_expect((x), 0)
+#endif
+
+#define RD_UNUSED             __attribute__((unused))
+#define RD_INLINE             inline
+#define RD_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+#define RD_NORETURN           __attribute__((noreturn))
+#define RD_IS_CONSTANT(p)     __builtin_constant_p((p))
+#define RD_TLS                __thread
+
+/**
+ * Allocation
+ */
+#if !defined(__FreeBSD__) && !defined(__OpenBSD__)
+/* alloca(3) is in stdlib on FreeBSD */
+#include <alloca.h>
+#endif
+
+#define rd_alloca(N) alloca(N)
+
+
+/**
+ * Strings, formatting, printf, ..
+ */
+
+/* size_t and ssize_t format strings */
+#define PRIusz "zu"
+#define PRIdsz "zd"
+
+#ifndef RD_FORMAT
+#define RD_FORMAT(...) __attribute__((format(__VA_ARGS__)))
+#endif
+#define rd_snprintf(...)  snprintf(__VA_ARGS__)
+#define rd_vsnprintf(...) vsnprintf(__VA_ARGS__)
+
+#define rd_strcasecmp(A, B)     strcasecmp(A, B)
+#define rd_strncasecmp(A, B, N) strncasecmp(A, B, N)
+
+
+#ifdef HAVE_STRCASESTR
+#define rd_strcasestr(HAYSTACK, NEEDLE) strcasestr(HAYSTACK, NEEDLE)
+#else
+#define rd_strcasestr(HAYSTACK, NEEDLE) _rd_strcasestr(HAYSTACK, NEEDLE)
+#endif
+
+
+/**
+ * Errors
+ */
+
+
+#define rd_set_errno(err) (errno = (err))
+
+#if HAVE_STRERROR_R
+static RD_INLINE RD_UNUSED const char *rd_strerror(int err) {
+        static RD_TLS char ret[128];
+
+#if defined(__GLIBC__) && defined(_GNU_SOURCE)
+        return strerror_r(err, ret, sizeof(ret));
+#else /* XSI version */
+        int r;
+        /* The r assignment is to catch the case where
+         * _GNU_SOURCE is not defined but the GNU version is
+         * picked up anyway. */
+        r = strerror_r(err, ret, sizeof(ret));
+        if (unlikely(r))
+                rd_snprintf(ret, sizeof(ret), "strerror_r(%d) failed (ret %d)",
+                            err, r);
+        return ret;
+#endif
+}
+#else
+#define rd_strerror(err) strerror(err)
+#endif
+
+
+/**
+ * Atomics
+ */
+#include "rdatomic.h"
+
+/**
+ * Misc
+ */
+
+/**
+ * Microsecond sleep.
+ * Will retry on signal interrupt unless *terminate is true.
+ */
+static RD_INLINE RD_UNUSED void rd_usleep(int usec, rd_atomic32_t *terminate) {
+        struct timespec req = {usec / 1000000, (long)(usec % 1000000) * 1000};
+
+        /* Retry until complete (issue #272), unless terminating. */
+        while (nanosleep(&req, &req) == -1 &&
+               (errno == EINTR && (!terminate || !rd_atomic32_get(terminate))))
+                ;
+}
+
+
+
+#define rd_gettimeofday(tv, tz) gettimeofday(tv, tz)
+
+
+#ifndef __COVERITY__
+#define rd_assert(EXPR) assert(EXPR)
+#else
+extern void __coverity_panic__(void);
+#define rd_assert(EXPR)                                                        \
+        do {                                                                   \
+                if (!(EXPR))                                                   \
+                        __coverity_panic__();                                  \
+        } while (0)
+#endif
+
+
+static RD_INLINE RD_UNUSED const char *rd_getenv(const char *env,
+                                                 const char *def) {
+        const char *tmp;
+        tmp = getenv(env);
+        if (tmp && *tmp)
+                return tmp;
+        return def;
+}
+
+
+/**
+ * Empty struct initializer
+ */
+#define RD_ZERO_INIT                                                           \
+        {}
+
+/**
+ * Sockets, IO
+ */
+
+/** @brief Socket type */
+typedef int rd_socket_t;
+
+/** @brief Socket API error return value */
+#define RD_SOCKET_ERROR (-1)
+
+/** @brief Last socket error */
+#define rd_socket_errno errno
+
+
+/** @brief String representation of socket error */
+#define rd_socket_strerror(ERR) rd_strerror(ERR)
+
+/** @brief poll() struct type */
+typedef struct pollfd rd_pollfd_t;
+
+/** @brief poll(2) */
+#define rd_socket_poll(POLLFD, FDCNT, TIMEOUT_MS)                              \
+        poll(POLLFD, FDCNT, TIMEOUT_MS)
+
+/**
+ * @brief Set socket to non-blocking
+ * @returns 0 on success or errno on failure.
+ */
+static RD_UNUSED int rd_fd_set_nonblocking(int fd) {
+        int fl = fcntl(fd, F_GETFL, 0);
+        if (fl == -1 || fcntl(fd, F_SETFL, fl | O_NONBLOCK) == -1)
+                return errno;
+        return 0;
+}
+
+/**
+ * @brief Create non-blocking pipe
+ * @returns 0 on success or errno on failure
+ */
+static RD_UNUSED int rd_pipe_nonblocking(rd_socket_t *fds) {
+        if (pipe(fds) == -1 || rd_fd_set_nonblocking(fds[0]) == -1 ||
+            rd_fd_set_nonblocking(fds[1]))
+                return errno;
+
+                /* Minimize buffer sizes to avoid a large number
+                 * of signaling bytes to accumulate when
+                 * io-signalled queue is not being served for a while. */
+#ifdef F_SETPIPE_SZ
+        /* Linux automatically rounds the pipe size up
+         * to the minimum size. */
+        fcntl(fds[0], F_SETPIPE_SZ, 100);
+        fcntl(fds[1], F_SETPIPE_SZ, 100);
+#endif
+        return 0;
+}
+#define rd_socket_read(fd, buf, sz)  read(fd, buf, sz)
+#define rd_socket_write(fd, buf, sz) write(fd, buf, sz)
+#define rd_socket_close(fd)          close(fd)
+
+/* File IO */
+#define rd_write(fd, buf, sz)      write(fd, buf, sz)
+#define rd_open(path, flags, mode) open(path, flags, mode)
+#define rd_close(fd)               close(fd)
+
+#endif /* _RDPOSIX_H_ */

package/deps/librdkafka/src/rdrand.c

@@ -0,0 +1,151 @@
+/*
+ * 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 "rdrand.h"
+#include "rdtime.h"
+#include "tinycthread.h"
+#include "rdmurmur2.h"
+
+#ifdef HAVE_OSSL_SECURE_RAND_BYTES
+#include <openssl/rand.h>
+#endif
+#if HAVE_GETENTROPY
+/* getentropy() can be present in one of these two */
+#include <unistd.h>
+#include <sys/random.h>
+#endif
+
+/* Initial seed with time+thread id */
+unsigned int rd_seed() {
+        unsigned int seed = 0, rand_bytes_seed = 0;
+        struct timeval tv;
+
+        if (rd_rand_bytes((unsigned char *)&rand_bytes_seed,
+                          sizeof(rand_bytes_seed)))
+                return rand_bytes_seed;
+
+        rd_gettimeofday(&tv, NULL);
+        seed = (unsigned int)(tv.tv_usec);
+        seed ^= thrd_current_id();
+
+        /* Apply the murmur2 hash to distribute entropy to
+         * the whole seed. */
+        seed = (unsigned int)rd_murmur2(&seed, sizeof(seed));
+        return seed;
+}
+
+static int rd_rand() {
+        int rand_num;
+#if HAVE_RAND_R
+        static RD_TLS unsigned int seed = 0;
+        if (unlikely(seed == 0)) {
+                seed = rd_seed();
+        }
+        rand_num = rand_r(&seed);
+#else
+        rand_num = rand();
+#endif
+        return rand_num;
+}
+
+#if HAVE_OSSL_SECURE_RAND_BYTES
+static rd_bool_t rd_rand_bytes_by_ossl(unsigned char *buf, int num) {
+        int res     = -1;
+        int retries = 0;
+        while ((res = RAND_priv_bytes(buf, num)) != 1) {
+                if (++retries == 5)
+                        break;
+
+                rd_usleep(1000, 0); /* wait for more entropy */
+        }
+        return res == 1;
+}
+#endif
+
+#ifdef _WIN32
+static rd_bool_t rd_rand_bytes_by_rand_s(unsigned char *buf, int num) {
+        unsigned int rand, retries = 0;
+        while (num > 0) {
+                errno_t err;
+                int i;
+                while ((err = rand_s(&rand)) != 0) {
+                        if (++retries == 5)
+                                return rd_false;
+                        rd_usleep(1000, 0); /* wait for more entropy */
+                }
+                retries = 0;
+                i       = sizeof(int);
+                while (i-- > 0 && num > 0) {
+                        *buf++ = (unsigned char)(rand & 0xff);
+                        rand >>= 8;
+                        num--;
+                }
+        }
+        return rd_true;
+}
+#endif
+
+rd_bool_t rd_rand_bytes(unsigned char *buf, unsigned int num) {
+#if HAVE_OSSL_SECURE_RAND_BYTES
+        if (rd_rand_bytes_by_ossl(buf, num))
+                return rd_true;
+#endif
+#if HAVE_GETENTROPY
+        if (getentropy(buf, (size_t)num) == 0)
+                return rd_true;
+#endif
+#ifdef _WIN32
+        if (rd_rand_bytes_by_rand_s(buf, num))
+                return rd_true;
+#endif
+        return rd_false;
+}
+
+int rd_jitter(int low, int high) {
+        int rand_num = rd_rand();
+        return (low + (rand_num % ((high - low) + 1)));
+}
+
+void rd_array_shuffle(void *base, size_t nmemb, size_t entry_size) {
+        int i;
+        void *tmp = rd_alloca(entry_size);
+
+        /* FIXME: Optimized version for word-sized entries. */
+
+        for (i = (int)nmemb - 1; i > 0; i--) {
+                int j = rd_jitter(0, i);
+                if (unlikely(i == j))
+                        continue;
+
+                memcpy(tmp, (char *)base + (i * entry_size), entry_size);
+                memcpy((char *)base + (i * entry_size),
+                       (char *)base + (j * entry_size), entry_size);
+                memcpy((char *)base + (j * entry_size), tmp, entry_size);
+        }
+}

package/deps/librdkafka/src/rdrand.h

@@ -0,0 +1,72 @@
+/*
+ * 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 _RDRAND_H_
+#define _RDRAND_H_
+
+#if WITH_SSL
+#include <openssl/crypto.h>
+#if OPENSSL_VERSION_NUMBER >= 0x10101000L
+#define HAVE_OSSL_SECURE_RAND_BYTES 1
+#define HAVE_SECURE_RAND_BYTES      1
+#endif
+#endif
+#ifndef HAVE_OSSL_SECURE_RAND_BYTES
+#if HAVE_GETENTROPY || defined(_WIN32)
+#define HAVE_SECURE_RAND_BYTES 1
+#else
+#define HAVE_SECURE_RAND_BYTES 0
+#endif
+#endif
+
+/**
+ * Returns a (non-secure) random seed for a pseudo-random number generator.
+ */
+unsigned int rd_seed();
+
+/**
+ * Fills \p buf with \p num cryptographically secure random bytes.
+ *
+ * @param buf Buffer to fill.
+ * @param num Number of bytes to generate.
+ *
+ * @return rd_true on success, rd_false on failure.
+ */
+rd_bool_t rd_rand_bytes(unsigned char *buf, unsigned int num);
+
+/**
+ * Returns a random (using rand(3)) number between 'low'..'high' (inclusive).
+ */
+int rd_jitter(int low, int high);
+
+/**
+ * Shuffles (randomizes) an array using the modern Fisher-Yates algorithm.
+ */
+void rd_array_shuffle(void *base, size_t nmemb, size_t entry_size);
+
+#endif /* _RDRAND_H_ */