fix(transport): relay announces among peers of a multipoint interface

defidude · defidude · commit f2751f4b57a7 · 2026-07-01T21:09:07.000-06:00
BLE Peer presents many hidden-from-each-other GATT links as one interface;
without back-out relay a hub never propagates announces between its peers,
breaking multi-hop discovery past two nodes.
diff --git a/crates/rns-runtime/src/reticulum.rs b/crates/rns-runtime/src/reticulum.rs
@@ -1337,6 +1337,7 @@ pub async fn init(
                     role,
                     ingress_overrides,
                     &reg_controls,
+                    false,
                 )
                 .await;
             }
@@ -1671,6 +1672,7 @@ async fn register_interface_handle_with_role(
         role,
         rns_transport::ingress::IngressOverrides::default(),
         interface_controls,
+        false,
     )
     .await;
 }
@@ -1681,6 +1683,7 @@ async fn register_interface_handle_with_role_and_overrides(
     role: rns_transport::messages::InterfaceRole,
     ingress_overrides: rns_transport::ingress::IngressOverrides,
     interface_controls: &InterfaceControlMap,
+    multipoint: bool,
 ) {
     let name = handle.name.clone();
     let id = handle.id;
@@ -1724,6 +1727,7 @@ async fn register_interface_handle_with_role_and_overrides(
         tx_drops: std::sync::Arc::new(std::sync::atomic::AtomicU64::new(0)),
         ingress,
         announce_queue: Vec::new(),
+        multipoint,
     };
     if let Err(e) = transport_tx
         .send(TransportMessage::RegisterInterface { id, entry })
@@ -1788,6 +1792,7 @@ async fn register_interface_with_post_init(
         tx_drops: std::sync::Arc::new(std::sync::atomic::AtomicU64::new(0)),
         ingress,
         announce_queue: Vec::new(),
+        multipoint: false,
     };
     if let Err(e) = transport_tx
         .send(TransportMessage::RegisterInterface { id, entry })
@@ -3223,10 +3228,15 @@ pub async fn spawn_ble_peer_runtime(
         format!("BLE Peer spawn failed: {e}")
     })?;
 
-    register_interface_handle(
+    // multipoint = true: BLE peers can't hear each other, so the transport must
+    // relay announces back out this interface to reach its other peers.
+    register_interface_handle_with_role_and_overrides(
         &handle.transport_tx,
         iface_handle,
+        rns_transport::messages::InterfaceRole::Normal,
+        rns_transport::ingress::IngressOverrides::default(),
         &handle.interface_controls,
+        true,
     )
     .await;
     tracing::info!(name = %name, id, "runtime BLE Peer mesh interface spawned");
diff --git a/crates/rns-transport/src/actor/mod.rs b/crates/rns-transport/src/actor/mod.rs
@@ -1048,7 +1048,16 @@ impl TransportActor {
         let Some(entry) = self.interfaces.get(&id) else {
             return false;
         };
-        if except == Some(id) || !entry.direction.outbound {
+        if !entry.direction.outbound {
+            return false;
+        }
+        // Normally an announce is never sent back out its source interface
+        // (loopback / dedup churn on a shared medium). A multipoint interface
+        // (e.g. BLE Peer) is the exception: its peers can't hear each other, so
+        // relaying back out reaches the ones the source peer couldn't. The
+        // driver's per-peer anti-loop filter keeps it off the source peer, and
+        // the announce-table dedup + hop cap bound propagation.
+        if except == Some(id) && !entry.multipoint {
             return false;
         }
 
@@ -1544,6 +1553,7 @@ mod tests {
             rxb: None,
             txb: None,
             tx_drops: std::sync::Arc::new(std::sync::atomic::AtomicU64::new(0)),
+            multipoint: false,
             ingress: crate::ingress::IngressController::new(),
             announce_queue: Vec::new(),
         };
@@ -1596,6 +1606,30 @@ mod tests {
         assert_eq!(actor.interfaces.get(&1).unwrap().name, "test_iface");
     }
 
+    #[test]
+    fn test_multipoint_interface_relays_announce_to_source() {
+        let (mut actor, _tx) = TransportActor::new();
+        let dest = [0xAB; 16];
+
+        // Point-to-multipoint medium whose peers can't hear each other:
+        // an announce arriving here must be allowed back out the same
+        // interface. A normal interface must still exclude its source.
+        let (normal, _rx) = make_test_interface("normal");
+        actor.interfaces.insert(1, normal);
+        let (mut mp, _rx2) = make_test_interface("ble");
+        mp.multipoint = true;
+        actor.interfaces.insert(2, mp);
+
+        assert!(
+            !actor.interface_allows_announce(1, &dest, Some(1)),
+            "normal interface must not relay an announce back to its source"
+        );
+        assert!(
+            actor.interface_allows_announce(2, &dest, Some(2)),
+            "multipoint interface must relay an announce back to its other peers"
+        );
+    }
+
     #[test]
     fn test_deregister_interface() {
         let (mut actor, _tx) = TransportActor::new();
diff --git a/crates/rns-transport/src/messages.rs b/crates/rns-transport/src/messages.rs
@@ -96,6 +96,13 @@ pub struct InterfaceEntry {
     /// Announces awaiting bandwidth-capped retransmission. Drained in
     /// hop-priority order (lowest hops first, oldest among ties).
     pub announce_queue: Vec<QueuedAnnounce>,
+    /// Multipoint medium whose peers cannot hear each other (e.g. BLE Peer:
+    /// each peer is a separate point-to-point GATT link presented as one
+    /// interface). Unlike a shared broadcast medium, an announce arriving on
+    /// such an interface must be relayed back out the SAME interface to reach
+    /// its other peers. Loop safety comes from the announce-table dedup + hop
+    /// cap and the driver's own per-peer anti-loop filter.
+    pub multipoint: bool,
 }
 
 impl InterfaceEntry {
@@ -131,9 +138,15 @@ impl InterfaceEntry {
             tx_drops: Arc::new(std::sync::atomic::AtomicU64::new(0)),
             ingress: IngressController::new(),
             announce_queue: Vec::new(),
+            multipoint: false,
         }
     }
 
+    pub fn with_multipoint(mut self, multipoint: bool) -> Self {
+        self.multipoint = multipoint;
+        self
+    }
+
     pub fn with_ifac(mut self, key: [u8; 64], size: usize) -> Self {
         self.ifac_key = Some(key);
         self.ifac_size = size;
