Struct BackwardReactor 

pub(super) struct BackwardReactor<B: BackwardHandler> {

    time_provider: DynTimeProvider,
    unique_id: UniqId,
    circ_id: CircId,
    channel: Arc<Channel>,
    inner: B,
    outbound_chan_rx: Option<Receiver<AnyChanMsg, MpscSpec>>,
    hops: Arc<RwLock<CircHopList>>,
    inbound_chan_tx: CircuitCellSender,
    command_rx: UnboundedReceiver<CtrlCmd<B::CtrlCmd>>,
    control_rx: UnboundedReceiver<CtrlMsg<B::CtrlMsg>>,
    forward_reactor_rx: Receiver<BackwardReactorCmd>,
    stream_rx: Receiver<ReadyStreamMsg>,
    padding_ctrl: PaddingController,
    padding_event_stream: PaddingEventStream,
    padding_block: Option<StartBlocking>,
}

The “backward” circuit reactor of a relay.

See the reactor module-level docs.

Shuts downs down if an error occurs, or if the Reactor, ForwardReactor, or if one of the StreamReactors of this circuit shuts down:

• if the Reactor shuts down, we are alerted via the ctrl/command mpsc channels (their sending ends will close, which causes run_once() to return ReactorError::Shutdown)
• if ForwardReactor shuts down, the Reactor will notice and will itself shut down, which, in turn, causes the BackwardReactor to shut down as described above
• if one of the StreamReactors shuts down, the ForwardReactor will notice when it next tries to deliver a stream message to it, and shut down, causing the BackwardReactor and top-level Reactor to follow suit

Fields

time_provider: DynTimeProvider

The time provider.

unique_id: UniqId

An identifier for logging about this reactor’s circuit.

circ_id: CircId

The circuit identifier on the backward Tor channel.

channel: Arc<Channel>

The inbound Tor channel.

inner: B

Implementation-dependent part of the reactor.

This enables us to customize the behavior of the reactor, depending on whether we are a client or a relay.

outbound_chan_rx: Option<Receiver<AnyChanMsg, MpscSpec>>

The reading end of the outbound Tor channel, if we are not the last hop.

Yields cells moving from the exit towards the client, if we are a middle relay.

hops: Arc<RwLock<CircHopList>>

The per-hop state, shared with the forward reactor.

The backward reactor acquires a read lock to this whenever it needs to

• send a circuit-level SENDME
• handle a circuit-level SENDME
• send a padding cell

inbound_chan_tx: CircuitCellSender

The sending end of the backward Tor channel.

Delivers cells towards the other endpoint: towards the client, if we are a relay, or towards the exit, if we are a client.

command_rx: UnboundedReceiver<CtrlCmd<B::CtrlCmd>>

Channel for receiving control commands.

control_rx: UnboundedReceiver<CtrlMsg<B::CtrlMsg>>

Channel for receiving control messages.

forward_reactor_rx: Receiver<BackwardReactorCmd>

Receiver for BackwardReactorCmds coming from the forward reactor.

The sender is in ForwardReactor, which will forward all cells carrying Tor stream data to us.

This serves a dual purpose:

• it enables the ForwardReactor to deliver Tor stream data received from the other endpoint
• it lets the BackwardReactor know if the ForwardReactor has shut down: we select! on this MPSC channel in the main loop, so if the ForwardReactor shuts down, we will get EOS upon calling .next())

stream_rx: Receiver<ReadyStreamMsg>

A channel for receiving endpoint-bound stream messages from the StreamReactor(s) (the stream messages are client-bound if we are a relay, or exit-bound if we are a client).

padding_ctrl: PaddingController

A padding controller to which padding-related events should be reported.

padding_event_stream: PaddingEventStream

An event stream telling us about padding-related events.

padding_block: Option<StartBlocking>

Current rules for blocking traffic, according to the padding controller.

Implementations

impl<B: BackwardHandler> BackwardReactor<B>

pub(crate) async fn run(self) -> Result<()>

Launch the reactor, and run until the circuit closes or we encounter an error.

Once this method returns, the circuit is dead and cannot be used again.

impl<B: BackwardHandler> BackwardReactor<B>

pub(super) fn new<R: Runtime>( runtime: R, channel: &Arc<Channel>, circ_id: CircId, unique_id: UniqId, inner: B, hops: Arc<RwLock<CircHopList>>, forward_reactor_rx: Receiver<BackwardReactorCmd>, control_rx: UnboundedReceiver<CtrlMsg<B::CtrlMsg>>, command_rx: UnboundedReceiver<CtrlCmd<B::CtrlCmd>>, padding_ctrl: PaddingController, padding_event_stream: PaddingEventStream, stream_rx: Receiver<ReadyStreamMsg>, ) -> Self

Create a new BackwardReactor.

