Struct ForwardReactor 

pub(super) struct ForwardReactor<R: Runtime, F: ForwardHandler> {
    runtime: R,
    unique_id: UniqId,
    circ_id: CircId,
    inner: F,
    command_rx: UnboundedReceiver<CtrlCmd<F::CtrlCmd>>,
    control_rx: UnboundedReceiver<CtrlMsg<F::CtrlMsg>>,
    inbound_chan_rx: CircuitRxReceiver,
    backward_reactor_tx: Sender<BackwardReactorCmd>,
    hop_mgr: HopMgr<R>,
    circ_events: Receiver<F::CircEvent>,
    padding_ctrl: PaddingController,
}

The forward circuit reactor.

See the reactor module-level docs.

Shuts downs down if an error occurs, or if either the Reactor or the BackwardReactor 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 BackwardReactor shuts down, the Reactor will notice and will itself shut down, which, in turn, causes the ForwardReactor to shut down as described above

Fields

runtime: R

A handle to the runtime.

unique_id: UniqId

An identifier for logging about this reactor’s circuit.

circ_id: CircId

The circuit identifier on the inbound Tor channel.

inner: F

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.

command_rx: UnboundedReceiver<CtrlCmd<F::CtrlCmd>>

Channel for receiving control commands.

control_rx: UnboundedReceiver<CtrlMsg<F::CtrlMsg>>

Channel for receiving control messages.

inbound_chan_rx: CircuitRxReceiver

The reading end of the inbound Tor channel.

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

backward_reactor_tx: Sender<BackwardReactorCmd>

Sender for sending commands to the BackwardReactor.

Used for sending:

• circuit-level SENDMEs received from the other endpoint ([BackwardReactorCmd::HandleSendme])
• circuit-level SENDMEs that need to be delivered to the other endpoint (using [BackwardReactorCmd::SendRelayMsg])

The receiver is in BackwardReactor, which is responsible for sending cell over the inbound channel.

hop_mgr: HopMgr<R>

Hop manager, storing per-hop state, and handles to the stream reactors.

Contains the CircHopList.

circ_events: Receiver<F::CircEvent>

An implementation-specific event stream.

Polled from the main loop of the reactor. Each event is passed to ForwardHandler::handle_event.

padding_ctrl: PaddingController

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

Implementations

impl<R: Runtime, F: ForwardHandler> ForwardReactor<R, F>

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<R: Runtime, F: ForwardHandler> ForwardReactor<R, F>

pub(super) fn new( runtime: R, unique_id: UniqId, circ_id: CircId, inner: F, hop_mgr: HopMgr<R>, inbound_chan_rx: CircuitRxReceiver, control_rx: UnboundedReceiver<CtrlMsg<F::CtrlMsg>>, command_rx: UnboundedReceiver<CtrlCmd<F::CtrlCmd>>, backward_reactor_tx: Sender<BackwardReactorCmd>, circ_events: Receiver<F::CircEvent>, padding_ctrl: PaddingController, ) -> Self

Create a new ForwardReactor.

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

Helper for run.

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

Handle a control command.

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

Handle a control message.

fn note_relay_cell_received( &self, hopnum: Option<HopNum>, c_t_w: bool, ) -> Result<(RelayCellFormat, bool)>

Note that we have received a RELAY cell.

Updates the padding and CC state.

async fn handle_relay_cell( &mut self, decode_res: RelayCellDecoderResult, early: bool, hopnum: Option<HopNum>, tag: SendmeTag, ) -> StdResult<(), ReactorError>

Handle a RELAY cell.

async fn handle_relay_msg( &mut self, early: bool, hop: Option<HopNum>, msg: UnparsedRelayMsg, relay_cell_format: RelayCellFormat, cell_counts_toward_windows: bool, ) -> StdResult<(), ReactorError>

Handle a single incoming RELAY message.

async fn handle_meta_msg( &mut self, early: bool, hopnum: Option<HopNum>, msg: UnparsedRelayMsg, relay_cell_format: RelayCellFormat, ) -> StdResult<(), ReactorError>

Handle a RELAY or RELAY_EARLY message on this circuit with stream ID 0.

async fn send_reactor_cmd( &mut self, forward: BackwardReactorCmd, ) -> StdResult<(), ReactorError>

Send a command to the backward reactor.

Blocks if the backward_reactor_tx channel is full, i.e. if the backward reactor is not ready to send any more cells.

Returns an error if the backward reactor has shut down.