net: identify transport mixed connections to make sure mixed addresses don't enter hostregistry

src/net/acceptor.rs

@@ -153,7 +153,7 @@ impl Acceptor {
 
                     // Create the new Channel.
                     let session = self.session.clone();
-                    let channel = Channel::new(stream, None, url, session).await;
+                    let channel = Channel::new(stream, None, url, session, false).await;
 
                     // Increment the connection counter
                     self.conn_count.fetch_add(1, SeqCst);

src/net/channel.rs

@@ -68,11 +68,17 @@ pub struct ChannelInfo {
     pub connect_addr: Url,
     pub start_time: u64,
     pub id: u32,
+    pub transport_mixed: bool,
 }
 
 impl ChannelInfo {
-    fn new(resolve_addr: Option<Url>, connect_addr: Url, start_time: u64) -> Self {
-        Self { resolve_addr, connect_addr, start_time, id: OsRng.gen() }
+    fn new(
+        resolve_addr: Option<Url>,
+        connect_addr: Url,
+        start_time: u64,
+        transport_mixed: bool,
+    ) -> Self {
+        Self { resolve_addr, connect_addr, start_time, id: OsRng.gen(), transport_mixed }
     }
 }
 
@@ -112,6 +118,7 @@ impl Channel {
         resolve_addr: Option<Url>,
         connect_addr: Url,
         session: SessionWeakPtr,
+        transport_mixed: bool,
     ) -> Arc<Self> {
         let (reader, writer) = io::split(stream);
         let reader = AsyncMutex::new(reader);
@@ -121,7 +128,8 @@ impl Channel {
         Self::setup_dispatchers(&message_subsystem).await;
 
         let start_time = UNIX_EPOCH.elapsed().unwrap().as_secs();
-        let info = ChannelInfo::new(resolve_addr, connect_addr.clone(), start_time);
+        let info =
+            ChannelInfo::new(resolve_addr, connect_addr.clone(), start_time, transport_mixed);
         let metering_map = AsyncMutex::new(HashMap::new());
 
         Arc::new(Self {
@@ -525,16 +533,19 @@ impl Channel {
         debug!(target: "net::channel::ban()", "STOP {self:?}");
     }
 
-    /// Returns the relevant socket address for this connection.  If this is
+    /// Returns the relevant socket address for this connection. If this is
     /// an outbound connection, the transport-processed resolve_addr will
-    /// be returned.  Otherwise for inbound connections it will default
+    /// be returned except for transport mixed connections, to make sure
+    /// mixed hosts don't enter hostlist.
+    /// Otherwise for inbound connections it will default
     /// to connect_addr.
     pub fn address(&self) -> &Url {
-        if self.info.resolve_addr.is_some() {
-            self.info.resolve_addr.as_ref().unwrap()
-        } else {
-            &self.info.connect_addr
+        if !self.info.transport_mixed {
+            if let Some(resolve_addr) = &self.info.resolve_addr {
+                return resolve_addr
+            }
         }
+        &self.info.connect_addr
     }
 
     /// Returns the socket address that has undergone transport

src/net/connector.rs

@@ -72,7 +72,7 @@ impl Connector {
         let nym_socks5_proxy = settings.nym_socks5_proxy.clone();
         drop(settings);
 
-        let endpoint = if let Some(mixed_host) = HostContainer::mix_host(
+        let (endpoint, mixed_transport) = if let Some(mixed_host) = HostContainer::mix_host(
             url.clone(),
             &transports,
             &mixed_transports,
@@ -81,9 +81,9 @@ impl Connector {
         )
         .first()
         {
-            mixed_host.clone()
+            (mixed_host.clone(), true)
         } else {
-            url.clone()
+            (url.clone(), false)
         };
 
         let dialer = Dialer::new(endpoint.clone(), datastore, Some(i2p_socks5_proxy)).await?;
@@ -104,6 +104,7 @@ impl Connector {
                     Some(endpoint.clone()),
                     url.clone(),
                     self.session.clone(),
+                    mixed_transport,
                 )
                 .await;
                 Ok((endpoint, channel))

src/net/protocol/protocol_version.rs

@@ -161,7 +161,7 @@ impl ProtocolVersion {
             version: app_version.clone(),
             timestamp: UNIX_EPOCH.elapsed().unwrap().as_secs(),
             connect_recv_addr: self.channel.connect_addr().clone(),
-            resolve_recv_addr: self.channel.resolve_addr().clone(),
+            resolve_recv_addr: self.channel.resolve_addr(),
             ext_send_addr: external_addrs,
             /* NOTE: `features` is a list of enabled features in the
             format Vec<(service, version)>. In the future, Protocols will

src/net/session/outbound_session.rs

@@ -361,10 +361,13 @@ impl Slot {
                 );
 
                 // Peer disconnected during the registry process. We'll downgrade this peer now.
-                self.p2p().hosts().move_host(&addr, last_seen, HostColor::Grey).await?;
+                self.p2p().hosts().move_host(channel.address(), last_seen, HostColor::Grey).await?;
 
                 // Mark its state as Suspend, which sends this node to the Refinery for processing.
-                self.p2p().hosts().try_register(addr.clone(), HostState::Suspend).unwrap();
+                self.p2p()
+                    .hosts()
+                    .try_register(channel.address().clone(), HostState::Suspend)
+                    .unwrap();
 
                 continue
             }

src/net/session/seedsync_session.rs

@@ -240,7 +240,7 @@ impl Slot {
                         }
 
                         Err(e) => {
-                            self.handle_failure(e, &url);
+                            self.handle_failure(e, ch.address());
 
                             continue
                         }