Add and test error if packet payload is too large

[m17rt] / m17app / src / app.rs

diff --git a/m17app/src/app.rs b/m17app/src/app.rs
index 81304559ddf6db33174da3fd74570ca046106547..0abfab640b51937b9076b45cea922ea43c4e954a 100644 (file)
--- a/m17app/src/app.rs
+++ b/m17app/src/app.rs
@@ -1,7 +1,10 @@
 use crate::adapter::{PacketAdapter, StreamAdapter};
 use crate::adapter::{PacketAdapter, StreamAdapter};

+use crate::error::M17Error;
+use crate::link_setup::LinkSetup;

 use crate::tnc::Tnc;
 use crate::tnc::Tnc;

+use crate::{LsfFrame, PacketType, StreamFrame};

 use m17core::kiss::{KissBuffer, KissCommand, KissFrame};
 use m17core::kiss::{KissBuffer, KissCommand, KissFrame};

-use m17core::protocol::{EncryptionType, LsfFrame, PacketType};
+use m17core::protocol::EncryptionType;

 
 use log::debug;
 use std::collections::HashMap;
 
 use log::debug;
 use std::collections::HashMap;


@@ -60,14 +63,6 @@ impl M17App {
         }
     }
 
         }
     }
 

-    pub fn transmit_packet(&self, packet_type: PacketType, payload: &[u8]) {
-        // hang on where do we get the LSF details from? We need a destination obviously
-        // our source address needs to be configured here too
-        // also there is possible CAN, encryption, meta payload
-
-        // we will immediately convert this into a KISS payload before sending into channel so we only need borrow on data
-    }
-

     /// Create a handle that can be used to transmit data on the TNC
     pub fn tx(&self) -> TxHandle {
         TxHandle {
     /// Create a handle that can be used to transmit data on the TNC
     pub fn tx(&self) -> TxHandle {
         TxHandle {


@@ -80,6 +75,8 @@ impl M17App {
     }
 
     pub fn close(&self) {
     }
 
     pub fn close(&self) {

+        // TODO: blocking function to indicate TNC has finished closing
+        // then we could call this in a signal handler to ensure PTT is dropped before quit

         let _ = self.event_tx.send(TncControlEvent::Close);
     }
 }
         let _ = self.event_tx.send(TncControlEvent::Close);
     }
 }


@@ -89,13 +86,40 @@ pub struct TxHandle {
 }
 
 impl TxHandle {
 }
 
 impl TxHandle {

-    // add more methods here for stream outgoing
+    pub fn transmit_packet(
+        &self,
+        link_setup: &LinkSetup,
+        packet_type: PacketType,
+        payload: &[u8],
+    ) -> Result<(), M17Error> {
+        let (pack_type, pack_type_len) = packet_type.as_proto();
+        if pack_type_len + payload.len() > 823 {
+            return Err(M17Error::PacketTooLarge {
+                provided: payload.len(),
+                capacity: 823 - pack_type_len,
+            });
+        }
+        let mut full_payload = vec![];
+        full_payload.extend_from_slice(&pack_type[0..pack_type_len]);
+        full_payload.extend_from_slice(payload);
+        let crc = m17core::crc::m17_crc(&full_payload);
+        full_payload.extend_from_slice(&crc.to_be_bytes());
+        let kiss_frame = KissFrame::new_full_packet(&link_setup.raw.0, &full_payload).unwrap();
+        let _ = self.event_tx.send(TncControlEvent::Kiss(kiss_frame));
+        Ok(())
+    }

 
 

-    pub fn transmit_stream_start(&self /* lsf?, payload? what needs to be configured ?! */) {}
+    pub fn transmit_stream_start(&self, link_setup: &LinkSetup) {
+        let kiss_frame = KissFrame::new_stream_setup(&link_setup.raw.0).unwrap();
+        let _ = self.event_tx.send(TncControlEvent::Kiss(kiss_frame));
+    }

 
     // as long as there is only one TNC it is implied there is only ever one stream transmission in flight
 
 
     // as long as there is only one TNC it is implied there is only ever one stream transmission in flight
 

-    pub fn transmit_stream_next(&self, /* next payload,  */ end_of_stream: bool) {}
+    pub fn transmit_stream_next(&self, stream: &StreamFrame) {
+        let kiss_frame = KissFrame::new_stream_data(stream).unwrap();
+        let _ = self.event_tx.send(TncControlEvent::Kiss(kiss_frame));
+    }

 }
 
 /// Synchronised structure for listeners subscribing to packets and streams.
 }
 
 /// Synchronised structure for listeners subscribing to packets and streams.


@@ -119,19 +143,20 @@ impl Adapters {
 }
 
 /// Carries a request from a method on M17App to the TNC's writer thread, which will execute it.
 }
 
 /// Carries a request from a method on M17App to the TNC's writer thread, which will execute it.

+#[allow(clippy::large_enum_variant)]

 enum TncControlEvent {
     Kiss(KissFrame),
     Start,
     Close,
 }
 
 enum TncControlEvent {
     Kiss(KissFrame),
     Start,
     Close,
 }
 

