tools: xxd-c: new helper tool to convert files to C static array defs

this tool is a simple clone of 'xxd -i' function to be used by
Fluent Bit build system to integrate static configuration files.

Signed-off-by: Eduardo Silva <eduardo@treasure-data.com>

Author: edsiper

tools/xxd-c/CMakeLists.txt

@@ -0,0 +1,5 @@
+set(src
+  xxd-c.c
+  )
+
+add_executable(xxd-c ${src})

tools/xxd-c/README.md

@@ -0,0 +1,6 @@
+# xxd-c utility
+
+xxd-c is a tool created originally to create static array definitions from a text file. It's a simple clone of LLVM xxd utility.
+
+Originally created to be used by Fluent Bit CMake build system.
+

tools/xxd-c/xxd-c.c

@@ -0,0 +1,205 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Fluent Bit / xxd-c
+ *  ==================
+ *  Copyright (C) 2015-2018 Treasure Data Inc.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+/*
+ * xxd-c is a really simple tool to convert text files to C static
+ * arrays definitions, it emulate the behavior of 'xxd -i' but with
+ * some other features required by Fluent Bit to ingest static
+ * configuration files and do registration in a proper way.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <getopt.h>
+#include <unistd.h>
+
+#define XXDC_CHUNK    1024
+
+int xxdc_verbose;
+
+static void xxdc_help(int rc)
+{
+    fprintf(stderr, "Usage: xxd-c -i FILE_INPUT [-o FILE_OUTPUT] "
+            "[-s NAME]\n\n");
+    fprintf(stderr, "  -i  input text file\n");
+    fprintf(stderr, "  -o  output C header file\n");
+    fprintf(stderr, "  -s  C struct array name name\n");
+    fprintf(stderr, "  -h  print this help\n\n");
+    exit(rc);
+}
+
+static char *xxdc_struct_name(char *in, char *name)
+{
+    int i;
+    int len;
+    char *p;
+    char *sname = NULL;
+
+    if (name) {
+        sname = strdup(name);
+    }
+    else {
+        p = strrchr(in, '/');
+        if (!p) {
+            sname = strdup(in);
+        }
+        else {
+            sname = strdup(p);
+        }
+    }
+
+    if (!sname) {
+        perror("strdup");
+        return NULL;
+    }
+
+    /* sanitize name */
+    len = strlen(sname);
+    for (i = 0; i < len; i++) {
+        if (sname[i] == '-' || sname[i] == '.') {
+            sname[i] = '_';
+        }
+    }
+    return sname;
+}
+
+static int xxdc_convert(char *in, char *out, char *name)
+{
+    int i;
+    int len;
+    size_t size;
+    char tmp[128];
+    char *sname;
+    char buf[XXDC_CHUNK];
+    FILE *f_in;
+    FILE *f_out;
+
+    /* If no output file is given just print to stdout */
+    if (!out) {
+        f_out = stdout;
+    }
+    else {
+        f_out = fopen(out, "w");
+        if (!f_out) {
+            perror("fopen");
+            fprintf(stderr, "error opening output file: %s\n", out);
+            return -1;
+        }
+    }
+
+    f_in = fopen(in, "r");
+    if (!f_in) {
+        perror("fopen");
+        fprintf(stderr, "error opening input file: %s\n", in);
+        return -1;
+    }
+
+    /* Get target struct name */
+    sname = xxdc_struct_name(in, name);
+    if (!sname) {
+        fclose(f_in);
+        if (out) {
+            fclose(f_out);
+        }
+        return -1;
+    }
+
+    len = snprintf(tmp, sizeof(tmp) - 1,
+                   "unsigned char __%s[] = {", sname);
+    fwrite(tmp, len, 1, f_out);
+    while ((size = fread(buf, sizeof(char), XXDC_CHUNK, f_in)) > 0) {
+        for (i = 0; i < size; i++) {
+            if (i % 12 == 0) {
+                fwrite("\n    ", 5, 1, f_out);
+            }
+            len = snprintf(tmp, sizeof(tmp) - 1,
+                           "0x%02x%s ", buf[i], (i+1 < size) ? ",": "");
+            fwrite(tmp, len, 1, f_out);
+        }
+    }
+    fwrite("\n};\n", 4, 1, f_out);
+    fclose(f_in);
+
+    if (out) {
+        fclose(f_out);
+    }
+
+    if (xxdc_verbose) {
+        fprintf(stderr, "[xxdc] converted '%s' to '%s'\n",
+                in, out ? out: "STDOUT");
+    }
+    return 0;
+}
+
+int main(int argc, char **argv)
+{
+    int opt;
+    int ret;
+    char *in = NULL;
+    char *out = NULL;
+    char *stname = NULL;
+
+    /* Setup long-options */
+    static const struct option long_opts[] = {
+        { "input",    required_argument, NULL, 'i' },
+        { "output",   optional_argument, NULL, 'o' },
+        { "stname",   optional_argument, NULL, 's' },
+        { "verbose",  no_argument      , NULL, 'v' },
+        { "help",     required_argument, NULL, 'h' },
+        { NULL, 0, NULL, 0 }
+    };
+
+    xxdc_verbose = 0;
+
+    while ((opt = getopt_long(argc, argv, "i:o:s:vh",
+                              long_opts, NULL)) != -1) {
+        switch (opt) {
+        case 'i':
+            in = strdup(optarg);
+            break;
+        case 'o':
+            out = strdup(optarg);
+            break;
+        case 's':
+            stname = strdup(optarg);
+            break;
+        case 'v':
+            xxdc_verbose = 1;
+            break;
+        case 'h':
+            xxdc_help(EXIT_SUCCESS);
+        default:
+            xxdc_help(EXIT_FAILURE);
+        }
+    }
+
+    if (!in) {
+        fprintf(stderr, "Error: input file not set\n\n");
+        xxdc_help(EXIT_FAILURE);
+    }
+
+    ret = xxdc_convert(in, out, stname);
+
+    free(in);
+    free(out);
+    free(stname);
+
+    return ret;
+}