wasm fixes

veilid-core/src/network_manager/connection_manager.rs

@@ -251,7 +251,8 @@ impl ConnectionManager {
         // Async lock on the remote address for atomicity per remote
         let peer_address = dial_info.to_peer_address();
         let remote_addr = peer_address.to_socket_addr();
-        let _lock_guard = self.arc.address_lock_table.lock_tag(remote_addr);
+
+        let _lock_guard = self.arc.address_lock_table.lock_tag(remote_addr).await;
 
         log_net!(
             "== get_or_create_connection local_addr={:?} dial_info={:?}",
@@ -369,7 +370,7 @@ impl ConnectionManager {
 
     // Called by low-level network when any connection-oriented protocol connection appears
     // either from incoming connections.
-    #[cfg_attr(target_os = "wasm32", allow(dead_code))]
+    #[cfg_attr(target_arch = "wasm32", allow(dead_code))]
     pub(super) async fn on_accepted_protocol_network_connection(
         &self,
         protocol_connection: ProtocolNetworkConnection,

veilid-core/src/network_manager/tasks.rs

@@ -353,7 +353,7 @@ impl NetworkManager {
         let node_refs = routing_table.get_nodes_needing_ping(RoutingDomain::PublicInternet, cur_ts);
 
         // Look up any NAT mappings we may need to try to preserve with keepalives
-        let mut mapped_port_info = routing_table.get_mapped_port_info();
+        let mut mapped_port_info = routing_table.get_low_level_port_info();
 
         // Get the PublicInternet relay if we are using one
         let opt_relay_nr = routing_table.relay_node(RoutingDomain::PublicInternet);
@@ -558,7 +558,8 @@ impl NetworkManager {
 
             // Do we need a relay?
             if !has_relay && node_info.requires_relay() {
-                // Do we need an outbound relay?
+                // Do we want an outbound relay?
+                let mut got_outbound_relay = false;
                 if network_class.outbound_wants_relay() {
                     // The outbound relay is the host of the PWA
                     if let Some(outbound_relay_peerinfo) = intf::get_outbound_relay_peer().await {
@@ -571,10 +572,11 @@ impl NetworkManager {
                         ) {
                             info!("Outbound relay node selected: {}", nr);
                             editor.set_relay_node(nr);
+                            got_outbound_relay = true;
                         }
                     }
-                // Otherwise we must need an inbound relay
-                } else {
+                }
+                if !got_outbound_relay {
                     // Find a node in our routing table that is an acceptable inbound relay
                     if let Some(nr) =
                         routing_table.find_inbound_relay(RoutingDomain::PublicInternet, cur_ts)

veilid-core/src/network_manager/tests/test_connection_table.rs

@@ -52,6 +52,7 @@ pub async fn test_add_get_remove() {
     );
 
     let c1 = NetworkConnection::dummy(1, a1);
+    let c1b = NetworkConnection::dummy(10, a1);
     let c1h = c1.get_handle();
     let c2 = NetworkConnection::dummy(2, a2);
     let c3 = NetworkConnection::dummy(3, a3);
@@ -65,6 +66,7 @@ pub async fn test_add_get_remove() {
     assert_eq!(table.connection_count(), 0);
     assert_eq!(table.get_connection_by_descriptor(a1), None);
     table.add_connection(c1).unwrap();
+    assert!(table.add_connection(c1b).is_err());
 
     assert_eq!(table.connection_count(), 1);
     assert!(table.remove_connection_by_id(4).is_none());

veilid-core/src/network_manager/wasm/mod.rs

@@ -16,7 +16,10 @@ struct NetworkInner {
 }
 
 struct NetworkUnlockedInner {
+    // Accessors
+    routing_table: RoutingTable,
     network_manager: NetworkManager,
+    connection_manager: ConnectionManager,
 }
 
 #[derive(Clone)]
@@ -35,9 +38,15 @@ impl Network {
         }
     }
 
-    fn new_unlocked_inner(network_manager: NetworkManager) -> NetworkUnlockedInner {
+    fn new_unlocked_inner(
+        network_manager: NetworkManager,
+        routing_table: RoutingTable,
+        connection_manager: ConnectionManager,
+    ) -> NetworkUnlockedInner {
         NetworkUnlockedInner {
-            network_manager
+            network_manager,
+            routing_table,
+            connection_manager
         }
     }
 
@@ -49,15 +58,18 @@ impl Network {
         Self {
             config: network_manager.config(),
             inner: Arc::new(Mutex::new(Self::new_inner())),
-            unlocked_inner: Arc::new(Self::new_unlocked_inner(network_manager))
+            unlocked_inner: Arc::new(Self::new_unlocked_inner(network_manager, routing_table, connection_manager))
         }
     }
 
     fn network_manager(&self) -> NetworkManager {
         self.unlocked_inner.network_manager.clone()
     }
+    fn routing_table(&self) -> RoutingTable {
+        self.unlocked_inner.routing_table.clone()
+    }
     fn connection_manager(&self) -> ConnectionManager {
-        self.unlocked_inner.network_manager.connection_manager()
+        self.unlocked_inner.connection_manager.clone()
     }
 
     /////////////////////////////////////////////////////////////////
@@ -279,8 +291,7 @@ impl Network {
         trace!("stopping network");
 
         // Reset state
-        let network_manager = self.network_manager();
-        let routing_table = network_manager.routing_table();
+        let routing_table = self.routing_table();
 
         // Drop all dial info
         let mut editor = routing_table.edit_routing_domain(RoutingDomain::PublicInternet);
@@ -299,7 +310,7 @@ impl Network {
         trace!("network stopped");
     }
 
-    pub fn is_usable_interface_address(&self, addr: IpAddr) -> bool {
+    pub fn is_usable_interface_address(&self, _addr: IpAddr) -> bool {
         false
     }
 

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

@@ -112,7 +112,7 @@ impl WebsocketProtocolHandler {
         timeout_ms: u32,
     ) -> io::Result<NetworkResult<ProtocolNetworkConnection>> {
         // Split dial info up
-        let (tls, scheme) = match dial_info {
+        let (_tls, scheme) = match dial_info {
             DialInfo::WS(_) => (false, "ws"),
             DialInfo::WSS(_) => (true, "wss"),
             _ => panic!("invalid dialinfo for WS/WSS protocol"),