1use 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 retained_tags: Mutex<Vec<(String, Instant)>>,
129 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 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 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 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 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 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 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 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 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 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 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); }
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}