#![allow(unsafe_code)]
use crate::error::Error;
use bitflags::bitflags;
macro_rules! io_err {
() => {
Err(Error::Io(std::io::Error::last_os_error()))
};
}
use std::collections::HashMap;
use std::ffi::{CStr, CString};
use std::mem;
use std::os::unix::io::FromRawFd;
use std::path::Path;
use std::ptr;
use super::types::ParamValue;
fn decode_errmsg(errmsg: &[u8; 256]) -> String {
CStr::from_bytes_until_nul(errmsg)
.map(|c| c.to_string_lossy().into_owned())
.unwrap_or_default()
}
fn check_jail_set_result(jid: i32, errmsg: &[u8; 256]) -> Result<i32, Error> {
match jid {
e if e < 0 => match errmsg[0] {
0 => io_err!(),
_ => Err(Error::JailSet(decode_errmsg(errmsg))),
},
_ => Ok(jid),
}
}
fn check_jail_get_result(jid: i32, errmsg: &[u8; 256]) -> Result<i32, Error> {
match jid {
e if e < 0 => match errmsg[0] {
0 => io_err!(),
_ => Err(Error::JailGet(decode_errmsg(errmsg))),
},
_ => Ok(jid),
}
}
fn iov_count(jiov: &[libc::iovec]) -> Result<u32, Error> {
u32::try_from(jiov.len()).map_err(|_| {
Error::Io(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"too many jail parameters",
))
})
}
const fn iov<T>(base: *const T, len: usize) -> libc::iovec {
libc::iovec {
iov_base: base.cast_mut().cast(),
iov_len: len,
}
}
fn jail_get_call(jiov: &mut Vec<libc::iovec>, errmsg_ptr: *const [u8; 256]) -> Result<i32, Error> {
let count = iov_count(jiov)?;
let jid = unsafe { libc::jail_get(jiov.as_mut_ptr(), count, JailFlags::empty().bits()) };
let errmsg = unsafe { &*errmsg_ptr };
check_jail_get_result(jid, errmsg)
}
type RawParams = Vec<(Vec<u8>, Vec<u8>)>;
fn build_raw_params(params: &HashMap<String, ParamValue>) -> Result<RawParams, Error> {
params
.iter()
.map(|(key, value)| {
Ok((
CString::new(key.clone())?.into_bytes_with_nul(),
value.as_bytes()?,
))
})
.collect()
}
macro_rules! iovec {
($key:expr => ($value:expr, $size:expr)) => {
vec![iovec!($key), iovec!($value, $size)]
};
($key:expr => ()) => {
vec![iovec!($key), iovec!()]
};
($key:expr => $value:expr) => {
vec![iovec!($key), iovec!($value)]
};
($key:expr => mut $value:expr) => {
vec![iovec!($key), iovec!(mut $value)]
};
($value:expr, $size:expr) => {
iov($value, $size)
};
($name:expr) => {
iovec!($name.as_ptr(), $name.len())
};
(mut $name:expr) => {
iovec!($name.as_mut_ptr(), $name.len())
};
() => {
iovec!(ptr::null::<libc::c_void>(), 0)
};
}
bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct JailFlags: i32 {
const CREATE = 0x01;
const UPDATE = 0x02;
const ATTACH = 0x04;
const DYING = 0x08;
const USE_DESC = 0x10;
const AT_DESC = 0x20;
const GET_DESC = 0x40;
const OWN_DESC = 0x80;
}
}
const SYS_JAIL_REMOVE_JD: libc::c_int = 598;
pub fn jail_create(path: &Path, params: &HashMap<String, ParamValue>) -> Result<i32, Error> {
let raw_params = build_raw_params(params)?;
let mut jiov: Vec<libc::iovec> = raw_params
.iter()
.flat_map(|(key, value)| iovec!(key => value))
.collect();
let pathstr = path
.to_str()
.ok_or_else(|| Error::JailSet("Invalid path encoding".into()))?;
let pathstr = CString::new(pathstr)?.into_bytes_with_nul();
let mut errmsg = [0u8; 256];
jiov.append(
&mut vec![
iovec!(b"path\0" => pathstr),
iovec!(b"errmsg\0" => mut errmsg),
iovec!(b"persist\0" => ()),
]
.into_iter()
.flatten()
.collect(),
);
let count = iov_count(&jiov)?;
let jid = unsafe { libc::jail_set(jiov[..].as_mut_ptr(), count, JailFlags::CREATE.bits()) };
check_jail_set_result(jid, &errmsg)
}
pub fn jail_update(jid: i32, params: &HashMap<String, ParamValue>) -> Result<(), Error> {
let raw_params = build_raw_params(params)?;
let mut jiov: Vec<libc::iovec> = raw_params
.iter()
.flat_map(|(key, value)| iovec!(key => value))
.collect();
let mut errmsg = [0u8; 256];
jiov.append(
&mut vec![
iovec!(b"jid\0" => (&raw const jid, mem::size_of::<i32>())),
iovec!(b"errmsg\0" => mut errmsg),
]
.into_iter()
.flatten()
.collect(),
);
let count = iov_count(&jiov)?;
let ret = unsafe { libc::jail_set(jiov[..].as_mut_ptr(), count, JailFlags::UPDATE.bits()) };
check_jail_set_result(ret, &errmsg).map(|_| ())
}
pub fn jail_getid(name: &str) -> Result<i32, Error> {
let mut errmsg = [0u8; 256];
if let Ok(jid) = name.parse::<i32>() {
return Ok(jid);
}
let mut name = CString::new(name)?.into_bytes_with_nul();
let mut jiov: Vec<libc::iovec> = vec![
iovec!(b"name\0" => mut name),
iovec!(b"errmsg\0" => mut errmsg),
]
.into_iter()
.flatten()
.collect();
jail_get_call(&mut jiov, &raw const errmsg)
}
pub fn jail_getname(mut jid: i32) -> Result<String, Error> {
let mut errmsg = [0u8; 256];
let mut name = [0u8; 256];
let mut jiov: Vec<libc::iovec> = vec![
iovec!(b"jid\0" => (&raw mut jid, mem::size_of::<i32>())),
iovec!(b"name\0" => mut name),
iovec!(b"errmsg\0" => mut errmsg),
]
.into_iter()
.flatten()
.collect();
jail_get_call(&mut jiov, &raw const errmsg)?;
let len = name.iter().position(|&b| b == 0).unwrap_or(name.len());
Ok(String::from_utf8_lossy(&name[..len]).into_owned())
}
pub fn jail_nextjid(mut lastjid: i32) -> Result<i32, Error> {
let mut errmsg = [0u8; 256];
let mut jiov: Vec<libc::iovec> = vec![
iovec!(b"lastjid\0" => (&raw mut lastjid, mem::size_of::<i32>())),
iovec!(b"errmsg\0" => mut errmsg),
]
.into_iter()
.flatten()
.collect();
jail_get_call(&mut jiov, &raw const errmsg)
}
pub fn jail_remove(jid: i32) -> Result<(), Error> {
let ret = unsafe { libc::jail_remove(jid) };
match ret {
0 => Ok(()),
-1 => io_err!(),
_ => Err(Error::JailRemoveFailed),
}
}
pub fn jail_create_with_descriptor(
path: &Path,
params: &HashMap<String, ParamValue>,
) -> Result<(i32, JailDescriptor), Error> {
let raw_params = build_raw_params(params)?;
let mut jiov: Vec<libc::iovec> = raw_params
.iter()
.flat_map(|(key, value)| iovec!(key => value))
.collect();
let pathstr = path
.to_str()
.ok_or_else(|| Error::JailSet("Invalid path encoding".into()))?;
let pathstr = CString::new(pathstr)?.into_bytes_with_nul();
let mut desc_fd: i32 = -1;
let mut errmsg = [0u8; 256];
jiov.append(
&mut vec![
iovec!(b"path\0" => pathstr),
iovec!(b"errmsg\0" => mut errmsg),
iovec!(b"persist\0" => ()),
iovec!(b"desc\0" => ((&raw mut desc_fd).cast::<u8>(), mem::size_of::<i32>())),
]
.into_iter()
.flatten()
.collect(),
);
let flags = JailFlags::CREATE | JailFlags::GET_DESC | JailFlags::OWN_DESC;
let count = iov_count(&jiov)?;
let jid = unsafe { libc::jail_set(jiov[..].as_mut_ptr(), count, flags.bits()) };
check_jail_set_result(jid, &errmsg)?;
if desc_fd < 0 {
return Err(Error::JailSet(
"jail_set returned success but descriptor fd is negative".into(),
));
}
let owned_fd = unsafe { std::os::fd::OwnedFd::from_raw_fd(desc_fd) };
Ok((jid, JailDescriptor { fd: owned_fd }))
}
pub fn jail_remove_jd(fd: std::os::fd::BorrowedFd<'_>) -> Result<(), Error> {
use std::os::unix::io::AsRawFd;
let ret = unsafe { libc::syscall(SYS_JAIL_REMOVE_JD, fd.as_raw_fd()) };
if ret != 0 {
return io_err!();
}
Ok(())
}
pub struct JailDescriptor {
fd: std::os::fd::OwnedFd,
}
impl JailDescriptor {
pub fn as_fd(&self) -> std::os::fd::BorrowedFd<'_> {
use std::os::unix::io::AsFd;
self.fd.as_fd()
}
pub fn as_raw_fd(&self) -> i32 {
use std::os::unix::io::AsRawFd;
self.fd.as_raw_fd()
}
pub fn remove(self) -> Result<(), Error> {
jail_remove_jd(self.as_fd())?;
Ok(())
}
}
impl std::fmt::Debug for JailDescriptor {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
use std::os::unix::io::AsRawFd;
f.debug_struct("JailDescriptor")
.field("fd", &self.fd.as_raw_fd())
.finish()
}
}
pub struct RunningJails {
lastjid: i32,
}
impl RunningJails {
pub const fn new() -> Self {
Self { lastjid: 0 }
}
}
impl Default for RunningJails {
fn default() -> Self {
Self::new()
}
}
impl Iterator for RunningJails {
type Item = i32;
fn next(&mut self) -> Option<Self::Item> {
match jail_nextjid(self.lastjid) {
Ok(jid) => {
self.lastjid = jid;
Some(jid)
}
Err(_) => None,
}
}
}