From 3bf373b2dc687bd3bd4437bc521ff9236d2faa06 Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Mon, 27 Jan 2025 00:14:40 +0100
Subject: [PATCH] Use objc2-core-foundation
---
Cargo.toml | 20 ++-
src/unix/apple/disk.rs | 240 ++++++++------------------
src/unix/apple/ffi.rs | 23 ---
src/unix/apple/macos/component/arm.rs | 93 ++++------
src/unix/apple/macos/component/x86.rs | 7 +-
src/unix/apple/macos/cpu.rs | 48 +++---
src/unix/apple/macos/disk.rs | 87 ++++------
src/unix/apple/macos/ffi.rs | 139 +++++++--------
src/unix/apple/utils.rs | 46 -----
9 files changed, 252 insertions(+), 451 deletions(-)
diff --git a/Cargo.toml b/Cargo.toml
index de0e81aa6..27375aa7c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,6 +23,11 @@ component = [
"windows/Win32_System_Rpc",
"windows/Win32_System_Variant",
"windows/Win32_System_Wmi",
+ "objc2-core-foundation/CFArray",
+ "objc2-core-foundation/CFBase",
+ "objc2-core-foundation/CFDictionary",
+ "objc2-core-foundation/CFNumber",
+ "objc2-core-foundation/CFString",
]
disk = [
"windows/Win32_Foundation",
@@ -32,6 +37,13 @@ disk = [
"windows/Win32_System_Ioctl",
"windows/Win32_System_SystemServices",
"windows/Win32_System_WindowsProgramming",
+ "objc2-core-foundation/CFArray",
+ "objc2-core-foundation/CFBase",
+ "objc2-core-foundation/CFDictionary",
+ "objc2-core-foundation/CFError",
+ "objc2-core-foundation/CFNumber",
+ "objc2-core-foundation/CFString",
+ "objc2-core-foundation/CFURL",
]
system = [
"windows/Win32_Foundation",
@@ -54,6 +66,10 @@ system = [
"windows/Win32_UI_Shell",
"dep:ntapi",
"dep:memchr",
+ "objc2-core-foundation/CFBase",
+ "objc2-core-foundation/CFData",
+ "objc2-core-foundation/CFDictionary",
+ "objc2-core-foundation/CFString",
]
network = [
"windows/Win32_Foundation",
@@ -107,7 +123,9 @@ windows = { version = ">=0.54, <=0.57", optional = true }
libc = "^0.2.164"
[target.'cfg(any(target_os = "macos", target_os = "ios"))'.dependencies]
-core-foundation-sys = "0.8.7"
+objc2-core-foundation = { version = "0.3.0", optional = true, default-features = false, features = [
+ "std",
+] }
[target.'cfg(all(target_os = "linux", not(target_os = "android")))'.dev-dependencies]
tempfile = "3.9"
diff --git a/src/unix/apple/disk.rs b/src/unix/apple/disk.rs
index c5b24b4f0..2219494f9 100644
--- a/src/unix/apple/disk.rs
+++ b/src/unix/apple/disk.rs
@@ -1,19 +1,16 @@
// Take a look at the license at the top of the repository in the LICENSE file.
-use crate::{
- sys::{
- ffi,
- utils::{self, CFReleaser},
- },
- DiskUsage,
-};
+use crate::{sys::ffi, DiskUsage};
use crate::{Disk, DiskKind, DiskRefreshKind};
-use core_foundation_sys::array::CFArrayCreate;
-use core_foundation_sys::base::kCFAllocatorDefault;
-use core_foundation_sys::dictionary::{CFDictionaryGetValueIfPresent, CFDictionaryRef};
-use core_foundation_sys::number::{kCFBooleanTrue, CFBooleanRef, CFNumberGetValue};
-use core_foundation_sys::string::{self as cfs, CFStringRef};
+use objc2_core_foundation::{
+ kCFAllocatorDefault, kCFTypeArrayCallBacks, kCFURLVolumeAvailableCapacityForImportantUsageKey,
+ kCFURLVolumeAvailableCapacityKey, kCFURLVolumeIsBrowsableKey, kCFURLVolumeIsEjectableKey,
+ kCFURLVolumeIsInternalKey, kCFURLVolumeIsLocalKey, kCFURLVolumeIsRemovableKey,
+ kCFURLVolumeNameKey, kCFURLVolumeTotalCapacityKey, CFArray, CFArrayCreate, CFBoolean,
+ CFDictionary, CFDictionaryGetValueIfPresent, CFNumber, CFRetained, CFString,
+ CFURLCopyResourcePropertiesForKeys, CFURLCreateFromFileSystemRepresentation, CFURL,
+};
use libc::c_void;
@@ -29,7 +26,7 @@ pub(crate) struct DiskInner {
bsd_name: Option<Vec<u8>>,
pub(crate) file_system: OsString,
pub(crate) mount_point: PathBuf,
- volume_url: RetainedCFURL,
+ volume_url: CFRetained<CFURL>,
pub(crate) total_space: u64,
pub(crate) available_space: u64,
pub(crate) is_removable: bool,
@@ -81,16 +78,13 @@ impl DiskInner {
if refresh_kind.storage() {
unsafe {
if let Some(requested_properties) = build_requested_properties(&[
- ffi::kCFURLVolumeTotalCapacityKey,
- ffi::kCFURLVolumeAvailableCapacityKey,
- ffi::kCFURLVolumeAvailableCapacityForImportantUsageKey,
+ kCFURLVolumeTotalCapacityKey,
+ kCFURLVolumeAvailableCapacityKey,
+ kCFURLVolumeAvailableCapacityForImportantUsageKey,
]) {
match get_disk_properties(&self.volume_url, &requested_properties) {
Some(disk_props) => {
- match get_int_value(
- disk_props.inner(),
- DictKey::Extern(ffi::kCFURLVolumeTotalCapacityKey),
- ) {
+ match get_int_value(&disk_props, kCFURLVolumeTotalCapacityKey) {
Some(total_space) => self.total_space = total_space,
None => {
sysinfo_debug!("Failed to get disk total space");
@@ -238,19 +232,19 @@ unsafe fn get_list(container: &mut Vec<Disk>, refresh_kind: DiskRefreshKind) {
// Currently we query maximum 9 properties.
let mut properties = Vec::with_capacity(9);
// "mandatory" information
- properties.push(ffi::kCFURLVolumeNameKey);
- properties.push(ffi::kCFURLVolumeIsBrowsableKey);
- properties.push(ffi::kCFURLVolumeIsLocalKey);
+ properties.push(kCFURLVolumeNameKey);
+ properties.push(kCFURLVolumeIsBrowsableKey);
+ properties.push(kCFURLVolumeIsLocalKey);
// is_removable
- properties.push(ffi::kCFURLVolumeIsEjectableKey);
- properties.push(ffi::kCFURLVolumeIsRemovableKey);
- properties.push(ffi::kCFURLVolumeIsInternalKey);
+ properties.push(kCFURLVolumeIsEjectableKey);
+ properties.push(kCFURLVolumeIsRemovableKey);
+ properties.push(kCFURLVolumeIsInternalKey);
if refresh_kind.storage() {
- properties.push(ffi::kCFURLVolumeTotalCapacityKey);
- properties.push(ffi::kCFURLVolumeAvailableCapacityForImportantUsageKey);
- properties.push(ffi::kCFURLVolumeAvailableCapacityKey);
+ properties.push(kCFURLVolumeTotalCapacityKey);
+ properties.push(kCFURLVolumeAvailableCapacityForImportantUsageKey);
+ properties.push(kCFURLVolumeAvailableCapacityKey);
}
// Create a list of properties about the disk that we want to fetch.
@@ -263,13 +257,11 @@ unsafe fn get_list(container: &mut Vec<Disk>, refresh_kind: DiskRefreshKind) {
};
for c_disk in raw_disks {
- let volume_url = match CFReleaser::new(
- core_foundation_sys::url::CFURLCreateFromFileSystemRepresentation(
- kCFAllocatorDefault,
- c_disk.f_mntonname.as_ptr() as *const _,
- c_disk.f_mntonname.len() as _,
- false as _,
- ),
+ let volume_url = match CFURLCreateFromFileSystemRepresentation(
+ kCFAllocatorDefault,
+ c_disk.f_mntonname.as_ptr() as *const _,
+ c_disk.f_mntonname.len() as _,
+ false as _,
) {
Some(url) => url,
None => {
@@ -287,11 +279,7 @@ unsafe fn get_list(container: &mut Vec<Disk>, refresh_kind: DiskRefreshKind) {
// `kCFURLEnumeratorSkipInvisibles` option of `CFURLEnumeratorOptions`. Specifically,
// the first one considers the writable `Data`(`/System/Volumes/Data`) partition to be
// browsable, while it is classified as "invisible" by CoreFoundation's volume emumerator.
- let browsable = get_bool_value(
- prop_dict.inner(),
- DictKey::Extern(ffi::kCFURLVolumeIsBrowsableKey),
- )
- .unwrap_or_default();
+ let browsable = get_bool_value(&prop_dict, kCFURLVolumeIsBrowsableKey).unwrap_or_default();
// Do not return invisible "disks". Most of the time, these are APFS snapshots, hidden
// system volumes, etc. Browsable is defined to be visible in the system's UI like Finder,
@@ -303,11 +291,7 @@ unsafe fn get_list(container: &mut Vec<Disk>, refresh_kind: DiskRefreshKind) {
continue;
}
- let local_only = get_bool_value(
- prop_dict.inner(),
- DictKey::Extern(ffi::kCFURLVolumeIsLocalKey),
- )
- .unwrap_or(true);
+ let local_only = get_bool_value(&prop_dict, kCFURLVolumeIsLocalKey).unwrap_or(true);
// Skip any drive that is not locally attached to the system.
//
@@ -336,155 +320,87 @@ unsafe fn get_list(container: &mut Vec<Disk>, refresh_kind: DiskRefreshKind) {
}
}
-type RetainedCFArray = CFReleaser<core_foundation_sys::array::__CFArray>;
-pub(crate) type RetainedCFDictionary = CFReleaser<core_foundation_sys::dictionary::__CFDictionary>;
-type RetainedCFURL = CFReleaser<core_foundation_sys::url::__CFURL>;
-#[cfg(target_os = "macos")]
-pub(crate) type RetainedCFString = CFReleaser<core_foundation_sys::string::__CFString>;
-
-unsafe fn build_requested_properties(properties: &[CFStringRef]) -> Option<RetainedCFArray> {
- CFReleaser::new(CFArrayCreate(
- ptr::null_mut(),
- properties.as_ptr() as *const *const c_void,
+unsafe fn build_requested_properties(
+ properties: &[Option<&CFString>],
+) -> Option<CFRetained<CFArray>> {
+ CFArrayCreate(
+ None,
+ properties.as_ptr() as *mut *const c_void,
properties.len() as _,
- &core_foundation_sys::array::kCFTypeArrayCallBacks,
- ))
+ &kCFTypeArrayCallBacks,
+ )
}
fn get_disk_properties(
- volume_url: &RetainedCFURL,
- requested_properties: &RetainedCFArray,
-) -> Option<RetainedCFDictionary> {
- CFReleaser::new(unsafe {
- ffi::CFURLCopyResourcePropertiesForKeys(
- volume_url.inner(),
- requested_properties.inner(),
- ptr::null_mut(),
- )
- })
+ volume_url: &CFURL,
+ requested_properties: &CFArray,
+) -> Option<CFRetained<CFDictionary>> {
+ unsafe {
+ CFURLCopyResourcePropertiesForKeys(volume_url, Some(requested_properties), ptr::null_mut())
+ }
}
-fn get_available_volume_space(disk_props: &RetainedCFDictionary) -> Option<u64> {
+fn get_available_volume_space(disk_props: &CFDictionary) -> Option<u64> {
// We prefer `AvailableCapacityForImportantUsage` over `AvailableCapacity` because
// it takes more of the system's properties into account, like the trash, system-managed caches,
// etc. It generally also returns higher values too, because of the above, so it's a more
// accurate representation of what the system _could_ still use.
unsafe {
get_int_value(
- disk_props.inner(),
- DictKey::Extern(ffi::kCFURLVolumeAvailableCapacityForImportantUsageKey),
+ disk_props,
+ kCFURLVolumeAvailableCapacityForImportantUsageKey,
)
.filter(|bytes| *bytes != 0)
- .or_else(|| {
- get_int_value(
- disk_props.inner(),
- DictKey::Extern(ffi::kCFURLVolumeAvailableCapacityKey),
- )
- })
+ .or_else(|| get_int_value(disk_props, kCFURLVolumeAvailableCapacityKey))
}
}
-pub(super) enum DictKey {
- Extern(CFStringRef),
- #[cfg(target_os = "macos")]
- Defined(&'static str),
-}
-
unsafe fn get_dict_value<T, F: FnOnce(*const c_void) -> Option<T>>(
- dict: CFDictionaryRef,
- key: DictKey,
+ dict: &CFDictionary,
+ key: Option<&CFString>,
callback: F,
) -> Option<T> {
- #[cfg(target_os = "macos")]
- let _defined;
- #[allow(clippy::infallible_destructuring_match)]
- let key = match key {
- DictKey::Extern(val) => val,
- #[cfg(target_os = "macos")]
- DictKey::Defined(val) => {
- _defined = CFReleaser::new(cfs::CFStringCreateWithBytesNoCopy(
- kCFAllocatorDefault,
- val.as_ptr(),
- val.len() as _,
- cfs::kCFStringEncodingUTF8,
- false as _,
- core_foundation_sys::base::kCFAllocatorNull,
- ))?;
-
- _defined.inner()
- }
- };
-
let mut value = std::ptr::null();
- if CFDictionaryGetValueIfPresent(dict, key.cast(), &mut value) != 0 {
+ let key: *const CFString = key.map(|key| key as *const CFString).unwrap_or(ptr::null());
+ if CFDictionaryGetValueIfPresent(dict, key.cast(), &mut value) {
callback(value)
} else {
None
}
}
-pub(super) unsafe fn get_str_value(dict: CFDictionaryRef, key: DictKey) -> Option<String> {
+pub(super) unsafe fn get_str_value(dict: &CFDictionary, key: Option<&CFString>) -> Option<String> {
get_dict_value(dict, key, |v| {
- let v = v as cfs::CFStringRef;
-
- let len_utf16 = cfs::CFStringGetLength(v) as usize;
- let len_bytes = len_utf16 * 2; // Two bytes per UTF-16 codepoint.
-
- let v_ptr = cfs::CFStringGetCStringPtr(v, cfs::kCFStringEncodingUTF8);
- if v_ptr.is_null() {
- // Fallback on CFStringGetString to read the underlying bytes from the CFString.
- let mut buf = vec![0; len_bytes];
- let success = cfs::CFStringGetCString(
- v,
- buf.as_mut_ptr(),
- len_bytes as _,
- cfs::kCFStringEncodingUTF8,
- );
-
- if success != 0 {
- utils::vec_to_rust(buf)
- } else {
- None
- }
- } else {
- crate::unix::utils::cstr_to_rust_with_size(v_ptr, Some(len_bytes))
- }
+ let v = unsafe { &*v.cast::<CFString>() };
+ Some(v.to_string())
})
}
-unsafe fn get_bool_value(dict: CFDictionaryRef, key: DictKey) -> Option<bool> {
- get_dict_value(dict, key, |v| Some(v as CFBooleanRef == kCFBooleanTrue))
+unsafe fn get_bool_value(dict: &CFDictionary, key: Option<&CFString>) -> Option<bool> {
+ get_dict_value(dict, key, |v| {
+ let v = unsafe { &*v.cast::<CFBoolean>() };
+ Some(v.as_bool())
+ })
}
-pub(super) unsafe fn get_int_value(dict: CFDictionaryRef, key: DictKey) -> Option<u64> {
+pub(super) unsafe fn get_int_value(dict: &CFDictionary, key: Option<&CFString>) -> Option<u64> {
get_dict_value(dict, key, |v| {
- let mut val: i64 = 0;
- if CFNumberGetValue(
- v.cast(),
- core_foundation_sys::number::kCFNumberSInt64Type,
- &mut val as *mut _ as *mut _,
- ) {
- Some(val as _)
- } else {
- None
- }
+ let v = unsafe { &*v.cast::<CFNumber>() };
+ Some(v.as_i64()? as u64)
})
}
unsafe fn new_disk(
disk: Option<&mut Disk>,
mount_point: PathBuf,
- volume_url: RetainedCFURL,
+ volume_url: CFRetained<CFURL>,
c_disk: libc::statfs,
- disk_props: &RetainedCFDictionary,
+ disk_props: &CFDictionary,
refresh_kind: DiskRefreshKind,
) -> Option<Disk> {
let (total_space, available_space) = if refresh_kind.storage() {
(
- get_int_value(
- disk_props.inner(),
- DictKey::Extern(ffi::kCFURLVolumeTotalCapacityKey),
- ),
+ get_int_value(disk_props, kCFURLVolumeTotalCapacityKey),
get_available_volume_space(disk_props),
)
} else {
@@ -509,11 +425,7 @@ unsafe fn new_disk(
// Note: Since we requested these properties from the system, we don't expect
// these property retrievals to fail.
- let name = get_str_value(
- disk_props.inner(),
- DictKey::Extern(ffi::kCFURLVolumeNameKey),
- )
- .map(OsString::from)?;
+ let name = get_str_value(disk_props, kCFURLVolumeNameKey).map(OsString::from)?;
let file_system = {
let len = c_disk
@@ -537,28 +449,16 @@ unsafe fn new_disk(
// so we just assume the disk type is an SSD and set disk i/o stats to 0 until Rust has a way to conditionally link to
// IOKit in more recent deployment versions.
- let ejectable = get_bool_value(
- disk_props.inner(),
- DictKey::Extern(ffi::kCFURLVolumeIsEjectableKey),
- )
- .unwrap_or(false);
+ let ejectable = get_bool_value(disk_props, kCFURLVolumeIsEjectableKey).unwrap_or(false);
- let removable = get_bool_value(
- disk_props.inner(),
- DictKey::Extern(ffi::kCFURLVolumeIsRemovableKey),
- )
- .unwrap_or(false);
+ let removable = get_bool_value(disk_props, kCFURLVolumeIsRemovableKey).unwrap_or(false);
let is_removable = if ejectable || removable {
true
} else {
// If neither `ejectable` or `removable` return `true`, fallback to checking
// if the disk is attached to the internal system.
- let internal = get_bool_value(
- disk_props.inner(),
- DictKey::Extern(ffi::kCFURLVolumeIsInternalKey),
- )
- .unwrap_or_default();
+ let internal = get_bool_value(disk_props, kCFURLVolumeIsInternalKey).unwrap_or_default();
!internal
};
diff --git a/src/unix/apple/ffi.rs b/src/unix/apple/ffi.rs
index 75ae0e1ec..d30e5649b 100644
--- a/src/unix/apple/ffi.rs
+++ b/src/unix/apple/ffi.rs
@@ -9,31 +9,8 @@ pub use crate::sys::inner::ffi::*;
cfg_if! {
if #[cfg(feature = "disk")] {
- use core_foundation_sys::{
- array::CFArrayRef, dictionary::CFDictionaryRef, error::CFErrorRef, string::CFStringRef,
- url::CFURLRef,
- };
use std::ffi::c_void;
- #[link(name = "CoreFoundation", kind = "framework")]
- extern "C" {
- pub fn CFURLCopyResourcePropertiesForKeys(
- url: CFURLRef,
- keys: CFArrayRef,
- error: *mut CFErrorRef,
- ) -> CFDictionaryRef;
-
- pub static kCFURLVolumeIsEjectableKey: CFStringRef;
- pub static kCFURLVolumeIsRemovableKey: CFStringRef;
- pub static kCFURLVolumeAvailableCapacityKey: CFStringRef;
- pub static kCFURLVolumeAvailableCapacityForImportantUsageKey: CFStringRef;
- pub static kCFURLVolumeTotalCapacityKey: CFStringRef;
- pub static kCFURLVolumeNameKey: CFStringRef;
- pub static kCFURLVolumeIsLocalKey: CFStringRef;
- pub static kCFURLVolumeIsInternalKey: CFStringRef;
- pub static kCFURLVolumeIsBrowsableKey: CFStringRef;
- }
-
#[link(name = "objc", kind = "dylib")]
extern "C" {
pub fn objc_autoreleasePoolPop(pool: *mut c_void);
diff --git a/src/unix/apple/macos/component/arm.rs b/src/unix/apple/macos/component/arm.rs
index 6577fd15d..05ed5ef14 100644
--- a/src/unix/apple/macos/component/arm.rs
+++ b/src/unix/apple/macos/component/arm.rs
@@ -1,26 +1,23 @@
// Take a look at the license at the top of the repository in the LICENSE file.
-use std::ffi::CStr;
+use std::ptr::NonNull;
-use core_foundation_sys::array::{CFArrayGetCount, CFArrayGetValueAtIndex};
-use core_foundation_sys::base::kCFAllocatorDefault;
-use core_foundation_sys::string::{
- kCFStringEncodingUTF8, CFStringCreateWithBytes, CFStringGetCStringPtr,
+use objc2_core_foundation::{
+ kCFAllocatorDefault, CFArrayGetCount, CFArrayGetValueAtIndex, CFRetained, CFString,
};
use crate::sys::inner::ffi::{
kHIDPage_AppleVendor, kHIDUsage_AppleVendor_TemperatureSensor, kIOHIDEventTypeTemperature,
matching, IOHIDEventFieldBase, IOHIDEventGetFloatValue, IOHIDEventSystemClientCopyServices,
IOHIDEventSystemClientCreate, IOHIDEventSystemClientSetMatching, IOHIDServiceClientCopyEvent,
- IOHIDServiceClientCopyProperty, __IOHIDEventSystemClient, __IOHIDServiceClient,
- HID_DEVICE_PROPERTY_PRODUCT,
+ IOHIDServiceClientCopyProperty, HID_DEVICE_PROPERTY_PRODUCT,
};
-use crate::sys::utils::CFReleaser;
+use crate::unix::apple::ffi::{IOHIDEventSystemClient, IOHIDServiceClient};
use crate::Component;
pub(crate) struct ComponentsInner {
pub(crate) components: Vec<Component>,
- client: Option<CFReleaser<__IOHIDEventSystemClient>>,
+ client: Option<CFRetained<IOHIDEventSystemClient>>,
}
impl ComponentsInner {
@@ -53,68 +50,49 @@ impl ComponentsInner {
#[allow(unreachable_code)]
pub(crate) fn refresh(&mut self) {
unsafe {
- let matches = match CFReleaser::new(matching(
+ let matches = match matching(
kHIDPage_AppleVendor,
kHIDUsage_AppleVendor_TemperatureSensor,
- )) {
+ ) {
Some(m) => m,
None => return,
};
if self.client.is_none() {
- let client =
- match CFReleaser::new(IOHIDEventSystemClientCreate(kCFAllocatorDefault)) {
- Some(c) => c,
- None => return,
- };
+ let client = match IOHIDEventSystemClientCreate(kCFAllocatorDefault) {
+ Some(c) => CFRetained::from_raw(c),
+ None => return,
+ };
self.client = Some(client);
}
let client = self.client.as_ref().unwrap();
- let _ = IOHIDEventSystemClientSetMatching(client.inner(), matches.inner());
+ let _ = IOHIDEventSystemClientSetMatching(client, &matches);
- let services = match CFReleaser::new(IOHIDEventSystemClientCopyServices(client.inner()))
- {
- Some(s) => s,
+ let services = match IOHIDEventSystemClientCopyServices(client) {
+ Some(s) => CFRetained::from_raw(s),
None => return,
};
- let key_ref = match CFReleaser::new(CFStringCreateWithBytes(
- kCFAllocatorDefault,
- HID_DEVICE_PROPERTY_PRODUCT.as_ptr(),
- HID_DEVICE_PROPERTY_PRODUCT.len() as _,
- kCFStringEncodingUTF8,
- false as _,
- )) {
- Some(r) => r,
- None => return,
- };
+ let key = CFString::from_static_str(HID_DEVICE_PROPERTY_PRODUCT);
- let count = CFArrayGetCount(services.inner());
+ let count = CFArrayGetCount(&services);
for i in 0..count {
- // The 'service' should never be freed since it is returned by a 'Get' call.
- // See issue https://github.com/GuillaumeGomez/sysinfo/issues/1279
- let service = CFArrayGetValueAtIndex(services.inner(), i);
+ let service = CFArrayGetValueAtIndex(&services, i).cast::<IOHIDServiceClient>();
if service.is_null() {
continue;
}
+ // The 'service' should never be freed since it is returned by a 'Get' call.
+ // See issue https://github.com/GuillaumeGomez/sysinfo/issues/1279
+ let service = CFRetained::retain(NonNull::from(&*service));
- let Some(name) = CFReleaser::new(IOHIDServiceClientCopyProperty(
- service as *const _,
- key_ref.inner(),
- )) else {
+ let Some(name) = IOHIDServiceClientCopyProperty(&service, &key) else {
continue;
};
-
- let name_ptr =
- CFStringGetCStringPtr(name.inner() as *const _, kCFStringEncodingUTF8);
- if name_ptr.is_null() {
- continue;
- }
-
- let name_str = CStr::from_ptr(name_ptr).to_string_lossy().to_string();
+ let name = CFRetained::from_raw(name);
+ let name_str = name.to_string();
if let Some(c) = self
.components
@@ -126,7 +104,7 @@ impl ComponentsInner {
continue;
}
- let mut component = ComponentInner::new(name_str, None, None, service as *mut _);
+ let mut component = ComponentInner::new(name_str, None, None, service);
component.refresh();
self.components.push(Component { inner: component });
@@ -136,7 +114,7 @@ impl ComponentsInner {
}
pub(crate) struct ComponentInner {
- service: *mut __IOHIDServiceClient,
+ service: CFRetained<IOHIDServiceClient>,
temperature: Option<f32>,
label: String,
max: f32,
@@ -152,7 +130,7 @@ impl ComponentInner {
label: String,
max: Option<f32>,
critical: Option<f32>,
- service: *mut __IOHIDServiceClient,
+ service: CFRetained<IOHIDServiceClient>,
) -> Self {
Self {
service,
@@ -182,20 +160,17 @@ impl ComponentInner {
pub(crate) fn refresh(&mut self) {
unsafe {
- let Some(event) = CFReleaser::new(IOHIDServiceClientCopyEvent(
- self.service as *const _,
- kIOHIDEventTypeTemperature,
- 0,
- 0,
- )) else {
+ let Some(event) =
+ IOHIDServiceClientCopyEvent(&self.service, kIOHIDEventTypeTemperature, 0, 0)
+ else {
self.temperature = None;
return;
};
+ let event = CFRetained::from_raw(event);
- let temperature = IOHIDEventGetFloatValue(
- event.inner(),
- IOHIDEventFieldBase(kIOHIDEventTypeTemperature),
- ) as _;
+ let temperature =
+ IOHIDEventGetFloatValue(&event, IOHIDEventFieldBase(kIOHIDEventTypeTemperature))
+ as _;
self.temperature = Some(temperature);
if temperature > self.max {
self.max = temperature;
diff --git a/src/unix/apple/macos/component/x86.rs b/src/unix/apple/macos/component/x86.rs
index a921179bf..f92690a55 100644
--- a/src/unix/apple/macos/component/x86.rs
+++ b/src/unix/apple/macos/component/x86.rs
@@ -296,11 +296,12 @@ impl IoService {
let mut iterator: ffi::io_iterator_t = 0;
unsafe {
- let matching_dictionary = ffi::IOServiceMatching(b"AppleSMC\0".as_ptr() as *const i8);
- if matching_dictionary.is_null() {
+ let Some(matching_dictionary) =
+ ffi::IOServiceMatching(b"AppleSMC\0".as_ptr() as *const i8)
+ else {
sysinfo_debug!("IOServiceMatching call failed, `AppleSMC` not found");
return None;
- }
+ };
let result = ffi::IOServiceGetMatchingServices(
ffi::kIOMasterPortDefault,
matching_dictionary,
diff --git a/src/unix/apple/macos/cpu.rs b/src/unix/apple/macos/cpu.rs
index 974f4d0b7..59f2b5379 100644
--- a/src/unix/apple/macos/cpu.rs
+++ b/src/unix/apple/macos/cpu.rs
@@ -9,14 +9,14 @@ pub(crate) unsafe fn get_cpu_frequency() -> u64 {
pub(crate) unsafe fn get_cpu_frequency() -> u64 {
use crate::sys::ffi;
use crate::sys::macos::utils::IOReleaser;
- use crate::sys::utils::CFReleaser;
- use core_foundation_sys::string::CFStringCreateWithCStringNoCopy;
+ use objc2_core_foundation::{
+ kCFAllocatorDefault, CFData, CFDataGetBytes, CFDataGetLength, CFRange, CFRetained, CFString,
+ };
- let matching = ffi::IOServiceMatching(b"AppleARMIODevice\0".as_ptr() as *const _);
- if matching.is_null() {
+ let Some(matching) = ffi::IOServiceMatching(b"AppleARMIODevice\0".as_ptr() as *const _) else {
sysinfo_debug!("IOServiceMatching call failed, `AppleARMIODevice` not found");
return 0;
- }
+ };
// Starting from mac M1, the above call returns nothing for the CPU frequency
// so we try to get it from another source. This code comes from
@@ -55,41 +55,39 @@ pub(crate) unsafe fn get_cpu_frequency() -> u64 {
}
};
- let node_name = match CFReleaser::new(CFStringCreateWithCStringNoCopy(
- std::ptr::null(),
- b"voltage-states5-sram\0".as_ptr() as *const _,
- core_foundation_sys::string::kCFStringEncodingUTF8,
- core_foundation_sys::base::kCFAllocatorNull as *mut _,
- )) {
- Some(n) => n,
- None => {
- sysinfo_debug!("CFStringCreateWithCStringNoCopy failed");
- return 0;
- }
- };
+ let node_name = CFString::from_static_str("voltage-states5-sram");
- let core_ref = match CFReleaser::new(ffi::IORegistryEntryCreateCFProperty(
+ let core_ref = match ffi::IORegistryEntryCreateCFProperty(
entry.inner(),
- node_name.inner(),
- core_foundation_sys::base::kCFAllocatorDefault,
+ &node_name,
+ kCFAllocatorDefault,
0,
- )) {
+ ) {
Some(c) => c,
None => {
sysinfo_debug!("`voltage-states5-sram` property not found");
return 0;
}
};
+ let core_ref = CFRetained::from_raw(core_ref);
+
+ let Ok(core_ref) = core_ref.downcast::<CFData>() else {
+ sysinfo_debug!("`voltage-states5-sram` property was not CFData");
+ return 0;
+ };
- let core_length = core_foundation_sys::data::CFDataGetLength(core_ref.inner() as *const _);
+ let core_length = CFDataGetLength(&core_ref);
if core_length < 8 {
sysinfo_debug!("expected `voltage-states5-sram` buffer to have at least size 8");
return 0;
}
let mut max: u64 = 0;
- core_foundation_sys::data::CFDataGetBytes(
- core_ref.inner() as *const _,
- core_foundation_sys::base::CFRange::init(core_length - 8, 4),
+ CFDataGetBytes(
+ &core_ref,
+ CFRange {
+ location: core_length - 8,
+ length: 4,
+ },
&mut max as *mut _ as *mut _,
);
max / 1_000_000
diff --git a/src/unix/apple/macos/disk.rs b/src/unix/apple/macos/disk.rs
index 3522b599a..22f1a14c3 100644
--- a/src/unix/apple/macos/disk.rs
+++ b/src/unix/apple/macos/disk.rs
@@ -2,35 +2,28 @@
use crate::sys::ffi;
use crate::sys::{
- disk::{get_int_value, get_str_value, DictKey},
+ disk::{get_int_value, get_str_value},
macos::utils::IOReleaser,
- utils::CFReleaser,
};
-use crate::unix::apple::disk::{RetainedCFDictionary, RetainedCFString};
use crate::DiskKind;
-use core_foundation_sys::base::{kCFAllocatorDefault, kCFAllocatorNull};
-use core_foundation_sys::string::{self as cfs};
+use objc2_core_foundation::{kCFAllocatorDefault, CFDictionary, CFRetained, CFString};
-fn iterate_service_tree<T, F>(bsd_name: &[u8], key: RetainedCFString, eval: F) -> Option<T>
+fn iterate_service_tree<T, F>(bsd_name: &[u8], key: &CFString, eval: F) -> Option<T>
where
- F: Fn(ffi::io_registry_entry_t, &RetainedCFDictionary) -> Option<T>,
+ F: Fn(ffi::io_registry_entry_t, &CFDictionary) -> Option<T>,
{
- // We don't need to wrap this in an auto-releaser because the following call to `IOServiceGetMatchingServices`
- // will take ownership of one retain reference.
+ // We don't need to wrap this in CFRetained because the following call to
+ // `IOServiceGetMatchingServices` will take ownership of one retain reference.
let matching =
- unsafe { ffi::IOBSDNameMatching(ffi::kIOMasterPortDefault, 0, bsd_name.as_ptr().cast()) };
-
- if matching.is_null() {
- return None;
- }
+ unsafe { ffi::IOBSDNameMatching(ffi::kIOMasterPortDefault, 0, bsd_name.as_ptr().cast()) }?;
let mut service_iterator: ffi::io_iterator_t = 0;
if unsafe {
ffi::IOServiceGetMatchingServices(
ffi::kIOMasterPortDefault,
- matching.cast(),
+ matching,
&mut service_iterator,
)
} != libc::KERN_SUCCESS
@@ -69,18 +62,21 @@ where
};
let properties_result = unsafe {
- CFReleaser::new(ffi::IORegistryEntryCreateCFProperty(
+ ffi::IORegistryEntryCreateCFProperty(
current_service_entry.inner(),
- key.inner(),
+ key,
kCFAllocatorDefault,
0,
- ))
+ )
};
- if let Some(result) =
- properties_result.and_then(|properties| eval(parent_entry, &properties))
- {
- return Some(result);
+ if let Some(properties) = properties_result {
+ let properties = unsafe { CFRetained::from_raw(properties) };
+ if let Ok(properties) = properties.downcast::<CFDictionary>() {
+ if let Some(result) = eval(parent_entry, &properties) {
+ return Some(result);
+ }
+ }
}
}
}
@@ -89,22 +85,14 @@ where
}
pub(crate) fn get_disk_type(bsd_name: &[u8]) -> Option<DiskKind> {
- let characteristics_string = unsafe {
- CFReleaser::new(cfs::CFStringCreateWithBytesNoCopy(
- kCFAllocatorDefault,
- ffi::kIOPropertyDeviceCharacteristicsKey.as_ptr(),
- ffi::kIOPropertyDeviceCharacteristicsKey.len() as _,
- cfs::kCFStringEncodingUTF8,
- false as _,
- kCFAllocatorNull,
- ))?
- };
-
- iterate_service_tree(bsd_name, characteristics_string, |_, properties| {
+ let characteristics_string =
+ CFString::from_static_str(ffi::kIOPropertyDeviceCharacteristicsKey);
+
+ iterate_service_tree(bsd_name, &characteristics_string, |_, properties| {
let medium = unsafe {
super::disk::get_str_value(
- properties.inner(),
- DictKey::Defined(ffi::kIOPropertyMediumTypeKey),
+ properties,
+ Some(&CFString::from_static_str(ffi::kIOPropertyMediumTypeKey)),
)
}?;
@@ -118,18 +106,9 @@ pub(crate) fn get_disk_type(bsd_name: &[u8]) -> Option<DiskKind> {
/// Returns a tuple consisting of the total number of bytes read and written by the specified disk
pub(crate) fn get_disk_io(bsd_name: &[u8]) -> Option<(u64, u64)> {
- let stat_string = unsafe {
- CFReleaser::new(cfs::CFStringCreateWithBytesNoCopy(
- kCFAllocatorDefault,
- ffi::kIOBlockStorageDriverStatisticsKey.as_ptr(),
- ffi::kIOBlockStorageDriverStatisticsKey.len() as _,
- cfs::kCFStringEncodingUTF8,
- false as _,
- kCFAllocatorNull,
- ))?
- };
-
- iterate_service_tree(bsd_name, stat_string, |parent_entry, properties| {
+ let stat_string = CFString::from_static_str(ffi::kIOBlockStorageDriverStatisticsKey);
+
+ iterate_service_tree(bsd_name, &stat_string, |parent_entry, properties| {
if unsafe {
ffi::IOObjectConformsTo(parent_entry, b"IOBlockStorageDriver\0".as_ptr() as *const _)
} == 0
@@ -139,12 +118,16 @@ pub(crate) fn get_disk_io(bsd_name: &[u8]) -> Option<(u64, u64)> {
unsafe {
let read_bytes = super::disk::get_int_value(
- properties.inner(),
- DictKey::Defined(ffi::kIOBlockStorageDriverStatisticsBytesReadKey),
+ properties,
+ Some(&CFString::from_static_str(
+ ffi::kIOBlockStorageDriverStatisticsBytesReadKey,
+ )),
)?;
let written_bytes = super::disk::get_int_value(
- properties.inner(),
- DictKey::Defined(ffi::kIOBlockStorageDriverStatisticsBytesWrittenKey),
+ properties,
+ Some(&CFString::from_static_str(
+ ffi::kIOBlockStorageDriverStatisticsBytesWrittenKey,
+ )),
)?;
Some((read_bytes, written_bytes))
diff --git a/src/unix/apple/macos/ffi.rs b/src/unix/apple/macos/ffi.rs
index 0bc21c83d..46efc8c00 100644
--- a/src/unix/apple/macos/ffi.rs
+++ b/src/unix/apple/macos/ffi.rs
@@ -8,11 +8,9 @@
any(target_arch = "x86", target_arch = "x86_64")
),
))]
-use core_foundation_sys::base::mach_port_t;
+use libc::mach_port_t;
#[cfg(any(feature = "system", feature = "disk"))]
-use core_foundation_sys::base::CFAllocatorRef;
-#[cfg(any(feature = "system", feature = "disk"))]
-use core_foundation_sys::dictionary::CFDictionaryRef;
+use objc2_core_foundation::CFAllocator;
#[cfg(any(
feature = "system",
feature = "disk",
@@ -21,9 +19,20 @@ use core_foundation_sys::dictionary::CFDictionaryRef;
any(target_arch = "x86", target_arch = "x86_64")
),
))]
-use core_foundation_sys::dictionary::CFMutableDictionaryRef;
+use objc2_core_foundation::CFMutableDictionary;
+#[cfg(any(feature = "system", feature = "disk"))]
+use objc2_core_foundation::CFString;
#[cfg(any(feature = "system", feature = "disk"))]
-use core_foundation_sys::string::CFStringRef;
+use objc2_core_foundation::CFType;
+#[cfg(any(
+ feature = "system",
+ feature = "disk",
+ all(
+ feature = "component",
+ any(target_arch = "x86", target_arch = "x86_64")
+ ),
+))]
+use std::ptr::NonNull;
use libc::c_char;
#[cfg(any(
@@ -120,7 +129,7 @@ pub const kIOMasterPortDefault: mach_port_t = 0;
extern "C" {
pub fn IOServiceGetMatchingServices(
mainPort: mach_port_t,
- matching: CFMutableDictionaryRef,
+ matching: NonNull<CFMutableDictionary>, // CF_RELEASES_ARGUMENT
existing: *mut io_iterator_t,
) -> kern_return_t;
#[cfg(all(
@@ -133,7 +142,7 @@ extern "C" {
),
),
))]
- pub fn IOServiceMatching(a: *const c_char) -> CFMutableDictionaryRef;
+ pub fn IOServiceMatching(a: *const c_char) -> Option<NonNull<CFMutableDictionary>>; // CF_RETURNS_RETAINED
pub fn IOIteratorNext(iterator: io_iterator_t) -> io_object_t;
@@ -142,10 +151,10 @@ extern "C" {
#[cfg(any(feature = "system", feature = "disk"))]
pub fn IORegistryEntryCreateCFProperty(
entry: io_registry_entry_t,
- key: CFStringRef,
- allocator: CFAllocatorRef,
+ key: &CFString,
+ allocator: Option<&CFAllocator>,
options: IOOptionBits,
- ) -> CFDictionaryRef;
+ ) -> Option<NonNull<CFType>>;
#[cfg(feature = "disk")]
pub fn IORegistryEntryGetParentEntry(
entry: io_registry_entry_t,
@@ -157,7 +166,7 @@ extern "C" {
mainPort: mach_port_t,
options: u32,
bsdName: *const c_char,
- ) -> CFMutableDictionaryRef;
+ ) -> Option<NonNull<CFMutableDictionary>>; // CF_RETURNS_RETAINED
#[cfg(all(feature = "system", not(feature = "apple-sandbox")))]
pub fn IORegistryEntryGetName(entry: io_registry_entry_t, name: io_name_t) -> kern_return_t;
#[cfg(feature = "disk")]
@@ -285,31 +294,36 @@ pub use io_service::*;
target_arch = "aarch64"
))]
mod io_service {
- use std::ptr::null;
+ use std::ptr::NonNull;
- use core_foundation_sys::array::CFArrayRef;
- use core_foundation_sys::base::{CFAllocatorRef, CFRelease};
- use core_foundation_sys::dictionary::{
- kCFTypeDictionaryKeyCallBacks, kCFTypeDictionaryValueCallBacks, CFDictionaryCreate,
- CFDictionaryRef,
+ use objc2_core_foundation::{
+ cf_type, kCFTypeDictionaryKeyCallBacks, kCFTypeDictionaryValueCallBacks, CFAllocator,
+ CFArray, CFDictionary, CFDictionaryCreate, CFNumber, CFRetained, CFString,
};
- use core_foundation_sys::number::{kCFNumberSInt32Type, CFNumberCreate};
- use core_foundation_sys::string::{CFStringCreateWithCStringNoCopy, CFStringRef};
#[repr(C)]
- pub struct __IOHIDServiceClient(libc::c_void);
+ pub struct IOHIDServiceClient(libc::c_void);
- pub type IOHIDServiceClientRef = *const __IOHIDServiceClient;
+ cf_type!(
+ #[encoding_name = "__IOHIDServiceClient"]
+ unsafe impl IOHIDServiceClient {}
+ );
#[repr(C)]
- pub struct __IOHIDEventSystemClient(libc::c_void);
+ pub struct IOHIDEventSystemClient(libc::c_void);
- pub type IOHIDEventSystemClientRef = *const __IOHIDEventSystemClient;
+ cf_type!(
+ #[encoding_name = "__IOHIDEventSystemClient"]
+ unsafe impl IOHIDEventSystemClient {}
+ );
#[repr(C)]
- pub struct __IOHIDEvent(libc::c_void);
+ pub struct IOHIDEvent(libc::c_void);
- pub type IOHIDEventRef = *const __IOHIDEvent;
+ cf_type!(
+ #[encoding_name = "__IOHIDEvent"]
+ unsafe impl IOHIDEvent {}
+ );
#[allow(non_upper_case_globals)]
pub const kIOHIDEventTypeTemperature: i64 = 15;
@@ -321,36 +335,40 @@ mod io_service {
}
#[cfg(not(feature = "apple-sandbox"))]
+ #[link(name = "IOKit", kind = "framework")]
extern "C" {
- pub fn IOHIDEventSystemClientCreate(allocator: CFAllocatorRef)
- -> IOHIDEventSystemClientRef;
+ pub fn IOHIDEventSystemClientCreate(
+ allocator: Option<&CFAllocator>,
+ ) -> Option<NonNull<IOHIDEventSystemClient>>;
pub fn IOHIDEventSystemClientSetMatching(
- client: IOHIDEventSystemClientRef,
- matches: CFDictionaryRef,
+ client: &IOHIDEventSystemClient,
+ matches: &CFDictionary,
) -> i32;
- pub fn IOHIDEventSystemClientCopyServices(client: IOHIDEventSystemClientRef) -> CFArrayRef;
+ pub fn IOHIDEventSystemClientCopyServices(
+ client: &IOHIDEventSystemClient,
+ ) -> Option<NonNull<CFArray>>;
pub fn IOHIDServiceClientCopyProperty(
- service: IOHIDServiceClientRef,
- key: CFStringRef,
- ) -> CFStringRef;
+ service: &IOHIDServiceClient,
+ key: &CFString,
+ ) -> Option<NonNull<CFString>>;
pub fn IOHIDServiceClientCopyEvent(
- service: IOHIDServiceClientRef,
+ service: &IOHIDServiceClient,
v0: i64,
v1: i32,
v2: i64,
- ) -> IOHIDEventRef;
+ ) -> Option<NonNull<IOHIDEvent>>;
- pub fn IOHIDEventGetFloatValue(event: IOHIDEventRef, field: i64) -> f64;
+ pub fn IOHIDEventGetFloatValue(event: &IOHIDEvent, field: i64) -> f64;
}
- pub(crate) const HID_DEVICE_PROPERTY_PRODUCT: &[u8] = b"Product\0";
+ pub(crate) const HID_DEVICE_PROPERTY_PRODUCT: &str = "Product";
- pub(crate) const HID_DEVICE_PROPERTY_PRIMARY_USAGE: &[u8] = b"PrimaryUsage\0";
- pub(crate) const HID_DEVICE_PROPERTY_PRIMARY_USAGE_PAGE: &[u8] = b"PrimaryUsagePage\0";
+ pub(crate) const HID_DEVICE_PROPERTY_PRIMARY_USAGE: &str = "PrimaryUsage";
+ pub(crate) const HID_DEVICE_PROPERTY_PRIMARY_USAGE_PAGE: &str = "PrimaryUsagePage";
#[allow(non_upper_case_globals)]
pub(crate) const kHIDPage_AppleVendor: i32 = 0xff00;
@@ -358,46 +376,23 @@ mod io_service {
#[allow(non_upper_case_globals)]
pub(crate) const kHIDUsage_AppleVendor_TemperatureSensor: i32 = 0x0005;
- pub(crate) fn matching(page: i32, usage: i32) -> CFDictionaryRef {
+ pub(crate) fn matching(page: i32, usage: i32) -> Option<CFRetained<CFDictionary>> {
unsafe {
let keys = [
- CFStringCreateWithCStringNoCopy(
- null() as *const _,
- HID_DEVICE_PROPERTY_PRIMARY_USAGE_PAGE.as_ptr() as *const _,
- core_foundation_sys::string::kCFStringEncodingUTF8,
- core_foundation_sys::base::kCFAllocatorNull as *mut _,
- ),
- CFStringCreateWithCStringNoCopy(
- null() as *const _,
- HID_DEVICE_PROPERTY_PRIMARY_USAGE.as_ptr() as *const _,
- core_foundation_sys::string::kCFStringEncodingUTF8,
- core_foundation_sys::base::kCFAllocatorNull as *mut _,
- ),
+ CFString::from_static_str(HID_DEVICE_PROPERTY_PRIMARY_USAGE_PAGE),
+ CFString::from_static_str(HID_DEVICE_PROPERTY_PRIMARY_USAGE),
];
- let nums = [
- CFNumberCreate(null(), kCFNumberSInt32Type, &page as *const _ as *const _),
- CFNumberCreate(null(), kCFNumberSInt32Type, &usage as *const _ as *const _),
- ];
+ let nums = [CFNumber::new_i32(page), CFNumber::new_i32(usage)];
- let dict = CFDictionaryCreate(
- null(),
- &keys as *const _ as *const _,
- &nums as *const _ as *const _,
+ CFDictionaryCreate(
+ None,
+ &keys as *const _ as *mut _,
+ &nums as *const _ as *mut _,
2,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks,
- );
-
- for key in keys {
- CFRelease(key as _);
- }
-
- for num in nums {
- CFRelease(num as _);
- }
-
- dict
+ )
}
}
}
diff --git a/src/unix/apple/utils.rs b/src/unix/apple/utils.rs
index dc7b28bd7..ed527ab9c 100644
--- a/src/unix/apple/utils.rs
+++ b/src/unix/apple/utils.rs
@@ -1,51 +1,5 @@
// Take a look at the license at the top of the repository in the LICENSE file.
-use core_foundation_sys::base::CFRelease;
-use std::ptr::NonNull;
-
-// A helper using to auto release the resource got from CoreFoundation.
-// More information about the ownership policy for CoreFoundation pelease refer the link below:
-// https://developer.apple.com/library/archive/documentation/CoreFoundation/Conceptual/CFMemoryMgmt/Concepts/Ownership.html#//apple_ref/doc/uid/20001148-CJBEJBHH
-#[repr(transparent)]
-#[allow(dead_code)]
-pub(crate) struct CFReleaser<T>(NonNull<T>);
-
-#[allow(dead_code)]
-impl<T> CFReleaser<T> {
- pub(crate) fn new(ptr: *const T) -> Option<Self> {
- // This cast is OK because `NonNull` is a transparent wrapper
- // over a `*const T`. Additionally, mutability doesn't matter with
- // pointers here.
- NonNull::new(ptr as *mut T).map(Self)
- }
-
- pub(crate) fn inner(&self) -> *const T {
- self.0.as_ptr().cast()
- }
-}
-
-impl<T> Drop for CFReleaser<T> {
- fn drop(&mut self) {
- unsafe { CFRelease(self.0.as_ptr().cast()) }
- }
-}
-
-// Safety: These are safe to implement because we only wrap non-mutable
-// CoreFoundation types, which are generally threadsafe unless noted
-// otherwise.
-unsafe impl<T> Send for CFReleaser<T> {}
-unsafe impl<T> Sync for CFReleaser<T> {}
-
-#[cfg(feature = "disk")]
-pub(crate) fn vec_to_rust(buf: Vec<i8>) -> Option<String> {
- String::from_utf8(
- buf.into_iter()
- .flat_map(|b| if b > 0 { Some(b as u8) } else { None })
- .collect(),
- )
- .ok()
-}
-
#[cfg(feature = "system")]
pub(crate) unsafe fn get_sys_value(
mut len: usize,