Update to Rust Edition 2024

native/src/Cargo.toml

@@ -3,6 +3,10 @@ exclude = ["external"]
 members = ["base", "boot", "core", "core/derive", "init", "sepolicy"]
 resolver = "2"
 
+[workspace.package]
+version = "0.0.0"
+edition = "2024"
+
 [workspace.dependencies]
 cxx = { path = "external/cxx-rs" }
 cxx-gen = { path = "external/cxx-rs/gen/lib" }
@@ -12,14 +16,14 @@ num-traits = "0.2"
 num-derive = "0.4"
 thiserror = "2.0"
 byteorder = "1"
-size = "0.4"
+size = "0.5"
 sha1 = "0.11.0-pre.4"
-sha2 = "=0.11.0-pre.4"
+sha2 = "0.11.0-pre.4"
 digest = "0.11.0-pre.9"
 p256 = "0.14.0-pre.2"
 p384 = "0.14.0-pre.2"
 p521 = "0.14.0-pre.2"
-rsa = "0.10.0-pre.3"
+rsa = "0.10.0-pre.4"
 x509-cert = "0.3.0-pre.0"
 der = "0.8.0-rc.1"
 bytemuck = "1.16"
@@ -30,6 +34,10 @@ syn = "2"
 quote = "1"
 proc-macro2 = "1"
 
+# Pin version to prevent cargo update break builds
+block-buffer = "=0.11.0-rc.3"
+sec1 = "=0.8.0-rc.3"
+
 [workspace.dependencies.argh]
 git = "https://github.com/google/argh.git"
 rev = "1c632b046d084e7bde86b82dfc969b30b4647c8c"

native/src/base/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "base"
-version = "0.0.0"
-edition = "2021"
+version.workspace = true
+edition.workspace = true
 
 [lib]
 path = "lib.rs"

native/src/base/build.rs

@@ -1,7 +1,7 @@
-use crate::gen::gen_cxx_binding;
+use crate::codegen::gen_cxx_binding;
 