-fn spawn_reader<T: Tnc + Send + 'static>(mut tnc: T, adapters: Arc<RwLock<Adapters>>) {
+fn spawn_reader<T: Tnc>(mut tnc: T, adapters: Arc<RwLock<Adapters>>) {

     std::thread::spawn(move || {
         let mut kiss_buffer = KissBuffer::new();
         let mut stream_running = false;
         loop {
     std::thread::spawn(move || {
         let mut kiss_buffer = KissBuffer::new();
         let mut stream_running = false;
         loop {

-            let mut buf = kiss_buffer.buf_remaining();
-            let n = match tnc.read(&mut buf) {
+            let buf = kiss_buffer.buf_remaining();
+            let n = match tnc.read(buf) {

                 Ok(n) => n,
                 Err(_) => break,
             };
                 Ok(n) => n,
                 Err(_) => break,
             };


@@ -156,7 +181,7 @@ fn spawn_reader<T: Tnc + Send + 'static>(mut tnc: T, adapters: Arc<RwLock<Adapte
                             continue;
                         }
                         let lsf = LsfFrame(payload[0..30].try_into().unwrap());
                             continue;
                         }
                         let lsf = LsfFrame(payload[0..30].try_into().unwrap());

-                        if lsf.crc() != 0 {
+                        if lsf.check_crc() != 0 {

                             debug!("LSF in full packet frame did not pass CRC");
                             continue;
                         }
                             debug!("LSF in full packet frame did not pass CRC");
                             continue;
                         }


@@ -185,8 +210,8 @@ fn spawn_reader<T: Tnc + Send + 'static>(mut tnc: T, adapters: Arc<RwLock<Adapte
                             adapters.read().unwrap().packet.values().cloned().collect();
                         for s in subs {
                             s.packet_received(
                             adapters.read().unwrap().packet.values().cloned().collect();
                         for s in subs {
                             s.packet_received(

-                                lsf.clone(),
-                                packet_type.clone(),
+                                LinkSetup::new_raw(lsf.clone()),
+                                packet_type,

                                 packet_payload.clone(),
                             );
                         }
                                 packet_payload.clone(),
                             );
                         }


@@ -199,7 +224,7 @@ fn spawn_reader<T: Tnc + Send + 'static>(mut tnc: T, adapters: Arc<RwLock<Adapte
                         };
                         if n == 30 {
                             let lsf = LsfFrame(payload[0..30].try_into().unwrap());
                         };
                         if n == 30 {
                             let lsf = LsfFrame(payload[0..30].try_into().unwrap());

-                            if lsf.crc() != 0 {
+                            if lsf.check_crc() != 0 {

                                 debug!("initial LSF in stream did not pass CRC");
                                 continue;
                             }
                                 debug!("initial LSF in stream did not pass CRC");
                                 continue;
                             }


@@ -207,7 +232,7 @@ fn spawn_reader<T: Tnc + Send + 'static>(mut tnc: T, adapters: Arc<RwLock<Adapte
                             let subs: Vec<_> =
                                 adapters.read().unwrap().stream.values().cloned().collect();
                             for s in subs {
                             let subs: Vec<_> =
                                 adapters.read().unwrap().stream.values().cloned().collect();
                             for s in subs {

-                                s.stream_began(lsf.clone());
+                                s.stream_began(LinkSetup::new_raw(lsf.clone()));

                             }
                         } else if n == 26 {
                             if !stream_running {
                             }
                         } else if n == 26 {
                             if !stream_running {


@@ -241,12 +266,12 @@ fn spawn_reader<T: Tnc + Send + 'static>(mut tnc: T, adapters: Arc<RwLock<Adapte
     });
 }
 
     });
 }
 

-fn spawn_writer<T: Tnc + Send + 'static>(mut tnc: T, event_rx: mpsc::Receiver<TncControlEvent>) {
+fn spawn_writer<T: Tnc>(mut tnc: T, event_rx: mpsc::Receiver<TncControlEvent>) {

     std::thread::spawn(move || {
         while let Ok(ev) = event_rx.recv() {
             match ev {
                 TncControlEvent::Kiss(k) => {
     std::thread::spawn(move || {
         while let Ok(ev) = event_rx.recv() {
             match ev {
                 TncControlEvent::Kiss(k) => {

-                    if let Err(e) = tnc.write_all(&k.as_bytes()) {
+                    if let Err(e) = tnc.write_all(k.as_bytes()) {

                         debug!("kiss send err: {:?}", e);
                         return;
                     }
                         debug!("kiss send err: {:?}", e);
                         return;
                     }


@@ -267,3 +292,33 @@ fn spawn_writer<T: Tnc + Send + 'static>(mut tnc: T, event_rx: mpsc::Receiver<Tn
         }
     });
 }
         }
     });
 }

+
+#[cfg(test)]
+mod tests {
+    use crate::{link_setup::M17Address, test_util::NullTnc};
+
+    use super::*;
+
+    #[test]
+    fn packet_payload_len() {
+        let app = M17App::new(NullTnc);
+        let res = app.tx().transmit_packet(
+            &LinkSetup::new_packet(&M17Address::new_broadcast(), &M17Address::new_broadcast()),
+            PacketType::Raw,
+            &[0u8; 100],
+        );
+        assert_eq!(res, Ok(()));
+        let res = app.tx().transmit_packet(
+            &LinkSetup::new_packet(&M17Address::new_broadcast(), &M17Address::new_broadcast()),
+            PacketType::Raw,
+            &[0u8; 900],
+        );
+        assert_eq!(
+            res,
+            Err(M17Error::PacketTooLarge {
+                provided: 900,
+                capacity: 822
+            })
+        );
+    }
+}