Introduce cstr_buf helper functions

native/src/base/cstr.rs

@@ -22,6 +22,8 @@ use crate::slice_from_ptr_mut;
 // Utf8CStrBufRef: reference to a fixed sized buffer
 // Utf8CStrBufArr<N>: fixed sized buffer allocated on the stack
 //
+// For easier usage, please use the helper functions in cstr_buf.
+//
 // In most cases, these are the types being used
 //
 // &Utf8CStr: whenever a printable null terminated string is needed
@@ -33,6 +35,37 @@ use crate::slice_from_ptr_mut;
 // All types dereferences to &Utf8CStr.
 // Utf8CString, Utf8CStrBufRef, and Utf8CStrBufArr<N> implements Utf8CStrBuf.
 
+// Public helper functions
+
+pub mod cstr_buf {
+    use super::{Utf8CStrBufArr, Utf8CStrBufRef, Utf8CString};
+
+    #[inline(always)]
+    pub fn with_capacity(capacity: usize) -> Utf8CString {
+        Utf8CString::with_capacity(capacity)
+    }
+
+    #[inline(always)]
+    pub fn default() -> Utf8CStrBufArr<4096> {
+        Utf8CStrBufArr::default()
+    }
+
+    #[inline(always)]
+    pub fn new<const N: usize>() -> Utf8CStrBufArr<N> {
+        Utf8CStrBufArr::new()
+    }
+
+    #[inline(always)]
+    pub fn wrap(buf: &mut [u8]) -> Utf8CStrBufRef {
+        Utf8CStrBufRef::from(buf)
+    }
+
+    #[inline(always)]
+    pub unsafe fn wrap_ptr<'a>(buf: *mut u8, len: usize) -> Utf8CStrBufRef<'a> {
+        Utf8CStrBufRef::from_ptr(buf, len)
+    }
+}
+
 // Trait definitions
 
 pub trait Utf8CStrBuf:
