#![allow(clippy::not_unsafe_ptr_arg_deref)]
use std::cell::RefCell;
use std::ffi::{c_char, c_void, CStr, CString};
use std::net::SocketAddr;
use std::os::raw::c_int;
use std::sync::Arc;
use tokio::runtime::Runtime;
use tokio::sync::Mutex;
use tokio::task::AbortHandle;
use crate::network_utils::{Network, Node, NodePublicKey, PartyId, VerifiedOrdering};
use crate::transports::quic::{ConnectionState, PeerConnection, QuicNetworkManager, QuicNode};
pub const STOFFELNET_OK: c_int = 0;
pub const STOFFELNET_ERR_NULL_POINTER: c_int = -1;
pub const STOFFELNET_ERR_INVALID_ADDRESS: c_int = -2;
pub const STOFFELNET_ERR_CONNECTION: c_int = -3;
pub const STOFFELNET_ERR_SEND: c_int = -4;
pub const STOFFELNET_ERR_RECEIVE: c_int = -5;
pub const STOFFELNET_ERR_TIMEOUT: c_int = -6;
pub const STOFFELNET_ERR_PARTY_NOT_FOUND: c_int = -7;
pub const STOFFELNET_ERR_RUNTIME: c_int = -8;
pub const STOFFELNET_ERR_INVALID_UTF8: c_int = -9;
pub const STOFFELNET_ERR_CANCELLED: c_int = -10;
pub const STOFFELNET_ERR_CONSENSUS: c_int = -11;
pub const STOFFELNET_STATE_CONNECTED: c_int = 0;
pub const STOFFELNET_STATE_CLOSING: c_int = 1;
pub const STOFFELNET_STATE_CLOSED: c_int = 2;
pub const STOFFELNET_STATE_DISCONNECTED: c_int = 3;
thread_local! {
static LAST_ERROR: RefCell<Option<CString>> = const { RefCell::new(None) };
}
fn set_last_error(err: impl ToString) {
LAST_ERROR.with(|e| {
let msg = CString::new(err.to_string())
.unwrap_or_else(|_| CString::new("Unknown error (invalid UTF-8)").unwrap());
*e.borrow_mut() = Some(msg);
});
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_last_error() -> *const c_char {
LAST_ERROR.with(|e| {
e.borrow()
.as_ref()
.map(|s| s.as_ptr())
.unwrap_or(std::ptr::null())
})
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_clear_error() {
LAST_ERROR.with(|e| {
*e.borrow_mut() = None;
});
}
pub struct RuntimeHandle {
runtime: Runtime,
}
impl RuntimeHandle {
pub fn new() -> Result<Self, String> {
let _ = rustls::crypto::ring::default_provider().install_default();
let runtime =
Runtime::new().map_err(|e| format!("Failed to create tokio runtime: {}", e))?;
Ok(Self { runtime })
}
pub fn block_on<F: std::future::Future>(&self, future: F) -> F::Output {
self.runtime.block_on(future)
}
pub fn spawn<F>(&self, future: F) -> AbortHandle
where
F: std::future::Future + Send + 'static,
F::Output: Send + 'static,
{
self.runtime.spawn(future).abort_handle()
}
}
pub struct NetworkManagerHandle {
manager: Arc<Mutex<QuicNetworkManager>>,
runtime: Arc<RuntimeHandle>,
}
pub struct PeerConnectionHandle {
connection: Arc<dyn PeerConnection>,
}
pub struct AsyncOperationHandle {
abort_handle: AbortHandle,
}
pub struct NodeHandle {
node: QuicNode,
}
pub struct VerifiedOrderingHandle {
ordering: VerifiedOrdering,
}
pub type StoffelRuntimeHandle = *mut c_void;
pub type StoffelNetworkManagerHandle = *mut c_void;
pub type StoffelPeerConnectionHandle = *mut c_void;
pub type StoffelAsyncOperationHandle = *mut c_void;
pub type StoffelNodeHandle = *mut c_void;
pub type StoffelVerifiedOrderingHandle = *mut c_void;
pub type StoffelConnectCallback = Option<extern "C" fn(result: c_int, user_data: *mut c_void)>;
pub type StoffelReceiveCallback =
Option<extern "C" fn(result: c_int, data: *const u8, len: usize, user_data: *mut c_void)>;
pub type StoffelSendCallback = Option<extern "C" fn(result: c_int, user_data: *mut c_void)>;
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_runtime_new() -> StoffelRuntimeHandle {
match RuntimeHandle::new() {
Ok(handle) => Box::into_raw(Box::new(handle)) as StoffelRuntimeHandle,
Err(e) => {
set_last_error(e);
std::ptr::null_mut()
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_runtime_destroy(runtime: StoffelRuntimeHandle) {
if !runtime.is_null() {
unsafe {
let _ = Box::from_raw(runtime as *mut RuntimeHandle);
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_node_new(address: *const c_char, party_id: u64) -> StoffelNodeHandle {
if address.is_null() {
set_last_error("Null address pointer");
return std::ptr::null_mut();
}
let c_str = unsafe { CStr::from_ptr(address) };
let address_str = match c_str.to_str() {
Ok(s) => s,
Err(_) => {
set_last_error("Invalid UTF-8 in address");
return std::ptr::null_mut();
}
};
let socket_addr: SocketAddr = match address_str.parse() {
Ok(addr) => addr,
Err(e) => {
set_last_error(format!("Invalid address format: {}", e));
return std::ptr::null_mut();
}
};
let node = QuicNode::from_party_id(party_id as PartyId, socket_addr);
Box::into_raw(Box::new(NodeHandle { node })) as StoffelNodeHandle
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_node_new_random_id(address: *const c_char) -> StoffelNodeHandle {
if address.is_null() {
set_last_error("Null address pointer");
return std::ptr::null_mut();
}
let c_str = unsafe { CStr::from_ptr(address) };
let address_str = match c_str.to_str() {
Ok(s) => s,
Err(_) => {
set_last_error("Invalid UTF-8 in address");
return std::ptr::null_mut();
}
};
let socket_addr: SocketAddr = match address_str.parse() {
Ok(addr) => addr,
Err(e) => {
set_last_error(format!("Invalid address format: {}", e));
return std::ptr::null_mut();
}
};
let node = QuicNode::new_with_random_id(socket_addr);
Box::into_raw(Box::new(NodeHandle { node })) as StoffelNodeHandle
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_node_destroy(node: StoffelNodeHandle) {
if !node.is_null() {
unsafe {
let _ = Box::from_raw(node as *mut NodeHandle);
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_node_address(node: StoffelNodeHandle) -> *mut c_char {
if node.is_null() {
set_last_error("Null node handle");
return std::ptr::null_mut();
}
let handle = unsafe { &*(node as *const NodeHandle) };
let address_str = handle.node.address().to_string();
match CString::new(address_str) {
Ok(c_string) => c_string.into_raw(),
Err(_) => {
set_last_error("Failed to create C string");
std::ptr::null_mut()
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_node_party_id(node: StoffelNodeHandle) -> u64 {
if node.is_null() {
set_last_error("Null node handle");
return 0;
}
let handle = unsafe { &*(node as *const NodeHandle) };
handle.node.id() as u64
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_new(
runtime: StoffelRuntimeHandle,
bind_address: *const c_char,
party_id: u64,
) -> StoffelNetworkManagerHandle {
if runtime.is_null() {
set_last_error("Null runtime handle");
return std::ptr::null_mut();
}
if bind_address.is_null() {
set_last_error("Null bind address");
return std::ptr::null_mut();
}
let runtime_handle = unsafe { &*(runtime as *const RuntimeHandle) };
let c_str = unsafe { CStr::from_ptr(bind_address) };
let address_str = match c_str.to_str() {
Ok(s) => s,
Err(_) => {
set_last_error("Invalid UTF-8 in bind address");
return std::ptr::null_mut();
}
};
let socket_addr: SocketAddr = match address_str.parse() {
Ok(addr) => addr,
Err(e) => {
set_last_error(format!("Invalid bind address format: {}", e));
return std::ptr::null_mut();
}
};
let mut manager = QuicNetworkManager::with_node_id(party_id as PartyId);
let result = runtime_handle.block_on(async {
use crate::transports::quic::NetworkManager;
manager.listen(socket_addr).await
});
if let Err(e) = result {
set_last_error(format!("Failed to start listening: {}", e));
return std::ptr::null_mut();
}
let runtime_arc = unsafe {
Arc::from_raw(runtime as *const RuntimeHandle)
};
let runtime_arc_clone = Arc::clone(&runtime_arc);
std::mem::forget(runtime_arc);
let handle = NetworkManagerHandle {
manager: Arc::new(Mutex::new(manager)),
runtime: runtime_arc_clone,
};
Box::into_raw(Box::new(handle)) as StoffelNetworkManagerHandle
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_destroy(manager: StoffelNetworkManagerHandle) {
if !manager.is_null() {
unsafe {
let _ = Box::from_raw(manager as *mut NetworkManagerHandle);
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_add_node(
manager: StoffelNetworkManagerHandle,
address: *const c_char,
party_id: u64,
) -> c_int {
if manager.is_null() {
set_last_error("Null manager handle");
return STOFFELNET_ERR_NULL_POINTER;
}
if address.is_null() {
set_last_error("Null address");
return STOFFELNET_ERR_NULL_POINTER;
}
let handle = unsafe { &*(manager as *const NetworkManagerHandle) };
let c_str = unsafe { CStr::from_ptr(address) };
let address_str = match c_str.to_str() {
Ok(s) => s,
Err(_) => {
set_last_error("Invalid UTF-8 in address");
return STOFFELNET_ERR_INVALID_UTF8;
}
};
let socket_addr: SocketAddr = match address_str.parse() {
Ok(addr) => addr,
Err(e) => {
set_last_error(format!("Invalid address format: {}", e));
return STOFFELNET_ERR_INVALID_ADDRESS;
}
};
handle.runtime.block_on(async {
let mut manager = handle.manager.lock().await;
manager.add_node_with_party_id(party_id as PartyId, socket_addr);
});
STOFFELNET_OK
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_add_allowed_certificate_public_key(
manager: StoffelNetworkManagerHandle,
key: *const u8,
key_len: usize,
) -> c_int {
if manager.is_null() {
set_last_error("Null manager handle");
return STOFFELNET_ERR_NULL_POINTER;
}
if key.is_null() || key_len == 0 {
set_last_error("Null or empty certificate public key");
return STOFFELNET_ERR_NULL_POINTER;
}
let key_bytes = unsafe { std::slice::from_raw_parts(key, key_len).to_vec() };
let handle = unsafe { &*(manager as *const NetworkManagerHandle) };
handle.runtime.block_on(async {
let mut manager = handle.manager.lock().await;
manager.add_allowed_certificate_public_key(NodePublicKey(key_bytes));
});
STOFFELNET_OK
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_clear_allowed_certificate_public_keys(
manager: StoffelNetworkManagerHandle,
) -> c_int {
if manager.is_null() {
set_last_error("Null manager handle");
return STOFFELNET_ERR_NULL_POINTER;
}
let handle = unsafe { &*(manager as *const NetworkManagerHandle) };
handle.runtime.block_on(async {
let mut manager = handle.manager.lock().await;
manager.clear_allowed_certificate_public_keys();
});
STOFFELNET_OK
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_connect_to_party(
manager: StoffelNetworkManagerHandle,
party_id: u64,
) -> c_int {
if manager.is_null() {
set_last_error("Null manager handle");
return STOFFELNET_ERR_NULL_POINTER;
}
let handle = unsafe { &*(manager as *const NetworkManagerHandle) };
let result = handle.runtime.block_on(async {
let mut manager = handle.manager.lock().await;
let node_addr = manager
.parties()
.iter()
.find(|n| n.id() == party_id as PartyId)
.map(|n| n.address());
match node_addr {
Some(addr) => manager.connect_as_server(addr).await,
None => Err(format!("Party {} not found", party_id)),
}
});
match result {
Ok(_) => STOFFELNET_OK,
Err(e) => {
set_last_error(e);
STOFFELNET_ERR_CONNECTION
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_connect_to_party_async(
manager: StoffelNetworkManagerHandle,
party_id: u64,
callback: StoffelConnectCallback,
user_data: *mut c_void,
) -> StoffelAsyncOperationHandle {
if manager.is_null() {
set_last_error("Null manager handle");
return std::ptr::null_mut();
}
let handle = unsafe { &*(manager as *const NetworkManagerHandle) };
let manager_arc = Arc::clone(&handle.manager);
let user_data = user_data as usize;
let abort_handle = handle.runtime.spawn(async move {
let result = {
let mut manager = manager_arc.lock().await;
let node_addr = manager
.parties()
.iter()
.find(|n| n.id() == party_id as PartyId)
.map(|n| n.address());
match node_addr {
Some(addr) => manager.connect_as_server(addr).await,
None => Err(format!("Party {} not found", party_id)),
}
};
if let Some(cb) = callback {
let code = match result {
Ok(_) => STOFFELNET_OK,
Err(e) => {
set_last_error(e);
STOFFELNET_ERR_CONNECTION
}
};
cb(code, user_data as *mut c_void);
}
});
Box::into_raw(Box::new(AsyncOperationHandle { abort_handle })) as StoffelAsyncOperationHandle
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_accept_connection(
manager: StoffelNetworkManagerHandle,
out_party_id: *mut u64,
) -> c_int {
if manager.is_null() {
set_last_error("Null manager handle");
return STOFFELNET_ERR_NULL_POINTER;
}
if out_party_id.is_null() {
set_last_error("Null out_party_id pointer");
return STOFFELNET_ERR_NULL_POINTER;
}
let handle = unsafe { &*(manager as *const NetworkManagerHandle) };
let result = handle.runtime.block_on(async {
use crate::transports::quic::NetworkManager;
let mut manager = handle.manager.lock().await;
manager.accept().await
});
match result {
Ok(conn) => {
let _remote_addr = conn.remote_address();
unsafe {
*out_party_id = 0;
}
STOFFELNET_OK
}
Err(e) => {
set_last_error(e);
STOFFELNET_ERR_CONNECTION
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_get_connection(
manager: StoffelNetworkManagerHandle,
party_id: u64,
) -> StoffelPeerConnectionHandle {
if manager.is_null() {
set_last_error("Null manager handle");
return std::ptr::null_mut();
}
let handle = unsafe { &*(manager as *const NetworkManagerHandle) };
let conn = handle.runtime.block_on(async {
let manager = handle.manager.lock().await;
manager.get_connection(party_id as PartyId).await
});
match conn {
Some(connection) => {
let conn_handle = PeerConnectionHandle { connection };
Box::into_raw(Box::new(conn_handle)) as StoffelPeerConnectionHandle
}
None => {
set_last_error(format!("No connection to party {}", party_id));
std::ptr::null_mut()
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_is_party_connected(
manager: StoffelNetworkManagerHandle,
party_id: u64,
) -> c_int {
if manager.is_null() {
return 0;
}
let handle = unsafe { &*(manager as *const NetworkManagerHandle) };
let is_connected = handle.runtime.block_on(async {
let manager = handle.manager.lock().await;
manager.is_party_connected(party_id as PartyId).await
});
if is_connected {
1
} else {
0
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_connection_send(
conn: StoffelPeerConnectionHandle,
runtime: StoffelRuntimeHandle,
data: *const u8,
data_len: usize,
) -> c_int {
if conn.is_null() {
set_last_error("Null connection handle");
return STOFFELNET_ERR_NULL_POINTER;
}
if runtime.is_null() {
set_last_error("Null runtime handle");
return STOFFELNET_ERR_NULL_POINTER;
}
if data.is_null() && data_len > 0 {
set_last_error("Null data pointer with non-zero length");
return STOFFELNET_ERR_NULL_POINTER;
}
let conn_handle = unsafe { &*(conn as *const PeerConnectionHandle) };
let runtime_handle = unsafe { &*(runtime as *const RuntimeHandle) };
let bytes = if data_len > 0 {
unsafe { std::slice::from_raw_parts(data, data_len) }
} else {
&[]
};
let result = runtime_handle.block_on(async { conn_handle.connection.send(bytes).await });
match result {
Ok(_) => STOFFELNET_OK,
Err(e) => {
set_last_error(e);
STOFFELNET_ERR_SEND
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_connection_receive(
conn: StoffelPeerConnectionHandle,
runtime: StoffelRuntimeHandle,
out_data: *mut *mut u8,
out_len: *mut usize,
) -> c_int {
if conn.is_null() {
set_last_error("Null connection handle");
return STOFFELNET_ERR_NULL_POINTER;
}
if runtime.is_null() {
set_last_error("Null runtime handle");
return STOFFELNET_ERR_NULL_POINTER;
}
if out_data.is_null() || out_len.is_null() {
set_last_error("Null output pointer");
return STOFFELNET_ERR_NULL_POINTER;
}
let conn_handle = unsafe { &*(conn as *const PeerConnectionHandle) };
let runtime_handle = unsafe { &*(runtime as *const RuntimeHandle) };
let result = runtime_handle.block_on(async { conn_handle.connection.receive().await });
match result {
Ok(data) => {
let len = data.len();
let ptr = if len > 0 {
let mut boxed = data.into_boxed_slice();
let ptr = boxed.as_mut_ptr();
std::mem::forget(boxed);
ptr
} else {
std::ptr::null_mut()
};
unsafe {
*out_data = ptr;
*out_len = len;
}
STOFFELNET_OK
}
Err(e) => {
set_last_error(e);
unsafe {
*out_data = std::ptr::null_mut();
*out_len = 0;
}
STOFFELNET_ERR_RECEIVE
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_connection_send_async(
conn: StoffelPeerConnectionHandle,
runtime: StoffelRuntimeHandle,
data: *const u8,
data_len: usize,
callback: StoffelSendCallback,
user_data: *mut c_void,
) -> StoffelAsyncOperationHandle {
if conn.is_null() || runtime.is_null() {
set_last_error("Null handle");
return std::ptr::null_mut();
}
if data.is_null() && data_len > 0 {
set_last_error("Null data pointer with non-zero length");
return std::ptr::null_mut();
}
let conn_handle = unsafe { &*(conn as *const PeerConnectionHandle) };
let runtime_handle = unsafe { &*(runtime as *const RuntimeHandle) };
let owned_data = if data_len > 0 {
unsafe { std::slice::from_raw_parts(data, data_len).to_vec() }
} else {
Vec::new()
};
let connection = Arc::clone(&conn_handle.connection);
let user_data = user_data as usize;
let abort_handle = runtime_handle.spawn(async move {
let result = connection.send(&owned_data).await;
if let Some(cb) = callback {
let code = match result {
Ok(_) => STOFFELNET_OK,
Err(e) => {
set_last_error(e);
STOFFELNET_ERR_SEND
}
};
cb(code, user_data as *mut c_void);
}
});
Box::into_raw(Box::new(AsyncOperationHandle { abort_handle })) as StoffelAsyncOperationHandle
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_connection_receive_async(
conn: StoffelPeerConnectionHandle,
runtime: StoffelRuntimeHandle,
callback: StoffelReceiveCallback,
user_data: *mut c_void,
) -> StoffelAsyncOperationHandle {
if conn.is_null() || runtime.is_null() {
set_last_error("Null handle");
return std::ptr::null_mut();
}
let conn_handle = unsafe { &*(conn as *const PeerConnectionHandle) };
let runtime_handle = unsafe { &*(runtime as *const RuntimeHandle) };
let connection = Arc::clone(&conn_handle.connection);
let user_data = user_data as usize;
let abort_handle = runtime_handle.spawn(async move {
let result = connection.receive().await;
if let Some(cb) = callback {
match result {
Ok(data) => {
cb(
STOFFELNET_OK,
data.as_ptr(),
data.len(),
user_data as *mut c_void,
);
}
Err(e) => {
set_last_error(e);
cb(
STOFFELNET_ERR_RECEIVE,
std::ptr::null(),
0,
user_data as *mut c_void,
);
}
}
}
});
Box::into_raw(Box::new(AsyncOperationHandle { abort_handle })) as StoffelAsyncOperationHandle
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_async_cancel(op: StoffelAsyncOperationHandle) -> c_int {
if op.is_null() {
return STOFFELNET_OK; }
let handle = unsafe { Box::from_raw(op as *mut AsyncOperationHandle) };
handle.abort_handle.abort();
STOFFELNET_OK
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_connection_state(
conn: StoffelPeerConnectionHandle,
runtime: StoffelRuntimeHandle,
) -> c_int {
if conn.is_null() || runtime.is_null() {
return -1;
}
let conn_handle = unsafe { &*(conn as *const PeerConnectionHandle) };
let runtime_handle = unsafe { &*(runtime as *const RuntimeHandle) };
let state = runtime_handle.block_on(async { conn_handle.connection.state().await });
match state {
ConnectionState::Connected => STOFFELNET_STATE_CONNECTED,
ConnectionState::Closing => STOFFELNET_STATE_CLOSING,
ConnectionState::Closed => STOFFELNET_STATE_CLOSED,
ConnectionState::Disconnected => STOFFELNET_STATE_DISCONNECTED,
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_connection_is_connected(
conn: StoffelPeerConnectionHandle,
runtime: StoffelRuntimeHandle,
) -> c_int {
if conn.is_null() || runtime.is_null() {
return 0;
}
let conn_handle = unsafe { &*(conn as *const PeerConnectionHandle) };
let runtime_handle = unsafe { &*(runtime as *const RuntimeHandle) };
let is_connected =
runtime_handle.block_on(async { conn_handle.connection.is_connected().await });
if is_connected {
1
} else {
0
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_connection_close(
conn: StoffelPeerConnectionHandle,
runtime: StoffelRuntimeHandle,
) {
if conn.is_null() || runtime.is_null() {
return;
}
let conn_handle = unsafe { &*(conn as *const PeerConnectionHandle) };
let runtime_handle = unsafe { &*(runtime as *const RuntimeHandle) };
let _ = runtime_handle.block_on(async { conn_handle.connection.close().await });
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_connection_destroy(conn: StoffelPeerConnectionHandle) {
if !conn.is_null() {
unsafe {
let _ = Box::from_raw(conn as *mut PeerConnectionHandle);
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_free_bytes(data: *mut u8, len: usize) {
if !data.is_null() && len > 0 {
unsafe {
let _ = Vec::from_raw_parts(data, len, len);
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_free_string(str: *mut c_char) {
if !str.is_null() {
unsafe {
let _ = CString::from_raw(str);
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_set_expected_parties(
manager: StoffelNetworkManagerHandle,
count: usize,
) -> c_int {
if manager.is_null() {
set_last_error("Null manager handle");
return STOFFELNET_ERR_NULL_POINTER;
}
let handle = unsafe { &*(manager as *const NetworkManagerHandle) };
handle.runtime.block_on(async {
let mut mgr = handle.manager.lock().await;
mgr.set_expected_parties(count);
});
STOFFELNET_OK
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_set_expected_clients(
manager: StoffelNetworkManagerHandle,
count: usize,
) -> c_int {
if manager.is_null() {
set_last_error("Null manager handle");
return STOFFELNET_ERR_NULL_POINTER;
}
let handle = unsafe { &*(manager as *const NetworkManagerHandle) };
handle.runtime.block_on(async {
let mut mgr = handle.manager.lock().await;
mgr.set_expected_clients(count);
});
STOFFELNET_OK
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_manager_get_verified_ordering(
manager: StoffelNetworkManagerHandle,
) -> StoffelVerifiedOrderingHandle {
if manager.is_null() {
set_last_error("Null manager handle");
return std::ptr::null_mut();
}
let handle = unsafe { &*(manager as *const NetworkManagerHandle) };
let ordering = handle.runtime.block_on(async {
let mgr = handle.manager.lock().await;
mgr.verified_ordering()
});
match ordering {
Some(o) => Box::into_raw(Box::new(VerifiedOrderingHandle { ordering: o }))
as StoffelVerifiedOrderingHandle,
None => std::ptr::null_mut(),
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_ordering_node_count(ordering: StoffelVerifiedOrderingHandle) -> usize {
if ordering.is_null() {
set_last_error("Null ordering handle");
return 0;
}
let handle = unsafe { &*(ordering as *const VerifiedOrderingHandle) };
handle.ordering.node_count()
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_ordering_client_count(
ordering: StoffelVerifiedOrderingHandle,
) -> usize {
if ordering.is_null() {
set_last_error("Null ordering handle");
return 0;
}
let handle = unsafe { &*(ordering as *const VerifiedOrderingHandle) };
handle.ordering.client_count()
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_ordering_node_key(
ordering: StoffelVerifiedOrderingHandle,
party_id: usize,
out_key: *mut *mut u8,
out_len: *mut usize,
) -> c_int {
if ordering.is_null() || out_key.is_null() || out_len.is_null() {
set_last_error("Null pointer argument");
return STOFFELNET_ERR_NULL_POINTER;
}
let handle = unsafe { &*(ordering as *const VerifiedOrderingHandle) };
match handle.ordering.node_key(party_id) {
Some(pk) => {
let mut bytes = pk.0.clone();
let len = bytes.len();
let ptr = bytes.as_mut_ptr();
std::mem::forget(bytes);
unsafe {
*out_key = ptr;
*out_len = len;
}
STOFFELNET_OK
}
None => {
set_last_error(format!("Party ID {} not found in ordering", party_id));
STOFFELNET_ERR_PARTY_NOT_FOUND
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_ordering_client_key(
ordering: StoffelVerifiedOrderingHandle,
client_id: usize,
out_key: *mut *mut u8,
out_len: *mut usize,
) -> c_int {
if ordering.is_null() || out_key.is_null() || out_len.is_null() {
set_last_error("Null pointer argument");
return STOFFELNET_ERR_NULL_POINTER;
}
let handle = unsafe { &*(ordering as *const VerifiedOrderingHandle) };
match handle.ordering.client_key(client_id) {
Some(pk) => {
let mut bytes = pk.0.clone();
let len = bytes.len();
let ptr = bytes.as_mut_ptr();
std::mem::forget(bytes);
unsafe {
*out_key = ptr;
*out_len = len;
}
STOFFELNET_OK
}
None => {
set_last_error(format!("Client ID {} not found in ordering", client_id));
STOFFELNET_ERR_PARTY_NOT_FOUND
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_ordering_destroy(ordering: StoffelVerifiedOrderingHandle) {
if !ordering.is_null() {
unsafe {
let _ = Box::from_raw(ordering as *mut VerifiedOrderingHandle);
}
}
}
#[unsafe(no_mangle)]
pub extern "C" fn stoffelnet_verify_node_ordering(
conn_handles: *const StoffelPeerConnectionHandle,
count: usize,
runtime: StoffelRuntimeHandle,
) -> StoffelVerifiedOrderingHandle {
if conn_handles.is_null() || runtime.is_null() {
set_last_error("Null pointer argument");
return std::ptr::null_mut();
}
if count == 0 {
set_last_error("No connections provided");
return std::ptr::null_mut();
}
let rt = unsafe { &*(runtime as *const RuntimeHandle) };
let connections: Vec<Arc<dyn PeerConnection>> = (0..count)
.map(|i| {
let handle_ptr = unsafe { *conn_handles.add(i) };
let handle = unsafe { &*(handle_ptr as *const PeerConnectionHandle) };
Arc::clone(&handle.connection)
})
.collect();
match rt.block_on(QuicNetworkManager::verify_node_ordering(&connections)) {
Ok(ordering) => Box::into_raw(Box::new(VerifiedOrderingHandle { ordering }))
as StoffelVerifiedOrderingHandle,
Err(e) => {
set_last_error(format!("Consensus verification failed: {}", e));
std::ptr::null_mut()
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_error_handling() {
set_last_error("Test error");
let error = stoffelnet_last_error();
assert!(!error.is_null());
let c_str = unsafe { CStr::from_ptr(error) };
assert_eq!(c_str.to_str().unwrap(), "Test error");
stoffelnet_clear_error();
let error = stoffelnet_last_error();
assert!(error.is_null());
}
#[test]
fn test_runtime_lifecycle() {
let runtime = stoffelnet_runtime_new();
assert!(!runtime.is_null());
stoffelnet_runtime_destroy(runtime);
}
#[test]
fn test_node_lifecycle() {
let addr = CString::new("127.0.0.1:9000").unwrap();
let node = stoffelnet_node_new(addr.as_ptr(), 42);
assert!(!node.is_null());
let party_id = stoffelnet_node_party_id(node);
assert_eq!(party_id, 42);
let address = stoffelnet_node_address(node);
assert!(!address.is_null());
stoffelnet_free_string(address);
stoffelnet_node_destroy(node);
}
#[test]
fn test_node_random_id() {
let addr = CString::new("127.0.0.1:9001").unwrap();
let node = stoffelnet_node_new_random_id(addr.as_ptr());
assert!(!node.is_null());
let party_id = stoffelnet_node_party_id(node);
assert!(party_id > 0);
stoffelnet_node_destroy(node);
}
#[test]
fn test_null_handling() {
assert_eq!(
stoffelnet_manager_add_node(std::ptr::null_mut(), std::ptr::null(), 0),
STOFFELNET_ERR_NULL_POINTER
);
assert_eq!(
stoffelnet_manager_connect_to_party(std::ptr::null_mut(), 0),
STOFFELNET_ERR_NULL_POINTER
);
assert!(stoffelnet_manager_get_connection(std::ptr::null_mut(), 0).is_null());
assert_eq!(
stoffelnet_manager_is_party_connected(std::ptr::null_mut(), 0),
0
);
stoffelnet_runtime_destroy(std::ptr::null_mut()); stoffelnet_manager_destroy(std::ptr::null_mut()); stoffelnet_node_destroy(std::ptr::null_mut()); stoffelnet_connection_destroy(std::ptr::null_mut()); }
#[test]
fn test_send_null_conn() {
let result = stoffelnet_connection_send(
std::ptr::null_mut(),
std::ptr::null_mut(),
std::ptr::null(),
0,
);
assert_eq!(result, STOFFELNET_ERR_NULL_POINTER);
let error = stoffelnet_last_error();
assert!(!error.is_null());
let error_str = unsafe { CStr::from_ptr(error) }.to_str().unwrap();
assert!(
error_str.contains("Null connection handle"),
"Expected 'Null connection handle', got: {}",
error_str
);
stoffelnet_clear_error();
}
#[test]
fn test_receive_null_conn() {
let mut out_data: *mut u8 = std::ptr::null_mut();
let mut out_len: usize = 0;
let result = stoffelnet_connection_receive(
std::ptr::null_mut(),
std::ptr::null_mut(),
&mut out_data as *mut *mut u8,
&mut out_len as *mut usize,
);
assert_eq!(result, STOFFELNET_ERR_NULL_POINTER);
let error = stoffelnet_last_error();
assert!(!error.is_null());
let error_str = unsafe { CStr::from_ptr(error) }.to_str().unwrap();
assert!(
error_str.contains("Null connection handle"),
"Expected 'Null connection handle', got: {}",
error_str
);
stoffelnet_clear_error();
}
#[test]
fn test_manager_new_null_runtime() {
let addr = CString::new("127.0.0.1:9000").unwrap();
let manager = stoffelnet_manager_new(std::ptr::null_mut(), addr.as_ptr(), 1);
assert!(manager.is_null());
let error = stoffelnet_last_error();
assert!(!error.is_null());
let error_str = unsafe { CStr::from_ptr(error) }.to_str().unwrap();
assert!(
error_str.contains("Null runtime handle"),
"Expected error to contain 'Null runtime handle', got: {}",
error_str
);
stoffelnet_clear_error();
}
#[test]
fn test_manager_new_null_address() {
let runtime = stoffelnet_runtime_new();
assert!(!runtime.is_null());
let manager = stoffelnet_manager_new(runtime, std::ptr::null(), 1);
assert!(manager.is_null());
let error = stoffelnet_last_error();
assert!(!error.is_null());
let error_str = unsafe { CStr::from_ptr(error) }.to_str().unwrap();
assert!(
error_str.contains("Null bind address"),
"Expected error to contain 'Null bind address', got: {}",
error_str
);
stoffelnet_clear_error();
stoffelnet_runtime_destroy(runtime);
}
#[test]
fn test_node_new_null_address() {
let node = stoffelnet_node_new(std::ptr::null(), 1);
assert!(node.is_null());
}
#[test]
fn test_node_new_invalid_address() {
let addr = CString::new("not-a-valid-address").unwrap();
let node = stoffelnet_node_new(addr.as_ptr(), 1);
assert!(node.is_null());
let error = stoffelnet_last_error();
assert!(!error.is_null());
let error_str = unsafe { CStr::from_ptr(error) }.to_str().unwrap();
assert!(
error_str.contains("Invalid address"),
"Expected error to contain 'Invalid address', got: {}",
error_str
);
stoffelnet_clear_error();
}
#[test]
fn test_node_address_null_handle() {
let address = stoffelnet_node_address(std::ptr::null_mut());
assert!(address.is_null());
}
#[test]
fn test_node_party_id_null_handle() {
let party_id = stoffelnet_node_party_id(std::ptr::null_mut());
assert_eq!(party_id, 0);
}
#[test]
fn test_free_bytes_null() {
stoffelnet_free_bytes(std::ptr::null_mut(), 0);
}
#[test]
fn test_free_string_null() {
stoffelnet_free_string(std::ptr::null_mut());
}
#[test]
fn test_error_persistence() {
set_last_error("first");
let error = stoffelnet_last_error();
assert!(!error.is_null());
let error_str = unsafe { CStr::from_ptr(error) }.to_str().unwrap();
assert_eq!(error_str, "first");
let _ = stoffelnet_node_party_id(std::ptr::null_mut());
let error = stoffelnet_last_error();
assert!(!error.is_null());
let error_str = unsafe { CStr::from_ptr(error) }.to_str().unwrap();
assert_eq!(error_str, "Null node handle");
stoffelnet_clear_error();
}
#[test]
fn test_multiple_runtime_lifecycle() {
let rt1 = stoffelnet_runtime_new();
let rt2 = stoffelnet_runtime_new();
let rt3 = stoffelnet_runtime_new();
assert!(!rt1.is_null());
assert!(!rt2.is_null());
assert!(!rt3.is_null());
stoffelnet_runtime_destroy(rt1);
stoffelnet_runtime_destroy(rt2);
stoffelnet_runtime_destroy(rt3);
}
#[test]
fn test_consensus_error_code_constant() {
assert_eq!(STOFFELNET_ERR_CONSENSUS, -11);
}
#[test]
fn test_ordering_null_checks() {
assert_eq!(stoffelnet_ordering_node_count(std::ptr::null_mut()), 0);
assert_eq!(stoffelnet_ordering_client_count(std::ptr::null_mut()), 0);
let mut key: *mut u8 = std::ptr::null_mut();
let mut len: usize = 0;
assert_eq!(
stoffelnet_ordering_node_key(std::ptr::null_mut(), 0, &mut key, &mut len),
STOFFELNET_ERR_NULL_POINTER
);
assert_eq!(
stoffelnet_ordering_client_key(std::ptr::null_mut(), 0, &mut key, &mut len),
STOFFELNET_ERR_NULL_POINTER
);
stoffelnet_ordering_destroy(std::ptr::null_mut());
}
#[test]
fn test_ordering_lifecycle() {
use crate::network_utils::NodePublicKey;
let ordering = VerifiedOrdering::new(
vec![NodePublicKey(vec![1, 2, 3]), NodePublicKey(vec![4, 5, 6])],
vec![NodePublicKey(vec![7, 8, 9])],
);
let handle = Box::into_raw(Box::new(VerifiedOrderingHandle { ordering }))
as StoffelVerifiedOrderingHandle;
assert_eq!(stoffelnet_ordering_node_count(handle), 2);
assert_eq!(stoffelnet_ordering_client_count(handle), 1);
let mut key: *mut u8 = std::ptr::null_mut();
let mut len: usize = 0;
let result = stoffelnet_ordering_node_key(handle, 0, &mut key, &mut len);
assert_eq!(result, STOFFELNET_OK);
assert_eq!(len, 3);
let bytes = unsafe { Vec::from_raw_parts(key, len, len) };
assert_eq!(bytes, vec![1, 2, 3]);
let mut key: *mut u8 = std::ptr::null_mut();
let mut len: usize = 0;
let result = stoffelnet_ordering_client_key(handle, 0, &mut key, &mut len);
assert_eq!(result, STOFFELNET_OK);
assert_eq!(len, 3);
let bytes = unsafe { Vec::from_raw_parts(key, len, len) };
assert_eq!(bytes, vec![7, 8, 9]);
let mut key: *mut u8 = std::ptr::null_mut();
let mut len: usize = 0;
let result = stoffelnet_ordering_node_key(handle, 99, &mut key, &mut len);
assert_eq!(result, STOFFELNET_ERR_PARTY_NOT_FOUND);
stoffelnet_ordering_destroy(handle);
}
#[test]
fn test_set_expected_parties_null() {
assert_eq!(
stoffelnet_manager_set_expected_parties(std::ptr::null_mut(), 3),
STOFFELNET_ERR_NULL_POINTER
);
}
#[test]
fn test_set_expected_clients_null() {
assert_eq!(
stoffelnet_manager_set_expected_clients(std::ptr::null_mut(), 2),
STOFFELNET_ERR_NULL_POINTER
);
}
#[test]
fn test_get_verified_ordering_null() {
let result = stoffelnet_manager_get_verified_ordering(std::ptr::null_mut());
assert!(result.is_null());
}
#[test]
fn test_verify_node_ordering_null() {
let result = stoffelnet_verify_node_ordering(std::ptr::null(), 1, std::ptr::null_mut());
assert!(result.is_null());
}
}