@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/src/rddl.c

@@ -0,0 +1,179 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2017-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 "rddl.h"
+
+#if WITH_LIBDL
+#include <dlfcn.h>
+
+#elif defined(_WIN32)
+
+#else
+#error "Dynamic library loading not supported on this platform"
+#endif
+
+
+
+/**
+ * @brief Latest thread-local dl error, normalized to suit our logging.
+ * @returns a newly allocated string that must be freed
+ */
+static char *rd_dl_error(void) {
+#if WITH_LIBDL
+        char *errstr;
+        char *s;
+        errstr = dlerror();
+        if (!errstr)
+                return rd_strdup("No error returned from dlerror()");
+
+        errstr = rd_strdup(errstr);
+        /* Change newlines to separators. */
+        while ((s = strchr(errstr, '\n')))
+                *s = '.';
+
+        return errstr;
+
+#elif defined(_WIN32)
+        char buf[1024];
+        rd_strerror_w32(GetLastError(), buf, sizeof(buf));
+        return rd_strdup(buf);
+#endif
+}
+
+/**
+ * @brief Attempt to load library \p path.
+ * @returns the library handle (platform dependent, thus opaque) on success,
+ *          else NULL.
+ */
+static rd_dl_hnd_t *
+rd_dl_open0(const char *path, char *errstr, size_t errstr_size) {
+        void *handle;
+        const char *loadfunc;
+#if WITH_LIBDL
+        loadfunc = "dlopen()";
+        handle   = dlopen(path, RTLD_NOW | RTLD_LOCAL);
+#elif defined(_WIN32)
+        loadfunc = "LoadLibrary()";
+        handle   = (void *)LoadLibraryA(path);
+#endif
+        if (!handle) {
+                char *dlerrstr = rd_dl_error();
+                rd_snprintf(errstr, errstr_size, "%s failed: %s", loadfunc,
+                            dlerrstr);
+                rd_free(dlerrstr);
+        }
+        return (rd_dl_hnd_t *)handle;
+}
+
+
+/**
+ * @brief Attempt to load library \p path, possibly with a filename extension
+ *        which will be automatically resolved depending on platform.
+ * @returns the library handle (platform dependent, thus opaque) on success,
+ *          else NULL.
+ */
+rd_dl_hnd_t *rd_dl_open(const char *path, char *errstr, size_t errstr_size) {
+        rd_dl_hnd_t *handle;
+        char *extpath;
+        size_t pathlen;
+        const char *td, *fname;
+        const char *solib_ext = SOLIB_EXT;
+
+        /* Try original path first. */
+        handle = rd_dl_open0(path, errstr, errstr_size);
+        if (handle)
+                return handle;
+
+        /* Original path not found, see if we can append the solib_ext
+         * filename extension. */
+
+        /* Get filename and filename extension.
+         * We can't rely on basename(3) since it is not portable */
+        fname = strrchr(path, '/');
+#ifdef _WIN32
+        td = strrchr(path, '\\');
+        if (td > fname)
+                fname = td;
+#endif
+        if (!fname)
+                fname = path;
+
+        td = strrchr(fname, '.');
+
+        /* If there is a filename extension ('.' within the last characters)
+         * then bail out, we will not append an extension in this case. */
+        if (td && td >= fname + strlen(fname) - strlen(SOLIB_EXT))
+                return NULL;
+
+        /* Append platform-specific library extension. */
+        pathlen = strlen(path);
+        extpath = rd_alloca(pathlen + strlen(solib_ext) + 1);
+        memcpy(extpath, path, pathlen);
+        memcpy(extpath + pathlen, solib_ext, strlen(solib_ext) + 1);
+
+        /* Try again with extension */
+        return rd_dl_open0(extpath, errstr, errstr_size);
+}
+
+
+/**
+ * @brief Close handle previously returned by rd_dl_open()
+ * @remark errors are ignored (what can we do anyway?)
+ */
+void rd_dl_close(rd_dl_hnd_t *handle) {
+#if WITH_LIBDL
+        dlclose((void *)handle);
+#elif defined(_WIN32)
+        FreeLibrary((HMODULE)handle);
+#endif
+}
+
+/**
+ * @brief look up address of \p symbol in library handle \p handle
+ * @returns the function pointer on success or NULL on error.
+ */
+void *rd_dl_sym(rd_dl_hnd_t *handle,
+                const char *symbol,
+                char *errstr,
+                size_t errstr_size) {
+        void *func;
+#if WITH_LIBDL
+        func = dlsym((void *)handle, symbol);
+#elif defined(_WIN32)
+        func = GetProcAddress((HMODULE)handle, symbol);
+#endif
+        if (!func) {
+                char *dlerrstr = rd_dl_error();
+                rd_snprintf(errstr, errstr_size,
+                            "Failed to load symbol \"%s\": %s", symbol,
+                            dlerrstr);
+                rd_free(dlerrstr);
+        }
+        return func;
+}

