Free strings on management

waku-bindings/src/node/management.rs

@@ -12,69 +12,103 @@ use crate::general::{JsonResponse, PeerId, Result};
 /// as per the [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_newchar-jsonconfig)
 pub fn waku_new(config: Option<WakuNodeConfig>) -> Result<bool> {
     let config = config.unwrap_or_default();
-    let s_config = serde_json::to_string(&config)
-        .expect("Serialization from properly built NodeConfig should never fail");
-    let result: &str = unsafe {
-        CStr::from_ptr(waku_sys::waku_new(
-            CString::new(s_config)
-                .expect("CString should build properly from the serialized node config")
-                .into_raw(),
-        ))
-    }
-    .to_str()
-    .expect("Response should always succeed to load to a &str");
+
+    let config_ptr = CString::new(
+        serde_json::to_string(&config)
+            .expect("Serialization from properly built NodeConfig should never fail"),
+    )
+    .expect("CString should build properly from the config")
+    .into_raw();
+
+    let result_ptr = unsafe {
+        let res = waku_sys::waku_new(config_ptr);
+        drop(CString::from_raw(config_ptr));
+        res
+    };
+
+    let result = unsafe { CStr::from_ptr(result_ptr) }
+        .to_str()
+        .expect("Response should always succeed to load to a &str");
+
     let json_response: JsonResponse<bool> =
         serde_json::from_str(result).expect("JsonResponse should always succeed to deserialize");
+
+    unsafe {
+        waku_sys::waku_utils_free(result_ptr);
+    }
+
     json_response.into()
 }
 
 /// Start a Waku node mounting all the protocols that were enabled during the Waku node instantiation.
 /// as per the [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_start)
 pub fn waku_start() -> Result<bool> {
-    let response = unsafe { CStr::from_ptr(waku_sys::waku_start()) }
+    let response_ptr = unsafe { waku_sys::waku_start() };
+    let response = unsafe { CStr::from_ptr(response_ptr) }
         .to_str()
         .expect("Response should always succeed to load to a &str");
 
     let json_response: JsonResponse<bool> =
         serde_json::from_str(response).expect("JsonResponse should always succeed to deserialize");
+
+    unsafe {
+        waku_sys::waku_utils_free(response_ptr);
+    }
+
     json_response.into()
 }
 
 /// Stops a Waku node
 /// as per the [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_stop)
 pub fn waku_stop() -> Result<bool> {
-    let response = unsafe { CStr::from_ptr(waku_sys::waku_stop()) }
+    let response_ptr = unsafe { waku_sys::waku_start() };
+    let response = unsafe { CStr::from_ptr(response_ptr) }
         .to_str()
         .expect("Response should always succeed to load to a &str");
 
     let json_response: JsonResponse<bool> =
         serde_json::from_str(response).expect("JsonResponse should always succeed to deserialize");
+
+    unsafe {
+        waku_sys::waku_utils_free(response_ptr);
+    }
+
     json_response.into()
 }
 
 /// If the execution is successful, the result is the peer ID as a string (base58 encoded)
 /// as per the [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_stop)
 pub fn waku_peer_id() -> Result<PeerId> {
-    let response = unsafe { CStr::from_ptr(waku_sys::waku_peerid()) }
+    let response_ptr = unsafe { waku_sys::waku_start() };
+    let response = unsafe { CStr::from_ptr(response_ptr) }
         .to_str()
         .expect("Response should always succeed to load to a &str");
 
     let json_response: JsonResponse<String> =
         serde_json::from_str(response).expect("JsonResponse should always succeed to deserialize");
 
+    unsafe {
+        waku_sys::waku_utils_free(response_ptr);
+    }
+
     json_response.into()
 }
 
 /// Get the multiaddresses the Waku node is listening to
 /// as per [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_listen_addresses)
 pub fn waku_listen_addresses() -> Result<Vec<Multiaddr>> {
-    let response = unsafe { CStr::from_ptr(waku_sys::waku_listen_addresses()) }
+    let response_ptr = unsafe { waku_sys::waku_start() };
+    let response = unsafe { CStr::from_ptr(response_ptr) }
         .to_str()
         .expect("Response should always succeed to load to a &str");
 
     let json_response: JsonResponse<Vec<Multiaddr>> =
         serde_json::from_str(response).expect("JsonResponse should always succeed to deserialize");
 
+    unsafe {
+        waku_sys::waku_utils_free(response_ptr);
+    }
+
     json_response.into()
 }