Add support for building GNU archives (issue #10)

Author: mdsteele

src/lib.rs

@@ -24,8 +24,7 @@
 //!   stores filenames in a slightly different, incompatible way, and has its
 //!   own strategy for supporting long filenames.
 //!
-//! Currently, this crate supports reading all three of these variants, but
-//! only supports writing the BSD/common variant.
+//! This crate supports reading and writing all three of these variants.
 //!
 //! # Example usage
 //!
@@ -71,6 +70,7 @@ extern crate byteorder;
 
 use byteorder::{BigEndian, LittleEndian, ReadBytesExt};
 use std::cmp;
+use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
 use std::fs::{File, Metadata};
 use std::io::{self, BufRead, BufReader, Error, ErrorKind, Read, Result, Seek,
@@ -97,7 +97,7 @@ const ENTRY_HEADER_LEN: usize = 60;
 const BSD_SYMBOL_LOOKUP_TABLE_ID: &[u8] = b"__.SYMDEF";
 const BSD_SORTED_SYMBOL_LOOKUP_TABLE_ID: &[u8] = b"__.SYMDEF SORTED";
 
-const GNU_NAME_TABLE_ID: &[u8] = b"//";
+const GNU_NAME_TABLE_ID: &str = "//";
 const GNU_SYMBOL_LOOKUP_TABLE_ID: &[u8] = b"/";
 
 // ========================================================================= //
@@ -130,12 +130,12 @@ impl Header {
     /// other fields set to zero.
     pub fn new(identifier: Vec<u8>, size: u64) -> Header {
         Header {
-            identifier: identifier,
+            identifier,
             mtime: 0,
             uid: 0,
             gid: 0,
             mode: 0,
-            size: size,
+            size,
         }
     }
 
@@ -144,7 +144,7 @@ impl Header {
     #[cfg(unix)]
     pub fn from_metadata(identifier: Vec<u8>, meta: &Metadata) -> Header {
         Header {
-            identifier: identifier,
+            identifier,
             mtime: meta.mtime() as u64,
             uid: meta.uid(),
             gid: meta.gid(),
@@ -230,7 +230,7 @@ impl Header {
             if identifier == GNU_SYMBOL_LOOKUP_TABLE_ID {
                 io::copy(&mut reader.by_ref().take(size), &mut io::sink())?;
                 return Ok(Some((Header::new(identifier, size), header_len)));
-            } else if identifier == GNU_NAME_TABLE_ID {
+            } else if identifier == GNU_NAME_TABLE_ID.as_bytes() {
                 *name_table = vec![0; size as usize];
                 reader.read_exact(name_table as &mut [u8]).map_err(|err| {
                     annotate(err, "failed to read name table")
@@ -308,12 +308,12 @@ impl Header {
         }
         Ok(Some((
             Header {
-                identifier: identifier,
-                mtime: mtime,
-                uid: uid,
-                gid: gid,
-                mode: mode,
-                size: size,
+                identifier,
+                mtime,
+                uid,
+                gid,
+                mode,
+                size,
             },
             header_len,
         )))
@@ -350,6 +350,31 @@ impl Header {
         }
         Ok(())
     }
+
+    fn write_gnu<W>(&self, writer: &mut W, names: &HashMap<Vec<u8>, usize>)
+        -> Result<()>
+    where
+        W: Write,
+    {
+        if self.identifier.len() > 15 {
+            let offset = names[&self.identifier];
+            write!(writer, "/{:<15}", offset)?;
+        } else {
+            writer.write_all(&self.identifier)?;
+            writer.write_all(b"/")?;
+            writer.write_all(&vec![b' '; 15 - self.identifier.len()])?;
+        }
+        write!(
+            writer,
+            "{:<12}{:<6}{:<6}{:<8o}{:<10}`\n",
+            self.mtime,
+            self.uid,
+            self.gid,
+            self.mode,
+            self.size
+        )?;
+        Ok(())
+    }
 }
 
 fn parse_number(field_name: &str, bytes: &[u8], radix: u32) -> Result<u64> {
@@ -419,7 +444,7 @@ impl<R: Read> Archive<R> {
     /// source of all data read.
     pub fn new(reader: R) -> Archive<R> {
         Archive {
-            reader: reader,
+            reader,
             variant: Variant::Common,
             name_table: Vec::new(),
             entry_headers: Vec::new(),
@@ -446,7 +471,8 @@ impl<R: Read> Archive<R> {
     pub fn into_inner(self) -> Result<R> { Ok(self.reader) }
 
     fn is_name_table_id(&self, identifier: &[u8]) -> bool {
-        self.variant == Variant::GNU && identifier == GNU_NAME_TABLE_ID
+        self.variant == Variant::GNU &&
+            identifier == GNU_NAME_TABLE_ID.as_bytes()
     }
 
     fn is_symbol_lookup_table_id(&self, identifier: &[u8]) -> bool {
@@ -650,7 +676,7 @@ impl<R: Read + Seek> Archive<R> {
         }
         self.next_entry_index = index + 1;
         Ok(Entry {
-            header: header,
+            header,
             reader: self.reader.by_ref(),
             length: size,
             position: 0,
@@ -851,7 +877,8 @@ impl<'a, R: Read> ExactSizeIterator for Symbols<'a, R> {}
 
 // ========================================================================= //
 
-/// A structure for building archives.
+/// A structure for building Common or BSD-variant archives (the archive format
+/// typically used on e.g. BSD and Mac OS X systems).
 ///
 /// This structure has methods for building up an archive from scratch into any
 /// arbitrary writer.
@@ -865,7 +892,7 @@ impl<W: Write> Builder<W> {
     /// destination of all data written.
     pub fn new(writer: W) -> Builder<W> {
         Builder {
-            writer: writer,
+            writer,
             started: false,
         }
     }
@@ -921,6 +948,135 @@ impl<W: Write> Builder<W> {
     }
 }
 
+// ========================================================================= //
+
+/// A structure for building GNU-variant archives (the archive format typically
+/// used on e.g. GNU/Linux and Windows systems).
+///
+/// This structure has methods for building up an archive from scratch into any
+/// arbitrary writer.
+pub struct GnuBuilder<W: Write> {
+    writer: W,
+    short_names: HashSet<Vec<u8>>,
+    long_names: HashMap<Vec<u8>, usize>,
+    name_table_size: usize,
+    started: bool,
+}
+
+impl<W: Write> GnuBuilder<W> {
+    /// Create a new archive builder with the underlying writer object as the
+    /// destination of all data written.  The `identifiers` parameter must give
+    /// the complete list of entry identifiers that will be included in this
+    /// archive.
+    pub fn new(writer: W, identifiers: Vec<Vec<u8>>) -> GnuBuilder<W> {
+        let mut short_names = HashSet::<Vec<u8>>::new();
+        let mut long_names = HashMap::<Vec<u8>, usize>::new();
+        let mut name_table_size: usize = 0;
+        for identifier in identifiers.into_iter() {
+            let length = identifier.len();
+            if length > 15 {
+                long_names.insert(identifier, name_table_size);
+                name_table_size += length + 2;
+            } else {
+                short_names.insert(identifier);
+            }
+        }
+        GnuBuilder {
+            writer,
+            short_names,
+            long_names,
+            name_table_size,
+            started: false,
+        }
+    }
+
+    /// Unwrap this archive builder, returning the underlying writer object.
+    pub fn into_inner(self) -> Result<W> { Ok(self.writer) }
+
+    /// Adds a new entry to this archive.
+    pub fn append<R: Read>(&mut self, header: &Header, mut data: R)
+        -> Result<()> {
+        let is_long_name = header.identifier().len() > 15;
+        let has_name = if is_long_name {
+            self.long_names.contains_key(header.identifier())
+        } else {
+            self.short_names.contains(header.identifier())
+        };
+        if !has_name {
+            let msg = format!(
+                "Identifier {:?} was not in the list of \
+                 identifiers passed to GnuBuilder::new()",
+                String::from_utf8_lossy(header.identifier())
+            );
+            return Err(Error::new(ErrorKind::InvalidInput, msg));
+        }
+
+        if !self.started {
+            self.writer.write_all(GLOBAL_HEADER)?;
+            if !self.long_names.is_empty() {
+                write!(
+                    self.writer,
+                    "{:<48}{:<10}`\n",
+                    GNU_NAME_TABLE_ID,
+                    self.name_table_size
+                )?;
+                let mut entries: Vec<(usize, &[u8])> = self.long_names
+                    .iter()
+                    .map(|(id, &start)| (start, id.as_slice()))
+                    .collect();
+                entries.sort();
+                for (_, id) in entries {
+                    self.writer.write_all(id)?;
+                    self.writer.write_all(b"/\n")?;
+                }
+            }
+            self.started = true;
+        }
+
+        header.write_gnu(&mut self.writer, &self.long_names)?;
+        let actual_size = io::copy(&mut data, &mut self.writer)?;
+        if actual_size != header.size() {
+            let msg = format!(
+                "Wrong file size (header.size() = {}, actual \
+                               size was {})",
+                header.size(),
+                actual_size
+            );
+            return Err(Error::new(ErrorKind::InvalidData, msg));
+        }
+        if actual_size % 2 != 0 {
+            self.writer.write_all(&['\n' as u8])?;
+        }
+
+        Ok(())
+    }
+
+    /// Adds a file on the local filesystem to this archive, using the file
+    /// name as its identifier.
+    pub fn append_path<P: AsRef<Path>>(&mut self, path: P) -> Result<()> {
+        let name: &OsStr = path.as_ref().file_name().ok_or_else(|| {
+            let msg = "Given path doesn't have a file name";
+            Error::new(ErrorKind::InvalidInput, msg)
+        })?;
+        let identifier = osstr_to_bytes(name)?;
+        let mut file = File::open(&path)?;
+        self.append_file_id(identifier, &mut file)
+    }
+
+    /// Adds a file to this archive, with the given name as its identifier.
+    pub fn append_file(&mut self, name: &[u8], file: &mut File) -> Result<()> {
+        self.append_file_id(name.to_vec(), file)
+    }
+
+    fn append_file_id(&mut self, id: Vec<u8>, file: &mut File) -> Result<()> {
+        let metadata = file.metadata()?;
+        let header = Header::from_metadata(id, &metadata);
+        self.append(&header, file)
+    }
+}
+
+// ========================================================================= //
+
 #[cfg(unix)]
 fn osstr_to_bytes(string: &OsStr) -> Result<Vec<u8>> {
     Ok(string.as_bytes().to_vec())
@@ -960,7 +1116,7 @@ fn annotate(error: io::Error, msg: &str) -> io::Error {
 
 #[cfg(test)]
 mod tests {
-    use super::{Archive, Builder, Header, Variant};
+    use super::{Archive, Builder, GnuBuilder, Header, Variant};
     use std::io::{Cursor, Read, Result, Seek, SeekFrom};
     use std::str;
 
@@ -1040,6 +1196,85 @@ mod tests {
         assert_eq!(str::from_utf8(&actual).unwrap(), expected);
     }
 
+    #[test]
+    fn build_gnu_archive() {
+        let names = vec![b"baz.txt".to_vec(), b"foo.txt".to_vec()];
+        let mut builder = GnuBuilder::new(Vec::new(), names);
+        let mut header1 = Header::new(b"foo.txt".to_vec(), 7);
+        header1.set_mtime(1487552916);
+        header1.set_uid(501);
+        header1.set_gid(20);
+        header1.set_mode(0o100644);
+        builder.append(&header1, "foobar\n".as_bytes()).unwrap();
+        let header2 = Header::new(b"baz.txt".to_vec(), 4);
+        builder.append(&header2, "baz\n".as_bytes()).unwrap();
+        let actual = builder.into_inner().unwrap();
+        let expected = "\
+        !<arch>\n\
+        foo.txt/        1487552916  501   20    100644  7         `\n\
+        foobar\n\n\
+        baz.txt/        0           0     0     0       4         `\n\
+        baz\n";
+        assert_eq!(str::from_utf8(&actual).unwrap(), expected);
+    }
+
+    #[test]
+    fn build_gnu_archive_with_long_filenames() {
+        let names = vec![
+            b"this_is_a_very_long_filename.txt".to_vec(),
+            b"and_this_is_another_very_long_filename.txt".to_vec(),
+        ];
+        let mut builder = GnuBuilder::new(Vec::new(), names);
+        let mut header1 = Header::new(b"short".to_vec(), 1);
+        header1.set_identifier(b"this_is_a_very_long_filename.txt".to_vec());
+        header1.set_mtime(1487552916);
+        header1.set_uid(501);
+        header1.set_gid(20);
+        header1.set_mode(0o100644);
+        header1.set_size(7);
+        builder.append(&header1, "foobar\n".as_bytes()).unwrap();
+        let header2 = Header::new(
+            b"and_this_is_another_very_long_filename.txt".to_vec(),
+            4,
+        );
+        builder.append(&header2, "baz\n".as_bytes()).unwrap();
+        let actual = builder.into_inner().unwrap();
+        let expected = "\
+        !<arch>\n\
+        //                                              78        `\n\
+        this_is_a_very_long_filename.txt/\n\
+        and_this_is_another_very_long_filename.txt/\n\
+        /0              1487552916  501   20    100644  7         `\n\
+        foobar\n\n\
+        /34             0           0     0     0       4         `\n\
+        baz\n";
+        assert_eq!(str::from_utf8(&actual).unwrap(), expected);
+    }
+
+    #[test]
+    fn build_gnu_archive_with_space_in_filename() {
+        let names = vec![b"foo bar".to_vec()];
+        let mut builder = GnuBuilder::new(Vec::new(), names);
+        let header = Header::new(b"foo bar".to_vec(), 4);
+        builder.append(&header, "baz\n".as_bytes()).unwrap();
+        let actual = builder.into_inner().unwrap();
+        let expected = "\
+        !<arch>\n\
+        foo bar/        0           0     0     0       4         `\n\
+        baz\n";
+        assert_eq!(str::from_utf8(&actual).unwrap(), expected);
+    }
+
+    #[test]
+    #[should_panic(expected = "Identifier \\\"bar\\\" was not in the list of \
+                               identifiers passed to GnuBuilder::new()")]
+    fn build_gnu_archive_with_unexpected_identifier() {
+        let names = vec![b"foo".to_vec()];
+        let mut builder = GnuBuilder::new(Vec::new(), names);
+        let header = Header::new(b"bar".to_vec(), 4);
+        builder.append(&header, "baz\n".as_bytes()).unwrap();
+    }
+
     #[test]
     fn read_common_archive() {
         let input = "\