Struct CreateRequestHandler 

pub struct CreateRequestHandler {
    chan_provider: Weak<dyn ChannelProvider<BuildSpec = OwnedChanTarget> + Send + Sync>,
    circ_net_params: RwLock<CircNetParameters>,
    ntor_keys: RwLock<RelayNtorKeys>,
    incoming_filter_factory: Box<dyn IncomingStreamRequestFilterFactory + Send + Sync>,
    allowed_stream_cmds: SmallVec<[RelayCmd; 3]>,
    circuit_stream_tx: Sender<Box<dyn Stream<Item = IncomingStream> + Send + Sync + Unpin>>,
}

Everything needed to handle CREATE* messages on channels.

Fields

chan_provider: Weak<dyn ChannelProvider<BuildSpec = OwnedChanTarget> + Send + Sync>

Something that can launch channels. Typically the ChanMgr.

circ_net_params: RwLock<CircNetParameters>

Circuit-related network parameters.

ntor_keys: RwLock<RelayNtorKeys>

The circuit extension keys.

incoming_filter_factory: Box<dyn IncomingStreamRequestFilterFactory + Send + Sync>

An IncomingStreamRequestFilter factory for checking whether the user wants this request, or wants to reject it immediately.

Used for obtaining a current IncomingStreamRequestFilter for building a circuit reactor.

allowed_stream_cmds: SmallVec<[RelayCmd; 3]>

The allowed incoming stream commands.

Used for rejecting BEGIN and RESOLVE if we are not configured to be an exit.

circuit_stream_tx: Sender<Box<dyn Stream<Item = IncomingStream> + Send + Sync + Unpin>>

A sender for the Streams of IncomingStream of all circuits.

The receiver will receive one Stream (of tor streams) per circuit.

This being a bounded MPSC might seem a bit risky, because in theory, if the receiver is not reading fast enough, sending will block. In practice, however, it should never block (or buffer very much at all, for that matter), because the user (arti-relay) is expected to read from this in a tight loop, and spawn a task for handling each Stream.

Note: because this MPSC is not associated with any particular circuit or channel, it does not participate in the memquota system (see crate::memquota).

Implementations

impl CreateRequestHandler

pub fn new( chan_provider: Weak<dyn ChannelProvider<BuildSpec = OwnedChanTarget> + Send + Sync>, circ_net_params: CircNetParameters, ntor_keys: RelayNtorKeys, incoming_filter_factory: Box<dyn IncomingStreamRequestFilterFactory + Send + Sync>, allowed_stream_cmds: &[RelayCmd], ) -> (Self, CircuitIncomingStreamReceiver)

Build a new CreateRequestHandler, and a CircuitIncomingStreamReceiver for receiving new streams that are opened on any incoming circuits.

pub fn update_params(&self, circ_net_params: CircNetParameters)

Update the circuit parameters from a network consensus.

pub fn update_ntor_keys(&self, ntor_keys: RelayNtorKeys)

Update the handler with a new set of circuit extension keys.

This is called periodically by the relay key rotation task.

pub(crate) async fn handle_create<R: Runtime>( &self, runtime: &R, channel: &Arc<Channel>, our_ed25519_id: &Ed25519Identity, our_rsa_id: &RsaIdentity, circ_id: CircId, msg: &CreateRequest, memquota: &ChannelAccount, circ_unique_id: UniqId, ) -> Result<(CreateResponse, RelayCircComponents), Destroy>

Handle a CREATE* cell.

This intentionally does not return a crate::Error so that we don’t accidentally shut down the channel reactor when we really should be returning a DESTROY. Shutting down a channel may cause us to leak information about paths of circuits travelling through this relay. This is especially important here since we’re handling data that is controllable from the other end of the circuit.

async fn handle_create_inner<R: Runtime>( &self, runtime: &R, channel: &Arc<Channel>, our_ed25519_id: &Ed25519Identity, our_rsa_id: &RsaIdentity, circ_id: CircId, msg: &CreateRequest, memquota: &ChannelAccount, circ_unique_id: UniqId, ) -> Result<(CreateResponse, RelayCircComponents), HandleCreateError>

See Self::handle_create.

async fn handle_create_fast( &self, msg: &CreateFast, ) -> Result<CompletedHandshakeComponents, HandleCreateError>

The handshake code for a CREATE_FAST request.

async fn handle_create2_ntor( &self, msg_body: &[u8], our_rsa_id: &RsaIdentity, ) -> Result<CompletedHandshakeComponents, HandleCreateError>

The handshake code for a CREATE2 ntor (non-v3) request.

async fn handle_create2_ntorv3( &self, msg_body: &[u8], our_ed25519_id: &Ed25519Identity, ) -> Result<CompletedHandshakeComponents, HandleCreateError>

The handshake code for a CREATE2 ntor-v3 request.

fn ntor_keys<T>( &self, map: impl FnMut(&RelayNtorKeypair) -> T, ) -> impl AsRef<[T]>

Helper to get the ntor keypairs after some transformation map.

The map transformation must be fast since it blocks a read lock. The returned keys are sorted with the most recent key first.

It would be nice if this just returned an iterator, but the read lock prevents this.

Trait Implementations

impl Debug for CreateRequestHandler

fn fmt(&self, __derive_more_f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.