feat: drive redirection for the viewer, .rdp files and Windows hotplug

crates/ironrdp-cfg/src/lib.rs

@@ -315,6 +315,120 @@ impl core::fmt::Display for DvcPipeSpecMissingDelimiter {
 
 impl core::error::Error for DvcPipeSpecMissingDelimiter {}
 
+/// Local drives selected for redirection.
+///
+/// Corresponds to the `drivestoredirect` `.rdp` property, using the mstsc syntax: entries are
+/// separated by `;`, `*` selects every drive (including drives connected later), `DynamicDrives`
+/// selects drives connected later, and `C:\` (or `C:`, `C`) selects one drive letter.
+/// Unrecognized entries, such as FreeRDP-specific paths, are ignored.
+///
+/// Selecting every drive implies dynamic drives, because `*` cannot express one without the other.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct DriveRedirection {
+    /// INVARIANT: only the low 26 bits are used; bit `n` selects the letter `'A' + n`.
+    letters: u32,
+    all: bool,
+    dynamic: bool,
+}
+
+impl DriveRedirection {
+    const DYNAMIC_DRIVES: &str = "DynamicDrives";
+
+    /// Selects every local drive, including drives connected later (`*`).
+    pub fn all() -> Self {
+        Self {
+            letters: 0,
+            all: true,
+            dynamic: true,
+        }
+    }
+
+    /// Parses a `drivestoredirect` value.
+    pub fn parse(value: &str) -> Self {
+        let mut selection = Self::default();
+        for entry in value.split(';').map(str::trim).filter(|entry| !entry.is_empty()) {
+            if entry == "*" {
+                selection.all = true;
+                selection.dynamic = true;
+            } else if entry.eq_ignore_ascii_case(Self::DYNAMIC_DRIVES) {
+                selection.dynamic = true;
+            } else if let Some(index) = drive_letter_index(entry) {
+                selection.letters |= 1 << index;
+            }
+        }
+        if selection.all {
+            // `*` already selects every letter.
+            selection.letters = 0;
+        }
+        selection
+    }
+
+    /// Returns this selection with drives connected later enabled or disabled.
+    ///
+    /// Has no effect on a selection of every drive.
+    #[must_use]
+    pub fn with_dynamic(mut self, enabled: bool) -> Self {
+        self.dynamic = enabled || self.all;
+        self
+    }
+
+    /// Whether every local drive is selected.
+    pub fn redirects_all(&self) -> bool {
+        self.all
+    }
+
+    /// Whether drives connected during the session are selected.
+    pub fn redirects_dynamic(&self) -> bool {
+        self.dynamic
+    }
+
+    /// Returns the uppercase drive letters selected explicitly, in alphabetical order.
+    pub fn letters(&self) -> impl Iterator<Item = char> + '_ {
+        (b'A'..=b'Z')
+            .zip(0u32..)
+            .filter(|(_, index)| self.letters & (1 << index) != 0)
+            .map(|(letter, _)| char::from(letter))
+    }
+
+    /// Whether no drive is selected.
+    pub fn is_empty(&self) -> bool {
+        self.letters == 0 && !self.all && !self.dynamic
+    }
+}
+
+impl core::fmt::Display for DriveRedirection {
+    /// Formats the selection as a `drivestoredirect` value.
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        if self.all {
+            return f.write_str("*");
+        }
+
+        let mut separator = "";
+        for letter in self.letters() {
+            write!(f, "{separator}{letter}:\\")?;
+            separator = ";";
+        }
+        if self.dynamic {
+            write!(f, "{separator}{}", Self::DYNAMIC_DRIVES)?;
+        }
+        Ok(())
+    }
+}
+
+/// Returns the bit index of a `C`, `C:`, `C:\` or `C:/` drive entry.
+fn drive_letter_index(entry: &str) -> Option<u32> {
+    match entry.as_bytes() {
+        [letter] | [letter, b':'] | [letter, b':', b'\\' | b'/'] => drive_letter_index_of(letter.to_ascii_uppercase()),
+        _ => None,
+    }
+}
+
+fn drive_letter_index_of(uppercase_letter: u8) -> Option<u32> {
+    uppercase_letter
+        .is_ascii_uppercase()
+        .then(|| u32::from(uppercase_letter - b'A'))
+}
+
 /// Typed accessors for the RDP properties IronRDP understands.
 ///
 /// Every property is exposed as a triplet of methods sharing the same underlying key: a getter
