use core::fmt;
use crate::metadata::{ArchiveMetadata, EntryMetadata};
use crate::{ArchiveError, ErrorKind};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EndOfInput {
More,
End,
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum ProbeResult<T> {
Match(T),
NeedMore {
minimum: usize,
},
NoMatch,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum CodecStatus {
NeedInput,
NeedOutput,
Done,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CodecStep {
pub consumed: usize,
pub produced: usize,
pub status: CodecStatus,
}
impl CodecStep {
pub fn validate(self, input_len: usize, output_len: usize) -> Result<Self, ArchiveError> {
if self.consumed > input_len || self.produced > output_len {
return Err(ArchiveError::new(ErrorKind::Protocol)
.with_context("codec reported out-of-range progress"));
}
if self.consumed == 0 && self.produced == 0 {
let valid_wait = matches!(self.status, CodecStatus::NeedInput) && input_len == 0;
let valid_backpressure =
matches!(self.status, CodecStatus::NeedOutput) && output_len == 0;
if !valid_wait && !valid_backpressure && !matches!(self.status, CodecStatus::Done) {
return Err(
ArchiveError::new(ErrorKind::Protocol).with_context("codec made no progress")
);
}
}
Ok(self)
}
}
pub trait Codec {
fn process(
&mut self,
input: &[u8],
output: &mut [u8],
end: EndOfInput,
) -> Result<CodecStep, ArchiveError>;
}
#[derive(Clone, Copy)]
pub struct Chunk<'a> {
bytes: &'a [u8],
}
impl<'a> Chunk<'a> {
#[must_use]
pub const fn new(bytes: &'a [u8]) -> Self {
Self { bytes }
}
#[must_use]
pub const fn as_bytes(self) -> &'a [u8] {
self.bytes
}
}
impl fmt::Debug for Chunk<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Chunk")
.field("len", &self.bytes.len())
.finish()
}
}
#[derive(Debug)]
#[non_exhaustive]
#[allow(clippy::large_enum_variant)]
pub enum DecodeEvent<'a> {
NeedInput,
NeedOutput,
ArchiveMetadata(ArchiveMetadata),
Entry(EntryMetadata),
Data(Chunk<'a>),
EndEntry,
Done,
}
#[derive(Debug)]
pub struct DecodeStep<'a> {
pub consumed: usize,
pub produced: usize,
pub event: DecodeEvent<'a>,
}
impl DecodeStep<'_> {
pub fn validate(self, input_len: usize, output_len: usize) -> Result<Self, ArchiveError> {
if self.consumed > input_len || self.produced > output_len {
return Err(ArchiveError::new(ErrorKind::Protocol)
.with_context("archive decoder reported out-of-range progress"));
}
if self.consumed == 0 && self.produced == 0 {
let semantic_progress = match &self.event {
DecodeEvent::NeedInput
| DecodeEvent::NeedOutput
| DecodeEvent::ArchiveMetadata(_)
| DecodeEvent::Entry(_)
| DecodeEvent::EndEntry
| DecodeEvent::Done => true,
DecodeEvent::Data(chunk) => !chunk.bytes.is_empty(),
};
if !semantic_progress {
return Err(ArchiveError::new(ErrorKind::Protocol)
.with_context("archive decoder made no progress"));
}
}
Ok(self)
}
}
pub trait ArchiveDecoder {
fn step<'a>(
&'a mut self,
input: &'a [u8],
output: &'a mut [u8],
end: EndOfInput,
) -> Result<DecodeStep<'a>, ArchiveError>;
}
#[derive(Debug)]
#[non_exhaustive]
pub enum EncodeCommand<'a> {
BeginEntry(&'a EntryMetadata),
Data(&'a [u8]),
EndEntry,
Finish,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum EncodeStatus {
NeedCommand,
NeedOutput,
Done,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EncodeStep {
pub consumed: usize,
pub produced: usize,
pub status: EncodeStatus,
}
impl EncodeStep {
pub fn validate(
self,
data_input_len: Option<usize>,
output_len: usize,
) -> Result<Self, ArchiveError> {
let maximum = data_input_len.unwrap_or(1);
if self.consumed > maximum || self.produced > output_len {
return Err(ArchiveError::new(ErrorKind::Protocol)
.with_context("archive encoder reported out-of-range progress"));
}
if data_input_len.is_some()
&& self.consumed == 0
&& self.produced == 0
&& (!matches!(self.status, EncodeStatus::NeedOutput) || output_len != 0)
{
return Err(ArchiveError::new(ErrorKind::Protocol)
.with_context("archive encoder made no data progress"));
}
Ok(self)
}
}
pub trait ArchiveEncoder {
fn step(
&mut self,
command: EncodeCommand<'_>,
output: &mut [u8],
) -> Result<EncodeStep, ArchiveError>;
}