Adding support for notifications, minor bugfixes and code improvement…

…s (PR #4)

* Adding support for file system notifications
* Some code refactoring
* Fixed memory leak when projection start failed
* Adding support for search expressions

.github/workflows/rust.yml

@@ -43,9 +43,10 @@ jobs:
       - name: Build
         run: cargo build --all-targets
       - name: Test
-        run: cargo test
+        run: cargo test -- --nocapture
         env:
           RUST_LOG: trace
+          RUST_TEST_THREADS: 1
   deploy:
     runs-on: windows-latest
     needs: tests

examples/virtual-fs/src/main.rs

@@ -5,6 +5,7 @@ use std::{
         Cursor,
         Read,
     },
+    ops::ControlFlow,
     path::PathBuf,
 };
 
@@ -13,6 +14,7 @@ use windows_projfs::{
     DirectoryEntry,
     DirectoryInfo,
     FileInfo,
+    Notification,
     ProjectedFileSystem,
     ProjectedFileSystemSource,
 };
@@ -47,6 +49,18 @@ impl ProjectedFileSystemSource for VirtualProjectedSource {
 
         Ok(Box::new(Cursor::new(buffer)))
     }
+
+    fn handle_notification(&self, notification: &Notification) -> ControlFlow<()> {
+        log::debug!("Notification: {:?}", notification);
+        if notification.is_cancelable()
+            && !matches!(notification, Notification::FilePreConvertToFull(_))
+        {
+            /* Try to cancel all possible actions to make the file system read only. */
+            ControlFlow::Break(())
+        } else {
+            ControlFlow::Continue(())
+        }
+    }
 }
 
 #[derive(clap::Parser)]

windows-projfs/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "windows-projfs"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 authors = ["M. Hadenfeldt <[email protected]>"]
 description = "A rust library for the Windows projected file system API"

windows-projfs/src/callback_data.rs

@@ -0,0 +1,93 @@
+use std::{
+    ffi::OsString,
+    os::windows::ffi::OsStringExt,
+    path::PathBuf,
+};
+
+use windows::{
+    core::{
+        GUID,
+        HRESULT,
+    },
+    Win32::{
+        Foundation::STATUS_SUCCESS,
+        Storage::ProjectedFileSystem::{
+            PRJ_CALLBACK_DATA,
+            PRJ_CALLBACK_DATA_FLAGS,
+            PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT,
+        },
+    },
+};
+
+#[allow(unused)]
+pub struct CallbackData<'a, C> {
+    pub flags: PRJ_CALLBACK_DATA_FLAGS,
+
+    pub namespace_virtualization_context: PRJ_NAMESPACE_VIRTUALIZATION_CONTEXT,
+    pub command_id: i32,
+
+    pub file_id: GUID,
+    pub data_stream_id: GUID,
+
+    // Unknown how to handle (yet)
+    // pub VersionInfo: *mut PRJ_PLACEHOLDER_VERSION_INFO,
+    pub file_path: Option<PathBuf>,
+
+    pub triggering_process_id: u32,
+    pub triggering_process_image_file_name: Option<String>,
+
+    /// The projection context should be a valid reference as long
+    /// as this callback data exists.
+    pub context: &'a C,
+    // pub extended_parameters: Mutex<Option<PRJ_COMPLETE_COMMAND_EXTENDED_PARAMETERS>>,
+}
+
+impl<'a, C> CallbackData<'a, C> {
+    pub fn execute<F>(self, executor: F) -> HRESULT
+    where
+        F: FnOnce(&Self) -> Result<(), HRESULT>,
+    {
+        match executor(&self) {
+            Ok(_) => STATUS_SUCCESS.to_hresult(),
+            Err(code) => code,
+        }
+    }
+}
+
+impl<'a, C> From<*const PRJ_CALLBACK_DATA> for CallbackData<'a, C> {
+    fn from(value: *const PRJ_CALLBACK_DATA) -> Self {
+        let value = unsafe { value.as_ref() }.expect("callback data should never be null");
+        let file_path = if value.FilePathName.is_null() {
+            None
+        } else {
+            Some(PathBuf::from(OsString::from_wide(unsafe {
+                value.FilePathName.as_wide()
+            })))
+        };
+
+        let triggering_process_image_file_name = if value.TriggeringProcessImageFileName.is_null() {
+            None
+        } else {
+            Some(String::from_utf16_lossy(unsafe {
+                value.TriggeringProcessImageFileName.as_wide()
+            }))
+        };
+
+        let context = unsafe { &mut *(value.InstanceContext as *mut C) };
+        Self {
+            flags: value.Flags,
+
+            namespace_virtualization_context: value.NamespaceVirtualizationContext,
+            command_id: value.CommandId,
+
+            file_path,
+            file_id: value.FileId,
+            data_stream_id: value.DataStreamId,
+
+            triggering_process_id: value.TriggeringProcessId,
+            triggering_process_image_file_name,
+
+            context,
+        }
+    }
+}