Support arbitrary byte sequence containers

Cargo.toml

@@ -12,7 +12,8 @@ documentation = "https://docs.rs/iso7816"
 
 [dependencies]
 delog = "0.1.2"
-heapless = "0.7"
+# use unreleased heapless for https://github.com/japaric/heapless/pull/255
+heapless = { git = "https://github.com/japaric/heapless" }
 
 [dev-dependencies]
 hex-literal = "0.3.1"

src/command.rs

@@ -1,35 +1,36 @@
 use core::convert::TryFrom;
 
-use crate::Data;
+use crate::somebytes::{Bytes, TryExtendFromSlice};
 
 pub mod class;
 pub mod instruction;
 pub use instruction::Instruction;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Command<const S: usize>
+pub struct Command<B: AsRef<[u8]>>
 {
     class: class::Class,
     instruction: Instruction,
 
     pub p1: u8,
     pub p2: u8,
 
-    /// The main reason this is modeled as Bytes and not
-    /// a fixed array is for serde purposes.
-    data: Data<S>,
+    data: Bytes<B>,
 
     le: usize,
     pub extended: bool,
 }
 
-impl<const S: usize> Command<S>
+impl<'a, B: AsRef<[u8]> + TryFrom<&'a [u8]>> Command<B>
 {
-    pub fn try_from(apdu: &[u8]) -> Result<Self, FromSliceError> {
+    pub fn try_from(apdu: &'a [u8]) -> Result<Self, FromSliceError> {
         use core::convert::TryInto;
         apdu.try_into()
     }
+}
 
+impl<B: AsRef<[u8]>> Command<B>
+{
     pub fn class(&self) -> class::Class {
         self.class
     }
@@ -38,22 +39,24 @@ impl<const S: usize> Command<S>
         self.instruction
     }
 
-    pub fn data(&self) -> &Data<S> {
+    pub fn data(&self) -> &B {
         &self.data
     }
 
-    pub fn data_mut(&mut self) -> &mut Data<S> {
+    pub fn data_mut(&mut self) -> &mut B {
         &mut self.data
     }
 
     pub fn expected(&self) -> usize {
         self.le
     }
+}
 
+impl<B: AsRef<[u8]> + TryExtendFromSlice<u8>> Command<B> {
     /// This can be use for APDU chaining to convert
     /// multiple APDU's into one.
     /// * Global Platform GPC_SPE_055 3.10
-    pub fn extend_from_command<const T: usize>(&mut self, command: &Command<T>) -> core::result::Result<(), ()> {
+    pub fn extend_from_command<T: AsRef<[u8]>>(&mut self, command: &Command<T>) -> core::result::Result<(), B::Error> {
 
         // Always take the header from the last command;
         self.class = command.class();
@@ -64,7 +67,7 @@ impl<const S: usize> Command<S>
         self.extended = true;
 
         // add the data to the end.
-        self.data.extend_from_slice(&command.data())
+        self.data.extend_from_slice(command.data().as_ref())
     }
 }
 
@@ -83,10 +86,9 @@ impl From<class::InvalidClass> for FromSliceError {
     }
 }
 
-impl<const S: usize> TryFrom<&[u8]> for Command<S>
-{
+impl<'a, B: AsRef<[u8]> + TryFrom<&'a [u8]>> TryFrom<&'a [u8]> for Command<B> {
     type Error = FromSliceError;
-    fn try_from(apdu: &[u8]) -> core::result::Result<Self, Self::Error> {
+    fn try_from(apdu: &'a [u8]) -> core::result::Result<Self, Self::Error> {
         if apdu.len() < 4 {
             return Err(FromSliceError::TooShort);
         }
@@ -106,8 +108,7 @@ impl<const S: usize> TryFrom<&[u8]> for Command<S>
             // maximum expected response length
             le: parsed.le,
             // payload
-            data: Data::from_slice(data_slice)
-                .map_err(|_| Self::Error::TooLong)?,
+            data: B::try_from(data_slice).map_err(|_| Self::Error::TooLong)?.into(),
             extended: parsed.extended,
         })
     }
@@ -249,6 +250,6 @@ mod test {
             0x06, 0x03, 0x55, 0x1d,
         ];
 
-        let command = Command::<256>::try_from(apdu).unwrap();
+        let command = Command::<heapless::Vec::<u8, 256>>::try_from(apdu).unwrap();
     }
 }

