Enum Cell 

pub enum Cell {
    Padding(PaddingCell),
    Versions(VersionsCell),
    Netinfo(NetinfoCell),
    CreateFast(CreateFastCell),
    CreatedFast(CreatedFastCell),
    Relay(RelayCell),
    Destroy(DestroyCell),
    VPadding(VPaddingCell),
    Certs(CertsCell),
    AuthChallenge(AuthChallengeCell),
}

Parsed cell from the Tor relay protocol.

This enum represents all supported cell types that can be parsed from or serialized to the wire format. Each variant wraps a specific cell type struct with its associated data.

Parsing

Use Cell::pop to parse a single cell from bytes, or Cell::unpack_all to parse multiple cells.

Serialization

Use Cell::pack to serialize a cell to bytes for transmission.

Example

use stem_rs::client::cell::{Cell, VersionsCell};
use stem_rs::client::datatype::LinkProtocol;

// Create and pack a cell
let versions = VersionsCell::new(vec![3, 4, 5]);
let packed = versions.pack(&LinkProtocol::new(2));

// Parse the cell back
let (cell, _) = Cell::pop(&packed, 2).unwrap();
match cell {
    Cell::Versions(v) => assert_eq!(v.versions, vec![3, 4, 5]),
    _ => panic!("Expected VersionsCell"),
}

Variants

Padding(PaddingCell)

Fixed-size padding cell.

Versions(VersionsCell)

Link protocol version negotiation.

Netinfo(NetinfoCell)

Time and address information.

CreateFast(CreateFastCell)

Create circuit without public key.

CreatedFast(CreatedFastCell)

Acknowledge fast circuit creation.

Relay(RelayCell)

End-to-end encrypted relay data.

Destroy(DestroyCell)

Tear down a circuit.

VPadding(VPaddingCell)

Variable-length padding.

Certs(CertsCell)

Relay certificates.

AuthChallenge(AuthChallengeCell)

Authentication challenge.

Implementations

impl Cell

pub fn pack(&self, link_protocol: u32) -> Vec<u8>

Packs this cell into bytes for transmission.

The output format depends on the link protocol version and cell type.

Arguments

• link_protocol - Link protocol version (affects circuit ID size)

pub fn pop(content: &[u8], link_protocol: u32) -> Result<(Cell, Vec<u8>), Error>

Parses a single cell from bytes and returns the remainder.

This is the primary method for parsing cells from received data. It handles both fixed-size and variable-size cells based on the command type.

Arguments

• content - Bytes to parse
• link_protocol - Link protocol version (affects circuit ID size)

Returns

A tuple of (parsed cell, remaining bytes).

Errors

Returns Error::Protocol if:

• Content is too short for the cell header
• Content is too short for the declared payload
• Cell type is unknown or not yet implemented

Example

use stem_rs::client::cell::{Cell, VersionsCell};
use stem_rs::client::datatype::LinkProtocol;

let versions = VersionsCell::new(vec![3, 4, 5]);
let packed = versions.pack(&LinkProtocol::new(2));

let (cell, remainder) = Cell::pop(&packed, 2).unwrap();
assert!(remainder.is_empty());

pub fn unpack_all( content: &[u8], link_protocol: u32, ) -> Result<Vec<Cell>, Error>

Parses all cells from a byte buffer.

Repeatedly calls Cell::pop until all bytes are consumed.

Arguments

• content - Bytes containing one or more cells
• link_protocol - Link protocol version

Errors

Returns an error if any cell fails to parse.

Trait Implementations

impl Clone for Cell

fn clone(&self) -> Cell

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Cell

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

Formats the value using the given formatter.

impl PartialEq for Cell

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