Bump to windows 0.60 (#22)

LeonarddeR · web-flow · commit b60d4cce81d8 · 2025-03-07T12:01:28.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -21,7 +21,7 @@ readme = "../readme.md"
 repository = "https://github.com/leonardder/rd_pipe-rs"
 license = "AGPL-3.0-or-later"
 categories = ["network-programming", "os::windows-apis"]
-edition = "2021"
+edition = "2024"
 
 [lib]
 crate-type = ["cdylib"]
@@ -34,11 +34,11 @@ tracing-appender = "0.2.3"
 tracing-subscriber = "0.3.19"
 itertools = "0.14.0"
 winreg = { version = "0.55", features = ["transactions"] }
+windows-core = "0.60.1"
 
 [dependencies.windows]
-version = "0.54.0"
+version = "0.60.0"
 features = [
-    "implement",
     "Win32_Foundation",
     "Win32_System_SystemServices",
     "Win32_System_LibraryLoader",
diff --git a/src/class_factory.rs b/src/class_factory.rs
@@ -12,31 +12,37 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use std::mem::transmute;
+use std::{fmt, mem::transmute};
 use tracing::{debug, instrument, trace};
 use windows::{
-    core::{implement, IUnknown, Result, GUID},
     Win32::{
-        Foundation::{BOOL, CLASS_E_NOAGGREGATION, E_NOINTERFACE},
-        System::Com::{IClassFactory, IClassFactory_Impl},
+        Foundation::{CLASS_E_NOAGGREGATION, E_NOINTERFACE},
+        System::{
+            Com::{IClassFactory, IClassFactory_Impl},
+            RemoteDesktop::IWTSPlugin,
+        },
     },
+    core::{Error, GUID, IUnknown, Interface, Result, implement},
 };
-use windows::{
-    core::{Error, Interface},
-    Win32::System::RemoteDesktop::IWTSPlugin,
-};
+use windows_core::BOOL;
 
 use crate::rd_pipe_plugin::RdPipePlugin;
 
 #[implement(IClassFactory)]
 #[derive(Debug)]
 pub struct ClassFactory;
 
-impl IClassFactory_Impl for ClassFactory {
-    #[instrument]
+impl fmt::Debug for ClassFactory_Impl {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("ClassFactory_Impl").finish()
+    }
+}
+
+impl IClassFactory_Impl for ClassFactory_Impl {
+    #[instrument(skip(outer))]
     fn CreateInstance(
         &self,
-        outer: Option<&IUnknown>,
+        outer: windows_core::Ref<'_, IUnknown>,
         iid: *const GUID,
         object: *mut *mut core::ffi::c_void,
     ) -> Result<()> {
diff --git a/src/lib.rs b/src/lib.rs
@@ -20,37 +20,38 @@ use crate::{
     class_factory::ClassFactory, rd_pipe_plugin::RdPipePlugin, registry::CLSID_RD_PIPE_PLUGIN,
 };
 use rd_pipe_plugin::REG_PATH;
-#[cfg(target_arch = "x86")]
-use registry::{ctx_add_to_registry, ctx_delete_from_registry};
 use registry::{
-    delete_from_registry, inproc_server_add_to_registry, msts_add_to_registry, COM_CLS_FOLDER,
-    TS_ADD_INS_FOLDER, TS_ADD_IN_RD_PIPE_FOLDER_NAME,
+    COM_CLS_FOLDER, TS_ADD_IN_RD_PIPE_FOLDER_NAME, TS_ADD_INS_FOLDER, delete_from_registry,
+    inproc_server_add_to_registry, msts_add_to_registry,
 };
+#[cfg(target_arch = "x86")]
+use registry::{ctx_add_to_registry, ctx_delete_from_registry};
 use std::{ffi::c_void, io, mem::transmute, panic, str::FromStr};
 use tokio::runtime::Runtime;
 use tracing::{debug, error, instrument, trace};
 use windows::{
-    core::{Interface, PCWSTR},
     Win32::{
-        Foundation::{ERROR_INVALID_FUNCTION, ERROR_INVALID_PARAMETER, HMODULE, WIN32_ERROR},
-        System::LibraryLoader::GetModuleFileNameW,
-    },
-};
-use windows::{
-    core::{GUID, HRESULT},
-    Win32::{
-        Foundation::{BOOL, CLASS_E_CLASSNOTAVAILABLE, E_UNEXPECTED, S_OK},
+        Foundation::{CLASS_E_CLASSNOTAVAILABLE, E_UNEXPECTED, S_OK},
         System::{
             Com::IClassFactory,
             LibraryLoader::DisableThreadLibraryCalls,
             RemoteDesktop::IWTSPlugin,
             SystemServices::{DLL_PROCESS_ATTACH, DLL_PROCESS_DETACH},
         },
     },
+    core::{GUID, HRESULT},
 };
+use windows::{
+    Win32::{
+        Foundation::{ERROR_INVALID_PARAMETER, HMODULE, WIN32_ERROR},
+        System::LibraryLoader::GetModuleFileNameW,
+    },
+    core::{Interface, PCWSTR},
+};
+use windows_core::BOOL;
 use winreg::{
+    HKEY, RegKey,
     enums::{HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE},
-    RegKey, HKEY,
 };
 
 lazy_static::lazy_static! {
@@ -70,7 +71,7 @@ fn get_log_level_from_registry(parent_key: HKEY) -> io::Result<u32> {
 
 static mut INSTANCE: Option<HMODULE> = None;
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub extern "stdcall" fn DllMain(hinst: HMODULE, reason: u32, _reserved: *mut c_void) -> BOOL {
     match reason {
         DLL_PROCESS_ATTACH => {
@@ -112,7 +113,7 @@ pub extern "stdcall" fn DllMain(hinst: HMODULE, reason: u32, _reserved: *mut c_v
     true.into()
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[instrument]
 pub extern "stdcall" fn DllGetClassObject(
     rclsid: *const GUID,
@@ -143,7 +144,7 @@ pub extern "stdcall" fn DllGetClassObject(
     S_OK
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[instrument]
 pub extern "stdcall" fn VirtualChannelGetInstance(
     riid: *const GUID,
@@ -160,9 +161,13 @@ pub extern "stdcall" fn VirtualChannelGetInstance(
         return E_UNEXPECTED;
     }
     let pnumobjs = unsafe { &mut *pnumobjs };
-    trace!("Checking whether result pointer is null (i.e. whether this call is a query for number of plugins or a query for the plugins itself)");
+    trace!(
+        "Checking whether result pointer is null (i.e. whether this call is a query for number of plugins or a query for the plugins itself)"
+    );
     if ppo.is_null() {
-        debug!("Result pointer is null, client is querying for number of objects. Setting pnumobjs to 1, since we only support one plugin");
+        debug!(
+            "Result pointer is null, client is querying for number of objects. Setting pnumobjs to 1, since we only support one plugin"
+        );
         *pnumobjs = 1;
     } else {
         debug!("{} plugins requested", *pnumobjs);
@@ -172,9 +177,9 @@ pub extern "stdcall" fn VirtualChannelGetInstance(
         }
         let ppo = unsafe { &mut *ppo };
         trace!("Constructing the plugin");
-        let plugin: IWTSPlugin = RdPipePlugin::new().into();
+        let plugin = RdPipePlugin::new();
         trace!("Setting result pointer to plugin");
-        *ppo = unsafe { transmute(plugin) };
+        *ppo = unsafe { transmute(&plugin) };
     }
     S_OK
 }
@@ -184,7 +189,7 @@ const CMD_MSTS: char = 'r'; // Registers/unregisters RDP/MSTS support
 const CMD_CITRIX: char = 'x'; // Registers/unregisters Citrix support
 const CMD_LOCAL_MACHINE: char = 'm'; // If omitted, registers to HKEY_CURRENT_USER
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 #[instrument]
 pub extern "stdcall" fn DllInstall(install: bool, cmd_line: PCWSTR) -> HRESULT {
     debug!("DllInstall called");
@@ -224,37 +229,29 @@ pub extern "stdcall" fn DllInstall(install: bool, cmd_line: PCWSTR) -> HRESULT {
                     error!("No channel names provided");
                     return ERROR_INVALID_PARAMETER.into();
                 }
-                match unsafe { INSTANCE } {
-                    Some(h) => {
-                        let mut file_name = [0u16; 256];
-                        let path_string: String;
-                        match unsafe { GetModuleFileNameW(h, file_name.as_mut()) } > 0 {
-                            true => {
-                                path_string = String::from_utf16_lossy(&file_name);
-                            }
-                            false => {
-                                let e = windows::core::Error::from_win32();
-                                error!("Error calling GetModuleFileNameW: {}", e);
-                                return e.into();
-                            }
-                        }
-                        if let Err(e) = inproc_server_add_to_registry(
-                            scope_hkey,
-                            &COM_CLS_FOLDER,
-                            &path_string,
-                            &arguments[1..],
-                        ) {
-                            let e: windows::core::Error =
-                                WIN32_ERROR(e.raw_os_error().unwrap() as u32).into();
-                            error!("Error calling inproc_server_add_to_registry: {}", e);
-                            return e.into();
-                        }
+                let mut file_name = [0u16; 256];
+                let path_string: String;
+                match unsafe { GetModuleFileNameW(INSTANCE, file_name.as_mut()) } > 0 {
+                    true => {
+                        path_string = String::from_utf16_lossy(&file_name);
                     }
-                    None => {
-                        error!("No hinstance to calculate dll path");
-                        return ERROR_INVALID_FUNCTION.into();
+                    false => {
+                        let e = windows::core::Error::from_win32();
+                        error!("Error calling GetModuleFileNameW: {}", e);
+                        return e.into();
                     }
                 }
+                if let Err(e) = inproc_server_add_to_registry(
+                    scope_hkey,
+                    &COM_CLS_FOLDER,
+                    &path_string,
+                    &arguments[1..],
+                ) {
+                    let e: windows::core::Error =
+                        WIN32_ERROR(e.raw_os_error().unwrap() as u32).into();
+                    error!("Error calling inproc_server_add_to_registry: {}", e);
+                    return e.into();
+                }
             }
             if commands.contains(CMD_MSTS) {
                 if let Err(e) = msts_add_to_registry(scope_hkey) {
diff --git a/src/rd_pipe_plugin.rs b/src/rd_pipe_plugin.rs
@@ -16,29 +16,31 @@
 use core::slice;
 use itertools::Itertools;
 use parking_lot::Mutex;
-use std::io;
+use std::{fmt, io};
 use std::{io::ErrorKind::WouldBlock, sync::Arc};
 use tokio::{
-    io::{split, AsyncReadExt, AsyncWriteExt, WriteHalf},
+    io::{AsyncReadExt, AsyncWriteExt, WriteHalf, split},
     net::windows::named_pipe::{NamedPipeServer, ServerOptions},
     task::JoinHandle,
-    time::{sleep, Duration},
+    time::{Duration, sleep},
 };
 use tracing::{debug, error, info, instrument, trace, warn};
+use windows::Win32::Foundation::ERROR_PIPE_NOT_CONNECTED;
 use windows::{
-    core::{implement, AgileReference, Error, Interface, Result, BSTR, PCSTR},
     Win32::{
-        Foundation::{BOOL, ERROR_PIPE_NOT_CONNECTED, E_UNEXPECTED},
+        Foundation::E_UNEXPECTED,
         System::RemoteDesktop::{
             IWTSListener, IWTSListenerCallback, IWTSListenerCallback_Impl, IWTSPlugin,
             IWTSPlugin_Impl, IWTSVirtualChannel, IWTSVirtualChannelCallback,
             IWTSVirtualChannelCallback_Impl, IWTSVirtualChannelManager,
         },
     },
+    core::{AgileReference, BSTR, Error, Interface, PCSTR, Result, implement},
 };
+use windows_core::{BOOL, OutRef};
 use winreg::{
+    HKEY, RegKey,
     enums::{HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE},
-    RegKey, HKEY,
 };
 
 use crate::ASYNC_RUNTIME;
@@ -83,10 +85,19 @@ impl RdPipePlugin {
     }
 }
 
-impl IWTSPlugin_Impl for RdPipePlugin {
-    #[instrument]
-    fn Initialize(&self, pchannelmgr: Option<&IWTSVirtualChannelManager>) -> Result<()> {
-        let channel_mgr = match pchannelmgr {
+impl fmt::Debug for RdPipePlugin_Impl {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("RdPipePlugin_Impl").finish()
+    }
+}
+
+impl IWTSPlugin_Impl for RdPipePlugin_Impl {
+    #[instrument(skip(pchannelmgr))]
+    fn Initialize(
+        &self,
+        pchannelmgr: windows_core::Ref<'_, IWTSVirtualChannelManager>,
+    ) -> Result<()> {
+        let channel_mgr = match pchannelmgr.as_ref() {
             Some(m) => m,
             None => {
                 error!("No pchannelmgr given when initializing");
@@ -142,31 +153,35 @@ impl RdPipeListenerCallback {
     }
 }
 
-impl IWTSListenerCallback_Impl for RdPipeListenerCallback {
-    #[instrument]
+impl fmt::Debug for RdPipeListenerCallback_Impl {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("RdPipeListenerCallback_Impl")
+            .field("name", &self.name)
+            .finish()
+    }
+}
+
+impl IWTSListenerCallback_Impl for RdPipeListenerCallback_Impl {
+    #[instrument(skip(pchannel, ppcallback))]
     fn OnNewChannelConnection(
         &self,
-        pchannel: Option<&IWTSVirtualChannel>,
+        pchannel: windows_core::Ref<'_, IWTSVirtualChannel>,
         data: &BSTR,
         pbaccept: *mut BOOL,
-        ppcallback: *mut Option<IWTSVirtualChannelCallback>,
+        ppcallback: OutRef<'_, IWTSVirtualChannelCallback>,
     ) -> Result<()> {
-        debug!(
-            "Creating new callback for channel {:?} with name {}",
-            pchannel, &self.name
-        );
-        let channel = match pchannel {
+        debug!("Creating new callback for channel with name {}", &self.name);
+        let channel = match pchannel.as_ref() {
             Some(c) => c,
             None => return Err(Error::from(E_UNEXPECTED)),
         };
         let pbaccept = unsafe { &mut *pbaccept };
-        let ppcallback = unsafe { &mut *ppcallback };
         *pbaccept = BOOL::from(true);
         debug!("Creating callback");
         let callback: IWTSVirtualChannelCallback =
             RdPipeChannelCallback::new(channel, &self.name).into();
         trace!("Callback {:?} created", callback);
-        *ppcallback = Some(callback);
+        ppcallback.write(callback.into()).unwrap();
         Ok(())
     }
 }
@@ -296,14 +311,14 @@ impl RdPipeChannelCallback {
     }
 }
 
-impl Drop for RdPipeChannelCallback {
-    #[instrument]
-    fn drop(&mut self) {
-        self.OnClose().unwrap_or_default();
+impl fmt::Debug for RdPipeChannelCallback_Impl {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("RdPipeChannelCallback_Impl")
+            .field("pipe_writer", &self.pipe_writer)
+            .finish()
     }
 }
-
-impl IWTSVirtualChannelCallback_Impl for RdPipeChannelCallback {
+impl IWTSVirtualChannelCallback_Impl for RdPipeChannelCallback_Impl {
     #[instrument]
     fn OnDataReceived(&self, cbsize: u32, pbuffer: *const u8) -> Result<()> {
         debug!("Data received, buffer has size {}", cbsize);
diff --git a/src/registry.rs b/src/registry.rs
@@ -16,7 +16,7 @@ use std::io;
 use tracing::{debug, instrument, trace};
 use windows::core::GUID;
 use winreg::enums::KEY_ALL_ACCESS;
-use winreg::{enums::KEY_WRITE, transaction::Transaction, types::ToRegValue, RegKey, HKEY};
+use winreg::{HKEY, RegKey, enums::KEY_WRITE, transaction::Transaction, types::ToRegValue};
 
 pub const CLSID_RD_PIPE_PLUGIN: GUID = GUID::from_u128(0xD1F74DC79FDE45BE9251FA72D4064DA3);
 const RD_PIPE_PLUGIN_NAME: &str = "RdPipe";