-#[path = "../include/gen.rs"]
-mod gen;
+#[path = "../include/codegen.rs"]
+mod codegen;
 
 fn main() {
     gen_cxx_binding("base-rs");

native/src/base/cstr.rs

@@ -62,7 +62,7 @@ pub mod cstr_buf {
 
     #[inline(always)]
     pub unsafe fn wrap_ptr<'a>(buf: *mut u8, len: usize) -> Utf8CStrBufRef<'a> {
-        Utf8CStrBufRef::from_ptr(buf, len)
+        unsafe { Utf8CStrBufRef::from_ptr(buf, len) }
     }
 }
 
@@ -232,7 +232,9 @@ impl Utf8CStrBuf for Utf8CString {
     }
 
     unsafe fn set_len(&mut self, len: usize) {
-        self.0.as_mut_vec().set_len(len);
+        unsafe {
+            self.0.as_mut_vec().set_len(len);
+        }
     }
 
     fn push_str(&mut self, s: &str) -> usize {
@@ -277,7 +279,7 @@ pub struct Utf8CStrBufRef<'a> {
 
 impl<'a> Utf8CStrBufRef<'a> {
     pub unsafe fn from_ptr(buf: *mut u8, len: usize) -> Utf8CStrBufRef<'a> {
-        Self::from(slice_from_ptr_mut(buf, len))
+        unsafe { Self::from(slice_from_ptr_mut(buf, len)) }
     }
 }
 
@@ -366,12 +368,12 @@ impl Utf8CStr {
 
     #[inline(always)]
     pub const unsafe fn from_bytes_unchecked(buf: &[u8]) -> &Utf8CStr {
-        mem::transmute(buf)
+        unsafe { mem::transmute(buf) }
     }
 
     #[inline(always)]
     unsafe fn from_bytes_unchecked_mut(buf: &mut [u8]) -> &mut Utf8CStr {
-        mem::transmute(buf)
+        unsafe { mem::transmute(buf) }
     }
 
     pub unsafe fn from_ptr<'a>(ptr: *const c_char) -> Result<&'a Utf8CStr, StrErr> {
@@ -382,8 +384,10 @@ impl Utf8CStr {
     }
 
     pub unsafe fn from_ptr_unchecked<'a>(ptr: *const c_char) -> &'a Utf8CStr {
-        let cstr = CStr::from_ptr(ptr);
-        Self::from_bytes_unchecked(cstr.to_bytes_with_nul())
+        unsafe {
+            let cstr = CStr::from_ptr(ptr);
+            Self::from_bytes_unchecked(cstr.to_bytes_with_nul())
+        }
     }
 
     #[inline(always)]

native/src/base/cxx_extern.rs

@@ -20,36 +20,42 @@ pub(crate) fn fd_path_for_cxx(fd: RawFd, buf: &mut [u8]) -> isize {
         .map_or(-1_isize, |_| buf.len() as isize)
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn canonical_path(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
-    match Utf8CStr::from_ptr(path) {
-        Ok(p) => {
-            let mut buf = cstr_buf::wrap_ptr(buf, bufsz);
-            FsPath::from(p)
-                .realpath(&mut buf)
-                .map_or(-1, |_| buf.len() as isize)
+    unsafe {
+        match Utf8CStr::from_ptr(path) {
+            Ok(p) => {
+                let mut buf = cstr_buf::wrap_ptr(buf, bufsz);
+                FsPath::from(p)
+                    .realpath(&mut buf)
+                    .map_or(-1, |_| buf.len() as isize)
+            }
+            Err(_) => -1,
         }
-        Err(_) => -1,
     }
 }
 
-#[export_name = "mkdirs"]
+#[unsafe(export_name = "mkdirs")]
 unsafe extern "C" fn mkdirs_for_cxx(path: *const c_char, mode: mode_t) -> i32 {
-    match Utf8CStr::from_ptr(path) {
-        Ok(p) => FsPath::from(p).mkdirs(mode).map_or(-1, |_| 0),
-        Err(_) => -1,
+    unsafe {
+        match Utf8CStr::from_ptr(path) {
+            Ok(p) => FsPath::from(p).mkdirs(mode).map_or(-1, |_| 0),
+            Err(_) => -1,
+        }
     }
 }
 
-#[export_name = "rm_rf"]
+#[unsafe(export_name = "rm_rf")]
 unsafe extern "C" fn rm_rf_for_cxx(path: *const c_char) -> bool {
-    match Utf8CStr::from_ptr(path) {
-        Ok(p) => FsPath::from(p).remove_all().is_ok(),
-        Err(_) => false,
+    unsafe {
+        match Utf8CStr::from_ptr(path) {
+            Ok(p) => FsPath::from(p).remove_all().is_ok(),
+            Err(_) => false,
+        }
     }
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "C" fn frm_rf(fd: OwnedFd) -> bool {
     fn inner(fd: OwnedFd) -> io::Result<()> {
         Directory::try_from(fd)?.remove_all()
@@ -83,110 +89,122 @@ pub(crate) unsafe fn readlinkat_for_cxx(
     buf: *mut u8,
     bufsz: usize,
 ) -> isize {
-    // readlinkat() may fail on x86 platform, returning random value
-    // instead of number of bytes placed in buf (length of link)
-    cfg_if! {
-        if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
-            libc::memset(buf.cast(), 0, bufsz);
-            let mut r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
-            if r > 0 {
-                r = libc::strlen(buf.cast()) as isize;
-            }
-        } else {
-            let r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
-            if r >= 0 {
-                *buf.offset(r) = b'\0';
+    unsafe {
+        // readlinkat() may fail on x86 platform, returning random value
+        // instead of number of bytes placed in buf (length of link)
+        cfg_if! {
+            if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
+                libc::memset(buf.cast(), 0, bufsz);
+                let mut r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
+                if r > 0 {
+                    r = libc::strlen(buf.cast()) as isize;
+                }
+            } else {
+                let r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
+                if r >= 0 {
+                    *buf.offset(r) = b'\0';
+                }
             }
         }
+        r
     }
-    r
 }
 
-#[export_name = "cp_afc"]
+#[unsafe(export_name = "cp_afc")]
 unsafe extern "C" fn cp_afc_for_cxx(src: *const c_char, dest: *const c_char) -> bool {
-    if let Ok(src) = Utf8CStr::from_ptr(src) {
-        if let Ok(dest) = Utf8CStr::from_ptr(dest) {
-            let src = FsPath::from(src);
-            let dest = FsPath::from(dest);
-            return src
-                .copy_to(dest)
-                .log_cxx_with_msg(|w| {
-                    w.write_fmt(format_args!("cp_afc {} -> {} failed", src, dest))
-                })
-                .is_ok();
+    unsafe {
+        if let Ok(src) = Utf8CStr::from_ptr(src) {
+            if let Ok(dest) = Utf8CStr::from_ptr(dest) {
+                let src = FsPath::from(src);
+                let dest = FsPath::from(dest);
+                return src
+                    .copy_to(dest)
+                    .log_cxx_with_msg(|w| {
+                        w.write_fmt(format_args!("cp_afc {} -> {} failed", src, dest))
+                    })
+                    .is_ok();
+            }
         }
+        false
     }
-    false
 }
 
-#[export_name = "mv_path"]
+#[unsafe(export_name = "mv_path")]
 unsafe extern "C" fn mv_path_for_cxx(src: *const c_char, dest: *const c_char) -> bool {
-    if let Ok(src) = Utf8CStr::from_ptr(src) {
-        if let Ok(dest) = Utf8CStr::from_ptr(dest) {
-            let src = FsPath::from(src);
-            let dest = FsPath::from(dest);
-            return src
-                .move_to(dest)
-                .log_cxx_with_msg(|w| {
-                    w.write_fmt(format_args!("mv_path {} -> {} failed", src, dest))
-                })
-                .is_ok();
+    unsafe {
+        if let Ok(src) = Utf8CStr::from_ptr(src) {
+            if let Ok(dest) = Utf8CStr::from_ptr(dest) {
+                let src = FsPath::from(src);
+                let dest = FsPath::from(dest);
+                return src
+                    .move_to(dest)
+                    .log_cxx_with_msg(|w| {
+                        w.write_fmt(format_args!("mv_path {} -> {} failed", src, dest))
+                    })
+                    .is_ok();
+            }
         }
+        false
     }
-    false
 }
 
-#[export_name = "link_path"]
+#[unsafe(export_name = "link_path")]
 unsafe extern "C" fn link_path_for_cxx(src: *const c_char, dest: *const c_char) -> bool {
-    if let Ok(src) = Utf8CStr::from_ptr(src) {
-        if let Ok(dest) = Utf8CStr::from_ptr(dest) {
-            let src = FsPath::from(src);
-            let dest = FsPath::from(dest);
-            return src
-                .link_to(dest)
-                .log_cxx_with_msg(|w| {
-                    w.write_fmt(format_args!("link_path {} -> {} failed", src, dest))
-                })
-                .is_ok();
+    unsafe {
+        if let Ok(src) = Utf8CStr::from_ptr(src) {
+            if let Ok(dest) = Utf8CStr::from_ptr(dest) {
+                let src = FsPath::from(src);
+                let dest = FsPath::from(dest);
+                return src
+                    .link_to(dest)
+                    .log_cxx_with_msg(|w| {
+                        w.write_fmt(format_args!("link_path {} -> {} failed", src, dest))
+                    })
+                    .is_ok();
+            }
         }
+        false
     }
-    false
 }
 
-#[export_name = "clone_attr"]
+#[unsafe(export_name = "clone_attr")]
 unsafe extern "C" fn clone_attr_for_cxx(src: *const c_char, dest: *const c_char) -> bool {
-    if let Ok(src) = Utf8CStr::from_ptr(src) {
-        if let Ok(dest) = Utf8CStr::from_ptr(dest) {
-            let src = FsPath::from(src);
-            let dest = FsPath::from(dest);
-            return clone_attr(src, dest)
-                .log_cxx_with_msg(|w| {
-                    w.write_fmt(format_args!("clone_attr {} -> {} failed", src, dest))
-                })
-                .is_ok();
+    unsafe {
+        if let Ok(src) = Utf8CStr::from_ptr(src) {
+            if let Ok(dest) = Utf8CStr::from_ptr(dest) {
+                let src = FsPath::from(src);
+                let dest = FsPath::from(dest);
+                return clone_attr(src, dest)
+                    .log_cxx_with_msg(|w| {
+                        w.write_fmt(format_args!("clone_attr {} -> {} failed", src, dest))
+                    })
+                    .is_ok();
+            }
         }
+        false
     }
-    false
 }
 
-#[export_name = "fclone_attr"]
+#[unsafe(export_name = "fclone_attr")]
 unsafe extern "C" fn fclone_attr_for_cxx(a: RawFd, b: RawFd) -> bool {
     fclone_attr(a, b)
         .log_cxx_with_msg(|w| w.write_str("fclone_attr failed"))
         .is_ok()
 }
 
-#[export_name = "cxx$utf8str$new"]
+#[unsafe(export_name = "cxx$utf8str$new")]
 unsafe extern "C" fn str_new(this: &mut &Utf8CStr, s: *const u8, len: usize) {
-    *this = Utf8CStr::from_bytes(slice_from_ptr(s, len)).unwrap_or(cstr!(""));
+    unsafe {
+        *this = Utf8CStr::from_bytes(slice_from_ptr(s, len)).unwrap_or(cstr!(""));
+    }
 }
 
-#[export_name = "cxx$utf8str$ptr"]
+#[unsafe(export_name = "cxx$utf8str$ptr")]
 unsafe extern "C" fn str_ptr(this: &&Utf8CStr) -> *const u8 {
     this.as_ptr().cast()
 }
 
-#[export_name = "cxx$utf8str$len"]
+#[unsafe(export_name = "cxx$utf8str$len")]
 unsafe extern "C" fn str_len(this: &&Utf8CStr) -> usize {
     this.len()
 }

native/src/base/files.rs

@@ -263,7 +263,7 @@ impl DirEntry<'_> {
     }
 
     unsafe fn open_fd(&self, flags: i32) -> io::Result<RawFd> {
-        self.dir.open_raw_fd(self.name(), flags, 0)
+        unsafe { self.dir.open_raw_fd(self.name(), flags, 0) }
     }
 
     pub fn open_as_dir(&self) -> io::Result<Directory> {
@@ -361,7 +361,9 @@ impl Directory {
     }
 
     unsafe fn open_raw_fd(&self, name: &CStr, flags: i32, mode: i32) -> io::Result<RawFd> {
-        libc::openat(self.as_raw_fd(), name.as_ptr(), flags | O_CLOEXEC, mode).check_os_err()
+        unsafe {
+            libc::openat(self.as_raw_fd(), name.as_ptr(), flags | O_CLOEXEC, mode).check_os_err()
+        }
     }
 
     pub fn open_fd(&self, name: &Utf8CStr, flags: i32, mode: i32) -> io::Result<OwnedFd> {
@@ -929,7 +931,7 @@ impl Drop for MappedFile {
     }
 }
 
-extern "C" {
+unsafe extern "C" {
     // Don't use the declaration from the libc crate as request should be u32 not i32
     fn ioctl(fd: RawFd, request: u32, ...) -> i32;
 }