refactor(uucore): replace unsafe sysctl with safe wrapper function

- Extract sysctl kern.boottime logic into dedicated safe wrapper function
- The get_macos_boot_time_sysctl() function encapsulates unsafe behavior
- Provides a safe API that returns Option<time_t> instead of direct unsafe access
- Updates test to use the new safe wrapper function
- Addresses review feedback to remove inline unsafe block

This change maintains the same functionality while improving code safety
and encapsulation. The unsafe behavior is now isolated in a single
well-documented function with proper safety invariants.

Author: naoNao89

src/uucore/src/lib/features/uptime.rs

@@ -41,6 +41,53 @@ pub fn get_formatted_time() -> String {
     Local::now().time().format("%H:%M:%S").to_string()
 }
 
+/// Safely get macOS boot time using sysctl kern.boottime
+/// 
+/// This function provides a safe wrapper around the sysctl system call
+/// to retrieve the kernel boot time on macOS. It encapsulates the unsafe
+/// behavior and provides a safe API that returns Option<time_t>.
+/// 
+/// # Returns
+/// 
+/// Returns Some(time_t) if successful, None if the call fails.
+#[cfg(target_os = "macos")]
+fn get_macos_boot_time_sysctl() -> Option<time_t> {
+    use libc::{c_int, c_void, size_t, timeval};
+    use std::mem::size_of;
+
+    // MIB for kern.boottime - the macOS-specific way to get boot time
+    let mut mib: [c_int; 2] = [libc::CTL_KERN, libc::KERN_BOOTTIME];
+    let mut tv: timeval = timeval {
+        tv_sec: 0,
+        tv_usec: 0,
+    };
+    let mut tv_len: size_t = size_of::<timeval>() as size_t;
+
+    // SAFETY: This unsafe block is isolated and carefully controlled:
+    // - mib is a valid 2-element array for kern.boottime
+    // - tv is a properly initialized timeval struct
+    // - tv_len correctly reflects the size of tv
+    // - All pointers are valid and properly aligned
+    // - We check the return value before using the result
+    // - The function returns None on any error, providing a safe API
+    let ret = unsafe {
+        libc::sysctl(
+            mib.as_mut_ptr(),
+            2u32, // namelen
+            std::ptr::from_mut::<timeval>(&mut tv) as *mut c_void,
+            std::ptr::from_mut::<size_t>(&mut tv_len),
+            std::ptr::null_mut(),
+            0,
+        )
+    };
+
+    if ret == 0 && tv.tv_sec > 0 {
+        Some(tv.tv_sec as time_t)
+    } else {
+        None
+    }
+}
+
 /// Get the system uptime
 ///
 /// # Arguments
@@ -135,38 +182,11 @@ pub fn get_uptime(boot_time: Option<time_t>) -> UResult<i64> {
     // This fallback only runs if utmpx failed to provide a boot time.
     #[cfg(target_os = "macos")]
     let derived_boot_time = {
-        use libc::{c_int, c_void, size_t, sysctl, timeval};
-        use std::mem::size_of;
-        use std::ptr;
-
         let mut t = derived_boot_time;
         if t.is_none() {
-            // MIB for kern.boottime - the macOS-specific way to get boot time
-            let mut mib: [c_int; 2] = [libc::CTL_KERN, libc::KERN_BOOTTIME];
-            let mut tv: timeval = timeval {
-                tv_sec: 0,
-                tv_usec: 0,
-            };
-            let mut tv_len: size_t = size_of::<timeval>() as size_t;
-
-            // SAFETY: We're calling sysctl with valid parameters:
-            // - mib is a valid 2-element array for kern.boottime
-            // - tv is a properly initialized timeval struct
-            // - tv_len correctly reflects the size of tv
-            // - All pointers are valid and properly aligned
-            // - We check the return value before using the result
-            let ret = unsafe {
-                sysctl(
-                    mib.as_mut_ptr(),
-                    2u32, // namelen
-                    std::ptr::from_mut::<timeval>(&mut tv) as *mut c_void,
-                    std::ptr::from_mut::<size_t>(&mut tv_len),
-                    ptr::null_mut(),
-                    0,
-                )
-            };
-            if ret == 0 && tv.tv_sec > 0 {
-                t = Some(tv.tv_sec as time_t);
+            // Use a safe wrapper function to get boot time via sysctl
+            if let Some(boot_time) = get_macos_boot_time_sysctl() {
+                t = Some(boot_time);
             }
         }
         t
@@ -446,47 +466,24 @@ mod tests {
     #[test]
     #[cfg(target_os = "macos")]
     fn test_macos_sysctl_boottime_available() {
-        use libc::{c_int, c_void, size_t, sysctl, timeval};
-        use std::mem::size_of;
-        use std::ptr;
-
-        // Attempt to get boot time directly via sysctl
-        let mut mib: [c_int; 2] = [libc::CTL_KERN, libc::KERN_BOOTTIME];
-        let mut tv: timeval = timeval {
-            tv_sec: 0,
-            tv_usec: 0,
-        };
-        let mut tv_len: size_t = size_of::<timeval>() as size_t;
-
-        // SAFETY: We're calling sysctl with valid parameters:
-        // - mib is a valid 2-element array for kern.boottime
-        // - tv is a properly initialized timeval struct
-        // - tv_len correctly reflects the size of tv
-        // - We check the return value before using the result
-        let ret = unsafe {
-            sysctl(
-                mib.as_mut_ptr(),
-                2u32,
-                std::ptr::from_mut::<timeval>(&mut tv) as *mut c_void,
-                std::ptr::from_mut::<size_t>(&mut tv_len),
-                ptr::null_mut(),
-                0,
-            )
-        };
-
-        // Verify sysctl succeeded
-        assert_eq!(ret, 0, "sysctl kern.boottime should succeed on macOS");
-
+        // Test the safe wrapper function
+        let boot_time = get_macos_boot_time_sysctl();
+        
+        // Verify the safe wrapper succeeded
+        assert!(boot_time.is_some(), "get_macos_boot_time_sysctl should succeed on macOS");
+        
+        let boot_time = boot_time.unwrap();
+        
         // Verify boot time is valid (positive, reasonable value)
-        assert!(tv.tv_sec > 0, "Boot time should be positive");
+        assert!(boot_time > 0, "Boot time should be positive");
 
         // Boot time should be after 2000-01-01 (946684800 seconds since epoch)
-        assert!(tv.tv_sec > 946684800, "Boot time should be after year 2000");
+        assert!(boot_time > 946684800, "Boot time should be after year 2000");
 
         // Boot time should be before current time
         let now = chrono::Local::now().timestamp();
         assert!(
-            (tv.tv_sec as i64) < now,
+            (boot_time as i64) < now,
             "Boot time should be before current time"
         );
     }