liveness tweaks

veilid-core/src/network_manager/mod.rs

@@ -964,6 +964,10 @@ impl NetworkManager {
                             Some(RoutingDomain::PublicInternet),
                             &reverse_dif,
                         ) {
+                            // Ensure we aren't on the same public IP address (no hairpin nat)
+                            if reverse_did.dial_info.to_ip_addr()
+                                != target_public_did.dial_info.to_ip_addr()
+                            {
                                 // Can we receive a direct reverse connection?
                                 if !reverse_did.class.requires_signal() {
                                     return ContactMethod::SignalReverse(
@@ -972,6 +976,7 @@ impl NetworkManager {
                                     );
                                 }
                             }
+                        }
 
                         ///////// UDP hole-punch
 
@@ -979,10 +984,9 @@ impl NetworkManager {
                         let udp_target_nr = target_node_ref.filtered_clone(
                             DialInfoFilter::global().with_protocol_type(ProtocolType::UDP),
                         );
-                        let target_has_udp_dialinfo = udp_target_nr
+                        if let Some(target_udp_dialinfo_detail) = udp_target_nr
                             .first_filtered_dial_info_detail(Some(RoutingDomain::PublicInternet))
-                            .is_some();
-
+                        {
                             // Does the self node have a direct udp dialinfo the target can reach?
                             let inbound_udp_dif = self
                                 .get_inbound_dial_info_filter(RoutingDomain::PublicInternet)
@@ -990,16 +994,23 @@ impl NetworkManager {
                                 .filtered(
                                     DialInfoFilter::global().with_protocol_type(ProtocolType::UDP),
                                 );
-                        let self_has_udp_dialinfo = routing_table
+                            if let Some(self_udp_dialinfo_detail) = routing_table
                                 .first_filtered_dial_info_detail(
                                     Some(RoutingDomain::PublicInternet),
                                     &inbound_udp_dif,
                                 )
-                            .is_some();
-
-                        // Does the target and ourselves have a udp dialinfo that they can reach?
-                        if target_has_udp_dialinfo && self_has_udp_dialinfo {
-                            return ContactMethod::SignalHolePunch(inbound_relay_nr, udp_target_nr);
+                            {
+                                // Ensure we aren't on the same public IP address (no hairpin nat)
+                                if target_udp_dialinfo_detail.dial_info.to_ip_addr()
+                                    != self_udp_dialinfo_detail.dial_info.to_ip_addr()
+                                {
+                                    // The target and ourselves have a udp dialinfo that they can reach
+                                    return ContactMethod::SignalHolePunch(
+                                        inbound_relay_nr,
+                                        udp_target_nr,
+                                    );
+                                }
+                            }
                         }
                         // Otherwise we have to inbound relay
                     }

veilid-core/src/routing_table/bucket_entry.rs

@@ -108,14 +108,15 @@ impl BucketEntryInner {
         move |e1, e2| Self::cmp_fastest_reliable(cur_ts, e1, e2)
     }
 
-    pub fn update_node_info(&mut self, signed_node_info: SignedNodeInfo) {
+    // Retuns true if the node info changed
+    pub fn update_node_info(&mut self, signed_node_info: SignedNodeInfo) -> bool {
         // Don't update with older node info, or something less valid
         if let Some(current_sni) = &self.opt_signed_node_info {
             if current_sni.signature.valid && !signed_node_info.signature.valid {
-                return;
+                return false;
             }
             if signed_node_info.timestamp < current_sni.timestamp {
-                return;
+                return false;
             }
         }
         self.min_max_version = Some((
@@ -123,6 +124,8 @@ impl BucketEntryInner {
             signed_node_info.node_info.max_version,
         ));
         self.opt_signed_node_info = Some(signed_node_info);
+
+        true
     }
     pub fn update_local_node_info(&mut self, local_node_info: LocalNodeInfo) {
         self.opt_local_node_info = Some(local_node_info)

veilid-core/src/routing_table/mod.rs

@@ -581,7 +581,10 @@ impl RoutingTable {
         }
 
         self.create_node_ref(node_id, |e| {
-            e.update_node_info(signed_node_info);
+            if e.update_node_info(signed_node_info) {
+                // at least someone thought this node was live and its node info changed so lets try to contact it
+                e.touch_last_seen(intf::get_timestamp());
+            }
         })
     }
 
@@ -596,6 +599,9 @@ impl RoutingTable {
         self.create_node_ref(node_id, |e| {
             // set the most recent node address for connection finding and udp replies
             e.set_last_connection(descriptor, timestamp);
+
+            // this node is live because it literally just connected to us
+            e.touch_last_seen(timestamp);
         })
     }
 

veilid-server/src/settings.rs

@@ -93,7 +93,7 @@ core:
             set_value_timeout:
             set_value_count: 20
             set_value_fanout: 5
-            min_peer_count: 20
+            min_peer_count: 2 # 20
             min_peer_refresh_time_ms: 2000
             validate_dial_info_receipt_time_ms: 2000
         upnp: false