Skip to main content

tunnet_core/
send.rs

1//! P2P file transfer via iroh-blobs + Tunnet offer ALPN.
2
3use std::collections::HashMap;
4use std::path::{Path, PathBuf};
5use std::sync::Arc;
6use std::time::{Duration, Instant};
7
8use anyhow::{Context, bail};
9use iroh::EndpointId;
10use iroh::endpoint::{Connection, RecvStream, SendStream};
11use iroh::protocol::ProtocolHandler;
12use iroh_blobs::format::collection::Collection;
13use iroh_blobs::store::fs::FsStore;
14use iroh_blobs::{BlobFormat, BlobsProtocol, Hash, HashAndFormat};
15use parking_lot::Mutex;
16use std::str::FromStr;
17use tokio::sync::mpsc;
18use tunnet_common::send::{
19    ConsentDecision, SEND_ALPN, SendBlobFormat, SendConsentMode, SendWireMsg, TransferDecision,
20    TransferDone, TransferOffer,
21};
22use tunnet_common::ws::ClientMsg;
23use uuid::Uuid;
24
25use crate::acl::AclEngine;
26use crate::iroh_pool::ConnPool;
27use crate::routing::RoutingTable;
28
29const SENDER_TTL: Duration = Duration::from_secs(60 * 60);
30const PROGRESS_THROTTLE: Duration = Duration::from_secs(1);
31
32#[derive(Debug, Clone, Copy, PartialEq, Eq)]
33pub enum TransferStatus {
34    Offered,
35    Pending,
36    Transferring,
37    Completed,
38    Failed,
39    Rejected,
40}
41
42impl TransferStatus {
43    pub fn as_str(self) -> &'static str {
44        match self {
45            Self::Offered => "offered",
46            Self::Pending => "pending",
47            Self::Transferring => "transferring",
48            Self::Completed => "completed",
49            Self::Failed => "failed",
50            Self::Rejected => "rejected",
51        }
52    }
53}
54
55#[derive(Debug, Clone)]
56pub struct TransferRecord {
57    pub transfer_id: String,
58    pub direction: TransferDirection,
59    pub peer_endpoint_id: String,
60    pub peer_hostname: Option<String>,
61    pub file_name: String,
62    pub size: u64,
63    pub hash: String,
64    pub format: SendBlobFormat,
65    pub is_directory: bool,
66    pub status: TransferStatus,
67    pub percent: f32,
68    pub bytes_transferred: u64,
69    pub message: Option<String>,
70    pub error: Option<String>,
71    pub inbox_path: Option<String>,
72    pub started_at_ms: u64,
73    pub completed_at_ms: Option<u64>,
74}
75
76#[derive(Debug, Clone, Copy, PartialEq, Eq)]
77pub enum TransferDirection {
78    Outbound,
79    Inbound,
80}
81
82#[derive(Debug, Clone)]
83pub struct SendConfig {
84    pub consent: SendConsentMode,
85    pub inbox_path: PathBuf,
86    pub pin_blobs: bool,
87}
88
89impl Default for SendConfig {
90    fn default() -> Self {
91        Self {
92            consent: SendConsentMode::Prompt,
93            inbox_path: default_inbox_path(),
94            pin_blobs: false,
95        }
96    }
97}
98
99fn default_inbox_path() -> PathBuf {
100    if let Ok(home) = std::env::var("HOME").or_else(|_| std::env::var("USERPROFILE")) {
101        return PathBuf::from(home).join("Tunnet").join("inbox");
102    }
103    PathBuf::from("./Tunnet/inbox")
104}
105
106fn now_ms() -> u64 {
107    std::time::SystemTime::now()
108        .duration_since(std::time::UNIX_EPOCH)
109        .map(|d| d.as_millis() as u64)
110        .unwrap_or(0)
111}
112
113#[derive(Clone)]
114pub struct SendManager {
115    inner: Arc<SendInner>,
116}
117
118struct SendInner {
119    store: FsStore,
120    blobs: BlobsProtocol,
121    pool: ConnPool,
122    routes: RoutingTable,
123    acl: AclEngine,
124    self_endpoint_id: String,
125    config: Mutex<SendConfig>,
126    transfers: Mutex<HashMap<String, TransferRecord>>,
127    /// Outbound sender tags kept until TTL after completion.
128    retained_tags: Mutex<Vec<(String, Instant)>>,
129    /// Pending inbound offers waiting for prompt consent.
130    pending: Mutex<HashMap<String, PendingOffer>>,
131    client_tx: Mutex<Option<mpsc::Sender<ClientMsg>>>,
132}
133
134struct PendingOffer {
135    offer: TransferOffer,
136    peer: EndpointId,
137    send: SendStream,
138    recv: RecvStream,
139}
140
141impl SendManager {
142    pub async fn open(
143        blobs_dir: PathBuf,
144        pool: ConnPool,
145        routes: RoutingTable,
146        acl: AclEngine,
147        self_endpoint_id: String,
148    ) -> anyhow::Result<Self> {
149        std::fs::create_dir_all(&blobs_dir)
150            .with_context(|| format!("mkdir blobs {}", blobs_dir.display()))?;
151        let store = FsStore::load(&blobs_dir)
152            .await
153            .map_err(|e| anyhow::anyhow!("open FsStore: {e}"))?;
154        Self::from_store(store, pool, routes, acl, self_endpoint_id).await
155    }
156
157    pub async fn from_store(
158        store: FsStore,
159        pool: ConnPool,
160        routes: RoutingTable,
161        acl: AclEngine,
162        self_endpoint_id: String,
163    ) -> anyhow::Result<Self> {
164        let blobs = BlobsProtocol::new(store.as_ref(), None);
165        let mgr = Self {
166            inner: Arc::new(SendInner {
167                store,
168                blobs,
169                pool,
170                routes,
171                acl,
172                self_endpoint_id,
173                config: Mutex::new(SendConfig::default()),
174                transfers: Mutex::new(HashMap::new()),
175                retained_tags: Mutex::new(Vec::new()),
176                pending: Mutex::new(HashMap::new()),
177                client_tx: Mutex::new(None),
178            }),
179        };
180        let cfg = mgr.config();
181        std::fs::create_dir_all(&cfg.inbox_path).ok();
182        let weak = mgr.clone();
183        tokio::spawn(async move {
184            loop {
185                tokio::time::sleep(Duration::from_secs(60)).await;
186                weak.gc_retained_tags().await;
187            }
188        });
189        Ok(mgr)
190    }
191
192    pub fn set_client_tx(&self, tx: mpsc::Sender<ClientMsg>) {
193        *self.inner.client_tx.lock() = Some(tx);
194    }
195
196    pub fn blobs_protocol(&self) -> BlobsProtocol {
197        self.inner.blobs.clone()
198    }
199
200    pub fn config(&self) -> SendConfig {
201        self.inner.config.lock().clone()
202    }
203
204    pub fn set_config(&self, cfg: SendConfig) {
205        std::fs::create_dir_all(&cfg.inbox_path).ok();
206        *self.inner.config.lock() = cfg;
207    }
208
209    pub fn list_active(&self) -> Vec<TransferRecord> {
210        self.inner
211            .transfers
212            .lock()
213            .values()
214            .filter(|t| {
215                matches!(
216                    t.status,
217                    TransferStatus::Offered
218                        | TransferStatus::Pending
219                        | TransferStatus::Transferring
220                )
221            })
222            .cloned()
223            .collect()
224    }
225
226    pub fn list_history(&self) -> Vec<TransferRecord> {
227        let mut v: Vec<_> = self
228            .inner
229            .transfers
230            .lock()
231            .values()
232            .filter(|t| {
233                matches!(
234                    t.status,
235                    TransferStatus::Completed | TransferStatus::Failed | TransferStatus::Rejected
236                )
237            })
238            .cloned()
239            .collect();
240        v.sort_by_key(|t| std::cmp::Reverse(t.started_at_ms));
241        v
242    }
243
244    pub fn list_pending(&self) -> Vec<TransferRecord> {
245        self.inner
246            .transfers
247            .lock()
248            .values()
249            .filter(|t| t.status == TransferStatus::Pending)
250            .cloned()
251            .collect()
252    }
253
254    async fn emit(&self, msg: ClientMsg) {
255        let tx = self.inner.client_tx.lock().clone();
256        if let Some(tx) = tx {
257            let _ = tx.send(msg).await;
258        }
259    }
260
261    fn upsert(&self, record: TransferRecord) {
262        self.inner
263            .transfers
264            .lock()
265            .insert(record.transfer_id.clone(), record);
266    }
267
268    fn update_status(
269        &self,
270        id: &str,
271        status: TransferStatus,
272        error: Option<String>,
273        inbox: Option<String>,
274    ) {
275        let mut guard = self.inner.transfers.lock();
276        if let Some(t) = guard.get_mut(id) {
277            t.status = status;
278            t.error = error;
279            if inbox.is_some() {
280                t.inbox_path = inbox;
281            }
282            if matches!(
283                status,
284                TransferStatus::Completed | TransferStatus::Failed | TransferStatus::Rejected
285            ) {
286                t.completed_at_ms = Some(now_ms());
287                if status == TransferStatus::Completed {
288                    t.percent = 100.0;
289                }
290            }
291        }
292    }
293
294    fn update_progress(&self, id: &str, bytes: u64, total: u64) {
295        let mut guard = self.inner.transfers.lock();
296        if let Some(t) = guard.get_mut(id) {
297            t.bytes_transferred = bytes;
298            t.status = TransferStatus::Transferring;
299            if total > 0 {
300                t.percent = (bytes as f32 / total as f32) * 100.0;
301            }
302        }
303    }
304
305    /// Resolve target hostname / IP / endpoint id / `tag:foo` to peer endpoint ids.
306    pub fn resolve_targets(
307        &self,
308        target: &str,
309    ) -> anyhow::Result<Vec<Arc<crate::routing::PeerInfo>>> {
310        if let Some(tag) = target.strip_prefix("tag:") {
311            let tag = tag.trim();
312            if tag.is_empty() {
313                bail!("empty tag");
314            }
315            let peers: Vec<_> = self
316                .inner
317                .routes
318                .peers()
319                .into_iter()
320                .filter(|p| p.tags.iter().any(|t| t == tag))
321                .collect();
322            if peers.is_empty() {
323                bail!("no peers with tag `{tag}`");
324            }
325            return Ok(peers);
326        }
327        let peer = if let Ok(ip) = target.parse::<std::net::Ipv4Addr>() {
328            self.inner.routes.lookup_ip(&ip)
329        } else {
330            self.inner
331                .routes
332                .lookup_hostname(target)
333                .or_else(|| self.inner.routes.lookup_endpoint(target))
334        }
335        .with_context(|| format!("peer not found: {target}"))?;
336        Ok(vec![peer])
337    }
338
339    /// Import path, offer to target(s), serve via blobs ALPN.
340    ///
341    /// When `transfer_id` is `Some`, it is used for the first (or only) peer so
342    /// control-plane / dashboard IDs stay aligned. Extra multicast peers get new UUIDs.
343    pub async fn send_file(
344        &self,
345        path: &Path,
346        target: &str,
347        message: Option<String>,
348    ) -> anyhow::Result<Vec<TransferRecord>> {
349        self.send_file_with_id(path, target, message, None).await
350    }
351
352    pub async fn send_file_with_id(
353        &self,
354        path: &Path,
355        target: &str,
356        message: Option<String>,
357        transfer_id: Option<String>,
358    ) -> anyhow::Result<Vec<TransferRecord>> {
359        let peers = self.resolve_targets(target)?;
360        let imported = self.import_path(path).await?;
361        let mut records = Vec::new();
362        for (i, peer) in peers.into_iter().enumerate() {
363            let transfer_id = if i == 0 {
364                transfer_id
365                    .clone()
366                    .unwrap_or_else(|| Uuid::new_v4().to_string())
367            } else {
368                Uuid::new_v4().to_string()
369            };
370            let record = TransferRecord {
371                transfer_id: transfer_id.clone(),
372                direction: TransferDirection::Outbound,
373                peer_endpoint_id: peer.endpoint_hex.clone(),
374                peer_hostname: Some(peer.hostname.clone()),
375                file_name: imported.file_name.clone(),
376                size: imported.size,
377                hash: imported.hash.to_hex(),
378                format: imported.format,
379                is_directory: imported.is_directory,
380                status: TransferStatus::Offered,
381                percent: 0.0,
382                bytes_transferred: 0,
383                message: message.clone(),
384                error: None,
385                inbox_path: None,
386                started_at_ms: now_ms(),
387                completed_at_ms: None,
388            };
389            self.upsert(record.clone());
390            self.emit(ClientMsg::TransferOffer {
391                transfer_id: transfer_id.clone(),
392                sender_endpoint_id: self.inner.self_endpoint_id.clone(),
393                receiver_endpoint_id: Some(peer.endpoint_hex.clone()),
394                file_name: imported.file_name.clone(),
395                size: imported.size,
396                blake3_hash: imported.hash.to_hex(),
397                status: "offered".into(),
398                message: message.clone(),
399            })
400            .await;
401
402            let mgr = self.clone();
403            let peer_id: EndpointId = peer
404                .endpoint_hex
405                .parse()
406                .context("parse peer endpoint id")?;
407            let offer = TransferOffer {
408                transfer_id: transfer_id.clone(),
409                hash: imported.hash.to_hex(),
410                format: imported.format,
411                file_name: imported.file_name.clone(),
412                size: imported.size,
413                sender_endpoint_id: self.inner.self_endpoint_id.clone(),
414                message: message.clone(),
415                is_directory: imported.is_directory,
416            };
417            let tag_name = transfer_id.clone();
418            let tid = transfer_id.clone();
419            let hash = imported.hash;
420            let format = imported.format;
421            tokio::spawn(async move {
422                if let Err(e) = mgr
423                    .run_outbound(peer_id, offer, tag_name, hash, format)
424                    .await
425                {
426                    tracing::warn!(?e, "outbound transfer failed");
427                    mgr.update_status(&tid, TransferStatus::Failed, Some(e.to_string()), None);
428                    mgr.emit(ClientMsg::TransferFailed {
429                        transfer_id: tid,
430                        error: e.to_string(),
431                        rejected: false,
432                    })
433                    .await;
434                }
435            });
436            records.push(record);
437        }
438        Ok(records)
439    }
440
441    async fn run_outbound(
442        &self,
443        peer: EndpointId,
444        offer: TransferOffer,
445        tag_name: String,
446        hash: Hash,
447        format: SendBlobFormat,
448    ) -> anyhow::Result<()> {
449        let transfer_id = offer.transfer_id.clone();
450        // Persist a named tag so the blob survives until TTL.
451        let haf = HashAndFormat {
452            hash,
453            format: match format {
454                SendBlobFormat::Blob => BlobFormat::Raw,
455                SendBlobFormat::HashSeq => BlobFormat::HashSeq,
456            },
457        };
458        self.inner
459            .store
460            .tags()
461            .set(tag_name.as_bytes(), haf)
462            .await
463            .map_err(|e| anyhow::anyhow!("set tag: {e}"))?;
464
465        let conn = self.inner.pool.get_alpn(peer, SEND_ALPN).await?;
466        let (mut send, mut recv) = conn.open_bi().await.context("open_bi send")?;
467        write_wire(&mut send, &SendWireMsg::Offer(offer)).await?;
468        let decision = match read_wire(&mut recv).await? {
469            SendWireMsg::Decision(d) => d,
470            other => bail!("expected Decision, got {other:?}"),
471        };
472        if !decision.accepted {
473            self.update_status(
474                &transfer_id,
475                TransferStatus::Rejected,
476                decision.reason.clone(),
477                None,
478            );
479            let _ = self.inner.store.tags().delete(tag_name.as_bytes()).await;
480            self.emit(ClientMsg::TransferFailed {
481                transfer_id: transfer_id.clone(),
482                error: decision.reason.unwrap_or_else(|| "rejected".into()),
483                rejected: true,
484            })
485            .await;
486            return Ok(());
487        }
488
489        self.update_status(&transfer_id, TransferStatus::Transferring, None, None);
490        // Wait for Done from receiver.
491        match read_wire(&mut recv).await {
492            Ok(SendWireMsg::Done(done)) => {
493                if done.status == "completed" {
494                    self.update_status(
495                        &transfer_id,
496                        TransferStatus::Completed,
497                        None,
498                        done.inbox_path,
499                    );
500                    self.inner
501                        .retained_tags
502                        .lock()
503                        .push((tag_name, Instant::now() + SENDER_TTL));
504                    self.emit(ClientMsg::TransferComplete {
505                        transfer_id,
506                        inbox_path: None,
507                        duration_ms: None,
508                    })
509                    .await;
510                } else {
511                    self.update_status(
512                        &transfer_id,
513                        TransferStatus::Failed,
514                        done.error.clone(),
515                        None,
516                    );
517                    let _ = self.inner.store.tags().delete(tag_name.as_bytes()).await;
518                    self.emit(ClientMsg::TransferFailed {
519                        transfer_id,
520                        error: done.error.unwrap_or_else(|| "failed".into()),
521                        rejected: false,
522                    })
523                    .await;
524                }
525            }
526            Ok(other) => bail!("expected Done, got {other:?}"),
527            Err(e) => {
528                self.update_status(
529                    &transfer_id,
530                    TransferStatus::Failed,
531                    Some(e.to_string()),
532                    None,
533                );
534                self.emit(ClientMsg::TransferFailed {
535                    transfer_id,
536                    error: e.to_string(),
537                    rejected: false,
538                })
539                .await;
540            }
541        }
542        Ok(())
543    }
544
545    /// Handle inbound SEND_ALPN connection (offer stream).
546    pub async fn handle_offer_connection(&self, conn: Connection) {
547        let peer_hex = format!("{}", conn.remote_id());
548        if !self.inner.acl.allow_inbound_peer(&peer_hex) {
549            tracing::warn!(%peer_hex, "send offer blocked by ACL");
550            return;
551        }
552        let (mut send, mut recv) = match conn.accept_bi().await {
553            Ok(s) => s,
554            Err(e) => {
555                tracing::debug!(?e, "send accept_bi closed");
556                return;
557            }
558        };
559        let offer = match read_wire(&mut recv).await {
560            Ok(SendWireMsg::Offer(o)) => o,
561            Ok(other) => {
562                tracing::warn!(?other, "unexpected first send msg");
563                return;
564            }
565            Err(e) => {
566                tracing::warn!(?e, "read offer failed");
567                return;
568            }
569        };
570
571        let peer: EndpointId = match peer_hex.parse() {
572            Ok(p) => p,
573            Err(_) => return,
574        };
575        let hostname = self
576            .inner
577            .routes
578            .lookup_endpoint(&peer_hex)
579            .map(|p| p.hostname.clone());
580
581        let record = TransferRecord {
582            transfer_id: offer.transfer_id.clone(),
583            direction: TransferDirection::Inbound,
584            peer_endpoint_id: peer_hex.clone(),
585            peer_hostname: hostname,
586            file_name: offer.file_name.clone(),
587            size: offer.size,
588            hash: offer.hash.clone(),
589            format: offer.format,
590            is_directory: offer.is_directory,
591            status: TransferStatus::Pending,
592            percent: 0.0,
593            bytes_transferred: 0,
594            message: offer.message.clone(),
595            error: None,
596            inbox_path: None,
597            started_at_ms: now_ms(),
598            completed_at_ms: None,
599        };
600        self.upsert(record);
601        self.emit(ClientMsg::TransferOffer {
602            transfer_id: offer.transfer_id.clone(),
603            sender_endpoint_id: offer.sender_endpoint_id.clone(),
604            receiver_endpoint_id: Some(self.inner.self_endpoint_id.clone()),
605            file_name: offer.file_name.clone(),
606            size: offer.size,
607            blake3_hash: offer.hash.clone(),
608            status: "pending".into(),
609            message: offer.message.clone(),
610        })
611        .await;
612
613        let consent = self.decide_consent(&peer_hex);
614        match consent {
615            ConsentDecision::Accept => {
616                if let Err(e) = self.accept_offer_inner(offer, peer, send, recv).await {
617                    tracing::warn!(?e, "accept offer failed");
618                }
619            }
620            ConsentDecision::Deny => {
621                let id = offer.transfer_id.clone();
622                let _ = write_wire(
623                    &mut send,
624                    &SendWireMsg::Decision(TransferDecision {
625                        transfer_id: id.clone(),
626                        accepted: false,
627                        reason: Some("denied by consent policy".into()),
628                    }),
629                )
630                .await;
631                self.update_status(&id, TransferStatus::Rejected, Some("denied".into()), None);
632                self.emit(ClientMsg::TransferFailed {
633                    transfer_id: id,
634                    error: "denied by consent policy".into(),
635                    rejected: true,
636                })
637                .await;
638            }
639            ConsentDecision::Prompt => {
640                self.inner.pending.lock().insert(
641                    offer.transfer_id.clone(),
642                    PendingOffer {
643                        offer,
644                        peer,
645                        send,
646                        recv,
647                    },
648                );
649            }
650        }
651    }
652
653    fn decide_consent(&self, peer_hex: &str) -> ConsentDecision {
654        let mode = self.inner.config.lock().consent;
655        mode.decide(self.peer_shares_tag(peer_hex))
656    }
657
658    /// True when this machine and the peer share at least one mesh tag.
659    pub fn peer_shares_tag(&self, peer_hex: &str) -> bool {
660        let self_tags = self.inner.acl.self_id.load().tags.clone();
661        if self_tags.is_empty() {
662            return false;
663        }
664        let Some(peer) = self.inner.routes.lookup_endpoint(peer_hex) else {
665            return false;
666        };
667        peer.tags.iter().any(|t| self_tags.contains(t))
668    }
669
670    pub async fn accept_pending(&self, transfer_id: &str) -> anyhow::Result<TransferRecord> {
671        let pending = self
672            .inner
673            .pending
674            .lock()
675            .remove(transfer_id)
676            .with_context(|| format!("no pending transfer `{transfer_id}`"))?;
677        self.accept_offer_inner(pending.offer, pending.peer, pending.send, pending.recv)
678            .await?;
679        self.inner
680            .transfers
681            .lock()
682            .get(transfer_id)
683            .cloned()
684            .context("transfer missing after accept")
685    }
686
687    pub async fn reject_pending(
688        &self,
689        transfer_id: &str,
690        reason: Option<String>,
691    ) -> anyhow::Result<()> {
692        let mut pending = self
693            .inner
694            .pending
695            .lock()
696            .remove(transfer_id)
697            .with_context(|| format!("no pending transfer `{transfer_id}`"))?;
698        let reason = reason.unwrap_or_else(|| "rejected".into());
699        write_wire(
700            &mut pending.send,
701            &SendWireMsg::Decision(TransferDecision {
702                transfer_id: transfer_id.to_string(),
703                accepted: false,
704                reason: Some(reason.clone()),
705            }),
706        )
707        .await?;
708        self.update_status(
709            transfer_id,
710            TransferStatus::Rejected,
711            Some(reason.clone()),
712            None,
713        );
714        self.emit(ClientMsg::TransferFailed {
715            transfer_id: transfer_id.to_string(),
716            error: reason,
717            rejected: true,
718        })
719        .await;
720        Ok(())
721    }
722
723    async fn accept_offer_inner(
724        &self,
725        offer: TransferOffer,
726        peer: EndpointId,
727        mut send: SendStream,
728        mut recv: RecvStream,
729    ) -> anyhow::Result<()> {
730        let transfer_id = offer.transfer_id.clone();
731        write_wire(
732            &mut send,
733            &SendWireMsg::Decision(TransferDecision {
734                transfer_id: transfer_id.clone(),
735                accepted: true,
736                reason: None,
737            }),
738        )
739        .await?;
740
741        self.update_status(&transfer_id, TransferStatus::Transferring, None, None);
742        let hash = Hash::from_str(&offer.hash).map_err(|e| anyhow::anyhow!("invalid hash: {e}"))?;
743        let format = match offer.format {
744            SendBlobFormat::Blob => BlobFormat::Raw,
745            SendBlobFormat::HashSeq => BlobFormat::HashSeq,
746        };
747
748        let started = Instant::now();
749        let result = self
750            .download_from_peer(peer, hash, format, offer.size, &transfer_id)
751            .await;
752
753        match result {
754            Ok(()) => {
755                let pin = self.inner.config.lock().pin_blobs;
756                if pin {
757                    let haf = HashAndFormat { hash, format };
758                    let tag = format!("pin-{transfer_id}");
759                    let _ = self.inner.store.tags().set(tag.as_bytes(), haf).await;
760                }
761                let inbox = self
762                    .export_to_inbox(&offer, hash)
763                    .await
764                    .context("export to inbox")?;
765                let inbox_str = inbox.display().to_string();
766                // When not pinning, drop any named tags so FsStore GC can reclaim
767                // after TempTags from the download are released.
768                if !pin {
769                    let _ = self
770                        .inner
771                        .store
772                        .tags()
773                        .delete(format!("recv-{transfer_id}").as_bytes())
774                        .await;
775                    let _ = self.inner.store.tags().delete(transfer_id.as_bytes()).await;
776                }
777                self.update_status(
778                    &transfer_id,
779                    TransferStatus::Completed,
780                    None,
781                    Some(inbox_str.clone()),
782                );
783                let _ = write_wire(
784                    &mut send,
785                    &SendWireMsg::Done(TransferDone {
786                        transfer_id: transfer_id.clone(),
787                        status: "completed".into(),
788                        error: None,
789                        inbox_path: Some(inbox_str.clone()),
790                    }),
791                )
792                .await;
793                // Keep recv half alive briefly
794                let _ = &mut recv;
795                self.emit(ClientMsg::TransferComplete {
796                    transfer_id,
797                    inbox_path: Some(inbox_str),
798                    duration_ms: Some(started.elapsed().as_millis() as u64),
799                })
800                .await;
801            }
802            Err(e) => {
803                self.update_status(
804                    &transfer_id,
805                    TransferStatus::Failed,
806                    Some(e.to_string()),
807                    None,
808                );
809                let _ = write_wire(
810                    &mut send,
811                    &SendWireMsg::Done(TransferDone {
812                        transfer_id: transfer_id.clone(),
813                        status: "failed".into(),
814                        error: Some(e.to_string()),
815                        inbox_path: None,
816                    }),
817                )
818                .await;
819                self.emit(ClientMsg::TransferFailed {
820                    transfer_id,
821                    error: e.to_string(),
822                    rejected: false,
823                })
824                .await;
825                return Err(e);
826            }
827        }
828        Ok(())
829    }
830
831    async fn download_from_peer(
832        &self,
833        peer: EndpointId,
834        hash: Hash,
835        format: BlobFormat,
836        total: u64,
837        transfer_id: &str,
838    ) -> anyhow::Result<()> {
839        let conn = self
840            .inner
841            .pool
842            .get_alpn(peer, iroh_blobs::ALPN)
843            .await
844            .context("connect blobs ALPN")?;
845        let progress = self
846            .inner
847            .store
848            .remote()
849            .fetch(conn, HashAndFormat { hash, format });
850
851        let mut stream = progress.stream();
852        use futures_util::StreamExt;
853        let mut last_emit = Instant::now() - PROGRESS_THROTTLE;
854        let mut last_pct = -1.0f32;
855        while let Some(item) = stream.next().await {
856            match item {
857                iroh_blobs::api::remote::GetProgressItem::Progress(bytes) => {
858                    self.update_progress(transfer_id, bytes, total);
859                    let pct = if total > 0 {
860                        (bytes as f32 / total as f32) * 100.0
861                    } else {
862                        0.0
863                    };
864                    if last_emit.elapsed() >= PROGRESS_THROTTLE || (pct - last_pct).abs() >= 1.0 {
865                        last_emit = Instant::now();
866                        last_pct = pct;
867                        self.emit(ClientMsg::TransferProgress {
868                            transfer_id: transfer_id.to_string(),
869                            percent: pct,
870                            bytes_transferred: bytes,
871                            bytes_total: Some(total),
872                        })
873                        .await;
874                    }
875                }
876                iroh_blobs::api::remote::GetProgressItem::Done(_) => return Ok(()),
877                iroh_blobs::api::remote::GetProgressItem::Error(e) => {
878                    bail!("download failed: {e}");
879                }
880            }
881        }
882        bail!("download stream ended without result");
883    }
884
885    async fn export_to_inbox(&self, offer: &TransferOffer, hash: Hash) -> anyhow::Result<PathBuf> {
886        let inbox = self.inner.config.lock().inbox_path.clone();
887        std::fs::create_dir_all(&inbox)?;
888        let safe_name = sanitize_file_name(&offer.file_name);
889        if offer.is_directory || offer.format == SendBlobFormat::HashSeq {
890            let dest_dir = unique_path(inbox.join(&safe_name));
891            std::fs::create_dir_all(&dest_dir)?;
892            let collection = Collection::load(hash, self.inner.store.as_ref())
893                .await
894                .map_err(|e| anyhow::anyhow!("load collection: {e}"))?;
895            for (name, file_hash) in collection.iter() {
896                let target = dest_dir.join(name);
897                if let Some(parent) = target.parent() {
898                    std::fs::create_dir_all(parent)?;
899                }
900                self.inner
901                    .store
902                    .export(*file_hash, &target)
903                    .await
904                    .map_err(|e| anyhow::anyhow!("export {name}: {e}"))?;
905            }
906            Ok(dest_dir)
907        } else {
908            let target = unique_path(inbox.join(&safe_name));
909            self.inner
910                .store
911                .export(hash, &target)
912                .await
913                .map_err(|e| anyhow::anyhow!("export: {e}"))?;
914            Ok(target)
915        }
916    }
917
918    async fn import_path(&self, path: &Path) -> anyhow::Result<ImportedBlob> {
919        let meta = std::fs::metadata(path).with_context(|| format!("stat {}", path.display()))?;
920        let file_name = path
921            .file_name()
922            .map(|s| s.to_string_lossy().into_owned())
923            .unwrap_or_else(|| "file".into());
924
925        if meta.is_dir() {
926            let mut collection = Collection::default();
927            let mut total_size = 0u64;
928            collect_dir(
929                path,
930                path,
931                &self.inner.store,
932                &mut collection,
933                &mut total_size,
934            )
935            .await?;
936            let tag = collection
937                .store(self.inner.store.as_ref())
938                .await
939                .map_err(|e| anyhow::anyhow!("store collection: {e}"))?;
940            Ok(ImportedBlob {
941                hash: tag.hash(),
942                format: SendBlobFormat::HashSeq,
943                file_name,
944                size: total_size,
945                is_directory: true,
946            })
947        } else {
948            let tag = self
949                .inner
950                .store
951                .add_path(path)
952                .await
953                .map_err(|e| anyhow::anyhow!("add_path: {e}"))?;
954            Ok(ImportedBlob {
955                hash: tag.hash,
956                format: SendBlobFormat::Blob,
957                file_name,
958                size: meta.len(),
959                is_directory: false,
960            })
961        }
962    }
963
964    async fn gc_retained_tags(&self) {
965        let now = Instant::now();
966        let expired: Vec<String> = {
967            let mut guard = self.inner.retained_tags.lock();
968            let mut keep = Vec::new();
969            let mut expired = Vec::new();
970            for (tag, until) in guard.drain(..) {
971                if until <= now {
972                    expired.push(tag);
973                } else {
974                    keep.push((tag, until));
975                }
976            }
977            *guard = keep;
978            expired
979        };
980        for tag in expired {
981            let _ = self.inner.store.tags().delete(tag.as_bytes()).await;
982        }
983    }
984
985    /// Serve an inbound blobs ALPN connection.
986    pub async fn handle_blobs_connection(&self, conn: Connection) {
987        let peer_hex = format!("{}", conn.remote_id());
988        if !self.inner.acl.allow_inbound_peer(&peer_hex) {
989            tracing::warn!(%peer_hex, "blobs ALPN blocked by ACL");
990            conn.close(1u32.into(), b"policy_deny");
991            return;
992        }
993        self.accept_blobs(conn).await;
994    }
995
996    /// Blobs accept without ACL (Direct PSK-authed peers / iroh-docs sync).
997    pub async fn handle_blobs_connection_trusted(&self, conn: Connection) {
998        self.accept_blobs(conn).await;
999    }
1000
1001    async fn accept_blobs(&self, conn: Connection) {
1002        if let Err(e) = self.inner.blobs.accept(conn).await {
1003            tracing::debug!(?e, "blobs accept ended");
1004        }
1005    }
1006}
1007
1008struct ImportedBlob {
1009    hash: Hash,
1010    format: SendBlobFormat,
1011    file_name: String,
1012    size: u64,
1013    is_directory: bool,
1014}
1015
1016async fn collect_dir(
1017    root: &Path,
1018    dir: &Path,
1019    store: &FsStore,
1020    collection: &mut Collection,
1021    total_size: &mut u64,
1022) -> anyhow::Result<()> {
1023    let mut rd = tokio::fs::read_dir(dir).await?;
1024    while let Some(entry) = rd.next_entry().await? {
1025        let path = entry.path();
1026        let ft = entry.file_type().await?;
1027        if ft.is_dir() {
1028            Box::pin(collect_dir(root, &path, store, collection, total_size)).await?;
1029        } else if ft.is_file() {
1030            let rel = path
1031                .strip_prefix(root)
1032                .unwrap_or(&path)
1033                .to_string_lossy()
1034                .replace('\\', "/");
1035            let meta = entry.metadata().await?;
1036            *total_size += meta.len();
1037            let tag = store
1038                .add_path(&path)
1039                .await
1040                .map_err(|e| anyhow::anyhow!("add {}: {e}", path.display()))?;
1041            collection.push(rel, tag.hash); // name is already String
1042        }
1043    }
1044    Ok(())
1045}
1046
1047fn sanitize_file_name(name: &str) -> String {
1048    let name = name.trim().trim_start_matches(['/', '\\']);
1049    if name.is_empty() || name == "." || name == ".." {
1050        return "file".into();
1051    }
1052    name.replace(['/', '\\', '\0'], "_")
1053}
1054
1055fn unique_path(path: PathBuf) -> PathBuf {
1056    if !path.exists() {
1057        return path;
1058    }
1059    let stem = path
1060        .file_stem()
1061        .map(|s| s.to_string_lossy().into_owned())
1062        .unwrap_or_else(|| "file".into());
1063    let ext = path
1064        .extension()
1065        .map(|s| format!(".{}", s.to_string_lossy()))
1066        .unwrap_or_default();
1067    let parent = path.parent().map(Path::to_path_buf).unwrap_or_default();
1068    for i in 1..10_000 {
1069        let candidate = parent.join(format!("{stem}-{i}{ext}"));
1070        if !candidate.exists() {
1071            return candidate;
1072        }
1073    }
1074    parent.join(format!("{stem}-{}{ext}", Uuid::new_v4()))
1075}
1076
1077async fn write_wire(send: &mut SendStream, msg: &SendWireMsg) -> anyhow::Result<()> {
1078    let bytes = msg.encode()?;
1079    let len = u32::try_from(bytes.len()).context("send frame too large")?;
1080    send.write_all(&len.to_be_bytes()).await?;
1081    send.write_all(&bytes).await?;
1082    Ok(())
1083}
1084
1085async fn read_wire(recv: &mut RecvStream) -> anyhow::Result<SendWireMsg> {
1086    let mut len_buf = [0u8; 4];
1087    recv.read_exact(&mut len_buf)
1088        .await
1089        .context("read send frame len")?;
1090    let len = u32::from_be_bytes(len_buf) as usize;
1091    if len > 1024 * 1024 {
1092        bail!("send frame too large ({len})");
1093    }
1094    let mut buf = vec![0u8; len];
1095    if len > 0 {
1096        recv.read_exact(&mut buf)
1097            .await
1098            .context("read send frame body")?;
1099    }
1100    SendWireMsg::decode(&buf)
1101}