DevComp/zip-rs-wasm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #197 from mvdnes/unbreak-0.5

Browse source 
Remove breaking changes in 0.5.7
This commit is contained in:
Plecra 2020-09-10 11:42:53 +01:00 • committed by GitHub
commit e7502199f9
Signed by: DevComp
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 46 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
src/read.rs
View file

@ -2,7 +2,7 @@
use crate::compression::CompressionMethod;
use crate::crc32::Crc32Reader;
use crate::result::{ZipError, ZipResult};
use crate::result::{InvalidPassword, ZipError, ZipResult};
use crate::spec;
use crate::zipcrypto::ZipCryptoReader;
use crate::zipcrypto::ZipCryptoReaderValid;
@ -137,17 +137,17 @@ fn make_reader<'a>(
crc32: u32,
reader: io::Take<&'a mut dyn io::Read>,
password: Option<&[u8]>,
) -> ZipResult<ZipFileReader<'a>> {
) -> ZipResult<Result<ZipFileReader<'a>, InvalidPassword>> {
let reader = match password {
None => CryptoReader::Plaintext(reader),
Some(password) => match ZipCryptoReader::new(reader, password).validate(crc32)? {
None => return Err(ZipError::InvalidPassword),
None => return Ok(Err(InvalidPassword)),
Some(r) => CryptoReader::ZipCrypto(r),
},
};
match compression_method {
CompressionMethod::Stored => Ok(ZipFileReader::Stored(Crc32Reader::new(reader, crc32))),
CompressionMethod::Stored => Ok(Ok(ZipFileReader::Stored(Crc32Reader::new(reader, crc32)))),
#[cfg(any(
feature = "deflate",
feature = "deflate-miniz",
@ -155,15 +155,18 @@ fn make_reader<'a>(
))]
CompressionMethod::Deflated => {
let deflate_reader = DeflateDecoder::new(reader);
Ok(ZipFileReader::Deflated(Crc32Reader::new(
Ok(Ok(ZipFileReader::Deflated(Crc32Reader::new(
deflate_reader,
crc32,
)))
))))
}
#[cfg(feature = "bzip2")]
CompressionMethod::Bzip2 => {
let bzip2_reader = BzDecoder::new(reader);
Ok(ZipFileReader::Bzip2(Crc32Reader::new(bzip2_reader, crc32)))
Ok(Ok(ZipFileReader::Bzip2(Crc32Reader::new(
bzip2_reader,
crc32,
))))
}
_ => unsupported_zip_error("Compression method not supported"),
}
@ -341,20 +344,20 @@ impl<R: Read + io::Seek> ZipArchive<R> {
&'a mut self,
name: &str,
password: &[u8],
) -> ZipResult<ZipFile<'a>> {
) -> ZipResult<Result<ZipFile<'a>, InvalidPassword>> {
self.by_name_with_optional_password(name, Some(password))
}
/// Search for a file entry by name
pub fn by_name<'a>(&'a mut self, name: &str) -> ZipResult<ZipFile<'a>> {
self.by_name_with_optional_password(name, None)
Ok(self.by_name_with_optional_password(name, None)?.unwrap())
}
fn by_name_with_optional_password<'a>(
&'a mut self,
name: &str,
password: Option<&[u8]>,
) -> ZipResult<ZipFile<'a>> {
) -> ZipResult<Result<ZipFile<'a>, InvalidPassword>> {
let index = match self.names_map.get(name) {
Some(index) => *index,
None => {
@ -369,27 +372,33 @@ impl<R: Read + io::Seek> ZipArchive<R> {
&'a mut self,
file_number: usize,
password: &[u8],
) -> ZipResult<ZipFile<'a>> {
) -> ZipResult<Result<ZipFile<'a>, InvalidPassword>> {
self.by_index_with_optional_password(file_number, Some(password))
}
/// Get a contained file by index
pub fn by_index<'a>(&'a mut self, file_number: usize) -> ZipResult<ZipFile<'a>> {
self.by_index_with_optional_password(file_number, None)
Ok(self
.by_index_with_optional_password(file_number, None)?
.unwrap())
}
fn by_index_with_optional_password<'a>(
&'a mut self,
file_number: usize,
mut password: Option<&[u8]>,
) -> ZipResult<ZipFile<'a>> {
) -> ZipResult<Result<ZipFile<'a>, InvalidPassword>> {
if file_number >= self.files.len() {
return Err(ZipError::FileNotFound);
}
let data = &mut self.files[file_number];
match (password, data.encrypted) {
(None, true) => return Err(ZipError::PasswordRequired),
(None, true) => {
return Err(ZipError::UnsupportedArchive(
"Password required to decrypt file",
))
}
(Some(_), false) => password = None, //Password supplied, but none needed! Discard.
_ => {}
}
@ -411,10 +420,14 @@ impl<R: Read + io::Seek> ZipArchive<R> {
self.reader.seek(io::SeekFrom::Start(data.data_start))?;
let limit_reader = (self.reader.by_ref() as &mut dyn Read).take(data.compressed_size);
Ok(ZipFile {
reader: make_reader(data.compression_method, data.crc32, limit_reader, password)?,
data: Cow::Borrowed(data),
})
match make_reader(data.compression_method, data.crc32, limit_reader, password) {
Ok(Ok(reader)) => Ok(Ok(ZipFile {
reader,
data: Cow::Borrowed(data),
})),
Err(e) => Err(e),
Ok(Err(e)) => Ok(Err(e)),
}
}
/// Unwrap and return the inner reader object
@ -778,7 +791,7 @@ pub fn read_zipfile_from_stream<'a, R: io::Read>(
let result_compression_method = result.compression_method;
Ok(Some(ZipFile {
data: Cow::Owned(result),
reader: make_reader(result_compression_method, result_crc32, limit_reader, None)?,
reader: make_reader(result_compression_method, result_crc32, limit_reader, None)?.unwrap(),
}))
}

