server: change type of checkn

[hippotat.git] / src / slip.rs

diff --git a/src/slip.rs b/src/slip.rs
index 9baf87546b481a4649ff1b6d93fcfe684213bdc6..3903636602f0166b32ba05d7ece8977963f757fd 100644 (file)
--- a/src/slip.rs
+++ b/src/slip.rs
@@ -24,26 +24,34 @@ 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>(
   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<(), PacketError> + Copy,
+        OUT: FnMut(Box<[u8]>),
         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)),
+      Err(PacketError::Empty) => { }
+      Err(e) => { err=true; error_handler(e); },
+      Ok(packet) => { ok=true; out(packet); },
     }
   }
 //  eprintln!(" after: {:?}", DumpHex(data));
+  if err && !ok { throw!(ErrorOnlyBad) }
 }
 
 #[throws(PacketError)]
@@ -58,14 +66,12 @@ where AC: Fn(&[u8]) -> Result<(), 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,6 +92,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 ..];
@@ -95,6 +102,11 @@ where AC: Fn(&[u8]) -> Result<(), PacketError>,
   let wheader_len = wheader.len();
   let header = &header[0.. header.len() - wheader_len];
 
+  let decoded_len = packet.len() - escapes;
+  if decoded_len > mtu.sat() {
+    throw!(PacketError::MTU { len: decoded_len, mtu });
+  }
+
   addr_chk(&header)?;
 
   packet
@@ -168,6 +180,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()
+      )?,
+    }
   }
 }