Make App trait generic over response size

The buffer size is an implementation detail of the dispatch
implementation.  Applications should not depend on it.  This patch makes
the App trait generic over the response size and changes the request
argument to use a slice instead of a reference to a heapless::Vec.

If applications need a minimum response size, they can still use a
const assertion to enforce it.

Author: robin-nitrokey

app/src/lib.rs

@@ -1,17 +1,16 @@
 #![no_std]
 
+use heapless::Vec;
 use trussed_core::InterruptFlag;
 
 mod command;
 
 pub use command::{Command, VendorCommand};
 
-pub type Message = heapless::Vec<u8, 7609>;
-
 /// trait interface for a CTAPHID application.
 /// The application chooses which commands to register to, and will be called upon
 /// when the commands are received in the CTAPHID layer.  Only one application can be registered to a particular command.
-pub trait App<'interrupt> {
+pub trait App<'interrupt, const N: usize> {
     /// Get access to the app interrupter
     fn interrupt(&self) -> Option<&'interrupt InterruptFlag> {
         None
@@ -27,8 +26,8 @@ pub trait App<'interrupt> {
     fn call(
         &mut self,
         command: Command,
-        request: &Message,
-        response: &mut Message,
+        request: &[u8],
+        response: &mut Vec<u8, N>,
     ) -> Result<(), Error>;
 }
 

dispatch/CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Optimize stack usage of `Dispatch::poll`
 - Replace `trussed` dependency with `trussed-core`.
 - Move the `app` and `command` modules into a separate crate, `ctaphid-app`, and re-export it.
+- Make `App` trait generic over the response size.
 
 ## [0.1.1] - 2022-08-22
 - adjust to `interchange` API change

dispatch/src/dispatch.rs

@@ -1,6 +1,6 @@
 use core::sync::atomic::Ordering;
 
-use crate::types::{InterchangeResponse, Message, Responder};
+use crate::types::{InterchangeResponse, Message, Responder, MESSAGE_SIZE};
 
 use ctaphid_app::{App, Command, Error};
 use ref_swap::OptionRefSwap;
@@ -33,8 +33,8 @@ impl<'pipe, 'interrupt> Dispatch<'pipe, 'interrupt> {
 
     fn find_app<'a, 'b>(
         command: Command,
-        apps: &'a mut [&'b mut dyn App<'interrupt>],
-    ) -> Option<&'a mut &'b mut dyn App<'interrupt>> {
+        apps: &'a mut [&'b mut dyn App<'interrupt, MESSAGE_SIZE>],
+    ) -> Option<&'a mut &'b mut dyn App<'interrupt, MESSAGE_SIZE>> {
         apps.iter_mut()
             .find(|app| app.commands().contains(&command))
     }
@@ -73,7 +73,12 @@ impl<'pipe, 'interrupt> Dispatch<'pipe, 'interrupt> {
     }
 
     #[inline(never)]
-    fn call_app(&mut self, app: &mut dyn App<'interrupt>, command: Command, request: &Message) {
+    fn call_app(
+        &mut self,
+        app: &mut dyn App<'interrupt, MESSAGE_SIZE>,
+        command: Command,
+        request: &Message,
+    ) {
         let response_buffer = self
             .responder
             .response_mut()
@@ -104,7 +109,7 @@ impl<'pipe, 'interrupt> Dispatch<'pipe, 'interrupt> {
     }
 
     #[inline(never)]
-    pub fn poll(&mut self, apps: &mut [&mut dyn App<'interrupt>]) -> bool {
+    pub fn poll(&mut self, apps: &mut [&mut dyn App<'interrupt, MESSAGE_SIZE>]) -> bool {
         // We could call take_request directly, but for some reason this doubles stack usage.
         let mut message_buffer = Message::new();
         if let Ok((command, message)) = self.responder.request() {

dispatch/src/lib.rs

@@ -18,7 +18,7 @@ pub mod types;
 
 pub mod app {
     pub use crate::types::AppResult;
-    pub use ctaphid_app::{App, Command, Error, Message};
+    pub use ctaphid_app::{App, Command, Error};
 }
 
 pub mod command {

dispatch/src/types.rs

@@ -1,4 +1,4 @@
-pub use ctaphid_app::{Error, Message};
+pub use ctaphid_app::Error;
 
 // // 7609 bytes is max message size for ctaphid
 // type U6144 = <heapless::consts::U4096 as core::ops::Add<heapless::consts::U2048>>::Output;
@@ -7,6 +7,10 @@ pub use ctaphid_app::{Error, Message};
 // pub type U7609 = heapless::consts::U4096;
 
 // TODO: find reasonable size
+// pub type Message = heapless::Vec<u8, 3072>;
+pub const MESSAGE_SIZE: usize = 7609;
+
+pub type Message = heapless::Vec<u8, MESSAGE_SIZE>;
 pub type AppResult = core::result::Result<(), Error>;
 pub type ShortMessage = heapless::Vec<u8, 1024>;