update iroh-share & cleanup api

Cargo.toml

@@ -83,8 +83,8 @@ futures-lite = "1.12.0"
 tokio-stream = { version = "0.1.11", features = ["fs"] }
 reqwest = { version = "0.11.12", features = ["json"] }
 async_zip = { version = "0.0.9", default-features = false, features = ["deflate"] }
-iroh-share = { git = "https://github.com/n0-computer/iroh", branch = "iroh-share" }
-iroh-resolver = { git = "https://github.com/n0-computer/iroh", branch = "iroh-share" }
+iroh-share = { git = "https://github.com/n0-computer/iroh", branch = "main" }
+iroh-resolver = { git = "https://github.com/n0-computer/iroh", branch = "main", default-features = false }
 tempfile = "3"
 multibase = "0.9.1"
 

deltachat-ffi/Cargo.toml

@@ -26,7 +26,7 @@ anyhow = "1"
 thiserror = "1"
 rand = "0.7"
 once_cell = "1.16.0"
-iroh-share = { git = "https://github.com/n0-computer/iroh", branch = "iroh-share" }
+iroh-share = { git = "https://github.com/n0-computer/iroh", branch = "main" }
 multibase = "0.9"
 
 [features]

deltachat-ffi/deltachat.h

@@ -2680,13 +2680,14 @@ char* dc_backup_sender_qr (dc_context_t* context, const dc_backup_sender_t* back
 
 
 /**
- * Free a backup sender object.
+ * Waits for the sending to finish and frees the backup sender object.
  *
  * @memberof dc_backup_sender_t
+ * @param context The context.
  * @param backup_sender The backup sender object as created by dc_send_backup(),
  *     If NULL is given, nothing is done.
  */
-void dc_backup_sender_unref (dc_backup_sender_t* backup_sender);
+void dc_backup_sender_done (dc_context_t* context, dc_backup_sender_t* backup_sender);
 
 
 /**

deltachat-ffi/src/lib.rs

@@ -2223,12 +2223,7 @@ pub unsafe extern "C" fn dc_send_backup(
         block_on(async move {
             imex::send_backup(ctx, folder.as_ref(), passphrase)
                 .await
-                .map(|(sender, transfer)| {
-                    Box::into_raw(Box::new(dc_backup_sender {
-                        _sender: sender,
-                        transfer,
-                    }))
-                })
+                .map(|transfer| Box::into_raw(Box::new(dc_backup_sender { transfer })))
                 .log_err(ctx, "send_backup failed")
                 .unwrap_or_else(|_| ptr::null_mut())
         })
@@ -2239,7 +2234,6 @@ pub unsafe extern "C" fn dc_send_backup(
 }
 
 pub struct dc_backup_sender {
-    _sender: iroh_share::Sender,
     transfer: iroh_share::SenderTransfer,
 }
 
@@ -2263,10 +2257,19 @@ pub unsafe extern "C" fn dc_backup_sender_qr(
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn dc_backup_sender_unref(bs: *mut dc_backup_sender) {
-    if !bs.is_null() {
-        let _ = Box::from_raw(bs);
+pub unsafe extern "C" fn dc_backup_sender_done(ctx: *mut dc_context_t, bs: *mut dc_backup_sender) {
+    if ctx.is_null() || bs.is_null() {
+        eprintln!("ignoring careless call to dc_backup_sender_wait");
+        return;
     }
+    let ctx = &*ctx;
+    let bs = Box::from_raw(bs);
+
+    block_on(async move {
+        if let Err(e) = bs.transfer.done().await {
+            error!(ctx, "sending backup failed: {:?}", e);
+        }
+    });
 }
 
 #[no_mangle]

examples/repl/cmdline.rs

@@ -481,8 +481,7 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
         }
         "send-backup" => {
             let dir = dirs::home_dir().unwrap_or_default();
-            let (sender, transfer) =
-                send_backup(&context, dir.as_ref(), Some(arg1.to_string())).await?;
+            let transfer = send_backup(&context, dir.as_ref(), Some(arg1.to_string())).await?;
             let ticket = transfer.ticket();
             let ticket_bytes = ticket.as_bytes();
 
@@ -495,7 +494,6 @@ pub async fn cmdline(context: Context, line: &str, chat_id: &mut ChatId) -> Resu
             tokio::fs::write(file, qr_code.as_bytes()).await?;
 
             transfer.done().await?;
-            sender.close().await?;
         }
         "receive-backup" => {
             ensure!(!arg1.is_empty(), "Argument <ticket> is missing.");

src/imex.rs

@@ -155,9 +155,7 @@ pub async fn receive_backup_inner(
     let sender_db = sender_dir.path().join("db");
 
     let port = 9991;
-    let rpc_p2p_port = 5551;
-    let rpc_store_port = 5561;
-    let receiver = Receiver::new(port, rpc_p2p_port, rpc_store_port, &sender_db)
+    let receiver = Receiver::new(port, &sender_db)
         .await
         .context("failed to create sender")?;
     let mut receiver_transfer = receiver
@@ -165,7 +163,7 @@ pub async fn receive_backup_inner(
         .await
         .context("failed to read transfer")?;
     let data = receiver_transfer.recv().await?;
-    let progress = receiver_transfer.progress()?;
+    let mut progress = receiver_transfer.progress()?;
 
     context.sql.config_cache.write().await.clear();
 
@@ -173,7 +171,7 @@ pub async fn receive_backup_inner(
     let ctx = context.clone();
     let progress_task = tokio::spawn(async move {
         let mut last_progress = 0;
-        while let Ok(ev) = progress.recv().await {
+        while let Some(ev) = progress.next().await {
             match ev {
                 Ok(iroh_share::ProgressEvent::Piece { index, total }) => {
                     let progress = 1000 * index / total;
@@ -222,9 +220,10 @@ pub async fn receive_backup_inner(
         }
     }
 
-    println!("Received all data, written to: {}", out.display());
-    receiver.close().await?;
     progress_task.await?;
+    receiver_transfer.finish().await?;
+
+    println!("Received all data, written to: {}", out.display());
 
     Ok(())
 }
@@ -233,7 +232,7 @@ pub async fn send_backup(
     context: &Context,
     path: &Path,
     passphrase: Option<String>,
-) -> Result<(iroh_share::Sender, iroh_share::SenderTransfer)> {
+) -> Result<iroh_share::SenderTransfer> {
     let cancel = context.alloc_ongoing().await?;
 
     let res = send_backup_inner(context, path, passphrase)
@@ -261,7 +260,7 @@ async fn send_backup_inner(
     context: &Context,
     path: &Path,
     passphrase: Option<String>,
-) -> Result<(iroh_share::Sender, iroh_share::SenderTransfer)> {
+) -> Result<iroh_share::SenderTransfer> {
     info!(context, "Import/export dir: {}", path.display());
     ensure!(context.sql.is_open().await, "Database not opened.");
     context.emit_event(EventType::ImexProgress(10));
@@ -782,7 +781,7 @@ async fn export_backup_iroh(
     context: &Context,
     dir: &Path,
     passphrase: String,
-) -> Result<(iroh_share::Sender, iroh_share::SenderTransfer)> {
+) -> Result<iroh_share::SenderTransfer> {
     // get a fine backup file name (the name includes the date so that multiple backup instances are possible)
     let now = time();
     let (temp_db_path, temp_path, dest_path) = get_next_backup_path(dir, now)?;
@@ -827,15 +826,10 @@ async fn export_backup_iroh(
     match res {
         Ok(dir_builder) => {
             let port = 9990;
-            let rpc_p2p_port = 5550;
-            let rpc_store_port = 5560;
-
-            let sender =
-                iroh_share::Sender::new(port, rpc_p2p_port, rpc_store_port, &sender_db_path)
-                    .await?;
+            let sender = iroh_share::Sender::new(port, &sender_db_path).await?;
             let transfer = sender.transfer_from_dir_builder(dir_builder).await?;
 
-            Ok((sender, transfer))
+            Ok(transfer)
         }
         Err(e) => {
             error!(context, "backup failed: {}", e);