Struct Context

struct Context<'c, R: Runtime, M: MocksForConnect<R>> {
    runtime: &'c R,
    circpool: &'c M::HsCircPool,
    netdir: Arc<NetDir>,
    config: Arc<Config>,
    secret_keys: HsClientSecretKeys,
    hsid: HsId,
    hs_blind_id: HsBlindId,
    subcredential: Subcredential,
    mocks: M,
}

Common context for a single request to connect to a hidden service

This saves on passing this same set of (immutable) values (or subsets thereof) to each method in the principal functional code, everywhere. It also provides a convenient type to be Self.

Its lifetime is one request to make a new client circuit to a hidden service, including all the retries and timeouts.

Fields

runtime: &'c R

Runtime

circpool: &'c M::HsCircPool

Circpool

netdir: Arc<NetDir>

Netdir

config: Arc<Config>

Configuration

secret_keys: HsClientSecretKeys

Secret keys to use

hsid: HsId

HS ID

hs_blind_id: HsBlindId

Blinded HS ID

subcredential: Subcredential

The subcredential to use during this time period

mocks: M

Mock data

Implementations

impl<'c, R: Runtime, M: MocksForConnect<R>> Context<'c, R, M>

fn new( runtime: &'c R, circpool: &'c M::HsCircPool, netdir: Arc<NetDir>, config: Arc<Config>, hsid: HsId, secret_keys: HsClientSecretKeys, mocks: M, ) -> Result<Self, ConnError>

Make a new Context from the input data

async fn connect( &self, data: &mut Data, ) -> Result<Arc<<<M as MocksForConnect<R>>::HsCircPool as MockableCircPool<R>>::ClientCirc>, ConnError>

Actually make a HS connection, updating our recorded state as necessary

Called by the connect function in this module.

This function handles all necessary retrying of fallible operations, (and, therefore, must also limit the total work done for a particular call).

async fn descriptor_ensure<'d>( &self, data: &'d mut Option<TimerangeBound<HsDesc>>, ) -> Result<&'d HsDesc, CE>

Ensure that Data.desc contains the HS descriptor

If we have a previously-downloaded descriptor, which is still valid, just returns a reference to it.

Otherwise, tries to obtain the descriptor by downloading it from hsdir(s).

Does all necessary retries and timeouts. Returns an error if no valid descriptor could be found.

async fn descriptor_fetch_attempt( &self, hsdir: &Relay<'_>, ) -> Result<TimerangeBound<HsDesc>, DescriptorErrorDetail>

Make one attempt to fetch the descriptor from a specific hsdir

No timeout

On success, returns the descriptor.

While the returned descriptor is TimerangeBound, its validity at the current time has been checked.

async fn intro_rend_connect( &self, desc: &HsDesc, data: &mut HashMap<RelayIdForExperience, IptExperience>, ) -> Result<Arc<<<M as MocksForConnect<R>>::HsCircPool as MockableCircPool<R>>::ClientCirc>, CE>

Given the descriptor, try to connect to service

Does all necessary retries, timeouts, etc.

async fn establish_rendezvous( &'c self, using_rend_pt: &mut Option<Redacted<RelayIds>>, ) -> Result<Rendezvous<'c, R, M>, FAE>

Make one attempt to establish a rendezvous circuit

This doesn’t really depend on anything, other than (obviously) the isolation implied by our circuit pool. In particular it doesn’t depend on the introduction point.

Does not apply a timeout.

On entry using_rend_pt is None. This function will store Some when it finds out which relay it is talking to and starts to converse with it. That way, if a timeout occurs, the caller can add that information to the error.

async fn exchange_introduce( &'c self, ipt: &UsableIntroPt<'_>, rendezvous: &mut Option<Rendezvous<'c, R, M>>, proof_of_work: Option<ProofOfWork>, ) -> Result<(Rendezvous<'c, R, M>, Introduced<R, M>), FAE>

Attempt (once) to send an INTRODUCE1 and wait for the INTRODUCE_ACK

takes the input rendezvous (but only takes it if it gets that far) and, if successful, returns it. (This arranges that the rendezvous is “used up” precisely if we sent its secret somewhere.)

Although this function handles the Rendezvous, nothing in it actually involves the rendezvous point. So if there’s a failure, it’s purely to do with the introduction point.

Does not apply a timeout.

async fn complete_rendezvous( &'c self, ipt: &UsableIntroPt<'_>, rendezvous: Rendezvous<'c, R, M>, introduced: Introduced<R, M>, ) -> Result<Arc<<<M as MocksForConnect<R>>::HsCircPool as MockableCircPool<R>>::ClientCirc>, FAE>

Attempt (once) to connect a rendezvous circuit using the given intro pt

Timeouts here might be due to the IPT, RPT, service, or any of the intermediate relays.

If, rather than a timeout, we actually encounter some kind of error, we’ll return the appropriate FailedAttemptError. (Who is responsible may vary, so the FailedAttemptError variant will reflect that.)

Does not apply a timeout

fn estimate_timeout(&self, actions: &[(u32, TimeoutsAction)]) -> Duration

Helper to estimate a timeout for a complicated operation

actions is a list of (count, action), where each entry represents doing action, count times sequentially.

Combines the timeout estimates and returns an overall timeout.