tor-proto 0.41.0

Asynchronous client-side implementation of the central Tor network protocols
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! Circuit padding
//!
// TODO(DEDUP): we should eventually move client::circuit::padding here

#[cfg(feature = "circ-padding")]
use {crate::circuit::cell_sender::CircuitCellSender, crate::client::circuit::padding};

/// A possible way to handle a request to send padding.
#[derive(Copy, Clone, Debug)]
pub(crate) enum CircPaddingDisposition {
    /// Enqueue the padding normally.
    QueuePaddingNormally,
    /// Enqueue the padding, and allow one cell of data on our outbound queue
    /// to bypass the current block.
    QueuePaddingAndBypass,
    /// Do not take any actual padding action:
    /// existing data on our outbound queue will count as padding.
    TreatQueuedCellAsPadding,
}

/// Determine how exactly to handle a request to handle padding.
///
/// This is fairly complicated; see the maybenot documentation for more information.
///
// TODO(relay): relays use the same logic as clients here. Is that okay,
// or do they need to handle SendPadding differently??
#[cfg(feature = "circ-padding")]
pub(crate) fn padding_disposition(
    send_padding: &padding::SendPadding,
    chan_sender: &CircuitCellSender,
    padding_block: Option<&padding::StartBlocking>,
) -> CircPaddingDisposition {
    use CircPaddingDisposition::*;
    use padding::Bypass::*;
    use padding::Replace::*;

    // If true, and we are trying to send Replaceable padding,
    // we should let any data in the queue count as the queued padding instead,
    // if it is queued for our target hop (or any subsequent hop).
    //
    // TODO circpad: In addition to letting currently-queued data count as padding,
    // maybenot also permits us to send currently pending data from our streams
    // (or from our next hop, if we're a relay).  We don't have that implemented yet.
    //
    // TODO circpad: This will usually be false, since we try not to queue data
    // when there isn't space to write it.  If we someday add internal per-circuit
    // Buffers to chan_sender, this test is more likely to trigger.
    let have_queued_cell_for_hop = chan_sender.have_queued_cell_for_hop_or_later(send_padding.hop);

    match padding_block {
        Some(blocking) if blocking.is_bypassable => {
            match (
                send_padding.may_replace_with_data(),
                send_padding.may_bypass_block(),
            ) {
                (NotReplaceable, DoNotBypass) => QueuePaddingNormally,
                (NotReplaceable, BypassBlocking) => QueuePaddingAndBypass,
                (Replaceable, DoNotBypass) => {
                    if have_queued_cell_for_hop {
                        TreatQueuedCellAsPadding
                    } else {
                        QueuePaddingNormally
                    }
                }
                (Replaceable, BypassBlocking) => {
                    if have_queued_cell_for_hop {
                        TreatQueuedCellAsPadding
                    } else {
                        QueuePaddingAndBypass
                    }
                }
            }
        }
        Some(_) | None => match send_padding.may_replace_with_data() {
            Replaceable => {
                if have_queued_cell_for_hop {
                    TreatQueuedCellAsPadding
                } else {
                    QueuePaddingNormally
                }
            }
            NotReplaceable => QueuePaddingNormally,
        },
    }
}