feat(rdpeudp): carry tunnel sub-headers through the UDP transport

crates/ironrdp-rdpeudp-tokio/src/error.rs

@@ -114,6 +114,11 @@ pub enum UdpTransportErrorKind {
     /// A `send()` payload exceeds the wire `PayloadLength` field's 65535-byte
     /// capacity ([MS-RDPEMT] 2.2.2.3, `RDP_TUNNEL_DATA`).
     PayloadTooLarge { len: usize },
+
+    /// A `send_message()` message's sub-headers, `len` bytes encoded, do not
+    /// fit beside the 4-byte tunnel header in the one-byte `HeaderLength`
+    /// field ([MS-RDPEMT] 2.2.1.1).
+    SubHeadersTooLarge { len: usize },
 }
 
 impl fmt::Display for UdpTransportErrorKind {
@@ -140,6 +145,9 @@ impl fmt::Display for UdpTransportErrorKind {
                     "send payload of {len} bytes exceeds the 65535-byte tunnel data limit"
                 )
             }
+            Self::SubHeadersTooLarge { len } => {
+                write!(f, "{len} bytes of sub-headers exceed the 251 a tunnel header holds")
+            }
         }
     }
 }
@@ -157,7 +165,7 @@ impl core::error::Error for UdpTransportErrorKind {
             | Self::TunnelTimeout
             | Self::TunnelRejected { .. }
             | Self::DriverPanic => None,
-            Self::UnsupportedProtocol { .. } | Self::PayloadTooLarge { .. } => None,
+            Self::UnsupportedProtocol { .. } | Self::PayloadTooLarge { .. } | Self::SubHeadersTooLarge { .. } => None,
         }
     }
 }

crates/ironrdp-rdpeudp-tokio/src/framed.rs

@@ -33,9 +33,9 @@ impl FramedRead for UdpTransport {
             // puts no minimum on HigherLayerData, and [MS-RDPBCGR] 1.3.9 sends
             // the four Continuous Auto-Detection messages "encapsulated in the
             // RDP_TUNNEL_SUBHEADER structure ... over the sideband channels
-            // that are in active use". The tunnel has already taken what it
-            // needs from those subheaders by the time we get here, leaving a
-            // payload of nothing to pass on.
+            // that are in active use". `recv` drops those subheaders (a caller
+            // that needs them uses `recv_message`), leaving a payload of
+            // nothing to pass on.
             loop {
                 match self.recv().await {
                     Some(data) if data.is_empty() => {
@@ -74,11 +74,12 @@ mod tests {
     use tokio::sync::mpsc;
 
     use super::*;
+    use crate::transport::TunnelMessage;
 
     /// Build a `UdpTransport` backed by test channels (no real network).
-    fn test_transport() -> (UdpTransport, mpsc::Sender<Vec<u8>>, mpsc::Receiver<Vec<u8>>) {
-        let (incoming_tx, incoming_rx) = mpsc::channel::<Vec<u8>>(16);
-        let (outgoing_tx, outgoing_rx) = mpsc::channel::<Vec<u8>>(16);
+    fn test_transport() -> (UdpTransport, mpsc::Sender<TunnelMessage>, mpsc::Receiver<TunnelMessage>) {
+        let (incoming_tx, incoming_rx) = mpsc::channel::<TunnelMessage>(16);
+        let (outgoing_tx, outgoing_rx) = mpsc::channel::<TunnelMessage>(16);
 
         let transport = UdpTransport::from_channels(incoming_rx, outgoing_tx);
 
@@ -88,7 +89,7 @@ mod tests {
     #[tokio::test]
     async fn framed_read_delivers_one_message() {
         let (mut transport, feeder, _) = test_transport();
-        feeder.send(vec![0xDE, 0xAD, 0xBE, 0xEF]).await.unwrap();
+        feeder.send(vec![0xDE, 0xAD, 0xBE, 0xEF].into()).await.unwrap();
 
         let mut buf = BytesMut::new();
         let n = FramedRead::read(&mut transport, &mut buf).await.unwrap();
@@ -120,8 +121,8 @@ mod tests {
     async fn framed_read_does_not_mistake_an_empty_message_for_eof() {
         let (mut transport, feeder, _) = test_transport();
 
-        feeder.send(Vec::new()).await.unwrap();
-        feeder.send(vec![0x11, 0x22]).await.unwrap();
+        feeder.send(Vec::new().into()).await.unwrap();
+        feeder.send(vec![0x11, 0x22].into()).await.unwrap();
 
         let mut buf = BytesMut::new();
         let n = FramedRead::read(&mut transport, &mut buf).await.unwrap();
@@ -135,7 +136,7 @@ mod tests {
     async fn framed_read_still_reports_eof_after_an_empty_message() {
         let (mut transport, feeder, _) = test_transport();
 
-        feeder.send(Vec::new()).await.unwrap();
+        feeder.send(Vec::new().into()).await.unwrap();
         drop(feeder);
 
         let mut buf = BytesMut::new();
@@ -154,7 +155,7 @@ mod tests {
             .unwrap();
 
         let data = receiver.recv().await.unwrap();
-        assert_eq!(data, vec![0x01, 0x02, 0x03]);
+        assert_eq!(data, TunnelMessage::from(vec![0x01, 0x02, 0x03]));
     }
 
     #[tokio::test]
@@ -171,8 +172,8 @@ mod tests {
     async fn framed_read_multiple_messages_accumulate() {
         let (mut transport, feeder, _) = test_transport();
 
-        feeder.send(vec![0xAA, 0xBB]).await.unwrap();
-        feeder.send(vec![0xCC, 0xDD]).await.unwrap();
+        feeder.send(vec![0xAA, 0xBB].into()).await.unwrap();
+        feeder.send(vec![0xCC, 0xDD].into()).await.unwrap();
 
         let mut buf = BytesMut::new();
 

crates/ironrdp-rdpeudp-tokio/src/lib.rs

@@ -15,5 +15,6 @@ pub(crate) mod tunnel;
 pub use self::error::{DriverError, DriverErrorKind, UdpTransportError, UdpTransportErrorKind};
 pub use self::multitransport::MultitransportBootstrap;
 pub use self::transport::{
-    UdpAcceptConfig, UdpTlsConfig, UdpTransport, UdpTransportConfig, UdpTransportSender, accept_udp, connect_udp,
+    TunnelMessage, UdpAcceptConfig, UdpTlsConfig, UdpTransport, UdpTransportConfig, UdpTransportSender, accept_udp,
+    connect_udp,
 };