Fix #20

Author: OpenByteDev

Cargo.toml

@@ -15,7 +15,7 @@ keywords = ["nethost", "hostfxr", "dotnet", "bindings", "coreclr"]
 num_enum = { version = "0.7", default-features = false }
 thiserror = { version = "2.0", default-features = false }
 derive_more = { version = "2.0", features = ["deref", "from", "display"], default-features = false }
-hostfxr-sys = { version = "0.11.1", features = ["enum-map", "undocumented", "wrapper", "optional-apis"], default-features = false }
+hostfxr-sys = { version = "0.12", features = ["enum-map", "undocumented", "wrapper", "optional-apis"], default-features = false }
 coreclr-hosting-shared = { version = "0.1", default-features = false }
 destruct-drop = { version = "0.2", default-features = false }
 ffi-opaque = { version = "2.0", default-features = false }

src/hostfxr/library3_0.rs

@@ -1,3 +1,5 @@
+use widestring::U16CStr;
+
 use crate::{
     bindings::hostfxr::{hostfxr_handle, hostfxr_initialize_parameters},
     error::{HostingError, HostingResult, HostingSuccess},
@@ -395,4 +397,50 @@ impl Hostfxr {
             )
         })
     }
+
+    /// Sets a callback which is to be used to write errors to.
+    ///
+    /// # Arguments
+    ///  * `error_writer`
+    ///    A callback function which will be invoked every time an error is to be reported.
+    ///    Or [`None`] to unregister previously registered callbacks and return to the default behavior.
+    ///
+    /// # Remarks
+    /// The error writer is registered per-thread, so the registration is thread-local. On each thread
+    /// only one callback can be registered. Subsequent registrations overwrite the previous ones.
+    ///
+    /// By default no callback is registered in which case the errors are written to stderr.
+    ///
+    /// Each call to the error writer is sort of like writing a single line (the EOL character is omitted).
+    /// Multiple calls to the error writer may occure for one failure.
+    ///
+    /// If the hostfxr invokes functions in hostpolicy as part of its operation, the error writer
+    /// will be propagated to hostpolicy for the duration of the call. This means that errors from
+    /// both hostfxr and hostpolicy will be reporter through the same error writer.
+    #[cfg_attr(feature = "doc-cfg", doc(cfg(feature = "netcore3_0")))]
+    pub fn set_error_writer(&self, error_writer: Option<ErrorWriter>) {
+        let new_raw_error_writer = error_writer
+            .as_ref()
+            .map(|_| error_writer_trampoline as hostfxr_sys::hostfxr_error_writer_fn);
+        unsafe { self.lib.hostfxr_set_error_writer(new_raw_error_writer) };
+
+        CURRENT_ERROR_WRITER.with(|current_writer| {
+            *current_writer.borrow_mut() = error_writer;
+        });
+    }
+}
+
+type ErrorWriter = Box<dyn FnMut(&U16CStr)>;
+
+thread_local! {
+    static CURRENT_ERROR_WRITER: std::cell::RefCell<Option<ErrorWriter>> = std::cell::RefCell::new(None);
+}
+
+extern "C" fn error_writer_trampoline(raw_error: *const u16) {
+    CURRENT_ERROR_WRITER.with(|writer_holder| {
+        if let Some(writer) = writer_holder.borrow_mut().as_mut() {
+            let error_message = unsafe { U16CStr::from_ptr_str(raw_error) };
+            writer(error_message);
+        }
+    });
 }

tests/error_writer.rs

@@ -0,0 +1,56 @@
+#![allow(deprecated)]
+
+use netcorehost::{hostfxr::Hostfxr, nethost, pdcstr};
+use rusty_fork::rusty_fork_test;
+use std::cell::Cell;
+
+#[path = "common.rs"]
+mod common;
+
+fn cause_error(hostfxr: &Hostfxr) {
+    let bad_path = pdcstr!("bad.runtimeconfig.json");
+    let _ = hostfxr.initialize_for_runtime_config(bad_path);
+}
+
+rusty_fork_test! {
+    #[test]
+    #[cfg(feature = "netcore3_0")]
+    fn gets_called() {
+        common::setup();
+
+        let hostfxr = nethost::load_hostfxr().unwrap();
+        let was_called = Box::leak(Box::new(Cell::new(false)));
+        hostfxr.set_error_writer(Some(Box::new(
+            |_| { was_called.set(true); }
+        )));
+        cause_error(&hostfxr);
+
+        assert!(was_called.get());
+    }
+
+    #[test]
+    #[cfg(feature = "netcore3_0")]
+    fn can_be_replaced() {
+        common::setup();
+
+        let hostfxr = nethost::load_hostfxr().unwrap();
+
+        let counter = Box::leak(Box::new(Cell::new(0)));
+        hostfxr.set_error_writer(Some(Box::new(
+            |_| { counter.set(counter.get() + 1); }
+        )));
+        cause_error(&hostfxr);
+        hostfxr.set_error_writer(Some(Box::new(
+            |_| { }
+        )));
+        cause_error(&hostfxr);
+        hostfxr.set_error_writer(Some(Box::new(
+            |_| { counter.set(counter.get() + 1); }
+        )));
+        cause_error(&hostfxr);
+        hostfxr.set_error_writer(None);
+        cause_error(&hostfxr);
+
+        assert_eq!(counter.get(), 2);
+    }
+}