openpgp: Use broken-down time in the literal data packet.

  - Also, make the `date` argument in the LiteralWriter's constructor
    optional, and explain what the parameters are for.

8 files changed, 41 insertions, 28 deletions

diff --git a/openpgp/examples/encrypt-for.rs b/openpgp/examples/encrypt-for.rs
index c65d73f8..5fe9360f 100644
--- a/openpgp/examples/encrypt-for.rs
+++ b/openpgp/examples/encrypt-for.rs
@@ -47,7 +47,7 @@ fn main() {
                                    &recipients,
                                    mode)
         .expect("Failed to create encryptor");
-    let mut literal_writer = LiteralWriter::new(encryptor, 't', None, 0)
+    let mut literal_writer = LiteralWriter::new(encryptor, 't', None, None)
         .expect("Failed to create literal writer");
 
     // Finally, copy stdin to our writer stack to encrypt the data.
diff --git a/openpgp/examples/sign.rs b/openpgp/examples/sign.rs
index 2e212c78..1d2376c2 100644
--- a/openpgp/examples/sign.rs
+++ b/openpgp/examples/sign.rs
@@ -37,7 +37,7 @@ fn main() {
 
     // Then, create a literal writer to wrap the data in a literal
     // message packet.
-    let mut literal = LiteralWriter::new(signer, 'b', None, 0)
+    let mut literal = LiteralWriter::new(signer, 'b', None, None)
         .expect("Failed to create literal writer");
 
     // Finally, just copy all the data.
diff --git a/openpgp/src/lib.rs b/openpgp/src/lib.rs
index 84dc6847..01b059f2 100644
--- a/openpgp/src/lib.rs
+++ b/openpgp/src/lib.rs
@@ -390,7 +390,7 @@ pub struct Literal {
     pub filename: Option<Vec<u8>>,
     /// A four-octet number that indicates a date associated with the
     /// literal data.
-    pub date: u32,
+    pub date: time::Tm,
 }
 
 /// Holds a compressed data packet.
diff --git a/openpgp/src/literal.rs b/openpgp/src/literal.rs
index 33464962..3b66d0c1 100644
--- a/openpgp/src/literal.rs
+++ b/openpgp/src/literal.rs
@@ -1,6 +1,8 @@
 use std::fmt;
 use std::cmp;
+use time;
 
+use conversions::Time;
 use Literal;
 use Packet;
 
@@ -42,7 +44,7 @@ impl Literal {
             common: Default::default(),
             format: format as u8,
             filename: None,
-            date: 0
+            date: time::Tm::from_pgp(0),
         }
     }
 
@@ -120,7 +122,7 @@ impl Literal {
     ///
     /// A Unix timestamp is the number of seconds since the Unix
     /// epoch.
-    pub fn date(mut self, timestamp: u32) -> Literal {
+    pub fn date(mut self, timestamp: time::Tm) -> Literal {
         self.date = timestamp;
         self
     }
diff --git a/openpgp/src/parse/parse.rs b/openpgp/src/parse/parse.rs
index 4d4e88d1..26af6449 100644
--- a/openpgp/src/parse/parse.rs
+++ b/openpgp/src/parse/parse.rs
@@ -1116,7 +1116,7 @@ impl Literal {
             common: Default::default(),
             format: format,
             filename: filename,
-            date: date,
+            date: time::Tm::from_pgp(date),
         }))?;
 
         // Enable hashing of the body.
