update: FFI PeerManager create/dispose methods

Author: joemphilips

bindings/src/adaptors/mod.rs

@@ -1,24 +1,44 @@
-use std::ffi::{CString};
-use std::sync::Arc;
+use std::{
+    io::Error,
+    ffi::{CString},
+    hash::{Hasher, Hash},
+    sync::Arc
+};
 
 use bitcoin_hashes::sha256d::Hash as Sha256dHash;
-use bitcoin::blockdata::transaction::Transaction;
-use bitcoin::blockdata::script::Script;
-use bitcoin::blockdata::block::Block;
-use bitcoin::consensus::serialize as bitcoin_serialize;
+use bitcoin::{
+    blockdata::transaction::Transaction,
+    blockdata::script::Script,
+    blockdata::block::Block,
+    consensus::serialize as bitcoin_serialize
+};
 
-use lightning::util::logger::{Logger, Record, Level};
-
-use lightning::chain::chaininterface::{BroadcasterInterface,FeeEstimator,ConfirmationTarget, ChainWatchInterface, ChainError};
-use lightning::chain::keysinterface::{InMemoryChannelKeys};
-use lightning::chain::transaction::{OutPoint};
-
-use lightning::ln::channelmonitor::{ManyChannelMonitor, ChannelMonitor, HTLCUpdate, ChannelMonitorUpdateErr, ChannelMonitorUpdate};
+use lightning::{
+    chain::transaction::{OutPoint},
+    chain::keysinterface::{InMemoryChannelKeys},
+    chain::chaininterface::{BroadcasterInterface, FeeEstimator, ConfirmationTarget, ChainWatchInterface, ChainError},
+    util::logger::{Logger, Record, Level},
+    ln::channelmonitor::{ManyChannelMonitor, ChannelMonitor, HTLCUpdate, ChannelMonitorUpdateErr, ChannelMonitorUpdate},
+    util::ser::{Writeable, Writer},
+    ln::peer_handler::SocketDescriptor,
+    ln::msgs::ErrorAction
+};
 
 pub mod primitives;
 use primitives::*;
