tcp entry points to try calling async lib from c

framework for "tcp" in rust called by c
implement blocking connect, c test passes

Author: ultrasaurus

mylib/Cargo.lock

@@ -9,12 +9,8 @@ edition = "2018"
 name = "mylib"
 crate-type = ["lib", "staticlib"]    
 
-
 [build-dependencies]
-cbindgen = "0.12"
-
-
+cbindgen = "0.13"
 
 [dependencies]
-
-
+tokio = { version = "0.2", features = ["full"] }

mylib/Cargo.toml

@@ -7,9 +7,11 @@ no_includes = true
 
 
 
-[export]
-prefix = "my_"
-
 [export.rename]
-"Thing_ExtThingStatus" = "thing_t"
-"StatusCallbackFunction" = "status_callback_t"
+"Thing_ExtThingStatus" = "my_thing_t"
+"StatusCallbackFunction" = "my_status_callback_t"
+
+
+
+[fn]
+sort_by = "None"

mylib/cbindgen.toml

@@ -7,18 +7,28 @@
 
 #include <stdint.h>
 
+typedef struct TcpConnection TcpConnection;
+
 typedef struct my_thing_t my_thing_t;
 
 typedef void (*my_status_callback_t)(int32_t code, void *user_data);
 
+typedef void (*TcpStatusCallback)(int32_t code, void *user_data);
+
 int32_t add(int32_t a, int32_t b);
 
 my_thing_t *create_thing(int32_t num, my_status_callback_t callback_or_null, void *userdata);
 
-void destroy_thing(my_thing_t *thing_ptr);
-
 int32_t thing_num(my_thing_t *thing_ptr);
 
 void thing_something(my_thing_t *thing_ptr);
 
+void destroy_thing(my_thing_t *thing_ptr);
+
+TcpConnection *create_tcp(TcpStatusCallback callback, void *user_data);
+
+void tcp_connect_blocking(TcpConnection *tcp_ptr);
+
+void destroy_tcp(TcpConnection *tcp_ptr);
+
 #endif /* mylib_h */

mylib/mylib.h

@@ -1,6 +1,7 @@
 mod thingc;
 mod thing;
 use thing::{Thing, StatusCallback, ThingStatus};
+mod tcp;
 
 #[no_mangle]
 pub extern "C" fn add(a: i32, b:i32) -> i32 {

mylib/src/lib.rs

@@ -0,0 +1,63 @@
+use std::ffi::c_void;
+use tokio::runtime::Runtime;
+use tokio::net::TcpStream;
+// use std::time::Duration;
+
+pub struct TcpConnection {
+  runtime: Runtime,
+  conn: Option<TcpStream>,
+  callback: TcpStatusCallback,
+  user_data: * mut c_void,
+}
+
+pub type TcpStatusCallback = extern "C" fn(code: i32, user_data: * mut c_void) -> ();
+
+impl TcpConnection {
+  pub fn trigger_callback(&self, code: i32) {
+    (self.callback)(code, self.user_data);
+  }
+}
+
+#[no_mangle]
+pub extern "C" fn create_tcp(callback: TcpStatusCallback, user_data: * mut c_void) -> * mut TcpConnection {
+  assert!(!(callback as *mut c_void).is_null());
+  let runtime = Runtime::new().unwrap();
+
+  Box::into_raw(Box::new(TcpConnection { runtime, conn: None, callback, user_data }))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn tcp_connect_blocking(tcp_ptr: *mut TcpConnection) -> () {
+  if tcp_ptr.is_null() {
+    return;   // should be an error, but just experimenting here
+  }
+  let tcp = &mut *tcp_ptr;
+
+  let mut code = -1;
+  let conn = TcpStream::connect("127.0.0.1:80");
+
+  tcp.runtime.block_on(async {
+    let result = conn.await;
+    code = match result {
+      Ok(_) => 200,
+      Err(_) => 404,
+    };
+  });
+  tcp.trigger_callback(code);
+
+}
+
+
+#[no_mangle]
+pub unsafe extern fn destroy_tcp(tcp_ptr: *mut TcpConnection) {
+    if tcp_ptr.is_null() {
+        return;
+    }
+    let _tcp = Box::from_raw(tcp_ptr);
+    // attempt to shutdown gracefully, but this API must have changed
+    // tcp.runtime.shutdown_timeout(Duration::from_millis(100));
+    //                ^^^^^^^^^^^^^^^^ method not found in `tokio::runtime::Runtime`
+    
+
+    // memory associated with `tcp` that was allocated by Rust freed on fn exit
+}

mylib/src/tcp.rs

@@ -26,33 +26,49 @@ int test_create_thing() {
   return 0;
 }
 
-int called = 0;
 typedef struct {
   int counter;
-} MyData;
+} TestThingStatusData;
 
 void status_callback(int32_t code, void *user_data) {
-  called = 1;
-  MyData* my_data = (MyData*)user_data;
+  TestThingStatusData* my_data = (TestThingStatusData*)user_data;
   my_data->counter++;
 }
 
 int test_thing_callback() {
-  MyData data = {0}; 
+  TestThingStatusData data = {0}; 
   my_thing_t* thing = create_thing(1, status_callback, &data);
   thing_something(thing);
   _assert(data.counter, 1);
   destroy_thing(thing);
   return 0;
 }
 
+typedef struct {
+  int counter;
+} TestTcpStatusData;
+
+void tcp_status_callback(int32_t code, void *user_data) {
+  TestTcpStatusData* my_data = (TestTcpStatusData*)user_data;
+  my_data->counter++;
+}
+
+int test_tcp_create_destroy() {
+  TestTcpStatusData data = {0};
+  TcpConnection* tcp = create_tcp(status_callback, &data);
+  tcp_connect_blocking(tcp);
+  _assert(data.counter, 1);
+  destroy_tcp(tcp);
+  return 0;
+}
 
 // would be good to test memory leaks
 int all_tests() {
     _verify(add_positive_numbers);
     _verify(add_negative_numbers);
     _verify(test_create_thing);
     _verify(test_thing_callback);
+    _verify(test_tcp_create_destroy);
     return 0;
 }