make route_packet async

[hippotat.git] / src / slip.rs

diff --git a/src/slip.rs b/src/slip.rs
index 397aa548aeda73cd0672cc5bb0fe1b271945ca39..f5980cc3b72f5d559f8170fc7bd50cce503ea57a 100644 (file)
--- a/src/slip.rs
+++ b/src/slip.rs
@@ -24,56 +24,64 @@ impl SlipMime for Slip2Mime { const CONV_TO: Option<bool> = Some(true); }
 impl SlipMime for Mime2Slip { const CONV_TO: Option<bool> = Some(false); }
 impl SlipMime for SlipNoConv { const CONV_TO: Option<bool> = None; }
 
-#[derive(Debug)]
-pub struct ErrorOnlyBad;
-
-#[throws(ErrorOnlyBad)]
-pub fn checkn<AC, EH, OUT, M: SlipMime+Copy>(
+#[derive(Debug,Error)]
+pub enum SlipFramesError<E> where E: std::error::Error + 'static {
+  #[error("only bad IP datagrams")] ErrorOnlyBad,
+  #[error("{0}")] Other(#[from] E),
+}
+  
+#[throws(SlipFramesError<EHE>)]
+pub async fn checkn<AC, EH, EHE, OUT, FOUT, ACR, M: SlipMime+Copy>(
   mime: M,
   mtu: u32,
   data: &[u8],
-  out: &mut OUT,
   addr_chk: AC,
+  mut out: OUT,
   mut error_handler: EH
-) where OUT: Extend<Box<[u8]>>,
-        AC: Fn(&[u8]) -> Result<(), PacketError> + Copy,
-        EH: FnMut(PacketError),
+) where AC: Fn(&[u8]) -> Result<ACR, PacketError> + Copy + Send,
+        OUT: FnMut((Box<[u8]>, ACR)) -> FOUT + Send,
+        FOUT: Future<Output=Result<(), PacketError>> + Send,
+        EH: FnMut(PacketError) -> Result<(), SlipFramesError<EHE>> + Send,
+        EHE: std::error::Error + Send + 'static,
 {
   //  eprintln!("before: {:?}", DumpHex(data));
   if data.is_empty() { return }
   let mut ok = false;
   let mut err = false;
   for packet in data.split(|&c| c == SLIP_END) {
-    match check1(mime, mtu, packet, addr_chk) {
-      Err(PacketError::Empty) => { }
-      Err(e) => { err=true; error_handler(e); },
-      Ok(packet) => { ok=true; out.extend(iter::once(packet)); },
+    match async {
+      let checked = check1(mime, mtu, packet, addr_chk);
+      if matches!(checked, Err(PacketError::Empty)) { return Ok::<_,PE>(()) }
+      out(checked?).await?;
+      ok = true;
+      Ok::<_,PE>(())
+    }.await {
+      Ok(()) => { },
+      Err(e) => { err=true; error_handler(e)?; },
     }
   }
 //  eprintln!(" after: {:?}", DumpHex(data));
-  if err && !ok { throw!(ErrorOnlyBad) }
+  if err && !ok { throw!(SlipFramesError::ErrorOnlyBad) }
 }
 
 #[throws(PacketError)]
-pub fn check1<AC, M: SlipMime>(
+pub fn check1<AC, M: SlipMime, ACR>(
   _mime: M,
   mtu: u32,
   packet: &[u8],
   addr_chk: AC,
-) -> Box<[u8]>
-where AC: Fn(&[u8]) -> Result<(), PacketError>,
+) -> (Box<[u8]>, ACR)
+where AC: Fn(&[u8]) -> Result<ACR, PacketError>,
 {
   if packet.len() == 0 {
     throw!(PacketError::Empty)
   }
-  if packet.len() > mtu.sat() {
-    throw!(PacketError::MTU { len: packet.len(), mtu });
-  }
 
   let mut packet: Box<[u8]> = packet.to_owned().into();
   let mut walk: &mut [u8] = &mut packet;
   let mut header = [0u8; HEADER_FOR_ADDR];
   let mut wheader = &mut header[..];
+  let mut escapes = 0;
 
   while let Some((i, was_mime)) = walk.iter().enumerate().find_map(
     |(i,&c)| match c {
@@ -94,6 +102,7 @@ where AC: Fn(&[u8]) -> Result<(), PacketError>,
       };
       let _ = wheader.write(&[c]);
       walk = &mut walk[i+2 ..];
+      escapes += 1;
     } else {
       let _ = wheader.write(&[SLIP_MIME_ESC]);
       walk = &mut walk[i+1 ..];
@@ -103,9 +112,14 @@ where AC: Fn(&[u8]) -> Result<(), PacketError>,
   let wheader_len = wheader.len();
   let header = &header[0.. header.len() - wheader_len];
 
-  addr_chk(&header)?;
+  let decoded_len = packet.len() - escapes;
+  if decoded_len > mtu.sat() {
+    throw!(PacketError::MTU { len: decoded_len, mtu });
+  }
+
+  let acr = addr_chk(&header)?;
 
-  packet
+  (packet, acr)
 }
 
 pub type Frame = Vec<u8>;
@@ -176,6 +190,12 @@ impl Debug for DumpHex<'_> {
   #[throws(fmt::Error)]
   fn fmt(&self, f: &mut fmt::Formatter) {
     for v in self.0 { write!(f, "{:02x}", v)?; }
+    match str::from_utf8(self.0) {
+      Ok(s) => write!(f, "={:?}", s)?,
+      Err(x) => write!(f, "={:?}..",
+                       str::from_utf8(&self.0[0..x.valid_up_to()]).unwrap()
+      )?,
+    }
   }
 }