Allow command line --epoch for Bootleby which has no proper app.toml(epoch)

Author: lzrd

hubedit/src/main.rs

@@ -33,6 +33,9 @@ pub enum Command {
         #[clap(short, long)]
         version: String,
 
+        #[clap(short, long)]
+        epoch: Option<String>,
+
         #[clap(short, long)]
         force: bool,
 
@@ -129,6 +132,7 @@ fn main() -> Result<()> {
         }
         Command::WriteCaboose {
             version,
+            epoch,
             force,
             no_defaults,
         } => {
@@ -143,9 +147,9 @@ fn main() -> Result<()> {
                 }
             }
             if no_defaults {
-                archive.write_version_to_caboose(&version)?;
+                archive.write_version_to_caboose(&version, epoch.as_ref())?;
             } else {
-                archive.write_default_caboose(Some(&version))?;
+                archive.write_default_caboose(Some(&version), epoch.as_ref())?;
             }
             archive.overwrite()?;
         }

hubtools/src/lib.rs

@@ -471,6 +471,9 @@ pub enum Error {
 
     #[error("packing error: {0}")]
     PackingError(String),
+
+    #[error("invalid epoch value: {0}")]
+    InvalidEpoch(String),
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -618,13 +621,25 @@ impl RawHubrisArchive {
     pub fn write_version_to_caboose(
         &mut self,
         version: &str,
+        epoch: Option<&String>,
     ) -> Result<(), Error> {
         // Manually build the TLV-C data for the caboose
-        let data = tlvc_text::Piece::Chunk(
-            tlvc_text::Tag::new(caboose::tags::VERS),
-            vec![tlvc_text::Piece::String(version.to_owned())],
-        );
-        let out = tlvc_text::pack(&[data]);
+        let mut chunks = vec![
+            tlvc_text::Piece::Chunk(
+                tlvc_text::Tag::new(caboose::tags::VERS),
+                vec![tlvc_text::Piece::String(version.to_owned())],
+            ),
+        ];
+        if let Some(param) = epoch {
+            let epoc = param.parse::<u32>().map_err(|_| Error::InvalidEpoch(param.to_string()))?;
+            let caboose_epoc = format!("{:010}", epoc).to_owned();
+            let data = tlvc_text::Piece::Chunk(
+                tlvc_text::Tag::new(caboose::tags::EPOC),
+                vec![tlvc_text::Piece::String(caboose_epoc)],
+            );
+            chunks.push(data);
+        }
+        let out = tlvc_text::pack(&chunks);
         self.write_caboose(&out)?;
         Ok(())
     }
@@ -642,6 +657,7 @@ impl RawHubrisArchive {
     fn generate_default_caboose(
         &mut self,
         version: Option<&String>,
+        epoch: Option<&String>,
     ) -> Result<Vec<tlvc_text::Piece>, Error> {
         let manifest = self.extract_file("app.toml")?;
         let git = self.extract_file("git-rev")?;
@@ -667,19 +683,21 @@ impl RawHubrisArchive {
             .as_str()
             .ok_or(Error::BadTomlType)?
             .to_owned();
-        let epoch = if let Some(epoch) =
-            manifest.as_table().ok_or(Error::BadTomlType)?.get("epoch")
-        {
-            epoch.as_integer().ok_or(Error::BadTomlType)?
+        // Hubris has an epoch in the app.toml but Bootleby does not.
+        // CLI arg overrides app.toml, value will default to zero.
+        let epoc: u32 = if let Some(param) = epoch {
+            param.parse::<u32>().map_err(|_| Error::InvalidEpoch(param.to_string()))?
+        } else if let Some(param) = manifest.as_table().ok_or(Error::BadTomlType)?.get("epoch") {
+            let toml_int = param.as_integer().ok_or(Error::BadTomlType)?;
+            u32::try_from(toml_int).map_err(|_| Error::InvalidEpoch(format!("epoch from toml = {}", toml_int)))?
         } else {
             // Default is zero if missing from app.toml
-            0i64
+            0u32
         };
         // EPOC in the caboose is a u32, zero-padded 10-digit ascii number.
         // Missing EPOC or all-zeros is equivalent to EPOC zero.
         // Anything else represents some future scheme or a typo in toml file.
-        let epoch = u32::try_from(epoch).map_err(|_| Error::BadTomlType)?;
-        let epoch = format!("{:010}", epoch as u32).to_owned();
+        let caboose_epoc = format!("{:010}", epoc).to_owned();
 
         // If this Hubris archive used our TOML inheritance system, then the
         // name could be overridden in the `patches.toml` file.
@@ -713,7 +731,7 @@ impl RawHubrisArchive {
             ),
             tlvc_text::Piece::Chunk(
                 tlvc_text::Tag::new(caboose::tags::EPOC),
-                vec![tlvc_text::Piece::String(epoch)],
+                vec![tlvc_text::Piece::String(caboose_epoc)],
             ),
         ];
         if let Some(v) = version {
@@ -729,8 +747,9 @@ impl RawHubrisArchive {
     pub fn write_default_caboose(
         &mut self,
         version: Option<&String>,
+        epoch: Option<&String>,
     ) -> Result<(), Error> {
-        let out = tlvc_text::pack(&self.generate_default_caboose(version)?);
+        let out = tlvc_text::pack(&self.generate_default_caboose(version, epoch)?);
         self.write_caboose(&out)
     }
 
@@ -876,6 +895,7 @@ impl RawHubrisArchive {
         root_certs: Vec<Certificate>,
         signing_certs: Vec<Certificate>,
         version: Option<&String>,
+        epoch: Option<&String>,
     ) -> Result<Vec<u8>, Error> {
         match self.is_lpc55() {
             Ok(_) => {
@@ -911,7 +931,7 @@ impl RawHubrisArchive {
                     )?;
                 }
 
-                let mut caboose = self.generate_default_caboose(version)?;
+                let mut caboose = self.generate_default_caboose(version, epoch)?;
 
                 caboose.push(tlvc_text::Piece::Chunk(
                     tlvc_text::Tag::new(caboose::tags::SIGN),
@@ -930,7 +950,7 @@ impl RawHubrisArchive {
                 Ok(stamped)
             }
             Err(_) => {
-                self.write_default_caboose(version)?;
+                self.write_default_caboose(version, epoch)?;
                 // Not an LPC55 image, just return the image back for now
                 self.image.to_binary()
             }