From b861671391b5aad7455fb49b0a05ebf4f1c8486b Mon Sep 17 00:00:00 2001 From: topjohnwu Date: Sun, 24 Aug 2025 21:31:53 -0700 Subject: [PATCH] Cleanup libbase --- native/src/base/cxx_extern.rs | 9 +-- native/src/base/files.cpp | 20 ++---- native/src/base/files.hpp | 22 +------ native/src/base/include/base.hpp | 5 +- native/src/base/lib.rs | 2 - native/src/base/misc.cpp | 25 +++----- native/src/base/misc.hpp | 105 +++++++++---------------------- native/src/base/xwrap.hpp | 2 - native/src/base/xwrap.rs | 24 +------ native/src/boot/bootimg.cpp | 100 ++++++++++++++--------------- native/src/boot/bootimg.hpp | 13 +++- native/src/core/su/su.cpp | 2 +- native/src/init/rootdir.cpp | 7 +-- native/src/sepolicy/policydb.cpp | 2 +- 14 files changed, 117 insertions(+), 221 deletions(-) diff --git a/native/src/base/cxx_extern.rs b/native/src/base/cxx_extern.rs index e39a35348..4e469bd4d 100644 --- a/native/src/base/cxx_extern.rs +++ b/native/src/base/cxx_extern.rs @@ -14,16 +14,9 @@ use crate::files::map_file_at; pub(crate) use crate::xwrap::*; use crate::{ BufReadExt, CxxResultExt, Directory, OsResultStatic, Utf8CStr, clone_attr, cstr, fclone_attr, - fd_path, map_fd, map_file, slice_from_ptr, + map_fd, map_file, slice_from_ptr, }; -pub(crate) fn fd_path_for_cxx(fd: RawFd, buf: &mut [u8]) -> isize { - let mut buf = cstr::buf::wrap(buf); - fd_path(fd, &mut buf) - .log_cxx() - .map_or(-1_isize, |_| buf.len() as isize) -} - #[unsafe(no_mangle)] unsafe extern "C" fn canonical_path(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize { unsafe { diff --git a/native/src/base/files.cpp b/native/src/base/files.cpp index fc948dbe2..585232f2c 100644 --- a/native/src/base/files.cpp +++ b/native/src/base/files.cpp @@ -8,28 +8,20 @@ using namespace std; -void full_read(int fd, string &str) { +string full_read(int fd) { + string str; char buf[4096]; for (ssize_t len; (len = xread(fd, buf, sizeof(buf))) > 0;) str.insert(str.end(), buf, buf + len); -} - -void full_read(const char *filename, string &str) { - if (int fd = xopen(filename, O_RDONLY | O_CLOEXEC); fd >= 0) { - full_read(fd, str); - close(fd); - } -} - -string full_read(int fd) { - string str; - full_read(fd, str); return str; } string full_read(const char *filename) { string str; - full_read(filename, str); + if (int fd = xopen(filename, O_RDONLY | O_CLOEXEC); fd >= 0) { + str = full_read(fd); + close(fd); + } return str; } diff --git a/native/src/base/files.hpp b/native/src/base/files.hpp index 35c5689bc..59f04ecaa 100644 --- a/native/src/base/files.hpp +++ b/native/src/base/files.hpp @@ -1,24 +1,12 @@ #pragma once #include +#include #include #include #include -#include -#include -#include "misc.hpp" - -template -static inline T align_to(T v, int a) { - static_assert(std::is_integral::value); - return (v + a - 1) / a * a; -} - -template -static inline T align_padding(T v, int a) { - return align_to(v, a) - v; -} +#include "base-rs.hpp" struct mmap_data : public byte_data { static_assert((sizeof(void *) == 8 && BLKGETSIZE64 == 0x80081272) || @@ -45,12 +33,6 @@ bool fclone_attr(int src, int dest); } // extern "C" -static inline ssize_t realpath( - const char * __restrict__ path, char * __restrict__ buf, size_t bufsiz) { - return canonical_path(path, buf, bufsiz); -} -void full_read(int fd, std::string &str); -void full_read(const char *filename, std::string &str); std::string full_read(int fd); std::string full_read(const char *filename); void write_zero(int fd, size_t size); diff --git a/native/src/base/include/base.hpp b/native/src/base/include/base.hpp index c2888fd76..649676c99 100644 --- a/native/src/base/include/base.hpp +++ b/native/src/base/include/base.hpp @@ -1,11 +1,10 @@ #pragma once #include "../xwrap.hpp" -#include "../files.hpp" #include "../misc.hpp" -#include "../logging.hpp" #include "../base-rs.hpp" +#include "../files.hpp" +#include "../logging.hpp" using rust::xpipe2; -using rust::fd_path; using kv_pairs = std::vector>; diff --git a/native/src/base/lib.rs b/native/src/base/lib.rs index 62f70d2bd..5eb0ea95a 100644 --- a/native/src/base/lib.rs +++ b/native/src/base/lib.rs @@ -69,8 +69,6 @@ pub mod ffi { #[namespace = "rust"] extern "Rust" { fn xpipe2(fds: &mut [i32; 2], flags: i32) -> i32; - #[cxx_name = "fd_path"] - fn fd_path_for_cxx(fd: i32, buf: &mut [u8]) -> isize; #[cxx_name = "map_file"] fn map_file_for_cxx(path: Utf8CStrRef, rw: bool) -> &'static mut [u8]; #[cxx_name = "map_file_at"] diff --git a/native/src/base/misc.cpp b/native/src/base/misc.cpp index 39fc53657..5f44890d9 100644 --- a/native/src/base/misc.cpp +++ b/native/src/base/misc.cpp @@ -15,14 +15,8 @@ bool byte_view::contains(byte_view pattern) const { return _buf != nullptr && memmem(_buf, _sz, pattern._buf, pattern._sz) != nullptr; } -bool byte_view::equals(byte_view o) const { - return _sz == o._sz && memcmp(_buf, o._buf, _sz) == 0; -} - -heap_data byte_view::clone() const { - heap_data copy(_sz); - memcpy(copy._buf, _buf, _sz); - return copy; +bool byte_view::operator==(byte_view rhs) const { + return _sz == rhs._sz && memcmp(_buf, rhs._buf, _sz) == 0; } void byte_data::swap(byte_data &o) { @@ -30,28 +24,25 @@ void byte_data::swap(byte_data &o) { std::swap(_sz, o._sz); } -rust::Vec byte_data::patch(byte_view from, byte_view to) { +rust::Vec byte_data::patch(byte_view from, byte_view to) const { rust::Vec v; if (_buf == nullptr) return v; auto p = _buf; auto eof = _buf + _sz; while (p < eof) { - p = static_cast(memmem(p, eof - p, from.buf(), from.sz())); + p = static_cast(memmem(p, eof - p, from.data(), from.size())); if (p == nullptr) return v; - memset(p, 0, from.sz()); - memcpy(p, to.buf(), to.sz()); + memset(p, 0, from.size()); + memcpy(p, to.data(), to.size()); v.push_back(p - _buf); - p += from.sz(); + p += from.size(); } return v; } -rust::Vec mut_u8_patch( - rust::Slice buf, - rust::Slice from, - rust::Slice to) { +rust::Vec mut_u8_patch(MutByteSlice buf, ByteSlice from, ByteSlice to) { byte_data data(buf); return data.patch(from, to); } diff --git a/native/src/base/misc.hpp b/native/src/base/misc.hpp index 501eb0317..52896745e 100644 --- a/native/src/base/misc.hpp +++ b/native/src/base/misc.hpp @@ -5,7 +5,6 @@ #include #include #include -#include #include #include "xwrap.hpp" @@ -46,30 +45,11 @@ private: Func fn; }; -template -class reversed_container { -public: - reversed_container(T &base) : base(base) {} - decltype(std::declval().rbegin()) begin() { return base.rbegin(); } - decltype(std::declval().crbegin()) begin() const { return base.crbegin(); } - decltype(std::declval().crbegin()) cbegin() const { return base.crbegin(); } - decltype(std::declval().rend()) end() { return base.rend(); } - decltype(std::declval().crend()) end() const { return base.crend(); } - decltype(std::declval().crend()) cend() const { return base.crend(); } -private: - T &base; -}; - -template -reversed_container reversed(T &base) { - return reversed_container(base); -} +template +static void default_new(T *&p) { p = new T(); } template -static inline void default_new(T *&p) { p = new T(); } - -template -static inline void default_new(std::unique_ptr &p) { p.reset(new T()); } +static void default_new(std::unique_ptr &p) { p.reset(new T()); } struct StringCmp { using is_transparent = void; @@ -78,49 +58,32 @@ struct StringCmp { struct heap_data; +using ByteSlice = rust::Slice; +using MutByteSlice = rust::Slice; + // Interchangeable as `&[u8]` in Rust struct byte_view { byte_view() : _buf(nullptr), _sz(0) {} byte_view(const void *buf, size_t sz) : _buf((uint8_t *) buf), _sz(sz) {} - // byte_view, or any of its subclass, can be copied as byte_view + // byte_view, or any of its subclasses, can be copied as byte_view byte_view(const byte_view &o) : _buf(o._buf), _sz(o._sz) {} - // Bridging to Rust slice - byte_view(rust::Slice o) : byte_view(o.data(), o.size()) {} - operator rust::Slice() const { return rust::Slice(_buf, _sz); } + // Transparent conversion to Rust slice + byte_view(const ByteSlice o) : byte_view(o.data(), o.size()) {} + operator ByteSlice() const { return {_buf, _sz}; } - // String as bytes - byte_view(const char *s, bool with_nul = true) - : byte_view(std::string_view(s), with_nul, false) {} - byte_view(const std::string &s, bool with_nul = true) - : byte_view(std::string_view(s), with_nul, false) {} - byte_view(std::string_view s, bool with_nul = true) - : byte_view(s, with_nul, true /* string_view is not guaranteed to null terminate */ ) {} - - // Vector as bytes - byte_view(const std::vector &v) : byte_view(v.data(), v.size()) {} - - const uint8_t *buf() const { return _buf; } - size_t sz() const { return _sz; } + // String as bytes, including null terminator + byte_view(const char *s) : byte_view(s, strlen(s) + 1) {} + const uint8_t *data() const { return _buf; } + size_t size() const { return _sz; } bool contains(byte_view pattern) const; - bool equals(byte_view o) const; - heap_data clone() const; + bool operator==(byte_view rhs) const; protected: uint8_t *_buf; size_t _sz; - -private: - byte_view(std::string_view s, bool with_nul, bool check_nul) - : byte_view(static_cast(s.data()), s.length()) { - if (with_nul) { - if (check_nul && s[s.length()] != '\0') - return; - ++_sz; - } - } }; // Interchangeable as `&mut [u8]` in Rust @@ -128,23 +91,18 @@ struct byte_data : public byte_view { byte_data() = default; byte_data(void *buf, size_t sz) : byte_view(buf, sz) {} - // byte_data, or any of its subclass, can be copied as byte_data + // byte_data, or any of its subclasses, can be copied as byte_data byte_data(const byte_data &o) : byte_data(o._buf, o._sz) {} - // Transparent conversion from common C++ types to mutable byte references - byte_data(std::string &s, bool with_nul = true) - : byte_data(s.data(), with_nul ? s.length() + 1 : s.length()) {} - byte_data(std::vector &v) : byte_data(v.data(), v.size()) {} + // Transparent conversion to Rust slice + byte_data(const MutByteSlice o) : byte_data(o.data(), o.size()) {} + operator MutByteSlice() const { return {_buf, _sz}; } - // Bridging to Rust slice - byte_data(rust::Slice o) : byte_data(o.data(), o.size()) {} - operator rust::Slice() { return rust::Slice(_buf, _sz); } - - using byte_view::buf; - uint8_t *buf() { return _buf; } + using byte_view::data; + uint8_t *data() const { return _buf; } void swap(byte_data &o); - rust::Vec patch(byte_view from, byte_view to); + rust::Vec patch(byte_view from, byte_view to) const; }; struct heap_data : public byte_data { @@ -170,10 +128,7 @@ private: int fd; }; -rust::Vec mut_u8_patch( - rust::Slice buf, - rust::Slice from, - rust::Slice to); +rust::Vec mut_u8_patch(MutByteSlice buf, ByteSlice from, ByteSlice to); uint32_t parse_uint32_hex(std::string_view s); int parse_int(std::string_view s); @@ -276,9 +231,7 @@ struct Utf8CStr { Utf8CStr() : Utf8CStr("", 1) {}; Utf8CStr(const Utf8CStr &o) = default; - Utf8CStr(Utf8CStr &&o) = default; Utf8CStr(const char *s) : Utf8CStr(s, strlen(s) + 1) {}; - Utf8CStr(std::string_view s) : Utf8CStr(s.data(), s.length() + 1) {}; Utf8CStr(std::string s) : Utf8CStr(s.data(), s.length() + 1) {}; const char *c_str() const { return this->data(); } size_t size() const { return this->length(); } @@ -296,15 +249,17 @@ private: } // namespace rust // Bindings for std::function to be callable from Rust -struct FnBoolStrStr : public std::function { - using std::function::function; + +using CxxFnBoolStrStr = std::function; +struct FnBoolStrStr : public CxxFnBoolStrStr { + using CxxFnBoolStrStr::function; bool call(rust::Str a, rust::Str b) const { return operator()(a, b); } }; - -struct FnBoolString : public std::function { - using std::function::function; +using CxxFnBoolString = std::function; +struct FnBoolString : public CxxFnBoolString { + using CxxFnBoolString::function; bool call(rust::String &s) const { return operator()(s); } diff --git a/native/src/base/xwrap.hpp b/native/src/base/xwrap.hpp index 5de6053d2..4e8ff28fb 100644 --- a/native/src/base/xwrap.hpp +++ b/native/src/base/xwrap.hpp @@ -27,7 +27,6 @@ int xlisten(int sockfd, int backlog); int xaccept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags); int xstat(const char *pathname, struct stat *buf); int xfstat(int fd, struct stat *buf); -int xdup(int fd); int xdup2(int oldfd, int newfd); ssize_t xreadlink(const char * __restrict__ pathname, char * __restrict__ buf, size_t bufsiz); ssize_t xreadlinkat( @@ -42,7 +41,6 @@ int xmkdir(const char *pathname, mode_t mode); int xmkdirs(const char *pathname, mode_t mode); ssize_t xsendfile(int out_fd, int in_fd, off_t *offset, size_t count); pid_t xfork(); -int xpoll(pollfd *fds, nfds_t nfds, int timeout); ssize_t xrealpath(const char * __restrict__ path, char * __restrict__ buf, size_t bufsiz); int xmknod(const char * pathname, mode_t mode, dev_t dev); diff --git a/native/src/base/xwrap.rs b/native/src/base/xwrap.rs index 273fd4ce6..89d7bbaa3 100644 --- a/native/src/base/xwrap.rs +++ b/native/src/base/xwrap.rs @@ -4,9 +4,7 @@ use crate::cxx_extern::readlinkat; use crate::{ BorrowedDirectory, CxxResultExt, LibcReturn, Utf8CStr, cstr, slice_from_ptr, slice_from_ptr_mut, }; -use libc::{ - c_char, c_uint, c_ulong, c_void, dev_t, mode_t, nfds_t, off_t, pollfd, sockaddr, socklen_t, -}; +use libc::{c_char, c_uint, c_ulong, c_void, dev_t, mode_t, off_t, sockaddr, socklen_t}; use std::ffi::CStr; use std::fs::File; use std::io::{Read, Write}; @@ -270,16 +268,6 @@ unsafe extern "C" fn xfstat(fd: RawFd, buf: *mut libc::stat) -> i32 { } } -#[unsafe(no_mangle)] -extern "C" fn xdup(oldfd: RawFd) -> RawFd { - unsafe { - libc::dup(oldfd) - .as_os_result("dup", None, None) - .log_cxx() - .unwrap_or(-1) - } -} - #[unsafe(no_mangle)] extern "C" fn xdup2(oldfd: RawFd, newfd: RawFd) -> RawFd { unsafe { @@ -381,16 +369,6 @@ extern "C" fn xfork() -> i32 { } } -#[unsafe(no_mangle)] -unsafe extern "C" fn xpoll(fds: *mut pollfd, nfds: nfds_t, timeout: i32) -> i32 { - unsafe { - libc::poll(fds, nfds, timeout) - .as_os_result("poll", None, None) - .log_cxx() - .unwrap_or(-1) - } -} - #[unsafe(no_mangle)] unsafe extern "C" fn xmknod(pathname: *const c_char, mode: mode_t, dev: dev_t) -> i32 { unsafe { diff --git a/native/src/boot/bootimg.cpp b/native/src/boot/bootimg.cpp index 6ee91e6bb..07da2947f 100644 --- a/native/src/boot/bootimg.cpp +++ b/native/src/boot/bootimg.cpp @@ -189,8 +189,8 @@ void dyn_img_hdr::load_hdr_file() { boot_img::boot_img(const char *image) : map(image), k_fmt(FileFormat::UNKNOWN), r_fmt(FileFormat::UNKNOWN), e_fmt(FileFormat::UNKNOWN) { fprintf(stderr, "Parsing boot image: [%s]\n", image); - for (const uint8_t *addr = map.buf(); addr < map.buf() + map.sz(); ++addr) { - FileFormat fmt = check_fmt(addr, map.sz()); + for (const uint8_t *addr = map.data(); addr < map.data() + map.size(); ++addr) { + FileFormat fmt = check_fmt(addr, map.size()); switch (fmt) { case FileFormat::CHROMEOS: // chromeos require external signing @@ -367,9 +367,9 @@ pair boot_img::create_hdr(const uint8_t *addr, F auto real_hdr_sz = h->page_size - AMONET_MICROLOADER_SZ; heap_data copy(h->page_size); - memcpy(copy.buf(), h, real_hdr_sz); + memcpy(copy.data(), h, real_hdr_sz); - return make_pair(addr, make_hdr(copy.buf())); + return make_pair(addr, make_hdr(copy.data())); } if (CMD_MATCH(NOOKHD_RL_MAGIC) || @@ -404,7 +404,7 @@ static const char *vendor_ramdisk_type(int type) { } #define assert_off() \ -if ((base_addr + off) > (map.buf() + map_end)) { \ +if ((base_addr + off) > (map.data() + map_end)) { \ fprintf(stderr, "Corrupted boot image!\n"); \ return false; \ } @@ -433,7 +433,7 @@ bool boot_img::parse_image(const uint8_t *p, FileFormat type) { hdr->print(); - size_t map_end = align_to(map.sz(), getpagesize()); + size_t map_end = align_to(map.size(), getpagesize()); size_t off = hdr->hdr_space(); get_block(kernel); get_block(ramdisk); @@ -447,13 +447,13 @@ bool boot_img::parse_image(const uint8_t *p, FileFormat type) { payload = byte_view(base_addr, off); auto tail_addr = base_addr + off; - tail = byte_view(tail_addr, map.buf() + map_end - tail_addr); + tail = byte_view(tail_addr, map.data() + map_end - tail_addr); if (auto size = hdr->kernel_size()) { if (int dtb_off = find_dtb_offset(kernel, size); dtb_off > 0) { kernel_dtb = byte_view(kernel + dtb_off, size - dtb_off); hdr->kernel_size() = dtb_off; - fprintf(stderr, "%-*s [%zu]\n", PADDING, "KERNEL_DTB_SZ", kernel_dtb.sz()); + fprintf(stderr, "%-*s [%zu]\n", PADDING, "KERNEL_DTB_SZ", kernel_dtb.size()); } k_fmt = check_fmt_lg(kernel, hdr->kernel_size()); @@ -552,12 +552,12 @@ bool boot_img::parse_image(const uint8_t *p, FileFormat type) { fprintf(stderr, "%-*s [%s]\n", PADDING, "EXTRA_FMT", fmt2name(e_fmt)); } - if (tail.sz()) { + if (tail.size()) { // Check special flags - if (tail.sz() >= 16 && BUFFER_MATCH(tail.buf(), SEANDROID_MAGIC)) { + if (tail.size() >= 16 && BUFFER_MATCH(tail.data(), SEANDROID_MAGIC)) { fprintf(stderr, "SAMSUNG_SEANDROID\n"); flags[SEANDROID_FLAG] = true; - } else if (tail.sz() >= 16 && BUFFER_MATCH(tail.buf(), LG_BUMP_MAGIC)) { + } else if (tail.size() >= 16 && BUFFER_MATCH(tail.data(), LG_BUMP_MAGIC)) { fprintf(stderr, "LG_BUMP_IMAGE\n"); flags[LG_BUMP_FLAG] = true; } else if (verify()) { @@ -566,7 +566,7 @@ bool boot_img::parse_image(const uint8_t *p, FileFormat type) { } // Find AVB footer - const void *footer = tail.buf() + tail.sz() - sizeof(AvbFooter); + const void *footer = tail.data() + tail.size() - sizeof(AvbFooter); if (BUFFER_MATCH(footer, AVB_FOOTER_MAGIC)) { avb_footer = static_cast(footer); // Double check if meta header exists @@ -586,16 +586,16 @@ bool boot_img::parse_image(const uint8_t *p, FileFormat type) { int split_image_dtb(rust::Utf8CStr filename, bool skip_decomp) { mmap_data img(filename.data()); - if (size_t off = find_dtb_offset(img.buf(), img.sz()); off > 0) { - FileFormat fmt = check_fmt_lg(img.buf(), img.sz()); + if (size_t off = find_dtb_offset(img.data(), img.size()); off > 0) { + FileFormat fmt = check_fmt_lg(img.data(), img.size()); if (!skip_decomp && fmt_compressed(fmt)) { int fd = creat(KERNEL_FILE, 0644); - decompress(fmt, fd, img.buf(), off); + decompress(fmt, fd, img.data(), off); close(fd); } else { - dump(img.buf(), off, KERNEL_FILE); + dump(img.data(), off, KERNEL_FILE); } - dump(img.buf() + off, img.sz() - off, KER_DTB_FILE); + dump(img.data() + off, img.size() - off, KER_DTB_FILE); return 0; } else { fprintf(stderr, "Cannot find DTB in %s\n", filename.data()); @@ -621,7 +621,7 @@ int unpack(rust::Utf8CStr image, bool skip_decomp, bool hdr) { } // Dump kernel_dtb - dump(boot.kernel_dtb.buf(), boot.kernel_dtb.sz(), KER_DTB_FILE); + dump(boot.kernel_dtb.data(), boot.kernel_dtb.size(), KER_DTB_FILE); // Dump ramdisk if (boot.hdr->vendor_ramdisk_table_size()) { @@ -725,16 +725,16 @@ void repack(rust::Utf8CStr src_img, rust::Utf8CStr out_img, bool skip_comp) { // Skip DHTB header write_zero(fd, sizeof(dhtb_hdr)); } else if (boot.flags[BLOB_FLAG]) { - xwrite(fd, boot.map.buf(), sizeof(blob_hdr)); + xwrite(fd, boot.map.data(), sizeof(blob_hdr)); } else if (boot.flags[NOOKHD_FLAG]) { - xwrite(fd, boot.map.buf(), NOOKHD_PRE_HEADER_SZ); + xwrite(fd, boot.map.data(), NOOKHD_PRE_HEADER_SZ); } else if (boot.flags[ACCLAIM_FLAG]) { - xwrite(fd, boot.map.buf(), ACCLAIM_PRE_HEADER_SZ); + xwrite(fd, boot.map.data(), ACCLAIM_PRE_HEADER_SZ); } // Copy raw header off.header = lseek(fd, 0, SEEK_CUR); - xwrite(fd, boot.payload.buf(), hdr->hdr_space()); + xwrite(fd, boot.payload.data(), hdr->hdr_space()); // kernel off.kernel = lseek(fd, 0, SEEK_CUR); @@ -748,12 +748,12 @@ void repack(rust::Utf8CStr src_img, rust::Utf8CStr out_img, bool skip_comp) { } if (access(KERNEL_FILE, R_OK) == 0) { mmap_data m(KERNEL_FILE); - if (!skip_comp && !fmt_compressed_any(check_fmt(m.buf(), m.sz())) && fmt_compressed(boot.k_fmt)) { + if (!skip_comp && !fmt_compressed_any(check_fmt(m.data(), m.size())) && fmt_compressed(boot.k_fmt)) { // Always use zopfli for zImage compression auto fmt = (boot.flags[ZIMAGE_KERNEL] && boot.k_fmt == FileFormat::GZIP) ? FileFormat::ZOPFLI : boot.k_fmt; hdr->kernel_size() = compress_len(fmt, m, fd); } else { - hdr->kernel_size() = xwrite(fd, m.buf(), m.sz()); + hdr->kernel_size() = xwrite(fd, m.data(), m.size()); } if (boot.flags[ZIMAGE_KERNEL]) { @@ -764,7 +764,7 @@ void repack(rust::Utf8CStr src_img, rust::Utf8CStr out_img, bool skip_comp) { } else if (!skip_comp) { // Pad zeros to make sure the zImage file size does not change // Also ensure the last 4 bytes are the uncompressed vmlinux size - uint32_t sz = m.sz(); + uint32_t sz = m.size(); write_zero(fd, boot.hdr->kernel_size() - hdr->kernel_size() - sizeof(sz)); xwrite(fd, &sz, sizeof(sz)); } @@ -779,7 +779,7 @@ void repack(rust::Utf8CStr src_img, rust::Utf8CStr out_img, bool skip_comp) { if (boot.flags[ZIMAGE_KERNEL]) { // Copy zImage tail and adjust size accordingly hdr->kernel_size() += boot.z_info.hdr_sz; - hdr->kernel_size() += xwrite(fd, boot.z_info.tail.buf(), boot.z_info.tail.sz()); + hdr->kernel_size() += xwrite(fd, boot.z_info.tail.data(), boot.z_info.tail.size()); } // kernel dtb @@ -816,10 +816,10 @@ void repack(rust::Utf8CStr src_img, rust::Utf8CStr out_img, bool skip_comp) { mmap_data m(dirfd, file_name); FileFormat fmt = check_fmt_lg(boot.ramdisk + it.ramdisk_offset, it.ramdisk_size); it.ramdisk_offset = ramdisk_offset; - if (!skip_comp && !fmt_compressed_any(check_fmt(m.buf(), m.sz())) && fmt_compressed(fmt)) { + if (!skip_comp && !fmt_compressed_any(check_fmt(m.data(), m.size())) && fmt_compressed(fmt)) { it.ramdisk_size = compress_len(fmt, m, fd); } else { - it.ramdisk_size = xwrite(fd, m.buf(), m.sz()); + it.ramdisk_size = xwrite(fd, m.data(), m.size()); } ramdisk_offset += it.ramdisk_size; } @@ -836,10 +836,10 @@ void repack(rust::Utf8CStr src_img, rust::Utf8CStr out_img, bool skip_comp) { fprintf(stderr, "RAMDISK_FMT: [%s] -> [%s]\n", fmt2name(r_fmt), fmt2name(FileFormat::LZ4_LEGACY)); r_fmt = FileFormat::LZ4_LEGACY; } - if (!skip_comp && !fmt_compressed_any(check_fmt(m.buf(), m.sz())) && fmt_compressed(r_fmt)) { + if (!skip_comp && !fmt_compressed_any(check_fmt(m.data(), m.size())) && fmt_compressed(r_fmt)) { hdr->ramdisk_size() = compress_len(r_fmt, m, fd); } else { - hdr->ramdisk_size() = xwrite(fd, m.buf(), m.sz()); + hdr->ramdisk_size() = xwrite(fd, m.data(), m.size()); } file_align(); } @@ -855,10 +855,10 @@ void repack(rust::Utf8CStr src_img, rust::Utf8CStr out_img, bool skip_comp) { off.extra = lseek(fd, 0, SEEK_CUR); if (access(EXTRA_FILE, R_OK) == 0) { mmap_data m(EXTRA_FILE); - if (!skip_comp && !fmt_compressed_any(check_fmt(m.buf(), m.sz())) && fmt_compressed(boot.e_fmt)) { + if (!skip_comp && !fmt_compressed_any(check_fmt(m.data(), m.size())) && fmt_compressed(boot.e_fmt)) { hdr->extra_size() = compress_len(boot.e_fmt, m, fd); } else { - hdr->extra_size() = xwrite(fd, m.buf(), m.sz()); + hdr->extra_size() = xwrite(fd, m.data(), m.size()); } file_align(); } @@ -921,8 +921,8 @@ void repack(rust::Utf8CStr src_img, rust::Utf8CStr out_img, bool skip_comp) { // Pad image to original size if not chromeos (as it requires post processing) if (!boot.flags[CHROMEOS_FLAG]) { off_t current = lseek(fd, 0, SEEK_CUR); - if (current < boot.map.sz()) { - write_zero(fd, boot.map.sz() - current); + if (current < boot.map.size()) { + write_zero(fd, boot.map.size() - current); } } @@ -935,12 +935,12 @@ void repack(rust::Utf8CStr src_img, rust::Utf8CStr out_img, bool skip_comp) { // MTK headers if (boot.flags[MTK_KERNEL]) { - auto m_hdr = reinterpret_cast(out.buf() + off.kernel); + auto m_hdr = reinterpret_cast(out.data() + off.kernel); m_hdr->size = hdr->kernel_size(); hdr->kernel_size() += sizeof(mtk_hdr); } if (boot.flags[MTK_RAMDISK]) { - auto m_hdr = reinterpret_cast(out.buf() + off.ramdisk); + auto m_hdr = reinterpret_cast(out.data() + off.ramdisk); m_hdr->size = hdr->ramdisk_size(); hdr->ramdisk_size() += sizeof(mtk_hdr); } @@ -952,28 +952,28 @@ void repack(rust::Utf8CStr src_img, rust::Utf8CStr out_img, bool skip_comp) { if (char *id = hdr->id()) { auto ctx = get_sha(!boot.flags[SHA256_FLAG]); uint32_t size = hdr->kernel_size(); - ctx->update(byte_view(out.buf() + off.kernel, size)); + ctx->update(byte_view(out.data() + off.kernel, size)); ctx->update(byte_view(&size, sizeof(size))); size = hdr->ramdisk_size(); - ctx->update(byte_view(out.buf() + off.ramdisk, size)); + ctx->update(byte_view(out.data() + off.ramdisk, size)); ctx->update(byte_view(&size, sizeof(size))); size = hdr->second_size(); - ctx->update(byte_view(out.buf() + off.second, size)); + ctx->update(byte_view(out.data() + off.second, size)); ctx->update(byte_view(&size, sizeof(size))); size = hdr->extra_size(); if (size) { - ctx->update(byte_view(out.buf() + off.extra, size)); + ctx->update(byte_view(out.data() + off.extra, size)); ctx->update(byte_view(&size, sizeof(size))); } uint32_t ver = hdr->header_version(); if (ver == 1 || ver == 2) { size = hdr->recovery_dtbo_size(); - ctx->update(byte_view(out.buf() + hdr->recovery_dtbo_offset(), size)); + ctx->update(byte_view(out.data() + hdr->recovery_dtbo_offset(), size)); ctx->update(byte_view(&size, sizeof(size))); } if (ver == 2) { size = hdr->dtb_size(); - ctx->update(byte_view(out.buf() + off.dtb, size)); + ctx->update(byte_view(out.data() + off.dtb, size)); ctx->update(byte_view(&size, sizeof(size))); } memset(id, 0, BOOT_ID_SIZE); @@ -986,39 +986,39 @@ void repack(rust::Utf8CStr src_img, rust::Utf8CStr out_img, bool skip_comp) { // Copy main header if (boot.flags[AMONET_FLAG]) { auto real_hdr_sz = std::min(hdr->hdr_space() - AMONET_MICROLOADER_SZ, hdr->hdr_size()); - memcpy(out.buf() + off.header + AMONET_MICROLOADER_SZ, hdr->raw_hdr(), real_hdr_sz); + memcpy(out.data() + off.header + AMONET_MICROLOADER_SZ, hdr->raw_hdr(), real_hdr_sz); } else { - memcpy(out.buf() + off.header, hdr->raw_hdr(), hdr->hdr_size()); + memcpy(out.data() + off.header, hdr->raw_hdr(), hdr->hdr_size()); } if (boot.flags[AVB_FLAG]) { // Copy and patch AVB structures - auto footer = reinterpret_cast(out.buf() + out.sz() - sizeof(AvbFooter)); + auto footer = reinterpret_cast(out.data() + out.size() - sizeof(AvbFooter)); memcpy(footer, boot.avb_footer, sizeof(AvbFooter)); footer->original_image_size = __builtin_bswap64(off.total); footer->vbmeta_offset = __builtin_bswap64(off.vbmeta); if (check_env("PATCHVBMETAFLAG")) { - auto vbmeta = reinterpret_cast(out.buf() + off.vbmeta); + auto vbmeta = reinterpret_cast(out.data() + off.vbmeta); vbmeta->flags = __builtin_bswap32(3); } } if (boot.flags[DHTB_FLAG]) { // DHTB header - auto d_hdr = reinterpret_cast(out.buf()); + auto d_hdr = reinterpret_cast(out.data()); memcpy(d_hdr, DHTB_MAGIC, 8); d_hdr->size = off.total - sizeof(dhtb_hdr); - sha256_hash(byte_view(out.buf() + sizeof(dhtb_hdr), d_hdr->size), + sha256_hash(byte_view(out.data() + sizeof(dhtb_hdr), d_hdr->size), byte_data(d_hdr->checksum, 32)); } else if (boot.flags[BLOB_FLAG]) { // Blob header - auto b_hdr = reinterpret_cast(out.buf()); + auto b_hdr = reinterpret_cast(out.data()); b_hdr->size = off.total - sizeof(blob_hdr); } // Sign the image after we finish patching the boot image if (boot.flags[AVB1_SIGNED_FLAG]) { - byte_view payload(out.buf() + off.header, off.total - off.header); + byte_view payload(out.data() + off.header, off.total - off.header); auto sig = sign_payload(payload); if (!sig.empty()) { lseek(fd, off.total, SEEK_SET); diff --git a/native/src/boot/bootimg.hpp b/native/src/boot/bootimg.hpp index 4c612e17a..3226ed11e 100644 --- a/native/src/boot/bootimg.hpp +++ b/native/src/boot/bootimg.hpp @@ -345,6 +345,17 @@ struct vendor_ramdisk_table_entry_v4 { * Polymorphic Universal Header *******************************/ +template +static T align_to(T v, int a) { + static_assert(std::is_integral_v); + return (v + a - 1) / a * a; +} + +template +static T align_padding(T v, int a) { + return align_to(v, a) - v; +} + #define decl_val(name, len) \ virtual uint##len##_t name() const { return 0; } @@ -678,7 +689,7 @@ struct boot_img { rust::Slice get_payload() const { return payload; } rust::Slice get_tail() const { return tail; } bool is_signed() const { return flags[AVB1_SIGNED_FLAG]; } - uint64_t tail_off() const { return tail.buf() - map.buf(); } + uint64_t tail_off() const { return tail.data() - map.data(); } // Implemented in Rust bool verify() const noexcept; diff --git a/native/src/core/su/su.cpp b/native/src/core/su/su.cpp index 4041e47b8..3243b558a 100644 --- a/native/src/core/su/su.cpp +++ b/native/src/core/su/su.cpp @@ -446,7 +446,7 @@ void exec_root_shell(int client, int pid, SuRequest &req, MntNsMode mode) { char path[32]; ssprintf(path, sizeof(path), "/proc/%d/cwd", pid); char cwd[4096]; - if (realpath(path, cwd, sizeof(cwd)) > 0) + if (canonical_path(path, cwd, sizeof(cwd)) > 0) chdir(cwd); ssprintf(path, sizeof(path), "/proc/%d/environ", pid); auto env = full_read(path); diff --git a/native/src/init/rootdir.cpp b/native/src/init/rootdir.cpp index b00bb6690..73cad825d 100644 --- a/native/src/init/rootdir.cpp +++ b/native/src/init/rootdir.cpp @@ -147,7 +147,7 @@ void MagiskInit::patch_fissiond(const char *tmp_path) noexcept { } mkdirs(ROOTOVL "/system/bin", 0755); if (auto target_fissiond = xopen_file(ROOTOVL "/system/bin/fissiond", "we")) { - fwrite(fissiond.buf(), 1, fissiond.sz(), target_fissiond.get()); + fwrite(fissiond.data(), 1, fissiond.size(), target_fissiond.get()); clone_attr("/system/bin/fissiond", ROOTOVL "/system/bin/fissiond"); } } @@ -160,8 +160,7 @@ void MagiskInit::patch_fissiond(const char *tmp_path) noexcept { LOGD("hijacked isolated\n"); xumount2("/sys/devices/system/cpu/isolated", MNT_DETACH); unlink(INTLROOT "/isolated"); - string content; - full_read(fileno(hijack.get()), content); + string content = full_read(fileno(hijack.get())); { string target = "/dev/cells/cell2"s + tmp_path; xmkdirs(target.data(), 0); @@ -299,7 +298,7 @@ void MagiskInit::patch_ro_root() noexcept { LOGD("Patch @ %08zX [android,fstab] -> [xxx]\n", off); } int dest = xopen(ROOTOVL "/init", O_CREAT | O_WRONLY | O_CLOEXEC, 0); - xwrite(dest, init.buf(), init.sz()); + xwrite(dest, init.data(), init.size()); fclone_attr(src, dest); close(src); close(dest); diff --git a/native/src/sepolicy/policydb.cpp b/native/src/sepolicy/policydb.cpp index 4c3e26ba3..5f849c33e 100644 --- a/native/src/sepolicy/policydb.cpp +++ b/native/src/sepolicy/policydb.cpp @@ -74,7 +74,7 @@ static bool check_precompiled(const char *precompiled) { static void load_cil(struct cil_db *db, const char *file) { mmap_data d(file); - cil_add_file(db, file, (const char *) d.buf(), d.sz()); + cil_add_file(db, file, (const char *) d.data(), d.size()); LOGD("cil_add [%s]\n", file); }