server: wip recv

[hippotat.git] / src / slip.rs

diff --git a/src/slip.rs b/src/slip.rs
index 67b4d40b17fc7d3da40bfe7d1d94c284b95d2b02..955c36f624dddd027e0798fe2e7c04947af1d480 100644 (file)
--- a/src/slip.rs
+++ b/src/slip.rs
@@ -13,7 +13,7 @@ pub enum PacketError {
   #[error("Invalid SLIP escape sequence")] SLIP,
   #[error("unexpected src addr {0:?}")]    Src(IpAddr),
   #[error("unexpected dst addr {0:?}")]    Dst(IpAddr),
-  #[error("bad, IPv{vsn}, len={len}")]     Bad { len: usize, vsn: u8 },
+  #[error("truncated, IPv{vsn}, len={len}")] Truncated { len: usize, vsn: u8 },
 }
 
 pub trait SlipMime { const CONV_TO: Option<bool>; }
@@ -24,48 +24,61 @@ 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; }
 
-pub fn checkn<AC, EH, OUT, M: SlipMime+Copy>(
+#[derive(Debug)]
+#[derive(Error)]
+#[error("only bad IP datagrams")]
+pub struct ErrorOnlyBad;
+
+#[throws(ErrorOnlyBad)]
+pub fn checkn<AC, EH, OUT, 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,
+) where AC: Fn(&[u8]) -> Result<ACR, PacketError> + Copy,
+        OUT: FnMut((Box<[u8]>, ACR)) -> Result<(), PacketError>,
         EH: FnMut(PacketError),
 {
   //  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(e) => error_handler(e),
-      Ok(packet) => out.extend(iter::once(packet)),
+    match (||{
+      let checked = check1(mime, mtu, packet, addr_chk);
+      if matches!(checked, Err(PacketError::Empty)) { return Ok::<_,PE>(()) }
+      out(checked?)?;
+      ok = true;
+      Ok::<_,PE>(())
+    })() {
+      Ok(()) => { },
+      Err(e) => { err=true; error_handler(e); },
     }
   }
 //  eprintln!(" after: {:?}", DumpHex(data));
+  if err && !ok { throw!(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 {
@@ -86,16 +99,24 @@ 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 ..];
     }
   }
   let _ = wheader.write(walk);
+  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 });
+  }
 
-  packet
+  let acr = addr_chk(&header)?;
+
+  (packet, acr)
 }
 
 pub type Frame = Vec<u8>;
@@ -156,7 +177,7 @@ pub fn ip_packet_addr<const DST: bool>(packet: &[u8]) -> IpAddr {
       Ipv6Addr::from(*<&[u8;16]>::try_from(slice).unwrap()).into()
     },
 
-    _ => throw!(PE::Bad{ vsn, len: packet.len() }),
+    _ => throw!(PE::Truncated{ vsn, len: packet.len() }),
   }
 }
 
@@ -166,6 +187,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()
+      )?,
+    }
   }
 }