From a16962cd2cc4d5d035942d984b716ab79f5706f0 Mon Sep 17 00:00:00 2001 From: Alexander Koval Date: Thu, 21 Apr 2016 18:42:10 +0300 Subject: [PATCH] Support for external file attributes --- examples/extract.rs | 40 +++++++++++++++++++++++++++++------- src/read.rs | 50 +++++++++++++++++++++++++++++++++++++++------ src/types.rs | 11 ++++++++++ src/write.rs | 8 ++++++-- 4 files changed, 94 insertions(+), 15 deletions(-) diff --git a/examples/extract.rs b/examples/extract.rs index 0bd5951f..25cadb54 100644 --- a/examples/extract.rs +++ b/examples/extract.rs @@ -3,6 +3,9 @@ extern crate zip; use std::io; use std::fs; +#[cfg(unix)] +use std::os::unix::fs::PermissionsExt; + fn main() { std::process::exit(real_main()); } @@ -30,28 +33,51 @@ fn real_main() -> i32 if comment.len() > 0 { println!(" File comment: {}", comment); } } - create_directory(outpath.parent().unwrap_or(std::path::Path::new(""))); + create_directory(outpath.parent().unwrap_or(std::path::Path::new("")), None); + + let perms = convert_permissions(file.unix_mode()); if (&*file.name()).ends_with("/") { - create_directory(&outpath); + create_directory(&outpath, perms); + } else { - write_file(&mut file, &outpath); + write_file(&mut file, &outpath, perms); } } return 0; } -fn write_file(reader: &mut zip::read::ZipFile, outpath: &std::path::Path) +#[cfg(unix)] +fn convert_permissions(mode: Option) -> Option { - let mut outfile = fs::File::create(&outpath).unwrap(); - io::copy(reader, &mut outfile).unwrap(); + match mode { + Some(mode) => Some(fs::Permissions::from_mode(mode)), + None => None, + } +} +#[cfg(not(unix))] +fn convert_permissions(_mode: Option) -> Option +{ + None } -fn create_directory(outpath: &std::path::Path) +fn write_file(file: &mut zip::read::ZipFile, outpath: &std::path::Path, perms: Option) +{ + let mut outfile = fs::File::create(&outpath).unwrap(); + io::copy(file, &mut outfile).unwrap(); + if let Some(perms) = perms { + fs::set_permissions(outpath, perms).unwrap(); + } +} + +fn create_directory(outpath: &std::path::Path, perms: Option) { fs::create_dir_all(&outpath).unwrap(); + if let Some(perms) = perms { + fs::set_permissions(outpath, perms).unwrap(); + } } fn sanitize_filename(filename: &str) -> std::path::PathBuf diff --git a/src/read.rs b/src/read.rs index 9d676965..6a30bceb 100644 --- a/src/read.rs +++ b/src/read.rs @@ -10,13 +10,18 @@ use std::collections::HashMap; use flate2; use flate2::FlateReadExt; use podio::{ReadPodExt, LittleEndian}; -use types::ZipFileData; +use types::{ZipFileData, SYSTEM_MSDOS, SYSTEM_UNIX}; use cp437::FromCp437; use msdos_time::{TmMsDosExt, MsDosDateTime}; #[cfg(feature = "bzip2")] use bzip2::read::BzDecoder; +mod ffi { + pub const S_IFDIR: u32 = 0o0040000; + pub const S_IFREG: u32 = 0o0100000; +} + /// Wrapper for reading the contents of a ZIP file. /// /// ``` @@ -181,8 +186,8 @@ fn central_header_to_zip_file(reader: &mut R) -> ZipResult()); - try!(reader.read_u16::()); + let version_made_by = try!(reader.read_u16::()); + let _version_to_extract = try!(reader.read_u16::()); let flags = try!(reader.read_u16::()); let encrypted = flags & 1 == 1; let is_utf8 = flags & (1 << 11) != 0; @@ -195,9 +200,9 @@ fn central_header_to_zip_file(reader: &mut R) -> ZipResult()) as usize; let extra_field_length = try!(reader.read_u16::()) as usize; let file_comment_length = try!(reader.read_u16::()) as usize; - try!(reader.read_u16::()); - try!(reader.read_u16::()); - try!(reader.read_u32::()); + let _disk_number = try!(reader.read_u16::()); + let _internal_file_attributes = try!(reader.read_u16::()); + let external_file_attributes = try!(reader.read_u32::()); let offset = try!(reader.read_u32::()) as u64; let file_name_raw = try!(ReadPodExt::read_exact(reader, file_name_length)); let extra_field = try!(ReadPodExt::read_exact(reader, extra_field_length)); @@ -234,6 +239,8 @@ fn central_header_to_zip_file(reader: &mut R) -> ZipResult> 8) as u8, + version: version_made_by as u8, encrypted: encrypted, compression_method: CompressionMethod::from_u16(compression_method), last_modified_time: try!(::time::Tm::from_msdos(MsDosDateTime::new(last_mod_time, last_mod_date))), @@ -244,6 +251,7 @@ fn central_header_to_zip_file(reader: &mut R) -> ZipResult ZipFile<'a> { ZipFileReader::Bzip2(ref mut r) => r as &mut Read, } } + /// Get compatibility of the file attribute information + pub fn system(&self) -> u8 { + self.data.system + } + /// Get the version of the file + pub fn version(&self) -> u8 { + self.data.version + } /// Get the name of the file pub fn name(&self) -> &str { &*self.data.file_name @@ -304,6 +320,28 @@ impl<'a> ZipFile<'a> { pub fn last_modified(&self) -> ::time::Tm { self.data.last_modified_time } + /// Get mode for the file + pub fn unix_mode(&self) -> Option { + match self.data.system { + s if s == SYSTEM_UNIX => { + Some(self.data.external_attributes >> 16) + }, + s if s == SYSTEM_MSDOS => { + // Interpret MSDOS directory bit + let mut mode = if 0x10 == (self.data.external_attributes & 0x10) { + ffi::S_IFDIR | 0o0775 + } else { + ffi::S_IFREG | 0o0664 + }; + if 0x01 == (self.data.external_attributes & 0x01) { + // Read-only bit; strip write permissions + mode &= 0o0555; + } + Some(mode) + }, + _ => None, + } + } } impl<'a> Read for ZipFile<'a> { diff --git a/src/types.rs b/src/types.rs index 51d72b34..6677637b 100644 --- a/src/types.rs +++ b/src/types.rs @@ -2,9 +2,18 @@ use time; +pub const SYSTEM_MSDOS: u8 = 0; +pub const SYSTEM_UNIX: u8 = 3; + +pub const DEFAULT_VERSION: u8 = 20; + /// Structure representing a ZIP file. pub struct ZipFileData { + /// Compatibility of the file attribute information + pub system: u8, + /// Specification version + pub version: u8, /// True if the file is encrypted. pub encrypted: bool, /// Compression method used to store the file @@ -25,4 +34,6 @@ pub struct ZipFileData pub header_start: u64, /// Specifies where the compressed data of the file starts pub data_start: u64, + /// External file attributes + pub external_attributes: u32, } diff --git a/src/write.rs b/src/write.rs index 88dad79b..5ab6d443 100644 --- a/src/write.rs +++ b/src/write.rs @@ -1,7 +1,7 @@ //! Structs for creating a new zip archive use compression::CompressionMethod; -use types::ZipFileData; +use types::{ZipFileData, SYSTEM_MSDOS, DEFAULT_VERSION}; use spec; use crc32; use result::{ZipResult, ZipError}; @@ -134,6 +134,8 @@ impl ZipWriter let mut file = ZipFileData { + system: SYSTEM_MSDOS, + version: DEFAULT_VERSION, encrypted: false, compression_method: compression, last_modified_time: time::now(), @@ -144,6 +146,7 @@ impl ZipWriter file_comment: String::new(), header_start: header_start, data_start: 0, + external_attributes: 0, }; try!(write_local_file_header(writer, &file)); @@ -319,7 +322,8 @@ impl GenericZipWriter fn write_local_file_header(writer: &mut T, file: &ZipFileData) -> ZipResult<()> { try!(writer.write_u32::(spec::LOCAL_FILE_HEADER_SIGNATURE)); - try!(writer.write_u16::(20)); + let version_made_by = (file.system as u16) << 8 | (file.version as u16); + try!(writer.write_u16::(version_made_by)); let flag = if !file.file_name.is_ascii() { 1u16 << 11 } else { 0 }; try!(writer.write_u16::(flag)); try!(writer.write_u16::(file.compression_method.to_u16()));