feat: reshuffle apps + generalizaiton

Signed-off-by: addrian-77 <lunguadrian30@gmail.com>

Author: addrian-77

tbf-parser/src/parse.rs

@@ -203,9 +203,10 @@ pub fn parse_tbf_header(
                         }
                         types::TbfHeaderTypes::TbfHeaderWriteableFlashRegions => {
                             // Length must be a multiple of the size of a region definition.
-                            if tlv_header.length as usize
-                                % mem::size_of::<types::TbfHeaderV2WriteableFlashRegion>()
-                                == 0
+                            if (tlv_header.length as usize)
+                                .is_multiple_of(mem::size_of::<
+                                    types::TbfHeaderV2WriteableFlashRegion,
+                                >())
                             {
                                 // Calculate how many writeable flash regions
                                 // there are specified in this header.

tbf-parser/src/types.rs

@@ -866,6 +866,7 @@ pub struct TbfHeaderV2 {
 // Clippy suggests we box TbfHeaderV2. We can't really do that, since
 // we are runnning under no_std, and I don't think it's that big of a issue.
 #[allow(clippy::large_enum_variant)]
+#[derive(Clone)]
 pub enum TbfHeader {
     TbfHeaderV2(TbfHeaderV2),
     Padding(TbfHeaderV2Base),

tockloader-lib/Cargo.toml

@@ -21,3 +21,4 @@ serde = { version = "1.0.210", features = ["derive"] }
 thiserror = "1.0.63"
 async-trait = "0.1.88"
 log = "0.4.27"
+itertools = "0.14.0"

tockloader-lib/src/attributes/app_attributes.rs

@@ -11,22 +11,41 @@ use tokio_serial::SerialStream;
 
 use crate::bootloader_serial::{issue_command, Command, Response};
 use crate::errors::{TockError, TockloaderError};
+use crate::IOCommands;
 
 /// This structure contains all relevant information about a tock application.
 ///
 /// All data is stored either within [TbfHeader]s, or [TbfFooter]s.
 ///
 /// See also <https://book.tockos.org/doc/tock_binary_format>
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct AppAttributes {
+    pub address: u64,
+    pub size: u32,
+    pub index: u8,
     pub tbf_header: TbfHeader,
     pub tbf_footers: Vec<TbfFooter>,
+    pub installed: bool,
+    pub is_padding: bool,
+}
+
+impl std::fmt::Display for AppAttributes {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}. {} - start: {:#x}, size: {}",
+            self.index,
+            self.tbf_header.get_package_name().unwrap_or(""),
+            self.address,
+            self.size
+        )
+    }
 }
 
 /// This structure represents a footer of a Tock application. Currently, footers
 /// only contain credentials, which are used to verify the integrity of the
 /// application.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct TbfFooter {
     pub credentials: TbfFooterV2Credentials,
     pub size: u32,
@@ -41,10 +60,22 @@ impl TbfFooter {
 // TODO(george-cosma): Could take advantages of the trait rework
 
 impl AppAttributes {
-    pub(crate) fn new(header_data: TbfHeader, footers_data: Vec<TbfFooter>) -> AppAttributes {
+    pub(crate) fn new(
+        address: u64,
+        size: u32,
+        index: u8,
+        header_data: TbfHeader,
+        footers_data: Vec<TbfFooter>,
+        installed: bool,
+    ) -> AppAttributes {
         AppAttributes {
+            address,
+            size,
+            index,
             tbf_header: header_data,
             tbf_footers: footers_data,
+            installed,
+            is_padding: false,
         }
     }
 
@@ -117,13 +148,10 @@ impl AppAttributes {
             // crash the process.
             let binary_end_offset = header.get_binary_end();
 
-            match &header {
-                TbfHeader::TbfHeaderV2(_hd) => {}
-                _ => {
-                    appaddr += total_size as u64;
-                    continue;
-                }
-            };
+            if !header.is_app() {
+                appaddr += total_size as u64;
+                continue;
+            }
 
             let mut footers: Vec<TbfFooter> = vec![];
             let total_footers_size = total_size - binary_end_offset;
@@ -137,9 +165,9 @@ impl AppAttributes {
                 // binary_end_offset`) , even if we overread.
                 let mut appfooter =
                     vec![0u8; (total_footers_size - (footer_offset - binary_end_offset)) as usize];
-
+                // log::info!("footer init {:?}", appfooter);
                 board_core.read(appaddr + footer_offset as u64, &mut appfooter)?;
-
+                // log::info!("footer read {:?}", appfooter);
                 let footer_info =
                     parse_tbf_footer(&appfooter).map_err(TockError::InvalidAppTbfHeader)?;
 
@@ -150,9 +178,10 @@ impl AppAttributes {
                 footer_offset += footer_info.1 + 4;
             }
 
-            let details: AppAttributes = AppAttributes::new(header, footers);
+            let details: AppAttributes =
+                AppAttributes::new(appaddr, total_size, apps_counter, header, footers, true);
 
-            apps_details.insert(apps_counter, details);
+            apps_details.insert(apps_counter.into(), details);
             apps_counter += 1;
             appaddr += total_size as u64;
         }
@@ -240,15 +269,13 @@ impl AppAttributes {
             log::debug!("App #{apps_counter}: Header data: {header_data:?}");
             let header = parse_tbf_header(&header_data, tbf_version)
                 .map_err(TockError::InvalidAppTbfHeader)?;
+
             let binary_end_offset = header.get_binary_end();
 
-            match &header {
-                TbfHeader::TbfHeaderV2(_hd) => {}
-                _ => {
-                    appaddr += total_size as u64;
-                    continue;
-                }
-            };
+            if !header.is_app() {
+                appaddr += total_size as u64;
+                continue;
+            }
 
             let mut footers: Vec<TbfFooter> = vec![];
             let total_footers_size = total_size - binary_end_offset;
@@ -289,12 +316,17 @@ impl AppAttributes {
                 footer_offset += footer_info.1 + 4;
             }
 
-            let details: AppAttributes = AppAttributes::new(header, footers);
+            let details: AppAttributes =
+                AppAttributes::new(appaddr, total_size, apps_counter, header, footers, true);
 
-            apps_details.insert(apps_counter, details);
+            apps_details.insert(apps_counter.into(), details);
             apps_counter += 1;
             appaddr += total_size as u64;
         }
         Ok(apps_details)
     }
+
+    pub async fn read(&mut self, conn: &mut dyn IOCommands) -> Result<Vec<u8>, TockloaderError> {
+        conn.read(self.address, self.size as usize).await
+    }
 }

tockloader-lib/src/bootloader_serial.rs

@@ -5,7 +5,7 @@
 // The "X" commands are for external flash
 
 use crate::errors::{self, InternalError, TockError};
-use bytes::BytesMut;
+use bytes::{BufMut, BytesMut};
 use errors::TockloaderError;
 use std::time::Duration;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
@@ -17,7 +17,7 @@ pub const SYNC_MESSAGE: [u8; 3] = [0x00, 0xFC, 0x05];
 // "This was chosen as it is infrequent in .bin files" - immesys
 pub const ESCAPE_CHAR: u8 = 0xFC;
 
-pub const DEFAULT_TIMEOUT: Duration = Duration::from_millis(500);
+pub const DEFAULT_TIMEOUT: Duration = Duration::from_millis(5000);
 
 #[allow(dead_code)]
 pub enum Command {
@@ -217,7 +217,7 @@ pub async fn issue_command(
     }
 
     if response_len != 0 {
-        let input = read_bytes(port, response_len, DEFAULT_TIMEOUT).await?;
+        let mut input = read_bytes(port, response_len, DEFAULT_TIMEOUT).await?;
         let mut result = Vec::with_capacity(input.len());
 
         // De-escape and add array of read in the bytes
@@ -227,6 +227,7 @@ pub async fn issue_command(
         while i < input.len() {
             if i + 1 < input.len() && input[i] == ESCAPE_CHAR && input[i + 1] == ESCAPE_CHAR {
                 // Found consecutive ESCAPE_CHAR bytes, add only one
+                input.put(read_bytes(port, 1, DEFAULT_TIMEOUT).await?);
                 result.push(ESCAPE_CHAR);
                 i += 2; // Skip both bytes
             } else {

tockloader-lib/src/command_impl/erase_apps.rs

@@ -0,0 +1,13 @@
+use async_trait::async_trait;
+
+use crate::board_settings::BoardSettings;
+use crate::connection::TockloaderConnection;
+use crate::errors::TockloaderError;
+use crate::{CommandEraseApps, IOCommands};
+
+#[async_trait]
+impl CommandEraseApps for TockloaderConnection {
+    async fn erase_apps(&mut self, settings: &BoardSettings) -> Result<(), TockloaderError> {
+        self.write(settings.start_address, [0x0].to_vec()).await
+    }
+}

tockloader-lib/src/command_impl/generalized.rs

@@ -1,59 +1,42 @@
 use async_trait::async_trait;
 
 use crate::attributes::app_attributes::AppAttributes;
-use crate::attributes::general_attributes::GeneralAttributes;
+use crate::attributes::system_attributes::SystemAttributes;
 use crate::board_settings::BoardSettings;
 use crate::connection::TockloaderConnection;
 use crate::errors::TockloaderError;
-use crate::tabs::tab::Tab;
-use crate::{CommandEraseApps, CommandInfo, CommandInstall, CommandList};
+use crate::IOCommands;
 
 #[async_trait]
-impl CommandList for TockloaderConnection {
-    async fn list(
-        &mut self,
-        settings: &BoardSettings,
-    ) -> Result<Vec<AppAttributes>, TockloaderError> {
+impl IOCommands for TockloaderConnection {
+    async fn read(&mut self, address: u64, size: usize) -> Result<Vec<u8>, TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.list(settings).await,
-            TockloaderConnection::Serial(conn) => conn.list(settings).await,
+            TockloaderConnection::ProbeRS(conn) => conn.read(address, size).await,
+            TockloaderConnection::Serial(conn) => conn.read(address, size).await,
         }
     }
-}
 
-#[async_trait]
-impl CommandInfo for TockloaderConnection {
-    async fn info(
-        &mut self,
-        settings: &BoardSettings,
-    ) -> Result<GeneralAttributes, TockloaderError> {
+    async fn write(&mut self, address: u64, pkt: Vec<u8>) -> Result<(), TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.info(settings).await,
-            TockloaderConnection::Serial(conn) => conn.info(settings).await,
+            TockloaderConnection::ProbeRS(conn) => conn.write(address, pkt).await,
+            TockloaderConnection::Serial(conn) => conn.write(address, pkt).await,
         }
     }
-}
 
-#[async_trait]
-impl CommandInstall for TockloaderConnection {
-    async fn install_app(
+    async fn list_apps(
         &mut self,
         settings: &BoardSettings,
-        tab_file: Tab,
-    ) -> Result<(), TockloaderError> {
+    ) -> Result<Vec<AppAttributes>, TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.install_app(settings, tab_file).await,
-            TockloaderConnection::Serial(conn) => conn.install_app(settings, tab_file).await,
+            TockloaderConnection::ProbeRS(conn) => conn.list_apps(settings).await,
+            TockloaderConnection::Serial(conn) => conn.list_apps(settings).await,
         }
     }
-}
 
-#[async_trait]
-impl CommandEraseApps for TockloaderConnection {
-    async fn erase_apps(&mut self, settings: &BoardSettings) -> Result<(), TockloaderError> {
+    async fn read_system_attributes(&mut self) -> Result<SystemAttributes, TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.erase_apps(settings).await,
-            TockloaderConnection::Serial(conn) => conn.erase_apps(settings).await,
+            TockloaderConnection::ProbeRS(conn) => conn.read_system_attributes().await,
+            TockloaderConnection::Serial(conn) => conn.read_system_attributes().await,
         }
     }
 }

tockloader-lib/src/command_impl/info.rs

@@ -0,0 +1,19 @@
+use async_trait::async_trait;
+
+use crate::attributes::general_attributes::GeneralAttributes;
+use crate::board_settings::BoardSettings;
+use crate::connection::TockloaderConnection;
+use crate::errors::TockloaderError;
+use crate::{CommandInfo, IOCommands};
+
+#[async_trait]
+impl CommandInfo for TockloaderConnection {
+    async fn info(
+        &mut self,
+        settings: &BoardSettings,
+    ) -> Result<GeneralAttributes, TockloaderError> {
+        let installed_apps = self.list_apps(settings).await.unwrap();
+        let system_atributes = self.read_system_attributes().await.unwrap();
+        Ok(GeneralAttributes::new(system_atributes, installed_apps))
+    }
+}

tockloader-lib/src/command_impl/install.rs

@@ -0,0 +1,53 @@
+use async_trait::async_trait;
+
+use crate::attributes::app_attributes::AppAttributes;
+use crate::board_settings::BoardSettings;
+use crate::command_impl::reshuffle_apps::{create_pkt, reconstruct_app, reshuffle_apps};
+use crate::connection::TockloaderConnection;
+use crate::errors::TockloaderError;
+use crate::tabs::tab::Tab;
+use crate::{CommandInstall, CommandList, IOCommands};
+
+#[async_trait]
+impl CommandInstall for TockloaderConnection {
+    async fn install_app(
+        &mut self,
+        settings: &BoardSettings,
+        tab: Tab,
+    ) -> Result<(), TockloaderError> {
+        // get the already installed apps
+        let mut installed_apps: Vec<AppAttributes> = self.list(settings).await.unwrap();
+
+        // reconstruct the new app
+        if let Some(mut app) = reconstruct_app(Some(&tab), settings) {
+            app.index = installed_apps.len() as u8;
+            installed_apps.push(app.clone());
+        }
+
+        // obtain the binaries in a vector
+        let mut app_binaries: Vec<Vec<u8>> = Vec::new();
+
+        for app in installed_apps.iter() {
+            match app.installed {
+                true => {
+                    app_binaries.push(app.clone().read(self).await.unwrap());
+                }
+                false => {
+                    // TODO(adi): change this when TBF Filtering will get merged
+                    app_binaries.push(
+                        tab.extract_binary(settings.arch.as_ref().unwrap().as_str())
+                            .unwrap(),
+                    );
+                }
+            }
+        }
+        let configuration = reshuffle_apps(settings, installed_apps).unwrap();
+
+        // create the pkt, this contains all the binaries in a vec
+        let pkt = create_pkt(configuration, app_binaries);
+
+        // write the pkt
+        let _ = self.write(settings.start_address, pkt).await;
+        Ok(())
+    }
+}

tockloader-lib/src/command_impl/list.rs

@@ -0,0 +1,17 @@
+use async_trait::async_trait;
+
+use crate::attributes::app_attributes::AppAttributes;
+use crate::board_settings::BoardSettings;
+use crate::connection::TockloaderConnection;
+use crate::errors::TockloaderError;
+use crate::{CommandList, IOCommands};
+
+#[async_trait]
+impl CommandList for TockloaderConnection {
+    async fn list(
+        &mut self,
+        settings: &BoardSettings,
+    ) -> Result<Vec<AppAttributes>, TockloaderError> {
+        self.list_apps(settings).await
+    }
+}