use std::io::BufRead;
use crate::import::ImportError;
pub(crate) fn within<T>(
input: &mut dyn BufRead,
limit: u64,
read: impl FnOnce(&mut dyn BufRead) -> Result<T, ImportError>,
) -> Result<T, ImportError> {
let mut bounded = Bounded::new(input, limit);
match read(&mut bounded) {
Err(_) if bounded.exhausted => Err(ImportError::DocumentTooLarge { limit }),
other => other,
}
}
struct Bounded<'a> {
inner: &'a mut dyn BufRead,
left: u64,
exhausted: bool,
}
impl<'a> Bounded<'a> {
fn new(inner: &'a mut dyn BufRead, limit: u64) -> Self {
Self {
inner,
left: limit,
exhausted: false,
}
}
fn over_budget(&mut self) -> std::io::Error {
self.exhausted = true;
std::io::Error::new(
std::io::ErrorKind::InvalidData,
"the document is past its byte ceiling",
)
}
}
impl Bounded<'_> {
fn overran(&mut self) -> std::io::Result<bool> {
Ok(self.left == 0 && !self.inner.fill_buf()?.is_empty())
}
}
impl std::io::Read for Bounded<'_> {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
if self.overran()? {
return Err(self.over_budget());
}
let ceiling = usize::try_from(self.left).unwrap_or(usize::MAX);
let take = buf.len().min(ceiling);
let read = self.inner.read(&mut buf[..take])?;
self.left -= read as u64;
Ok(read)
}
}
impl BufRead for Bounded<'_> {
fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
if self.overran()? {
return Err(self.over_budget());
}
let ceiling = usize::try_from(self.left).unwrap_or(usize::MAX);
let available = self.inner.fill_buf()?;
Ok(&available[..available.len().min(ceiling)])
}
fn consume(&mut self, amount: usize) {
self.left = self.left.saturating_sub(amount as u64);
self.inner.consume(amount);
}
}