servicepoint/servicepoint-binding-c
0
2
Fork 0
Code Issues 1 Pull requests 1 Projects Releases 2 Packages Wiki Activity Actions

fix compression, rename enum values

Browse source
This commit is contained in:
Vinzenz Schroeter 2024-05-16 21:32:33 +02:00
parent 7b6b4ea806
commit 6834bb084b
10 changed files with 119 additions and 123 deletions
Download patch file Download diff file Expand all files Collapse all files

15
servicepoint2/src/command.rs
View file

@ -252,12 +252,13 @@ fn bitmap_linear_into_packet(
compression: CompressionCode,
payload: Vec<u8>,
) -> Packet {
let length = payload.len() as u16;
let payload = into_compressed(compression, payload);
Packet(
Header(
command.into(),
offset,
payload.len() as u16,
length,
compression.into(),
0,
),
@ -290,12 +291,6 @@ fn packet_into_linear_bitmap(
if reserved != 0 {
return Err(TryFromPacketError::ExtraneousHeaderValues);
}
if payload.len() != length as usize {
return Err(TryFromPacketError::UnexpectedPayloadSize(
length as usize,
payload.len(),
));
}
let sub = match CompressionCode::try_from(sub) {
Err(_) => return Err(TryFromPacketError::InvalidCompressionCode(sub)),
Ok(value) => value,
@ -304,6 +299,12 @@ fn packet_into_linear_bitmap(
None => return Err(TryFromPacketError::DecompressionFailed),
Some(value) => value,
};
if payload.len() != length as usize {
return Err(TryFromPacketError::UnexpectedPayloadSize(
length as usize,
payload.len(),
));
}
Ok((BitVec::from(&*payload), sub))
}

98
servicepoint2/src/compression.rs
View file

@ -1,33 +1,40 @@
#[cfg(feature = "compression-bz")]
use bzip2::read::{BzDecoder, BzEncoder};
#[cfg(feature = "compression-gz")]
use flate2::read::{GzDecoder, GzEncoder};
#[cfg(feature = "compression-lz")]
use lz4::{Decoder as Lz4Decoder, EncoderBuilder as Lz4EncoderBuilder};
#[cfg(feature = "compression")]
use std::io::{Read, Write};
#[cfg(feature = "compression-zs")]
#[cfg(feature = "compression_bzip2")]
use bzip2::read::{BzDecoder, BzEncoder};
use flate2::{FlushCompress, FlushDecompress, Status};
#[cfg(feature = "compression_lzma")]
use lzma;
#[cfg(feature = "compression_zstd")]
use zstd::{Decoder as ZstdDecoder, Encoder as ZstdEncoder};
use crate::{CompressionCode, Payload};
pub(crate) fn into_decompressed(
kind: CompressionCode,
payload: Payload,
mut payload: Payload,
) -> Option<Payload> {
match kind {
CompressionCode::Uncompressed => Some(payload),
#[cfg(feature = "compression-gz")]
CompressionCode::Gz => {
let mut decoder = GzDecoder::new(&*payload);
let mut decompressed = vec![];
match decoder.read_to_end(&mut decompressed) {
Err(_) => None,
Ok(_) => Some(decompressed),
#[cfg(feature = "compression_zlib")]
CompressionCode::Zlib => {
let mut decompress = flate2::Decompress::new(true);
let mut buffer = [0u8; 10000];
let status = match decompress.decompress(&*payload, &mut buffer, FlushDecompress::Finish) {
Err(_) => return None,
Ok(status) => status,
};
match status {
Status::Ok => None,
Status::BufError => None,
Status::StreamEnd => Some(buffer[0..(decompress.total_out() as usize)].to_owned()),
}
}
#[cfg(feature = "compression-bz")]
CompressionCode::Bz => {
#[cfg(feature = "compression_bzip2")]
CompressionCode::Bzip2 => {
let mut decoder = BzDecoder::new(&*payload);
let mut decompressed = vec![];
match decoder.read_to_end(&mut decompressed) {
@ -35,20 +42,12 @@ pub(crate) fn into_decompressed(
Ok(_) => Some(decompressed),
}
}
#[cfg(feature = "compression-lz")]
CompressionCode::Lz => {
let mut decoder = match Lz4Decoder::new(&*payload) {
Err(_) => return None,
Ok(value) => value,
};
let mut decompressed = vec![];
match decoder.read_to_end(&mut decompressed) {
Err(_) => None,
Ok(_) => Some(decompressed),
}
#[cfg(feature = "compression_lzma")]
CompressionCode::Lzma => {
Some(lzma::decompress(&mut payload).unwrap())
}
#[cfg(feature = "compression-zs")]
CompressionCode::Zs => {
#[cfg(feature = "compression_zstd")]
CompressionCode::Zstd => {
let mut decoder = match ZstdDecoder::new(&*payload) {
Err(_) => return None,
Ok(value) => value,
@ -68,18 +67,20 @@ pub(crate) fn into_compressed(
) -> Payload {
match kind {
CompressionCode::Uncompressed => payload,
#[cfg(feature = "compression-gz")]
CompressionCode::Gz => {
let mut encoder =
GzEncoder::new(&*payload, flate2::Compression::fast());
let mut compressed = vec![];
match encoder.read_to_end(&mut compressed) {
Err(err) => panic!("could not compress payload: {}", err),
Ok(_) => compressed,
}
#[cfg(feature = "compression_zlib")]
CompressionCode::Zlib => {
let mut compress = flate2::Compress::new(flate2::Compression::fast(), true);
let mut buffer = [0u8; 10000];
match compress.compress(&*payload, &mut buffer, FlushCompress::Finish).expect("compress failed") {
Status::Ok => panic!("buffer should be big enough"),
Status::BufError => panic!("BufError"),
Status::StreamEnd => {}
};
buffer[..compress.total_out() as usize].to_owned()
}
#[cfg(feature = "compression-bz")]
CompressionCode::Bz => {
#[cfg(feature = "compression_bzip2")]
CompressionCode::Bzip2 => {
let mut encoder =
BzEncoder::new(&*payload, bzip2::Compression::fast());
let mut compressed = vec![];
@ -88,17 +89,12 @@ pub(crate) fn into_compressed(
Ok(_) => compressed,
}
}
#[cfg(feature = "compression-lz")]
CompressionCode::Lz => {
let mut encoder = Lz4EncoderBuilder::new()
.build(vec![])
.expect("could not create encoder");
encoder.write_all(&payload).expect("could not write payload");
let (payload, _) = encoder.finish();
payload
#[cfg(feature = "compression_lzma")]
CompressionCode::Lzma => {
lzma::compress(&payload, 6).unwrap()
}
#[cfg(feature = "compression-zs")]
CompressionCode::Zs => {
#[cfg(feature = "compression_zstd")]
CompressionCode::Zstd => {
let mut encoder =
ZstdEncoder::new(vec![], zstd::DEFAULT_COMPRESSION_LEVEL)
.expect("could not create encoder");

32
servicepoint2/src/compression_code.rs
View file

@ -5,14 +5,14 @@ use CompressionCode::*;
#[derive(Debug, Clone, Copy)]
pub enum CompressionCode {
Uncompressed = 0x0,
#[cfg(feature = "compression-gz")]
Gz = 0x677a,
#[cfg(feature = "compression-bz")]
Bz = 0x627a,
#[cfg(feature = "compression-lz")]
Lz = 0x6c7a,
#[cfg(feature = "compression-zs")]
Zs = 0x7a73,
#[cfg(feature = "compression_zlib")]
Zlib = 0x677a,
#[cfg(feature = "compression_bzip2")]
Bzip2 = 0x627a,
#[cfg(feature = "compression_lzma")]
Lzma = 0x6c7a,
#[cfg(feature = "compression_zstd")]
Zstd = 0x7a73,
}
impl From<CompressionCode> for u16 {
@ -27,14 +27,14 @@ impl TryFrom<u16> for CompressionCode {
fn try_from(value: u16) -> Result<Self, Self::Error> {
match value {
value if value == Uncompressed as u16 => Ok(Uncompressed),
#[cfg(feature = "compression-gz")]
value if value == Gz as u16 => Ok(Gz),
#[cfg(feature = "compression-bz")]
value if value == Bz as u16 => Ok(Bz),
#[cfg(feature = "compression-lz")]
value if value == Lz as u16 => Ok(Lz),
#[cfg(feature = "compression-zs")]
value if value == Zs as u16 => Ok(Zs),
#[cfg(feature = "compression_zlib")]
value if value == Zlib as u16 => Ok(Zlib),
#[cfg(feature = "compression_bzip2")]
value if value == Bzip2 as u16 => Ok(Bzip2),
#[cfg(feature = "compression_lzma")]
value if value == Lzma as u16 => Ok(Lzma),
#[cfg(feature = "compression_zstd")]
value if value == Zstd as u16 => Ok(Zstd),
_ => Err(()),
}
}