Skip to content

Your Android phone and your Windows PC, working as one. Local-first, end-to-end encrypted, no account.

fix(core): no request runs twice after a reconnect, and LAN-only keeps working with relay-first paths

Beef9b2a202aed0
diff --git a/core/nectarlink-core/src/node.rs b/core/nectarlink-core/src/node.rs
index 5953a21..1dc611a 100644
--- a/core/nectarlink-core/src/node.rs
+++ b/core/nectarlink-core/src/node.rs
@@ -624,25 +624,27 @@ impl Shared {
if self.away_mode() || self.is_usb_connection(conn) {
return true;
}
- let paths = conn.paths();
- let selected = paths.iter().find(|p| p.is_selected()).or_else(|| paths.iter().next());
- match selected {
- Some(p) if p.is_relay() => false,
- Some(p) => match p.remote_addr() {
- iroh::TransportAddr::Ip(addr) => self.is_usb_addr(addr) || self.is_allowed_peer_ip(addr.ip()),
- _ => false,
- },
- None => false,
- }
+ // Any direct LAN (or USB) path will do: a connection often reports its
+ // relay path first while the direct one comes up.
+ conn.paths().iter().any(|p| {
+ !p.is_relay()
+ && match p.remote_addr() {
+ iroh::TransportAddr::Ip(addr) => {
+ self.is_usb_addr(addr) || self.is_allowed_peer_ip(addr.ip())
+ }
+ _ => false,
+ }
+ })
}
pub(crate) async fn wait_connection_allowed(&self, conn: &Connection) -> bool {
if self.away_mode() || self.is_usb_connection(conn) {
return true;
}
+ // Up to 200 ms for a direct path, not just for the first path of any kind.
for _ in 0..20 {
- if !conn.paths().is_empty() {
- return self.is_connection_allowed(conn);
+ if self.is_connection_allowed(conn) {
+ return true;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
@@ -1110,8 +1112,8 @@ impl Shared {
if let Err(e) = self.store.update_info(&peer, &remote_device) {
tracing::warn!(error = %e, "failed to update peer info");
}
- let effective_device =
- self.store.get_peer(&peer).ok().flatten().map(|p| p.info).unwrap_or(remote_device);
+ // What the apps show is what's stored, so the event carries that.
+ let effective_device = self.store.get_peer(&peer).ok().flatten().map(|p| p.info);
let caps = features::sanitize_capabilities(remote.caps);
if let Err(e) = self.store.update_capabilities(&peer, Some(&caps), Some(remote.power.effective())) {
tracing::warn!(error = %e, "failed to update peer capabilities");
@@ -1158,7 +1160,9 @@ impl Shared {
tracing::warn!(error = %e, "failed to record peer addresses");
}
self.remember_addrs(&peer, &persisted_addrs);
- self.emit(NodeEvent::PeerInfoChanged { device: peer, info: effective_device });
+ if let Some(info) = effective_device {
+ self.emit(NodeEvent::PeerInfoChanged { device: peer, info });
+ }
self.emit(NodeEvent::PeerPowerChanged { device: peer, power: remote.power.effective() });
self.refresh_capabilities(&peer);
self.publish_online(&session);
@@ -1321,6 +1325,10 @@ async fn maintain(shared: Weak<Shared>, peer: DeviceId, wake: Arc<Notify>, cance
waited_for_usb = false;
continue;
}
+ // Unplugged before the PC dialled: the next plug-in gets its grace again.
+ if !node.usb_tunnel_inbound(&peer) {
+ waited_for_usb = false;
+ }
if node.session(&peer).is_none() && node.usb_tunnel_inbound(&peer) && !waited_for_usb {
// Plugged in: the PC dials through the cable. Dial only if it hasn't by then.
waited_for_usb = true;
@@ -1620,22 +1628,9 @@ impl Node {
tokio::task::spawn_blocking(move || transfer::clean_incoming(&incoming));
for peer in shared.store.list_peers()? {
- if !config.away_mode {
- let lan_only: Vec<SocketAddr> = peer
- .last_addrs
- .iter()
- .copied()
- .filter(|a| !a.ip().to_canonical().is_loopback() && crate::session::is_lan_ip(a.ip()))
- .collect();
- if lan_only.len() != peer.last_addrs.len()
- && let Some(seen) = peer.last_seen
- {
- let _ = shared.store.record_seen(&peer.id, seen, &lan_only);
- }
- shared.remember_addrs(&peer.id, &lan_only);
- } else {
- shared.remember_addrs(&peer.id, &peer.last_addrs);
- }
+ // remember_addrs keeps only LAN addresses while away mode is off.
+ // The stored list keeps the rest, for when it's turned on again.
+ shared.remember_addrs(&peer.id, &peer.last_addrs);
shared.start_supervisor(peer.id);
}
run_queue_coordinator(Arc::downgrade(&shared), shared.cancel.child_token());
@@ -1658,20 +1653,11 @@ impl Node {
session.close(CLOSE_NORMAL, b"away mode disabled");
}
}
+ // Only what's dialled changes (remember_addrs keeps LAN addresses
+ // now); the stored list keeps the others for turning it back on.
if let Ok(peers) = self.shared.store.list_peers() {
for peer in peers {
- let lan_only: Vec<SocketAddr> = peer
- .last_addrs
- .iter()
- .copied()
- .filter(|a| !a.ip().to_canonical().is_loopback() && crate::session::is_lan_ip(a.ip()))
- .collect();
- if lan_only.len() != peer.last_addrs.len()
- && let Some(seen) = peer.last_seen
- {
- let _ = self.shared.store.record_seen(&peer.id, seen, &lan_only);
- }
- self.shared.remember_addrs(&peer.id, &lan_only);
+ self.shared.remember_addrs(&peer.id, &peer.last_addrs);
}
}
} else {
@@ -1866,12 +1852,15 @@ impl Node {
/// on the new one, so requests must be idempotent.
async fn request(&self, peer: DeviceId, env: Envelope) -> Result<Envelope> {
let first = self.connected(&peer)?;
- match first.request(env.clone(), REQUEST_TIMEOUT).await {
- Err(Error::Offline) => match self.shared.session(&peer) {
+ match first.request_tracked(env.clone(), REQUEST_TIMEOUT).await {
+ // The connection was replaced before the request went out: send it
+ // on the new one. Once it went out it may have run (a reply to a
+ // chat, a notification's action), so it isn't sent twice.
+ (Err(Error::Offline), false) => match self.shared.session(&peer) {
Some(next) if !Arc::ptr_eq(&next, &first) => next.request(env, REQUEST_TIMEOUT).await,
_ => Err(Error::Offline),
},
- other => other,
+ (other, _) => other,
}
}
diff --git a/core/nectarlink-core/src/session.rs b/core/nectarlink-core/src/session.rs
index 33c748b..0470151 100644
--- a/core/nectarlink-core/src/session.rs
+++ b/core/nectarlink-core/src/session.rs
@@ -318,11 +318,20 @@ impl Session {
/// Sends a request and waits for the reply with the matching `re`.
pub async fn request(&self, env: Envelope, timeout: Duration) -> Result<Envelope> {
+ self.request_tracked(env, timeout).await.0
+ }
+
+ /// Like [`request`](Self::request), and also says whether the request was
+ /// sent. A request that went out may have run on the peer even if no
+ /// reply came back, so only an unsent one is safe to send again.
+ pub async fn request_tracked(&self, env: Envelope, timeout: Duration) -> (Result<Envelope>, bool) {
let id = self.next_id.fetch_add(1, Ordering::Relaxed);
let (tx, rx) = oneshot::channel();
self.pending.lock().unwrap_or_else(|e| e.into_inner()).insert(id, tx);
+ let mut sent = false;
let result = match tokio::time::timeout(timeout, async {
self.send(env.with_id(id)).await?;
+ sent = true;
rx.await.map_err(|_| Error::Offline)
})
.await
@@ -331,7 +340,7 @@ impl Session {
Err(_) => Err(Error::Timeout),
};
self.pending.lock().unwrap_or_else(|e| e.into_inner()).remove(&id);
- result
+ (result, sent)
}
/// Closes the connection with an application code.