Struct Forward 

pub(crate) struct Forward {
    unique_id: UniqId,
    outbound: Option<Outbound>,
    crypto_out: Box<dyn OutboundRelayLayer + Send>,
    relay_early_count: usize,
    extend_handler: ExtendRequestHandler,
}

Relay-specific state for the forward reactor.

Fields

unique_id: UniqId

An identifier for logging about this reactor’s circuit.

outbound: Option<Outbound>

The outbound view of this circuit, if we are not the last hop.

Delivers cells towards the exit.

Only set for middle relays.

crypto_out: Box<dyn OutboundRelayLayer + Send>

The cryptographic state for this circuit for inbound cells.

relay_early_count: usize

The number of RELAY_EARLY cells we have seen so far on this circuit.

If we see more than MAX_RELAY_EARLY_CELLS_PER_CIRCUIT RELAY_EARLY cells, we tear down the circuit.

extend_handler: ExtendRequestHandler

Helper for handling circuit extension requests.

Used for validating EXTEND2 cells.

Implementations

impl Forward

pub(crate) fn new( inbound_chan: &Arc<Channel>, unique_id: UniqId, crypto_out: Box<dyn OutboundRelayLayer + Send>, chan_provider: Arc<dyn ChannelProvider<BuildSpec = OwnedChanTarget> + Send + Sync>, event_tx: Sender<CircEvent>, memquota: CircuitAccount, ) -> Self

Create a new Forward.

fn decode_relay_cell<R: Runtime>( &mut self, hop_mgr: &mut HopMgr<R>, cell: Relay, ) -> Result<(Option<HopNum>, CellDecodeResult)>

Decode cell, returning its corresponding hop number, tag and decoded body.

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

Handle a DROP message.

fn handle_extend_result( &mut self, res: StdResult<ExtendResult, ReactorError>, ) -> StdResult<Option<BackwardReactorCmd>, ReactorError>

Handle the outcome of handling an EXTEND2.

fn handle_relay_cell<R: Runtime>( &mut self, hop_mgr: &mut HopMgr<R>, cell: Relay, early: bool, ) -> StdResult<Option<ForwardCellDisposition>, ReactorError>

Handle a RELAY or RELAY_EARLY cell.

fn handle_unrecognized_cell( &mut self, body: RelayCellBody, info: Option<QueuedCellPaddingInfo>, early: bool, ) -> StdResult<(), ReactorError>

Handle a forward cell that we could not decrypt.

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

Handle a TRUNCATE cell.

fn handle_destroy_cell(&mut self, _cell: Destroy) -> StdResult<(), ReactorError>

Handle a DESTROY cell originating from the client.

fn handle_padding_negotiate( &mut self, _cell: PaddingNegotiate, ) -> StdResult<(), ReactorError>

Handle a PADDING_NEGOTIATE cell originating from the client.

Trait Implementations

impl ControlHandler for Forward

type CtrlMsg = ()

The type of control message expected by the forward reactor.

type CtrlCmd = ()

The type of control command expected by the forward reactor.

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

Handle a control command.

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

Handle a control message.

impl Drop for Forward

fn drop(&mut self)

Executes the destructor for this type.

impl ForwardHandler for Forward

type BuildSpec = OwnedChanTarget

Type that explains how to build an outgoing channel.

type CircChanMsg = RelayCircChanMsg

The subclass of ChanMsg that can arrive on this type of circuit.

type CircEvent = CircEvent

An opaque event type.

async fn handle_meta_msg<R: Runtime>( &mut self, runtime: &R, early: bool, _hopnum: Option<HopNum>, msg: UnparsedRelayMsg, _relay_cell_format: RelayCellFormat, ) -> StdResult<(), ReactorError>

Handle a non-SENDME RELAY message on this circuit with stream ID 0.

async fn handle_forward_cell<R: Runtime>( &mut self, hop_mgr: &mut HopMgr<R>, cell: RelayCircChanMsg, ) -> StdResult<Option<ForwardCellDisposition>, ReactorError>

Handle a forward (TODO terminology) cell.

fn handle_event( &mut self, event: Self::CircEvent, ) -> StdResult<Option<BackwardReactorCmd>, ReactorError>

Handle an implementation-specific circuit event.

async fn outbound_chan_ready(&mut self) -> Result<()>

Wait until the outbound channel, if there is one, is ready to accept more cells.