Do not blindly assume strings returned by uname will always be valid UTF-8

Author: koute

src/features.rs

@@ -31,7 +31,7 @@ mod os {
         let mut minor: usize = 0;
         let mut patch: usize = 0;
 
-        for b in u.release().bytes() {
+        for &b in u.release() {
             if curr >= 3 {
                 break;
             }

src/sys/utsname.rs

@@ -1,8 +1,6 @@
 //! Get system identification
 use std::mem;
-use libc::{self, c_char};
-use std::ffi::CStr;
-use std::str::from_utf8_unchecked;
+use libc::c_char;
 use crate::Errno;
 
 /// Describes the running system.  Return type of [`uname`].
@@ -11,29 +9,29 @@ use crate::Errno;
 pub struct UtsName(libc::utsname);
 
 impl UtsName {
-    /// Name of the operating system implementation
-    pub fn sysname(&self) -> &str {
-        to_str(&(&self.0.sysname as *const c_char ) as *const *const c_char)
+    /// Name of the operating system implementation.
+    pub fn sysname(&self) -> &[u8] {
+        cast_and_trim(&self.0.sysname)
     }
 
     /// Network name of this machine.
-    pub fn nodename(&self) -> &str {
-        to_str(&(&self.0.nodename as *const c_char ) as *const *const c_char)
+    pub fn nodename(&self) -> &[u8] {
+        cast_and_trim(&self.0.nodename)
     }
 
     /// Release level of the operating system.
-    pub fn release(&self) -> &str {
-        to_str(&(&self.0.release as *const c_char ) as *const *const c_char)
+    pub fn release(&self) -> &[u8] {
+        cast_and_trim(&self.0.release)
     }
 
     /// Version level of the operating system.
-    pub fn version(&self) -> &str {
-        to_str(&(&self.0.version as *const c_char ) as *const *const c_char)
+    pub fn version(&self) -> &[u8] {
+        cast_and_trim(&self.0.version)
     }
 
     /// Machine hardware platform.
-    pub fn machine(&self) -> &str {
-        to_str(&(&self.0.machine as *const c_char ) as *const *const c_char)
+    pub fn machine(&self) -> &[u8] {
+        cast_and_trim(&self.0.machine)
     }
 }
 
@@ -46,11 +44,10 @@ pub fn uname() -> Result<UtsName, Errno> {
     }
 }
 
-#[inline]
-fn to_str<'a>(s: *const *const c_char) -> &'a str {
+fn cast_and_trim(slice: &[c_char]) -> &[u8] {
+    let length = slice.iter().position(|&byte| byte == 0).unwrap_or(slice.len());
     unsafe {
-        let res = CStr::from_ptr(*s).to_bytes();
-        from_utf8_unchecked(res)
+        std::slice::from_raw_parts(slice.as_ptr().cast(), length)
     }
 }
 
@@ -59,18 +56,18 @@ mod test {
     #[cfg(target_os = "linux")]
     #[test]
     pub fn test_uname_linux() {
-        assert_eq!(super::uname().unwrap().sysname(), "Linux");
+        assert_eq!(super::uname().unwrap().sysname(), b"Linux");
     }
 
     #[cfg(any(target_os = "macos", target_os = "ios"))]
     #[test]
     pub fn test_uname_darwin() {
-        assert_eq!(super::uname().unwrap().sysname(), "Darwin");
+        assert_eq!(super::uname().unwrap().sysname(), b"Darwin");
     }
 
     #[cfg(target_os = "freebsd")]
     #[test]
     pub fn test_uname_freebsd() {
-        assert_eq!(super::uname().unwrap().sysname(), "FreeBSD");
+        assert_eq!(super::uname().unwrap().sysname(), b"FreeBSD");
     }
 }

test/common/mod.rs

@@ -112,14 +112,14 @@ cfg_if! {
                         .expect("Bad match_version provided");
 
                 let uname = nix::sys::utsname::uname().unwrap();
-                println!("{}", uname.sysname());
-                println!("{}", uname.nodename());
-                println!("{}", uname.release());
-                println!("{}", uname.version());
-                println!("{}", uname.machine());
+                println!("{}", std::str::from_utf8(uname.sysname()).unwrap());
+                println!("{}", std::str::from_utf8(uname.nodename()).unwrap());
+                println!("{}", std::str::from_utf8(uname.release()).unwrap());
+                println!("{}", std::str::from_utf8(uname.version()).unwrap());
+                println!("{}", std::str::from_utf8(uname.machine()).unwrap());
 
                 // Fix stuff that the semver parser can't handle
-                let fixed_release = &uname.release().to_string()
+                let fixed_release = &std::str::from_utf8(uname.release()).unwrap().to_string()
                     // Fedora 33 reports version as 4.18.el8_2.x86_64 or
                     // 5.18.200-fc33.x86_64.  Remove the underscore.
                     .replace("_", "-")