13
src/result.rs
View file

@ -7,6 +7,11 @@ 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")]
pub struct InvalidPassword;
/// Error type for Zip
#[derive(Debug, Error)]
pub enum ZipError {
@ -25,14 +30,6 @@ pub enum ZipError {
/// The requested file could not be found in the archive
#[error("specified file not found in archive")]
FileNotFound,
/// No password was given but the data is encrypted
#[error("missing password, file in archive is encrypted")]
PasswordRequired,
/// The given password is wrong
#[error("invalid password for file in archive")]
InvalidPassword,
}
impl From<ZipError> for io::Error {

13
tests/zip_crypto.rs
View file

@ -47,7 +47,9 @@ fn encrypted_file() {
// No password
let file = archive.by_index(0);
match file {
Err(zip::result::ZipError::PasswordRequired) => (),
Err(zip::result::ZipError::UnsupportedArchive("Password required to decrypt file")) => {
()
}
Err(_) => panic!(
"Expected PasswordRequired error when opening encrypted file without password"
),
@ -59,17 +61,20 @@ fn encrypted_file() {
// Wrong password
let file = archive.by_index_decrypt(0, b"wrong password");
match file {
Err(zip::result::ZipError::InvalidPassword) => (),
Ok(Err(zip::result::InvalidPassword)) => (),
Err(_) => panic!(
"Expected InvalidPassword error when opening encrypted file with wrong password"
),
Ok(_) => panic!("Error: Successfully opened encrypted file with wrong password?!"),
Ok(Ok(_)) => panic!("Error: Successfully opened encrypted file with wrong password?!"),
}
}
{
// Correct password, read contents
let mut file = archive.by_index_decrypt(0, "test".as_bytes()).unwrap();
let mut file = archive
.by_index_decrypt(0, "test".as_bytes())
.unwrap()
.unwrap();
#[allow(deprecated)]
let file_name = file.sanitized_name();
assert_eq!(file_name, std::path::PathBuf::from("test.txt"));