Do not require context for non-context methods

This follows the ffi style better.

Cargo.lock

@@ -4136,9 +4136,9 @@ dependencies = [
 
 [[package]]
 name = "testdir"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23029d5d16b0351859485c6849252f00bf0ebc98098a9efd954853c3533720c7"
+checksum = "c31eb500f7513b559ed7e0652894268dbe8ef27b6241b783ce274f4741eae137"
 dependencies = [
  "anyhow",
  "backtrace",

deltachat-ffi/src/lib.rs

@@ -4139,7 +4139,12 @@ pub unsafe extern "C" fn dc_str_unref(s: *mut libc::c_char) {
     libc::free(s as *mut _)
 }
 
-pub type dc_backup_provider_t = BackupProvider;
+pub struct BackupProviderWrapper {
+    context: *const dc_context_t,
+    provider: BackupProvider,
+}
+
+pub type dc_backup_provider_t = BackupProviderWrapper;
 
 #[no_mangle]
 pub unsafe extern "C" fn dc_backup_provider_new(
@@ -4151,49 +4156,54 @@ pub unsafe extern "C" fn dc_backup_provider_new(
     }
     let ctx = &*context;
     block_on(BackupProvider::prepare(ctx))
-        .map(|provider| Box::into_raw(Box::new(provider)))
+        .map(|provider| BackupProviderWrapper {
+            context: ctx,
+            provider,
+        })
+        .map(|ffi_provider| Box::into_raw(Box::new(ffi_provider)))
         .log_err(ctx, "BackupProvider failed")
         .unwrap_or(ptr::null_mut())
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn dc_backup_provider_qr(
-    _context: *mut dc_context_t,
     provider: *const dc_backup_provider_t,
 ) -> *mut libc::c_char {
-    let provider = &*provider;
+    if provider.is_null() {
-    deltachat::qr::format_backup(&provider.qr())
+        eprintln!("ignoring careless call to dc_backup_provider_qr");
+        return ptr::null_mut();
+    }
+    let ffi_provider = &*provider;
+    deltachat::qr::format_backup(&ffi_provider.provider.qr())
         .unwrap_or_default()
         .strdup()
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn dc_backup_provider_qr_svg(
-    context: *mut dc_context_t,
     provider: *const dc_backup_provider_t,
 ) -> *mut libc::c_char {
-    if context.is_null() {
+    if provider.is_null() {
         eprintln!("ignoring careless call to dc_backup_provider_qr_svg()");
         return ptr::null_mut();
     }
-    let ctx = &*context;
+    let ffi_provider = &*provider;
-    let provider = &*provider;
+    let ctx = &*ffi_provider.context;
+    let provider = &ffi_provider.provider;
     block_on(generate_backup_qr(ctx, &provider.qr()))
         .unwrap_or_default()
         .strdup()
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn dc_backup_provider_wait(
+pub unsafe extern "C" fn dc_backup_provider_wait(provider: *mut dc_backup_provider_t) {
-    context: *mut dc_context_t,
+    if provider.is_null() {
-    provider: *mut dc_backup_provider_t,
-) {
-    if context.is_null() {
         eprintln!("ignoring careless call to dc_backup_provider_wait()");
         return;
     }
-    let ctx = &*context;
+    let ffi_provider = &mut *provider;
-    let provider = &mut *provider;
+    let ctx = &*ffi_provider.context;
+    let provider = &mut ffi_provider.provider;
     block_on(provider)
         .log_err(ctx, "Failed to join provider")
         .ok();