avoid all compiler error by using ARc

Author: joemphilips

bindings/src/channelmanager.rs

@@ -14,8 +14,8 @@ use lightning::ln::channelmonitor::{ManyChannelMonitor, ChannelMonitor, HTLCUpda
 use lightning::ln::channelmanager::{ChannelManager};
 
 use crate::error::FFIResult;
+use crate::handle::{Out, Ref, RefMut,HandleShared};
 
-/*
 #[repr(C)]
 pub struct FFIManyChannelMonitor {
     add_monitor_ptr: extern "C" fn(&Self, funding_txo: OutPoint, monitor: ChannelMonitor<InMemoryChannelKeys>) -> i32,
@@ -73,8 +73,6 @@ impl FeeEstimator for FFIFeeEstimator {
     }
 }
 
-type FFIArcChannelManager = *const ChannelManager<InMemoryChannelKeys, Arc<FFIManyChannelMonitor>, Arc<FFIBroadCaster>, Arc<KeysManager>, Arc<FFIFeeEstimator>>;
-
 #[repr(C)]
 pub enum FFINetwork {
     MainNet = 0,
@@ -103,73 +101,39 @@ impl Logger for FFILogger {
     }
 }
 
-#[repr(C)]
-pub struct NullFFILogger {
-    log_ptr: fn(&Self),
-}
-
-impl Logger for NullFFILogger {
-    fn log(&self, record: &Record) {
-        (self.log_ptr)(self)
-    }
-}
-
-
-ffi!{
-    fn create_ffi_channel_manager(seed_ptr: *const u8, seed_len: i32, network_ptr: *const FFINetwork, logger_ptr: *const FFILogger, config_ptr: *mut UserConfig, monitor: *const FFIManyChannelMonitor, broadcaster: *const FFIBroadCaster, fee_est: *const FFIFeeEstimator, cur_block_height: usize) -> FFIArcChannelManager {
-        unsafe {
-            let mut emptyArgname = None;
-            if seed_ptr.is_null() {
-                emptyArgname = Some(stringify!(seed_ptr));
-            }
-            if network_ptr.is_null() {
-                emptyArgname = Some(stringify!(network_ptr));
-            }
-            if config_ptr.is_null() {
-                emptyArgname = Some(stringify!(config_ptr));
-            }
-            if monitor.is_null() {
-                emptyArgname = Some(stringify!(monitor));
-            }
-            if broadcaster.is_null() {
-                emptyArgname = Some(stringify!(broadcaster)));
-            }
-            if fee_est.is_null() {
-                emptyArgname = Some(stringify!(fee_est));
-            }
-            if let Some(v) = emptyArgname {
-                update_last_error(FFIError::EmptyPointerProvided(v));
-                return std::ptr::null();
-            }
-            if seed_len != 32 {
-                update_last_error(FFIError::InvalidSeedLength(seed_len))
-                return std::ptr::null();
-            }
-            let network = (&(*network_ptr)).to_network();
-            let now = SystemTime::now().duration_since(UNIX_EPOCH).expect("Time went backwards");
-            let logger = Arc::from_raw(logger_ptr);
-            let seed = std::slice::from_raw_parts(seed_ptr, 32 as usize);
-            let mut s: [u8; 32] = Default::default();
-            s.copy_from_slice(&seed[0..32]);
-            let keyman = Arc::new(KeysManager::new(&s, network, logger.clone(), now.as_secs(), now.subsec_nanos()));
-            let cfg = Box::from_raw(config_ptr);
-            let chan_man: FFIArcChannelManager =
-                Box::into_raw(Box::new(ChannelManager::new(network, Arc::from_raw(fee_est), Arc::from_raw(monitor), Arc::from_raw(broadcaster), logger, keyman, *cfg, cur_block_height).unwrap()));
-            return chan_man;
-        };
-    }
-}
-
-
-#[no_mangle]
-pub extern fn release_ffi_channel_manager(ptr: *mut FFIArcChannelManager) {
-    if ptr.is_null() {
-        let err = FFIError::EmptyPointerProvided("ptr");
-        update_last_error(err);
-        return;
-    }
-    unsafe {
-        Box::from_raw(ptr);
+type FFIArcChannelManager = ChannelManager<InMemoryChannelKeys, Arc<FFIManyChannelMonitor>, Arc<FFIBroadCaster>, Arc<KeysManager>, Arc<FFIFeeEstimator>>;
+type FFIArcChannelManagerHandle<'a> = HandleShared<'a, FFIArcChannelManager>;
+
+/// We wanted to use `ffi` macro here, but Arc<dyn Logger> does not support unwind safety.
+ffi_no_catch!{
+    fn create_ffi_channel_manager(
+        seed_ptr: Ref<u8>,
+        seed_len: usize,
+        network: Ref<FFINetwork>,
+        cfg: Ref<UserConfig>,
+        monitor: Ref<FFIManyChannelMonitor>,
+        logger: Ref<FFILogger>,
+        broadcaster: Ref<FFIBroadCaster>,
+        fee_est: Ref<FFIFeeEstimator>,
+        cur_block_height: usize,
+        chan_man: Out<FFIArcChannelManagerHandle>) -> FFIResult {
+        if seed_len != 32 {
+            return FFIResult::invalid_seed_length();
+        }
+        let seed_slice = unsafe_block!("The seed lives as long as `create_ffi_channel_manager` and the length is within the seed" => seed_ptr.as_bytes(seed_len));
+        let network = unsafe_block!("We no pointer is not null by function of ffi! macro, and the lifetime will be the same of those with ChannelManager" => network.as_ref().to_network());
+        let now = SystemTime::now().duration_since(UNIX_EPOCH)?;
+        let logger = unsafe_block!("" => logger.as_arc());
+        let mut seed: [u8; 32] = Default::default();
+        seed.copy_from_slice(seed_slice);
+        let keyman = Arc::new(KeysManager::new(&seed, network, logger.clone(), now.as_secs(), now.subsec_nanos()));
+        let cfg = unsafe_block!("" => cfg.as_ref());
+        let fee_est = unsafe_block!("" => fee_est.as_arc());
+        let monitor = unsafe_block!("" => monitor.as_arc());
+        let broadcaster = unsafe_block!("" => broadcaster.as_arc());
+        let chan_man_raw: FFIArcChannelManager =
+            ChannelManager::new(network, fee_est, monitor, broadcaster, logger, keyman, (*cfg).clone(), cur_block_height)?;
+        unsafe_block!("We know chan_man is not null by wrapper macro. And we know `Out` is writable" => chan_man.init(HandleShared::alloc(chan_man_raw)));
+        FFIResult::ok()
     }
 }
-*/

bindings/src/error.rs

@@ -49,6 +49,7 @@ impl<E> From<E> for FFIResult
 }
 
 /// Allow casting standard `Result` to FFIResult
