Restructure mctp_estack::Router, add timeouts, add round trip tests

.github/workflows/ci.yml

@@ -14,9 +14,15 @@ jobs:
   ci:
     strategy:
       matrix:
-        # 1.82 is the earliest version that will build. Notice if it breaks,
-        # though MSRV may be bumped as needed.
-        rust_version: [stable, 1.82, nightly]
+        include:
+          - rust_version: stable
+
+          # 1.85 is the earliest version that will build. Notice if it breaks,
+          # though MSRV may be bumped as needed.
+          - rust_version: 1.85
+            no_clippy: yes
+
+          - rust_version: nightly
 
     runs-on: ubuntu-latest
 
@@ -41,4 +47,7 @@ jobs:
           rustup override set ${{ matrix.rust_version }}
 
       - name: Build and test ${{ matrix.rust_version }}
+        env:
+          # Older clippy has some unwanted lints, ignore them.
+          NO_CLIPPY: ${{ matrix.no_clippy }}
         run: ./ci/runtests.sh

ci/runtests.sh

@@ -15,7 +15,9 @@ cargo fmt -- --check
 
 # Check everything first
 cargo check --all-targets --locked
-cargo clippy --all-targets
+if [ -z "NO_CLIPPY" ]; then
+    cargo clippy --all-targets
+fi
 
 # stable, std
 cargo build --release

mctp-estack/Cargo.toml

@@ -6,7 +6,7 @@ edition.workspace = true
 license.workspace = true
 repository.workspace = true
 categories = ["network-programming", "embedded", "hardware-support", "no-std"]
-rust-version = "1.82"
+rust-version = "1.85"
 
 [dependencies]
 crc = { workspace = true }
@@ -20,11 +20,14 @@ smbus-pec = { version = "1.0", features = ["lookup-table"] }
 uuid = { workspace = true }
 
 [dev-dependencies]
+critical-section = { version = "1.2.0", features = ["std"] }
 embedded-io-adapters = { workspace = true }
 env_logger =  { workspace = true }
+futures = "0.3"
 proptest = { workspace = true }
 smol = { workspace = true }
 
+
 [features]
 default = ["log"]
 std = ["mctp/std"]

mctp-estack/src/fragment.rs

@@ -10,7 +10,7 @@ use crate::fmt::{debug, error, info, trace, warn};
 
 use mctp::{Eid, Error, MsgIC, MsgType, Result, Tag};
 
-use crate::{AppCookie, MctpHeader, MAX_MTU};
+use crate::{AppCookie, MctpHeader};
 
 /// Fragments a MCTP message.
 ///
@@ -44,15 +44,10 @@ impl Fragmenter {
         }
         debug_assert!(typ.0 & 0x80 == 0, "IC bit's set in typ");
         debug_assert!(initial_seq & !mctp::MCTP_SEQ_MASK == 0);
-        if mtu < MctpHeader::LEN + 1 {
+        if mtu < mctp::MCTP_MIN_MTU {
             debug!("mtu too small");
             return Err(Error::BadArgument);
         }
-        if mtu > MAX_MTU {
-            debug!("mtu too large");
-            return Err(Error::BadArgument);
-        }
-        // TODO other validity checks
 
         let header = MctpHeader {
             dest,
@@ -93,6 +88,8 @@ impl Fragmenter {
     ///
     /// The same input message `payload` should be passed to each `fragment()` call.
     /// In `SendOutput::Packet(buf)`, `out` is borrowed as the returned fragment, filled with packet contents.
+    ///
+    /// `out` must be at least as large as the specified `mtu`.
     pub fn fragment<'f>(
         &mut self,
         payload: &[u8],
@@ -102,17 +99,16 @@ impl Fragmenter {
             return SendOutput::success(self);
         }
 
-        // first fragment needs type byte
-        let min = MctpHeader::LEN + self.header.som as usize;
-
-        if out.len() < min {
-            return SendOutput::failure(Error::NoSpace, self);
+        // Require at least MTU buffer size, to ensure that all non-end
+        // fragments are the same size per the spec.
+        if out.len() < self.mtu {
+            debug!("small out buffer");
+            return SendOutput::failure(Error::BadArgument, self);
         }
 
         // Reserve header space, the remaining buffer keeps being
         // updated in `rest`
         let max_total = out.len().min(self.mtu);
-        // let out = &mut out[..max_total];
         let (h, mut rest) = out[..max_total].split_at_mut(MctpHeader::LEN);
 
         // Append type byte
@@ -123,6 +119,7 @@ impl Fragmenter {
 
         if payload.len() < self.payload_used {
             // Caller is passing varying payload buffers
+            debug!("varying payload");
             return SendOutput::failure(Error::BadArgument, self);
         }