fix: update version to 0.2.63, modify transaction timers

Author: shenjinti

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rsipstack"
-version = "0.2.62"
+version = "0.2.63"
 edition = "2021"
 description = "SIP Stack Rust library for building SIP applications"
 license = "MIT"
@@ -25,13 +25,6 @@ log = "0.4.28"
 rsip = { version = "0.4.0" }
 thiserror = "2.0.16"
 tracing = "0.1.41"
-wasm-bindgen = "0.2.101"
-# The `console_error_panic_hook` crate provides better debugging of panics by
-# logging them with `console.error`. This is great for development, but requires
-# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
-# code size when deploying.
-console_error_panic_hook = { version = "0.1.7", optional = true }
-wasm-bindgen-futures = "0.4.51"
 tokio-util = { version = "0.7.16", features = ["full"] }
 tracing-subscriber = { version = "0.3.20", features = ["local-time"] }
 rand = { version = "0.9.2" }
@@ -48,7 +41,7 @@ clap = { version = "4.5.47", features = ["derive"] }
 http = "1.3.1"
 
 [features]
-default = ["console_error_panic_hook", "rustls", "websocket"]
+default = ["rustls", "websocket"]
 rustls = ["tokio-rustls", "rustls-pemfile", "webpki-roots"]
 websocket = ["tokio-tungstenite"]
 all-transports = ["rustls", "websocket"]
@@ -68,8 +61,8 @@ rtp-rs = "0.6.0"
 stun-rs = "0.1.11"
 openai-api-rs = "6.0.11"
 base64 = "0.22.1"
-serde = "1.0.219"
-serde_json = "1.0.143"
+serde = "1.0.226"
+serde_json = "1.0.145"
 dasp = { version = "0.11", features = ["all"] }
 axum = { version = "0.8.4", features = ["ws"] }
 tower = "0.5.2"

src/dialog/dialog.rs

