Use fork and execve instead

Author: yim-lee

Sources/TSCBasic/Process.swift

@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+ Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See http://swift.org/LICENSE.txt for license information
@@ -658,6 +658,7 @@ public final class Process {
         posix_spawn_file_actions_init(&fileActions)
         defer { posix_spawn_file_actions_destroy(&fileActions) }
 
+        var spawnFunc: SpawnFunc = .posix_spawn
         if let workingDirectory = workingDirectory?.pathString {
           #if canImport(Darwin)
             // The only way to set a workingDirectory is using an availability-gated initializer, so we don't need
@@ -667,11 +668,11 @@ public final class Process {
                 posix_spawn_file_actions_addchdir_np(&fileActions, workingDirectory)
             }
           #elseif os(Linux)
-            guard SPM_posix_spawn_file_actions_addchdir_np_supported() else {
-                throw Process.Error.workingDirectoryNotSupported
+            if SPM_posix_spawn_file_actions_addchdir_np_supported() {
+                SPM_posix_spawn_file_actions_addchdir_np(&fileActions, workingDirectory)
+            } else {
+                spawnFunc = .fork_exec(workingDirectory: workingDirectory)
             }
-
-            SPM_posix_spawn_file_actions_addchdir_np(&fileActions, workingDirectory)
           #else
             throw Process.Error.workingDirectoryNotSupported
           #endif
@@ -725,8 +726,13 @@ public final class Process {
         }
         let argv = CStringArray(resolvedArgs)
         let env = CStringArray(environment.map({ "\($0.0)=\($0.1)" }))
-        let rv = posix_spawnp(&processID, argv.cArray[0]!, &fileActions, &attributes, argv.cArray, env.cArray)
-
+        let rv = switch spawnFunc {
+        case .posix_spawn:
+            posix_spawnp(&processID, argv.cArray[0]!, &fileActions, &attributes, argv.cArray, env.cArray)
+        case .fork_exec(let workingDirectory):
+            SPM_fork_exec_chdir(&processID, workingDirectory, argv.cArray[0]!, argv.cArray, env.cArray, &stdinPipe, &outputPipe, &stderrPipe, outputRedirection.redirectsOutput, outputRedirection.redirectStderr)
+        }
+        
         guard rv == 0 else {
             throw SystemError.posix_spawn(rv, arguments)
         }
@@ -1349,3 +1355,10 @@ extension Process {
         stdoutStream.flush()
     }
 }
+
+extension Process {
+    enum SpawnFunc {
+        case posix_spawn
+        case fork_exec(workingDirectory: String)
+    }
+}

Sources/TSCclibc/include/process.h

@@ -9,4 +9,8 @@ int SPM_posix_spawn_file_actions_addchdir_np(posix_spawn_file_actions_t *restric
 // Runtime check for the availability of posix_spawn_file_actions_addchdir_np. Returns 0 if the method is available, -1 if not.
 bool SPM_posix_spawn_file_actions_addchdir_np_supported();
 
+// Alternative for posix_spawn_file_actions_addchdir_np on Linux that mimics its behavior using fork, exec*, and chdir.
+int SPM_fork_exec_chdir(pid_t *pid, const char *target_directory, const char *cmd, char *const argv[], char *const envp[],
+                        int in_pipe[], int out_pipe[], int err_pipe[], bool redirect_out, bool redirect_err);
+
 #endif

Sources/TSCclibc/process.c

@@ -5,7 +5,10 @@
 #endif
 
 #include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <unistd.h>
+#include <sys/wait.h>
 
 #include "process.h"
 
@@ -14,8 +17,7 @@ int SPM_posix_spawn_file_actions_addchdir_np(posix_spawn_file_actions_t *restric
 #  if __GLIBC_PREREQ(2, 29)
     return posix_spawn_file_actions_addchdir_np(file_actions, path);
 #  else
-    // Change working directory which child process will inherit
-    return chdir(path);
+    return ENOSYS;
 #  endif
 #else
     return ENOSYS;
@@ -24,10 +26,71 @@ int SPM_posix_spawn_file_actions_addchdir_np(posix_spawn_file_actions_t *restric
 
 bool SPM_posix_spawn_file_actions_addchdir_np_supported() {
 #if defined(__GLIBC__)
+#  if __GLIBC_PREREQ(2, 29)
     return true;
+#  else
+    return false;
+#  endif
 #else
     return false;
 #endif
 }
 
+int SPM_fork_exec_chdir(pid_t *pid, const char *cwd,
+                        const char *cmd, char *const argv[], char *const envp[],
+                        int in_pipe[], int out_pipe[], int err_pipe[], bool redirect_out, bool redirect_err) {
+    *pid = fork();
+
+    if (*pid < 0) {
+        perror("fork() failed");
+        _exit(EXIT_FAILURE);
+    } else if (*pid > 0) { // Parent process
+        // Wait for child process to finish
+        int status;
+        waitpid(*pid, &status, 0);
+        return status;
+    } else { // Child process
+        // Change working directory then execute cmd
+        if (chdir(cwd)) {
+            _exit(EXIT_FAILURE);
+        }
+        
+        // Replicate pipe logic in TSCBasic.Process.launch()
+        
+        // Dupe the read portion of the remote to 0.
+        dup2(in_pipe[0], 0);
+        // Close the other side's pipe since it was duped to 0.
+        close(in_pipe[0]);
+        close(in_pipe[1]);
+        
+        if (redirect_out) {
+            // Open the write end of the pipe.
+            dup2(out_pipe[1], 1);
+            // Close the other ends of the pipe since they were duped to 1.
+            close(out_pipe[0]);
+            close(out_pipe[1]);
+            
+            if (redirect_err) {
+                // If merged was requested, send stderr to stdout.
+                dup2(1, 2);
+            } else {
+                // If no redirect was requested, open the pipe for stderr.
+                dup2(err_pipe[1], 2);
+                // Close the other ends of the pipe since they were dupped to 2.
+                close(err_pipe[0]);
+                close(err_pipe[1]);
+            }
+        } else {
+            dup2(1, 1);
+            dup2(2, 2);
+        }
+
+        execve(cmd, argv, envp);
+        
+        // If execve returns, it must have failed.
+        perror(cmd);
+        _exit(EXIT_FAILURE);
+    }
+}
+
 #endif