Add run_command_async

crates/bitwarden-c/src/c.rs

@@ -1,6 +1,11 @@
-use std::{ffi::CStr, os::raw::c_char, str};
+use std::{
+    ffi::{CStr, CString},
+    os::raw::c_char,
+    str,
+};
 
 use bitwarden_json::client::Client;
+use tokio::task::JoinHandle;
 
 use crate::{box_ptr, ffi_ref};
 
@@ -28,6 +33,48 @@
     }
 }
 
+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,
+    is_cancellable: bool,
+) -> *mut JoinHandle<()> {
+    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();
+
+    let join_handle = 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);
+        }
+    });
+
+    // We only want to box the join handle the caller
+    // has said that they may want to cancel, essentially
+    // promising to us that they will take care of the
+    // returned pointer.
+    if is_cancellable {
+        box_ptr!(join_handle)
+    } else {
+        std::ptr::null_mut()
+    }
+}
+
 // 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 {
@@ -56,3 +103,15 @@
 pub extern "C" fn free_mem(client_ptr: *mut CClient) {
     std::mem::drop(unsafe { Box::from_raw(client_ptr) });
 }
+
+#[no_mangle]
+pub extern "C" fn abort_and_free_handle(join_handle_ptr: *mut tokio::task::JoinHandle<()>) -> () {
+    let join_handle = unsafe { Box::from_raw(join_handle_ptr) };
+    join_handle.abort();
+    std::mem::drop(join_handle);
+}
+
+#[no_mangle]
+pub extern "C" fn free_handle(join_handle_ptr: *mut tokio::task::JoinHandle<()>) -> () {
+    std::mem::drop(unsafe { Box::from_raw(join_handle_ptr) });
+}

crates/bitwarden-core/Cargo.toml

@@ -54,6 +54,9 @@ validator = { version = "0.18.1", features = ["derive"] }
 zeroize = { version = ">=1.7.0, <2.0", features = ["derive", "aarch64"] }
 zxcvbn = { version = ">=3.0.1, <4.0", optional = true }
 
+[target.'cfg(debug_assertions)'.dependencies]
+tokio = { version = "1.36.0", features = ["rt", "macros", "time"] }
+
 [target.'cfg(all(not(target_arch="wasm32"), not(windows)))'.dependencies]
 # By default, we use rustls as the TLS stack and rust-platform-verifier to support user-installed root certificates
 # The only exception is WASM, as it just uses the browsers/node fetch
@@ -71,7 +74,6 @@ reqwest = { version = ">=0.12.5, <0.13", features = [
 [dev-dependencies]
 bitwarden-crypto = { workspace = true }
 rand_chacha = "0.3.1"
-tokio = { version = "1.36.0", features = ["rt", "macros"] }
 wiremock = "0.6.0"
 zeroize = { version = ">=1.7.0, <2.0", features = ["derive", "aarch64"] }
 

crates/bitwarden-core/src/platform/client_platform.rs

@@ -24,6 +24,28 @@
     ) -> Result<UserApiKeyResponse> {
         get_user_api_key(self.client, &input).await
     }
+
+    #[cfg(debug_assertions)]
+    pub async fn cancellation_test(&mut self, duration_millis: u64) -> Result<i32> {
+        use std::time::Duration;
+
+        tokio::time::sleep(Duration::from_millis(duration_millis)).await;
+        println!("After wait #1");
+        tokio::time::sleep(Duration::from_millis(duration_millis)).await;
+        println!("After wait #2");
+        tokio::time::sleep(Duration::from_millis(duration_millis)).await;
+        println!("After wait #3");
+        Ok(42)
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn error_test(&mut self) -> Result<i32> {
+        use crate::Error;
+
+        Err(Error::Internal(std::borrow::Cow::Borrowed(
+            "This is an error.",
+        )))
+    }
 }
 
 impl<'a> Client {

crates/bitwarden-json/src/client.rs

@@ -98,6 +98,18 @@
                     client.generator().password(req).into_string()
                 }
             },
