bgp: resolve unnumbered peers from interface snapshots

Replace the BGP-facing unnumbered trait methods that returned separate
scope and neighbor projections with active-interface snapshot lookups.
The unnumbered manager now answers those lookups from a single active
interface map entry, so BGP callers receive the interface name, scope
ID, and discovered neighbor consistently.

Use the scope-indexed snapshot for inbound link-local session-key
resolution and the interface-indexed snapshot for outbound connection
target resolution.

Signed-off-by: Trey Aspelund <trey@oxidecomputer.com>

Author: taspelund

bgp/src/connection.rs

@@ -53,32 +53,21 @@ pub fn resolve_session_key(
     {
         match mgr.get_active_interface_by_scope(v6_addr.scope_id()) {
             Ok(Some(interface)) => {
-                match mgr.get_discovered_ndp_neighbor(&interface) {
-                    Ok(Some(neighbor)) if neighbor == *v6_addr.ip() => {
-                        return PeerId::Interface(interface);
-                    }
-                    Ok(Some(neighbor)) => {
-                        debug!(log,
-                            "incoming unnumbered peer does not match discovered NDP neighbor";
-                            "interface" => interface.as_str(),
-                            "peer" => peer_addr,
-                            "discovered" => neighbor.to_string(),
-                        );
-                    }
-                    Ok(None) => {
-                        debug!(log,
-                            "incoming unnumbered peer has no discovered NDP neighbor";
-                            "interface" => interface.as_str(),
-                            "peer" => peer_addr,
-                        );
-                    }
-                    Err(e) => {
-                        error!(log,
-                            "discovered unnumbered neighbor query error: {e}";
-                            "interface" => interface.as_str(),
-                            "error" => format!("{e}"),
-                        );
-                    }
+                if interface.discovered_neighbor == Some(*v6_addr.ip()) {
+                    return PeerId::Interface(interface.interface);
+                } else if let Some(neighbor) = interface.discovered_neighbor {
+                    debug!(log,
+                        "incoming unnumbered peer does not match discovered NDP neighbor";
+                        "interface" => interface.interface.as_str(),
+                        "peer" => peer_addr,
+                        "discovered" => neighbor.to_string(),
+                    );
+                } else {
+                    debug!(log,
+                        "incoming unnumbered peer has no discovered NDP neighbor";
+                        "interface" => interface.interface.as_str(),
+                        "peer" => peer_addr,
+                    );
                 }
             }
             // Fallback to IP-based key on failure/missing interface

bgp/src/dispatcher.rs

@@ -197,65 +197,57 @@ mod tests {
     use crate::{connection::resolve_session_key, session::PeerId};
     use slog::Logger;
     use std::{net::Ipv6Addr, sync::Arc};
-    use unnumbered::{BgpUnnumbered, UnnumberedError};
+    use unnumbered::{BgpUnnumbered, BgpUnnumberedInterface, UnnumberedError};
 
     struct TestUnnumbered {
-        scope_result: Result<Option<String>, UnnumberedError>,
-        neighbor_result: Result<Option<Ipv6Addr>, UnnumberedError>,
+        interface_result:
+            Result<Option<BgpUnnumberedInterface>, UnnumberedError>,
     }
 
     impl BgpUnnumbered for TestUnnumbered {
         fn get_active_interface_by_scope(
             &self,
             _scope_id: u32,
-        ) -> Result<Option<String>, UnnumberedError> {
-            self.scope_result.clone()
+        ) -> Result<Option<BgpUnnumberedInterface>, UnnumberedError> {
+            self.interface_result.clone()
         }
 
-        fn get_active_interface_scope_id(
+        fn get_active_interface(
             &self,
             _interface: &str,
-        ) -> Result<Option<u32>, UnnumberedError> {
+        ) -> Result<Option<BgpUnnumberedInterface>, UnnumberedError> {
             Ok(None)
         }
-
-        fn get_discovered_ndp_neighbor(
-            &self,
-            _interface: &str,
-        ) -> Result<Option<Ipv6Addr>, UnnumberedError> {
-            self.neighbor_result.clone()
-        }
     }
 
     fn log() -> Logger {
         Logger::root(slog::Discard, slog::o!())
     }
 
     fn unnumbered_manager(
-        scope_result: Result<Option<String>, UnnumberedError>,
+        interface_result: Result<
+            Option<BgpUnnumberedInterface>,
+            UnnumberedError,
+        >,
     ) -> Arc<dyn BgpUnnumbered> {
-        Arc::new(TestUnnumbered {
-            scope_result,
-            neighbor_result: Ok(None),
-        })
+        Arc::new(TestUnnumbered { interface_result })
     }
 
-    fn unnumbered_manager_with_neighbor(
-        scope_result: Result<Option<String>, UnnumberedError>,
-        neighbor_result: Result<Option<Ipv6Addr>, UnnumberedError>,
-    ) -> Arc<dyn BgpUnnumbered> {
-        Arc::new(TestUnnumbered {
-            scope_result,
-            neighbor_result,
-        })
+    fn active_interface(
+        discovered_neighbor: Option<Ipv6Addr>,
+    ) -> BgpUnnumberedInterface {
+        BgpUnnumberedInterface {
+            interface: "eth0".into(),
+            scope_id: 7,
+            discovered_neighbor,
+        }
     }
 
     #[test]
     fn discovered_link_local_uses_interface_key() {
-        let manager = unnumbered_manager_with_neighbor(
-            Ok(Some("eth0".into())),
-            Ok(Some("fe80::1".parse().unwrap())),
-        );
+        let manager = unnumbered_manager(Ok(Some(active_interface(Some(
+            "fe80::1".parse().unwrap(),
+        )))));
         let peer = "[fe80::1%7]:179".parse().unwrap();
 
         let key = resolve_session_key(peer, Some(&manager), &log());
@@ -265,7 +257,7 @@ mod tests {
 
     #[test]
     fn undiscovered_link_local_uses_ip_key() {
-        let manager = unnumbered_manager(Ok(Some("eth0".into())));
+        let manager = unnumbered_manager(Ok(Some(active_interface(None))));
         let peer = "[fe80::1%7]:179".parse().unwrap();
 
         let key = resolve_session_key(peer, Some(&manager), &log());
@@ -275,10 +267,9 @@ mod tests {
 
     #[test]
     fn mismatched_link_local_uses_ip_key() {
-        let manager = unnumbered_manager_with_neighbor(
-            Ok(Some("eth0".into())),
-            Ok(Some("fe80::2".parse().unwrap())),
-        );
+        let manager = unnumbered_manager(Ok(Some(active_interface(Some(
+            "fe80::2".parse().unwrap(),
+        )))));
         let peer = "[fe80::1%7]:179".parse().unwrap();
 
         let key = resolve_session_key(peer, Some(&manager), &log());
@@ -312,7 +303,9 @@ mod tests {
 
     #[test]
     fn non_link_local_address_uses_ip_session_key() {
-        let manager = unnumbered_manager(Ok(Some("eth0".into())));
+        let manager = unnumbered_manager(Ok(Some(active_interface(Some(
+            "fe80::1".parse().unwrap(),
+        )))));
         let peer = "[2001:db8::1]:179".parse().unwrap();
 
         let key = resolve_session_key(peer, Some(&manager), &log());

bgp/src/session.rs

@@ -1759,36 +1759,23 @@ impl<Cnx: BgpConnection + 'static> SessionRunner<Cnx> {
             PeerId::Interface(iface) => {
                 // Unnumbered: query BgpUnnumbered for NDP neighbor
                 let mgr = self.unnumbered_manager.as_ref()?;
-                match mgr.get_discovered_ndp_neighbor(iface) {
-                    Ok(Some(addr)) => {
-                        match mgr.get_active_interface_scope_id(iface) {
-                            Ok(Some(scope_id)) => {
-                                Some(SocketAddr::V6(SocketAddrV6::new(
-                                    addr,
-                                    self.neighbor.port.get(),
-                                    0,
-                                    scope_id,
-                                )))
-                            }
-                            Ok(None) => None,
-                            Err(e) => {
-                                session_log_lite!(
-                                    self,
-                                    debug,
-                                    "failed to query scope for interface";
-                                    "interface" => iface,
-                                    "error" => e.to_string()
-                                );
-                                None
-                            }
-                        }
+                match mgr.get_active_interface(iface) {
+                    Ok(Some(interface)) => {
+                        interface.discovered_neighbor.map(|addr| {
+                            SocketAddr::V6(SocketAddrV6::new(
+                                addr,
+                                self.neighbor.port.get(),
+                                0,
+                                interface.scope_id,
+                            ))
+                        })
                     }
-                    Ok(None) => None, // No neighbor discovered yet - expected
+                    Ok(None) => None, // Interface inactive - expected
                     Err(e) => {
                         session_log_lite!(
                             self,
                             debug,
-                            "failed to query neighbor for interface";
+                            "failed to query active unnumbered interface";
                             "interface" => iface,
                             "error" => e.to_string()
                         );
@@ -1816,17 +1803,17 @@ impl<Cnx: BgpConnection + 'static> SessionRunner<Cnx> {
                     .unnumbered_manager
                     .as_ref()
                     .ok_or(ResolveTargetError::NoUnnumberedManager)?;
-                let addr = mgr
-                    .get_discovered_ndp_neighbor(iface)?
-                    .ok_or(ResolveTargetError::NoNeighbor)?;
-                let scope_id = mgr
-                    .get_active_interface_scope_id(iface)?
+                let interface = mgr
+                    .get_active_interface(iface)?
                     .ok_or(ResolveTargetError::InterfaceInactive)?;
+                let addr = interface
+                    .discovered_neighbor
+                    .ok_or(ResolveTargetError::NoNeighbor)?;
                 Ok(SocketAddr::V6(SocketAddrV6::new(
                     addr,
                     self.neighbor.port.get(),
                     0,
-                    scope_id,
+                    interface.scope_id,
                 )))
             }
             PeerId::Ip(ip) => {

bgp/src/test.rs

@@ -38,7 +38,7 @@ use std::{
     thread::{Builder, sleep},
     time::{Duration, Instant},
 };
-use unnumbered::BgpUnnumbered;
+use unnumbered::{BgpUnnumbered, BgpUnnumberedInterface, UnnumberedError};
 
 // Use non-standard port outside the privileged range to avoid needing privs
 const TEST_BGP_PORT: u16 = 10179;
@@ -178,74 +178,73 @@ struct NeighborConfig {
 
 #[derive(Clone)]
 struct TestBgpUnnumbered {
-    scopes: Arc<Mutex<HashMap<u32, String>>>,
-    neighbors: Arc<Mutex<HashMap<String, Option<Ipv6Addr>>>>,
+    interfaces: Arc<Mutex<HashMap<String, BgpUnnumberedInterface>>>,
 }
 
 impl TestBgpUnnumbered {
     fn new() -> Arc<Self> {
         Arc::new(TestBgpUnnumbered {
-            scopes: Arc::new(Mutex::new(HashMap::new())),
-            neighbors: Arc::new(Mutex::new(HashMap::new())),
+            interfaces: Arc::new(Mutex::new(HashMap::new())),
         })
     }
 
     fn activate_interface(&self, interface: impl Into<String>, scope_id: u32) {
         let interface = interface.into();
-        lock!(self.scopes).insert(scope_id, interface.clone());
-        lock!(self.neighbors).entry(interface).or_insert(None);
+        lock!(self.interfaces).insert(
+            interface.clone(),
+            BgpUnnumberedInterface {
+                interface,
+                scope_id,
+                discovered_neighbor: None,
+            },
+        );
     }
 
     fn deactivate_interface(&self, interface: &str) {
-        lock!(self.scopes).retain(|_, name| name != interface);
-        lock!(self.neighbors).remove(interface);
+        lock!(self.interfaces).remove(interface);
     }
 
     fn discover_ndp_neighbor(
         &self,
         interface: &str,
         addr: Ipv6Addr,
     ) -> Result<(), &'static str> {
-        let mut neighbors = lock!(self.neighbors);
-        let entry =
-            neighbors.get_mut(interface).ok_or("interface not active")?;
-        *entry = Some(addr);
+        let mut interfaces = lock!(self.interfaces);
+        let interface = interfaces
+            .get_mut(interface)
+            .ok_or("interface not active")?;
+        interface.discovered_neighbor = Some(addr);
         Ok(())
     }
 
     fn expire_ndp_neighbor(
         &self,
         interface: &str,
     ) -> Result<Option<Ipv6Addr>, &'static str> {
-        let mut neighbors = lock!(self.neighbors);
-        let entry =
-            neighbors.get_mut(interface).ok_or("interface not active")?;
-        Ok(entry.take())
+        let mut interfaces = lock!(self.interfaces);
+        let interface = interfaces
+            .get_mut(interface)
+            .ok_or("interface not active")?;
+        Ok(interface.discovered_neighbor.take())
     }
 }
 
 impl BgpUnnumbered for TestBgpUnnumbered {
     fn get_active_interface_by_scope(
         &self,
         scope_id: u32,
-    ) -> Result<Option<String>, unnumbered::UnnumberedError> {
-        Ok(lock!(self.scopes).get(&scope_id).cloned())
-    }
-
-    fn get_discovered_ndp_neighbor(
-        &self,
-        interface: &str,
-    ) -> Result<Option<Ipv6Addr>, unnumbered::UnnumberedError> {
-        Ok(lock!(self.neighbors).get(interface).copied().flatten())
+    ) -> Result<Option<BgpUnnumberedInterface>, UnnumberedError> {
+        Ok(lock!(self.interfaces)
+            .values()
+            .find(|interface| interface.scope_id == scope_id)
+            .cloned())
     }
 
-    fn get_active_interface_scope_id(
+    fn get_active_interface(
         &self,
         interface: &str,
-    ) -> Result<Option<u32>, unnumbered::UnnumberedError> {
-        Ok(lock!(self.scopes).iter().find_map(|(scope_id, name)| {
-            (name == interface).then_some(*scope_id)
-        }))
+    ) -> Result<Option<BgpUnnumberedInterface>, UnnumberedError> {
+        Ok(lock!(self.interfaces).get(interface).cloned())
     }
 }
 

unnumbered/src/bgp.rs

@@ -5,6 +5,14 @@
 use crate::UnnumberedError;
 use std::net::Ipv6Addr;
 
+/// Active unnumbered interface state exposed to BGP.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct BgpUnnumberedInterface {
+    pub interface: String,
+    pub scope_id: u32,
+    pub discovered_neighbor: Option<Ipv6Addr>,
+}
+
 /// Trait for managing unnumbered BGP sessions via NDP neighbor discovery.
 ///
 /// This trait provides the interface between BGP and the external NDP/neighbor
@@ -18,15 +26,10 @@ pub trait BgpUnnumbered: Send + Sync {
     fn get_active_interface_by_scope(
         &self,
         scope_id: u32,
-    ) -> Result<Option<String>, UnnumberedError>;
-
-    fn get_active_interface_scope_id(
-        &self,
-        interface: &str,
-    ) -> Result<Option<u32>, UnnumberedError>;
+    ) -> Result<Option<BgpUnnumberedInterface>, UnnumberedError>;
 
-    fn get_discovered_ndp_neighbor(
+    fn get_active_interface(
         &self,
         interface: &str,
-    ) -> Result<Option<Ipv6Addr>, UnnumberedError>;
+    ) -> Result<Option<BgpUnnumberedInterface>, UnnumberedError>;
 }

unnumbered/src/lib.rs

@@ -7,7 +7,7 @@ pub mod error;
 mod interface;
 pub mod manager;
 
-pub use bgp::BgpUnnumbered;
+pub use bgp::{BgpUnnumbered, BgpUnnumberedInterface};
 pub use error::UnnumberedError;
 pub use interface::{
     InterfaceMap, NewUnnumberedInterfaceError, UnnumberedInterface,