Merge branch 'master' into no-thiserror
This commit is contained in:
Plecra
commit
cfe3bbfa26
GPG key ID:
4AEE18F83AFDEB23
19 changed files with 228 additions and 168 deletions
23
.github/workflows/ci.yaml
vendored
23
.github/workflows/ci.yaml
vendored
|
|
@ -16,7 +16,7 @@ jobs:
|
|||
strategy:
|
||||
matrix:
|
||||
os: [ubuntu-latest, macOS-latest, windows-latest]
|
||||
rust: [stable, 1.36.0]
|
||||
rust: [stable, 1.54.0]
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@master
|
||||
|
|
@ -39,6 +39,25 @@ jobs:
|
|||
command: test
|
||||
args: --all
|
||||
|
||||
clippy:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
|
||||
- uses: actions-rs/toolchain@v1
|
||||
with:
|
||||
profile: minimal
|
||||
toolchain: nightly
|
||||
override: true
|
||||
components: clippy
|
||||
|
||||
- name: clippy
|
||||
uses: actions-rs/cargo@v1
|
||||
with:
|
||||
command: clippy
|
||||
args: --all-targets --all-features -- -D warnings
|
||||
|
||||
check_fmt_and_docs:
|
||||
name: Checking fmt and docs
|
||||
runs-on: ubuntu-latest
|
||||
|
|
@ -54,4 +73,4 @@ jobs:
|
|||
run: cargo fmt --all -- --check
|
||||
|
||||
- name: Docs
|
||||
run: cargo doc
|
||||
run: cargo doc
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
|
||||
# Contributor Covenant Code of Conduct
|
||||
|
||||
## Our Pledge
|
||||
|
|
|
|||
10
Cargo.toml
10
Cargo.toml
|
|
@ -12,14 +12,16 @@ edition = "2018"
|
|||
|
||||
[dependencies]
|
||||
flate2 = { version = "1.0.0", default-features = false, optional = true }
|
||||
time = { version = "0.1", optional = true }
|
||||
time = { version = "0.3", features = ["formatting", "macros" ], optional = true }
|
||||
byteorder = "1.3"
|
||||
bzip2 = { version = "0.4", optional = true }
|
||||
crc32fast = "1.0"
|
||||
crc32fast = "1.1.1"
|
||||
thiserror = "1.0.7"
|
||||
zstd = { version = "0.10", optional = true }
|
||||
|
||||
[dev-dependencies]
|
||||
bencher = "0.1"
|
||||
rand = "0.7"
|
||||
getrandom = "0.2"
|
||||
walkdir = "2"
|
||||
|
||||
[features]
|
||||
|
|
@ -27,7 +29,7 @@ deflate = ["flate2/rust_backend"]
|
|||
deflate-miniz = ["flate2/default"]
|
||||
deflate-zlib = ["flate2/zlib"]
|
||||
unreserved = []
|
||||
default = ["bzip2", "deflate", "time"]
|
||||
default = ["bzip2", "deflate", "time", "zstd"]
|
||||
|
||||
[[bench]]
|
||||
name = "read_entry"
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@ Supported compression formats:
|
|||
* stored (i.e. none)
|
||||
* deflate
|
||||
* bzip2
|
||||
* zstd
|
||||
|
||||
Currently unsupported zip extensions:
|
||||
|
||||
|
|
@ -42,16 +43,17 @@ zip = { version = "0.5", default-features = false }
|
|||
|
||||
The features available are:
|
||||
|
||||
* `deflate`: Enables the deflate compression algorithm, which is the default for zipfiles
|
||||
* `deflate`: Enables the deflate compression algorithm, which is the default for zip files.
|
||||
* `bzip2`: Enables the BZip2 compression algorithm.
|
||||
* `time`: Enables features using the [time](https://github.com/rust-lang-deprecated/time) crate.
|
||||
* `zstd`: Enables the Zstandard compression algorithm.
|
||||
|
||||
All of these are enabled by default.
|
||||
|
||||
MSRV
|
||||
----
|
||||
|
||||
Our current Minimum Supported Rust Version is **1.36.0**. When adding features,
|
||||
Our current Minimum Supported Rust Version is **1.54.0**. When adding features,
|
||||
we will follow these guidelines:
|
||||
|
||||
- We will always support the latest four minor Rust versions. This gives you a 6
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@ use bencher::{benchmark_group, benchmark_main};
|
|||
use std::io::{Cursor, Read, Write};
|
||||
|
||||
use bencher::Bencher;
|
||||
use rand::Rng;
|
||||
use getrandom::getrandom;
|
||||
use zip::{ZipArchive, ZipWriter};
|
||||
|
||||
fn generate_random_archive(size: usize) -> Vec<u8> {
|
||||
|
|
@ -14,7 +14,7 @@ fn generate_random_archive(size: usize) -> Vec<u8> {
|
|||
|
||||
writer.start_file("random.dat", options).unwrap();
|
||||
let mut bytes = vec![0u8; size];
|
||||
rand::thread_rng().fill_bytes(&mut bytes);
|
||||
getrandom(&mut bytes).unwrap();
|
||||
writer.write_all(&bytes).unwrap();
|
||||
|
||||
writer.finish().unwrap().into_inner()
|
||||
|
|
|
|||
|
|
@ -59,5 +59,6 @@ fn real_main() -> i32 {
|
|||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
||||
0
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,5 +27,5 @@ fn real_main() -> i32 {
|
|||
file.read_to_string(&mut contents).unwrap();
|
||||
println!("{}", contents);
|
||||
|
||||
return 0;
|
||||
0
|
||||
}
|
||||
|
|
|
|||
|
|
@ -49,5 +49,6 @@ fn real_main() -> i32 {
|
|||
);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
||||
0
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,5 +30,6 @@ fn real_main() -> i32 {
|
|||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
||||
0
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,6 +32,11 @@ const METHOD_BZIP2: Option<zip::CompressionMethod> = Some(zip::CompressionMethod
|
|||
#[cfg(not(feature = "bzip2"))]
|
||||
const METHOD_BZIP2: Option<zip::CompressionMethod> = None;
|
||||
|
||||
#[cfg(feature = "zstd")]
|
||||
const METHOD_ZSTD: Option<zip::CompressionMethod> = Some(zip::CompressionMethod::Zstd);
|
||||
#[cfg(not(feature = "zstd"))]
|
||||
const METHOD_ZSTD: Option<zip::CompressionMethod> = None;
|
||||
|
||||
fn real_main() -> i32 {
|
||||
let args: Vec<_> = std::env::args().collect();
|
||||
if args.len() < 3 {
|
||||
|
|
@ -44,7 +49,7 @@ fn real_main() -> i32 {
|
|||
|
||||
let src_dir = &*args[1];
|
||||
let dst_file = &*args[2];
|
||||
for &method in [METHOD_STORED, METHOD_DEFLATED, METHOD_BZIP2].iter() {
|
||||
for &method in [METHOD_STORED, METHOD_DEFLATED, METHOD_BZIP2, METHOD_ZSTD].iter() {
|
||||
if method.is_none() {
|
||||
continue;
|
||||
}
|
||||
|
|
@ -54,7 +59,7 @@ fn real_main() -> i32 {
|
|||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
0
|
||||
}
|
||||
|
||||
fn zip_dir<T>(
|
||||
|
|
@ -87,7 +92,7 @@ where
|
|||
f.read_to_end(&mut buffer)?;
|
||||
zip.write_all(&*buffer)?;
|
||||
buffer.clear();
|
||||
} else if name.as_os_str().len() != 0 {
|
||||
} else if !name.as_os_str().is_empty() {
|
||||
// Only if not root! Avoids path spec / warning
|
||||
// and mapname conversion failed error on unzip
|
||||
println!("adding dir {:?} as {:?} ...", path, name);
|
||||
|
|
@ -111,7 +116,7 @@ fn doit(
|
|||
let path = Path::new(dst_file);
|
||||
let file = File::create(&path).unwrap();
|
||||
|
||||
let walkdir = WalkDir::new(src_dir.to_string());
|
||||
let walkdir = WalkDir::new(src_dir);
|
||||
let it = walkdir.into_iter();
|
||||
|
||||
zip_dir(&mut it.filter_map(|e| e.ok()), src_dir, file, method)?;
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ fn real_main() -> i32 {
|
|||
Err(e) => println!("Error: {:?}", e),
|
||||
}
|
||||
|
||||
return 0;
|
||||
0
|
||||
}
|
||||
|
||||
fn doit(filename: &str) -> zip::result::ZipResult<()> {
|
||||
|
|
@ -42,7 +42,7 @@ fn doit(filename: &str) -> zip::result::ZipResult<()> {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
const LOREM_IPSUM : &'static [u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. In tellus elit, tristique vitae mattis egestas, ultricies vitae risus. Quisque sit amet quam ut urna aliquet
|
||||
const LOREM_IPSUM : &[u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. In tellus elit, tristique vitae mattis egestas, ultricies vitae risus. Quisque sit amet quam ut urna aliquet
|
||||
molestie. Proin blandit ornare dui, a tempor nisl accumsan in. Praesent a consequat felis. Morbi metus diam, auctor in auctor vel, feugiat id odio. Curabitur ex ex,
|
||||
dictum quis auctor quis, suscipit id lorem. Aliquam vestibulum dolor nec enim vehicula, porta tristique augue tincidunt. Vivamus ut gravida est. Sed pellentesque, dolor
|
||||
vitae tristique consectetur, neque lectus pulvinar dui, sed feugiat purus diam id lectus. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ use std::fmt;
|
|||
/// contents to be read without context.
|
||||
///
|
||||
/// When creating ZIP files, you may choose the method to use with
|
||||
/// [`zip::write::FileOptions::compression_method`]
|
||||
/// [`crate::write::FileOptions::compression_method`]
|
||||
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
|
||||
pub enum CompressionMethod {
|
||||
/// Store the file as is
|
||||
|
|
@ -24,6 +24,9 @@ pub enum CompressionMethod {
|
|||
/// Compress the file using BZIP2
|
||||
#[cfg(feature = "bzip2")]
|
||||
Bzip2,
|
||||
/// Compress the file using ZStandard
|
||||
#[cfg(feature = "zstd")]
|
||||
Zstd,
|
||||
/// Unsupported compression method
|
||||
#[deprecated(since = "0.5.7", note = "use the constants instead")]
|
||||
Unsupported(u16),
|
||||
|
|
@ -60,6 +63,9 @@ impl CompressionMethod {
|
|||
pub const IBM_ZOS_CMPSC: Self = CompressionMethod::Unsupported(16);
|
||||
pub const IBM_TERSE: Self = CompressionMethod::Unsupported(18);
|
||||
pub const ZSTD_DEPRECATED: Self = CompressionMethod::Unsupported(20);
|
||||
#[cfg(feature = "zstd")]
|
||||
pub const ZSTD: Self = CompressionMethod::Zstd;
|
||||
#[cfg(not(feature = "zstd"))]
|
||||
pub const ZSTD: Self = CompressionMethod::Unsupported(93);
|
||||
pub const MP3: Self = CompressionMethod::Unsupported(94);
|
||||
pub const XZ: Self = CompressionMethod::Unsupported(95);
|
||||
|
|
@ -85,6 +91,8 @@ impl CompressionMethod {
|
|||
8 => CompressionMethod::Deflated,
|
||||
#[cfg(feature = "bzip2")]
|
||||
12 => CompressionMethod::Bzip2,
|
||||
#[cfg(feature = "zstd")]
|
||||
93 => CompressionMethod::Zstd,
|
||||
|
||||
v => CompressionMethod::Unsupported(v),
|
||||
}
|
||||
|
|
@ -107,6 +115,9 @@ impl CompressionMethod {
|
|||
CompressionMethod::Deflated => 8,
|
||||
#[cfg(feature = "bzip2")]
|
||||
CompressionMethod::Bzip2 => 12,
|
||||
#[cfg(feature = "zstd")]
|
||||
CompressionMethod::Zstd => 93,
|
||||
|
||||
CompressionMethod::Unsupported(v) => v,
|
||||
}
|
||||
}
|
||||
|
|
@ -125,7 +136,7 @@ mod test {
|
|||
|
||||
#[test]
|
||||
fn from_eq_to() {
|
||||
for v in 0..(::std::u16::MAX as u32 + 1) {
|
||||
for v in 0..(u16::MAX as u32 + 1) {
|
||||
#[allow(deprecated)]
|
||||
let from = CompressionMethod::from_u16(v as u16);
|
||||
#[allow(deprecated)]
|
||||
|
|
@ -135,17 +146,19 @@ mod test {
|
|||
}
|
||||
|
||||
fn methods() -> Vec<CompressionMethod> {
|
||||
let mut methods = Vec::new();
|
||||
methods.push(CompressionMethod::Stored);
|
||||
#[cfg(any(
|
||||
feature = "deflate",
|
||||
feature = "deflate-miniz",
|
||||
feature = "deflate-zlib"
|
||||
))]
|
||||
methods.push(CompressionMethod::Deflated);
|
||||
#[cfg(feature = "bzip2")]
|
||||
methods.push(CompressionMethod::Bzip2);
|
||||
methods
|
||||
vec![
|
||||
CompressionMethod::Stored,
|
||||
#[cfg(any(
|
||||
feature = "deflate",
|
||||
feature = "deflate-miniz",
|
||||
feature = "deflate-zlib"
|
||||
))]
|
||||
CompressionMethod::Deflated,
|
||||
#[cfg(feature = "bzip2")]
|
||||
CompressionMethod::Bzip2,
|
||||
#[cfg(feature = "zstd")]
|
||||
CompressionMethod::Zstd,
|
||||
]
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
|
|
@ -6,7 +6,8 @@ pub trait FromCp437 {
|
|||
type Target;
|
||||
|
||||
/// Function that does the conversion from cp437.
|
||||
/// Gennerally allocations will be avoided if all data falls into the ASCII range.
|
||||
/// Generally allocations will be avoided if all data falls into the ASCII range.
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_cp437(self) -> Self::Target;
|
||||
}
|
||||
|
||||
|
|
|
|||
52
src/read.rs
52
src/read.rs
|
|
@ -24,6 +24,9 @@ use flate2::read::DeflateDecoder;
|
|||
#[cfg(feature = "bzip2")]
|
||||
use bzip2::read::BzDecoder;
|
||||
|
||||
#[cfg(feature = "zstd")]
|
||||
use zstd::stream::read::Decoder as ZstdDecoder;
|
||||
|
||||
mod ffi {
|
||||
pub const S_IFDIR: u32 = 0o0040000;
|
||||
pub const S_IFREG: u32 = 0o0100000;
|
||||
|
|
@ -90,6 +93,8 @@ enum ZipFileReader<'a> {
|
|||
Deflated(Crc32Reader<flate2::read::DeflateDecoder<CryptoReader<'a>>>),
|
||||
#[cfg(feature = "bzip2")]
|
||||
Bzip2(Crc32Reader<BzDecoder<CryptoReader<'a>>>),
|
||||
#[cfg(feature = "zstd")]
|
||||
Zstd(Crc32Reader<ZstdDecoder<'a, io::BufReader<CryptoReader<'a>>>>),
|
||||
}
|
||||
|
||||
impl<'a> Read for ZipFileReader<'a> {
|
||||
|
|
@ -106,6 +111,8 @@ impl<'a> Read for ZipFileReader<'a> {
|
|||
ZipFileReader::Deflated(r) => r.read(buf),
|
||||
#[cfg(feature = "bzip2")]
|
||||
ZipFileReader::Bzip2(r) => r.read(buf),
|
||||
#[cfg(feature = "zstd")]
|
||||
ZipFileReader::Zstd(r) => r.read(buf),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -125,6 +132,8 @@ impl<'a> ZipFileReader<'a> {
|
|||
ZipFileReader::Deflated(r) => r.into_inner().into_inner().into_inner(),
|
||||
#[cfg(feature = "bzip2")]
|
||||
ZipFileReader::Bzip2(r) => r.into_inner().into_inner().into_inner(),
|
||||
#[cfg(feature = "zstd")]
|
||||
ZipFileReader::Zstd(r) => r.into_inner().finish().into_inner().into_inner(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -189,11 +198,11 @@ fn make_crypto_reader<'a>(
|
|||
Ok(Ok(reader))
|
||||
}
|
||||
|
||||
fn make_reader<'a>(
|
||||
fn make_reader(
|
||||
compression_method: CompressionMethod,
|
||||
crc32: u32,
|
||||
reader: CryptoReader<'a>,
|
||||
) -> ZipFileReader<'a> {
|
||||
reader: CryptoReader,
|
||||
) -> ZipFileReader {
|
||||
match compression_method {
|
||||
CompressionMethod::Stored => ZipFileReader::Stored(Crc32Reader::new(reader, crc32)),
|
||||
#[cfg(any(
|
||||
|
|
@ -210,6 +219,11 @@ fn make_reader<'a>(
|
|||
let bzip2_reader = BzDecoder::new(reader);
|
||||
ZipFileReader::Bzip2(Crc32Reader::new(bzip2_reader, crc32))
|
||||
}
|
||||
#[cfg(feature = "zstd")]
|
||||
CompressionMethod::Zstd => {
|
||||
let zstd_reader = ZstdDecoder::new(reader).unwrap();
|
||||
ZipFileReader::Zstd(Crc32Reader::new(zstd_reader, crc32))
|
||||
}
|
||||
_ => panic!("Compression method not supported"),
|
||||
}
|
||||
}
|
||||
|
|
@ -303,7 +317,7 @@ impl<R: Read + io::Seek> ZipArchive<R> {
|
|||
let directory_start = footer
|
||||
.central_directory_offset
|
||||
.checked_add(archive_offset)
|
||||
.ok_or_else(|| {
|
||||
.ok_or({
|
||||
ZipError::InvalidArchive("Invalid central directory size or offset")
|
||||
})?;
|
||||
|
||||
|
|
@ -332,7 +346,7 @@ impl<R: Read + io::Seek> ZipArchive<R> {
|
|||
let mut files = Vec::new();
|
||||
let mut names_map = HashMap::new();
|
||||
|
||||
if let Err(_) = reader.seek(io::SeekFrom::Start(directory_start)) {
|
||||
if reader.seek(io::SeekFrom::Start(directory_start)).is_err() {
|
||||
return Err(ZipError::InvalidArchive(
|
||||
"Could not seek to start of central directory",
|
||||
));
|
||||
|
|
@ -457,14 +471,14 @@ impl<R: Read + io::Seek> ZipArchive<R> {
|
|||
}
|
||||
|
||||
/// Get a contained file by index
|
||||
pub fn by_index<'a>(&'a mut self, file_number: usize) -> ZipResult<ZipFile<'a>> {
|
||||
pub fn by_index(&mut self, file_number: usize) -> ZipResult<ZipFile<'_>> {
|
||||
Ok(self
|
||||
.by_index_with_optional_password(file_number, None)?
|
||||
.unwrap())
|
||||
}
|
||||
|
||||
/// Get a contained file by index without decompressing it
|
||||
pub fn by_index_raw<'a>(&'a mut self, file_number: usize) -> ZipResult<ZipFile<'a>> {
|
||||
pub fn by_index_raw(&mut self, file_number: usize) -> ZipResult<ZipFile<'_>> {
|
||||
let reader = &mut self.reader;
|
||||
self.files
|
||||
.get_mut(file_number)
|
||||
|
|
@ -603,7 +617,10 @@ pub(crate) fn central_header_to_zip_file<R: Read + io::Seek>(
|
|||
}
|
||||
|
||||
// Account for shifted zip offsets.
|
||||
result.header_start += archive_offset;
|
||||
result.header_start = result
|
||||
.header_start
|
||||
.checked_add(archive_offset)
|
||||
.ok_or(ZipError::InvalidArchive("Archive header is too large"))?;
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
|
|
@ -1017,7 +1034,7 @@ mod test {
|
|||
let mut v = Vec::new();
|
||||
v.extend_from_slice(include_bytes!("../tests/data/zip64_demo.zip"));
|
||||
let reader = ZipArchive::new(io::Cursor::new(v)).unwrap();
|
||||
assert!(reader.len() == 1);
|
||||
assert_eq!(reader.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -1028,7 +1045,7 @@ mod test {
|
|||
let mut v = Vec::new();
|
||||
v.extend_from_slice(include_bytes!("../tests/data/mimetype.zip"));
|
||||
let mut reader = ZipArchive::new(io::Cursor::new(v)).unwrap();
|
||||
assert!(reader.comment() == b"");
|
||||
assert_eq!(reader.comment(), b"");
|
||||
assert_eq!(reader.by_index(0).unwrap().central_header_start(), 77);
|
||||
}
|
||||
|
||||
|
|
@ -1041,9 +1058,8 @@ mod test {
|
|||
v.extend_from_slice(include_bytes!("../tests/data/mimetype.zip"));
|
||||
let mut reader = io::Cursor::new(v);
|
||||
loop {
|
||||
match read_zipfile_from_stream(&mut reader).unwrap() {
|
||||
None => break,
|
||||
_ => (),
|
||||
if read_zipfile_from_stream(&mut reader).unwrap().is_none() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1079,14 +1095,14 @@ mod test {
|
|||
let mut buf3 = [0; 5];
|
||||
let mut buf4 = [0; 5];
|
||||
|
||||
file1.read(&mut buf1).unwrap();
|
||||
file2.read(&mut buf2).unwrap();
|
||||
file1.read(&mut buf3).unwrap();
|
||||
file2.read(&mut buf4).unwrap();
|
||||
file1.read_exact(&mut buf1).unwrap();
|
||||
file2.read_exact(&mut buf2).unwrap();
|
||||
file1.read_exact(&mut buf3).unwrap();
|
||||
file2.read_exact(&mut buf4).unwrap();
|
||||
|
||||
assert_eq!(buf1, buf2);
|
||||
assert_eq!(buf3, buf4);
|
||||
assert!(buf1 != buf3);
|
||||
assert_ne!(buf1, buf3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
|||
135
src/types.rs
135
src/types.rs
|
|
@ -1,5 +1,8 @@
|
|||
//! Types that specify what is contained in a ZIP.
|
||||
|
||||
#[cfg(feature = "time")]
|
||||
use time::{error::ComponentRange, Date, Month, OffsetDateTime, PrimitiveDateTime, Time};
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
pub enum System {
|
||||
Dos = 0,
|
||||
|
|
@ -62,7 +65,7 @@ impl DateTime {
|
|||
let seconds = (timepart & 0b0000000000011111) << 1;
|
||||
let minutes = (timepart & 0b0000011111100000) >> 5;
|
||||
let hours = (timepart & 0b1111100000000000) >> 11;
|
||||
let days = (datepart & 0b0000000000011111) >> 0;
|
||||
let days = datepart & 0b0000000000011111;
|
||||
let months = (datepart & 0b0000000111100000) >> 5;
|
||||
let years = (datepart & 0b1111111000000000) >> 9;
|
||||
|
||||
|
|
@ -85,6 +88,7 @@ impl DateTime {
|
|||
/// * hour: [0, 23]
|
||||
/// * minute: [0, 59]
|
||||
/// * second: [0, 60]
|
||||
#[allow(clippy::result_unit_err)]
|
||||
pub fn from_date_and_time(
|
||||
year: u16,
|
||||
month: u8,
|
||||
|
|
@ -93,8 +97,7 @@ impl DateTime {
|
|||
minute: u8,
|
||||
second: u8,
|
||||
) -> Result<DateTime, ()> {
|
||||
if year >= 1980
|
||||
&& year <= 2107
|
||||
if (1980..=2107).contains(&year)
|
||||
&& month >= 1
|
||||
&& month <= 12
|
||||
&& day >= 1
|
||||
|
|
@ -117,30 +120,19 @@ impl DateTime {
|
|||
}
|
||||
|
||||
#[cfg(feature = "time")]
|
||||
/// Converts a ::time::Tm object to a DateTime
|
||||
/// Converts a OffsetDateTime object to a DateTime
|
||||
///
|
||||
/// Returns `Err` when this object is out of bounds
|
||||
pub fn from_time(tm: ::time::Tm) -> Result<DateTime, ()> {
|
||||
if tm.tm_year >= 80
|
||||
&& tm.tm_year <= 207
|
||||
&& tm.tm_mon >= 0
|
||||
&& tm.tm_mon <= 11
|
||||
&& tm.tm_mday >= 1
|
||||
&& tm.tm_mday <= 31
|
||||
&& tm.tm_hour >= 0
|
||||
&& tm.tm_hour <= 23
|
||||
&& tm.tm_min >= 0
|
||||
&& tm.tm_min <= 59
|
||||
&& tm.tm_sec >= 0
|
||||
&& tm.tm_sec <= 60
|
||||
{
|
||||
#[allow(clippy::result_unit_err)]
|
||||
pub fn from_time(dt: OffsetDateTime) -> Result<DateTime, ()> {
|
||||
if dt.year() >= 1980 && dt.year() <= 2107 {
|
||||
Ok(DateTime {
|
||||
year: (tm.tm_year + 1900) as u16,
|
||||
month: (tm.tm_mon + 1) as u8,
|
||||
day: tm.tm_mday as u8,
|
||||
hour: tm.tm_hour as u8,
|
||||
minute: tm.tm_min as u8,
|
||||
second: tm.tm_sec as u8,
|
||||
year: (dt.year()) as u16,
|
||||
month: (dt.month()) as u8,
|
||||
day: dt.day() as u8,
|
||||
hour: dt.hour() as u8,
|
||||
minute: dt.minute() as u8,
|
||||
second: dt.second() as u8,
|
||||
})
|
||||
} else {
|
||||
Err(())
|
||||
|
|
@ -158,20 +150,14 @@ impl DateTime {
|
|||
}
|
||||
|
||||
#[cfg(feature = "time")]
|
||||
/// Converts the datetime to a Tm structure
|
||||
///
|
||||
/// The fields `tm_wday`, `tm_yday`, `tm_utcoff` and `tm_nsec` are set to their defaults.
|
||||
pub fn to_time(&self) -> ::time::Tm {
|
||||
::time::Tm {
|
||||
tm_sec: self.second as i32,
|
||||
tm_min: self.minute as i32,
|
||||
tm_hour: self.hour as i32,
|
||||
tm_mday: self.day as i32,
|
||||
tm_mon: self.month as i32 - 1,
|
||||
tm_year: self.year as i32 - 1900,
|
||||
tm_isdst: -1,
|
||||
..::time::empty_tm()
|
||||
}
|
||||
/// Converts the DateTime to a OffsetDateTime structure
|
||||
pub fn to_time(&self) -> Result<OffsetDateTime, ComponentRange> {
|
||||
use std::convert::TryFrom;
|
||||
|
||||
let date =
|
||||
Date::from_calendar_date(self.year as i32, Month::try_from(self.month)?, self.day)?;
|
||||
let time = Time::from_hms(self.hour, self.minute, self.second)?;
|
||||
Ok(PrimitiveDateTime::new(date, time).assume_utc())
|
||||
}
|
||||
|
||||
/// Get the year. There is no epoch, i.e. 2018 will be returned as 2018.
|
||||
|
|
@ -271,10 +257,7 @@ impl ZipFileData {
|
|||
|
||||
::std::path::Path::new(&filename)
|
||||
.components()
|
||||
.filter(|component| match *component {
|
||||
::std::path::Component::Normal(..) => true,
|
||||
_ => false,
|
||||
})
|
||||
.filter(|component| matches!(*component, ::std::path::Component::Normal(..)))
|
||||
.fold(::std::path::PathBuf::new(), |mut path, ref cur| {
|
||||
path.push(cur.as_os_str());
|
||||
path
|
||||
|
|
@ -340,6 +323,7 @@ mod test {
|
|||
}
|
||||
|
||||
#[test]
|
||||
#[allow(clippy::unusual_byte_groupings)]
|
||||
fn datetime_default() {
|
||||
use super::DateTime;
|
||||
let dt = DateTime::default();
|
||||
|
|
@ -348,6 +332,7 @@ mod test {
|
|||
}
|
||||
|
||||
#[test]
|
||||
#[allow(clippy::unusual_byte_groupings)]
|
||||
fn datetime_max() {
|
||||
use super::DateTime;
|
||||
let dt = DateTime::from_date_and_time(2107, 12, 31, 23, 59, 60).unwrap();
|
||||
|
|
@ -374,58 +359,26 @@ mod test {
|
|||
assert!(DateTime::from_date_and_time(2107, 12, 32, 0, 0, 0).is_err());
|
||||
}
|
||||
|
||||
#[cfg(feature = "time")]
|
||||
use time::{format_description::well_known::Rfc3339, OffsetDateTime};
|
||||
|
||||
#[cfg(feature = "time")]
|
||||
#[test]
|
||||
fn datetime_from_time_bounds() {
|
||||
use super::DateTime;
|
||||
use time::macros::datetime;
|
||||
|
||||
// 1979-12-31 23:59:59
|
||||
assert!(DateTime::from_time(::time::Tm {
|
||||
tm_sec: 59,
|
||||
tm_min: 59,
|
||||
tm_hour: 23,
|
||||
tm_mday: 31,
|
||||
tm_mon: 11, // tm_mon has number range [0, 11]
|
||||
tm_year: 79, // 1979 - 1900 = 79
|
||||
..::time::empty_tm()
|
||||
})
|
||||
.is_err());
|
||||
assert!(DateTime::from_time(datetime!(1979-12-31 23:59:59 UTC)).is_err());
|
||||
|
||||
// 1980-01-01 00:00:00
|
||||
assert!(DateTime::from_time(::time::Tm {
|
||||
tm_sec: 0,
|
||||
tm_min: 0,
|
||||
tm_hour: 0,
|
||||
tm_mday: 1,
|
||||
tm_mon: 0, // tm_mon has number range [0, 11]
|
||||
tm_year: 80, // 1980 - 1900 = 80
|
||||
..::time::empty_tm()
|
||||
})
|
||||
.is_ok());
|
||||
assert!(DateTime::from_time(datetime!(1980-01-01 00:00:00 UTC)).is_ok());
|
||||
|
||||
// 2107-12-31 23:59:59
|
||||
assert!(DateTime::from_time(::time::Tm {
|
||||
tm_sec: 59,
|
||||
tm_min: 59,
|
||||
tm_hour: 23,
|
||||
tm_mday: 31,
|
||||
tm_mon: 11, // tm_mon has number range [0, 11]
|
||||
tm_year: 207, // 2107 - 1900 = 207
|
||||
..::time::empty_tm()
|
||||
})
|
||||
.is_ok());
|
||||
assert!(DateTime::from_time(datetime!(2107-12-31 23:59:59 UTC)).is_ok());
|
||||
|
||||
// 2108-01-01 00:00:00
|
||||
assert!(DateTime::from_time(::time::Tm {
|
||||
tm_sec: 0,
|
||||
tm_min: 0,
|
||||
tm_hour: 0,
|
||||
tm_mday: 1,
|
||||
tm_mon: 0, // tm_mon has number range [0, 11]
|
||||
tm_year: 208, // 2108 - 1900 = 208
|
||||
..::time::empty_tm()
|
||||
})
|
||||
.is_err());
|
||||
assert!(DateTime::from_time(datetime!(2108-01-01 00:00:00 UTC)).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -441,7 +394,7 @@ mod test {
|
|||
|
||||
#[cfg(feature = "time")]
|
||||
assert_eq!(
|
||||
format!("{}", dt.to_time().rfc3339()),
|
||||
dt.to_time().unwrap().format(&Rfc3339).unwrap(),
|
||||
"2018-11-17T10:38:30Z"
|
||||
);
|
||||
}
|
||||
|
|
@ -458,10 +411,7 @@ mod test {
|
|||
assert_eq!(dt.second(), 62);
|
||||
|
||||
#[cfg(feature = "time")]
|
||||
assert_eq!(
|
||||
format!("{}", dt.to_time().rfc3339()),
|
||||
"2107-15-31T31:63:62Z"
|
||||
);
|
||||
assert!(dt.to_time().is_err());
|
||||
|
||||
let dt = DateTime::from_msdos(0x0000, 0x0000);
|
||||
assert_eq!(dt.year(), 1980);
|
||||
|
|
@ -472,10 +422,7 @@ mod test {
|
|||
assert_eq!(dt.second(), 0);
|
||||
|
||||
#[cfg(feature = "time")]
|
||||
assert_eq!(
|
||||
format!("{}", dt.to_time().rfc3339()),
|
||||
"1980-00-00T00:00:00Z"
|
||||
);
|
||||
assert!(dt.to_time().is_err());
|
||||
}
|
||||
|
||||
#[cfg(feature = "time")]
|
||||
|
|
@ -484,8 +431,8 @@ mod test {
|
|||
use super::DateTime;
|
||||
|
||||
// 2020-01-01 00:00:00
|
||||
let clock = ::time::Timespec::new(1577836800, 0);
|
||||
let tm = ::time::at_utc(clock);
|
||||
assert!(DateTime::from_time(tm).is_ok());
|
||||
let clock = OffsetDateTime::from_unix_timestamp(1_577_836_800).unwrap();
|
||||
|
||||
assert!(DateTime::from_time(clock).is_ok());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
48
src/write.rs
48
src/write.rs
|
|
@ -22,6 +22,12 @@ use flate2::write::DeflateEncoder;
|
|||
#[cfg(feature = "bzip2")]
|
||||
use bzip2::write::BzEncoder;
|
||||
|
||||
#[cfg(feature = "time")]
|
||||
use time::OffsetDateTime;
|
||||
|
||||
#[cfg(feature = "zstd")]
|
||||
use zstd::stream::write::Encoder as ZstdEncoder;
|
||||
|
||||
enum GenericZipWriter<W: Write + io::Seek> {
|
||||
Closed,
|
||||
Storer(W),
|
||||
|
|
@ -33,6 +39,8 @@ enum GenericZipWriter<W: Write + io::Seek> {
|
|||
Deflater(DeflateEncoder<W>),
|
||||
#[cfg(feature = "bzip2")]
|
||||
Bzip2(BzEncoder<W>),
|
||||
#[cfg(feature = "zstd")]
|
||||
Zstd(ZstdEncoder<'static, W>),
|
||||
}
|
||||
|
||||
/// ZIP archive generator
|
||||
|
|
@ -113,7 +121,7 @@ impl FileOptions {
|
|||
)))]
|
||||
compression_method: CompressionMethod::Stored,
|
||||
#[cfg(feature = "time")]
|
||||
last_modified_time: DateTime::from_time(time::now()).unwrap_or_default(),
|
||||
last_modified_time: DateTime::from_time(OffsetDateTime::now_utc()).unwrap_or_default(),
|
||||
#[cfg(not(feature = "time"))]
|
||||
last_modified_time: DateTime::default(),
|
||||
permissions: None,
|
||||
|
|
@ -125,6 +133,7 @@ impl FileOptions {
|
|||
///
|
||||
/// The default is `CompressionMethod::Deflated`. If the deflate compression feature is
|
||||
/// disabled, `CompressionMethod::Stored` becomes the default.
|
||||
#[must_use]
|
||||
pub fn compression_method(mut self, method: CompressionMethod) -> FileOptions {
|
||||
self.compression_method = method;
|
||||
self
|
||||
|
|
@ -134,6 +143,7 @@ impl FileOptions {
|
|||
///
|
||||
/// The default is the current timestamp if the 'time' feature is enabled, and 1980-01-01
|
||||
/// otherwise
|
||||
#[must_use]
|
||||
pub fn last_modified_time(mut self, mod_time: DateTime) -> FileOptions {
|
||||
self.last_modified_time = mod_time;
|
||||
self
|
||||
|
|
@ -144,6 +154,7 @@ impl FileOptions {
|
|||
/// The format is represented with unix-style permissions.
|
||||
/// The default is `0o644`, which represents `rw-r--r--` for files,
|
||||
/// and `0o755`, which represents `rwxr-xr-x` for directories
|
||||
#[must_use]
|
||||
pub fn unix_permissions(mut self, mode: u32) -> FileOptions {
|
||||
self.permissions = Some(mode & 0o777);
|
||||
self
|
||||
|
|
@ -154,6 +165,7 @@ impl FileOptions {
|
|||
/// If set to `false` and the file exceeds the limit, an I/O error is thrown. If set to `true`,
|
||||
/// readers will require ZIP64 support and if the file does not exceed the limit, 20 B are
|
||||
/// wasted. The default is `false`.
|
||||
#[must_use]
|
||||
pub fn large_file(mut self, large: bool) -> FileOptions {
|
||||
self.large_file = large;
|
||||
self
|
||||
|
|
@ -234,7 +246,10 @@ impl<A: Read + Write + io::Seek> ZipWriter<A> {
|
|||
let (archive_offset, directory_start, number_of_files) =
|
||||
ZipArchive::get_directory_counts(&mut readwriter, &footer, cde_start_pos)?;
|
||||
|
||||
if let Err(_) = readwriter.seek(io::SeekFrom::Start(directory_start)) {
|
||||
if readwriter
|
||||
.seek(io::SeekFrom::Start(directory_start))
|
||||
.is_err()
|
||||
{
|
||||
return Err(ZipError::InvalidArchive(
|
||||
"Could not seek to start of central directory",
|
||||
));
|
||||
|
|
@ -304,7 +319,7 @@ impl<W: Write + io::Seek> ZipWriter<W> {
|
|||
{
|
||||
self.finish_file()?;
|
||||
|
||||
let raw_values = raw_values.unwrap_or_else(|| ZipRawValues {
|
||||
let raw_values = raw_values.unwrap_or(ZipRawValues {
|
||||
crc32: 0,
|
||||
compressed_size: 0,
|
||||
uncompressed_size: 0,
|
||||
|
|
@ -545,7 +560,7 @@ impl<W: Write + io::Seek> ZipWriter<W> {
|
|||
}
|
||||
let file = self.files.last_mut().unwrap();
|
||||
|
||||
validate_extra_data(&file)?;
|
||||
validate_extra_data(file)?;
|
||||
|
||||
if !self.writing_to_central_extra_field_only {
|
||||
let writer = self.inner.get_plain();
|
||||
|
|
@ -603,11 +618,11 @@ impl<W: Write + io::Seek> ZipWriter<W> {
|
|||
where
|
||||
S: Into<String>,
|
||||
{
|
||||
let options = FileOptions::default()
|
||||
let mut options = FileOptions::default()
|
||||
.last_modified_time(file.last_modified())
|
||||
.compression_method(file.compression());
|
||||
if let Some(perms) = file.unix_mode() {
|
||||
options.unix_permissions(perms);
|
||||
options = options.unix_permissions(perms);
|
||||
}
|
||||
|
||||
let raw_values = ZipRawValues {
|
||||
|
|
@ -804,6 +819,8 @@ impl<W: Write + io::Seek> GenericZipWriter<W> {
|
|||
GenericZipWriter::Deflater(w) => w.finish()?,
|
||||
#[cfg(feature = "bzip2")]
|
||||
GenericZipWriter::Bzip2(w) => w.finish()?,
|
||||
#[cfg(feature = "zstd")]
|
||||
GenericZipWriter::Zstd(w) => w.finish()?,
|
||||
GenericZipWriter::Closed => {
|
||||
return Err(io::Error::new(
|
||||
io::ErrorKind::BrokenPipe,
|
||||
|
|
@ -830,6 +847,10 @@ impl<W: Write + io::Seek> GenericZipWriter<W> {
|
|||
CompressionMethod::Bzip2 => {
|
||||
GenericZipWriter::Bzip2(BzEncoder::new(bare, bzip2::Compression::default()))
|
||||
}
|
||||
#[cfg(feature = "zstd")]
|
||||
CompressionMethod::Zstd => {
|
||||
GenericZipWriter::Zstd(ZstdEncoder::new(bare, 0).unwrap())
|
||||
}
|
||||
CompressionMethod::Unsupported(..) => {
|
||||
return Err(ZipError::UnsupportedArchive("Unsupported compression"))
|
||||
}
|
||||
|
|
@ -850,15 +871,14 @@ impl<W: Write + io::Seek> GenericZipWriter<W> {
|
|||
GenericZipWriter::Deflater(ref mut w) => Some(w as &mut dyn Write),
|
||||
#[cfg(feature = "bzip2")]
|
||||
GenericZipWriter::Bzip2(ref mut w) => Some(w as &mut dyn Write),
|
||||
#[cfg(feature = "zstd")]
|
||||
GenericZipWriter::Zstd(ref mut w) => Some(w as &mut dyn Write),
|
||||
GenericZipWriter::Closed => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn is_closed(&self) -> bool {
|
||||
match *self {
|
||||
GenericZipWriter::Closed => true,
|
||||
_ => false,
|
||||
}
|
||||
matches!(*self, GenericZipWriter::Closed)
|
||||
}
|
||||
|
||||
fn get_plain(&mut self) -> &mut W {
|
||||
|
|
@ -879,6 +899,8 @@ impl<W: Write + io::Seek> GenericZipWriter<W> {
|
|||
GenericZipWriter::Deflater(..) => Some(CompressionMethod::Deflated),
|
||||
#[cfg(feature = "bzip2")]
|
||||
GenericZipWriter::Bzip2(..) => Some(CompressionMethod::Bzip2),
|
||||
#[cfg(feature = "zstd")]
|
||||
GenericZipWriter::Zstd(..) => Some(CompressionMethod::Zstd),
|
||||
GenericZipWriter::Closed => None,
|
||||
}
|
||||
}
|
||||
|
|
@ -932,7 +954,7 @@ fn write_local_file_header<T: Write>(writer: &mut T, file: &ZipFileData) -> ZipR
|
|||
writer.write_all(file.file_name.as_bytes())?;
|
||||
// zip64 extra field
|
||||
if file.large_file {
|
||||
write_local_zip64_extra_field(writer, &file)?;
|
||||
write_local_zip64_extra_field(writer, file)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
|
|
@ -1050,7 +1072,7 @@ fn validate_extra_data(file: &ZipFileData) -> ZipResult<()> {
|
|||
)));
|
||||
}
|
||||
|
||||
while data.len() > 0 {
|
||||
while !data.is_empty() {
|
||||
let left = data.len();
|
||||
if left < 4 {
|
||||
return Err(ZipError::Io(io::Error::new(
|
||||
|
|
@ -1230,7 +1252,7 @@ mod test {
|
|||
};
|
||||
writer.start_file("mimetype", options).unwrap();
|
||||
writer
|
||||
.write(b"application/vnd.oasis.opendocument.text")
|
||||
.write_all(b"application/vnd.oasis.opendocument.text")
|
||||
.unwrap();
|
||||
let result = writer.finish().unwrap();
|
||||
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ impl ZipCryptoKeys {
|
|||
}
|
||||
|
||||
fn crc32(crc: Wrapping<u32>, input: u8) -> Wrapping<u32> {
|
||||
return (crc >> 8) ^ Wrapping(CRCTABLE[((crc & Wrapping(0xff)).0 as u8 ^ input) as usize]);
|
||||
(crc >> 8) ^ Wrapping(CRCTABLE[((crc & Wrapping(0xff)).0 as u8 ^ input) as usize])
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -71,7 +71,7 @@ impl<R: std::io::Read> ZipCryptoReader<R> {
|
|||
/// password byte sequence that is unrepresentable in UTF-8.
|
||||
pub fn new(file: R, password: &[u8]) -> ZipCryptoReader<R> {
|
||||
let mut result = ZipCryptoReader {
|
||||
file: file,
|
||||
file,
|
||||
keys: ZipCryptoKeys::new(),
|
||||
};
|
||||
|
||||
|
|
@ -129,11 +129,11 @@ pub struct ZipCryptoReaderValid<R> {
|
|||
}
|
||||
|
||||
impl<R: std::io::Read> std::io::Read for ZipCryptoReaderValid<R> {
|
||||
fn read(&mut self, mut buf: &mut [u8]) -> std::io::Result<usize> {
|
||||
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
|
||||
// Note: There might be potential for optimization. Inspiration can be found at:
|
||||
// https://github.com/kornelski/7z/blob/master/CPP/7zip/Crypto/ZipCrypto.cpp
|
||||
|
||||
let result = self.reader.file.read(&mut buf);
|
||||
let result = self.reader.file.read(buf);
|
||||
for byte in buf.iter_mut() {
|
||||
*byte = self.reader.keys.decrypt_byte(*byte);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ fn read_zip<R: Read + Seek>(zip_file: R) -> zip::result::ZipResult<zip::ZipArchi
|
|||
"test_with_extra_data/🐢.txt",
|
||||
ENTRY_NAME,
|
||||
];
|
||||
let expected_file_names = HashSet::from_iter(expected_file_names.iter().map(|&v| v));
|
||||
let expected_file_names = HashSet::from_iter(expected_file_names.iter().copied());
|
||||
let file_names = archive.file_names().collect::<HashSet<_>>();
|
||||
assert_eq!(file_names, expected_file_names);
|
||||
|
||||
|
|
@ -134,17 +134,17 @@ fn check_zip_contents(zip_file: &mut Cursor<Vec<u8>>, name: &str) {
|
|||
|
||||
fn check_zip_file_contents<R: Read + Seek>(archive: &mut zip::ZipArchive<R>, name: &str) {
|
||||
let file_contents: String = read_zip_file(archive, name).unwrap();
|
||||
assert!(file_contents.as_bytes() == LOREM_IPSUM);
|
||||
assert_eq!(file_contents.as_bytes(), LOREM_IPSUM);
|
||||
}
|
||||
|
||||
const LOREM_IPSUM : &'static [u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. In tellus elit, tristique vitae mattis egestas, ultricies vitae risus. Quisque sit amet quam ut urna aliquet
|
||||
const LOREM_IPSUM : &[u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. In tellus elit, tristique vitae mattis egestas, ultricies vitae risus. Quisque sit amet quam ut urna aliquet
|
||||
molestie. Proin blandit ornare dui, a tempor nisl accumsan in. Praesent a consequat felis. Morbi metus diam, auctor in auctor vel, feugiat id odio. Curabitur ex ex,
|
||||
dictum quis auctor quis, suscipit id lorem. Aliquam vestibulum dolor nec enim vehicula, porta tristique augue tincidunt. Vivamus ut gravida est. Sed pellentesque, dolor
|
||||
vitae tristique consectetur, neque lectus pulvinar dui, sed feugiat purus diam id lectus. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per
|
||||
inceptos himenaeos. Maecenas feugiat velit in ex ultrices scelerisque id id neque.
|
||||
";
|
||||
|
||||
const EXTRA_DATA: &'static [u8] = b"Extra Data";
|
||||
const EXTRA_DATA: &[u8] = b"Extra Data";
|
||||
|
||||
const ENTRY_NAME: &str = "test/lorem_ipsum.txt";
|
||||
|
||||
|
|
|
|||
31
tests/issue_234.rs
Normal file
31
tests/issue_234.rs
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
use zip::result::ZipError;
|
||||
|
||||
const BUF: &[u8] = &[
|
||||
0, 80, 75, 1, 2, 127, 120, 0, 3, 3, 75, 80, 232, 3, 0, 0, 0, 0, 0, 0, 3, 0, 1, 0, 7, 0, 0, 0,
|
||||
0, 65, 0, 1, 0, 0, 0, 4, 0, 0, 224, 255, 0, 255, 255, 255, 255, 255, 255, 20, 39, 221, 221,
|
||||
221, 221, 221, 221, 205, 221, 221, 221, 42, 221, 221, 221, 221, 221, 221, 221, 221, 38, 34, 34,
|
||||
219, 80, 75, 5, 6, 0, 0, 0, 0, 5, 96, 0, 1, 71, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 234, 236, 124,
|
||||
221, 221, 37, 221, 221, 221, 221, 221, 129, 4, 0, 0, 221, 221, 80, 75, 1, 2, 127, 120, 0, 4, 0,
|
||||
0, 2, 127, 120, 0, 79, 75, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0,
|
||||
234, 0, 0, 0, 3, 8, 4, 232, 3, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 0, 7, 0, 0, 0, 0, 3, 0,
|
||||
221, 209, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
|
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 58, 58, 42, 75, 9, 2, 127,
|
||||
120, 0, 99, 99, 99, 99, 99, 99, 94, 7, 0, 0, 0, 0, 0, 0, 213, 213, 213, 213, 213, 213, 213,
|
||||
213, 213, 7, 0, 0, 211, 211, 211, 211, 124, 236, 99, 99, 99, 94, 7, 0, 0, 0, 0, 0, 0, 213, 213,
|
||||
213, 213, 213, 213, 213, 213, 213, 7, 0, 0, 211, 211, 211, 211, 124, 236, 234, 0, 0, 0, 3, 8,
|
||||
0, 0, 0, 12, 0, 0, 0, 0, 0, 3, 0, 0, 0, 7, 0, 0, 0, 0, 0, 58, 58, 58, 42, 175, 221, 253, 221,
|
||||
221, 221, 221, 221, 80, 75, 9, 2, 127, 120, 0, 99, 99, 99, 99, 99, 99, 94, 7, 0, 0, 0, 0, 0, 0,
|
||||
213, 213, 213, 213, 213, 213, 213, 213, 213, 7, 0, 0, 211, 211, 211, 211, 124, 236, 221, 221,
|
||||
221, 221, 221, 80, 75, 9, 2, 127, 120, 0, 99, 99, 99, 99, 99, 99, 94, 7, 0, 0, 0, 0, 0, 0, 213,
|
||||
213, 213, 213, 213, 213, 213, 213, 213, 7, 0, 0, 211, 211, 211, 211, 124, 236,
|
||||
];
|
||||
|
||||
#[test]
|
||||
fn invalid_header() {
|
||||
let reader = std::io::Cursor::new(&BUF);
|
||||
let archive = zip::ZipArchive::new(reader);
|
||||
match archive {
|
||||
Err(ZipError::InvalidArchive(_)) => {}
|
||||
value => panic!("Unexpected value: {:?}", value),
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue