TSCBasic: avoid using C library functions for environment

Prefer to use the Win32 APIs for environment management.  Note that this
is going to break any user of libc on Windows.  Setting environment
variables through this function will not be reflected in the C library
only the Win32 APIs.  Furthermore, we use the unicode variants always as
the unicode and ANSI environment may diverge as not all unicode (UTF-16)
is translatable to ANSI, which is documented at [1].

[1] https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/getenv-wgetenv?view=msvc-170&viewFallbackFrom=vs-2019.

Author: compnerd

Sources/TSCBasic/Process/ProcessEnv.swift

@@ -67,26 +67,68 @@ public enum ProcessEnv {
     /// Returns a dictionary containing the current environment.
     public static var block: ProcessEnvironmentBlock { _vars }
 
+#if os(Windows)
+    private static var _vars: ProcessEnvironmentBlock = {
+        guard let lpwchEnvironment = GetEnvironmentStringsW() else { return [:] }
+        defer { FreeEnvironmentStringsW(lpwchEnvironment) }
+        var environment: ProcessEnvironmentBlock = [:]
+        var pVariable = UnsafePointer<WCHAR>(lpwchEnvironment)
+        while let entry = String.decodeCString(pVariable, as: UTF16.self) {
+            if entry.result.isEmpty { break }
+            let parts = entry.result.split(separator: "=", maxSplits: 1, omittingEmptySubsequences: false)
+            if parts.count == 2 {
+                environment[CaseInsensitiveString(String(parts[0]))] = String(parts[1])
+            }
+            pVariable = pVariable.advanced(by: entry.result.utf16.count + 1)
+        }
+        return environment
+    }()
+#else
     private static var _vars = ProcessEnvironmentBlock(
         uniqueKeysWithValues: ProcessInfo.processInfo.environment.map {
             (ProcessEnvironmentBlock.Key($0.key), $0.value)
         }
     )
+#endif
 
     /// Invalidate the cached env.
     public static func invalidateEnv() {
+#if os(Windows)
+        guard let lpwchEnvironment = GetEnvironmentStringsW() else {
+          _vars = [:]
+          return
+        }
+        defer { FreeEnvironmentStringsW(lpwchEnvironment) }
+
+        var environment: ProcessEnvironmentBlock = [:]
+        var pVariable = UnsafePointer<WCHAR>(lpwchEnvironment)
+        while let entry = String.decodeCString(pVariable, as: UTF16.self) {
+            if entry.result.isEmpty { break }
+            let parts = entry.result.split(separator: "=", maxSplits: 1, omittingEmptySubsequences: false)
+            if parts.count == 2 {
+                environment[CaseInsensitiveString(String(parts[0]))] = String(parts[1])
+            }
+            pVariable = pVariable.advanced(by: entry.result.utf16.count + 1)
+        }
+        _vars = environment
+#else
         _vars = ProcessEnvironmentBlock(
             uniqueKeysWithValues: ProcessInfo.processInfo.environment.map {
                 (CaseInsensitiveString($0.key), $0.value)
             }
         )
+#endif
     }
 
     /// Set the given key and value in the process's environment.
     public static func setVar(_ key: String, value: String) throws {
       #if os(Windows)
-        guard TSCLibc._putenv("\(key)=\(value)") == 0 else {
-            throw SystemError.setenv(Int32(GetLastError()), key)
+        try key.withCString(encodedAs: UTF16.self) { pwszKey in
+          try value.withCString(encodedAs: UTF16.self) { pwszValue in
+            guard SetEnvironmentVariableW(pwszKey, pwszValue) else {
+              throw SystemError.setenv(Int32(GetLastError()), key)
+            }
+          }
         }
       #else
         guard TSCLibc.setenv(key, value, 1) == 0 else {
@@ -99,7 +141,9 @@ public enum ProcessEnv {
     /// Unset the give key in the process's environment.
     public static func unsetVar(_ key: String) throws {
       #if os(Windows)
-        guard TSCLibc._putenv("\(key)=") == 0 else {
+        guard key.withCString(encodedAs: UTF16.self, {
+          SetEnvironmentVariableW($0, nil)
+        }) else {
             throw SystemError.unsetenv(Int32(GetLastError()), key)
         }
       #else
@@ -124,9 +168,7 @@ public enum ProcessEnv {
     public static func chdir(_ path: AbsolutePath) throws {
         let path = path.pathString
       #if os(Windows)
-        guard path.withCString(encodedAs: UTF16.self, {
-            SetCurrentDirectoryW($0)
-        }) else {
+        guard path.withCString(encodedAs: UTF16.self, SetCurrentDirectoryW) else {
             throw SystemError.chdir(Int32(GetLastError()), path)
         }
       #else

Tests/TSCBasicTests/ProcessEnvTests.swift

@@ -12,6 +12,9 @@ import XCTest
 
 import TSCBasic
 import TSCTestSupport
+#if os(Windows)
+import WinSDK
+#endif
 
 class ProcessEnvTests: XCTestCase {
 
@@ -55,4 +58,42 @@ class ProcessEnvTests: XCTestCase {
         }
         XCTAssertNil(ProcessEnv.vars[key])
     }
+
+    func testWin32API() throws {
+        #if os(Windows)
+        let variable: String = "SWIFT_TOOLS_SUPPORT_CORE_VARIABLE"
+        let value: String = "1"
+
+        try variable.withCString(encodedAs: UTF16.self) { pwszVariable in
+            try value.withCString(encodedAs: UTF16.self) { pwszValue in
+                guard SetEnvironmentVariableW(pwszVariable, pwszValue) else {
+                    throw XCTSkip("Failed to set environment variable")
+                }
+            }
+        }
+
+        // Ensure that libc does not see the variable.
+        XCTAssertNil(getenv(variable))
+        variable.withCString(encodedAs: UTF16.self) { pwszVariable in
+            XCTAssertNil(_wgetenv(pwszVariable))
+        }
+
+        // Ensure that we can read the variable
+        ProcessEnv.invalidateEnv()
+        XCTAssertEqual(ProcessEnv.vars[variable], value)
+
+        // Ensure that we can read the variable using the Win32 API.
+        variable.withCString(encodedAs: UTF16.self) { pwszVariable in
+            let dwLength = GetEnvironmentVariableW(pwszVariable, nil, 0)
+            withUnsafeTemporaryAllocation(of: WCHAR.self, capacity: Int(dwLength + 1)) {
+                let dwLength = GetEnvironmentVariableW(pwszVariable, $0.baseAddress, dwLength + 1)
+                XCTAssertEqual(dwLength, 1)
+                XCTAssertEqual(String(decodingCString: $0.baseAddress!, as: UTF16.self), value)
+            }
+        }
+        #else
+        throw XCTSkip("Win32 API is only available on Windows")
+        #endif
+
+    }
 }