transports/onion: Add dial-only implementation of Transport

examples/ping-onion.rs

@@ -61,7 +61,7 @@ async fn onion_transport(
             tcp::GenTcpConfig::new().nodelay(true),
         ))
         .await?;
-        let onion = onion::OnionClient::from_builder(onion::OnionClient::builder())?;
+        let onion = onion::OnionClient::from_builder(onion::OnionClient::builder(), false)?;
         println!("bootstrapping...");
         onion.bootstrap().await?;
         println!("bootstrapped!");

transports/onion/src/address.rs

@@ -1,13 +1,13 @@
 use std::net::{IpAddr, SocketAddr};
 
-use arti_client::{TorAddr, TorAddrError};
+use arti_client::{IntoTorAddr, TorAddr, TorAddrError};
 use libp2p_core::{multiaddr::Protocol, Multiaddr};
 
-fn try_extract_socket_addr(mutliaddr: &Multiaddr) -> Result<SocketAddr, TorAddrError> {
+fn try_extract_socket_addr(multiaddr: &Multiaddr) -> Result<SocketAddr, TorAddrError> {
     let mut ip_4 = None;
     let mut ip_6 = None;
     let mut tcp_port_opt = None;
-    for e in mutliaddr.iter() {
+    for e in multiaddr.iter() {
         match e {
             Protocol::Ip4(a) => {
                 ip_4 = Some(IpAddr::V4(a));
@@ -32,3 +32,49 @@ pub(super) fn dangerous_extract_tor_address(
     let socket_addr = try_extract_socket_addr(multiaddr)?;
     TorAddr::dangerously_from(socket_addr)
 }
+
+macro_rules! try_convert_to_tor_addr {
+    ($dns:ident, $tcp_port:ident, $tor_addr_error:ident) => {
+        if let Some(dns_s) = $dns {
+            match (dns_s.as_ref(), $tcp_port).into_tor_addr() {
+                Ok(tor_addr) => return Ok(tor_addr),
+                Err(e) => $tor_addr_error = Some(e),
+            }
+        }
+    };
+}
+
+pub(super) fn safe_extract_tor_address(multiaddr: &Multiaddr) -> Result<TorAddr, TorAddrError> {
+    let mut dns = None;
+    let mut dns_4 = None;
+    let mut dns_6 = None;
+    let mut dns_addr = None;
+    let mut tcp_port_opt = None;
+    for e in multiaddr.iter() {
+        match e {
+            Protocol::Dns(s) => {
+                dns = Some(s);
+            }
+            Protocol::Dns4(s) => {
+                dns_4 = Some(s);
+            }
+            Protocol::Dns6(s) => {
+                dns_6 = Some(s);
+            }
+            Protocol::Dnsaddr(s) => {
+                dns_addr = Some(s);
+            }
+            Protocol::Tcp(p) => {
+                tcp_port_opt = Some(p);
+            }
+            _ => {}
+        }
+    }
+    let tcp_port = tcp_port_opt.ok_or(TorAddrError::NoPort)?;
+    let mut tor_addr_error = None;
+    try_convert_to_tor_addr!(dns, tcp_port, tor_addr_error);
+    try_convert_to_tor_addr!(dns_4, tcp_port, tor_addr_error);
+    try_convert_to_tor_addr!(dns_6, tcp_port, tor_addr_error);
+    try_convert_to_tor_addr!(dns_addr, tcp_port, tor_addr_error);
+    Err(tor_addr_error.unwrap_or(TorAddrError::InvalidHostname))
+}

transports/onion/src/lib.rs

@@ -1,14 +1,15 @@
 #![doc(html_logo_url = "https://libp2p.io/img/logo_small.png")]
 #![doc(html_favicon_url = "https://libp2p.io/img/favicon.png")]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 use std::pin::Pin;
 use std::sync::Arc;
 
-use address::dangerous_extract_tor_address;
+use address::{dangerous_extract_tor_address, safe_extract_tor_address};
 use arti_client::{TorAddrError, TorClient, TorClientBuilder};
 use futures::{future::BoxFuture, FutureExt};
 use libp2p_core::{transport::TransportError, Multiaddr, Transport};
-use tor_rtcompat::PreferredRuntime;
+use tor_rtcompat::Runtime;
 
 mod address;
 mod provider;
@@ -22,37 +23,95 @@ pub enum OnionError {
     AddrErr(#[from] TorAddrError),
     #[error("error in arti")]
     ArtiErr(#[from] arti_client::Error),
-    #[error("onion services are not implented yet, since arti doesn't support it. (awaiting Arti 1.2.0)")]
-    OnionServiceUnimplemented,
 }
 
 #[derive(Clone)]
-pub struct OnionClient {
+pub struct OnionClient<R: Runtime> {
     // client is in an Arc, because wihtout it the Transport::Dial method can't be implemented,
     // due to lifetime issues. With the, eventual, stabilization of static async traits this issue
     // will be resolved.
-    client: Arc<TorClient<PreferredRuntime>>,
+    client: Arc<TorClient<R>>,
+    safe_mode: bool,
 }
 
-pub type OnionBuilder = TorClientBuilder<PreferredRuntime>;
+pub type OnionBuilder<R> = TorClientBuilder<R>;
 
-impl OnionClient {
+impl<R: Runtime> OnionClient<R> {
     #[inline]
-    pub fn builder() -> OnionBuilder {
-        TorClient::builder()
+    pub fn from_builder(builder: OnionBuilder<R>, safe_mode: bool) -> Result<Self, OnionError> {
+        let client = Arc::new(builder.create_unbootstrapped()?);
+        Ok(Self { client, safe_mode })
     }
 
     #[inline]
-    pub fn from_builder(builder: OnionBuilder) -> Result<Self, OnionError> {
-        let client = Arc::new(builder.create_unbootstrapped()?);
-        Ok(Self { client })
+    pub fn is_safe_mode(&self) -> bool {
+        self.safe_mode
+    }
+
+    #[inline]
+    pub fn set_safe_mode(&mut self, mode: bool) {
+        self.safe_mode = mode
     }
 
     pub async fn bootstrap(&self) -> Result<(), OnionError> {
-        Ok(self.client.bootstrap().await?)
+        self.client.bootstrap().await.map_err(OnionError::ArtiErr)
+    }
+}
+
+#[cfg(all(feature = "native-tls", feature = "async-std"))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "native-tls", feature = "async-std"))))]
+impl OnionClient<tor_rtcompat::async_std::AsyncStdNativeTlsRuntime> {
+    pub fn builder() -> OnionBuilder<tor_rtcompat::async_std::AsyncStdNativeTlsRuntime> {
+        let runtime = tor_rtcompat::async_std::AsyncStdNativeTlsRuntime::current()
+            .expect("Couldn't get the current async_std native-tls runtime");
+        TorClient::with_runtime(runtime)
+    }
+}
+
+#[cfg(all(feature = "rustls", feature = "async-std"))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "rustls", feature = "async-std"))))]
+impl OnionClient<tor_rtcompat::async_std::AsyncStdRustlsRuntime> {
+    pub fn builder() -> OnionBuilder<tor_rtcompat::async_std::AsyncStdRustlsRuntime> {
+        let runtime = tor_rtcompat::async_std::AsyncStdRustlsRuntime::current()
+            .expect("Couldn't get the current async_std rustls runtime");
+        TorClient::with_runtime(runtime)
+    }
+}
+
+#[cfg(all(feature = "native-tls", feature = "tokio"))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "native-tls", feature = "tokio"))))]
+impl OnionClient<tor_rtcompat::tokio::TokioNativeTlsRuntime> {
+    pub fn builder() -> OnionBuilder<tor_rtcompat::tokio::TokioNativeTlsRuntime> {
+        let runtime = tor_rtcompat::tokio::TokioNativeTlsRuntime::current()
+            .expect("Couldn't get the current tokio native-tls runtime");
+        TorClient::with_runtime(runtime)
     }
 }
 
+#[cfg(all(feature = "rustls", feature = "tokio"))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "rustls", feature = "tokio"))))]
+impl OnionClient<tor_rtcompat::tokio::TokioRustlsRuntime> {
+    pub fn builder() -> OnionBuilder<tor_rtcompat::tokio::TokioRustlsRuntime> {
+        let runtime = tor_rtcompat::tokio::TokioRustlsRuntime::current()
+            .expect("Couldn't get the current tokio rustls runtime");
+        TorClient::with_runtime(runtime)
+    }
+}
+
+#[cfg(all(feature = "native-tls", feature = "async-std"))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "native-tls", feature = "async-std"))))]
+pub type OnionAsyncStdNativeTlsClient =
+    OnionClient<tor_rtcompat::async_std::AsyncStdNativeTlsRuntime>;
+#[cfg(all(feature = "rustls", feature = "async-std"))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "rustls", feature = "async-std"))))]
+pub type OnionAsyncStdRustlsClient = OnionClient<tor_rtcompat::async_std::AsyncStdRustlsRuntime>;
+#[cfg(all(feature = "native-tls", feature = "tokio"))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "native-tls", feature = "tokio"))))]
+pub type OnionTokioNativeTlsClient = OnionClient<tor_rtcompat::tokio::TokioNativeTlsRuntime>;
+#[cfg(all(feature = "rustls", feature = "tokio"))]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "rustls", feature = "tokio"))))]
+pub type OnionTokioRustlsClient = OnionClient<tor_rtcompat::tokio::TokioRustlsRuntime>;
+
 #[derive(Debug, Clone, Copy, Default)]
 pub struct AlwaysErrorListenerUpgrade;
 
@@ -62,11 +121,11 @@ impl core::future::Future for AlwaysErrorListenerUpgrade {
         self: std::pin::Pin<&mut Self>,
         _cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
-        core::task::Poll::Ready(Err(OnionError::OnionServiceUnimplemented))
+        panic!("onion services are not implented yet, since arti doesn't support it. (awaiting Arti 1.2.0)")
     }
 }
 
-impl Transport for OnionClient {
+impl<R: Runtime> Transport for OnionClient<R> {
     type Output = OnionStream;
     type Error = OnionError;
     type Dial = BoxFuture<'static, Result<Self::Output, Self::Error>>;
@@ -91,11 +150,22 @@ impl Transport for OnionClient {
     }
 
     fn dial(&mut self, addr: Multiaddr) -> Result<Self::Dial, TransportError<Self::Error>> {
-        let tor_address = dangerous_extract_tor_address(&addr)
-            .map_err(OnionError::from)
-            .map_err(TransportError::Other)?;
+        let tor_address = if !self.safe_mode {
+            safe_extract_tor_address(&addr).or_else(|_| dangerous_extract_tor_address(&addr))
+        } else {
+            safe_extract_tor_address(&addr)
+        }
+        .map_err(OnionError::from)
+        .map_err(TransportError::Other)?;
         let onion_client = self.client.clone();
-        Ok(async move { Ok(OnionStream::new(onion_client.connect(tor_address).await?)) }.boxed())
+        Ok(async move {
+            onion_client
+                .connect(tor_address)
+                .await
+                .map(OnionStream::new)
+                .map_err(OnionError::ArtiErr)
+        }
+        .boxed())
     }
 
     /// Equivalent to `Transport::dial`