use std::{
io::{self, ErrorKind},
ops::Range,
};
use crate::{Error, Result};
#[derive(Debug)]
pub(crate) struct Layout {
state: Range<usize>,
items: Vec<Range<usize>>,
len: usize,
}
impl Layout {
pub(crate) fn new<I>(state_len: usize, item_lens: I) -> io::Result<Self>
where
I: ExactSizeIterator<Item = usize>,
{
let table_len = item_lens
.len()
.checked_mul(ENTRY_LEN)
.ok_or_else(too_long)?;
let mut end = HEADER_LEN.checked_add(table_len).ok_or_else(too_long)?;
let mut place = |len: usize| -> io::Result<Range<usize>> {
let start = end;
end = start
.checked_add(len)
.and_then(|end| end.checked_next_multiple_of(8))
.ok_or_else(too_long)?;
Ok(start..start + len)
};
let state = place(state_len)?;
let items = item_lens.map(&mut place).collect::<io::Result<_>>()?;
if isize::try_from(end).is_err() {
return Err(too_long());
}
Ok(Self {
state,
items,
len: end,
})
}
pub(crate) fn len(&self) -> usize {
self.len
}
pub(crate) fn state(&self) -> Range<usize> {
self.state.clone()
}
pub(crate) fn item(&self, index: usize) -> Range<usize> {
self.items[index].clone()
}
pub(crate) fn write(&self, memfd: &mut [u8], state_fds: usize, entries: &[Entry]) {
let fds = state_fds as u64 + entries.iter().map(Entry::fd_count).sum::<u64>();
let mut header = Writer(&mut memfd[..HEADER_LEN]);
header.put(MAGIC);
header.put(&MAJOR.to_le_bytes());
header.put(&(HEADER_LEN as u16).to_le_bytes());
header.put(&0u32.to_le_bytes());
for value in [
self.len as u64,
entries.len() as u64,
fds,
self.state.start as u64,
self.state.len() as u64,
state_fds as u64,
] {
header.put(&value.to_le_bytes());
}
let table_len = entries.len() * ENTRY_LEN;
let mut table = Writer(&mut memfd[HEADER_LEN..HEADER_LEN + table_len]);
for entry in entries {
for value in [
entry.id,
entry.record.start as u64,
entry.record.len() as u64,
entry.fds.start,
entry.fd_count(),
] {
table.put(&value.to_le_bytes());
}
}
}
}
#[derive(Debug, PartialEq, Eq)]
pub(crate) struct Entry {
pub(crate) id: u64,
pub(crate) record: Range<usize>,
pub(crate) fds: Range<u64>,
}
impl Entry {
fn fd_count(&self) -> u64 {
self.fds.end - self.fds.start
}
}
#[derive(Debug)]
pub(crate) struct Contents {
pub(crate) state: Range<usize>,
pub(crate) state_fds: u64,
pub(crate) entries: Vec<Entry>,
}
pub(crate) fn read(memfd: &[u8]) -> Result<Contents> {
if memfd.get(..MAGIC.len()) != Some(MAGIC) {
return Err(malformed());
}
match u16::from_le_bytes(field(memfd, 8)?) {
MAJOR => (),
major if major > MAJOR => {
return Err(Error::UnsupportedHandover(format!(
"the hand-over is of version {major} of its format, later than {MAJOR}"
)));
}
_ => return Err(malformed()),
}
let header_len = usize::from(u16::from_le_bytes(field(memfd, 10)?));
if header_len % 8 != 0 || header_len < HEADER_LEN {
return Err(malformed());
}
if u32::from_le_bytes(field(memfd, 12)?) & !KNOWN_FEATURES != 0 {
return Err(Error::UnsupportedHandover(
"the hand-over needs a feature of its format that this version of zoter doesn't know"
.to_owned(),
));
}
if number(memfd, 16)? != memfd.len() as u64 {
return Err(malformed());
}
let count = usize::try_from(number(memfd, 24)?).map_err(|_| malformed())?;
let fds = number(memfd, 32)?;
let state = record(memfd, number(memfd, 40)?, number(memfd, 48)?)?;
let state_fds = number(memfd, 56)?;
if state_fds > fds {
return Err(malformed());
}
let table_len = count.checked_mul(ENTRY_LEN).ok_or_else(malformed)?;
let table = header_len
.checked_add(table_len)
.and_then(|end| memfd.get(header_len..end))
.ok_or_else(malformed)?;
let entries = table
.as_chunks::<ENTRY_LEN>()
.0
.iter()
.map(|entry| -> Result<Entry> {
let first = number(entry, 24)?;
let end = first
.checked_add(number(entry, 32)?)
.ok_or_else(malformed)?;
if end > fds {
return Err(malformed());
}
Ok(Entry {
id: number(entry, 0)?,
record: record(memfd, number(entry, 8)?, number(entry, 16)?)?,
fds: first..end,
})
})
.collect::<Result<_>>()?;
Ok(Contents {
state,
state_fds,
entries,
})
}
struct Writer<'d>(&'d mut [u8]);
impl Writer<'_> {
fn put(&mut self, bytes: &[u8]) {
let (head, rest) = std::mem::take(&mut self.0).split_at_mut(bytes.len());
head.copy_from_slice(bytes);
self.0 = rest;
}
}
fn field<const N: usize>(bytes: &[u8], at: usize) -> Result<[u8; N]> {
let field = at
.checked_add(N)
.and_then(|end| bytes.get(at..end))
.ok_or_else(malformed)?;
Ok(field
.try_into()
.expect("the bytes of a field are as many as it has"))
}
fn number(bytes: &[u8], at: usize) -> Result<u64> {
field(bytes, at).map(u64::from_le_bytes)
}
fn record(memfd: &[u8], offset: u64, len: u64) -> Result<Range<usize>> {
let start = usize::try_from(offset).map_err(|_| malformed())?;
let end = usize::try_from(len)
.ok()
.and_then(|len| start.checked_add(len))
.ok_or_else(malformed)?;
if end > memfd.len() {
return Err(malformed());
}
Ok(start..end)
}
fn malformed() -> Error {
Error::InvalidHandover("the memfd of the hand-over isn't one that zoter laid out".to_owned())
}
fn too_long() -> io::Error {
io::Error::new(
ErrorKind::InvalidInput,
"the hand-over is longer than a memfd can be",
)
}
const MAGIC: &[u8; 8] = b"zoter\0\0\0";
const MAJOR: u16 = 1;
const KNOWN_FEATURES: u32 = 0;
const HEADER_LEN: usize = 64;
const ENTRY_LEN: usize = 40;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn round_trip() {
let layout = Layout::new(5, [3, 0, 9].into_iter()).unwrap();
assert_eq!(layout.state(), 184..189);
assert_eq!(layout.item(0), 192..195);
assert_eq!(layout.item(1), 200..200);
assert_eq!(layout.item(2), 200..209);
assert_eq!(layout.len(), 216);
let mut memfd = vec![0; layout.len()];
memfd[layout.state()].copy_from_slice(b"state");
let entries = [
Entry {
id: 7,
record: layout.item(0),
fds: 2..3,
},
Entry {
id: u64::MAX,
record: layout.item(2),
fds: 3..5,
},
];
layout.write(&mut memfd, 2, &entries);
let contents = read(&memfd).unwrap();
assert_eq!(&memfd[contents.state], b"state");
assert_eq!(contents.state_fds, 2);
assert_eq!(contents.entries, entries);
}
#[test]
fn empty() {
let layout = Layout::new(0, [].into_iter()).unwrap();
let mut memfd = vec![0; layout.len()];
layout.write(&mut memfd, 0, &[]);
let contents = read(&memfd).unwrap();
assert!(contents.state.is_empty());
assert_eq!(contents.state_fds, 0);
assert!(contents.entries.is_empty());
}
#[test]
fn too_long_for_a_memfd() {
let error = Layout::new(usize::MAX - 8, [].into_iter()).unwrap_err();
assert_eq!(error.kind(), ErrorKind::InvalidInput);
let error = Layout::new(0, [isize::MAX as usize].into_iter()).unwrap_err();
assert_eq!(error.kind(), ErrorKind::InvalidInput);
}
#[test]
fn others_are_refused() {
let layout = Layout::new(5, [3].into_iter()).unwrap();
let mut memfd = vec![0; layout.len()];
let entry = Entry {
id: 1,
record: layout.item(0),
fds: 0..1,
};
layout.write(&mut memfd, 0, &[entry]);
read(&memfd).unwrap();
let unsupported: [(usize, &[u8]); 2] =
[(8, &2u16.to_le_bytes()), (12, &1u32.to_le_bytes())];
for (at, bytes) in unsupported {
let mut spoiled = memfd.clone();
spoiled[at..at + bytes.len()].copy_from_slice(bytes);
let error = read(&spoiled).unwrap_err();
assert!(
matches!(error, Error::UnsupportedHandover(_)),
"at {at}: {error:?}"
);
}
let malformed: [(usize, &[u8]); 9] = [
(0, b"x"),
(8, &0u16.to_le_bytes()),
(10, &56u16.to_le_bytes()),
(10, &65u16.to_le_bytes()),
(16, &1u64.to_le_bytes()),
(24, &2u64.to_le_bytes()),
(48, &(layout.len() as u64).to_le_bytes()),
(56, &2u64.to_le_bytes()),
(64 + 32, &2u64.to_le_bytes()),
];
for (at, bytes) in malformed {
let mut spoiled = memfd.clone();
spoiled[at..at + bytes.len()].copy_from_slice(bytes);
let error = read(&spoiled).unwrap_err();
assert!(
matches!(error, Error::InvalidHandover(_)),
"at {at}: {error:?}"
);
}
assert!(read(&memfd[..63]).is_err());
assert!(read(b"").is_err());
}
}