Merge branch 'main' into SHGetKnownFolderPath-Continued

Author: ShikiSuen

CMakeLists.txt

@@ -124,6 +124,11 @@ add_compile_definitions(
 if(CMAKE_SYSTEM_NAME STREQUAL Linux)
   check_symbol_exists(sched_getaffinity "sched.h" HAVE_SCHED_GETAFFINITY)
   add_compile_definitions($<$<COMPILE_LANGUAGE:C>:HAVE_SCHED_GETAFFINITY>)
+
+  # Pass -fno-omit-frame-pointer while compiling for better backtraces
+  add_compile_options(
+    "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xcc -fno-omit-frame-pointer>"
+    "$<$<COMPILE_LANGUAGE:C,CXX>:-fno-omit-frame-pointer>")
 endif()
 
 # Precompute module triple for installation

Sources/CoreFoundation/CFPlatform.c

@@ -136,6 +136,10 @@ static inline void _CFSetProgramNameFromPath(const char *path) {
 #include <sys/exec.h>
 #endif
 
+#if TARGET_OS_BSD && defined(__FreeBSD__)
+#include <sys/sysctl.h>
+#endif
+
 const char *_CFProcessPath(void) {
     if (__CFProcessPath) return __CFProcessPath;
 
@@ -230,6 +234,29 @@ const char *_CFProcessPath(void) {
         char *res = realpath(ps->ps_argvstr[0], NULL);
         argv0 = res? res: strdup(ps->ps_argvstr[0]);
     }
+#elif defined(__FreeBSD__)
+    // see sysctl(3), pid == -1 means current process
+    int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
+    int sysctl_ret = 0;
+    size_t len = PATH_MAX + 1;
+    argv0 = calloc(len, 1);
+
+    sysctl_ret = sysctl(mib, 4, argv0, &len, NULL, 0);
+
+    // in case for whatever reason the path is > PATH_MAX
+    if (sysctl_ret == -1 && errno == ENOMEM) {
+        // get size needed
+        sysctl_ret = sysctl(mib, 4, NULL, &len, NULL, 0);
+        if (sysctl_ret != -1) {
+            argv0 = realloc(argv0, len);
+            sysctl_ret = sysctl(mib, 4, argv0, &len, NULL, 0);
+        }
+    }
+
+    if (sysctl_ret == -1) {
+        free(argv0);
+        argv0 = NULL;
+    }
 #endif
 
     if (!__CFProcessIsRestricted() && argv0 && argv0[0] == '/') {
@@ -908,6 +935,9 @@ static void __CFTSDFinalize(void *arg) {
 
     if (!arg || arg == CF_TSD_BAD_PTR) {
         // We've already been destroyed. The call above set the bad pointer again. Now we just return.
+#if defined(__FreeBSD__)
+        __CFTSDSetSpecific(NULL);
+#endif
         return;
     }
 
@@ -2287,9 +2317,10 @@ CF_EXPORT int _CFPosixSpawnFileActionsChdir(_CFPosixSpawnFileActionsRef file_act
   // Glibc versions prior to 2.29 don't support posix_spawn_file_actions_addchdir_np, impacting:
   //  - Amazon Linux 2 (EoL mid-2025)
   return ENOSYS;
-  #elif defined(__OpenBSD__)
+  #elif defined(__OpenBSD__) || defined(__QNX__)
   // Currently missing as of:
   //  - OpenBSD 7.5 (April 2024)
+  //  - QNX 8 (December 2023)
   return ENOSYS;
   #elif defined(__GLIBC__) || TARGET_OS_DARWIN || defined(__FreeBSD__) || (defined(__ANDROID__) && __ANDROID_API__ >= 34) || defined(__musl__)
   // Pre-standard posix_spawn_file_actions_addchdir_np version available in:
@@ -2304,7 +2335,6 @@ CF_EXPORT int _CFPosixSpawnFileActionsChdir(_CFPosixSpawnFileActionsRef file_act
   // Standardized posix_spawn_file_actions_addchdir version (POSIX.1-2024, June 2024) available in:
   //  - Solaris 11.4 (August 2018)
   //  - NetBSD 10.0 (March 2024)
-  //  - QNX 8 (December 2023)
   return posix_spawn_file_actions_addchdir((posix_spawn_file_actions_t *)file_actions, path);
   #endif
 }

Sources/Foundation/NSConcreteValue.swift

@@ -97,6 +97,7 @@ internal class NSConcreteValue : NSValue, @unchecked Sendable {
         value.copyMemory(from: self._storage, byteCount: self._size)
     }
 
+    @available(*, deprecated, message: "On platforms without Objective-C autorelease pools, use withCString instead")
     override var objCType : UnsafePointer<Int8> {
         return NSString(self._typeInfo.name).utf8String! // XXX leaky
     }

Sources/Foundation/NSData.swift

@@ -433,10 +433,13 @@ open class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
 #if os(WASI)
         // WASI does not have permission concept
         let permissions: Int? = nil
+        // ReadingOptions.atomic won't be specified on WASI as it's marked unavailable
+        var atomicWrite: Bool { false }
 #else
         let permissions = try? fm.attributesOfItem(atPath: path)[.posixPermissions] as? Int
+        let atomicWrite = writeOptionsMask.contains(.atomic)
 #endif
-        if writeOptionsMask.contains(.atomic) {
+        if atomicWrite {
             let (newFD, auxFilePath) = try _NSCreateTemporaryFile(path)
             let fh = FileHandle(fileDescriptor: newFD, closeOnDealloc: true)
             do {
@@ -487,22 +490,38 @@ open class NSData : NSObject, NSCopying, NSMutableCopying, NSSecureCoding {
 
     /// Writes the data object's bytes to the file specified by a given path.
     /// NOTE: the 'atomically' flag is ignored if the url is not of a type the supports atomic writes
+    #if os(WASI)
+    @available(*, unavailable, message: "WASI does not support atomic file-writing as it does not have temporary directories")
+    #endif
     open func write(toFile path: String, atomically useAuxiliaryFile: Bool) -> Bool {
+        #if os(WASI)
+        // WASI does not support atomic file-writing as it does not have temporary directories
+        return false
+        #else
         do {
             try write(toFile: path, options: useAuxiliaryFile ? .atomic : [])
         } catch {
             return false
         }
         return true
+        #endif
     }
 
     /// Writes the data object's bytes to the location specified by a given URL.
     /// NOTE: the 'atomically' flag is ignored if the url is not of a type the supports atomic writes
+    #if os(WASI)
+    @available(*, unavailable, message: "WASI does not support atomic file-writing as it does not have temporary directories")
+    #endif
     open func write(to url: URL, atomically: Bool) -> Bool {
+        #if os(WASI)
+        // WASI does not support atomic file-writing as it does not have temporary directories
+        return false
+        #else
         if url.isFileURL {
             return write(toFile: url.path, atomically: atomically)
         }
         return false
+        #endif
     }
 
     ///    Writes the data object's bytes to the location specified by a given URL.

Sources/Foundation/NSNumber.swift

@@ -1150,6 +1150,18 @@ open class NSNumber : NSValue, @unchecked Sendable {
     }
 
     open override var classForCoder: AnyClass { return NSNumber.self }
+    
+    /// Provides a way for `plutil` to know if `CFPropertyList` has returned a literal `true`/`false` value, as opposed to a number which happens to have a value of 1 or 0.
+    @_spi(BooleanCheckingForPLUtil)
+    public var _exactBoolValue: Bool? {
+        if self === kCFBooleanTrue {
+            return true
+        } else if self === kCFBooleanFalse {
+            return false
+        } else {
+            return nil
+        }
+    }
 }
 
 extension CFNumber : _NSBridgeable {

Sources/Foundation/NSSpecialValue.swift

@@ -97,6 +97,7 @@ internal class NSSpecialValue : NSValue, @unchecked Sendable {
         _value.encodeWithCoder(aCoder)
     }
 
+    @available(*, deprecated, message: "On platforms without Objective-C autorelease pools, use withCString instead")
     override var objCType : UnsafePointer<Int8> {
         let typeName = NSSpecialValue._objCTypeFromType(type(of: _value))
         return typeName!._bridgeToObjectiveC().utf8String! // leaky

Sources/Foundation/NSString.swift

@@ -7,7 +7,7 @@
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 
-
+@_spi(SwiftCorelibsFoundation) @_exported import FoundationEssentials
 @_implementationOnly import CoreFoundation
 internal import Synchronization
 
@@ -160,32 +160,19 @@ internal func _createRegexForPattern(_ pattern: String, _ options: NSRegularExpr
     return regex
 }
 
-internal func _bytesInEncoding(_ str: NSString, _ encoding: String.Encoding, _ fatalOnError: Bool, _ externalRep: Bool, _ lossy: Bool) -> UnsafePointer<Int8>? {
-    let theRange = NSRange(location: 0, length: str.length)
+// Caller must free, or leak, the pointer
+fileprivate func _allocateBytesInEncoding(_ str: NSString, _ encoding: String.Encoding) -> UnsafeMutableBufferPointer<Int8>? {
+    let theRange: NSRange = NSRange(location: 0, length: str.length)
     var cLength = 0
-    var used = 0
-    var options: NSString.EncodingConversionOptions = []
-    if externalRep {
-        options.formUnion(.externalRepresentation)
-    }
-    if lossy {
-        options.formUnion(.allowLossy)
-    }
-    if !str.getBytes(nil, maxLength: Int.max - 1, usedLength: &cLength, encoding: encoding.rawValue, options: options, range: theRange, remaining: nil) {
-        if fatalOnError {
-            fatalError("Conversion on encoding failed")
-        }
+    if !str.getBytes(nil, maxLength: Int.max - 1, usedLength: &cLength, encoding: encoding.rawValue, options: [], range: theRange, remaining: nil) {
         return nil
     }
 
-    let buffer = malloc(cLength + 1)!.bindMemory(to: Int8.self, capacity: cLength + 1)
-    if !str.getBytes(buffer, maxLength: cLength, usedLength: &used, encoding: encoding.rawValue, options: options, range: theRange, remaining: nil) {
-        fatalError("Internal inconsistency; previously claimed getBytes returned success but failed with similar invocation")
-    }
+    let buffer = UnsafeMutableBufferPointer<Int8>.allocate(capacity: cLength + 1)
+    buffer.initialize(repeating: 0)
+    _ = str.getBytes(buffer.baseAddress, maxLength: cLength, usedLength: nil, encoding: encoding.rawValue, options: [], range: theRange, remaining: nil)    
 
-    buffer.advanced(by: cLength).initialize(to: 0)
-    
-    return UnsafePointer(buffer) // leaked and should be autoreleased via a NSData backing but we cannot here
+    return buffer
 }
 
 internal func isALineSeparatorTypeCharacter(_ ch: unichar) -> Bool {
@@ -903,8 +890,13 @@ extension NSString {
         }
     }
 
+    @available(*, deprecated, message: "On platforms without Objective-C autorelease pools, use withCString instead")
     public var utf8String: UnsafePointer<Int8>? {
-        return _bytesInEncoding(self, .utf8, false, false, false)
+        guard let buffer = _allocateBytesInEncoding(self, .utf8) else {
+            return nil
+        }
+        // leaked. On Darwin, freed via an autorelease
+        return UnsafePointer<Int8>(buffer.baseAddress)
     }
 
     public var fastestEncoding: UInt {
@@ -961,8 +953,24 @@ extension NSString {
                                           0, nil, 0, nil) == length
     }
 
-    public func cString(using encoding: UInt) -> UnsafePointer<Int8>? { 
-        return _bytesInEncoding(self, String.Encoding(rawValue: encoding), false, false, false)
+    @available(*, deprecated, message: "On platforms without Objective-C autorelease pools, use withCString(encodedAs:_) instead")
+    public func cString(using encoding: UInt) -> UnsafePointer<Int8>? {
+        // leaked. On Darwin, freed via an autorelease
+        guard let buffer = _allocateBytesInEncoding(self,  String.Encoding(rawValue: encoding)) else {
+            return nil
+        }
+        // leaked. On Darwin, freed via an autorelease
+        return UnsafePointer<Int8>(buffer.baseAddress)
+    }
+
+    internal func _withCString<T>(using encoding: UInt, closure: (UnsafePointer<Int8>?) -> T) -> T {
+        let buffer = _allocateBytesInEncoding(self, String.Encoding(rawValue: encoding))
+        let result = closure(buffer?.baseAddress)
+        if let buffer {
+            buffer.deinitialize()
+            buffer.deallocate()
+        }
+        return result
     }
 
     public func getCString(_ buffer: UnsafeMutablePointer<Int8>, maxLength maxBufferCount: Int, encoding: UInt) -> Bool {
@@ -1258,16 +1266,29 @@ extension NSString {
         data = mData
     }
 
+    #if os(WASI)
+    @available(*, unavailable, message: "WASI does not support atomic file-writing as it does not have temporary directories")
+    #endif
     internal func _writeTo(_ url: URL, _ useAuxiliaryFile: Bool, _ enc: UInt) throws {
+        #if os(WASI)
+        throw CocoaError(.featureUnsupported)
+        #else
         var data = Data()
         try _getExternalRepresentation(&data, url, enc)
         try data.write(to: url, options: useAuxiliaryFile ? .atomic : [])
+        #endif
     }
 
+    #if os(WASI)
+    @available(*, unavailable, message: "WASI does not support atomic file-writing as it does not have temporary directories")
+    #endif
     public func write(to url: URL, atomically useAuxiliaryFile: Bool, encoding enc: UInt) throws {
         try _writeTo(url, useAuxiliaryFile, enc)
     }
 
+    #if os(WASI)
+    @available(*, unavailable, message: "WASI does not support atomic file-writing as it does not have temporary directories")
+    #endif
     public func write(toFile path: String, atomically useAuxiliaryFile: Bool, encoding enc: UInt) throws {
         try _writeTo(URL(fileURLWithPath: path), useAuxiliaryFile, enc)
     }
@@ -1669,3 +1690,14 @@ extension String : CVarArg, _CVarArgObject {
     }
 }
 #endif
+
+// Upcall from swift-foundation for conversion of less frequently-used encodings
+@_dynamicReplacement(for: _cfStringEncodingConvert(string:using:allowLossyConversion:))
+private func _cfStringEncodingConvert_corelibs_foundation(string: String, using encoding: UInt, allowLossyConversion: Bool) -> Data? {
+    return (string as NSString).data(using: encoding, allowLossyConversion: allowLossyConversion)
+}
+
+@_dynamicReplacement(for: _cfMakeStringFromBytes(_:encoding:))
+private func _cfMakeStringFromBytes_corelibs_foundation(_ bytes: UnsafeBufferPointer<UInt8>, encoding: UInt) -> String? {
+    return NSString(bytes: bytes.baseAddress!, length: bytes.count, encoding: encoding) as? String
+}

Sources/Foundation/NSStringAPI.swift

@@ -633,9 +633,8 @@ extension StringProtocol {
     /// Returns a representation of the string as a C string
     /// using a given encoding.
     public func cString(using encoding: String.Encoding) -> [CChar]? {
-        return withExtendedLifetime(_ns) {
-            (s: NSString) -> [CChar]? in
-            _persistCString(s.cString(using: encoding.rawValue))
+        return _ns._withCString(using: encoding.rawValue) {
+            _persistCString($0)
         }
     }
 

Sources/FoundationNetworking/URLSession/libcurl/EasyHandle.swift

@@ -29,15 +29,15 @@ import Dispatch
 // These helper functions avoid warnings about "will never be executed" code which checks the availability of the underlying libcurl features.
 
 internal func curlInfoCAInfoSupported() -> Bool {
-    NS_CURL_CURLINFO_CAINFO_SUPPORTED == 1
+    CFURLSessionInfoCAINFO.value != CFURLSessionInfoNONE.value
 }
 
 internal func maxHostConnectionsSupported() -> Bool {
-    NS_CURL_MAX_HOST_CONNECTIONS_SUPPORTED == 1
+    CFURLSessionMultiOptionMAX_HOST_CONNECTIONS.value != 0
 }
 
 internal func xferInfoFunctionSupported() -> Bool {
-    NS_CURL_XFERINFOFUNCTION_SUPPORTED == 1
+    CFURLSessionOptionXFERINFOFUNCTION.value != 0
 }
 
 /// Minimal wrapper around the [curl easy interface](https://curl.haxx.se/libcurl/c/)

Sources/_CFURLSessionInterface/CFURLSessionInterface.c

@@ -23,6 +23,31 @@
 #include "CFString.h"
 #include <curl/curl.h>
 
+#if !defined(LIBCURL_VERSION_MAJOR)
+#error "LIBCURL_VERSION_MAJOR not defined, missing curlver.h"
+#endif
+
+// 7.84.0 or later
+#if LIBCURL_VERSION_MAJOR > 7 || (LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR > 84) || (LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR == 84 && LIBCURL_VERSION_PATCH >= 0)
+#define NS_CURL_CURLINFO_CAINFO_SUPPORTED 1
+#else
+#define NS_CURL_CURLINFO_CAINFO_SUPPORTED 0
+#endif
+
+// 7.30.0 or later
+#if LIBCURL_VERSION_MAJOR > 7 || (LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR > 30) || (LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR == 30 && LIBCURL_VERSION_PATCH >= 0)
+#define NS_CURL_MAX_HOST_CONNECTIONS_SUPPORTED 1
+#else
+#define NS_CURL_MAX_HOST_CONNECTIONS_SUPPORTED 0
+#endif
+
+// 7.32.0 or later
+#if LIBCURL_VERSION_MAJOR > 7 || (LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR > 32) || (LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR == 32 && LIBCURL_VERSION_PATCH >= 0)
+#define NS_CURL_XFERINFOFUNCTION_SUPPORTED 1
+#else
+#define NS_CURL_XFERINFOFUNCTION_SUPPORTED 0
+#endif
+
 FILE* aa = NULL;
 CURL * gcurl = NULL;
 
@@ -223,7 +248,7 @@ CFURLSessionEasyCode const CFURLSessionEasyCodeFTP_COULDNT_RETR_FILE = { CURLE_F
 #if LIBCURL_VERSION_MAJOR > 7 || (LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR > 67) || (LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR == 67 && LIBCURL_VERSION_PATCH >= 1)
 CFURLSessionEasyCode const CFURLSessionEasyCodeHTTP3 = { CURLE_HTTP3 };
 #else
-CFURLSessionEasyCode const CFURLSessionEasyCodeOBSOLETE20 = { CURLE_OBSOLETE20 };
+CFURLSessionEasyCode const CFURLSessionEasyCodeHTTP3 = { CURLE_OBSOLETE20 };
 #endif
 CFURLSessionEasyCode const CFURLSessionEasyCodeQUOTE_ERROR = { CURLE_QUOTE_ERROR };
 CFURLSessionEasyCode const CFURLSessionEasyCodeHTTP_RETURNED_ERROR = { CURLE_HTTP_RETURNED_ERROR };