feat: hook up resize for ironrdp-client crate

crates/ironrdp-client/Cargo.toml

@@ -28,7 +28,7 @@ native-tls = ["ironrdp-tls/native-tls"]
 [dependencies]
 
 # Protocols
-ironrdp = { workspace = true, features = ["input", "graphics", "dvc", "rdpdr", "rdpsnd", "cliprdr"] }
+ironrdp = { workspace = true, features = ["input", "graphics", "dvc", "svc", "rdpdr", "rdpsnd", "cliprdr", "displaycontrol"] }
 ironrdp-cliprdr-native.workspace = true
 ironrdp-tls.workspace = true
 ironrdp-tokio.workspace = true

crates/ironrdp-client/src/config.rs

@@ -296,6 +296,7 @@ impl Config {
                 width: DEFAULT_WIDTH,
                 height: DEFAULT_HEIGHT,
             },
+            desktop_scale_factor: 0, // Default to 0 per FreeRDP
             bitmap,
             client_build: semver::Version::parse(env!("CARGO_PKG_VERSION"))
                 .map(|version| version.major * 100 + version.minor * 10 + version.patch)

crates/ironrdp-client/src/gui.rs

@@ -63,9 +63,17 @@ impl GuiContext {
             match event {
                 Event::WindowEvent { window_id, event } if window_id == window.id() => match event {
                     WindowEvent::Resized(size) => {
+                        let scale_factor = (window.scale_factor() * 100.0) as u32;
+                        // TODO: it should be possible to get the physical size here, however winit doesn't make it straightforward.
+                        // FreeRDP does it based on DPI reading grabbed via [`SDL_GetDisplayDPI`](https://wiki.libsdl.org/SDL2/SDL_GetDisplayDPI):
+                        // https://github.com/FreeRDP/FreeRDP/blob/ba8cf8cf2158018fb7abbedb51ab245f369be813/client/SDL/sdl_monitor.cpp#L250-L262
+                        let (physical_width, physical_height) = (0, 0);
                         let _ = input_event_sender.send(RdpInputEvent::Resize {
                             width: u16::try_from(size.width).unwrap(),
                             height: u16::try_from(size.height).unwrap(),
+                            scale_factor,
+                            physical_width,
+                            physical_height,
                         });
                     }
                     WindowEvent::CloseRequested => {
@@ -225,6 +233,8 @@ impl GuiContext {
                     // TODO: is there something we should handle here?
                 }
                 Event::UserEvent(RdpOutputEvent::Image { buffer, width, height }) => {
+                    trace!(width = ?width, height = ?height, "Received image with size");
+                    trace!(window_physical_size = ?window.inner_size(), "Drawing image to the window with size");
                     surface
                         .resize(
                             NonZeroU32::new(u32::from(width)).unwrap(),

crates/ironrdp-client/src/main.rs

@@ -19,6 +19,7 @@ fn main() -> anyhow::Result<()> {
     debug!("GUI context initialized");
 
     let window_size = gui.window().inner_size();
+    config.connector.desktop_scale_factor = 0; // TODO: should this be `(gui.window().scale_factor() * 100.0) as u32`?
     config.connector.desktop_size.width = u16::try_from(window_size.width).unwrap();
     config.connector.desktop_size.height = u16::try_from(window_size.height).unwrap();
 

crates/ironrdp-client/src/rdp.rs

@@ -1,6 +1,8 @@
 use ironrdp::cliprdr::backend::{ClipboardMessage, CliprdrBackendFactory};
 use ironrdp::connector::connection_activation::ConnectionActivationState;
 use ironrdp::connector::{ConnectionResult, ConnectorResult};
+use ironrdp::displaycontrol::client::DisplayControlClient;
+use ironrdp::displaycontrol::pdu::MonitorLayoutEntry;
 use ironrdp::graphics::image_processing::PixelFormat;
 use ironrdp::pdu::input::fast_path::FastPathInputEvent;
 use ironrdp::pdu::write_buf::WriteBuf;
@@ -28,7 +30,13 @@ pub enum RdpOutputEvent {
 
 #[derive(Debug)]
 pub enum RdpInputEvent {
-    Resize { width: u16, height: u16 },
+    Resize {
+        width: u16,
+        height: u16,
+        scale_factor: u32,
+        physical_width: u32,
+        physical_height: u32,
+    },
     FastPath(SmallVec<[FastPathInputEvent; 2]>),
     Close,
     Clipboard(ClipboardMessage),
@@ -107,7 +115,9 @@ async fn connect(
 
     let mut connector = connector::ClientConnector::new(config.connector.clone())
         .with_server_addr(server_addr)
-        .with_static_channel(ironrdp::dvc::DrdynvcClient::new())
+        .with_static_channel(
+            ironrdp::dvc::DrdynvcClient::new().with_dynamic_channel(DisplayControlClient::new(|_| Ok(Vec::new()))),
+        )
         .with_static_channel(rdpsnd::Rdpsnd::new())
         .with_static_channel(rdpdr::Rdpdr::new(Box::new(NoopRdpdrBackend {}), "IronRDP".to_owned()).with_smartcard(0));
 
@@ -177,24 +187,30 @@ async fn active_session(
                 let input_event = input_event.ok_or_else(|| session::general_err!("GUI is stopped"))?;
 
                 match input_event {
-                    RdpInputEvent::Resize { mut width, mut height } => {
-                        // TODO(#105): Add support for Display Update Virtual Channel Extension
-                        // https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpedisp/d2954508-f487-48bc-8731-39743e0854a9
-                        // One approach when this extension is not available is to perform a connection from scratch again.
-
+                    RdpInputEvent::Resize { mut width, mut height, .. } => {
                         // Find the last resize event
                         while let Ok(newer_event) = input_event_receiver.try_recv() {
-                            if let RdpInputEvent::Resize { width: newer_width, height: newer_height } = newer_event {
+                            if let RdpInputEvent::Resize {
+                                width: newer_width,
+                                height: newer_height,
+                                ..
+                            } = newer_event {
                                 width = newer_width;
                                 height = newer_height;
                             }
                         }
 
-                        // TODO(#271): use the "auto-reconnect cookie": https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/15b0d1c9-2891-4adb-a45e-deb4aeeeab7c
-
                         info!(width, height, "resize event");
-
-                        return Ok(RdpControlFlow::ReconnectWithNewSize { width, height })
+                        let (width, height) = MonitorLayoutEntry::adjust_display_size(width.into(), height.into());
+                        debug!(width, height, "Adjusted display size");
+
+                        if let Some(response_frame) = active_stage.encode_resize(width, height, None, Some((width, height))) { // Set physical width and height to the same as the pixel width and heighbbt per FreeRDP
+                            vec![ActiveStageOutput::ResponseFrame(response_frame?)]
+                        } else {
+                            // TODO(#271): use the "auto-reconnect cookie": https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/15b0d1c9-2891-4adb-a45e-deb4aeeeab7c
+                            debug!("Reconnecting with new size");
+                            return Ok(RdpControlFlow::ReconnectWithNewSize { width: width.try_into().unwrap(), height: height.try_into().unwrap() })
+                        }
                     },
                     RdpInputEvent::FastPath(events) => {
                         trace!(?events);
@@ -307,10 +323,10 @@ async fn active_session(
                             pointer_software_rendering,
                         } = connection_activation.state
                         {
-                            debug!("Deactivation-Reactivation Sequence completed");
+                            debug!(?desktop_size, "Deactivation-Reactivation Sequence completed");
+                            // Update image size with the new desktop size.
                             image = DecodedImage::new(PixelFormat::RgbA32, desktop_size.width, desktop_size.height);
-                            // Create a new [`FastPathProcessor`] with potentially updated
-                            // io/user channel ids.
+                            // Update the active stage with the new channel IDs and pointer settings.
                             active_stage.set_fastpath_processor(
                                 fast_path::ProcessorBuilder {
                                     io_channel_id,
@@ -320,6 +336,7 @@ async fn active_session(
                                 }
                                 .build(),
                             );
+                            active_stage.set_no_server_pointer(no_server_pointer);
                             break 'activation_seq;
                         }
                     }

crates/ironrdp-connector/src/connection.rs

@@ -660,11 +660,19 @@ fn create_gcc_blocks<'a>(
                 dig_product_id: Some(config.dig_product_id.clone()),
                 connection_type: Some(ConnectionType::Lan),
                 server_selected_protocol: Some(selected_protocol),
-                desktop_physical_width: None,
-                desktop_physical_height: None,
-                desktop_orientation: None,
-                desktop_scale_factor: None,
-                device_scale_factor: None,
+                desktop_physical_width: Some(0),  // 0 per FreeRDP
+                desktop_physical_height: Some(0), // 0 per FreeRDP
+                desktop_orientation: if config.desktop_size.width > config.desktop_size.height {
+                    Some(MonitorOrientation::Landscape as u16)
+                } else {
+                    Some(MonitorOrientation::Portrait as u16)
+                },
+                desktop_scale_factor: Some(config.desktop_scale_factor),
+                device_scale_factor: if config.desktop_scale_factor >= 100 && config.desktop_scale_factor <= 500 {
+                    Some(100)
+                } else {
+                    Some(0)
+                },
             },
         },
         security: ClientSecurityData {
@@ -700,7 +708,9 @@ fn create_client_info_pdu(config: &Config, routing_addr: &SocketAddr) -> rdp::Cl
     };
 
     // Default flags for all sessions
-    let mut flags = ClientInfoFlags::UNICODE
+    let mut flags = ClientInfoFlags::MOUSE
+        | ClientInfoFlags::MOUSE_HAS_WHEEL
+        | ClientInfoFlags::UNICODE
         | ClientInfoFlags::DISABLE_CTRL_ALT_DEL
         | ClientInfoFlags::LOGON_NOTIFY
         | ClientInfoFlags::LOGON_ERRORS

crates/ironrdp-connector/src/connection_activation.rs

@@ -19,7 +19,7 @@ use crate::{legacy, Config, ConnectionFinalizationSequence, ConnectorResult, Des
 #[derive(Debug, Clone)]
 pub struct ConnectionActivationSequence {
     pub state: ConnectionActivationState,
-    pub config: Config,
+    config: Config,
 }
 
 impl ConnectionActivationSequence {
@@ -127,6 +127,15 @@ impl Sequence for ConnectionActivationSequence {
                     }
                 }
 
+                // At this point we have already sent a requested desktop size to the server -- either as a part of the
+                // [`TS_UD_CS_CORE`] (on initial connection) or the [`DISPLAYCONTROL_MONITOR_LAYOUT`] (on resize event).
+                //
+                // The server is therefore responding with a desktop size here, which will be close to the requested size but
+                // may be slightly different due to server-side constraints. We should use this negotiated size for the rest of
+                // the session.
+                //
+                // [TS_UD_CS_CORE]: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/00f1da4a-ee9c-421a-852f-c19f92343d73
+                // [DISPLAYCONTROL_MONITOR_LAYOUT]: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpedisp/ea2de591-9203-42cd-9908-be7a55237d1c
                 let desktop_size = capability_sets
                     .iter()
                     .find_map(|c| match c {
@@ -142,7 +151,7 @@ impl Sequence for ConnectionActivationSequence {
                     });
 
                 let client_confirm_active = rdp::headers::ShareControlPdu::ClientConfirmActive(
-                    create_client_confirm_active(&self.config, capability_sets),
+                    create_client_confirm_active(&self.config, capability_sets, desktop_size),
                 );
 
                 debug!(message = ?client_confirm_active, "Send");
@@ -249,6 +258,7 @@ const DEFAULT_POINTER_CACHE_SIZE: u16 = 32;
 fn create_client_confirm_active(
     config: &Config,
     mut server_capability_sets: Vec<CapabilitySet>,
+    desktop_size: DesktopSize,
 ) -> rdp::capability_sets::ClientConfirmActive {
     use ironrdp_pdu::rdp::capability_sets::*;
 
@@ -276,8 +286,8 @@ fn create_client_confirm_active(
         }),
         CapabilitySet::Bitmap(Bitmap {
             pref_bits_per_pix: 32,
-            desktop_width: config.desktop_size.width,
-            desktop_height: config.desktop_size.height,
+            desktop_width: desktop_size.width,
+            desktop_height: desktop_size.height,
             // This is required to be true in order for the Microsoft::Windows::RDS::DisplayControl DVC to work.
             desktop_resize_flag: true,
             drawing_flags,
@@ -355,7 +365,10 @@ fn create_client_confirm_active(
             })),
         }])),
         CapabilitySet::FrameAcknowledge(FrameAcknowledge {
-            max_unacknowledged_frame_count: 2,
+            // FIXME(#447): Revert this to 2 per FreeRDP.
+            // This is a temporary hack to fix a resize bug, see:
+            // https://github.com/Devolutions/IronRDP/issues/447
+            max_unacknowledged_frame_count: 20,
         }),
     ]);
 
@@ -364,7 +377,7 @@ fn create_client_confirm_active(
         .any(|c| matches!(&c, CapabilitySet::MultiFragmentUpdate(_)))
     {
         server_capability_sets.push(CapabilitySet::MultiFragmentUpdate(MultifragmentUpdate {
-            max_request_size: 1024,
+            max_request_size: 8 * 1024 * 1024, // 8 MB
         }));
     }
 

crates/ironrdp-connector/src/lib.rs

@@ -72,6 +72,10 @@ impl Credentials {
 pub struct Config {
     /// The initial desktop size to request
     pub desktop_size: DesktopSize,
+    /// The initial desktop scale factor to request.
+    ///
+    /// This becomes the `desktop_scale_factor` in the [`TS_UD_CS_CORE`](gcc::ClientCoreOptionalData) structure.
+    pub desktop_scale_factor: u32,
     /// TLS + Graphical login (legacy)
     ///
     /// Also called SSL or TLS security protocol.

crates/ironrdp-displaycontrol/src/client.rs

@@ -37,13 +37,29 @@ impl DisplayControlClient {
 
     /// Builds a [`DisplayControlPdu::MonitorLayout`] with a single primary monitor
     /// with the given `width` and `height`, and wraps it as an [`SvcMessage`].
+    ///
+    /// Per [2.2.2.2.1]:
+    /// - The `width` MUST be greater than or equal to 200 pixels and less than or equal to 8192 pixels, and MUST NOT be an odd value.
+    /// - The `height` MUST be greater than or equal to 200 pixels and less than or equal to 8192 pixels.
+    /// - The `scale_factor` MUST be ignored if it is less than 100 percent or greater than 500 percent.
+    /// - The `physical_dims` (width, height) MUST be ignored if either is less than 10 mm or greater than 10,000 mm.
+    ///
+    /// Use [`crate::pdu::MonitorLayoutEntry::adjust_display_size`] to adjust `width` and `height` before calling this function
+    /// to ensure the display size is within the valid range.
+    ///
+    /// [2.2.2.2.2]: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpedisp/ea2de591-9203-42cd-9908-be7a55237d1c
     pub fn encode_single_primary_monitor(
         &self,
         channel_id: u32,
         width: u32,
         height: u32,
+        scale_factor: Option<u32>,
+        physical_dims: Option<(u32, u32)>,
     ) -> PduResult<Vec<SvcMessage>> {
-        let pdu: DisplayControlPdu = DisplayControlMonitorLayout::new_single_primary_monitor(width, height)?.into();
+        // TODO: prevent resolution with values greater than max monitor area received in caps.
+        let pdu: DisplayControlPdu =
+            DisplayControlMonitorLayout::new_single_primary_monitor(width, height, scale_factor, physical_dims)?.into();
+        debug!(?pdu, "Sending monitor layout");
         encode_dvc_messages(channel_id, vec![Box::new(pdu)], ChannelFlags::empty())
     }
 }