async fn run_once(&mut self) -> StdResult<(), ReactorError>

Helper for run.

Handles cells arriving on the outbound Tor channel, and writes cells to the inbound Tor channel.

Because the Tor application streams, the forward_reactor_rx MPSC streams, and the outbound Tor channel MPSC stream are driven concurrently using PollAll, this function can send up to 3 cells per call over the inbound Tor channel:

• a cell carrying Tor stream data
• a cell received from the outbound Tor channel, if we are a relay (moving from the exit towards the client)
• a circuit-level SENDME

However, in practice, leaky pipe is not really used, and so relays that have application streams (i.e. the exits), are not going to have an outbound Tor channel, and so this will only really drive Tor stream data, delivering at most 2 cells per call.

fn handle_cmd( &mut self, cmd: CtrlCmd<B::CtrlCmd>, ) -> StdResult<(), ReactorError>

Handle a control command.

fn handle_msg( &mut self, msg: CtrlMsg<B::CtrlMsg>, ) -> StdResult<(), ReactorError>

Handle a control message.

async fn run_padding_event( &mut self, padding_event: PaddingEvent, ) -> StdResult<(), ReactorError>

Perform some circuit-padding-based event on the specified circuit.

async fn send_padding(&mut self, send_padding: SendPadding) -> Result<()>

Handle a request from our padding subsystem to send a padding packet.

pub(super) fn start_blocking_for_padding(&mut self, block: StartBlocking)

Enable padding-based blocking, or change the rule for padding-based blocking to the one in block.

pub(super) fn stop_blocking_for_padding(&mut self)

Disable padding-based blocking.

async fn queue_padding_cell_for_hop( &mut self, target_hop: HopNum, queue_info: Option<QueuedCellPaddingInfo>, ) -> Result<()>

Generate and encrypt a padding cell, and send it to a targeted hop.

Ignores any padding-based blocking.

fn padding_disposition( &self, send_padding: &SendPadding, ) -> CircPaddingDisposition

Determine how exactly to handle a request to handle padding.

async fn handle_event( &mut self, event: CircuitEvent<B::CircChanMsg>, ) -> StdResult<(), ReactorError>

Handle a circuit event.

fn hop_info( &self, hopnum: Option<HopNum>, ) -> Result<(RelayCellFormat, Arc<Mutex<CongestionControl>>)>

Return the RelayCellFormat and CC state of a given hop.

async fn handle_reactor_cmd( &mut self, msg: BackwardReactorCmd, ) -> StdResult<(), ReactorError>

Handle a command sent to us by the forward reactor.

async fn send_relay_msg( &mut self, hopnum: Option<HopNum>, msg: AnyRelayMsgOuter, ) -> StdResult<(), ReactorError>

Send a relay message to the specified hop.

async fn handle_sendme( &mut self, hopnum: Option<HopNum>, sendme: Sendme, ) -> StdResult<(), ReactorError>

Handle a circuit-level SENDME (stream ID = 0).

Returns an error if the SENDME does not have an authentication tag (versions of Tor <=0.3.5 omit the SENDME tag, but we don’t support those any longer).

Any error returned from this function will shut down the reactor.

fn encode_relay_cell( &mut self, relay_format: RelayCellFormat, hop: Option<HopNum>, early: bool, msg: AnyRelayMsgOuter, ) -> Result<(AnyChanMsg, SendmeTag)>

Encode msg and encrypt it, returning the resulting cell and tag that should be expected for an authenticated SENDME sent in response to that cell.

async fn send_relay_cell( &mut self, hop: Option<HopNum>, relay_cell_format: RelayCellFormat, msg: AnyRelayMsgOuter, early: bool, ccontrol: &Arc<Mutex<CongestionControl>>, ) -> Result<()>

Encode msg, encrypt it, and send it to the ’hop’th hop.

If there is insufficient outgoing circuit-level or stream-level SENDME window, an error is returned instead.

Does not check whether the cell is well-formed or reasonable.

async fn send_relay_cell_inner( &mut self, hop: Option<HopNum>, relay_cell_format: RelayCellFormat, msg: AnyRelayMsgOuter, early: bool, ccontrol: &Arc<Mutex<CongestionControl>>, padding_info: Option<QueuedCellPaddingInfo>, ) -> Result<()>

As send_relay_cell, but takes an optional QueuedCellPaddingInfo in padding_info.

If padding_info is None, msg must be non-padding: we report it as such to the padding controller.

async fn handle_backward_cell( &mut self, cell: B::CircChanMsg, ) -> StdResult<(), ReactorError>

Handle a backward cell (moving from the exit towards the client).

Trait Implementations

impl<B: BackwardHandler> Drop for BackwardReactor<B>

fn drop(&mut self)

Executes the destructor for this type.