fd inheritance - per-process stdio & fd inheritance for spawned children (#416)

* Don't open timer.device any tyme a pthread timed function is called

* Fixed uuid created as local memory variable

* Refactor debug output formatting

* fd inheritance: implement per-process stdio and fd inheritance for spawned children

- Move struct iob __sf[3] and struct _glue __sglue from shared globals
  to per-process heap-allocated fields in struct _clib4 (dos.h, clib4.h).
  Each process now has isolated stdio state; child cleanup no longer
  corrupts the parent's stdio buffers.

- stdio_file_init (file_init.c) allocates per-process iob structs and
  the root glue node on the heap.  __close_all_files (init_exit.c) frees
  them.  __stdin/__stdout/__stderr (__std.c) and _fwalk (fwalk.c) use the
  per-process pointers.  findfp.c and stdio_headers.h updated accordingly.

- fd inheritance: parent encodes open fds >= 3 as a spec string
  (fd:flags:handle_or_token;) passed via spawnData.fdInherit.
  PIPE: handles are stored as symbolic tokens STDIN/STDOUT/STDERR so the
  child uses Input()/Output()/ErrorOutput() instead of a disconnected
  DupFileHandle copy (AmigaOS4 PIPE: limitation).

- children.c: insertSpawnedChildren gains fdInherit param; new functions
  import_inherited_fds_from_spec and import_pending_fds_for_process.
  FDF_NO_CLOSE_BPTR set for symbolic-token handles.

- clib4.c (libOpen): added existing->self == _me guard so NP_Child TRUE
  children are not mistaken for the parent and get their own _clib4 +
  run import_pending_fds_for_process after _start_ctors.

- Extract build_fd_inherit_spec / close_fd_inherit_spec_handles into
  spawn_utils.c / spawn_utils.h (shared by spawnvpe, spawnv, popen).
  spawnvpe passes the explicit fhin/fhout/fherr for token detection;
  spawnv and popen pass -1/-1/-1 (no stdio redirection).

- spawnData changed from stack-allocated struct to heap-allocated pointer
  (ownership transferred to spawnedProcessEnter / Clib4Children).
  NP_CopyVars TRUE added to spawnv and popen SystemTags calls.

- Remove all debug DOS Printf calls added during development.

Author: afxgroup

library/c.lib_rev.h

@@ -2,7 +2,7 @@
 #define REVISION                1
 #define SUBREVISION             0
 
-#define DATE                    "14.05.2026"
+#define DATE                    "28.05.2026"
 #define VERS                    "clib4.library 2.1"
-#define VSTRING                 "clib4.library 2.1 (14.05.2026)\r\n"
-#define VERSTAG                 "\0$VER: clib4.library 2.1-ab40f98 (14.05.2026)"
+#define VSTRING                 "clib4.library 2.1 (28.05.2026)\r\n"
+#define VERSTAG                 "\0$VER: clib4.library 2.1-ab40f98 (28.05.2026)"

library/dos.h

@@ -139,6 +139,13 @@ struct _wchar {
     _mbstate_t _wcsrtombs_state;
 };
 
+/*
+ * Forward declarations for stdio internals (full definitions in stdio_headers.h).
+ * Only pointer types are used in _clib4, so forward declarations are sufficient.
+ */
+struct iob;
+struct _glue;
+
 /*
  * Initial _clib4 structure. This contains all fields used by current progream
  */
@@ -589,12 +596,14 @@ struct _clib4 {
     int __stdio_initialized;            /* Non-zero after __sinit() has run */
 
     /*
-     * Per-process glue-list root for stream allocation.
-     * Replaces the global __sglue which is shared across all processes
-     * in the shared library — using a global caused child processes
-     * (via spawnvpe) to corrupt the parent's stdin/stdout/stderr buffers.
+     * Per-process stdio streams and glue-list root.
+     * Replaces the shared globals __sf[3] and __sglue from findfp.c.
+     * Each process that opens clib4.library gets its own iob structs and
+     * glue root, preventing child processes from corrupting the parent's
+     * stdin/stdout/stderr buffers.
      */
-    void *__sglue_root;                 /* per-process root _glue node (struct _glue *) */
+    struct iob   *__sf[3];              /* per-process stdin/stdout/stderr iob pointers */
+    struct _glue *__sglue;              /* per-process root glue node for FILE slots */
 };
 
 #ifndef __getClib4

library/misc/children.c

@@ -13,6 +13,89 @@
 #include "clib4.h"
 #include "children.h"
 
+void
+import_inherited_fds_from_spec(struct _clib4 *__clib4, const char *spec) {
+    char *copy;
+    char *entry;
+
+    if (spec == NULL || spec[0] == '\0')
+        return;
+
+    copy = strdup(spec);
+    if (copy == NULL)
+        return;
+
+    entry = strtok(copy, ";");
+    while (entry != NULL) {
+        char *fd_str = entry;
+        char *flags_str = strchr(fd_str, ':');
+
+        if (flags_str != NULL) {
+            *flags_str++ = '\0';
+            char *handle_str = strchr(flags_str, ':');
+            if (handle_str != NULL) {
+                *handle_str++ = '\0';
+
+                int fd_num = (int) strtol(fd_str, NULL, 10);
+                ULONG flags = (ULONG) strtoul(flags_str, NULL, 10);
+                BPTR inherited_handle = BZERO;
+                BOOL no_close = FALSE;
+
+                /*
+                 * Symbolic tokens: the parent detected that this fd shares
+                 * the same underlying pipe handle as fhin/fhout/fherr.
+                 * AmigaOS4's PIPE: device does not properly share the data
+                 * stream with DupFileHandle copies, so we map these fds to
+                 * the process-level Input()/Output()/ErrorOutput() handles
+                 * which are guaranteed to be connected to the right pipe.
+                 * Mark FDF_NO_CLOSE_BPTR so clib4 doesn't close these
+                 * process-managed handles.
+                 */
+                if (strcmp(handle_str, "STDIN") == 0) {
+                    inherited_handle = Input();
+                    no_close = TRUE;
+                } else if (strcmp(handle_str, "STDOUT") == 0) {
+                    inherited_handle = Output();
+                    no_close = TRUE;
+                } else if (strcmp(handle_str, "STDERR") == 0) {
+                    inherited_handle = ErrorOutput();
+                    no_close = TRUE;
+                } else {
+                    inherited_handle = (BPTR) strtoul(handle_str, NULL, 16);
+                }
+
+                if (fd_num > STDERR_FILENO && inherited_handle != BZERO) {
+                    if (fd_num >= __clib4->__num_fd) {
+                        if (__grow_fd_table(__clib4, fd_num + 1) < 0) {
+                            entry = strtok(NULL, ";");
+                            continue;
+                        }
+                    }
+
+                    APTR lock = __create_mutex();
+                    if (lock != NULL) {
+                        ULONG inherited_flags = flags;
+                        CLEAR_FLAG(inherited_flags, FDF_CLOEXEC);
+                        SET_FLAG(inherited_flags, FDF_IN_USE);
+                        if (no_close)
+                            SET_FLAG(inherited_flags, FDF_NO_CLOSE_BPTR);
+
+                        __initialize_fd(__clib4->__fd[fd_num],
+                                        __fd_hook_entry,
+                                        inherited_handle,
+                                        inherited_flags,
+                                        lock);
+                    }
+                }
+            }
+        }
+
+        entry = strtok(NULL, ";");
+    }
+
+    free(copy);
+}
+
 static void *
 gidChildrenScan(const void *children, void *gid) {
     const struct Clib4Children *myChildren = children;
@@ -41,7 +124,7 @@ pipeChildrenScan(const void *children, void *pipe) {
 }
 
 BOOL
-insertSpawnedChildren(uint32 pid, uint32 gid, const char *parentUuid) {
+insertSpawnedChildren(uint32 pid, uint32 gid, const char *parentUuid, const char *fdInherit) {
     DECLARE_UTILITYBASE();
 
     struct Clib4Resource *res = (APTR) OpenResource(RESOURCE_NAME);
@@ -50,6 +133,9 @@ insertSpawnedChildren(uint32 pid, uint32 gid, const char *parentUuid) {
         children.pid = pid;
         children.returnCode = 0x10000000; //set this flag for WIFEXITED
         children.groupId = gid;
+        children.pipe = NULL;
+        /* take direct ownership of the heap-allocated spec; caller must set its ptr to NULL */
+        children.fdInherit = (fdInherit != NULL && fdInherit[0] != '\0') ? (char *)fdInherit : NULL;
 
         /* Use direct hashmap_get by uuid — avoids hashmap_iter race condition */
         struct Clib4Node nodeKey;
@@ -154,16 +240,46 @@ spawnedProcessEnter(int32 entry_data) {
 	struct Task *parentTask = data->parentTask;
 
     uint32 pid = GetPID(0, GPID_PROCESS);
-    if (insertSpawnedChildren(pid, groupId, data->parentUuid)) {
+    /* fdInherit ownership transferred into Clib4Children; consumed later in libOpen */
+    if (insertSpawnedChildren(pid, groupId, data->parentUuid, data->fdInherit)) {
+        data->fdInherit = NULL;  /* ownership transferred */
         __CLIB4->__children++;
         D(("Children with pid %ld and gid %ld inserted into list\n", pid, groupId));
     }
     else {
         D(("Cannot insert children with pid %ld and gid %ld into list\n", pid, groupId));
+        /* insertion failed: free the spec that was not transferred */
+        free(data->fdInherit);
+        data->fdInherit = NULL;
     }
+	free(data);
 	Signal(parentTask, SIGF_CHILD);
 }
 
+void
+import_pending_fds_for_process(struct _clib4 *__clib4, uint32 pid, uint32 ppid) {
+    struct Clib4Resource *res = (APTR) OpenResource(RESOURCE_NAME);
+    if (!res) return;
+
+    size_t iter = 0;
+    void *item;
+    while (hashmap_iter(res->children, &iter, &item)) {
+        struct Clib4Node *node = item;
+        if (node->pid == ppid) {
+            struct Clib4Children key;
+            memset(&key, 0, sizeof(key));
+            key.pid = pid;
+            struct Clib4Children *ce = (struct Clib4Children *) hashmap_get(node->spawnedProcesses, &key);
+            if (ce != NULL && ce->fdInherit != NULL) {
+                import_inherited_fds_from_spec(__clib4, ce->fdInherit);
+                free(ce->fdInherit);
+                ce->fdInherit = NULL;
+            }
+            break;
+        }
+    }
+}
+
 void
 spawnedProcessExit(int32 rc, int32 data UNUSED) {
     struct Clib4Resource *res = (APTR) OpenResource(RESOURCE_NAME);

library/misc/children.h

@@ -7,18 +7,21 @@
 
 #include "clib4.h"
 
-BOOL insertSpawnedChildren(uint32 pid, uint32 gid, const char *parentUuid);
+BOOL insertSpawnedChildren(uint32 pid, uint32 gid, const char *parentUuid, const char *fdInherit);
 struct Clib4Children *findSpawnedChildrenByPid(uint32 pid);
 struct Clib4Children *findSpawnedChildrenByGid(uint32 pid, uint32 gid);
 void addSpawnedChildrenPipeHandle(uint32 pid, FILE *pipe);
 pid_t findSpawnedChildrenPidByPipe(FILE *pipe);
 void spawnedProcessExit(int32 rc, int32 data UNUSED);
 void spawnedProcessEnter(int32 entry_data);
+void import_inherited_fds_from_spec(struct _clib4 *__clib4, const char *spec);
+void import_pending_fds_for_process(struct _clib4 *__clib4, uint32 pid, uint32 ppid);
 
 struct spawnData {
 	gid_t groupId;
 	struct Task *parentTask;
 	char parentUuid[UUID4_LEN + 1];
+	char *fdInherit;
 };
 
 #endif

library/shared_library/clib4.c

@@ -415,7 +415,16 @@ struct Clib4Library *libOpen(struct LibraryManagerInterface *Self, uint32 versio
         struct Process *_me = (struct Process *) IExec->FindTask(NULL);
         if (_me->pr_Task.tc_Node.ln_Type == NT_PROCESS && _me->pr_UID != 0) {
             struct _clib4 *existing = (struct _clib4 *) _me->pr_UID;
-            if (existing->__fully_initialized) {
+            /*
+             * Only reuse an existing context if it actually belongs to THIS
+             * process.  With NP_Child TRUE, a spawned child inherits the
+             * parent's pr_UID (pointing to the parent's fully-initialised
+             * _clib4).  We must NOT take the early-return for a new child
+             * process — it needs its own context so that
+             * import_pending_fds_for_process() can run and wire up the
+             * inherited file descriptors.
+             */
+            if (existing->__fully_initialized && existing->self == _me) {
                 D(bug("(libOpen) Process already has a valid _clib4 (%p) — reusing it\n", existing));
                 existing->__lib_open_count++;
                 if (IExpansion != NULL) {
@@ -560,6 +569,14 @@ struct Clib4Library *libOpen(struct LibraryManagerInterface *Self, uint32 versio
             _start_ctors(__CTOR_LIST__);
             SHOWMSG("Done. All constructors called");
 
+            /* Import any file descriptors inherited from the parent process.
+             * Must be done AFTER _start_ctors (which runs stdio_file_init and
+             * sets up __fd[0..2]) so that __clib4 is the child's own context. */
+            {
+                extern void import_pending_fds_for_process(struct _clib4 *__clib4, uint32 pid, uint32 ppid);
+                import_pending_fds_for_process(__clib4, pid, ppid);
+            }
+
             /* Copy environment variables into clib4 reent structure */
             SHOWMSG("Make environment");
 			makeEnvironment(__clib4);

library/shared_library/clib4.h

@@ -74,6 +74,7 @@ struct Clib4Children {
     gid_t   groupId;    /* Group ID of process */
     uint32  returnCode; /* the return code of process */
     FILE    *pipe;
+    char   *fdInherit;  /* heap-allocated fd inherit spec, consumed by child libOpen */
 };
 
 int libReserved(void);