Support for external file attributes

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<u32>) -> Option<fs::Permissions>
 {
-    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<u32>) -> Option<fs::Permissions>
+{
+    None
 }
 
-fn create_directory(outpath: &std::path::Path)
+fn write_file(file: &mut zip::read::ZipFile, outpath: &std::path::Path, perms: Option<fs::Permissions>)
+{
+    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::Permissions>)
 {
     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

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<R: Read+io::Seek>(reader: &mut R) -> ZipResult<Zip
         return Err(ZipError::InvalidArchive("Invalid Central Directory header"))
     }
 
-    try!(reader.read_u16::<LittleEndian>());
-    try!(reader.read_u16::<LittleEndian>());
+    let version_made_by = try!(reader.read_u16::<LittleEndian>());
+    let _version_to_extract = try!(reader.read_u16::<LittleEndian>());
     let flags = try!(reader.read_u16::<LittleEndian>());
     let encrypted = flags & 1 == 1;
     let is_utf8 = flags & (1 << 11) != 0;
@@ -195,9 +200,9 @@ fn central_header_to_zip_file<R: Read+io::Seek>(reader: &mut R) -> ZipResult<Zip
     let file_name_length = try!(reader.read_u16::<LittleEndian>()) as usize;
     let extra_field_length = try!(reader.read_u16::<LittleEndian>()) as usize;
     let file_comment_length = try!(reader.read_u16::<LittleEndian>()) as usize;
-    try!(reader.read_u16::<LittleEndian>());
-    try!(reader.read_u16::<LittleEndian>());
-    try!(reader.read_u32::<LittleEndian>());
+    let _disk_number = try!(reader.read_u16::<LittleEndian>());
+    let _internal_file_attributes = try!(reader.read_u16::<LittleEndian>());
+    let external_file_attributes = try!(reader.read_u32::<LittleEndian>());
     let offset = try!(reader.read_u32::<LittleEndian>()) 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<R: Read+io::Seek>(reader: &mut R) -> ZipResult<Zip
     // Construct the result
     let mut result = ZipFileData
     {
+        system: (version_made_by >> 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<R: Read+io::Seek>(reader: &mut R) -> ZipResult<Zip
         file_comment: file_comment,
         header_start: offset,
         data_start: data_start,
+        external_attributes: external_file_attributes,
     };
 
     try!(parse_extra_field(&mut result, &*extra_field));
@@ -280,6 +288,14 @@ impl<'a> 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<u32> {
+        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> {

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,
 }

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<W: Write+io::Seek> ZipWriter<W>
 
             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<W: Write+io::Seek> ZipWriter<W>
                 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<W: Write+io::Seek> GenericZipWriter<W>
 fn write_local_file_header<T: Write>(writer: &mut T, file: &ZipFileData) -> ZipResult<()>
 {
     try!(writer.write_u32::<LittleEndian>(spec::LOCAL_FILE_HEADER_SIGNATURE));
-    try!(writer.write_u16::<LittleEndian>(20));
+    let version_made_by = (file.system as u16) << 8 | (file.version as u16);
+    try!(writer.write_u16::<LittleEndian>(version_made_by));
     let flag = if !file.file_name.is_ascii() { 1u16 << 11 } else { 0 };
     try!(writer.write_u16::<LittleEndian>(flag));
     try!(writer.write_u16::<LittleEndian>(file.compression_method.to_u16()));