Enum LinkSpecifier 

pub enum LinkSpecifier {
    IPv4 {
        address: String,
        port: u16,
    },
    IPv6 {
        address: String,
        port: u16,
    },
    Fingerprint {
        fingerprint: [u8; 20],
    },
    Ed25519 {
        fingerprint: [u8; 32],
    },
    Unknown {
        link_type: u8,
        value: Vec<u8>,
    },
}

Method of communicating with a relay in a circuit.

Link specifiers describe how to connect to a relay when extending a circuit. They are used in EXTEND2 cells to specify the next hop. Multiple specifiers can be provided to give the extending relay options for how to connect.

For more information, see the EXTEND cell specification.

Wire Format

+----------+--------+------------------+
| Type (1) | Len (1)| Value (Len bytes)|
+----------+--------+------------------+

Variants

Type	Value Size	Description
0	6 bytes	IPv4 address (4) + port (2)
1	18 bytes	IPv6 address (16) + port (2)
2	20 bytes	SHA-1 identity fingerprint
3	32 bytes	Ed25519 identity fingerprint
4+	variable	Unknown/future types

Example

use stem_rs::client::datatype::LinkSpecifier;

// Create an IPv4 link specifier
let spec = LinkSpecifier::IPv4 {
    address: "192.168.1.1".to_string(),
    port: 9001,
};

// Pack and unpack
let packed = spec.pack();
let (unpacked, _) = LinkSpecifier::pop(&packed).unwrap();

match unpacked {
    LinkSpecifier::IPv4 { address, port } => {
        assert_eq!(address, "192.168.1.1");
        assert_eq!(port, 9001);
    }
    _ => panic!("Expected IPv4"),
}

Variants

IPv4

TLS connection to an IPv4 address.

Fields

address: String

The relay’s IPv4 address.

port: u16

The relay’s ORPort.

IPv6

TLS connection to an IPv6 address.

Fields

address: String

The relay’s IPv6 address (fully expanded form).

port: u16

The relay’s ORPort.

Fingerprint

SHA-1 identity fingerprint (20 bytes).

Fields

fingerprint: [u8; 20]

The relay’s SHA-1 identity fingerprint.

Ed25519

Ed25519 identity fingerprint (32 bytes).

Fields

fingerprint: [u8; 32]

The relay’s Ed25519 identity fingerprint.

Unknown

Unrecognized link specifier type.

Fields

link_type: u8

The raw link type byte.

value: Vec<u8>

The raw value bytes.

Implementations

impl LinkSpecifier

pub fn link_type(&self) -> u8

Returns the link type byte for this specifier.

Type	Meaning
0	IPv4
1	IPv6
2	Fingerprint
3	Ed25519
4+	Unknown

pub fn value(&self) -> Vec<u8>

Returns the encoded value bytes for this specifier.

The format depends on the specifier type:

• IPv4: 4-byte address + 2-byte port
• IPv6: 16-byte address + 2-byte port
• Fingerprint: 20-byte SHA-1 hash
• Ed25519: 32-byte public key

pub fn pack(&self) -> Vec<u8>

Packs the link specifier into its wire format.

Returns

A Vec<u8> containing: [type (1), length (1), value...]

pub fn unpack(data: &[u8]) -> Result<Self, Error>

Unpacks a link specifier from its wire format.

Arguments

• data - The packed link specifier bytes

Errors

Returns Error::Protocol if the data is malformed.

pub fn pop(packed: &[u8]) -> Result<(Self, &[u8]), Error>

Unpacks a link specifier from the start of a byte slice, returning the remainder.

Arguments

• packed - The byte slice to read from

Returns

A tuple of (LinkSpecifier, remainder).

Errors

Returns Error::Protocol if:

• The data is too short for the header
• The specified length exceeds the available data
• The value size doesn’t match the expected size for the type

Trait Implementations

impl Clone for LinkSpecifier

fn clone(&self) -> LinkSpecifier

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LinkSpecifier

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

Formats the value using the given formatter.

impl PartialEq for LinkSpecifier

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

impl StructuralPartialEq for LinkSpecifier