src/lib.rs

@@ -10,12 +10,12 @@ pub enum Interface {
     Contactless,
 }
 
-pub type Data<const S: usize> = heapless::Vec<u8, S>;
 pub type Result<T=()> = core::result::Result<T, Status>;
 
 pub mod aid;
 pub mod command;
 pub mod response;
+pub mod somebytes;
 
 pub use aid::{Aid, App};
 pub use command::{Command, Instruction};

src/response.rs

@@ -1,15 +1,15 @@
 mod status;
 pub use status::Status;
 
-use crate::Data;
+use crate::somebytes::Bytes;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub enum Response<const S: usize> {
-    Data(Data<S>),
+pub enum Response<B: AsRef<[u8]>> {
+    Data(Bytes<B>),
     Status(Status),
 }
 
-impl<const S: usize> Default for Response<S> {
+impl<B: AsRef<[u8]>> Default for Response<B> {
     fn default() -> Self {
         Self::Status(Default::default())
     }

src/response/status.rs

@@ -1,5 +1,4 @@
 use core::convert::TryFrom;
-use crate::Data;
 
 impl Default for Status {
     fn default() -> Self {
@@ -171,12 +170,10 @@ impl Into<[u8; 2]> for Status {
     }
 }
 
-impl<const S: usize> Into<Data<S>> for Status
-{
+impl<const S: usize> Into<heapless::Vec<u8, S>> for Status {
     #[inline]
-    fn into(self) -> Data<S> {
+    fn into(self) -> heapless::Vec<u8, S> {
         let arr: [u8; 2] = self.into();
-        Data::from_slice(&arr).unwrap()
+        heapless::Vec::from_slice(&arr).unwrap()
     }
 }
-

src/somebytes.rs

@@ -0,0 +1,79 @@
+// This could be a separate crate.
+
+use core::{cmp, fmt, ops};
+
+pub trait TryExtendFromSlice<T> {
+    type Error;
+    fn extend_from_slice(&mut self, slice: &[T]) -> Result<(), Self::Error>;
+}
+
+impl<T: Clone, const N: usize> TryExtendFromSlice<T> for heapless::Vec<T, N> {
+    type Error = ();
+    fn extend_from_slice(&mut self, slice: &[T]) -> Result<(), Self::Error> {
+        heapless::Vec::extend_from_slice(self, slice)
+    }
+}
+
+/// A wrapper type for a byte sequence.
+///
+/// This wrapper implements common traits based on the content of the byte sequence.
+#[derive(Clone)]
+pub struct Bytes<T: AsRef<[u8]>>(T);
+
+impl<T: AsRef<[u8]>> Bytes<T> {
+    pub fn into_bytes(self) -> T {
+        self.0
+    }
+}
+
+impl<T: AsRef<[u8]>> AsRef<[u8]> for Bytes<T> {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
+impl<T: AsRef<[u8]>> ops::Deref for Bytes<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T: AsRef<[u8]>> ops::DerefMut for Bytes<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T: AsRef<[u8]>> From<T> for Bytes<T> {
+    fn from(bytes: T) -> Self {
+        Self(bytes)
+    }
+}
+
+impl<T: AsRef<[u8]>> fmt::Debug for Bytes<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.as_ref().fmt(f)
+    }
+}
+
+impl<T: AsRef<[u8]>> Eq for Bytes<T> {}
+
+impl<T: AsRef<[u8]>> PartialEq for Bytes<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.as_ref().eq(other.0.as_ref())
+    }
+}
+
+impl<T: AsRef<[u8]>> Ord for Bytes<T> {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.0.as_ref().cmp(other.0.as_ref())
+    }
+}
+
+impl<T: AsRef<[u8]>> PartialOrd for Bytes<T> {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        self.0.as_ref().partial_cmp(other.0.as_ref())
+    }
+}