Adding upstream version 1.37.1.upstream/1.37.1upstream

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

1 files changed, 460 insertions, 0 deletions

diff --git a/libnetdata/popen/popen.c b/libnetdata/popen/popen.c
new file mode 100644
index 0000000..57f957f
--- /dev/null
+++ b/libnetdata/popen/popen.c
@@ -0,0 +1,460 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "../libnetdata.h"
+
+// ----------------------------------------------------------------------------
+// popen with tracking
+
+static pthread_mutex_t netdata_popen_tracking_mutex;
+static bool netdata_popen_tracking_enabled = false;
+
+struct netdata_popen {
+    pid_t pid;
+    struct netdata_popen *next;
+    struct netdata_popen *prev;
+};
+
+static struct netdata_popen *netdata_popen_root = NULL;
+
+// myp_add_lock takes the lock if we're tracking.
+static void netdata_popen_tracking_lock(void) {
+    if(!netdata_popen_tracking_enabled)
+        return;
+
+    netdata_mutex_lock(&netdata_popen_tracking_mutex);
+}
+
+// myp_add_unlock release the lock if we're tracking.
+static void netdata_popen_tracking_unlock(void) {
+    if(!netdata_popen_tracking_enabled)
+        return;
+
+    netdata_mutex_unlock(&netdata_popen_tracking_mutex);
+}
+
+// myp_add_locked adds pid if we're tracking.
+// myp_add_lock must have been called previously.
+static void netdata_popen_tracking_add_pid_unsafe(pid_t pid) {
+    if(!netdata_popen_tracking_enabled)
+        return;
+
+    struct netdata_popen *mp;
+
+    mp = mallocz(sizeof(struct netdata_popen));
+    mp->pid = pid;
+
+    DOUBLE_LINKED_LIST_PREPEND_UNSAFE(netdata_popen_root, mp, prev, next);
+}
+
+// myp_del deletes pid if we're tracking.
+static void netdata_popen_tracking_del_pid(pid_t pid) {
+    if(!netdata_popen_tracking_enabled)
+        return;
+
+    struct netdata_popen *mp;
+
+    netdata_mutex_lock(&netdata_popen_tracking_mutex);
+
+    DOUBLE_LINKED_LIST_FOREACH_FORWARD(netdata_popen_root, mp, prev, next) {
+        if(unlikely(mp->pid == pid))
+            break;
+    }
+
+    if(mp) {
+        DOUBLE_LINKED_LIST_REMOVE_UNSAFE(netdata_popen_root, mp, prev, next);
+        freez(mp);
+    }
+    else
+        error("Cannot find pid %d.", pid);
+
+    netdata_mutex_unlock(&netdata_popen_tracking_mutex);
+}
+
+// netdata_popen_tracking_init() should be called by apps which act as init
+// (pid 1) so that processes created by mypopen and mypopene
+// are tracked. This enables the reaper to ignore processes
+// which will be handled internally, by calling myp_reap, to
+// avoid issues with already reaped processes during wait calls.
+//
+// Callers should call myp_free() to clean up resources.
+void netdata_popen_tracking_init(void) {
+    info("process tracking enabled.");
+    netdata_popen_tracking_enabled = true;
+
+    if (netdata_mutex_init(&netdata_popen_tracking_mutex) != 0)
+        fatal("netdata_popen_tracking_init() mutex init failed.");
+}
+
+// myp_free cleans up any resources allocated for process
+// tracking.
+void netdata_popen_tracking_cleanup(void) {
+    if(!netdata_popen_tracking_enabled)
+        return;
+
+    netdata_mutex_lock(&netdata_popen_tracking_mutex);
+    netdata_popen_tracking_enabled = false;
+
+    while(netdata_popen_root) {
+        struct netdata_popen *mp = netdata_popen_root;
+        DOUBLE_LINKED_LIST_REMOVE_UNSAFE(netdata_popen_root, mp, prev, next);
+        freez(mp);
+    }
+
+    netdata_mutex_unlock(&netdata_popen_tracking_mutex);
+}
+
+// myp_reap returns 1 if pid should be reaped, 0 otherwise.
+int netdata_popen_tracking_pid_shoud_be_reaped(pid_t pid) {
+    if(!netdata_popen_tracking_enabled)
+        return 0;
+
+    netdata_mutex_lock(&netdata_popen_tracking_mutex);
+
+    int ret = 1;
+    struct netdata_popen *mp;
+    DOUBLE_LINKED_LIST_FOREACH_FORWARD(netdata_popen_root, mp, prev, next) {
+        if(unlikely(mp->pid == pid)) {
+            ret = 0;
+            break;
+        }
+    }
+
+    netdata_mutex_unlock(&netdata_popen_tracking_mutex);
+    return ret;
+}
+
+// ----------------------------------------------------------------------------
+// helpers
+
+static inline void convert_argv_to_string(char *dst, size_t size, const char *spawn_argv[]) {
+    int i;
+    for(i = 0; spawn_argv[i] ;i++) {
+        if(i == 0) snprintfz(dst, size, "%s", spawn_argv[i]);
+        else {
+            size_t len = strlen(dst);
+            snprintfz(&dst[len], size - len, " '%s'", spawn_argv[i]);
+        }
+    }
+}
+
+// ----------------------------------------------------------------------------
+// the core of netdata popen
+
+/*
+ * Returns -1 on failure, 0 on success. When POPEN_FLAG_CREATE_PIPE is set, on success set the FILE *fp pointer.
+ */
+#define PIPE_READ 0
+#define PIPE_WRITE 1
+
+static int popene_internal(volatile pid_t *pidptr, char **env, uint8_t flags, FILE **fpp_child_stdin, FILE **fpp_child_stdout, const char *command, const char *spawn_argv[]) {
+    // create a string to be logged about the command we are running
+    char command_to_be_logged[2048];
+    convert_argv_to_string(command_to_be_logged, sizeof(command_to_be_logged), spawn_argv);
+    // info("custom_popene() running command: %s", command_to_be_logged);
+
+    int ret = 0;     // success by default
+    int attr_rc = 1; // failure by default
+
+    FILE *fp_child_stdin = NULL, *fp_child_stdout = NULL;
+    int pipefd_stdin[2] = { -1, -1 };
+    int pipefd_stdout[2] = { -1, -1 };
+
+    pid_t pid;
+    posix_spawnattr_t attr;
+    posix_spawn_file_actions_t fa;
+
+    int stdin_fd_to_exclude_from_closing = -1;
+    int stdout_fd_to_exclude_from_closing = -1;
+
+    if(posix_spawn_file_actions_init(&fa)) {
+        error("POPEN: posix_spawn_file_actions_init() failed.");
+        ret = -1;
+        goto set_return_values_and_return;
+    }
+
+    if(fpp_child_stdin) {
+        if (pipe(pipefd_stdin) == -1) {
+            error("POPEN: stdin pipe() failed");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+
+        if ((fp_child_stdin = fdopen(pipefd_stdin[PIPE_WRITE], "w")) == NULL) {
+            error("POPEN: fdopen() stdin failed");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+
+        if(posix_spawn_file_actions_adddup2(&fa, pipefd_stdin[PIPE_READ], STDIN_FILENO)) {
+            error("POPEN: posix_spawn_file_actions_adddup2() on stdin failed.");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+    }
+    else {
+        if (posix_spawn_file_actions_addopen(&fa, STDIN_FILENO, "/dev/null", O_RDONLY, 0)) {
+            error("POPEN: posix_spawn_file_actions_addopen() on stdin to /dev/null failed.");
+            // this is not a fatal error
+            stdin_fd_to_exclude_from_closing = STDIN_FILENO;
+        }
+    }
+
+    if (fpp_child_stdout) {
+        if (pipe(pipefd_stdout) == -1) {
+            error("POPEN: stdout pipe() failed");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+
+        if ((fp_child_stdout = fdopen(pipefd_stdout[PIPE_READ], "r")) == NULL) {
+            error("POPEN: fdopen() stdout failed");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+
+        if(posix_spawn_file_actions_adddup2(&fa, pipefd_stdout[PIPE_WRITE], STDOUT_FILENO)) {
+            error("POPEN: posix_spawn_file_actions_adddup2() on stdout failed.");
+            ret = -1;
+            goto cleanup_and_return;
+        }
+    }
+    else {
+        if (posix_spawn_file_actions_addopen(&fa, STDOUT_FILENO, "/dev/null", O_WRONLY, 0)) {
+            error("POPEN: posix_spawn_file_actions_addopen() on stdout to /dev/null failed.");
+            // this is not a fatal error
+            stdout_fd_to_exclude_from_closing = STDOUT_FILENO;
+        }
+    }
+
+    if(flags & POPEN_FLAG_CLOSE_FD) {
+        // Mark all files to be closed by the exec() stage of posix_spawn()
+        for(int i = (int)(sysconf(_SC_OPEN_MAX) - 1); i >= 0; i--) {
+            if(likely(i != STDERR_FILENO && i != stdin_fd_to_exclude_from_closing && i != stdout_fd_to_exclude_from_closing))
+                (void)fcntl(i, F_SETFD, FD_CLOEXEC);
+        }
+    }
+
+    attr_rc = posix_spawnattr_init(&attr);
+    if(attr_rc) {
+        // failed
+        error("POPEN: posix_spawnattr_init() failed.");
+    }
+    else {
+        // success
+        // reset all signals in the child
+
+        if (posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETSIGDEF))
+            error("POPEN: posix_spawnattr_setflags() failed.");
+
+        sigset_t mask;
+        sigemptyset(&mask);
+
+        if (posix_spawnattr_setsigmask(&attr, &mask))
+            error("POPEN: posix_spawnattr_setsigmask() failed.");
+    }
+
+    // Take the lock while we fork to ensure we don't race with SIGCHLD
+    // delivery on a process which exits quickly.
+    netdata_popen_tracking_lock();
+    if (!posix_spawn(&pid, command, &fa, &attr, (char * const*)spawn_argv, env)) {
+        // success
+        *pidptr = pid;
+        netdata_popen_tracking_add_pid_unsafe(pid);
+        netdata_popen_tracking_unlock();
+    }
+    else {
+        // failure
+        netdata_popen_tracking_unlock();
+        error("POPEN: failed to spawn command: \"%s\" from parent pid %d.", command_to_be_logged, getpid());
+        ret = -1;
+        goto cleanup_and_return;
+    }
+
+    // the normal cleanup will run
+    // but ret == 0 at this point
+
+cleanup_and_return:
+    if(!attr_rc) {
+        // posix_spawnattr_init() succeeded
+        if (posix_spawnattr_destroy(&attr))
+            error("POPEN: posix_spawnattr_destroy() failed");
+    }
+
+    if (posix_spawn_file_actions_destroy(&fa))
+        error("POPEN: posix_spawn_file_actions_destroy() failed");
+
+    // the child end - close it
+    if(pipefd_stdin[PIPE_READ] != -1)
+        close(pipefd_stdin[PIPE_READ]);
+
+    // our end
+    if(ret == -1 || !fpp_child_stdin) {
+        if (fp_child_stdin)
+            fclose(fp_child_stdin);
+        else if (pipefd_stdin[PIPE_WRITE] != -1)
+            close(pipefd_stdin[PIPE_WRITE]);
+
+        fp_child_stdin = NULL;
+    }
+
+    // the child end - close it
+    if (pipefd_stdout[PIPE_WRITE] != -1)
+        close(pipefd_stdout[PIPE_WRITE]);
+
+    // our end
+    if (ret == -1 || !fpp_child_stdout) {
+        if (fp_child_stdout)
+            fclose(fp_child_stdout);
+        else if (pipefd_stdout[PIPE_READ] != -1)
+            close(pipefd_stdout[PIPE_READ]);
+
+        fp_child_stdout = NULL;
+    }
+
+set_return_values_and_return:
+    if(fpp_child_stdin)
+        *fpp_child_stdin = fp_child_stdin;
+
+    if(fpp_child_stdout)
+        *fpp_child_stdout = fp_child_stdout;
+
+    return ret;
+}
+
+int netdata_popene_variadic_internal_dont_use_directly(volatile pid_t *pidptr, char **env, uint8_t flags, FILE **fpp_child_input, FILE **fpp_child_output, const char *command, ...) {
+    // convert the variable list arguments into what posix_spawn() needs
+    // all arguments are expected strings
+    va_list args;
+    int args_count;
+
+    // count the number variable parameters
+    // the variable parameters are expected NULL terminated
+    {
+        const char *s;
+
+        va_start(args, command);
+        args_count = 0;
+        while ((s = va_arg(args, const char *))) args_count++;
+        va_end(args);
+    }
+
+    // create a string pointer array as needed by posix_spawn()
+    // variable array in the stack
+    const char *spawn_argv[args_count + 1];
+    {
+        const char *s;
+        va_start(args, command);
+        int i;
+        for (i = 0; i < args_count; i++) {
+            s = va_arg(args, const char *);
+            spawn_argv[i] = s;
+        }
+        spawn_argv[args_count] = NULL;
+        va_end(args);
+    }
+
+    return popene_internal(pidptr, env, flags, fpp_child_input, fpp_child_output, command, spawn_argv);
+}
+
+// See man environ
+extern char **environ;
+
+FILE *netdata_popen(const char *command, volatile pid_t *pidptr, FILE **fpp_child_input) {
+    FILE *fp_child_output = NULL;
+    const char *spawn_argv[] = {
+        "sh",
+        "-c",
+        command,
+        NULL
+    };
+    (void)popene_internal(pidptr, environ, POPEN_FLAG_CLOSE_FD, fpp_child_input, &fp_child_output, "/bin/sh", spawn_argv);
+    return fp_child_output;
+}
+
+FILE *netdata_popene(const char *command, volatile pid_t *pidptr, char **env, FILE **fpp_child_input) {
+    FILE *fp_child_output = NULL;
+    const char *spawn_argv[] = {
+        "sh",
+        "-c",
+        command,
+        NULL
+    };
+    (void)popene_internal(pidptr, env, POPEN_FLAG_CLOSE_FD, fpp_child_input, &fp_child_output, "/bin/sh", spawn_argv);
+    return fp_child_output;
+}
+
+// returns 0 on success, -1 on failure
+int netdata_spawn(const char *command, volatile pid_t *pidptr) {
+    const char *spawn_argv[] = {
+        "sh",
+        "-c",
+        command,
+        NULL
+    };
+    return popene_internal(pidptr, environ, POPEN_FLAG_NONE, NULL, NULL, "/bin/sh", spawn_argv);
+}
+
+int netdata_pclose(FILE *fp_child_input, FILE *fp_child_output, pid_t pid) {
+    int ret;
+    siginfo_t info;
+
+    debug(D_EXIT, "Request to netdata_pclose() on pid %d", pid);
+
+    if (fp_child_input)
+        fclose(fp_child_input);
+
+    if (fp_child_output)
+        fclose(fp_child_output);
+
+    errno = 0;
+
+    ret = waitid(P_PID, (id_t) pid, &info, WEXITED);
+    netdata_popen_tracking_del_pid(pid);
+
+    if (ret != -1) {
+        switch (info.si_code) {
+            case CLD_EXITED:
+                if(info.si_status)
+                    error("child pid %d exited with code %d.", info.si_pid, info.si_status);
+                return(info.si_status);
+
+            case CLD_KILLED:
+                if(info.si_status == 15) {
+                    info("child pid %d killed by signal %d.", info.si_pid, info.si_status);
+                    return(0);
+                }
+                else {
+                    error("child pid %d killed by signal %d.", info.si_pid, info.si_status);
+                    return(-1);
+                }
+
+            case CLD_DUMPED:
+                error("child pid %d core dumped by signal %d.", info.si_pid, info.si_status);
+                return(-2);
+
+            case CLD_STOPPED:
+                error("child pid %d stopped by signal %d.", info.si_pid, info.si_status);
+                return(0);
+
+            case CLD_TRAPPED:
+                error("child pid %d trapped by signal %d.", info.si_pid, info.si_status);
+                return(-4);
+
+            case CLD_CONTINUED:
+                error("child pid %d continued by signal %d.", info.si_pid, info.si_status);
+                return(0);
+
+            default:
+                error("child pid %d gave us a SIGCHLD with code %d and status %d.", info.si_pid, info.si_code, info.si_status);
+                return(-5);
+        }
+    }
+    else
+        error("Cannot waitid() for pid %d", pid);
+    
+    return 0;
+}
+
+int netdata_spawn_waitpid(pid_t pid) {
+    return netdata_pclose(NULL, NULL, pid);
+}