Enum TransactionTimer 

pub enum TransactionTimer {
    TimerA(TransactionKey, Duration),
    TimerB(TransactionKey),
    TimerC(TransactionKey),
    TimerD(TransactionKey),
    TimerK(TransactionKey),
    TimerG(TransactionKey, Duration),
    TimerCleanup(TransactionKey),
}

SIP Transaction Timers

TransactionTimer represents the various timers used in SIP transactions as defined in RFC 3261. These timers ensure reliable message delivery and proper transaction cleanup.

Timer Types

• TimerA - Retransmission timer for client transactions (unreliable transport)
• TimerB - Transaction timeout timer for client transactions
• TimerD - Wait timer for response retransmissions (client)
• TimerE - Retransmission timer for non-INVITE server transactions
• TimerF - Transaction timeout timer for non-INVITE server transactions
• TimerK - Wait timer for ACK (server INVITE transactions)
• TimerG - Retransmission timer for INVITE server transactions
• TimerCleanup - Internal cleanup timer for transaction removal

Timer Values (RFC 3261)

• T1 = 500ms (RTT estimate)
• T2 = 4s (maximum retransmit interval)
• T4 = 5s (maximum duration a message will remain in the network)

Timer Calculations

• Timer A: starts at T1, doubles each retransmission up to T2
• Timer B: 64*T1 (32 seconds)
• Timer D: 32 seconds for unreliable, 0 for reliable transports
• Timer E: starts at T1, doubles up to T2
• Timer F: 64*T1 (32 seconds)
• Timer G: starts at T1, doubles up to T2
• Timer K: T4 for unreliable, 0 for reliable transports

Examples

use rsipstack::transaction::{TransactionTimer, key::{TransactionKey, TransactionRole}};
use std::time::Duration;

// Create a mock request to generate a transaction key
let request = rsip::Request {
    method: rsip::Method::Register,
    uri: rsip::Uri::try_from("sip:example.com")?,
    headers: vec![
        rsip::Header::Via("SIP/2.0/UDP example.com:5060;branch=z9hG4bKnashds".into()),
        rsip::Header::CSeq("1 REGISTER".into()),
        rsip::Header::From("Alice <sip:alice@example.com>;tag=1928301774".into()),
        rsip::Header::CallId("a84b4c76e66710@pc33.atlanta.com".into()),
    ].into(),
    version: rsip::Version::V2,
    body: Default::default(),
};
let key = TransactionKey::from_request(&request, TransactionRole::Client)?;

let timer = TransactionTimer::TimerA(key.clone(), Duration::from_millis(500));
match timer {
    TransactionTimer::TimerA(key, duration) => {
        println!("Timer A fired for transaction {}", key);
    },
    TransactionTimer::TimerB(key) => {
        println!("Transaction {} timed out", key);
    },
    _ => {}
}

Usage

Timers are automatically managed by the transaction layer:

• Started when entering appropriate states
• Cancelled when leaving states or receiving responses
• Fire events that drive state machine transitions
• Handle retransmissions and timeouts

Variants

TimerA(TransactionKey, Duration)

TimerB(TransactionKey)

TimerC(TransactionKey)

TimerD(TransactionKey)

TimerK(TransactionKey)

TimerG(TransactionKey, Duration)

TimerCleanup(TransactionKey)

Implementations

impl TransactionTimer

pub fn key(&self) -> &TransactionKey

Trait Implementations

impl Display for TransactionTimer

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

Formats the value using the given formatter.