+            #[cfg(debug_assertions)]
+            Command::Debug(cmd) => {
+                use crate::command::DebugCommand;
+                match cmd {
+                    DebugCommand::CancellationTest { duration_millis } => client
+                        .platform()
+                        .cancellation_test(duration_millis)
+                        .await
+                        .into_string(),
+                    DebugCommand::ErrorTest {} => client.platform().error_test().into_string(),
+                }
+            }
         }
     }
 

crates/bitwarden-json/src/command.rs

@@ -79,6 +79,8 @@
     Projects(ProjectsCommand),
     #[cfg(feature = "secrets")]
     Generators(GeneratorsCommand),
+    #[cfg(debug_assertions)]
+    Debug(DebugCommand),
 }
 
 #[cfg(feature = "secrets")]
@@ -188,3 +190,11 @@
     /// Returns: [String]
     GeneratePassword(PasswordGeneratorRequest),
 }
+
+#[cfg(debug_assertions)]
+#[derive(Serialize, Deserialize, JsonSchema, Debug)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+pub enum DebugCommand {
+    CancellationTest { duration_millis: u64 },
+    ErrorTest {},
+}

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;
 
 // Get environment variables
 var identityUrl = Environment.GetEnvironmentVariable("IDENTITY_URL")!;
@@ -15,10 +15,10 @@
 });
 
 // Authenticate
-bitwardenClient.Auth.LoginAccessToken(accessToken, stateFile);
+await bitwardenClient.Auth.LoginAccessTokenAsync(accessToken, stateFile);
 
 // Projects List
