WIP: Add a process manager "class"

In many places there's a need to keep track of sub-processes
spawned by the main process. Such processes need to be looked up
by various parameters, interacted with, and, eventually,
terminated.

Having a common, reliable and fast implementation with high test
coverage that holds the various pieces of information about
sub-processes together is beneficial.

Ticket: CFE-3572
Changelog: None

Author: vpodzime

libutils/Makefile.am

@@ -63,6 +63,7 @@ libutils_la_SOURCES = \
 	platform.h condition_macros.h \
 	printsize.h \
 	proc_keyvalue.c proc_keyvalue.h \
+	proc_manager.c proc_manager.h \
 	queue.c queue.h \
 	rb-tree.c rb-tree.h \
 	refcount.c refcount.h \

libutils/proc_manager.c

@@ -0,0 +1,296 @@
+/*
+  Copyright 2021 Northern.tech AS
+
+  This file is part of CFEngine 3 - written and maintained by Northern.tech AS.
+
+  This program is free software; you can redistribute it and/or modify it
+  under the terms of the GNU General Public License as published by the
+  Free Software Foundation; version 3.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
+
+  To the extent this program is licensed as part of the Enterprise
+  versions of CFEngine, the applicable Commercial Open Source License
+  (COSL) may apply to this file if you as a licensee so wish it. See
+  included file COSL.txt.
+*/
+
+#include <platform.h>
+#include <map.h>                /* Map* */
+#include <alloc.h>              /* xmalloc, xasprintf */
+#include <string_lib.c>         /* StringHash_untyped, StringEqual_untyped */
+#include <logging.h>
+#include <proc_manager.h>
+
+#ifdef __MINGW32__
+#define fileno _fileno
+#endif
+
+struct ProcManager_ {
+    Map *procs_by_id;  /** primary storage for the subprocesses info (owns the data)    */
+    Map *procs_by_fd;  /** a different view on the data to speed up lookup by FD/stream */
+    Map *procs_by_pid; /** a different view on the data to speed up lookup by PID       */
+};
+
+static unsigned int HashFD_untyped(const void *fd, ARG_UNUSED unsigned int seed)
+{
+    assert(fd != NULL);
+    return *((unsigned int*) fd);
+}
+
+static bool FDEqual_untyped(const void *fd1, const void *fd2)
+{
+    assert((fd1 != NULL) && (fd2 != NULL));
+    return (*((int*) fd1) == (*(int*) fd2));
+}
+
+static unsigned int HashPID_untyped(const void *pid, ARG_UNUSED unsigned int seed)
+{
+    assert(pid != NULL);
+    return *((unsigned int*) pid);
+}
+
+static bool PIDEqual_untyped(const void *pid1, const void *pid2)
+{
+    assert((pid1 != NULL) && (pid2 != NULL));
+    return (*((pid_t*) pid1) == *((pid_t*) pid2));
+}
+
+static void NoopDestroy(ARG_UNUSED void *p)
+{
+    /* not destroying anything here */
+}
+
+ProcManager *ProcManagerNew()
+{
+    ProcManager *manager = xmalloc(sizeof(ProcManager));
+
+    /* keys are just pointers into data, this map actually holds the data */
+    manager->procs_by_id = MapNew(StringHash_untyped, StringEqual_untyped,
+                                  NoopDestroy, (MapDestroyDataFn) SubprocessDestroy);
+
+    /* keys are allocated, data belongs to the procs_by_id map */
+    manager->procs_by_fd = MapNew(HashFD_untyped, FDEqual_untyped,
+                                  free, NoopDestroy);
+
+    /* keys are just pointers into data, data belongs to the procs_by_id map */
+    manager->procs_by_pid = MapNew(HashPID_untyped, PIDEqual_untyped,
+                                   NoopDestroy, NoopDestroy);
+
+    return manager;
+}
+
+void ProcManagerDestroy(ProcManager *manager)
+{
+    if (manager != NULL)
+    {
+        /* procs_by_id owns the data */
+        MapSoftDestroy(manager->procs_by_fd);
+        MapSoftDestroy(manager->procs_by_pid);
+        MapDestroy(manager->procs_by_id);
+        free(manager);
+    }
+}
+
+static inline Subprocess *SubprocessNew(char *id, char *cmd, char *description,
+                                        pid_t pid, FILE *input, FILE *output, char lookup_io)
+{
+    Subprocess *ret  = xmalloc(sizeof(Subprocess));
+    ret->id          = id;
+    ret->cmd         = cmd;
+    ret->description = description;
+    ret->pid         = pid;
+    ret->input       = input;
+    ret->output      = output;
+    ret->lookup_io   = lookup_io;
+
+    return ret;
+}
+
+void SubprocessDestroy(Subprocess *proc)
+{
+    if (proc != NULL)
+    {
+        free(proc->id);
+        free(proc->cmd);
+        free(proc->description);
+        free(proc);
+    }
+}
+
+static inline int *DupInt(int val)
+{
+    int *ret = xmalloc(sizeof(int));
+    *ret = val;
+    return ret;
+}
+
+bool ProcManagerAddProcess(ProcManager *manager,
+                           char *id, char *cmd, char *description, pid_t pid,
+                           FILE *input, FILE *output, char lookup_io)
+{
+    assert(manager != NULL);
+
+    if (id == NULL)
+    {
+        NDEBUG_UNUSED int ret = xasprintf(&id, "%jd", (intmax_t) pid);
+        assert(ret > 0);
+    }
+
+    int *lookup_fd = NULL;
+    if (lookup_io == 'i')
+    {
+        assert(input != NULL);
+        int fd = fileno(input);
+        if (fd >= 0)
+        {
+            lookup_fd = DupInt(fd);
+        }
+        else
+        {
+            Log(LOG_LEVEL_ERR, "Failed to get FD for input file stream for the process '%s'",
+                description != NULL ? description : id);
+        }
+    }
+    else if (lookup_io == 'o')
+    {
+        assert(output != NULL);
+        int fd = fileno(output);
+        if (fd >= 0)
+        {
+            lookup_fd = DupInt(fd);
+        }
+        else
+        {
+            Log(LOG_LEVEL_ERR, "Failed to get FD for output file stream for the process '%s'",
+                description != NULL ? description : id);
+        }
+    }
+    else
+    {
+        assert(lookup_io == '\0');
+    }
+
+    if (MapHasKey(manager->procs_by_id, id) ||
+        MapHasKey(manager->procs_by_pid, &pid) ||
+        ((lookup_fd != NULL) && MapHasKey(manager->procs_by_fd, lookup_fd)))
+    {
+        Log(LOG_LEVEL_ERR,
+            "Attempt to insert the process '%s:%jd:%d' twice into the same process manager",
+            id, (intmax_t) pid, *lookup_fd);
+
+        free(id);
+        free(cmd);
+        free(description);
+        free(lookup_fd);
+
+        return false;
+    }
+
+    Subprocess *proc = SubprocessNew(id, cmd, description, pid, input, output, lookup_io);
+    MapInsert(manager->procs_by_id, id, proc);
+    MapInsert(manager->procs_by_pid, &(proc->pid), proc);
+
+    if (lookup_fd != NULL)
+    {
+        MapInsert(manager->procs_by_fd, lookup_fd, proc);
+    }
+
+    return true;
+}
+
+
+Subprocess *ProcManagerGetProcessByPID(ProcManager *manager, pid_t pid)
+{
+    assert(manager != NULL);
+    return (Subprocess*) MapGet(manager->procs_by_pid, &pid);
+}
+
+Subprocess *ProcManagerGetProcessById(ProcManager *manager, const char *id)
+{
+    assert(manager != NULL);
+    return (Subprocess*) MapGet(manager->procs_by_id, id);
+}
+
+Subprocess *ProcManagerGetProcessByFD(ProcManager *manager, int fd)
+{
+    assert(manager != NULL);
+    return (Subprocess*) MapGet(manager->procs_by_fd, &fd);
+}
+
+Subprocess *ProcManagerGetProcessByStream(ProcManager *manager, FILE *stream)
+{
+    assert(manager != NULL);
+    int fd = fileno(stream);
+    return (Subprocess*) MapGet(manager->procs_by_fd, &fd);
+}
+
+
+static inline void SoftRemoveProcFromMaps(ProcManager *manager, Subprocess *proc)
+{
+    assert(manager != NULL);
+
+    MapRemoveSoft(manager->procs_by_id, proc->id);
+    MapRemoveSoft(manager->procs_by_pid, &(proc->pid));
+
+    int lookup_fd = -1;
+    if (proc->lookup_io == 'i')
+    {
+        lookup_fd = fileno(proc->input);
+        assert(lookup_fd != -1);
+    }
+    else if (proc->lookup_io == 'o')
+    {
+        lookup_fd = fileno(proc->output);
+        assert(lookup_fd != -1);
+    }
+
+    if (lookup_fd != -1)
+    {
+        MapRemoveSoft(manager->procs_by_fd, &lookup_fd);
+    }
+}
+
+Subprocess *ProcManagerPopProcessByPID(ProcManager *manager, pid_t pid)
+{
+    assert(manager != NULL);
+
+    Subprocess *proc = MapGet(manager->procs_by_pid, &pid);
+    SoftRemoveProcFromMaps(manager, proc);
+    return proc;
+}
+
+Subprocess *ProcManagerPopProcessById(ProcManager *manager, const char *id)
+{
+    assert(manager != NULL);
+
+    Subprocess *proc = MapGet(manager->procs_by_id, id);
+    SoftRemoveProcFromMaps(manager, proc);
+    return proc;
+}
+
+Subprocess *ProcManagerPopProcessByFD(ProcManager *manager, int fd)
+{
+    assert(manager != NULL);
+
+    Subprocess *proc = MapGet(manager->procs_by_fd, &fd);
+    SoftRemoveProcFromMaps(manager, proc);
+    return proc;
+}
+
+Subprocess *ProcManagerPopProcessByStream(ProcManager *manager, FILE *stream)
+{
+    assert(manager != NULL);
+
+    int fd = fileno(stream);
+    Subprocess *proc = MapGet(manager->procs_by_fd, &fd);
+    SoftRemoveProcFromMaps(manager, proc);
+    return proc;
+}