use crate::error::{Error, Result};
use nix::sys::wait::{waitpid, WaitPidFlag, WaitStatus};
use nix::unistd::{close, fork, pipe, ForkResult};
use std::ffi::CString;
use std::io::Read;
use std::os::unix::io::{AsRawFd, FromRawFd, RawFd};
use std::time::{Duration, Instant};
unsafe extern "C" {
fn jail_attach(jid: libc::c_int) -> libc::c_int;
}
pub fn jexec_with_output(jid: i32, command: &[&str]) -> Result<(i32, Vec<u8>, Vec<u8>)> {
if command.is_empty() {
return Err(Error::CommandFailed {
command: "jexec".to_string(),
message: "Empty command".to_string(),
});
}
let (stdout_read, stdout_write) = pipe().map_err(|e| Error::CommandFailed {
command: "jexec".to_string(),
message: format!("Failed to create stdout pipe: {}", e),
})?;
let (stderr_read, stderr_write) = pipe().map_err(|e| Error::CommandFailed {
command: "jexec".to_string(),
message: format!("Failed to create stderr pipe: {}", e),
})?;
match unsafe { fork() } {
Ok(ForkResult::Parent { child }) => {
close(stdout_write.as_raw_fd()).ok();
close(stderr_write.as_raw_fd()).ok();
let stdout = read_fd_to_end(stdout_read.as_raw_fd());
close(stdout_read.as_raw_fd()).ok();
let stderr = read_fd_to_end(stderr_read.as_raw_fd());
close(stderr_read.as_raw_fd()).ok();
match waitpid(child, None) {
Ok(WaitStatus::Exited(_, exit_code)) => Ok((exit_code, stdout, stderr)),
Ok(WaitStatus::Signaled(_, signal, _)) => Err(Error::CommandFailed {
command: format!("jexec {} {:?}", jid, command),
message: format!("Process killed by signal {}", signal),
}),
Ok(status) => Err(Error::CommandFailed {
command: format!("jexec {} {:?}", jid, command),
message: format!("Unexpected wait status: {:?}", status),
}),
Err(e) => Err(Error::CommandFailed {
command: format!("jexec {} {:?}", jid, command),
message: format!("waitpid failed: {}", e),
}),
}
}
Ok(ForkResult::Child) => {
close(stdout_read.as_raw_fd()).ok();
close(stderr_read.as_raw_fd()).ok();
unsafe {
libc::dup2(stdout_write.as_raw_fd(), 1); libc::dup2(stderr_write.as_raw_fd(), 2); }
close(stdout_write.as_raw_fd()).ok();
close(stderr_write.as_raw_fd()).ok();
let result = unsafe { jail_attach(jid) };
if result != 0 {
eprintln!("jail_attach({}) failed: {}", jid, std::io::Error::last_os_error());
std::process::exit(1);
}
let cmd_cstring = match CString::new(command[0]) {
Ok(s) => s,
Err(e) => {
eprintln!("Invalid command string: {}", e);
std::process::exit(1);
}
};
let mut args: Vec<CString> = Vec::new();
for arg in command {
match CString::new(*arg) {
Ok(s) => args.push(s),
Err(e) => {
eprintln!("Invalid argument string: {}", e);
std::process::exit(1);
}
}
}
let mut arg_ptrs: Vec<*const libc::c_char> = args.iter().map(|s| s.as_ptr()).collect();
arg_ptrs.push(std::ptr::null());
unsafe {
libc::execvp(cmd_cstring.as_ptr(), arg_ptrs.as_ptr());
}
eprintln!("execvp failed: {}", std::io::Error::last_os_error());
std::process::exit(127);
}
Err(e) => Err(Error::CommandFailed {
command: "jexec".to_string(),
message: format!("Fork failed: {}", e),
}),
}
}
fn read_fd_to_end(fd: RawFd) -> Vec<u8> {
let mut buffer = Vec::new();
let mut file = unsafe { std::fs::File::from_raw_fd(fd) };
file.read_to_end(&mut buffer).ok();
std::mem::forget(file); buffer
}
pub fn jexec_with_timeout(
jid: i32,
command: &[&str],
timeout_secs: u64,
) -> Result<(i32, String, String)> {
if command.is_empty() {
return Err(Error::CommandFailed {
command: "jexec".to_string(),
message: "Empty command".to_string(),
});
}
let (stdout_read, stdout_write) = pipe().map_err(|e| Error::CommandFailed {
command: "jexec".to_string(),
message: format!("Failed to create stdout pipe: {}", e),
})?;
let (stderr_read, stderr_write) = pipe().map_err(|e| Error::CommandFailed {
command: "jexec".to_string(),
message: format!("Failed to create stderr pipe: {}", e),
})?;
match unsafe { fork() } {
Ok(ForkResult::Parent { child }) => {
close(stdout_write.as_raw_fd()).ok();
close(stderr_write.as_raw_fd()).ok();
let timeout = Duration::from_secs(timeout_secs);
let start = Instant::now();
loop {
match waitpid(child, Some(WaitPidFlag::WNOHANG)) {
Ok(WaitStatus::StillAlive) => {
if timeout_secs > 0 && start.elapsed() > timeout {
unsafe {
libc::kill(child.as_raw(), libc::SIGKILL);
}
let _ = waitpid(child, None);
close(stdout_read.as_raw_fd()).ok();
close(stderr_read.as_raw_fd()).ok();
return Err(Error::JailTimeout(timeout_secs));
}
std::thread::sleep(Duration::from_millis(10));
}
Ok(WaitStatus::Exited(_, exit_code)) => {
let stdout = read_fd_to_end(stdout_read.as_raw_fd());
close(stdout_read.as_raw_fd()).ok();
let stderr = read_fd_to_end(stderr_read.as_raw_fd());
close(stderr_read.as_raw_fd()).ok();
return Ok((
exit_code,
String::from_utf8_lossy(&stdout).into_owned(),
String::from_utf8_lossy(&stderr).into_owned(),
));
}
Ok(WaitStatus::Signaled(_, signal, _)) => {
close(stdout_read.as_raw_fd()).ok();
close(stderr_read.as_raw_fd()).ok();
return Err(Error::CommandFailed {
command: format!("jexec {} {:?}", jid, command),
message: format!("Process killed by signal {}", signal),
});
}
Ok(status) => {
close(stdout_read.as_raw_fd()).ok();
close(stderr_read.as_raw_fd()).ok();
return Err(Error::CommandFailed {
command: format!("jexec {} {:?}", jid, command),
message: format!("Unexpected wait status: {:?}", status),
});
}
Err(e) => {
close(stdout_read.as_raw_fd()).ok();
close(stderr_read.as_raw_fd()).ok();
return Err(Error::CommandFailed {
command: format!("jexec {} {:?}", jid, command),
message: format!("waitpid failed: {}", e),
});
}
}
}
}
Ok(ForkResult::Child) => {
close(stdout_read.as_raw_fd()).ok();
close(stderr_read.as_raw_fd()).ok();
unsafe {
libc::dup2(stdout_write.as_raw_fd(), 1);
libc::dup2(stderr_write.as_raw_fd(), 2);
}
close(stdout_write.as_raw_fd()).ok();
close(stderr_write.as_raw_fd()).ok();
let result = unsafe { jail_attach(jid) };
if result != 0 {
eprintln!("jail_attach({}) failed: {}", jid, std::io::Error::last_os_error());
std::process::exit(1);
}
let shell_cmd = command.join(" ");
let cmd_cstring = CString::new("/bin/sh").unwrap();
let arg_c = CString::new("-c").unwrap();
let arg_cmd = CString::new(shell_cmd).unwrap();
let args: [*const libc::c_char; 4] = [
cmd_cstring.as_ptr(),
arg_c.as_ptr(),
arg_cmd.as_ptr(),
std::ptr::null(),
];
unsafe {
libc::execvp(cmd_cstring.as_ptr(), args.as_ptr());
}
eprintln!("execvp failed: {}", std::io::Error::last_os_error());
std::process::exit(127);
}
Err(e) => Err(Error::CommandFailed {
command: "jexec".to_string(),
message: format!("Fork failed: {}", e),
}),
}
}
pub fn chroot_exec(
root_path: &str,
command: &str,
env_vars: &[(String, String)],
) -> Result<(i32, Vec<u8>, Vec<u8>)> {
let (stdout_read, stdout_write) = pipe().map_err(|e| Error::CommandFailed {
command: "chroot".to_string(),
message: format!("Failed to create stdout pipe: {}", e),
})?;
let (stderr_read, stderr_write) = pipe().map_err(|e| Error::CommandFailed {
command: "chroot".to_string(),
message: format!("Failed to create stderr pipe: {}", e),
})?;
let root_cstring = CString::new(root_path).map_err(|e| Error::CommandFailed {
command: "chroot".to_string(),
message: format!("Invalid path: {}", e),
})?;
match unsafe { fork() } {
Ok(ForkResult::Parent { child }) => {
close(stdout_write.as_raw_fd()).ok();
close(stderr_write.as_raw_fd()).ok();
let stdout = read_fd_to_end(stdout_read.as_raw_fd());
close(stdout_read.as_raw_fd()).ok();
let stderr = read_fd_to_end(stderr_read.as_raw_fd());
close(stderr_read.as_raw_fd()).ok();
match waitpid(child, None) {
Ok(WaitStatus::Exited(_, exit_code)) => Ok((exit_code, stdout, stderr)),
Ok(WaitStatus::Signaled(_, signal, _)) => Err(Error::CommandFailed {
command: format!("chroot {}", root_path),
message: format!("Process killed by signal {}", signal),
}),
Ok(status) => Err(Error::CommandFailed {
command: format!("chroot {}", root_path),
message: format!("Unexpected wait status: {:?}", status),
}),
Err(e) => Err(Error::CommandFailed {
command: format!("chroot {}", root_path),
message: format!("waitpid failed: {}", e),
}),
}
}
Ok(ForkResult::Child) => {
close(stdout_read.as_raw_fd()).ok();
close(stderr_read.as_raw_fd()).ok();
unsafe {
libc::dup2(stdout_write.as_raw_fd(), 1);
libc::dup2(stderr_write.as_raw_fd(), 2);
}
close(stdout_write.as_raw_fd()).ok();
close(stderr_write.as_raw_fd()).ok();
let result = unsafe { libc::chroot(root_cstring.as_ptr()) };
if result != 0 {
eprintln!("chroot({}) failed: {}", root_path, std::io::Error::last_os_error());
std::process::exit(1);
}
let root_dir = CString::new("/").unwrap();
unsafe {
libc::chdir(root_dir.as_ptr());
}
for (key, value) in env_vars {
unsafe { std::env::set_var(key, value) };
}
let cmd_cstring = CString::new("/bin/sh").unwrap();
let arg_c = CString::new("-c").unwrap();
let arg_cmd = match CString::new(command) {
Ok(s) => s,
Err(e) => {
eprintln!("Invalid command string: {}", e);
std::process::exit(1);
}
};
let args: [*const libc::c_char; 4] = [
cmd_cstring.as_ptr(),
arg_c.as_ptr(),
arg_cmd.as_ptr(),
std::ptr::null(),
];
unsafe {
libc::execvp(cmd_cstring.as_ptr(), args.as_ptr());
}
eprintln!("execvp failed: {}", std::io::Error::last_os_error());
std::process::exit(127);
}
Err(e) => Err(Error::CommandFailed {
command: "chroot".to_string(),
message: format!("Fork failed: {}", e),
}),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[ignore] fn test_jexec_basic() {
let result = jexec_with_output(1, &["echo", "hello"]);
assert!(result.is_ok());
if let Ok((exit_code, stdout, _stderr)) = result {
assert_eq!(exit_code, 0);
assert_eq!(String::from_utf8_lossy(&stdout).trim(), "hello");
}
}
}