Lock down windows-core internals (#3129)

Author: kennykerr

crates/libs/core/src/com_object.rs

@@ -165,7 +165,7 @@ impl<T: ComObjectInner> ComObject<T> {
     /// Gets a borrowed reference to an interface that is implemented by `T`.
     ///
     /// The returned reference does not have an additional reference count.
-    /// You can AddRef it by calling [`Self::to_owned`].
+    /// You can AddRef it by calling [`InterfaceRef::to_owned`].
     #[inline(always)]
     pub fn as_interface<I: Interface>(&self) -> InterfaceRef<'_, I>
     where

crates/libs/core/src/event.rs

@@ -1,4 +1,5 @@
 use super::*;
+use core::ffi::c_void;
 use core::marker::PhantomData;
 use core::mem::{size_of, transmute_copy};
 use core::ptr::null_mut;
@@ -212,7 +213,7 @@ impl<T: Interface> Drop for Array<T> {
         unsafe {
             if !self.is_empty() && (*self.buffer).0.release() == 0 {
                 core::ptr::drop_in_place(self.as_mut_slice());
-                imp::heap_free(self.buffer as _)
+                heap_free(self.buffer as _)
             }
         }
     }
@@ -230,7 +231,7 @@ impl<T: Interface> Buffer<T> {
             Ok(null_mut())
         } else {
             let alloc_size = size_of::<Self>() + len * size_of::<Delegate<T>>();
-            let header = imp::heap_alloc(alloc_size)? as *mut Self;
+            let header = heap_alloc(alloc_size)? as *mut Self;
             unsafe {
                 header.write(Self(imp::RefCount::new(1), PhantomData));
             }
@@ -285,3 +286,30 @@ impl<T: Interface> Delegate<T> {
         }
     }
 }
+
+/// Allocate memory of size `bytes` using `malloc` - the `Event` implementation does not
+/// need to use any particular allocator so `HeapAlloc` need not be used.
+fn heap_alloc(bytes: usize) -> crate::Result<*mut c_void> {
+    let ptr: *mut c_void = unsafe {
+        extern "C" {
+            fn malloc(bytes: usize) -> *mut c_void;
+        }
+
+        malloc(bytes)
+    };
+
+    if ptr.is_null() {
+        Err(Error::from_hresult(imp::E_OUTOFMEMORY))
+    } else {
+        Ok(ptr)
+    }
+}
+
+/// Free memory allocated by `heap_alloc`.
+unsafe fn heap_free(ptr: *mut c_void) {
+    extern "C" {
+        fn free(ptr: *mut c_void);
+    }
+
+    free(ptr);
+}

crates/libs/core/src/imp/bindings.rs

@@ -11,9 +11,6 @@ windows_targets::link!("kernel32.dll" "system" fn CreateEventW(lpeventattributes
 windows_targets::link!("kernel32.dll" "system" fn EncodePointer(ptr : *const core::ffi::c_void) -> *mut core::ffi::c_void);
 windows_targets::link!("kernel32.dll" "system" fn FreeLibrary(hlibmodule : HMODULE) -> BOOL);
 windows_targets::link!("kernel32.dll" "system" fn GetProcAddress(hmodule : HMODULE, lpprocname : PCSTR) -> FARPROC);
-windows_targets::link!("kernel32.dll" "system" fn GetProcessHeap() -> HANDLE);
-windows_targets::link!("kernel32.dll" "system" fn HeapAlloc(hheap : HANDLE, dwflags : HEAP_FLAGS, dwbytes : usize) -> *mut core::ffi::c_void);
-windows_targets::link!("kernel32.dll" "system" fn HeapFree(hheap : HANDLE, dwflags : HEAP_FLAGS, lpmem : *const core::ffi::c_void) -> BOOL);
 windows_targets::link!("kernel32.dll" "system" fn LoadLibraryExA(lplibfilename : PCSTR, hfile : HANDLE, dwflags : LOAD_LIBRARY_FLAGS) -> HMODULE);
 windows_targets::link!("kernel32.dll" "system" fn SetEvent(hevent : HANDLE) -> BOOL);
 windows_targets::link!("kernel32.dll" "system" fn WaitForSingleObject(hhandle : HANDLE, dwmilliseconds : u32) -> WAIT_EVENT);
@@ -337,7 +334,6 @@ impl GUID {
     }
 }
 pub type HANDLE = *mut core::ffi::c_void;
-pub type HEAP_FLAGS = u32;
 pub type HMODULE = *mut core::ffi::c_void;
 pub type HRESULT = i32;
 #[repr(C)]

crates/libs/core/src/imp/delay_load.rs

@@ -6,7 +6,6 @@ use core::mem::{forget, transmute, transmute_copy};
 use core::ptr::null_mut;
 use core::sync::atomic::{AtomicPtr, Ordering};
 
-#[doc(hidden)]
 pub struct FactoryCache<C, I> {
     shared: AtomicPtr<c_void>,
     _c: PhantomData<C>,
@@ -154,6 +153,27 @@ unsafe fn get_activation_factory(
     function(transmute_copy(name), &mut abi).and_then(|| crate::Type::from_abi(abi))
 }
 
+unsafe fn delay_load<T>(library: crate::PCSTR, function: crate::PCSTR) -> Option<T> {
+    let library = LoadLibraryExA(
+        library.0,
+        core::ptr::null_mut(),
+        LOAD_LIBRARY_SEARCH_DEFAULT_DIRS,
+    );
+
+    if library.is_null() {
+        return None;
+    }
+
+    let address = GetProcAddress(library, function.0);
+
+    if address.is_some() {
+        return Some(core::mem::transmute_copy(&address));
+    }
+
+    FreeLibrary(library);
+    None
+}
+
 type DllGetActivationFactory =
     extern "system" fn(name: *mut c_void, factory: *mut *mut c_void) -> crate::HRESULT;
 

crates/libs/core/src/imp/factory_cache.rs

@@ -1,10 +1,8 @@
 mod bindings;
 mod can_into;
 mod com_bindings;
-mod delay_load;
 mod factory_cache;
 mod generic_factory;
-mod heap;
 mod ref_count;
 mod sha1;
 mod waiter;
@@ -13,25 +11,13 @@ mod weak_ref_count;
 pub use bindings::*;
 pub use can_into::*;
 pub use com_bindings::*;
-pub use delay_load::*;
 pub use factory_cache::*;
 pub use generic_factory::*;
-pub use heap::*;
 pub use ref_count::*;
 pub use sha1::*;
 pub use waiter::*;
 pub use weak_ref_count::*;
 
-pub fn wide_trim_end(mut wide: &[u16]) -> &[u16] {
-    while let Some(last) = wide.last() {
-        match last {
-            32 | 9..=13 => wide = &wide[..wide.len() - 1],
-            _ => break,
-        }
-    }
-    wide
-}
-
 #[doc(hidden)]
 #[macro_export]
 macro_rules! interface_hierarchy {

crates/libs/core/src/imp/heap.rs

@@ -1,6 +1,5 @@
 use core::sync::atomic::{fence, AtomicI32, Ordering};
 
-#[doc(hidden)]
 #[repr(transparent)]
 #[derive(Default)]
 pub struct RefCount(pub(crate) AtomicI32);

crates/libs/core/src/imp/mod.rs

@@ -1,6 +1,5 @@
 use super::*;
 
-#[doc(hidden)]
 pub struct Waiter(HANDLE);
 pub struct WaiterSignaler(HANDLE);
 

crates/libs/core/src/imp/ref_count.rs

@@ -5,7 +5,6 @@ use core::mem::{transmute, transmute_copy};
 use core::ptr::null_mut;
 use core::sync::atomic::{AtomicIsize, Ordering};
 
-#[doc(hidden)]
 #[repr(transparent)]
 #[derive(Default)]
 pub struct WeakRefCount(AtomicIsize);