[android] Implement Process and modify TestProcess to pass.

Until recent API levels, Android haven't provide posix_spawn and other
functions from that family, so Process was not going to work with the
path used for the POSIX OS.

Instead of creating an specific path for Android, which will probably be
forgotten by other changes, we implement a subset of the posix_spawn
family of functions for Android, using fork and exec underneath, and
other functions from the POSIX APIs. The already code in Process do not
have to be modified.

The tests have to be modified slightly for working on Android. Many
changes are related to the environment needing the key LD_LIBRARY_PATH,
or the xdgTestHelper will not be able to start in some of the tests. The
other change is using NSTemporaryDirectory() instead of a hardcoded
`/tmp`, which doesn't exist in Android (the code also removes the last
slash, to match the original code expectations).

It also includes a small fix for when launch() is used and a error is
thrown which is not related to the current working directory. Before the
error was ignored silently, and now it will fatalError.

Author: drodriguez

Foundation/Process.swift

@@ -7,7 +7,6 @@
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 
-#if !os(Android) // not available
 import CoreFoundation
 
 extension Process {
@@ -287,6 +286,8 @@ open class Process: NSObject {
                 default:
                     fatalError("Process: The specified working directory cannot be set.")
                 }
+            } else {
+                fatalError(String(describing: nserror))
             }
         } catch {
             fatalError(String(describing: error))
@@ -608,7 +609,7 @@ open class Process: NSObject {
         }
 
         var taskSocketPair : [Int32] = [0, 0]
-#if os(macOS) || os(iOS)
+#if os(macOS) || os(iOS) || os(Android)
         socketpair(AF_UNIX, SOCK_STREAM, 0, &taskSocketPair)
 #else
         socketpair(AF_UNIX, Int32(SOCK_STREAM.rawValue), 0, &taskSocketPair)
@@ -978,4 +979,133 @@ private func posix(_ code: Int32) {
     default: fatalError("POSIX command failed with error: \(code)")
     }
 }
+
+#if os(Android)
+// Android doesn't provide posix_spawn APIs until recent API level, so we cannot
+// depend on them, but we can imitate the API, and perform the same work.
+
+private struct posix_spawn_file_actions_t {
+    enum Action {
+    case dup2(old: Int32, new: Int32)
+    case close(fd: Int32)
+    }
+
+    private(set) var actions: [Action] = []
+
+    mutating func add(_ action: Action) {
+        actions.append(action)
+    }
+}
+
+private struct posix_spawnattr_t {}
+
+private func posix_spawn_file_actions_init(_ actions: inout posix_spawn_file_actions_t) -> Int32 {
+    // NOTE: Nothing to do here, the struct initializes itself.
+    return 0
+}
+
+@discardableResult
+private func posix_spawn_file_actions_destroy(_ actions: inout posix_spawn_file_actions_t) -> Int32 {
+    // NOTE: Nothing to do here, the struct handles its own memory.
+    return 0
+}
+
+private func posix_spawn_file_actions_adddup2(_ actions: inout posix_spawn_file_actions_t, _ old: Int32, _ new: Int32) -> Int32 {
+    actions.add(.dup2(old: old, new: new))
+    return 0
+}
+
+private func posix_spawn_file_actions_addclose(_ actions: inout posix_spawn_file_actions_t, _ fd: Int32) -> Int32 {
+    actions.add(.close(fd: fd))
+    return 0
+}
+
+private func posix_spawn(_ pidPtr: UnsafeMutablePointer<pid_t>?,
+                         _ launchPath: UnsafePointer<Int8>?,
+                         _ actions: UnsafeMutablePointer<posix_spawn_file_actions_t>?,
+                         _ attrp: UnsafeMutablePointer<posix_spawnattr_t>?,
+                         _ argv: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>?,
+                         _ envp: UnsafeMutablePointer<UnsafeMutablePointer<Int8>?>?) -> Int32 {
+    // TODO: We completely ignore attrp, because at the moment, the only
+    // invocation doesn't pass a value.
+
+    // Block signals during this fork/execv dance.
+    var signalSet = sigset_t()
+    sigfillset(&signalSet)
+    var oldmask = sigset_t()
+    guard sigprocmask(SIG_BLOCK, &signalSet, &oldmask) == 0 else {
+        fatalError("sigprocmask() call failed: \(errno)")
+    }
+
+    let pid = fork()
+    guard pid == 0  else {
+        // This is the parent. fork call might have been successful or not.
+
+        // Unblock signals.
+        guard sigprocmask(SIG_SETMASK, &oldmask, nil) == 0 else {
+            fatalError("sigprocmask() call failed: \(errno)")
+        }
+
+        if pid < 0 {
+            return pid
+        } else {
+            if let pidPtr = pidPtr {
+                pidPtr.pointee = pid
+            }
+            return 0
+        }
+    }
+
+    // This is the child.
+
+    // Clean up the parent signal handlers
+    for idx in 1..<(NSIG as Int32) {
+        // Seems that SIGKILL/SIGSTOP are sometimes silently ignored, and
+        // sometimes return EINVAL. Since one cannot change the handlers anyway,
+        // skip them.
+        if idx == SIGKILL || idx == SIGSTOP {
+          continue
+        }
+        var sigAction = sigaction()
+        guard sigaction(idx, nil, &sigAction) == 0 else {
+            exit(127)
+        }
+
+        // One cannot compare @convention(c) function pointers without the
+        // conversion.
+        if unsafeBitCast(sigAction.sa_handler, to: UnsafeRawPointer?.self)
+                != unsafeBitCast(SIG_IGN, to: UnsafeRawPointer?.self) {
+            sigAction.sa_handler = SIG_DFL;
+            guard sigaction(idx, &sigAction, nil) == 0 else {
+                exit(127)
+            }
+        }
+    }
+
+    // Perform the actions
+    if let actions = actions?.pointee {
+        for action in actions.actions {
+            switch action {
+            case .dup2(let old, let new):
+                guard dup2(old, new) >= 0 else {
+                    exit(127)
+                }
+            case .close(let fd):
+                guard close(fd) == 0 else {
+                    exit(127)
+                }
+            }
+        }
+    }
+
+    // Unblock the signals
+    guard sigprocmask(SIG_SETMASK, &oldmask, nil) == 0 else {
+        fatalError("sigprocmask() call failed: \(errno)")
+    }
+
+    // If execv fails, we will simply exit 127 as the standard says.
+    execve(launchPath, argv, envp ?? environ)
+    exit(127)
+    // no need for return here
+}
 #endif

