Add Windows user clipboard agent

Signed-off-by: Tu Dinh <[email protected]>

Author: dinhngtu

Cargo.toml

@@ -15,6 +15,7 @@ members = [
   "publishers/publisher-xenstore",
   "publishers/publisher-console",
   "xen-win-utils",
+  "xen-win-clipboard",
 ]
 
 [profile.release]

xen-win-clipboard/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "xen-win-clipboard"
+version = "0.5.0-dev"
+edition = "2021"
+rust-version = "1.76"
+license = "AGPL-3.0-only"
+
+[dependencies]
+anyhow = "1.0"
+# not sure why explicitly specifying std is needed here
+log = { version = "0.4.0", features = ["std"] }
+windows = { version = "0.61", features = [
+  "Win32_Foundation",
+  "Win32_System_Diagnostics_Debug",
+  "Win32_UI_WindowsAndMessaging",
+  "Win32_Graphics_Gdi",
+  "Win32_System_DataExchange",
+  "Win32_System_LibraryLoader",
+  "Win32_System_Ole",
+  "Win32_System_Memory",
+  "Win32_System_Recovery",
+] }
+xen-win-utils = { path = "../xen-win-utils" }
+
+[build-dependencies]
+winres = "0.1"

xen-win-clipboard/README.md

@@ -0,0 +1,4 @@
+# Pipe talker message format
+
+UTF-8 string containing clipboard contents.
+This is eventually converted into UTF-16 by xen-win-clipboard for use with CF_UNICODETEXT.

xen-win-clipboard/build.rs

@@ -0,0 +1,12 @@
+#[cfg(windows)]
+extern crate winres;
+
+#[cfg(windows)]
+fn main() {
+    let mut res = winres::WindowsResource::new();
+    res.set_manifest_file("manifest.xml");
+    res.compile().unwrap();
+}
+
+#[cfg(unix)]
+fn main() {}

xen-win-clipboard/manifest.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
+    <security>
+      <requestedPrivileges>
+        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <!-- Windows 10 -->
+      <supportedOS
+        Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
+    </application>
+  </compatibility>
+</assembly>

xen-win-clipboard/src/clipboard.rs

@@ -0,0 +1,86 @@
+use std::marker::PhantomData;
+
+use windows::Win32::{
+    Foundation::{ERROR_BUFFER_OVERFLOW, HANDLE, HGLOBAL, HWND},
+    System::{
+        DataExchange::{CloseClipboard, GetClipboardData, OpenClipboard, SetClipboardData},
+        Memory::{GlobalAlloc, GMEM_MOVEABLE},
+        Ole::{CF_UNICODETEXT, CLIPBOARD_FORMAT},
+    },
+};
+use xen_win_utils::heap::GlobalLockGuard;
+
+fn as_u8_slice(input: &[u16]) -> windows::core::Result<&[u8]> {
+    let count = input.len().checked_mul(2).ok_or(ERROR_BUFFER_OVERFLOW)?;
+    unsafe {
+        Ok(core::slice::from_raw_parts(
+            input.as_ptr() as *const u8,
+            count,
+        ))
+    }
+}
+
+fn as_u16_box(input: &[u8]) -> Box<[u16]> {
+    let count = input.len() / 2;
+    let mut bx = vec![0u16; count];
+    bx.copy_from_slice(unsafe { core::slice::from_raw_parts(input.as_ptr().cast(), count) });
+    bx.into_boxed_slice()
+}
+
+pub(crate) struct Clipboard {
+    _private: PhantomData<()>,
+}
+
+impl Clipboard {
+    pub fn new(hwnd: HWND) -> windows::core::Result<Self> {
+        unsafe {
+            OpenClipboard(Some(hwnd))?;
+        }
+        Ok(Self {
+            _private: PhantomData,
+        })
+    }
+
+    fn get_raw(&self, format: CLIPBOARD_FORMAT) -> windows::core::Result<GlobalLockGuard<u8>> {
+        let hcb = unsafe { GetClipboardData(format.0.into()) }?;
+        let hmem = HGLOBAL(hcb.0);
+
+        Ok(GlobalLockGuard::lock(hmem)?)
+    }
+
+    #[allow(dead_code)]
+    pub fn get(&self, format: CLIPBOARD_FORMAT) -> windows::core::Result<Box<[u8]>> {
+        let hmem_lock = self.get_raw(format)?;
+        Ok(hmem_lock.get().to_vec().into_boxed_slice())
+    }
+
+    /// Null-terminated.
+    pub fn get_wide_z(&self) -> windows::core::Result<Box<[u16]>> {
+        let hmem_lock = self.get_raw(CF_UNICODETEXT)?;
+        Ok(as_u16_box(hmem_lock.get()))
+    }
+
+    pub fn set(&self, format: CLIPBOARD_FORMAT, data: &[u8]) -> windows::core::Result<()> {
+        // ownership transferred to the system
+        let hmem = unsafe { GlobalAlloc(GMEM_MOVEABLE, data.len())? };
+        {
+            let mut hmem_lock = GlobalLockGuard::lock(hmem)?;
+            hmem_lock.get_mut().copy_from_slice(data);
+        }
+        unsafe { SetClipboardData(format.0.into(), Some(HANDLE(hmem.0))) }?;
+        Ok(())
+    }
+
+    /// Null-terminated.
+    pub fn set_wide_z(&self, data_z: &[u16]) -> windows::core::Result<()> {
+        self.set(CF_UNICODETEXT, as_u8_slice(data_z)?)
+    }
+}
+
+impl Drop for Clipboard {
+    fn drop(&mut self) {
+        unsafe {
+            let _ = CloseClipboard();
+        }
+    }
+}

xen-win-clipboard/src/global_lock.rs

@@ -0,0 +1,47 @@
+use windows::Win32::{
+    Foundation::HGLOBAL,
+    System::Memory::{GlobalLock, GlobalSize, GlobalUnlock},
+};
+
+pub(crate) struct GlobalLockGuard<'a, T>
+where
+    T: windows::core::Param<HGLOBAL> + Copy,
+{
+    hmem: T,
+    data: &'a mut [u8],
+}
+
+impl<'a, T> GlobalLockGuard<'a, T>
+where
+    T: windows::core::Param<HGLOBAL> + Copy,
+{
+    pub fn lock(hmem: T) -> windows::core::Result<Self> {
+        let p = unsafe { GlobalLock(hmem) } as *mut u8;
+        if p.is_null() {
+            return Err(windows::core::Error::from_win32());
+        }
+        let len = unsafe { GlobalSize(hmem) };
+        assert!(len > 0);
+        let data = unsafe { core::slice::from_raw_parts_mut(p, len) };
+        Ok(Self { hmem, data })
+    }
+
+    pub fn get(&self) -> &[u8] {
+        return self.data;
+    }
+
+    pub fn get_mut(&mut self) -> &mut [u8] {
+        return self.data;
+    }
+}
+
+impl<'a, T> Drop for GlobalLockGuard<'a, T>
+where
+    T: windows::core::Param<HGLOBAL> + Copy,
+{
+    fn drop(&mut self) {
+        unsafe {
+            let _ = GlobalUnlock(self.hmem);
+        }
+    }
+}