use std::{
convert::Infallible,
os::fd::{AsFd, BorrowedFd, OwnedFd},
};
use crate::{Error, Result};
pub trait Save {
fn saved_len(&self) -> Option<usize>;
fn save(&self, dest: &mut [u8]) -> Result<()>;
fn fds(&self) -> Vec<BorrowedFd<'_>>;
}
pub trait Restore: Sized {
type Error;
fn restore(record: &[u8], fds: Vec<OwnedFd>) -> std::result::Result<Self, Self::Error>;
}
impl Save for [u8] {
fn saved_len(&self) -> Option<usize> {
Some(self.len())
}
fn save(&self, dest: &mut [u8]) -> Result<()> {
dest.copy_from_slice(self);
Ok(())
}
fn fds(&self) -> Vec<BorrowedFd<'_>> {
Vec::new()
}
}
impl Save for Vec<u8> {
fn saved_len(&self) -> Option<usize> {
self.as_slice().saved_len()
}
fn save(&self, dest: &mut [u8]) -> Result<()> {
self.as_slice().save(dest)
}
fn fds(&self) -> Vec<BorrowedFd<'_>> {
Vec::new()
}
}
impl Save for OwnedFd {
fn saved_len(&self) -> Option<usize> {
Some(0)
}
fn save(&self, _dest: &mut [u8]) -> Result<()> {
Ok(())
}
fn fds(&self) -> Vec<BorrowedFd<'_>> {
vec![self.as_fd()]
}
}
impl Save for BorrowedFd<'_> {
fn saved_len(&self) -> Option<usize> {
Some(0)
}
fn save(&self, _dest: &mut [u8]) -> Result<()> {
Ok(())
}
fn fds(&self) -> Vec<BorrowedFd<'_>> {
vec![self.as_fd()]
}
}
impl<T> Save for &T
where
T: Save + ?Sized,
{
fn saved_len(&self) -> Option<usize> {
(**self).saved_len()
}
fn save(&self, dest: &mut [u8]) -> Result<()> {
(**self).save(dest)
}
fn fds(&self) -> Vec<BorrowedFd<'_>> {
(**self).fds()
}
}
impl<T> Save for Box<T>
where
T: Save + ?Sized,
{
fn saved_len(&self) -> Option<usize> {
(**self).saved_len()
}
fn save(&self, dest: &mut [u8]) -> Result<()> {
(**self).save(dest)
}
fn fds(&self) -> Vec<BorrowedFd<'_>> {
(**self).fds()
}
}
impl Restore for Vec<u8> {
type Error = Error;
fn restore(record: &[u8], fds: Vec<OwnedFd>) -> Result<Self> {
if !fds.is_empty() {
return Err(Error::InvalidHandover(format!(
"a record of bytes alone came with {} file descriptors",
fds.len()
)));
}
Ok(record.to_vec())
}
}
impl Restore for OwnedFd {
type Error = Error;
fn restore(record: &[u8], fds: Vec<OwnedFd>) -> Result<Self> {
let Ok([fd]) = <[OwnedFd; 1]>::try_from(fds) else {
return Err(Error::InvalidHandover(
"a file descriptor came with other than one".to_owned(),
));
};
if !record.is_empty() {
return Err(Error::InvalidHandover(
"a file descriptor came with a record".to_owned(),
));
}
Ok(fd)
}
}
impl Restore for (Vec<u8>, Vec<OwnedFd>) {
type Error = Infallible;
fn restore(record: &[u8], fds: Vec<OwnedFd>) -> std::result::Result<Self, Infallible> {
Ok((record.to_vec(), fds))
}
}
#[cfg(test)]
mod tests {
use std::os::fd::AsRawFd;
use super::*;
use crate::test_utils::pipe;
#[test]
fn bytes() {
let bytes = b"a record".to_vec();
let mut dest = vec![0; bytes.saved_len().unwrap()];
bytes.save(&mut dest).unwrap();
assert_eq!(dest, bytes);
assert!(bytes.fds().is_empty());
assert_eq!(Vec::<u8>::restore(&dest, Vec::new()).unwrap(), bytes);
let (_, write) = pipe();
let error = Vec::<u8>::restore(&dest, vec![write]).unwrap_err();
assert!(matches!(error, Error::InvalidHandover(_)), "{error:?}");
}
#[test]
fn fd() {
let (read, write) = pipe();
assert_eq!(write.saved_len(), Some(0));
let fds = write.fds();
assert_eq!(fds.len(), 1);
assert_eq!(fds[0].as_raw_fd(), write.as_raw_fd());
assert_eq!(write.as_fd().fds()[0].as_raw_fd(), write.as_raw_fd());
let restored = OwnedFd::restore(&[], vec![write]).unwrap();
let error = OwnedFd::restore(b"x", vec![restored]).unwrap_err();
assert!(matches!(error, Error::InvalidHandover(_)), "{error:?}");
let error = OwnedFd::restore(&[], Vec::new()).unwrap_err();
assert!(matches!(error, Error::InvalidHandover(_)), "{error:?}");
let error = OwnedFd::restore(&[], vec![read, pipe().1]).unwrap_err();
assert!(matches!(error, Error::InvalidHandover(_)), "{error:?}");
}
#[test]
fn dyn_items() {
let (_, write) = pipe();
let bytes = vec![1, 2, 3];
let items: Vec<Box<dyn Save + '_>> = vec![Box::new(&bytes), Box::new(write.as_fd())];
let lens: Vec<_> = items.iter().map(|item| item.saved_len()).collect();
assert_eq!(lens, [Some(3), Some(0)]);
let fds: Vec<_> = items.iter().map(|item| item.fds().len()).collect();
assert_eq!(fds, [0, 1]);
}
#[test]
fn raw() {
let (_, write) = pipe();
let (record, fds) = <(Vec<u8>, Vec<OwnedFd>)>::restore(b"raw", vec![write]).unwrap();
assert_eq!(record, b"raw");
assert_eq!(fds.len(), 1);
}
}