Struct ChanBuilder 

pub struct ChanBuilder<R, H: TransportImplHelper>
where
    R: TlsProvider<H::Stream> + Runtime,
{
    runtime: R,
    transport: H,
    tls_connector: <R as TlsProvider<H::Stream>>::Connector,
    tls_acceptor: Option<<R as TlsProvider<H::Stream>>::Acceptor>,
    auth_material: Option<Arc<RelayChannelAuthMaterial>>,
    my_addrs: Vec<SocketAddr>,
    create_request_handler: Option<Arc<CreateRequestHandler>>,
}

TLS-based channel builder.

This is a separate type so that we can keep our channel management code network-agnostic.

It uses a provided TransportHelper type to make a connection (possibly directly over TCP, and possibly over some other protocol). It then negotiates TLS over that connection, and negotiates a Tor channel over that TLS session.

This channel builder does not retry on failure, but it does implement a time-out.

Fields

runtime: R

Asynchronous runtime for TLS, TCP, spawning, and timeouts.

transport: H

The transport object that we use to construct streams.

tls_connector: <R as TlsProvider<H::Stream>>::Connector

Object to build TLS connections.

tls_acceptor: Option<<R as TlsProvider<H::Stream>>::Acceptor>

Object to accept TLS connections.

auth_material: Option<Arc<RelayChannelAuthMaterial>>

Relay authentication key material needed for relay channels.

my_addrs: Vec<SocketAddr>

Our address(es) to use in the NETINFO cell.

create_request_handler: Option<Arc<CreateRequestHandler>>

Provided to each new channel so that they can handle CREATE* requests.

Implementations

impl<R, H: TransportImplHelper> ChanBuilder<R, H>

where R: TlsProvider<H::Stream> + Runtime,

pub fn new_client(runtime: R, transport: H) -> Self

Construct a new client specific ChanBuilder.

pub fn new_relay( runtime: R, transport: H, auth_material: Arc<RelayChannelAuthMaterial>, my_addrs: Vec<SocketAddr>, create_request_handler: Option<Arc<CreateRequestHandler>>, ) -> Result<Self>

Construct a new relay specific ChanBuilder.

pub fn rebuild_with_auth_material( &self, auth_material: Arc<RelayChannelAuthMaterial>, ) -> Result<Self>

where H: Clone,

Build a new ChanBuilder with the given auth_material, cloning everything else.

This is needed because some relay keys rotate over time.

pub fn rebuild_with_create_request_handler( &self, handler: Arc<CreateRequestHandler>, ) -> Result<Self>

where H: Clone,

Build a new ChanBuilder with the given CREATE* request handler, cloning everything else.

This is needed so that we can set the handler, which isn’t known when the builder is initially created.

fn outbound_chan_type(&self) -> ChannelType

Return the outbound channel type of this config.

The channel type is used when creating outbound channels. Relays always initiate channels as “relay initiator” while client and bridges behave like a “client initiator”.

Important: The wrong channel type is returned if this is called before with_identities() is called.

impl<R, H> ChanBuilder<R, H>

where R: TlsProvider<H::Stream> + Send + Sync + Runtime, H: Send + Sync + TransportImplHelper,

async fn connect_no_timeout( &self, target: &OwnedChanTarget, event_sender: Arc<Mutex<ChanMgrEventSender>>, memquota: ChannelAccount, ) -> Result<Arc<Channel>>

Perform the work of connect_via_transport, but without enforcing a timeout.

Return a Channel on success.

fn validate_target_as_relay<CT>(&self, target: &CT) -> Result<()>

where CT: ChanTarget,

Validate the given target as we (a relay) are attempting to connect to another relay.

fn validate_target<CT>(&self, target: &CT) -> Result<()>

where CT: ChanTarget,

Validate the given target as in if it is fine to connect to it.

There are several rules to follow based on the channel outbound type.

async fn build_client_channel<T>( &self, tls: T, peer_addr: MaybeSensitive<PeerAddr>, target: &OwnedChanTarget, peer_tls_cert: &[u8], memquota: ChannelAccount, event_sender: Arc<Mutex<ChanMgrEventSender>>, ) -> Result<Arc<Channel>>

where T: AsyncRead + AsyncWrite + CertifiedConn + StreamOps + Send + Unpin + 'static,

Build a client channel (always initiator).

This spawns the Reactor and return the tor_proto::channel::Channel.

async fn build_relay_channel<T>( &self, tls: T, peer_addr: MaybeSensitive<PeerAddr>, target: &OwnedChanTarget, peer_tls_cert: &[u8], memquota: ChannelAccount, event_sender: Arc<Mutex<ChanMgrEventSender>>, ) -> Result<Arc<Channel>>

where T: AsyncRead + AsyncWrite + CertifiedConn + StreamOps + Send + Unpin + 'static,

Build a relay initiator channel.

This spawns the Reactor and return the tor_proto::channel::Channel.

Trait Implementations

impl<R, H> ChannelFactory for ChanBuilder<R, H>

where R: TlsProvider<H::Stream> + Send + Sync + Runtime, H: Send + Sync + TransportImplHelper,

fn connect_via_transport<'life0, 'life1, 'async_trait>( &'life0 self, target: &'life1 OwnedChanTarget, reporter: BootstrapReporter, memquota: ChannelAccount, ) -> Pin<Box<dyn Future<Output = Result<Arc<Channel>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Open an authenticated channel to target.

impl<R, H> IncomingChannelFactory for ChanBuilder<R, H>

where R: TlsProvider<H::Stream> + Send + Sync + Runtime, H: Send + Sync + TransportImplHelper,

type Stream = <H as TransportImplHelper>::Stream

The type of byte stream that’s required to build channels for incoming connections.

fn accept_from_transport<'life0, 'async_trait>( &'life0 self, peer: Sensitive<SocketAddr>, stream: Self::Stream, memquota: ChannelAccount, ) -> Pin<Box<dyn Future<Output = Result<Arc<Channel>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Open a channel from peer with the given stream. The channel may or may not be authenticated.