-var projectsList = bitwardenClient.Projects.List(organizationId).Data;
+var projectsList = (await bitwardenClient.Projects.ListAsync(organizationId)).Data;
 Console.WriteLine("A list of all projects:");
 foreach (ProjectResponse pr in projectsList)
 {
@@ -30,17 +30,17 @@
 
 // Projects Create, Update, & Get
 Console.WriteLine("Creating and updating a project");
-var projectResponse = bitwardenClient.Projects.Create(organizationId, "NewTestProject");
-projectResponse = bitwardenClient.Projects.Update(organizationId, projectResponse.Id, "NewTestProject Renamed");
-projectResponse = bitwardenClient.Projects.Get(projectResponse.Id);
+var projectResponse = await bitwardenClient.Projects.CreateAsync(organizationId, "NewTestProject");
+projectResponse = await bitwardenClient.Projects.UpdateAsync(organizationId, projectResponse.Id, "NewTestProject Renamed");
+projectResponse = await bitwardenClient.Projects.GetAsync(projectResponse.Id);
 Console.WriteLine("Here is the project we created and updated:");
 Console.WriteLine(projectResponse.Name);
 
 Console.Write("Press enter to continue...");
 Console.ReadLine();
 
 // Secrets list
-var secretsList = bitwardenClient.Secrets.List(organizationId).Data;
+var secretsList = (await bitwardenClient.Secrets.ListAsync(organizationId)).Data;
 Console.WriteLine("A list of all secrets:");
 foreach (SecretIdentifierResponse sr in secretsList)
 {
@@ -52,22 +52,22 @@
 
 // Secrets Create, Update, Get
 Console.WriteLine("Creating and updating a secret");
-var secretResponse = bitwardenClient.Secrets.Create(organizationId, "New Secret", "the secret value", "the secret note", new[] { projectResponse.Id });
-secretResponse = bitwardenClient.Secrets.Update(organizationId, secretResponse.Id, "New Secret Name", "the secret value", "the secret note", new[] { projectResponse.Id });
-secretResponse = bitwardenClient.Secrets.Get(secretResponse.Id);
+var secretResponse = await bitwardenClient.Secrets.CreateAsync(organizationId, "New Secret", "the secret value", "the secret note", new[] { projectResponse.Id });
+secretResponse = await bitwardenClient.Secrets.UpdateAsync(organizationId, secretResponse.Id, "New Secret Name", "the secret value", "the secret note", new[] { projectResponse.Id });
+secretResponse = await bitwardenClient.Secrets.GetAsync(secretResponse.Id);
 Console.WriteLine("Here is the secret we created and updated:");
 Console.WriteLine(secretResponse.Key);
 
 Console.Write("Press enter to continue...");
 Console.ReadLine();
 
 // Secrets GetByIds
-var secretsResponse = bitwardenClient.Secrets.GetByIds(new[] { secretResponse.Id });
+var secretsResponse = await bitwardenClient.Secrets.GetByIdsAsync(new[] { secretResponse.Id });
 
 // Secrets Sync
-var syncResponse = bitwardenClient.Secrets.Sync(organizationId, null);
+var syncResponse = await bitwardenClient.Secrets.SyncAsync(organizationId, null);
 
 // Secrets & Projects Delete
 Console.WriteLine("Deleting our secret and project");
-bitwardenClient.Secrets.Delete(new[] { secretResponse.Id });
-bitwardenClient.Projects.Delete(new[] { projectResponse.Id });
+await bitwardenClient.Secrets.DeleteAsync(new[] { secretResponse.Id });
+await bitwardenClient.Projects.DeleteAsync(new[] { projectResponse.Id });

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

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Bitwarden.Sdk\Bitwarden.Sdk.csproj" />
+  </ItemGroup>
+
+</Project>

languages/csharp/Bitwarden.Sdk.Tests/GlobalUsings.cs

@@ -0,0 +1 @@
+global using Xunit;

languages/csharp/Bitwarden.Sdk.Tests/InteropTests.cs

@@ -0,0 +1,35 @@
+using Bitwarden.Sdk;
+using System.Diagnostics;
+
+namespace Bitwarden.Sdk.Tests;
+
+public class InteropTests
+{
+    [Fact]
+    public async void CancelingTest_ThrowsTaskCanceledException()
+    {
+        var client = new BitwardenClient();
+
+        var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(250));
+
+        await Assert.ThrowsAsync<TaskCanceledException>(async () => await client.CancellationTestAsync(cts.Token));
+    }
+
+    [Fact]
+    public async void NoCancel_TaskCompletesSuccessfully()
+    {
+        var client = new BitwardenClient();
+
+        var result = await client.CancellationTestAsync(CancellationToken.None);
+        Assert.Equal(42, result);
+    }
+
+    [Fact]
+    public async void Error_ThrowsException()
+    {
+        var client = new BitwardenClient();
+
+        var bitwardenException = await Assert.ThrowsAsync<BitwardenException>(async () => await client.ErrorTestAsync());
+        Assert.Equal("Internal error: This is an error.", bitwardenException.Message);
+    }
+}

languages/csharp/Bitwarden.Sdk/AuthClient.cs

@@ -9,10 +9,10 @@ internal AuthClient(CommandRunner commandRunner)
         _commandRunner = commandRunner;
     }
 
-    public void LoginAccessToken(string accessToken, string stateFile = "")
+    public async Task LoginAccessTokenAsync(string accessToken, string stateFile = "", CancellationToken cancellationToken = default)
     {
         var command = new Command { LoginAccessToken = new AccessTokenLoginRequest { AccessToken = accessToken, StateFile = stateFile } };
-        var response = _commandRunner.RunCommand<ResponseForApiKeyLoginResponse>(command);
+        var response = await _commandRunner.RunCommandAsync<ResponseForApiKeyLoginResponse>(command, cancellationToken);
         if (response is not { Success: true })
         {
             throw new BitwardenAuthException(response != null ? response.ErrorMessage : "Login failed");

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

@@ -1,17 +1,19 @@
 <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>
     <Copyright>Bitwarden Inc.</Copyright>
     <Product>SDK</Product>
 
+    <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+
     <RepositoryUrl>https://github.com/bitwarden/sdk/tree/main/languages/csharp</RepositoryUrl>
     <RepositoryType>Git</RepositoryType>
 
@@ -74,4 +76,4 @@
       <PackagePath>runtimes/win-x64/native</PackagePath>
     </Content>
   </ItemGroup>
-</Project>
+</Project>