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

merge edition 2018 and other improvements from master

Browse source
This commit is contained in:
Benjamin Richner 2020-05-21 21:58:38 +02:00
commit cf7ff173b3
20 changed files with 153 additions and 98 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
Cargo.toml
View file

@ -1,7 +1,7 @@
[package]
name = "zip"
version = "0.5.3"
version = "0.5.5"
authors = ["Mathijs van de Nes <git@mathijs.vd-nes.nl>"]
license = "MIT"
repository = "https://github.com/mvdnes/zip-rs.git"
@ -10,6 +10,7 @@ keywords = ["zip", "archive"]
description = """
Library to support the reading and writing of zip files.
"""
edition = "2018"
[dependencies]
flate2 = { version = "1.0", default-features = false, optional = true }

3
README.md
View file

@ -1,3 +1,5 @@
**Unfortunately, due to a lack of time and loss of interest, this project will no longer be actively maintained.**
zip-rs
======
@ -7,6 +9,7 @@ zip-rs
[Documentation](http://mvdnes.github.io/rust-docs/zip-rs/zip/index.html)
Info
----

5
benches/read_entry.rs
View file

@ -1,7 +1,4 @@
#[macro_use]
extern crate bencher;
extern crate rand;
extern crate zip;
use bencher::{benchmark_group, benchmark_main};
use std::io::{Cursor, Read, Write};

2
examples/extract.rs
View file

@ -1,5 +1,3 @@
extern crate zip;
use std::io;
use std::fs;

2
examples/extract_lorem.rs
View file

@ -1,7 +1,5 @@
use std::io::prelude::*;
extern crate zip;
fn main()
{
std::process::exit(real_main());

2
examples/file_info.rs
View file

@ -1,5 +1,3 @@
extern crate zip;
use std::fs;
use std::io::BufReader;

2
examples/stdin_info.rs
View file

@ -1,5 +1,3 @@
extern crate zip;
use std::io::{self, Read};
fn main() {

4
examples/write_dir.rs
View file

@ -1,5 +1,3 @@
extern crate zip;
extern crate walkdir;
use std::io::prelude::*;
use std::io::{Write, Seek};
@ -48,7 +46,7 @@ fn real_main() -> i32 {
return 0;
}
fn zip_dir<T>(it: &mut Iterator<Item=DirEntry>, prefix: &str, writer: T, method: zip::CompressionMethod)
fn zip_dir<T>(it: &mut dyn Iterator<Item=DirEntry>, prefix: &str, writer: T, method: zip::CompressionMethod)
-> zip::result::ZipResult<()>
where T: Write+Seek
{

2
examples/write_sample.rs
View file

@ -1,8 +1,6 @@
use std::io::prelude::*;
use zip::write::FileOptions;
extern crate zip;
fn main()
{
std::process::exit(real_main());

2
src/compression.rs
View file

@ -45,7 +45,7 @@ impl CompressionMethod {
}
impl fmt::Display for CompressionMethod {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// Just duplicate what the Debug format looks like, i.e, the enum key:
write!(f, "{:?}", self)
}

2
src/cp437.rs
View file

@ -41,7 +41,7 @@ fn to_char(input: u8) -> char
{
let output = match input
{
0x00 ... 0x7f => input as u32,
0x00 ..= 0x7f => input as u32,
0x80 => 0x00c7,
0x81 => 0x00fc,
0x82 => 0x00e9,

17
src/lib.rs
View file

@ -2,19 +2,10 @@
#![warn(missing_docs)]
#[cfg(feature = "bzip2")]
extern crate bzip2;
extern crate crc32fast;
#[cfg(feature = "deflate")]
extern crate flate2;
extern crate podio;
#[cfg(feature = "time")]
extern crate time;
pub use read::ZipArchive;
pub use write::ZipWriter;
pub use compression::CompressionMethod;
pub use types::DateTime;
pub use crate::read::ZipArchive;
pub use crate::write::ZipWriter;
pub use crate::compression::CompressionMethod;
pub use crate::types::DateTime;
mod spec;
mod crc32;

48
src/read.rs
View file

@ -1,22 +1,20 @@
//! Structs for reading a ZIP archive
use crc32::Crc32Reader;
use compression::CompressionMethod;
use zipcrypto::ZipCryptoReader;
use zipcrypto::ZipCryptoReaderValid;
use spec;
use result::{ZipResult, ZipError};
use crate::crc32::Crc32Reader;
use crate::compression::CompressionMethod;
use crate::zipcrypto::ZipCryptoReader;
use crate::zipcrypto::ZipCryptoReaderValid;
use crate::spec;
use crate::result::{ZipResult, ZipError};
use std::io;
use std::io::prelude::*;
use std::collections::HashMap;
use std::borrow::Cow;
use podio::{ReadPodExt, LittleEndian};
use types::{ZipFileData, System, DateTime};
use cp437::FromCp437;
use crate::types::{ZipFileData, System, DateTime};
use crate::cp437::FromCp437;
#[cfg(feature = "deflate")]
use flate2;
#[cfg(feature = "deflate")]
use flate2::read::DeflateDecoder;
@ -66,8 +64,8 @@ pub struct ZipArchive<R: Read + io::Seek>
enum CryptoReader<'a>
{
Plaintext(io::Take<&'a mut Read>),
ZipCrypto(ZipCryptoReaderValid<io::Take<&'a mut Read>>),
Plaintext(io::Take<&'a mut dyn Read>),
ZipCrypto(ZipCryptoReaderValid<io::Take<&'a mut dyn Read>>),
}
impl<'a> Read for CryptoReader<'a> {
@ -82,7 +80,7 @@ impl<'a> Read for CryptoReader<'a> {
impl<'a> CryptoReader<'a>
{
/// Consumes this decoder, returning the underlying reader.
pub fn into_inner(self) -> io::Take<&'a mut Read> {
pub fn into_inner(self) -> io::Take<&'a mut dyn Read> {
match self {
CryptoReader::Plaintext(r) => r,
CryptoReader::ZipCrypto(r) => r.into_inner(),
@ -116,7 +114,7 @@ impl<'a> Read for ZipFileReader<'a> {
impl<'a> ZipFileReader<'a>
{
/// Consumes this decoder, returning the underlying reader.
pub fn into_inner(self) -> io::Take<&'a mut Read> {
pub fn into_inner(self) -> io::Take<&'a mut dyn Read> {
match self {
ZipFileReader::NoReader => panic!("ZipFileReader was in an invalid state"),
ZipFileReader::Stored(r) => r.into_inner().into_inner(),
@ -141,9 +139,9 @@ fn unsupported_zip_error<T>(detail: &'static str) -> ZipResult<T>
fn make_reader<'a>(
compression_method: ::compression::CompressionMethod,
compression_method: crate::compression::CompressionMethod,
crc32: u32,
reader: io::Take<&'a mut io::Read>,
reader: io::Take<&'a mut dyn io::Read>,
password: Option<&[u8]>)
-> ZipResult<ZipFileReader<'a>> {
@ -325,6 +323,16 @@ impl<R: Read+io::Seek> ZipArchive<R>
self.offset
}
/// Get the comment of the zip archive.
pub fn comment(&self) -> &[u8] {
&self.comment
}
/// Returns an iterator over all the file and directory names in this archive.
pub fn file_names(&self) -> impl Iterator<Item = &str> {
self.names_map.keys().map(|s| s.as_str())
}
/// Search for a file entry by name, decrypt with given password
pub fn by_name_decrypt<'a>(&'a mut self, name: &str, password: &[u8]) -> ZipResult<ZipFile<'a>>
{
@ -391,7 +399,7 @@ impl<R: Read+io::Seek> ZipArchive<R>
data.data_start = data.header_start + magic_and_header + file_name_length + extra_field_length;
self.reader.seek(io::SeekFrom::Start(data.data_start))?;
let limit_reader = (self.reader.by_ref() as &mut Read).take(data.compressed_size);
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) })
}
@ -645,7 +653,7 @@ impl<'a> Drop for ZipFile<'a> {
/// * `comment`: set to an empty string
/// * `data_start`: set to 0
/// * `external_attributes`: `unix_mode()`: will return None
pub fn read_zipfile_from_stream<'a, R: io::Read>(reader: &'a mut R) -> ZipResult<Option<ZipFile>> {
pub fn read_zipfile_from_stream<'a, R: io::Read>(reader: &'a mut R) -> ZipResult<Option<ZipFile<'_>>> {
let signature = reader.read_u32::<LittleEndian>()?;
match signature {
@ -712,7 +720,7 @@ pub fn read_zipfile_from_stream<'a, R: io::Read>(reader: &'a mut R) -> ZipResult
return unsupported_zip_error("The file length is not available in the local header");
}
let limit_reader = (reader as &'a mut io::Read).take(result.compressed_size as u64);
let limit_reader = (reader as &'a mut dyn io::Read).take(result.compressed_size as u64);
let result_crc32 = result.crc32;
let result_compression_method = result.compression_method;
@ -754,7 +762,7 @@ mod test {
let mut v = Vec::new();
v.extend_from_slice(include_bytes!("../tests/data/mimetype.zip"));
let reader = ZipArchive::new(io::Cursor::new(v)).unwrap();
assert!(reader.comment == b"zip-rs");
assert!(reader.comment() == b"zip-rs");
}
#[test]

12
src/result.rs
View file

@ -33,14 +33,14 @@ pub enum ZipError
impl ZipError
{
fn detail(&self) -> ::std::borrow::Cow<str>
fn detail(&self) -> ::std::borrow::Cow<'_, str>
{
use std::error::Error;
match *self
{
ZipError::Io(ref io_err) => {
("Io Error: ".to_string() + (io_err as &error::Error).description()).into()
("Io Error: ".to_string() + (io_err as &dyn error::Error).description()).into()
},
ZipError::InvalidArchive(msg) | ZipError::UnsupportedArchive(msg) => {
(self.description().to_string() + ": " + msg).into()
@ -70,7 +70,7 @@ impl convert::From<ZipError> for io::Error
impl fmt::Display for ZipError
{
fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error>
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error>
{
fmt.write_str(&*self.detail())
}
@ -82,7 +82,7 @@ impl error::Error for ZipError
{
match *self
{
ZipError::Io(ref io_err) => (io_err as &error::Error).description(),
ZipError::Io(ref io_err) => (io_err as &dyn error::Error).description(),
ZipError::InvalidArchive(..) => "Invalid Zip archive",
ZipError::UnsupportedArchive(..) => "Unsupported Zip archive",
ZipError::FileNotFound => "Specified file not found in archive",
@ -91,11 +91,11 @@ impl error::Error for ZipError
}
}
fn cause(&self) -> Option<&error::Error>
fn cause(&self) -> Option<&dyn error::Error>
{
match *self
{
ZipError::Io(ref io_err) => Some(io_err as &error::Error),
ZipError::Io(ref io_err) => Some(io_err as &dyn error::Error),
_ => None,
}
}

2
src/spec.rs
View file

@ -1,6 +1,6 @@
use std::io;
use std::io::prelude::*;
use result::{ZipResult, ZipError};
use crate::result::{ZipResult, ZipError};
use podio::{ReadPodExt, WritePodExt, LittleEndian};
pub const LOCAL_FILE_HEADER_SIGNATURE : u32 = 0x04034b50;

73
src/types.rs
View file

@ -111,7 +111,7 @@ impl 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 >= 1 && tm.tm_mon <= 31
&& 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
@ -202,7 +202,7 @@ pub struct ZipFileData
/// True if the file is encrypted.
pub encrypted: bool,
/// Compression method used to store the file
pub compression_method: ::compression::CompressionMethod,
pub compression_method: crate::compression::CompressionMethod,
/// Last modified time. This will only have a 2 second precision.
pub last_modified_time: DateTime,
/// CRC32 checksum
@ -258,7 +258,7 @@ impl ZipFileData {
pub fn version_needed(&self) -> u16 {
match self.compression_method {
#[cfg(feature = "bzip2")]
::compression::CompressionMethod::Bzip2 => 46,
crate::compression::CompressionMethod::Bzip2 => 46,
_ => 20,
}
}
@ -283,7 +283,7 @@ mod test {
system: System::Dos,
version_made_by: 0,
encrypted: false,
compression_method: ::compression::CompressionMethod::Stored,
compression_method: crate::compression::CompressionMethod::Stored,
last_modified_time: DateTime::default(),
crc32: 0,
compressed_size: 0,
@ -333,6 +333,60 @@ mod test {
assert!(DateTime::from_date_and_time(2107, 12, 32, 0, 0, 0).is_err());
}
#[cfg(feature = "time")]
#[test]
fn datetime_from_time_bounds() {
use super::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());
// 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());
// 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());
// 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());
}
#[test]
fn time_conversion() {
use super::DateTime;
@ -373,4 +427,15 @@ mod test {
#[cfg(feature = "time")]
assert_eq!(format!("{}", dt.to_time().rfc3339()), "1980-00-00T00:00:00Z");
}
#[cfg(feature = "time")]
#[test]
fn time_at_january() {
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());
}
}

40
src/write.rs
View file

@ -1,25 +1,19 @@
//! Structs for creating a new zip archive
use compression::CompressionMethod;
use types::{ZipFileData, System, DEFAULT_VERSION, DateTime};
use spec;
use crate::compression::CompressionMethod;
use crate::types::{ZipFileData, System, DEFAULT_VERSION, DateTime};
use crate::spec;
use crc32fast::Hasher;
use result::{ZipResult, ZipError};
use crate::result::{ZipResult, ZipError};
use std::default::Default;
use std::io;
use std::io::prelude::*;
use std::mem;
#[cfg(feature = "time")]
use time;
use podio::{WritePodExt, LittleEndian};
#[cfg(feature = "deflate")]
use flate2;
#[cfg(feature = "deflate")]
use flate2::write::DeflateEncoder;
#[cfg(feature = "bzip2")]
use bzip2;
#[cfg(feature = "bzip2")]
use bzip2::write::BzEncoder;
@ -63,6 +57,7 @@ pub struct ZipWriter<W: Write + io::Seek>
files: Vec<ZipFileData>,
stats: ZipWriterStats,
writing_to_file: bool,
comment: String,
}
#[derive(Default)]
@ -180,9 +175,15 @@ impl<W: Write+io::Seek> ZipWriter<W>
files: Vec::new(),
stats: Default::default(),
writing_to_file: false,
comment: "zip-rs".into(),
}
}
/// Set ZIP archive comment. Defaults to 'zip-rs' if not set.
pub fn set_comment<S>(&mut self, comment: S) where S: Into<String> {
self.comment = comment.into();
}
/// Start a new file for with the requested options.
fn start_entry<S>(&mut self, name: S, options: FileOptions) -> ZipResult<()>
where S: Into<String>
@ -339,7 +340,7 @@ impl<W: Write+io::Seek> ZipWriter<W>
number_of_files: self.files.len() as u16,
central_directory_size: central_size as u32,
central_directory_offset: central_start as u32,
zip_file_comment: b"zip-rs".to_vec(),
zip_file_comment: self.comment.as_bytes().to_vec(),
};
footer.write(writer)?;
@ -395,13 +396,13 @@ impl<W: Write+io::Seek> GenericZipWriter<W>
Ok(())
}
fn ref_mut(&mut self) -> Option<&mut Write> {
fn ref_mut(&mut self) -> Option<&mut dyn Write> {
match *self {
GenericZipWriter::Storer(ref mut w) => Some(w as &mut Write),
GenericZipWriter::Storer(ref mut w) => Some(w as &mut dyn Write),
#[cfg(feature = "deflate")]
GenericZipWriter::Deflater(ref mut w) => Some(w as &mut Write),
GenericZipWriter::Deflater(ref mut w) => Some(w as &mut dyn Write),
#[cfg(feature = "bzip2")]
GenericZipWriter::Bzip2(ref mut w) => Some(w as &mut Write),
GenericZipWriter::Bzip2(ref mut w) => Some(w as &mut dyn Write),
GenericZipWriter::Closed => None,
}
}
@ -563,16 +564,17 @@ fn path_to_string(path: &std::path::Path) -> String {
mod test {
use std::io;
use std::io::Write;
use types::DateTime;
use crate::types::DateTime;
use super::{FileOptions, ZipWriter};
use compression::CompressionMethod;
use crate::compression::CompressionMethod;
#[test]
fn write_empty_zip() {
let mut writer = ZipWriter::new(io::Cursor::new(Vec::new()));
writer.set_comment("ZIP");
let result = writer.finish().unwrap();
assert_eq!(result.get_ref().len(), 28);
assert_eq!(*result.get_ref(), [80, 75, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 122, 105, 112, 45, 114, 115]);
assert_eq!(result.get_ref().len(), 25);
assert_eq!(*result.get_ref(), [80, 75, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 90, 73, 80]);
}
#[test]

9
tests/end_to_end.rs
View file

@ -1,8 +1,8 @@
extern crate zip;
use std::io::prelude::*;
use zip::write::FileOptions;
use std::io::Cursor;
use std::iter::FromIterator;
use std::collections::HashSet;
// This test asserts that after creating a zip file, then reading its contents back out,
// the extracted data will *always* be exactly the same as the original data.
@ -38,6 +38,11 @@ fn write_to_zip_file(file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<()> {
fn read_zip_file(zip_file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<String> {
let mut archive = zip::ZipArchive::new(zip_file).unwrap();
let expected_file_names = [ "test/", "test/☃.txt", "test/lorem_ipsum.txt" ];
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);
let mut file = archive.by_name("test/lorem_ipsum.txt")?;
let mut contents = String::new();

2
tests/invalid_date.rs
View file

@ -1,5 +1,3 @@
extern crate zip;
use zip::read::ZipArchive;
use std::io::Cursor;

11
tests/zip64_large.rs
View file

@ -53,9 +53,6 @@
// 22c400260 00 00 50 4b 05 06 00 00 00 00 03 00 03 00 27 01 |..PK..........'.|
// 22c400270 00 00 ff ff ff ff 00 00 |........|
// 22c400278
extern crate zip;
use std::io::{self, Seek, SeekFrom, Read};
const BLOCK1_LENGTH : u64 = 0x60;
@ -167,16 +164,16 @@ impl Read for Zip64File {
return Ok(0);
}
match self.pointer {
BLOCK1_START ... BLOCK1_END => {
BLOCK1_START ..= BLOCK1_END => {
buf[0] = BLOCK1[(self.pointer - BLOCK1_START) as usize];
},
BLOCK2_START ... BLOCK2_END => {
BLOCK2_START ..= BLOCK2_END => {
buf[0] = BLOCK2[(self.pointer - BLOCK2_START) as usize];
},
BLOCK3_START ... BLOCK3_END => {
BLOCK3_START ..= BLOCK3_END => {
buf[0] = BLOCK3[(self.pointer - BLOCK3_START) as usize];
},
BLOCK4_START ... BLOCK4_END => {
BLOCK4_START ..= BLOCK4_END => {
buf[0] = BLOCK4[(self.pointer - BLOCK4_START) as usize];
},
_ => {