@@ -325,8 +325,27 @@ impl DialogInner {
         headers.push(Header::CallId(
             self.id.lock().unwrap().call_id.clone().into(),
         ));
-        headers.push(self.from.clone().into());
-        headers.push(self.to.lock().unwrap().clone().into());
+
+        let to = self
+            .to
+            .lock()
+            .unwrap()
+            .clone()
+            .untyped()
+            .value()
+            .to_string();
+
+        let from = self.from.clone().untyped().value().to_string();
+        match self.role {
+            TransactionRole::Client => {
+                headers.push(Header::From(from.into()));
+                headers.push(Header::To(to.into()));
+            }
+            TransactionRole::Server => {
+                headers.push(Header::From(to.into()));
+                headers.push(Header::To(from.into()));
+            }
+        }
         headers.push(Header::CSeq(cseq_header.into()));
         headers.push(Header::UserAgent(
             self.endpoint_inner.user_agent.clone().into(),

src/transaction/endpoint.rs

@@ -32,7 +32,7 @@ pub struct EndpointOption {
     pub t1: Duration,
     pub t4: Duration,
     pub t1x64: Duration,
-    pub timerb: Duration,
+    pub timerc: Duration,
     pub ignore_out_of_dialog_option: bool,
     pub callid_suffix: Option<String>,
     pub dialog_keepalive_duration: Option<Duration>,
@@ -44,7 +44,7 @@ impl Default for EndpointOption {
             t1: Duration::from_millis(500),
             t4: Duration::from_secs(4),
             t1x64: Duration::from_millis(64 * 500),
-            timerb: Duration::from_secs(64),
+            timerc: Duration::from_secs(180),
             ignore_out_of_dialog_option: true,
             callid_suffix: None,
             dialog_keepalive_duration: Some(Duration::from_secs(60)),

src/transaction/mod.rs

@@ -249,6 +249,7 @@ impl std::fmt::Display for TransactionType {
 pub enum TransactionTimer {
     TimerA(TransactionKey, Duration),
     TimerB(TransactionKey),
+    TimerC(TransactionKey),
     TimerD(TransactionKey),
     TimerK(TransactionKey),
     TimerG(TransactionKey, Duration),
@@ -260,6 +261,7 @@ impl TransactionTimer {
         match self {
             TransactionTimer::TimerA(key, _) => key,
             TransactionTimer::TimerB(key) => key,
+            TransactionTimer::TimerC(key) => key,
             TransactionTimer::TimerD(key) => key,
             TransactionTimer::TimerG(key, _) => key,
             TransactionTimer::TimerK(key) => key,
@@ -275,6 +277,7 @@ impl std::fmt::Display for TransactionTimer {
                 write!(f, "TimerA: {} {}", key, duration.as_millis())
             }
             TransactionTimer::TimerB(key) => write!(f, "TimerB: {}", key),
+            TransactionTimer::TimerC(key) => write!(f, "TimerC: {}", key),
             TransactionTimer::TimerD(key) => write!(f, "TimerD: {}", key),
             TransactionTimer::TimerG(key, duration) => {
                 write!(f, "TimerG: {} {}", key, duration.as_millis())

src/transaction/transaction.rs

@@ -8,7 +8,7 @@ use crate::{Error, Result};
 use rsip::headers::ContentLength;
 use rsip::message::HasHeaders;
 use rsip::prelude::HeadersExt;
-use rsip::{Header, Method, Request, Response, SipMessage, StatusCode};
+use rsip::{Header, Method, Request, Response, SipMessage, StatusCode, StatusCodeKind};
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
 use tracing::{debug, info, trace};
 
@@ -161,6 +161,7 @@ pub struct Transaction {
     pub tu_sender: TransactionEventSender,
     pub timer_a: Option<u64>,
     pub timer_b: Option<u64>,
+    pub timer_c: Option<u64>,
     pub timer_d: Option<u64>,
     pub timer_k: Option<u64>, // server invite only
     pub timer_g: Option<u64>, // server invite only
@@ -197,6 +198,7 @@ impl Transaction {
             last_ack: None,
             timer_a: None,
             timer_b: None,
+            timer_c: None,
             timer_d: None,
             timer_k: None,
             timer_g: None,
@@ -414,7 +416,7 @@ impl Transaction {
         }
     }
 
-    async fn send_ack(&mut self, connection: Option<SipConnection>) -> Result<()> {
+    pub async fn send_ack(&mut self, connection: Option<SipConnection>) -> Result<()> {
         if self.transaction_type != TransactionType::ClientInvite {
             return Err(Error::TransactionError(
                 "send_ack is only valid for client invite transactions".to_string(),
@@ -595,7 +597,7 @@ impl Transaction {
             _ => {}
         }
         let new_state = match resp.status_code.kind() {
-            rsip::StatusCodeKind::Provisional => {
+            StatusCodeKind::Provisional => {
                 if resp.status_code == rsip::StatusCode::Trying {
                     TransactionState::Trying
                 } else {
@@ -651,25 +653,26 @@ impl Transaction {
                             .timeout(duration, TransactionTimer::TimerA(key, duration));
                         self.timer_a.replace(timer_a);
                     } else if let TransactionTimer::TimerB(_) = timer {
-                        // Inform TU about timeout
                         let timeout_response = self.endpoint_inner.make_response(
                             &self.original,
                             rsip::StatusCode::RequestTimeout,
                             None,
                         );
                         self.inform_tu_response(timeout_response)?;
+                        self.transition(TransactionState::Terminated)?;
                     }
                 }
             }
             TransactionState::Proceeding => {
-                if let TransactionTimer::TimerB(_) = timer {
+                if let TransactionTimer::TimerC(_) = timer {
                     // Inform TU about timeout
                     let timeout_response = self.endpoint_inner.make_response(
                         &self.original,
                         rsip::StatusCode::RequestTimeout,
                         None,
                     );
                     self.inform_tu_response(timeout_response)?;
+                    self.transition(TransactionState::Terminated)?;
                 }
             }
             TransactionState::Completed => {
@@ -738,7 +741,7 @@ impl Transaction {
                         self.timer_a.replace(timer_a);
                     }
                     self.timer_b.replace(self.endpoint_inner.timers.timeout(
-                        self.endpoint_inner.option.timerb,
+                        self.endpoint_inner.option.t1x64,
                         TransactionTimer::TimerB(self.key.clone()),
                     ));
                 }
@@ -747,17 +750,18 @@ impl Transaction {
                 self.timer_a
                     .take()
                     .map(|id| self.endpoint_inner.timers.cancel(id));
-
-                if matches!(
-                    self.transaction_type,
-                    TransactionType::ClientInvite | TransactionType::ClientNonInvite
-                ) && self.timer_b.is_none()
-                {
-                    let timer_b = self.endpoint_inner.timers.timeout(
-                        self.endpoint_inner.option.timerb,
-                        TransactionTimer::TimerB(self.key.clone()),
-                    );
-                    self.timer_b.replace(timer_b);
+                if matches!(self.transaction_type, TransactionType::ClientInvite) {
+                    self.timer_b
+                        .take()
+                        .map(|id| self.endpoint_inner.timers.cancel(id));
+                    if self.timer_c.is_none() {
+                        // start Timer C for client invite only
+                        let timer_c = self.endpoint_inner.timers.timeout(
+                            self.endpoint_inner.option.timerc,
+                            TransactionTimer::TimerC(self.key.clone()),
+                        );
+                        self.timer_c.replace(timer_c);
+                    }
                 }
             }
             TransactionState::Completed => {
@@ -767,6 +771,9 @@ impl Transaction {
                 self.timer_b
                     .take()
                     .map(|id| self.endpoint_inner.timers.cancel(id));
+                self.timer_c
+                    .take()
+                    .map(|id| self.endpoint_inner.timers.cancel(id));
 
                 if self.transaction_type == TransactionType::ServerInvite {
                     // start Timer G for server invite only
@@ -839,6 +846,9 @@ impl Transaction {
         self.timer_b
             .take()
             .map(|id| self.endpoint_inner.timers.cancel(id));
+        self.timer_c
+            .take()
+            .map(|id| self.endpoint_inner.timers.cancel(id));
         self.timer_d
             .take()
             .map(|id| self.endpoint_inner.timers.cancel(id));