Add run_command_async

crates/bitwarden-c/src/c.rs

@@ -1,4 +1,8 @@
-use std::{ffi::CStr, os::raw::c_char, str};
+use std::{
+    ffi::{CStr, CString},
+    os::raw::c_char,
+    str
+};
 
 use bitwarden_json::client::Client;
 
@@ -28,6 +32,37 @@
     }
 }
 
+type OnCompletedCallback = unsafe extern "C" fn(result: *mut c_char) -> ();
+
+#[no_mangle]
+pub extern "C" fn run_command_async(
+    c_str_ptr: *const c_char,
+    client_ptr: *const CClient,
+    on_completed_callback: OnCompletedCallback,
+) -> () {
+    let client = unsafe { ffi_ref!(client_ptr) };
+    let input_str = str::from_utf8(unsafe { CStr::from_ptr(c_str_ptr) }.to_bytes())
+        .expect("Input should be a valid string")
+        // Languages may assume that the string is collectable as soon as this method exits
+        // but it's not since the request will be run in the background
+        // so we need to make our own copy.
+        .to_owned();
+
+    client.runtime.spawn(async move {
+        let result = client.client.run_command(input_str.as_str()).await;
+        let str_result = match std::ffi::CString::new(result) {
+            Ok(cstr) => cstr.into_raw(),
+            Err(_) => panic!("failed to return comment result: null encountered"),
+        };
+
+        // run completed function
+        unsafe {
+            on_completed_callback(str_result);
+            let _ = CString::from_raw(str_result);
+        }
+    });
+}
+
 // Init client, potential leak! You need to call free_mem after this!
 #[no_mangle]
 pub extern "C" fn init(c_str_ptr: *const c_char) -> *mut CClient {

languages/csharp/Bitwarden.Sdk.Samples/Bitwarden.Sdk.Samples.csproj

@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <OutputType>Exe</OutputType>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
     </PropertyGroup>

languages/csharp/Bitwarden.Sdk.Samples/Program.cs

@@ -1,4 +1,4 @@
-using Bitwarden.Sdk;
+using Bitwarden.Sdk;
 
 // Configure secrets
 var accessToken = Environment.GetEnvironmentVariable("ACCESS_TOKEN")!;
@@ -9,7 +9,7 @@
 using var bitwardenClient = new BitwardenClient();
 
 // Authenticate
-bitwardenClient.AccessTokenLogin(accessToken);
+await bitwardenClient.AccessTokenLoginAsync(accessToken);
 
 // Project operations
 var projectResponse = bitwardenClient.Projects.Create(organizationId, "NewTestProject");

languages/csharp/Bitwarden.Sdk/Bitwarden.Sdk.csproj

@@ -1,11 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <RootNamespace>Bitwarden.Sdk</RootNamespace>
-
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Title>Bitwarden Secrets Manager SDK</Title>
     <Authors>Bitwarden Inc.</Authors>
     <Description>.NET bindings for interacting with the Bitwarden Secrets Manager</Description>
@@ -74,4 +74,4 @@
       <PackagePath>runtimes/win-x64/native</PackagePath>
     </Content>
   </ItemGroup>
-</Project>
+</Project>

languages/csharp/Bitwarden.Sdk/BitwardenClient.cs

@@ -20,10 +20,10 @@ public BitwardenClient(BitwardenSettings? settings = null)
         Secrets = new SecretsClient(_commandRunner);
     }
 
-    public void AccessTokenLogin(string accessToken)
+    public async Task AccessTokenLoginAsync(string accessToken)
     {
-        var command = new Command { AccessTokenLogin = new AccessTokenLoginRequest { AccessToken = accessToken } };
-        var response = _commandRunner.RunCommand<ResponseForApiKeyLoginResponse>(command);
+        var command = new Command { LoginAccessToken = new AccessTokenLoginRequest { AccessToken = accessToken } };
+        var response = await _commandRunner.RunCommandAsync<ResponseForApiKeyLoginResponse>(command);
         if (response is not { Success: true })
         {
             throw new BitwardenAuthException(response != null ? response.ErrorMessage : "Login failed");

languages/csharp/Bitwarden.Sdk/BitwardenLibrary.cs

@@ -2,20 +2,47 @@
 
 namespace Bitwarden.Sdk;
 
-internal static class BitwardenLibrary
+internal static partial class BitwardenLibrary
 {
-    [DllImport("bitwarden_c", CallingConvention = CallingConvention.Cdecl)]
-    private static extern BitwardenSafeHandle init(string settings);
+    [LibraryImport("bitwarden_c", StringMarshalling = StringMarshalling.Utf8)]
+    private static partial BitwardenSafeHandle init(string settings);
 
-    [DllImport("bitwarden_c", CallingConvention = CallingConvention.Cdecl)]
-    private static extern void free_mem(IntPtr handle);
+    [LibraryImport("bitwarden_c", StringMarshalling = StringMarshalling.Utf8)]
+    private static partial void free_mem(IntPtr handle);
 
-    [DllImport("bitwarden_c", CallingConvention = CallingConvention.Cdecl)]
-    private static extern string run_command(string json, BitwardenSafeHandle handle);
+    [LibraryImport("bitwarden_c", StringMarshalling = StringMarshalling.Utf8)]
+    private static partial string run_command(string json, BitwardenSafeHandle handle);
+
+    internal delegate void OnCompleteCallback(IntPtr json);
+
+    [LibraryImport("bitwarden_c", StringMarshalling = StringMarshalling.Utf8)]
+    private static partial void run_command_async(string json, BitwardenSafeHandle handle, OnCompleteCallback on_completed_callback);
 
     internal static BitwardenSafeHandle Init(string settings) => init(settings);
 
     internal static void FreeMemory(IntPtr handle) => free_mem(handle);
 
     internal static string RunCommand(string json, BitwardenSafeHandle handle) => run_command(json, handle);
+
+    internal static Task<string> RunCommandAsync(string json, BitwardenSafeHandle handle, CancellationToken token = default)
+    {
+        var tcs = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        try
+        {
+            run_command_async(json, handle, (resultPointer) =>
+            {
+                var stringResult = Marshal.PtrToStringUTF8(resultPointer);
+                tcs.SetResult(stringResult);
+            });
+        }
+        catch (Exception ex)
+        {
+            tcs.SetException(ex);
+        }
+
+        // TODO: Register cancellation on token
+
+        return tcs.Task;
+    }
 }

languages/csharp/Bitwarden.Sdk/CommandRunner.cs

@@ -17,4 +17,11 @@ internal CommandRunner(BitwardenSafeHandle handle)
         var result = BitwardenLibrary.RunCommand(req, _handle);
         return JsonSerializer.Deserialize<T>(result, Converter.Settings);
     }
+
+    internal async Task<T?> RunCommandAsync<T>(Command command)
+    {
+        var req = JsonSerializer.Serialize(command, Converter.Settings);
+        var result = await BitwardenLibrary.RunCommandAsync(req, _handle);
+        return JsonSerializer.Deserialize<T>(result, Converter.Settings);
+    }
 }