Struct CircuitExtender 

pub(crate) struct CircuitExtender<H>
where
    H: ClientHandshake,
{
    peer_id: OwnedChanTarget,
    state: Option<H::StateType>,
    settings: HopSettings,
    unique_id: TunnelScopedCircId,
    expected_hop: HopNum,
    operation_finished: Option<Sender<Result<()>>>,
}

An object that can extend a circuit by one hop, using the MetaCellHandler trait.

Yes, I know having trait bounds on structs is bad, but in this case it’s necessary since we want to be able to use H::KeyType.

Fields

peer_id: OwnedChanTarget

The peer that we’re extending to.

Used to extend our record of the circuit’s path.

state: Option<H::StateType>

Handshake state.

settings: HopSettings

In-progress settings that we’re negotiating for this hop.

unique_id: TunnelScopedCircId

An identifier for logging about this reactor’s circuit.

expected_hop: HopNum

The hop we’re expecting the EXTENDED2 cell to come back from.

operation_finished: Option<Sender<Result<()>>>

A oneshot channel that we should inform when we are done with this extend operation.

Implementations

impl<H> CircuitExtender<H>

where H: ClientHandshake + HandshakeAuxDataHandler, H::KeyGen: KeyGenerator,

pub(crate) fn begin( peer_id: OwnedChanTarget, handshake_id: HandshakeType, key: &H::KeyType, linkspecs: Vec<EncodedLinkSpec>, settings: HopSettings, client_aux_data: &impl Borrow<H::ClientAuxData>, circ: &mut Circuit, done: Sender<Result<()>>, ) -> Result<(Self, SendRelayCell)>

Start extending a circuit, sending the necessary EXTEND cell and returning a new CircuitExtender to be called when the reply arrives.

The handshake_id is the numeric identifier for what kind of handshake we’re doing. The key is the relay’s onion key that goes along with the handshake, and the linkspecs are the link specifiers to include in the EXTEND cell to tell the current last hop which relay to connect to.

fn extend_circuit( &mut self, msg: UnparsedRelayMsg, circ: &mut Circuit, ) -> Result<MetaCellDisposition>

Perform the work of extending the circuit another hop.

This is a separate function to simplify the error-handling work of handle_msg().

Trait Implementations

impl<H> MetaCellHandler for CircuitExtender<H>

where H: ClientHandshake + HandshakeAuxDataHandler, H::StateType: Send, H::KeyGen: KeyGenerator,

fn expected_hop(&self) -> HopLocation

The hop we’re expecting the message to come from. This is compared against the hop from which we actually receive messages, and an error is thrown if the two don’t match.

fn handle_msg( &mut self, msg: UnparsedRelayMsg, circ: &mut Circuit, ) -> Result<MetaCellDisposition>

Called when the message we were waiting for arrives.