DRAFT: Add launcher binary that allows for debugging missing DLL dependencies at load time

Author: jakepetroules

Sources/swblauncher/main.swift

@@ -0,0 +1,235 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2025 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
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import WinSDK
+import struct Foundation.Data
+import class Foundation.FileHandle
+import struct Foundation.URL
+
+// https://learn.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntqueryinformationprocess
+// Also see winternl.h in the Windows SDK.
+
+fileprivate struct PROCESS_BASIC_INFORMATION {
+    var ExitStatus: NTSTATUS = 0
+    var PebBaseAddress: ULONG_PTR = 0
+    var AffinityMask: ULONG_PTR = 0
+    var BasePriority: LONG = 0
+    var UniqueProcessId: ULONG_PTR = 0
+    var InheritedFromUniqueProcessId: ULONG_PTR = 0
+}
+
+fileprivate typealias NtQueryInformationProcessFunction = @convention(c) (_ ProcessHandle: HANDLE, _ ProcessInformationClass: CInt, _ ProcessInformation: PVOID, _ ProcessInformationLength: ULONG, _ ReturnLength: PULONG) -> NTSTATUS
+
+fileprivate struct _Win32Error: Error {
+    let functionName: String
+    let error: DWORD
+}
+
+fileprivate nonisolated var KF_FLAG_DEFAULT: DWORD {
+    DWORD(WinSDK.KF_FLAG_DEFAULT.rawValue)
+}
+
+fileprivate func SUCCEEDED(_ hr: HRESULT) -> Bool {
+    hr >= 0
+}
+
+fileprivate func _url(for id: KNOWNFOLDERID) throws -> URL {
+    var pszPath: PWSTR?
+    let hr: HRESULT = withUnsafePointer(to: id) { id in
+        SHGetKnownFolderPath(id, KF_FLAG_DEFAULT, nil, &pszPath)
+    }
+    guard SUCCEEDED(hr) else { throw _Win32Error(functionName: "SHGetKnownFolderPath", error: GetLastError()) }
+    defer { CoTaskMemFree(pszPath) }
+    return URL(filePath: String(decodingCString: pszPath!, as: UTF16.self), directoryHint: .isDirectory)
+}
+
+extension String {
+    fileprivate func withLPWSTR<T>(_ body: (UnsafeMutablePointer<WCHAR>) throws -> T) rethrows -> T {
+        try withUnsafeTemporaryAllocation(of: WCHAR.self, capacity: self.utf16.count + 1, { outBuffer in
+            try self.withCString(encodedAs: UTF16.self) { inBuffer in
+                outBuffer.baseAddress!.initialize(from: inBuffer, count: self.utf16.count)
+                outBuffer[outBuffer.count - 1] = 0
+                return try body(outBuffer.baseAddress!)
+            }
+        })
+    }
+}
+
+func withDebugEventLoop(_ hProcess: HANDLE, _ handle: (_ event: String) throws -> ()) throws {
+    let ntdllURL = try _url(for: FOLDERID_System).appendingPathComponent("ntdll.dll")
+    guard let ntdll = ntdllURL.withUnsafeFileSystemRepresentation({ s in s.map({ String(cString: $0) }) ?? String() }).withLPWSTR({ LoadLibraryW($0) }) else {
+        throw _Win32Error(functionName: "LoadLibraryW", error: GetLastError())
+    }
+
+    defer {
+        _ = FreeLibrary(ntdll)
+    }
+
+    guard let ntQueryInformationProc = GetProcAddress(ntdll, "NtQueryInformationProcess") else {
+        throw _Win32Error(functionName: "GetProcAddress", error: GetLastError())
+    }
+
+    var processBasicInformation = PROCESS_BASIC_INFORMATION()
+    var len: ULONG = 0
+
+    let processBasicInformationSize = MemoryLayout.size(ofValue: processBasicInformation)
+#if arch(x86_64) || arch(arm64)
+    precondition(processBasicInformationSize == 48)
+#else
+    precondition(processBasicInformationSize == 24)
+#endif
+    guard unsafeBitCast(ntQueryInformationProc, to: NtQueryInformationProcessFunction.self)(hProcess, 0, &processBasicInformation, ULONG(processBasicInformationSize), &len) == 0 else {
+        throw _Win32Error(functionName: "NtQueryInformationProcess", error: GetLastError())
+    }
+
+    let peb = Int(processBasicInformation.PebBaseAddress)
+
+    var gflags: ULONG = 0
+    var actual: SIZE_T = 0
+    guard ReadProcessMemory(hProcess, UnsafeMutableRawPointer(bitPattern: peb + 0xBC), &gflags, SIZE_T(MemoryLayout.size(ofValue: gflags)), &actual) else {
+        throw _Win32Error(functionName: "ReadProcessMemory", error: GetLastError())
+    }
+
+    gflags |= 0x2
+    guard WriteProcessMemory(hProcess, UnsafeMutableRawPointer(bitPattern: peb + 0xBC), &gflags, SIZE_T(MemoryLayout.size(ofValue: gflags)), &actual) else {
+        throw _Win32Error(functionName: "WriteProcessMemory", error: GetLastError())
+    }
+
+    func debugOutputString(_ hProcess: HANDLE, _ dbgEvent: inout DEBUG_EVENT) throws -> String {
+        let size = SIZE_T(dbgEvent.u.DebugString.nDebugStringLength)
+        return try withUnsafeTemporaryAllocation(of: UInt8.self, capacity: Int(size) + 2) { buffer in
+            guard ReadProcessMemory(hProcess, dbgEvent.u.DebugString.lpDebugStringData, buffer.baseAddress, size, nil) else {
+                throw _Win32Error(functionName: "ReadProcessMemory", error: GetLastError())
+            }
+
+            buffer[Int(size)] = 0
+            buffer[Int(size + 1)] = 0
+
+            if dbgEvent.u.DebugString.fUnicode != 0 {
+                return buffer.withMemoryRebound(to: UInt16.self) { String(decoding: $0, as: UTF16.self) }
+            } else {
+                return try withUnsafeTemporaryAllocation(of: UInt16.self, capacity: Int(size)) { wideBuffer in
+                    if MultiByteToWideChar(UINT(CP_ACP), 0, buffer.baseAddress, Int32(size), wideBuffer.baseAddress, Int32(size)) == 0 {
+                        throw _Win32Error(functionName: "MultiByteToWideChar", error: GetLastError())
+                    }
+                    return String(decoding: wideBuffer, as: UTF16.self)
+                }
+            }
+        }
+    }
+
+    func _WaitForDebugEventEx() throws -> DEBUG_EVENT {
+        // WARNING: Only the thread that created the process being debugged can call WaitForDebugEventEx.
+        var dbgEvent = DEBUG_EVENT()
+        guard WaitForDebugEventEx(&dbgEvent, INFINITE) else {
+            // WaitForDebugEventEx will fail if dwCreationFlags did not contain DEBUG_ONLY_THIS_PROCESS
+            throw _Win32Error(functionName: "WaitForDebugEventEx", error: GetLastError())
+        }
+        return dbgEvent
+    }
+
+    func runDebugEventLoop() throws {
+        do {
+            while true {
+                var dbgEvent = try _WaitForDebugEventEx()
+                if dbgEvent.dwProcessId == GetProcessId(hProcess) {
+                    switch dbgEvent.dwDebugEventCode {
+                    case DWORD(OUTPUT_DEBUG_STRING_EVENT):
+                        try handle(debugOutputString(hProcess, &dbgEvent))
+                    case DWORD(EXIT_PROCESS_DEBUG_EVENT):
+                        return // done!
+                    default:
+                        break
+                    }
+                }
+
+                guard ContinueDebugEvent(dbgEvent.dwProcessId, dbgEvent.dwThreadId, DBG_EXCEPTION_NOT_HANDLED) else {
+                    throw _Win32Error(functionName: "WaitForDebugEventEx", error: GetLastError())
+                }
+            }
+        } catch {
+            throw error
+        }
+    }
+
+    try runDebugEventLoop()
+}
+
+func createProcessTrampoline(_ commandLine: String) throws -> Int32 {
+    var processInformation = PROCESS_INFORMATION()
+    guard commandLine.withLPWSTR({ wCommandLine in
+        var startupInfo = STARTUPINFOW()
+        startupInfo.cb = DWORD(MemoryLayout.size(ofValue: startupInfo))
+        return CreateProcessW(
+            nil,
+            wCommandLine,
+            nil,
+            nil,
+            false,
+            DWORD(DEBUG_ONLY_THIS_PROCESS),
+            nil,
+            nil,
+            &startupInfo,
+            &processInformation,
+        )
+    }) else {
+        throw _Win32Error(functionName: "CreateProcessW", error: GetLastError())
+    }
+    defer {
+        _ = CloseHandle(processInformation.hThread)
+        _ = CloseHandle(processInformation.hProcess)
+    }
+    var missingDLLs: [String] = []
+    try withDebugEventLoop(processInformation.hProcess) { message in
+        if let match = try #/ ERROR: Unable to load DLL: "(?<moduleName>.*?)",/#.firstMatch(in: message) {
+            missingDLLs.append(String(match.output.moduleName))
+        }
+    }
+    // Don't need to call WaitForSingleObject because the process will have exited after withDebugEventLoop is called
+    var exitCode: DWORD = .max
+    guard GetExitCodeProcess(processInformation.hProcess, &exitCode) else {
+        throw _Win32Error(functionName: "GetExitCodeProcess", error: GetLastError())
+    }
+    if exitCode == STATUS_DLL_NOT_FOUND {
+        let stderr = FileHandle.standardError
+        for missingDLL in missingDLLs {
+            try stderr.write(contentsOf: Data("This application has failed to start because \(missingDLL) was not found.\r\n".utf8))
+        }
+    }
+    return Int32(bitPattern: exitCode)
+}
+
+func main() -> Int32 {
+    do {
+        var commandLine = String(decodingCString: GetCommandLineW(), as: UTF16.self)
+
+        // FIXME: This could probably be more robust
+        if commandLine.first == "\"" {
+            commandLine = String(commandLine.dropFirst())
+            if let index = commandLine.firstIndex(of: "\"") {
+                commandLine = String(commandLine.dropFirst(commandLine.distance(from: commandLine.startIndex, to: index) + 2))
+            }
+        } else if let index = commandLine.firstIndex(of: " ") {
+            commandLine = String(commandLine.dropFirst(commandLine.distance(from: commandLine.startIndex, to: index) + 1))
+        } else {
+            commandLine = ""
+        }
+
+        return try createProcessTrampoline(commandLine)
+    } catch {
+        let stderr = FileHandle.standardError
+        try? stderr.write(contentsOf: Data("\(error)\r\n".utf8))
+        return EXIT_FAILURE
+    }
+}
+
+exit(main())