-use lightning::util::ser::{Writeable, Writer};
-use std::io::Error;
+use std::convert::TryFrom;
+use lightning::ln::msgs::{ErrorMessage, RoutingMessageHandler, HTLCFailChannelUpdate, ChannelAnnouncement, NodeAnnouncement, LightningError, ChannelUpdate};
+use std::ffi::CStr;
+use std::ptr::NonNull;
+
+type cstr = NonNull<i8>;
+
+#[derive(PartialOrd, PartialEq, Eq, Ord, Debug, Copy, Clone)]
+#[repr(u8)]
+pub enum Bool { False = 0, True = 1 }
+impl Bool {
+    pub fn to_bool(&self) -> bool { *self == Bool::True }
+}
 
 pub mod broadcaster_fn {
     use crate::adaptors::primitives::FFITransaction;
@@ -135,11 +155,11 @@ pub struct FFILogRecord {
 	/// The verbosity level of the message.
 	pub level: FFILogLevel,
 	/// The message body.
-	pub args: *const i8,
+	pub args: cstr,
 	/// The module path of the message.
-	pub module_path: *const i8,
+	pub module_path: cstr,
 	/// The source file containing the message.
-	pub file: *const i8,
+	pub file: cstr,
 	/// The line containing the message.
 	pub line: u32,
 }
@@ -162,9 +182,9 @@ impl Logger for FFILogger {
         let ffi_record =
             FFILogRecord {
                 level: rec.level.into(),
-                args: args.as_ptr(),
-                module_path: module_path.as_ptr(),
-                file: file.as_ptr(),
+                args: NonNull::new(args.as_ptr() as *mut _).unwrap(),
+                module_path: NonNull::new(module_path.as_ptr() as *mut _).unwrap(),
+                file: NonNull::new(file.as_ptr() as *mut _).unwrap(),
                 line: rec.line,
             };
         (self.log_ptr)(&ffi_record as *const _);
@@ -226,3 +246,211 @@ impl ChainWatchInterface for FFIChainWatchInterface {
     }
 }
 
+pub mod socket_descriptor_fn {
+    use super::FFIBytes;
+    pub type SendData = extern "cdecl" fn (data: *const FFIBytes, resume_read: u8) -> usize;
+    pub type DisconnectSocket = extern "cdecl" fn ();
+}
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct FFISocketDescriptor {
+    pub index: usize,
+    pub send_data_ptr: socket_descriptor_fn::SendData,
+    pub disconnect_socket_ptr: socket_descriptor_fn::DisconnectSocket,
+}
+
+impl PartialEq for FFISocketDescriptor {
+    fn eq(&self, other: &Self) -> bool {
+        self.index == other.index
+    }
+}
+impl Eq for FFISocketDescriptor {}
+impl Hash for FFISocketDescriptor {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.index.hash(state)
+    }
+}
+
+impl SocketDescriptor for FFISocketDescriptor {
+    fn send_data(&mut self, data: &[u8], resume_read: bool) -> usize {
+        let r: FFIBytes = data.into();
+        (self.send_data_ptr)(&r as *const _, resume_read as u8)
+    }
+
+    fn disconnect_socket(&mut self) {
+        (self.disconnect_socket_ptr)()
+    }
+}
+
+#[repr(u8)]
+#[derive(Debug,Clone)]
+pub enum FFIErrorActionType {
+    DisconnectPeer = 0u8,
+    /// The peer did something harmless that we weren't able to process, just log and ignore
+    IgnoreError,
+    /// The peer did something incorrect. Tell them.
+    SendErrorMessage,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone)]
+pub struct FFIErrorMsg {
+    pub channel_id: [u8; 32],
+    pub data: cstr,
+}
+
+impl From<FFIErrorMsg> for ErrorMessage {
+    fn from(msg: FFIErrorMsg) -> Self {
+        let data = unsafe_block!("We know pointer is non-null" => CStr::from_ptr(msg.data.as_ptr()) );
+        ErrorMessage {
+            data: data.to_str().unwrap().to_owned(),
+            channel_id: msg.channel_id
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Clone)]
+pub struct FFIErrorAction {
+    ty: FFIErrorActionType,
+    payload: Option<*const FFIErrorMsg>
+}
+
+impl From<FFIErrorAction> for ErrorAction {
+    fn from(x: FFIErrorAction) -> Self {
+        match x.ty {
+            FFIErrorActionType::DisconnectPeer => {
+                ErrorAction::DisconnectPeer {
+                    msg: x.payload.map(|msg| {
+                        From::from(unsafe_block!("`from` conversion consumes x" => (*msg).clone()))
+                    })
+                }
+            },
+            FFIErrorActionType::IgnoreError => {
+                ErrorAction::IgnoreError
+            },
+            FFIErrorActionType::SendErrorMessage => {
+                match x.payload {
+                    None => panic!(format!("Inconsistent enum {:?}", x)),
+                    Some(msg) => {
+                        let msg = unsafe_block!("`from` conversion consumes x" => (*msg).clone()).into();
+                        ErrorAction::SendErrorMessage { msg }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+#[repr(C)]
+pub struct FFILightningError {
+    /// A human-readable message describing the error
+    pub err: cstr,
+    /// The action which should be taken against the offending peer.
+    pub action: FFIErrorAction,
+}
+
+impl From<FFILightningError> for LightningError {
+    fn from(v: FFILightningError) -> Self {
+        let err = unsafe_block!("We know error msg is non-null c string" => CStr::from_ptr(v.err.as_ptr()) );
+        LightningError {
+            err: err.to_str().unwrap(),
+            action: v.action.into()
+        }
+    }
+}
+
+pub mod routing_msg_descriptor_fn {
+    use super::*;
+    use crate::adaptors::primitives::PublicKey;
+    use lightning::ln::msgs::{NodeAnnouncement, LightningError, ChannelAnnouncement, ChannelUpdate, HTLCFailChannelUpdate};
+
+    /// Handle an incoming node_announcement message, returning true if it should be forwarded on,
+    /// false or returning an Err otherwise.
+    pub type HandleNodeAnnouncement = extern "cdecl" fn (msg: *const FFIBytes, error: *mut FFILightningError) -> Bool;
+    /// Handle a channel_announcement message, returning true if it should be forwarded on, false
+    /// or returning an Err otherwise.
+    pub type HandleChannelAnnouncement = extern "cdecl" fn (msg: *const FFIBytes, error: *mut FFILightningError) -> Bool;
+    /// Handle an incoming channel_update message, returning true if it should be forwarded on,
+    /// false or returning an Err otherwise.
+    pub type HandleChannelUpdate = extern "cdecl" fn (msg: *const FFIBytes, error: *mut FFILightningError) -> Bool;
+    /// Handle some updates to the route graph that we learned due to an outbound failed payment.
+    pub type HandleHTLCFailChannelUpdate = extern "cdecl" fn (update: *const FFIBytes);
+    /// Gets a subset of the channel announcements and updates required to dump our routing table
+    /// to a remote node, starting at the short_channel_id indicated by starting_point and
+    /// including the batch_amount entries immediately higher in numerical value than starting_point.
+    /// Return type is serialized `Vec<(ChannelAnnouncement, ChannelUpdate, ChannelUpdate)>`
+    pub type GetNextChannelAnnouncements = extern "cdecl" fn (starting_point: u64, batch_amount: u8) -> FFIBytes<'static>;
+    /// Gets a subset of the node announcements required to dump our routing table to a remote node,
+    /// starting at the node *after* the provided publickey and including batch_amount entries
+    /// immediately higher (as defined by <PublicKey as Ord>::cmp) than starting_point.
+    /// If None is provided for starting_point, we start at the first node.
+    /// Return type is binary serialized `Vec<NodeAnnouncement>` .
+    pub type GetNextNodeAnnouncements = extern "cdecl" fn (starting_point: Option<*const PublicKey>, batch_amount: u8) -> FFIBytes<'static>;
+    /// Returns whether a full sync should be requested from a peer.
+    pub type ShouldRequestFullSync = extern "cdecl" fn (node_id: NonNull<PublicKey>) -> Bool;
+}
+
+pub struct FFIRoutingMsgHandler {
+    pub handle_node_announcement_ptr: routing_msg_descriptor_fn::HandleNodeAnnouncement,
+    pub handle_channel_announcement_ptr: routing_msg_descriptor_fn::HandleChannelAnnouncement,
+    pub handle_channel_update_ptr: routing_msg_descriptor_fn::HandleChannelUpdate,
+    pub handle_htlc_fail_channel_update_ptr: routing_msg_descriptor_fn::HandleHTLCFailChannelUpdate,
+    pub get_next_channel_announcements_ptr: routing_msg_descriptor_fn::GetNextChannelAnnouncements,
+    pub get_next_node_announcements_ptr: routing_msg_descriptor_fn::GetNextNodeAnnouncements,
+    pub should_request_full_sync_ptr: routing_msg_descriptor_fn::ShouldRequestFullSync
+}
+
+pub struct VecWriter(pub Vec<u8>);
+impl Writer for VecWriter {
+    fn write_all(&mut self, buf: &[u8]) -> Result<(), Error> {
+        self.0.extend_from_slice(buf);
+        Ok(())
+    }
+
+    fn size_hint(&mut self, size: usize) {
+        self.0.reserve_exact(size)
+    }
+}
+
+impl RoutingMessageHandler for FFIRoutingMsgHandler {
+    fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<bool, LightningError> {
+        let mut w = VecWriter(Vec::new());
+        msg.write(&mut w);
+        let bytes = FFIBytes::from(w.0.into_boxed_slice());
+        let e = std::ptr::null_mut();
+        let is_success = (self.handle_node_announcement_ptr)(&bytes as *const _, e);
+        if e.is_null() {
+            Ok(is_success.to_bool())
+        } else {
+            let e = unsafe_block!("we know the error is not a null pointer" => (*e).clone());
+            Err(e.into())
+        }
+    }
+
+    fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result<bool, LightningError> {
+        unimplemented!()
+    }
+
+    fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<bool, LightningError> {
+        unimplemented!()
+    }
+
+    fn handle_htlc_fail_channel_update(&self, update: &HTLCFailChannelUpdate) {
+        unimplemented!()
+    }
+
+    fn get_next_channel_announcements(&self, starting_point: u64, batch_amount: u8) -> Vec<(ChannelAnnouncement, ChannelUpdate, ChannelUpdate)> {
+        unimplemented!()
+    }
+
+    fn get_next_node_announcements(&self, starting_point: Option<&secp256k1::PublicKey>, batch_amount: u8) -> Vec<NodeAnnouncement> {
+        unimplemented!()
+    }
+
+    fn should_request_full_sync(&self, node_id: &secp256k1::PublicKey) -> bool {
+        unimplemented!()
+    }
+}

bindings/src/adaptors/primitives.rs

@@ -65,9 +65,17 @@ macro_rules! array_struct{
 #[doc="The length must be [the same as a byte number of secp256k1 secret key](secp256k1::constants::SECRET_KEY_SIZE)"]
 array_struct!(SecretKey, u8);
 
+impl<'a> TryFrom<SecretKey<'a>> for secp256k1::SecretKey {
+    type Error = FFIResult;
+
+    fn try_from(value: SecretKey<'a>) -> Result<Self, Self::Error> {
+        let s = value.as_ref();
+        secp256k1::SecretKey::from_slice(s).map_err(|_| FFIResult::invalid_data_length())
+    }
+}
+
 #[doc="The length must be [the same as a byte number of secp256k1 public key] `secp256k1::constants::PUBLIC_KEY_SIZE`"]
 array_struct!(PublicKey, u8);
-
 impl<'a> TryFrom<PublicKey<'a>> for secp256k1::PublicKey {
     type Error = FFIResult;
 
@@ -166,6 +174,8 @@ array_struct!(FFITransaction, u8);
 array_struct!(FFIBlock, u8);
 array_struct!(FFIEvents, u8);
 
+/// General purpose byte array which has to cross ffi-boundary
+array_struct!(FFIBytes, u8);
 
 impl<'a> TryFrom<Vec<Event>> for FFIEvents<'a> {
     type Error = lightning::ln::msgs::DecodeError;