+/// In this way, we assure 
 impl Try for FFIResult {
     type Ok = Self;
     type Error = Self;
@@ -148,6 +149,8 @@ impl FFIResult {
         self.kind == Kind::InternalError
     }
 
+    /// Attempt to get a human-readable error message for a result.
+    /// If the result is successful then this method returns `None`.
     pub fn as_err(&self) -> Option<&'static str> {
         match self.kind {
             Kind::Ok => None,
@@ -158,13 +161,16 @@ impl FFIResult {
     }
 
 
+    /// Call a function that returns a `FFIResult`, setting the thread local last result.
+    /// This method will also catch panics, so the function to call must be unwind safe.
     pub(super) fn catch(f: impl FnOnce() -> Self + UnwindSafe) -> Self {
         LAST_RESULT.with(|last_result| {
             {
                 *last_result.borrow_mut() = None;
             }
 
             match catch_unwind(f) {
+                // when no panic
                 Ok(ffi_result) =>  {
                     let extract_err = || ffi_result.as_err().map(Into::into);
                     last_result
@@ -179,7 +185,7 @@ impl FFIResult {
                         })
                         .value
                 },
-
+                // when panic
                 Err(e) => {
                     let extract_panic = || extract_panic(&e).map(|s| format!("Internal panic with {}", s));
                     last_result
@@ -197,15 +203,18 @@ impl FFIResult {
         })
     }
 
+    /// Access the last result returned on the calling thread.
+    /// First argument for the closure is the last FFI result.
+    /// Second is its error message (if any).
     pub(super) fn with_last_result<R>(f: impl FnOnce(Option<(FFIResult, Option<&str>)>) -> R) -> R {
         LAST_RESULT.with(|last_result| {
             let last_result = last_result.borrow();
-            let last_result = last_result.as_ref().map(|r| {
+            let last_result_and_its_err_msg = last_result.as_ref().map(|r| {
                 let v = r.value;
                 let msg = v.as_err().and_then(|_| r.err.as_ref().map(|msg| msg.as_ref()));
                 (v, msg)
             });
-            f(last_result)
+            f(last_result_and_its_err_msg)
         })
     }
 }

bindings/src/handle/mod.rs

@@ -2,6 +2,7 @@ use std::marker::PhantomData;
 use std::panic::{RefUnwindSafe, UnwindSafe};
 use std::ptr;
 use std::slice;
+use std::sync::Arc;
 
 pub(crate) mod thread_bound;
 
@@ -115,17 +116,25 @@ unsafe_impl!("The handle is semantically `&mut T`" => impl<'a, T: ?Sized> Send f
 unsafe_impl!("The handle uses `ThreadBound` for synchronization" => impl<'a, T: ?Sized> Sync for Ref<'a, T> where &'a T: Sync {});
 
 impl<'a, T: ?Sized> Ref<'a, T> {
-    unsafe_fn!("The pointer must be nonnull and will remain valid" => pub fn as_ref(&self) -> &T {
+    unsafe_fn!("The pointer must be nonnull and will remain valid" =>
+    pub fn as_ref(&self) -> &T {
         &*self.0
-    });
+    }
+    );
+
+    unsafe_fn!("The pointer must be nonnull" => 
+    pub fn as_arc(&self) -> Arc<T> {
+        Arc::from_raw(self.0)
+    }
+    );
 }
-/*
-*/
 
 impl<'a> Ref<'a, u8> {
-    unsafe_fn!("The pointer must be nonnull, the length is correct, and will remain valid" => pub fn as_bytes(&self, len: usize) -> &[u8] {
+    unsafe_fn!("The pointer must be nonnull, the length is correct, and will remain valid" =>
+    pub fn as_bytes(&self, len: usize) -> &[u8] {
         slice::from_raw_parts(self.0, len)
-    });
+    }
+    );
 }
 
 /**
@@ -163,19 +172,25 @@ unsafe_impl!("The handle is semantically `&mut T`" => impl<'a, T: ?Sized> Send f
 unsafe_impl!("The handle uses `ThreadBound` for synchronization" => impl<'a, T: ?Sized> Sync for Out<'a, T> where &'a mut T: Sync {});
 
 impl<'a, T> Out<'a, T> {
-    unsafe_fn!("The pointer must be nonnull and valid for writes" => pub fn init(&mut self, value: T) {
+    unsafe_fn!("The pointer must be nonnull and valid for writes" =>
+    pub fn init(&mut self, value: T) {
         ptr::write(self.0, value);
-    });
+    }
+    );
 }
 
 impl<'a> Out<'a, u8> {
-    unsafe_fn!("The pointer must be nonnull, not overlap the slice, must be valid for the length of the slice, and valid for writes" => pub fn init_bytes(&mut self, value: &[u8]) {
+    unsafe_fn!("The pointer must be nonnull, not overlap the slice, must be valid for the length of the slice, and valid for writes" =>
+    pub fn init_bytes(&mut self, value: &[u8]) {
         ptr::copy_nonoverlapping(value.as_ptr(), self.0, value.len());
-    });
+    }
+    );
 
-    unsafe_fn!("The slice must never be read from and must be valid for the length of the slice" => pub fn as_uninit_bytes_mut(&mut self, len: usize) -> &mut [u8] {
+    unsafe_fn!("The slice must never be read from and must be valid for the length of the slice" =>
+    pub fn as_uninit_bytes_mut(&mut self, len: usize) -> &mut [u8] {
         slice::from_raw_parts_mut(self.0, len)
-    });
+    }
+    );
 }
 
 impl<'a, T: ?Sized> IsNull for HandleExclusive<'a, T> {