diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 83741894..6f0e4b9d 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -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 \ No newline at end of file + run: cargo doc diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md index 845634eb..2290ec2b 100644 --- a/CODE_OF_CONDUCT.md +++ b/CODE_OF_CONDUCT.md @@ -1,4 +1,3 @@ - # Contributor Covenant Code of Conduct ## Our Pledge diff --git a/Cargo.toml b/Cargo.toml index ae78ae33..971b7cc3 100644 --- a/Cargo.toml +++ b/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" diff --git a/README.md b/README.md index e489b98d..72ea9daa 100644 --- a/README.md +++ b/README.md @@ -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 diff --git a/benches/read_entry.rs b/benches/read_entry.rs index 25c0b94a..af9affe3 100644 --- a/benches/read_entry.rs +++ b/benches/read_entry.rs @@ -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 { @@ -14,7 +14,7 @@ fn generate_random_archive(size: usize) -> Vec { 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() diff --git a/examples/extract.rs b/examples/extract.rs index 05c5a4aa..b02eb4cd 100644 --- a/examples/extract.rs +++ b/examples/extract.rs @@ -59,5 +59,6 @@ fn real_main() -> i32 { } } } - return 0; + + 0 } diff --git a/examples/extract_lorem.rs b/examples/extract_lorem.rs index 89e33ef9..a34a04f4 100644 --- a/examples/extract_lorem.rs +++ b/examples/extract_lorem.rs @@ -27,5 +27,5 @@ fn real_main() -> i32 { file.read_to_string(&mut contents).unwrap(); println!("{}", contents); - return 0; + 0 } diff --git a/examples/file_info.rs b/examples/file_info.rs index 315b5c38..824278df 100644 --- a/examples/file_info.rs +++ b/examples/file_info.rs @@ -49,5 +49,6 @@ fn real_main() -> i32 { ); } } - return 0; + + 0 } diff --git a/examples/stdin_info.rs b/examples/stdin_info.rs index 606944ce..10d7aa8b 100644 --- a/examples/stdin_info.rs +++ b/examples/stdin_info.rs @@ -30,5 +30,6 @@ fn real_main() -> i32 { } } } - return 0; + + 0 } diff --git a/examples/write_dir.rs b/examples/write_dir.rs index 793bd6ba..8cc561ff 100644 --- a/examples/write_dir.rs +++ b/examples/write_dir.rs @@ -32,6 +32,11 @@ const METHOD_BZIP2: Option = Some(zip::CompressionMethod #[cfg(not(feature = "bzip2"))] const METHOD_BZIP2: Option = None; +#[cfg(feature = "zstd")] +const METHOD_ZSTD: Option = Some(zip::CompressionMethod::Zstd); +#[cfg(not(feature = "zstd"))] +const METHOD_ZSTD: Option = 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( @@ -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)?; diff --git a/examples/write_sample.rs b/examples/write_sample.rs index 4ef5ce34..b5749509 100644 --- a/examples/write_sample.rs +++ b/examples/write_sample.rs @@ -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 diff --git a/src/compression.rs b/src/compression.rs index 5fdde070..e4546e27 100644 --- a/src/compression.rs +++ b/src/compression.rs @@ -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 { - 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] diff --git a/src/cp437.rs b/src/cp437.rs index f9948143..4dba9af1 100644 --- a/src/cp437.rs +++ b/src/cp437.rs @@ -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; } diff --git a/src/read.rs b/src/read.rs index 97bccd2d..a9f173fd 100644 --- a/src/read.rs +++ b/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>>), #[cfg(feature = "bzip2")] Bzip2(Crc32Reader>>), + #[cfg(feature = "zstd")] + Zstd(Crc32Reader>>>), } 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 ZipArchive { 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 ZipArchive { 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 ZipArchive { } /// Get a contained file by index - pub fn by_index<'a>(&'a mut self, file_number: usize) -> ZipResult> { + pub fn by_index(&mut self, file_number: usize) -> ZipResult> { 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> { + pub fn by_index_raw(&mut self, file_number: usize) -> ZipResult> { let reader = &mut self.reader; self.files .get_mut(file_number) @@ -603,7 +617,10 @@ pub(crate) fn central_header_to_zip_file( } // 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] diff --git a/src/types.rs b/src/types.rs index 026aa150..88434e3f 100644 --- a/src/types.rs +++ b/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 { - 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 { - 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 { + 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 { + 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()); } } diff --git a/src/write.rs b/src/write.rs index 05c3666a..17fd3344 100644 --- a/src/write.rs +++ b/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 { Closed, Storer(W), @@ -33,6 +39,8 @@ enum GenericZipWriter { Deflater(DeflateEncoder), #[cfg(feature = "bzip2")] Bzip2(BzEncoder), + #[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 ZipWriter { 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 ZipWriter { { 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 ZipWriter { } 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 ZipWriter { where S: Into, { - 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 GenericZipWriter { 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 GenericZipWriter { 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 GenericZipWriter { 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 GenericZipWriter { 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(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(); diff --git a/src/zipcrypto.rs b/src/zipcrypto.rs index 3196ea36..91d40395 100644 --- a/src/zipcrypto.rs +++ b/src/zipcrypto.rs @@ -47,7 +47,7 @@ impl ZipCryptoKeys { } fn crc32(crc: Wrapping, input: u8) -> Wrapping { - 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 ZipCryptoReader { /// password byte sequence that is unrepresentable in UTF-8. pub fn new(file: R, password: &[u8]) -> ZipCryptoReader { let mut result = ZipCryptoReader { - file: file, + file, keys: ZipCryptoKeys::new(), }; @@ -129,11 +129,11 @@ pub struct ZipCryptoReaderValid { } impl std::io::Read for ZipCryptoReaderValid { - fn read(&mut self, mut buf: &mut [u8]) -> std::io::Result { + fn read(&mut self, buf: &mut [u8]) -> std::io::Result { // 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); } diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index baebd287..d0185f60 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -100,7 +100,7 @@ fn read_zip(zip_file: R) -> zip::result::ZipResult>(); assert_eq!(file_names, expected_file_names); @@ -134,17 +134,17 @@ fn check_zip_contents(zip_file: &mut Cursor>, name: &str) { fn check_zip_file_contents(archive: &mut zip::ZipArchive, 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"; diff --git a/tests/issue_234.rs b/tests/issue_234.rs new file mode 100644 index 00000000..bd01d1d0 --- /dev/null +++ b/tests/issue_234.rs @@ -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), + } +}