TheArchive/Magisk
1
0
Fork 0
mirror of https://github.com/topjohnwu/Magisk.git synced 2024-12-21 23:47:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

Properly handle visibility

Browse Source
This commit is contained in:
topjohnwu 2023-07-06 04:54:33 -07:00
parent af2207433d
commit e8e8afa6c2
5 changed files with 137 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
native/src/base/cxx_extern.rs
View File

@ -1,4 +1,4 @@
// Functions listed here are just to export to C++
// Functions in this file are only for exporting to C++, DO NOT USE IN RUST
use std::fmt::Write;
use std::io;
@ -7,6 +7,7 @@ use std::os::fd::{BorrowedFd, OwnedFd, RawFd};
use cxx::private::c_char;
use libc::mode_t;
pub(crate) use crate::xwrap::*;
use crate::{
fd_path, map_fd, map_file, mkdirs, realpath, rm_rf, slice_from_ptr_mut, Directory, ResultExt,
Utf8CStr,

2
native/src/base/files.rs
View File

@ -31,7 +31,7 @@ macro_rules! open_fd {
};
}
pub unsafe fn readlink_unsafe(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
pub(crate) unsafe fn readlink_unsafe(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
let r = libc::readlink(path, buf.cast(), bufsz - 1);
if r >= 0 {
*buf.offset(r) = b'\0';

1
native/src/base/lib.rs
View File

@ -8,7 +8,6 @@ use cxx_extern::*;
pub use files::*;
pub use logging::*;
pub use misc::*;
pub use xwrap::*;
mod cxx_extern;
mod files;

12
native/src/base/misc.rs
View File

@ -256,22 +256,10 @@ impl PartialEq<Utf8CStr> for str {
}
}
pub fn ptr_to_str<'a, T>(ptr: *const T) -> &'a str {
if ptr.is_null() {
"(null)"
} else {
unsafe { CStr::from_ptr(ptr.cast()) }.to_str().unwrap_or("")
}
}
pub fn errno() -> &'static mut i32 {
unsafe { &mut *libc::__errno() }
}
pub fn error_str() -> &'static str {
unsafe { ptr_to_str(libc::strerror(*errno())) }
}
// 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] {

283
native/src/base/xwrap.rs
View File

@ -1,13 +1,32 @@
// Functions in this file are only for exporting to C++, DO NOT USE IN RUST
use std::ffi::CStr;
use std::fmt::Write;
use std::os::unix::io::RawFd;
use std::ptr;
use cfg_if::cfg_if;
use libc::{
c_char, c_uint, c_ulong, c_void, dev_t, mode_t, nfds_t, off_t, pollfd, sockaddr, socklen_t,
ssize_t, SYS_dup3,
};
use crate::{cstr, errno, mkdirs, ptr_to_str, raw_cstr, ResultExt, Utf8CStr};
use crate::{
cstr, errno, mkdirs, raw_cstr, readlink_unsafe, realpath, slice_from_ptr_mut, ResultExt,
Utf8CStr,
};
fn ptr_to_str<'a, T>(ptr: *const T) -> &'a str {
if ptr.is_null() {
"(null)"
} else {
unsafe { CStr::from_ptr(ptr.cast()) }.to_str().unwrap_or("")
}
}
fn error_str() -> &'static str {
unsafe { ptr_to_str(libc::strerror(*errno())) }
}
macro_rules! error_cxx {
($($args:tt)+) => {
@ -19,117 +38,82 @@ macro_rules! perror {
($fmt:expr) => {
$crate::log_with_formatter($crate::ffi::LogLevel::ErrorCxx, |w| {
w.write_str($fmt)?;
w.write_fmt(format_args!(" failed with {}: {}", $crate::errno(), $crate::error_str()))
w.write_fmt(format_args!(" failed with {}: {}", $crate::errno(), error_str()))
})
};
($fmt:expr, $($args:tt)*) => {
$crate::log_with_formatter($crate::ffi::LogLevel::ErrorCxx, |w| {
w.write_fmt(format_args!($fmt, $($args)*))?;
w.write_fmt(format_args!(" failed with {}: {}", $crate::errno(), $crate::error_str()))
w.write_fmt(format_args!(" failed with {}: {}", $crate::errno(), error_str()))
})
};
}
mod unsafe_impl {
use std::fmt::Write;
mod c_export {
use std::os::unix::io::RawFd;
use cfg_if::cfg_if;
use libc::{c_char, nfds_t, off_t, pollfd};
use crate::{
ptr_to_str, readlink_unsafe, realpath, slice_from_ptr, slice_from_ptr_mut, ResultExt,
Utf8CStr,
};
use crate::{slice_from_ptr, slice_from_ptr_mut};
#[no_mangle]
unsafe extern "C" fn xwrite(fd: RawFd, buf: *const u8, bufsz: usize) -> isize {
super::xwrite(fd, slice_from_ptr(buf, bufsz))
}
#[no_mangle]
unsafe extern "C" fn xread(fd: RawFd, buf: *mut u8, bufsz: usize) -> isize {
super::xread(fd, slice_from_ptr_mut(buf, bufsz))
}
#[no_mangle]
unsafe extern "C" fn xxread(fd: RawFd, buf: *mut u8, bufsz: usize) -> isize {
super::xxread(fd, slice_from_ptr_mut(buf, bufsz))
}
#[no_mangle]
unsafe extern "C" fn xrealpath(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
match Utf8CStr::from_ptr(path) {
Ok(p) => realpath(p, slice_from_ptr_mut(buf, bufsz))
.log_cxx_with_msg(|w| w.write_fmt(format_args!("realpath {} failed", p)))
.map_or(-1, |v| v as isize),
Err(_) => -1,
}
}
#[no_mangle]
pub unsafe extern "C" fn xreadlink(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
let r = readlink_unsafe(path, buf, bufsz);
if r < 0 {
perror!("readlink");
}
r
}
#[no_mangle]
pub unsafe extern "C" fn xreadlinkat(
dirfd: RawFd,
path: *const c_char,
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 r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
if r < 0 {
perror!("readlinkat {}", ptr_to_str(path))
}
} else {
let r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
if r < 0 {
perror!("readlinkat {}", ptr_to_str(path))
} else {
*buf.offset(r) = b'\0';
}
}
}
r
}
#[no_mangle]
pub 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");
}
r
}
#[no_mangle]
pub 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");
}
r
}
}
#[no_mangle]
pub unsafe extern "C" fn xfopen(path: *const c_char, mode: *const c_char) -> *mut libc::FILE {
unsafe extern "C" fn xrealpath(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
match Utf8CStr::from_ptr(path) {
Ok(p) => realpath(p, slice_from_ptr_mut(buf, bufsz))
.log_cxx_with_msg(|w| w.write_fmt(format_args!("realpath {} failed", p)))
.map_or(-1, |v| v as isize),
Err(_) => -1,
}
}
#[no_mangle]
unsafe extern "C" fn xreadlink(path: *const c_char, buf: *mut u8, bufsz: usize) -> isize {
let r = readlink_unsafe(path, buf, bufsz);
if r < 0 {
perror!("readlink");
}
r
}
#[no_mangle]
unsafe extern "C" fn xreadlinkat(
dirfd: RawFd,
path: *const c_char,
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 r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
if r < 0 {
perror!("readlinkat {}", ptr_to_str(path))
}
} else {
let r = libc::readlinkat(dirfd, path, buf.cast(), bufsz - 1);
if r < 0 {
perror!("readlinkat {}", ptr_to_str(path))
} else {
*buf.offset(r) = b'\0';
}
}
}
r
}
#[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));
@ -138,7 +122,7 @@ pub unsafe extern "C" fn xfopen(path: *const c_char, mode: *const c_char) -> *mu
}
#[no_mangle]
pub unsafe extern "C" fn xfdopen(fd: RawFd, mode: *const c_char) -> *mut libc::FILE {
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");
@ -147,7 +131,7 @@ pub unsafe extern "C" fn xfdopen(fd: RawFd, mode: *const c_char) -> *mut libc::F
}
#[no_mangle]
pub unsafe extern "C" fn xopen(path: *const c_char, flags: i32, mode: mode_t) -> RawFd {
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));
@ -156,12 +140,7 @@ pub unsafe extern "C" fn xopen(path: *const c_char, flags: i32, mode: mode_t) ->
}
#[no_mangle]
pub unsafe extern "C" fn xopenat(
dirfd: RawFd,
path: *const c_char,
flags: i32,
mode: mode_t,
) -> RawFd {
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));
@ -170,7 +149,7 @@ pub unsafe extern "C" fn xopenat(
}
// Fully write data slice
pub fn xwrite(fd: RawFd, data: &[u8]) -> isize {
fn xwrite(fd: RawFd, data: &[u8]) -> isize {
unsafe {
let mut write_sz: usize = 0;
let mut r: ssize_t;
@ -198,9 +177,10 @@ pub fn xwrite(fd: RawFd, data: &[u8]) -> isize {
}
}
pub fn xread(fd: RawFd, data: &mut [u8]) -> isize {
#[no_mangle]
unsafe extern "C" fn xread(fd: RawFd, buf: *mut c_void, bufsz: usize) -> isize {
unsafe {
let r = libc::read(fd, data.as_mut_ptr().cast(), data.len());
let r = libc::read(fd, buf, bufsz);
if r < 0 {
perror!("read");
}
@ -209,7 +189,7 @@ pub fn xread(fd: RawFd, data: &mut [u8]) -> isize {
}
// Fully read size of data slice
pub fn xxread(fd: RawFd, data: &mut [u8]) -> isize {
fn xxread(fd: RawFd, data: &mut [u8]) -> isize {
unsafe {
let mut read_sz: usize = 0;
let mut r: ssize_t;
@ -238,7 +218,7 @@ pub fn xxread(fd: RawFd, data: &mut [u8]) -> isize {
}
#[no_mangle]
pub extern "C" fn xlseek64(fd: RawFd, offset: i64, whence: i32) -> i64 {
extern "C" fn xlseek64(fd: RawFd, offset: i64, whence: i32) -> i64 {
unsafe {
let r = libc::lseek64(fd, offset, whence);
if r < 0 {
@ -248,7 +228,7 @@ pub extern "C" fn xlseek64(fd: RawFd, offset: i64, whence: i32) -> i64 {
}
}
pub fn xpipe2(fds: &mut [i32; 2], flags: i32) -> i32 {
pub(crate) fn xpipe2(fds: &mut [i32; 2], flags: i32) -> i32 {
unsafe {
let r = libc::pipe2(fds.as_mut_ptr(), flags);
if r < 0 {
@ -259,7 +239,7 @@ pub fn xpipe2(fds: &mut [i32; 2], flags: i32) -> i32 {
}
#[no_mangle]
pub extern "C" fn xsetns(fd: RawFd, nstype: i32) -> i32 {
extern "C" fn xsetns(fd: RawFd, nstype: i32) -> i32 {
unsafe {
let r = libc::setns(fd, nstype);
if r < 0 {
@ -270,7 +250,7 @@ pub extern "C" fn xsetns(fd: RawFd, nstype: i32) -> i32 {
}
#[no_mangle]
pub extern "C" fn xunshare(flags: i32) -> i32 {
extern "C" fn xunshare(flags: i32) -> i32 {
unsafe {
let r = libc::unshare(flags);
if r < 0 {
@ -281,7 +261,7 @@ pub extern "C" fn xunshare(flags: i32) -> i32 {
}
#[no_mangle]
pub unsafe extern "C" fn xopendir(path: *const c_char) -> *mut libc::DIR {
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));
@ -290,7 +270,7 @@ pub unsafe extern "C" fn xopendir(path: *const c_char) -> *mut libc::DIR {
}
#[no_mangle]
pub extern "C" fn xfdopendir(fd: RawFd) -> *mut libc::DIR {
extern "C" fn xfdopendir(fd: RawFd) -> *mut libc::DIR {
unsafe {
let dp = libc::fdopendir(fd);
if dp.is_null() {
@ -301,7 +281,7 @@ pub extern "C" fn xfdopendir(fd: RawFd) -> *mut libc::DIR {
}
#[no_mangle]
pub unsafe extern "C" fn xreaddir(dirp: *mut libc::DIR) -> *mut libc::dirent {
unsafe extern "C" fn xreaddir(dirp: *mut libc::DIR) -> *mut libc::dirent {
*errno() = 0;
loop {
let e = libc::readdir(dirp);
@ -321,7 +301,7 @@ pub unsafe extern "C" fn xreaddir(dirp: *mut libc::DIR) -> *mut libc::dirent {
}
#[no_mangle]
pub extern "C" fn xsetsid() -> i32 {
extern "C" fn xsetsid() -> i32 {
unsafe {
let r = libc::setsid();
if r < 0 {
@ -332,7 +312,7 @@ pub extern "C" fn xsetsid() -> i32 {
}
#[no_mangle]
pub extern "C" fn xsocket(domain: i32, ty: i32, protocol: i32) -> RawFd {
extern "C" fn xsocket(domain: i32, ty: i32, protocol: i32) -> RawFd {
unsafe {
let fd = libc::socket(domain, ty, protocol);
if fd < 0 {
@ -343,7 +323,7 @@ pub extern "C" fn xsocket(domain: i32, ty: i32, protocol: i32) -> RawFd {
}
#[no_mangle]
pub unsafe extern "C" fn xbind(socket: i32, address: *const sockaddr, len: socklen_t) -> i32 {
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");
@ -352,7 +332,7 @@ pub unsafe extern "C" fn xbind(socket: i32, address: *const sockaddr, len: sockl
}
#[no_mangle]
pub extern "C" fn xlisten(socket: i32, backlog: i32) -> i32 {
extern "C" fn xlisten(socket: i32, backlog: i32) -> i32 {
unsafe {
let r = libc::listen(socket, backlog);
if r < 0 {
@ -363,7 +343,7 @@ pub extern "C" fn xlisten(socket: i32, backlog: i32) -> i32 {
}
#[no_mangle]
pub unsafe extern "C" fn xaccept4(
unsafe extern "C" fn xaccept4(
sockfd: RawFd,
addr: *mut sockaddr,
len: *mut socklen_t,
@ -377,7 +357,7 @@ pub unsafe extern "C" fn xaccept4(
}
#[no_mangle]
pub unsafe extern "C" fn xsendmsg(fd: RawFd, msg: *const libc::msghdr, flags: i32) -> ssize_t {
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");
@ -386,7 +366,7 @@ pub unsafe extern "C" fn xsendmsg(fd: RawFd, msg: *const libc::msghdr, flags: i3
}
#[no_mangle]
pub unsafe extern "C" fn xrecvmsg(fd: RawFd, msg: *mut libc::msghdr, flags: i32) -> ssize_t {
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");
@ -395,7 +375,7 @@ pub unsafe extern "C" fn xrecvmsg(fd: RawFd, msg: *mut libc::msghdr, flags: i32)
}
#[no_mangle]
pub unsafe extern "C" fn xaccess(path: *const c_char, mode: i32) -> i32 {
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));
@ -404,12 +384,7 @@ pub unsafe extern "C" fn xaccess(path: *const c_char, mode: i32) -> i32 {
}
#[no_mangle]
pub unsafe extern "C" fn xfaccessat(
dirfd: RawFd,
path: *const c_char,
mode: i32,
flags: i32,
) -> i32 {
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 {
@ -423,7 +398,7 @@ pub unsafe extern "C" fn xfaccessat(
}
#[no_mangle]
pub unsafe extern "C" fn xstat(path: *const c_char, buf: *mut libc::stat) -> i32 {
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));
@ -432,7 +407,7 @@ pub unsafe extern "C" fn xstat(path: *const c_char, buf: *mut libc::stat) -> i32
}
#[no_mangle]
pub unsafe extern "C" fn xlstat(path: *const c_char, buf: *mut libc::stat) -> i32 {
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));
@ -441,7 +416,7 @@ pub unsafe extern "C" fn xlstat(path: *const c_char, buf: *mut libc::stat) -> i3
}
#[no_mangle]
pub unsafe extern "C" fn xfstat(fd: RawFd, buf: *mut libc::stat) -> i32 {
unsafe extern "C" fn xfstat(fd: RawFd, buf: *mut libc::stat) -> i32 {
let r = libc::fstat(fd, buf);
if r < 0 {
perror!("fstat");
@ -450,7 +425,7 @@ pub unsafe extern "C" fn xfstat(fd: RawFd, buf: *mut libc::stat) -> i32 {
}
#[no_mangle]
pub unsafe extern "C" fn xfstatat(
unsafe extern "C" fn xfstatat(
dirfd: RawFd,
path: *const c_char,
buf: *mut libc::stat,
@ -464,7 +439,7 @@ pub unsafe extern "C" fn xfstatat(
}
#[no_mangle]
pub extern "C" fn xdup(oldfd: RawFd) -> RawFd {
extern "C" fn xdup(oldfd: RawFd) -> RawFd {
unsafe {
let fd = libc::dup(oldfd);
if fd < 0 {
@ -475,7 +450,7 @@ pub extern "C" fn xdup(oldfd: RawFd) -> RawFd {
}
#[no_mangle]
pub extern "C" fn xdup2(oldfd: RawFd, newfd: RawFd) -> RawFd {
extern "C" fn xdup2(oldfd: RawFd, newfd: RawFd) -> RawFd {
unsafe {
let fd = libc::dup2(oldfd, newfd);
if fd < 0 {
@ -486,7 +461,7 @@ pub extern "C" fn xdup2(oldfd: RawFd, newfd: RawFd) -> RawFd {
}
#[no_mangle]
pub extern "C" fn xdup3(oldfd: RawFd, newfd: RawFd, flags: i32) -> RawFd {
extern "C" fn xdup3(oldfd: RawFd, newfd: RawFd, flags: i32) -> RawFd {
unsafe {
let fd = libc::syscall(SYS_dup3, oldfd, newfd, flags) as RawFd;
if fd < 0 {
@ -497,7 +472,7 @@ pub extern "C" fn xdup3(oldfd: RawFd, newfd: RawFd, flags: i32) -> RawFd {
}
#[no_mangle]
pub unsafe extern "C" fn xsymlink(target: *const c_char, linkpath: *const c_char) -> i32 {
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));
@ -506,7 +481,7 @@ pub unsafe extern "C" fn xsymlink(target: *const c_char, linkpath: *const c_char
}
#[no_mangle]
pub unsafe extern "C" fn xsymlinkat(
unsafe extern "C" fn xsymlinkat(
target: *const c_char,
dirfd: RawFd,
linkpath: *const c_char,
@ -523,7 +498,7 @@ pub unsafe extern "C" fn xsymlinkat(
}
#[no_mangle]
pub unsafe extern "C" fn xlinkat(
unsafe extern "C" fn xlinkat(
olddirfd: RawFd,
target: *const c_char,
newdirfd: RawFd,
@ -538,7 +513,7 @@ pub unsafe extern "C" fn xlinkat(
}
#[no_mangle]
pub unsafe extern "C" fn xmount(
unsafe extern "C" fn xmount(
src: *const c_char,
target: *const c_char,
fstype: *const c_char,
@ -553,7 +528,7 @@ pub unsafe extern "C" fn xmount(
}
#[no_mangle]
pub unsafe extern "C" fn xumount(target: *const c_char) -> i32 {
unsafe extern "C" fn xumount(target: *const c_char) -> i32 {
let r = libc::umount(target);
if r < 0 {
perror!("umount {}", ptr_to_str(target));
@ -562,7 +537,7 @@ pub unsafe extern "C" fn xumount(target: *const c_char) -> i32 {
}
#[no_mangle]
pub unsafe extern "C" fn xumount2(target: *const c_char, flags: i32) -> i32 {
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));
@ -571,7 +546,7 @@ pub unsafe extern "C" fn xumount2(target: *const c_char, flags: i32) -> i32 {
}
#[no_mangle]
pub unsafe extern "C" fn xrename(oldname: *const c_char, newname: *const c_char) -> i32 {
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));
@ -580,7 +555,7 @@ pub unsafe extern "C" fn xrename(oldname: *const c_char, newname: *const c_char)
}
#[no_mangle]
pub unsafe extern "C" fn xmkdir(path: *const c_char, mode: mode_t) -> i32 {
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));
@ -589,7 +564,7 @@ pub unsafe extern "C" fn xmkdir(path: *const c_char, mode: mode_t) -> i32 {
}
#[no_mangle]
pub unsafe extern "C" fn xmkdirs(path: *const c_char, mode: mode_t) -> i32 {
unsafe extern "C" fn xmkdirs(path: *const c_char, mode: mode_t) -> i32 {
match Utf8CStr::from_ptr(path) {
Ok(p) => mkdirs(p, mode)
.log_cxx_with_msg(|w| w.write_fmt(format_args!("mkdirs {} failed", p)))
@ -599,7 +574,7 @@ pub unsafe extern "C" fn xmkdirs(path: *const c_char, mode: mode_t) -> i32 {
}
#[no_mangle]
pub unsafe extern "C" fn xmkdirat(dirfd: RawFd, path: *const c_char, mode: mode_t) -> i32 {
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));
@ -607,16 +582,22 @@ pub unsafe extern "C" fn xmkdirat(dirfd: RawFd, path: *const c_char, mode: mode_
r
}
#[inline]
pub fn xsendfile(out_fd: RawFd, in_fd: RawFd, offset: Option<&mut off_t>, count: usize) -> isize {
unsafe {
let p = offset.map_or(ptr::null_mut(), |it| it);
unsafe_impl::xsendfile(out_fd, in_fd, p, count)
#[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");
}
r
}
#[no_mangle]
pub unsafe extern "C" fn xmmap(
unsafe extern "C" fn xmmap(
addr: *mut c_void,
len: usize,
prot: i32,
@ -633,7 +614,7 @@ pub unsafe extern "C" fn xmmap(
}
#[no_mangle]
pub extern "C" fn xfork() -> i32 {
extern "C" fn xfork() -> i32 {
unsafe {
let r = libc::fork();
if r < 0 {
@ -643,13 +624,17 @@ pub extern "C" fn xfork() -> i32 {
}
}
#[inline]
pub fn xpoll(fds: &mut [pollfd], timeout: i32) -> i32 {
unsafe { unsafe_impl::xpoll(fds.as_mut_ptr(), fds.len() as nfds_t, timeout) }
#[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");
}
r
}
#[no_mangle]
pub unsafe extern "C" fn xmknod(pathname: *const c_char, mode: mode_t, dev: dev_t) -> i32 {
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));