Magisk/native/src/base/misc.rs

135 lines
3.2 KiB
Rust
Raw Normal View History

use std::fmt::Arguments;
use std::io::Write;
2023-07-03 21:57:28 -07:00
use std::process::exit;
use std::{fmt, io, slice, str};
2022-07-05 21:13:09 -07:00
2023-07-03 21:57:28 -07:00
use argh::EarlyExit;
use libc::c_char;
use crate::{ffi, StrErr, Utf8CStr};
2022-08-08 22:53:37 -07:00
pub fn errno() -> &'static mut i32 {
2022-08-15 11:53:51 -07:00
unsafe { &mut *libc::__errno() }
2022-08-08 22:53:37 -07:00
}
// 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)
}
}
// 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)
}
}
2023-05-09 18:54:38 -07:00
2023-06-23 01:50:33 -07:00
// Check libc return value and map to Result
pub trait LibcReturn
where
Self: Copy,
{
fn is_error(&self) -> bool;
fn check_os_err(self) -> io::Result<Self> {
if self.is_error() {
2023-06-23 01:50:33 -07:00
Err(io::Error::last_os_error())
} else {
Ok(self)
}
}
fn as_os_err(self) -> io::Result<()> {
self.check_os_err()?;
Ok(())
}
}
2023-06-23 01:50:33 -07:00
macro_rules! impl_libc_return {
($($t:ty)*) => ($(
impl LibcReturn for $t {
#[inline]
fn is_error(&self) -> bool {
*self < 0
}
}
)*)
}
2023-06-23 01:50:33 -07:00
impl_libc_return! { i8 i16 i32 i64 isize }
impl<T> LibcReturn for *const T {
2023-06-23 01:50:33 -07:00
#[inline]
fn is_error(&self) -> bool {
self.is_null()
}
}
impl<T> LibcReturn for *mut T {
2023-06-23 01:50:33 -07:00
#[inline]
fn is_error(&self) -> bool {
self.is_null()
}
}
2023-06-20 18:17:26 -07:00
pub trait MutBytesExt {
fn patch(&mut self, from: &[u8], to: &[u8]) -> Vec<usize>;
}
impl<T: AsMut<[u8]>> MutBytesExt for T {
fn patch(&mut self, from: &[u8], to: &[u8]) -> Vec<usize> {
ffi::mut_u8_patch(self.as_mut(), from, to)
}
}
2023-07-03 21:57:28 -07:00
// SAFETY: libc guarantees argc and argv are properly setup and are static
2023-07-03 21:57:28 -07:00
#[allow(clippy::not_unsafe_ptr_arg_deref)]
pub fn map_args(argc: i32, argv: *const *const c_char) -> Result<Vec<&'static str>, StrErr> {
2023-07-03 21:57:28 -07:00
unsafe { slice::from_raw_parts(argv, argc as usize) }
.iter()
.map(|s| unsafe { Utf8CStr::from_ptr(*s) }.map(|s| s.as_str()))
2023-07-03 21:57:28 -07:00
.collect()
}
pub trait EarlyExitExt<T> {
fn on_early_exit<F: FnOnce()>(self, print_help_msg: F) -> T;
2023-07-03 21:57:28 -07:00
}
impl<T> EarlyExitExt<T> for Result<T, EarlyExit> {
fn on_early_exit<F: FnOnce()>(self, print_help_msg: F) -> T {
2023-07-03 21:57:28 -07:00
match self {
Ok(t) => t,
Err(EarlyExit { output, status }) => match status {
Ok(_) => {
print_help_msg();
2023-07-03 21:57:28 -07:00
exit(0)
}
Err(_) => {
eprintln!("{}", output);
print_help_msg();
2023-07-03 21:57:28 -07:00
exit(1)
}
},
}
}
}
pub struct FmtAdaptor<'a, T>(pub &'a mut T)
where
T: Write;
impl<T: Write> fmt::Write for FmtAdaptor<'_, T> {
fn write_str(&mut self, s: &str) -> fmt::Result {
self.0.write_all(s.as_bytes()).map_err(|_| fmt::Error)
}
fn write_fmt(&mut self, args: Arguments<'_>) -> fmt::Result {
self.0.write_fmt(args).map_err(|_| fmt::Error)
}
}