Merge branch 'master' into feature/end-to-end-tests-only
This commit is contained in:
Jack Fletcher
commit
772ab59471
8 changed files with 145 additions and 160 deletions
|
|
@ -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
|
||||
|
|
@ -157,7 +157,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)]
|
||||
|
|
@ -167,20 +167,19 @@ mod test {
|
|||
}
|
||||
|
||||
fn methods() -> Vec<CompressionMethod> {
|
||||
let mut methods = Vec::new();
|
||||
methods.push(CompressionMethod::Stored);
|
||||
vec![
|
||||
CompressionMethod::Stored,
|
||||
#[cfg(any(
|
||||
feature = "deflate",
|
||||
feature = "deflate-miniz",
|
||||
feature = "deflate-zlib"
|
||||
))]
|
||||
methods.push(CompressionMethod::Deflated);
|
||||
CompressionMethod::Deflated,
|
||||
#[cfg(feature = "bzip2")]
|
||||
methods.push(CompressionMethod::Bzip2);
|
||||
CompressionMethod::Bzip2,
|
||||
#[cfg(feature = "zstd")]
|
||||
methods.push(CompressionMethod::Zstd);
|
||||
|
||||
methods
|
||||
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;
|
||||
}
|
||||
|
||||
|
|
|
|||
38
src/read.rs
38
src/read.rs
|
|
@ -198,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(
|
||||
|
|
@ -317,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")
|
||||
})?;
|
||||
|
||||
|
|
@ -346,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",
|
||||
));
|
||||
|
|
@ -471,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)
|
||||
|
|
@ -617,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)
|
||||
}
|
||||
|
|
@ -1031,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]
|
||||
|
|
@ -1042,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);
|
||||
}
|
||||
|
||||
|
|
@ -1055,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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1093,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]
|
||||
|
|
|
|||
|
|
@ -1,37 +1,66 @@
|
|||
//! Error types that can be emitted from this library
|
||||
|
||||
use std::error::Error;
|
||||
use std::fmt;
|
||||
use std::io;
|
||||
|
||||
use thiserror::Error;
|
||||
|
||||
/// Generic result type with ZipError as its error variant
|
||||
pub type ZipResult<T> = Result<T, ZipError>;
|
||||
|
||||
/// The given password is wrong
|
||||
#[derive(Error, Debug)]
|
||||
#[error("invalid password for file in archive")]
|
||||
#[derive(Debug)]
|
||||
pub struct InvalidPassword;
|
||||
|
||||
impl fmt::Display for InvalidPassword {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(fmt, "invalid password for file in archive")
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for InvalidPassword {}
|
||||
|
||||
/// Error type for Zip
|
||||
#[derive(Debug, Error)]
|
||||
#[derive(Debug)]
|
||||
pub enum ZipError {
|
||||
/// An Error caused by I/O
|
||||
#[error(transparent)]
|
||||
Io(#[from] io::Error),
|
||||
Io(io::Error),
|
||||
|
||||
/// This file is probably not a zip archive
|
||||
#[error("invalid Zip archive")]
|
||||
InvalidArchive(&'static str),
|
||||
|
||||
/// This archive is not supported
|
||||
#[error("unsupported Zip archive")]
|
||||
UnsupportedArchive(&'static str),
|
||||
|
||||
/// The requested file could not be found in the archive
|
||||
#[error("specified file not found in archive")]
|
||||
FileNotFound,
|
||||
}
|
||||
|
||||
impl From<io::Error> for ZipError {
|
||||
fn from(err: io::Error) -> ZipError {
|
||||
ZipError::Io(err)
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for ZipError {
|
||||
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
||||
match self {
|
||||
ZipError::Io(err) => write!(fmt, "{}", err),
|
||||
ZipError::InvalidArchive(err) => write!(fmt, "invalid Zip archive: {}", err),
|
||||
ZipError::UnsupportedArchive(err) => write!(fmt, "unsupported Zip archive: {}", err),
|
||||
ZipError::FileNotFound => write!(fmt, "specified file not found in archive"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for ZipError {
|
||||
fn source(&self) -> Option<&(dyn Error + 'static)> {
|
||||
match self {
|
||||
ZipError::Io(err) => Some(err),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ZipError {
|
||||
/// The text used as an error when a password is required and not supplied
|
||||
///
|
||||
|
|
|
|||
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());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
33
src/write.rs
33
src/write.rs
|
|
@ -22,6 +22,9 @@ 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;
|
||||
|
||||
|
|
@ -118,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,
|
||||
|
|
@ -130,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
|
||||
|
|
@ -139,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
|
||||
|
|
@ -149,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
|
||||
|
|
@ -159,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
|
||||
|
|
@ -239,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",
|
||||
));
|
||||
|
|
@ -309,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,
|
||||
|
|
@ -550,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();
|
||||
|
|
@ -608,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 {
|
||||
|
|
@ -868,10 +878,7 @@ impl<W: Write + io::Seek> GenericZipWriter<W> {
|
|||
}
|
||||
|
||||
fn is_closed(&self) -> bool {
|
||||
match *self {
|
||||
GenericZipWriter::Closed => true,
|
||||
_ => false,
|
||||
}
|
||||
matches!(*self, GenericZipWriter::Closed)
|
||||
}
|
||||
|
||||
fn get_plain(&mut self) -> &mut W {
|
||||
|
|
@ -947,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(())
|
||||
|
|
@ -1065,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(
|
||||
|
|
@ -1245,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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -121,7 +121,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);
|
||||
|
||||
|
|
@ -173,17 +173,17 @@ fn check_zip_contents(
|
|||
|
||||
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";
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue