[SR-190] Problem Calling CFStringGetBytes With UTF-16 Encoding

Pass the encoding requested for CFStringGetBytes up to the Swift code so it can use either UTF8 or UTF16 view to get the correct bytes.

Author: parkera

CoreFoundation/Base.subproj/ForSwiftFoundationOnly.h

@@ -98,7 +98,7 @@ struct _NSStringBridge {
     CFIndex (*length)(CFTypeRef str);
     UniChar (*characterAtIndex)(CFTypeRef str, CFIndex idx);
     void (*getCharacters)(CFTypeRef str, CFRange range, UniChar *buffer);
-    CFIndex (*__getBytes)(CFTypeRef str, CFRange range, uint8_t *buffer, CFIndex maxBufLen, CFIndex *usedBufLen);
+    CFIndex (*__getBytes)(CFTypeRef str, CFStringEncoding encoding, CFRange range, uint8_t *buffer, CFIndex maxBufLen, CFIndex *usedBufLen);
     const char *_Nullable (*_Nonnull _fastCStringContents)(CFTypeRef str);
     const UniChar *_Nullable (*_Nonnull _fastCharacterContents)(CFTypeRef str);
     bool (*_getCString)(CFTypeRef str, char *buffer, size_t len, UInt32 encoding);

CoreFoundation/String.subproj/CFString.c

@@ -2041,7 +2041,7 @@ int _CFStringCheckAndGetCharacters(CFStringRef str, CFRange range, UniChar *buff
 
 CFIndex CFStringGetBytes(CFStringRef str, CFRange range, CFStringEncoding encoding, uint8_t lossByte, Boolean isExternalRepresentation, uint8_t *buffer, CFIndex maxBufLen, CFIndex *usedBufLen) {
     if (CF_IS_SWIFT(CFStringGetTypeID(), str) && __CFSwiftBridge.NSString.__getBytes != NULL) {
-        return __CFSwiftBridge.NSString.__getBytes(str, range, buffer, maxBufLen, usedBufLen);
+        return __CFSwiftBridge.NSString.__getBytes(str, encoding, range, buffer, maxBufLen, usedBufLen);
     }
     __CFAssertIsNotNegative(maxBufLen);
 

Foundation/NSCFString.swift

@@ -113,18 +113,45 @@ internal func _CFSwiftStringGetCharacters(str: AnyObject, range: CFRange, buffer
     (str as! NSString).getCharacters(buffer, range: NSMakeRange(range.location, range.length))
 }
 
-internal func _CFSwiftStringGetBytes(str: AnyObject, range: CFRange, buffer: UnsafeMutablePointer<UInt8>, maxBufLen: CFIndex, usedBufLen: UnsafeMutablePointer<CFIndex>) -> CFIndex {
-    let s = (str as! NSString)._swiftObject.utf8
-    let start = s.startIndex
-    if buffer != nil {
-        for idx in 0..<range.length {
-            let c = s[start.advancedBy(idx + range.location)]
-            buffer.advancedBy(idx).initialize(c)
+internal func _CFSwiftStringGetBytes(str: AnyObject, encoding: CFStringEncoding, range: CFRange, buffer: UnsafeMutablePointer<UInt8>, maxBufLen: CFIndex, usedBufLen: UnsafeMutablePointer<CFIndex>) -> CFIndex {
+    switch encoding {
+        // TODO: Don't treat many encodings like they are UTF8
+    case CFStringEncoding(kCFStringEncodingUTF8), CFStringEncoding(kCFStringEncodingISOLatin1), CFStringEncoding(kCFStringEncodingMacRoman), CFStringEncoding(kCFStringEncodingASCII), CFStringEncoding(kCFStringEncodingNonLossyASCII):
+        let encodingView = (str as! NSString)._swiftObject.utf8
+        let start = encodingView.startIndex
+        if buffer != nil {
+            for idx in 0..<range.length {
+                let character = encodingView[start.advancedBy(idx + range.location)]
+                buffer.advancedBy(idx).initialize(character)
+            }
         }
+        if usedBufLen != nil {
+            usedBufLen.memory = range.length
+        }
+        
+    case CFStringEncoding(kCFStringEncodingUTF16):
+        let encodingView = (str as! NSString)._swiftObject.utf16
+        let start = encodingView.startIndex
+        if buffer != nil {
+            for idx in 0..<range.length {
+                // Since character is 2 bytes but the buffer is in term of 1 byte values, we have to split it up
+                let character = encodingView[start.advancedBy(idx + range.location)]
+                let byte0 = UInt8(character & 0x00ff)
+                let byte1 = UInt8((character >> 8) & 0x00ff)
+                buffer.advancedBy(idx * 2).initialize(byte0)
+                buffer.advancedBy((idx * 2) + 1).initialize(byte1)
+            }
+        }
+        if usedBufLen != nil {
+            // Every character was 2 bytes
+            usedBufLen.memory = range.length * 2
+        }
+
+
+    default:
+        fatalError("Attempted to get bytes of a Swift string using an unsupported encoding")
     }
-    if usedBufLen != nil {
-        usedBufLen.memory = range.length
-    }
+    
     return range.length
 }
 

TestFoundation/TestNSString.swift

@@ -44,6 +44,7 @@ class TestNSString : XCTestCase {
             ("test_longLongValue", test_longLongValue ),
             ("test_rangeOfCharacterFromSet", test_rangeOfCharacterFromSet ),
             ("test_CFStringCreateMutableCopy", test_CFStringCreateMutableCopy),
+            ("test_swiftStringUTF16", test_swiftStringUTF16),
         ]
     }
 
@@ -309,4 +310,30 @@ class TestNSString : XCTestCase {
         let str = unsafeBitCast(mCopy, NSString.self).bridge()
         XCTAssertEqual(nsstring.bridge(), str)
     }
+    
+    // This test verifies that CFStringGetBytes with a UTF16 encoding works on an NSString backed by a Swift string
+    func test_swiftStringUTF16() {
+        #if os(OSX) || os(iOS)
+        let kCFStringEncodingUTF16 = CFStringBuiltInEncodings.UTF16.rawValue
+        #endif
+
+        let testString = "hello world"
+        let string = NSString(string: testString)
+        let cfString = unsafeBitCast(string, CFStringRef.self)
+        
+        // Get the bytes as UTF16
+        let reservedLength = 50
+        var buf : [UInt8] = []
+        buf.reserveCapacity(reservedLength)
+        var usedLen : CFIndex = 0
+        buf.withUnsafeMutableBufferPointer { p in
+            CFStringGetBytes(cfString, CFRangeMake(0, CFStringGetLength(cfString)), CFStringEncoding(kCFStringEncodingUTF16), 0, false, p.baseAddress, reservedLength, &usedLen)
+        }
+        
+        // Make a new string out of it
+        let newCFString = CFStringCreateWithBytes(nil, buf, usedLen, CFStringEncoding(kCFStringEncodingUTF16), false)
+        let newString = unsafeBitCast(newCFString, NSString.self)
+        
+        XCTAssertTrue(newString.isEqualToString(testString))
+    }
 }