checkpoint

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

@@ -80,9 +80,6 @@ impl DiscoveryContext {
     async fn request_public_address(&self, node_ref: NodeRef) -> Option<SocketAddress> {
         let rpc = self.routing_table.rpc_processor();
 
-        // Ensure we ask for a fresh connection
-        node_ref.clear_last_connection();
-
         let res = network_result_value_or_log!(debug match rpc.rpc_call_status(node_ref.clone()).await {
                 Ok(v) => v,
                 Err(e) => {

veilid-core/src/network_manager/native/protocol/tcp.rs

@@ -134,7 +134,8 @@ impl RawTcpProtocolHandler {
         );
         let local_address = self.inner.lock().local_address;
         let conn = ProtocolNetworkConnection::RawTcp(RawTcpNetworkConnection::new(
-            ConnectionDescriptor::new(peer_addr, SocketAddress::from_socket_addr(local_address)),
+            ConnectionDescriptor::new(peer_addr, SocketAddress::from_socket_addr(local_address))
+                .map_err(|e| io::Error::new(io::ErrorKind::AddrNotAvailable, e))?,
             stream,
         ));
 
@@ -174,7 +175,8 @@ impl RawTcpProtocolHandler {
                     ProtocolType::TCP,
                 ),
                 SocketAddress::from_socket_addr(actual_local_address),
-            ),
+            )
+            .map_err(|e| io::Error::new(io::ErrorKind::AddrNotAvailable, e))?,
             ps,
         ));
 

veilid-core/src/network_manager/native/protocol/udp.rs

@@ -13,24 +13,31 @@ impl RawUdpProtocolHandler {
 
     #[instrument(level = "trace", err, skip(self, data), fields(data.len = data.len(), ret.len, ret.from))]
     pub async fn recv_message(&self, data: &mut [u8]) -> io::Result<(usize, ConnectionDescriptor)> {
-        let (size, remote_addr) = loop {
+        let (size, descriptor) = loop {
             let (size, remote_addr) = network_result_value_or_log!(debug self.socket.recv_from(data).await.into_network_result()? => continue);
             if size > MAX_MESSAGE_SIZE {
                 log_net!(debug "{}({}) at {}@{}:{}", "Invalid message".green(), "received too large UDP message", file!(), line!(), column!());
                 continue;
             }
-            break (size, remote_addr);
-        };
 
-        let peer_addr = PeerAddress::new(
-            SocketAddress::from_socket_addr(remote_addr),
-            ProtocolType::UDP,
-        );
-        let local_socket_addr = self.socket.local_addr()?;
-        let descriptor = ConnectionDescriptor::new(
-            peer_addr,
-            SocketAddress::from_socket_addr(local_socket_addr),
-        );
+            let peer_addr = PeerAddress::new(
+                SocketAddress::from_socket_addr(remote_addr),
+                ProtocolType::UDP,
+            );
+            let local_socket_addr = self.socket.local_addr()?;
+            let descriptor = match ConnectionDescriptor::new(
+                peer_addr,
+                SocketAddress::from_socket_addr(local_socket_addr),
+            ) {
+                Ok(d) => d,
+                Err(_) => {
+                    log_net!(debug "{}({}) at {}@{}:{}: {:?}", "Invalid peer scope".green(), "received message from invalid peer scope", file!(), line!(), column!(), peer_addr);
+                    continue;
+                }
+            };
+
+            break (size, descriptor);
+        };
 
         tracing::Span::current().record("ret.len", &size);
         tracing::Span::current().record("ret.from", &format!("{:?}", descriptor).as_str());
@@ -46,6 +53,17 @@ impl RawUdpProtocolHandler {
         if data.len() > MAX_MESSAGE_SIZE {
             bail_io_error_other!("sending too large UDP message");
         }
+        let peer_addr = PeerAddress::new(
+            SocketAddress::from_socket_addr(socket_addr),
+            ProtocolType::UDP,
+        );
+        let local_socket_addr = self.socket.local_addr()?;
+
+        let descriptor = ConnectionDescriptor::new(
+            peer_addr,
+            SocketAddress::from_socket_addr(local_socket_addr),
+        )
+        .map_err(|e| io::Error::new(io::ErrorKind::AddrNotAvailable, e))?;
 
         let len = network_result_try!(self
             .socket
@@ -56,16 +74,6 @@ impl RawUdpProtocolHandler {
             bail_io_error_other!("UDP partial send")
         }
 
-        let peer_addr = PeerAddress::new(
-            SocketAddress::from_socket_addr(socket_addr),
-            ProtocolType::UDP,
-        );
-        let local_socket_addr = self.socket.local_addr()?;
-        let descriptor = ConnectionDescriptor::new(
-            peer_addr,
-            SocketAddress::from_socket_addr(local_socket_addr),
-        );
-
         Ok(NetworkResult::value(descriptor))
     }
 

veilid-core/src/network_manager/native/protocol/ws.rs

@@ -204,7 +204,8 @@ impl WebsocketProtocolHandler {
             ConnectionDescriptor::new(
                 peer_addr,
                 SocketAddress::from_socket_addr(self.arc.local_address),
-            ),
+            )
+            .map_err(|e| io::Error::new(io::ErrorKind::AddrNotAvailable, e))?,
             ws_stream,
         ));
 
@@ -259,7 +260,9 @@ impl WebsocketProtocolHandler {
         let descriptor = ConnectionDescriptor::new(
             dial_info.to_peer_address(),
             SocketAddress::from_socket_addr(actual_local_addr),
-        );
+        )
+        .map_err(|e| io::Error::new(io::ErrorKind::AddrNotAvailable, e))?;
+
         // Negotiate TLS if this is WSS
         if tls {
             let connector = TlsConnector::default();

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

@@ -383,10 +383,9 @@ impl Network {
         // Save the bound ws port for use later on
         self.inner.lock().ws_port = ws_port;
 
-        trace!(
+        info!(
             "WS: starting listener on port {} at {:?}",
-            ws_port,
-            ip_addrs
+            ws_port, ip_addrs
         );
         let socket_addresses = self
             .start_tcp_listener(
@@ -510,10 +509,9 @@ impl Network {
         // Save the bound wss port for use later on
         self.inner.lock().wss_port = wss_port;
 
-        trace!(
+        info!(
             "WSS: starting listener on port {} at {:?}",
-            wss_port,
-            ip_addrs
+            wss_port, ip_addrs
         );
         let socket_addresses = self
             .start_tcp_listener(
@@ -615,10 +613,9 @@ impl Network {
         // Save the bound tcp port for use later on
         self.inner.lock().tcp_port = tcp_port;
 
-        trace!(
+        info!(
             "TCP: starting listener on port {} at {:?}",
-            tcp_port,
-            ip_addrs
+            tcp_port, ip_addrs
         );
         let socket_addresses = self
             .start_tcp_listener(