private routing

veilid-core/src/network_manager/mod.rs

@@ -783,6 +783,26 @@ impl NetworkManager {
             .await
     }
 
+    /// Process a received safety receipt
+    #[instrument(level = "trace", skip(self, receipt_data), ret)]
+    pub async fn handle_safety_receipt<R: AsRef<[u8]>>(
+        &self,
+        receipt_data: R,
+    ) -> NetworkResult<()> {
+        let receipt_manager = self.receipt_manager();
+
+        let receipt = match Receipt::from_signed_data(receipt_data.as_ref()) {
+            Err(e) => {
+                return NetworkResult::invalid_message(e.to_string());
+            }
+            Ok(v) => v,
+        };
+
+        receipt_manager
+            .handle_receipt(receipt, ReceiptReturned::Safety)
+            .await
+    }
+
     /// Process a received private receipt
     #[instrument(level = "trace", skip(self, receipt_data), ret)]
     pub async fn handle_private_receipt<R: AsRef<[u8]>>(
@@ -1025,7 +1045,8 @@ impl NetworkManager {
         // Wait for the return receipt
         let inbound_nr = match eventual_value.await.take_value().unwrap() {
             ReceiptEvent::ReturnedPrivate { private_route: _ }
-            | ReceiptEvent::ReturnedOutOfBand => {
+            | ReceiptEvent::ReturnedOutOfBand
+            | ReceiptEvent::ReturnedSafety => {
                 return Ok(NetworkResult::invalid_message(
                     "reverse connect receipt should be returned in-band",
                 ));
@@ -1127,7 +1148,8 @@ impl NetworkManager {
         // Wait for the return receipt
         let inbound_nr = match eventual_value.await.take_value().unwrap() {
             ReceiptEvent::ReturnedPrivate { private_route: _ }
-            | ReceiptEvent::ReturnedOutOfBand => {
+            | ReceiptEvent::ReturnedOutOfBand
+            | ReceiptEvent::ReturnedSafety => {
                 return Ok(NetworkResult::invalid_message(
                     "hole punch receipt should be returned in-band",
                 ));

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

@@ -79,7 +79,7 @@ impl DiscoveryContext {
     async fn request_public_address(&self, node_ref: NodeRef) -> Option<SocketAddress> {
         let rpc = self.routing_table.rpc_processor();
 
-        let res = network_result_value_or_log!(debug match rpc.rpc_call_status(node_ref.clone()).await {
+        let res = network_result_value_or_log!(debug match rpc.rpc_call_status(Destination::direct(node_ref.clone())).await {
                 Ok(v) => v,
                 Err(e) => {
                     log_net!(error
@@ -98,7 +98,7 @@ impl DiscoveryContext {
             node_ref,
             res.answer
         );
-        res.answer.socket_address
+        res.answer.map(|si| si.socket_address)
     }
 
     // find fast peers with a particular address type, and ask them to tell us what our external address is

veilid-core/src/network_manager/tasks.rs

@@ -343,7 +343,7 @@ impl NetworkManager {
         &self,
         cur_ts: u64,
         unord: &mut FuturesUnordered<
-            SendPinBoxFuture<Result<NetworkResult<Answer<SenderInfo>>, RPCError>>,
+            SendPinBoxFuture<Result<NetworkResult<Answer<Option<SenderInfo>>>, RPCError>>,
         >,
     ) -> EyreResult<()> {
         let rpc = self.rpc_processor();
@@ -394,7 +394,7 @@ impl NetworkManager {
                             nr.filtered_clone(NodeRefFilter::new().with_dial_info_filter(dif));
                         log_net!("--> Keepalive ping to {:?}", nr_filtered);
                         unord.push(
-                            async move { rpc.rpc_call_status(nr_filtered).await }
+                            async move { rpc.rpc_call_status(Destination::direct(nr_filtered)).await }
                                 .instrument(Span::current())
                                 .boxed(),
                         );
@@ -408,7 +408,7 @@ impl NetworkManager {
             if !did_pings {
                 let rpc = rpc.clone();
                 unord.push(
-                    async move { rpc.rpc_call_status(nr).await }
+                    async move { rpc.rpc_call_status(Destination::direct(nr)).await }
                         .instrument(Span::current())
                         .boxed(),
                 );
@@ -425,7 +425,7 @@ impl NetworkManager {
         &self,
         cur_ts: u64,
         unord: &mut FuturesUnordered<
-            SendPinBoxFuture<Result<NetworkResult<Answer<SenderInfo>>, RPCError>>,
+            SendPinBoxFuture<Result<NetworkResult<Answer<Option<SenderInfo>>>, RPCError>>,
         >,
     ) -> EyreResult<()> {
         let rpc = self.rpc_processor();
@@ -440,7 +440,7 @@ impl NetworkManager {
 
             // Just do a single ping with the best protocol for all the nodes
             unord.push(
-                async move { rpc.rpc_call_status(nr).await }
+                async move { rpc.rpc_call_status(Destination::direct(nr)).await }
                     .instrument(Span::current())
                     .boxed(),
             );