Add non-blocking execution of script

Author: maximmenshikov

src/es_node_local.c

@@ -8,6 +8,7 @@
 #include <sys/types.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <sys/types.h>
 #include "es_node.h"
 #include "es_status.h"
 #include "stun.h"
@@ -138,14 +139,21 @@ es_local_process_binding_response(es_node *node,
 
     {
         char full_cmd[1024];
-        int ret;
+        pid_t pid;
 
         sprintf(full_cmd, "%s bind %s %u", node->params.script,
             node->status.mapped_addr,
             (unsigned)node->status.mapped_port);
-        ret = system(full_cmd);
-        ring("Script '%s' executed with return code %d", node->params.script,
-             ret);
+
+        pid = es_spawn_sh_noblock(full_cmd);
+        if (pid < 0)
+        {
+            warn("Failed to spawn script '%s': %s", node->params.script, strerror(errno));
+        }
+        else
+        {
+            ring("Script '%s' spawned (pid %ld)", node->params.script, (long)pid);
+        }
     }
     return ES_EOK;
 }

src/es_node_local_cr.c

@@ -3,6 +3,7 @@
 #include <fcntl.h>
 #include <string.h>
 #include <stdlib.h>
+#include <errno.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <netinet/in.h>
@@ -13,24 +14,31 @@
 #include "es_msg.h"
 #include "es_bool.h"
 #include "debug.h"
+#include "helper.h"
 
 es_status
 es_local_conn_request(es_node *node, const char *buf, uint32_t buf_len)
 {
     char full_cmd[1024];
-    int ret;
+    pid_t pid;
+
+    UNUSED(buf);
+    UNUSED(buf_len);
 
     /* FIXME: we need to parse connection request properly */
 
     sprintf(full_cmd, "%s cr %s %u", node->params.script,
         node->status.mapped_addr,
         (unsigned)node->status.mapped_port);
-    ret = system(full_cmd);
-    ring("Script '%s' executed with return code %d", node->params.script, ret);
-    if (ret != 0)
+
+    /* Fire-and-forget: do not block the request processing path */
+    pid = es_spawn_sh_noblock(full_cmd);
+    if (pid < 0)
     {
+        warn("Failed to spawn script '%s': %s", node->params.script, strerror(errno));
         return ES_ESCRIPTFAIL;
     }
 
+    ring("Script '%s' spawned (pid %ld)", node->params.script, (long)pid);
     return ES_EOK;
 }

src/helper.h

@@ -1,5 +1,61 @@
 #pragma once
 
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+/*
+ * Execute a shell command asynchronously:
+ *  - does NOT block the caller
+ *  - returns immediately with child's PID (>0) on success
+ *  - returns -1 on failure and sets errno
+ *
+ * If `dbg`/`warn` are available (debug.h), the implementation logs failures.
+ *
+ * The child:
+ *  - detaches from parent's process group
+ *  - execs `/bin/sh -lc <cmd>`
+ *
+ * Reaping:
+ *  - child is waited for using WNOHANG once immediately
+ *  - on many systems the child will be reaped when it exits if SIGCHLD is
+ *    configured appropriately by the embedding program; otherwise it may become
+ *    a zombie until reaped elsewhere.
+ *
+ * If you want strict zombie-free behavior without an event loop, install a
+ * SIGCHLD handler that loops waitpid(-1, ..., WNOHANG) in your program init.
+ */
+static inline pid_t
+es_spawn_sh_noblock(const char *cmd)
+{
+    pid_t pid = fork();
+    if (pid < 0)
+    {
+        /* fork failed */
+#ifdef warn
+        warn("fork() failed: %s", strerror(errno));
+#endif
+        return (pid_t)-1;
+    }
+
+    if (pid == 0)
+    {
+        /* child */
+        (void)setsid();
+        execl("/bin/sh", "sh", "-lc", cmd, (char *)NULL);
+
+        /* exec failed */
+#ifdef warn
+        warn("exec(/bin/sh -lc ...) failed: %s", strerror(errno));
+#endif
+        _exit(127);
+    }
+
+    (void)waitpid(pid, NULL, WNOHANG);
+    return pid;
+}
 
 #define EXIT_ON_ERROR(__msg, __rc) do { \
     if ((__rc) != ES_EOK) { \

src/main.c

@@ -7,6 +7,8 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/socket.h>
+#include <signal.h>
+#include <sys/wait.h>
 #include "stun.h"
 #include "debug.h"
 
@@ -56,6 +58,37 @@ optimize_socket(int sockfd)
     return 0;
 }
 
+static void
+es_reap_children(int signo)
+{
+    (void)signo;
+
+    /* Reap all finished children (non-blocking). */
+    for (;;)
+    {
+        int status;
+        pid_t pid = waitpid(-1, &status, WNOHANG);
+        if (pid <= 0)
+            break;
+
+        if (WIFEXITED(status))
+        {
+            ring("Script process %ld exited with code %d",
+                 (long)pid, WEXITSTATUS(status));
+        }
+        else if (WIFSIGNALED(status))
+        {
+            ring("Script process %ld terminated by signal %d",
+                 (long)pid, WTERMSIG(status));
+        }
+        else
+        {
+            ring("Script process %ld finished (status=0x%x)",
+                 (long)pid, status);
+        }
+    }
+}
+
 int main(int argc, const char *argv[])
 {
     es_status rc;
@@ -94,6 +127,22 @@ int main(int argc, const char *argv[])
         freopen("/dev/null", "w", stderr);
     }
 
+    /*
+     * Reap child processes spawned for scripts (fire-and-forget) without blocking.
+     * Use SA_RESTART so syscalls like poll() resume across signals.
+     */
+    {
+        struct sigaction sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sa_handler = es_reap_children;
+        sigemptyset(&sa.sa_mask);
+        sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
+        if (sigaction(SIGCHLD, &sa, NULL) != 0)
+        {
+            warn("sigaction(SIGCHLD) failed: %s", strerror(errno));
+        }
+    }
+
     es_init(node);
     es_init_params(node, params);