From c90e73ccec063baafe6b784c10f76c7de4e9f510 Mon Sep 17 00:00:00 2001 From: topjohnwu Date: Thu, 6 Mar 2025 23:04:02 -0800 Subject: [PATCH] Migration to Edition 2024 --- native/src/Cargo.toml | 2 +- native/src/base/build.rs | 6 +- native/src/base/cstr.rs | 18 +- native/src/base/cxx_extern.rs | 184 ++++---- native/src/base/files.rs | 8 +- native/src/base/misc.rs | 20 +- native/src/base/xwrap.rs | 490 ++++++++++++---------- native/src/boot/build.rs | 6 +- native/src/boot/dtb.rs | 7 +- native/src/boot/patch.rs | 22 +- native/src/boot/sign.rs | 40 +- native/src/core/build.rs | 6 +- native/src/core/db.rs | 59 +-- native/src/core/lib.rs | 6 +- native/src/core/logging.rs | 2 +- native/src/core/package.rs | 16 +- native/src/core/resetprop/persist.rs | 8 +- native/src/include/{gen.rs => codegen.rs} | 6 +- native/src/init/build.rs | 6 +- native/src/init/init.rs | 24 +- native/src/init/mount.rs | 2 +- native/src/init/twostage.rs | 61 +-- native/src/sepolicy/build.rs | 6 +- 23 files changed, 568 insertions(+), 437 deletions(-) rename native/src/include/{gen.rs => codegen.rs} (80%) diff --git a/native/src/Cargo.toml b/native/src/Cargo.toml index 4454bad82..a5fb75275 100644 --- a/native/src/Cargo.toml +++ b/native/src/Cargo.toml @@ -5,7 +5,7 @@ resolver = "2" [workspace.package] version = "0.0.0" -edition = "2021" +edition = "2024" [workspace.dependencies] cxx = { path = "external/cxx-rs" } diff --git a/native/src/base/build.rs b/native/src/base/build.rs index 59d58759c..0cd5d17c4 100644 --- a/native/src/base/build.rs +++ b/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"); diff --git a/native/src/base/cstr.rs b/native/src/base/cstr.rs index 89fa18eab..620d36323 100644 --- a/native/src/base/cstr.rs +++ b/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)] diff --git a/native/src/base/cxx_extern.rs b/native/src/base/cxx_extern.rs index 455bc76d8..cf049ea19 100644 --- a/native/src/base/cxx_extern.rs +++ b/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() } diff --git a/native/src/base/files.rs b/native/src/base/files.rs index 175c33aec..743adbf76 100644 --- a/native/src/base/files.rs +++ b/native/src/base/files.rs @@ -263,7 +263,7 @@ impl DirEntry<'_> { } unsafe fn open_fd(&self, flags: i32) -> io::Result { - 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 { @@ -361,7 +361,9 @@ impl Directory { } unsafe fn open_raw_fd(&self, name: &CStr, flags: i32, mode: i32) -> io::Result { - 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 { @@ -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; } diff --git a/native/src/base/misc.rs b/native/src/base/misc.rs index e29835c00..ef57779d7 100644 --- a/native/src/base/misc.rs +++ b/native/src/base/misc.rs @@ -16,20 +16,24 @@ pub fn errno() -> &'static mut i32 { // When len is 0, don't care whether buf is null or not #[inline] pub unsafe fn slice_from_ptr<'a, T>(buf: *const T, len: usize) -> &'a [T] { - if len == 0 { - &[] - } else { - slice::from_raw_parts(buf, len) + unsafe { + if len == 0 { + &[] + } else { + slice::from_raw_parts(buf, len) + } } } // When len is 0, don't care whether buf is null or not #[inline] pub unsafe fn slice_from_ptr_mut<'a, T>(buf: *mut T, len: usize) -> &'a mut [T] { - if len == 0 { - &mut [] - } else { - slice::from_raw_parts_mut(buf, len) + unsafe { + if len == 0 { + &mut [] + } else { + slice::from_raw_parts_mut(buf, len) + } } } diff --git a/native/src/base/xwrap.rs b/native/src/base/xwrap.rs index 8bd58abea..dc3f864c7 100644 --- a/native/src/base/xwrap.rs +++ b/native/src/base/xwrap.rs @@ -50,93 +50,107 @@ mod c_export { use crate::{slice_from_ptr, slice_from_ptr_mut}; - #[no_mangle] + #[unsafe(no_mangle)] unsafe extern "C" fn xwrite(fd: RawFd, buf: *const u8, bufsz: usize) -> isize { - super::xwrite(fd, slice_from_ptr(buf, bufsz)) + unsafe { super::xwrite(fd, slice_from_ptr(buf, bufsz)) } } - #[no_mangle] + #[unsafe(no_mangle)] unsafe extern "C" fn xxread(fd: RawFd, buf: *mut u8, bufsz: usize) -> isize { - super::xxread(fd, slice_from_ptr_mut(buf, bufsz)) + unsafe { super::xxread(fd, slice_from_ptr_mut(buf, bufsz)) } } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xrealpath(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize { - match Utf8CStr::from_ptr(path) { - Ok(p) => { - let mut buf = Utf8CStrBufRef::from_ptr(buf, bufsz); - FsPath::from(p) - .realpath(&mut buf) - .log_cxx_with_msg(|w| w.write_fmt(format_args!("realpath {} failed", p))) - .map_or(-1, |_| buf.len() as isize) + unsafe { + match Utf8CStr::from_ptr(path) { + Ok(p) => { + let mut buf = Utf8CStrBufRef::from_ptr(buf, bufsz); + FsPath::from(p) + .realpath(&mut buf) + .log_cxx_with_msg(|w| w.write_fmt(format_args!("realpath {} failed", p))) + .map_or(-1, |_| buf.len() as isize) + } + Err(_) => -1, } - Err(_) => -1, } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xreadlink(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize { - match Utf8CStr::from_ptr(path) { - Ok(p) => { - let mut buf = Utf8CStrBufRef::from_ptr(buf, bufsz); - FsPath::from(p) - .read_link(&mut buf) - .log_cxx_with_msg(|w| w.write_fmt(format_args!("readlink {} failed", p))) - .map_or(-1, |_| buf.len() as isize) + unsafe { + match Utf8CStr::from_ptr(path) { + Ok(p) => { + let mut buf = Utf8CStrBufRef::from_ptr(buf, bufsz); + FsPath::from(p) + .read_link(&mut buf) + .log_cxx_with_msg(|w| w.write_fmt(format_args!("readlink {} failed", p))) + .map_or(-1, |_| buf.len() as isize) + } + Err(_) => -1, } - Err(_) => -1, } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xreadlinkat( dirfd: RawFd, path: *const c_char, buf: *mut u8, bufsz: usize, ) -> isize { - let r = readlinkat_for_cxx(dirfd, path, buf, bufsz); - if r < 0 { - perror!("readlinkat {}", ptr_to_str(path)) + unsafe { + let r = readlinkat_for_cxx(dirfd, path, buf, bufsz); + if r < 0 { + perror!("readlinkat {}", ptr_to_str(path)) + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xfopen(path: *const c_char, mode: *const c_char) -> *mut libc::FILE { - let fp = libc::fopen(path, mode); - if fp.is_null() { - perror!("fopen {}", ptr_to_str(path)); + unsafe { + let fp = libc::fopen(path, mode); + if fp.is_null() { + perror!("fopen {}", ptr_to_str(path)); + } + fp } - fp } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xfdopen(fd: RawFd, mode: *const c_char) -> *mut libc::FILE { - let fp = libc::fdopen(fd, mode); - if fp.is_null() { - perror!("fdopen"); + unsafe { + let fp = libc::fdopen(fd, mode); + if fp.is_null() { + perror!("fdopen"); + } + fp } - fp } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xopen(path: *const c_char, flags: i32, mode: mode_t) -> RawFd { - let r = libc::open(path, flags, mode as c_uint); - if r < 0 { - perror!("open {}", ptr_to_str(path)); + unsafe { + let r = libc::open(path, flags, mode as c_uint); + if r < 0 { + perror!("open {}", ptr_to_str(path)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xopenat(dirfd: RawFd, path: *const c_char, flags: i32, mode: mode_t) -> RawFd { - let r = libc::openat(dirfd, path, flags, mode as c_uint); - if r < 0 { - perror!("openat {}", ptr_to_str(path)); + unsafe { + let r = libc::openat(dirfd, path, flags, mode as c_uint); + if r < 0 { + perror!("openat {}", ptr_to_str(path)); + } + r } - r } // Fully write data slice @@ -168,7 +182,7 @@ fn xwrite(fd: RawFd, data: &[u8]) -> isize { } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xread(fd: RawFd, buf: *mut c_void, bufsz: usize) -> isize { unsafe { let r = libc::read(fd, buf, bufsz); @@ -208,7 +222,7 @@ fn xxread(fd: RawFd, data: &mut [u8]) -> isize { } } -#[no_mangle] +#[unsafe(no_mangle)] extern "C" fn xlseek64(fd: RawFd, offset: i64, whence: i32) -> i64 { unsafe { let r = libc::lseek64(fd, offset, whence); @@ -229,7 +243,7 @@ pub(crate) fn xpipe2(fds: &mut [i32; 2], flags: i32) -> i32 { } } -#[no_mangle] +#[unsafe(no_mangle)] extern "C" fn xsetns(fd: RawFd, nstype: i32) -> i32 { unsafe { let r = libc::setns(fd, nstype); @@ -240,7 +254,7 @@ extern "C" fn xsetns(fd: RawFd, nstype: i32) -> i32 { } } -#[no_mangle] +#[unsafe(no_mangle)] extern "C" fn xunshare(flags: i32) -> i32 { unsafe { let r = libc::unshare(flags); @@ -251,16 +265,18 @@ extern "C" fn xunshare(flags: i32) -> i32 { } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xopendir(path: *const c_char) -> *mut libc::DIR { - let dp = libc::opendir(path); - if dp.is_null() { - perror!("opendir {}", ptr_to_str(path)); + unsafe { + let dp = libc::opendir(path); + if dp.is_null() { + perror!("opendir {}", ptr_to_str(path)); + } + dp } - dp } -#[no_mangle] +#[unsafe(no_mangle)] extern "C" fn xfdopendir(fd: RawFd) -> *mut libc::DIR { unsafe { let dp = libc::fdopendir(fd); @@ -271,27 +287,29 @@ extern "C" fn xfdopendir(fd: RawFd) -> *mut libc::DIR { } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xreaddir(dirp: *mut libc::DIR) -> *mut libc::dirent { - *errno() = 0; - loop { - let e = libc::readdir(dirp); - if e.is_null() { - if *errno() != 0 { - perror!("readdir") - } - } else { - // Filter out . and .. - let s = (*e).d_name.as_ptr(); - if libc::strcmp(s, raw_cstr!(".")) == 0 || libc::strcmp(s, raw_cstr!("..")) == 0 { - continue; - } - }; - return e; + unsafe { + *errno() = 0; + loop { + let e = libc::readdir(dirp); + if e.is_null() { + if *errno() != 0 { + perror!("readdir") + } + } else { + // Filter out . and .. + let s = (*e).d_name.as_ptr(); + if libc::strcmp(s, raw_cstr!(".")) == 0 || libc::strcmp(s, raw_cstr!("..")) == 0 { + continue; + } + }; + return e; + } } } -#[no_mangle] +#[unsafe(no_mangle)] extern "C" fn xsetsid() -> i32 { unsafe { let r = libc::setsid(); @@ -302,7 +320,7 @@ extern "C" fn xsetsid() -> i32 { } } -#[no_mangle] +#[unsafe(no_mangle)] extern "C" fn xsocket(domain: i32, ty: i32, protocol: i32) -> RawFd { unsafe { let fd = libc::socket(domain, ty, protocol); @@ -313,16 +331,18 @@ extern "C" fn xsocket(domain: i32, ty: i32, protocol: i32) -> RawFd { } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xbind(socket: i32, address: *const sockaddr, len: socklen_t) -> i32 { - let r = libc::bind(socket, address, len); - if r < 0 { - perror!("bind"); + unsafe { + let r = libc::bind(socket, address, len); + if r < 0 { + perror!("bind"); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] extern "C" fn xlisten(socket: i32, backlog: i32) -> i32 { unsafe { let r = libc::listen(socket, backlog); @@ -333,103 +353,121 @@ extern "C" fn xlisten(socket: i32, backlog: i32) -> i32 { } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xaccept4( sockfd: RawFd, addr: *mut sockaddr, len: *mut socklen_t, flg: i32, ) -> RawFd { - let fd = libc::accept4(sockfd, addr, len, flg); - if fd < 0 { - perror!("accept4"); + unsafe { + let fd = libc::accept4(sockfd, addr, len, flg); + if fd < 0 { + perror!("accept4"); + } + fd } - fd } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xsendmsg(fd: RawFd, msg: *const libc::msghdr, flags: i32) -> ssize_t { - let r = libc::sendmsg(fd, msg, flags); - if r < 0 { - perror!("sendmsg"); + unsafe { + let r = libc::sendmsg(fd, msg, flags); + if r < 0 { + perror!("sendmsg"); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xrecvmsg(fd: RawFd, msg: *mut libc::msghdr, flags: i32) -> ssize_t { - let r = libc::recvmsg(fd, msg, flags); - if r < 0 { - perror!("recvmsg"); + unsafe { + let r = libc::recvmsg(fd, msg, flags); + if r < 0 { + perror!("recvmsg"); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xaccess(path: *const c_char, mode: i32) -> i32 { - let r = libc::access(path, mode); - if r < 0 { - perror!("access {}", ptr_to_str(path)); + unsafe { + let r = libc::access(path, mode); + if r < 0 { + perror!("access {}", ptr_to_str(path)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xfaccessat(dirfd: RawFd, path: *const c_char, mode: i32, flags: i32) -> i32 { - #[allow(unused_mut)] - let mut r = libc::faccessat(dirfd, path, mode, flags); - if r < 0 { - perror!("faccessat {}", ptr_to_str(path)); + unsafe { + #[allow(unused_mut)] + let mut r = libc::faccessat(dirfd, path, mode, flags); + if r < 0 { + perror!("faccessat {}", ptr_to_str(path)); + } + #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] + if r > 0 && *errno() == 0 { + r = 0 + } + r } - #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] - if r > 0 && *errno() == 0 { - r = 0 - } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xstat(path: *const c_char, buf: *mut libc::stat) -> i32 { - let r = libc::stat(path, buf); - if r < 0 { - perror!("stat {}", ptr_to_str(path)); + unsafe { + let r = libc::stat(path, buf); + if r < 0 { + perror!("stat {}", ptr_to_str(path)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xlstat(path: *const c_char, buf: *mut libc::stat) -> i32 { - let r = libc::lstat(path, buf); - if r < 0 { - perror!("lstat {}", ptr_to_str(path)); + unsafe { + let r = libc::lstat(path, buf); + if r < 0 { + perror!("lstat {}", ptr_to_str(path)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xfstat(fd: RawFd, buf: *mut libc::stat) -> i32 { - let r = libc::fstat(fd, buf); - if r < 0 { - perror!("fstat"); + unsafe { + let r = libc::fstat(fd, buf); + if r < 0 { + perror!("fstat"); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xfstatat( dirfd: RawFd, path: *const c_char, buf: *mut libc::stat, flags: i32, ) -> i32 { - let r = libc::fstatat(dirfd, path, buf, flags); - if r < 0 { - perror!("fstatat {}", ptr_to_str(path)); + unsafe { + let r = libc::fstatat(dirfd, path, buf, flags); + if r < 0 { + perror!("fstatat {}", ptr_to_str(path)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] extern "C" fn xdup(oldfd: RawFd) -> RawFd { unsafe { let fd = libc::dup(oldfd); @@ -440,7 +478,7 @@ extern "C" fn xdup(oldfd: RawFd) -> RawFd { } } -#[no_mangle] +#[unsafe(no_mangle)] extern "C" fn xdup2(oldfd: RawFd, newfd: RawFd) -> RawFd { unsafe { let fd = libc::dup2(oldfd, newfd); @@ -451,7 +489,7 @@ extern "C" fn xdup2(oldfd: RawFd, newfd: RawFd) -> RawFd { } } -#[no_mangle] +#[unsafe(no_mangle)] extern "C" fn xdup3(oldfd: RawFd, newfd: RawFd, flags: i32) -> RawFd { unsafe { let fd = libc::syscall(SYS_dup3, oldfd, newfd, flags) as RawFd; @@ -462,33 +500,37 @@ extern "C" fn xdup3(oldfd: RawFd, newfd: RawFd, flags: i32) -> RawFd { } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xsymlink(target: *const c_char, linkpath: *const c_char) -> i32 { - let r = libc::symlink(target, linkpath); - if r < 0 { - perror!("symlink {} -> {}", ptr_to_str(target), ptr_to_str(linkpath)); + unsafe { + let r = libc::symlink(target, linkpath); + if r < 0 { + perror!("symlink {} -> {}", ptr_to_str(target), ptr_to_str(linkpath)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xsymlinkat( target: *const c_char, dirfd: RawFd, linkpath: *const c_char, ) -> i32 { - let r = libc::symlinkat(target, dirfd, linkpath); - if r < 0 { - perror!( - "symlinkat {} -> {}", - ptr_to_str(target), - ptr_to_str(linkpath) - ); + unsafe { + let r = libc::symlinkat(target, dirfd, linkpath); + if r < 0 { + perror!( + "symlinkat {} -> {}", + ptr_to_str(target), + ptr_to_str(linkpath) + ); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xlinkat( olddirfd: RawFd, target: *const c_char, @@ -496,14 +538,16 @@ unsafe extern "C" fn xlinkat( linkpath: *const c_char, flags: i32, ) -> i32 { - let r = libc::linkat(olddirfd, target, newdirfd, linkpath, flags); - if r < 0 { - perror!("linkat {} -> {}", ptr_to_str(target), ptr_to_str(linkpath)); + unsafe { + let r = libc::linkat(olddirfd, target, newdirfd, linkpath, flags); + if r < 0 { + perror!("linkat {} -> {}", ptr_to_str(target), ptr_to_str(linkpath)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xmount( src: *const c_char, target: *const c_char, @@ -511,84 +555,100 @@ unsafe extern "C" fn xmount( flags: c_ulong, data: *const c_void, ) -> i32 { - let r = libc::mount(src, target, fstype, flags, data); - if r < 0 { - perror!("mount {} -> {}", ptr_to_str(src), ptr_to_str(target)); + unsafe { + let r = libc::mount(src, target, fstype, flags, data); + if r < 0 { + perror!("mount {} -> {}", ptr_to_str(src), ptr_to_str(target)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xumount(target: *const c_char) -> i32 { - let r = libc::umount(target); - if r < 0 { - perror!("umount {}", ptr_to_str(target)); + unsafe { + let r = libc::umount(target); + if r < 0 { + perror!("umount {}", ptr_to_str(target)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xumount2(target: *const c_char, flags: i32) -> i32 { - let r = libc::umount2(target, flags); - if r < 0 { - perror!("umount2 {}", ptr_to_str(target)); + unsafe { + let r = libc::umount2(target, flags); + if r < 0 { + perror!("umount2 {}", ptr_to_str(target)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xrename(oldname: *const c_char, newname: *const c_char) -> i32 { - let r = libc::rename(oldname, newname); - if r < 0 { - perror!("rename {} -> {}", ptr_to_str(oldname), ptr_to_str(newname)); + unsafe { + let r = libc::rename(oldname, newname); + if r < 0 { + perror!("rename {} -> {}", ptr_to_str(oldname), ptr_to_str(newname)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xmkdir(path: *const c_char, mode: mode_t) -> i32 { - let r = libc::mkdir(path, mode); - if r < 0 && *errno() != libc::EEXIST { - perror!("mkdir {}", ptr_to_str(path)); + unsafe { + let r = libc::mkdir(path, mode); + if r < 0 && *errno() != libc::EEXIST { + perror!("mkdir {}", ptr_to_str(path)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xmkdirs(path: *const c_char, mode: mode_t) -> i32 { - match Utf8CStr::from_ptr(path) { - Ok(p) => FsPath::from(p) - .mkdirs(mode) - .log_cxx_with_msg(|w| w.write_fmt(format_args!("mkdirs {} failed", p))) - .map_or(-1, |_| 0), - Err(_) => -1, + unsafe { + match Utf8CStr::from_ptr(path) { + Ok(p) => FsPath::from(p) + .mkdirs(mode) + .log_cxx_with_msg(|w| w.write_fmt(format_args!("mkdirs {} failed", p))) + .map_or(-1, |_| 0), + Err(_) => -1, + } } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xmkdirat(dirfd: RawFd, path: *const c_char, mode: mode_t) -> i32 { - let r = libc::mkdirat(dirfd, path, mode); - if r < 0 && *errno() != libc::EEXIST { - perror!("mkdirat {}", ptr_to_str(path)); + unsafe { + let r = libc::mkdirat(dirfd, path, mode); + if r < 0 && *errno() != libc::EEXIST { + perror!("mkdirat {}", ptr_to_str(path)); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xsendfile( out_fd: RawFd, in_fd: RawFd, offset: *mut off_t, count: usize, ) -> isize { - let r = libc::sendfile(out_fd, in_fd, offset, count); - if r < 0 { - perror!("sendfile"); + unsafe { + let r = libc::sendfile(out_fd, in_fd, offset, count); + if r < 0 { + perror!("sendfile"); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xmmap( addr: *mut c_void, len: usize, @@ -597,15 +657,17 @@ unsafe extern "C" fn xmmap( fd: RawFd, offset: off_t, ) -> *mut c_void { - let r = libc::mmap(addr, len, prot, flags, fd, offset); - if r == libc::MAP_FAILED { - perror!("mmap"); - return ptr::null_mut(); + unsafe { + let r = libc::mmap(addr, len, prot, flags, fd, offset); + if r == libc::MAP_FAILED { + perror!("mmap"); + return ptr::null_mut(); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] extern "C" fn xfork() -> i32 { unsafe { let r = libc::fork(); @@ -616,20 +678,24 @@ extern "C" fn xfork() -> i32 { } } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xpoll(fds: *mut pollfd, nfds: nfds_t, timeout: i32) -> i32 { - let r = libc::poll(fds, nfds, timeout); - if r < 0 { - perror!("poll"); + unsafe { + let r = libc::poll(fds, nfds, timeout); + if r < 0 { + perror!("poll"); + } + r } - r } -#[no_mangle] +#[unsafe(no_mangle)] unsafe extern "C" fn xmknod(pathname: *const c_char, mode: mode_t, dev: dev_t) -> i32 { - let r = libc::mknod(pathname, mode, dev); - if r < 0 { - perror!("mknod {}", ptr_to_str(pathname)); + unsafe { + let r = libc::mknod(pathname, mode, dev); + if r < 0 { + perror!("mknod {}", ptr_to_str(pathname)); + } + r } - r } diff --git a/native/src/boot/build.rs b/native/src/boot/build.rs index 200693aed..ce6039923 100644 --- a/native/src/boot/build.rs +++ b/native/src/boot/build.rs @@ -1,9 +1,9 @@ use pb_rs::{types::FileDescriptor, ConfigBuilder}; -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() { println!("cargo:rerun-if-changed=proto/update_metadata.proto"); diff --git a/native/src/boot/dtb.rs b/native/src/boot/dtb.rs index 38d4750e4..b308e6fee 100644 --- a/native/src/boot/dtb.rs +++ b/native/src/boot/dtb.rs @@ -1,7 +1,10 @@ use std::{cell::UnsafeCell, process::exit}; use argh::FromArgs; -use fdt::{node::{FdtNode, NodeProperty}, Fdt, FdtError}; +use fdt::{ + node::{FdtNode, NodeProperty}, + Fdt, FdtError, +}; use base::{ libc::c_char, log_err, map_args, EarlyExitExt, LoggedResult, MappedFile, ResultExt, Utf8CStr, @@ -172,7 +175,7 @@ fn for_each_fdt LoggedResult<()>>( Err(FdtError::BufferTooSmall) => { eprintln!("dtb.{:04} is truncated", dtb_num); break; - }, + } Ok(fdt) => fdt, e => e?, }; diff --git a/native/src/boot/patch.rs b/native/src/boot/patch.rs index 15968a5d4..d9fecd580 100644 --- a/native/src/boot/patch.rs +++ b/native/src/boot/patch.rs @@ -63,15 +63,17 @@ fn remove_pattern(buf: &mut [u8], pattern_matcher: unsafe fn(&[u8]) -> Option usize { unsafe fn match_verity_pattern(buf: &[u8]) -> Option { - match_patterns!( - buf, - b"verifyatboot", - b"verify", - b"avb_keys", - b"avb", - b"support_scfs", - b"fsverity" - ) + unsafe { + match_patterns!( + buf, + b"verifyatboot", + b"verify", + b"avb_keys", + b"avb", + b"support_scfs", + b"fsverity" + ) + } } remove_pattern(buf, match_verity_pattern) @@ -79,7 +81,7 @@ pub fn patch_verity(buf: &mut [u8]) -> usize { pub fn patch_encryption(buf: &mut [u8]) -> usize { unsafe fn match_encryption_pattern(buf: &[u8]) -> Option { - match_patterns!(buf, b"forceencrypt", b"forcefdeorfbe", b"fileencryption") + unsafe { match_patterns!(buf, b"forceencrypt", b"forcefdeorfbe", b"fileencryption") } } remove_pattern(buf, match_encryption_pattern) diff --git a/native/src/boot/sign.rs b/native/src/boot/sign.rs index 89245ec85..6e58c4199 100644 --- a/native/src/boot/sign.rs +++ b/native/src/boot/sign.rs @@ -157,20 +157,32 @@ struct Signer { impl Signer { fn from_private_key(key: &[u8]) -> LoggedResult { let digest: Box; - let key = if let Ok(rsa) = RsaPrivateKey::from_pkcs8_der(key) { - digest = Box::::default(); - SigningKey::SHA256withRSA(RsaSigningKey::::new(rsa)) - } else if let Ok(ec) = P256SigningKey::from_pkcs8_der(key) { - digest = Box::::default(); - SigningKey::SHA256withECDSA(ec) - } else if let Ok(ec) = P384SigningKey::from_pkcs8_der(key) { - digest = Box::::default(); - SigningKey::SHA384withECDSA(ec) - } else if let Ok(ec) = P521SigningKey::from_pkcs8_der(key) { - digest = Box::::default(); - SigningKey::SHA521withECDSA(ec) - } else { - return Err(log_err!("Unsupported private key")); + let key = match RsaPrivateKey::from_pkcs8_der(key) { + Ok(rsa) => { + digest = Box::::default(); + SigningKey::SHA256withRSA(RsaSigningKey::::new(rsa)) + } + _ => match P256SigningKey::from_pkcs8_der(key) { + Ok(ec) => { + digest = Box::::default(); + SigningKey::SHA256withECDSA(ec) + } + _ => match P384SigningKey::from_pkcs8_der(key) { + Ok(ec) => { + digest = Box::::default(); + SigningKey::SHA384withECDSA(ec) + } + _ => match P521SigningKey::from_pkcs8_der(key) { + Ok(ec) => { + digest = Box::::default(); + SigningKey::SHA521withECDSA(ec) + } + _ => { + return Err(log_err!("Unsupported private key")); + } + }, + }, + }, }; Ok(Signer { digest, key }) } diff --git a/native/src/core/build.rs b/native/src/core/build.rs index bdd3c8139..eae7a5082 100644 --- a/native/src/core/build.rs +++ b/native/src/core/build.rs @@ -1,9 +1,9 @@ use pb_rs::{types::FileDescriptor, ConfigBuilder}; -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() { println!("cargo:rerun-if-changed=resetprop/proto/persistent_properties.proto"); diff --git a/native/src/core/db.rs b/native/src/core/db.rs index f29f91c9e..81be4bf34 100644 --- a/native/src/core/db.rs +++ b/native/src/core/db.rs @@ -138,7 +138,7 @@ unsafe impl Send for Sqlite3 {} type SqlBindCallback = Option) -> i32>; type SqlExecCallback = Option; -extern "C" { +unsafe extern "C" { fn sql_exec_impl( db: *mut sqlite3, sql: &str, @@ -160,16 +160,18 @@ struct DbArgs<'a> { } unsafe extern "C" fn bind_arguments(v: *mut c_void, idx: i32, stmt: Pin<&mut DbStatement>) -> i32 { - let args = &mut *(v as *mut DbArgs<'_>); - if args.curr < args.args.len() { - let arg = &args.args[args.curr]; - args.curr += 1; - match *arg { - Text(v) => stmt.bind_text(idx, v), - Integer(v) => stmt.bind_int64(idx, v), + unsafe { + let args = &mut *(v as *mut DbArgs<'_>); + if args.curr < args.args.len() { + let arg = &args.args[args.curr]; + args.curr += 1; + match *arg { + Text(v) => stmt.bind_text(idx, v), + Integer(v) => stmt.bind_int64(idx, v), + } + } else { + 0 } - } else { - 0 } } @@ -178,8 +180,10 @@ unsafe extern "C" fn read_db_row( columns: &[String], values: &DbValues, ) { - let table = &mut *(v as *mut T); - table.on_row(columns, values); + unsafe { + let table = &mut *(v as *mut T); + table.on_row(columns, values); + } } impl MagiskD { @@ -189,10 +193,9 @@ impl MagiskD { let raw_db = open_and_init_db(); *db = NonNull::new(raw_db).map(Sqlite3); } - if let Some(ref mut db) = *db { - f(db.0.as_ptr()) - } else { - -1 + match *db { + Some(ref mut db) => f(db.0.as_ptr()), + _ => -1, } } @@ -333,7 +336,7 @@ impl MagiskD { } } -#[export_name = "sql_exec_rs"] +#[unsafe(export_name = "sql_exec_rs")] unsafe extern "C" fn sql_exec_for_cxx( sql: &str, bind_callback: SqlBindCallback, @@ -341,14 +344,16 @@ unsafe extern "C" fn sql_exec_for_cxx( exec_callback: SqlExecCallback, exec_cookie: *mut c_void, ) -> i32 { - MAGISKD.get().unwrap_unchecked().with_db(|db| { - sql_exec_impl( - db, - sql, - bind_callback, - bind_cookie, - exec_callback, - exec_cookie, - ) - }) + unsafe { + MAGISKD.get().unwrap_unchecked().with_db(|db| { + sql_exec_impl( + db, + sql, + bind_callback, + bind_cookie, + exec_callback, + exec_cookie, + ) + }) + } } diff --git a/native/src/core/lib.rs b/native/src/core/lib.rs index 225dca157..65540ea6d 100644 --- a/native/src/core/lib.rs +++ b/native/src/core/lib.rs @@ -257,8 +257,10 @@ unsafe impl ExternType for UCred { impl SuRequest { unsafe fn write_to_fd(&self, fd: i32) { - let mut w = ManuallyDrop::new(File::from_raw_fd(fd)); - self.encode(w.deref_mut()).ok(); + unsafe { + let mut w = ManuallyDrop::new(File::from_raw_fd(fd)); + self.encode(w.deref_mut()).ok(); + } } } diff --git a/native/src/core/logging.rs b/native/src/core/logging.rs index b67dfe225..c670bd614 100644 --- a/native/src/core/logging.rs +++ b/native/src/core/logging.rs @@ -42,7 +42,7 @@ enum ALogPriority { type ThreadEntry = extern "C" fn(*mut c_void) -> *mut c_void; -extern "C" { +unsafe extern "C" { fn __android_log_write(prio: i32, tag: *const c_char, msg: *const c_char); fn strftime(buf: *mut c_char, len: usize, fmt: *const c_char, tm: *const tm) -> usize; fn new_daemon_thread(entry: ThreadEntry, arg: *mut c_void); diff --git a/native/src/core/package.rs b/native/src/core/package.rs index 361b723a4..f9f4a5797 100644 --- a/native/src/core/package.rs +++ b/native/src/core/package.rs @@ -485,14 +485,16 @@ impl MagiskD { } pub unsafe fn get_manager_for_cxx(&self, user: i32, ptr: *mut CxxString, install: bool) -> i32 { - let mut info = self.manager_info.lock().unwrap(); - let (uid, pkg) = info.get_manager(self, user, install); - if let Some(str) = ptr.as_mut() { - let mut str = Pin::new_unchecked(str); - str.as_mut().clear(); - str.push_str(pkg); + unsafe { + let mut info = self.manager_info.lock().unwrap(); + let (uid, pkg) = info.get_manager(self, user, install); + if let Some(str) = ptr.as_mut() { + let mut str = Pin::new_unchecked(str); + str.as_mut().clear(); + str.push_str(pkg); + } + uid } - uid } // app_id = app_no + AID_APP_START diff --git a/native/src/core/resetprop/persist.rs b/native/src/core/resetprop/persist.rs index 7600770df..25eba2c7d 100644 --- a/native/src/core/resetprop/persist.rs +++ b/native/src/core/resetprop/persist.rs @@ -130,8 +130,8 @@ pub fn persist_get_prop(name: &Utf8CStr, mut prop_cb: Pin<&mut PropCb>) { let mut props = proto_read_props()?; let prop = props.find(name)?; if let PersistentPropertyRecord { - name: Some(ref mut n), - value: Some(ref mut v), + name: Some(n), + value: Some(v), } = prop { prop_cb.exec(Utf8CStr::from_string(n), Utf8CStr::from_string(v)); @@ -151,8 +151,8 @@ pub fn persist_get_props(mut prop_cb: Pin<&mut PropCb>) { let mut props = proto_read_props()?; props.iter_mut().for_each(|prop| { if let PersistentPropertyRecord { - name: Some(ref mut n), - value: Some(ref mut v), + name: Some(n), + value: Some(v), } = prop { prop_cb.exec(Utf8CStr::from_string(n), Utf8CStr::from_string(v)); diff --git a/native/src/include/gen.rs b/native/src/include/codegen.rs similarity index 80% rename from native/src/include/gen.rs rename to native/src/include/codegen.rs index 0b4d2c20b..d8414b656 100644 --- a/native/src/include/gen.rs +++ b/native/src/include/codegen.rs @@ -39,7 +39,7 @@ fn write_if_diff>(path: P, bytes: &[u8]) -> io::Result<()> { pub fn gen_cxx_binding(name: &str) { println!("cargo:rerun-if-changed=lib.rs"); let opt = Opt::default(); - let gen = cxx_gen::generate_header_and_cc_with_path("lib.rs", &opt); - write_if_diff(format!("{}.cpp", name), gen.implementation.as_slice()).ok_or_exit(); - write_if_diff(format!("{}.hpp", name), gen.header.as_slice()).ok_or_exit(); + let code = cxx_gen::generate_header_and_cc_with_path("lib.rs", &opt); + write_if_diff(format!("{}.cpp", name), code.implementation.as_slice()).ok_or_exit(); + write_if_diff(format!("{}.hpp", name), code.header.as_slice()).ok_or_exit(); } diff --git a/native/src/init/build.rs b/native/src/init/build.rs index 2b7192615..6eb5e6356 100644 --- a/native/src/init/build.rs +++ b/native/src/init/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("init-rs"); diff --git a/native/src/init/init.rs b/native/src/init/init.rs index 5bb0defe6..6acb0b756 100644 --- a/native/src/init/init.rs +++ b/native/src/init/init.rs @@ -132,23 +132,25 @@ impl MagiskInit { } } -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn main( argc: i32, argv: *mut *mut c_char, _envp: *const *const c_char, ) -> i32 { - umask(0); + unsafe { + umask(0); - let name = basename(*argv); + let name = basename(*argv); - if CStr::from_ptr(name) == c"magisk" { - return magisk_proxy_main(argc, argv); + if CStr::from_ptr(name) == c"magisk" { + return magisk_proxy_main(argc, argv); + } + + if getpid() == 1 { + MagiskInit::new(argv).start().log_ok(); + } + + 1 } - - if getpid() == 1 { - MagiskInit::new(argv).start().log_ok(); - } - - 1 } diff --git a/native/src/init/mount.rs b/native/src/init/mount.rs index 634390e2d..957bb52c8 100644 --- a/native/src/init/mount.rs +++ b/native/src/init/mount.rs @@ -13,7 +13,7 @@ use std::{ ptr::null as nullptr, }; -extern "C" { +unsafe extern "C" { static environ: *const *mut libc::c_char; } diff --git a/native/src/init/twostage.rs b/native/src/init/twostage.rs index a8482d976..766f737d3 100644 --- a/native/src/init/twostage.rs +++ b/native/src/init/twostage.rs @@ -75,7 +75,31 @@ impl MagiskInit { self.restore_ramdisk_init(); // fallback to hexpatch if /sdcard exists - if let Ok(mut map) = MappedFile::open_rw(cstr!("/init")) { + match MappedFile::open_rw(cstr!("/init")) { + Ok(mut map) => { + let from = "/system/bin/init"; + let to = "/data/magiskinit"; + + // Redirect original init to magiskinit + let v = map.patch(from.as_bytes(), to.as_bytes()); + #[allow(unused_variables)] + for off in &v { + debug!("Patch @ {:#010X} [{}] -> [{}]", off, from, to); + } + } + _ => { + error!("Failed to open /init for hexpatch"); + } + } + } + } + + pub(crate) fn redirect_second_stage(&self) { + let src = path!("/init"); + let dest = path!("/data/init"); + // Patch init binary + match MappedFile::open(src) { + Ok(mut map) => { let from = "/system/bin/init"; let to = "/data/magiskinit"; @@ -85,33 +109,18 @@ impl MagiskInit { for off in &v { debug!("Patch @ {:#010X} [{}] -> [{}]", off, from, to); } - } else { - error!("Failed to open /init for hexpatch"); + match dest.create(O_CREAT | O_WRONLY, 0) { + Ok(mut dest) => { + dest.write_all(map.as_ref()).log_ok(); + } + _ => { + error!("Failed to create {}", dest); + } + } } - } - } - - pub(crate) fn redirect_second_stage(&self) { - let src = path!("/init"); - let dest = path!("/data/init"); - // Patch init binary - if let Ok(mut map) = MappedFile::open(src) { - let from = "/system/bin/init"; - let to = "/data/magiskinit"; - - // Redirect original init to magiskinit - let v = map.patch(from.as_bytes(), to.as_bytes()); - #[allow(unused_variables)] - for off in &v { - debug!("Patch @ {:#010X} [{}] -> [{}]", off, from, to); + _ => { + error!("Failed to open {} for hexpatch", src); } - if let Ok(mut dest) = dest.create(O_CREAT | O_WRONLY, 0) { - dest.write_all(map.as_ref()).log_ok(); - } else { - error!("Failed to create {}", dest); - } - } else { - error!("Failed to open {} for hexpatch", src); } clone_attr(src, dest).log_ok(); unsafe { diff --git a/native/src/sepolicy/build.rs b/native/src/sepolicy/build.rs index 34e1f6b12..f61c6e222 100644 --- a/native/src/sepolicy/build.rs +++ b/native/src/sepolicy/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("policy-rs");