A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// SPDX-License-Identifier: AGPL-3.0-or-later
use zstd::zstd_safe::zstd_sys::ZSTD_EndDirective;
use zstd::zstd_safe::{CCtx, CParameter, DCtx, DParameter, InBuffer, OutBuffer};
const READ_BUFFER_BYTES: usize = 16 * 1024;
const MAX_DECOMPRESSED_BYTES: usize = 64 * 1024 * 1024;
const ENCODER_WINDOW_LOG: u32 = 17;
const ENCODER_TABLE_LOG: u32 = 15;
const DECODER_WINDOW_LOG_MAX: u32 = 21;
#[derive(Debug)]
pub enum ZstdError {
DecompressedSizeTooLarge,
Decode,
Encode,
OutOfMemory,
}
impl ZstdError {
pub fn message(&self) -> &'static str {
match self {
Self::DecompressedSizeTooLarge => "zstd decompressed payload is too large",
Self::Decode => "zstd decompression failed",
Self::Encode => "zstd compression failed",
Self::OutOfMemory => "out of memory",
}
}
}
pub struct ZstdStreamEncoder {
context: CCtx<'static>,
}
impl ZstdStreamEncoder {
pub fn new(level: i32) -> Result<Self, ZstdError> {
let mut context = CCtx::try_create().ok_or(ZstdError::OutOfMemory)?;
for parameter in [
CParameter::CompressionLevel(level),
CParameter::WindowLog(ENCODER_WINDOW_LOG),
CParameter::HashLog(ENCODER_TABLE_LOG),
CParameter::ChainLog(ENCODER_TABLE_LOG),
] {
context
.set_parameter(parameter)
.map_err(|_| ZstdError::Encode)?;
}
Ok(Self { context })
}
pub fn compress_chunk(&mut self, input: &[u8]) -> Result<Vec<u8>, ZstdError> {
let mut input = InBuffer::around(input);
let mut output = Vec::new();
let mut buffer = [0u8; READ_BUFFER_BYTES];
loop {
let previous_input_pos = input.pos();
let (remaining, written) = {
let mut out_buffer = OutBuffer::around(&mut buffer[..]);
let remaining = self
.context
.compress_stream2(&mut out_buffer, &mut input, ZSTD_EndDirective::ZSTD_e_flush)
.map_err(|_| ZstdError::Encode)?;
(remaining, out_buffer.pos())
};
append_output(&mut output, &buffer[..written])?;
if remaining == 0 {
return Ok(output);
}
let made_progress = input.pos() > previous_input_pos || written > 0;
if !made_progress {
return Err(ZstdError::Encode);
}
}
}
}
pub struct ZstdStreamDecoder {
context: DCtx<'static>,
}
impl ZstdStreamDecoder {
pub fn new() -> Result<Self, ZstdError> {
let mut context = DCtx::try_create().ok_or(ZstdError::OutOfMemory)?;
context.init().map_err(|_| ZstdError::Decode)?;
context
.set_parameter(DParameter::WindowLogMax(DECODER_WINDOW_LOG_MAX))
.map_err(|_| ZstdError::Decode)?;
Ok(Self { context })
}
pub fn decompress_chunk(&mut self, input: &[u8]) -> Result<Vec<u8>, ZstdError> {
if input.is_empty() {
return Ok(Vec::new());
}
let mut input = InBuffer::around(input);
let mut output = Vec::new();
let mut buffer = [0u8; READ_BUFFER_BYTES];
loop {
let previous_input_pos = input.pos();
let (remaining, written) = {
let mut out_buffer = OutBuffer::around(&mut buffer[..]);
let remaining = self
.context
.decompress_stream(&mut out_buffer, &mut input)
.map_err(|_| ZstdError::Decode)?;
(remaining, out_buffer.pos())
};
append_output(&mut output, &buffer[..written])?;
let consumed = input.pos() > previous_input_pos;
if input.pos() == input.src.len() && written < buffer.len() {
return Ok(output);
}
if !consumed && written == 0 {
if remaining > 0 && input.pos() == input.src.len() {
return Ok(output);
}
return Err(ZstdError::Decode);
}
}
}
}
fn append_output(output: &mut Vec<u8>, bytes: &[u8]) -> Result<(), ZstdError> {
if bytes.is_empty() {
return Ok(());
}
let next_len = output
.len()
.checked_add(bytes.len())
.ok_or(ZstdError::DecompressedSizeTooLarge)?;
if next_len > MAX_DECOMPRESSED_BYTES {
return Err(ZstdError::DecompressedSizeTooLarge);
}
output
.try_reserve(bytes.len())
.map_err(|_| ZstdError::OutOfMemory)?;
output.extend_from_slice(bytes);
Ok(())
}