@point3/node-rdkafka 3.6.0-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,80 @@
+/*
+ * 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"
+
+int rd_jitter(int low, int high) {
+        int rand_num;
+#if HAVE_RAND_R
+        static RD_TLS unsigned int seed = 0;
+
+        /* Initial seed with time+thread id */
+        if (unlikely(seed == 0)) {
+                struct timeval tv;
+                rd_gettimeofday(&tv, NULL);
+                seed = (unsigned int)(tv.tv_usec);
+                seed ^= (unsigned int)(intptr_t)thrd_current();
+
+                /* When many threads are created at the same time and the
+                 * thread id is different only by a few bits it's possible that
+                 * `rand_r`, that is initially multiplying by `1103515245`,
+                 * truncates the variable bits and uses the same seed for
+                 * different threads. By applying `murmur2` we ensure that seed
+                 * variability is distributed across various bits at different
+                 * positions. */
+                seed = (unsigned int)rd_murmur2(&seed, sizeof(seed));
+        }
+
+        rand_num = rand_r(&seed);
+#else
+        rand_num = rand();
+#endif
+        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,43 @@
+/*
+ * 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_
+
+
+/**
+ * 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_ */

package/deps/librdkafka/src/rdregex.c

@@ -0,0 +1,156 @@
+/*
+ * librdkafka - The Apache Kafka C/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.
+ */
+
+
+#include "rd.h"
+#include "rdstring.h"
+#include "rdregex.h"
+
+#if HAVE_REGEX
+#include <regex.h>
+struct rd_regex_s {
+        regex_t re;
+};
+
+#else
+
+#include "regexp.h"
+struct rd_regex_s {
+        Reprog *re;
+};
+#endif
+
+
+/**
+ * @brief Destroy compiled regex
+ */
+void rd_regex_destroy(rd_regex_t *re) {
+#if HAVE_REGEX
+        regfree(&re->re);
+#else
+        re_regfree(re->re);
+#endif
+        rd_free(re);
+}
+
+
+/**
+ * @brief Compile regex \p pattern
+ * @returns Compiled regex object on success on error.
+ */
+rd_regex_t *
+rd_regex_comp(const char *pattern, char *errstr, size_t errstr_size) {
+        rd_regex_t *re = rd_calloc(1, sizeof(*re));
+#if HAVE_REGEX
+        int r;
+
+        r = regcomp(&re->re, pattern, REG_EXTENDED | REG_NOSUB);
+        if (r) {
+                if (errstr)
+                        regerror(r, &re->re, errstr, errstr_size);
+                rd_free(re);
+                return NULL;
+        }
+#else
+        const char *errstr2;
+
+        re->re = re_regcomp(pattern, 0, &errstr2);
+        if (!re->re) {
+                if (errstr)
+                        rd_strlcpy(errstr, errstr2, errstr_size);
+                rd_free(re);
+                return NULL;
+        }
+#endif
+
+        return re;
+}
+
+
+/**
+ * @brief Match \p str to pre-compiled regex \p re
+ * @returns 1 on match, else 0
+ */
+int rd_regex_exec(rd_regex_t *re, const char *str) {
+#if HAVE_REGEX
+        return regexec(&re->re, str, 0, NULL, 0) != REG_NOMATCH;
+#else
+        return !re_regexec(re->re, str, NULL, 0);
+#endif
+}
+
+
+/**
+ * @brief Perform regex match of \p str using regex \p pattern.
+ *
+ * @returns 1 on match, 0 on non-match or -1 on regex compilation error
+ *          in which case a human readable error string is written to
+ *          \p errstr (if not NULL).
+ */
+int rd_regex_match(const char *pattern,
+                   const char *str,
+                   char *errstr,
+                   size_t errstr_size) {
+#if HAVE_REGEX /* use libc regex */
+        regex_t re;
+        int r;
+
+        /* FIXME: cache compiled regex */
+        r = regcomp(&re, pattern, REG_EXTENDED | REG_NOSUB);
+        if (r) {
+                if (errstr)
+                        regerror(r, &re, errstr, errstr_size);
+                return 0;
+        }
+
+        r = regexec(&re, str, 0, NULL, 0) != REG_NOMATCH;
+
+        regfree(&re);
+
+        return r;
+
+#else /* Using regexp.h from minilibs (included) */
+        Reprog *re;
+        int r;
+        const char *errstr2;
+
+        /* FIXME: cache compiled regex */
+        re = re_regcomp(pattern, 0, &errstr2);
+        if (!re) {
+                if (errstr)
+                        rd_strlcpy(errstr, errstr2, errstr_size);
+                return -1;
+        }
+
+        r = !re_regexec(re, str, NULL, 0);
+
+        re_regfree(re);
+
+        return r;
+#endif
+}

package/deps/librdkafka/src/rdregex.h

@@ -0,0 +1,43 @@
+/*
+ * librdkafka - The Apache Kafka C/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 _RDREGEX_H_
+#define _RDREGEX_H_
+
+typedef struct rd_regex_s rd_regex_t;
+
+void rd_regex_destroy(rd_regex_t *re);
+rd_regex_t *
+rd_regex_comp(const char *pattern, char *errstr, size_t errstr_size);
+int rd_regex_exec(rd_regex_t *re, const char *str);
+
+int rd_regex_match(const char *pattern,
+                   const char *str,
+                   char *errstr,
+                   size_t errstr_size);
+
+#endif /* _RDREGEX_H_ */