Struct CircHop 

pub(crate) struct CircHop {
    unique_id: TunnelScopedCircId,
    hop_num: HopNum,
    inbound: CircHopInbound,
    outbound: CircHopOutbound,
}

Represents the reactor’s view of a single hop.

Fields

unique_id: TunnelScopedCircId

The unique ID of the circuit. Used for logging.

hop_num: HopNum

Hop number in the path.

inbound: CircHopInbound

The inbound state of the hop.

Used for processing cells received from this hop.

outbound: CircHopOutbound

The outbound state of the hop.

Used for preparing cells to send to this hop.

Implementations

impl CircHop

pub(crate) fn new( unique_id: TunnelScopedCircId, hop_num: HopNum, settings: &HopSettings, ) -> Self

Create a new hop.

pub(crate) fn begin_stream( &mut self, message: AnyRelayMsg, sender: StreamQueueSender, rx: Receiver<AnyRelayMsg, MpscSpec>, rate_limit_updater: Sender<StreamRateLimit>, drain_rate_requester: NotifySender<DrainRateRequest>, cmd_checker: Box<dyn CmdChecker + Send + 'static>, ) -> Result<(SendRelayCell, StreamId)>

Start a stream. Creates an entry in the stream map with the given channels, and sends the message to the provided hop.

pub(crate) fn close_stream( &mut self, id: StreamId, message: CloseStreamBehavior, why: TerminateReason, expiry: Instant, ) -> Result<Option<SendRelayCell>>

Close the stream associated with id because the stream was dropped.

See CircHopOutbound::close_stream.

pub(crate) fn maybe_send_xon( &mut self, rate: XonKbpsEwma, id: StreamId, ) -> Result<Option<Xon>>

Check if we should send an XON message.

If we should, then returns the XON message that should be sent.

pub(crate) fn maybe_send_xoff(&mut self, id: StreamId) -> Result<Option<Xoff>>

Check if we should send an XOFF message.

If we should, then returns the XOFF message that should be sent.

pub(crate) fn relay_cell_format(&self) -> RelayCellFormat

Return the format that is used for relay cells sent to this hop.

For the most part, this format isn’t necessary to interact with a CircHop; it becomes relevant when we are deciding what we can encode for the hop.

pub(crate) fn ccontrol(&self) -> MutexGuard<'_, CongestionControl>

Return a mutable reference to our CongestionControl object.

pub(crate) fn outbound(&self) -> &CircHopOutbound

Return a reference to our CircHopOutbound object.

pub(crate) fn about_to_send( &mut self, stream_id: StreamId, msg: &AnyRelayMsg, ) -> Result<()>

We’re about to send msg.

See OpenStreamEnt::about_to_send.

pub(crate) fn add_ent_with_id( &self, sink: StreamQueueSender, rx: Receiver<AnyRelayMsg, MpscSpec>, rate_limit_updater: Sender<StreamRateLimit>, drain_rate_requester: NotifySender<DrainRateRequest>, stream_id: StreamId, cmd_checker: Box<dyn CmdChecker + Send + 'static>, ) -> Result<()>

Add an entry to this map using the specified StreamId.

pub(crate) fn ending_msg_received(&self, stream_id: StreamId) -> Result<()>

Note that we received an END message (or other message indicating the end of the stream) on the stream with id.

See StreamMap::ending_msg_received.

pub(crate) fn decode( &mut self, cell: BoxedCellBody, ) -> Result<RelayCellDecoderResult>

Parse a RELAY or RELAY_EARLY cell body.

Requires that the cryptographic checks on the message have already been performed

pub(super) fn handle_msg( &self, hop_detail: &PathEntry, cell_counts_toward_windows: bool, streamid: StreamId, msg: UnparsedRelayMsg, now: Instant, ) -> Result<Option<UnparsedRelayMsg>>

Handle msg, delivering it to the stream with the specified streamid if appropriate.

Returns back the provided msg, if the message is an incoming stream request that needs to be handled by the calling code.

pub(crate) fn stream_map(&self) -> &Arc<Mutex<StreamMap>>

Get the stream map of this hop.

pub(crate) fn set_stream_map( &mut self, map: Arc<Mutex<StreamMap>>, ) -> StdResult<(), Bug>

Set the stream map of this hop to map.

Returns an error if the existing stream map of the hop has any open stream.

pub(crate) fn decrement_outbound_cell_limit(&mut self) -> Result<()>

Decrement the limit of outbound cells that may be sent to this hop; give an error if it would reach zero.

pub(crate) fn decrement_inbound_cell_limit(&mut self) -> Result<()>

Decrement the limit of inbound cells that may be received from this hop; give an error if it would reach zero.