+use lightning::ln::peer_handler::PeerDetails as nativePeerDetailsImport;
+pub(crate) type nativePeerDetails = nativePeerDetailsImport;
+
+/// Details of a connected peer as returned by [`PeerManager::list_peers`].
+#[must_use]
+#[repr(C)]
+pub struct PeerDetails {
+ /// A pointer to the opaque Rust object.
+
+ /// Nearly everywhere, inner must be non-null, however in places where
+ /// the Rust equivalent takes an Option, it may be set to null to indicate None.
+ pub inner: *mut nativePeerDetails,
+ /// Indicates that this is the only struct which contains the same pointer.
+
+ /// Rust functions which take ownership of an object provided via an argument require
+ /// this to be true and invalidate the object pointed to by inner.
+ pub is_owned: bool,
+}
+
+impl core::ops::Deref for PeerDetails {
+ type Target = nativePeerDetails;
+ fn deref(&self) -> &Self::Target { unsafe { &*ObjOps::untweak_ptr(self.inner) } }
+}
+unsafe impl core::marker::Send for PeerDetails { }
+unsafe impl core::marker::Sync for PeerDetails { }
+impl Drop for PeerDetails {
+ fn drop(&mut self) {
+ if self.is_owned && !<*mut nativePeerDetails>::is_null(self.inner) {
+ let _ = unsafe { Box::from_raw(ObjOps::untweak_ptr(self.inner)) };
+ }
+ }
+}
+/// Frees any resources used by the PeerDetails, if is_owned is set and inner is non-NULL.
+#[no_mangle]
+pub extern "C" fn PeerDetails_free(this_obj: PeerDetails) { }
+#[allow(unused)]
+/// Used only if an object of this type is returned as a trait impl by a method
+pub(crate) extern "C" fn PeerDetails_free_void(this_ptr: *mut c_void) {
+ let _ = unsafe { Box::from_raw(this_ptr as *mut nativePeerDetails) };
+}
+#[allow(unused)]
+impl PeerDetails {
+ pub(crate) fn get_native_ref(&self) -> &'static nativePeerDetails {
+ unsafe { &*ObjOps::untweak_ptr(self.inner) }
+ }
+ pub(crate) fn get_native_mut_ref(&self) -> &'static mut nativePeerDetails {
+ unsafe { &mut *ObjOps::untweak_ptr(self.inner) }
+ }
+ /// When moving out of the pointer, we have to ensure we aren't a reference, this makes that easy
+ pub(crate) fn take_inner(mut self) -> *mut nativePeerDetails {
+ assert!(self.is_owned);
+ let ret = ObjOps::untweak_ptr(self.inner);
+ self.inner = core::ptr::null_mut();
+ ret
+ }
+ pub(crate) fn as_ref_to(&self) -> Self {
+ Self { inner: self.inner, is_owned: false }
+ }
+}
+/// The node id of the peer.
+///
+/// For outbound connections, this [`PublicKey`] will be the same as the `their_node_id` parameter
+/// passed in to [`PeerManager::new_outbound_connection`].
+#[no_mangle]
+pub extern "C" fn PeerDetails_get_counterparty_node_id(this_ptr: &PeerDetails) -> crate::c_types::PublicKey {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().counterparty_node_id;
+ crate::c_types::PublicKey::from_rust(&inner_val)
+}
+/// The node id of the peer.
+///
+/// For outbound connections, this [`PublicKey`] will be the same as the `their_node_id` parameter
+/// passed in to [`PeerManager::new_outbound_connection`].
+#[no_mangle]
+pub extern "C" fn PeerDetails_set_counterparty_node_id(this_ptr: &mut PeerDetails, mut val: crate::c_types::PublicKey) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.counterparty_node_id = val.into_rust();
+}
+/// The socket address the peer provided in the initial handshake.
+///
+/// Will only be `Some` if an address had been previously provided to
+/// [`PeerManager::new_outbound_connection`] or [`PeerManager::new_inbound_connection`].
+///
+/// Returns a copy of the field.
+#[no_mangle]
+pub extern "C" fn PeerDetails_get_socket_address(this_ptr: &PeerDetails) -> crate::c_types::derived::COption_SocketAddressZ {
+ let mut inner_val = this_ptr.get_native_mut_ref().socket_address.clone();
+ let mut local_inner_val = if inner_val.is_none() { crate::c_types::derived::COption_SocketAddressZ::None } else { crate::c_types::derived::COption_SocketAddressZ::Some( { crate::lightning::ln::msgs::SocketAddress::native_into(inner_val.unwrap()) }) };
+ local_inner_val
+}
+/// The socket address the peer provided in the initial handshake.
+///
+/// Will only be `Some` if an address had been previously provided to
+/// [`PeerManager::new_outbound_connection`] or [`PeerManager::new_inbound_connection`].
+#[no_mangle]
+pub extern "C" fn PeerDetails_set_socket_address(this_ptr: &mut PeerDetails, mut val: crate::c_types::derived::COption_SocketAddressZ) {
+ let mut local_val = { /*val*/ let val_opt = val; if val_opt.is_none() { None } else { Some({ { { val_opt.take() }.into_native() }})} };
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.socket_address = local_val;
+}
+/// The features the peer provided in the initial handshake.
+#[no_mangle]
+pub extern "C" fn PeerDetails_get_init_features(this_ptr: &PeerDetails) -> crate::lightning_types::features::InitFeatures {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().init_features;
+ crate::lightning_types::features::InitFeatures { inner: unsafe { ObjOps::nonnull_ptr_to_inner((inner_val as *const lightning_types::features::InitFeatures<>) as *mut _) }, is_owned: false }
+}
+/// The features the peer provided in the initial handshake.
+#[no_mangle]
+pub extern "C" fn PeerDetails_set_init_features(this_ptr: &mut PeerDetails, mut val: crate::lightning_types::features::InitFeatures) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.init_features = *unsafe { Box::from_raw(val.take_inner()) };
+}
+/// Indicates the direction of the peer connection.
+///
+/// Will be `true` for inbound connections, and `false` for outbound connections.
+#[no_mangle]
+pub extern "C" fn PeerDetails_get_is_inbound_connection(this_ptr: &PeerDetails) -> bool {
+ let mut inner_val = &mut this_ptr.get_native_mut_ref().is_inbound_connection;
+ *inner_val
+}
+/// Indicates the direction of the peer connection.
+///
+/// Will be `true` for inbound connections, and `false` for outbound connections.
+#[no_mangle]
+pub extern "C" fn PeerDetails_set_is_inbound_connection(this_ptr: &mut PeerDetails, mut val: bool) {
+ unsafe { &mut *ObjOps::untweak_ptr(this_ptr.inner) }.is_inbound_connection = val;
+}
+/// Constructs a new PeerDetails given each field
+#[must_use]
+#[no_mangle]
+pub extern "C" fn PeerDetails_new(mut counterparty_node_id_arg: crate::c_types::PublicKey, mut socket_address_arg: crate::c_types::derived::COption_SocketAddressZ, mut init_features_arg: crate::lightning_types::features::InitFeatures, mut is_inbound_connection_arg: bool) -> PeerDetails {
+ let mut local_socket_address_arg = { /*socket_address_arg*/ let socket_address_arg_opt = socket_address_arg; if socket_address_arg_opt.is_none() { None } else { Some({ { { socket_address_arg_opt.take() }.into_native() }})} };
+ PeerDetails { inner: ObjOps::heap_alloc(nativePeerDetails {
+ counterparty_node_id: counterparty_node_id_arg.into_rust(),
+ socket_address: local_socket_address_arg,
+ init_features: *unsafe { Box::from_raw(init_features_arg.take_inner()) },
+ is_inbound_connection: is_inbound_connection_arg,
+ }), is_owned: true }
+}
+
projects / ldk-c-bindings / blobdiff