@@ -411,6 +525,15 @@ pub trait PropertySetExt {
     /// Removes the `domain` property.
     fn clear_domain(&mut self);
 
+    /// Raw local drive selection (`drivestoredirect`); see [`DriveRedirection`] for the syntax.
+    ///
+    /// Prefer [`Self::drive_redirection`], which also honors the legacy `redirectdrives` key.
+    fn drives_to_redirect(&self) -> Option<&str>;
+    /// Sets the `drivestoredirect` property.
+    fn set_drives_to_redirect(&mut self, value: impl Into<String>);
+    /// Removes the `drivestoredirect` property.
+    fn clear_drives_to_redirect(&mut self);
+
     /// Whether CredSSP/NLA support is enabled (`enablecredsspsupport`).
     fn enable_credssp_support(&self) -> Option<bool>;
     /// Sets the `enablecredsspsupport` property.
@@ -485,6 +608,15 @@ pub trait PropertySetExt {
     /// Removes the `redirectclipboard` property.
     fn clear_redirect_clipboard(&mut self);
 
+    /// Whether every local drive is redirected (`redirectdrives`, legacy).
+    ///
+    /// Prefer [`Self::drive_redirection`], which gives `drivestoredirect` precedence.
+    fn redirect_drives(&self) -> Option<bool>;
+    /// Sets the `redirectdrives` property.
+    fn set_redirect_drives(&mut self, value: bool);
+    /// Removes the `redirectdrives` property.
+    fn clear_redirect_drives(&mut self);
+
     /// Whether WebAuthn redirection is requested (`redirectwebauthn`).
     fn redirect_webauthn(&self) -> Option<bool>;
     /// Sets the `redirectwebauthn` property.
@@ -681,6 +813,14 @@ pub trait PropertySetExt {
     /// `gatewayusername`, and both `GatewayPassword` casings).
     fn clear_gateway(&mut self);
 
+    /// Local drive selection resolved from `drivestoredirect` and the legacy `redirectdrives`.
+    ///
+    /// A nonempty `drivestoredirect` takes precedence. Otherwise `redirectdrives:i:1` selects every
+    /// drive, as in FreeRDP. Returns `None` when neither key is present.
+    fn drive_redirection(&self) -> Option<DriveRedirection>;
+    /// Writes `drivestoredirect` and `redirectdrives` from a drive selection.
+    fn set_drive_redirection(&mut self, value: DriveRedirection);
+
     /// Removes every RDCleanPath-related key (`ironrdp_rdcleanpathurl` and
     /// `ironrdp_rdcleanpathtoken`).
     fn clear_rdcleanpath(&mut self);
@@ -831,6 +971,18 @@ impl PropertySetExt for PropertySet {
         self.remove("domain");
     }
 
+    fn drives_to_redirect(&self) -> Option<&str> {
+        self.get::<&str>("drivestoredirect")
+    }
+
+    fn set_drives_to_redirect(&mut self, value: impl Into<String>) {
+        self.insert("drivestoredirect", value.into());
+    }
+
+    fn clear_drives_to_redirect(&mut self) {
+        self.remove("drivestoredirect");
+    }
+
     fn enable_credssp_support(&self) -> Option<bool> {
         self.get::<bool>("enablecredsspsupport")
     }
@@ -961,6 +1113,18 @@ impl PropertySetExt for PropertySet {
         self.remove("redirectclipboard");
     }
 
+    fn redirect_drives(&self) -> Option<bool> {
+        self.get::<bool>("redirectdrives")
+    }
+
+    fn set_redirect_drives(&mut self, value: bool) {
+        self.insert("redirectdrives", value);
+    }
+
+    fn clear_redirect_drives(&mut self) {
+        self.remove("redirectdrives");
+    }
+
     fn redirect_webauthn(&self) -> Option<bool> {
         self.get::<bool>("redirectwebauthn")
     }
@@ -1340,6 +1504,22 @@ impl PropertySetExt for PropertySet {
         self.remove("GatewayPassword");
     }
 
+    fn drive_redirection(&self) -> Option<DriveRedirection> {
+        let drives_to_redirect = self.drives_to_redirect();
+        let redirect_drives = self.redirect_drives();
+        match (drives_to_redirect.map(str::trim), redirect_drives) {
+            (Some(value), _) if !value.is_empty() => Some(DriveRedirection::parse(value)),
+            (_, Some(true)) => Some(DriveRedirection::all()),
+            (None, None) => None,
+            _ => Some(DriveRedirection::default()),
+        }
+    }
+
+    fn set_drive_redirection(&mut self, value: DriveRedirection) {
+        self.set_drives_to_redirect(value.to_string());
+        self.set_redirect_drives(!value.is_empty());
+    }
+
     fn clear_rdcleanpath(&mut self) {
         self.remove("ironrdp_rdcleanpathurl");
         self.remove("ironrdp_rdcleanpathtoken");

crates/ironrdp-client/src/config.rs

@@ -11,6 +11,10 @@ use ironrdp_propertyset::PropertySet;
 use ironrdp_rail::pdu::ExecutePdu;
 use url::Url;
 
+/// Local drive selection, as configured with [`ConfigBuilder::with_drive_redirection`].
+#[cfg(feature = "rdpdr")]
+pub use ironrdp_cfg::DriveRedirection;
+
 /// RDP-UDP protocol version, as offered with [`ConfigBuilder::with_udp_offer_version`].
 #[cfg(feature = "udp")]
 pub use ironrdp_rdpeudp::pdu::UdpVersion;
@@ -435,6 +439,12 @@ pub struct RdpdrConfig {
     /// Enable smart-card redirection within RDPDR.
     #[cfg(feature = "smartcard")]
     pub smartcard: bool,
+
+    /// Local drives requested for redirection.
+    ///
+    /// The client does not enumerate drives itself: frontends read this selection to configure
+    /// their native RDPDR backend factory.
+    pub drives: DriveRedirection,
 }
 
 #[cfg(feature = "rdpdr")]
@@ -444,6 +454,7 @@ impl Default for RdpdrConfig {
             enabled: true,
             #[cfg(feature = "smartcard")]
             smartcard: true,
+            drives: DriveRedirection::default(),
         }
     }
 }
@@ -1484,6 +1495,15 @@ impl ConfigBuilder {
         self
     }
 
+    /// Selects the local drives to redirect (`drivestoredirect`).
+    #[cfg(feature = "rdpdr")]
+    #[must_use]
+    pub fn with_drive_redirection(mut self, drives: DriveRedirection) -> Self {
+        self.channels.rdpdr.drives = drives;
+        self.properties.set_drive_redirection(drives);
+        self
+    }
+
     /// Enable or disable smart-card redirection within RDPDR.
     #[cfg(feature = "smartcard")]
     #[must_use]
@@ -2337,6 +2357,10 @@ impl ConfigBuilder {
         if let Some(enabled) = ps.enable_rdpdr() {
             self.channels.rdpdr.enabled = enabled;
         }
+        #[cfg(feature = "rdpdr")]
+        if let Some(drives) = ps.drive_redirection() {
+            self.channels.rdpdr.drives = drives;
+        }
         #[cfg(feature = "smartcard")]
         if let Some(enabled) = ps.enable_smartcard() {
             self.channels.rdpdr.smartcard = enabled;