package/deps/librdkafka/src/rddl.h

@@ -0,0 +1,43 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2017-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 _RDDL_H
+#define _RDDL_H
+
+#include <sys/types.h>
+
+typedef void rd_dl_hnd_t;
+
+rd_dl_hnd_t *rd_dl_open(const char *path, char *errstr, size_t errstr_size);
+void rd_dl_close(rd_dl_hnd_t *handle);
+void *rd_dl_sym(rd_dl_hnd_t *handle,
+                const char *symbol,
+                char *errstr,
+                size_t errstr_size);
+
+#endif /* _RDDL_H */

package/deps/librdkafka/src/rdendian.h

@@ -0,0 +1,175 @@
+/*
+ * 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.
+ */
+#ifndef _RDENDIAN_H_
+#define _RDENDIAN_H_
+
+/**
+ * Provides portable endian-swapping macros/functions.
+ *
+ *   be64toh()
+ *   htobe64()
+ *   be32toh()
+ *   htobe32()
+ *   be16toh()
+ *   htobe16()
+ *   le64toh()
+ */
+
+#ifdef __FreeBSD__
+#include <sys/endian.h>
+#elif defined __GLIBC__
+#include <endian.h>
+#ifndef be64toh
+/* Support older glibc (<2.9) which lack be64toh */
+#include <byteswap.h>
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define be16toh(x) (x)
+#define be32toh(x) (x)
+#define be64toh(x) (x)
+#define le64toh(x) __bswap_64(x)
+#define le32toh(x) __bswap_32(x)
+#else
+#define be16toh(x) __bswap_16(x)
+#define be32toh(x) __bswap_32(x)
+#define be64toh(x) __bswap_64(x)
+#define le64toh(x) (x)
+#define le32toh(x) (x)
+#endif
+#endif
+
+#elif defined __CYGWIN__
+#include <endian.h>
+#elif defined __BSD__
+#include <sys/endian.h>
+#elif defined __sun
+#include <sys/byteorder.h>
+#include <sys/isa_defs.h>
+#define __LITTLE_ENDIAN 1234
+#define __BIG_ENDIAN    4321
+#ifdef _BIG_ENDIAN
+#define __BYTE_ORDER __BIG_ENDIAN
+#define be64toh(x)   (x)
+#define be32toh(x)   (x)
+#define be16toh(x)   (x)
+#define le16toh(x)   ((uint16_t)BSWAP_16(x))
+#define le32toh(x)   BSWAP_32(x)
+#define le64toh(x)   BSWAP_64(x)
+#else
+#define __BYTE_ORDER __LITTLE_ENDIAN
+#define be64toh(x)   BSWAP_64(x)
+#define be32toh(x)   ntohl(x)
+#define be16toh(x)   ntohs(x)
+#define le16toh(x)   (x)
+#define le32toh(x)   (x)
+#define le64toh(x)   (x)
+#define htole16(x)   (x)
+#define htole64(x)   (x)
+#endif /* __sun */
+
+#elif defined __APPLE__
+#include <machine/endian.h>
+#include <libkern/OSByteOrder.h>
+#if __DARWIN_BYTE_ORDER == __DARWIN_BIG_ENDIAN
+#define be64toh(x) (x)
+#define be32toh(x) (x)
+#define be16toh(x) (x)
+#define le16toh(x) OSSwapInt16(x)
+#define le32toh(x) OSSwapInt32(x)
+#define le64toh(x) OSSwapInt64(x)
+#else
+#define be64toh(x) OSSwapInt64(x)
+#define be32toh(x) OSSwapInt32(x)
+#define be16toh(x) OSSwapInt16(x)
+#define le16toh(x) (x)
+#define le32toh(x) (x)
+#define le64toh(x) (x)
+#endif
+
+#elif defined(_WIN32)
+#include <intrin.h>
+
+#define be64toh(x) _byteswap_uint64(x)
+#define be32toh(x) _byteswap_ulong(x)
+#define be16toh(x) _byteswap_ushort(x)
+#define le16toh(x) (x)
+#define le32toh(x) (x)
+#define le64toh(x) (x)
+
+#elif defined _AIX /* AIX is always big endian */
+#define be64toh(x) (x)
+#define be32toh(x) (x)
+#define be16toh(x) (x)
+#define le32toh(x)                                                             \
+        ((((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))
+#else
+#include <endian.h>
+#endif
+
+
+
+/*
+ * On Solaris, be64toh is a function, not a macro, so there's no need to error
+ * if it's not defined.
+ */
+#if !defined(__sun) && !defined(be64toh)
+#error Missing definition for be64toh
+#endif
+
+#ifndef be32toh
+#define be32toh(x) ntohl(x)
+#endif
+
+#ifndef be16toh
+#define be16toh(x) ntohs(x)
+#endif
+
+#ifndef htobe64
+#define htobe64(x) be64toh(x)
+#endif
+#ifndef htobe32
+#define htobe32(x) be32toh(x)
+#endif
+#ifndef htobe16
+#define htobe16(x) be16toh(x)
+#endif
+
+#ifndef htole32
+#define htole32(x) le32toh(x)
+#endif
+
+#endif /* _RDENDIAN_H_ */

package/deps/librdkafka/src/rdfloat.h

@@ -0,0 +1,67 @@
+/*
+ * 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
+ * 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.
+ */
+
+#pragma once
+
+#include <math.h>
+
+/**
+ * rd_dbl_eq0(a,b,prec)
+ * Check two doubles for equality with the specified precision.
+ * Use this instead of != and == for all floats/doubles.
+ * More info:
+ *  http://docs.sun.com/source/806-3568/ncg_goldberg.html
+ */
+static RD_INLINE RD_UNUSED int rd_dbl_eq0(double a, double b, double prec) {
+        return fabs(a - b) < prec;
+}
+
+/* A default 'good' double-equality precision value.
+ * This rather timid epsilon value is useful for tenths, hundreths,
+ * and thousands parts, but not anything more precis than that.
+ * If a higher precision is needed, use dbl_eq0 and dbl_eq0 directly
+ * and specify your own precision. */
+#define RD_DBL_EPSILON 0.00001
+
+/**
+ * rd_dbl_eq(a,b)
+ * Same as rd_dbl_eq0() above but with a predefined 'good' precision.
+ */
+#define rd_dbl_eq(a, b) rd_dbl_eq0(a, b, RD_DBL_EPSILON)
+
+/**
+ * rd_dbl_ne(a,b)
+ * Same as rd_dbl_eq() above but with reversed logic: not-equal.
+ */
+#define rd_dbl_ne(a, b) (!rd_dbl_eq0(a, b, RD_DBL_EPSILON))
+
+/**
+ * rd_dbl_zero(a)
+ * Checks if the double `a' is zero (or close enough).
+ */
+#define rd_dbl_zero(a) rd_dbl_eq0(a, 0.0, RD_DBL_EPSILON)

package/deps/librdkafka/src/rdfnv1a.c

@@ -0,0 +1,113 @@
+/*
+ * 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.
+ */
+
+#include "rd.h"
+#include "rdunittest.h"
+#include "rdfnv1a.h"
+
+
+/* FNV-1a by Glenn Fowler, Landon Curt Noll, and Kiem-Phong Vo
+ *
+ * Based on http://www.isthe.com/chongo/src/fnv/hash_32a.c
+ * with librdkafka modifications to match the Sarama default Producer
+ * implementation, as seen here:
+ * https://github.com/Shopify/sarama/blob/master/partitioner.go#L203 Note that
+ * this implementation is only compatible with Sarama's default
+ * NewHashPartitioner and not NewReferenceHashPartitioner.
+ */
+uint32_t rd_fnv1a(const void *key, size_t len) {
+        const uint32_t prime  = 0x01000193;  // 16777619
+        const uint32_t offset = 0x811C9DC5;  // 2166136261
+        size_t i;
+        int32_t h = offset;
+
+        const unsigned char *data = (const unsigned char *)key;
+
+        for (i = 0; i < len; i++) {
+                h ^= data[i];
+                h *= prime;
+        }
+
+        /* Take absolute value to match the Sarama NewHashPartitioner
+         * implementation */
+        if (h < 0) {
+                h = -h;
+        }
+
+        return (uint32_t)h;
+}
+
+
+/**
+ * @brief Unittest for rd_fnv1a()
+ */
+int unittest_fnv1a(void) {
+        const char *short_unaligned = "1234";
+        const char *unaligned       = "PreAmbleWillBeRemoved,ThePrePartThatIs";
+        const char *keysToTest[]    = {
+            "kafka",
+            "giberish123456789",
+            short_unaligned,
+            short_unaligned + 1,
+            short_unaligned + 2,
+            short_unaligned + 3,
+            unaligned,
+            unaligned + 1,
+            unaligned + 2,
+            unaligned + 3,
+            "",
+            NULL,
+        };
+
+        // Acquired via https://play.golang.org/p/vWIhw3zJINA
+        const int32_t golang_hashfnv_results[] = {
+            0xd33c4e1,   // kafka
+            0x77a58295,  // giberish123456789
+            0x23bdd03,   // short_unaligned
+            0x2dea3cd2,  // short_unaligned+1
+            0x740fa83e,  // short_unaligned+2
+            0x310ca263,  // short_unaligned+3
+            0x65cbd69c,  // unaligned
+            0x6e49c79a,  // unaligned+1
+            0x69eed356,  // unaligned+2
+            0x6abcc023,  // unaligned+3
+            0x7ee3623b,  // ""
+            0x7ee3623b,  // NULL
+        };
+
+        size_t i;
+        for (i = 0; i < RD_ARRAYSIZE(keysToTest); i++) {
+                uint32_t h = rd_fnv1a(
+                    keysToTest[i], keysToTest[i] ? strlen(keysToTest[i]) : 0);
+                RD_UT_ASSERT((int32_t)h == golang_hashfnv_results[i],
+                             "Calculated FNV-1a hash 0x%x for \"%s\", "
+                             "expected 0x%x",
+                             h, keysToTest[i], golang_hashfnv_results[i]);
+        }
+        RD_UT_PASS();
+}

package/deps/librdkafka/src/rdfnv1a.h

@@ -0,0 +1,35 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2020-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 __RDFNV1A___H__
+#define __RDFNV1A___H__
+
+uint32_t rd_fnv1a(const void *key, size_t len);
+int unittest_fnv1a(void);
+
+#endif  // __RDFNV1A___H__