refactor: separated IO Commands

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

Author: addrian-77

tbf-parser/src/parse.rs

@@ -203,10 +203,9 @@ 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)
-                                .is_multiple_of(mem::size_of::<
-                                    types::TbfHeaderV2WriteableFlashRegion,
-                                >())
+                            if tlv_header.length as usize
+                                % mem::size_of::<types::TbfHeaderV2WriteableFlashRegion>()
+                                == 0
                             {
                                 // Calculate how many writeable flash regions
                                 // there are specified in this header.

tockloader-lib/src/attributes/app_attributes.rs

@@ -11,7 +11,7 @@ use tokio_serial::SerialStream;
 
 use crate::bootloader_serial::{issue_command, Command, Response};
 use crate::errors::{TockError, TockloaderError};
-use crate::IOCommands;
+use crate::IO;
 
 /// This structure contains all relevant information about a tock application.
 ///
@@ -326,7 +326,8 @@ impl AppAttributes {
         Ok(apps_details)
     }
 
-    pub async fn read(&mut self, conn: &mut dyn IOCommands) -> Result<Vec<u8>, TockloaderError> {
+    /// This function reads the full binary of a given app
+    pub async fn read_binary(&mut self, conn: &mut dyn IO) -> Result<Vec<u8>, TockloaderError> {
         conn.read(self.address, self.size as usize).await
     }
 }

tockloader-lib/src/command_impl/erase_apps.rs

@@ -3,11 +3,11 @@ use async_trait::async_trait;
 use crate::board_settings::BoardSettings;
 use crate::connection::TockloaderConnection;
 use crate::errors::TockloaderError;
-use crate::{CommandEraseApps, IOCommands};
+use crate::{CommandEraseApps, IO};
 
 #[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
+        self.write(settings.start_address, vec![0u8]).await
     }
 }

tockloader-lib/src/command_impl/generalized.rs

@@ -5,10 +5,10 @@ use crate::attributes::system_attributes::SystemAttributes;
 use crate::board_settings::BoardSettings;
 use crate::connection::TockloaderConnection;
 use crate::errors::TockloaderError;
-use crate::IOCommands;
+use crate::{IOCommands, IO};
 
 #[async_trait]
