Enum TransactionKey 

pub enum TransactionKey {
    Rfc3261 {
        branch: Vec<u8>,
        sent_by: Vec<u8>,
        method: Vec<u8>,
    },
    Legacy {
        request_uri: Vec<u8>,
        top_via: Vec<u8>,
        from_tag: Vec<u8>,
        to_tag: Vec<u8>,
        call_id: Vec<u8>,
        cseq: u32,
        method: Vec<u8>,
    },
}

A key identifying a transaction.

Variants

Rfc3261

RFC 3261 matching: the branch carries the magic cookie.

Fields

branch: Vec<u8>

The branch parameter of the topmost Via.

sent_by: Vec<u8>

The topmost Via’s sent-by, lowercased.

method: Vec<u8>

The method, with ACK folded to INVITE.

Legacy

RFC 2543 matching, reconstructed from the fields that were available before branch meant anything.

Fields

request_uri: Vec<u8>

The Request-URI, for a request; empty for a response.

top_via: Vec<u8>

The topmost Via, verbatim.

from_tag: Vec<u8>

The From tag.

to_tag: Vec<u8>

The To tag, which RFC 3261 §17.2.3 makes part of the match: a forked INVITE retried under a different tag, and an ACK belonging to another branch’s response, are separate transactions however alike the rest of their fields look.

call_id: Vec<u8>

The Call-ID.

cseq: u32

The CSeq number.

method: Vec<u8>

The method, with ACK folded to INVITE.

Implementations

impl TransactionKey

pub fn from_request(request: &Request) -> Option<Self>

The key a received request belongs to (RFC 3261 §17.2.3).

Returns None if the request has no usable Via, which is not a transaction question — a request without a Via cannot be answered at all, and validation reports it.

pub fn from_sent_request(request: &Request) -> Option<Self>

The key a request sent by this element belongs to (RFC 3261 §17.1.3).

Not Self::from_request’s derivation. §17.2.3 is the server rule, and it keys a legacy transaction on the Request-URI and the To tag; a response has no Request-URI at all, and carries the tag the UAS added rather than the one the request was sent with. A client keyed by the server rule therefore never matches any of its own responses — it does not fail, it retransmits until Timer F with the answer sitting in front of it.

§17.1.3 is narrower on purpose (docs/specs/sip-transaction.md §6.2): the key is the branch and the CSeq method, over fields a response echoes back unchanged. This agrees with Self::from_response field for field, which is the property that matters.

The legacy half of this is reached by an application that supplies its own cookieless Via, not by an old peer: the topmost Via on a client transaction is ours, and the transport gives it a z9hG4bK branch. Self::from_request is the one old peers meet.

pub fn from_response(response: &Response) -> Option<Self>

The key a received response belongs to (RFC 3261 §17.1.3).

The branch of the topmost Via plus the CSeq method — and only those two. In particular the sent-by is not part of it, because the response may come back from a different address than the request went to.

pub fn for_cancelled_invite(request: &Request) -> Option<Self>

The key of the INVITE a CANCEL refers to (RFC 3261 §9.2).

A CANCEL shares the INVITE’s branch and differs only in method, so this is that key with the method put back. Returns None for anything that is not a CANCEL, since no other request cancels one.

pub fn is_legacy(&self) -> bool

Whether this key was derived by the pre-RFC-3261 rules.

Trait Implementations

impl Clone for TransactionKey

fn clone(&self) -> TransactionKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransactionKey

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

Formats the value using the given formatter.

impl Hash for TransactionKey

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 TransactionKey

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

impl StructuralPartialEq for TransactionKey