dialinfoclass refactor, cleaning up network class detection

veilid-core/src/rpc_processor/coders/dial_info_class.rs

@@ -0,0 +1,23 @@
+use crate::*;
+
+pub fn encode_dial_info_class(dial_info_class: DialInfoClass) -> veilid_capnp::DialInfoClass {
+    match dial_info_class {
+        DialInfoClass::Direct => veilid_capnp::DialInfoClass::Direct,
+        DialInfoClass::Mapped => veilid_capnp::DialInfoClass::Mapped,
+        DialInfoClass::FullConeNAT => veilid_capnp::DialInfoClass::FullConeNAT,
+        DialInfoClass::Blocked => veilid_capnp::DialInfoClass::Blocked,
+        DialInfoClass::AddressRestrictedNAT => veilid_capnp::DialInfoClass::AddressRestrictedNAT,
+        DialInfoClass::PortRestrictedNAT => veilid_capnp::DialInfoClass::PortRestrictedNAT,
+    }
+}
+
+pub fn decode_dial_info_class(dial_info_class: veilid_capnp::DialInfoClass) -> DialInfoClass {
+    match dial_info_class {
+        veilid_capnp::DialInfoClass::Direct => DialInfoClass::Direct,
+        veilid_capnp::DialInfoClass::Mapped => DialInfoClass::Mapped,
+        veilid_capnp::DialInfoClass::FullConeNAT => DialInfoClass::FullConeNAT,
+        veilid_capnp::DialInfoClass::Blocked => DialInfoClass::Blocked,
+        veilid_capnp::DialInfoClass::AddressRestrictedNAT => DialInfoClass::AddressRestrictedNAT,
+        veilid_capnp::DialInfoClass::PortRestrictedNAT => DialInfoClass::PortRestrictedNAT,
+    }
+}

veilid-core/src/rpc_processor/coders/dial_info_detail.rs

@@ -0,0 +1,33 @@
+use crate::*;
+use rpc_processor::*;
+
+pub fn encode_dial_info_detail(
+    dial_info_detail: &DialInfoDetail,
+    builder: &mut veilid_capnp::dial_info_detail::Builder,
+) -> Result<(), RPCError> {
+    let mut di_builder = builder.reborrow().init_dial_info();
+    encode_dial_info(&node_info.dial_info, &mut di_builder)?;
+
+    builder.set_class(encode_dial_info_class(dial_info_detail.class));
+    Ok(())
+}
+
+pub fn decode_dial_info_detail(
+    reader: &veilid_capnp::dial_info_detail::Reader,
+) -> Result<DialInfoDetail, RPCError> {
+    let dial_info = decode_dial_info(
+        &reader
+            .reborrow()
+            .get_dial_info()
+            .map_err(map_error_capnp_error!())?,
+    )?;
+
+    let dial_info_class = decode_dial_info_class(
+        reader
+            .reborrow()
+            .get_class()
+            .map_err(map_error_capnp_notinschema!())?,
+    );
+
+    Ok(DialInfoDetail { dial_info, class })
+}

veilid-core/src/rpc_processor/coders/mod.rs

@@ -1,5 +1,7 @@
 mod address;
 mod dial_info;
+mod dial_info_class;
+mod dial_info_detail;
 mod network_class;
 mod node_dial_info;
 mod node_info;
@@ -15,6 +17,8 @@ mod socket_address;
 
 pub use address::*;
 pub use dial_info::*;
+pub use dial_info_class::*;
+pub use dial_info_detail::*;
 pub use network_class::*;
 pub use node_dial_info::*;
 pub use node_info::*;

veilid-core/src/rpc_processor/coders/node_info.rs

@@ -10,17 +10,19 @@ pub fn encode_node_info(
     let mut ps_builder = builder.reborrow().init_outbound_protocols();
     encode_protocol_set(&node_info.outbound_protocols, &mut ps_builder)?;
 
-    let mut dil_builder = builder.reborrow().init_dial_info_list(
+    let mut didl_builder = builder.reborrow().init_dial_info_detail_list(
         node_info
-            .dial_info_list
+            .dial_info_detail_list
             .len()
             .try_into()
-            .map_err(map_error_protocol!("too many dial infos in node info"))?,
+            .map_err(map_error_protocol!(
+                "too many dial info details in node info"
+            ))?,
     );
 
-    for idx in 0..node_info.dial_info_list.len() {
-        let mut di_builder = dil_builder.reborrow().get(idx as u32);
-        encode_dial_info(&node_info.dial_info_list[idx], &mut di_builder)?;
+    for idx in 0..node_info.dial_info_detail_list.len() {
+        let mut did_builder = didl_builder.reborrow().get(idx as u32);
+        encode_dial_info_detail(&node_info.dial_info_detail_list[idx], &mut did_builder)?;
     }
 
     if let Some(rpi) = &node_info.relay_peer_info {
@@ -49,18 +51,18 @@ pub fn decode_node_info(
             .map_err(map_error_capnp_error!())?,
     )?;
 
-    let dil_reader = reader
+    let didl_reader = reader
         .reborrow()
-        .get_dial_info_list()
+        .get_dial_info_detail_list()
         .map_err(map_error_capnp_error!())?;
-    let mut dial_info_list = Vec::<DialInfo>::with_capacity(
-        dil_reader
+    let mut dial_info_detail_list = Vec::<DialInfo>::with_capacity(
+        didl_reader
             .len()
             .try_into()
-            .map_err(map_error_protocol!("too many dial infos"))?,
+            .map_err(map_error_protocol!("too many dial info details"))?,
     );
     for di in dil_reader.iter() {
-        dial_info_list.push(decode_dial_info(&di)?)
+        dial_info_detail_list.push(decode_dial_info_detail(&di)?)
     }
 
     let relay_peer_info = if allow_relay_peer_info {
@@ -82,7 +84,7 @@ pub fn decode_node_info(
     Ok(NodeInfo {
         network_class,
         outbound_protocols,
-        dial_info_list,
+        dial_info_detail_list,
         relay_peer_info,
     })
 }

veilid-core/src/rpc_processor/mod.rs

@@ -1349,12 +1349,16 @@ impl RPCProcessor {
     }
 
     // Gets a 'RespondTo::Sender' that contains either our dial info,
-    // or None if the peer has seen our dial info before
-    pub fn get_respond_to_sender(&self, peer: NodeRef) -> RespondTo {
-        if peer.has_seen_our_node_info() {
+    // or None if the peer has seen our dial info before or our node info is not yet valid
+    // because of an unknown network class
+    pub fn make_respond_to_sender(&self, peer: NodeRef) -> RespondTo {
+        let our_node_info = self.routing_table().get_own_peer_info().node_info;
+        if peer.has_seen_our_node_info()
+            || matches!(our_node_info.network_class, NetworkClass::Invalid)
+        {
             RespondTo::Sender(None)
         } else {
-            RespondTo::Sender(Some(self.routing_table().get_own_peer_info().node_info))
+            RespondTo::Sender(Some(our_node_info))
         }
     }
 
@@ -1366,7 +1370,7 @@ impl RPCProcessor {
             let mut question = info_q_msg.init_root::<veilid_capnp::operation::Builder>();
             question.set_op_id(self.get_next_op_id());
             let mut respond_to = question.reborrow().init_respond_to();
-            self.get_respond_to_sender(peer.clone())
+            self.make_respond_to_sender(peer.clone())
                 .encode(&mut respond_to)?;
             let detail = question.reborrow().init_detail();
             let mut iqb = detail.init_info_q();