Struct LinkProtocol 

pub struct LinkProtocol {
    pub version: u32,
    pub circ_id_size: Size,
    pub fixed_cell_length: usize,
    pub first_circ_id: u32,
}

Link protocol version with version-dependent constants.

The Tor link protocol has evolved over time, with different versions using different field sizes and constants. This struct encapsulates the version-specific parameters needed for cell encoding and decoding.

Version Differences

Version	Circuit ID Size	First Circuit ID	Fixed Cell Length
1-3	2 bytes (Short)	0x0001	512 bytes
4+	4 bytes (Long)	0x80000000	514 bytes

The first_circ_id determines the starting point for client-initiated circuit identifiers. Clients use IDs with the high bit set (version 4+) or starting from 1 (version 1-3).

Example

use stem_rs::client::datatype::{LinkProtocol, Size};

// Version 3 uses 2-byte circuit IDs
let v3 = LinkProtocol::new(3);
assert_eq!(v3.circ_id_size, Size::Short);
assert_eq!(v3.first_circ_id, 0x01);

// Version 5 uses 4-byte circuit IDs
let v5 = LinkProtocol::new(5);
assert_eq!(v5.circ_id_size, Size::Long);
assert_eq!(v5.first_circ_id, 0x80000000);

Equality

LinkProtocol can be compared directly with u32 version numbers:

use stem_rs::client::datatype::LinkProtocol;

let protocol = LinkProtocol::new(5);
assert!(protocol == 5);
assert!(protocol != 4);

Fields

version: u32

The link protocol version number.

circ_id_size: Size

Size of circuit identifier fields (2 or 4 bytes).

fixed_cell_length: usize

Total length of fixed-size cells in bytes.

first_circ_id: u32

First circuit ID to use when creating circuits.

Clients pick circuit IDs from a range determined by the protocol version to avoid collisions with relay-initiated circuits.

Implementations

impl LinkProtocol

pub fn new(version: u32) -> Self

Creates a new LinkProtocol for the given version number.

This automatically configures all version-dependent constants based on the protocol specification.

Arguments

• version - The link protocol version (typically 4 or 5 for modern Tor)

Example

use stem_rs::client::datatype::LinkProtocol;

let protocol = LinkProtocol::new(5);
assert_eq!(protocol.version, 5);
assert_eq!(protocol.fixed_cell_length, 514);

Trait Implementations

impl Clone for LinkProtocol

fn clone(&self) -> LinkProtocol

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinkProtocol

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

Formats the value using the given formatter.

impl From<u32> for LinkProtocol

fn from(version: u32) -> Self

Creates a LinkProtocol from a version number.

impl Hash for LinkProtocol

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<u32> for LinkProtocol

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

Compares the protocol version with a u32.

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 PartialEq for LinkProtocol

fn eq(&self, other: &LinkProtocol) -> 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 LinkProtocol

impl Eq for LinkProtocol

impl StructuralPartialEq for LinkProtocol