Enum RelayCommand 

pub enum RelayCommand {
    Begin = 1,
    Data = 2,
    End = 3,
    Connected = 4,
    SendMe = 5,
    Extend = 6,
    Extended = 7,
    Truncate = 8,
    Truncated = 9,
    Drop = 10,
    Resolve = 11,
    Resolved = 12,
    BeginDir = 13,
    Extend2 = 14,
    Extended2 = 15,
    Unknown = 16,
}

Relay cell command types.

Commands used within relay cells to manage streams and circuits. These commands have two characteristics:

• Direction: Forward commands originate from the client; backward commands come from the relay.
• Scope: Stream commands affect individual streams; circuit commands affect the entire circuit.

Variants

Command	Value	Direction	Scope	Description
Begin	1	Forward	Stream	Begin a new stream
Data	2	Forward/Backward	Stream	Transmit data
End	3	Forward/Backward	Stream	End a stream
Connected	4	Backward	Stream	Reply to BEGIN
SendMe	5	Forward/Backward	Both	Flow control acknowledgment
Extend	6	Forward	Circuit	Extend circuit (legacy)
Extended	7	Backward	Circuit	Reply to EXTEND
Truncate	8	Forward	Circuit	Remove last hop
Truncated	9	Backward	Circuit	Reply to TRUNCATE
Drop	10	Forward/Backward	Circuit	Ignorable no-op
Resolve	11	Forward	Stream	DNS resolution request
Resolved	12	Backward	Stream	Reply to RESOLVE
BeginDir	13	Forward	Stream	Request directory info
Extend2	14	Forward	Circuit	Extend circuit (ntor)
Extended2	15	Backward	Circuit	Reply to EXTEND2
Unknown	-	-	-	Unrecognized command

Example

use stem_rs::client::datatype::RelayCommand;

let (cmd, raw) = RelayCommand::get(1);
assert_eq!(cmd, RelayCommand::Begin);
assert_eq!(format!("{}", cmd), "RELAY_BEGIN");

Variants

Begin = 1

Begin a new stream (forward, stream).

Data = 2

Transmit data (forward/backward, stream).

End = 3

End a stream (forward/backward, stream).

Connected = 4

Reply to BEGIN (backward, stream).

SendMe = 5

Flow control - ready for more cells (forward/backward, stream/circuit).

Extend = 6

Extend circuit through another relay - legacy (forward, circuit).

Extended = 7

Reply to EXTEND (backward, circuit).

Truncate = 8

Remove last circuit hop (forward, circuit).

Truncated = 9

Reply to TRUNCATE (backward, circuit).

Drop = 10

Ignorable no-op (forward/backward, circuit).

Resolve = 11

Request DNS resolution (forward, stream).

Resolved = 12

Reply to RESOLVE (backward, stream).

BeginDir = 13

Request directory information (forward, stream).

Extend2 = 14

Extend circuit - ntor handshake (forward, circuit).

Extended2 = 15

Reply to EXTEND2 (backward, circuit).

Unknown = 16

Unrecognized command.

Implementations

impl RelayCommand

pub fn get(val: u8) -> (RelayCommand, u8)

Converts a raw byte value to a RelayCommand and its integer representation.

Arguments

• val - The raw command byte from the relay cell

Returns

A tuple of (RelayCommand, u8) where the second element is the original byte value.

pub fn value(&self) -> u8

Returns the integer value for this relay command.

Returns 255 for Unknown commands.

Trait Implementations

impl Clone for RelayCommand

fn clone(&self) -> RelayCommand

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RelayCommand

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

Formats the value using the given formatter.

impl Display for RelayCommand

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

Formats the relay command as its canonical string name.

impl Hash for RelayCommand

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RelayCommand

fn eq(&self, other: &RelayCommand) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for RelayCommand

impl Eq for RelayCommand

impl StructuralPartialEq for RelayCommand