@@ -1138,7 +1138,7 @@ fn literal_parser_test () {
         if let &Packet::Literal(ref p) = p {
             assert_eq!(p.format, 'b' as u8);
             assert_eq!(p.filename.as_ref().unwrap()[..], b"foobar"[..]);
-            assert_eq!(p.date, 1507458744);
+            assert_eq!(p.date, time::Tm::from_pgp(1507458744));
             assert_eq!(content, b"FOOBAR");
         } else {
             panic!("Wrong packet!");
@@ -1155,7 +1155,7 @@ fn literal_parser_test () {
             assert_eq!(p.format, 't' as u8);
             assert_eq!(p.filename.as_ref().unwrap()[..],
                        b"manifesto.txt"[..]);
-            assert_eq!(p.date, 1508000649);
+            assert_eq!(p.date, time::Tm::from_pgp(1508000649));
 
             let expected = bytes!("a-cypherpunks-manifesto.txt");
 
@@ -1270,7 +1270,7 @@ fn compressed_data_parser_test () {
         if let Packet::Literal(literal) = literal {
             assert_eq!(literal.filename, None);
             assert_eq!(literal.format, 'b' as u8);
-            assert_eq!(literal.date, 1509219866);
+            assert_eq!(literal.date, time::Tm::from_pgp(1509219866));
             assert_eq!(content, expected.to_vec());
         } else {
             panic!("Wrong packet!");
diff --git a/openpgp/src/serialize/mod.rs b/openpgp/src/serialize/mod.rs
index e0eeb9b2..235bbd6d 100644
--- a/openpgp/src/serialize/mod.rs
+++ b/openpgp/src/serialize/mod.rs
@@ -771,7 +771,7 @@ impl Literal {
         write_byte(o, self.format)?;
         write_byte(o, filename.len() as u8)?;
         o.write_all(filename)?;
-        write_be_u32(o, self.date)?;
+        write_be_u32(o, self.date.to_pgp()?)?;
         Ok(())
     }
 }
diff --git a/openpgp/src/serialize/stream.rs b/openpgp/src/serialize/stream.rs
index 25702647..5af69a05 100644
--- a/openpgp/src/serialize/stream.rs
+++ b/openpgp/src/serialize/stream.rs
@@ -33,6 +33,7 @@ use constants::{
     SignatureType,
     SymmetricAlgorithm,
 };
+use conversions::Time;
 
 /// Cookie must be public because the writers are.
 #[doc(hidden)]
@@ -198,7 +199,7 @@ impl<'a> Signer<'a> {
     /// let mut o = vec![];
     /// {
     ///     let signer = Signer::new(wrap(&mut o), &[&tsk])?;
-    ///     let mut ls = LiteralWriter::new(signer, 't', None, 0)?;
+    ///     let mut ls = LiteralWriter::new(signer, 't', None, None)?;
     ///     ls.write_all(b"Make it so, number one!")?;
     ///     ls.finalize_all()?;
     /// }
@@ -462,7 +463,7 @@ impl<'a> writer::Stackable<'a, Cookie> for Signer<'a> {
 /// # fn f() -> Result<()> {
 /// let mut o = vec![];
 /// {
-///     let mut w = LiteralWriter::new(wrap(&mut o), 't', None, 0)?;
+///     let mut w = LiteralWriter::new(wrap(&mut o), 't', None, None)?;
 ///     w.write_all(b"Hello world.")?;
 /// }
 /// assert_eq!(b"\xcb\x12t\x00\x00\x00\x00\x00Hello world.", o.as_slice());
@@ -476,13 +477,23 @@ pub struct LiteralWriter<'a> {
 
 impl<'a> LiteralWriter<'a> {
     /// Creates a new literal writer.
+    ///
+    /// `format`, `filename`, and `date` will be emitted as part of
+    /// the literal packets headers.  Note that these headers will not
+    /// be authenticated by signatures (but will be authenticated by a
+    /// SEIP/MDC container), and are therefore unreliable and should
+    /// not be trusted.
+    ///
+    /// If `date` is `None`, then the earliest representable time will
+    /// be used as a dummy value.
     pub fn new(inner: writer::Stack<'a, Cookie>,
-               format: char, filename: Option<&[u8]>, date: u32)
+               format: char, filename: Option<&[u8]>, date: Option<time::Tm>)
                -> Result<writer::Stack<'a, Cookie>> {
         let mut inner = writer::BoxStack::from(inner);
         let level = inner.cookie_ref().level + 1;
 
-        let mut template = Literal::new(format).date(date);
+        let mut template = Literal::new(format)
+            .date(date.unwrap_or(time::Tm::from_pgp(0)));
 
         if let Some(f) = filename {
             template = template.filename_from_bytes(f);
@@ -613,7 +624,7 @@ impl<'a> writer::Stackable<'a, Cookie> for LiteralWriter<'a> {
 /// {
 ///     let w = Compressor::new(wrap(&mut o),
 ///                             CompressionAlgorithm::Uncompressed)?;
-///     let mut w = LiteralWriter::new(w, 't', None, 0)?;
+///     let mut w = LiteralWriter::new(w, 't', None, None)?;
 ///     w.write_all(b"Hello world.")?;
 /// }
 /// assert_eq!(b"\xc8\x15\x00\xcb\x12t\x00\x00\x00\x00\x00Hello world.",
@@ -797,7 +808,7 @@ impl<'a> Encryptor<'a> {
     ///                                &[&tpk],
     ///                                EncryptionMode::AtRest)
     ///     .expect("Failed to create encryptor");
-    /// let mut w = LiteralWriter::new(encryptor, 't', None, 0)?;
+    /// let mut w = LiteralWriter::new(encryptor, 't', None, None)?;
     /// w.write_all(b"Hello world.")?;
     /// # Ok(())
     /// # }
@@ -1037,7 +1048,7 @@ mod test {
         if let Packet::Literal(ref l) = pp.packet {
                 assert_eq!(l.format, 't' as u8);
                 assert_eq!(l.filename, None);
-                assert_eq!(l.date, 0);
+                assert_eq!(l.date, time::Tm::from_pgp(0));
         } else {
             panic!("Unexpected packet type.");
         }
@@ -1072,14 +1083,14 @@ mod test {
         {
             let c = Compressor::new(
                 wrap(&mut o), CompressionAlgorithm::Uncompressed).unwrap();
-            let mut ls = LiteralWriter::new(c, 't', None, 0).unwrap();
+            let mut ls = LiteralWriter::new(c, 't', None, None).unwrap();
             write!(ls, "one").unwrap();
             let c = ls.finalize().unwrap().unwrap(); // Pop the LiteralWriter.
-            let mut ls = LiteralWriter::new(c, 't', None, 0).unwrap();
+            let mut ls = LiteralWriter::new(c, 't', None, None).unwrap();
             write!(ls, "two").unwrap();
             let c = ls.finalize().unwrap().unwrap(); // Pop the LiteralWriter.
             let c = c.finalize().unwrap().unwrap(); // Pop the Compressor.
-            let mut ls = LiteralWriter::new(c, 't', None, 0).unwrap();
+            let mut ls = LiteralWriter::new(c, 't', None, None).unwrap();
             write!(ls, "three").unwrap();
         }
 
@@ -1124,19 +1135,19 @@ mod test {
                 wrap(&mut o), CompressionAlgorithm::Uncompressed).unwrap();
             let c = Compressor::new(
                 c0, CompressionAlgorithm::Uncompressed).unwrap();
-            let mut ls = LiteralWriter::new(c, 't', None, 0).unwrap();
+            let mut ls = LiteralWriter::new(c, 't', None, None).unwrap();
             write!(ls, "one").unwrap();
             let c = ls.finalize().unwrap().unwrap();
-            let mut ls = LiteralWriter::new(c, 't', None, 0).unwrap();
+            let mut ls = LiteralWriter::new(c, 't', None, None).unwrap();
             write!(ls, "two").unwrap();
             let c = ls.finalize().unwrap().unwrap();
             let c0 = c.finalize().unwrap().unwrap();
             let c = Compressor::new(
                 c0, CompressionAlgorithm::Uncompressed).unwrap();
-            let mut ls = LiteralWriter::new(c, 't', None, 0).unwrap();
+            let mut ls = LiteralWriter::new(c, 't', None, None).unwrap();
             write!(ls, "three").unwrap();
             let c = ls.finalize().unwrap().unwrap();
-            let mut ls = LiteralWriter::new(c, 't', None, 0).unwrap();
+            let mut ls = LiteralWriter::new(c, 't', None, None).unwrap();
             write!(ls, "four").unwrap();
         }
 
@@ -1160,7 +1171,7 @@ mod test {
         {
             let c = Compressor::new(wrap(&mut o),
                                     CompressionAlgorithm::BZip2).unwrap();
-            let mut ls = LiteralWriter::new(c, 't', None, 0).unwrap();
+            let mut ls = LiteralWriter::new(c, 't', None, None).unwrap();
             // Write 64 megabytes of zeroes.
             for _ in 0 .. 16 * 1024 {
                 ls.write_all(&zeros).unwrap();
@@ -1186,7 +1197,7 @@ mod test {
                 wrap(&mut o),
                 &tsks.iter().map(|(_, tsk)| tsk).collect::<Vec<&TPK>>())
                 .unwrap();
-            let mut ls = LiteralWriter::new(signer, 't', None, 0).unwrap();
+            let mut ls = LiteralWriter::new(signer, 't', None, None).unwrap();
             ls.write_all(b"Tis, tis, tis.  Tis is important.").unwrap();
             let signer = ls.finalize().unwrap().unwrap();
             let _ = signer.finalize().unwrap().unwrap();
@@ -1223,7 +1234,7 @@ mod test {
             let encryptor = Encryptor::new(wrap(&mut o), &passwords, &[],
                                            EncryptionMode::ForTransport)
                 .unwrap();
-            let mut literal = LiteralWriter::new(encryptor, 'b', None, 0)
+            let mut literal = LiteralWriter::new(encryptor, 'b', None, None)
                 .unwrap();
             literal.write_all(message).unwrap();
         }
diff --git a/tool/src/commands.rs b/tool/src/commands.rs
index 95f5b2ea..cd591f52 100644
--- a/tool/src/commands.rs
+++ b/tool/src/commands.rs
@@ -154,7 +154,7 @@ pub fn encrypt(store: &mut store::Store,
                                    &recipients,
                                    EncryptionMode::AtRest)
         .context("Failed to create encryptor")?;
-    let mut literal_writer = LiteralWriter::new(encryptor, 'b', None, 0)
+    let mut literal_writer = LiteralWriter::new(encryptor, 'b', None, None)
         .context("Failed to create literal writer")?;
 
     // Finally, copy stdin to our writer stack to encrypt the data.