fix udp and refactor native network

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

@@ -70,13 +70,17 @@ pub fn encode_dial_info(
                 &ws.socket_address,
                 &mut di_ws_builder.reborrow().init_socket_address(),
             )?;
+            let request = dial_info
+                .request()
+                .ok_or_else(|| rpc_error_internal("no request for WS dialinfo"))?;
+
             let mut requestb = di_ws_builder.init_request(
-                ws.request
+                request
                     .len()
                     .try_into()
                     .map_err(map_error_protocol!("request too long"))?,
             );
-            requestb.push_str(ws.request.as_str());
+            requestb.push_str(request.as_str());
         }
         DialInfo::WSS(wss) => {
             let mut di_wss_builder = builder.reborrow().init_wss();
@@ -84,13 +88,17 @@ pub fn encode_dial_info(
                 &wss.socket_address,
                 &mut di_wss_builder.reborrow().init_socket_address(),
             )?;
+            let request = dial_info
+                .request()
+                .ok_or_else(|| rpc_error_internal("no request for WSS dialinfo"))?;
+
             let mut requestb = di_wss_builder.init_request(
-                wss.request
+                request
                     .len()
                     .try_into()
                     .map_err(map_error_protocol!("request too long"))?,
             );
-            requestb.push_str(wss.request.as_str());
+            requestb.push_str(request.as_str());
         }
     };
     Ok(())

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

@@ -1,6 +1,6 @@
 mod address;
 mod dial_info;
-mod node_dial_info_single;
+mod node_dial_info;
 mod node_info;
 mod nonce;
 mod peer_info;
@@ -11,7 +11,7 @@ mod socket_address;
 
 pub use address::*;
 pub use dial_info::*;
-pub use node_dial_info_single::*;
+pub use node_dial_info::*;
 pub use node_info::*;
 pub use nonce::*;
 pub use peer_info::*;

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

@@ -0,0 +1,33 @@
+use crate::*;
+use rpc_processor::*;
+
+pub fn encode_node_dial_info(
+    ndis: &NodeDialInfo,
+    builder: &mut veilid_capnp::node_dial_info::Builder,
+) -> Result<(), RPCError> {
+    let mut ni_builder = builder.reborrow().init_node_id();
+    encode_public_key(&ndis.node_id.key, &mut ni_builder)?;
+    let mut di_builder = builder.reborrow().init_dial_info();
+    encode_dial_info(&ndis.dial_info, &mut di_builder)?;
+    Ok(())
+}
+
+pub fn decode_node_dial_info(
+    reader: &veilid_capnp::node_dial_info::Reader,
+) -> Result<NodeDialInfo, RPCError> {
+    let node_id = decode_public_key(
+        &reader
+            .get_node_id()
+            .map_err(map_error_protocol!("invalid public key in node_dial_info"))?,
+    );
+    let dial_info = decode_dial_info(
+        &reader
+            .get_dial_info()
+            .map_err(map_error_protocol!("invalid dial_info in node_dial_info"))?,
+    )?;
+
+    Ok(NodeDialInfo {
+        node_id: NodeId::new(node_id),
+        dial_info,
+    })
+}

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

@@ -1,29 +0,0 @@
-use crate::*;
-use rpc_processor::*;
-
-pub fn encode_node_dial_info_single(
-    ndis: &NodeDialInfoSingle,
-    builder: &mut veilid_capnp::node_dial_info_single::Builder,
-) -> Result<(), RPCError> {
-    let mut ni_builder = builder.reborrow().init_node_id();
-    encode_public_key(&ndis.node_id.key, &mut ni_builder)?;
-    let mut di_builder = builder.reborrow().init_dial_info();
-    encode_dial_info(&ndis.dial_info, &mut di_builder)?;
-    Ok(())
-}
-
-pub fn decode_node_dial_info_single(
-    reader: &veilid_capnp::node_dial_info_single::Reader,
-) -> Result<NodeDialInfoSingle, RPCError> {
-    let node_id = decode_public_key(&reader.get_node_id().map_err(map_error_protocol!(
-        "invalid public key in node_dial_info_single"
-    ))?);
-    let dial_info = decode_dial_info(&reader.get_dial_info().map_err(map_error_protocol!(
-        "invalid dial_info in node_dial_info_single"
-    ))?)?;
-
-    Ok(NodeDialInfoSingle {
-        node_id: NodeId::new(node_id),
-        dial_info,
-    })
-}

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

@@ -13,7 +13,7 @@ pub struct RouteHopData {
 
 #[derive(Clone, Debug)]
 pub struct RouteHop {
-    pub dial_info: NodeDialInfoSingle,
+    pub dial_info: NodeDialInfo,
     pub next_hop: Option<RouteHopData>,
 }
 
@@ -61,7 +61,7 @@ pub fn encode_route_hop(
     route_hop: &RouteHop,
     builder: &mut veilid_capnp::route_hop::Builder,
 ) -> Result<(), RPCError> {
-    encode_node_dial_info_single(
+    encode_node_dial_info(
         &route_hop.dial_info,
         &mut builder.reborrow().init_dial_info(),
     )?;
@@ -133,7 +133,7 @@ pub fn decode_route_hop_data(
 }
 
 pub fn decode_route_hop(reader: &veilid_capnp::route_hop::Reader) -> Result<RouteHop, RPCError> {
-    let dial_info = decode_node_dial_info_single(
+    let dial_info = decode_node_dial_info(
         &reader
             .reborrow()
             .get_dial_info()