1 files changed, 156 insertions, 0 deletions
diff --git a/fluent-bit/lib/librdkafka-2.1.0/src/rdregex.c b/fluent-bit/lib/librdkafka-2.1.0/src/rdregex.c
new file mode 100644
index 00000000..0c70cb33
--- /dev/null
+++ b/fluent-bit/lib/librdkafka-2.1.0/src/rdregex.c
@@ -0,0 +1,156 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2016 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
+}