From bcba52b2766e9bb31503aae37f0f2dc0ef058afa Mon Sep 17 00:00:00 2001 From: Fedor Kiselev <116813641+FedorKiselev76@users.noreply.github.com> Date: Thu, 5 Nov 2026 14:13:06 +0000 Subject: [PATCH 01/12] feat(dialog): capture coherent snapshots with recovery metadata --- src/dialog/client_dialog.rs | 17 ++- src/dialog/dialog.rs | 165 ++++++++++++++++++++-- src/dialog/dialog_layer.rs | 1 + src/dialog/invite_dialog.rs | 29 ++-- src/dialog/lifecycle.rs | 65 +++++++-- src/dialog/mod.rs | 1 + src/dialog/server_dialog.rs | 17 ++- src/dialog/snapshot.rs | 49 +++++++ src/dialog/tests/test_bye_during_ack.rs | 28 ++++ src/dialog/tests/test_snapshot_restore.rs | 102 +++++++++++++ src/transaction/invite_usage.rs | 10 +- 11 files changed, 433 insertions(+), 51 deletions(-) create mode 100644 src/dialog/snapshot.rs diff --git a/src/dialog/client_dialog.rs b/src/dialog/client_dialog.rs index 5e6a1598..ebc4b058 100644 --- a/src/dialog/client_dialog.rs +++ b/src/dialog/client_dialog.rs @@ -579,10 +579,7 @@ impl ClientInviteDialog { return Ok(()); } - self.inner - .remote_seq - .compare_exchange(remote_seq, cseq, Ordering::Relaxed, Ordering::Relaxed) - .ok(); + self.inner.admit_remote_seq(cseq, &tx.original.method).ok(); if self.inner.is_confirmed() { match tx.original.method { @@ -615,13 +612,12 @@ impl ClientInviteDialog { } async fn handle_bye(&mut self, tx: &mut Transaction) -> Result<()> { - self.inner.record_remote_bye( + debug!(id = %self.id(), uri = %tx.original.uri, "received bye"); + self.inner.terminate_remote_bye( + TerminatedReason::UasBye, tx.original_received_at .unwrap_or_else(super::lifecycle::LifecycleTime::now), ); - debug!(id = %self.id(), uri = %tx.original.uri, "received bye"); - self.inner - .transition(DialogState::Terminated(self.id(), TerminatedReason::UasBye)); tx.reply(crate::sip::StatusCode::OK).await?; Ok(()) } @@ -665,7 +661,10 @@ impl ClientInviteDialog { } async fn handle_reinvite(&mut self, tx: &mut Transaction) -> Result<()> { - self.inner.process_reinvite(tx, false).await + self.inner.begin_negotiation(); + let result = self.inner.process_reinvite(tx, false).await; + self.inner.finish_negotiation(); + result } async fn handle_refer(&mut self, tx: &mut Transaction) -> Result<()> { diff --git a/src/dialog/dialog.rs b/src/dialog/dialog.rs index fdd19832..faddf34e 100644 --- a/src/dialog/dialog.rs +++ b/src/dialog/dialog.rs @@ -453,6 +453,8 @@ pub struct SessionIdState { } #[derive(Clone, Debug)] pub struct DialogSnapshot { + /// Captured with routing, CSeq, lifecycle facts, and transaction admission. + pub runtime: super::snapshot::DialogSnapshotRuntime, pub state: DialogSnapshotState, pub role: TransactionRole, pub id: DialogId, @@ -473,6 +475,13 @@ pub struct DialogSnapshot { /// RFC 7989 Session-ID state, preserved across snapshot restore. pub session_id: Option, } +impl DialogSnapshot { + /// Only confirmed snapshots with no unfinished signaling can be resumed. + pub fn is_quiescent(&self) -> bool { + self.state == DialogSnapshotState::Confirmed && self.runtime.pending.is_empty() + } +} + impl DialogInner { #[allow(clippy::too_many_arguments)] pub fn new( @@ -600,10 +609,12 @@ impl DialogInner { { return; } + let _snapshot_gate = self.state.lock(); let mut state = self.session_id.lock(); if let Some(sid) = state.as_mut() { if sid.local != uuid { sid.remote = Some(uuid); + self.lifecycle.lock().revision += 1; } } } @@ -638,13 +649,45 @@ impl DialogInner { self.local_seq.load(Ordering::Relaxed) } pub fn increment_local_seq(&self) -> u32 { - // Return this caller's reservation, not a subsequent caller's value. + let _snapshot_gate = self.state.lock(); + self.increment_local_seq_locked() + } + + fn increment_local_seq_locked(&self) -> u32 { + self.lifecycle.lock().revision += 1; self.local_seq .fetch_add(1, Ordering::Relaxed) .wrapping_add(1) } + pub(crate) fn admit_remote_seq( + &self, + cseq: u32, + method: &Method, + ) -> core::result::Result { + let _snapshot_gate = self.state.lock(); + let previous = self.remote_seq.load(Ordering::Relaxed); + if cseq < previous { + return Err(previous); + } + if *method == Method::Bye && (_snapshot_gate.is_confirmed() || _snapshot_gate.waiting_ack()) + { + let mut lifecycle = self.lifecycle.lock(); + if !lifecycle.pending_remote_bye { + lifecycle.pending_remote_bye = true; + lifecycle.revision += 1; + } + } + if cseq != previous { + self.remote_seq.store(cseq, Ordering::Relaxed); + self.lifecycle.lock().revision += 1; + } + Ok(previous) + } + pub fn update_remote_tag(&self, tag: &str) -> Result<()> { + let _snapshot_gate = self.state.lock(); + self.lifecycle.lock().revision += 1; self.id.lock().remote_tag = tag.to_string(); if self.role == TransactionRole::Client { @@ -837,9 +880,19 @@ impl DialogInner { &self, uri: crate::sip::Uri, contact: Option, + ) { + let _snapshot_gate = self.state.lock(); + self.set_remote_target_locked(uri, contact); + } + + fn set_remote_target_locked( + &self, + uri: crate::sip::Uri, + contact: Option, ) { *self.remote_uri.lock() = uri; *self.remote_contact.lock() = contact; + self.lifecycle.lock().revision += 1; } pub(super) fn is_target_refresh(method: &Method) -> bool { @@ -885,11 +938,12 @@ impl DialogInner { } pub(super) fn accept_target_refresh(&self, cseq: u32, target: &RemoteTarget) { + let _snapshot_gate = self.state.lock(); let mut last = self.remote_target_cseq.lock(); if last.is_some_and(|accepted| cseq <= accepted) { return; } - self.set_remote_target(target.uri.clone(), Some(target.contact.clone())); + self.set_remote_target_locked(target.uri.clone(), Some(target.contact.clone())); *last = Some(cseq); } @@ -924,7 +978,9 @@ impl DialogInner { .collect(); new_route_set.reverse(); + let _snapshot_gate = self.state.lock(); *self.route_set.lock() = new_route_set; + self.lifecycle.lock().revision += 1; } pub(super) fn make_request_with_vias( @@ -935,12 +991,13 @@ impl DialogInner { headers: Option>, body: Option>, ) -> Result { + let _snapshot_gate = self.state.lock(); let mut out: Vec
= Vec::new(); // --- system headers first --- let cseq_header = CSeq { - seq: cseq.unwrap_or_else(|| self.increment_local_seq()), + seq: cseq.unwrap_or_else(|| self.increment_local_seq_locked()), method: method.clone(), }; @@ -1267,6 +1324,22 @@ impl DialogInner { &self, request: Request, options: Option, + ) -> Result> { + let negotiation = Self::is_target_refresh(&request.method); + if negotiation { + self.begin_negotiation(); + } + let result = self.send_dialog_request_inner(request, options).await; + if negotiation { + self.finish_negotiation(); + } + result + } + + async fn send_dialog_request_inner( + &self, + request: Request, + options: Option, ) -> Result> { let method = request.method().to_owned(); let key = TransactionKey::from_request(&request, TransactionRole::Client)?; @@ -1747,10 +1820,15 @@ impl DialogInner { } } + /// Capture a single revision. Mutate dialogs through their methods; direct + /// writes to DialogInner public fields bypass these synchronization guarantees. pub fn snapshot(&self) -> DialogSnapshot { + let state_guard = self.state.lock(); + let usage = self.invite_usage.lock(); + let lifecycle = self.lifecycle.lock(); let id = self.id.lock().clone(); - let state = match &*self.state.lock() { + let state = match &*state_guard { DialogState::Calling(_) => DialogSnapshotState::Calling, DialogState::Trying(_) => DialogSnapshotState::Trying, DialogState::Early(_, _) => DialogSnapshotState::Early, @@ -1768,6 +1846,20 @@ impl DialogInner { }; DialogSnapshot { + runtime: super::snapshot::DialogSnapshotRuntime { + revision: lifecycle.revision + usage.revision, + lifecycle: lifecycle.facts.clone(), + pending: super::snapshot::DialogPendingState { + local_invite: usage.client_pending, + remote_invite: usage.server_pending, + remote_invite_awaiting_ack: usage.server_waiting_ack != 0, + initial_ack: lifecycle.pending_initial_ack, + negotiations: lifecycle.negotiations, + remote_termination: lifecycle.pending_remote_bye + && !state_guard.is_terminated(), + local_termination: lifecycle.emitted & 2 != 0 && !state_guard.is_terminated(), + }, + }, state, role: self.role, @@ -1804,6 +1896,10 @@ impl DialogInner { return Ok(None); } + if !snapshot.runtime.pending.is_empty() { + return Err(crate::Error::Error("dialog snapshot contains unfinished signaling; application recovery policy is required".into())); + } + // Ensure To has tag let mut to = snapshot.to.clone(); let to_tag = match snapshot.role { @@ -1830,6 +1926,7 @@ impl DialogInner { } let role = snapshot.role; + let lifecycle = super::lifecycle::LifecycleState::restored(&snapshot.runtime)?; let initial_request = Mutex::new(Self::build_restored_initial_request( role, @@ -1870,7 +1967,7 @@ impl DialogInner { endpoint_inner, state_sender, - lifecycle: Mutex::new(super::lifecycle::LifecycleState::default()), + lifecycle: Mutex::new(lifecycle), tu_sender, initial_request, @@ -1958,6 +2055,29 @@ impl DialogInner { version: Version::V2, } } + pub(crate) fn complete_initial_ack(&self) { + let _snapshot_gate = self.state.lock(); + let mut lifecycle = self.lifecycle.lock(); + if lifecycle.pending_initial_ack { + lifecycle.pending_initial_ack = false; + lifecycle.revision += 1; + } + } + + pub(crate) fn begin_negotiation(&self) { + let _snapshot_gate = self.state.lock(); + let mut lifecycle = self.lifecycle.lock(); + lifecycle.negotiations += 1; + lifecycle.revision += 1; + } + + pub(crate) fn finish_negotiation(&self) { + let _snapshot_gate = self.state.lock(); + let mut lifecycle = self.lifecycle.lock(); + lifecycle.negotiations -= 1; + lifecycle.revision += 1; + } + pub(crate) fn record_initial_acceptance( &self, response: &Response, @@ -1986,15 +2106,21 @@ impl DialogInner { ); } - pub(crate) fn record_remote_bye(&self, time: super::lifecycle::LifecycleTime) { - let state = self.state.lock(); + pub(crate) fn terminate_remote_bye( + &self, + reason: TerminatedReason, + time: super::lifecycle::LifecycleTime, + ) { + let id = self.id.lock().clone(); + let mut state = self.state.lock(); if !state.is_terminated() { self.lifecycle.lock().emit( - self.id.lock().clone(), + id.clone(), self.role, time, super::lifecycle::DialogLifecycleKind::RemoteByeReceived, ); + self.transition_locked(&mut state, DialogState::Terminated(id, reason)); } } @@ -2042,6 +2168,11 @@ impl DialogInner { // Publish the full dialog key before notifying the application. A // concurrent handler cannot inspect the state until this lock releases. register(); + { + let mut lifecycle = self.lifecycle.lock(); + lifecycle.pending_initial_ack = true; + lifecycle.revision += 1; + } if let DialogState::Confirmed(id, response) = &confirmed { self.lifecycle.lock().emit( id.clone(), @@ -2092,6 +2223,7 @@ impl DialogInner { }, ); } + self.lifecycle.lock().revision += 1; *old_state = state.clone(); // Try to send state update, but don't fail if channel is closed self.state_sender.send(state).ok(); @@ -2099,6 +2231,23 @@ impl DialogInner { #[cfg_attr(not(feature = "platform-tokio"), allow(unused_mut))] pub async fn process_transaction_handle( + &self, + tx: &mut Transaction, + rx: TransactionCommandReceiver, + ) -> Result<()> { + let negotiation = tx.original.method == Method::Update; + if negotiation { + self.begin_negotiation(); + } + let result = self.process_transaction_handle_inner(tx, rx).await; + if negotiation { + self.finish_negotiation(); + } + result + } + + #[cfg_attr(not(feature = "platform-tokio"), allow(unused_mut))] + async fn process_transaction_handle_inner( &self, tx: &mut Transaction, mut rx: TransactionCommandReceiver, diff --git a/src/dialog/dialog_layer.rs b/src/dialog/dialog_layer.rs index d7a9649b..6b039bad 100644 --- a/src/dialog/dialog_layer.rs +++ b/src/dialog/dialog_layer.rs @@ -557,6 +557,7 @@ impl DialogLayer { }; inner.credential = credential; + inner.lifecycle.lock().sender = self.inner.lifecycle_sender.lock().clone(); let inner = Arc::new(inner); let dialog = Dialog::from_inner(inner.role, inner.clone()); diff --git a/src/dialog/invite_dialog.rs b/src/dialog/invite_dialog.rs index 4ff5113e..4544f538 100644 --- a/src/dialog/invite_dialog.rs +++ b/src/dialog/invite_dialog.rs @@ -398,6 +398,9 @@ impl InviteDialog { }) .await; ack.finish(); + if msg.is_some() { + self.inner.complete_initial_ack(); + } let cancelled = established?; let Some(msg) = msg else { break }; if matches!(&msg, SipMessage::Response(r) if r.status_code.kind() != StatusCodeKind::Provisional) @@ -530,14 +533,14 @@ impl InviteDialog { fn update_remote_target_from_2xx(&self, resp: &Response) -> Result<()> { self.inner.update_route_set_from_response(resp); let contact = resp.contact_header()?; - self.inner.remote_contact.lock().replace(contact.clone()); let contact_uri = resp .typed_contact_headers()? .first() .map(|c| c.uri.clone()) .ok_or_else(|| crate::Error::Error("missing Contact header".to_string()))?; - *self.inner.remote_uri.lock() = contact_uri; + self.inner + .set_remote_target(contact_uri, Some(contact.clone())); Ok(()) } @@ -867,11 +870,7 @@ impl InviteDialog { let sequence = if matches!(tx.original.method, Method::Ack | Method::Cancel) { Ok(self.inner.remote_seq.load(Ordering::Relaxed)) } else { - self.inner - .remote_seq - .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |remote_seq| { - (cseq >= remote_seq).then_some(cseq) - }) + self.inner.admit_remote_seq(cseq, &tx.original.method) }; if let Err(remote_seq) = sequence { match self.role() { @@ -1017,17 +1016,16 @@ impl InviteDialog { } async fn handle_bye(&mut self, tx: &mut Transaction) -> Result<()> { - self.inner.record_remote_bye( - tx.original_received_at - .unwrap_or_else(super::lifecycle::LifecycleTime::now), - ); debug!(id = %self.id(), uri = %tx.original.uri, "received bye"); let reason = match self.role() { TransactionRole::Server => TerminatedReason::UacBye, TransactionRole::Client => TerminatedReason::UasBye, }; - self.inner - .transition(DialogState::Terminated(self.id(), reason)); + self.inner.terminate_remote_bye( + reason, + tx.original_received_at + .unwrap_or_else(super::lifecycle::LifecycleTime::now), + ); tx.reply(StatusCode::OK).await?; Ok(()) } @@ -1135,7 +1133,10 @@ impl InviteDialog { } async fn handle_reinvite(&mut self, tx: &mut Transaction) -> Result<()> { - self.inner.process_reinvite(tx, true).await + self.inner.begin_negotiation(); + let result = self.inner.process_reinvite(tx, true).await; + self.inner.finish_negotiation(); + result } async fn handle_invite(&mut self, tx: &mut Transaction) -> Result<()> { diff --git a/src/dialog/lifecycle.rs b/src/dialog/lifecycle.rs index c0e10c29..6e110ac8 100644 --- a/src/dialog/lifecycle.rs +++ b/src/dialog/lifecycle.rs @@ -32,8 +32,9 @@ //! application. An accepted CANCEL followed by a late 2xx is cleanup, not a new //! accepted call. Fork branches discarded by the dialog are not reported. //! -//! Subscriptions apply to newly created dialogs, not previously created or -//! restored ones. The existing `DialogState` channel is unchanged. An unbounded +//! Subscriptions apply to subsequently created or restored dialogs. Restoring +//! a snapshot retains fact sequence numbers without replaying notifications. +//! The existing `DialogState` channel is unchanged. An unbounded //! receiver avoids SIP backpressure; applications must drain or drop it. use super::{dialog::TerminatedReason, DialogId}; @@ -108,9 +109,50 @@ pub(crate) struct LifecycleState { pub sender: Option, pub sequence: u64, pub emitted: u8, + pub revision: u64, + pub pending_initial_ack: bool, + pub pending_remote_bye: bool, + pub negotiations: u32, + pub facts: alloc::vec::Vec, } impl LifecycleState { + pub fn restored(runtime: &super::snapshot::DialogSnapshotRuntime) -> crate::Result { + let mut state = Self { + revision: runtime.revision, + ..Self::default() + }; + for fact in &runtime.lifecycle { + let bit = match &fact.kind { + DialogLifecycleKind::InviteAccepted { status } + if status.kind() == crate::sip::StatusCodeKind::Successful => + { + 1 + } + DialogLifecycleKind::LocalTerminationRequested => 2, + DialogLifecycleKind::RemoteByeReceived => 4, + // A confirmed snapshot cannot already contain a terminal fact. + _ => { + return Err(crate::Error::Error( + "invalid snapshot lifecycle fact".into(), + )) + } + }; + if state.emitted & bit != 0 || fact.sequence != state.sequence + 1 { + return Err(crate::Error::Error( + "invalid snapshot lifecycle sequence".into(), + )); + } + state.emitted |= bit; + state.sequence = fact.sequence; + } + if runtime.revision < state.sequence || runtime.revision == u64::MAX { + return Err(crate::Error::Error("invalid snapshot revision".into())); + } + state.facts = runtime.lifecycle.clone(); + Ok(state) + } + pub fn emit( &mut self, id: DialogId, @@ -118,7 +160,6 @@ impl LifecycleState { time: LifecycleTime, kind: DialogLifecycleKind, ) { - let Some(sender) = &self.sender else { return }; let bit = match &kind { DialogLifecycleKind::InviteAccepted { .. } => 1, DialogLifecycleKind::LocalTerminationRequested => 2, @@ -130,12 +171,20 @@ impl LifecycleState { } self.emitted |= bit; self.sequence += 1; - let _ = sender.send(DialogLifecycleEvent { - dialog_id: id, - role, + self.revision += 1; + self.facts.push(super::snapshot::DialogLifecycleRecord { sequence: self.sequence, - occurred_at: time, - kind, + since_unix_epoch: time.since_unix_epoch, + kind: kind.clone(), }); + if let Some(sender) = &self.sender { + let _ = sender.send(DialogLifecycleEvent { + dialog_id: id, + role, + sequence: self.sequence, + occurred_at: time, + kind, + }); + } } } diff --git a/src/dialog/mod.rs b/src/dialog/mod.rs index 0b3f1372..fe4dffd5 100644 --- a/src/dialog/mod.rs +++ b/src/dialog/mod.rs @@ -16,6 +16,7 @@ pub mod publication; pub mod registration; pub mod reinvite; pub mod server_dialog; +pub mod snapshot; pub mod subscription; #[cfg(test)] diff --git a/src/dialog/server_dialog.rs b/src/dialog/server_dialog.rs index caa4ba46..821ecd32 100644 --- a/src/dialog/server_dialog.rs +++ b/src/dialog/server_dialog.rs @@ -673,10 +673,7 @@ impl ServerInviteDialog { // discard old request return Ok(()); } - self.inner - .remote_seq - .compare_exchange(remote_seq, cseq, Ordering::Relaxed, Ordering::Relaxed) - .ok(); + self.inner.admit_remote_seq(cseq, &tx.original.method).ok(); if self.inner.is_confirmed() { match tx.original.method { @@ -745,13 +742,12 @@ impl ServerInviteDialog { } async fn handle_bye(&mut self, tx: &mut Transaction) -> Result<()> { - self.inner.record_remote_bye( + debug!(id = %self.id(), uri = %tx.original.uri, "received bye"); + self.inner.terminate_remote_bye( + TerminatedReason::UacBye, tx.original_received_at .unwrap_or_else(super::lifecycle::LifecycleTime::now), ); - debug!(id = %self.id(), uri = %tx.original.uri, "received bye"); - self.inner - .transition(DialogState::Terminated(self.id(), TerminatedReason::UacBye)); tx.reply(crate::sip::StatusCode::OK).await?; Ok(()) } @@ -854,7 +850,10 @@ impl ServerInviteDialog { } async fn handle_reinvite(&mut self, tx: &mut Transaction) -> Result<()> { - self.inner.process_reinvite(tx, true).await + self.inner.begin_negotiation(); + let result = self.inner.process_reinvite(tx, true).await; + self.inner.finish_negotiation(); + result } async fn handle_invite(&mut self, tx: &mut Transaction) -> Result<()> { diff --git a/src/dialog/snapshot.rs b/src/dialog/snapshot.rs new file mode 100644 index 00000000..deae0464 --- /dev/null +++ b/src/dialog/snapshot.rs @@ -0,0 +1,49 @@ +//! Recovery metadata captured together with the dialog's routing state. +use super::lifecycle::DialogLifecycleKind; +use alloc::vec::Vec; +use core::time::Duration; + +/// A persisted fact deliberately excludes process-local monotonic time. +#[derive(Clone, Debug)] +#[non_exhaustive] +pub struct DialogLifecycleRecord { + pub sequence: u64, + pub since_unix_epoch: Option, + pub kind: DialogLifecycleKind, +} + +/// In-flight work is recorded for recovery decisions, not replayed as SIP +/// transactions. Interrupted application handlers remain pending conservatively. +#[derive(Clone, Debug, Default, PartialEq, Eq)] +#[non_exhaustive] +pub struct DialogPendingState { + pub local_invite: bool, + pub remote_invite: bool, + pub remote_invite_awaiting_ack: bool, + pub initial_ack: bool, + pub negotiations: u32, + pub local_termination: bool, + pub remote_termination: bool, +} + +impl DialogPendingState { + pub fn is_empty(&self) -> bool { + !self.local_invite + && !self.remote_invite + && !self.remote_invite_awaiting_ack + && !self.initial_ack + && self.negotiations == 0 + && !self.local_termination + && !self.remote_termination + } +} + +/// Versioned metadata for a single coherent dialog snapshot. This is not a +/// storage schema: applications own serialization and migrations of old records. +#[derive(Clone, Debug, Default)] +#[non_exhaustive] +pub struct DialogSnapshotRuntime { + pub revision: u64, + pub pending: DialogPendingState, + pub lifecycle: Vec, +} diff --git a/src/dialog/tests/test_bye_during_ack.rs b/src/dialog/tests/test_bye_during_ack.rs index 90c35eeb..a2afd4f0 100644 --- a/src/dialog/tests/test_bye_during_ack.rs +++ b/src/dialog/tests/test_bye_during_ack.rs @@ -507,3 +507,31 @@ async fn lifecycle_closed_receiver_does_not_prevent_remote_bye() -> crate::Resul assert!(call.dialog.state().is_terminated()); Ok(()) } + +#[tokio::test] +async fn snapshot_records_initial_ack_until_it_completes() -> crate::Result<()> { + let mut call = start_observed(true, false, true).await?; + let accepted = call.facts.try_recv().unwrap(); + let before = call.dialog.snapshot(); + assert!(before.runtime.pending.initial_ack); + assert!(!before.is_quiescent()); + assert_eq!( + before.runtime.lifecycle[0].since_unix_epoch, + accepted.occurred_at.since_unix_epoch + ); + let restore = DialogLayer::new(EndpointBuilder::new().build().inner); + let (sender, _) = unbounded_channel(); + assert!(restore + .restore_from_snapshot(before.clone(), sender) + .is_err()); + call.release.cancel(); + request(&call.peer, Method::Ack).await; + tokio::time::timeout(Duration::from_secs(2), &mut call.join) + .await + .unwrap() + .unwrap()?; + let after = call.dialog.snapshot(); + assert!(after.is_quiescent()); + assert!(after.runtime.revision > before.runtime.revision); + Ok(()) +} diff --git a/src/dialog/tests/test_snapshot_restore.rs b/src/dialog/tests/test_snapshot_restore.rs index d46c9bd6..04fec3d7 100644 --- a/src/dialog/tests/test_snapshot_restore.rs +++ b/src/dialog/tests/test_snapshot_restore.rs @@ -120,3 +120,105 @@ async fn snapshot_restore_still_skips_non_confirmed_states() -> crate::Result<() assert!(layer.is_empty()); Ok(()) } + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn snapshots_never_mix_target_uri_and_contact() -> crate::Result<()> { + let layer = DialogLayer::new(EndpointBuilder::new().build().inner); + let original = snapshot(TransactionRole::Client); + let (states, _) = unbounded_channel(); + layer.restore_from_snapshot(original.clone(), states)?; + let Some(Dialog::Invite(dialog)) = layer.get_dialog(&original.id) else { + unreachable!() + }; + let uri = Uri::try_from("sip:target0@example.com")?; + dialog.inner.set_remote_target( + uri.clone(), + Some(crate::sip::headers::untyped::Contact::from( + crate::sip::typed::Contact::from(uri), + )), + ); + let writer = dialog.clone(); + let task = std::thread::spawn(move || { + for n in 1..5000 { + let uri = Uri::try_from(format!("sip:target{n}@example.com").as_str()).unwrap(); + writer.inner.set_remote_target( + uri.clone(), + Some(crate::sip::headers::untyped::Contact::from( + crate::sip::typed::Contact::from(uri), + )), + ); + writer.inner.update_remote_tag(&format!("tag{n}")).unwrap(); + writer.inner.increment_local_seq(); + } + }); + let mut revision = 0; + for _ in 0..5000 { + let current = dialog.snapshot(); + use crate::sip::prelude::ToTypedHeader; + assert_eq!( + current.remote_uri, + current.remote_contact.as_ref().unwrap().typed()?.uri + ); + assert_eq!(current.id.remote_tag, current.to.tag().unwrap().value()); + assert!(current.runtime.revision >= revision); + revision = current.runtime.revision; + } + task.join().unwrap(); + Ok(()) +} + +#[tokio::test] +async fn snapshot_restore_retains_facts_without_replaying_them() -> crate::Result<()> { + use crate::dialog::dialog::{DialogState, TerminatedReason}; + use crate::dialog::lifecycle::{ + dialog_lifecycle_channel, DialogLifecycleKind as K, LifecycleTime, + }; + let layer = DialogLayer::new(EndpointBuilder::new().build().inner); + let original = snapshot(TransactionRole::Client); + let (states, _) = unbounded_channel(); + layer.restore_from_snapshot(original.clone(), states.clone())?; + let Some(Dialog::Invite(dialog)) = layer.get_dialog(&original.id) else { + unreachable!() + }; + dialog + .inner + .record_initial_acceptance(&crate::sip::Response::default(), LifecycleTime::now()); + let saved = dialog.snapshot(); + // Response::default() is 200 OK; this is an already established dialog. + assert_eq!(saved.runtime.lifecycle.len(), 1); + assert!(saved.is_quiescent()); + let restored = DialogLayer::new(EndpointBuilder::new().build().inner); + let (sender, mut events) = dialog_lifecycle_channel(); + restored.set_lifecycle_events(Some(sender)); + assert!(restored.restore_from_snapshot(saved, states)?); + assert!(events.try_recv().is_err()); + let Some(Dialog::Invite(dialog)) = restored.get_dialog(&original.id) else { + unreachable!() + }; + dialog.inner.transition(DialogState::Terminated( + dialog.id(), + TerminatedReason::Timeout, + )); + let event = events.try_recv().unwrap(); + assert_eq!(event.sequence, 2); + assert!(matches!(event.kind, K::DialogTerminated { .. })); + assert_eq!(dialog.snapshot().runtime.lifecycle.len(), 2); + Ok(()) +} + +#[tokio::test] +async fn unfinished_or_corrupt_snapshot_is_not_silently_resumed() -> crate::Result<()> { + let layer = DialogLayer::new(EndpointBuilder::new().build().inner); + let (states, _) = unbounded_channel(); + let mut pending = snapshot(TransactionRole::Client); + pending.runtime.pending.negotiations = 1; + assert!(!pending.is_quiescent()); + assert!(layer + .restore_from_snapshot(pending, states.clone()) + .is_err()); + let mut invalid = snapshot(TransactionRole::Client); + invalid.runtime.revision = u64::MAX; + assert!(layer.restore_from_snapshot(invalid, states).is_err()); + assert!(layer.is_empty()); + Ok(()) +} diff --git a/src/transaction/invite_usage.rs b/src/transaction/invite_usage.rs index 5d743ef7..0aba0b93 100644 --- a/src/transaction/invite_usage.rs +++ b/src/transaction/invite_usage.rs @@ -6,9 +6,10 @@ use crate::prelude::*; #[derive(Default)] pub(crate) struct InviteUsage { - client_pending: bool, - server_pending: bool, - server_waiting_ack: usize, + pub(crate) revision: u64, + pub(crate) client_pending: bool, + pub(crate) server_pending: bool, + pub(crate) server_waiting_ack: usize, } enum Phase { @@ -36,6 +37,7 @@ impl InviteReservation { { return Err(TransactionRole::Server); } + state.revision += 1; let phase = match role { TransactionRole::Client => { state.client_pending = true; @@ -66,6 +68,7 @@ impl InviteReservation { TransactionState::Completed | TransactionState::Accepted, ) => { let mut usage = self.usage.lock(); + usage.revision += 1; usage.server_pending = false; usage.server_waiting_ack += 1; self.phase = Some(Phase::ServerWaitingAck); @@ -77,6 +80,7 @@ impl InviteReservation { fn release(&mut self) { if let Some(phase) = self.phase.take() { let mut usage = self.usage.lock(); + usage.revision += 1; match phase { Phase::ClientPending => usage.client_pending = false, Phase::ServerPending => usage.server_pending = false, From 2f19887ed59a11ffc92a105e8bc984df29ba77b5 Mon Sep 17 00:00:00 2001 From: Fedor Kiselev <116813641+FedorKiselev76@users.noreply.github.com> Date: Fri, 6 Nov 2026 09:52:52 +0000 Subject: [PATCH 02/12] fix(dialog): expose lifecycle record reconstruction Add a public constructor for non-exhaustive lifecycle records so applications can reconstruct persisted history. Keep restore-time history validation unchanged. Exercise the API from an external integration test across two restores, including absent timestamps and invalid history. Verify the constructor documentation and Embassy build. --- src/dialog/snapshot.rs | 36 +++++++++++ tests/snapshot_reconstruction.rs | 105 +++++++++++++++++++++++++++++++ 2 files changed, 141 insertions(+) create mode 100644 tests/snapshot_reconstruction.rs diff --git a/src/dialog/snapshot.rs b/src/dialog/snapshot.rs index deae0464..d36eea38 100644 --- a/src/dialog/snapshot.rs +++ b/src/dialog/snapshot.rs @@ -12,6 +12,42 @@ pub struct DialogLifecycleRecord { pub kind: DialogLifecycleKind, } +impl DialogLifecycleRecord { + /// Reconstruct a fact from application-owned storage. + /// + /// Preserves the supplied sequence and optional wall-clock timestamp; it + /// does not generate a new event or time. The complete history is validated + /// when restoring a confirmed snapshot through + /// [`DialogLayer::restore_from_snapshot`](super::dialog_layer::DialogLayer::restore_from_snapshot). + /// + /// ``` + /// use core::time::Duration; + /// use rsipstack::dialog::{ + /// lifecycle::DialogLifecycleKind, + /// snapshot::DialogLifecycleRecord, + /// }; + /// use rsipstack::sip::StatusCode; + /// + /// let record = DialogLifecycleRecord::new( + /// 1, + /// Some(Duration::from_millis(1_700_000_000_123)), + /// DialogLifecycleKind::InviteAccepted { status: StatusCode::OK }, + /// ); + /// assert_eq!(record.sequence, 1); + /// ``` + pub fn new( + sequence: u64, + since_unix_epoch: Option, + kind: DialogLifecycleKind, + ) -> Self { + Self { + sequence, + since_unix_epoch, + kind, + } + } +} + /// In-flight work is recorded for recovery decisions, not replayed as SIP /// transactions. Interrupted application handlers remain pending conservatively. #[derive(Clone, Debug, Default, PartialEq, Eq)] diff --git a/tests/snapshot_reconstruction.rs b/tests/snapshot_reconstruction.rs new file mode 100644 index 00000000..d10efb4a --- /dev/null +++ b/tests/snapshot_reconstruction.rs @@ -0,0 +1,105 @@ +//! Exercise reconstruction through the public API, as a downstream crate. +#![cfg(feature = "platform-tokio")] + +use rsipstack::{ + dialog::{ + dialog::{Dialog, DialogSnapshot, DialogSnapshotState}, + dialog_layer::DialogLayer, + lifecycle::{dialog_lifecycle_channel, DialogLifecycleKind}, + snapshot::{DialogLifecycleRecord, DialogSnapshotRuntime}, + DialogId, + }, + sip::{prelude::ToTypedHeader, StatusCode}, + transaction::key::TransactionRole, + EndpointBuilder, +}; +use std::time::Duration; + +type TestResult = Result>; + +fn snapshot(history: Vec) -> TestResult { + let mut runtime = DialogSnapshotRuntime::default(); + runtime.revision = 42; + runtime.lifecycle = history; + Ok(DialogSnapshot { + runtime, + state: DialogSnapshotState::Confirmed, + role: TransactionRole::Client, + id: DialogId { + call_id: "stored-call".into(), + local_tag: "local".into(), + remote_tag: "remote".into(), + }, + from: rsipstack::sip::headers::From::from(";tag=local").typed()?, + to: rsipstack::sip::headers::To::from(";tag=remote").typed()?, + local_cseq: 7, + remote_cseq: 3, + local_contact: Some("sip:alice@127.0.0.1:5060".try_into()?), + remote_uri: "sip:bob@127.0.0.1:5061".try_into()?, + remote_contact: None, + route_set: vec![], + supports_100rel: false, + session_id: None, + }) +} + +#[tokio::test] +async fn external_application_can_reconstruct_persisted_lifecycle_history() -> TestResult { + // These are application-decoded storage fields, not records cloned from a + // live dialog. Both clock-bearing and clockless persisted facts are valid. + for stored_timestamp in [Some(Duration::new(1_700_000_000, 123_456_789)), None] { + let history = vec![DialogLifecycleRecord::new( + 1, + stored_timestamp, + DialogLifecycleKind::InviteAccepted { + status: StatusCode::OK, + }, + )]; + let mut saved = snapshot(history)?; + // A second restart must retain the reconstructed history as well. + for _ in 0..2 { + let layer = DialogLayer::new(EndpointBuilder::new().build().inner); + let (sender, mut events) = dialog_lifecycle_channel(); + layer.set_lifecycle_events(Some(sender)); + let (states, _receiver) = layer.new_dialog_state_channel(); + let id = saved.id.clone(); + assert!(layer.restore_from_snapshot(saved, states)?); + assert!(events.try_recv().is_err(), "restore must not replay facts"); + let Some(Dialog::Invite(dialog)) = layer.get_dialog(&id) else { + panic!("restored dialog is missing"); + }; + saved = dialog.snapshot(); + assert!(saved.is_quiescent()); + assert_eq!(saved.runtime.revision, 42); + assert_eq!(saved.runtime.lifecycle.len(), 1); + let fact = &saved.runtime.lifecycle[0]; + assert_eq!(fact.sequence, 1); + assert_eq!(fact.since_unix_epoch, stored_timestamp); + assert!(matches!( + fact.kind, + DialogLifecycleKind::InviteAccepted { + status: StatusCode::OK + } + )); + } + } + Ok(()) +} + +#[tokio::test] +async fn reconstructed_records_still_pass_through_restore_validation() -> TestResult { + for (sequence, status) in [(2, StatusCode::OK), (1, StatusCode::BusyHere)] { + let record = DialogLifecycleRecord::new( + sequence, + None, + DialogLifecycleKind::InviteAccepted { status }, + ); + let layer = DialogLayer::new(EndpointBuilder::new().build().inner); + let (states, _receiver) = layer.new_dialog_state_channel(); + assert!(layer + .restore_from_snapshot(snapshot(vec![record])?, states) + .is_err()); + assert!(layer.is_empty()); + } + Ok(()) +} From 2c05a1fd7f99b71eb32b2d505eada1eb231909a2 Mon Sep 17 00:00:00 2001 From: Fedor Kiselev <116813641+FedorKiselev76@users.noreply.github.com> Date: Fri, 6 Nov 2026 10:11:12 +0000 Subject: [PATCH 03/12] feat(dialog)!: add snapshot builder and document 0.9 migration Make DialogSnapshot non-exhaustive and require explicit state, CSeq counters and recovery metadata through its public builder. Preserve optional stored values and validate confirmed lifecycle history without discarding pending work. Document the proposed 0.9.0 release gate, legacy storage migration and changed restore behavior. Exercise downstream reconstruction and snapshot admission around the upstream re-INVITE handlers. --- CHANGELOG.md | 13 ++ MIGRATING-0.9.md | 101 ++++++++++ src/dialog/dialog.rs | 19 ++ src/dialog/snapshot.rs | 151 ++++++++++++++ src/dialog/tests/test_reinvite_control.rs | 17 ++ tests/snapshot_reconstruction.rs | 231 +++++++++++++++++++--- 6 files changed, 507 insertions(+), 25 deletions(-) create mode 100644 MIGRATING-0.9.md diff --git a/CHANGELOG.md b/CHANGELOG.md index 47edbdb9..09005d6e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,18 @@ # Changelog +## Unreleased — proposed 0.9.0 + +- **Breaking (requires maintainer approval for 0.9.0):** `DialogSnapshot` adds + coherent `runtime` metadata and becomes `#[non_exhaustive]`. External callers + must use `DialogSnapshot::builder(...)` and include `..` in destructuring + patterns. State, both CSeq values and runtime metadata must be explicit. +- **Recovery behavior:** confirmed snapshots with unfinished signaling or invalid + lifecycle history are rejected. Stored transactions and handlers are not + replayed. Lifecycle records can be reconstructed with `DialogLifecycleRecord::new`. +- See [the migration guide](MIGRATING-0.9.md) for storage defaults, legacy-record + handling, and the release compatibility plan. The release target is proposed; + this change does not itself bump or publish the package version. + ## 0.8.1 Fourteen fixes and additions merged (#223–#236). diff --git a/MIGRATING-0.9.md b/MIGRATING-0.9.md new file mode 100644 index 00000000..a1a9b151 --- /dev/null +++ b/MIGRATING-0.9.md @@ -0,0 +1,101 @@ +# Snapshot migration for the proposed 0.9.0 release + +These changes require a breaking release. The proposed target is **0.9.0**, +subject to maintainer approval; this document does not announce a release or +change the package version. Do not backport this API change into 0.8.x. + +## Constructing and reading snapshots + +`DialogSnapshot` now includes coherent runtime metadata and is +`#[non_exhaustive]`. Adding `runtime` breaks old struct literals and exhaustive +patterns. The attribute also prevents external struct literals, even if they +include `runtime`. Replace them with `DialogSnapshot::builder(...)`; adding +`runtime: DialogSnapshotRuntime::default()` to a literal is not sufficient. + +Supply the stored identity, role, From/To headers, remote URI, state, both CSeq +counters, and runtime metadata. The builder requires state, counters and runtime +explicitly: it never assumes a stored dialog was confirmed or quiescent. Copy +optional stored contacts, routes, 100rel support and Session-ID through their +builder methods too. Omitting those optional settings yields `None`, no routes, +`false`, and `None`, respectively; it does not recover their persisted values. + +This example illustrates an application-approved migration of a legacy, +confirmed record known to have been captured with no signaling in flight: + +```rust +use rsipstack::{ + dialog::{ + dialog::{DialogSnapshot, DialogSnapshotState}, + snapshot::DialogSnapshotRuntime, + DialogId, + }, + sip::{headers, prelude::ToTypedHeader}, + transaction::key::TransactionRole, +}; + +let snapshot = DialogSnapshot::builder( + DialogId { + call_id: "stored-call".into(), + local_tag: "local".into(), + remote_tag: "remote".into(), + }, + TransactionRole::Client, + headers::From::from(";tag=local").typed()?, + headers::To::from(";tag=remote").typed()?, + "sip:bob@example.com".try_into()?, +) +.state(DialogSnapshotState::Confirmed) +.local_cseq(42) +.remote_cseq(7) +.local_contact(Some("sip:alice@example.com".try_into()?)) +// The application has established that this legacy record was quiescent. +.runtime(DialogSnapshotRuntime::default()) +.build()?; + +// Field access is unchanged. Patterns must allow future fields. +let DialogSnapshot { id, runtime, .. } = snapshot; +assert_eq!(id.call_id, "stored-call"); +assert!(runtime.lifecycle.is_empty()); +# Ok::<(), Box>(()) +``` + +The builder checks required inputs and the lifecycle history of confirmed +snapshots. It also represents pending and non-confirmed snapshots so applications +can inspect or store them. `build()` succeeding does **not** guarantee that +restore will resume the dialog. Public fields remain mutable, so restore retains +its own validation. + +## Storage and recovery behavior + +The application owns serialization, storage schema versions and migrations. +`runtime.revision` identifies a dialog state revision, **not a storage schema**. +Persist the complete runtime metadata, including pending operations and lifecycle +records. Reconstruct individual facts with +`DialogLifecycleRecord::new(sequence, since_unix_epoch, kind)`. Preserve their +sequence and optional wall-clock time; do not invent timestamps or acceptance +events during migration. Restoring retains the history without replaying it to +notification consumers. Monotonic timestamps are process-local and not stored. + +For a pre-0.9 record without runtime metadata, explicitly passing +`DialogSnapshotRuntime::default()` represents revision zero, no recorded history, +and no pending operations. This is appropriate only when the application's +existing capture contract or other reliable evidence establishes that signaling +was quiescent. Missing metadata alone does not establish that fact. Empty history +means no history was retained; it is not evidence that the call was never answered. +If quiescence cannot be established, apply an explicit application recovery policy +instead of silently resuming the call. Never discard known pending work or use a +default to hide corrupt metadata. + +Calls to `dialog.snapshot()` and `layer.restore_from_snapshot(snapshot, sender)` +keep their signatures. The restore behavior changes as follows: + +- A confirmed snapshot with non-empty `runtime.pending` returns an error. SIP + transactions, outstanding ACKs and application handlers are not replayed. +- Invalid confirmed lifecycle history or revision returns an error. +- Non-confirmed snapshots are still skipped with `Ok(false)`. +- An already registered dialog is still retained and restore returns `Ok(false)`. + +Future optional fields may have safe defaults without breaking builder callers. +New data required for safe recovery must instead have an explicit migration or +compatibility plan. `#[non_exhaustive]` protects source construction and matching; +it is not a promise that every future persisted record can be silently migrated. diff --git a/src/dialog/dialog.rs b/src/dialog/dialog.rs index faddf34e..b5b9d1da 100644 --- a/src/dialog/dialog.rs +++ b/src/dialog/dialog.rs @@ -451,7 +451,12 @@ pub struct SessionIdState { pub local: String, pub remote: Option, } +/// A coherent snapshot for application-owned storage and recovery. +/// +/// Use [`Self::builder`] to reconstruct stored data. Direct field access remains +/// available; destructuring outside this crate must include `..`. #[derive(Clone, Debug)] +#[non_exhaustive] pub struct DialogSnapshot { /// Captured with routing, CSeq, lifecycle facts, and transaction admission. pub runtime: super::snapshot::DialogSnapshotRuntime, @@ -476,6 +481,20 @@ pub struct DialogSnapshot { pub session_id: Option, } impl DialogSnapshot { + /// Reconstruct a snapshot without depending on its complete field list. + /// + /// State, both CSeq values, and runtime metadata must be supplied explicitly + /// before building. See [`super::snapshot`] for the 0.9 migration guide. + pub fn builder( + id: DialogId, + role: TransactionRole, + from: crate::sip::typed::From, + to: crate::sip::typed::To, + remote_uri: crate::sip::Uri, + ) -> super::snapshot::DialogSnapshotBuilder { + super::snapshot::DialogSnapshotBuilder::new(id, role, from, to, remote_uri) + } + /// Only confirmed snapshots with no unfinished signaling can be resumed. pub fn is_quiescent(&self) -> bool { self.state == DialogSnapshotState::Confirmed && self.runtime.pending.is_empty() diff --git a/src/dialog/snapshot.rs b/src/dialog/snapshot.rs index d36eea38..75c89e23 100644 --- a/src/dialog/snapshot.rs +++ b/src/dialog/snapshot.rs @@ -1,8 +1,159 @@ //! Recovery metadata captured together with the dialog's routing state. +#![doc = include_str!("../../MIGRATING-0.9.md")] +use super::dialog::{DialogSnapshot, DialogSnapshotState, SessionIdState}; use super::lifecycle::DialogLifecycleKind; +use super::DialogId; +use crate::sip::{headers::Route, typed, Uri}; +use crate::transaction::key::TransactionRole; use alloc::vec::Vec; use core::time::Duration; +/// Reconstruct application-owned snapshot data through [`DialogSnapshot::builder`]. +/// +/// State, CSeq values and runtime metadata have no implicit defaults. Optional +/// contacts and Session-ID default to `None`, routes to an empty vector, and +/// 100rel support to `false`. Preserve all stored values when rebuilding a +/// snapshot; defaults do not migrate storage or infer missing recovery data. +#[derive(Clone, Debug)] +#[must_use] +pub struct DialogSnapshotBuilder { + id: DialogId, + role: TransactionRole, + from: typed::From, + to: typed::To, + remote_uri: Uri, + state: Option, + local_cseq: Option, + remote_cseq: Option, + runtime: Option, + local_contact: Option, + remote_contact: Option, + route_set: Vec, + supports_100rel: bool, + session_id: Option, +} + +impl DialogSnapshotBuilder { + pub(crate) fn new( + id: DialogId, + role: TransactionRole, + from: typed::From, + to: typed::To, + remote_uri: Uri, + ) -> Self { + Self { + id, + role, + from, + to, + remote_uri, + state: None, + local_cseq: None, + remote_cseq: None, + runtime: None, + local_contact: None, + remote_contact: None, + route_set: Vec::new(), + supports_100rel: false, + session_id: None, + } + } + + /// Set the persisted dialog state; building does not imply confirmation. + pub fn state(mut self, state: DialogSnapshotState) -> Self { + self.state = Some(state); + self + } + + /// Set the persisted local sequence counter, without resetting it. + pub fn local_cseq(mut self, cseq: u32) -> Self { + self.local_cseq = Some(cseq); + self + } + + /// Set the persisted remote sequence counter, including an explicit zero. + pub fn remote_cseq(mut self, cseq: u32) -> Self { + self.remote_cseq = Some(cseq); + self + } + + /// Set recovery metadata, preserving pending operations and lifecycle facts. + /// + /// For pre-0.9 records, pass `DialogSnapshotRuntime::default()` only after + /// the application has established that no signaling was in flight. Missing + /// metadata alone is not evidence of a quiescent dialog. + pub fn runtime(mut self, runtime: DialogSnapshotRuntime) -> Self { + self.runtime = Some(runtime); + self + } + + pub fn local_contact(mut self, contact: Option) -> Self { + self.local_contact = contact; + self + } + + pub fn remote_contact( + mut self, + contact: Option, + ) -> Self { + self.remote_contact = contact; + self + } + + pub fn route_set(mut self, routes: Vec) -> Self { + self.route_set = routes; + self + } + + pub fn supports_100rel(mut self, supported: bool) -> Self { + self.supports_100rel = supported; + self + } + + pub fn session_id(mut self, session_id: Option) -> Self { + self.session_id = session_id; + self + } + + /// Check required inputs and the lifecycle history of a confirmed snapshot. + /// + /// This does not restore a dialog or prove it can be resumed. In particular, + /// pending operations and non-confirmed states remain representable for + /// application recovery decisions. Restore still rejects confirmed snapshots + /// with pending signaling and skips non-confirmed snapshots. Mutable public + /// fields are rechecked at restore time. + pub fn build(self) -> crate::Result { + let snapshot = DialogSnapshot { + id: self.id, + role: self.role, + from: self.from, + to: self.to, + remote_uri: self.remote_uri, + state: self + .state + .ok_or_else(|| crate::Error::Error("snapshot state is required".into()))?, + local_cseq: self + .local_cseq + .ok_or_else(|| crate::Error::Error("snapshot local CSeq is required".into()))?, + remote_cseq: self + .remote_cseq + .ok_or_else(|| crate::Error::Error("snapshot remote CSeq is required".into()))?, + runtime: self.runtime.ok_or_else(|| { + crate::Error::Error("snapshot runtime metadata is required".into()) + })?, + local_contact: self.local_contact, + remote_contact: self.remote_contact, + route_set: self.route_set, + supports_100rel: self.supports_100rel, + session_id: self.session_id, + }; + if snapshot.state == DialogSnapshotState::Confirmed { + super::lifecycle::LifecycleState::restored(&snapshot.runtime)?; + } + Ok(snapshot) + } +} + /// A persisted fact deliberately excludes process-local monotonic time. #[derive(Clone, Debug)] #[non_exhaustive] diff --git a/src/dialog/tests/test_reinvite_control.rs b/src/dialog/tests/test_reinvite_control.rs index de660bea..94981d7f 100644 --- a/src/dialog/tests/test_reinvite_control.rs +++ b/src/dialog/tests/test_reinvite_control.rs @@ -77,6 +77,10 @@ async fn deferred_ack_waits_for_answer_and_retransmits_identically() -> crate::R peer.send_to(success.to_string().as_bytes(), address) .await?; assert_eq!(received_offer.recv().await.unwrap().body, OFFER); + let during_answer = dialog.snapshot(); + assert_eq!(during_answer.runtime.pending.negotiations, 1); + assert!(during_answer.runtime.pending.local_invite); + assert!(!during_answer.is_quiescent()); peer.send_to(success.to_string().as_bytes(), address) .await?; let overlapping = dialog.prepare_reinvite(None, Some(OFFER.to_vec()))?; @@ -100,6 +104,7 @@ async fn deferred_ack_waits_for_answer_and_retransmits_identically() -> crate::R assert_eq!(ack.body, ANSWER); assert_eq!(ack.cseq_header()?.seq()?, sequence); assert_eq!(pending.await.unwrap()?.unwrap().status_code.code(), 200); + assert!(dialog.snapshot().is_quiescent()); peer.send_to(success.to_string().as_bytes(), address) .await?; let (repeated, _) = recv_request(&peer, Method::Ack).await; @@ -161,6 +166,7 @@ async fn cancelled_reinvite_waits_for_provisional_and_preserves_session() -> cra recv_request(&peer, Method::Ack).await; assert_eq!(pending.await.unwrap()?.unwrap().status_code.code(), 487); assert!(matches!(dialog.state(), DialogState::Confirmed(..))); + assert!(dialog.snapshot().is_quiescent()); Ok(()) } @@ -612,6 +618,10 @@ async fn incoming_offerless_reinvite_exposes_only_matching_ack_answer() -> crate .await .unwrap(); receive_response(&peer, Method::Invite, 200).await?; + let awaiting_ack = dialog.snapshot(); + assert_eq!(awaiting_ack.runtime.pending.negotiations, 1); + assert!(awaiting_ack.runtime.pending.remote_invite_awaiting_ack); + assert!(!awaiting_ack.is_quiescent()); let mut ack = request; ack.method = Method::Ack; ack.headers.unique_push(Header::CSeq("9 ACK".into())); @@ -634,5 +644,12 @@ async fn incoming_offerless_reinvite_exposes_only_matching_ack_answer() -> crate assert_eq!(received.body, ANSWER); assert_eq!(received.cseq_header()?.seq()?, 10); assert!(dialog.state().is_confirmed()); + tokio::time::timeout(Duration::from_secs(1), async { + while !dialog.snapshot().is_quiescent() { + tokio::task::yield_now().await; + } + }) + .await + .expect("matching ACK must finish the snapshot negotiation"); Ok(()) } diff --git a/tests/snapshot_reconstruction.rs b/tests/snapshot_reconstruction.rs index d10efb4a..98bc8d9d 100644 --- a/tests/snapshot_reconstruction.rs +++ b/tests/snapshot_reconstruction.rs @@ -3,10 +3,10 @@ use rsipstack::{ dialog::{ - dialog::{Dialog, DialogSnapshot, DialogSnapshotState}, + dialog::{Dialog, DialogSnapshot, DialogSnapshotState, SessionIdState}, dialog_layer::DialogLayer, lifecycle::{dialog_lifecycle_channel, DialogLifecycleKind}, - snapshot::{DialogLifecycleRecord, DialogSnapshotRuntime}, + snapshot::{DialogLifecycleRecord, DialogSnapshotBuilder, DialogSnapshotRuntime}, DialogId, }, sip::{prelude::ToTypedHeader, StatusCode}, @@ -17,30 +17,31 @@ use std::time::Duration; type TestResult = Result>; -fn snapshot(history: Vec) -> TestResult { - let mut runtime = DialogSnapshotRuntime::default(); - runtime.revision = 42; - runtime.lifecycle = history; - Ok(DialogSnapshot { - runtime, - state: DialogSnapshotState::Confirmed, - role: TransactionRole::Client, - id: DialogId { +fn builder() -> TestResult { + Ok(DialogSnapshot::builder( + DialogId { call_id: "stored-call".into(), local_tag: "local".into(), remote_tag: "remote".into(), }, - from: rsipstack::sip::headers::From::from(";tag=local").typed()?, - to: rsipstack::sip::headers::To::from(";tag=remote").typed()?, - local_cseq: 7, - remote_cseq: 3, - local_contact: Some("sip:alice@127.0.0.1:5060".try_into()?), - remote_uri: "sip:bob@127.0.0.1:5061".try_into()?, - remote_contact: None, - route_set: vec![], - supports_100rel: false, - session_id: None, - }) + TransactionRole::Client, + rsipstack::sip::headers::From::from(";tag=local").typed()?, + rsipstack::sip::headers::To::from(";tag=remote").typed()?, + "sip:bob@127.0.0.1:5061".try_into()?, + )) +} + +fn snapshot(history: Vec) -> TestResult { + let mut runtime = DialogSnapshotRuntime::default(); + runtime.revision = 42; + runtime.lifecycle = history; + Ok(builder()? + .state(DialogSnapshotState::Confirmed) + .local_cseq(7) + .remote_cseq(3) + .local_contact(Some("sip:alice@127.0.0.1:5060".try_into()?)) + .runtime(runtime) + .build()?) } #[tokio::test] @@ -96,10 +97,190 @@ async fn reconstructed_records_still_pass_through_restore_validation() -> TestRe ); let layer = DialogLayer::new(EndpointBuilder::new().build().inner); let (states, _receiver) = layer.new_dialog_state_channel(); - assert!(layer - .restore_from_snapshot(snapshot(vec![record])?, states) - .is_err()); + // Builder and restore both validate: public fields remain mutable. + assert!(snapshot(vec![record.clone()]).is_err()); + let mut corrupted = snapshot(vec![])?; + corrupted.runtime.lifecycle.push(record); + assert!(layer.restore_from_snapshot(corrupted, states).is_err()); assert!(layer.is_empty()); } Ok(()) } + +#[test] +fn builder_requires_recovery_inputs_instead_of_guessing_defaults() -> TestResult { + let base = builder()?; + let state = DialogSnapshotState::Confirmed; + let runtime = DialogSnapshotRuntime::default(); + for (builder, missing) in [ + ( + base.clone() + .local_cseq(1) + .remote_cseq(0) + .runtime(runtime.clone()), + "state", + ), + ( + base.clone() + .state(state) + .remote_cseq(0) + .runtime(runtime.clone()), + "local CSeq", + ), + ( + base.clone().state(state).local_cseq(1).runtime(runtime), + "remote CSeq", + ), + ( + base.state(state).local_cseq(1).remote_cseq(0), + "runtime metadata", + ), + ] { + let error = builder + .build() + .expect_err("required input must not default"); + assert!(error.to_string().contains(missing), "{error}"); + } + Ok(()) +} + +#[tokio::test] +async fn explicit_legacy_migration_uses_only_optional_defaults() -> TestResult { + let saved = builder()? + .state(DialogSnapshotState::Confirmed) + .local_cseq(42) + .remote_cseq(0) + // The application has established that the legacy record was quiescent. + .runtime(DialogSnapshotRuntime::default()) + .build()?; + assert!(saved.local_contact.is_none()); + assert!(saved.remote_contact.is_none()); + assert!(saved.route_set.is_empty()); + assert!(!saved.supports_100rel); + assert!(saved.session_id.is_none()); + let layer = DialogLayer::new(EndpointBuilder::new().build().inner); + let (states, _) = layer.new_dialog_state_channel(); + let id = saved.id.clone(); + assert!(layer.restore_from_snapshot(saved, states)?); + let Some(Dialog::Invite(dialog)) = layer.get_dialog(&id) else { + panic!("restored dialog missing"); + }; + let saved = dialog.snapshot(); + assert_eq!(saved.local_cseq, 42); + assert_eq!(saved.remote_cseq, 0); + assert_eq!(saved.runtime.revision, 0); + assert!(saved.runtime.lifecycle.is_empty()); + Ok(()) +} + +#[test] +fn builder_preserves_all_supplied_fields_and_allows_non_exhaustive_patterns() -> TestResult { + let mut stored = snapshot(vec![DialogLifecycleRecord::new( + 1, + Some(Duration::from_nanos(123)), + DialogLifecycleKind::InviteAccepted { + status: StatusCode::OK, + }, + )])?; + stored.remote_contact = Some(rsipstack::sip::headers::Contact::from( + "", + )); + stored.route_set = vec![rsipstack::sip::Route::from("")]; + stored.supports_100rel = true; + stored.session_id = Some(SessionIdState { + local: "0123456789abcdef0123456789abcdef".into(), + remote: Some("abcdef0123456789abcdef0123456789".into()), + }); + // A persistence adapter must explicitly map every stored field. Exercise + // both roles without deriving either role or state from default values. + for role in [TransactionRole::Client, TransactionRole::Server] { + stored.role = role; + let DialogSnapshot { + id, + role, + from, + to, + remote_uri, + state, + local_cseq, + remote_cseq, + local_contact, + remote_contact, + route_set, + supports_100rel, + session_id, + runtime, + .. + } = stored.clone(); + let rebuilt = DialogSnapshot::builder(id, role, from, to, remote_uri) + .state(state) + .local_cseq(local_cseq) + .remote_cseq(remote_cseq) + .local_contact(local_contact) + .remote_contact(remote_contact) + .route_set(route_set) + .supports_100rel(supports_100rel) + .session_id(session_id) + .runtime(runtime) + .build()?; + assert_eq!(format!("{rebuilt:?}"), format!("{stored:?}")); + } + Ok(()) +} + +#[tokio::test] +async fn builder_preserves_each_pending_flag_and_restore_refuses_to_resume() -> TestResult { + for flag in 0..7 { + let mut runtime = DialogSnapshotRuntime::default(); + match flag { + 0 => runtime.pending.local_invite = true, + 1 => runtime.pending.remote_invite = true, + 2 => runtime.pending.remote_invite_awaiting_ack = true, + 3 => runtime.pending.initial_ack = true, + 4 => runtime.pending.negotiations = 2, + 5 => runtime.pending.local_termination = true, + _ => runtime.pending.remote_termination = true, + } + let saved = builder()? + .state(DialogSnapshotState::Confirmed) + .local_cseq(7) + .remote_cseq(3) + .runtime(runtime.clone()) + .build()?; + assert_eq!(saved.runtime.pending, runtime.pending); + assert!(!saved.is_quiescent()); + let layer = DialogLayer::new(EndpointBuilder::new().build().inner); + let (states, _) = layer.new_dialog_state_channel(); + let error = layer.restore_from_snapshot(saved, states).unwrap_err(); + assert!(error.to_string().contains("unfinished signaling")); + assert!(layer.is_empty()); + } + Ok(()) +} + +#[tokio::test] +async fn builder_keeps_non_confirmed_snapshots_inspectable() -> TestResult { + use rsipstack::dialog::dialog::TerminatedReason; + let mut runtime = DialogSnapshotRuntime::default(); + runtime.revision = 1; + runtime.lifecycle.push(DialogLifecycleRecord::new( + 1, + None, + DialogLifecycleKind::DialogTerminated { + reason: TerminatedReason::Timeout, + }, + )); + let saved = builder()? + .state(DialogSnapshotState::Terminated) + .local_cseq(7) + .remote_cseq(3) + .runtime(runtime) + .build()?; + assert_eq!(saved.runtime.lifecycle.len(), 1); + assert!(!saved.is_quiescent()); + let layer = DialogLayer::new(EndpointBuilder::new().build().inner); + let (states, _) = layer.new_dialog_state_channel(); + assert!(!layer.restore_from_snapshot(saved, states)?); + assert!(layer.is_empty()); + Ok(()) +} From ec078e425f75e9b180107f0c893cd46b1575a78f Mon Sep 17 00:00:00 2001 From: Fedor Kiselev <116813641+FedorKiselev76@users.noreply.github.com> Date: Thu, 5 Nov 2026 15:08:23 +0000 Subject: [PATCH 04/12] feat(dialog): add opt-in durable signaling checkpoints --- src/dialog/client_dialog.rs | 7 + src/dialog/dialog.rs | 43 +- src/dialog/dialog_layer.rs | 24 + src/dialog/invitation.rs | 4 + src/dialog/invite_dialog.rs | 60 ++- src/dialog/lifecycle.rs | 15 +- src/dialog/mod.rs | 1 + src/dialog/persistence.rs | 297 +++++++++++++ src/dialog/server_dialog.rs | 14 + src/dialog/tests/mod.rs | 1 + src/dialog/tests/test_persistence.rs | 630 +++++++++++++++++++++++++++ src/transaction/transaction.rs | 98 ++++- tests/interop/README.md | 11 + tests/interop/checkpoints.rs | 53 +++ tests/interop/mod.rs | 2 + 15 files changed, 1250 insertions(+), 10 deletions(-) create mode 100644 src/dialog/persistence.rs create mode 100644 src/dialog/tests/test_persistence.rs create mode 100644 tests/interop/checkpoints.rs diff --git a/src/dialog/client_dialog.rs b/src/dialog/client_dialog.rs index ebc4b058..786caaee 100644 --- a/src/dialog/client_dialog.rs +++ b/src/dialog/client_dialog.rs @@ -558,6 +558,7 @@ impl ClientInviteDialog { /// * `UPDATE` - Handles session updates /// * `INVITE` - Handles re-INVITE (when confirmed) pub async fn handle(&mut self, tx: &mut Transaction) -> Result<()> { + self.inner.bind_persistence(tx); trace!( id = %self.id(), method = %tx.original.method, @@ -664,6 +665,12 @@ impl ClientInviteDialog { self.inner.begin_negotiation(); let result = self.inner.process_reinvite(tx, false).await; self.inner.finish_negotiation(); + self.inner + .checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; result } diff --git a/src/dialog/dialog.rs b/src/dialog/dialog.rs index b5b9d1da..c1aed319 100644 --- a/src/dialog/dialog.rs +++ b/src/dialog/dialog.rs @@ -342,6 +342,8 @@ pub struct DialogInner { pub(super) endpoint_inner: EndpointInnerRef, pub(super) state_sender: DialogStateSender, pub(crate) lifecycle: Mutex, + pub(crate) persistence: Mutex>>, + pub(crate) persistence_owner: Mutex>, pub(super) tu_sender: TransactionEventSender, /// RFC 7989 Session-ID state; `None` when the dialog does not participate /// (no UUID supplied by the application and none received from the peer). @@ -566,6 +568,8 @@ impl DialogInner { route_set: Mutex::new(route_set), endpoint_inner, state_sender, + persistence: Mutex::new(None), + persistence_owner: Mutex::new(alloc::sync::Weak::new()), lifecycle: Mutex::new(super::lifecycle::LifecycleState::default()), tu_sender, state: Mutex::new(DialogState::Calling(id)), @@ -823,6 +827,7 @@ impl DialogInner { } } + self.bind_persistence(&tx); match tx.send().await { Ok(_) => { debug!( @@ -867,6 +872,7 @@ impl DialogInner { if let Some(cred) = &self.credential { let new_seq = self.increment_local_seq(); tx = handle_client_authenticate(new_seq, &tx, resp, cred).await?; + self.bind_persistence(&tx); tx.send().await?; continue; } else { @@ -888,6 +894,7 @@ impl DialogInner { _ => break, } } + tx.check_persistence()?; Ok(None) } @@ -1351,6 +1358,11 @@ impl DialogInner { let result = self.send_dialog_request_inner(request, options).await; if negotiation { self.finish_negotiation(); + self.checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; } result } @@ -1373,6 +1385,7 @@ impl DialogInner { ); tx.defer_success_ack = options.as_ref().is_some_and(|o| o.answer_handler.is_some()); tx.force_success_ack = options.is_some() && !tx.defer_success_ack; + self.bind_persistence(&tx); self.reserve_invite(&tx)?; if let Some(route) = tx.original.route_header() { @@ -1594,6 +1607,7 @@ impl DialogInner { tx.defer_success_ack = options.as_ref().is_some_and(|o| o.answer_handler.is_some()); tx.force_success_ack = options.is_some() && !tx.defer_success_ack; + self.bind_persistence(&tx); self.reserve_invite(&tx)?; tx.send().await?; cancel_watch = options.as_ref().map(|o| { @@ -1690,6 +1704,7 @@ impl DialogInner { _ => break, } } + tx.check_persistence()?; Ok(None) } @@ -1732,6 +1747,11 @@ impl DialogInner { } self.record_local_termination(); } + self.checkpoint( + super::persistence::DialogCheckpointReason::LocalTerminationRequested, + None, + ) + .await?; let initial_ack = self.initial_ack.lock().clone(); let reinvite_ack = self.reinvite_ack.lock().clone(); for ack in [initial_ack, reinvite_ack].into_iter().flatten() { @@ -1747,6 +1767,8 @@ impl DialogInner { let result = self.do_request(request).await; let id = self.id.lock().clone(); self.transition(DialogState::Terminated(id, reason)); + self.checkpoint(super::persistence::DialogCheckpointReason::Terminated, None) + .await?; result.map(|_| ()) } @@ -1843,11 +1865,15 @@ impl DialogInner { /// writes to DialogInner public fields bypass these synchronization guarantees. pub fn snapshot(&self) -> DialogSnapshot { let state_guard = self.state.lock(); + self.snapshot_locked(&state_guard) + } + + pub(crate) fn snapshot_locked(&self, state_guard: &DialogState) -> DialogSnapshot { let usage = self.invite_usage.lock(); let lifecycle = self.lifecycle.lock(); let id = self.id.lock().clone(); - let state = match &*state_guard { + let state = match state_guard { DialogState::Calling(_) => DialogSnapshotState::Calling, DialogState::Trying(_) => DialogSnapshotState::Trying, DialogState::Early(_, _) => DialogSnapshotState::Early, @@ -1986,6 +2012,8 @@ impl DialogInner { endpoint_inner, state_sender, + persistence: Mutex::new(None), + persistence_owner: Mutex::new(alloc::sync::Weak::new()), lifecycle: Mutex::new(lifecycle), tu_sender, @@ -2244,6 +2272,13 @@ impl DialogInner { } self.lifecycle.lock().revision += 1; *old_state = state.clone(); + if state.is_terminated() { + self.enqueue_checkpoint_locked( + old_state, + super::persistence::DialogCheckpointReason::Terminated, + None, + ); + } // Try to send state update, but don't fail if channel is closed self.state_sender.send(state).ok(); } @@ -2261,6 +2296,11 @@ impl DialogInner { let result = self.process_transaction_handle_inner(tx, rx).await; if negotiation { self.finish_negotiation(); + self.checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; } result } @@ -2271,6 +2311,7 @@ impl DialogInner { tx: &mut Transaction, mut rx: TransactionCommandReceiver, ) -> Result<()> { + self.bind_persistence(tx); let target = if Self::is_target_refresh(&tx.original.method) { match Self::parse_target_refresh_contact(&tx.original) { Ok(target) => target, diff --git a/src/dialog/dialog_layer.rs b/src/dialog/dialog_layer.rs index 6b039bad..d481b907 100644 --- a/src/dialog/dialog_layer.rs +++ b/src/dialog/dialog_layer.rs @@ -34,6 +34,8 @@ use tracing::debug; /// * `last_seq` uses atomic operations for lock-free increments /// * `dialogs` uses RwLock for concurrent read access with exclusive writes pub struct DialogLayerInner { + pub(super) persistence_config: + crate::platform::sync::Mutex>, pub(super) lifecycle_sender: crate::platform::sync::Mutex>, pub(super) last_seq: AtomicU32, @@ -143,6 +145,7 @@ impl DialogLayer { endpoint, inner: Arc::new(DialogLayerInner { last_seq: AtomicU32::new(0), + persistence_config: crate::platform::sync::Mutex::new(None), lifecycle_sender: crate::platform::sync::Mutex::new(None), dialogs: RwMap::new(), }), @@ -161,6 +164,22 @@ impl DialogLayer { *self.inner.lifecycle_sender.lock() = sender; } + /// Configure optional durable checkpoints for subsequently created/restored + /// INVITE dialogs. Existing dialogs retain their configuration. + pub fn set_persistence( + &self, + config: Option, + ) -> Result<()> { + if let Some(config) = &config { + config.validate()?; + self.endpoint + .record_receipt_times + .store(true, Ordering::Relaxed); + } + *self.inner.persistence_config.lock() = config; + Ok(()) + } + pub fn get_or_create_server_invite( &self, tx: &Transaction, @@ -223,6 +242,10 @@ impl DialogLayer { let dialog = InviteDialog::from_inner(Arc::new(dlg_inner)); dialog.inner.lifecycle.lock().sender = self.inner.lifecycle_sender.lock().clone(); *tx.initial_dialog.lock() = Some(Arc::downgrade(&dialog.inner)); + dialog + .inner + .configure_persistence(self.inner.persistence_config.lock().clone()); + dialog.inner.bind_persistence(tx); dialog.inner.reserve_invite(tx)?; dialog.inner.set_server_connection(tx.connection.clone()); self.inner @@ -559,6 +582,7 @@ impl DialogLayer { inner.credential = credential; inner.lifecycle.lock().sender = self.inner.lifecycle_sender.lock().clone(); let inner = Arc::new(inner); + inner.configure_persistence(self.inner.persistence_config.lock().clone()); let dialog = Dialog::from_inner(inner.role, inner.clone()); let key = dialog.id().to_string(); diff --git a/src/dialog/invitation.rs b/src/dialog/invitation.rs index 594f9e18..ad9616e9 100644 --- a/src/dialog/invitation.rs +++ b/src/dialog/invitation.rs @@ -901,6 +901,10 @@ impl DialogLayer { } let dialog = InviteDialog::from_inner(Arc::new(dlg_inner)); dialog.inner.lifecycle.lock().sender = self.inner.lifecycle_sender.lock().clone(); + dialog + .inner + .configure_persistence(self.inner.persistence_config.lock().clone()); + dialog.inner.bind_persistence(&tx); dialog.inner.reserve_invite(&tx)?; Ok((dialog, tx)) } diff --git a/src/dialog/invite_dialog.rs b/src/dialog/invite_dialog.rs index 4544f538..c78e9619 100644 --- a/src/dialog/invite_dialog.rs +++ b/src/dialog/invite_dialog.rs @@ -78,6 +78,15 @@ impl InviteDialog { self.inner.state.lock().clone() } + /// Inspect checkpoint progress and any permanent storage failure. + pub fn persistence_status(&self) -> Option { + self.inner + .persistence + .lock() + .as_ref() + .map(|runtime| runtime.status.lock().clone()) + } + pub fn snapshot(&self) -> super::dialog::DialogSnapshot { self.inner.snapshot() } @@ -259,7 +268,7 @@ impl InviteDialog { StatusCode::ServerInternalError, )); } - { + let deferred = { // Decided under the state lock, so `process_invite` either sees // the deferred CANCEL after leaving Calling or we see it left. let state = self.inner.state.lock(); @@ -268,16 +277,27 @@ impl InviteDialog { self.inner.record_local_termination(); self.inner.cancel_requested.store(true, Ordering::SeqCst); self.inner.cancel_deferred.store(true, Ordering::SeqCst); - return Ok(()); + true } DialogState::Trying(_) | DialogState::Early(_, _) => { self.inner.record_local_termination(); self.inner.cancel_requested.store(true, Ordering::SeqCst); + false } _ => return Ok(()), } + }; + self.inner + .checkpoint( + super::persistence::DialogCheckpointReason::LocalTerminationRequested, + None, + ) + .await?; + if deferred { + Ok(()) + } else { + self.send_cancel().await } - self.send_cancel().await } /// Send the CANCEL `cancel()` deferred in Calling, once the INVITE got a @@ -375,7 +395,10 @@ impl InviteDialog { self.inner.reserve_invite(tx)?; self.inner.transition(DialogState::Calling(self.id())); let mut auth = AuthRetry::new(); - tx.track_receipt_times(self.inner.lifecycle.lock().sender.is_some()); + self.inner.bind_persistence(tx); + tx.track_receipt_times( + self.inner.lifecycle.lock().sender.is_some() || self.inner.persistence.lock().is_some(), + ); tx.send().await?; // Record the flow the INVITE actually went out on, so later // in-dialog requests (BYE / re-INVITE / INFO) reuse it instead of @@ -397,9 +420,18 @@ impl InviteDialog { } }) .await; + tx.check_persistence()?; ack.finish(); if msg.is_some() { self.inner.complete_initial_ack(); + if self.inner.is_confirmed() || self.inner.is_terminated() { + self.inner + .checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; + } } let cancelled = established?; let Some(msg) = msg else { break }; @@ -452,7 +484,11 @@ impl InviteDialog { ) .await?; self.inner.reserve_invite(tx)?; - tx.track_receipt_times(self.inner.lifecycle.lock().sender.is_some()); + self.inner.bind_persistence(tx); + tx.track_receipt_times( + self.inner.lifecycle.lock().sender.is_some() + || self.inner.persistence.lock().is_some(), + ); tx.send().await?; self.inner.set_server_connection(tx.connection.clone()); self.inner.update_remote_tag("").ok(); @@ -846,6 +882,7 @@ impl InviteDialog { /// Handle an incoming transaction routed to this dialog. pub async fn handle(&mut self, tx: &mut Transaction) -> Result<()> { + self.inner.bind_persistence(tx); trace!( id = %self.id(), method = %tx.original.method, @@ -1136,6 +1173,12 @@ impl InviteDialog { self.inner.begin_negotiation(); let result = self.inner.process_reinvite(tx, true).await; self.inner.finish_negotiation(); + self.inner + .checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; result } @@ -1178,8 +1221,15 @@ impl InviteDialog { SipMessage::Response(_) => {} } } + tx.check_persistence()?; let answered_2xx = self.inner.waiting_ack(); self.inner.end_session_without_ack(tx, answered_2xx).await; + self.inner + .checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; Ok::<(), crate::Error>(()) }; match handle_loop.await { diff --git a/src/dialog/lifecycle.rs b/src/dialog/lifecycle.rs index 6e110ac8..d2dc547f 100644 --- a/src/dialog/lifecycle.rs +++ b/src/dialog/lifecycle.rs @@ -3,6 +3,8 @@ //! Unlike `DialogState`, these are facts, not requests for application action. //! Delivery never awaits application code or storage. Events are not a durable //! journal: a closed receiver drops notifications without affecting SIP. +//! Explicitly enabling persistence holds delivery until a covering checkpoint +//! commits; the notification receiver itself still cannot delay SIP. //! //! Configure the layer before creating calls: //! @@ -114,6 +116,8 @@ pub(crate) struct LifecycleState { pub pending_remote_bye: bool, pub negotiations: u32, pub facts: alloc::vec::Vec, + pub defer_delivery: bool, + pub undelivered: alloc::vec::Vec, } impl LifecycleState { @@ -177,14 +181,19 @@ impl LifecycleState { since_unix_epoch: time.since_unix_epoch, kind: kind.clone(), }); - if let Some(sender) = &self.sender { - let _ = sender.send(DialogLifecycleEvent { + if self.sender.is_some() { + let event = DialogLifecycleEvent { dialog_id: id, role, sequence: self.sequence, occurred_at: time, kind, - }); + }; + if self.defer_delivery { + self.undelivered.push(event); + } else if let Some(sender) = &self.sender { + let _ = sender.send(event); + } } } } diff --git a/src/dialog/mod.rs b/src/dialog/mod.rs index fe4dffd5..f0b71f94 100644 --- a/src/dialog/mod.rs +++ b/src/dialog/mod.rs @@ -12,6 +12,7 @@ pub mod dialog_layer; pub mod invitation; pub mod invite_dialog; pub mod lifecycle; +pub mod persistence; pub mod publication; pub mod registration; pub mod reinvite; diff --git a/src/dialog/persistence.rs b/src/dialog/persistence.rs new file mode 100644 index 00000000..55c42528 --- /dev/null +++ b/src/dialog/persistence.rs @@ -0,0 +1,297 @@ +//! Opt-in durable checkpoints. Storage remains application-owned. +//! +//! Each dialog has one serial worker. A callback runs without a dialog state +//! lock and may inspect snapshots. It must not await another SIP operation on +//! the same dialog: that operation would wait behind this callback. +//! +//! Returning `Ok(())` promises the application has durably committed the supplied +//! snapshot and any related application state. No serialization or database is +//! chosen by the stack. Applications choose which message fields to serialize; +//! SIP messages may include authentication headers. Media policy remains external. +//! +//! Failure or timeout poisons this dialog's persistence worker. No subsequent +//! protected sends are permitted. A timeout cannot undo a database write that +//! has already started; recovery must inspect storage. Ordinary lifecycle events +//! are released only after the checkpoint covering them succeeds. The legacy +//! `DialogState` channel is still a protocol channel, not a durable commit feed. +//! +//! Enable this explicitly before creating or restoring calls: +//! +//! ```rust,no_run +//! use std::sync::Arc; +//! use rsipstack::dialog::{dialog_layer::DialogLayer, persistence::*}; +//! # fn configure(layer: &DialogLayer, store: Arc) -> rsipstack::Result<()> { +//! layer.set_persistence(Some(DialogPersistenceConfig::new(store)))?; +//! # Ok(()) +//! # } +//! ``` +//! +//! Protected boundaries are the first outgoing request of each dialog-owned +//! transaction (including authentication retries), an incoming final response +//! before its ACK, a locally generated final response before transport send, +//! local termination intent, and completed signaling/terminal state. A wire +//! response and its later acknowledgment are separate checkpoints. Provisional +//! responses and transaction-generated CANCEL acknowledgments do not wait for +//! storage. Pure transaction/proxy users are unaffected. +//! +//! A commit cannot be atomic with network transmission. A crash after commit +//! but before send leaves an intended message with an unknown send outcome. +//! Recovery must use the pending markers and application policy; the stack does +//! not replay in-flight transactions. A successful `accept()`/`reject()` only +//! queues a response: the transaction driver performs its checkpoint. Errors +//! from asynchronous/terminal writes are exposed by `persistence_status()`. +//! After failure, remove the dialog from the layer and reconcile stored state; +//! there is no automatic retry or fail-open mode. The application must keep its +//! async runtime alive long enough to finish accepted writes during shutdown. +//! +//! Handlers must yield rather than block an executor, and must not panic. Use +//! an application-owned incarnation key alongside dialog ID/revision for +//! snapshot idempotency across process restarts. Multiple checkpoints may share +//! a revision: it versions dialog state, not a storage operation. Deduplicate +//! message-related work with its own request/operation identity as well. +//! A new lifecycle notification is not an +//! exactly-once external side effect; persist an application outbox if needed. +//! Early checkpoints may have an empty remote tag; correlate them with the +//! later established dialog using that same application call/incarnation key. + +use super::{ + dialog::{DialogInner, DialogSnapshot}, + lifecycle::DialogLifecycleEvent, +}; +use crate::{ + platform::{mpsc, sync::Mutex}, + prelude::*, + sip::SipMessage, +}; +use alloc::sync::Weak; +use async_trait::async_trait; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +#[non_exhaustive] +pub enum DialogCheckpointReason { + /// Before the first send of a transaction, including authenticated retries. + OutgoingRequest, + /// Local hangup/cancellation intent, before waiting for an ACK or peer. + LocalTerminationRequested, + /// Before sending a final response to an incoming request. + BeforeResponse, + /// A successful INVITE response was received; before its automatic ACK. + /// Includes re-INVITEs and fork cleanup; lifecycle facts identify initial acceptance. + BeforeAck, + /// A completed ACK/negotiation permits future quiescent restoration. + SignalingCompleted, + /// The dialog ended, including local rejection and protocol timeout. + Terminated, +} + +#[derive(Clone, Debug)] +#[non_exhaustive] +pub struct DialogCheckpoint { + pub reason: DialogCheckpointReason, + pub snapshot: DialogSnapshot, + /// Intended or observed SIP message, when the checkpoint protects a send. + /// This lets the application commit its SDP or request metadata atomically. + pub message: Option, +} + +#[async_trait] +pub trait DialogPersistence: Send + Sync { + async fn save(&self, checkpoint: DialogCheckpoint) -> crate::Result<()>; +} + +#[derive(Clone)] +pub struct DialogPersistenceConfig { + pub handler: Arc, + pub timeout: Duration, +} + +impl DialogPersistenceConfig { + pub fn new(handler: Arc) -> Self { + Self { + handler, + timeout: Duration::from_secs(5), + } + } + + pub(crate) fn validate(&self) -> crate::Result<()> { + if self.timeout.is_zero() { + return Err(crate::Error::Error( + "persistence timeout must be positive".into(), + )); + } + Ok(()) + } +} + +#[derive(Clone, Debug, Default)] +#[non_exhaustive] +pub struct DialogPersistenceStatus { + pub last_committed_revision: Option, + pub failure: Option, +} + +type CommitResult = core::result::Result<(), String>; +pub(crate) type CommitReceiver = mpsc::UnboundedReceiver; + +struct Work { + checkpoint: DialogCheckpoint, + reply: mpsc::UnboundedSender, +} + +pub(crate) struct PersistenceRuntime { + sender: mpsc::UnboundedSender>, + pub status: Arc>, +} + +impl PersistenceRuntime { + #[cfg_attr(not(feature = "platform-tokio"), allow(unused_mut))] + pub fn start(dialog: Weak, config: DialogPersistenceConfig) -> Arc { + let (sender, mut receiver) = mpsc::unbounded_channel::>(); + let status = Arc::new(Mutex::new(DialogPersistenceStatus::default())); + let worker_status = status.clone(); + // The worker never owns a strong dialog reference while awaiting storage. + // Dropping the dialog queues a stop marker; pending writes have finite timeouts. + crate::platform::spawn(async move { + while let Some(Some(work)) = receiver.recv().await { + let revision = work.checkpoint.snapshot.runtime.revision; + let sequence = work + .checkpoint + .snapshot + .runtime + .lifecycle + .last() + .map_or(0, |fact| fact.sequence); + let previous = worker_status.lock().clone(); + let result = if let Some(error) = previous.failure { + Err(error) + } else if previous + .last_committed_revision + .is_some_and(|r| r > revision) + { + Err("checkpoint revision moved backwards".into()) + } else if work.checkpoint.reason == DialogCheckpointReason::Terminated + && previous.last_committed_revision == Some(revision) + { + Ok(()) + } else { + match crate::platform::timeout( + config.timeout, + config.handler.save(work.checkpoint), + ) + .await + { + Ok(Ok(())) => Ok(()), + Ok(Err(error)) => Err(format!("dialog persistence failed: {error}")), + Err(_) => { + Err("dialog persistence timed out; commit outcome is unknown".into()) + } + } + }; + match &result { + Ok(()) => { + worker_status.lock().last_committed_revision = Some(revision); + if let Some(dialog) = dialog.upgrade() { + dialog.release_committed_facts(sequence); + } + } + Err(error) => { + worker_status.lock().failure = Some(error.clone()); + tracing::warn!(%error, revision, "dialog persistence stopped"); + } + } + let _ = work.reply.send(result); + } + }); + Arc::new(Self { sender, status }) + } + + /// Enqueue while the snapshot gate is held; user code runs in the worker. + pub fn submit(&self, checkpoint: DialogCheckpoint) -> CommitReceiver { + let (reply, receiver) = mpsc::unbounded_channel(); + if let Some(error) = self.status.lock().failure.clone() { + let _ = reply.send(Err(error)); + return receiver; + } + if let Err(error) = self.sender.send(Some(Work { checkpoint, reply })) { + if let Some(work) = error.0 { + let _ = work + .reply + .send(Err("dialog persistence worker stopped".into())); + } + } + receiver + } +} + +impl DialogInner { + pub(crate) fn configure_persistence(self: &Arc, config: Option) { + if let Some(config) = config { + *self.persistence_owner.lock() = Arc::downgrade(self); + self.lifecycle.lock().defer_delivery = true; + *self.persistence.lock() = + Some(PersistenceRuntime::start(Arc::downgrade(self), config)); + } + } + + pub(crate) fn bind_persistence(&self, tx: &crate::transaction::transaction::Transaction) { + *tx.persistence_dialog.lock() = self.persistence_owner.lock().clone(); + } + + pub(crate) fn release_committed_facts(&self, sequence: u64) { + let _state = self.state.lock(); + let mut lifecycle = self.lifecycle.lock(); + let mut waiting: Vec = Vec::new(); + for event in core::mem::take(&mut lifecycle.undelivered) { + if event.sequence <= sequence { + if let Some(sender) = &lifecycle.sender { + let _ = sender.send(event); + } + } else { + waiting.push(event); + } + } + lifecycle.undelivered = waiting; + } + + #[cfg_attr(not(feature = "platform-tokio"), allow(unused_mut))] + pub(crate) async fn checkpoint( + &self, + reason: DialogCheckpointReason, + message: Option, + ) -> crate::Result<()> { + let receiver = { + let state = self.state.lock(); + self.enqueue_checkpoint_locked(&state, reason, message) + }; + if let Some(mut receiver) = receiver { + receiver + .recv() + .await + .unwrap_or_else(|| Err("dialog persistence worker stopped".into())) + .map_err(crate::Error::Error)?; + } + Ok(()) + } + + pub(crate) fn enqueue_checkpoint_locked( + &self, + state: &super::dialog::DialogState, + reason: DialogCheckpointReason, + message: Option, + ) -> Option { + let runtime = self.persistence.lock().clone()?; + Some(runtime.submit(DialogCheckpoint { + reason, + snapshot: self.snapshot_locked(state), + message, + })) + } +} + +impl Drop for PersistenceRuntime { + fn drop(&mut self) { + // Also works on runtimes whose channels do not close on last-sender drop. + // FIFO drains already accepted writes before stopping the worker. + let _ = self.sender.send(None); + } +} diff --git a/src/dialog/server_dialog.rs b/src/dialog/server_dialog.rs index 821ecd32..fbb123d2 100644 --- a/src/dialog/server_dialog.rs +++ b/src/dialog/server_dialog.rs @@ -653,6 +653,7 @@ impl ServerInviteDialog { /// * `UPDATE` - Handles session updates /// * `INVITE` - Handles initial INVITE or re-INVITE pub async fn handle(&mut self, tx: &mut Transaction) -> Result<()> { + self.inner.bind_persistence(tx); debug!( id = %self.id(), method = %tx.original.method, @@ -853,6 +854,12 @@ impl ServerInviteDialog { self.inner.begin_negotiation(); let result = self.inner.process_reinvite(tx, true).await; self.inner.finish_negotiation(); + self.inner + .checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; result } @@ -895,8 +902,15 @@ impl ServerInviteDialog { SipMessage::Response(_) => {} } } + tx.check_persistence()?; let answered_2xx = self.inner.waiting_ack(); self.inner.end_session_without_ack(tx, answered_2xx).await; + self.inner + .checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; Ok::<(), crate::Error>(()) }; match handle_loop.await { diff --git a/src/dialog/tests/mod.rs b/src/dialog/tests/mod.rs index f30db8a0..b39813bf 100644 --- a/src/dialog/tests/mod.rs +++ b/src/dialog/tests/mod.rs @@ -13,6 +13,7 @@ mod test_in_dialog_provisional; mod test_in_dialog_via; mod test_invite_auth_challenge; mod test_invite_overlap; +mod test_persistence; mod test_prack; mod test_proxy_headers; mod test_refer; diff --git a/src/dialog/tests/test_persistence.rs b/src/dialog/tests/test_persistence.rs new file mode 100644 index 00000000..14d19952 --- /dev/null +++ b/src/dialog/tests/test_persistence.rs @@ -0,0 +1,630 @@ +//! Wire-level checks for storage barriers, failures, and teardown races. +use crate::dialog::{ + dialog::DialogStateReceiver, + dialog_layer::DialogLayer, + invitation::{InviteAsyncResult, InviteOption}, + invite_dialog::InviteDialog, + lifecycle::{dialog_lifecycle_channel, DialogLifecycleKind, DialogLifecycleReceiver}, + persistence::{ + DialogCheckpoint, DialogCheckpointReason as Reason, DialogPersistence, + DialogPersistenceConfig, + }, +}; +use crate::sip::{prelude::HeadersExt, Method, Request, SipMessage, StatusCode, Uri}; +use crate::transport::{udp::UdpConnection, TransportLayer}; +use crate::EndpointBuilder; +use async_trait::async_trait; +use std::{ + sync::{ + atomic::{AtomicBool, AtomicUsize, Ordering}, + Arc, Mutex, + }, + time::Duration, +}; +use tokio::{net::UdpSocket, sync::mpsc::unbounded_channel, task::JoinHandle}; +use tokio_util::sync::CancellationToken; + +#[derive(Clone, Copy, PartialEq, Eq)] +enum Gate { + Never, + InitialRequest, + Answer, + ByeResponse, + UasResponse, + Info, +} + +struct Storage { + gate: Gate, + entered: CancellationToken, + release: CancellationToken, + fail: AtomicBool, + committed: Mutex>, + attempts: Mutex>, + inspecting: Mutex>>, + active: AtomicUsize, + max_active: AtomicUsize, +} + +impl Storage { + fn new(gate: Gate) -> Arc { + Arc::new(Self { + gate, + entered: CancellationToken::new(), + release: CancellationToken::new(), + fail: AtomicBool::new(false), + committed: Mutex::new(Vec::new()), + attempts: Mutex::new(Vec::new()), + inspecting: Mutex::new(None), + active: AtomicUsize::new(0), + max_active: AtomicUsize::new(0), + }) + } + fn matches(&self, c: &DialogCheckpoint) -> bool { + match self.gate { + Gate::Never => false, + Gate::InitialRequest => { + c.reason == Reason::OutgoingRequest + && matches!(&c.message, Some(SipMessage::Request(r)) if r.method == Method::Invite) + } + Gate::Answer => c.reason == Reason::BeforeAck, + Gate::ByeResponse => { + c.reason == Reason::BeforeResponse + && matches!(&c.message, Some(SipMessage::Response(r)) if r.cseq_header().unwrap().method().unwrap() == Method::Bye) + } + Gate::UasResponse => { + c.reason == Reason::BeforeResponse + && matches!(&c.message, Some(SipMessage::Response(r)) if r.status_code == StatusCode::OK && r.cseq_header().unwrap().method().unwrap() == Method::Invite) + } + Gate::Info => { + c.reason == Reason::OutgoingRequest + && matches!(&c.message, Some(SipMessage::Request(r)) if r.method == Method::Info) + } + } + } + fn config(self: &Arc, timeout: Duration) -> DialogPersistenceConfig { + DialogPersistenceConfig { + handler: self.clone(), + timeout, + } + } +} + +struct Active<'a>(&'a AtomicUsize); +impl Drop for Active<'_> { + fn drop(&mut self) { + self.0.fetch_sub(1, Ordering::SeqCst); + } +} + +#[async_trait] +impl DialogPersistence for Storage { + async fn save(&self, c: DialogCheckpoint) -> crate::Result<()> { + let active = self.active.fetch_add(1, Ordering::SeqCst) + 1; + let _active = Active(&self.active); + self.max_active.fetch_max(active, Ordering::SeqCst); + let inspect = self + .inspecting + .lock() + .unwrap() + .as_ref() + .and_then(std::sync::Weak::upgrade); + if let Some(dialog) = inspect { + // A callback must be able to inspect the dialog: no state lock is held. + assert!(dialog.snapshot().runtime.revision >= c.snapshot.runtime.revision); + } + self.attempts.lock().unwrap().push(c.clone()); + if self.matches(&c) { + self.entered.cancel(); + self.release.cancelled().await; + } + if self.fail.load(Ordering::SeqCst) { + return Err(crate::Error::Error("test storage failure".into())); + } + self.committed.lock().unwrap().push(c); + Ok(()) + } +} + +struct Call { + peer: UdpSocket, + local: std::net::SocketAddr, + dialog: InviteDialog, + facts: DialogLifecycleReceiver, + _states: DialogStateReceiver, + task: JoinHandle, + router: JoinHandle<()>, + endpoint: JoinHandle>, + stop: CancellationToken, +} + +impl Drop for Call { + fn drop(&mut self) { + self.stop.cancel(); + self.task.abort(); + self.router.abort(); + self.endpoint.abort(); + } +} + +async fn start(storage: Arc, timeout: Duration) -> crate::Result { + let stop = CancellationToken::new(); + let transport = TransportLayer::new(stop.child_token()); + let udp = + UdpConnection::create_connection("127.0.0.1:0".parse()?, None, Some(stop.child_token())) + .await?; + let local = udp.get_addr().get_socketaddr()?; + transport.add_transport(udp.into()); + let endpoint = EndpointBuilder::new() + .with_transport_layer(transport) + .with_cancel_token(stop.child_token()) + .build(); + let layer = Arc::new(DialogLayer::new(endpoint.inner.clone())); + let (sender, facts) = dialog_lifecycle_channel(); + layer.set_lifecycle_events(Some(sender)); + layer.set_persistence(Some(storage.config(timeout)))?; + let mut incoming = endpoint.incoming_transactions()?; + let endpoint_ref = endpoint.inner.clone(); + let endpoint = tokio::spawn(async move { endpoint_ref.serve().await }); + let routing = layer.clone(); + let router = tokio::spawn(async move { + while let Some(mut tx) = incoming.recv().await { + if let Some(mut dialog) = routing.match_dialog(&tx) { + let _ = dialog.handle(&mut tx).await; + } else { + let _ = tx.reply(StatusCode::CallTransactionDoesNotExist).await; + } + } + }); + let peer = UdpSocket::bind("127.0.0.1:0").await?; + let option = InviteOption { + caller: Uri::try_from("sip:alice@example.com")?, + callee: Uri::try_from(format!("sip:bob@{}", peer.local_addr()?).as_str())?, + contact: Uri::try_from(format!("sip:alice@{local}").as_str())?, + ..Default::default() + }; + let (sender, states) = unbounded_channel(); + let (dialog, task) = layer.do_invite_async(option, sender)?; + *storage.inspecting.lock().unwrap() = Some(Arc::downgrade(&dialog.inner)); + Ok(Call { + peer, + local, + dialog, + facts, + _states: states, + task, + router, + endpoint, + stop, + }) +} + +async fn receive(peer: &UdpSocket) -> SipMessage { + let mut bytes = [0u8; 8192]; + let (len, _) = tokio::time::timeout(Duration::from_secs(2), peer.recv_from(&mut bytes)) + .await + .expect("SIP receive timeout") + .unwrap(); + SipMessage::try_from(&bytes[..len]).unwrap() +} + +async fn request(peer: &UdpSocket, method: Method) -> Request { + let SipMessage::Request(r) = receive(peer).await else { + panic!("expected request") + }; + assert_eq!(r.method, method); + r +} + +fn response(request: &Request, contact: &str) -> String { + let to = request.to_header().unwrap(); + let to = if to.tag().unwrap().is_some() { + to.value().to_string() + } else { + format!("{};tag=peer", to.value()) + }; + format!("SIP/2.0 200 OK\r\nVia: {}\r\nFrom: {}\r\nTo: {to}\r\nCall-ID: {}\r\nCSeq: {}\r\nContact: <{contact}>\r\nContent-Length: 0\r\n\r\n", + request.via_header().unwrap().value(), request.from_header().unwrap().value(), request.call_id_header().unwrap().value(), request.cseq_header().unwrap().value()) +} + +async fn answer(call: &Call, invite: &Request) { + call.peer + .send_to( + response( + invite, + &format!("sip:bob@{}", call.peer.local_addr().unwrap()), + ) + .as_bytes(), + call.local, + ) + .await + .unwrap(); +} + +async fn established(call: &mut Call) -> Request { + let invite = request(&call.peer, Method::Invite).await; + answer(call, &invite).await; + request(&call.peer, Method::Ack).await; + tokio::time::timeout(Duration::from_secs(2), &mut call.task) + .await + .unwrap() + .unwrap() + .unwrap(); + invite +} + +async fn send_bye(call: &Call, invite: &Request, seq: u32) -> Vec { + let bytes = format!("BYE sip:alice@{} SIP/2.0\r\nVia: SIP/2.0/UDP {};branch=z9hG4bK-peer-bye{seq}\r\nFrom: ;tag=peer\r\nTo: {}\r\nCall-ID: {}\r\nCSeq: {seq} BYE\r\nMax-Forwards: 70\r\nContent-Length: 0\r\n\r\n", + call.local, call.peer.local_addr().unwrap(), invite.from_header().unwrap().value(), invite.call_id_header().unwrap().value()).into_bytes(); + call.peer.send_to(&bytes, call.local).await.unwrap(); + bytes +} + +async fn silent(peer: &UdpSocket) { + let mut bytes = [0u8; 8192]; + assert!( + tokio::time::timeout(Duration::from_millis(40), peer.recv_from(&mut bytes)) + .await + .is_err(), + "SIP escaped the persistence barrier" + ); +} + +async fn entered(store: &Storage) { + tokio::time::timeout(Duration::from_secs(2), store.entered.cancelled()) + .await + .unwrap(); +} + +#[tokio::test] +async fn persistence_initial_invite_waits_for_durable_write() -> crate::Result<()> { + let store = Storage::new(Gate::InitialRequest); + let call = start(store.clone(), Duration::from_secs(2)).await?; + entered(&store).await; + silent(&call.peer).await; + store.release.cancel(); + let invite = request(&call.peer, Method::Invite).await; + let saved = store.committed.lock().unwrap(); + assert_eq!(saved[0].snapshot.local_cseq, invite.cseq_header()?.seq()?); + assert_eq!(store.max_active.load(Ordering::SeqCst), 1); + Ok(()) +} + +#[tokio::test] +async fn persistence_failed_initial_write_sends_nothing() -> crate::Result<()> { + let store = Storage::new(Gate::Never); + store.fail.store(true, Ordering::SeqCst); + let mut call = start(store, Duration::from_secs(1)).await?; + assert!(tokio::time::timeout(Duration::from_secs(2), &mut call.task) + .await + .unwrap() + .unwrap() + .is_err()); + silent(&call.peer).await; + assert!(call.dialog.persistence_status().unwrap().failure.is_some()); + Ok(()) +} + +#[tokio::test] +async fn persistence_timeout_poisoning_is_bounded() -> crate::Result<()> { + let store = Storage::new(Gate::InitialRequest); + let mut call = start(store.clone(), Duration::from_millis(30)).await?; + assert!(tokio::time::timeout(Duration::from_secs(1), &mut call.task) + .await + .unwrap() + .unwrap() + .is_err()); + silent(&call.peer).await; + store.release.cancel(); + assert_eq!(store.active.load(Ordering::SeqCst), 0); + assert!(call + .dialog + .persistence_status() + .unwrap() + .failure + .unwrap() + .contains("timed out")); + Ok(()) +} + +#[tokio::test] +async fn persistence_answer_waits_before_ack_and_fact_delivery() -> crate::Result<()> { + let store = Storage::new(Gate::Answer); + let mut call = start(store.clone(), Duration::from_secs(2)).await?; + let invite = request(&call.peer, Method::Invite).await; + answer(&call, &invite).await; + entered(&store).await; + assert!(call.dialog.state().is_confirmed()); + assert!(call.dialog.snapshot().runtime.pending.initial_ack); + assert!(call.facts.try_recv().is_err()); + silent(&call.peer).await; + let original_time = call.dialog.snapshot().runtime.lifecycle[0].since_unix_epoch; + store.release.cancel(); + request(&call.peer, Method::Ack).await; + let fact = tokio::time::timeout(Duration::from_secs(1), call.facts.recv()) + .await + .unwrap() + .unwrap(); + assert!(matches!( + fact.kind, + DialogLifecycleKind::InviteAccepted { .. } + )); + assert_eq!(fact.occurred_at.since_unix_epoch, original_time); + Ok(()) +} + +#[tokio::test] +async fn persistence_bye_during_answer_commit_keeps_original_facts() -> crate::Result<()> { + let store = Storage::new(Gate::Answer); + let mut call = start(store.clone(), Duration::from_secs(2)).await?; + let invite = request(&call.peer, Method::Invite).await; + answer(&call, &invite).await; + entered(&store).await; + send_bye(&call, &invite, 2).await; + tokio::time::timeout(Duration::from_secs(1), async { + while !call.dialog.state().is_terminated() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + let before = call.dialog.snapshot(); + assert_eq!(before.runtime.lifecycle.len(), 3); + assert!(call.facts.try_recv().is_err()); + silent(&call.peer).await; + store.release.cancel(); + let messages = [receive(&call.peer).await, receive(&call.peer).await]; + assert!(messages + .iter() + .any(|m| matches!(m, SipMessage::Request(r) if r.method == Method::Ack))); + assert!(messages + .iter() + .any(|m| matches!(m, SipMessage::Response(r) if r.status_code == StatusCode::OK))); + for expected in 1..=3 { + let fact = tokio::time::timeout(Duration::from_secs(1), call.facts.recv()) + .await + .unwrap() + .unwrap(); + assert_eq!(fact.sequence, expected); + assert_eq!( + fact.occurred_at.since_unix_epoch, + before.runtime.lifecycle[(expected - 1) as usize].since_unix_epoch + ); + } + assert_eq!(store.max_active.load(Ordering::SeqCst), 1); + let revisions: Vec<_> = store + .committed + .lock() + .unwrap() + .iter() + .map(|c| c.snapshot.runtime.revision) + .collect(); + assert!(revisions.windows(2).all(|w| w[0] <= w[1])); + Ok(()) +} + +#[tokio::test] +async fn persistence_failed_answer_commit_returns_without_ack() -> crate::Result<()> { + let store = Storage::new(Gate::Answer); + let mut call = start(store.clone(), Duration::from_secs(2)).await?; + let invite = request(&call.peer, Method::Invite).await; + answer(&call, &invite).await; + entered(&store).await; + store.fail.store(true, Ordering::SeqCst); + store.release.cancel(); + assert!(tokio::time::timeout(Duration::from_secs(1), &mut call.task) + .await + .unwrap() + .unwrap() + .is_err()); + silent(&call.peer).await; + answer(&call, &invite).await; + silent(&call.peer).await; + assert!(call.facts.try_recv().is_err()); + Ok(()) +} + +#[tokio::test] +async fn persistence_failed_bye_response_is_not_cached_for_retransmit() -> crate::Result<()> { + let store = Storage::new(Gate::ByeResponse); + let mut call = start(store.clone(), Duration::from_secs(2)).await?; + let invite = established(&mut call).await; + let bye = send_bye(&call, &invite, 2).await; + entered(&store).await; + silent(&call.peer).await; + store.fail.store(true, Ordering::SeqCst); + store.release.cancel(); + tokio::time::timeout(Duration::from_secs(1), async { + while call.dialog.persistence_status().unwrap().failure.is_none() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + call.peer.send_to(&bye, call.local).await?; + silent(&call.peer).await; + Ok(()) +} + +#[tokio::test] +async fn persistence_concurrent_requests_commit_reserved_cseq_before_send() -> crate::Result<()> { + let store = Storage::new(Gate::Info); + let mut call = start(store.clone(), Duration::from_secs(2)).await?; + established(&mut call).await; + let first = call.dialog.clone(); + let second = call.dialog.clone(); + let a = tokio::spawn(async move { first.info(None, None).await }); + let b = tokio::spawn(async move { second.info(None, None).await }); + entered(&store).await; + silent(&call.peer).await; + store.release.cancel(); + let one = request(&call.peer, Method::Info).await; + let two = request(&call.peer, Method::Info).await; + assert_ne!(one.cseq_header()?.seq()?, two.cseq_header()?.seq()?); + for req in [one, two] { + let seq = req.cseq_header()?.seq()?; + assert!(store.committed.lock().unwrap().iter().any(|c| c.reason == Reason::OutgoingRequest + && c.snapshot.local_cseq >= seq && matches!(&c.message, Some(SipMessage::Request(r)) if r.cseq_header().unwrap().seq().unwrap() == seq))); + call.peer + .send_to(response(&req, "sip:bob@example.com").as_bytes(), call.local) + .await?; + } + tokio::time::timeout(Duration::from_secs(1), a) + .await + .unwrap() + .unwrap()?; + tokio::time::timeout(Duration::from_secs(1), b) + .await + .unwrap() + .unwrap()?; + assert_eq!(store.max_active.load(Ordering::SeqCst), 1); + Ok(()) +} + +#[tokio::test] +async fn persistence_worker_releases_dialog_and_handler_after_teardown() -> crate::Result<()> { + use crate::dialog::dialog::DialogInner; + use crate::dialog::DialogId; + use crate::transaction::key::TransactionRole; + // Isolate worker ownership from the INVITE Accepted transaction's Timer M. + // That transaction intentionally retains its dialog to clean up forked 2xx. + let store = Storage::new(Gate::Never); + let req = super::test_dialog_states::create_invite_request("alice", "bob", "worker"); + let (states, _) = unbounded_channel(); + let (transactions, _) = unbounded_channel(); + let dialog = Arc::new(DialogInner::new( + TransactionRole::Client, + DialogId::try_from((&req, TransactionRole::Client))?, + req, + EndpointBuilder::new().build().inner, + states, + None, + None, + transactions, + )?); + dialog.configure_persistence(Some(store.config(Duration::from_secs(1)))); + dialog.checkpoint(Reason::SignalingCompleted, None).await?; + let weak = Arc::downgrade(&dialog); + drop(dialog); + tokio::time::timeout(Duration::from_secs(1), async { + while weak.upgrade().is_some() || Arc::strong_count(&store) != 1 { + tokio::task::yield_now().await; + } + }) + .await + .expect("persistence worker retained a dialog or storage handler"); + Ok(()) +} + +#[tokio::test] +async fn persistence_uas_saves_before_200_and_after_ack() -> crate::Result<()> { + let stop = CancellationToken::new(); + let (dialog, mut tx, _states, peer) = + super::test_accept_before_handle::incoming_invite(&stop).await?; + let store = Storage::new(Gate::UasResponse); + dialog + .inner + .configure_persistence(Some(store.config(Duration::from_secs(2)))); + let (sender, mut facts) = dialog_lifecycle_channel(); + dialog.inner.lifecycle.lock().sender = Some(sender); + let invite = tx.original.clone(); + let destination = crate::transport::SipAddr::try_from(&invite.uri)?.get_socketaddr()?; + dialog.accept(None, None)?; + let mut handler = dialog.clone(); + let task = tokio::spawn(async move { handler.handle(&mut tx).await }); + entered(&store).await; + silent(&peer).await; + assert!(facts.try_recv().is_err()); + store.release.cancel(); + let SipMessage::Response(response) = receive(&peer).await else { + panic!("expected 200") + }; + assert_eq!(response.status_code, StatusCode::OK); + let event = tokio::time::timeout(Duration::from_secs(1), facts.recv()) + .await + .unwrap() + .unwrap(); + assert!(matches!( + event.kind, + DialogLifecycleKind::InviteAccepted { .. } + )); + let ack = format!("ACK {} SIP/2.0\r\nVia: SIP/2.0/UDP {};branch=z9hG4bK-ack\r\nFrom: {}\r\nTo: {}\r\nCall-ID: {}\r\nCSeq: 1 ACK\r\nMax-Forwards: 70\r\nContent-Length: 0\r\n\r\n", + invite.uri, peer.local_addr()?, response.from_header()?.value(), response.to_header()?.value(), response.call_id_header()?.value()); + peer.send_to(ack.as_bytes(), destination).await?; + tokio::time::timeout(Duration::from_secs(1), task) + .await + .unwrap() + .unwrap()?; + let committed = store.committed.lock().unwrap(); + assert!(committed.last().unwrap().snapshot.is_quiescent()); + assert_eq!( + committed.last().unwrap().snapshot.runtime.lifecycle.len(), + 1 + ); + assert!(committed + .iter() + .any(|c| c.reason == Reason::BeforeResponse && !c.snapshot.is_quiescent())); + stop.cancel(); + Ok(()) +} + +#[tokio::test] +async fn persistence_uas_failed_write_never_sends_or_caches_200() -> crate::Result<()> { + let stop = CancellationToken::new(); + let (dialog, mut tx, _states, peer) = + super::test_accept_before_handle::incoming_invite(&stop).await?; + let store = Storage::new(Gate::UasResponse); + dialog + .inner + .configure_persistence(Some(store.config(Duration::from_secs(2)))); + dialog.accept(None, None)?; + let mut handler = dialog.clone(); + let task = tokio::spawn(async move { + let result = handler.handle(&mut tx).await; + (result, tx.last_response.take()) + }); + entered(&store).await; + store.fail.store(true, Ordering::SeqCst); + store.release.cancel(); + let (result, last_response) = tokio::time::timeout(Duration::from_secs(1), task) + .await + .unwrap() + .unwrap(); + assert!(result.is_err()); + assert!(last_response.is_none()); + silent(&peer).await; + assert!(dialog.snapshot().runtime.lifecycle.is_empty()); + stop.cancel(); + Ok(()) +} + +#[tokio::test] +async fn persistence_request_is_not_sent_if_peer_ends_during_commit() -> crate::Result<()> { + let store = Storage::new(Gate::Info); + let mut call = start(store.clone(), Duration::from_secs(2)).await?; + let invite = established(&mut call).await; + let dialog = call.dialog.clone(); + let task = tokio::spawn(async move { dialog.info(None, None).await }); + entered(&store).await; + send_bye(&call, &invite, 2).await; + tokio::time::timeout(Duration::from_secs(1), async { + while !call.dialog.state().is_terminated() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + store.release.cancel(); + assert!(tokio::time::timeout(Duration::from_secs(1), task) + .await + .unwrap() + .unwrap() + .is_err()); + let SipMessage::Response(response) = receive(&call.peer).await else { + panic!("expected BYE response") + }; + assert_eq!(response.status_code, StatusCode::OK); + assert_eq!(response.cseq_header()?.method()?, Method::Bye); + silent(&call.peer).await; + Ok(()) +} diff --git a/src/transaction/transaction.rs b/src/transaction/transaction.rs index dfd46ead..ccb03635 100644 --- a/src/transaction/transaction.rs +++ b/src/transaction/transaction.rs @@ -188,6 +188,8 @@ pub struct Transaction { pub timer_g: Option, // server invite only (non-2xx final response retransmits per RFC 6026 §7.1) pub timer_l: Option, // server invite only (Accepted-state 64*T1 per RFC 6026 §7.1) pub timer_m: Option, // client invite only (Accepted-state 64*T1 per RFC 6026 §7.2) + pub(crate) persistence_dialog: Mutex>, + persistence_sent: bool, pub(crate) original_received_at: Option, receipt_times: Option>, last_received_at: Option, @@ -233,6 +235,8 @@ impl Transaction { timer_d: None, timer_k: None, timer_g: None, + persistence_dialog: Mutex::new(alloc::sync::Weak::new()), + persistence_sent: false, original_received_at: None, receipt_times: None, last_received_at: None, @@ -250,6 +254,19 @@ impl Transaction { tx } + pub(crate) fn check_persistence(&self) -> Result<()> { + let dialog = self.persistence_dialog.lock().upgrade(); + if let Some(dialog) = dialog { + let runtime = dialog.persistence.lock().clone(); + if let Some(runtime) = runtime { + if let Some(error) = runtime.status.lock().failure.clone() { + return Err(Error::Error(error)); + } + } + } + Ok(()) + } + pub(crate) fn track_receipt_times(&mut self, enabled: bool) { if enabled && self.receipt_times.is_none() { let receipts = Arc::new(super::receipt::ReceiptTimes::default()); @@ -306,6 +323,30 @@ impl Transaction { } // send client request pub async fn send(&mut self) -> Result<()> { + self.check_persistence()?; + if !self.persistence_sent { + let dialog = self.persistence_dialog.lock().upgrade(); + if let Some(dialog) = dialog { + dialog + .checkpoint( + crate::dialog::persistence::DialogCheckpointReason::OutgoingRequest, + Some(self.original.clone().into()), + ) + .await?; + if dialog.is_terminated() + && !matches!( + self.original.method, + Method::Bye | Method::Cancel | Method::Ack + ) + && self.original.to_header()?.tag()?.is_some() + { + return Err(Error::Error( + "dialog terminated while saving request".into(), + )); + } + } + self.persistence_sent = true; + } match self.transaction_type { TransactionType::ClientInvite | TransactionType::ClientNonInvite => {} _ => { @@ -500,6 +541,7 @@ impl Transaction { /// is acceptable. Prefer the `TransactionEvent::Respond` channel for /// cancellation-aware integration. pub async fn respond(&mut self, response: Response) -> Result<()> { + self.check_persistence()?; match self.transaction_type { TransactionType::ServerInvite | TransactionType::ServerNonInvite => {} _ => { @@ -550,6 +592,17 @@ impl Transaction { } else { response.to_owned().into() }; + if new_state != TransactionState::Trying && new_state != TransactionState::Proceeding { + let dialog = self.persistence_dialog.lock().upgrade(); + if let Some(dialog) = dialog { + dialog + .checkpoint( + crate::dialog::persistence::DialogCheckpointReason::BeforeResponse, + Some(response.clone()), + ) + .await?; + } + } trace!(key = %self.key, response = %response, "responding"); match response.clone() { @@ -598,7 +651,23 @@ impl Transaction { } } guard.0 = None; - self.transition(new_state).map(|_| ()) + let final_response = !matches!( + new_state, + TransactionState::Trying | TransactionState::Proceeding + ); + self.transition(new_state)?; + if final_response { + let dialog = self.persistence_dialog.lock().upgrade(); + if let Some(dialog) = dialog { + dialog + .checkpoint( + crate::dialog::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; + } + } + Ok(()) } fn add_ack_cseq_route(&self, dialog_id: &DialogId) -> Option<(DialogId, u32)> { @@ -713,6 +782,7 @@ impl Transaction { /// inappropriate retransmits. Do not place inside `tokio::select!` /// unless this hazard is acceptable. pub async fn send_ack(&mut self, mut connection: Option) -> Result<()> { + self.check_persistence()?; if self.transaction_type != TransactionType::ClientInvite { return Err(Error::TransactionError( "send_ack is only valid for client invite transactions".to_string(), @@ -804,6 +874,7 @@ impl Transaction { ack.to_owned().into() }; + self.check_persistence()?; match ack.clone() { SipMessage::Request(ref ack_req) => self.last_ack.replace(ack_req.clone()), _ => None, @@ -889,10 +960,16 @@ impl Transaction { &mut self, mut observer: impl FnMut(&Response, crate::dialog::lifecycle::LifecycleTime) + Send, ) -> Option { + if self.check_persistence().is_err() { + return None; + } while let Some(event) = self.tu_receiver.recv().await { if let Some(result) = self.dispatch_event_observed(event, &mut observer).await { return result; } + if self.check_persistence().is_err() { + return None; + } } None } @@ -1301,6 +1378,23 @@ impl Transaction { self.last_received_at .unwrap_or_else(crate::dialog::lifecycle::LifecycleTime::now), ); + let dialog = self.persistence_dialog.lock().upgrade(); + if let Some(dialog) = dialog { + if resp.status_code.kind() == StatusCodeKind::Successful + && self.original.method == Method::Invite + { + if let Err(error) = dialog + .checkpoint( + crate::dialog::persistence::DialogCheckpointReason::BeforeAck, + Some(resp.clone().into()), + ) + .await + { + tracing::warn!(%error, "INVITE checkpoint failed before ACK"); + return None; + } + } + } if auto_ack_client_invite { if let Err(e) = self.send_ack(connection).await { warn!( @@ -1323,6 +1417,7 @@ impl Transaction { key: &TransactionKey, duration: &Duration, ) -> Result<()> { + self.check_persistence()?; if let Some(last_response) = &self.last_response { if let Some(connection) = &self.connection { let last_response = @@ -1347,6 +1442,7 @@ impl Transaction { } async fn on_timer(&mut self, timer: TransactionTimer) -> Result<()> { + self.check_persistence()?; match self.state { TransactionState::Calling | TransactionState::Trying | TransactionState::Proceeding if self.state != TransactionState::Proceeding diff --git a/tests/interop/README.md b/tests/interop/README.md index 9cbd3443..eb540ab7 100644 --- a/tests/interop/README.md +++ b/tests/interop/README.md @@ -51,6 +51,17 @@ PJSUA_BIN=/absolute/path/to/pjsua SIPP_BIN=/absolute/path/to/sipp \ ``` The binaries must support the flags and CLI used by the pinned versions below. + +To exercise the opt-in dialog persistence barriers against the same peers: + +```sh +RSIPSTACK_INTEROP_CHECKPOINTS=1 bash scripts/interop/run.sh regression +``` + +Each scenario writes `checkpoints.log`; the test handler syncs each checkpoint +to disk before acknowledging it and rejects backwards revisions. This is a +test journal, not a production storage format. The regular library tests cover +blocked writes, failures, timeouts, concurrent BYE, and lifecycle delivery. To prepare peers without running the suite, use `bash scripts/interop/build-pjsua.sh` and `bash scripts/interop/build-sipp.sh`. Set `JOBS=2` to limit build concurrency. With Rust dependencies and peers already cached, `CARGO_NET_OFFLINE=true bash diff --git a/tests/interop/checkpoints.rs b/tests/interop/checkpoints.rs new file mode 100644 index 00000000..a81e3af0 --- /dev/null +++ b/tests/interop/checkpoints.rs @@ -0,0 +1,53 @@ +//! Optional real-file persistence for the existing external-peer scenarios. +use super::*; +use rsipstack::dialog::persistence::{ + DialogCheckpoint, DialogPersistence, DialogPersistenceConfig, +}; +use std::collections::BTreeMap; + +struct Journal { + file: File, + revisions: BTreeMap, +} + +struct Storage(Mutex); + +#[async_trait::async_trait] +impl DialogPersistence for Storage { + async fn save(&self, checkpoint: DialogCheckpoint) -> rsipstack::Result<()> { + // These tiny loopback fixtures deliberately use a synchronous file. + // Production handlers should use async storage or a blocking executor. + let mut journal = self.0.lock().unwrap_or_else(|p| p.into_inner()); + let id = checkpoint.snapshot.id.to_string(); + let revision = checkpoint.snapshot.runtime.revision; + if journal + .revisions + .get(&id) + .is_some_and(|previous| *previous > revision) + { + return Err(rsipstack::Error::Error( + "checkpoint revision moved backwards".into(), + )); + } + writeln!(journal.file, "{checkpoint:?}")?; + journal.file.sync_all()?; + journal.revisions.insert(id, revision); + Ok(()) + } +} + +pub(super) fn configure(layer: &DialogLayer, dir: &Path) -> TestResult { + if std::env::var_os("RSIPSTACK_INTEROP_CHECKPOINTS").as_deref() + == Some(std::ffi::OsStr::new("1")) + { + layer + .set_persistence(Some(DialogPersistenceConfig::new(Arc::new(Storage( + Mutex::new(Journal { + file: File::create(dir.join("checkpoints.log")).required()?, + revisions: BTreeMap::new(), + }), + ))))) + .required()?; + } + Ok(()) +} diff --git a/tests/interop/mod.rs b/tests/interop/mod.rs index 8d303085..8e80be5b 100644 --- a/tests/interop/mod.rs +++ b/tests/interop/mod.rs @@ -4,6 +4,7 @@ mod failure; pub use failure::{Failure, Required, TestResult}; mod applications; mod b2bua; +mod checkpoints; mod faults; mod pjsip; mod proxy; @@ -513,6 +514,7 @@ impl Stack { .with_transport_inspector(Box::new(Received(inspector))) .build(); let layer = Arc::new(DialogLayer::new(endpoint.inner.clone())); + checkpoints::configure(&layer, dir)?; let mut transactions = endpoint.incoming_transactions().required()?; tasks.push(errors.spawn("endpoint serve", async move { endpoint.inner.serve().await.required() From 580189e570c1684ab57847782046831d8da76aab Mon Sep 17 00:00:00 2001 From: Fedor Kiselev <116813641+FedorKiselev76@users.noreply.github.com> Date: Fri, 6 Nov 2026 10:15:46 +0000 Subject: [PATCH 05/12] test(dialog): cover checkpoints with controlled re-INVITEs Verify that incoming re-INVITE responses wait for storage and that ACK completion produces a quiescent checkpoint. Exercise successful and failed commits before a deferred outgoing ACK handler. Clarify that the interop checkpoint switch configures in-process dialog peers, not the standalone proxy and B2BUA applications. --- src/dialog/tests/test_persistence.rs | 165 +++++++++++++++++++++++++++ tests/interop/README.md | 10 +- 2 files changed, 171 insertions(+), 4 deletions(-) diff --git a/src/dialog/tests/test_persistence.rs b/src/dialog/tests/test_persistence.rs index 14d19952..8d907c99 100644 --- a/src/dialog/tests/test_persistence.rs +++ b/src/dialog/tests/test_persistence.rs @@ -29,6 +29,7 @@ enum Gate { Never, InitialRequest, Answer, + ReinviteAnswer, ByeResponse, UasResponse, Info, @@ -68,6 +69,9 @@ impl Storage { && matches!(&c.message, Some(SipMessage::Request(r)) if r.method == Method::Invite) } Gate::Answer => c.reason == Reason::BeforeAck, + Gate::ReinviteAnswer => { + c.reason == Reason::BeforeAck && c.snapshot.runtime.pending.negotiations != 0 + } Gate::ByeResponse => { c.reason == Reason::BeforeResponse && matches!(&c.message, Some(SipMessage::Response(r)) if r.cseq_header().unwrap().method().unwrap() == Method::Bye) @@ -628,3 +632,164 @@ async fn persistence_request_is_not_sent_if_peer_ends_during_commit() -> crate:: silent(&call.peer).await; Ok(()) } + +#[tokio::test] +async fn persistence_incoming_reinvite_saves_response_and_ack_completion() -> crate::Result<()> { + use crate::dialog::dialog::DialogState; + let store = Storage::new(Gate::UasResponse); + let mut call = start(store.clone(), Duration::from_secs(2)).await?; + let initial = established(&mut call).await; + store.committed.lock().unwrap().clear(); + let remote = call.peer.local_addr()?; + let invite = Request::try_from(format!( + "INVITE sip:alice@{} SIP/2.0\r\nVia: SIP/2.0/UDP {remote};branch=z9hG4bK-persist-reinvite\r\nFrom: ;tag=peer\r\nTo: {}\r\nCall-ID: {}\r\nCSeq: 10 INVITE\r\nContact: \r\nMax-Forwards: 70\r\nContent-Length: 0\r\n\r\n", + call.local, initial.from_header()?.value(), initial.call_id_header()?.value() + ).as_str())?; + call.peer + .send_to(invite.to_string().as_bytes(), call.local) + .await?; + let handle = tokio::time::timeout(Duration::from_secs(2), async { + while let Some(state) = call._states.recv().await { + if let DialogState::Updated(_, _, handle) = state { + return handle; + } + } + panic!("missing re-INVITE handle"); + }) + .await + .unwrap(); + handle.respond(StatusCode::OK, None, None).await?; + entered(&store).await; + let pending_revision = { + let attempts = store.attempts.lock().unwrap(); + let before = attempts.last().unwrap(); + assert_eq!(before.reason, Reason::BeforeResponse); + assert_eq!(before.snapshot.runtime.pending.negotiations, 1); + assert!(!before.snapshot.is_quiescent()); + before.snapshot.runtime.revision + }; + silent(&call.peer).await; + store.release.cancel(); + let SipMessage::Response(response) = receive(&call.peer).await else { + panic!("expected re-INVITE response"); + }; + assert_eq!(response.status_code, StatusCode::OK); + assert_eq!(response.cseq_header()?.seq()?, 10); + let mut ack = invite; + ack.method = Method::Ack; + ack.cseq_header_mut()?.mut_method(Method::Ack)?; + call.peer + .send_to(ack.to_string().as_bytes(), call.local) + .await?; + tokio::time::timeout(Duration::from_secs(2), async { + loop { + let completed = store.committed.lock().unwrap().iter().any(|checkpoint| { + checkpoint.reason == Reason::SignalingCompleted + && checkpoint.snapshot.is_quiescent() + && checkpoint.snapshot.runtime.revision > pending_revision + }); + if completed { + break; + } + tokio::task::yield_now().await; + } + }) + .await + .expect("matching ACK must produce a quiescent checkpoint"); + assert!(call.dialog.snapshot().is_quiescent()); + Ok(()) +} + +#[tokio::test] +async fn persistence_reinvite_commit_precedes_deferred_ack_handler() -> crate::Result<()> { + use crate::dialog::reinvite::{AckBody, InviteAnswerHandler, ReinviteOptions}; + use crate::sip::{Header, Response}; + struct DeferredAnswer { + entered: CancellationToken, + release: CancellationToken, + } + const SDP: &[u8] = b"v=0\r\no=- 1 1 IN IP4 127.0.0.1\r\ns=-\r\nc=IN IP4 127.0.0.1\r\nt=0 0\r\nm=audio 10000 RTP/AVP 0\r\n"; + #[async_trait] + impl InviteAnswerHandler for DeferredAnswer { + async fn answer(&self, _: Response) -> crate::Result { + self.entered.cancel(); + self.release.cancelled().await; + Ok(AckBody::sdp(SDP.to_vec())) + } + fn fallback_answer(&self, _: &Response) -> AckBody { + AckBody::sdp(SDP.to_vec()) + } + } + for fail in [false, true] { + let store = Storage::new(Gate::ReinviteAnswer); + let mut call = start(store.clone(), Duration::from_secs(2)).await?; + established(&mut call).await; + store.committed.lock().unwrap().clear(); + let handler = Arc::new(DeferredAnswer { + entered: CancellationToken::new(), + release: CancellationToken::new(), + }); + let options = ReinviteOptions { + answer_handler: Some(handler.clone()), + ..Default::default() + }; + let dialog = call.dialog.clone(); + let invite = dialog.prepare_reinvite(None, None)?; + let sender = tokio::spawn(async move { dialog.send_reinvite(invite, options).await }); + let invite = request(&call.peer, Method::Invite).await; + let mut success = Response::try_from( + response(&invite, &format!("sip:bob@{}", call.peer.local_addr()?)).as_str(), + )?; + success.body = SDP.to_vec(); + success + .headers + .unique_push(Header::ContentType("application/sdp".into())); + success + .headers + .unique_push(Header::ContentLength((SDP.len() as u32).into())); + call.peer + .send_to(success.to_string().as_bytes(), call.local) + .await?; + entered(&store).await; + assert!( + !handler.entered.is_cancelled(), + "answer handler ran before storage committed" + ); + assert!(!call.dialog.snapshot().is_quiescent()); + silent(&call.peer).await; + store.fail.store(fail, Ordering::SeqCst); + store.release.cancel(); + if fail { + assert!(tokio::time::timeout(Duration::from_secs(2), sender) + .await + .unwrap() + .unwrap() + .is_err()); + assert!(!handler.entered.is_cancelled()); + assert!(call.dialog.persistence_status().unwrap().failure.is_some()); + silent(&call.peer).await; + } else { + tokio::time::timeout(Duration::from_secs(2), handler.entered.cancelled()) + .await + .unwrap(); + silent(&call.peer).await; + handler.release.cancel(); + let ack = request(&call.peer, Method::Ack).await; + assert_eq!(ack.body, SDP); + assert_eq!( + tokio::time::timeout(Duration::from_secs(2), sender) + .await + .unwrap() + .unwrap()? + .unwrap() + .status_code, + StatusCode::OK + ); + assert!(store.committed.lock().unwrap().iter().any(|checkpoint| { + checkpoint.reason == Reason::SignalingCompleted + && checkpoint.snapshot.is_quiescent() + })); + } + } + Ok(()) +} diff --git a/tests/interop/README.md b/tests/interop/README.md index eb540ab7..38dc4c38 100644 --- a/tests/interop/README.md +++ b/tests/interop/README.md @@ -58,10 +58,12 @@ To exercise the opt-in dialog persistence barriers against the same peers: RSIPSTACK_INTEROP_CHECKPOINTS=1 bash scripts/interop/run.sh regression ``` -Each scenario writes `checkpoints.log`; the test handler syncs each checkpoint -to disk before acknowledging it and rejects backwards revisions. This is a -test journal, not a production storage format. The regular library tests cover -blocked writes, failures, timeouts, concurrent BYE, and lifecycle delivery. +In-process dialog-peer scenarios write `checkpoints.log`; the test handler syncs +each checkpoint to disk before acknowledging it and rejects backwards revisions. +The standalone proxy/B2BUA applications use their own dialog layers and are not +configured by this switch. This is a test journal, not a production storage +format. The regular library tests cover blocked writes, failures, timeouts, +concurrent BYE, lifecycle delivery, and application-controlled re-INVITEs. To prepare peers without running the suite, use `bash scripts/interop/build-pjsua.sh` and `bash scripts/interop/build-sipp.sh`. Set `JOBS=2` to limit build concurrency. With Rust dependencies and peers already cached, `CARGO_NET_OFFLINE=true bash From 84fa9064977a4d3b452e55d89c4e13e9c14fb80b Mon Sep 17 00:00:00 2001 From: Fedor Kiselev <116813641+FedorKiselev76@users.noreply.github.com> Date: Fri, 6 Nov 2026 10:21:52 +0000 Subject: [PATCH 06/12] test(interop): wait for callee ACK before exercising BYE loss The caller can report CONFIRMED before the proxy forwards ACK. Wait for a SIPp receive marker before requesting hangup, so this scenario tests retransmission of BYE instead of racing it with the initial ACK. --- tests/interop/applications.rs | 5 ++++- tests/interop/scenarios/application_lost_bye_response.xml | 1 + tests/interop/sipp.rs | 2 +- 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/tests/interop/applications.rs b/tests/interop/applications.rs index 71c34b25..3e1c2f4d 100644 --- a/tests/interop/applications.rs +++ b/tests/interop/applications.rs @@ -500,7 +500,7 @@ pub async fn lost_bye_response(mode: &str, name: &str) -> TestResult { std::fs::create_dir_all(dir.join(peer)).required()?; } let unused: Uri = "sip:unused@127.0.0.1:9".parse().required()?; - let callee = super::sipp::Sipp::start( + let mut callee = super::sipp::Sipp::start( "application_lost_bye_response", "udp", &dir.join("callee"), @@ -511,6 +511,9 @@ pub async fn lost_bye_response(mode: &str, name: &str) -> TestResult { let mut caller = Peer::start("udp", &dir.join("caller")).await?; caller.command(&format!("m\n{}\n", app.uri)).await?; caller.wait_text("state changed to CONFIRMED").await?; + // CONFIRMED at the caller does not prove that the callee received ACK. + // Independent proxy tasks can forward BYE first if hangup starts now. + callee.marker("APPLICATION_ACK_RECEIVED").await?; caller.command("h\n").await?; callee.finish().await?; caller.wait_text("Response msg 200/BYE").await?; diff --git a/tests/interop/scenarios/application_lost_bye_response.xml b/tests/interop/scenarios/application_lost_bye_response.xml index 016a8000..685ae94b 100644 --- a/tests/interop/scenarios/application_lost_bye_response.xml +++ b/tests/interop/scenarios/application_lost_bye_response.xml @@ -43,6 +43,7 @@ a=rtpmap:0 PCMU/8000 a=inactive ]]> + diff --git a/tests/interop/sipp.rs b/tests/interop/sipp.rs index e0bc6606..974bc8cc 100644 --- a/tests/interop/sipp.rs +++ b/tests/interop/sipp.rs @@ -162,7 +162,7 @@ impl Sipp { message } - async fn marker(&mut self, marker: &str) -> TestResult { + pub(super) async fn marker(&mut self, marker: &str) -> TestResult { until_result(marker, || { let text = match std::fs::read_to_string(&self.log) { Ok(text) => text, From b396c8f0698b13486434f06815babd7c8f7e9e8a Mon Sep 17 00:00:00 2001 From: Fedor Kiselev <116813641+FedorKiselev76@users.noreply.github.com> Date: Thu, 5 Nov 2026 10:08:48 +0000 Subject: [PATCH 07/12] feat(dialog): bridge re-INVITEs across independent call legs --- src/dialog/mod.rs | 1 + src/dialog/reinvite_bridge.rs | 535 ++++++++++++++++++ src/dialog/tests/mod.rs | 1 + src/dialog/tests/test_reinvite_bridge.rs | 360 ++++++++++++ tests/interop/COVERAGE.md | 23 +- tests/interop/README.md | 27 +- tests/interop/pjsip.rs | 1 + tests/interop/pjsip/bridge.rs | 202 +++++++ .../scenarios/bridge_offerless_origin.xml | 101 ++++ .../scenarios/bridge_offerless_peer.xml | 126 +++++ tests/interop/sipp.rs | 6 +- tests/interop/sipp/bridge.rs | 199 +++++++ 12 files changed, 1569 insertions(+), 13 deletions(-) create mode 100644 src/dialog/reinvite_bridge.rs create mode 100644 src/dialog/tests/test_reinvite_bridge.rs create mode 100644 tests/interop/pjsip/bridge.rs create mode 100644 tests/interop/scenarios/bridge_offerless_origin.xml create mode 100644 tests/interop/scenarios/bridge_offerless_peer.xml create mode 100644 tests/interop/sipp/bridge.rs diff --git a/src/dialog/mod.rs b/src/dialog/mod.rs index 0b3f1372..3183356d 100644 --- a/src/dialog/mod.rs +++ b/src/dialog/mod.rs @@ -15,6 +15,7 @@ pub mod lifecycle; pub mod publication; pub mod registration; pub mod reinvite; +pub mod reinvite_bridge; pub mod server_dialog; pub mod subscription; diff --git a/src/dialog/reinvite_bridge.rs b/src/dialog/reinvite_bridge.rs new file mode 100644 index 00000000..a330fd64 --- /dev/null +++ b/src/dialog/reinvite_bridge.rs @@ -0,0 +1,535 @@ +//! Couple re-INVITEs between two already confirmed dialogs. +//! +//! Feed re-INVITE `Updated` events to [`ReinviteBridge::handle`] in spawned +//! tasks, so the application can still handle BYE and other dialog events. +//! Call [`ReinviteBridge::shutdown`] when either call leg ends. Initial call +//! establishment, registration, media transport and whole-call routing remain +//! application responsibilities. One bridge instance serializes negotiation in +//! both directions; it rejects overlap with 491 rather than retrying invisibly. +//! +//! The default policy relays SDP unchanged. Dialog identifiers, route sets, +//! Contact and CSeq remain local to each leg. Offerless re-INVITEs relay the +//! 2xx offer and wait for the matching incoming ACK before answering the other +//! leg. Missing ACK or an unusable answer ends the affected session, using a +//! rejecting SDP answer before BYE. No media rollback is implied by CANCEL or +//! by a failed negotiation after a peer already accepted it. +//! +//! Reliable provisional offer/answer and session-timer negotiation are outside +//! this component's current scope. Requests requiring 100rel or timer are +//! rejected with 420 rather than silently claiming support. +//! +//! ```no_run +//! # async fn example(a: rsipstack::dialog::invite_dialog::InviteDialog, +//! # b: rsipstack::dialog::invite_dialog::InviteDialog, +//! # event: rsipstack::dialog::dialog::DialogState) +//! # -> rsipstack::Result<()> { +//! use rsipstack::dialog::{dialog::DialogState, reinvite_bridge::ReinviteBridge}; +//! use rsipstack::sip::Method; +//! let bridge = ReinviteBridge::new(a.clone(), b.clone())?; +//! // Retain one bridge for this pair of dialogs. In an event loop, spawn +//! // this operation instead of blocking receipt of BYE/termination events. +//! if let DialogState::Updated(id, request, handle) = event { +//! if request.method == Method::Invite { +//! if let Err(error) = bridge.handle(id, request, handle).await { +//! bridge.shutdown(); +//! let _ = futures::join!(a.hangup(), b.hangup()); +//! return Err(error); +//! } +//! } +//! } +//! # Ok(()) } +//! ``` + +use super::{ + dialog::TransactionHandle, + invite_dialog::InviteDialog, + reinvite::{AckBody, InviteAnswerHandler, ReinviteOptions}, + DialogId, +}; +use crate::{ + platform::{mpsc, select2, CancellationToken, Either}, + prelude::*, + sip::{Header, HeadersExt, Method, Request, Response, StatusCode, StatusCodeKind}, + transaction::key::TransactionRole, + Result, +}; +use core::sync::atomic::{AtomicBool, Ordering}; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum BridgeDirection { + AtoB, + BtoA, +} +impl BridgeDirection { + fn reverse(self) -> Self { + match self { + Self::AtoB => Self::BtoA, + Self::BtoA => Self::AtoB, + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum BridgeBodyRole { + Offer, + Answer, +} + +/// Application hook for SDP rewriting or a media controller. A transformation +/// must preserve offer/answer semantics. `reject_offer` must be immediate and +/// produce a valid answer rejecting every offered stream. +pub trait ReinviteBridgePolicy: Send + Sync { + fn transform( + &self, + direction: BridgeDirection, + role: BridgeBodyRole, + body: AckBody, + ) -> Result; + fn reject_offer(&self, offer: &Response) -> AckBody; +} + +/// Relays valid SDP without changing media addresses, codecs or directions. +#[derive(Default)] +pub struct PassthroughSdp; +impl ReinviteBridgePolicy for PassthroughSdp { + fn transform(&self, _: BridgeDirection, _: BridgeBodyRole, body: AckBody) -> Result { + if !body + .content_type + .split(';') + .next() + .is_some_and(|t| t.trim().eq_ignore_ascii_case("application/sdp")) + || !core::str::from_utf8(&body.body).is_ok_and(|s| s.lines().any(|l| l == "v=0")) + { + return Err(error("bridge requires an application/sdp body")); + } + Ok(body) + } + fn reject_offer(&self, offer: &Response) -> AckBody { + // RFC 3264 section 6: preserve each media line's position and protocol, + // set its port to zero, and retain at least one format. No RTP/RTCP is + // enabled and no offered security or transport attributes are accepted. + let mut answer = + String::from("v=0\r\no=- 0 0 IN IP4 0.0.0.0\r\ns=-\r\nc=IN IP4 0.0.0.0\r\nt=0 0\r\n"); + if let Ok(sdp) = core::str::from_utf8(&offer.body) { + for line in sdp.lines().filter_map(|l| l.strip_prefix("m=")) { + let fields: Vec<_> = line.split_whitespace().collect(); + if fields.len() >= 4 { + answer.push_str(&format!( + "m={} 0 {} {}\r\n", + fields[0], + fields[2], + fields[3..].join(" ") + )); + } + } + } + AckBody::sdp(answer.into_bytes()) + } +} + +struct Inner { + a: InviteDialog, + b: InviteDialog, + busy: AtomicBool, + shutdown: CancellationToken, + policy: Arc, +} + +#[derive(Clone)] +pub struct ReinviteBridge { + inner: Arc, +} + +struct Reservation(Arc); +impl Drop for Reservation { + fn drop(&mut self) { + self.0.busy.store(false, Ordering::SeqCst); + } +} +struct StopWatch(CancellationToken); +impl Drop for StopWatch { + fn drop(&mut self) { + self.0.cancel(); + } +} + +impl ReinviteBridge { + pub fn new(a: InviteDialog, b: InviteDialog) -> Result { + Self::with_policy(a, b, Arc::new(PassthroughSdp)) + } + pub fn with_policy( + a: InviteDialog, + b: InviteDialog, + policy: Arc, + ) -> Result { + if !a.state().is_confirmed() || !b.state().is_confirmed() || a.id() == b.id() { + return Err(error("bridge requires two distinct confirmed dialogs")); + } + Ok(Self { + inner: Arc::new(Inner { + a, + b, + busy: AtomicBool::new(false), + shutdown: CancellationToken::new(), + policy, + }), + }) + } + + /// Cancel pending negotiation and reject future requests. The application + /// still drives each dialog and its whole-call BYE policy. + pub fn shutdown(&self) { + self.inner.shutdown.cancel(); + } + + /// Handle an incoming re-INVITE's Updated event. The operation owns a task + /// once polled, so dropping its awaiter cannot abandon either transaction. + /// Returns the relayed status; a rejected negotiation normally preserves + /// the established session. On an error, shut down the bridge and terminate + /// both call legs: a peer may already have accepted the modification. + pub async fn handle( + &self, + source: DialogId, + request: Request, + handle: TransactionHandle, + ) -> Result { + let inner = self.inner.clone(); + let task = crate::platform::spawn_with_result(async move { + inner.handle(source, request, handle).await + }); + #[cfg(feature = "platform-tokio")] + { + task.await.map_err(|e| error(&e.to_string()))? + } + #[cfg(not(feature = "platform-tokio"))] + { + task.await + } + } +} + +impl Inner { + async fn handle( + self: Arc, + source: DialogId, + request: Request, + handle: TransactionHandle, + ) -> Result { + let direction = if source == self.a.id() { + BridgeDirection::AtoB + } else if source == self.b.id() { + BridgeDirection::BtoA + } else { + return reply(&handle, StatusCode::CallTransactionDoesNotExist, None, None).await; + }; + if request.method != Method::Invite + || DialogId::try_from((&request, TransactionRole::Server))? != source + { + return Err(error("bridge requires the source dialog's re-INVITE event")); + } + if self.shutdown.is_cancelled() { + return reply(&handle, StatusCode::CallTransactionDoesNotExist, None, None).await; + } + let unsupported: Vec<_> = ["100rel", "timer"] + .into_iter() + .filter(|name| request.header_contains_token("require", name)) + .collect(); + if !unsupported.is_empty() { + return reply( + &handle, + StatusCode::BadExtension, + Some(vec![Header::Unsupported(unsupported.join(", ").into())]), + None, + ) + .await; + } + if self + .busy + .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst) + .is_err() + { + return reply(&handle, StatusCode::RequestPending, None, None).await; + } + let _reservation = Reservation(self.clone()); + let destination = match direction { + BridgeDirection::AtoB => &self.b, + BridgeDirection::BtoA => &self.a, + }; + if !destination.state().is_confirmed() { + return reply(&handle, StatusCode::CallTransactionDoesNotExist, None, None).await; + } + let incoming_cancel = handle.cancellation(); + if incoming_cancel.is_cancelled() { + // CANCEL can win before the application dispatches Updated. The + // default dialog handler may already have sent 487; either way, + // do not start a new negotiation on the other leg. + handle.reply(StatusCode::RequestTerminated).await.ok(); + return Ok(StatusCode::RequestTerminated); + } + let cancellation = self.shutdown.child_token(); + let done = CancellationToken::new(); + let _watch = StopWatch(done.clone()); + let forward_cancel = cancellation.clone(); + crate::platform::spawn(async move { + if matches!( + select2( + core::pin::pin!(incoming_cancel.cancelled()), + core::pin::pin!(done.cancelled()) + ) + .await, + Either::A(_) + ) { + forward_cancel.cancel(); + } + }); + let offered = !request.body.is_empty(); + let payload = if offered { + match self + .policy + .transform(direction, BridgeBodyRole::Offer, request_body(&request)) + { + Ok(body) => Some(body), + Err(_) => return reply(&handle, StatusCode::NotAcceptableHere, None, None).await, + } + } else { + None + }; + let outgoing = match destination + .prepare_reinvite(payload.as_ref().map(body_headers), payload.map(|p| p.body)) + { + Ok(request) => request, + Err(_) => { + return reply(&handle, StatusCode::CallTransactionDoesNotExist, None, None).await + } + }; + let answered = Arc::new(AtomicBool::new(false)); + let handler = (!offered).then(|| { + Arc::new(RelayAnswer { + handle: handle.clone(), + policy: self.policy.clone(), + direction, + answered: answered.clone(), + shutdown: self.shutdown.clone(), + }) as Arc + }); + #[cfg_attr(not(feature = "platform-tokio"), allow(unused_mut))] + let (provisionals, mut progress) = mpsc::unbounded_channel(); + let mut pending = core::pin::pin!(destination.send_reinvite( + outgoing, + ReinviteOptions { + cancellation: cancellation.clone(), + answer_handler: handler, + provisional_responses: Some(provisionals), + } + )); + let mut relay_failure = None; + let result = loop { + match select2(&mut pending, core::pin::pin!(progress.recv())).await { + Either::A(result) => break result, + Either::B(Some(response)) => { + if relay_failure.is_some() { + continue; + } + // 100rel is terminated independently on the outgoing leg. + // Do not advertise reliability that this incoming leg did + // not negotiate. A reliable SDP exchange needs PRACK policy. + if response.header_contains_token("require", "100rel") { + continue; + } + let payload = (!response.body.is_empty()).then(|| response_body(&response)); + let payload = match payload { + Some(body) => match self.policy.transform( + direction.reverse(), + if offered { + BridgeBodyRole::Answer + } else { + BridgeBodyRole::Offer + }, + body, + ) { + Ok(body) => Some(body), + Err(error) => { + relay_failure = Some(error); + cancellation.cancel(); + continue; + } + }, + None => None, + }; + if let Err(error) = reply( + &handle, + response.status_code, + payload.as_ref().map(body_headers), + payload.map(|p| p.body), + ) + .await + { + relay_failure = Some(error); + cancellation.cancel(); + } + } + Either::B(None) => break pending.await, + } + }; + if let Some(error) = relay_failure { + self.shutdown.cancel(); + reply(&handle, StatusCode::BadGateway, None, None) + .await + .ok(); + if result.as_ref().is_ok_and(|r| { + r.as_ref() + .is_some_and(|r| r.status_code.kind() == StatusCodeKind::Successful) + }) { + destination.bye().await.ok(); + } + return Err(error); + } + let response = match result { + Ok(Some(response)) => response, + other => { + if !answered.load(Ordering::SeqCst) { + let status = match &other { + Err(crate::Error::DialogError(_, _, StatusCode::RequestPending)) => { + StatusCode::RequestPending + } + _ => StatusCode::BadGateway, + }; + return reply(&handle, status, None, None).await; + } + return Err(other.err().unwrap_or_else(|| { + error("outgoing re-INVITE ended without a final response") + })); + } + }; + let status = response.status_code.clone(); + if !answered.load(Ordering::SeqCst) { + let payload = if status.kind() == StatusCodeKind::Successful { + match self.policy.transform( + direction.reverse(), + BridgeBodyRole::Answer, + response_body(&response), + ) { + Ok(body) => Some(body), + Err(error) => { + self.shutdown.cancel(); + reply(&handle, StatusCode::BadGateway, None, None) + .await + .ok(); + destination.bye().await.ok(); + return Err(error); + } + } + } else if response.body.is_empty() { + None + } else { + Some(response_body(&response)) + }; + let mut headers = payload.as_ref().map(body_headers).unwrap_or_default(); + headers.extend( + response + .headers + .iter() + .filter(|h| matches!(h, Header::RetryAfter(_) | Header::Warning(_))) + .cloned(), + ); + reply( + &handle, + status.clone(), + Some(headers), + payload.map(|p| p.body), + ) + .await?; + } + // Keep the bridge reservation until both ACK directions are complete. + if let Err(error) = handle.wait_ack().await { + if status.kind() == StatusCodeKind::Successful { + destination.bye().await.ok(); + } + return Err(error); + } + Ok(status) + } +} + +struct RelayAnswer { + handle: TransactionHandle, + policy: Arc, + direction: BridgeDirection, + answered: Arc, + shutdown: CancellationToken, +} +#[async_trait::async_trait] +impl InviteAnswerHandler for RelayAnswer { + async fn answer(&self, response: Response) -> Result { + let offer = self.policy.transform( + self.direction.reverse(), + BridgeBodyRole::Offer, + response_body(&response), + )?; + reply( + &self.handle, + response.status_code, + Some(body_headers(&offer)), + Some(offer.body), + ) + .await?; + self.answered.store(true, Ordering::SeqCst); + let ack = match select2( + core::pin::pin!(self.handle.wait_ack()), + core::pin::pin!(self.shutdown.cancelled()), + ) + .await + { + Either::A(result) => result?, + Either::B(_) => return Err(error("bridge ended while waiting for an ACK answer")), + }; + self.policy + .transform(self.direction, BridgeBodyRole::Answer, request_body(&ack)) + } + fn fallback_answer(&self, response: &Response) -> AckBody { + self.policy.reject_offer(response) + } +} + +fn error(message: &str) -> crate::Error { + crate::Error::Error(message.into()) +} +async fn reply( + handle: &TransactionHandle, + status: StatusCode, + headers: Option>, + body: Option>, +) -> Result { + handle + .respond(status.clone(), headers, body) + .await + .map_err(|e| error(&e.to_string()))?; + Ok(status) +} +fn body_headers(body: &AckBody) -> Vec
{ + vec![Header::ContentType(body.content_type.clone().into())] +} +fn content_type(headers: &crate::sip::Headers) -> String { + headers + .iter() + .find_map(|h| { + if let Header::ContentType(value) = h { + Some(value.value().to_owned()) + } else { + None + } + }) + .unwrap_or_default() +} +fn request_body(request: &Request) -> AckBody { + AckBody { + content_type: content_type(&request.headers), + body: request.body.clone(), + } +} +fn response_body(response: &Response) -> AckBody { + AckBody { + content_type: content_type(&response.headers), + body: response.body.clone(), + } +} diff --git a/src/dialog/tests/mod.rs b/src/dialog/tests/mod.rs index f30db8a0..100a1779 100644 --- a/src/dialog/tests/mod.rs +++ b/src/dialog/tests/mod.rs @@ -29,4 +29,5 @@ mod test_uas_ack_timeout; mod test_via_listen_addr; mod test_warn_logs; +mod test_reinvite_bridge; mod test_reinvite_control; diff --git a/src/dialog/tests/test_reinvite_bridge.rs b/src/dialog/tests/test_reinvite_bridge.rs new file mode 100644 index 00000000..aa9c79b9 --- /dev/null +++ b/src/dialog/tests/test_reinvite_bridge.rs @@ -0,0 +1,360 @@ +use super::test_in_dialog_provisional::{establish_with_options, recv_request, reply, response}; +use crate::{ + dialog::{ + dialog::{DialogState, DialogStateReceiver, TransactionHandle}, + invite_dialog::InviteDialog, + reinvite_bridge::{PassthroughSdp, ReinviteBridge, ReinviteBridgePolicy}, + }, + sip::{Header, HeadersExt, Method, Request, Response, SipMessage}, + transaction::endpoint::EndpointOption, +}; +use std::{net::SocketAddr, time::Duration}; +use tokio::{net::UdpSocket, task::JoinHandle}; +use tokio_util::sync::CancellationToken; + +const OFFER: &[u8] = b"v=0\r\no=- 1 2 IN IP4 127.0.0.1\r\ns=-\r\nc=IN IP4 127.0.0.1\r\nt=0 0\r\nm=audio 10000 RTP/AVP 0\r\na=sendonly\r\n"; +const ANSWER: &[u8] = b"v=0\r\no=- 2 2 IN IP4 127.0.0.1\r\ns=-\r\nc=IN IP4 127.0.0.1\r\nt=0 0\r\nm=audio 20000 RTP/AVP 0\r\na=recvonly\r\n"; + +fn incoming( + dialog: &InviteDialog, + peer: &UdpSocket, + offer: bool, +) -> crate::Result<(Request, SocketAddr)> { + let local = dialog + .inner + .endpoint_inner + .transport_layer + .get_listen_addrs()[0] + .get_socketaddr()?; + let remote = peer.local_addr()?; + let id = dialog.id(); + let mut request = Request::try_from(format!( + "INVITE sip:alice@{local} SIP/2.0\r\nVia: SIP/2.0/UDP {remote};branch=z9hG4bK-bridge-10\r\nMax-Forwards: 70\r\nFrom: ;tag={}\r\nTo: ;tag={}\r\nCall-ID: {}\r\nCSeq: 10 INVITE\r\nContact: \r\nContent-Length: 0\r\n\r\n", id.remote_tag, id.local_tag, id.call_id + ).as_str())?; + if offer { + request.body = OFFER.to_vec(); + request + .headers + .unique_push(Header::ContentType("application/sdp".into())); + request + .headers + .unique_push(Header::ContentLength((OFFER.len() as u32).into())); + } + Ok((request, local)) +} + +async fn updated(states: &mut DialogStateReceiver) -> TransactionHandle { + tokio::time::timeout(Duration::from_secs(1), async { + while let Some(state) = states.recv().await { + if let DialogState::Updated(_, _, handle) = state { + return handle; + } + } + panic!("missing re-INVITE event") + }) + .await + .unwrap() +} +async fn received(peer: &UdpSocket, method: Method, status: u16) -> crate::Result { + tokio::time::timeout(Duration::from_secs(2), async { + let mut packet = [0; 8192]; + loop { + let (len, _) = peer.recv_from(&mut packet).await?; + if let SipMessage::Response(response) = SipMessage::try_from(&packet[..len])? { + if response.cseq_header()?.method()? == method + && response.status_code.code() == status + { + return Ok(response); + } + } + } + }) + .await + .unwrap() +} +async fn ack( + peer: &UdpSocket, + address: SocketAddr, + request: &Request, + body: Option<&[u8]>, +) -> crate::Result<()> { + let mut ack = request.clone(); + ack.method = Method::Ack; + ack.cseq_header_mut()?.mut_method(Method::Ack)?; + ack.body = body.unwrap_or_default().to_vec(); + ack.headers + .unique_push(Header::ContentLength((ack.body.len() as u32).into())); + if body.is_some() { + ack.headers + .unique_push(Header::ContentType("application/sdp".into())); + } else { + ack.headers.retain(|h| !matches!(h, Header::ContentType(_))); + } + peer.send_to(ack.to_string().as_bytes(), address).await?; + Ok(()) +} +async fn success( + peer: &UdpSocket, + address: SocketAddr, + request: &Request, + body: &[u8], +) -> crate::Result { + let mut response = Response::try_from( + response( + request, + 200, + "OK", + &format!("sip:peer@{}", peer.local_addr()?), + ) + .as_str(), + )?; + response.body = body.to_vec(); + response + .headers + .unique_push(Header::ContentType("application/sdp".into())); + response + .headers + .unique_push(Header::ContentLength((body.len() as u32).into())); + peer.send_to(response.to_string().as_bytes(), address) + .await?; + Ok(response) +} +async fn result( + task: JoinHandle>, +) -> crate::Result { + tokio::time::timeout(Duration::from_secs(2), task) + .await + .unwrap() + .unwrap() +} + +#[derive(Clone, Copy)] +enum Scenario { + Offered, + Offerless, + Rejected, + Cancelled, + LateSuccess, + MissingAck, + Glare, + Shutdown, +} + +async fn scenario(reverse: bool, scenario: Scenario) -> crate::Result<()> { + let token = CancellationToken::new(); + let _guard = token.clone().drop_guard(); + let option = || EndpointOption { + t1: Duration::from_millis(10), + t1x64: Duration::from_millis(640), + ..Default::default() + }; + let (a, mut a_states, a_peer) = establish_with_options(&token, None, option()).await?; + let (b, mut b_states, b_peer) = establish_with_options(&token, None, option()).await?; + let bridge = ReinviteBridge::new(a.clone(), b.clone())?; + let (source, destination, states, peer, other) = if reverse { + (&b, &a, &mut b_states, &b_peer, &a_peer) + } else { + (&a, &b, &mut a_states, &a_peer, &b_peer) + }; + let offer = !matches!(scenario, Scenario::Offerless | Scenario::MissingAck); + let (request, address) = incoming(source, peer, offer)?; + peer.send_to(request.to_string().as_bytes(), address) + .await?; + let handle = updated(states).await; + let source_id = source.id(); + let original = request.clone(); + let pending_bridge = bridge.clone(); + let task = + tokio::spawn(async move { pending_bridge.handle(source_id, original, handle).await }); + let (outgoing, other_address) = recv_request(other, Method::Invite).await; + assert_ne!(outgoing.call_id_header()?, request.call_id_header()?); + assert_ne!( + outgoing.cseq_header()?.seq()?, + request.cseq_header()?.seq()? + ); + assert_eq!(outgoing.body, request.body); + reply(other, other_address, &outgoing, 180, "Ringing").await; + received(peer, Method::Invite, 180).await?; + + if matches!(scenario, Scenario::Shutdown) { + let mut bye = request.clone(); + bye.method = Method::Bye; + bye.cseq_header_mut()? + .mut_seq(11)? + .mut_method(Method::Bye)?; + bye.body.clear(); + bye.headers.unique_push(Header::ContentLength(0.into())); + peer.send_to(bye.to_string().as_bytes(), address).await?; + received(peer, Method::Bye, 200).await?; + bridge.shutdown(); + let (cancel, _) = recv_request(other, Method::Cancel).await; + reply(other, other_address, &cancel, 200, "OK").await; + } + if matches!(scenario, Scenario::Glare) { + let (collision, collision_address) = incoming(destination, other, true)?; + other + .send_to(collision.to_string().as_bytes(), collision_address) + .await?; + received(other, Method::Invite, 491).await?; + ack(other, collision_address, &collision, None).await?; + } + if matches!(scenario, Scenario::Cancelled | Scenario::LateSuccess) { + let mut cancel = request.clone(); + cancel.method = Method::Cancel; + cancel.cseq_header_mut()?.mut_method(Method::Cancel)?; + cancel.body.clear(); + cancel + .headers + .retain(|h| !matches!(h, Header::ContentType(_))); + cancel.headers.unique_push(Header::ContentLength(0.into())); + peer.send_to(cancel.to_string().as_bytes(), address).await?; + received(peer, Method::Cancel, 200).await?; + let (forwarded, _) = recv_request(other, Method::Cancel).await; + assert_eq!(forwarded.via_header()?, outgoing.via_header()?); + assert_eq!( + forwarded.cseq_header()?.seq()?, + outgoing.cseq_header()?.seq()? + ); + reply(other, other_address, &forwarded, 200, "OK").await; + } + if matches!( + scenario, + Scenario::Rejected | Scenario::Cancelled | Scenario::Shutdown + ) { + let code = if matches!(scenario, Scenario::Rejected) { + 488 + } else { + 487 + }; + reply(other, other_address, &outgoing, code, "Rejected").await; + let (out_ack, _) = recv_request(other, Method::Ack).await; + assert_eq!( + out_ack.cseq_header()?.seq()?, + outgoing.cseq_header()?.seq()? + ); + received(peer, Method::Invite, code).await?; + ack(peer, address, &request, None).await?; + assert_eq!(result(task).await?.code(), code); + } else { + let payload = if offer { ANSWER } else { OFFER }; + let final_response = success(other, other_address, &outgoing, payload).await?; + if offer { + recv_request(other, Method::Ack).await; + } + let incoming_response = received(peer, Method::Invite, 200).await?; + assert_eq!(incoming_response.body, payload); + if matches!(scenario, Scenario::MissingAck) { + let (rejection, _) = recv_request(other, Method::Ack).await; + assert!(String::from_utf8_lossy(&rejection.body).contains("m=audio 0 RTP/AVP 0")); + let (bye, _) = recv_request(other, Method::Bye).await; + reply(other, other_address, &bye, 200, "OK").await; + let (bye, _) = recv_request(peer, Method::Bye).await; + reply(peer, address, &bye, 200, "OK").await; + assert!(result(task).await.is_err()); + assert!(a.state().is_terminated()); + assert!(b.state().is_terminated()); + return Ok(()); + } + if !offer { + let mut bytes = [0; 8192]; + assert!( + tokio::time::timeout(Duration::from_millis(20), other.recv_from(&mut bytes)) + .await + .is_err() + ); + } + ack(peer, address, &request, (!offer).then_some(ANSWER)).await?; + if !offer { + let (answer, _) = recv_request(other, Method::Ack).await; + assert_eq!(answer.body, ANSWER); + other + .send_to(final_response.to_string().as_bytes(), other_address) + .await?; + let (repeated, _) = recv_request(other, Method::Ack).await; + assert_eq!(repeated, answer); + } + assert_eq!(result(task).await?.code(), 200); + } + if matches!(scenario, Scenario::Shutdown) { + assert!(source.state().is_terminated()); + let closer = destination.clone(); + let closing = tokio::spawn(async move { closer.bye().await }); + let (bye, _) = recv_request(other, Method::Bye).await; + reply(other, other_address, &bye, 200, "OK").await; + closing.await.unwrap()?; + assert!(destination.state().is_terminated()); + } else { + assert!(a.state().is_confirmed()); + assert!(b.state().is_confirmed()); + } + Ok(()) +} + +macro_rules! cases { + ($($name:ident, $reverse:expr, $case:ident;)*) => {$( + #[tokio::test] + async fn $name() -> crate::Result<()> { scenario($reverse, Scenario::$case).await } + )*}; +} +cases! { + a_to_b_offer, false, Offered; b_to_a_offer, true, Offered; + a_to_b_offerless, false, Offerless; b_to_a_offerless, true, Offerless; + a_to_b_rejected, false, Rejected; b_to_a_rejected, true, Rejected; + a_to_b_cancelled, false, Cancelled; b_to_a_cancelled, true, Cancelled; + a_to_b_late_success, false, LateSuccess; b_to_a_late_success, true, LateSuccess; + a_to_b_missing_ack, false, MissingAck; b_to_a_missing_ack, true, MissingAck; + a_to_b_glare, false, Glare; b_to_a_glare, true, Glare; + a_to_b_shutdown, false, Shutdown; b_to_a_shutdown, true, Shutdown; +} + +#[test] +fn rejecting_answer_preserves_media_order_and_disables_every_stream() { + let mut offer = Response::default(); + offer.body = b"v=0\r\nm=audio 10000 RTP/AVP 0 8\r\nm=video 10002 RTP/SAVPF 96\r\nm=application 10004 UDP/DTLS/SCTP webrtc-datachannel\r\n".to_vec(); + let answer = PassthroughSdp.reject_offer(&offer); + let text = String::from_utf8(answer.body).unwrap(); + assert_eq!( + text.lines() + .filter(|l| l.starts_with("m=")) + .collect::>(), + vec![ + "m=audio 0 RTP/AVP 0 8", + "m=video 0 RTP/SAVPF 96", + "m=application 0 UDP/DTLS/SCTP webrtc-datachannel" + ] + ); +} + +#[tokio::test] +async fn cancel_before_application_dispatch_does_not_start_other_leg() -> crate::Result<()> { + let token = CancellationToken::new(); + let _guard = token.clone().drop_guard(); + let (a, mut states, peer) = establish_with_options(&token, None, Default::default()).await?; + let (b, _other_states, other) = + establish_with_options(&token, None, Default::default()).await?; + let bridge = ReinviteBridge::new(a.clone(), b)?; + let (request, address) = incoming(&a, &peer, true)?; + peer.send_to(request.to_string().as_bytes(), address) + .await?; + let handle = updated(&mut states).await; + let mut cancel = request.clone(); + cancel.method = Method::Cancel; + cancel.cseq_header_mut()?.mut_method(Method::Cancel)?; + cancel.body.clear(); + cancel.headers.unique_push(Header::ContentLength(0.into())); + peer.send_to(cancel.to_string().as_bytes(), address).await?; + received(&peer, Method::Cancel, 200).await?; + received(&peer, Method::Invite, 487).await?; + assert_eq!( + bridge.handle(a.id(), request.clone(), handle).await?.code(), + 487 + ); + ack(&peer, address, &request, None).await?; + let mut bytes = [0; 8192]; + assert!( + tokio::time::timeout(Duration::from_millis(30), other.recv_from(&mut bytes)) + .await + .is_err() + ); + Ok(()) +} diff --git a/tests/interop/COVERAGE.md b/tests/interop/COVERAGE.md index cd20659e..f66ded94 100644 --- a/tests/interop/COVERAGE.md +++ b/tests/interop/COVERAGE.md @@ -3,7 +3,23 @@ This harness is a growing collection of real-process interoperability tests, not a certification of complete SIP conformance. A passing case covers only the exchange and assertions stated for that case. -The current baseline is upstream `54e99b0` (0.8.1) with the standalone application tests. +The current baseline is upstream `895d443` (0.8.1) plus the re-INVITE bridge. + +## Established-dialog re-INVITE bridge + +`pjsip bridge` adds four UDP/TCP cases with two PJSUA processes: hold and resume +from either dialog leg, independent dialog identifiers and CSeq, SDP relay, +ACK on both legs, and teardown. `sipp bridge` adds four UDP/TCP offerless cases +plus one UDP ACK-loss case. SIPp supplies an offer in 200, waits for an explicit +driver handshake before returning the answer in ACK, and checks the answer +again after repeating the 200. The loss case drops the first SDP ACK at the +UDP socket boundary and requires a retransmitted ACK with identical contents. + +Library wire tests additionally cover 488, CANCEL and late 200, simultaneous +re-INVITEs, missing ACK and rejecting answers with multiple media streams. +They complement the external cases; raw UDP tests are not independent stack +implementations. Initial-call bridging, reliable provisional offer/answer, +session timers and media negotiation remain separate responsibilities. ## Known gap: standard SHA-256 digest challenge @@ -92,8 +108,8 @@ accepting other response codes. ## Executed matrix -There are 183 external-peer test executions: -173 regression cases and 10 known-gap probes. The lost-PRACK-response, +There are 192 external-peer test executions: +182 regression cases and 10 known-gap probes. The lost-PRACK-response, application lost-BYE-response and all fault-injection cases are UDP-only; the other families run on both transports. @@ -119,6 +135,7 @@ the other families run on both transports. | UDP races with SIPp | delayed ACK delivery, valid/wrong-tag BYE during blocked ACK, local BYE waiting for ACK, CANCEL crossing held 200, crossed BYEs | 6 | | Standalone proxy | two PJSUA peers; caller/callee BYE, 486, CANCEL; SIPp late 200 and lost BYE response; preserved dialog identity and Via/Record-Route forwarding | 11 | | Standalone B2BUA | two independent dialogs; caller/callee BYE, 486, CANCEL; SIPp late 200 and lost BYE response; independent identifiers and both-leg cleanup | 11 | +| Re-INVITE bridge | two PJSUA peers for hold/resume, two SIPp peers for offerless SDP, lost answer ACK | 9 | | Known-gap probes | SHA-256; PRACK | 10 | The lost-487 case is a regression test. An earlier fixture dropped the server diff --git a/tests/interop/README.md b/tests/interop/README.md index 9cbd3443..b2ef8fe6 100644 --- a/tests/interop/README.md +++ b/tests/interop/README.md @@ -21,21 +21,31 @@ brew install cmake pkg-config openssl@3 python From the repository root: ```sh -bash scripts/interop/run.sh regression # supported baseline (173 tests) -bash scripts/interop/run.sh all # all 183; includes 10 known-gap probes -bash scripts/interop/run.sh pjsip # 72 PJSUA regression tests +bash scripts/interop/run.sh regression # supported baseline (182 tests) +bash scripts/interop/run.sh all # all 192; includes 10 known-gap probes +bash scripts/interop/run.sh pjsip # 76 PJSUA regression tests bash scripts/interop/run.sh pjsip mid_dialog # 36 mid-dialog PJSUA cases -bash scripts/interop/run.sh sipp # 89 SIPp tests, including known gaps +bash scripts/interop/run.sh sipp # 94 SIPp tests, including known gaps bash scripts/interop/run.sh proxy # 11 standalone proxy cases bash scripts/interop/run.sh b2bua # 11 linked two-dialog B2BUA cases bash scripts/interop/run.sh sipp prack # all 19 PRACK cases, including known gaps bash scripts/interop/run.sh regression prack # 11 passing PRACK regression cases -bash scripts/interop/run.sh faults # 26 UDP loss/delay/race cases +bash scripts/interop/run.sh faults # 27 UDP loss/delay/race cases bash scripts/interop/run.sh known-gaps # reproduce documented failures bash scripts/interop/run.sh pjsip udp_uac_peer_bye # one test bash scripts/interop/run.sh sipp wrong_tag_bye # UDP and TCP +bash scripts/interop/run.sh pjsip bridge # two-peer hold/resume bridge +bash scripts/interop/run.sh sipp bridge # offerless bridge and lost SDP ACK ``` +The bridge cases use two independent peer processes and two rsipstack dialog +legs joined by the public `ReinviteBridge` component. Four PJSUA cases cover +hold/resume initiated from either leg over UDP/TCP. Five SIPp cases cover +offerless re-INVITEs in both directions, delayed answers supplied in ACK, +identical ACK retransmission, and loss of the first SDP-bearing ACK over UDP. +Each leg has a separate trace directory; both must finish without background +errors or live dialogs. These tests do not assert RTP delivery or PRACK bridging. + The **first explicit harness run** downloads and builds the selected peers in `target/interop`. Later runs reuse them. Normal `cargo build` and `cargo test` never download or run PJSIP/SIPp; these integration tests are marked `#[ignore]`. @@ -64,8 +74,7 @@ See [COVERAGE.md](COVERAGE.md) for the complete matrix, reproducible known gaps, and the features this suite does not exercise. The default (`all`) and `sipp` include known-gap probes and currently **return nonzero**. `regression` explicitly reports and excludes them; it does not change their assertions. -The documented counts describe upstream baseline `004f607` plus these application -tests; results can differ when +The documented counts describe upstream baseline `895d443` plus the re-INVITE bridge; results can differ when run against another revision or with uncommitted application changes. PJSUA checks calls in both directions, UDP loss/retransmission, hold/resume and UPDATE initiated by @@ -185,8 +194,8 @@ crash recovery remain outside this initial matrix. ## Controlled UDP faults and replay -`bash scripts/interop/run.sh faults` selects only the 26 fault scenarios. -All 26 are regression cases on upstream `004f607`, including the previously +`bash scripts/interop/run.sh faults` selects only the 27 fault scenarios. +All 27 are regression cases in this checkout, including the previously failing blocked-ACK cases fixed by PR #235. A `known-gaps faults` selection now matches no tests and fails explicitly rather than reporting a misleading pass. The six small fault-engine checks also run under normal `cargo test`; they diff --git a/tests/interop/pjsip.rs b/tests/interop/pjsip.rs index 88427e6a..ef31aae8 100644 --- a/tests/interop/pjsip.rs +++ b/tests/interop/pjsip.rs @@ -1,3 +1,4 @@ +mod bridge; mod faults; mod mid_dialog; use super::{bounded, log_dir, sdp, until, Peer, Stack}; diff --git a/tests/interop/pjsip/bridge.rs b/tests/interop/pjsip/bridge.rs new file mode 100644 index 00000000..30fb7d22 --- /dev/null +++ b/tests/interop/pjsip/bridge.rs @@ -0,0 +1,202 @@ +//! Two independent PJSUA call state machines joined by ReinviteBridge. +use crate::interop::{bounded, log_dir, until, until_result, Peer, Required, Stack, TestResult}; +use rsipstack::{ + dialog::{dialog::DialogState, invitation::InviteOption, reinvite_bridge::ReinviteBridge}, + sip::{Header, HeadersExt, Method, SipMessage}, +}; + +async fn scenario(name: &str, transport: &str, reverse: bool) -> TestResult { + let dir = log_dir(name)?; + let a_dir = dir.join("a"); + let b_dir = dir.join("b"); + std::fs::create_dir_all(&a_dir).required()?; + std::fs::create_dir_all(&b_dir).required()?; + let mut a_stack = Stack::start(transport, &a_dir).await?; + let b_stack = Stack::start(transport, &b_dir).await?; + let mut a_peer = Peer::start(transport, &a_dir).await?; + let mut b_peer = Peer::start(transport, &b_dir).await?; + a_peer.command(&format!("m\n{}\n", a_stack.uri)).await?; + let a = bounded("incoming A dialog", a_stack.incoming.recv()) + .await? + .required()?; + a.ringing(None, None).required()?; + let initial = a_stack.wire.request(false, Method::Invite).await?; + let (b, task) = b_stack + .layer + .do_invite_async( + InviteOption { + caller: b_stack.uri.clone(), + callee: b_peer.uri.clone(), + contact: b_stack.uri.clone(), + offer: Some(initial.body.clone()), + content_type: Some("application/sdp".into()), + ..Default::default() + }, + b_stack.sender.clone(), + ) + .required()?; + b_peer.wait_text("state changed to EARLY").await?; + b_peer.command("a\n200\n").await?; + let (_, response) = bounded("outgoing B dialog", task) + .await? + .required()? + .required()?; + let response = response.required()?; + a.accept( + Some(vec![Header::ContentType("application/sdp".into())]), + Some(response.body), + ) + .required()?; + a_stack + .state("A confirmed", |s| matches!(s, DialogState::Confirmed(..))) + .await?; + b_stack + .state("B confirmed", |s| matches!(s, DialogState::Confirmed(..))) + .await?; + a_peer.wait_text("state changed to CONFIRMED").await?; + b_peer.wait_text("state changed to CONFIRMED").await?; + let bridge = ReinviteBridge::new(a.clone(), b.clone()).required()?; + check!( + a.id().call_id != b.id().call_id, + "B2BUA legs must have independent Call-IDs" + ); + let (source, destination, initiator) = if reverse { + (&b_stack, &a_stack, &mut b_peer) + } else { + (&a_stack, &b_stack, &mut a_peer) + }; + for command in ["H\n", "v\n"] { + let source_offset = source.wire.checkpoint(); + let destination_offset = destination.wire.checkpoint(); + let state_offset = source + .states + .lock() + .unwrap_or_else(|p| p.into_inner()) + .len(); + initiator.command(command).await?; + let (id, request, handle) = until("incoming bridge re-INVITE", || { + source + .states + .lock() + .unwrap_or_else(|p| p.into_inner()) + .iter() + .skip(state_offset) + .find_map(|s| { + if let DialogState::Updated(id, request, handle) = s { + (request.method == Method::Invite) + .then(|| (id.clone(), request.clone(), handle.clone())) + } else { + None + } + }) + }) + .await?; + let status = bounded( + "bridged PJSUA re-INVITE", + bridge.handle(id, request.clone(), handle), + ) + .await? + .required()?; + check_eq!(status.code(), 200); + let forwarded = destination + .wire + .request_after(true, Method::Invite, destination_offset) + .await?; + check_eq!(forwarded.body, request.body); + check!(forwarded.call_id_header().required()? != request.call_id_header().required()?); + let answer = until_result("relayed SDP answer", || { + for packet in source + .wire + .0 + .lock() + .unwrap_or_else(|p| p.into_inner()) + .iter() + .skip(source_offset) + { + if let SipMessage::Response(r) = &packet.message { + if packet.sent + && r.status_code.code() == 200 + && r.cseq_header().required()?.method().required()? == Method::Invite + { + return Ok(Some(r.clone())); + } + } + } + Ok(None) + }) + .await?; + let text = String::from_utf8_lossy(&answer.body); + check!( + text.contains(if command == "H\n" { + "a=recvonly" + } else { + "a=sendrecv" + }), + "Unexpected answer: {text}" + ); + let incoming_ack = source + .wire + .request_after(false, Method::Ack, source_offset) + .await?; + let outgoing_ack = destination + .wire + .request_after(true, Method::Ack, destination_offset) + .await?; + check_eq!( + incoming_ack.cseq_header().required()?.seq().required()?, + request.cseq_header().required()?.seq().required()? + ); + check_eq!( + outgoing_ack.cseq_header().required()?.seq().required()?, + forwarded.cseq_header().required()?.seq().required()? + ); + check!(a.state().is_confirmed() && b.state().is_confirmed()); + } + bridge.shutdown(); + a_peer.command("h\n").await?; + a_stack + .state("A ended", |s| matches!(s, DialogState::Terminated(..))) + .await?; + bounded("forward teardown to B", b.bye()) + .await? + .required()?; + b_stack + .state("B ended", |s| matches!(s, DialogState::Terminated(..))) + .await?; + a_peer.wait_text("is DISCONNECTED").await?; + b_peer.wait_text("is DISCONNECTED").await?; + a_peer.stop().await?; + b_peer.stop().await?; + for (stack, path) in [(&a_stack, &a_dir), (&b_stack, &b_dir)] { + until("empty bridge dialog registry", || { + stack.layer.is_empty().then_some(()) + }) + .await?; + let ended = stack + .states + .lock() + .unwrap_or_else(|p| p.into_inner()) + .iter() + .filter(|s| matches!(s, DialogState::Terminated(..))) + .count(); + check_eq!(ended, 1); + stack + .finish(path, format!("{name}: bridge hold/resume and teardown\n")) + .await?; + } + Ok(()) +} + +macro_rules! cases { + ($($name:ident, $transport:literal, $reverse:expr;)*) => {$( + #[tokio::test] + #[ignore = "requires PJSUA; use scripts/interop/run.sh pjsip bridge"] + async fn $name() -> TestResult { scenario(stringify!($name), $transport, $reverse).await } + )*}; +} +cases! { + udp_bridge_a_to_b_hold_resume, "udp", false; + udp_bridge_b_to_a_hold_resume, "udp", true; + tcp_bridge_a_to_b_hold_resume, "tcp", false; + tcp_bridge_b_to_a_hold_resume, "tcp", true; +} diff --git a/tests/interop/scenarios/bridge_offerless_origin.xml b/tests/interop/scenarios/bridge_offerless_origin.xml new file mode 100644 index 00000000..eebc16e4 --- /dev/null +++ b/tests/interop/scenarios/bridge_offerless_origin.xml @@ -0,0 +1,101 @@ + + + + + + + + +Content-Type: application/sdp +Content-Length: [len] + +v=0 +o=sipp 1 1 IN IP4 127.0.0.1 +s=interop +c=IN IP4 127.0.0.1 +t=0 0 +m=audio 9 RTP/AVP 0 +a=rtpmap:0 PCMU/8000 +a=inactive +]]> + + + + +Max-Forwards: 70 +Content-Length: 0 + +]]> + + + + + + + + + + + + + diff --git a/tests/interop/scenarios/bridge_offerless_peer.xml b/tests/interop/scenarios/bridge_offerless_peer.xml new file mode 100644 index 00000000..5891e016 --- /dev/null +++ b/tests/interop/scenarios/bridge_offerless_peer.xml @@ -0,0 +1,126 @@ + + + + +Content-Type: application/sdp +Content-Length: [len] + +v=0 +o=sipp 1 1 IN IP4 127.0.0.1 +s=interop +c=IN IP4 127.0.0.1 +t=0 0 +m=audio 9 RTP/AVP 0 +a=rtpmap:0 PCMU/8000 +a=inactive +]]> + + + + + + + + + + + +Content-Type: application/sdp +Content-Length: [len] + +v=0 +o=destination 3 2 IN IP4 127.0.0.1 +s=interop +c=IN IP4 127.0.0.1 +t=0 0 +m=audio 9 RTP/AVP 0 +a=rtpmap:0 PCMU/8000 +a=sendonly +]]> + + + + diff --git a/tests/interop/sipp.rs b/tests/interop/sipp.rs index e0bc6606..3dadfbec 100644 --- a/tests/interop/sipp.rs +++ b/tests/interop/sipp.rs @@ -10,6 +10,7 @@ use std::{ process::Stdio, }; use tokio::process::{Child, Command}; +mod bridge; mod extended; mod faults; mod prack_uas; @@ -66,7 +67,10 @@ impl Sipp { // duplicate detector would otherwise consume it before the XML step. let duplicate_flags = if matches!( scenario, - "duplicate_200" | "prack_lost_response" | "application_lost_bye_response" + "duplicate_200" + | "prack_lost_response" + | "bridge_offerless_peer" + | "application_lost_bye_response" ) { vec!["-nr"] } else { diff --git a/tests/interop/sipp/bridge.rs b/tests/interop/sipp/bridge.rs new file mode 100644 index 00000000..daadd0ed --- /dev/null +++ b/tests/interop/sipp/bridge.rs @@ -0,0 +1,199 @@ +//! Controlled offerless exchange between two independent SIPp peers. +use super::Sipp; +use crate::interop::{bounded, log_dir, sdp, until, Required, Stack, TestResult}; +use rsipstack::{ + dialog::{dialog::DialogState, invitation::InviteOption, reinvite_bridge::ReinviteBridge}, + sip::{Header, HeadersExt, Method, SipMessage}, +}; + +async fn scenario(name: &str, transport: &str, reverse: bool, lose_ack: bool) -> TestResult { + let dir = log_dir(name)?; + let origin_dir = dir.join("origin"); + let destination_dir = dir.join("destination"); + std::fs::create_dir_all(&origin_dir).required()?; + std::fs::create_dir_all(&destination_dir).required()?; + let origin = Stack::start(transport, &origin_dir).await?; + let destination = if lose_ack { + use crate::interop::faults::{Action, Direction, Rule}; + Stack::with_faults( + &destination_dir, + vec![Rule::new( + "bridge_answer_ack", + Direction::Send, + Method::Ack, + None, + 2, + Action::Drop, + )], + ) + .await? + } else { + Stack::start(transport, &destination_dir).await? + }; + let mut origin_peer = Sipp::start( + "bridge_offerless_origin", + transport, + &origin_dir, + &origin.uri, + ) + .await?; + let mut destination_peer = Sipp::start( + "bridge_offerless_peer", + transport, + &destination_dir, + &destination.uri, + ) + .await?; + let mut dialogs = Vec::new(); + for (stack, peer) in [(&origin, &origin_peer), (&destination, &destination_peer)] { + let (dialog, task) = stack + .layer + .do_invite_async( + InviteOption { + caller: stack.uri.clone(), + callee: peer.uri.clone(), + contact: stack.uri.clone(), + offer: Some(sdp()), + content_type: Some("application/sdp".into()), + ..Default::default() + }, + stack.sender.clone(), + ) + .required()?; + bounded("initial SIPp dialog", task) + .await? + .required()? + .required()?; + stack.wire.request(true, Method::Ack).await?; + dialogs.push(dialog); + } + let bridge = if reverse { + ReinviteBridge::new(dialogs[1].clone(), dialogs[0].clone()) + } else { + ReinviteBridge::new(dialogs[0].clone(), dialogs[1].clone()) + } + .required()?; + let source_offset = origin.wire.checkpoint(); + let target_offset = destination.wire.checkpoint(); + bounded( + "start offerless re-INVITE", + dialogs[0].request(Method::Options, None, None), + ) + .await? + .required()?; + let (id, request, handle) = until("SIPp offerless re-INVITE", || { + origin + .states + .lock() + .unwrap_or_else(|p| p.into_inner()) + .iter() + .find_map(|s| { + if let DialogState::Updated(id, request, handle) = s { + (request.method == Method::Invite) + .then(|| (id.clone(), request.clone(), handle.clone())) + } else { + None + } + }) + }) + .await?; + check!(request.body.is_empty()); + let bridge_task = bridge.clone(); + let task = tokio::spawn(async move { bridge_task.handle(id, request, handle).await }); + origin_peer.marker("BRIDGE_OFFER_RECEIVED").await?; + { + let wire = destination.wire.0.lock().unwrap_or_else(|p| p.into_inner()); + check!(!wire.iter().skip(target_offset).any(|p| matches!(&p.message, SipMessage::Request(r) if p.sent && r.method == Method::Ack)), "ACK escaped before the other leg supplied its SDP answer"); + } + bounded( + "release ACK answer", + dialogs[0].request( + Method::Message, + Some(vec![Header::ContentType("text/plain".into())]), + Some(b"answer now".to_vec()), + ), + ) + .await? + .required()?; + check_eq!( + bounded("bridge result", task) + .await? + .required()? + .required()? + .code(), + 200 + ); + destination_peer.marker("BRIDGE_ACK_REPEATED").await?; + let received = origin + .wire + .request_after(false, Method::Ack, source_offset) + .await?; + let sent = destination + .wire + .request_after(true, Method::Ack, target_offset) + .await?; + check_eq!(received.body, sent.body); + check!(received.call_id_header().required()? != sent.call_id_header().required()?); + let wire = destination + .wire + .0 + .lock() + .unwrap_or_else(|p| p.into_inner()) + .clone(); + let acks: Vec<_> = wire + .iter() + .skip(target_offset) + .filter_map(|p| match &p.message { + SipMessage::Request(r) if p.sent && r.method == Method::Ack => Some(r), + _ => None, + }) + .collect(); + check_eq!(acks.len(), if lose_ack { 3 } else { 2 }); + for ack in &acks { + check_eq!(*ack, acks[0]); + } + if let Some(control) = &destination.faults { + control.check_retransmissions().await?; + } + bridge.shutdown(); + for dialog in &dialogs { + bounded("bridge BYE", dialog.bye()).await?.required()?; + } + origin_peer.finish().await?; + destination_peer.finish().await?; + for (stack, path) in [(&origin, &origin_dir), (&destination, &destination_dir)] { + until("empty bridge registry", || { + stack.layer.is_empty().then_some(()) + }) + .await?; + stack + .finish( + path, + format!("{name}: offerless bridge and repeated SDP ACK\n"), + ) + .await?; + } + Ok(()) +} +macro_rules! cases { + ($($name:ident, $transport:literal, $reverse:expr;)*) => {$( + #[tokio::test] + #[ignore = "requires SIPp; use scripts/interop/run.sh sipp bridge"] + async fn $name() -> TestResult { scenario(stringify!($name), $transport, $reverse, false).await } + )*}; +} +cases! { + udp_bridge_a_to_b_offerless, "udp", false; + udp_bridge_b_to_a_offerless, "udp", true; + tcp_bridge_a_to_b_offerless, "tcp", false; + tcp_bridge_b_to_a_offerless, "tcp", true; +} + +mod faults { + use super::*; + #[tokio::test] + #[ignore = "requires SIPp; use scripts/interop/run.sh faults bridge"] + async fn udp_bridge_offerless_lost_answer_ack() -> TestResult { + scenario("udp_bridge_offerless_lost_answer_ack", "udp", false, true).await + } +} From c6a2872a1a5396cc267ac53706216b89849707a1 Mon Sep 17 00:00:00 2001 From: Fedor Kiselev <116813641+FedorKiselev76@users.noreply.github.com> Date: Thu, 5 Nov 2026 10:09:38 +0000 Subject: [PATCH 08/12] feat(dialog): implement opt-in UAC and UAS PRACK/100rel --- Cargo.toml | 6 + README.md | 82 + examples/prack_probe.rs | 141 ++ src/dialog/client_dialog.rs | 9 + src/dialog/dialog.rs | 400 ++++- src/dialog/dialog_layer.rs | 48 +- src/dialog/invitation.rs | 12 +- src/dialog/invite_dialog.rs | 60 +- src/dialog/mod.rs | 1 + src/dialog/reinvite.rs | 29 +- src/dialog/reinvite_bridge.rs | 7 +- src/dialog/reliable.rs | 867 +++++++++++ src/dialog/server_dialog.rs | 39 +- src/dialog/tests/mod.rs | 2 + src/dialog/tests/test_prack.rs | 32 +- src/dialog/tests/test_prack_validation.rs | 328 ++++ src/dialog/tests/test_reliable_provisional.rs | 1327 +++++++++++++++++ src/dialog/tests/test_target_refresh.rs | 7 +- src/sip/message.rs | 72 +- src/transaction/transaction.rs | 34 +- tests/interop/COVERAGE.md | 64 +- tests/interop/README.md | 14 +- tests/interop/scenarios/prack_sdp.xml | 80 + tests/interop/scenarios/prack_uas.xml | 4 +- tests/interop/scenarios/prack_uas_reject.xml | 6 +- .../scenarios/prack_uas_retransmit.xml | 4 +- tests/interop/sipp.rs | 2 + tests/interop/sipp/extended.rs | 7 +- tests/interop/sipp/prack_sdp.rs | 244 +++ tests/interop/sipp/prack_uas.rs | 40 +- 30 files changed, 3749 insertions(+), 219 deletions(-) create mode 100644 examples/prack_probe.rs create mode 100644 src/dialog/reliable.rs create mode 100644 src/dialog/tests/test_prack_validation.rs create mode 100644 src/dialog/tests/test_reliable_provisional.rs create mode 100644 tests/interop/scenarios/prack_sdp.xml create mode 100644 tests/interop/sipp/prack_sdp.rs diff --git a/Cargo.toml b/Cargo.toml index 22770621..725e954c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -86,6 +86,7 @@ embassy-time = { version = "0.5", optional = true, default-features = false } critical-section = { version = "1", optional = true } [dev-dependencies] +tokio = { version = "1.50.0", features = ["test-util"] } dotenvy = "0.15.7" tempfile = "3" sdp-rs = "0.2.1" @@ -112,3 +113,8 @@ required-features = ["platform-tokio"] [[example]] name = "interop_b2bua" required-features = ["platform-tokio"] + +[[example]] +name = "prack_probe" +path = "examples/prack_probe.rs" +required-features = ["platform-tokio"] diff --git a/README.md b/README.md index bdbdbf78..65aa6c34 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,88 @@ A RFC 3261/3262 compliant SIP stack written in Rust. The goal of this project is - **Digest Authentication**: Built-in authentication support - **no_std / Embedded**: alloc-only core with an embassy backend +## Reliable provisional responses (100rel / PRACK) + +Full UAC and UAS signaling is enabled explicitly on the dialog layer: + +```rust,ignore +use rsipstack::dialog::reliable::ReliableProvisionalConfig; + +// media implements the async PrackHandler trait. +let mut config = ReliableProvisionalConfig::new(media); +config.require = false; // true additionally sends Require: 100rel on INVITEs +dialog_layer.set_reliable_provisional(Some(config)); +``` + +The setting applies to new calls and restored confirmed dialogs. The UAS sends +reliable 101–199 only when the INVITE advertises or requires 100rel. Without this +configuration, required 100rel is rejected with 420/Unsupported; ordinary calls +keep their existing behavior. The legacy `InviteOption::support_prack` switch +does not install a media handler and is not needed with the full configuration. + +The stack assigns RSeq, validates RAck, keeps state per dialog and INVITE CSeq, +retransmits reliable provisionals from T1 with exponential backoff (without a +T2 cap), and rejects the INVITE after 64*T1 without PRACK. It serializes reliable +provisionals and defers final 2xx while a reliable SDP response is unacknowledged. +CANCEL/non-2xx finals discard a queued successful final; late PRACK remains +routable for 64*T1 when a dialog is removed. PRACK requests use independent +transactions, including authentication and retransmission, so waiting for their +responses does not block INVITE final responses or cancellation. + +`PrackHandler` is the media boundary: + +- `on_reliable_response`: for `Offer`, return an SDP answer for PRACK. For + `Answer`, consume the answer and return either no body or a new SDP offer. +- `on_prack`: consume an SDP answer received in PRACK; return an SDP answer + when PRACK contains an offer. +- `on_prack_result`: receives the final PRACK response, including the answer + to an offer sent in PRACK; `None` means transaction timeout. +- `on_error`: reports transport, timeout, protocol or media-handler failures. + +`SdpKind::Ignored` marks subsequent SDP for an INVITE whose initial description +has already been processed. Do not renegotiate from that body. The ordinary +Early/Confirmed events retain raw SIP messages for observation; applications +using the handler should not apply their SDP a second time. Media negotiation, +codec selection, rejected-media answers, RTP, and coordination with application +UPDATE/re-INVITE offers remain the media application's responsibility. A failed +UAS media callback returns 500 and fails the pending INVITE rather than leaving +a deferred final response waiting indefinitely. + +The existing INVITE/ACK API still handles SDP first delivered in a final 2xx. +For an offerless INVITE that might receive its first offer in 2xx instead of +reliable 1xx, disable automatic 2xx ACKs (`EndpointOption::auto_ack_2xx = false`) +and supply the SDP answer through the application's ACK handling. The new +handler owns SDP in reliable provisional responses and PRACK, not ordinary +INVITE/ACK or UPDATE exchanges. + +For an initial server INVITE, use the usual `ringing()` and `accept()` methods; +for a re-INVITE, use its `TransactionHandle`. Keep the INVITE transaction's owning +task running: it sends queued responses and retransmissions. With 100rel enabled, +Early/WaitAck notifications reflect actual response transmission, which may occur +after `ringing()`/`accept()` returns. Configure the layer before creating calls; +do not change a dialog's configuration during an INVITE exchange. + +An independent UDP signaling probe is provided in `examples/prack_probe.rs`. +It accepts an application-prepared SDP file and sends no RTP: + +```bash +cargo run --example prack_probe -- \ + 0.0.0.0:5062 sip:100@example.net sip:destination@example.net \ + sip:100@YOUR_PUBLIC_IP:5062 ./compatible-sdp.txt --require +``` + +The probe sends the file as the INVITE offer. Optional digest credentials +come from `SIP_USERNAME`, `SIP_PASSWORD`, and `SIP_REALM`. The probe sends BYE +after an answered call and does not modify any application configuration. + +The regression suite covers RFC 3262 sections 3–5 and the SDP patterns clarified +by RFC 6337, including real UDP stack-to-stack calls and deterministic timers: + +```bash +cargo test --lib test_reliable_provisional +bash scripts/interop/run.sh regression prack +``` + ## no_std / Embedded Support rsipstack compiles without `std` (`alloc`-only) for embassy-based targets — diff --git a/examples/prack_probe.rs b/examples/prack_probe.rs new file mode 100644 index 00000000..87e6b26a --- /dev/null +++ b/examples/prack_probe.rs @@ -0,0 +1,141 @@ +//! UDP SIP signaling probe; it does not run an RTP/media engine. +//! Usage: prack_probe LISTEN FROM CALLEE CONTACT SDP_FILE [--require] +//! Supply an SDP offer prepared for the peer's media capabilities. +use async_trait::async_trait; +use rsipstack::dialog::{ + authenticate::Credential, + dialog_layer::DialogLayer, + invitation::InviteOption, + reliable::{ + IncomingPrack, PrackBody, PrackHandler, ReliableProvisionalConfig, ReliableResponse, + SdpKind, + }, + DialogId, +}; +use rsipstack::sip::{Request, Response, StatusCodeKind}; +use rsipstack::transport::{udp::UdpConnection, TransportLayer}; +use rsipstack::{EndpointBuilder, Result}; +use std::{env, sync::Arc, time::Duration}; +use tokio_util::sync::CancellationToken; + +struct Media { + sdp: Vec, +} +#[async_trait] +impl PrackHandler for Media { + async fn on_reliable_response(&self, event: ReliableResponse) -> Result> { + eprintln!( + "reliable {}: {:?}, dialog {}", + event.response.status_code, event.sdp_kind, event.dialog_id + ); + Ok((event.sdp_kind == SdpKind::Offer).then(|| PrackBody::sdp(self.sdp.clone()))) + } + async fn on_prack(&self, event: IncomingPrack) -> Result> { + eprintln!("incoming PRACK: {:?}", event.sdp_kind); + Ok((event.sdp_kind == SdpKind::Offer).then(|| PrackBody::sdp(self.sdp.clone()))) + } + async fn on_prack_result(&self, _: Request, response: Option) { + eprintln!( + "PRACK result: {}", + response + .map(|r| r.status_code.to_string()) + .unwrap_or_else(|| "timeout".into()) + ); + } + async fn on_error(&self, id: DialogId, message: String) { + eprintln!("100rel error ({id}): {message}"); + } +} + +#[tokio::main] +async fn main() -> std::result::Result<(), Box> { + let args: Vec<_> = env::args().skip(1).collect(); + if args.len() < 5 || args.iter().any(|a| a == "--help") { + eprintln!("Usage: prack_probe LISTEN FROM CALLEE CONTACT SDP_FILE [--require]\nSends one real SIP call and BYE after answer. SDP must be prepared for the peer; no RTP is sent."); + return Ok(()); + } + for flag in &args[5..] { + if flag != "--require" { + return Err(format!("Unknown option: {flag}").into()); + } + } + let media = Arc::new(Media { + sdp: std::fs::read(&args[4])?, + }); + if media.sdp.is_empty() { + return Err("SDP file is empty".into()); + } + let token = CancellationToken::new(); + let transport = TransportLayer::new(token.child_token()); + let udp = + UdpConnection::create_connection(args[0].parse()?, None, Some(token.child_token())).await?; + transport.add_transport(udp.into()); + let endpoint = EndpointBuilder::new() + .with_transport_layer(transport) + .with_cancel_token(token.child_token()) + .build(); + let layer = Arc::new(DialogLayer::new(endpoint.inner.clone())); + layer.set_reliable_provisional(Some(ReliableProvisionalConfig { + handler: media.clone(), + require: args.iter().any(|a| a == "--require"), + })); + let mut incoming = endpoint.incoming_transactions()?; + let router = layer.clone(); + tokio::spawn(async move { + while let Some(mut tx) = incoming.recv().await { + if let Some(mut dialog) = router.match_dialog(&tx) { + tokio::spawn(async move { dialog.handle(&mut tx).await }); + } else { + tx.reply(rsipstack::sip::StatusCode::CallTransactionDoesNotExist) + .await + .ok(); + } + } + }); + let server = endpoint.inner.clone(); + tokio::spawn(async move { server.serve().await }); + let credential = match (env::var("SIP_USERNAME"), env::var("SIP_PASSWORD")) { + (Ok(username), Ok(password)) => Some(Credential { + username, + password, + realm: env::var("SIP_REALM").ok(), + auth_username: None, + }), + (Err(_), Err(_)) => None, + _ => return Err("Set both SIP_USERNAME and SIP_PASSWORD".into()), + }; + let option = InviteOption { + caller: args[1].as_str().try_into()?, + callee: args[2].as_str().try_into()?, + contact: args[3].as_str().try_into()?, + offer: Some(media.sdp.clone()), + credential, + ..Default::default() + }; + let (states, mut events) = tokio::sync::mpsc::unbounded_channel(); + tokio::spawn(async move { + while let Some(event) = events.recv().await { + eprintln!("{event}"); + } + }); + let (dialog, mut join) = layer.do_invite_async(option, states)?; + let (_, result) = match tokio::time::timeout(Duration::from_secs(60), &mut join).await { + Ok(result) => result??, + Err(_) => { + dialog.cancel().await?; + let _ = tokio::time::timeout(Duration::from_secs(35), &mut join).await; + token.cancel(); + return Err("Call setup timed out; CANCEL requested".into()); + } + }; + if let Some(response) = result { + eprintln!("INVITE result: {}", response.status_code); + if response.status_code.kind() == StatusCodeKind::Successful { + tokio::time::sleep(Duration::from_secs(2)).await; + dialog.bye().await?; + } + } + layer.remove_dialog(&dialog.id()); + token.cancel(); + Ok(()) +} diff --git a/src/dialog/client_dialog.rs b/src/dialog/client_dialog.rs index 5e6a1598..e06b3a1e 100644 --- a/src/dialog/client_dialog.rs +++ b/src/dialog/client_dialog.rs @@ -565,6 +565,11 @@ impl ClientInviteDialog { "handle request" ); + self.inner.attach_reliable_server(tx)?; + if self.inner.reject_required_100rel(tx).await? { + return Ok(()); + } + let cseq = tx.original.cseq_header()?.seq()?; let remote_seq = self.inner.remote_seq.load(Ordering::Relaxed); if remote_seq > 0 && cseq < remote_seq { @@ -584,6 +589,10 @@ impl ClientInviteDialog { .compare_exchange(remote_seq, cseq, Ordering::Relaxed, Ordering::Relaxed) .ok(); + if tx.original.method == crate::sip::Method::PRack { + return self.inner.receive_prack(tx).await; + } + if self.inner.is_confirmed() { match tx.original.method { crate::sip::Method::Invite => return self.handle_reinvite(tx).await, diff --git a/src/dialog/dialog.rs b/src/dialog/dialog.rs index fdd19832..f3942682 100644 --- a/src/dialog/dialog.rs +++ b/src/dialog/dialog.rs @@ -273,15 +273,15 @@ impl Dialog { #[derive(Clone)] pub(super) struct RemoteReliableState { - last_rseq: u32, + dialog_id: DialogId, invite_cseq: u32, - prack_request: Request, + last_rseq: u32, } /// A validated Contact, kept separate from the dialog until its refresh is accepted. pub(super) struct RemoteTarget { - uri: crate::sip::Uri, - contact: crate::sip::headers::untyped::Contact, + pub(super) uri: crate::sip::Uri, + pub(super) contact: crate::sip::headers::untyped::Contact, } /// Internal Dialog State and Management @@ -349,7 +349,10 @@ pub struct DialogInner { // initial request updated when INVITE auth failed with new INVITE pub(super) initial_request: Mutex, pub(super) supports_100rel: bool, - pub(super) remote_reliable: Mutex>, + pub(super) remote_reliable: Mutex>, + pub(super) reliable_clients: Mutex>, + pub(super) reliable_config: Mutex>, + pub(super) reliable_servers: Mutex>>, /// The last ACK received for an INVITE or re-INVITE this dialog answered /// (UAS role). Carries the answer when the 2xx carried the offer. pub(super) remote_ack: Mutex>, @@ -546,7 +549,10 @@ impl DialogInner { local_contact, remote_contact: Mutex::new(None), supports_100rel, - remote_reliable: Mutex::new(None), + remote_reliable: Mutex::new(Vec::new()), + reliable_clients: Mutex::new(BTreeMap::new()), + reliable_config: Mutex::new(None), + reliable_servers: Mutex::new(BTreeMap::new()), remote_ack: Mutex::new(None), server_connection: Mutex::new(None), dialback_target: Mutex::new(None), @@ -654,59 +660,98 @@ impl DialogInner { Ok(()) } - fn clear_remote_reliable(&self) { - self.remote_reliable.lock().take(); + pub(super) fn attach_reliable_server(self: &Arc, tx: &Transaction) -> Result<()> { + if tx.original.method != Method::Invite { + return Ok(()); + } + let Some(config) = self.reliable_config.lock().clone() else { + return Ok(()); + }; + if !tx.original.header_contains_token("Supported", "100rel") + && !tx.original.header_contains_token("Require", "100rel") + { + return Ok(()); + } + let cseq = tx.original.cseq_header()?.seq()?; + let mut servers = self.reliable_servers.lock(); + let server = servers + .entry(cseq) + .or_insert_with(|| { + super::reliable::ReliableServer::new( + self, + tx.original.clone(), + tx.tu_sender.clone(), + config, + ) + }) + .clone(); + *tx.reliable_provisional.lock() = Some(server); + Ok(()) + } + + pub(super) async fn receive_prack(&self, tx: &mut Transaction) -> Result<()> { + let Some((_, cseq, _)) = crate::sip::message::rack_parts(&tx.original) else { + return tx.reply(StatusCode::BadRequest).await; + }; + let server = self.reliable_servers.lock().get(&cseq).cloned(); + if let Some(server) = server { + server.handle_prack(tx).await + } else { + self.reject_unmatched_prack(tx).await + } + } + + pub(super) fn clear_remote_reliable(&self, invite_cseq: u32) { + self.reliable_clients + .lock() + .retain(|(_, cseq), _| *cseq != invite_cseq); + self.remote_reliable + .lock() + .retain(|s| s.invite_cseq != invite_cseq); } pub(super) fn prepare_prack_request(&self, resp: &Response) -> Result> { - if !resp.header_contains_token("Require", "100rel") { + if !(101..200).contains(&resp.status_code.code()) + || !resp.header_contains_token("Require", "100rel") + { return Ok(None); } - let Some(rseq) = resp.rseq_value() else { - warn!( - id = self.id.lock().to_string(), - "received reliable provisional response without RSeq" - ); return Ok(None); }; - if rseq == 0 || rseq > 0x7fff_ffff { - return Ok(None); - } - let cseq_header = resp.cseq_header()?; let cseq = cseq_header.seq()?; - let method = cseq_header.method()?; - if method != Method::Invite { + if cseq_header.method()? != Method::Invite { return Ok(None); } - + let dialog_id = DialogId::try_from((resp, TransactionRole::Client))?; + let local_id = self.id.lock().clone(); + if dialog_id.call_id != local_id.call_id + || dialog_id.local_tag != local_id.local_tag + || dialog_id.remote_tag.is_empty() { - let state_guard = self.remote_reliable.lock(); - if let Some(state) = state_guard.as_ref() { - if state.invite_cseq == cseq && state.last_rseq == rseq { - return Ok(Some(state.prack_request.clone())); - } + return Ok(None); + } - if cseq < state.invite_cseq || (state.invite_cseq == cseq && state.last_rseq > rseq) - { - return Ok(None); - } + let mut states = self.remote_reliable.lock(); + let state = states + .iter_mut() + .find(|s| s.dialog_id == dialog_id && s.invite_cseq == cseq); + if let Some(state) = state.as_ref() { + // RFC 3262 §4: duplicates, old responses and gaps are discarded + // without delivering their SDP or generating another PRACK. + if state.last_rseq.checked_add(1) != Some(rseq) { + return Ok(None); } + } else if rseq > i32::MAX as u32 { + // The first RSeq in a transaction is in 1..=2^31-1 (§3). + return Ok(None); } - - // RFC 6141 §4.7/4.9: a reliable INVITE provisional response refreshes - // the target before PRACK is built. Duplicates/older RSeqs above must - // not replay an old Contact. Initial-dialog route learning is separate. + // RFC 6141: a newly accepted reliable provisional refreshes Contact + // before its PRACK is routed. Duplicates and gaps were rejected above. self.refresh_target_from_response(resp)?; - - let rack_value = format!("{} {} {}", rseq, cseq, method); - let mut headers = vec![Header::RAck(rack_value.into())]; - if self.supports_100rel { - headers.push(Header::Supported("100rel".into())); - } - - let prack_request = self.make_request( + let headers = vec![Header::RAck(format!("{} {} INVITE", rseq, cseq).into())]; + let mut prack = self.make_request( Method::PRack, Some(self.increment_local_seq()), None, @@ -714,35 +759,117 @@ impl DialogInner { Some(headers), None, )?; + // Select the early dialog that sent this response, including forks. + prack + .headers + .unique_push(Header::To(resp.to_header()?.clone())); + if let Some(state) = state { + state.last_rseq = rseq; + } else { + states.push(RemoteReliableState { + dialog_id, + invite_cseq: cseq, + last_rseq: rseq, + }); + } + Ok(Some(prack)) + } - let state = RemoteReliableState { - last_rseq: rseq, - invite_cseq: cseq, - prack_request: prack_request.clone(), - }; - + /// Returns false when the provisional must be discarded, including its body. + pub(super) async fn handle_provisional_response( + self: &Arc, + resp: &Response, + request: &Request, + ) -> Result { + if resp.header_contains_token("Require", "100rel") && resp.status_code != StatusCode::Trying { - let mut state_guard = self.remote_reliable.lock(); - *state_guard = Some(state); - } + let config = self.reliable_config.lock().clone(); + if let Some(config) = config { + return self.start_reliable_prack(resp, request, config); + } - Ok(Some(prack_request)) + if request.method != Method::Invite + || resp.cseq_header()?.seq()? != request.cseq_header()?.seq()? + { + return Ok(false); + } + // An in-dialog response must not change the peer's tag. + if let Some(tag) = request.to_header()?.tag()? { + if resp.to_header()?.tag()?.as_ref() != Some(&tag) { + return Ok(false); + } + } + let Some(prack) = self.prepare_prack_request(resp)? else { + return Ok(false); + }; + if let Some(tag) = resp.to_header()?.tag()? { + self.update_remote_tag(tag.value())?; + } + let _ = self.send_prack_request(prack).await?; + } else if resp.status_code != StatusCode::Trying { + if let Some(tag) = resp.to_header()?.tag()? { + self.update_remote_tag(tag.value())?; + } + } + Ok(true) } - pub(super) async fn handle_provisional_response(&self, resp: &Response) -> Result<()> { - let to_header = resp.to_header()?; - if let Ok(Some(tag)) = to_header.tag() { - self.update_remote_tag(tag.value())?; + /// Disabled dialogs reject required 100rel rather than falsely accepting it. + /// RFC 3262 §3 explicitly permits rejecting required 100rel with 420. + pub(super) async fn reject_required_100rel(&self, tx: &mut Transaction) -> Result { + if self.reliable_config.lock().is_some() + || tx.original.method != Method::Invite + || !tx.original.header_contains_token("Require", "100rel") + { + return Ok(false); } - - if let Some(prack) = self.prepare_prack_request(resp)? { - let _ = self.send_prack_request(prack).await?; + let initial = + self.role == TransactionRole::Server && tx.original.to_header()?.tag()?.is_none(); + tx.reply_with( + StatusCode::BadExtension, + vec![Header::Unsupported("100rel".into())], + None, + ) + .await?; + if initial { + let id = self.id.lock().clone(); + self.transition(DialogState::Terminated( + id, + TerminatedReason::UasOther(StatusCode::BadExtension), + )); } + Ok(true) + } - Ok(()) + pub(super) async fn reject_unmatched_prack(&self, tx: &mut Transaction) -> Result<()> { + // A syntactically valid RAck is not proof of a matching outstanding + // reliable response. The built-in UAS does not create any (§3). + let status = if crate::sip::message::rack_parts(&tx.original).is_some() { + StatusCode::CallTransactionDoesNotExist + } else { + StatusCode::BadRequest + }; + tx.reply(status).await } pub(super) async fn send_prack_request(&self, request: Request) -> Result> { + self.send_prack_request_to(request, None).await + } + + pub(super) async fn send_prack_request_to( + &self, + request: Request, + destination: Option, + ) -> Result> { + let tx = self.start_prack_transaction(request, destination).await?; + self.finish_prack_transaction(tx).await + } + + pub(super) async fn start_prack_transaction( + &self, + request: Request, + destination: Option, + ) -> Result { let method = request.method().to_owned(); let key = TransactionKey::from_request(&request, TransactionRole::Client)?; // RFC 5626 flow affinity: reuse the reliable connection recorded for @@ -755,7 +882,9 @@ impl DialogInner { affinity_connection, ); - if let Some(route) = tx.original.route_header() { + if destination.is_some() { + tx.destination = destination; + } else if let Some(route) = tx.original.route_header() { if let Ok(first_route) = route.typed() { tx.destination = SipAddr::try_from(&first_route.uri).ok(); } @@ -784,6 +913,13 @@ impl DialogInner { } } + Ok(tx) + } + + pub(super) async fn finish_prack_transaction( + &self, + mut tx: Transaction, + ) -> Result> { let mut auth = AuthRetry::new(); while let Some(msg) = tx.receive().await { match msg { @@ -792,6 +928,9 @@ impl DialogInner { StatusCode::ProxyAuthenticationRequired | StatusCode::Unauthorized => { let id = self.id.lock().clone(); if !auth.should_answer(&resp) { + if self.reliable_config.lock().is_some() { + return Ok(Some(resp)); + } debug!( id = self.id.lock().to_string(), "received {} response after auth sent", resp.status_code @@ -808,6 +947,9 @@ impl DialogInner { tx.send().await?; continue; } else { + if self.reliable_config.lock().is_some() { + return Ok(Some(resp)); + } debug!( id = self.id.lock().to_string(), "received 407 response without auth option" @@ -900,9 +1042,7 @@ impl DialogInner { && response.status_code.kind() == StatusCodeKind::Provisional && response.status_code != StatusCode::Trying && response.header_contains_token("Require", "100rel") - && response - .rseq_value() - .is_some_and(|rseq| (1..=0x7fff_ffff).contains(&rseq)))) + && response.rseq_value().is_some())) } /// Update the stored route set from Record-Route headers present in a response. @@ -1010,13 +1150,22 @@ impl DialogInner { } } - Ok(crate::sip::Request { + let mut request = crate::sip::Request { method, uri: self.remote_uri.lock().clone(), headers: out.into(), body: body.unwrap_or_default(), version: crate::sip::Version::V2, - }) + }; + if request.method == Method::Invite { + if let Some(config) = self.reliable_config.lock().as_ref() { + super::reliable::add_option(&mut request, "Supported", "100rel"); + if config.require { + super::reliable::add_option(&mut request, "Require", "100rel"); + } + } + } + Ok(request) } pub(super) fn make_request( @@ -1264,7 +1413,7 @@ impl DialogInner { } async fn send_dialog_request( - &self, + self: &Arc, request: Request, options: Option, ) -> Result> { @@ -1439,15 +1588,19 @@ impl DialogInner { } if status.kind() == StatusCodeKind::Provisional { + if method == Method::Invite + && !self + .handle_provisional_response(&resp, &tx.original) + .await? + { + continue; + } if let Some(sender) = options .as_ref() .and_then(|o| o.provisional_responses.as_ref()) { sender.send(resp.clone()).ok(); } - if method == Method::Invite { - self.handle_provisional_response(&resp).await?; - } // RFC 3261 §12: a dialog moves from early to confirmed // and never back. A 1xx to a mid-dialog request (re-INVITE, // UPDATE, ...) must not regress an established dialog to @@ -1483,7 +1636,7 @@ impl DialogInner { // established session (RFC 3261 sections 12/14.1). if self.is_confirmed() { if method != Method::PRack { - self.clear_remote_reliable(); + self.clear_remote_reliable(tx.original.cseq_header()?.seq()?); } return Ok(Some(resp)); } @@ -1521,7 +1674,7 @@ impl DialogInner { // another operation or normal call teardown. if self.is_confirmed() { if method != Method::PRack { - self.clear_remote_reliable(); + self.clear_remote_reliable(tx.original.cseq_header()?.seq()?); } return Ok(Some(resp)); } @@ -1543,8 +1696,10 @@ impl DialogInner { { self.refresh_target_from_response(&resp)?; } - if !matches!(method, Method::PRack) { - self.clear_remote_reliable(); + let reliable_sdp = method == Method::Invite + && self.has_reliable_sdp(tx.original.cseq_header()?.seq()?); + if method == Method::Invite { + self.clear_remote_reliable(tx.original.cseq_header()?.seq()?); } if let Some(options) = &options { if status.kind() == StatusCodeKind::Successful { @@ -1554,7 +1709,15 @@ impl DialogInner { super::reinvite::AckGuard(gate) }); let answer = if let Some(handler) = &options.answer_handler { - self.answer_reinvite(&mut tx, &resp, handler).await + if reliable_sdp { + // The offer was answered in PRACK. The final + // response repeats it; ACK must not negotiate again. + tx.last_ack = + Some(self.endpoint_inner.make_ack(&tx.original, &resp)?); + tx.send_ack(tx.connection.clone()).await + } else { + self.answer_reinvite(&mut tx, &resp, handler).await + } } else { Ok(()) }; @@ -1602,14 +1765,14 @@ impl DialogInner { } pub(super) fn do_request( - &self, + self: &Arc, request: Request, ) -> futures::future::BoxFuture<'_, Result>> { self.send_dialog_request(request, None).boxed() } pub(super) async fn do_reinvite( - &self, + self: &Arc, request: Request, options: super::reinvite::ReinviteOptions, ) -> Result> { @@ -1632,7 +1795,11 @@ impl DialogInner { /// once the BYE is handed to its transaction, and a 481, a 408 or no /// response ends the dialog. So whatever the transaction returns, the /// dialog is `Terminated(reason)`; a failure is still returned. - pub(super) async fn send_bye(&self, request: Request, reason: TerminatedReason) -> Result<()> { + pub(super) async fn send_bye( + self: &Arc, + request: Request, + reason: TerminatedReason, + ) -> Result<()> { { let state = self.state.lock(); if state.is_terminated() { @@ -1666,7 +1833,7 @@ impl DialogInner { /// the extra branch. The BYE is built from that response's own remote /// target (Contact) and route set (Record-Route); the confirmed dialog's /// state is not touched and no dialog is registered for the branch. - pub(super) async fn bye_forked_branch(&self, resp: &Response) -> Result<()> { + pub(super) async fn bye_forked_branch(self: &Arc, resp: &Response) -> Result<()> { let contact_uri = resp .typed_contact_headers()? .first() @@ -1723,7 +1890,11 @@ impl DialogInner { /// retransmitted our 2xx (`answered_2xx`) for 64*T1 and ended without an /// ACK. The dialog is terminated with [`TerminatedReason::Timeout`] and the /// session is ended with a BYE. - pub(super) async fn end_session_without_ack(&self, tx: &Transaction, answered_2xx: bool) { + pub(super) async fn end_session_without_ack( + self: &Arc, + tx: &Transaction, + answered_2xx: bool, + ) { if !answered_2xx || tx.state != crate::transaction::TransactionState::Terminated || self.is_terminated() @@ -1876,7 +2047,10 @@ impl DialogInner { initial_request, session_id: Mutex::new(snapshot.session_id), supports_100rel: snapshot.supports_100rel, - remote_reliable: Mutex::new(None), + remote_reliable: Mutex::new(Vec::new()), + reliable_clients: Mutex::new(BTreeMap::new()), + reliable_config: Mutex::new(None), + reliable_servers: Mutex::new(BTreeMap::new()), remote_ack: Mutex::new(None), server_connection: Mutex::new(None), dialback_target: Mutex::new(None), @@ -2097,6 +2271,67 @@ impl DialogInner { self.state_sender.send(state).ok(); } + #[cfg_attr(not(feature = "platform-tokio"), allow(unused_mut))] + async fn process_reliable_invite_handle( + &self, + tx: &mut Transaction, + mut rx: TransactionCommandReceiver, + ) -> Result<()> { + use crate::platform::{select3, Which3}; + let mut deadline = + core::pin::pin!(crate::platform::sleep(self.endpoint_inner.option.t1x64)); + let mut commands_closed = false; + loop { + let selected = { + let command = if commands_closed { + futures::future::pending().boxed() + } else { + rx.recv().boxed() + }; + let event = core::pin::pin!(tx.tu_receiver.recv()); + select3(command, event, &mut deadline).await + }; + match selected { + Which3::A(Some(TransactionCommand::Respond { + status, + headers, + body, + })) => { + let response = self.make_response(&tx.original, status, headers, body); + tx.respond(response).await?; + } + Which3::A(None) => { + commands_closed = true; + // A final response may be waiting for SDP's PRACK. + if tx + .reliable_provisional + .lock() + .as_ref() + .is_none_or(|s| !s.pending()) + { + return tx.reply(StatusCode::NotImplemented).await; + } + } + Which3::B(Some(event)) => match tx.dispatch_event(event).await { + Some(Some(SipMessage::Request(req))) if req.method == Method::Cancel => { + return tx.reply(StatusCode::RequestTerminated).await; + } + Some(None) => return Ok(()), + _ => {} + }, + Which3::B(None) => return Ok(()), + Which3::C(_) => return tx.reply(StatusCode::ServerTimeOut).await, + } + if tx + .last_response + .as_ref() + .is_some_and(|r| r.status_code.kind() != StatusCodeKind::Provisional) + { + return Ok(()); + } + } + } + #[cfg_attr(not(feature = "platform-tokio"), allow(unused_mut))] pub async fn process_transaction_handle( &self, @@ -2112,6 +2347,9 @@ impl DialogInner { None }; let cseq = tx.original.cseq_header()?.seq()?; + if tx.reliable_provisional.lock().is_some() { + return self.process_reliable_invite_handle(tx, rx).await; + } let timeout_duration = self.endpoint_inner.option.t1x64; let result = crate::platform::timeout(timeout_duration, async { while let Some(cmd) = rx.recv().await { diff --git a/src/dialog/dialog_layer.rs b/src/dialog/dialog_layer.rs index d7a9649b..e4350d18 100644 --- a/src/dialog/dialog_layer.rs +++ b/src/dialog/dialog_layer.rs @@ -38,6 +38,9 @@ pub struct DialogLayerInner { crate::platform::sync::Mutex>, pub(super) last_seq: AtomicU32, pub(super) dialogs: RwMap, + retired_reliable: RwMap, + pub(super) reliable_config: + crate::platform::sync::Mutex>, } pub type DialogLayerInnerRef = Arc; @@ -145,6 +148,8 @@ impl DialogLayer { last_seq: AtomicU32::new(0), lifecycle_sender: crate::platform::sync::Mutex::new(None), dialogs: RwMap::new(), + retired_reliable: RwMap::new(), + reliable_config: crate::platform::sync::Mutex::new(None), }), } } @@ -161,6 +166,14 @@ impl DialogLayer { *self.inner.lifecycle_sender.lock() = sender; } + /// Configure new INVITE dialogs. Existing dialogs retain their configuration. + pub fn set_reliable_provisional( + &self, + config: Option, + ) { + *self.inner.reliable_config.lock() = config; + } + pub fn get_or_create_server_invite( &self, tx: &Transaction, @@ -224,6 +237,8 @@ impl DialogLayer { dialog.inner.lifecycle.lock().sender = self.inner.lifecycle_sender.lock().clone(); *tx.initial_dialog.lock() = Some(Arc::downgrade(&dialog.inner)); dialog.inner.reserve_invite(tx)?; + *dialog.inner.reliable_config.lock() = self.inner.reliable_config.lock().clone(); + dialog.inner.attach_reliable_server(tx)?; dialog.inner.set_server_connection(tx.connection.clone()); self.inner .dialogs @@ -558,6 +573,7 @@ impl DialogLayer { inner.credential = credential; let inner = Arc::new(inner); + *inner.reliable_config.lock() = self.inner.reliable_config.lock().clone(); let dialog = Dialog::from_inner(inner.role, inner.clone()); let key = dialog.id().to_string(); @@ -578,13 +594,41 @@ impl DialogLayer { pub fn remove_dialog(&self, id: &DialogId) { if let Some(d) = self.inner.dialogs.remove(&id.to_string()) { - d.on_remove() + let pending = match &d { + Dialog::Invite(d) => d + .inner + .reliable_servers + .lock() + .values() + .any(|s| s.pending()), + _ => false, + }; + if pending { + let key = id.to_string(); + self.inner.retired_reliable.insert(key.clone(), d); + let layer = self.inner.clone(); + let delay = self.endpoint.option.t1x64; + crate::platform::spawn(async move { + crate::platform::sleep(delay).await; + if let Some(dialog) = layer.retired_reliable.remove(&key) { + dialog.on_remove(); + } + }); + } else { + d.on_remove(); + } } } pub fn match_dialog(&self, tx: &Transaction) -> Option { let id = DialogId::try_from(tx).ok()?; - self.get_dialog(&id) + self.get_dialog(&id).or_else(|| { + if tx.original.method == crate::sip::Method::PRack { + self.inner.retired_reliable.get(&id.to_string()) + } else { + None + } + }) } pub fn new_dialog_state_channel(&self) -> (DialogStateSender, DialogStateReceiver) { diff --git a/src/dialog/invitation.rs b/src/dialog/invitation.rs index 594f9e18..60149509 100644 --- a/src/dialog/invitation.rs +++ b/src/dialog/invitation.rs @@ -147,6 +147,9 @@ pub struct InviteOption { /// `Content-Type` here replaces the one the stack would add, so it is /// never sent twice; a `Content-Type` here wins over `content_type`. pub headers: Option>, + /// Legacy client-side advertisement switch. For full UAC/UAS support, + /// configure `DialogLayer::set_reliable_provisional` with a `PrackHandler`. + /// That configuration also advertises 100rel; this flag can remain false. pub support_prack: bool, pub call_id: Option, /// RFC 7989: local Session-ID UUID for this call (32 hex chars; dashed @@ -493,7 +496,13 @@ impl DialogLayer { .into(), )); - if opt.support_prack { + if let Some(config) = self.inner.reliable_config.lock().as_ref() { + super::reliable::add_option(&mut request, "Supported", "100rel"); + if config.require { + super::reliable::add_option(&mut request, "Require", "100rel"); + } + } + if opt.support_prack && !request.header_contains_token("Supported", "100rel") { request .headers .unique_push(crate::sip::Header::Supported("100rel".into())); @@ -902,6 +911,7 @@ impl DialogLayer { let dialog = InviteDialog::from_inner(Arc::new(dlg_inner)); dialog.inner.lifecycle.lock().sender = self.inner.lifecycle_sender.lock().clone(); dialog.inner.reserve_invite(&tx)?; + *dialog.inner.reliable_config.lock() = self.inner.reliable_config.lock().clone(); Ok((dialog, tx)) } } diff --git a/src/dialog/invite_dialog.rs b/src/dialog/invite_dialog.rs index 4ff5113e..ffd4d7f0 100644 --- a/src/dialog/invite_dialog.rs +++ b/src/dialog/invite_dialog.rs @@ -102,6 +102,15 @@ impl InviteDialog { self.inner.remote_ack.lock().clone() } + /// Enable full 100rel before starting the dialog. Prefer configuring the layer + /// before call creation; changes during an INVITE exchange are unsupported. + pub fn set_reliable_provisional( + &self, + config: Option, + ) { + *self.inner.reliable_config.lock() = config; + } + /// The initial INVITE request that created this dialog. pub fn initial_request(&self) -> Request { self.inner.initial_request.lock().clone() @@ -132,7 +141,9 @@ impl InviteDialog { self.inner .tu_sender .send(TransactionEvent::Respond(resp.clone()))?; - self.inner.transition(DialogState::Early(self.id(), resp)); + if self.inner.reliable_config.lock().is_none() || !self.inner.supports_100rel { + self.inner.transition(DialogState::Early(self.id(), resp)); + } Ok(()) } @@ -148,7 +159,9 @@ impl InviteDialog { self.inner .tu_sender .send(TransactionEvent::Respond(resp.clone()))?; - self.inner.transition(DialogState::WaitAck(self.id(), resp)); + if self.inner.reliable_config.lock().is_none() || !self.inner.supports_100rel { + self.inner.transition(DialogState::WaitAck(self.id(), resp)); + } Ok(()) } @@ -419,13 +432,21 @@ impl InviteDialog { // Not held back by a PRACK (RFC 3262); again after // the transition for a cancel() racing this one. self.send_deferred_cancel(); - self.inner.handle_provisional_response(&resp).await?; + if !self + .inner + .handle_provisional_response(&resp, &tx.original) + .await? + { + continue; + } self.inner.transition(DialogState::Early(self.id(), resp)); self.send_deferred_cancel(); continue; } // A challenge to a cancelled INVITE is its final response. + self.inner + .clear_remote_reliable(tx.original.cseq_header()?.seq()?); if matches!( status, StatusCode::ProxyAuthenticationRequired | StatusCode::Unauthorized @@ -859,6 +880,11 @@ impl InviteDialog { self.inner.observe_peer_session_uuid(peer_uuid); } + self.inner.attach_reliable_server(tx)?; + if self.inner.reject_required_100rel(tx).await? { + return Ok(()); + } + let cseq = tx.original.cseq_header()?.seq()?; // ACK and CANCEL reuse their INVITE's CSeq and are matched by the // transaction layer. Neither participates in the dialog sequence. @@ -900,6 +926,10 @@ impl InviteDialog { } } + // A locally originated dialog can receive PRACK for its re-INVITE. + if tx.original.method == Method::PRack { + return self.handle_prack(tx).await; + } if self.inner.is_confirmed() { // Validate before the application can change its media state or // accept the request. Receiving a Contact alone does not commit it. @@ -1053,29 +1083,7 @@ impl InviteDialog { } async fn handle_prack(&mut self, tx: &mut Transaction) -> Result<()> { - debug!(id = %self.id(), uri = %tx.original.uri, "received prack"); - - let rack_ok = tx.original.rack_value().is_some() - || tx - .original - .header_value("RAck") - .and_then(|value| { - let mut items = value.split_whitespace(); - let rseq = items.next()?.parse::().ok()?; - let cseq = items.next()?.parse::().ok()?; - let method = items.next()?.parse::().ok()?; - Some((rseq, cseq, method)) - }) - .is_some(); - - if !rack_ok { - warn!(id = %self.id(), "received PRACK without RAck header"); - tx.reply(StatusCode::BadRequest).await?; - return Ok(()); - } - - tx.reply(StatusCode::OK).await?; - Ok(()) + self.inner.receive_prack(tx).await } async fn handle_options(&mut self, tx: &mut Transaction) -> Result<()> { diff --git a/src/dialog/mod.rs b/src/dialog/mod.rs index 3183356d..119f1abe 100644 --- a/src/dialog/mod.rs +++ b/src/dialog/mod.rs @@ -16,6 +16,7 @@ pub mod publication; pub mod registration; pub mod reinvite; pub mod reinvite_bridge; +pub mod reliable; pub mod server_dialog; pub mod subscription; diff --git a/src/dialog/reinvite.rs b/src/dialog/reinvite.rs index 13850615..238f875a 100644 --- a/src/dialog/reinvite.rs +++ b/src/dialog/reinvite.rs @@ -24,6 +24,10 @@ //! rather than inspecting the dialog-wide last ACK. `finished` signals the //! terminal ACK outcome, before any missing-ACK cleanup BYE completes. //! +//! With full 100rel enabled, an offer in a reliable provisional is answered +//! by `PrackHandler`. A repeated offer in the final 2xx receives an empty ACK; +//! `InviteAnswerHandler` is used only when no reliable SDP was received. +//! //! Initial INVITE handling, media transport, and a policy for coupling multiple //! dialogs are separate. Dropping the outgoing awaiter does not stop its SIP //! transaction; use the cancellation token and still handle its final result. @@ -308,7 +312,7 @@ impl RequestCancellation { impl DialogInner { pub(super) async fn process_reinvite( - &self, + self: &Arc, tx: &mut Transaction, notify_confirmed: bool, ) -> Result<()> { @@ -369,9 +373,14 @@ impl DialogInner { let cseq = tx.original.cseq_header()?.seq()?; let mut deadline = core::pin::pin!(crate::platform::sleep(self.endpoint_inner.option.t1x64)); + let mut commands_closed = false; loop { let selected = { - let command = commands.recv().boxed(); + let command = if commands_closed { + futures::future::pending().boxed() + } else { + commands.recv().boxed() + }; let event = core::pin::pin!(tx.tu_receiver.recv()); select3(command, event, &mut deadline).await }; @@ -384,13 +393,23 @@ impl DialogInner { let response = self.make_response(&tx.original, status, headers, body); let refresh = Self::accepts_target_refresh(&tx.original.method, &response); tx.respond(response).await?; - if refresh { + if refresh && tx.reliable_provisional.lock().is_none() { if let Some(target) = &target { self.accept_target_refresh(cseq, target); } } } - Which3::A(None) => return tx.reply(StatusCode::NotImplemented).await, + Which3::A(None) => { + commands_closed = true; + if tx + .reliable_provisional + .lock() + .as_ref() + .is_none_or(|s| !s.pending()) + { + return tx.reply(StatusCode::NotImplemented).await; + } + } Which3::B(Some(event)) => match tx.dispatch_event(event).await { Some(Some(SipMessage::Request(request))) if request.method == Method::Cancel => @@ -417,7 +436,7 @@ impl DialogInner { } pub(super) async fn answer_reinvite( - &self, + self: &Arc, tx: &mut Transaction, response: &Response, handler: &Arc, diff --git a/src/dialog/reinvite_bridge.rs b/src/dialog/reinvite_bridge.rs index a330fd64..64758c82 100644 --- a/src/dialog/reinvite_bridge.rs +++ b/src/dialog/reinvite_bridge.rs @@ -15,7 +15,9 @@ //! by a failed negotiation after a peer already accepted it. //! //! Reliable provisional offer/answer and session-timer negotiation are outside -//! this component's current scope. Requests requiring 100rel or timer are +//! this component's current scope. Construction rejects dialogs with a full +//! 100rel media handler: that handler would otherwise consume the peer's offer +//! independently of the other leg. Requests requiring 100rel or timer are //! rejected with 420 rather than silently claiming support. //! //! ```no_run @@ -165,6 +167,9 @@ impl ReinviteBridge { if !a.state().is_confirmed() || !b.state().is_confirmed() || a.id() == b.id() { return Err(error("bridge requires two distinct confirmed dialogs")); } + if a.inner.reliable_config.lock().is_some() || b.inner.reliable_config.lock().is_some() { + return Err(error("reliable-provisional bridging requires a separate media policy; disable 100rel on these bridge legs")); + } Ok(Self { inner: Arc::new(Inner { a, diff --git a/src/dialog/reliable.rs b/src/dialog/reliable.rs new file mode 100644 index 00000000..09dfb845 --- /dev/null +++ b/src/dialog/reliable.rs @@ -0,0 +1,867 @@ +//! RFC 3262 reliable provisional responses and application-owned SDP negotiation. +//! +//! Enable this on a `DialogLayer` before creating calls. The handler supplies +//! SDP answers (and, optionally, a new offer in PRACK); the stack owns RSeq, +//! RAck, transactions, retransmissions and final-response ordering. +use super::{ + dialog::{DialogInner, DialogState, TerminatedReason}, + DialogId, +}; +use crate::platform::{self, sync::Mutex, CancellationToken}; +use crate::prelude::*; +use crate::sip::{ + HasHeaders, Header, HeadersExt, Method, Request, Response, StatusCode, StatusCodeKind, +}; +use crate::transaction::{ + key::TransactionRole, + transaction::{Transaction, TransactionEvent, TransactionEventSender}, +}; +use crate::{Error, Result}; +use async_trait::async_trait; + +/// Meaning of the SDP carried by the message delivered to the handler. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum SdpKind { + None, + Offer, + Answer, + /// A subsequent SDP body for this INVITE; do not apply it as offer/answer. + Ignored, +} + +/// A body to put in PRACK or its 200 response. SDP is not synthesized by SIP. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct PrackBody { + pub content_type: String, + pub body: Vec, +} +impl PrackBody { + pub fn sdp(body: impl Into>) -> Self { + Self { + content_type: "application/sdp".into(), + body: body.into(), + } + } + pub(crate) fn is_sdp(&self) -> bool { + !self.body.is_empty() + && self + .content_type + .split(';') + .next() + .is_some_and(|s| s.trim().eq_ignore_ascii_case("application/sdp")) + } + fn apply(self, request: &mut Request) { + request + .headers + .unique_push(Header::ContentType(self.content_type.into())); + request + .headers + .unique_push(Header::ContentLength((self.body.len() as u32).into())); + request.body = self.body; + } +} + +#[derive(Clone, Debug)] +pub struct ReliableResponse { + pub dialog_id: DialogId, + pub invite: Request, + pub response: Response, + pub sdp_kind: SdpKind, +} +#[derive(Clone, Debug)] +pub struct IncomingPrack { + pub dialog_id: DialogId, + pub invite: Request, + pub response: Response, + pub prack: Request, + pub sdp_kind: SdpKind, +} + +/// Callbacks may run concurrently for different dialogs. Do not wait for an +/// INVITE final response here: an SDP answer can be required before that final. +/// +/// For an SDP offer return an SDP answer (use rejected media ports to decline +/// an offer). For an answer, apply it and normally return `None`; a UAC may +/// return a new SDP offer when acknowledging the first SDP answer. RFC 3262 §5. +#[async_trait] +pub trait PrackHandler: Send + Sync { + async fn on_reliable_response(&self, event: ReliableResponse) -> Result>; + async fn on_prack(&self, event: IncomingPrack) -> Result>; + /// Includes the SDP answer to an offer sent in PRACK. A missing response + /// means transaction timeout. The application decides whether to end a call. + async fn on_prack_result(&self, _request: Request, _response: Option) {} + /// Transport, callback and protocol errors, including UAS 64*T1 expiry. + async fn on_error(&self, _dialog_id: DialogId, _message: String) {} +} + +/// Explicitly enabled full 100rel support. A media handler is mandatory so +/// offerless INVITE and SDP in PRACK can be handled by the application. +#[derive(Clone)] +pub struct ReliableProvisionalConfig { + pub handler: Arc, + /// Add Require: 100rel to outgoing INVITEs, in addition to Supported. + pub require: bool, +} +impl ReliableProvisionalConfig { + pub fn new(handler: Arc) -> Self { + Self { + handler, + require: false, + } + } +} +impl core::fmt::Debug for ReliableProvisionalConfig { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.debug_struct("ReliableProvisionalConfig") + .field("require", &self.require) + .finish_non_exhaustive() + } +} + +pub(crate) fn has_sdp(message: &impl HeadersExt, body: &[u8]) -> bool { + !body.is_empty() + && message.header_value("Content-Type").is_some_and(|s| { + s.split(';') + .next() + .is_some_and(|s| s.trim().eq_ignore_ascii_case("application/sdp")) + }) +} +pub(crate) fn add_option(message: &mut impl HasHeaders, name: &str, token: &str) { + let exists = message + .headers() + .iter() + .filter(|h| h.name().eq_ignore_ascii_case(name)) + .any(|h| { + h.value() + .split(',') + .any(|s| s.trim().eq_ignore_ascii_case(token)) + }); + if !exists { + message.headers_mut().push(match name { + "Require" => Header::Require(token.into()), + _ => Header::Supported(token.into()), + }); + } +} +fn error(message: &str) -> Error { + Error::Error(message.into()) +} + +struct PrackJob { + event: ReliableResponse, + request: Request, + destination: Option, +} + +pub(super) struct ReliableClient { + sender: platform::BoundedSender, + last_rseq: u32, + routes: Vec, + target: crate::sip::Uri, + first_sdp: Option>, +} + +impl DialogInner { + pub(super) fn has_reliable_sdp(&self, cseq: u32) -> bool { + let id = self.id.lock().clone(); + self.reliable_clients + .lock() + .get(&(id, cseq)) + .is_some_and(|c| c.first_sdp.is_some()) + } + + #[cfg_attr(not(feature = "platform-tokio"), allow(unused_mut))] + pub(super) fn start_reliable_prack( + self: &Arc, + response: &Response, + invite: &Request, + config: ReliableProvisionalConfig, + ) -> Result { + use crate::sip::{Param, ToTypedHeader}; + if invite.method != Method::Invite + || response.cseq_header()?.method()? != Method::Invite + || response.cseq_header()?.seq()? != invite.cseq_header()?.seq()? + || response.call_id_header()? != invite.call_id_header()? + || response.from_header()?.tag()? != invite.from_header()?.tag()? + { + return Ok(false); + } + let id = DialogId::try_from((response, TransactionRole::Client))?; + if id.remote_tag.is_empty() { + return Ok(false); + } + let in_dialog = invite.to_header()?.tag()?; + if in_dialog + .as_ref() + .is_some_and(|t| t.value() != id.remote_tag) + { + return Ok(false); + } + let Some(rseq) = response.rseq_value() else { + return Ok(false); + }; + let cseq = invite.cseq_header()?.seq()?; + let (kind, target, routes, sender, receiver) = { + let mut clients = self.reliable_clients.lock(); + let key = (id.clone(), cseq); + if let Some(client) = clients.get(&key) { + if client.last_rseq.checked_add(1) != Some(rseq) { + return Ok(false); + } + } else if rseq > i32::MAX as u32 { + return Ok(false); + } + // RFC 6141 sections 4.7/4.9: each newly accepted reliable + // provisional can refresh Contact, including on a re-INVITE. + // Sequence validation above prevents replaying an old target. + let target = if let Some(target) = Self::parse_target_refresh_contact(response)? { + target.uri + } else if in_dialog.is_some() { + self.remote_uri.lock().clone() + } else if let Some(client) = clients.get(&key) { + client.target.clone() + } else { + return Err(error( + "dialog-establishing reliable response needs one Contact", + )); + }; + let routes = if let Some(client) = clients.get(&key) { + client.routes.clone() + } else if in_dialog.is_some() { + self.route_set.lock().clone() + } else { + let mut routes: Vec = response + .record_route_headers() + .into_iter() + .flat_map(|h| { + crate::sip::headers::typed::record_route::split_rr_values(h.value()) + }) + .map(crate::sip::Route::from) + .collect(); + routes.reverse(); + routes + }; + let first_sdp = clients.get(&key).and_then(|c| c.first_sdp.clone()); + let sdp = has_sdp(response, &response.body); + let kind = if sdp { + if first_sdp.is_some() { + // RFC 6337 §3.1: later SDP is not a new offer/answer, + // including peers that repeat a different description. + SdpKind::Ignored + } else if has_sdp(invite, &invite.body) { + SdpKind::Answer + } else { + SdpKind::Offer + } + } else { + if first_sdp.is_none() && !has_sdp(invite, &invite.body) { + return Err(error( + "first reliable response to offerless INVITE has no SDP offer", + )); + } + SdpKind::None + }; + let (sender, receiver) = match clients.get(&key) { + Some(client) => (client.sender.clone(), None), + None => { + let (sender, receiver) = platform::mpsc::channel(32); + (sender, Some(receiver)) + } + }; + clients.insert( + key, + ReliableClient { + sender: sender.clone(), + last_rseq: rseq, + routes: routes.clone(), + target: target.clone(), + first_sdp: first_sdp.or_else(|| sdp.then(|| response.body.clone())), + }, + ); + (kind, target, routes, sender, receiver) + }; + let mut prack = self.make_request( + Method::PRack, + Some(0), + None, + None, + Some(vec![Header::RAck(format!("{rseq} {cseq} INVITE").into())]), + None, + )?; + prack + .headers + .unique_push(Header::To(response.to_header()?.clone())); + prack.uri = target.clone(); + prack.headers.retain(|h| !matches!(h, Header::Route(_))); + let destination = if let Some(first) = routes.first() { + let first = first.typed()?; + let destination = crate::transport::SipAddr::try_from(&first.uri)?; + if first.uri.params.iter().any(|p| { + matches!(p, Param::Lr) + || matches!(p, Param::Other(n, _) if n.value().eq_ignore_ascii_case("lr")) + }) { + prack + .headers + .extend(routes.iter().cloned().map(Header::Route).collect()); + } else { + prack.uri = first.uri; + prack + .headers + .extend(routes.iter().skip(1).cloned().map(Header::Route).collect()); + prack + .headers + .push(Header::Route(format!("<{target}>").into())); + } + Some(destination) + } else { + Some(crate::transport::SipAddr::try_from(&target)?) + }; + // Keep the first early dialog as the public call's target; fork-specific + // PRACK requests carry their own target, routes and To-tag above. + let current = self.id.lock().clone(); + if current.remote_tag.is_empty() || current.remote_tag == id.remote_tag { + self.update_remote_tag(&id.remote_tag)?; + if let Some(target) = Self::parse_target_refresh_contact(response)? { + self.set_remote_target(target.uri, Some(target.contact)); + } + if in_dialog.is_none() { + *self.route_set.lock() = routes; + } + } + let event = ReliableResponse { + dialog_id: id.clone(), + invite: invite.clone(), + response: response.clone(), + sdp_kind: kind, + }; + sender + .try_send(PrackJob { + event, + request: prack, + destination, + }) + .map_err(|_| error("PRACK preparation queue is full or closed"))?; + if let Some(mut receiver) = receiver { + let weak = Arc::downgrade(self); + platform::spawn(async move { + while let Some(job) = receiver.recv().await { + let Some(inner) = weak.upgrade() else { + break; + }; + let id = job.event.dialog_id.clone(); + match inner.prepare_prack_job(job, &config).await { + Ok((tx, offered)) => { + let config = config.clone(); + platform::spawn(async move { + let request = tx.original.clone(); + let result = inner.finish_prack_transaction(tx).await; + match result { + Ok(response) => { + if offered + && response.as_ref().is_some_and(|r| { + r.status_code.kind() == StatusCodeKind::Successful + && !has_sdp(r, &r.body) + }) + { + config.handler.on_error(id.clone(), "successful PRACK response omitted the SDP answer".into()).await; + } + config.handler.on_prack_result(request, response).await; + } + Err(e) => config.handler.on_error(id, e.to_string()).await, + } + }); + } + Err(e) => config.handler.on_error(id, e.to_string()).await, + } + } + }); + } + Ok(true) + } + async fn prepare_prack_job( + &self, + job: PrackJob, + config: &ReliableProvisionalConfig, + ) -> Result<(Transaction, bool)> { + let kind = job.event.sdp_kind; + let body = platform::timeout( + self.endpoint_inner.option.t1x64, + config.handler.on_reliable_response(job.event), + ) + .await + .map_err(|_| error("reliable response SDP handler timed out"))??; + if kind == SdpKind::Offer && !body.as_ref().is_some_and(PrackBody::is_sdp) { + return Err(error( + "SDP offer in reliable response needs an answer in PRACK", + )); + } + if body.as_ref().is_some_and(PrackBody::is_sdp) + && !matches!(kind, SdpKind::Offer | SdpKind::Answer) + { + return Err(error( + "SDP offer is only allowed in PRACK acknowledging an SDP answer", + )); + } + let offered = kind == SdpKind::Answer && body.as_ref().is_some_and(PrackBody::is_sdp); + let mut request = job.request; + if let Some(body) = body { + body.apply(&mut request); + } + request.headers.unique_push(Header::CSeq( + format!("{} PRACK", self.increment_local_seq()).into(), + )); + let tx = self + .start_prack_transaction(request, job.destination) + .await?; + Ok((tx, offered)) + } +} + +struct Outstanding { + response: Response, + kind: SdpKind, + cancel: CancellationToken, + timer_started: bool, + processing: bool, +} +struct ServerState { + next_rseq: u32, + outstanding: Option, + queue: Vec, + final_response: Option, + final_sent: bool, + first_answer: Option>, + offer_answer_complete: bool, +} + +/// One incoming INVITE transaction; retained by the dialog for late PRACKs. +pub(crate) struct ReliableServer { + owner: Weak, + pub(crate) request: Request, + sender: TransactionEventSender, + config: ReliableProvisionalConfig, + state: Mutex, +} +impl ReliableServer { + pub(crate) fn new( + owner: &Arc, + request: Request, + sender: TransactionEventSender, + config: ReliableProvisionalConfig, + ) -> Arc { + let seed = crate::transaction::make_uuid_v4(); + let next_rseq = (u32::from_str_radix(&seed[..8], 16).unwrap_or(1) & 0x7fff_ffff).max(1); + Arc::new(Self { + owner: Arc::downgrade(owner), + request, + sender, + config, + state: Mutex::new(ServerState { + next_rseq, + outstanding: None, + queue: Vec::new(), + final_response: None, + final_sent: false, + first_answer: None, + offer_answer_complete: false, + }), + }) + } + + /// Called by the owning transaction, never while a network send is in flight. + pub(crate) fn prepare(&self, mut response: Response) -> Result> { + let mut s = self.state.lock(); + if response.status_code == StatusCode::Trying { + response + .headers + .retain(|h| !h.name().eq_ignore_ascii_case("RSeq")); + if response.header_contains_token("Require", "100rel") { + return Err(error("100 Trying cannot be reliable")); + } + return Ok(Some(response)); + } + if response.status_code.kind() != StatusCodeKind::Provisional { + if s.final_sent { + return Ok(Some(response)); + } + if response.status_code.kind() == StatusCodeKind::Successful + && s.outstanding + .as_ref() + .is_some_and(|o| has_sdp(&o.response, &o.response.body) || o.processing) + { + s.final_response = Some(response); + s.queue.clear(); + return Ok(None); + } + s.final_sent = true; + s.queue.clear(); + s.final_response = None; + if let Some(o) = &s.outstanding { + o.cancel.cancel(); + } + return Ok(Some(response)); + } + if s.final_sent { + return Ok(None); + } + // Only the stored exact response is a retransmission. Caller-supplied + // RSeq cannot bypass the sequence/offer-answer machinery. + if response + .headers + .iter() + .any(|h| h.name().eq_ignore_ascii_case("RSeq")) + { + return Ok(s + .outstanding + .as_ref() + .filter(|o| !o.processing && o.response == response) + .map(|_| response)); + } + if s.final_response.is_some() { + return Err(error("final INVITE response already queued")); + } + if s.outstanding.is_some() { + if s.queue.len() >= 32 { + return Err(error("too many queued reliable responses")); + } + s.queue.push(response); + return Ok(None); + } + let sdp = has_sdp(&response, &response.body); + let kind = if has_sdp(&self.request, &self.request.body) { + if sdp { + if let Some(answer) = &s.first_answer { + if *answer != response.body { + return Err(error("subsequent reliable response changed the SDP answer")); + } + SdpKind::Ignored + } else { + s.first_answer = Some(response.body.clone()); + s.offer_answer_complete = true; + SdpKind::Answer + } + } else { + SdpKind::None + } + } else if !s.offer_answer_complete { + if !sdp { + return Err(error( + "offerless INVITE requires an SDP offer in the first reliable response", + )); + } + SdpKind::Offer + } else { + if sdp { + return Err(error( + "new SDP offer cannot be sent in a subsequent reliable response", + )); + } + SdpKind::None + }; + let rseq = s.next_rseq; + if rseq == 0 { + return Err(error("RSeq space exhausted")); + } + s.next_rseq = rseq.checked_add(1).unwrap_or(0); + add_option(&mut response, "Require", "100rel"); + response + .headers + .unique_push(Header::RSeq(rseq.to_string().into())); + s.outstanding = Some(Outstanding { + response: response.clone(), + kind, + cancel: CancellationToken::new(), + timer_started: false, + processing: false, + }); + Ok(Some(response)) + } + + pub(crate) fn sent(self: &Arc, response: &Response) { + let Some(owner) = self.owner.upgrade() else { + return; + }; + // Commit a target refresh only after the accepting response reached + // the transport, including a previously queued 2xx or reliable 1xx. + if DialogInner::accepts_target_refresh(&self.request.method, response) { + if let (Ok(Some(target)), Ok(cseq)) = ( + DialogInner::parse_target_refresh_contact(&self.request), + self.request.cseq_header().and_then(|h| h.seq()), + ) { + owner.accept_target_refresh(cseq, &target); + } + } + let final_response = response.status_code.kind() != StatusCodeKind::Provisional; + if !final_response + && self.state.lock().outstanding.as_ref().is_some_and(|o| { + o.timer_started && o.response.rseq_value() == response.rseq_value() + }) + { + return; + } + if final_response { + let weak_owner = self.owner.clone(); + let weak_server = Arc::downgrade(self); + let cseq = self + .request + .cseq_header() + .and_then(|h| h.seq()) + .unwrap_or(0); + let delay = owner.endpoint_inner.option.t1x64; + platform::spawn(async move { + platform::sleep(delay).await; + if let (Some(owner), Some(server)) = (weak_owner.upgrade(), weak_server.upgrade()) { + let mut servers = owner.reliable_servers.lock(); + if servers.get(&cseq).is_some_and(|s| Arc::ptr_eq(s, &server)) { + servers.remove(&cseq); + } + } + }); + } + if self + .request + .to_header() + .ok() + .and_then(|h| h.tag().ok()) + .flatten() + .is_none() + { + let id = owner.id.lock().clone(); + match response.status_code.kind() { + StatusCodeKind::Provisional if response.status_code != StatusCode::Trying => { + owner.transition(DialogState::Early(id, response.clone())) + } + StatusCodeKind::Successful => { + owner.transition(DialogState::WaitAck(id, response.clone())) + } + StatusCodeKind::Provisional => {} + _ => owner.transition(DialogState::Terminated( + id, + TerminatedReason::UasOther(response.status_code.clone()), + )), + } + } + let token = { + let mut s = self.state.lock(); + if s.final_sent { + return; + } + let Some(o) = &mut s.outstanding else { + return; + }; + if o.timer_started || o.response.rseq_value() != response.rseq_value() { + return; + } + o.timer_started = true; + o.cancel.clone() + }; + let weak = Arc::downgrade(self); + let t1 = owner.endpoint_inner.option.t1; + let deadline = owner.endpoint_inner.option.t1x64; + platform::spawn(async move { + let mut elapsed = Duration::ZERO; + let mut interval = t1; + loop { + let delay = interval.min(deadline.saturating_sub(elapsed)); + let wait = core::pin::pin!(platform::sleep(delay)); + let cancel = core::pin::pin!(token.cancelled()); + if matches!( + platform::select2(wait, cancel).await, + platform::Either::B(_) + ) { + break; + } + elapsed += delay; + let Some(server) = weak.upgrade() else { + break; + }; + if elapsed >= deadline { + server.expire().await; + break; + } + let response = { + let s = server.state.lock(); + if s.final_sent { + break; + } + s.outstanding + .as_ref() + .filter(|o| !o.processing) + .map(|o| o.response.clone()) + }; + let Some(response) = response else { + break; + }; + if server + .sender + .send(TransactionEvent::Respond(response)) + .is_err() + { + break; + } + interval = interval.saturating_mul(2); // RFC 3262: no T2 cap. + } + }); + } + + async fn expire(&self) { + let Some(owner) = self.owner.upgrade() else { + return; + }; + { + let mut s = self.state.lock(); + if s.final_sent || s.outstanding.as_ref().is_none_or(|o| o.processing) { + return; + } + s.outstanding = None; + s.queue.clear(); + s.final_response = None; + } + let response = owner.make_response(&self.request, StatusCode::ServerTimeOut, None, None); + self.sender.send(TransactionEvent::Respond(response)).ok(); + let id = owner.id.lock().clone(); + self.config + .handler + .on_error(id, "PRACK not received within 64*T1".into()) + .await; + } + + pub(crate) fn fail(&self, message: String) { + let Some(owner) = self.owner.upgrade() else { + return; + }; + let reject = { + let mut state = self.state.lock(); + if let Some(outstanding) = state.outstanding.take() { + outstanding.cancel.cancel(); + } + state.queue.clear(); + state.final_response = None; + !state.final_sent + }; + if reject { + self.sender + .send(TransactionEvent::Respond(owner.make_response( + &self.request, + StatusCode::ServerInternalError, + None, + None, + ))) + .ok(); + } + let id = owner.id.lock().clone(); + let handler = self.config.handler.clone(); + platform::spawn(async move { + handler.on_error(id, message).await; + }); + } + + pub(crate) fn pending(&self) -> bool { + self.state.lock().outstanding.is_some() + } + + pub(crate) async fn handle_prack(&self, tx: &mut Transaction) -> Result<()> { + let Some((rseq, cseq, method)) = crate::sip::message::rack_parts(&tx.original) else { + return tx.reply(StatusCode::BadRequest).await; + }; + let Some(owner) = self.owner.upgrade() else { + return tx.reply(StatusCode::CallTransactionDoesNotExist).await; + }; + let id = owner.id.lock().clone(); + let matches = DialogId::try_from((&tx.original, TransactionRole::Server)) + .ok() + .as_ref() + == Some(&id) + && method == "INVITE" + && self.request.cseq_header()?.seq()? == cseq; + let selected = { + let mut s = self.state.lock(); + if matches { + s.outstanding + .as_mut() + .filter(|o| !o.processing && o.response.rseq_value() == Some(rseq)) + .map(|o| { + let sdp = has_sdp(&tx.original, &tx.original.body); + let kind = match (o.kind, sdp) { + (SdpKind::Offer, true) => Some(SdpKind::Answer), + (SdpKind::Offer, false) => None, + (SdpKind::Answer, true) => Some(SdpKind::Offer), + (_, false) => Some(SdpKind::None), + _ => None, + }; + if kind.is_some() { + o.processing = true; + o.cancel.cancel(); + } + (o.response.clone(), kind) + }) + } else { + None + } + }; + let Some((response, kind)) = selected else { + return tx.reply(StatusCode::CallTransactionDoesNotExist).await; + }; + let Some(kind) = kind else { + return tx.reply(StatusCode::BadRequest).await; + }; + let event = IncomingPrack { + dialog_id: id.clone(), + invite: self.request.clone(), + response, + prack: tx.original.clone(), + sdp_kind: kind, + }; + let answer = platform::timeout( + owner.endpoint_inner.option.t1x64, + self.config.handler.on_prack(event), + ) + .await; + let answer = match answer { + Ok(Ok(body)) + if kind != SdpKind::Offer || body.as_ref().is_some_and(PrackBody::is_sdp) => + { + body + } + _ => { + self.fail("PRACK SDP handler failed or did not supply the required answer".into()); + return tx.reply(StatusCode::ServerInternalError).await; + } + }; + if kind != SdpKind::Offer && answer.as_ref().is_some_and(PrackBody::is_sdp) { + self.fail("unexpected SDP supplied for PRACK response".into()); + return tx.reply(StatusCode::ServerInternalError).await; + } + let (headers, body) = match answer { + Some(body) => ( + vec![Header::ContentType(body.content_type.into())], + Some(body.body), + ), + None => (vec![], None), + }; + if let Err(e) = tx.reply_with(StatusCode::OK, headers, body).await { + self.fail(format!("could not send PRACK response: {e}")); + return Err(e); + } + let next = { + let mut s = self.state.lock(); + s.outstanding = None; + if kind == SdpKind::Answer { + s.offer_answer_complete = true; + } + if s.final_sent { + None + } else if let Some(final_response) = s.final_response.take() { + Some(final_response) + } else if !s.queue.is_empty() { + Some(s.queue.remove(0)) + } else { + None + } + }; + if let Some(response) = next { + self.sender.send(TransactionEvent::Respond(response))?; + } + Ok(()) + } +} diff --git a/src/dialog/server_dialog.rs b/src/dialog/server_dialog.rs index caa4ba46..cfc97502 100644 --- a/src/dialog/server_dialog.rs +++ b/src/dialog/server_dialog.rs @@ -3,7 +3,7 @@ use super::subscription::ServerSubscriptionDialog; use super::DialogId; use crate::platform::CancellationToken; use crate::prelude::*; -use crate::sip::{prelude::HeadersExt, Header, Method, Request, SipMessage, StatusCode}; +use crate::sip::{prelude::HeadersExt, Header, Request, SipMessage, StatusCode}; use crate::{ transaction::transaction::{Transaction, TransactionEvent}, Result, @@ -148,7 +148,9 @@ impl ServerInviteDialog { self.inner .tu_sender .send(TransactionEvent::Respond(resp.clone()))?; - self.inner.transition(DialogState::Early(self.id(), resp)); + if self.inner.reliable_config.lock().is_none() || !self.inner.supports_100rel { + self.inner.transition(DialogState::Early(self.id(), resp)); + } Ok(()) } /// Accept the incoming INVITE request @@ -193,7 +195,9 @@ impl ServerInviteDialog { .tu_sender .send(TransactionEvent::Respond(resp.clone()))?; - self.inner.transition(DialogState::WaitAck(self.id(), resp)); + if self.inner.reliable_config.lock().is_none() || !self.inner.supports_100rel { + self.inner.transition(DialogState::WaitAck(self.id(), resp)); + } Ok(()) } @@ -660,6 +664,11 @@ impl ServerInviteDialog { "handle request" ); + self.inner.attach_reliable_server(tx)?; + if self.inner.reject_required_100rel(tx).await? { + return Ok(()); + } + let cseq = tx.original.cseq_header()?.seq()?; let remote_seq = self.inner.remote_seq.load(Ordering::Relaxed); if remote_seq > 0 && cseq < remote_seq { @@ -777,29 +786,7 @@ impl ServerInviteDialog { } async fn handle_prack(&mut self, tx: &mut Transaction) -> Result<()> { - debug!(id = %self.id(), uri = %tx.original.uri, "received prack"); - - let rack_ok = tx.original.rack_value().is_some() - || tx - .original - .header_value("RAck") - .and_then(|value| { - let mut items = value.split_whitespace(); - let rseq = items.next()?.parse::().ok()?; - let cseq = items.next()?.parse::().ok()?; - let method = items.next()?.parse::().ok()?; - Some((rseq, cseq, method)) - }) - .is_some(); - - if !rack_ok { - warn!(id = %self.id(), "received PRACK without RAck header"); - tx.reply(crate::sip::StatusCode::BadRequest).await?; - return Ok(()); - } - - tx.reply(crate::sip::StatusCode::OK).await?; - Ok(()) + self.inner.receive_prack(tx).await } async fn handle_options(&mut self, tx: &mut Transaction) -> Result<()> { diff --git a/src/dialog/tests/mod.rs b/src/dialog/tests/mod.rs index 100a1779..f6d4b239 100644 --- a/src/dialog/tests/mod.rs +++ b/src/dialog/tests/mod.rs @@ -29,5 +29,7 @@ mod test_uas_ack_timeout; mod test_via_listen_addr; mod test_warn_logs; +mod test_prack_validation; mod test_reinvite_bridge; mod test_reinvite_control; +mod test_reliable_provisional; diff --git a/src/dialog/tests/test_prack.rs b/src/dialog/tests/test_prack.rs index 51630326..47bb9d8d 100644 --- a/src/dialog/tests/test_prack.rs +++ b/src/dialog/tests/test_prack.rs @@ -15,7 +15,7 @@ use tokio::sync::mpsc::unbounded_channel; use tokio::time::{timeout, Duration}; #[tokio::test] -async fn server_dialog_handles_prack_request() -> crate::Result<()> { +async fn server_dialog_rejects_prack_without_outstanding_response() -> crate::Result<()> { let endpoint = create_test_endpoint().await?; let (state_sender, _state_receiver) = unbounded_channel(); let (tu_sender, _tu_receiver) = unbounded_channel(); @@ -95,7 +95,7 @@ async fn server_dialog_handles_prack_request() -> crate::Result<()> { .expect("transport event"); match event { TransportEvent::Incoming(SipMessage::Response(resp), _, _) => { - assert_eq!(resp.status_code, StatusCode::OK); + assert_eq!(resp.status_code, StatusCode::CallTransactionDoesNotExist); } other => panic!("unexpected transport event: {other:?}"), } @@ -136,9 +136,10 @@ async fn client_dialog_pracks_each_reliable_provisional() -> crate::Result<()> { callee: crate::sip::Uri::try_from(format!("sip:bob@{}", peer.local_addr()?).as_str())?, contact: crate::sip::Uri::try_from(format!("sip:alice@{uac_addr}").as_str())?, support_prack: true, + offer: Some(b"v=0\r\no=- 1 1 IN IP4 127.0.0.1\r\ns=-\r\nc=IN IP4 127.0.0.1\r\nt=0 0\r\nm=audio 5000 RTP/AVP 0\r\n".to_vec()), ..Default::default() }; - let (state_sender, _states) = unbounded_channel(); + let (state_sender, mut states) = unbounded_channel(); let invite = tokio::spawn(async move { layer.do_invite(option, state_sender).await }); async fn recv(peer: &UdpSocket, method: Method) -> (Request, std::net::SocketAddr) { @@ -177,8 +178,17 @@ async fn client_dialog_pracks_each_reliable_provisional() -> crate::Result<()> { let (inv, uac) = recv(&peer, Method::Invite).await; assert!(inv.header_contains_token("Supported", "100rel")); - let sdp = "v=0\r\no=- 1 1 IN IP4 127.0.0.1\r\ns=-\r\nc=IN IP4 127.0.0.1\r\nt=0 0\r\n"; + let sdp = "v=0\r\no=- 1 1 IN IP4 127.0.0.1\r\ns=-\r\nc=IN IP4 127.0.0.1\r\nt=0 0\r\nm=audio 5002 RTP/AVP 0\r\n"; for rseq in [1u32, 2] { + if rseq == 2 { + // Even changed status/body cannot turn the same (dialog, CSeq, + // RSeq) into a new response. A gap must not advance the sequence. + for (status, sequence) in [("180 Ringing", 1), ("183 Session Progress", 3)] { + let extra = format!("Require: 100rel\r\nRSeq: {sequence}\r\n"); + peer.send_to(reply(&inv, status, &extra, "").as_bytes(), uac) + .await?; + } + } let extra = format!("Require: 100rel\r\nRSeq: {rseq}\r\nContent-Type: application/sdp\r\n"); let progress = reply(&inv, "183 Session Progress", &extra, sdp); peer.send_to(progress.as_bytes(), uac).await?; @@ -187,6 +197,20 @@ async fn client_dialog_pracks_each_reliable_provisional() -> crate::Result<()> { peer.send_to(reply(&prack, "200 OK", "", "").as_bytes(), from) .await?; } + let early = timeout(Duration::from_secs(1), async { + let mut early = vec![]; + while early.len() < 2 { + if let Some(crate::dialog::dialog::DialogState::Early(_, response)) = + states.recv().await + { + early.push(response.rseq_value().unwrap()); + } + } + early + }) + .await + .expect("early responses"); + assert_eq!(early, [1, 2]); invite.abort(); token.cancel(); Ok(()) diff --git a/src/dialog/tests/test_prack_validation.rs b/src/dialog/tests/test_prack_validation.rs new file mode 100644 index 00000000..0fe6e1b8 --- /dev/null +++ b/src/dialog/tests/test_prack_validation.rs @@ -0,0 +1,328 @@ +//! RFC 3262 §§3, 4, 7 and 10: sequence validation and truthful UAS behavior. +use super::test_dialog_states::{create_invite_request, create_test_endpoint}; +use crate::dialog::{ + dialog::{DialogInner, DialogState}, + invite_dialog::InviteDialog, + server_dialog::ServerInviteDialog, + DialogId, +}; +use crate::sip::{headers, Header, HeadersExt, Method, Response, SipMessage, StatusCode}; +use crate::transaction::{ + key::{TransactionKey, TransactionRole}, + transaction::Transaction, +}; +use crate::transport::{channel::ChannelConnection, SipAddr, SipConnection, TransportEvent}; +use std::sync::Arc; +use tokio::sync::mpsc::unbounded_channel; + +fn response(rseq: &str, cseq: u32, tag: &str) -> Response { + format!("SIP/2.0 183 Session Progress\r\nVia: SIP/2.0/UDP 127.0.0.1:5060;branch=z9hG4bK-rel\r\nFrom: ;tag=alice\r\nTo: ;tag={tag}\r\nCall-ID: reliable\r\nCSeq: {cseq} INVITE\r\nRequire: 100rel\r\nRSeq: {rseq}\r\nContact: \r\nContent-Length: 0\r\n\r\n").try_into().unwrap() +} + +#[test] +fn rseq_requires_one_nonzero_unsigned_number() { + for (value, expected) in [ + ("1", Some(1)), + ("4294967295", Some(u32::MAX)), + ("0", None), + ("+1", None), + ("-1", None), + ("", None), + ("1 2", None), + ("4294967296", None), + ] { + assert_eq!(response(value, 1, "bob").rseq_value(), expected, "{value}"); + } + let mut resp = response("1", 1, "bob"); + resp.headers.push(Header::Other("rseq".into(), "1".into())); + assert_eq!(resp.rseq_value(), None); +} +#[test] +fn rack_requires_exactly_two_numbers_and_case_sensitive_method() { + for (value, valid) in [ + ("1 0 INVITE", true), + ("4294967295 2147483647 INVITE", true), + ("0 1 INVITE", false), + ("+1 1 INVITE", false), + ("1 +1 INVITE", false), + ("1 2147483648 INVITE", false), + ("1 1 invite", false), + ("1 1 INVITE extra", false), + ("1 1", false), + ] { + let mut resp = response("1", 1, "bob"); + resp.headers.push(Header::RAck(value.into())); + assert_eq!(resp.rack_value().is_some(), valid, "{value}"); + } +} +#[test] +fn rack_duplicate_is_invalid_and_generic_header_is_supported() { + let mut resp = response("1", 1, "bob"); + resp.headers + .push(Header::Other("rack".into(), "1 1 INVITE".into())); + assert_eq!(resp.rack_value(), Some((1, 1, Method::Invite))); + resp.headers.push(Header::RAck("1 1 INVITE".into())); + assert_eq!(resp.rack_value(), None); +} + +async fn client() -> crate::Result> { + let endpoint = create_test_endpoint().await?; + let mut request = create_invite_request("alice", "", "reliable"); + request + .headers + .unique_push(headers::To::new("").into()); + let (states, _) = unbounded_channel(); + let (tu, _) = unbounded_channel(); + Ok(Arc::new(DialogInner::new( + TransactionRole::Client, + DialogId { + call_id: "reliable".into(), + local_tag: "alice".into(), + remote_tag: "".into(), + }, + request, + endpoint.inner.clone(), + states, + None, + None, + tu, + )?)) +} +#[tokio::test] +async fn gaps_are_discarded_without_advancing_rseq() -> crate::Result<()> { + let inner = client().await?; + assert!(inner + .prepare_prack_request(&response("20", 1, "bob"))? + .is_some()); + assert!(inner + .prepare_prack_request(&response("22", 1, "bob"))? + .is_none()); + assert!(inner + .prepare_prack_request(&response("21", 1, "bob"))? + .is_some()); + assert!(inner + .prepare_prack_request(&response("22", 1, "bob"))? + .is_some()); + Ok(()) +} +#[tokio::test] +async fn duplicates_and_old_responses_do_not_create_prack() -> crate::Result<()> { + let inner = client().await?; + let first = inner + .prepare_prack_request(&response("20", 1, "bob"))? + .unwrap(); + for rseq in ["20", "19"] { + let mut retransmission = response(rseq, 1, "bob"); + retransmission.body = b"different SDP".to_vec(); + assert!(inner.prepare_prack_request(&retransmission)?.is_none()); + } + let next = inner + .prepare_prack_request(&response("21", 1, "bob"))? + .unwrap(); + assert_eq!(next.cseq_header()?.seq()?, first.cseq_header()?.seq()? + 1); + Ok(()) +} +#[tokio::test] +async fn each_invite_and_early_dialog_has_its_own_rseq_space() -> crate::Result<()> { + let inner = client().await?; + for (rseq, cseq, tag) in [ + ("20", 1, "bob"), + ("1", 2, "bob"), + ("5", 1, "carol"), + ("21", 1, "bob"), + ("6", 1, "carol"), + ] { + let prack = inner + .prepare_prack_request(&response(rseq, cseq, tag))? + .unwrap(); + assert_eq!( + prack.rack_value(), + Some((rseq.parse().unwrap(), cseq, Method::Invite)) + ); + assert_eq!(prack.to_header()?.tag()?.unwrap().value(), tag); + } + Ok(()) +} +#[tokio::test] +async fn first_rseq_is_limited_and_100_or_final_never_pracked() -> crate::Result<()> { + let inner = client().await?; + assert!(inner + .prepare_prack_request(&response("2147483648", 1, "bob"))? + .is_none()); + assert!(inner + .prepare_prack_request(&response("2147483647", 1, "bob"))? + .is_some()); + let mut next = response("2147483648", 1, "bob"); + next.headers + .unique_push(Header::Contact("".into())); + assert!(inner.prepare_prack_request(&next)?.is_some()); + assert_eq!( + inner.remote_uri.lock().to_string(), + "sip:refreshed@127.0.0.1:5061" + ); + for status in [StatusCode::Trying, StatusCode::OK] { + let mut resp = response("1", 2, "bob"); + resp.status_code = status; + assert!(inner.prepare_prack_request(&resp)?.is_none()); + } + Ok(()) +} +#[tokio::test] +async fn unrelated_responses_cannot_change_reliable_sequence() -> crate::Result<()> { + let inner = client().await?; + for header in [ + Header::CallId("other".into()), + Header::From(";tag=other".into()), + Header::CSeq("1 UPDATE".into()), + ] { + let mut resp = response("1", 1, "bob"); + resp.headers.unique_push(header); + assert!(inner.prepare_prack_request(&resp)?.is_none()); + } + assert!(inner + .prepare_prack_request(&response("1", 1, "bob"))? + .is_some()); + Ok(()) +} +#[tokio::test] +async fn invalid_reliable_provisional_is_not_delivered_or_applied() -> crate::Result<()> { + let inner = client().await?; + let req = inner.initial_request.lock().clone(); + inner.prepare_prack_request(&response("20", 1, "bob"))?; + for rseq in ["20", "22", "0", "+21"] { + assert!( + !inner + .handle_provisional_response(&response(rseq, 1, "bob"), &req) + .await? + ); + } + assert!( + !inner + .handle_provisional_response(&response("1", 2, "bob"), &req) + .await? + ); + assert!(inner.id.lock().remote_tag.is_empty()); + Ok(()) +} + +async fn uas( + required: bool, + confirmed: bool, + legacy: bool, + rack: Option<&str>, +) -> crate::Result<(Response, DialogState)> { + let endpoint = create_test_endpoint().await?; + let (out, mut outgoing) = unbounded_channel(); + let addr: SipAddr = "127.0.0.1:5060".parse::()?.into(); + let conn: SipConnection = + ChannelConnection::create_connection(unbounded_channel().1, out, addr, None) + .await? + .into(); + let (states, _) = unbounded_channel(); + let (tu, _) = unbounded_channel(); + let mut request = create_invite_request("alice", "", "reliable"); + request + .headers + .unique_push(headers::To::new("").into()); + let id = DialogId { + call_id: "reliable".into(), + local_tag: "bob".into(), + remote_tag: "alice".into(), + }; + let inner = Arc::new(DialogInner::new( + TransactionRole::Server, + id.clone(), + request.clone(), + endpoint.inner.clone(), + states, + None, + None, + tu, + )?); + if confirmed { + request.to_header_mut()?.mut_tag("bob".into())?; + *inner.state.lock() = DialogState::Confirmed(id, Response::default()); + } + if required { + request + .headers + .push(Header::Require("timer, 100rel".into())); + } + if let Some(rack) = rack { + request.method = Method::PRack; + request.headers.unique_push(Header::CSeq("2 PRACK".into())); + request.to_header_mut()?.mut_tag("bob".into())?; + if rack != "missing" { + request.headers.push(Header::RAck(rack.into())); + } + } + let key = TransactionKey::from_request(&request, TransactionRole::Server)?; + let mut tx = Transaction::new_server(key, request, endpoint.inner.clone(), Some(conn)); + tokio::time::timeout(std::time::Duration::from_millis(200), async { + if legacy { + ServerInviteDialog::from_inner(inner.clone()) + .handle(&mut tx) + .await + } else { + InviteDialog::from_inner(inner.clone()) + .handle(&mut tx) + .await + } + }) + .await + .expect("UAS should answer immediately")?; + let TransportEvent::Incoming(SipMessage::Response(response), _, _) = + outgoing.try_recv().unwrap() + else { + panic!("no response") + }; + let state = inner.state.lock().clone(); + Ok((response, state)) +} +#[tokio::test] +async fn required_100rel_gets_420_and_unsupported() -> crate::Result<()> { + for legacy in [false, true] { + let (response, state) = uas(true, false, legacy, None).await?; + assert_eq!(response.status_code, StatusCode::BadExtension); + assert_eq!( + response.header_value("Unsupported").as_deref(), + Some("100rel") + ); + assert!(state.is_terminated()); + } + Ok(()) +} +#[tokio::test] +async fn rejecting_required_100rel_reinvite_preserves_confirmed_dialog() -> crate::Result<()> { + for legacy in [false, true] { + let (response, state) = uas(true, true, legacy, None).await?; + assert_eq!(response.status_code, StatusCode::BadExtension); + assert!(state.is_confirmed()); + } + Ok(()) +} +#[tokio::test] +async fn prack_requires_a_real_outstanding_response_not_just_valid_rack() -> crate::Result<()> { + for legacy in [false, true] { + for rack in [ + "1 1 INVITE", + "2 1 INVITE", + "1 2 INVITE", + "1 1 UPDATE", + "1 1 X-EXT", + "1 1 invite", + ] { + assert_eq!( + uas(false, false, legacy, Some(rack)).await?.0.status_code, + StatusCode::CallTransactionDoesNotExist + ); + } + for rack in ["missing", "0 1 INVITE", "1 1 INVITE extra", "1 1 INV/ITE"] { + assert_eq!( + uas(false, false, legacy, Some(rack)).await?.0.status_code, + StatusCode::BadRequest + ); + } + } + Ok(()) +} diff --git a/src/dialog/tests/test_reliable_provisional.rs b/src/dialog/tests/test_reliable_provisional.rs new file mode 100644 index 00000000..98265091 --- /dev/null +++ b/src/dialog/tests/test_reliable_provisional.rs @@ -0,0 +1,1327 @@ +use super::test_dialog_states::create_invite_request; +use crate::dialog::{ + dialog::{DialogState, TransactionHandle}, + dialog_layer::DialogLayer, + invite_dialog::InviteDialog, + reliable::{ + IncomingPrack, PrackBody, PrackHandler, ReliableProvisionalConfig, ReliableResponse, + SdpKind, + }, +}; +use crate::sip::{Header, HeadersExt, Method, Request, Response, SipMessage, StatusCode}; +use crate::transaction::{ + endpoint::{Endpoint, EndpointOption}, + key::{TransactionKey, TransactionRole}, + transaction::Transaction, +}; +use crate::transport::{channel::ChannelConnection, SipAddr, SipConnection, TransportEvent}; +use crate::{EndpointBuilder, Result}; +use async_trait::async_trait; +use std::sync::Arc; +use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver}; +use tokio::time::{timeout, Duration}; + +const OFFER: &str = "v=0\r\no=- 1 1 IN IP4 127.0.0.1\r\ns=-\r\nc=IN IP4 127.0.0.1\r\nt=0 0\r\nm=audio 4000 RTP/AVP 0\r\n"; +const ANSWER: &str = "v=0\r\no=- 2 1 IN IP4 127.0.0.1\r\ns=-\r\nc=IN IP4 127.0.0.1\r\nt=0 0\r\nm=audio 4002 RTP/AVP 0\r\n"; + +#[derive(Default)] +struct Media { + events: parking_lot::Mutex>, + results: parking_lot::Mutex>>, + errors: parking_lot::Mutex>, + new_offer: bool, +} +#[async_trait] +impl PrackHandler for Media { + async fn on_reliable_response(&self, event: ReliableResponse) -> Result> { + self.events.lock().push(event.sdp_kind); + Ok(match event.sdp_kind { + SdpKind::Offer => Some(PrackBody::sdp(ANSWER)), + SdpKind::Answer if self.new_offer => Some(PrackBody::sdp(OFFER)), + _ => None, + }) + } + async fn on_prack(&self, event: IncomingPrack) -> Result> { + self.events.lock().push(event.sdp_kind); + Ok((event.sdp_kind == SdpKind::Offer).then(|| PrackBody::sdp(ANSWER))) + } + async fn on_prack_result(&self, _: Request, response: Option) { + self.results.lock().push(response); + } + async fn on_error(&self, _: crate::dialog::DialogId, error: String) { + self.errors.lock().push(error); + } +} + +struct Server { + endpoint: Endpoint, + layer: DialogLayer, + dialog: InviteDialog, + tx: Transaction, + outgoing: UnboundedReceiver, + conn: SipConnection, + media: Arc, + events: UnboundedReceiver, +} +impl Server { + async fn new(offer: bool) -> Result { + Self::with_peer(offer, Some(Header::Require("100rel".into()))).await + } + async fn with_peer(offer: bool, option: Option
) -> Result { + let endpoint = EndpointBuilder::new() + .with_option(EndpointOption { + t1: Duration::from_millis(20), + t2: Duration::from_millis(40), + t1x64: Duration::from_millis(1280), + ..Default::default() + }) + .build(); + let (out, outgoing) = unbounded_channel(); + let addr: SipAddr = "127.0.0.1:5060".parse::()?.into(); + let conn: SipConnection = + ChannelConnection::create_connection(unbounded_channel().1, out, addr, None) + .await? + .into(); + endpoint.inner.transport_layer.add_transport(conn.clone()); + let mut request = create_invite_request("alice", "", "reliable-full"); + request + .headers + .unique_push(Header::To("".into())); + if let Some(option) = option { + request.headers.push(option); + } + request.body.clear(); + if offer { + request.body = OFFER.as_bytes().to_vec(); + request + .headers + .unique_push(Header::ContentType("application/sdp".into())); + } + request + .headers + .unique_push(Header::ContentLength((request.body.len() as u32).into())); + let key = TransactionKey::from_request(&request, TransactionRole::Server)?; + let tx = Transaction::new_server(key, request, endpoint.inner.clone(), Some(conn.clone())); + let layer = Arc::new(DialogLayer::new(endpoint.inner.clone())); + let media = Arc::new(Media::default()); + layer.set_reliable_provisional(Some(ReliableProvisionalConfig::new(media.clone()))); + let (states, events) = unbounded_channel(); + let dialog = layer.get_or_create_server_invite( + &tx, + states, + None, + Some("sip:b@127.0.0.1:5060".try_into()?), + )?; + Ok(Self { + endpoint, + layer: Arc::try_unwrap(layer).ok().unwrap(), + dialog, + tx, + outgoing, + conn, + media, + events, + }) + } + fn response(&self, status: StatusCode, body: Option<&str>) -> Response { + self.dialog.inner.make_response( + &self.tx.original, + status, + body.map(|_| vec![Header::ContentType("application/sdp".into())]), + body.map(|s| s.as_bytes().to_vec()), + ) + } + async fn send(&mut self, status: StatusCode, body: Option<&str>) -> Result<()> { + self.tx.respond(self.response(status, body)).await + } + fn wire(&mut self) -> Response { + match self.outgoing.try_recv().expect("response on wire") { + TransportEvent::Incoming(SipMessage::Response(r), _, _) => r, + _ => panic!("not a response"), + } + } + fn prack(&self, response: &Response, body: Option<&str>) -> Result { + let mut request = self.tx.original.clone(); + request.method = Method::PRack; + request.headers.unique_push(Header::CSeq("2 PRACK".into())); + request.headers.unique_push(Header::Via( + format!( + "SIP/2.0/UDP 127.0.0.1:5060;branch=z9hG4bK{}", + crate::transaction::make_uuid_v4() + ) + .into(), + )); + request + .headers + .unique_push(Header::To(response.to_header()?.clone())); + request.headers.unique_push(Header::RAck( + format!( + "{} {} INVITE", + response.rseq_value().unwrap(), + self.tx.original.cseq_header()?.seq()? + ) + .into(), + )); + request.body = body.unwrap_or("").as_bytes().to_vec(); + request + .headers + .retain(|h| !matches!(h, Header::Require(_) | Header::ContentType(_))); + if body.is_some() { + request + .headers + .push(Header::ContentType("application/sdp".into())); + } + request + .headers + .unique_push(Header::ContentLength((request.body.len() as u32).into())); + let key = TransactionKey::from_request(&request, TransactionRole::Server)?; + Ok(Transaction::new_server( + key, + request, + self.endpoint.inner.clone(), + Some(self.conn.clone()), + )) + } + async fn ack(&mut self, response: &Response, body: Option<&str>) -> Result { + let mut tx = self.prack(response, body)?; + self.dialog.inner.receive_prack(&mut tx).await?; + Ok(self.wire()) + } + async fn pump(&mut self) { + let event = self + .tx + .tu_receiver + .try_recv() + .expect("queued transaction event"); + self.tx.dispatch_event(event).await; + } +} + +#[tokio::test] +async fn reliable_uas_waits_for_sdp_prack_before_final_200() -> Result<()> { + let mut s = Server::new(true).await?; + s.send(StatusCode::SessionProgress, Some(ANSWER)).await?; + let first = s.wire(); + assert!(first.header_contains_token("Require", "100rel")); + assert!((1..=i32::MAX as u32).contains(&first.rseq_value().unwrap())); + s.send(StatusCode::OK, None).await?; + assert!(s.outgoing.try_recv().is_err()); + assert!(matches!( + *s.dialog.inner.state.lock(), + DialogState::Early(..) + )); + assert_eq!(s.ack(&first, None).await?.status_code, StatusCode::OK); + s.pump().await; + assert_eq!(s.wire().status_code, StatusCode::OK); + assert!(s.dialog.inner.waiting_ack()); + Ok(()) +} + +#[tokio::test] +async fn reliable_uas_offerless_invite_gets_answer_in_prack() -> Result<()> { + let mut s = Server::new(false).await?; + s.send(StatusCode::SessionProgress, Some(OFFER)).await?; + let first = s.wire(); + assert_eq!( + s.ack(&first, None).await?.status_code, + StatusCode::BadRequest + ); + assert_eq!( + s.ack(&first, Some(ANSWER)).await?.status_code, + StatusCode::OK + ); + assert_eq!(*s.media.events.lock(), vec![SdpKind::Answer]); + Ok(()) +} + +#[tokio::test] +async fn reliable_uas_answers_new_offer_in_prack_200() -> Result<()> { + let mut s = Server::new(true).await?; + s.send(StatusCode::SessionProgress, Some(ANSWER)).await?; + let first = s.wire(); + let response = s.ack(&first, Some(OFFER)).await?; + assert_eq!(response.status_code, StatusCode::OK); + assert_eq!(response.body, ANSWER.as_bytes()); + assert_eq!(*s.media.events.lock(), vec![SdpKind::Offer]); + Ok(()) +} + +#[tokio::test] +async fn reliable_uas_serializes_provisional_responses_and_increments_rseq() -> Result<()> { + let mut s = Server::new(true).await?; + s.send(StatusCode::Ringing, None).await?; + let first = s.wire(); + s.send(StatusCode::SessionProgress, Some(ANSWER)).await?; + assert!(s.outgoing.try_recv().is_err()); + s.ack(&first, None).await?; + s.pump().await; + let second = s.wire(); + assert_eq!(second.rseq_value(), first.rseq_value().map(|n| n + 1)); + assert_eq!(second.body, ANSWER.as_bytes()); + Ok(()) +} + +#[tokio::test] +async fn reliable_uas_checks_dialog_and_entire_rack() -> Result<()> { + let mut s = Server::new(true).await?; + s.send(StatusCode::SessionProgress, Some(ANSWER)).await?; + let first = s.wire(); + for header in [ + Header::RAck(format!("{} 99 INVITE", first.rseq_value().unwrap()).into()), + Header::RAck(format!("{} 1 UPDATE", first.rseq_value().unwrap()).into()), + Header::From(";tag=wrong".into()), + Header::To(";tag=wrong".into()), + Header::CallId("wrong".into()), + ] { + let mut tx = s.prack(&first, None)?; + tx.original.headers.unique_push(header); + s.dialog.inner.receive_prack(&mut tx).await?; + assert_eq!( + s.wire().status_code, + StatusCode::CallTransactionDoesNotExist + ); + } + assert_eq!(s.ack(&first, None).await?.status_code, StatusCode::OK); + assert_eq!( + s.ack(&first, None).await?.status_code, + StatusCode::CallTransactionDoesNotExist + ); + Ok(()) +} + +#[tokio::test] +async fn reliable_uas_cancel_discards_deferred_200_but_accepts_late_prack() -> Result<()> { + let mut s = Server::new(true).await?; + s.send(StatusCode::SessionProgress, Some(ANSWER)).await?; + let first = s.wire(); + s.send(StatusCode::OK, None).await?; + s.send(StatusCode::RequestTerminated, None).await?; + assert_eq!(s.wire().status_code, StatusCode::RequestTerminated); + s.layer.remove_dialog(&s.dialog.id()); + let mut prack = s.prack(&first, None)?; + let mut retired = s + .layer + .match_dialog(&prack) + .expect("late PRACK route retained"); + retired.handle(&mut prack).await?; + assert_eq!(s.wire().status_code, StatusCode::OK); + assert!(s.tx.tu_receiver.try_recv().is_err()); + assert!(s.dialog.inner.is_terminated()); + Ok(()) +} + +#[tokio::test(start_paused = true)] +async fn reliable_uas_retransmits_without_t2_cap_and_times_out_at_64_t1() -> Result<()> { + let mut s = Server::new(true).await?; + s.send(StatusCode::SessionProgress, Some(ANSWER)).await?; + let first = s.wire(); + s.send(StatusCode::OK, None).await?; + tokio::task::yield_now().await; + for delay in [20, 40, 80, 160, 320, 640] { + tokio::time::advance(Duration::from_millis(delay - 1)).await; + tokio::task::yield_now().await; + assert!(s.tx.tu_receiver.try_recv().is_err()); + tokio::time::advance(Duration::from_millis(1)).await; + tokio::task::yield_now().await; + s.pump().await; + assert_eq!(s.wire(), first); + } + tokio::time::advance(Duration::from_millis(20)).await; + tokio::task::yield_now().await; + s.pump().await; + assert_eq!(s.wire().status_code, StatusCode::ServerTimeOut); + assert_eq!(s.media.errors.lock().len(), 1); + Ok(()) +} + +#[tokio::test(start_paused = true)] +async fn reliable_uas_prack_stops_already_queued_retransmission() -> Result<()> { + let mut s = Server::new(true).await?; + s.send(StatusCode::SessionProgress, Some(ANSWER)).await?; + let first = s.wire(); + tokio::task::yield_now().await; + tokio::time::advance(Duration::from_millis(20)).await; + tokio::task::yield_now().await; + s.ack(&first, None).await?; + s.pump().await; + assert!(s.outgoing.try_recv().is_err()); + tokio::time::advance(Duration::from_secs(2)).await; + tokio::task::yield_now().await; + assert!(s.tx.tu_receiver.try_recv().is_err()); + Ok(()) +} + +#[tokio::test] +async fn reliable_reinvite_command_loop_drives_queued_final() -> Result<()> { + let mut s = Server::new(true).await?; + *s.dialog.inner.state.lock() = DialogState::Confirmed(s.dialog.id(), Response::default()); + let mut reinvite = s.tx.original.clone(); + reinvite + .to_header_mut()? + .mut_tag(s.dialog.id().local_tag.into())?; + reinvite + .headers + .unique_push(Header::CSeq("3 INVITE".into())); + reinvite.headers.unique_push(Header::Via( + "SIP/2.0/UDP 127.0.0.1:5060;branch=z9hG4bK-reinvite".into(), + )); + let key = TransactionKey::from_request(&reinvite, TransactionRole::Server)?; + s.tx = Transaction::new_server( + key, + reinvite, + s.endpoint.inner.clone(), + Some(s.conn.clone()), + ); + s.dialog.inner.attach_reliable_server(&s.tx)?; + let (handle, rx) = TransactionHandle::new(); + handle + .respond( + StatusCode::SessionProgress, + Some(vec![Header::ContentType("application/sdp".into())]), + Some(ANSWER.as_bytes().to_vec()), + ) + .await + .unwrap(); + handle.respond(StatusCode::OK, None, None).await.unwrap(); + let inner = s.dialog.inner.clone(); + let task = tokio::spawn(async move { + inner + .process_transaction_handle(&mut s.tx, rx) + .await + .map(|_| s.tx) + }); + let TransportEvent::Incoming(SipMessage::Response(first), _, _) = + timeout(Duration::from_secs(1), s.outgoing.recv()) + .await + .unwrap() + .unwrap() + else { + panic!("no provisional"); + }; + assert!(!task.is_finished()); + let mut request = create_invite_request("alice", "", "reliable-full"); + request.body.clear(); + request.method = Method::PRack; + request + .headers + .unique_push(Header::To(first.to_header()?.clone())); + request.headers.unique_push(Header::CSeq("2 PRACK".into())); + request.headers.push(Header::RAck( + format!("{} 3 INVITE", first.rseq_value().unwrap()).into(), + )); + let key = TransactionKey::from_request(&request, TransactionRole::Server)?; + let mut prack = Transaction::new_server(key, request, s.endpoint.inner.clone(), Some(s.conn)); + s.dialog.inner.receive_prack(&mut prack).await?; + let tx = timeout(Duration::from_secs(1), task) + .await + .unwrap() + .unwrap()?; + assert_eq!( + tx.last_response.as_ref().unwrap().status_code, + StatusCode::OK + ); + assert!(s.dialog.inner.is_confirmed()); + Ok(()) +} + +struct Client { + token: tokio_util::sync::CancellationToken, + peer: tokio::net::UdpSocket, + invite: Request, + uac: std::net::SocketAddr, + call: tokio::task::JoinHandle)>>, + media: Arc, + dialog: InviteDialog, + states: UnboundedReceiver, +} +async fn receive_request(peer: &tokio::net::UdpSocket, method: Method) -> Request { + let mut bytes = vec![0; 8192]; + timeout(Duration::from_secs(2), async { + loop { + let (len, _) = peer.recv_from(&mut bytes).await.unwrap(); + if let SipMessage::Request(req) = + SipMessage::try_from(std::str::from_utf8(&bytes[..len]).unwrap()).unwrap() + { + if req.method == method { + return req; + } + } + } + }) + .await + .expect("SIP request") +} +fn reply( + request: &Request, + status: StatusCode, + tag: &str, + contact: std::net::SocketAddr, + rseq: Option, + body: Option<&str>, +) -> Response { + let mut to = request.to_header().unwrap().clone(); + to.mut_tag(tag.into()).unwrap(); + let mut headers = vec![ + Header::Via(request.via_header().unwrap().clone()), + Header::From(request.from_header().unwrap().clone()), + Header::To(to), + Header::CallId(request.call_id_header().unwrap().clone()), + Header::CSeq(request.cseq_header().unwrap().clone()), + Header::Contact(format!("").into()), + Header::ContentLength((body.unwrap_or("").len() as u32).into()), + ]; + if let Some(rseq) = rseq { + headers.push(Header::RSeq(rseq.to_string().into())); + headers.push(Header::Require("100rel".into())); + } + if body.is_some() { + headers.push(Header::ContentType("application/sdp".into())); + } + Response { + status_code: status, + wire_reason: None, + headers: headers.into(), + body: body.unwrap_or("").as_bytes().to_vec(), + version: crate::sip::Version::V2, + } +} +impl Client { + async fn new(offer: bool, new_offer: bool, require: bool) -> Result { + use crate::dialog::invitation::InviteOption; + use crate::transport::{udp::UdpConnection, TransportLayer}; + let token = tokio_util::sync::CancellationToken::new(); + let peer = tokio::net::UdpSocket::bind("127.0.0.1:0").await?; + let transport = TransportLayer::new(token.child_token()); + let udp = UdpConnection::create_connection( + "127.0.0.1:0".parse().unwrap(), + None, + Some(token.child_token()), + ) + .await?; + let uac = udp.get_addr().addr.to_string().parse().unwrap(); + transport.add_transport(udp.into()); + let endpoint = EndpointBuilder::new() + .with_transport_layer(transport) + .with_cancel_token(token.child_token()) + .with_option(EndpointOption { + t1: Duration::from_millis(40), + t1x64: Duration::from_millis(2560), + ..Default::default() + }) + .build(); + let serve = endpoint.inner.clone(); + tokio::spawn(async move { serve.serve().await }); + let layer = Arc::new(DialogLayer::new(endpoint.inner.clone())); + let media = Arc::new(Media { + new_offer, + ..Default::default() + }); + layer.set_reliable_provisional(Some(ReliableProvisionalConfig { + handler: media.clone(), + require, + })); + let opt = InviteOption { + caller: "sip:alice@example.com".try_into()?, + callee: format!("sip:b@{}", peer.local_addr()?) + .as_str() + .try_into()?, + contact: format!("sip:a@{uac}").as_str().try_into()?, + offer: offer.then(|| OFFER.as_bytes().to_vec()), + ..Default::default() + }; + let (sender, states) = unbounded_channel(); + let (dialog, call) = layer.do_invite_async(opt, sender)?; + let invite = receive_request(&peer, Method::Invite).await; + Ok(Self { + token, + peer, + invite, + uac, + call, + media, + dialog, + states, + }) + } + async fn send(&self, response: Response) { + self.peer + .send_to(response.to_string().as_bytes(), self.uac) + .await + .unwrap(); + } + fn progress(&self, tag: &str, rseq: u32, body: Option<&str>) -> Response { + reply( + &self.invite, + StatusCode::SessionProgress, + tag, + self.peer.local_addr().unwrap(), + Some(rseq), + body, + ) + } + async fn acknowledge(&self, prack: &Request, body: Option<&str>) { + self.send(reply( + prack, + StatusCode::OK, + prack.to_header().unwrap().tag().unwrap().unwrap().value(), + self.peer.local_addr().unwrap(), + None, + body, + )) + .await; + } +} +impl Drop for Client { + fn drop(&mut self) { + self.call.abort(); + self.token.cancel(); + } +} + +#[tokio::test] +async fn reliable_uac_offerless_invite_answers_in_prack_and_handles_required_mode() -> Result<()> { + let mut c = Client::new(false, false, true).await?; + assert!(c.invite.header_contains_token("Supported", "100rel")); + assert!(c.invite.header_contains_token("Require", "100rel")); + c.send(c.progress("bob", 1, Some(OFFER))).await; + let prack = receive_request(&c.peer, Method::PRack).await; + assert_eq!(prack.body, ANSWER.as_bytes()); + assert_eq!( + crate::dialog::dialog::Dialog::Invite(c.dialog.clone()).remote_contact(), + Some(prack.uri.clone()) + ); + assert_eq!( + prack.rack_value(), + Some((1, c.invite.cseq_header()?.seq()?, Method::Invite)) + ); + assert_eq!(*c.media.events.lock(), vec![SdpKind::Offer]); + assert!(matches!( + *c.dialog.inner.state.lock(), + DialogState::Early(_, _) + )); + assert!(std::iter::from_fn(|| c.states.try_recv().ok()) + .any(|s| matches!(s, DialogState::Early(_, _)))); + c.acknowledge(&prack, None).await; + Ok(()) +} + +#[tokio::test] +async fn reliable_reinvite_prack_preserves_or_refreshes_target_from_contact() -> Result<()> { + reinvite_prack_target(false).await +} +#[tokio::test] +async fn controlled_reinvite_prack_preserves_or_refreshes_target_from_contact() -> Result<()> { + reinvite_prack_target(true).await +} +async fn reinvite_prack_target(controlled: bool) -> Result<()> { + let mut c = Client::new(true, false, false).await?; + c.send(reply( + &c.invite, + StatusCode::OK, + "bob", + c.peer.local_addr()?, + None, + Some(ANSWER), + )) + .await; + let (_, _) = timeout(Duration::from_secs(1), &mut c.call) + .await + .unwrap() + .unwrap()?; + let dialog = c.dialog.clone(); + let target = dialog.inner.remote_uri.lock().clone(); + let sender = dialog.clone(); + let reinvite_task = tokio::spawn(async move { + let headers = Some(vec![Header::ContentType("application/sdp".into())]); + let body = Some(OFFER.as_bytes().to_vec()); + if controlled { + let request = sender.prepare_reinvite(headers, body)?; + sender.send_reinvite(request, Default::default()).await + } else { + sender.reinvite(headers, body).await + } + }); + let reinvite = receive_request(&c.peer, Method::Invite).await; + assert!(reinvite.header_contains_token("Supported", "100rel")); + let mut progress = reply( + &reinvite, + StatusCode::SessionProgress, + "bob", + c.peer.local_addr()?, + Some(1), + Some(ANSWER), + ); + progress + .headers + .retain(|h| !matches!(h, Header::Contact(_))); + c.send(progress.clone()).await; + let first = receive_request(&c.peer, Method::PRack).await; + assert_eq!(first.uri, target); + c.acknowledge(&first, None).await; + progress.headers.unique_push(Header::RSeq("2".into())); + let refreshed_peer = tokio::net::UdpSocket::bind("127.0.0.1:0").await?; + let refreshed_target = format!("sip:refreshed@{}", refreshed_peer.local_addr()?); + progress + .headers + .push(Header::Contact(format!("<{refreshed_target}>").into())); + c.send(progress).await; + let second = receive_request(&refreshed_peer, Method::PRack).await; + assert_eq!(second.uri.to_string(), refreshed_target); + assert_eq!(dialog.inner.remote_uri.lock().to_string(), refreshed_target); + let ok = reply( + &second, + StatusCode::OK, + "bob", + refreshed_peer.local_addr()?, + None, + None, + ); + refreshed_peer + .send_to(ok.to_string().as_bytes(), c.uac) + .await?; + c.send(reply( + &reinvite, + StatusCode::OK, + "bob", + c.peer.local_addr()?, + None, + Some(ANSWER), + )) + .await; + assert_eq!( + timeout(Duration::from_secs(1), reinvite_task) + .await + .unwrap() + .unwrap()? + .unwrap() + .status_code, + StatusCode::OK + ); + Ok(()) +} + +#[tokio::test] +async fn reliable_uac_new_offer_in_prack_delivers_the_answer() -> Result<()> { + let c = Client::new(true, true, false).await?; + c.send(c.progress("bob", 10, Some(ANSWER))).await; + let prack = receive_request(&c.peer, Method::PRack).await; + assert_eq!(prack.body, OFFER.as_bytes()); + c.acknowledge(&prack, Some(ANSWER)).await; + timeout(Duration::from_secs(1), async { + while c.media.results.lock().is_empty() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + assert_eq!( + c.media.results.lock()[0].as_ref().unwrap().body, + ANSWER.as_bytes() + ); + Ok(()) +} + +#[tokio::test] +async fn reliable_uac_invite_final_does_not_wait_for_prack_transaction() -> Result<()> { + let mut c = Client::new(true, false, false).await?; + c.send(c.progress("bob", 1, Some(ANSWER))).await; + let prack = receive_request(&c.peer, Method::PRack).await; + c.send(reply( + &c.invite, + StatusCode::OK, + "bob", + c.peer.local_addr()?, + None, + Some(ANSWER), + )) + .await; + let (_, response) = timeout(Duration::from_millis(500), &mut c.call) + .await + .expect("INVITE must not wait for PRACK's 200") + .unwrap()?; + assert_eq!(response.unwrap().status_code, StatusCode::OK); + c.acknowledge(&prack, None).await; + Ok(()) +} + +#[tokio::test] +async fn reliable_uac_prack_retransmission_is_owned_by_its_transaction() -> Result<()> { + let c = Client::new(true, false, false).await?; + let progress = c.progress("bob", 1, Some(ANSWER)); + c.send(progress.clone()).await; + let first = receive_request(&c.peer, Method::PRack).await; + c.send(progress).await; // retransmitted 183 must not create another transaction + let repeated = receive_request(&c.peer, Method::PRack).await; + assert_eq!(first, repeated); + assert_eq!(c.media.events.lock().len(), 1); + c.acknowledge(&first, None).await; + Ok(()) +} + +#[tokio::test] +async fn reliable_uac_forks_have_independent_rseq_and_contact() -> Result<()> { + let c = Client::new(true, false, false).await?; + let other = tokio::net::UdpSocket::bind("127.0.0.1:0").await?; + c.send(c.progress("bob", 9, Some(ANSWER))).await; + let bob = receive_request(&c.peer, Method::PRack).await; + c.acknowledge(&bob, None).await; + c.send(reply( + &c.invite, + StatusCode::SessionProgress, + "carol", + other.local_addr()?, + Some(9), + Some(ANSWER), + )) + .await; + let carol = receive_request(&other, Method::PRack).await; + assert_eq!(carol.to_header()?.tag()?.unwrap().value(), "carol"); + assert_eq!( + carol.uri.to_string(), + format!("sip:peer@{}", other.local_addr()?) + ); + assert_ne!(bob.via_header()?, carol.via_header()?); + c.acknowledge(&carol, None).await; + assert_eq!(c.media.events.lock().len(), 2); + Ok(()) +} + +#[tokio::test] +async fn reliable_uac_strict_route_rewrites_uri_and_preserves_target() -> Result<()> { + let c = Client::new(true, false, false).await?; + let proxy = tokio::net::UdpSocket::bind("127.0.0.1:0").await?; + let mut response = c.progress("bob", 1, Some(ANSWER)); + response.headers.push(Header::RecordRoute( + format!( + ", ", + proxy.local_addr()? + ) + .into(), + )); + c.send(response).await; + let prack = receive_request(&proxy, Method::PRack).await; + assert_eq!( + prack.uri.to_string(), + format!("sip:strict@{}", proxy.local_addr()?) + ); + let routes: Vec<_> = prack.route_headers().iter().map(|r| r.value()).collect(); + assert_eq!( + routes, + vec![ + "".to_string(), + format!("", c.peer.local_addr()?) + ] + ); + c.acknowledge(&prack, None).await; + Ok(()) +} + +#[tokio::test] +async fn reliable_negotiation_supported_only_and_no_peer_support() -> Result<()> { + let mut supported = + Server::with_peer(true, Some(Header::Supported("timer, 100rel".into()))).await?; + supported.send(StatusCode::Ringing, None).await?; + assert!(supported.wire().rseq_value().is_some()); + let mut plain = Server::with_peer(true, None).await?; + plain.dialog.ringing(None, None)?; + plain.pump().await; + let response = plain.wire(); + assert!(response.rseq_value().is_none()); + assert!(!response.header_contains_token("Require", "100rel")); + plain.dialog.accept(None, None)?; + plain.pump().await; + assert_eq!(plain.wire().status_code, StatusCode::OK); + assert!(plain.dialog.inner.waiting_ack()); + Ok(()) +} + +#[tokio::test] +async fn reliable_missing_offer_rejects_invite_instead_of_hanging() -> Result<()> { + let mut s = Server::new(false).await?; + assert!(s.send(StatusCode::Ringing, None).await.is_err()); + s.pump().await; + assert_eq!(s.wire().status_code, StatusCode::ServerInternalError); + assert!(s.dialog.inner.is_terminated()); + Ok(()) +} + +#[tokio::test] +async fn reliable_no_sdp_provisional_does_not_delay_final() -> Result<()> { + let mut s = Server::new(true).await?; + s.send(StatusCode::Ringing, None).await?; + let provisional = s.wire(); + s.send(StatusCode::OK, Some(ANSWER)).await?; + assert_eq!(s.wire().status_code, StatusCode::OK); + assert_eq!(s.ack(&provisional, None).await?.status_code, StatusCode::OK); + assert!(s.dialog.inner.waiting_ack()); + Ok(()) +} + +#[tokio::test] +async fn reliable_lost_prack_200_replays_transaction_response_without_media_callback() -> Result<()> +{ + let mut s = Server::new(true).await?; + s.send(StatusCode::SessionProgress, Some(ANSWER)).await?; + let first = s.wire(); + let peer = tokio::net::UdpSocket::bind("127.0.0.1:0").await?; + let udp = crate::transport::udp::UdpConnection::create_connection( + "127.0.0.1:0".parse().unwrap(), + None, + None, + ) + .await?; + let connection: SipConnection = udp.into(); + let mut request = s.prack(&first, None)?.original.clone(); + request.headers.unique_push(Header::Via( + format!( + "SIP/2.0/UDP {};branch=z9hG4bK-prack-cache", + peer.local_addr()? + ) + .into(), + )); + let key = TransactionKey::from_request(&request, TransactionRole::Server)?; + let mut prack = Transaction::new_server( + key, + request.clone(), + s.endpoint.inner.clone(), + Some(connection.clone()), + ); + s.dialog.inner.receive_prack(&mut prack).await?; + let mut bytes = [0; 8192]; + let (len, _) = timeout(Duration::from_secs(1), peer.recv_from(&mut bytes)) + .await + .unwrap()?; + let response = bytes[..len].to_vec(); // Treat the first 200 as lost. + drop(prack); + let from: SipAddr = peer.local_addr()?.into(); + s.endpoint + .inner + .on_received_message(request.into(), connection, &from) + .await?; + let (len, _) = timeout(Duration::from_secs(1), peer.recv_from(&mut bytes)) + .await + .unwrap()?; + assert_eq!(&bytes[..len], response.as_slice()); + assert_eq!(s.media.events.lock().len(), 1); + Ok(()) +} + +#[tokio::test] +async fn reliable_incoming_reinvite_prack_on_locally_originated_dialog() -> Result<()> { + for legacy in [false, true] { + let mut s = Server::new(true).await?; + let inner = Arc::new(crate::dialog::dialog::DialogInner::new( + TransactionRole::Client, + s.dialog.id(), + s.tx.original.clone(), + s.endpoint.inner.clone(), + unbounded_channel().0, + None, + Some("sip:local@127.0.0.1:5060".try_into()?), + s.tx.tu_sender.clone(), + )?); + *inner.reliable_config.lock() = Some(ReliableProvisionalConfig::new(s.media.clone())); + inner.attach_reliable_server(&s.tx)?; + s.dialog = InviteDialog::from_inner(inner.clone()); + s.send(StatusCode::SessionProgress, Some(ANSWER)).await?; + let first = s.wire(); + // Re-INVITE is waiting on the application while its PRACK arrives. + *inner.state.lock() = DialogState::Updated( + s.dialog.id(), + s.tx.original.clone(), + TransactionHandle::new().0, + ); + let mut prack = s.prack(&first, None)?; + if legacy { + crate::dialog::client_dialog::ClientInviteDialog::from_inner(inner) + .handle(&mut prack) + .await?; + } else { + s.dialog.handle(&mut prack).await?; + } + assert_eq!(s.wire().status_code, StatusCode::OK); + assert_eq!(s.media.events.lock().len(), 1); + } + Ok(()) +} + +#[tokio::test] +async fn reliable_legacy_server_uses_the_same_engine() -> Result<()> { + use crate::dialog::server_dialog::ServerInviteDialog; + let mut s = Server::new(true).await?; + let mut legacy = ServerInviteDialog::from_inner(s.dialog.inner.clone()); + legacy.ringing( + Some(vec![Header::ContentType("application/sdp".into())]), + Some(ANSWER.as_bytes().to_vec()), + )?; + legacy.accept(None, None)?; + s.pump().await; + let first = s.wire(); + s.pump().await; + assert!(s.outgoing.try_recv().is_err()); + let mut prack = s.prack(&first, None)?; + legacy.handle(&mut prack).await?; + assert_eq!(s.wire().status_code, StatusCode::OK); + s.pump().await; + assert_eq!(s.wire().status_code, StatusCode::OK); + Ok(()) +} + +#[tokio::test] +async fn reliable_uac_discards_gaps_and_ignores_subsequent_sdp() -> Result<()> { + let c = Client::new(true, false, false).await?; + c.send(c.progress("bob", 1, Some(ANSWER))).await; + let first = receive_request(&c.peer, Method::PRack).await; + c.acknowledge(&first, None).await; + c.send(c.progress("bob", 3, None)).await; + c.send(c.progress("bob", 2, None)).await; + let next = receive_request(&c.peer, Method::PRack).await; + assert_eq!(next.rack_value().unwrap().0, 2); + c.acknowledge(&next, None).await; + c.send(c.progress("bob", 3, Some(OFFER))).await; // not a new offer + let last = receive_request(&c.peer, Method::PRack).await; + assert_eq!(last.rack_value().unwrap().0, 3); + assert!(last.body.is_empty()); + c.acknowledge(&last, None).await; + assert_eq!( + *c.media.events.lock(), + vec![SdpKind::Answer, SdpKind::None, SdpKind::Ignored] + ); + Ok(()) +} + +#[tokio::test] +async fn reliable_bad_media_handler_fails_both_transactions_cleanly() -> Result<()> { + struct Broken; + #[async_trait] + impl PrackHandler for Broken { + async fn on_reliable_response(&self, _: ReliableResponse) -> Result> { + Ok(None) + } + async fn on_prack(&self, _: IncomingPrack) -> Result> { + Err(crate::Error::Error("media failure".into())) + } + } + let mut s = Server::new(true).await?; + s.dialog + .set_reliable_provisional(Some(ReliableProvisionalConfig::new(Arc::new(Broken)))); + s.dialog.inner.reliable_servers.lock().clear(); + s.dialog.inner.attach_reliable_server(&s.tx)?; + s.send(StatusCode::SessionProgress, Some(ANSWER)).await?; + let first = s.wire(); + s.send(StatusCode::OK, None).await?; + assert_eq!( + s.ack(&first, Some(OFFER)).await?.status_code, + StatusCode::ServerInternalError + ); + s.pump().await; + assert_eq!(s.wire().status_code, StatusCode::ServerInternalError); + assert!(s.dialog.inner.is_terminated()); + Ok(()) +} + +async fn udp_endpoint( + token: &tokio_util::sync::CancellationToken, +) -> Result<(Endpoint, std::net::SocketAddr)> { + use crate::transport::{udp::UdpConnection, TransportLayer}; + let transport = TransportLayer::new(token.child_token()); + let udp = UdpConnection::create_connection( + "127.0.0.1:0".parse().unwrap(), + None, + Some(token.child_token()), + ) + .await?; + let addr = udp.get_addr().addr.to_string().parse().unwrap(); + transport.add_transport(udp.into()); + let endpoint = EndpointBuilder::new() + .with_transport_layer(transport) + .with_cancel_token(token.child_token()) + .build(); + let inner = endpoint.inner.clone(); + tokio::spawn(async move { inner.serve().await }); + Ok((endpoint, addr)) +} + +#[tokio::test] +async fn reliable_udp_stack_to_stack_all_three_sdp_patterns_and_bye() -> Result<()> { + use crate::dialog::invitation::InviteOption; + for (invite_offer, prack_offer) in [(true, false), (false, false), (true, true)] { + let token = tokio_util::sync::CancellationToken::new(); + let (server, server_addr) = udp_endpoint(&token).await?; + let mut incoming = server.incoming_transactions()?; + let server_layer = Arc::new(DialogLayer::new(server.inner.clone())); + let server_media = Arc::new(Media::default()); + server_layer + .set_reliable_provisional(Some(ReliableProvisionalConfig::new(server_media.clone()))); + let (states, mut events) = unbounded_channel(); + let router = tokio::spawn(async move { + while let Some(mut tx) = incoming.recv().await { + if let Some(mut dialog) = server_layer.match_dialog(&tx) { + tokio::spawn(async move { dialog.handle(&mut tx).await }); + } else if tx.original.method == Method::Invite { + let mut dialog = server_layer + .get_or_create_server_invite( + &tx, + states.clone(), + None, + Some(format!("sip:b@{server_addr}").as_str().try_into().unwrap()), + ) + .unwrap(); + dialog + .ringing( + Some(vec![Header::ContentType("application/sdp".into())]), + Some( + if invite_offer { ANSWER } else { OFFER } + .as_bytes() + .to_vec(), + ), + ) + .unwrap(); + dialog.accept(None, None).unwrap(); + tokio::spawn(async move { dialog.handle(&mut tx).await }); + } + } + }); + let (client, client_addr) = udp_endpoint(&token).await?; + let client_layer = DialogLayer::new(client.inner.clone()); + let client_media = Arc::new(Media { + new_offer: prack_offer, + ..Default::default() + }); + client_layer.set_reliable_provisional(Some(ReliableProvisionalConfig { + handler: client_media.clone(), + require: true, + })); + let opt = InviteOption { + caller: "sip:a@example.com".try_into()?, + callee: format!("sip:b@{server_addr}").as_str().try_into()?, + contact: format!("sip:a@{client_addr}").as_str().try_into()?, + offer: invite_offer.then(|| OFFER.as_bytes().to_vec()), + ..Default::default() + }; + let (dialog, final_response) = timeout( + Duration::from_secs(2), + client_layer.do_invite(opt, unbounded_channel().0), + ) + .await + .unwrap()?; + assert_eq!(final_response.unwrap().status_code, StatusCode::OK); + timeout(Duration::from_secs(2), async { + while !matches!(events.recv().await, Some(DialogState::Confirmed(..))) {} + }) + .await + .unwrap(); + timeout(Duration::from_secs(2), async { + while client_media.results.lock().is_empty() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + assert_eq!( + *client_media.events.lock(), + vec![if invite_offer { + SdpKind::Answer + } else { + SdpKind::Offer + }] + ); + assert_eq!( + *server_media.events.lock(), + vec![if prack_offer { + SdpKind::Offer + } else if invite_offer { + SdpKind::None + } else { + SdpKind::Answer + }] + ); + timeout(Duration::from_secs(2), dialog.bye()) + .await + .unwrap()?; + assert!(client_media.errors.lock().is_empty()); + assert!(server_media.errors.lock().is_empty()); + token.cancel(); + router.abort(); + } + Ok(()) +} + +#[tokio::test] +async fn reliable_reinvite_returns_after_consuming_transaction_termination() -> Result<()> { + use crate::transaction::{transaction::TransactionEvent, TransactionState}; + let mut s = Server::new(true).await?; + *s.dialog.inner.state.lock() = DialogState::Confirmed(s.dialog.id(), Response::default()); + let mut request = s.tx.original.clone(); + request + .to_header_mut()? + .mut_tag(s.dialog.id().local_tag.into())?; + request.headers.unique_push(Header::CSeq("3 INVITE".into())); + request.headers.unique_push(Header::Via( + "SIP/2.0/UDP 127.0.0.1:5060;branch=z9hG4bK-ended-reinvite".into(), + )); + let key = TransactionKey::from_request(&request, TransactionRole::Server)?; + s.tx = Transaction::new_server( + key.clone(), + request, + s.endpoint.inner.clone(), + Some(s.conn.clone()), + ); + // Model an already queued terminal event from the transaction's driver. + // The command loop consumes it; the ACK loop must not wait for it again. + s.tx.state = TransactionState::Terminated; + s.tx.tu_sender.send(TransactionEvent::Terminate(key))?; + timeout(Duration::from_secs(1), s.dialog.handle(&mut s.tx)) + .await + .expect("re-INVITE handler must finish")?; + assert!(matches!(s.events.try_recv(), Ok(DialogState::Updated(..)))); + Ok(()) +} + +#[tokio::test] +async fn controlled_offerless_reinvite_uses_prack_answer_and_empty_ack() -> Result<()> { + use crate::dialog::reinvite::{AckBody, InviteAnswerHandler, ReinviteOptions}; + use core::sync::atomic::{AtomicUsize, Ordering}; + struct FinalAnswer(AtomicUsize); + #[async_trait] + impl InviteAnswerHandler for FinalAnswer { + async fn answer(&self, _: Response) -> Result { + self.0.fetch_add(1, Ordering::SeqCst); + Ok(AckBody::sdp(ANSWER)) + } + fn fallback_answer(&self, _: &Response) -> AckBody { + AckBody::sdp(ANSWER) + } + } + let mut c = Client::new(true, false, false).await?; + c.send(reply( + &c.invite, + StatusCode::OK, + "bob", + c.peer.local_addr()?, + None, + Some(ANSWER), + )) + .await; + timeout(Duration::from_secs(1), &mut c.call) + .await + .unwrap() + .unwrap()?; + receive_request(&c.peer, Method::Ack).await; + let final_answer = Arc::new(FinalAnswer(AtomicUsize::new(0))); + let options = ReinviteOptions { + answer_handler: Some(final_answer.clone()), + ..Default::default() + }; + let dialog = c.dialog.clone(); + let request = dialog.prepare_reinvite(None, None)?; + let task = tokio::spawn(async move { dialog.send_reinvite(request, options).await }); + let invite = receive_request(&c.peer, Method::Invite).await; + c.send(reply( + &invite, + StatusCode::SessionProgress, + "bob", + c.peer.local_addr()?, + Some(1), + Some(OFFER), + )) + .await; + let prack = receive_request(&c.peer, Method::PRack).await; + assert_eq!(prack.body, ANSWER.as_bytes()); + c.acknowledge(&prack, None).await; + let final_response = reply( + &invite, + StatusCode::OK, + "bob", + c.peer.local_addr()?, + None, + Some(OFFER), + ); + c.send(final_response.clone()).await; + let ack = receive_request(&c.peer, Method::Ack).await; + assert!(ack.body.is_empty()); + assert_eq!(final_answer.0.load(Ordering::SeqCst), 0); + timeout(Duration::from_secs(1), task) + .await + .unwrap() + .unwrap()?; + c.send(final_response).await; + assert_eq!(receive_request(&c.peer, Method::Ack).await, ack); + Ok(()) +} + +#[tokio::test] +async fn controlled_incoming_reinvite_drives_prack_with_closed_command_channel() -> Result<()> { + use crate::transaction::transaction::TransactionEvent; + let mut s = Server::new(true).await?; + *s.dialog.inner.state.lock() = DialogState::Confirmed(s.dialog.id(), Response::default()); + let mut request = s.tx.original.clone(); + request + .to_header_mut()? + .mut_tag(s.dialog.id().local_tag.into())?; + request.headers.unique_push(Header::CSeq("3 INVITE".into())); + request.headers.unique_push(Header::Via( + "SIP/2.0/UDP 127.0.0.1:5060;branch=z9hG4bK-controlled-reliable".into(), + )); + let key = TransactionKey::from_request(&request, TransactionRole::Server)?; + s.tx = Transaction::new_server( + key, + request.clone(), + s.endpoint.inner.clone(), + Some(s.conn.clone()), + ); + s.dialog.inner.attach_reliable_server(&s.tx)?; + let sender = s.tx.tu_sender.clone(); + let inner = s.dialog.inner.clone(); + let task = tokio::spawn(async move { inner.process_reinvite(&mut s.tx, true).await }); + let Some(DialogState::Updated(_, _, handle)) = s.events.recv().await else { + panic!("missing re-INVITE event") + }; + handle + .respond( + StatusCode::SessionProgress, + Some(vec![Header::ContentType("application/sdp".into())]), + Some(ANSWER.as_bytes().to_vec()), + ) + .await?; + handle.respond(StatusCode::OK, None, None).await?; + drop(handle); + let Some(TransportEvent::Incoming(SipMessage::Response(first), _, _)) = s.outgoing.recv().await + else { + panic!("missing 183") + }; + assert_eq!(first.status_code, StatusCode::SessionProgress); + let mut prack = request.clone(); + prack.method = Method::PRack; + prack.headers.unique_push(Header::CSeq("4 PRACK".into())); + prack.headers.unique_push(Header::RAck( + format!("{} 3 INVITE", first.rseq_value().unwrap()).into(), + )); + prack.headers.unique_push(Header::Via( + "SIP/2.0/UDP 127.0.0.1:5060;branch=z9hG4bK-controlled-prack".into(), + )); + prack.body.clear(); + let key = TransactionKey::from_request(&prack, TransactionRole::Server)?; + let mut prack = + Transaction::new_server(key, prack, s.endpoint.inner.clone(), Some(s.conn.clone())); + s.dialog.inner.receive_prack(&mut prack).await?; + // First 200 is PRACK, second is the previously queued INVITE final. + s.outgoing.recv().await.unwrap(); + let Some(TransportEvent::Incoming(SipMessage::Response(final_response), _, _)) = + s.outgoing.recv().await + else { + panic!("missing INVITE final") + }; + assert_eq!(final_response.cseq_header()?.method()?, Method::Invite); + assert_eq!(final_response.status_code, StatusCode::OK); + let ack = s.endpoint.inner.make_ack(&request, &final_response)?; + sender.send(TransactionEvent::Received( + SipMessage::Request(ack), + Some(s.conn), + ))?; + timeout(Duration::from_secs(1), task) + .await + .unwrap() + .unwrap()?; + Ok(()) +} diff --git a/src/dialog/tests/test_target_refresh.rs b/src/dialog/tests/test_target_refresh.rs index 57dbb08a..7af71b4a 100644 --- a/src/dialog/tests/test_target_refresh.rs +++ b/src/dialog/tests/test_target_refresh.rs @@ -493,10 +493,9 @@ async fn reliable_response_duplicates_do_not_reapply_stale_contact() { assert_eq!(prack.uri.to_string(), NEW); assert_eq!(prack.route_header().unwrap().value(), ROUTE); inner.set_remote_target(OLD.try_into().unwrap(), Some(format!("<{OLD}>").into())); - assert_eq!( - inner.prepare_prack_request(&response).unwrap().unwrap(), - prack - ); + // RFC 3262 duplicates are discarded; the existing PRACK transaction + // owns retransmission. Its old Contact must not be applied again. + assert!(inner.prepare_prack_request(&response).unwrap().is_none()); assert_eq!(inner.remote_uri.lock().to_string(), OLD); response.headers.unique_push(Header::RSeq("4".into())); assert!(inner.prepare_prack_request(&response).unwrap().is_none()); diff --git a/src/sip/message.rs b/src/sip/message.rs index ab6d5bbb..d1555c0d 100644 --- a/src/sip/message.rs +++ b/src/sip/message.rs @@ -65,6 +65,42 @@ macro_rules! all_headers { }; } +fn sip_sequence_number(value: &str) -> Option { + if value.is_empty() || !value.bytes().all(|b| b.is_ascii_digit()) { + return None; + } + value.parse().ok() +} + +// Keep the wire method token: RFC 3261 permits extension methods, including +// case-sensitive tokens that the library's Method enum cannot represent. +pub(crate) fn rack_parts(message: &T) -> Option<(u32, u32, &str)> { + let mut fields = message + .headers() + .iter() + .filter(|h| h.name().eq_ignore_ascii_case("RAck")); + let value = fields.next()?.value(); + if fields.next().is_some() { + return None; + } + let mut parts = value.split_ascii_whitespace(); + let rseq = sip_sequence_number(parts.next()?).filter(|n| *n > 0)?; + let cseq = sip_sequence_number(parts.next()?).filter(|n| *n < (1 << 31))?; + let method = parts.next()?; + if parts.next().is_some() + || !method.bytes().all(|b| { + b.is_ascii_alphanumeric() + || matches!( + b, + b'-' | b'.' | b'!' | b'%' | b'*' | b'_' | b'+' | b'`' | b'\'' | b'~' + ) + }) + { + return None; + } + Some((rseq, cseq, method)) +} + pub trait HeadersExt: HasHeaders { fn to_header(&self) -> Result<&To, Error> { header_get!( @@ -344,28 +380,26 @@ pub trait HeadersExt: HasHeaders { fn path_headers(&self) -> Vec<&crate::sip::headers::untyped::Path> { all_headers!(self.headers().iter(), Header::Path) } + /// RFC 3262 §§7.1, 10: one RSeq, containing a nonzero 32-bit number. fn rseq_value(&self) -> Option { - self.headers().iter().find_map(|h| { - if let Header::RSeq(r) = h { - r.value().trim().parse().ok() - } else { - None - } - }) + let mut fields = self + .headers() + .iter() + .filter(|h| h.name().eq_ignore_ascii_case("RSeq")); + let value = fields.next()?.value().trim(); + if fields.next().is_some() { + return None; + } + sip_sequence_number(value).filter(|n| *n > 0) } + /// RFC 3262 §§7.2, 10: exactly response-num, CSeq-num and method. fn rack_value(&self) -> Option<(u32, u32, Method)> { - self.headers().iter().find_map(|h| { - if let Header::RAck(r) = h { - let v = r.value(); - let mut parts = v.split_whitespace(); - let rseq = parts.next()?.parse::().ok()?; - let cseq = parts.next()?.parse::().ok()?; - let method = parts.next()?.parse::().ok()?; - Some((rseq, cseq, method)) - } else { - None - } - }) + let (rseq, cseq, token) = rack_parts(self)?; + let method: Method = token.parse().ok()?; + if token != method.to_string() { + return None; + } + Some((rseq, cseq, method)) } fn header_value(&self, name: &str) -> Option { self.headers().iter().find_map(|h| { diff --git a/src/transaction/transaction.rs b/src/transaction/transaction.rs index dfd46ead..522c2d3c 100644 --- a/src/transaction/transaction.rs +++ b/src/transaction/transaction.rs @@ -195,6 +195,8 @@ pub struct Transaction { retransmission: bool, is_cleaned_up: bool, invite_reservation: Mutex>, + pub(crate) reliable_provisional: + crate::platform::sync::Mutex>>, } impl Transaction { @@ -244,6 +246,7 @@ impl Transaction { tu_sender, is_cleaned_up: false, invite_reservation: Mutex::new(None), + reliable_provisional: crate::platform::sync::Mutex::new(None), }; tx.endpoint_inner .attach_transaction(&tx.key, tx.tu_sender.clone()); @@ -483,6 +486,11 @@ impl Transaction { /// - the connection is missing, /// - the underlying transport send fails. /// + /// When full 100rel is enabled on this INVITE, a subsequent reliable 1xx + /// or a 2xx waiting for SDP's PRACK can be queued. Success then means the + /// response was accepted for delivery. Keep driving the owning transaction + /// to transmit it after PRACK; `last_response` reflects what was sent. + /// /// # Cancel safety /// /// **NOT cancel-safe.** The mutation order is: store `last_response` @@ -510,6 +518,20 @@ impl Transaction { } } + let reliable = self.reliable_provisional.lock().clone(); + let response = if let Some(server) = &reliable { + match server.prepare(response) { + Ok(Some(response)) => response, + Ok(None) => return Ok(()), + Err(e) => { + server.fail(e.to_string()); + return Err(e); + } + } + } else { + response + }; + let new_state = match response.status_code.kind() { StatusCodeKind::Provisional => match response.status_code { StatusCode::Trying => TransactionState::Trying, @@ -598,7 +620,11 @@ impl Transaction { } } guard.0 = None; - self.transition(new_state).map(|_| ()) + self.transition(new_state)?; + if let (Some(server), Some(response)) = (reliable, self.last_response.as_ref()) { + server.sent(response); + } + Ok(()) } fn add_ack_cseq_route(&self, dialog_id: &DialogId) -> Option<(DialogId, u32)> { @@ -1273,6 +1299,12 @@ impl Transaction { if last.status_code == resp.status_code && last.body == resp.body && last.rseq_value() == resp.rseq_value() + && last.cseq_header().ok() == resp.cseq_header().ok() + && last.call_id_header().ok() == resp.call_id_header().ok() + && last.from_header().and_then(|h| h.tag()).ok() + == resp.from_header().and_then(|h| h.tag()).ok() + && last.to_header().and_then(|h| h.tag()).ok() + == resp.to_header().and_then(|h| h.tag()).ok() { // ignore duplicate response return None; diff --git a/tests/interop/COVERAGE.md b/tests/interop/COVERAGE.md index f66ded94..0b7ad0a0 100644 --- a/tests/interop/COVERAGE.md +++ b/tests/interop/COVERAGE.md @@ -40,7 +40,7 @@ reports the excluded count, and is used by the normal CI job. `known-gaps` runs only these probes. Once fixed, move the tests into the regression set by removing `known_gap_` from their names and update this document. -The harness commit does not modify the digest parser or other library code. +The digest parser is unchanged by these tests. ## Resolved: remote Session-ID UUID lost before BYE @@ -53,29 +53,33 @@ the peer; see [RFC 7989 sections 6 and 8](https://www.rfc-editor.org/rfc/rfc7989 Both UDP and TCP cases pass on upstream `004f607` and are now part of regression. Their assertions are unchanged; only the `known_gap_` classification was removed. -## Known gaps: incomplete PRACK reliability and validation - -Use `bash scripts/interop/run.sh known-gaps prack`. Eight probes fail at -upstream `004f607`, reproducing the following on both UDP and TCP: - -- `prack_rseq_gap`: after acknowledging RSeq 1, the peer sends RSeq 3 before - RSeq 2. rsipstack sends `RAck: 3 1 INVITE`; RFC 3262 section 4 requires - leaving the out-of-order response unacknowledged until the sequence is - contiguous. SIPp expects the next PRACK to acknowledge RSeq 2. -- `prack_uas_wrong_rseq` and `prack_uas_wrong_cseq`: rsipstack sends a reliable - 183 with `RSeq: 1`, but answers PRACK with `RAck: 999 1 INVITE` or - `RAck: 1 999 INVITE` with 200. A PRACK that does not match the outstanding - reliable response should receive 481 (RFC 3262 section 3). These cases - recover with a valid PRACK after the expected rejection. -- `prack_uas_retransmit`: rsipstack's public `ringing()` API sends one 183 - carrying Require: 100rel and RSeq: 1. With no PRACK, SIPp receives no repeat - within three seconds (the default T1 is 500 ms). RFC 3262 section 3 requires - retransmission even over reliable transports. This exposes that the API - does not itself manage the UAS reliable-provisional timer. - -These tests distinguish parsing/accepting a PRACK from implementing the full -100rel state machine. A passing basic PRACK exchange is not evidence that -the remaining reliability, validation or offer/answer behavior is complete. +## PRACK / 100rel regression coverage + +Use `bash scripts/interop/run.sh regression prack`. All 27 executions use +`ReliableProvisionalConfig` with an application media handler. Eight former +known-gap probes are now ordinary regression cases on UDP and TCP: + +- `prack_rseq_gap`: RSeq 3 after RSeq 1 is discarded; the next PRACK + acknowledges the contiguous RSeq 2. +- `prack_uas_wrong_rseq` and `prack_uas_wrong_cseq`: unmatched RAck receives + 481, then a valid PRACK acknowledges the outstanding provisional. SIPp + extracts the stack-generated random RSeq from the response. +- `prack_uas_retransmit`: the UAS retransmits its reliable 183 on both + transports until PRACK arrives. SIPp's automatic UDP duplicate handling + is disabled so the scenario itself observes the repeated 183. + +Additional cases cover an offerless INVITE with the answer in PRACK, a new +SDP offer in PRACK with its answer in 200, and PRACK 401/407 authentication. +The retry must retain RAck and SDP, advance CSeq and change the Via branch. +SIPp verifies the 401 digest; the independent Python verifier checks 407 +because SIPp's `verifyauth` only reads Authorization. The tests inspect the +media callback and final PRACK response as well as the wire exchange. + +Library tests additionally cover all three SDP patterns in both roles, +fork-specific routes and targets, malformed/overflow sequence values, +queued provisionals and finals, CANCEL followed by late PRACK, callback +failures, and deterministic 64*T1 exhaustion without a T2 retransmission cap. +External cases are signaling tests and send no RTP. ## Resolved: blocked ACK @@ -108,8 +112,8 @@ accepting other response codes. ## Executed matrix -There are 192 external-peer test executions: -182 regression cases and 10 known-gap probes. The lost-PRACK-response, +There are 200 external-peer test executions: +198 regression cases and 2 known-gap probes. The lost-PRACK-response, application lost-BYE-response and all fault-injection cases are UDP-only; the other families run on both transports. @@ -120,7 +124,7 @@ the other families run on both transports. | PJSIP in-dialog methods | INFO in both directions, MESSAGE delivery, OPTIONS rejection without losing the call | 16 | | SIPp final responses | 403, 404, 408, 480, 488, 500, 503, 603; ACK and cleanup | 16 | | SIPp authentication | 401, 407, stale nonce; no credentials for 401/407 | 10 | -| Reliable provisional responses | UAC PRACK RAck, duplicate 183, successive RSeq; UDP retry; UAS valid/missing RAck | 11 | +| Reliable provisional responses | UAC/UAS validation, retransmission, contiguous RSeq, offer/answer in PRACK, 401/407 | 27 | | Call progress | 100, 180, SDP in 183, final 200 | 2 | | In-dialog methods | OPTIONS, INFO with DTMF body, MESSAGE with text | 2 | | Session modification | hold/resume re-INVITEs, 488 rejection, UPDATE | 6 | @@ -136,7 +140,7 @@ the other families run on both transports. | Standalone proxy | two PJSUA peers; caller/callee BYE, 486, CANCEL; SIPp late 200 and lost BYE response; preserved dialog identity and Via/Record-Route forwarding | 11 | | Standalone B2BUA | two independent dialogs; caller/callee BYE, 486, CANCEL; SIPp late 200 and lost BYE response; independent identifiers and both-leg cleanup | 11 | | Re-INVITE bridge | two PJSUA peers for hold/resume, two SIPp peers for offerless SDP, lost answer ACK | 9 | -| Known-gap probes | SHA-256; PRACK | 10 | +| Known-gap probes | SHA-256 | 2 | The lost-487 case is a regression test. An earlier fixture dropped the server INVITE transaction when `dialog.handle()` returned after CANCEL, cancelling @@ -181,7 +185,7 @@ features. No finite suite covers every SIP message sequence or peer behavior. | Area | Not yet exercised with an external peer | | --- | --- | | Transports | TLS/WSS certificates, WS, IPv6, DNS SRV/NAPTR, reconnects and NAT | -| PRACK | Offer in PRACK, offerless INVITE, malformed/overflow RSeq, full timer exhaustion | +| PRACK | External peer malformed/overflow RSeq and full timer exhaustion; PJSIP media negotiation | | Dialog races | overlapping re-INVITEs/glare, additional forking and cancellation schedules | | Transactions | multi-packet loss bursts, long timer exhaustion, crash/restart recovery | | Authentication | multiple challenges, auth-int, sess algorithms, SHA-512/256, rejected credentials | @@ -226,7 +230,7 @@ Priorities beyond the executed matrix above: 1. Extend the existing UDP fault schedules to loss bursts, re-INVITE glare and forking. Add a separate stream disconnect/reconnect fixture for TCP/TLS. -2. PRACK offer/answer, authentication and timeout exhaustion; session timer +2. External-peer PRACK timeout exhaustion; session timer negotiation, 422 retry, refresh failure and cleanup. 3. Initial SUBSCRIBE and final NOTIFY, REFER/NOTIFY transfers, redirect chains, DNS failover and transport reconnection. diff --git a/tests/interop/README.md b/tests/interop/README.md index b2ef8fe6..f604d504 100644 --- a/tests/interop/README.md +++ b/tests/interop/README.md @@ -21,15 +21,15 @@ brew install cmake pkg-config openssl@3 python From the repository root: ```sh -bash scripts/interop/run.sh regression # supported baseline (182 tests) -bash scripts/interop/run.sh all # all 192; includes 10 known-gap probes +bash scripts/interop/run.sh regression # supported baseline (198 tests) +bash scripts/interop/run.sh all # all 200; includes 2 known-gap probes bash scripts/interop/run.sh pjsip # 76 PJSUA regression tests bash scripts/interop/run.sh pjsip mid_dialog # 36 mid-dialog PJSUA cases -bash scripts/interop/run.sh sipp # 94 SIPp tests, including known gaps +bash scripts/interop/run.sh sipp # 102 SIPp tests, including known gaps bash scripts/interop/run.sh proxy # 11 standalone proxy cases bash scripts/interop/run.sh b2bua # 11 linked two-dialog B2BUA cases -bash scripts/interop/run.sh sipp prack # all 19 PRACK cases, including known gaps -bash scripts/interop/run.sh regression prack # 11 passing PRACK regression cases +bash scripts/interop/run.sh sipp prack # all 27 PRACK cases +bash scripts/interop/run.sh regression prack # 27 passing PRACK regression cases bash scripts/interop/run.sh faults # 27 UDP loss/delay/race cases bash scripts/interop/run.sh known-gaps # reproduce documented failures bash scripts/interop/run.sh pjsip udp_uac_peer_bye # one test @@ -92,8 +92,8 @@ may send RTP to loopback discard port 9. No test asserts media delivery or quality. RTP/audio quality, scale and downstream application behavior (such as CDR/billing) require separate tests. -SIPp's repeated-200, lost-PRACK-response and application lost-BYE-response cases -use `-nr` so its UDP duplicate +SIPp's repeated-200, repeated-183, lost-PRACK-response, bridge offerless, and +application lost-BYE-response cases use `-nr` so its UDP duplicate detector does not consume the repeated request before the explicit XML receive step. The peer still has to receive the real retransmission from rsipstack. Handshake messages/log markers coordinate state checks without timed sleeps. diff --git a/tests/interop/scenarios/prack_sdp.xml b/tests/interop/scenarios/prack_sdp.xml new file mode 100644 index 00000000..8844794a --- /dev/null +++ b/tests/interop/scenarios/prack_sdp.xml @@ -0,0 +1,80 @@ + + + [invite_assertions] + + + + + + + + +Content-Type: application/sdp +Content-Length: [len] + +v=0 +o=sipp 1 1 IN IP4 127.0.0.1 +s=interop +c=IN IP4 127.0.0.1 +t=0 0 +m=audio 9 RTP/AVP 0 +a=rtpmap:0 PCMU/8000 +a=inactive +]]> + + + + + [prack_challenge] + + +Content-Type: application/sdp +Content-Length: [len] + +v=0 +o=sipp 1 1 IN IP4 127.0.0.1 +s=interop +c=IN IP4 127.0.0.1 +t=0 0 +m=audio 9 RTP/AVP 0 +a=rtpmap:0 PCMU/8000 +a=inactive +]]> + + + + diff --git a/tests/interop/scenarios/prack_uas.xml b/tests/interop/scenarios/prack_uas.xml index d705ec6d..0664a881 100644 --- a/tests/interop/scenarios/prack_uas.xml +++ b/tests/interop/scenarios/prack_uas.xml @@ -23,7 +23,9 @@ a=rtpmap:0 PCMU/8000 a=inactive ]]> - + + + - + + + - + + + TestResult { async fn scenario(name: &str, transport: &str, case: Case) -> TestResult { let dir = log_dir(name)?; let stack = Stack::start(transport, &dir).await?; + if matches!(case, Case::Prack(_)) { + super::prack_uas::enable(&stack); + } let mut peer = Sipp::start_with_keys(case.file(), transport, &dir, &stack.uri, &case.keys()).await?; let credential = matches!(case, Case::Auth(..)).then(|| Credential { @@ -379,7 +382,7 @@ async fn scenario(name: &str, transport: &str, case: Case) -> TestResult { Ok(()) } -fn verify_proxy_digest(request: &Request) -> TestResult { +pub(super) fn verify_proxy_digest(request: &Request) -> TestResult { use std::{ io::Write, process::{Command, Stdio}, @@ -439,7 +442,7 @@ cases! { (udp_prack_basic, tcp_prack_basic, Case::Prack("prack_basic")), (udp_prack_duplicate, tcp_prack_duplicate, Case::Prack("prack_duplicate")), (udp_prack_sequential, tcp_prack_sequential, Case::Prack("prack_sequential")), - (udp_known_gap_prack_rseq_gap, tcp_known_gap_prack_rseq_gap, Case::Prack("prack_gap")), + (udp_prack_rseq_gap, tcp_prack_rseq_gap, Case::Prack("prack_gap")), (udp_record_route, tcp_record_route, Case::RecordRoute), (udp_target_refresh, tcp_target_refresh, Case::TargetRefresh), (udp_session_id, tcp_session_id, Case::SessionId), diff --git a/tests/interop/sipp/prack_sdp.rs b/tests/interop/sipp/prack_sdp.rs new file mode 100644 index 00000000..13b0afe6 --- /dev/null +++ b/tests/interop/sipp/prack_sdp.rs @@ -0,0 +1,244 @@ +use super::{bounded, log_dir, sdp, until, Sipp, Stack}; +use crate::interop::{Required, TestResult}; +use rsipstack::{ + dialog::{ + authenticate::Credential, + dialog::DialogState, + invitation::InviteOption, + reliable::{ + IncomingPrack, PrackBody, PrackHandler, ReliableProvisionalConfig, ReliableResponse, + SdpKind, + }, + DialogId, + }, + sip::{HeadersExt, Method, Request, Response, ToTypedHeader}, +}; +use std::sync::{Arc, Mutex}; + +#[derive(Default)] +struct Media { + kinds: Mutex>, + results: Mutex>>, + errors: Mutex>, +} +#[async_trait::async_trait] +impl PrackHandler for Media { + async fn on_reliable_response( + &self, + event: ReliableResponse, + ) -> rsipstack::Result> { + self.kinds + .lock() + .unwrap_or_else(|p| p.into_inner()) + .push(event.sdp_kind); + // Answer an early offer, or make a new offer after receiving an answer. + Ok(Some(PrackBody::sdp(sdp()))) + } + async fn on_prack(&self, _: IncomingPrack) -> rsipstack::Result> { + Ok(None) + } + async fn on_prack_result(&self, _: Request, response: Option) { + self.results + .lock() + .unwrap_or_else(|p| p.into_inner()) + .push(response); + } + async fn on_error(&self, _: DialogId, message: String) { + self.errors + .lock() + .unwrap_or_else(|p| p.into_inner()) + .push(message); + } +} + +async fn scenario( + name: &str, + transport: &str, + offered: bool, + challenge: Option, +) -> TestResult { + let dir = log_dir(name)?; + let stack = Stack::start(transport, &dir).await?; + let media = Arc::new(Media::default()); + stack + .layer + .set_reliable_provisional(Some(ReliableProvisionalConfig::new(media.clone()))); + let challenge_xml = challenge + .map(|code| { + format!( + r#" + + + + + + + + +