diff --git i/src/node/tests/forwarding.rs w/src/node/tests/forwarding.rs index 9f9f97d..9f42f32 100644 --- i/src/node/tests/forwarding.rs +++ w/src/node/tests/forwarding.rs @@ -2442,3 +2442,83 @@ async fn a_foreign_root_write_is_not_counted_as_a_key_mismatch() { "a write refused for a foreign root was also counted as a key mismatch" ); } + +// Local Archipelago diagnostic only: not a change to the pinned dependency. +// The server/phone LAN edge goes silent while both retain their anchor edge. +#[tokio::test] +async fn archy_lost_lan_peer_blocks_live_anchor_return_until_remote_cleanup() { + let _ = tracing_subscriber::fmt().with_max_level(tracing::Level::DEBUG).with_test_writer().try_init(); + let acl_dir = tempfile::tempdir().unwrap(); + std::fs::write(acl_dir.path().join("allow"), "").unwrap(); + std::fs::write(acl_dir.path().join("deny"), "").unwrap(); + let mut nodes = vec![spanning_tree::make_test_node().await, spanning_tree::make_test_node().await, spanning_tree::make_test_node().await]; + for node in &mut nodes { + node.node.peer_acl = crate::node::acl::PeerAclReloader::with_paths(acl_dir.path().join("allow"), acl_dir.path().join("deny")); + } + for (a,b) in [(0,1),(0,2),(1,2)] { spanning_tree::initiate_handshake(&mut nodes,a,b).await; } + spanning_tree::drain_all_packets(&mut nodes,true).await; + nodes.sort_by_key(|n| *n.node.node_addr()); + const ANCHOR: usize = 0; + const SERVER: usize = 1; + const PHONE: usize = 2; + verify_tree_convergence(&nodes); + populate_all_coord_caches(&mut nodes); + let server = *nodes[SERVER].node.node_addr(); + let phone = *nodes[PHONE].node.node_addr(); + let anchor = *nodes[ANCHOR].node.node_addr(); + let server_key = nodes[SERVER].node.identity().pubkey_full(); + let server_transport = nodes[SERVER].addr.clone(); + let phone_transport = nodes[PHONE].addr.clone(); + + // Android can immediately discard its vanished local edge; the remote + // still considers that edge alive until its liveness check removes it. + nodes[PHONE].node.remove_active_peer(&server); + populate_all_coord_caches(&mut nodes); + assert_eq!(*nodes[PHONE].node.find_next_hop(&server).unwrap().node_addr(), anchor); + assert_eq!(*nodes[SERVER].node.find_next_hop(&phone).unwrap().node_addr(), phone); + nodes[PHONE].node.initiate_session(server, server_key).await.unwrap(); + + async fn deliver_except_lost_lan( + nodes: &mut [TestNode], server_transport: &TransportAddr, phone_transport: &TransportAddr, + ) -> usize { + let mut discarded = 0; + for _ in 0..24 { + let queued: Vec<_> = nodes.iter().map(|n| n.packet_rx.len()).collect(); + if queued.iter().all(|n| *n == 0) { break; } + for (index, count) in queued.into_iter().enumerate() { + for _ in 0..count { + let packet = nodes[index].packet_rx.try_recv().unwrap(); + if (index == PHONE && &packet.remote_addr == server_transport) + || (index == SERVER && &packet.remote_addr == phone_transport) { + discarded += 1; + continue; + } + use crate::proto::fmp::wire::{CommonPrefix, PHASE_MSG1, PHASE_MSG2, PHASE_ESTABLISHED}; + if let Some(prefix) = CommonPrefix::parse(&packet.data) { + match prefix.phase { + PHASE_MSG1 => nodes[index].node.handle_msg1(packet).await, + PHASE_MSG2 => nodes[index].node.handle_msg2(packet).await, + PHASE_ESTABLISHED => nodes[index].node.handle_encrypted_frame(packet).await, + _ => {} + } + } + } + } + } + discarded + } + let lost = deliver_except_lost_lan(&mut nodes, &server_transport, &phone_transport).await; + assert!(lost > 0, "server should still send the reply toward the vanished LAN edge"); + assert!(!nodes[PHONE].node.get_session(&server).unwrap().is_established()); + + // Model the remote dead-link cleanup, without sleeping for 30 seconds. + nodes[SERVER].node.remove_active_peer(&phone); + populate_all_coord_caches(&mut nodes); + assert_eq!(*nodes[SERVER].node.find_next_hop(&phone).unwrap().node_addr(), anchor); + let retry_at = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_millis() as u64 + 2_000; + nodes[PHONE].node.resend_pending_session_handshakes(retry_at).await; + deliver_except_lost_lan(&mut nodes, &server_transport, &phone_transport).await; + assert!(nodes[PHONE].node.get_session(&server).unwrap().is_established(), "the same anchor path must work after remote cleanup"); + assert!(nodes[SERVER].node.get_session(&phone).unwrap().is_established()); + cleanup_nodes(&mut nodes).await; +}