Use objc2-core-foundation and objc2-io-kit crates

Author: madsmtm

Cargo.toml

@@ -23,10 +23,21 @@ libudev = { version = "0.3.0", optional = true }
 unescaper = "0.1.3"
 
 [target.'cfg(target_vendor = "apple")'.dependencies]
-# TODO: Remove pinning this dependency when we are bumping our MSRV.
-core-foundation = "=0.10.0"
-core-foundation-sys = "0.8.4"
-io-kit-sys = "0.4.0"
+objc2-io-kit = { version = "0.3.2", default-features = false, features = [
+    "std",
+    "libc",
+    "usb",
+    "serial",
+    "IOUSBLib",
+    "IOUSBHostFamilyDefinitions",
+] }
+objc2-core-foundation = { version = "0.3.2", default-features = false, features = [
+    "std",
+    "CFBase",
+    "CFDictionary",
+    "CFNumber",
+    "CFString",
+] }
 
 [target."cfg(windows)".dependencies.windows-sys]
 version = "0.52.0"

src/posix/enumerate.rs

@@ -8,21 +8,22 @@ cfg_if! {
 
 cfg_if! {
     if #[cfg(target_vendor = "apple")] {
-        use core_foundation::base::CFType;
-        use core_foundation::base::TCFType;
-        use core_foundation::dictionary::CFDictionary;
-        use core_foundation::dictionary::CFMutableDictionary;
-        use core_foundation::number::CFNumber;
-        use core_foundation::string::CFString;
-        use core_foundation_sys::base::{kCFAllocatorDefault, CFRetain};
-        use io_kit_sys::*;
-        use io_kit_sys::keys::*;
-        use io_kit_sys::serial::keys::*;
-        use io_kit_sys::types::*;
-        use io_kit_sys::usb::lib::*;
-        use core::ffi::{c_char, c_int, c_uint, c_void, CStr};
+        use core::ffi::{c_char, c_int, c_uint, CStr};
         use core::mem::MaybeUninit;
 
+        use objc2_core_foundation::{
+            kCFAllocatorDefault, CFMutableDictionary, CFNumber, CFRetained, CFString, CFType,
+        };
+        #[allow(deprecated)]
+        use objc2_io_kit::{kIOMasterPortDefault, IOMasterPort};
+        use objc2_io_kit::{
+            io_object_t, io_registry_entry_t, kIOServiceClass, kIOUSBDeviceClassName,
+            kIOUSBHostInterfaceClassName, IOIteratorNext, IOObjectGetClass, IOObjectRelease,
+            IORegistryEntryCreateCFProperties, IORegistryEntryCreateCFProperty,
+            IORegistryEntryGetParentEntry, IOServiceGetMatchingServices, IOServiceMatching,
+            kIOSerialBSDServiceValue, kIOSerialBSDTypeKey, kIOSerialBSDAllTypes,
+        };
+
         // NOTE: Do not use `mach` nor `mach2` crates, they're unmaintained,
         // and don't work on tvOS/watchOS/visionOS.
         //
@@ -273,22 +274,24 @@ fn parse_modalias(moda: &str) -> Option<UsbPortInfo> {
 #[cfg(target_vendor = "apple")]
 fn get_parent_device_by_type(
     device: io_object_t,
-    parent_type: *const c_char,
+    parent_type: &CStr,
 ) -> Option<io_registry_entry_t> {
-    let parent_type = unsafe { CStr::from_ptr(parent_type) };
     let mut device = device;
     loop {
         let mut class_name = MaybeUninit::<[c_char; 128]>::uninit();
-        unsafe { IOObjectGetClass(device, class_name.as_mut_ptr() as *mut c_char) };
+        unsafe { IOObjectGetClass(device, class_name.as_mut_ptr()) };
         let class_name = unsafe { class_name.assume_init() };
         let name = unsafe { CStr::from_ptr(&class_name[0]) };
         if name == parent_type {
             return Some(device);
         }
         let mut parent = MaybeUninit::uninit();
         if unsafe {
-            IORegistryEntryGetParentEntry(device, kIOServiceClass, parent.as_mut_ptr())
-                != KERN_SUCCESS
+            IORegistryEntryGetParentEntry(
+                device,
+                kIOServiceClass.as_ptr() as _,
+                parent.as_mut_ptr(),
+            ) != KERN_SUCCESS
         } {
             return None;
         }
@@ -300,24 +303,17 @@ fn get_parent_device_by_type(
 #[allow(non_upper_case_globals)]
 /// Returns a specific property of the given device as an integer.
 fn get_int_property(device_type: io_registry_entry_t, property: &str) -> Result<u32> {
-    let cf_property = CFString::new(property);
-
-    let cf_type_ref = unsafe {
-        IORegistryEntryCreateCFProperty(
-            device_type,
-            cf_property.as_concrete_TypeRef(),
-            kCFAllocatorDefault,
-            0,
-        )
-    };
-    if cf_type_ref.is_null() {
-        return Err(Error::new(ErrorKind::Unknown, "Failed to get property"));
+    let cf_property = CFString::from_str(property);
+
+    let cf_type = unsafe {
+        IORegistryEntryCreateCFProperty(device_type, Some(&cf_property), kCFAllocatorDefault, 0)
     }
+    .ok_or_else(|| Error::new(ErrorKind::Unknown, "Failed to get property"))?;
 
-    let cf_type = unsafe { CFType::wrap_under_create_rule(cf_type_ref) };
     cf_type
         .downcast::<CFNumber>()
-        .and_then(|n| n.to_i64())
+        .ok()
+        .and_then(|n| n.as_i64())
         .map(|n| n as u32)
         .ok_or(Error::new(
             ErrorKind::Unknown,
@@ -328,23 +324,16 @@ fn get_int_property(device_type: io_registry_entry_t, property: &str) -> Result<
 #[cfg(target_vendor = "apple")]
 /// Returns a specific property of the given device as a string.
 fn get_string_property(device_type: io_registry_entry_t, property: &str) -> Result<String> {
-    let cf_property = CFString::new(property);
-
-    let cf_type_ref = unsafe {
-        IORegistryEntryCreateCFProperty(
-            device_type,
-            cf_property.as_concrete_TypeRef(),
-            kCFAllocatorDefault,
-            0,
-        )
-    };
-    if cf_type_ref.is_null() {
-        return Err(Error::new(ErrorKind::Unknown, "Failed to get property"));
+    let cf_property = CFString::from_str(property);
+
+    let cf_type = unsafe {
+        IORegistryEntryCreateCFProperty(device_type, Some(&cf_property), kCFAllocatorDefault, 0)
     }
+    .ok_or_else(|| Error::new(ErrorKind::Unknown, "Failed to get property"))?;
 
-    let cf_type = unsafe { CFType::wrap_under_create_rule(cf_type_ref) };
     cf_type
         .downcast::<CFString>()
+        .ok()
         .map(|s| s.to_string())
         .ok_or(Error::new(ErrorKind::Unknown, "Failed to get string value"))
 }
@@ -353,8 +342,9 @@ fn get_string_property(device_type: io_registry_entry_t, property: &str) -> Resu
 /// Determine the serial port type based on the service object (like that returned by
 /// `IOIteratorNext`). Specific properties are extracted for USB devices.
 fn port_type(service: io_object_t) -> SerialPortType {
-    let bluetooth_device_class_name = b"IOBluetoothSerialClient\0".as_ptr() as *const c_char;
-    let usb_device_class_name = b"IOUSBHostInterface\0".as_ptr() as *const c_char;
+    let bluetooth_device_class_name =
+        CStr::from_bytes_with_nul(b"IOBluetoothSerialClient\0").unwrap();
+    let usb_device_class_name = kIOUSBHostInterfaceClassName;
     let legacy_usb_device_class_name = kIOUSBDeviceClassName;
 
     let maybe_usb_device = get_parent_device_by_type(service, usb_device_class_name)
@@ -388,29 +378,24 @@ cfg_if! {
     if #[cfg(target_vendor = "apple")] {
         /// Scans the system for serial ports and returns a list of them.
         /// The `SerialPortInfo` struct contains the name of the port which can be used for opening it.
+        #[allow(deprecated)]
         pub fn available_ports() -> Result<Vec<SerialPortInfo>> {
             let mut vec = Vec::new();
             unsafe {
                 // Create a dictionary for specifying the search terms against the IOService
-                let classes_to_match = IOServiceMatching(kIOSerialBSDServiceValue);
-                if classes_to_match.is_null() {
-                    return Err(Error::new(
-                        ErrorKind::Unknown,
-                        "IOServiceMatching returned a NULL dictionary.",
-                    ));
-                }
-                let mut classes_to_match = CFMutableDictionary::wrap_under_create_rule(classes_to_match);
+                let classes_to_match = IOServiceMatching(kIOSerialBSDServiceValue.as_ptr())
+                .ok_or_else(|| Error::new(ErrorKind::Unknown, "IOServiceMatching returned a NULL dictionary."))?;
+                let classes_to_match = classes_to_match.cast_unchecked::<CFString, CFType>();
 
                 // Populate the search dictionary with a single key/value pair indicating that we're
                 // searching for serial devices matching the RS232 device type.
-                let search_key = CStr::from_ptr(kIOSerialBSDTypeKey);
-                let search_key = CFString::from_static_string(search_key.to_str().map_err(|_| Error::new(ErrorKind::Unknown, "Failed to convert search key string"))?);
-                let search_value = CStr::from_ptr(kIOSerialBSDAllTypes);
-                let search_value = CFString::from_static_string(search_value.to_str().map_err(|_| Error::new(ErrorKind::Unknown, "Failed to convert search key string"))?);
-                classes_to_match.set(search_key, search_value);
+                let search_key = CFString::from_static_str(kIOSerialBSDTypeKey.to_str().map_err(|_| Error::new(ErrorKind::Unknown, "Failed to convert search key string"))?);
+                let search_value = CFString::from_static_str(kIOSerialBSDAllTypes.to_str().map_err(|_| Error::new(ErrorKind::Unknown, "Failed to convert search key string"))?);
+                classes_to_match.set(&search_key, &search_value);
 
                 // Get an interface to IOKit
                 let mut master_port: mach_port_t = MACH_PORT_NULL;
+                #[allow(deprecated)]
                 let mut kern_result = IOMasterPort(MACH_PORT_NULL, &mut master_port);
                 if kern_result != KERN_SUCCESS {
                     return Err(Error::new(
@@ -419,17 +404,11 @@ cfg_if! {
                     ));
                 }
 
-                // Run the search. IOServiceGetMatchingServices consumes one reference count of
-                // classes_to_match, so explicitly retain.
-                //
-                // TODO: We could also just mem::forget classes_to_match like in
-                // TCFType::into_CFType. Is there a special reason that there is no
-                // TCFType::into_concrete_TypeRef()?
-                CFRetain(classes_to_match.as_CFTypeRef());
+                // Run the search.
                 let mut matching_services = MaybeUninit::uninit();
                 kern_result = IOServiceGetMatchingServices(
                     kIOMasterPortDefault,
-                    classes_to_match.as_concrete_TypeRef(),
+                    Some(classes_to_match.as_opaque().into()),
                     matching_services.as_mut_ptr(),
                 );
                 if kern_result != KERN_SUCCESS {
@@ -467,15 +446,15 @@ cfg_if! {
                         // properties dict has been allocated and we as the caller are in charge of
                         // releasing it.
                         let props = props.assume_init();
-                        let props: CFDictionary<CFString, *const c_void> = CFDictionary::wrap_under_create_rule(props);
+                        let props: CFRetained<CFMutableDictionary> = CFRetained::from_raw(core::ptr::NonNull::new(props).unwrap());
+                        let props = props.cast_unchecked::<CFString, CFType>();
 
                         for key in ["IOCalloutDevice", "IODialinDevice"].iter() {
-                            let cf_key = CFString::new(key);
+                            let cf_key = CFString::from_str(key);
 
-                            if let Some(cf_ref) = props.find(cf_key) {
-                                let cf_type = CFType::wrap_under_get_rule(*cf_ref);
+                            if let Some(cf_type) = props.get(&cf_key) {
                                 match cf_type
-                                     .downcast::<CFString>()
+                                     .downcast_ref::<CFString>()
                                      .map(|s| s.to_string())
                                 {
                                     Some(path) => {