Struct Certificate 

pub struct Certificate {
    pub cert_type: CertType,
    pub type_int: u8,
    pub value: Vec<u8>,
}

A relay certificate as defined in tor-spec section 4.2.

Certificates are used in CERTS cells to authenticate relays during the link handshake. Each certificate has a type and a variable-length value containing the actual certificate data.

Wire Format

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

Note that the length field is 2 bytes (unlike Address which uses 1 byte).

Example

use stem_rs::client::datatype::{Certificate, CertType};

// Create a certificate
let cert = Certificate::new(CertType::Link, vec![0x01, 0x02, 0x03]);
assert_eq!(cert.cert_type, CertType::Link);

// Pack and unpack
let packed = cert.pack();
let (unpacked, _) = Certificate::pop(&packed).unwrap();
assert_eq!(cert, unpacked);

Fields

cert_type: CertType

The type of this certificate.

type_int: u8

The raw type byte (preserved for unknown types).

value: Vec<u8>

The certificate data.

Implementations

impl Certificate

pub fn new(cert_type: CertType, value: Vec<u8>) -> Self

Creates a new certificate with the given type and value.

Arguments

• cert_type - The certificate type
• value - The certificate data

pub fn from_int(cert_type: u8, value: Vec<u8>) -> Self

Creates a certificate from a raw type byte and value.

This is used when parsing certificates from the wire format.

Arguments

• cert_type - The raw certificate type byte
• value - The certificate data

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

Packs the certificate into its wire format.

Returns

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

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

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

Arguments

• content - The byte slice to read from

Returns

A tuple of (Certificate, remainder).

Errors

Returns Error::Protocol if:

• The data is too short for the header
• The specified length exceeds the available data

Trait Implementations

impl Clone for Certificate

fn clone(&self) -> Certificate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Certificate

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

Formats the value using the given formatter.

impl PartialEq for Certificate

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

impl StructuralPartialEq for Certificate