private route work

veilid-core/src/network_manager/mod.rs

@@ -788,6 +788,7 @@ impl NetworkManager {
     pub async fn handle_private_receipt<R: AsRef<[u8]>>(
         &self,
         receipt_data: R,
+        private_route: DHTKey,
     ) -> NetworkResult<()> {
         let receipt_manager = self.receipt_manager();
 
@@ -799,7 +800,7 @@ impl NetworkManager {
         };
 
         receipt_manager
-            .handle_receipt(receipt, ReceiptReturned::Private)
+            .handle_receipt(receipt, ReceiptReturned::Private { private_route })
             .await
     }
 
@@ -1023,7 +1024,8 @@ impl NetworkManager {
 
         // Wait for the return receipt
         let inbound_nr = match eventual_value.await.take_value().unwrap() {
-            ReceiptEvent::ReturnedPrivate | ReceiptEvent::ReturnedOutOfBand => {
+            ReceiptEvent::ReturnedPrivate { private_route: _ }
+            | ReceiptEvent::ReturnedOutOfBand => {
                 return Ok(NetworkResult::invalid_message(
                     "reverse connect receipt should be returned in-band",
                 ));
@@ -1124,7 +1126,8 @@ impl NetworkManager {
 
         // Wait for the return receipt
         let inbound_nr = match eventual_value.await.take_value().unwrap() {
-            ReceiptEvent::ReturnedPrivate | ReceiptEvent::ReturnedOutOfBand => {
+            ReceiptEvent::ReturnedPrivate { private_route: _ }
+            | ReceiptEvent::ReturnedOutOfBand => {
                 return Ok(NetworkResult::invalid_message(
                     "hole punch receipt should be returned in-band",
                 ));

veilid-core/src/network_manager/native/network_class_discovery.rs

@@ -125,22 +125,24 @@ impl DiscoveryContext {
             RoutingDomain::PublicInternet,
             dial_info_filter.clone(),
         );
-        let disallow_relays_filter = move |_rti, e: &BucketEntryInner| {
-            if let Some(n) = e.node_info(RoutingDomain::PublicInternet) {
-                n.relay_peer_info.is_none()
-            } else {
-                false
-            }
-        };
-        let filter = RoutingTable::combine_entry_filters(
-            inbound_dial_info_entry_filter,
-            disallow_relays_filter,
-        );
+        let disallow_relays_filter = Box::new(
+            move |rti: &RoutingTableInner, _k: DHTKey, v: Option<Arc<BucketEntry>>| {
+                let v = v.unwrap();
+                v.with(rti, |_rti, e| {
+                    if let Some(n) = e.node_info(RoutingDomain::PublicInternet) {
+                        n.relay_peer_info.is_none()
+                    } else {
+                        false
+                    }
+                })
+            },
+        ) as RoutingTableEntryFilter;
+        let filters = VecDeque::from([inbound_dial_info_entry_filter, disallow_relays_filter]);
 
         // Find public nodes matching this filter
         let peers = self
             .routing_table
-            .find_fast_public_nodes_filtered(node_count, filter);
+            .find_fast_public_nodes_filtered(node_count, filters);
         if peers.is_empty() {
             log_net!(
                 "no external address detection peers of type {:?}:{:?}",

veilid-core/src/network_manager/tasks.rs

@@ -495,7 +495,7 @@ impl NetworkManager {
         // even the unreliable ones, and ask them to find nodes close to our node too
         let noderefs = routing_table.find_fastest_nodes(
             min_peer_count,
-            |_rti, _k, _v| true,
+            VecDeque::new(),
             |_rti, k: DHTKey, v: Option<Arc<BucketEntry>>| {
                 NodeRef::new(routing_table.clone(), k, v.unwrap().clone(), None)
             },