Struct ChanMgrStatus

struct ChanMgrStatus {
    startup: Instant,
    n_attempts: usize,
    last_tcp_success: Option<Instant>,
    last_tls_success: Option<Instant>,
    last_chan_auth_success: Option<Instant>,
    last_chan_success: Option<Instant>,
}

Crate-internal view of “how connected are we to the internet?”

This is a more complex and costly structure than ConnStatus, so we track this here, and only expose the minimum via ConnStatus over a postage::watch. Later, we might want to expose more of this information.

Fields

startup: Instant

When did we first get initialized?

n_attempts: usize

Since we started, how many channels have we tried to build?

last_tcp_success: Option<Instant>

When (if ever) have we made a TCP connection to (what we hoped was) a Tor relay?

If we don’t reach this point, we’re probably not on the internet.

If we get no further than this, we’re probably having our TCP connections captured or replaced.

last_tls_success: Option<Instant>

When (if ever) have we successfully finished a TLS handshake to (what we hoped was) a Tor relay?

If we get no further than this, we might be facing a TLS MITM attack.

last_chan_auth_success: Option<Instant>

When (if ever) have we ever finished the inner Tor handshake with a relay, up to the point where we check for certificate timeliness?

last_chan_success: Option<Instant>

When (if ever) have we successfully finished the inner Tor handshake with a relay?

If we get to this point, we can successfully talk to something that holds the private key that it’s supposed to.

Implementations

impl ChanMgrStatus

fn new_at(now: Instant) -> ChanMgrStatus

Construct a new ChanMgr status.

It will be built as having been initialized at the time now.

fn conn_status_at(&self, now: Instant) -> ConnStatus

Return a ConnStatus for the current state, at time now.

(The time is necessary because a lack of success doesn’t indicate a problem until enough time has passed.)

fn record_attempt(&mut self)

Note that an attempt to connect has been started.

fn record_tcp_success(&mut self, now: Instant)

Note that we’ve successfully done a TCP handshake with an alleged relay.

fn record_tls_finished(&mut self, now: Instant)

Note that we’ve completed a TLS handshake with an alleged relay.

(Its identity won’t be verified till the next step.)

fn record_handshake_done_with_skewed_clock(&mut self, now: Instant)

Note that we’ve completed a Tor handshake with a relay, but failed to verify the certificates in a way that could indicate clock skew.

fn record_handshake_done(&mut self, now: Instant)

Note that we’ve completed a Tor handshake with a relay.

(This includes performing the TLS handshake, and verifying that the relay was indeed the one that we wanted to reach.)

Trait Implementations

impl Clone for ChanMgrStatus

fn clone(&self) -> ChanMgrStatus

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ChanMgrStatus

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

Formats the value using the given formatter.