@@ -492,13 +525,13 @@ impl FsPathBuf<0> {
 
 impl Default for FsPathBuf<4096> {
     fn default() -> Self {
-        FsPathBuf(Utf8CStrBufOwned::Fixed(Utf8CStrBufArr::default()))
+        FsPathBuf(Utf8CStrBufOwned::Fixed(cstr_buf::default()))
     }
 }
 
 impl<const N: usize> FsPathBuf<N> {
     pub fn new() -> Self {
-        FsPathBuf(Utf8CStrBufOwned::Fixed(Utf8CStrBufArr::<N>::new()))
+        FsPathBuf(Utf8CStrBufOwned::Fixed(cstr_buf::new::<N>()))
     }
 
     pub fn clear(&mut self) {

native/src/base/cxx_extern.rs

@@ -9,12 +9,12 @@ use libc::{c_char, mode_t};
 use crate::files::map_file_at;
 pub(crate) use crate::xwrap::*;
 use crate::{
-    clone_attr, cstr, fclone_attr, fd_path, map_fd, map_file, slice_from_ptr, CxxResultExt,
+    clone_attr, cstr, cstr_buf, fclone_attr, fd_path, map_fd, map_file, slice_from_ptr,
-    Directory, FsPath, Utf8CStr, Utf8CStrBufRef,
+    CxxResultExt, Directory, FsPath, Utf8CStr,
 };
 
 pub(crate) fn fd_path_for_cxx(fd: RawFd, buf: &mut [u8]) -> isize {
-    let mut buf = Utf8CStrBufRef::from(buf);
+    let mut buf = cstr_buf::wrap(buf);
     fd_path(fd, &mut buf)
         .log_cxx_with_msg(|w| w.write_str("fd_path failed"))
         .map_or(-1_isize, |_| buf.len() as isize)
@@ -24,7 +24,7 @@ pub(crate) fn fd_path_for_cxx(fd: RawFd, buf: &mut [u8]) -> isize {
 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 = Utf8CStrBufRef::from_ptr(buf, bufsz);
+            let mut buf = cstr_buf::wrap_ptr(buf, bufsz);
             FsPath::from(p)
                 .realpath(&mut buf)
                 .map_or(-1, |_| buf.len() as isize)

native/src/base/files.rs

@@ -1,6 +1,7 @@
 use crate::cxx_extern::readlinkat_for_cxx;
 use crate::{
-    cstr, errno, error, FsPath, FsPathBuf, LibcReturn, Utf8CStr, Utf8CStrBuf, Utf8CStrBufArr,
+    cstr, cstr_buf, errno, error, FsPath, FsPathBuf, LibcReturn, Utf8CStr, Utf8CStrBuf,
+    Utf8CStrBufArr,
 };
 use bytemuck::{bytes_of, bytes_of_mut, Pod};
 use libc::{
@@ -284,13 +285,13 @@ impl DirEntry<'_> {
     }
 
     pub fn get_attr(&self) -> io::Result<FileAttr> {
-        let mut path = Utf8CStrBufArr::default();
+        let mut path = cstr_buf::default();
         self.path(&mut path)?;
         FsPath::from(&path).get_attr()
     }
 
     pub fn set_attr(&self, attr: &FileAttr) -> io::Result<()> {
-        let mut path = Utf8CStrBufArr::default();
+        let mut path = cstr_buf::default();
         self.path(&mut path)?;
         FsPath::from(&path).set_attr(attr)
     }
@@ -431,7 +432,7 @@ impl Directory {
                 std::io::copy(&mut src, &mut dest)?;
                 fd_set_attr(dest.as_raw_fd(), &attr)?;
             } else if e.is_symlink() {
-                let mut path = Utf8CStrBufArr::default();
+                let mut path = cstr_buf::default();
                 e.read_link(&mut path)?;
                 unsafe {
                     libc::symlinkat(path.as_ptr(), dir.as_raw_fd(), e.d_name.as_ptr())
@@ -645,7 +646,7 @@ impl FsPath {
         if self.is_empty() {
             return Ok(());
         }
-        let mut arr = Utf8CStrBufArr::default();
+        let mut arr = cstr_buf::default();
         arr.push_str(self);
         let mut off = 1;
         unsafe {
@@ -748,7 +749,7 @@ impl FsPath {
                 let mut dest = path.create(O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0o777)?;
                 std::io::copy(&mut src, &mut dest)?;
             } else if attr.is_symlink() {
-                let mut buf = Utf8CStrBufArr::default();
+                let mut buf = cstr_buf::default();
                 self.read_link(&mut buf)?;
                 unsafe {
                     libc::symlink(buf.as_ptr(), path.as_ptr()).as_os_err()?;

native/src/base/logging.rs

@@ -7,7 +7,7 @@ use num_derive::{FromPrimitive, ToPrimitive};
 use num_traits::FromPrimitive;
 
 use crate::ffi::LogLevelCxx;
-use crate::{Utf8CStr, Utf8CStrBufArr};
+use crate::{cstr_buf, Utf8CStr};
 
 // Ugly hack to avoid using enum
 #[allow(non_snake_case, non_upper_case_globals)]
@@ -96,7 +96,7 @@ pub fn log_from_cxx(level: LogLevelCxx, msg: &Utf8CStr) {
 
 pub fn log_with_formatter<F: FnOnce(Formatter) -> fmt::Result>(level: LogLevel, f: F) {
     log_with_writer(level, |write| {
-        let mut buf = Utf8CStrBufArr::default();
+        let mut buf = cstr_buf::default();
         f(&mut buf).ok();
         write(level, &buf);
     });

native/src/boot/cpio.rs

@@ -20,8 +20,8 @@ use base::libc::{
     S_IROTH, S_IRUSR, S_IWGRP, S_IWOTH, S_IWUSR, S_IXGRP, S_IXOTH, S_IXUSR,
 };
 use base::{
-    log_err, map_args, BytesExt, EarlyExitExt, FsPath, LoggedResult, MappedFile, ResultExt,
+    cstr_buf, log_err, map_args, BytesExt, EarlyExitExt, FsPath, LoggedResult, MappedFile,
-    Utf8CStr, Utf8CStrBuf, Utf8CStrBufArr, WriteExt,
+    ResultExt, Utf8CStr, Utf8CStrBuf, WriteExt,
 };
 
 use crate::check_env;
@@ -344,7 +344,7 @@ impl Cpio {
         let out = Utf8CStr::from_string(out);
         let out = FsPath::from(out);
 
-        let mut buf = Utf8CStrBufArr::default();
+        let mut buf = cstr_buf::default();
 
         // Make sure its parent directories exist
         if out.parent(&mut buf) {

native/src/core/logging.rs

@@ -6,8 +6,8 @@ use base::libc::{
     timespec, tm, O_CLOEXEC, O_RDWR, O_WRONLY, PIPE_BUF, SIGPIPE, SIG_BLOCK, SIG_SETMASK,
 };
 use base::{
-    const_format::concatcp, libc, raw_cstr, FsPathBuf, LogLevel, Logger, ReadExt, Utf8CStr,
+    const_format::concatcp, cstr_buf, libc, raw_cstr, FsPathBuf, LogLevel, Logger, ReadExt,
-    Utf8CStrBuf, Utf8CStrBufArr, WriteExt, LOGGER,
+    Utf8CStr, Utf8CStrBuf, WriteExt, LOGGER,
 };
 use bytemuck::{bytes_of, write_zeroes, Pod, Zeroable};
 use num_derive::{FromPrimitive, ToPrimitive};
@@ -130,7 +130,7 @@ fn write_log_to_pipe(mut logd: &File, prio: i32, msg: &Utf8CStr) -> io::Result<u
     let io2 = IoSlice::new(msg);
     let result = logd.write_vectored(&[io1, io2]);
     if let Err(ref e) = result {
-        let mut buf = Utf8CStrBufArr::default();
+        let mut buf = cstr_buf::default();
         buf.write_fmt(format_args!("Cannot write_log_to_pipe: {}", e))
             .ok();
         android_log_write(LogLevel::Error, &buf);
@@ -266,7 +266,7 @@ extern "C" fn logfile_writer(arg: *mut c_void) -> *mut c_void {
 
         let mut meta = LogMeta::zeroed();
         let mut msg_buf = [0u8; MAX_MSG_LEN];
-        let mut aux = Utf8CStrBufArr::<64>::new();
+        let mut aux = cstr_buf::new::<64>();
 
         loop {
             // Read request

native/src/core/mount.rs

@@ -8,8 +8,8 @@ use num_traits::AsPrimitive;
 
 use base::libc::{c_uint, dev_t};
 use base::{
-    cstr, debug, info, libc, parse_mount_info, raw_cstr, warn, FsPath, FsPathBuf, LibcReturn,
+    cstr, cstr_buf, debug, info, libc, parse_mount_info, raw_cstr, warn, FsPath, FsPathBuf,
-    LoggedResult, MountInfo, ResultExt, Utf8CStr, Utf8CStrBufArr,
+    LibcReturn, LoggedResult, MountInfo, ResultExt, Utf8CStr,
 };
 
 use crate::consts::{MODULEMNT, MODULEROOT, PREINITDEV, PREINITMIRR, WORKERDIR};
@@ -45,7 +45,7 @@ pub fn setup_mounts() {
                     let preinit_dir = Utf8CStr::from_string(&mut preinit_dir);
                     let r: LoggedResult<()> = try {
                         FsPath::from(preinit_dir).mkdir(0o700)?;
-                        let mut buf = Utf8CStrBufArr::default();
+                        let mut buf = cstr_buf::default();
                         if mnt_path.parent(&mut buf) {
                             FsPath::from(&buf).mkdirs(0o755)?;
                         }
@@ -217,7 +217,7 @@ pub fn find_preinit_device() -> String {
         let preinit_dir = FsPath::from(Utf8CStr::from_string(&mut preinit_dir));
         let _: LoggedResult<()> = try {
             preinit_dir.mkdirs(0o700)?;
-            let mut buf = Utf8CStrBufArr::default();
+            let mut buf = cstr_buf::default();
             if mirror_dir.parent(&mut buf) {
                 FsPath::from(&buf).mkdirs(0o755)?;
             }

native/src/core/package.rs

@@ -4,8 +4,8 @@ use crate::ffi::{get_magisk_tmp, install_apk, uninstall_pkg, DbEntryKey};
 use base::libc::{O_CLOEXEC, O_CREAT, O_RDONLY, O_TRUNC, O_WRONLY};
 use base::WalkResult::{Abort, Continue, Skip};
 use base::{
-    cstr, error, fd_get_attr, open_fd, warn, BufReadExt, Directory, FsPath, FsPathBuf,
+    cstr, cstr_buf, error, fd_get_attr, open_fd, warn, BufReadExt, Directory, FsPath, FsPathBuf,
-    LoggedResult, ReadExt, ResultExt, Utf8CStrBuf, Utf8CStrBufArr,
+    LoggedResult, ReadExt, ResultExt, Utf8CStrBuf,
 };
 use bit_set::BitSet;
 use cxx::CxxString;
@@ -273,7 +273,7 @@ impl ManagerInfo {
     }
 
     fn check_stub(&mut self, user: i32, pkg: &str) -> Status {
-        let mut arr = Utf8CStrBufArr::default();
+        let mut arr = cstr_buf::default();
         if find_apk_path(pkg, &mut arr).is_err() {
             return Status::NotInstalled;
         }
@@ -298,7 +298,7 @@ impl ManagerInfo {
     }
 
     fn check_orig(&mut self, user: i32) -> Status {
-        let mut arr = Utf8CStrBufArr::default();
+        let mut arr = cstr_buf::default();
         if find_apk_path(APP_PACKAGE_NAME, &mut arr).is_err() {
             return Status::NotInstalled;
         }

native/src/core/zygisk/daemon.rs

@@ -6,8 +6,8 @@ use crate::ffi::{
 use crate::socket::{IpcRead, UnixSocketExt};
 use base::libc::{O_CLOEXEC, O_CREAT, O_RDONLY, STDOUT_FILENO};
 use base::{
-    cstr, error, fork_dont_care, libc, open_fd, raw_cstr, warn, Directory, FsPathBuf, LoggedError,
+    cstr, cstr_buf, error, fork_dont_care, libc, open_fd, raw_cstr, warn, Directory, FsPathBuf,
-    LoggedResult, ResultExt, Utf8CStrBufArr, WriteExt,
+    LoggedError, LoggedResult, ResultExt, WriteExt,
 };
 use std::fmt::Write;
 use std::os::fd::{AsRawFd, FromRawFd, RawFd};
@@ -39,7 +39,7 @@ fn exec_zygiskd(is_64_bit: bool, remote: UnixStream) {
 
     let exe = FsPathBuf::<64>::new().join(get_magisk_tmp()).join(magisk);
 
-    let mut fd_str = Utf8CStrBufArr::<16>::new();
+    let mut fd_str = cstr_buf::new::<16>();
     write!(fd_str, "{}", remote.as_raw_fd()).ok();
     unsafe {
         libc::execl(

native/src/init/rootdir.rs

@@ -1,8 +1,8 @@
 use crate::ffi::MagiskInit;
 use base::libc::O_RDONLY;
 use base::{
-    debug, libc, path, BufReadExt, Directory, LibcReturn, LoggedResult, ResultExt, Utf8CStr,
+    cstr_buf, debug, libc, path, BufReadExt, Directory, LibcReturn, LoggedResult, ResultExt,
-    Utf8CStrBuf, Utf8CStrBufArr, WalkResult,
+    Utf8CStr, Utf8CStrBuf, Utf8CStrBufArr, WalkResult,
 };
 use std::io::BufReader;
 use std::{
@@ -48,8 +48,8 @@ pub fn collect_overlay_contexts(src: &Utf8CStr) {
     OVERLAY_ATTRS
         .get_or_try_init(|| -> LoggedResult<_> {
             let mut contexts = vec![];
-            let mut con = Utf8CStrBufArr::default();
+            let mut con = cstr_buf::default();
-            let mut path = Utf8CStrBufArr::default();
+            let mut path = cstr_buf::default();
             let mut src = Directory::open(src)?;
             src.path(&mut path)?;
             let src_len = path.len();