Adding upstream version 1.46.3.upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 466 insertions, 2 deletions

diff --git a/src/libnetdata/config/README.md b/src/libnetdata/config/README.md
new file mode 100644
index 000000000..665a7196c
--- /dev/null
+++ b/src/libnetdata/config/README.md
@@ -0,0 +1,58 @@
+<!--
+title: "Netdata ini config files"
+custom_edit_url: https://github.com/netdata/netdata/edit/master/src/libnetdata/config/README.md
+sidebar_label: "Netdata ini config files"
+learn_status: "Published"
+learn_topic_type: "Tasks"
+learn_rel_path: "Developers/libnetdata"
+-->
+
+# Netdata ini config files
+
+Configuration files `netdata.conf` and `stream.conf` are Netdata ini files.
+
+## Motivation
+
+The whole idea came up when we were evaluating the documentation involved
+in maintaining a complex configuration system. Our intention was to give
+configuration options for everything imaginable. But then, documenting all
+these options would require a tremendous amount of time, users would have
+to search through endless pages for the option they need, etc.
+
+We concluded then that **configuring software like that is a waste of time
+and effort**. Of course there must be plenty of configuration options, but
+the implementation itself should require a lot less effort for both the
+developers and the users.
+
+So, we did this:
+
+1.  No configuration is required to run Netdata
+2.  There are plenty of options to tweak
+3.  There is minimal documentation (or no at all)
+
+## Why this works?
+
+The configuration file is a `name = value` dictionary with `[sections]`.
+Write whatever you like there as long as it follows this simple format.
+
+Netdata loads this dictionary and then when the code needs a value from
+it, it just looks up the `name` in the dictionary at the proper `section`.
+In all places, in the code, there are both the `names` and their
+`default values`, so if something is not found in the configuration
+file, the default is used. The lookup is made using B-Trees and hashes
+(no string comparisons), so they are super fast. Also the `names` of the
+settings can be `my super duper setting that once set to yes, will turn the world upside down = no`
+
+-   so goodbye to most of the documentation involved.
+
+Next, Netdata can generate a valid configuration for the user to edit.
+No need to remember anything or copy and paste settings. Just get the
+configuration from the server (`/netdata.conf` on your Netdata server),
+edit it and save it.
+
+Last, what about options you believe you have set, but you misspelled?
+When you get the configuration file from the server, there will be a
+comment above all `name = value` pairs the server does not use.
+So you know that whatever you wrote there, is not used.
+
+
diff --git a/libnetdata/config/appconfig.c b/src/libnetdata/config/appconfig.c
index fe4c1222d..81946b594 100644
--- a/libnetdata/config/appconfig.c
+++ b/src/libnetdata/config/appconfig.c
@@ -904,7 +904,7 @@ void appconfig_generate(struct config *root, BUFFER *wb, int only_changed)
  * @return It returns 1 on success and 0 otherwise
  */
 int config_parse_duration(const char* string, int* result) {
-    while(*string && isspace(*string)) string++;
+    while(*string && isspace((uint8_t)*string)) string++;
 
     if(unlikely(!*string)) goto fallback;
 
@@ -915,7 +915,7 @@ int config_parse_duration(const char* string, int* result) {
     }
 
     // make sure it is a number
-    if(!(isdigit(*string) || *string == '+' || *string == '-')) goto fallback;
+    if(!(isdigit((uint8_t)*string) || *string == '+' || *string == '-')) goto fallback;
 
     char *e = NULL;
     NETDATA_DOUBLE n = str2ndd(string, &e);
diff --git a/libnetdata/config/appconfig.h b/src/libnetdata/config/appconfig.h
index 214a15edd..214a15edd 100644
--- a/libnetdata/config/appconfig.h
+++ b/src/libnetdata/config/appconfig.h
diff --git a/src/libnetdata/config/dyncfg.c b/src/libnetdata/config/dyncfg.c
new file mode 100644
index 000000000..244864c65
--- /dev/null
+++ b/src/libnetdata/config/dyncfg.c
@@ -0,0 +1,316 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "../../libnetdata/libnetdata.h"
+
+// ----------------------------------------------------------------------------
+
+static struct {
+    DYNCFG_TYPE type;
+    const char *name;
+} dyncfg_types[] = {
+    { .type = DYNCFG_TYPE_SINGLE, .name = "single" },
+    { .type = DYNCFG_TYPE_TEMPLATE, .name = "template" },
+    { .type = DYNCFG_TYPE_JOB, .name = "job" },
+};
+
+DYNCFG_TYPE dyncfg_type2id(const char *type) {
+    if(!type || !*type)
+        return DYNCFG_TYPE_SINGLE;
+
+    size_t entries = sizeof(dyncfg_types) / sizeof(dyncfg_types[0]);
+    for(size_t i = 0; i < entries ;i++) {
+        if(strcmp(dyncfg_types[i].name, type) == 0)
+            return dyncfg_types[i].type;
+    }
+
+    return DYNCFG_TYPE_SINGLE;
+}
+
+const char *dyncfg_id2type(DYNCFG_TYPE type) {
+    size_t entries = sizeof(dyncfg_types) / sizeof(dyncfg_types[0]);
+    for(size_t i = 0; i < entries ;i++) {
+        if(type == dyncfg_types[i].type)
+            return dyncfg_types[i].name;
+    }
+
+    return "single";
+}
+
+// ----------------------------------------------------------------------------
+
+static struct {
+    DYNCFG_SOURCE_TYPE source_type;
+    const char *name;
+} dyncfg_source_types[] = {
+    { .source_type = DYNCFG_SOURCE_TYPE_INTERNAL, .name = "internal" },
+    { .source_type = DYNCFG_SOURCE_TYPE_STOCK, .name = "stock" },
+    { .source_type = DYNCFG_SOURCE_TYPE_USER, .name = "user" },
+    { .source_type = DYNCFG_SOURCE_TYPE_DYNCFG, .name = "dyncfg" },
+    { .source_type = DYNCFG_SOURCE_TYPE_DISCOVERED, .name = "discovered" },
+};
+
+DYNCFG_SOURCE_TYPE dyncfg_source_type2id(const char *source_type) {
+    if(!source_type || !*source_type)
+        return DYNCFG_SOURCE_TYPE_INTERNAL;
+
+    size_t entries = sizeof(dyncfg_source_types) / sizeof(dyncfg_source_types[0]);
+    for(size_t i = 0; i < entries ;i++) {
+        if(strcmp(dyncfg_source_types[i].name, source_type) == 0)
+            return dyncfg_source_types[i].source_type;
+    }
+
+    return DYNCFG_SOURCE_TYPE_INTERNAL;
+}
+
+const char *dyncfg_id2source_type(DYNCFG_SOURCE_TYPE source_type) {
+    size_t entries = sizeof(dyncfg_source_types) / sizeof(dyncfg_source_types[0]);
+    for(size_t i = 0; i < entries ;i++) {
+        if(source_type == dyncfg_source_types[i].source_type)
+            return dyncfg_source_types[i].name;
+    }
+
+    return "internal";
+}
+
+// ----------------------------------------------------------------------------
+
+static struct {
+    DYNCFG_STATUS status;
+    const char *name;
+} dyncfg_statuses[] = {
+    { .status = DYNCFG_STATUS_NONE, .name = "none" },
+    { .status = DYNCFG_STATUS_ACCEPTED, .name = "accepted" },
+    { .status = DYNCFG_STATUS_RUNNING, .name = "running" },
+    { .status = DYNCFG_STATUS_FAILED, .name = "failed" },
+    { .status = DYNCFG_STATUS_DISABLED, .name = "disabled" },
+    { .status = DYNCFG_STATUS_ORPHAN, .name = "orphan" },
+    { .status = DYNCFG_STATUS_INCOMPLETE, .name = "incomplete" },
+};
+
+DYNCFG_STATUS dyncfg_status2id(const char *status) {
+    if(!status || !*status)
+        return DYNCFG_STATUS_NONE;
+
+    size_t entries = sizeof(dyncfg_statuses) / sizeof(dyncfg_statuses[0]);
+    for(size_t i = 0; i < entries ;i++) {
+        if(strcmp(dyncfg_statuses[i].name, status) == 0)
+            return dyncfg_statuses[i].status;
+    }
+
+    return DYNCFG_STATUS_NONE;
+}
+
+const char *dyncfg_id2status(DYNCFG_STATUS status) {
+    size_t entries = sizeof(dyncfg_statuses) / sizeof(dyncfg_statuses[0]);
+    for(size_t i = 0; i < entries ;i++) {
+        if(status == dyncfg_statuses[i].status)
+            return dyncfg_statuses[i].name;
+    }
+
+    return "none";
+}
+
+// ----------------------------------------------------------------------------
+
+static struct {
+    DYNCFG_CMDS cmd;
+    const char *name;
+} cmd_map[] = {
+    { .cmd = DYNCFG_CMD_GET, .name = "get" },
+    { .cmd = DYNCFG_CMD_SCHEMA, .name = "schema" },
+    { .cmd = DYNCFG_CMD_UPDATE, .name = "update" },
+    { .cmd = DYNCFG_CMD_ADD, .name = "add" },
+    { .cmd = DYNCFG_CMD_TEST, .name = "test" },
+    { .cmd = DYNCFG_CMD_REMOVE, .name = "remove" },
+    { .cmd = DYNCFG_CMD_ENABLE, .name = "enable" },
+    { .cmd = DYNCFG_CMD_DISABLE, .name = "disable" },
+    { .cmd = DYNCFG_CMD_RESTART, .name = "restart" },
+    { .cmd = DYNCFG_CMD_USERCONFIG, .name = "userconfig" },
+};
+
+const char *dyncfg_id2cmd_one(DYNCFG_CMDS cmd) {
+    for (size_t i = 0; i < sizeof(cmd_map) / sizeof(cmd_map[0]); i++) {
+        if(cmd == cmd_map[i].cmd)
+            return cmd_map[i].name;
+    }
+
+    return NULL;
+}
+
+DYNCFG_CMDS dyncfg_cmds2id(const char *cmds) {
+    if(!cmds || !*cmds)
+        return DYNCFG_CMD_NONE;
+
+    DYNCFG_CMDS result = DYNCFG_CMD_NONE;
+    const char *p = cmds;
+    size_t len, i;
+
+    while (*p) {
+        // Skip any leading spaces
+        while (*p == ' ') p++;
+
+        // Find the end of the current word
+        const char *end = p;
+        while (*end && *end != ' ') end++;
+        len = end - p;
+
+        // Compare with known commands
+        for (i = 0; i < sizeof(cmd_map) / sizeof(cmd_map[0]); i++) {
+            if (strncmp(p, cmd_map[i].name, len) == 0 && cmd_map[i].name[len] == '\0') {
+                result |= cmd_map[i].cmd;
+                break;
+            }
+        }
+
+        // Move to the next word
+        p = end;
+    }
+
+    return result;
+}
+
+void dyncfg_cmds2fp(DYNCFG_CMDS cmds, FILE *fp) {
+    for (size_t i = 0; i < sizeof(cmd_map) / sizeof(cmd_map[0]); i++) {
+        if(cmds & cmd_map[i].cmd)
+            fprintf(fp, "%s ", cmd_map[i].name);
+    }
+}
+
+void dyncfg_cmds2json_array(DYNCFG_CMDS cmds, const char *key, BUFFER *wb) {
+    buffer_json_member_add_array(wb, key);
+    for (size_t i = 0; i < sizeof(cmd_map) / sizeof(cmd_map[0]); i++) {
+        if(cmds & cmd_map[i].cmd)
+            buffer_json_add_array_item_string(wb, cmd_map[i].name);
+    }
+    buffer_json_array_close(wb);
+}
+
+void dyncfg_cmds2buffer(DYNCFG_CMDS cmds, BUFFER *wb) {
+    size_t added = 0;
+    for (size_t i = 0; i < sizeof(cmd_map) / sizeof(cmd_map[0]); i++) {
+        if(cmds & cmd_map[i].cmd) {
+            if(added)
+                buffer_fast_strcat(wb, " ", 1);
+
+            buffer_strcat(wb, cmd_map[i].name);
+            added++;
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+
+bool dyncfg_is_valid_id(const char *id) {
+    const char *s = id;
+
+    while(*s) {
+        if(isspace((uint8_t)*s) || *s == '\'') return false;
+        s++;
+    }
+
+    return true;
+}
+
+static inline bool is_forbidden_char(char c) {
+    if(isspace((uint8_t)c) || !isprint((uint8_t)c))
+        return true;
+
+    switch(c) {
+        case '`': // good not to have this in filenames
+        case '$': // good not to have this in filenames
+        case '/': // unix does not support this
+        case ':': // windows does not support this
+        case '|': // windows does not support this
+            return true;
+
+        default:
+            return false;
+    }
+}
+
+char *dyncfg_escape_id_for_filename(const char *id) {
+    if (id == NULL) return NULL;
+
+    // Allocate memory for the worst case, where every character is escaped.
+    char *escaped = mallocz(strlen(id) * 3 + 1); // Each char can become '%XX', plus '\0'
+    if (!escaped) return NULL;
+
+    const char *src = id;
+    char *dest = escaped;
+
+    while (*src) {
+        if (is_forbidden_char(*src)) {
+            sprintf(dest, "%%%02X", (unsigned char)*src);
+            dest += 3;
+        } else {
+            *dest++ = *src;
+        }
+        src++;
+    }
+
+    *dest = '\0';
+    return escaped;
+}
+
+// ----------------------------------------------------------------------------
+
+int dyncfg_default_response(BUFFER *wb, int code, const char *msg) {
+    buffer_flush(wb);
+    wb->content_type = CT_APPLICATION_JSON;
+    wb->expires = now_realtime_sec();
+
+    buffer_json_initialize(wb, "\"", "\"", 0, true, BUFFER_JSON_OPTIONS_MINIFY);
+    buffer_json_member_add_uint64(wb, "status", code);
+    buffer_json_member_add_string(wb, "message", msg);
+    buffer_json_finalize(wb);
+
+    return code;
+}
+
+int dyncfg_node_find_and_call(DICTIONARY *dyncfg_nodes, const char *transaction, const char *function,
+                              usec_t *stop_monotonic_ut, bool *cancelled,
+                              BUFFER *payload, HTTP_ACCESS access, const char *source, BUFFER *result) {
+    if(!function || !*function)
+        return dyncfg_default_response(result, HTTP_RESP_BAD_REQUEST, "command received is empty");
+
+    char buf[strlen(function) + 1];
+    memcpy(buf, function, sizeof(buf));
+
+    char *words[MAX_FUNCTION_PARAMETERS];    // an array of pointers for the words in this line
+    size_t num_words = quoted_strings_splitter_pluginsd(buf, words, MAX_FUNCTION_PARAMETERS);
+
+    const char *id = get_word(words, num_words, 1);
+    const char *action = get_word(words, num_words, 2);
+    const char *add_name = get_word(words, num_words, 3);
+
+    if(!id || !*id)
+        return dyncfg_default_response(result, HTTP_RESP_BAD_REQUEST, "dyncfg node: id is missing from the request");
+
+    if(!action || !*action)
+        return dyncfg_default_response(result, HTTP_RESP_BAD_REQUEST, "dyncfg node: action is missing from the request");
+
+    DYNCFG_CMDS cmd = dyncfg_cmds2id(action);
+    if(cmd == DYNCFG_CMD_NONE)
+        return dyncfg_default_response(result, HTTP_RESP_BAD_REQUEST, "dyncfg node: action given in request is unknown");
+
+    const DICTIONARY_ITEM *item = dictionary_get_and_acquire_item(dyncfg_nodes, id);
+    if(!item)
+        return dyncfg_default_response(result, HTTP_RESP_NOT_FOUND, "dyncfg node: id is not found");
+
+    struct dyncfg_node *df = dictionary_acquired_item_value(item);
+
+    buffer_flush(result);
+    result->content_type = CT_APPLICATION_JSON;
+
+    int code = df->cb(transaction, id, cmd, add_name, payload, stop_monotonic_ut, cancelled, result, access, source, df->data);
+
+    if(!result->expires)
+        result->expires = now_realtime_sec();
+
+    if(!buffer_tostring(result))
+        dyncfg_default_response(result, code, "");
+
+    dictionary_acquired_item_release(dyncfg_nodes, item);
+
+    return code;
+}
diff --git a/src/libnetdata/config/dyncfg.h b/src/libnetdata/config/dyncfg.h
new file mode 100644
index 000000000..e34dc5484
--- /dev/null
+++ b/src/libnetdata/config/dyncfg.h
@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#ifndef LIBNETDATA_DYNCFG_H
+#define LIBNETDATA_DYNCFG_H
+
+#define DYNCFG_VERSION (size_t)1
+
+#define DYNCFG_RESP_SUCCESS(code) (code >= 200 && code <= 299)
+#define DYNCFG_RESP_RUNNING                   200 // accepted and running
+#define DYNCFG_RESP_ACCEPTED                  202 // accepted, but not running yet
+#define DYNCFG_RESP_ACCEPTED_DISABLED         298 // accepted, but is disabled
+#define DYNCFG_RESP_ACCEPTED_RESTART_REQUIRED 299 // accepted, but restart is required to apply it
+
+typedef enum __attribute__((packed)) {
+    DYNCFG_TYPE_SINGLE = 0,
+    DYNCFG_TYPE_TEMPLATE,
+    DYNCFG_TYPE_JOB,
+} DYNCFG_TYPE;
+DYNCFG_TYPE dyncfg_type2id(const char *type);
+const char *dyncfg_id2type(DYNCFG_TYPE type);
+
+typedef enum __attribute__((packed)) {
+    DYNCFG_SOURCE_TYPE_INTERNAL = 0,
+    DYNCFG_SOURCE_TYPE_STOCK,
+    DYNCFG_SOURCE_TYPE_USER,
+    DYNCFG_SOURCE_TYPE_DYNCFG,
+    DYNCFG_SOURCE_TYPE_DISCOVERED,
+} DYNCFG_SOURCE_TYPE;
+DYNCFG_SOURCE_TYPE dyncfg_source_type2id(const char *source_type);
+const char *dyncfg_id2source_type(DYNCFG_SOURCE_TYPE source_type);
+
+typedef enum __attribute__((packed)) {
+    DYNCFG_STATUS_NONE = 0,
+    DYNCFG_STATUS_ACCEPTED,     // the plugin has accepted the configuration
+    DYNCFG_STATUS_RUNNING,      // the plugin runs the accepted configuration
+    DYNCFG_STATUS_FAILED,       // the plugin fails to run the accepted configuration
+    DYNCFG_STATUS_DISABLED,     // the configuration is disabled by a user
+    DYNCFG_STATUS_ORPHAN,       // no plugin has claimed this configurations
+    DYNCFG_STATUS_INCOMPLETE,   // a special kind of failed configuration
+} DYNCFG_STATUS;
+DYNCFG_STATUS dyncfg_status2id(const char *status);
+const char *dyncfg_id2status(DYNCFG_STATUS status);
+
+typedef enum __attribute__((packed)) {
+    DYNCFG_CMD_NONE         = 0,
+    DYNCFG_CMD_GET          = (1 << 0),
+    DYNCFG_CMD_SCHEMA       = (1 << 1),
+    DYNCFG_CMD_UPDATE       = (1 << 2),
+    DYNCFG_CMD_ADD          = (1 << 3),
+    DYNCFG_CMD_TEST         = (1 << 4),
+    DYNCFG_CMD_REMOVE       = (1 << 5),
+    DYNCFG_CMD_ENABLE       = (1 << 6),
+    DYNCFG_CMD_DISABLE      = (1 << 7),
+    DYNCFG_CMD_RESTART      = (1 << 8),
+    DYNCFG_CMD_USERCONFIG   = (1 << 9),
+} DYNCFG_CMDS;
+
+DYNCFG_CMDS dyncfg_cmds2id(const char *cmds);
+void dyncfg_cmds2buffer(DYNCFG_CMDS cmds, struct web_buffer *wb);
+void dyncfg_cmds2json_array(DYNCFG_CMDS cmds, const char *key, struct web_buffer *wb);
+void dyncfg_cmds2fp(DYNCFG_CMDS cmds, FILE *fp);
+const char *dyncfg_id2cmd_one(DYNCFG_CMDS cmd);
+
+bool dyncfg_is_valid_id(const char *id);
+char *dyncfg_escape_id_for_filename(const char *id);
+
+#include "../clocks/clocks.h"
+#include "../buffer/buffer.h"
+#include "../dictionary/dictionary.h"
+
+typedef int (*dyncfg_cb_t)(const char *transaction, const char *id, DYNCFG_CMDS cmd, const char *add_name,
+                           BUFFER *payload, usec_t *stop_monotonic_ut, bool *cancelled, BUFFER *result,
+                           HTTP_ACCESS access, const char *source, void *data);
+
+struct dyncfg_node {
+    DYNCFG_TYPE type;
+    DYNCFG_CMDS cmds;
+    dyncfg_cb_t cb;
+    void *data;
+};
+
+#define dyncfg_nodes_dictionary_create() dictionary_create_advanced(DICT_OPTION_FIXED_SIZE, NULL, sizeof(struct dyncfg_node))
+
+int dyncfg_default_response(BUFFER *wb, int code, const char *msg);
+
+int dyncfg_node_find_and_call(DICTIONARY *dyncfg_nodes, const char *transaction, const char *function,
+                              usec_t *stop_monotonic_ut, bool *cancelled,
+                              BUFFER *payload, HTTP_ACCESS access, const char *source, BUFFER *result);
+
+#endif //LIBNETDATA_DYNCFG_H