(draft) feat: tcp transport

iroh/bench/src/iroh.rs

@@ -1,12 +1,14 @@
 use std::{
     net::SocketAddr,
+    sync::Arc,
     time::{Duration, Instant},
 };
 
 use bytes::Bytes;
 use iroh::{
-    Endpoint, EndpointAddr, RelayMode, RelayUrl,
+    Endpoint, EndpointAddr, RelayMode, RelayUrl, TransportAddr,
     endpoint::{Connection, ConnectionError, QuicTransportConfig, RecvStream, SendStream},
+    tcp::TcpTransport,
 };
 use n0_error::{Result, StackResultExt, StdResultExt};
 use tracing::{trace, warn};
@@ -38,6 +40,13 @@ pub fn server_endpoint(
                 builder = builder.clear_ip_transports();
             }
         }
+        if opt.tcp {
+            let tcp_transport = TcpTransport::new("127.0.0.1:0".parse().unwrap());
+            builder = builder
+                .clear_ip_transports()
+                .clear_relay_transports()
+                .add_user_transport(Arc::new(tcp_transport));
+        }
         let ep = builder
             .alpns(vec![ALPN.to_vec()])
             .relay_mode(relay_mode)
@@ -50,12 +59,24 @@ pub fn server_endpoint(
             ep.online().await;
         }
 
-        let addr = ep.bound_sockets();
-        let addr = SocketAddr::new("127.0.0.1".parse().unwrap(), addr[0].port());
-        let mut addr = EndpointAddr::new(ep.id()).with_ip_addr(addr);
-        if let Some(relay_url) = relay_url {
-            addr = addr.with_relay_url(relay_url.clone());
-        }
+        let addr = if opt.tcp {
+            let addr = ep.addr();
+            let user_addrs = addr
+                .addrs
+                .into_iter()
+                .filter(|a| matches!(a, TransportAddr::User(_)));
+            let addr = EndpointAddr::from_parts(addr.id, user_addrs);
+            assert!(addr.addrs.len() == 1, "expected to have one user addr");
+            addr
+        } else {
+            let addr = ep.bound_sockets();
+            let addr = SocketAddr::new("127.0.0.1".parse().unwrap(), addr[0].port());
+            let mut addr = EndpointAddr::new(ep.id()).with_ip_addr(addr);
+            if let Some(relay_url) = relay_url {
+                addr = addr.with_relay_url(relay_url.clone());
+            }
+            addr
+        };
         (addr, ep)
     })
 }
@@ -97,6 +118,13 @@ pub async fn connect_client(
             builder = builder.clear_ip_transports();
         }
     }
+    if opt.tcp {
+        let tcp_transport = TcpTransport::new("127.0.0.1:0".parse().unwrap());
+        builder = builder
+            .clear_ip_transports()
+            .clear_relay_transports()
+            .add_user_transport(Arc::new(tcp_transport));
+    }
     let endpoint = builder
         .alpns(vec![ALPN.to_vec()])
         .relay_mode(relay_mode)

iroh/bench/src/lib.rs

@@ -76,6 +76,8 @@ pub struct Opt {
     pub only_relay: bool,
     #[clap(long, default_value_t = false)]
     pub use_ipv6: bool,
+    #[clap(long, default_value_t = false)]
+    pub tcp: bool,
 }
 
 pub enum EndpointSelector {

iroh/src/endpoint.rs

@@ -997,18 +997,25 @@ impl Endpoint {
     #[cfg(not(wasm_browser))]
     pub fn watch_addr(&self) -> impl n0_watcher::Watcher<Value = EndpointAddr> + use<> {
         let watch_addrs = self.msock.ip_addrs();
+        // TODO(Frando): I had to put in the local addrs because that's the only place right now where
+        // the user addrs end up in.
+        let local_addrs = self.msock.local_addrs_watch.clone();
         let watch_relay = self.msock.home_relay();
         let endpoint_id = self.id();
 
-        watch_addrs.or(watch_relay).map(move |(addrs, relays)| {
-            EndpointAddr::from_parts(
-                endpoint_id,
-                relays
-                    .into_iter()
-                    .map(TransportAddr::Relay)
-                    .chain(addrs.into_iter().map(|x| TransportAddr::Ip(x.addr))),
-            )
-        })
+        watch_addrs
+            .or(watch_relay)
+            .or(local_addrs)
+            .map(move |((addrs, relays), local_addrs)| {
+                EndpointAddr::from_parts(
+                    endpoint_id,
+                    relays
+                        .into_iter()
+                        .map(TransportAddr::Relay)
+                        .chain(addrs.into_iter().map(|x| TransportAddr::Ip(x.addr)))
+                        .chain(local_addrs.into_iter().map(TransportAddr::from)),
+                )
+            })
     }
 
     /// Returns a [`Watcher`] for the current [`EndpointAddr`] for this endpoint.

iroh/src/lib.rs

@@ -280,3 +280,6 @@ pub use net_report::{Report as NetReport, TIMEOUT as NET_REPORT_TIMEOUT};
 
 #[cfg(any(test, feature = "test-utils"))]
 pub mod test_utils;
+
+#[cfg(not(wasm_browser))]
+pub use magicsock::transports::tcp;

iroh/src/magicsock.rs

@@ -213,7 +213,7 @@ pub(crate) struct MagicSock {
     pub(crate) remote_map: RemoteMap,
 
     /// Local addresses
-    local_addrs_watch: LocalAddrsWatch,
+    pub(crate) local_addrs_watch: LocalAddrsWatch,
     /// Currently bound IP addresses of all sockets
     #[cfg(not(wasm_browser))]
     ip_bind_addrs: Vec<SocketAddr>,

iroh/src/magicsock/transports.rs

@@ -22,6 +22,8 @@ use crate::{metrics::EndpointMetrics, net_report::Report};
 #[cfg(not(wasm_browser))]
 mod ip;
 mod relay;
+#[cfg(not(wasm_browser))]
+pub mod tcp;
 pub(crate) mod user;
 
 use user::{CustomEndpoint, CustomSender, CustomTransport};