refactor(swap/tor): deduplicate upgrading TorBackend to final transport

Author: nabijaczleweli

swap-tor/src/lib.rs

@@ -270,7 +270,7 @@ impl SocksServerAddress {
     }
 }
 
-type TcpTransport = libp2p::dns::tokio::Transport<libp2p::tcp::tokio::Transport>;
+pub type TcpTransport = libp2p::dns::tokio::Transport<libp2p::tcp::tokio::Transport>;
 pub struct TorsocksTransport(pub TcpTransport);
 impl Transport for TorsocksTransport {
     type Output = <TcpTransport as Transport>::Output;

swap/src/asb/network.rs

@@ -18,7 +18,7 @@ use swap_feed::LatestRate;
 
 pub mod transport {
     use arti_client::config::onion_service::OnionServiceConfigBuilder;
-    use libp2p::{dns, identity, tcp, Transport};
+    use libp2p::{identity, Transport};
     use libp2p_tor::AddressConversion;
 
     use super::*;
@@ -45,7 +45,7 @@ pub mod transport {
         num_intro_points: u8,
     ) -> Result<OnionTransportWithAddresses> {
         let mut onion_addresses = vec![];
-        let maybe_tor_transport =
+        let transport =
             maybe_tor_client.into_transport(AddressConversion::DnsOnly, |arti_tor_transport| {
                 if register_hidden_service {
                     let onion_service_config = OnionServiceConfigBuilder::default()
@@ -75,14 +75,8 @@ pub mod transport {
                 }
             })?;
 
-        let tcp = tcp::tokio::Transport::new(tcp::Config::new().nodelay(true));
-        let tcp_with_dns = dns::tokio::Transport::system(tcp)?;
-
         Ok((
-            authenticate_and_multiplex(
-                maybe_tor_transport.or_transport(tcp_with_dns).boxed(),
-                identity,
-            )?,
+            authenticate_and_multiplex(transport.boxed(), identity)?,
             onion_addresses,
         ))
     }

swap/src/cli/transport.rs

@@ -3,9 +3,8 @@ use crate::network::transport::authenticate_and_multiplex;
 use anyhow::Result;
 use libp2p::core::muxing::StreamMuxerBox;
 use libp2p::core::transport::Boxed;
-use libp2p::dns;
-use libp2p::tcp;
-use libp2p::{identity, PeerId, Transport};
+use libp2p::Transport;
+use libp2p::{identity, PeerId};
 use libp2p_tor::AddressConversion;
 
 /// Creates the libp2p transport for the swap CLI.
@@ -20,13 +19,7 @@ pub fn new(
     identity: &identity::Keypair,
     maybe_tor_client: TorBackend,
 ) -> Result<Boxed<(PeerId, StreamMuxerBox)>> {
-    let tcp = tcp::tokio::Transport::new(tcp::Config::new().nodelay(true));
-    let tcp_with_dns = dns::tokio::Transport::system(tcp)?;
+    let transport = maybe_tor_client.into_transport(AddressConversion::IpAndDns, |_| {})?;
 
-    let maybe_tor_transport =
-        maybe_tor_client.into_transport(AddressConversion::IpAndDns, |_| {})?;
-
-    let transport = maybe_tor_transport.or_transport(tcp_with_dns).boxed();
-
-    authenticate_and_multiplex(transport, identity)
+    authenticate_and_multiplex(transport.boxed(), identity)
 }

swap/src/common/tor.rs

@@ -6,6 +6,7 @@ use crate::cli::api::tauri_bindings::{
 use arti_client::{config::TorClientConfigBuilder, status::BootstrapStatus, Error, TorClient};
 use futures::StreamExt;
 use libp2p::core::transport::{OptionalTransport, OrTransport};
+use libp2p::{dns, tcp, Transport};
 use libp2p_tor::{AddressConversion, TorTransport};
 use swap_env::env::{is_whonix, may_init_tor};
 use swap_tor::*;
@@ -54,8 +55,11 @@ pub trait TorBackendSwap {
     ) -> std::io::Result<IntoTransportT>;
 }
 type IntoTransportT = OrTransport<
-    OptionalTransport<TorTransport>,
-    OrTransport<OptionalTransport<Socks5Transport>, OptionalTransport<TorsocksTransport>>,
+    OrTransport<
+        OptionalTransport<TorTransport>,
+        OrTransport<OptionalTransport<Socks5Transport>, OptionalTransport<TorsocksTransport>>,
+    >,
+    swap_tor::TcpTransport,
 >;
 impl TorBackendSwap for TorBackend {
     async fn bootstrap(&self, tauri_handle: Option<TauriHandle>) -> anyhow::Result<()> {
@@ -83,7 +87,13 @@ impl TorBackendSwap for TorBackend {
         arti_address_conversion: AddressConversion,
         arti_transport_hook: impl FnOnce(&mut TorTransport),
     ) -> std::io::Result<IntoTransportT> {
-        Ok(match self {
+        fn plain_transport() -> std::io::Result<swap_tor::TcpTransport> {
+            let tcp = tcp::tokio::Transport::new(tcp::Config::new().nodelay(true));
+            dns::tokio::Transport::system(tcp)
+        }
+        let tcp_with_dns = plain_transport()?;
+
+        let tor = match self {
             TorBackend::Arti(tor_client) => {
                 let mut tor_transport =
                     libp2p_tor::TorTransport::from_client(tor_client, arti_address_conversion);
@@ -104,18 +114,16 @@ impl TorBackendSwap for TorBackend {
                 OptionalTransport::none(),
                 OrTransport::new(
                     OptionalTransport::none(),
-                    OptionalTransport::some(TorsocksTransport(
-                        libp2p::dns::tokio::Transport::system(libp2p::tcp::tokio::Transport::new(
-                            libp2p::tcp::Config::new().nodelay(true),
-                        ))?,
-                    )),
+                    OptionalTransport::some(TorsocksTransport(plain_transport()?)),
                 ),
             ),
             TorBackend::None => OrTransport::new(
                 OptionalTransport::none(),
                 OrTransport::new(OptionalTransport::none(), OptionalTransport::none()),
             ),
-        })
+        };
+
+        Ok(tor.or_transport(tcp_with_dns))
     }
 }