Struct Reactor 

pub struct Reactor<R: Runtime> {

    pub(super) runtime: R,
    pub(super) control: UnboundedReceiver<CtrlMsg>,
    pub(super) reactor_closed_tx: Sender<Result<CloseInfo>>,
    pub(super) cells: CountingStream<Receiver<(AnyChanCell, Option<QueuedCellPaddingInfo>), MpscSpec>>,
    pub(super) input: Fuse<Box<dyn Stream<Item = Result<AnyChanCell, Error>> + Send + Unpin + 'static>>,
    pub(super) output: SinkBlocker<Box<dyn Sink<AnyChanCell, Error = Error> + Send + Unpin + 'static>, CountingPolicy>,
    pub(super) streamops: Box<dyn StreamOps + Send + Unpin + 'static>,
    pub(super) create_request_handler: Option<CreateRequestHandlerAndData>,
    pub(super) padding_timer: Pin<Box<Timer<R>>>,
    pub(super) special_outgoing: SpecialOutgoing,
    pub(super) circs: CircMap,
    pub(super) unique_id: UniqId,
    pub(super) details: Arc<ChannelDetails>,
    pub(super) circ_unique_id_ctx: CircUniqIdContext,
    pub(super) padding_ctrl: PaddingController<DynTimeProvider>,
    pub(super) padding_event_stream: PaddingEventStream<DynTimeProvider>,
    pub(super) padding_blocker: Option<StartBlocking>,
    pub(super) link_protocol: u16,
}

Object to handle incoming cells and background tasks on a channel.

This type is returned when you finish a channel; you need to spawn a new task that calls run() on it.

Fields

runtime: R

Underlying runtime we use for generating sleep futures and telling time.

control: UnboundedReceiver<CtrlMsg>

A receiver for control messages from Channel objects.

reactor_closed_tx: Sender<Result<CloseInfo>>

A oneshot sender that is used to alert other tasks when this reactor is finally dropped.

cells: CountingStream<Receiver<(AnyChanCell, Option<QueuedCellPaddingInfo>), MpscSpec>>

A receiver for cells to be sent on this reactor’s sink.

Channel objects have a sender that can send cells here.

input: Fuse<Box<dyn Stream<Item = Result<AnyChanCell, Error>> + Send + Unpin + 'static>>

A Stream from which we can read ChanCells.

This should be backed by a TLS connection if you want it to be secure.

output: SinkBlocker<Box<dyn Sink<AnyChanCell, Error = Error> + Send + Unpin + 'static>, CountingPolicy>

A Sink to which we can write ChanCells.

This should also be backed by a TLS connection if you want it to be secure.

streamops: Box<dyn StreamOps + Send + Unpin + 'static>

A handler for setting stream options on the underlying stream.

create_request_handler: Option<CreateRequestHandlerAndData>

A handler and associated data for CREATE2/CREATE_FAST messages, if this channel should handle them.

padding_timer: Pin<Box<Timer<R>>>

Timer tracking when to generate channel padding.

Note that this is distinct from the experimental maybenot-based padding implemented with padding_ctrl and padding_stream. This is the existing per-channel padding in the tor protocol used to resist netflow attacks.

special_outgoing: SpecialOutgoing

Outgoing cells introduced at the channel reactor

circs: CircMap

A map from circuit ID to Sinks on which we can deliver cells.

unique_id: UniqId

A unique identifier for this channel.

details: Arc<ChannelDetails>

Information shared with the frontend

circ_unique_id_ctx: CircUniqIdContext

Context for allocating unique circuit log identifiers.

padding_ctrl: PaddingController<DynTimeProvider>

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

(This is used for experimental maybenot-based padding.)

padding_event_stream: PaddingEventStream<DynTimeProvider>

An event stream telling us about padding-related events.

(This is used for experimental maybenot-based padding.)

padding_blocker: Option<StartBlocking>

If present, the current rules for blocking the output based on the padding framework.

link_protocol: u16

What link protocol is the channel using?

Implementations

impl<R: Runtime> Reactor<R>

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

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

Once this function returns, the channel is dead, and can’t be used again.

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

Helper for run(): handles only one action.

async fn handle_control(&mut self, msg: CtrlMsg) -> Result<()>

Handle a CtrlMsg other than Shutdown.

async fn handle_padding_event(&mut self, action: PaddingEvent) -> Result<()>

Take the padding action described in action.

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

Send the padding described in padding.

async fn output_is_full(&mut self) -> Result<bool>

Return true if the output stream is full.

We use this in circuit padding to implement replaceable padding.

async fn handle_cell(&mut self, cell: AnyChanCell) -> Result<()>

Helper: process a cell on a channel. Most cell types get ignored or rejected; a few get delivered to circuits.

async fn deliver_relay( &mut self, circid: Option<CircId>, msg: AnyChanMsg, ) -> Result<()>

Give the RELAY (or possibly RELAY_EARLY) cell msg to the appropriate circuit.

async fn handle_create( &mut self, circid: Option<CircId>, msg: CreateRequest, ) -> Result<()>

Handle a CREATE* cell msg.

fn deliver_created( &mut self, circid: Option<CircId>, msg: AnyChanMsg, ) -> Result<()>

Handle a CREATED{_FAST,2} cell by passing it on to the appropriate circuit, if that circuit is waiting for one.

async fn deliver_destroy( &mut self, circid: Option<CircId>, msg: AnyChanMsg, ) -> Result<()>

Handle a DESTROY cell by removing the corresponding circuit from the map, and passing the destroy cell onward to the circuit.

async fn send_cell(&mut self, cell: AnyChanCell) -> Result<()>

Helper: send a cell on the outbound sink.

async fn outbound_destroy_circ(&mut self, id: CircId) -> Result<()>

Called when a circuit goes away: sends a DESTROY cell and removes the circuit.

fn update_disused_since(&self)

Update disused timestamp with current time if this channel is no longer used

fn apply_kist_params(&self, params: &KistParams)

Use the new KIST parameters.

Trait Implementations

impl<R: Runtime> Display for Reactor<R>

Allows us to just say debug!(“{}: Reactor did a thing”, &self, …)

There is no risk of confusion because no-one would try to print a Reactor for some other reason.

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

Formats the value using the given formatter.