Struct arti_client::TorClient
source · pub struct TorClient<R: Runtime> { /* private fields */ }
Expand description
An active client session on the Tor network.
While it’s running, it will fetch directory information, build circuits, and make connections for you.
Cloning this object makes a new reference to the same underlying
handles: it’s usually better to clone the TorClient
than it is to
create a new one.
Implementations§
source§impl TorClient<PreferredRuntime>
impl TorClient<PreferredRuntime>
sourcepub async fn create_bootstrapped(config: TorClientConfig) -> Result<Self>
Available on (crate features native-tls
or rustls
) and (crate features async-std
or tokio
) only.
pub async fn create_bootstrapped(config: TorClientConfig) -> Result<Self>
native-tls
or rustls
) and (crate features async-std
or tokio
) only.Bootstrap a connection to the Tor network, using the provided config
.
Returns a client once there is enough directory material to connect safely over the Tor network.
Consider using TorClient::builder
for more fine-grained control.
Panics
If Tokio is being used (the default), panics if created outside the context of a currently
running Tokio runtime. See the documentation for PreferredRuntime::current
for
more information.
If using async-std
, either take care to ensure Arti is not compiled with Tokio support,
or manually create an async-std
runtime using tor_rtcompat
and use it with
TorClient::with_runtime
.
sourcepub fn builder() -> TorClientBuilder<PreferredRuntime>
Available on (crate features native-tls
or rustls
) and (crate features async-std
or tokio
) only.
pub fn builder() -> TorClientBuilder<PreferredRuntime>
native-tls
or rustls
) and (crate features async-std
or tokio
) only.Return a new builder for creating TorClient objects.
If you want to make a TorClient
synchronously, this is what you want; call
TorClientBuilder::create_unbootstrapped
on the returned builder.
Panics
If Tokio is being used (the default), panics if created outside the context of a currently
running Tokio runtime. See the documentation for tokio::runtime::Handle::current
for
more information.
If using async-std
, either take care to ensure Arti is not compiled with Tokio support,
or manually create an async-std
runtime using tor_rtcompat
and use it with
TorClient::with_runtime
.
source§impl<R: Runtime> TorClient<R>
impl<R: Runtime> TorClient<R>
sourcepub fn with_runtime(runtime: R) -> TorClientBuilder<R>
pub fn with_runtime(runtime: R) -> TorClientBuilder<R>
Return a new builder for creating TorClient objects, with a custom provided Runtime
.
See the tor_rtcompat
crate for more information on custom runtimes.
sourcepub async fn bootstrap(&self) -> Result<()>
pub async fn bootstrap(&self) -> Result<()>
Bootstrap a connection to the Tor network, with a client created by create_unbootstrapped
.
Since cloned copies of a TorClient
share internal state, you can bootstrap a client by
cloning it and running this function in a background task (or similar). This function
only needs to be called on one client in order to bootstrap all of its clones.
Returns once there is enough directory material to connect safely over the Tor network. If the client or one of its clones has already been bootstrapped, returns immediately with success. If a bootstrap is in progress, waits for it to finish, then retries it if it failed (returning success if it succeeded).
Bootstrap progress can be tracked by listening to the event receiver returned by
bootstrap_events
.
Failures
If the bootstrapping process fails, returns an error. This function can safely be called again later to attempt to bootstrap another time.
sourcepub fn reconfigure(
&self,
new_config: &TorClientConfig,
how: Reconfigure
) -> Result<()>
pub fn reconfigure( &self, new_config: &TorClientConfig, how: Reconfigure ) -> Result<()>
Change the configuration of this TorClient to new_config
.
The how
describes whether to perform an all-or-nothing
reconfiguration: either all of the configuration changes will be
applied, or none will. If you have disabled all-or-nothing changes, then
only fatal errors will be reported in this function’s return value.
This function applies its changes to all TorClient instances derived
from the same call to TorClient::create_*
: even ones whose circuits
are isolated from this handle.
Limitations
Although most options are reconfigurable, there are some whose values can’t be changed on an a running TorClient. Those options (or their sections) are explicitly documented not to be changeable.
Changing some options do not take effect immediately on all open streams and circuits, but rather affect only future streams and circuits. Those are also explicitly documented.
sourcepub fn isolated_client(&self) -> TorClient<R>
pub fn isolated_client(&self) -> TorClient<R>
Return a new isolated TorClient
handle.
The two TorClient
s will share internal state and configuration, but
their streams will never share circuits with one another.
Use this function when you want separate parts of your program to each have a TorClient handle, but where you don’t want their activities to be linkable to one another over the Tor network.
Calling this function is usually preferable to creating a
completely separate TorClient instance, since it can share its
internals with the existing TorClient
.
(Connections made with clones of the returned TorClient
may
share circuits with each other.)
sourcepub async fn connect<A: IntoTorAddr>(&self, target: A) -> Result<DataStream>
pub async fn connect<A: IntoTorAddr>(&self, target: A) -> Result<DataStream>
Launch an anonymized connection to the provided address and port over the Tor network.
Note that because Tor prefers to do DNS resolution on the remote side of the network, this function takes its address as a string:
// The most usual way to connect is via an address-port tuple.
let socket = tor_client.connect(("www.example.com", 443)).await?;
// You can also specify an address and port as a colon-separated string.
let socket = tor_client.connect("www.example.com:443").await?;
Hostnames are strongly preferred here: if this function allowed the
caller here to provide an IPAddr or IpAddr
or
SocketAddr
address, then
// BAD: We're about to leak our target address to the local resolver!
let address = "www.example.com:443".to_socket_addrs().unwrap().next().unwrap();
// 🤯 Oh no! Now any eavesdropper can tell where we're about to connect! 🤯
// Fortunately, this won't compile, since SocketAddr doesn't implement IntoTorAddr.
// let socket = tor_client.connect(address).await?;
// ^^^^^^^ the trait `IntoTorAddr` is not implemented for `std::net::SocketAddr`
If you really do need to connect to an IP address rather than a hostname, and if you’re sure that the IP address came from a safe location, there are a few ways to do so.
// ⚠️This is risky code!⚠️
// (Make sure your addresses came from somewhere safe...)
// If we have a fixed address, we can just provide it as a string.
let socket = tor_client.connect("192.0.2.22:443").await?;
let socket = tor_client.connect(("192.0.2.22", 443)).await?;
// If we have a SocketAddr or an IpAddr, we can use the
// DangerouslyIntoTorAddr trait.
use arti_client::DangerouslyIntoTorAddr;
let sockaddr = SocketAddr::from(([192, 0, 2, 22], 443));
let ipaddr = IpAddr::from([192, 0, 2, 22]);
let socket = tor_client.connect(sockaddr.into_tor_addr_dangerously().unwrap()).await?;
let socket = tor_client.connect((ipaddr, 443).into_tor_addr_dangerously().unwrap()).await?;
sourcepub async fn connect_with_prefs<A: IntoTorAddr>(
&self,
target: A,
prefs: &StreamPrefs
) -> Result<DataStream>
pub async fn connect_with_prefs<A: IntoTorAddr>( &self, target: A, prefs: &StreamPrefs ) -> Result<DataStream>
Launch an anonymized connection to the provided address and port over the Tor network, with explicit connection preferences.
Note that because Tor prefers to do DNS resolution on the remote
side of the network, this function takes its address as a string.
(See TorClient::connect()
for more information.)
sourcepub fn set_stream_prefs(&mut self, connect_prefs: StreamPrefs)
pub fn set_stream_prefs(&mut self, connect_prefs: StreamPrefs)
Sets the default preferences for future connections made with this client.
The preferences set with this function will be inherited by clones of this client, but
updates to the preferences in those clones will not propagate back to the original. I.e.,
the preferences are copied by clone
.
Connection preferences always override configuration, even configuration set later (eg, by a config reload).
sourcepub fn clone_with_prefs(&self, connect_prefs: StreamPrefs) -> Self
pub fn clone_with_prefs(&self, connect_prefs: StreamPrefs) -> Self
Provides a new handle on this client, but with adjusted default preferences.
Connections made with e.g. connect
on the returned handle will use
connect_prefs
. This is a convenience wrapper for clone
and set_connect_prefs
.
sourcepub async fn resolve(&self, hostname: &str) -> Result<Vec<IpAddr>>
pub async fn resolve(&self, hostname: &str) -> Result<Vec<IpAddr>>
On success, return a list of IP addresses.
sourcepub async fn resolve_with_prefs(
&self,
hostname: &str,
prefs: &StreamPrefs
) -> Result<Vec<IpAddr>>
pub async fn resolve_with_prefs( &self, hostname: &str, prefs: &StreamPrefs ) -> Result<Vec<IpAddr>>
On success, return a list of IP addresses, but use prefs.
sourcepub async fn resolve_ptr(&self, addr: IpAddr) -> Result<Vec<String>>
pub async fn resolve_ptr(&self, addr: IpAddr) -> Result<Vec<String>>
Perform a remote DNS reverse lookup with the provided IP address.
On success, return a list of hostnames.
sourcepub async fn resolve_ptr_with_prefs(
&self,
addr: IpAddr,
prefs: &StreamPrefs
) -> Result<Vec<String>>
pub async fn resolve_ptr_with_prefs( &self, addr: IpAddr, prefs: &StreamPrefs ) -> Result<Vec<String>>
Perform a remote DNS reverse lookup with the provided IP address.
On success, return a list of hostnames.
sourcepub fn dirmgr(&self) -> &Arc<dyn DirProvider>
Available on crate feature experimental-api
only.
pub fn dirmgr(&self) -> &Arc<dyn DirProvider>
experimental-api
only.Return a reference to this client’s directory manager.
This function is unstable. It is only enabled if the crate was
built with the experimental-api
feature.
sourcepub fn circmgr(&self) -> &Arc<CircMgr<R>>
Available on crate feature experimental-api
only.
pub fn circmgr(&self) -> &Arc<CircMgr<R>>
experimental-api
only.Return a reference to this client’s circuit manager.
This function is unstable. It is only enabled if the crate was
built with the experimental-api
feature.
sourcepub fn chanmgr(&self) -> &Arc<ChanMgr<R>>
Available on crate feature experimental-api
only.
pub fn chanmgr(&self) -> &Arc<ChanMgr<R>>
experimental-api
only.Return a reference to this client’s channel manager.
This function is unstable. It is only enabled if the crate was
built with the experimental-api
feature.
sourcepub fn launch_onion_service(
&self,
config: OnionServiceConfig
) -> Result<(Arc<OnionService>, impl Stream<Item = RendRequest>)>
Available on crate feature onion-service-service
only.
pub fn launch_onion_service( &self, config: OnionServiceConfig ) -> Result<(Arc<OnionService>, impl Stream<Item = RendRequest>)>
onion-service-service
only.Try to launch an onion service with a given configuration.
This onion service will not actually handle any requests on its own: you
will need to
pull RendRequest
objects from the returned stream,
accept
the ones that you want to
answer, and then wait for them to give you StreamRequest
s.
You may find the tor_hsservice::handle_rend_requests
API helpful for
translating RendRequest
s into StreamRequest
s.
If you want to forward all the requests from an onion service to a set
of local ports, you may want to use the tor-hsrproxy
crate.
TODO HSS: This feature does not yet work.
sourcepub fn bootstrap_status(&self) -> BootstrapStatus
pub fn bootstrap_status(&self) -> BootstrapStatus
Return a current status::BootstrapStatus
describing how close this client
is to being ready for user traffic.
sourcepub fn bootstrap_events(&self) -> BootstrapEvents
pub fn bootstrap_events(&self) -> BootstrapEvents
Return a stream of status::BootstrapStatus
events that will be updated
whenever the client’s status changes.
The receiver might not receive every update sent to this stream, though when it does poll the stream it should get the most recent one.
sourcepub fn set_dormant(&self, mode: DormantMode)
pub fn set_dormant(&self, mode: DormantMode)
Change the client’s current dormant mode, putting background tasks to sleep or waking them up as appropriate.
This can be used to conserve CPU usage if you aren’t planning on using the client for a while, especially on mobile platforms.
See the DormantMode
documentation for more details.
Trait Implementations§
source§impl HasConstTypeId_ for TorClient<PreferredRuntime>
Available on crate feature rpc
only.
impl HasConstTypeId_ for TorClient<PreferredRuntime>
rpc
only.const CONST_TYPE_ID_: ConstTypeId_ = _
Auto Trait Implementations§
impl<R> !RefUnwindSafe for TorClient<R>
impl<R> Send for TorClient<R>
impl<R> Sync for TorClient<R>
impl<R> Unpin for TorClient<R>where R: Unpin,
impl<R> !UnwindSafe for TorClient<R>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> Conv for T
impl<T> Conv for T
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere T: Any,
§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where Self: Display,
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where &'a Self: for<'a> IntoIterator,
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere Self: Borrow<B>, B: 'a + ?Sized, R: 'a,
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> Rwhere
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> Rwhere Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere Self: AsRef<U>, U: 'a + ?Sized, R: 'a,
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere Self: AsMut<U>, U: 'a + ?Sized, R: 'a,
self
, then passes self.as_mut()
into the pipe
function.§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere Self: Borrow<B>, B: ?Sized,
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere Self: BorrowMut<B>, B: ?Sized,
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere Self: AsRef<R>, R: ?Sized,
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere Self: AsMut<R>, R: ?Sized,
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere
Self: Deref<Target = T>,
T: ?Sized,
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere Self: Deref<Target = T>, T: ?Sized,
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere Self: DerefMut<Target = T> + Deref, T: ?Sized,
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere Self: Borrow<B>, B: ?Sized,
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere Self: BorrowMut<B>, B: ?Sized,
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere Self: AsRef<R>, R: ?Sized,
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere Self: AsMut<R>, R: ?Sized,
.tap_ref_mut()
only in debug builds, and is erased in release
builds.