Your Android phone and your Windows PC, working as one. Local-first, end-to-end encrypted, no account.
fix(core): LocalSend sessions expire, end cleanly and trust peers by what they proved
Beeb8d9a578207f
diff --git a/core/nectarlink-core/src/localsend.rs b/core/nectarlink-core/src/localsend.rsindex 100cba4..b7f72a2 100644--- a/core/nectarlink-core/src/localsend.rs+++ b/core/nectarlink-core/src/localsend.rs@@ -77,6 +77,10 @@ const PROGRESS_EVERY: Duration = Duration::from_millis(150);const UPLOAD_CHUNK: usize = 64 * 1024;const MAX_HEADER_BYTES: usize = 64 * 1024;const MAX_JSON_BODY_BYTES: usize = 4 * 1024 * 1024;+/// An accepted upload session with no upload for this long is dropped.+const SESSION_IDLE: Duration = Duration::from_secs(30 * 60);+/// Connections served at once; more wait in the OS backlog.+const MAX_CONNECTIONS: usize = 64;/// A LocalSend device discovered on the local network.#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]@@ -228,6 +232,8 @@ struct IncomingFileSpec {sha256: Option<String>,part_path: PathBuf,uploaded: bool,+ /// An upload of this file is under way (a second one is refused).+ uploading: bool,}struct UploadSession {@@ -239,6 +245,10 @@ struct UploadSession {saved_items: Vec<PathBuf>,cancel: CancellationToken,last_progress: Instant,+ /// The last upload request or progress, for expiring idle sessions.+ last_activity: Instant,+ /// The sender's address; only it may cancel the session.+ peer_ip: std::net::IpAddr,}struct RunningState {@@ -291,7 +301,11 @@ impl LocalSendState {let id = generate_self_signed_identity()?;stored.cert_der_hex = data_encoding::HEXLOWER.encode(&id.cert_der);stored.key_pkcs8_hex = data_encoding::HEXLOWER.encode(&id.key_pkcs8);- let _ = save_stored_state(data_dir, &*protector, &stored);+ if let Err(e) = save_stored_state(data_dir, &*protector, &stored) {+ // Runs anyway; the next start makes a new identity, which+ // LocalSend peers see as a new device.+ tracing::warn!(error = %e, "can't save the LocalSend identity");+ }id}};@@ -333,13 +347,14 @@ impl LocalSendState {}pub fn set_enabled(&self, shared: &Arc<Shared>, enabled: bool) -> Result<()> {- let prev = self.enabled.swap(enabled, Ordering::SeqCst);let stored = StoredLocalSendState {enabled,cert_der_hex: data_encoding::HEXLOWER.encode(&self.identity.cert_der),key_pkcs8_hex: data_encoding::HEXLOWER.encode(&self.identity.key_pkcs8),};+ // Saved first, so memory never disagrees with disk.save_stored_state(&self.data_dir, &*self.protector, &stored)?;+ let prev = self.enabled.swap(enabled, Ordering::SeqCst);if enabled && !prev {self.start(shared);@@ -377,6 +392,9 @@ impl LocalSendState {}let changed = {let mut map = self.peers.lock().unwrap_or_else(|e| e.into_inner());+ if downgrades(map.get(&peer.id), &peer) {+ return false;+ }map.insert(peer.id, peer.clone()).as_ref() != Some(&peer)};if changed {@@ -459,7 +477,15 @@ impl LocalSendState {let tcp_cancel = cancel.child_token();tokio::spawn(async move {let Ok(listener) = TcpListener::from_std(std_listener) else { return };+ let slots = Arc::new(tokio::sync::Semaphore::new(MAX_CONNECTIONS));loop {+ let slot = tokio::select! {+ _ = tcp_cancel.cancelled() => return,+ slot = slots.clone().acquire_owned() => match slot {+ Ok(slot) => slot,+ Err(_) => return,+ },+ };let accepted = tokio::select! {_ = tcp_cancel.cancelled() => return,res = listener.accept() => res,@@ -469,6 +495,7 @@ impl LocalSendState {let conn_cancel = tcp_cancel.child_token();tokio::spawn(async move {handle_incoming_connection(shared, stream, remote_addr, conn_cancel).await;+ drop(slot);});}});@@ -551,12 +578,75 @@ impl LocalSendState {for (_, tx) in self.pending_approvals.lock().unwrap_or_else(|e| e.into_inner()).drain() {let _ = tx.send(false);}- for (_, session) in self.sessions.lock().unwrap_or_else(|e| e.into_inner()).drain() {- let s = session.lock().unwrap_or_else(|e| e.into_inner());- s.cancel.cancel();+ let sessions: Vec<_> = self.sessions.lock().unwrap_or_else(|e| e.into_inner()).drain().collect();+ for (_, session) in sessions {+ end_session(shared, &session, TransferState::Cancelled);}shared.emit(NodeEvent::LocalSendChanged);}++ /// Ends sessions that have had no upload for [`SESSION_IDLE`].+ fn sweep_idle_sessions(&self, shared: &Shared) {+ let idle: Vec<_> = {+ let mut sessions = self.sessions.lock().unwrap_or_else(|e| e.into_inner());+ let ids: Vec<String> = sessions+ .iter()+ .filter(|(_, s)| {+ s.lock().unwrap_or_else(|e| e.into_inner()).last_activity.elapsed() >= SESSION_IDLE+ })+ .map(|(id, _)| id.clone())+ .collect();+ ids.into_iter().filter_map(|id| sessions.remove(&id)).collect()+ };+ for session in idle {+ end_session(shared, &session, TransferState::Cancelled);+ }+ }+}++/// Whether `update` would move a peer known to speak HTTPS to plain HTTP. An+/// unauthenticated announce claiming its fingerprint mustn't do that.+fn downgrades(known: Option<&LocalSendPeer>, update: &LocalSendPeer) -> bool {+ update.protocol == "http" && known.is_some_and(|known| known.protocol == "https")+}++/// Ends an upload session that's already out of the session map: stops it,+/// removes its staged parts and reports it as `state`. Files it already saved+/// stay, with a timeline entry saying so.+fn end_session(shared: &Shared, session: &Arc<Mutex<UploadSession>>, state: TransferState) {+ let (transfer, staging_dir) = {+ let mut guard = session.lock().unwrap_or_else(|e| e.into_inner());+ guard.cancel.cancel();+ guard.transfer.state = state;+ record_partial_delivery(shared, &guard);+ (guard.transfer.clone(), guard.staging_dir.clone())+ };+ shared.unregister_transfer(&transfer.id);+ let _ = fs::remove_dir_all(&staging_dir);+ shared.emit(NodeEvent::Transfer(transfer));+}++/// A timeline entry for the files a session saved before it ended early.+fn record_partial_delivery(shared: &Shared, session: &UploadSession) {+ let saved_files = session.files.iter().filter(|f| f.uploaded).count();+ if saved_files == 0 {+ return;+ }+ let target =+ session.saved_items.iter().map(|p| p.to_string_lossy().into_owned()).collect::<Vec<_>>().join("\n");+ let _ = shared.record_timeline(NewTimelineEntry {+ kind: TimelineKind::File,+ device_id: session.transfer.device,+ device_name: session.peer_name.clone(),+ incoming: true,+ timestamp: crate::now_unix(),+ title: transfer_timeline_title(&session.transfer.names),+ detail: format!("Partly received · {saved_files} of {} files (LocalSend)", session.files.len()),+ target,+ size_bytes: session.files.iter().filter(|f| f.uploaded).map(|f| f.size).sum(),+ duration_secs: 0,+ ref_id: Some(session.transfer.id.clone()),+ });}fn build_our_multicast_dto(shared: &Shared, port: u16, announce: bool) -> MulticastDto {@@ -694,6 +784,8 @@ pub(crate) async fn probe_peer(shared: &Arc<Shared>, host: &str, port: u16) -> Rlet Ok(mut stream) = connect_peer_stream(shared, host, port, use_tls, None).await else {continue;};+ // From here on it has answered over TLS: whatever fails next, it isn't+ // tried again in cleartext.let req_res = if shared.localsend.receiving() {let dto = build_our_multicast_dto(shared, shared.localsend.bound_port(), false);let body = serde_json::to_vec(&dto).unwrap_or_default();@@ -718,16 +810,16 @@ pub(crate) async fn probe_peer(shared: &Arc<Shared>, host: &str, port: u16) -> R.await};if req_res.is_err() {- continue;+ if use_tls { return Err(Error::Offline) } else { continue }}let Ok(resp) = read_http_response(&mut stream).await else {- continue;+ if use_tls { return Err(Error::Offline) } else { continue }};if !(200..300).contains(&resp.status) {- continue;+ if use_tls { return Err(Error::Offline) } else { continue }}let Ok(info) = serde_json::from_slice::<InfoDto>(&resp.body) else {- continue;+ if use_tls { return Err(Error::Offline) } else { continue }};if info.fingerprint == shared.localsend.identity.fingerprint || info.alias.trim().is_empty() {return Err(Error::NotFound);@@ -735,7 +827,7 @@ pub(crate) async fn probe_peer(shared: &Arc<Shared>, host: &str, port: u16) -> R// Over HTTPS the fingerprint it claims must be its certificate's.if use_tls && !stream.has_fingerprint(&info.fingerprint) {tracing::warn!(%host, port, "LocalSend peer's certificate doesn't match its fingerprint");- continue;+ if use_tls { return Err(Error::Offline) } else { continue }}let peer_port = info.port.unwrap_or(port);let peer_proto = info@@ -881,7 +973,7 @@ async fn handle_incoming_connection(handle_upload(&shared, &mut stream, &head, query).await;}("POST", "/api/localsend/v2/cancel" | "/api/localsend/v1/cancel") => {- handle_cancel(&shared, &mut stream, query).await;+ handle_cancel(&shared, &mut stream, query, remote_addr).await;}_ => {let _ = write_http_response(&mut stream, 404, "Not Found", None, &[]).await;@@ -905,6 +997,13 @@ async fn handle_prepare_upload(let _ = write_http_response(stream, 400, "Bad Request", None, &[]).await;return;}+ // Each file is uploaded by its id, so two with one id could never both arrive.+ let mut ids = std::collections::HashSet::with_capacity(req.files.len());+ if !req.files.values().all(|f| ids.insert(f.id.as_str())) {+ let _ = write_http_response(stream, 400, "Bad Request", None, &[]).await;+ return;+ }+ shared.localsend.sweep_idle_sessions(shared);let ip = remote_addr.ip().to_string();let port = req.info.port.unwrap_or(LOCALSEND_DEFAULT_PORT);@@ -970,6 +1069,7 @@ async fn handle_prepare_upload(.map(|h| h.to_ascii_lowercase()),part_path: staging_dir.join(format!("{idx}.part")),uploaded: false,+ uploading: false,});}@@ -1031,6 +1131,8 @@ async fn handle_prepare_upload(saved_items: Vec::new(),cancel: cancel.clone(),last_progress: Instant::now() - PROGRESS_EVERY,+ last_activity: Instant::now(),+ peer_ip: remote_addr.ip(),}));shared.localsend.sessions.lock().unwrap_or_else(|e| e.into_inner()).insert(session_id.clone(), session);@@ -1048,6 +1150,7 @@ async fn handle_upload(shared: &Arc<Shared>, stream: &mut ServerStream, head: &Hreturn;};+ shared.localsend.sweep_idle_sessions(shared);let Some(session_arc) =shared.localsend.sessions.lock().unwrap_or_else(|e| e.into_inner()).get(&session_id).cloned()else {@@ -1062,18 +1165,27 @@ async fn handle_upload(shared: &Arc<Shared>, stream: &mut ServerStream, head: &H}let lookup = {- let guard = session_arc.lock().unwrap_or_else(|e| e.into_inner());- match guard.files.iter().enumerate().find(|(_, f)| f.file_id == file_id) {+ let mut guard = session_arc.lock().unwrap_or_else(|e| e.into_inner());+ guard.last_activity = Instant::now();+ let cancel = guard.cancel.clone();+ let transfer_id = guard.transfer.id.clone();+ match guard.files.iter_mut().enumerate().find(|(_, f)| f.file_id == file_id) {None => UploadLookup::NotFound,- Some((_, spec)) if spec.token != token || spec.uploaded => UploadLookup::Forbidden,- Some((idx, spec)) => UploadLookup::Found(- idx,- spec.part_path.clone(),- spec.size,- spec.sha256.clone(),- guard.cancel.clone(),- guard.transfer.id.clone(),- ),+ // Two uploads of one file at once would write the same part file.+ Some((_, spec)) if spec.token != token || spec.uploaded || spec.uploading => {+ UploadLookup::Forbidden+ }+ Some((idx, spec)) => {+ spec.uploading = true;+ UploadLookup::Found(+ idx,+ spec.part_path.clone(),+ spec.size,+ spec.sha256.clone(),+ cancel,+ transfer_id,+ )+ }}};@@ -1096,6 +1208,7 @@ async fn handle_upload(shared: &Arc<Shared>, stream: &mut ServerStream, head: &Hlet stream_res = stream_body_to_file(stream, head, &mut out, expected_size, &cancel, |delta| {let mut guard = session_arc.lock().unwrap_or_else(|e| e.into_inner());+ guard.last_activity = Instant::now();guard.transfer.done = guard.transfer.done.saturating_add(delta);if guard.last_progress.elapsed() >= PROGRESS_EVERY {guard.last_progress = Instant::now();@@ -1122,14 +1235,8 @@ async fn handle_upload(shared: &Arc<Shared>, stream: &mut ServerStream, head: &Hif let Err(err_state) = stream_res {shared.localsend.sessions.lock().unwrap_or_else(|e| e.into_inner()).remove(&session_id);- shared.unregister_transfer(&transfer_id);- let staging_dir = {- let mut guard = session_arc.lock().unwrap_or_else(|e| e.into_inner());- guard.transfer.state = err_state;- shared.emit(NodeEvent::Transfer(guard.transfer.clone()));- guard.staging_dir.clone()- };- let _ = tokio::fs::remove_dir_all(&staging_dir).await;+ let (shared_ref, session) = (shared.clone(), session_arc.clone());+ let _ = tokio::task::spawn_blocking(move || end_session(&shared_ref, &session, err_state)).await;let _ = write_http_response(stream, 500, "Upload Interrupted", None, &[]).await;return;}@@ -1137,6 +1244,8 @@ async fn handle_upload(shared: &Arc<Shared>, stream: &mut ServerStream, head: &H// Move completed part file into downloads_dir.let finalize_res = finalize_uploaded_file(shared, &session_arc, spec_idx).await;if finalize_res.is_err() {+ // The part file is still there: the sender may try this file again.+ session_arc.lock().unwrap_or_else(|e| e.into_inner()).files[spec_idx].uploading = false;let _ = write_http_response(stream, 500, "Internal Server Error", None, &[]).await;return;}@@ -1204,6 +1313,9 @@ async fn finalize_uploaded_file(let downloads_dir = shared.downloads_dir.clone();let session_arc = session_arc.clone();tokio::task::spawn_blocking(move || {+ // Sessions finishing at once could pick the same free name.+ static FINALIZE: Mutex<()> = Mutex::new(());+ let _one_at_a_time = FINALIZE.lock().unwrap_or_else(|e| e.into_inner());fs::create_dir_all(&downloads_dir)?;let mut guard = session_arc.lock().unwrap_or_else(|e| e.into_inner());let folder = guard.files[spec_idx].folder.clone();@@ -1240,27 +1352,35 @@ async fn finalize_uploaded_file(guard.saved_items.push(dest);}guard.files[spec_idx].uploaded = true;+ guard.files[spec_idx].uploading = false;Ok(())}).await.map_err(std::io::Error::other)?}-async fn handle_cancel(shared: &Arc<Shared>, stream: &mut ServerStream, query: &str) {+async fn handle_cancel(+ shared: &Arc<Shared>,+ stream: &mut ServerStream,+ query: &str,+ remote_addr: SocketAddr,+) {let params = parse_query(query);let removed = params.get("sessionId").and_then(|session_id| {- shared.localsend.sessions.lock().unwrap_or_else(|e| e.into_inner()).remove(session_id)+ let mut sessions = shared.localsend.sessions.lock().unwrap_or_else(|e| e.into_inner());+ // Only the sender cancels its session. Anyone else gets the same+ // answer, so it doesn't learn which sessions exist.+ let from_sender = sessions+ .get(session_id)+ .is_some_and(|s| s.lock().unwrap_or_else(|e| e.into_inner()).peer_ip == remote_addr.ip());+ if from_sender { sessions.remove(session_id) } else { None }});if let Some(session_arc) = removed {- let (transfer_id, staging_dir, mut transfer) = {- let guard = session_arc.lock().unwrap_or_else(|e| e.into_inner());- guard.cancel.cancel();- (guard.transfer.id.clone(), guard.staging_dir.clone(), guard.transfer.clone())- };- shared.unregister_transfer(&transfer_id);- let _ = tokio::fs::remove_dir_all(&staging_dir).await;- transfer.state = TransferState::Cancelled;- shared.emit(NodeEvent::Transfer(transfer));+ let shared_ref = shared.clone();+ let _ = tokio::task::spawn_blocking(move || {+ end_session(&shared_ref, &session_arc, TransferState::Cancelled)+ })+ .await;}let _ = write_http_response(stream, 200, "OK", None, &[]).await;}@@ -2037,7 +2157,13 @@ fn split_localsend_file_name(raw: &str) -> (Option<String>, String) {[] => (None, "file".into()),[single] => (None, safe_file_name(single)),[folders @ .., last] => {- let folder = folders.iter().map(|s| storable_name(s)).collect::<Vec<_>>().join("/");+ // As deep and as long as the protocol allows (files::MAX_FOLDER_DEPTH).+ let folder = folders+ .iter()+ .take(files::MAX_FOLDER_DEPTH)+ .map(|s| storable_name(&safe_file_name(s)))+ .collect::<Vec<_>>()+ .join("/");(Some(folder), safe_file_name(last))}}@@ -2476,6 +2602,36 @@ mod tests {assert!(res.is_err());}+ #[test]+ fn incoming_folders_are_capped_in_depth_and_name_length() {+ let deep = (0..50).map(|i| format!("d{i}")).collect::<Vec<_>>().join("/") + "/f.txt";+ let (folder, name) = split_localsend_file_name(&deep);+ assert_eq!(folder.unwrap().split('/').count(), files::MAX_FOLDER_DEPTH);+ assert_eq!(name, "f.txt");++ let long = format!("{}/f.txt", "x".repeat(400));+ let (folder, _) = split_localsend_file_name(&long);+ assert_eq!(folder.unwrap().len(), files::MAX_NAME_BYTES);+ }++ #[test]+ fn a_known_https_peer_isnt_moved_to_http() {+ let peer = |protocol: &str| LocalSendPeer {+ id: DeviceId([7; 32]),+ alias: "Laptop".into(),+ device_model: None,+ device_type: "desktop".into(),+ fingerprint: "fp".into(),+ ip: "192.168.1.5".into(),+ port: 53317,+ protocol: protocol.into(),+ };+ assert!(downgrades(Some(&peer("https")), &peer("http")));+ assert!(!downgrades(Some(&peer("http")), &peer("https")));+ assert!(!downgrades(Some(&peer("https")), &peer("https")));+ assert!(!downgrades(None, &peer("http")), "a new HTTP-only peer is fine");+ }+#[test]fn sha256_file_hex_matches_a_known_digest() {let dir = tempfile::tempdir().unwrap();diff --git a/core/nectarlink-core/tests/two_devices.rs b/core/nectarlink-core/tests/two_devices.rsindex 0a37a79..aca45e1 100644--- a/core/nectarlink-core/tests/two_devices.rs+++ b/core/nectarlink-core/tests/two_devices.rs@@ -4680,6 +4680,146 @@ async fn localsend_discovers_peer_requires_accept_and_transfers_files_over_httpsreceiver.node.shutdown().await;}+/// One HTTP/1.1 request over plain TCP to a LocalSend server, as a LocalSend+/// sender would send it; returns the status and the body.+async fn localsend_request(port: u16, method: &str, target: &str, body: &[u8]) -> (u16, Vec<u8>) {+ use tokio::io::{AsyncReadExt, AsyncWriteExt};+ let mut tcp = tokio::net::TcpStream::connect(("127.0.0.1", port)).await.unwrap();+ let head = format!(+ "{method} {target} HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nContent-Type: application/json\r\n\+ Content-Length: {}\r\nConnection: close\r\n\r\n",+ body.len()+ );+ tcp.write_all(head.as_bytes()).await.unwrap();+ tcp.write_all(body).await.unwrap();+ let mut out = Vec::new();+ let _ = tcp.read_to_end(&mut out).await;+ let text = String::from_utf8_lossy(&out);+ let status = text.split(' ').nth(1).and_then(|c| c.parse().ok()).unwrap_or(0);+ let split = out.windows(4).position(|w| w == b"\r\n\r\n").map_or(out.len(), |i| i + 4);+ (status, out[split..].to_vec())+}++fn localsend_offer(files: &[(&str, &str, &str, u64)]) -> Vec<u8> {+ let files: serde_json::Map<String, serde_json::Value> = files+ .iter()+ .map(|(key, id, name, size)| {+ (+ (*key).to_owned(),+ serde_json::json!({ "id": id, "fileName": name, "size": size, "fileType": "text/plain" }),+ )+ })+ .collect();+ serde_json::to_vec(&serde_json::json!({+ "info": { "alias": "Raw sender", "version": "2.1", "deviceType": "mobile", "fingerprint": "raw-sender-fp", "port": 1, "protocol": "http" },+ "files": files,+ }))+ .unwrap()+}++fn part_files(dir: &std::path::Path) -> Vec<std::path::PathBuf> {+ let mut found = Vec::new();+ for entry in std::fs::read_dir(dir).into_iter().flatten().flatten() {+ let path = entry.path();+ if path.is_dir() {+ found.extend(part_files(&path));+ } else if path.extension().is_some_and(|e| e == "part") {+ found.push(path);+ }+ }+ found+}++/// A sender that offers duplicate file ids is refused; one that sends one of+/// two files and cancels leaves that file, a timeline entry saying it only+/// partly arrived, no staged parts, and no session (#72 audit).+#[tokio::test]+async fn localsend_refuses_duplicate_ids_and_records_a_cancelled_partial_delivery() {+ let port = free_tcp_port();+ let mut receiver =+ start_localsend_in(tempfile::tempdir().unwrap(), "PC Receiver", DeviceKind::Desktop, port).await;+ receiver.node.set_localsend_enabled(true).unwrap();+ for _ in 0..40 {+ if receiver.node.localsend_receiving() {+ break;+ }+ tokio::time::sleep(Duration::from_millis(50)).await;+ }+ assert!(receiver.node.localsend_receiving());++ let (status, _) = localsend_request(+ port,+ "POST",+ "/api/localsend/v2/prepare-upload",+ &localsend_offer(&[("a", "same", "a.txt", 5), ("b", "same", "b.txt", 5)]),+ )+ .await;+ assert_eq!(status, 400, "two files with one id could never both arrive");++ let offer = localsend_offer(&[("f1", "f1", "first.txt", 5), ("f2", "f2", "second.txt", 6)]);+ let prepare = tokio::spawn(async move {+ localsend_request(port, "POST", "/api/localsend/v2/prepare-upload", &offer).await+ });+ let req: Transfer = wait_for(&mut receiver, "offer", |e| match e {+ NodeEvent::Transfer(t) if t.state == TransferState::Requested => Some(t.clone()),+ _ => None,+ })+ .await;+ receiver.node.accept_transfer(&req.id);+ let (status, body) = with_timeout("prepare-upload", prepare).await.unwrap();+ assert_eq!(status, 200);+ let answer: serde_json::Value = serde_json::from_slice(&body).unwrap();+ let session = answer["sessionId"].as_str().unwrap().to_owned();+ let token = answer["files"]["f1"].as_str().unwrap().to_owned();++ let (status, _) = localsend_request(+ port,+ "POST",+ &format!("/api/localsend/v2/upload?sessionId={session}&fileId=f1&token={token}"),+ b"hello",+ )+ .await;+ assert_eq!(status, 200);+ let (status, _) = localsend_request(+ port,+ "POST",+ &format!("/api/localsend/v2/upload?sessionId={session}&fileId=f1&token={token}"),+ b"again",+ )+ .await;+ assert_eq!(status, 403, "a file that arrived isn't uploaded twice");++ let (status, _) =+ localsend_request(port, "POST", &format!("/api/localsend/v2/cancel?sessionId={session}"), b"").await;+ assert_eq!(status, 200);+ wait_for(&mut receiver, "cancelled", |e| match e {+ NodeEvent::Transfer(t) if t.id == req.id && t.state == TransferState::Cancelled => Some(()),+ _ => None,+ })+ .await;++ let saved = receiver.dir.path().join("received").join("first.txt");+ assert_eq!(std::fs::read(&saved).unwrap(), b"hello", "what arrived is kept");+ let entries =+ receiver.node.timeline_page(&nectarlink_core::timeline::TimelineQuery::default()).unwrap().entries;+ assert!(+ entries.iter().any(|e| e.detail.contains("1 of 2 files") && e.target.contains("first.txt")),+ "{:?}",+ entries.iter().map(|e| &e.detail).collect::<Vec<_>>()+ );+ assert!(part_files(receiver.dir.path()).is_empty(), "no staged parts are left");+ let (status, _) = localsend_request(+ port,+ "POST",+ &format!("/api/localsend/v2/upload?sessionId={session}&fileId=f2&token=x"),+ b"second",+ )+ .await;+ assert_eq!(status, 404, "the session is gone");++ receiver.node.shutdown().await;+}+#[tokio::test]async fn localsend_declining_transfer_returns_denied_to_sender() {let sender_port = free_tcp_port();