use std::io;
use std::os::fd::AsRawFd;
use std::os::fd::BorrowedFd;
use std::os::fd::FromRawFd;
use std::os::fd::OwnedFd;
use reverie_inguest::launcher::native::NativeGuestSetup;
use reverie_inguest::launcher::native::NativeRootObservation;
use reverie_inguest::launcher::native_frontend::NativeFrontend;
use super::container::declared_inputs::GuestDeclaredRootSetup;
use super::container::declared_inputs::MaterializedDeclaredRoot;
pub(super) const DETLOG_FD: i32 = 204;
const FIRST_ROLE: i32 = 198;
const ROLES: usize = 7;
const SEALS: i32 = libc::F_SEAL_SEAL
| libc::F_SEAL_WRITE
| libc::F_SEAL_GROW
| libc::F_SEAL_SHRINK
| libc::F_SEAL_FUTURE_WRITE
| 0x0020;
#[derive(Clone, Copy)]
struct Identity {
device: u64,
inode: u64,
mode: u32,
}
struct Setup {
root: GuestDeclaredRootSetup,
entered: Option<MaterializedDeclaredRoot>,
frontend: NativeFrontend,
leases: [OwnedFd; ROLES],
identities: [Identity; ROLES],
entered_once: bool,
}
pub(super) unsafe fn prepare(
root: GuestDeclaredRootSetup,
frontend: NativeFrontend,
roles: [BorrowedFd<'_>; 5],
observer: BorrowedFd<'_>,
detlog: BorrowedFd<'_>,
) -> io::Result<Box<dyn NativeGuestSetup>> {
let descriptors = [
roles[0], roles[1], roles[2], roles[3], roles[4], observer, detlog,
];
let mut identities = [Identity {
device: 0,
inode: 0,
mode: 0,
}; ROLES];
let mut leases = Vec::with_capacity(ROLES);
for (index, descriptor) in descriptors.iter().enumerate() {
let identity = identify(descriptor.as_raw_fd())?;
if index < 5 {
let seals = unsafe { libc::fcntl(descriptor.as_raw_fd(), libc::F_GET_SEALS) };
if identity.mode & libc::S_IFMT != libc::S_IFREG || seals < 0 || seals & SEALS != SEALS
{
return Err(refused());
}
} else {
let mut kind = 0i32;
let mut length = std::mem::size_of::<i32>() as libc::socklen_t;
if identity.mode & libc::S_IFMT != libc::S_IFSOCK
|| unsafe {
libc::getsockopt(
descriptor.as_raw_fd(),
libc::SOL_SOCKET,
libc::SO_TYPE,
(&raw mut kind).cast(),
&mut length,
)
} != 0
|| length as usize != std::mem::size_of::<i32>()
|| kind != libc::SOCK_SEQPACKET
{
return Err(refused());
}
}
let wanted = FIRST_ROLE + index as i32;
let actual = unsafe { libc::fcntl(descriptor.as_raw_fd(), libc::F_DUPFD_CLOEXEC, wanted) };
if actual < 0 {
return Err(io::Error::last_os_error());
}
let lease = unsafe { OwnedFd::from_raw_fd(actual) };
if actual != wanted {
return Err(refused());
}
identities[index] = identity;
leases.push(lease);
}
if identities[0].device != identities[2].device
|| identities[0].inode != identities[2].inode
|| (identities[5].device, identities[5].inode)
== (identities[6].device, identities[6].inode)
{
return Err(refused());
}
let leases: [OwnedFd; ROLES] = leases.try_into().map_err(|_| refused())?;
Ok(Box::new(Setup {
root,
entered: None,
frontend,
leases,
identities,
entered_once: false,
}))
}
unsafe impl NativeGuestSetup for Setup {
unsafe fn bind_and_enter(&mut self) -> io::Result<NativeRootObservation> {
if self.entered_once {
return Err(refused());
}
self.entered_once = true;
let entered = unsafe { self.root.bind_and_enter()? };
if (FIRST_ROLE..=DETLOG_FD).contains(&entered.descriptor().as_raw_fd()) {
return Err(refused());
}
for (index, lease) in self.leases.iter().enumerate() {
let found = identify(lease.as_raw_fd())?;
let expected = self.identities[index];
if (found.device, found.inode, found.mode)
!= (expected.device, expected.inode, expected.mode)
|| lease.as_raw_fd() != FIRST_ROLE + index as i32
{
return Err(refused());
}
if unsafe { libc::fcntl(lease.as_raw_fd(), libc::F_SETFD, 0) } != 0 {
return Err(io::Error::last_os_error());
}
}
unsafe { self.frontend.prepare_child()? };
let namespace = entered.namespace();
let observation = NativeRootObservation {
pid: entered.visible_pid(),
tid: unsafe { libc::syscall(libc::SYS_gettid) } as i32,
device: entered.device(),
inode: entered.inode(),
mount_id: entered.mount_id(),
namespace_device: namespace.0,
namespace_inode: namespace.1,
};
self.entered = Some(entered);
Ok(observation)
}
fn root_descriptor(&self) -> BorrowedFd<'_> {
self.entered
.as_ref()
.expect("entered root before transfer")
.descriptor()
}
unsafe fn install_frontend(&mut self) -> io::Result<()> {
let entered = self.entered.take().ok_or_else(refused)?;
drop(entered);
unsafe { self.frontend.install_child() }
}
}
fn identify(fd: i32) -> io::Result<Identity> {
let mut stat = std::mem::MaybeUninit::<libc::stat>::zeroed();
if unsafe { libc::fstat(fd, stat.as_mut_ptr()) } != 0 {
return Err(io::Error::last_os_error());
}
let stat = unsafe { stat.assume_init() };
Ok(Identity {
device: stat.st_dev,
inode: stat.st_ino,
mode: stat.st_mode,
})
}
fn refused() -> io::Error {
io::Error::from_raw_os_error(libc::EPERM)
}