use crate::error::Error;
use bitflags::bitflags;
use std::collections::HashMap;
use std::ffi::{CStr, CString};
use std::mem;
use std::path::Path;
use std::ptr;
use super::types::ParamValue;
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) => {
libc::iovec {
iov_base: $value as *mut libc::c_void,
iov_len: $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;
}
}
pub fn jail_create(path: &Path, params: HashMap<String, ParamValue>) -> Result<i32, Error> {
let raw_params: Vec<(Vec<u8>, Vec<u8>)> = params
.iter()
.map(|(key, value)| {
Ok((
CString::new(key.clone())?.into_bytes_with_nul(),
value.as_bytes()?,
))
})
.collect::<Result<_, Error>>()?;
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: [u8; 256] = unsafe { mem::zeroed() };
jiov.append(
&mut vec![
iovec!(b"path\0" => pathstr),
iovec!(b"errmsg\0" => mut errmsg),
iovec!(b"persist\0" => ()),
]
.into_iter()
.flatten()
.collect(),
);
let jid = unsafe {
libc::jail_set(
jiov[..].as_mut_ptr(),
jiov.len() as u32,
JailFlags::CREATE.bits(),
)
};
let err = unsafe { CStr::from_ptr(errmsg.as_ptr() as *mut libc::c_char) }
.to_string_lossy()
.to_string();
match jid {
e if e < 0 => match errmsg[0] {
0 => Err(Error::Io(std::io::Error::last_os_error())),
_ => Err(Error::JailSet(err)),
},
_ => Ok(jid),
}
}
pub fn jail_getid(name: &str) -> Result<i32, Error> {
let mut errmsg: [u8; 256] = unsafe { mem::zeroed() };
if let Ok(jid) = name.parse::<i32>() {
return Ok(jid);
}
let name = CString::new(name)?.into_bytes_with_nul();
let mut jiov: Vec<libc::iovec> =
vec![iovec!(b"name\0" => name), iovec!(b"errmsg\0" => mut errmsg)]
.into_iter()
.flatten()
.collect();
let jid = unsafe {
libc::jail_get(
jiov[..].as_mut_ptr(),
jiov.len() as u32,
JailFlags::empty().bits(),
)
};
let err = unsafe { CStr::from_ptr(errmsg.as_ptr() as *mut libc::c_char) }
.to_string_lossy()
.to_string();
match jid {
e if e < 0 => match errmsg[0] {
0 => Err(Error::Io(std::io::Error::last_os_error())),
_ => Err(Error::JailGet(err)),
},
_ => Ok(jid),
}
}
#[allow(dead_code)]
pub fn jail_nextjid(lastjid: i32) -> Result<i32, Error> {
let mut errmsg: [u8; 256] = unsafe { mem::zeroed() };
let mut jiov: Vec<libc::iovec> = vec![
iovec!(b"lastjid\0" => (&lastjid as *const _, mem::size_of::<i32>())),
iovec!(b"errmsg\0" => mut errmsg),
]
.into_iter()
.flatten()
.collect();
let jid = unsafe {
libc::jail_get(
jiov[..].as_mut_ptr(),
jiov.len() as u32,
JailFlags::empty().bits(),
)
};
let err = unsafe { CStr::from_ptr(errmsg.as_ptr() as *mut libc::c_char) }
.to_string_lossy()
.to_string();
match jid {
e if e < 0 => match errmsg[0] {
0 => Err(Error::Io(std::io::Error::last_os_error())),
_ => Err(Error::JailGet(err)),
},
_ => Ok(jid),
}
}
pub fn jail_remove(jid: i32) -> Result<(), Error> {
let ret = unsafe { libc::jail_remove(jid) };
match ret {
0 => Ok(()),
-1 => Err(Error::Io(std::io::Error::last_os_error())),
_ => Err(Error::JailRemoveFailed),
}
}
pub fn jail_attach(jid: i32) -> Result<(), Error> {
let ret = unsafe { libc::jail_attach(jid) };
match ret {
0 => Ok(()),
-1 => Err(Error::JailAttachFailed(jid)),
_ => Err(Error::JailAttachFailed(jid)),
}
}
#[allow(dead_code)]
pub fn jail_clearpersist(jid: i32) -> Result<(), Error> {
let mut errmsg: [u8; 256] = unsafe { mem::zeroed() };
let mut jiov: Vec<libc::iovec> = vec![
iovec!(b"jid\0" => (&jid as *const _, mem::size_of::<i32>())),
iovec!(b"errmsg\0" => mut errmsg),
iovec!(b"nopersist\0" => ()),
]
.into_iter()
.flatten()
.collect();
let jid = unsafe {
libc::jail_set(
jiov[..].as_mut_ptr(),
jiov.len() as u32,
JailFlags::UPDATE.bits(),
)
};
let err = unsafe { CStr::from_ptr(errmsg.as_ptr() as *mut libc::c_char) }
.to_string_lossy()
.to_string();
match jid {
e if e < 0 => match errmsg[0] {
0 => Err(Error::Io(std::io::Error::last_os_error())),
_ => Err(Error::JailSet(err)),
},
_ => Ok(()),
}
}
pub struct RunningJails {
lastjid: i32,
}
impl RunningJails {
#[allow(dead_code)]
pub 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,
}
}
}