-impl IOCommands for TockloaderConnection {
+impl IO for TockloaderConnection {
     async fn read(&mut self, address: u64, size: usize) -> Result<Vec<u8>, TockloaderError> {
         match self {
             TockloaderConnection::ProbeRS(conn) => conn.read(address, size).await,
@@ -22,14 +22,17 @@ impl IOCommands for TockloaderConnection {
             TockloaderConnection::Serial(conn) => conn.write(address, pkt).await,
         }
     }
+}
 
-    async fn list_apps(
+#[async_trait]
+impl IOCommands for TockloaderConnection {
+    async fn read_installed_apps(
         &mut self,
         settings: &BoardSettings,
     ) -> Result<Vec<AppAttributes>, TockloaderError> {
         match self {
-            TockloaderConnection::ProbeRS(conn) => conn.list_apps(settings).await,
-            TockloaderConnection::Serial(conn) => conn.list_apps(settings).await,
+            TockloaderConnection::ProbeRS(conn) => conn.read_installed_apps(settings).await,
+            TockloaderConnection::Serial(conn) => conn.read_installed_apps(settings).await,
         }
     }
 

tockloader-lib/src/command_impl/info.rs

@@ -12,7 +12,7 @@ impl CommandInfo for TockloaderConnection {
         &mut self,
         settings: &BoardSettings,
     ) -> Result<GeneralAttributes, TockloaderError> {
-        let installed_apps = self.list_apps(settings).await.unwrap();
+        let installed_apps = self.read_installed_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

@@ -6,7 +6,7 @@ use crate::command_impl::reshuffle_apps::{create_pkt, reconstruct_app, reshuffle
 use crate::connection::TockloaderConnection;
 use crate::errors::TockloaderError;
 use crate::tabs::tab::Tab;
-use crate::{CommandInstall, CommandList, IOCommands};
+use crate::{CommandInstall, CommandList, IO};
 
 #[async_trait]
 impl CommandInstall for TockloaderConnection {
@@ -30,7 +30,7 @@ impl CommandInstall for TockloaderConnection {
         for app in installed_apps.iter() {
             match app.installed {
                 true => {
-                    app_binaries.push(app.clone().read(self).await.unwrap());
+                    app_binaries.push(app.clone().read_binary(self).await.unwrap());
                 }
                 false => {
                     // TODO(adi): change this when TBF Filtering will get merged

tockloader-lib/src/command_impl/list.rs

@@ -12,6 +12,6 @@ impl CommandList for TockloaderConnection {
         &mut self,
         settings: &BoardSettings,
     ) -> Result<Vec<AppAttributes>, TockloaderError> {
-        self.list_apps(settings).await
+        self.read_installed_apps(settings).await
     }
 }

tockloader-lib/src/command_impl/probers/io.rs

@@ -6,11 +6,11 @@ use crate::{
     board_settings::BoardSettings,
     connection::{Connection, ProbeRSConnection},
     errors::{InternalError, TockloaderError},
-    IOCommands,
+    IOCommands, IO,
 };
 
 #[async_trait]
-impl IOCommands for ProbeRSConnection {
+impl IO for ProbeRSConnection {
     async fn read(&mut self, address: u64, size: usize) -> Result<Vec<u8>, TockloaderError> {
         if !self.is_open() {
             return Err(InternalError::ConnectionNotOpen.into());
@@ -38,8 +38,11 @@ impl IOCommands for ProbeRSConnection {
         loader.commit(session, options)?;
         Ok(())
     }
+}
 
-    async fn list_apps(
+#[async_trait]
+impl IOCommands for ProbeRSConnection {
+    async fn read_installed_apps(
         &mut self,
         settings: &BoardSettings,
     ) -> Result<Vec<AppAttributes>, TockloaderError> {
@@ -60,7 +63,6 @@ impl IOCommands for ProbeRSConnection {
 
         let mut core = session.core(self.target_info.core)?;
 
-        // TODO(george-cosma): extract these informations without bootloader
         let system_attributes = SystemAttributes::read_system_attributes_probe(&mut core)?;
         Ok(system_attributes)
     }

tockloader-lib/src/command_impl/serial/erase_apps.rs

@@ -7,11 +7,11 @@ use crate::{
     command_impl::reshuffle_apps::PAGE_SIZE,
     connection::{Connection, SerialConnection},
     errors::{InternalError, TockloaderError},
-    IOCommands,
+    IOCommands, IO,
 };
 
 #[async_trait]
-impl IOCommands for SerialConnection {
+impl IO for SerialConnection {
     async fn read(&mut self, address: u64, size: usize) -> Result<Vec<u8>, TockloaderError> {
         let mut pkt = (address as u32).to_le_bytes().to_vec();
         let length = (size as u16).to_le_bytes().to_vec();
@@ -30,34 +30,35 @@ impl IOCommands for SerialConnection {
         )
         .await?;
 
-        // this might be very specific, but when I was testing, i got 8191 bytes instead of 8192
-        // this is because of the consecutive ESCAPE_CHAR rule inside issue_command function
-
         if appdata.len() < size {
-            panic!("Appdata was not read correctly?? We should not reach here");
+            // Sanity check that we wrote everything. This was previously failing
+            // due to not reading enough when encountering double ESCAPE_CHAR.
+            panic!("Internal Error: When reading from a Serial connection, we read less bytes than requested despite previous checks.");
         }
         Ok(appdata)
     }
 
     async fn write(&mut self, address: u64, pkt: Vec<u8>) -> Result<(), TockloaderError> {
         let stream = self.stream.as_mut().expect("Board must be open");
         let mut binary = pkt.clone();
-        while !binary.len().is_multiple_of(PAGE_SIZE as usize) {
-            binary.push(0u8);
+
+        if !binary.len().is_multiple_of(PAGE_SIZE as usize) {
+            binary.extend(vec![
+                0u8;
+                PAGE_SIZE as usize - (binary.len() % PAGE_SIZE as usize)
+            ]);
         }
 
-        let mut page_number = 0;
-        while (page_number + 1) * PAGE_SIZE <= binary.len() as u32 {
-            let mut pkt = (address as u32 + page_number * PAGE_SIZE)
+        for page_number in 0..(binary.len() / PAGE_SIZE as usize) {
+            let mut pkt = (address as u32 + page_number as u32 * PAGE_SIZE)
                 .to_le_bytes()
                 .to_vec();
             pkt.append(
                 &mut binary
-                    [(page_number * PAGE_SIZE) as usize..((page_number + 1) * PAGE_SIZE) as usize]
+                    [(page_number * PAGE_SIZE as usize)..((page_number + 1) * PAGE_SIZE as usize)]
                     .to_vec(),
             );
             let _ = issue_command(stream, Command::WritePage, pkt, true, 0, Response::OK).await?;
-            page_number += 1;
         }
 
         let pkt = (address as u32 + binary.len() as u32)
@@ -67,8 +68,11 @@ impl IOCommands for SerialConnection {
         let _ = issue_command(stream, Command::ErasePage, pkt, true, 0, Response::OK).await?;
         Ok(())
     }
+}
 
-    async fn list_apps(
+#[async_trait]
+impl IOCommands for SerialConnection {
+    async fn read_installed_apps(
         &mut self,
         settings: &BoardSettings,
     ) -> Result<Vec<AppAttributes>, TockloaderError> {