TestFoundation/TestProcess.swift

@@ -7,7 +7,6 @@
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 
-#if !os(Android)
 class TestProcess : XCTestCase {
 
     func test_exit0() throws {
@@ -155,6 +154,13 @@ class TestProcess : XCTestCase {
         // Clear the environment to stop the malloc debug flags used in Xcode debug being
         // set in the subprocess.
         process.environment = [:]
+#if os(Android)
+        // In Android, we have to provide at least an LD_LIBRARY_PATH, or
+        // xdgTestHelper will not be able to find the Swift libraries.
+        if let ldLibraryPath = ProcessInfo.processInfo.environment["LD_LIBRARY_PATH"] {
+            process.environment?["LD_LIBRARY_PATH"] = ldLibraryPath
+        }
+#endif
         try? process.run()
         process.waitUntilExit()
         XCTAssertEqual(process.terminationStatus, 1)
@@ -231,7 +237,16 @@ class TestProcess : XCTestCase {
     }
 
     func test_current_working_directory() {
-        let tmpDir = "/tmp" //.standardizingPath
+        let tmpDir = { () -> String in
+            // NSTemporaryDirectory might return a final slash, but
+            // FileManager.currentDirectoryPath seems to avoid it.
+            var dir = NSTemporaryDirectory()
+            if dir.hasSuffix("/") && dir != "/",
+                    let idx = dir.lastIndex(of: "/") {
+               dir.remove(at: idx)
+            }
+            return dir
+        }()
 
         let fm = FileManager.default
         let previousWorkingDirectory = fm.currentDirectoryPath
@@ -637,7 +652,16 @@ internal func runTask(_ arguments: [String], environment: [String: String]? = ni
     process.arguments = arguments
     // Darwin Foundation doesnt allow .environment to be set to nil although the documentation
     // says it is an optional. https://developer.apple.com/documentation/foundation/process/1409412-environment
-    if let e = environment {
+    if var e = environment {
+#if os(Android)
+        // In Android, we have to provide at least an LD_LIBRARY_PATH, or
+        // xdgTestHelper will not be able to find the Swift libraries.
+        if e["LD_LIBRARY_PATH"] == nil {
+            if let ldLibraryPath = ProcessInfo.processInfo.environment["LD_LIBRARY_PATH"] {
+                e["LD_LIBRARY_PATH"] = ldLibraryPath
+            }
+        }
+#endif
         process.environment = e
     }
 
@@ -701,9 +725,16 @@ private func parseEnv(_ env: String) throws -> [String: String] {
         guard let range = line.range(of: "=") else {
             throw Error.InvalidEnvironmentVariable(line)
         }
-        result[String(line[..<range.lowerBound])] = String(line[range.upperBound...])
+        let key = String(line[..<range.lowerBound])
+#if os(Android)
+        // NOTE: this works because the results of parseEnv are never checked
+        // against the parent environment, where this key will be set. If that
+        // ever happen, the checks should be changed.
+        if key == "LD_LIBRARY_PATH" {
+            continue
+        }
+#endif
+        result[key] = String(line[range.upperBound...])
     }
     return result
 }
-#endif // !os(Android)
-