diff --git a/CHANGELOG.md b/CHANGELOG.md index 47edbdb9..429c6c18 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,23 @@ # Changelog +## Unreleased — proposed 0.9.0 + +- Opt-in persistence now saves every INVITE final response before its ACK, + including rejection and authentication challenges. A successful re-INVITE + checkpoint contains the accepted Contact and the observed response in one + coherent snapshot boundary. Failed writes continue to block protected sends. + +- **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/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/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/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..d1d42511 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, @@ -565,6 +566,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 { @@ -579,10 +585,11 @@ 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 tx.original.method == crate::sip::Method::PRack { + return self.inner.receive_prack(tx).await; + } if self.inner.is_confirmed() { match tx.original.method { @@ -615,13 +622,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 +671,16 @@ 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(); + self.inner + .checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; + 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..c39ff3ca 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 @@ -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). @@ -349,7 +351,11 @@ 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(crate) session_timer: 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>, @@ -451,8 +457,15 @@ 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, pub state: DialogSnapshotState, pub role: TransactionRole, pub id: DialogId, @@ -473,6 +486,27 @@ pub struct DialogSnapshot { /// RFC 7989 Session-ID state, preserved across snapshot restore. 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() + } +} + impl DialogInner { #[allow(clippy::too_many_arguments)] pub fn new( @@ -538,6 +572,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)), @@ -546,7 +582,11 @@ 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), + session_timer: Mutex::new(None), + reliable_servers: Mutex::new(BTreeMap::new()), remote_ack: Mutex::new(None), server_connection: Mutex::new(None), dialback_target: Mutex::new(None), @@ -600,10 +640,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 +680,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 { @@ -654,59 +728,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 +827,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,12 +950,15 @@ 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(); } } + self.bind_persistence(&tx); match tx.send().await { Ok(_) => { debug!( @@ -784,6 +982,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 +997,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 @@ -805,9 +1013,13 @@ 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 { + if self.reliable_config.lock().is_some() { + return Ok(Some(resp)); + } debug!( id = self.id.lock().to_string(), "received 407 response without auth option" @@ -826,6 +1038,7 @@ impl DialogInner { _ => break, } } + tx.check_persistence()?; Ok(None) } @@ -837,9 +1050,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 { @@ -877,6 +1100,50 @@ impl DialogInner { })) } + /// Preserve the observed final response and its accepted target together. + /// Initial INVITE confirmation is installed by its response observer; + /// a re-INVITE may refresh only its own established dialog, not another fork. + #[cfg_attr(not(feature = "platform-tokio"), allow(unused_mut))] + pub(crate) async fn checkpoint_invite_response( + &self, + request: &Request, + response: &Response, + ) -> Result<()> { + let in_dialog = request + .to_header()? + .tag()? + .is_some_and(|tag| !tag.value().is_empty()); + let target = if in_dialog + && response.status_code.kind() == StatusCodeKind::Successful + && DialogId::try_from((response, TransactionRole::Client)) + .is_ok_and(|id| id == *self.id.lock()) + && response.cseq_header()?.seq()? == request.cseq_header()?.seq()? + { + Self::parse_target_refresh_contact(response)? + } else { + None + }; + let receiver = { + let state = self.state.lock(); + if let Some(target) = target { + self.set_remote_target_locked(target.uri, Some(target.contact)); + } + self.enqueue_checkpoint_locked( + &state, + super::persistence::DialogCheckpointReason::BeforeAck, + Some(response.clone().into()), + ) + }; + if let Some(mut receiver) = receiver { + receiver + .recv() + .await + .unwrap_or_else(|| Err("dialog persistence worker stopped".into())) + .map_err(crate::Error::Error)?; + } + Ok(()) + } + fn refresh_target_from_response(&self, response: &Response) -> Result<()> { if let Some(target) = Self::parse_target_refresh_contact(response)? { self.set_remote_target(target.uri, Some(target.contact)); @@ -885,11 +1152,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); } @@ -900,9 +1168,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. @@ -924,7 +1190,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 +1203,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(), }; @@ -1010,13 +1279,25 @@ 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"); + } + } + } + if let Some(timer) = self.session_timer.lock().as_ref() { + timer.outgoing(&mut request); + } + Ok(request) } pub(super) fn make_request( @@ -1264,7 +1545,28 @@ impl DialogInner { } async fn send_dialog_request( - &self, + self: &Arc, + 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(); + self.checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; + } + result + } + + async fn send_dialog_request_inner( + self: &Arc, request: Request, options: Option, ) -> Result> { @@ -1281,6 +1583,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() { @@ -1408,7 +1711,25 @@ impl DialogInner { .as_ref() .map(|o| super::reinvite::RequestCancellation::new(&tx, Some(o.cancellation.clone()))); let mut auth = AuthRetry::new(); - while let Some(msg) = tx.receive().await { + let mut timer_retries = 0; + loop { + let timer = self.session_timer.lock().clone(); + let original = tx.original.clone(); + let mut timer_result = Ok(()); + let msg = tx + .receive_with_response_observer(|response, _received_at| { + if DialogId::try_from((response, TransactionRole::Client)) + .is_ok_and(|id| id == *self.id.lock()) + { + if let Some(timer) = &timer { + timer_result = timer.received(&original, response); + } + } + }) + .await; + let Some(msg) = msg else { + break; + }; match msg { SipMessage::Response(resp) => { // RFC 7989 §8: accept the peer's (possibly new) UUID from @@ -1439,15 +1760,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 +1808,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)); } @@ -1502,6 +1827,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| { @@ -1521,7 +1847,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)); } @@ -1533,6 +1859,27 @@ impl DialogInner { } } + let timer = self.session_timer.lock().clone(); + if let Some(timer) = timer { + if !options + .as_ref() + .is_some_and(|o| o.cancellation.is_cancelled()) + { + if let Some(next) = timer.retry(self, &tx, &resp, &mut timer_retries)? { + tx = next; + self.reserve_invite(&tx)?; + auth = AuthRetry::new(); + tx.send().await?; + cancel_watch = options.as_ref().map(|o| { + super::reinvite::RequestCancellation::new( + &tx, + Some(o.cancellation.clone()), + ) + }); + continue; + } + } + } debug!( id = self.id.lock().to_string(), method = %method, @@ -1543,8 +1890,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 +1903,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(()) }; @@ -1593,23 +1950,33 @@ impl DialogInner { } } } + // A malformed timer agreement cannot skip the successful + // INVITE's ACK, including an offer answered in that ACK. + if let Err(error) = timer_result { + super::invite_dialog::InviteDialog::from_inner(self.clone()) + .bye() + .await + .ok(); + return Err(error); + } return Ok(Some(resp)); } _ => break, } } + tx.check_persistence()?; Ok(None) } 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 +1999,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() { @@ -1640,6 +2011,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() { @@ -1655,6 +2031,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(|_| ()) } @@ -1666,7 +2044,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 +2101,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() @@ -1747,10 +2129,19 @@ 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(); + 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 &*self.state.lock() { + let state = match state_guard { DialogState::Calling(_) => DialogSnapshotState::Calling, DialogState::Trying(_) => DialogSnapshotState::Trying, DialogState::Early(_, _) => DialogSnapshotState::Early, @@ -1768,6 +2159,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 +2209,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 +2239,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,13 +2280,19 @@ impl DialogInner { endpoint_inner, state_sender, - lifecycle: Mutex::new(super::lifecycle::LifecycleState::default()), + persistence: Mutex::new(None), + persistence_owner: Mutex::new(alloc::sync::Weak::new()), + lifecycle: Mutex::new(lifecycle), tu_sender, 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), + session_timer: Mutex::new(None), + reliable_servers: Mutex::new(BTreeMap::new()), remote_ack: Mutex::new(None), server_connection: Mutex::new(None), dialback_target: Mutex::new(None), @@ -1958,6 +2374,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 +2425,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 +2487,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,17 +2542,114 @@ impl DialogInner { }, ); } + self.lifecycle.lock().revision += 1; + if matches!(state, DialogState::Terminated(..)) { + if let Some(timer) = self.session_timer.lock().as_ref() { + timer.stop(); + } + } *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(); } + #[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, + 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(); + self.checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; + } + result + } + + #[cfg_attr(not(feature = "platform-tokio"), allow(unused_mut))] + async fn process_transaction_handle_inner( &self, 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, @@ -2112,6 +2659,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..b8c50cb7 100644 --- a/src/dialog/dialog_layer.rs +++ b/src/dialog/dialog_layer.rs @@ -34,10 +34,17 @@ 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, pub(super) dialogs: RwMap, + retired_reliable: RwMap, + pub(super) session_timer_config: + crate::platform::sync::Mutex>, + pub(super) reliable_config: + crate::platform::sync::Mutex>, } pub type DialogLayerInnerRef = Arc; @@ -143,8 +150,12 @@ 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(), + retired_reliable: RwMap::new(), + reliable_config: crate::platform::sync::Mutex::new(None), + session_timer_config: crate::platform::sync::Mutex::new(None), }), } } @@ -161,6 +172,43 @@ 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(()) + } + + /// Configure new INVITE dialogs. Existing dialogs retain their configuration. + pub fn set_reliable_provisional( + &self, + config: Option, + ) { + *self.inner.reliable_config.lock() = config; + } + + /// Opt in to RFC 4028 for subsequently created INVITE dialogs. Existing and + /// snapshot-restored dialogs retain their own recovery policy. + pub fn set_session_timer( + &self, + config: Option, + ) -> Result<()> { + if let Some(config) = &config { + config.validate()?; + } + *self.inner.session_timer_config.lock() = config; + Ok(()) + } + pub fn get_or_create_server_invite( &self, tx: &Transaction, @@ -223,7 +271,17 @@ 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.reliable_config.lock() = self.inner.reliable_config.lock().clone(); + if let Some(config) = self.inner.session_timer_config.lock().clone() { + super::session_timer::SessionTimer::install(&dialog.inner, config); + *tx.session_timer.lock() = dialog.inner.session_timer.lock().clone(); + } + dialog.inner.attach_reliable_server(tx)?; dialog.inner.set_server_connection(tx.connection.clone()); self.inner .dialogs @@ -557,7 +615,10 @@ 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()); + *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 +639,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..122ce6b8 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())); @@ -542,6 +551,9 @@ impl DialogLayer { } } } + if let Some(config) = self.inner.session_timer_config.lock().as_ref() { + config.initial(&mut request); + } Ok(request) } @@ -901,7 +913,15 @@ 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)?; + *dialog.inner.reliable_config.lock() = self.inner.reliable_config.lock().clone(); + if let Some(config) = self.inner.session_timer_config.lock().clone() { + super::session_timer::SessionTimer::install(&dialog.inner, config); + } Ok((dialog, tx)) } } diff --git a/src/dialog/invite_dialog.rs b/src/dialog/invite_dialog.rs index 4ff5113e..153c7810 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() } @@ -102,6 +111,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 +150,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 +168,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(()) } @@ -259,7 +281,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 +290,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 +408,11 @@ 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(), + ); + let mut timer_retries = 0; 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 @@ -387,6 +424,9 @@ impl InviteDialog { let ack = InviteAck::new(); let _ack_guard = InitialAckGuard(ack.clone()); let mut established = Ok(false); + let timer = self.inner.session_timer.lock().clone(); + let request = tx.original.clone(); + let mut timer_result = Ok(()); let msg = tx .receive_with_response_observer(|resp, received_at| { let peer_uuid = resp.session_id_header().and_then(|s| s.local_uuid()); @@ -394,11 +434,32 @@ impl InviteDialog { if resp.status_code.kind() == StatusCodeKind::Successful { self.inner.initial_ack.lock().replace(ack.clone()); established = self.establish_from_2xx(resp, received_at, &mut register); + if established.is_ok() { + if let Some(timer) = &timer { + timer_result = timer.received(&request, resp); + } + } } }) .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?; + if let Err(error) = timer_result { + self.bye().await.ok(); + return Err(error); + } let Some(msg) = msg else { break }; if matches!(&msg, SipMessage::Response(r) if r.status_code.kind() != StatusCodeKind::Provisional) { @@ -419,13 +480,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 @@ -449,7 +518,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(); @@ -470,6 +543,23 @@ impl InviteDialog { break; } } + let timer = self.inner.session_timer.lock().clone(); + if let Some(timer) = timer { + if !self.inner.cancel_requested.load(Ordering::SeqCst) { + if let Some(next) = + timer.retry(&self.inner, tx, &resp, &mut timer_retries)? + { + *tx = next; + self.inner.reserve_invite(tx)?; + self.inner.update_remote_tag("")?; + *self.inner.initial_request.lock() = tx.original.clone(); + auth = AuthRetry::new(); + tx.send().await?; + self.inner.set_server_connection(tx.connection.clone()); + continue; + } + } + } final_response = Some(resp.clone()); if let Some(tag) = resp.to_header()?.tag()? { self.inner.update_remote_tag(tag.value())? @@ -530,14 +620,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(()) } @@ -843,6 +933,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, @@ -859,6 +950,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. @@ -867,11 +963,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() { @@ -900,6 +992,14 @@ impl InviteDialog { } } + if self.inner.handle_session_timer(tx).await? { + return Ok(()); + } + + // 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. @@ -1017,17 +1117,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(()) } @@ -1053,29 +1152,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<()> { @@ -1135,7 +1212,16 @@ 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(); + self.inner + .checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; + result } async fn handle_invite(&mut self, tx: &mut Transaction) -> Result<()> { @@ -1177,8 +1263,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 c0e10c29..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: //! @@ -32,8 +34,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 +111,52 @@ 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, + pub defer_delivery: bool, + pub undelivered: 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 +164,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 +175,25 @@ 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 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 0b3f1372..08f85064 100644 --- a/src/dialog/mod.rs +++ b/src/dialog/mod.rs @@ -12,10 +12,15 @@ 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; +pub mod reinvite_bridge; +pub mod reliable; pub mod server_dialog; +pub mod session_timer; +pub mod snapshot; pub mod subscription; #[cfg(test)] diff --git a/src/dialog/persistence.rs b/src/dialog/persistence.rs new file mode 100644 index 00000000..48853b8a --- /dev/null +++ b/src/dialog/persistence.rs @@ -0,0 +1,299 @@ +//! 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, + /// An INVITE final response was received; before its automatic ACK. + /// Includes failures/challenges, re-INVITEs, and fork cleanup. A successful + /// re-INVITE's snapshot already contains its accepted Contact. The message + /// preserves the observed response; 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/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 new file mode 100644 index 00000000..64758c82 --- /dev/null +++ b/src/dialog/reinvite_bridge.rs @@ -0,0 +1,540 @@ +//! 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. 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 +//! # 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")); + } + 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, + 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/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..7b482a6f 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(()) } @@ -653,6 +657,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, @@ -660,6 +665,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 { @@ -673,10 +683,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 +752,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(()) } @@ -777,29 +783,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<()> { @@ -854,7 +838,16 @@ 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(); + self.inner + .checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; + result } async fn handle_invite(&mut self, tx: &mut Transaction) -> Result<()> { @@ -896,8 +889,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/session_timer.rs b/src/dialog/session_timer.rs new file mode 100644 index 00000000..6104bad2 --- /dev/null +++ b/src/dialog/session_timer.rs @@ -0,0 +1,835 @@ +//! Opt-in RFC 4028 session timers for INVITE dialogs. +//! +//! Configure [`DialogLayer::set_session_timer`](super::dialog_layer::DialogLayer::set_session_timer) +//! before creating dialogs. The stack negotiates each leg independently, retries +//! bounded 422 challenges, and owns one cancellable timer task per enabled dialog. +//! Only successful INVITE/UPDATE exchanges extend the deadline. A session refresh +//! is not a billing-duration limit or an OPTIONS keepalive. +//! +//! Automatic refresh prefers a bodyless UPDATE when the peer advertises UPDATE. +//! Otherwise it sends a re-INVITE with the last successfully negotiated local SDP. +//! Applications which generate their SDP elsewhere can supply [`RefreshSdp`]. +//! They still handle incoming offers through the normal dialog events; only +//! bodyless UPDATE refreshes are answered automatically. +//! +//! Timer configuration and deadlines are not part of `DialogSnapshot`. Restoring +//! a SIP dialog does not establish a new timer agreement: applications must keep +//! their recovery policy and renegotiate (or end the call) after a restart. + +use super::{dialog::DialogInner, invite_dialog::InviteDialog, reinvite::AckBody}; +#[cfg(not(feature = "platform-tokio"))] +use crate::platform::Instant; +use crate::{ + platform::{select3, sync::Mutex, CancellationToken, Which3}, + prelude::*, + sip::{ + Header, HeadersExt, Method, Request, Response, StatusCode, StatusCodeKind, ToTypedHeader, + }, + transaction::{ + key::{TransactionKey, TransactionRole}, + Transaction, + }, + Result, +}; +use alloc::sync::Weak; +use core::{ + sync::atomic::{AtomicBool, AtomicUsize, Ordering}, + time::Duration, +}; +#[cfg(feature = "platform-tokio")] +use tokio::time::Instant; + +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub enum RefreshMethod { + /// UPDATE only when advertised by the peer, otherwise re-INVITE. + #[default] + Automatic, + /// Require peer UPDATE support; do not send an unsupported method. + Update, + Reinvite, +} + +/// Produces a current SDP offer without sending any SIP messages. Implementations +/// must be cancellation-safe: the session deadline can cancel this future. +#[async_trait::async_trait] +pub trait RefreshSdp: Send + Sync { + async fn offer(&self) -> Result; + + /// Observe a successful automatic re-INVITE's answer, after ACK. Return an + /// error if the negotiated media cannot be used; the session is then ended. + async fn answer(&self, _response: &Response) -> Result<()> { + Ok(()) + } +} + +#[derive(Clone)] +pub struct SessionTimerConfig { + /// Desired interval, in seconds; default 1800, never below `min_se`. + pub expires: u32, + /// Minimum accepted interval, in seconds; RFC 4028 requires at least 90. + pub min_se: u32, + /// Prefer the local endpoint as refresher when negotiation allows a choice. + /// An explicit choice by an incoming UAC is always honored. + pub prefer_local: bool, + pub refresh_method: RefreshMethod, + pub sdp: Option>, +} +impl Default for SessionTimerConfig { + fn default() -> Self { + Self { + expires: 1800, + min_se: 90, + prefer_local: true, + refresh_method: RefreshMethod::Automatic, + sdp: None, + } + } +} +impl SessionTimerConfig { + pub fn validate(&self) -> Result<()> { + if self.min_se < 90 || self.expires < self.min_se { + return Err(error("session interval must be >= Min-SE >= 90 seconds")); + } + Ok(()) + } + pub(super) fn initial(&self, request: &mut Request) { + super::reliable::add_option(request, "Supported", "timer"); + advertise_update(request); + request + .headers + .unique_push(Header::MinSE(self.min_se.to_string().into())); + let value = if self.prefer_local { + format!("{};refresher=uac", self.expires) + } else { + self.expires.to_string() + }; + request + .headers + .unique_push(Header::SessionExpires(value.into())); + } +} + +#[derive(Clone, Debug)] +pub struct SessionTimerStatus { + pub interval: Option, + pub local_refresher: bool, + pub remaining: Duration, + pub refreshes: usize, + pub expirations: usize, + pub worker_running: bool, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +struct Agreement { + interval: u32, + local: bool, +} +#[derive(Clone, Copy)] +struct Active { + agreement: Agreement, + expires: Instant, + due: Instant, + generation: u64, +} +struct State { + active: Option, + generation: u64, + changed: CancellationToken, + min_se: u32, + client_seq: Option, + server_seq: Option, + peer_update: bool, + local_sdp: Option, + local_options: Option>, +} + +pub(crate) struct SessionTimer { + dialog: Weak, + config: SessionTimerConfig, + state: Mutex, + stop: CancellationToken, + running: AtomicBool, + refreshes: AtomicUsize, + expirations: AtomicUsize, +} + +fn error(message: &str) -> crate::Error { + crate::Error::Error(message.into()) +} +fn seconds(value: &str) -> Result { + let value = value.trim(); + if value.is_empty() || !value.bytes().all(|c| c.is_ascii_digit()) { + return Err(error("invalid session timer delta-seconds")); + } + value + .parse() + .map_err(|_| error("session timer delta-seconds overflow")) +} +fn single<'a>(message: &'a impl HeadersExt, name: &str) -> Result> { + let mut values = message + .headers() + .iter() + .filter(|h| h.name().eq_ignore_ascii_case(name)); + let value = values.next().map(|h| h.value()); + if values.next().is_some() { + return Err(error("duplicate session timer header")); + } + Ok(value) +} +fn min_se(message: &impl HeadersExt) -> Result> { + single(message, "Min-SE")? + .map(|value| { + let n = seconds(value.split(';').next().unwrap_or_default())?; + if n < 90 { + return Err(error("Min-SE must be at least 90")); + } + Ok(n) + }) + .transpose() +} +fn session_expires(message: &impl HeadersExt) -> Result)>> { + single(message, "Session-Expires")? + .map(|value| { + let mut parts = value.split(';'); + let n = seconds(parts.next().unwrap_or_default())?; + let mut refresher = None; + for part in parts { + let (name, value) = part.trim().split_once('=').unwrap_or((part.trim(), "")); + if name.trim().eq_ignore_ascii_case("refresher") { + if refresher.is_some() { + return Err(error("duplicate refresher parameter")); + } + refresher = Some(match value.trim().to_ascii_lowercase().as_str() { + "uac" => true, + "uas" => false, + _ => return Err(error("invalid refresher parameter")), + }); + } + } + Ok((n, refresher)) + }) + .transpose() +} +fn advertise_update(message: &mut impl crate::sip::HasHeaders) { + if !has_token(message, "Allow", "UPDATE") { + message + .headers_mut() + .push(Header::Allow("INVITE, ACK, CANCEL, BYE, UPDATE".into())); + } +} +fn has_token(message: &impl crate::sip::HasHeaders, name: &str, token: &str) -> bool { + message.headers().iter().any(|h| { + h.name().eq_ignore_ascii_case(name) + && h.value() + .split(',') + .any(|v| v.trim().eq_ignore_ascii_case(token)) + }) +} +fn supported(message: &impl HeadersExt) -> bool { + message.header_contains_token("Supported", "timer") + || message.header_contains_token("Require", "timer") +} +fn refresh(method: &Method) -> bool { + matches!(method, Method::Invite | Method::Update) +} +fn option_header(header: &Header) -> bool { + ["Supported", "Require", "Proxy-Require"] + .iter() + .any(|name| header.name().eq_ignore_ascii_case(name)) +} +fn option_headers(message: &impl HeadersExt) -> Vec
{ + message + .headers() + .iter() + .filter(|h| option_header(h)) + .cloned() + .collect() +} +fn remaining(deadline: Instant) -> Duration { + deadline + .checked_duration_since(Instant::now()) + .unwrap_or_default() +} + +impl SessionTimer { + pub(super) fn install(inner: &Arc, config: SessionTimerConfig) { + let token = inner.cancel_token.child_token(); + let timer = Arc::new(Self { + dialog: Arc::downgrade(inner), + state: Mutex::new(State { + active: None, + generation: 0, + changed: CancellationToken::new(), + min_se: config.min_se, + client_seq: None, + server_seq: None, + peer_update: false, + local_sdp: None, + local_options: (inner.role == TransactionRole::Client) + .then(|| option_headers(&*inner.initial_request.lock())), + }), + config, + stop: token, + running: AtomicBool::new(true), + refreshes: AtomicUsize::new(0), + expirations: AtomicUsize::new(0), + }); + *inner.session_timer.lock() = Some(timer.clone()); + let shutdown = inner.endpoint_inner.shutdown_token(); + crate::platform::spawn(async move { + struct Finished(Arc); + impl Drop for Finished { + fn drop(&mut self) { + self.0.stop(); + self.0.running.store(false, Ordering::Release); + } + } + let _finished = Finished(timer.clone()); + crate::platform::select2( + core::pin::pin!(timer.run()), + core::pin::pin!(shutdown.cancelled()), + ) + .await; + }); + } + pub(crate) fn stop(&self) { + self.stop.cancel(); + } + pub(super) fn status(&self) -> SessionTimerStatus { + let state = self.state.lock(); + SessionTimerStatus { + interval: state.active.map(|a| a.agreement.interval), + local_refresher: state.active.is_some_and(|a| a.agreement.local), + remaining: state + .active + .map_or(Duration::ZERO, |a| remaining(a.expires)), + refreshes: self.refreshes.load(Ordering::Relaxed), + expirations: self.expirations.load(Ordering::Relaxed), + worker_running: self.running.load(Ordering::Acquire), + } + } + pub(super) fn outgoing(&self, request: &mut Request) { + if request.method == Method::Ack { + return; + } + super::reliable::add_option(request, "Supported", "timer"); + advertise_update(request); + if !refresh(&request.method) { + return; + } + let mut state = self.state.lock(); + let options = state + .local_options + .get_or_insert_with(|| option_headers(request)); + request.headers.retain(|h| !option_header(h)); + request.headers.extend(options.clone()); + let interval = state + .active + .map_or(self.config.expires, |a| a.agreement.interval) + .max(state.min_se); + let local = state + .active + .map_or(self.config.prefer_local, |a| a.agreement.local); + request + .headers + .unique_push(Header::MinSE(state.min_se.to_string().into())); + let value = if state.active.is_none() && !local { + interval.to_string() + } else { + format!("{interval};refresher={}", if local { "uac" } else { "uas" }) + }; + request + .headers + .unique_push(Header::SessionExpires(value.into())); + } + fn server_agreement(&self, request: &Request) -> Result> { + let requested = session_expires(request)?; + let floor = min_se(request)?.unwrap_or(90).max(self.config.min_se); + if requested.is_some_and(|(n, _)| n < floor) { + return Ok(Err(floor)); + } + let interval = requested + .map_or(self.config.expires, |s| s.0) + .min(self.config.expires.max(floor)); + let local = if !supported(request) { + if requested.is_some_and(|(_, who)| who.is_some()) { + return Err(error("refresher without timer support")); + } + true + } else { + requested + .and_then(|(_, uac)| uac) + .map_or(self.config.prefer_local, |uac| !uac) + }; + Ok(Ok(Agreement { + interval: interval.max(floor), + local, + })) + } + pub(super) fn rejection(&self, request: &Request) -> Option<(StatusCode, Vec
)> { + if !refresh(&request.method) { + return None; + } + if let Ok(Some(min)) = min_se(request) { + let mut state = self.state.lock(); + state.min_se = state.min_se.max(min); + } + match self.server_agreement(request) { + Ok(Ok(_)) => None, + Ok(Err(min)) => Some(( + StatusCode::from(422), + vec![Header::MinSE(min.to_string().into())], + )), + Err(_) => Some((StatusCode::BadRequest, vec![])), + } + } + pub(crate) fn prepare_response( + &self, + request: &Request, + response: &mut Response, + ) -> Result<()> { + if !refresh(&request.method) || response.status_code.kind() != StatusCodeKind::Successful { + return Ok(()); + } + let agreement = self + .server_agreement(request)? + .map_err(|_| error("session interval too small"))?; + response.headers.unique_push(Header::SessionExpires( + format!( + "{};refresher={}", + agreement.interval, + if agreement.local { "uas" } else { "uac" } + ) + .into(), + )); + if supported(request) { + super::reliable::add_option(response, "Require", "timer"); + } + super::reliable::add_option(response, "Supported", "timer"); + advertise_update(response); + Ok(()) + } + pub(crate) fn sent(&self, request: &Request, response: &Response) { + if !refresh(&request.method) || response.status_code.kind() != StatusCodeKind::Successful { + return; + } + if let Ok(Some((interval, Some(uac)))) = session_expires(response) { + self.apply( + request, + response, + false, + Some(Agreement { + interval, + local: !uac, + }), + ); + } + } + pub(super) fn received(&self, request: &Request, response: &Response) -> Result<()> { + if !refresh(&request.method) || response.status_code.kind() != StatusCodeKind::Successful { + return Ok(()); + } + let negotiated = session_expires(response)?; + if negotiated.is_none() && response.header_contains_token("Require", "timer") { + return Err(error("Require: timer without Session-Expires")); + } + let agreement = negotiated + .map(|(interval, uac)| { + if interval < 90 { + return Err(error("unsafe session interval in response")); + } + let local = uac.ok_or_else(|| error("response has no refresher"))?; + Ok(Agreement { interval, local }) + }) + .transpose()?; + self.apply(request, response, true, agreement); + Ok(()) + } + fn apply( + &self, + request: &Request, + response: &Response, + client: bool, + agreement: Option, + ) { + let Ok(cseq) = request.cseq_header().and_then(|h| h.seq()) else { + return; + }; + let mut state = self.state.lock(); + if self.stop.is_cancelled() { + return; + } + let last = if client { + &mut state.client_seq + } else { + &mut state.server_seq + }; + if last.is_some_and(|old| cseq <= old) { + return; + } + *last = Some(cseq); + if let Ok(Some(min)) = min_se(request) { + state.min_se = state.min_se.max(min); + } + let (peer_update, body, content_type) = if client { + ( + has_token(response, "Allow", "UPDATE"), + &request.body, + single(request, "Content-Type").ok().flatten(), + ) + } else { + ( + has_token(request, "Allow", "UPDATE"), + &response.body, + single(response, "Content-Type").ok().flatten(), + ) + }; + state.peer_update |= peer_update; + if !body.is_empty() + && content_type.is_some_and(|v| { + v.split(';') + .next() + .unwrap_or_default() + .trim() + .eq_ignore_ascii_case("application/sdp") + }) + { + state.local_sdp = Some(AckBody::sdp(body.clone())); + } + state.generation += 1; + let now = Instant::now(); + state.active = agreement.map(|agreement| { + let interval = Duration::from_secs(agreement.interval as u64); + let due = if agreement.local { + interval / 2 + } else { + interval - Duration::from_secs(32).min(interval / 3) + }; + Active { + agreement, + expires: now + interval, + due: now + due, + generation: state.generation, + } + }); + state.changed.cancel(); + state.changed = CancellationToken::new(); + } + pub(super) fn retry( + &self, + inner: &Arc, + tx: &Transaction, + response: &Response, + attempts: &mut u8, + ) -> Result> { + if response.status_code.code() != 422 || !refresh(&tx.original.method) || *attempts >= 3 { + return Ok(None); + } + let Some(min) = min_se(response)? else { + return Ok(None); + }; + let mut state = self.state.lock(); + if min <= state.min_se { + return Ok(None); + } + state.min_se = min; + drop(state); + *attempts += 1; + let mut request = tx.original.clone(); + request + .cseq_header_mut()? + .mut_seq(inner.increment_local_seq())?; + request.via_header_mut()?.update_first_value(|v| { + let mut via = v.typed()?; + via.params + .retain(|p| !matches!(p, crate::sip::Param::Branch(_))); + via.params.push(crate::transaction::make_via_branch()); + Ok(via.into()) + })?; + // Authentication must be recomputed for the new request/CSeq (auth-int + // may cover the body). A challenge on this retry uses the normal path. + request + .headers + .retain(|h| !matches!(h, Header::Authorization(_) | Header::ProxyAuthorization(_))); + self.outgoing(&mut request); + let key = TransactionKey::from_request(&request, TransactionRole::Client)?; + let mut next = Transaction::new_client( + key, + request, + tx.endpoint_inner.clone(), + tx.connection.clone(), + ); + next.destination = tx.destination.clone(); + next.defer_success_ack = tx.defer_success_ack; + next.force_success_ack = tx.force_success_ack; + // A 422 retry is a new transaction, but belongs to the same durable + // dialog and must retain receipt timing for its initial acceptance. + inner.bind_persistence(&next); + next.track_receipt_times( + inner.lifecycle.lock().sender.is_some() || inner.persistence.lock().is_some(), + ); + Ok(Some(next)) + } + async fn expire(&self, generation: Option) { + { + let state = self.state.lock(); + if generation + .is_some_and(|generation| state.active.is_none_or(|a| a.generation != generation)) + || self.stop.is_cancelled() + { + return; + } + self.stop.cancel(); + } + self.expirations.fetch_add(1, Ordering::Relaxed); + if let Some(inner) = self.dialog.upgrade() { + let dialog = InviteDialog::from_inner(inner); + if let Err(error) = dialog + .bye_with_reason("SIP;cause=408;text=\"Session timer expired\"".into()) + .await + { + tracing::warn!(%error, "session timer teardown failed"); + } + } + } + async fn deadline(&self) -> u64 { + loop { + let (active, changed) = { + let state = self.state.lock(); + (state.active, state.changed.clone()) + }; + let delay = active.map_or(Duration::from_secs(u32::MAX as u64), |a| { + remaining(a.expires) + }); + if matches!( + crate::platform::select2( + core::pin::pin!(changed.cancelled()), + core::pin::pin!(crate::platform::sleep(delay)) + ) + .await, + crate::platform::Either::B(_) + ) { + if let Some(active) = active { + return active.generation; + } + } + } + } + async fn send_refresh(&self) -> Result> { + let inner = self + .dialog + .upgrade() + .ok_or_else(|| error("dialog removed"))?; + let ack = inner.initial_ack.lock().clone(); + if let Some(ack) = ack { + ack.done.cancelled().await; + } + let dialog = InviteDialog::from_inner(inner); + let (update, cached) = { + let state = self.state.lock(); + (state.peer_update, state.local_sdp.clone()) + }; + let method = match self.config.refresh_method { + RefreshMethod::Automatic if update => Method::Update, + RefreshMethod::Update if !update => { + return Err(error("peer has not advertised UPDATE")) + } + RefreshMethod::Update => Method::Update, + _ => Method::Invite, + }; + self.refreshes.fetch_add(1, Ordering::Relaxed); + if method == Method::Update { + return dialog.update(None, None).await; + } + let body = match &self.config.sdp { + Some(provider) => provider.offer().await?, + None => cached.ok_or_else(|| { + error("re-INVITE refresh requires negotiated local SDP or RefreshSdp") + })?, + }; + if body.body.is_empty() { + return Err(error("empty session refresh SDP offer")); + } + let request = dialog.prepare_reinvite( + Some(vec![Header::ContentType(body.content_type.into())]), + Some(body.body), + )?; + let response = dialog.send_reinvite(request, Default::default()).await?; + if let (Some(provider), Some(response)) = (&self.config.sdp, &response) { + if response.status_code.kind() == StatusCodeKind::Successful { + provider.answer(response).await?; + } + } + Ok(response) + } + async fn run(self: Arc) { + loop { + let (active, changed) = { + let state = self.state.lock(); + (state.active, state.changed.clone()) + }; + let delay = active.map_or(Duration::from_secs(u32::MAX as u64), |a| remaining(a.due)); + match select3( + core::pin::pin!(self.stop.cancelled()), + core::pin::pin!(changed.cancelled()), + core::pin::pin!(crate::platform::sleep(delay)), + ) + .await + { + Which3::A(_) => return, + Which3::B(_) => continue, + Which3::C(_) => {} + } + let Some(active) = active else { + continue; + }; + if self + .state + .lock() + .active + .is_none_or(|a| a.generation != active.generation) + { + continue; + } + if !active.agreement.local || remaining(active.expires).is_zero() { + self.expire(Some(active.generation)).await; + return; + } + // The owning re-INVITE task keeps driving ACK after a deadline. + // The watchdog never extends a deadline merely by starting a request. + let result = select3( + core::pin::pin!(self.stop.cancelled()), + core::pin::pin!(self.send_refresh()), + core::pin::pin!(self.deadline()), + ) + .await; + match result { + Which3::A(_) => return, + Which3::C(generation) => { + self.expire(Some(generation)).await; + } + Which3::B(result) => { + let retry = matches!(&result, Ok(Some(r)) if r.status_code.code() == 491) + || matches!( + &result, + Err(crate::Error::DialogError(_, _, StatusCode::RequestPending)) + ); + let fatal = matches!(&result, Ok(None) | Err(_)) && !retry + || matches!(&result, Ok(Some(r)) if matches!(r.status_code.code(), 408 | 481)); + if fatal { + self.expire(None).await; + } else { + let mut state = self.state.lock(); + if let Some(a) = state + .active + .as_mut() + .filter(|a| a.generation == active.generation) + { + a.due = if retry { + // RFC 3261 14.1: disjoint glare windows for the + // Call-ID owner and the other endpoint. + let owner = self + .dialog + .upgrade() + .is_some_and(|d| d.role == TransactionRole::Client); + let mut bytes = [0; 2]; + crate::transaction::fill_random_bytes(&mut bytes); + let ticks = u16::from_ne_bytes(bytes) as u64; + let ms = if owner { + 2100 + ticks % 1901 + } else { + ticks % 2001 + }; + (Instant::now() + Duration::from_millis(ms)).min(a.expires) + } else { + a.expires + }; + } + } + } + } + } + } +} + +impl InviteDialog { + pub fn session_timer_status(&self) -> Option { + self.inner + .session_timer + .lock() + .as_ref() + .map(|timer| timer.status()) + } +} + +impl DialogInner { + pub(super) async fn handle_session_timer( + self: &Arc, + tx: &mut Transaction, + ) -> Result { + if !refresh(&tx.original.method) { + return Ok(false); + } + let timer = self.session_timer.lock().clone(); + let rejection = match &timer { + Some(timer) => timer.rejection(&tx.original), + None if tx.original.header_contains_token("Require", "timer") => Some(( + StatusCode::BadExtension, + vec![Header::Unsupported("timer".into())], + )), + None => None, + }; + if let Some((status, headers)) = rejection { + let response = self.make_response(&tx.original, status.clone(), Some(headers), None); + tx.respond(response).await?; + if !self.is_confirmed() { + self.transition(super::dialog::DialogState::Terminated( + self.id.lock().clone(), + super::dialog::TerminatedReason::UasOther(status), + )); + } + return Ok(true); + } + *tx.session_timer.lock() = timer.clone(); + if timer.is_some() + && self.is_confirmed() + && tx.original.method == Method::Update + && tx.original.body.is_empty() + { + let contact = match Self::parse_target_refresh_contact(&tx.original) { + Ok(contact) => contact, + Err(_) => { + tx.reply(StatusCode::BadRequest).await?; + return Ok(true); + } + }; + self.begin_negotiation(); + let result = async { + tx.respond(self.make_response(&tx.original, StatusCode::OK, None, None)) + .await?; + if let Some(contact) = contact { + self.accept_target_refresh(tx.original.cseq_header()?.seq()?, &contact); + } + Ok::<(), crate::Error>(()) + } + .await; + self.finish_negotiation(); + self.checkpoint( + super::persistence::DialogCheckpointReason::SignalingCompleted, + None, + ) + .await?; + result?; + return Ok(true); + } + Ok(false) + } +} + +impl Drop for DialogInner { + fn drop(&mut self) { + if let Some(timer) = self.session_timer.lock().as_ref() { + timer.stop(); + } + } +} diff --git a/src/dialog/snapshot.rs b/src/dialog/snapshot.rs new file mode 100644 index 00000000..75c89e23 --- /dev/null +++ b/src/dialog/snapshot.rs @@ -0,0 +1,236 @@ +//! 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] +pub struct DialogLifecycleRecord { + pub sequence: u64, + pub since_unix_epoch: Option, + 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)] +#[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/mod.rs b/src/dialog/tests/mod.rs index f30db8a0..a9ef1a4a 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; @@ -29,4 +30,9 @@ 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; + +mod test_session_timer; 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_persistence.rs b/src/dialog/tests/test_persistence.rs new file mode 100644 index 00000000..03d58213 --- /dev/null +++ b/src/dialog/tests/test_persistence.rs @@ -0,0 +1,952 @@ +//! 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, + ReinviteAnswer, + SessionRetry, + TimerResponse, + 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::ReinviteAnswer => { + c.reason == Reason::BeforeAck && c.snapshot.runtime.pending.negotiations != 0 + } + Gate::SessionRetry => { + c.reason == Reason::OutgoingRequest + && matches!(&c.message, Some(SipMessage::Request(r)) + if r.method == Method::Invite && r.to_string().contains("Min-SE: 180\r\n")) + } + Gate::TimerResponse => { + c.reason == Reason::BeforeResponse + && matches!(&c.message, Some(SipMessage::Response(r)) + if r.cseq_header().unwrap().method().unwrap() == Method::Update) + } + 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 { + start_with_timer(storage, timeout, None).await +} + +async fn start_with_timer( + storage: Arc, + timeout: Duration, + timer: Option, +) -> 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)))?; + layer.set_session_timer(timer)?; + 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(()) +} + +#[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(()) +} + +#[tokio::test] +async fn persistence_session_422_retry_keeps_storage_barrier() -> crate::Result<()> { + use crate::dialog::session_timer::SessionTimerConfig; + for fail in [false, true] { + let store = Storage::new(Gate::SessionRetry); + let mut call = start_with_timer( + store.clone(), + Duration::from_secs(2), + Some(SessionTimerConfig { + expires: 90, + ..Default::default() + }), + ) + .await?; + let initial = request(&call.peer, Method::Invite).await; + let rejection = format!( + "SIP/2.0 422 Session Interval Too Small\r\nVia: {}\r\nFrom: {}\r\nTo: {};tag=retry\r\nCall-ID: {}\r\nCSeq: {}\r\nMin-SE: 180\r\nContent-Length: 0\r\n\r\n", + initial.via_header()?.value(), initial.from_header()?.value(), + initial.to_header()?.value(), initial.call_id_header()?.value(), + initial.cseq_header()?.value(), + ); + call.peer.send_to(rejection.as_bytes(), call.local).await?; + request(&call.peer, Method::Ack).await; + // The rejected attempt must be durable before its ACK, independently + // of the later retry's outgoing-request barrier. + assert!(store.committed.lock().unwrap().iter().any(|checkpoint| { + checkpoint.reason == Reason::BeforeAck + && matches!(&checkpoint.message, Some(SipMessage::Response(response)) + if response.status_code == StatusCode::SessionIntervalTooSmall + && response.cseq_header().unwrap() == initial.cseq_header().unwrap()) + })); + entered(&store).await; + silent(&call.peer).await; + store.fail.store(fail, Ordering::SeqCst); + store.release.cancel(); + if fail { + 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()); + } else { + let retry = request(&call.peer, Method::Invite).await; + assert!(retry.cseq_header()?.seq()? > initial.cseq_header()?.seq()?); + assert_ne!(retry.via_header()?, initial.via_header()?); + let success = response(&retry, &format!("sip:bob@{}", call.peer.local_addr()?)) + .replace( + "Content-Length: 0", + "Session-Expires: 180;refresher=uac\r\nContent-Length: 0", + ); + call.peer.send_to(success.as_bytes(), call.local).await?; + request(&call.peer, Method::Ack).await; + tokio::time::timeout(Duration::from_secs(2), &mut call.task) + .await + .unwrap() + .unwrap()?; + let checkpoints = store.committed.lock().unwrap(); + assert_eq!( + checkpoints + .iter() + .filter(|c| c.reason == Reason::OutgoingRequest) + .count(), + 2 + ); + assert_eq!( + checkpoints + .iter() + .filter(|c| c.reason == Reason::BeforeAck) + .map(|c| match &c.message { + Some(SipMessage::Response(response)) => response.status_code.clone(), + _ => panic!("BeforeAck must preserve the observed final response"), + }) + .collect::>(), + vec![StatusCode::SessionIntervalTooSmall, StatusCode::OK] + ); + assert_eq!(call.dialog.snapshot().runtime.lifecycle.len(), 1); + } + } + Ok(()) +} + +#[tokio::test] +async fn persistence_automatic_update_records_pending_and_refreshed_target() -> crate::Result<()> { + use crate::dialog::session_timer::SessionTimerConfig; + let store = Storage::new(Gate::TimerResponse); + let mut call = start_with_timer( + store.clone(), + Duration::from_secs(2), + Some(SessionTimerConfig { + expires: 90, + ..Default::default() + }), + ) + .await?; + let initial = established(&mut call).await; + let remote = call.peer.local_addr()?; + let target: Uri = format!("sip:refreshed@{remote}").try_into()?; + let update = format!( + "UPDATE sip:alice@{} SIP/2.0\r\nVia: SIP/2.0/UDP {remote};branch=z9hG4bK-timer-update\r\nFrom: ;tag=peer\r\nTo: {}\r\nCall-ID: {}\r\nCSeq: 10 UPDATE\r\nContact: <{target}>\r\nSupported: timer\r\nSession-Expires: 180;refresher=uac\r\nMax-Forwards: 70\r\nContent-Length: 0\r\n\r\n", + call.local, initial.from_header()?.value(), initial.call_id_header()?.value(), + ); + call.peer.send_to(update.as_bytes(), call.local).await?; + entered(&store).await; + { + let attempts = store.attempts.lock().unwrap(); + let pending = &attempts.last().unwrap().snapshot; + assert_eq!(pending.runtime.pending.negotiations, 1); + assert_ne!(pending.remote_uri, target); + assert!(!pending.is_quiescent()); + } + silent(&call.peer).await; + store.release.cancel(); + let SipMessage::Response(response) = receive(&call.peer).await else { + panic!("expected automatic UPDATE response"); + }; + assert_eq!(response.status_code, StatusCode::OK); + tokio::time::timeout(Duration::from_secs(2), async { + loop { + if store.committed.lock().unwrap().iter().any(|c| { + c.reason == Reason::SignalingCompleted + && c.snapshot.is_quiescent() + && c.snapshot.remote_uri == target + }) { + break; + } + tokio::task::yield_now().await; + } + }) + .await + .expect("automatic UPDATE must persist the committed remote target"); + assert!(call.dialog.snapshot().is_quiescent()); + Ok(()) +} 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_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/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/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_session_timer.rs b/src/dialog/tests/test_session_timer.rs new file mode 100644 index 00000000..c6f2cb0a --- /dev/null +++ b/src/dialog/tests/test_session_timer.rs @@ -0,0 +1,909 @@ +//! RFC 4028 wire regressions. SIP intervals stay >= 90 seconds; only the +//! Tokio clock used by the session scheduler is advanced between exchanges. +use super::test_in_dialog_provisional::{recv_request, response}; +use crate::{ + dialog::{ + dialog::{DialogState, DialogStateSender}, + dialog_layer::DialogLayer, + invitation::InviteOption, + invite_dialog::InviteDialog, + session_timer::{RefreshMethod, SessionTimerConfig}, + }, + sip::{ + Header, HeadersExt, Method, Request, Response, SipMessage, StatusCode, ToTypedHeader, Uri, + }, + transport::{udp::UdpConnection, TransportLayer}, + EndpointBuilder, +}; +use std::{net::SocketAddr, sync::Arc, time::Duration}; +use tokio::{net::UdpSocket, sync::mpsc, task::JoinHandle}; +use tokio_util::sync::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 9000 RTP/AVP 0\r\na=inactive\r\n"; + +fn config() -> SessionTimerConfig { + SessionTimerConfig { + expires: 90, + ..Default::default() + } +} + +struct Node { + token: CancellationToken, + layer: Arc, + uri: Uri, + sender: DialogStateSender, + incoming: mpsc::UnboundedReceiver, + errors: Arc>>, + tasks: Vec>, +} +impl Drop for Node { + fn drop(&mut self) { + for id in self.layer.all_dialog_ids() { + if let Some(d) = self.layer.get_dialog_with(&id) { + self.layer.remove_dialog(&d.id()); + } + } + self.token.cancel(); + for task in &self.tasks { + task.abort(); + } + } +} +impl Node { + async fn new(config: Option) -> crate::Result { + let token = CancellationToken::new(); + 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 uri: Uri = format!("sip:timer@{}", udp.get_addr().addr).parse()?; + 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_session_timer(config)?; + let (sender, mut states) = layer.new_dialog_state_channel(); + let mut transactions = endpoint.incoming_transactions()?; + let (incoming_tx, incoming) = mpsc::unbounded_channel(); + let errors = Arc::new(std::sync::Mutex::new(Vec::new())); + let serve = tokio::spawn(async move { + endpoint.inner.serve().await.ok(); + }); + let router = layer.clone(); + let events = sender.clone(); + let local = uri.clone(); + let diagnostics = errors.clone(); + let request_task = tokio::spawn(async move { + while let Some(mut tx) = transactions.recv().await { + let dialog = router.match_dialog(&tx).or_else(|| { + if tx.original.method != Method::Invite { + return None; + } + let dialog = router + .get_or_create_server_invite(&tx, events.clone(), None, Some(local.clone())) + .ok()?; + incoming_tx.send(dialog.clone()).ok(); + Some(crate::dialog::dialog::Dialog::Invite(dialog)) + }); + if let Some(mut dialog) = dialog { + let diagnostics = diagnostics.clone(); + tokio::spawn(async move { + if let Err(error) = dialog.handle(&mut tx).await { + diagnostics.lock().unwrap().push(error.to_string()); + } + while tx.receive().await.is_some() {} + }); + } else { + tx.reply(StatusCode::CallTransactionDoesNotExist).await.ok(); + } + } + }); + let registry = layer.clone(); + let state_task = tokio::spawn(async move { + while let Some(state) = states.recv().await { + if let DialogState::Terminated(id, _) = state { + registry.remove_dialog(&id); + } + } + }); + Ok(Self { + token, + layer, + uri, + sender, + incoming, + errors, + tasks: vec![serve, request_task, state_task], + }) + } + fn invite( + &self, + peer: &UdpSocket, + ) -> JoinHandle)>> { + let layer = self.layer.clone(); + let sender = self.sender.clone(); + let opt = InviteOption { + caller: self.uri.clone(), + contact: self.uri.clone(), + callee: format!("sip:peer@{}", peer.local_addr().unwrap()) + .parse() + .unwrap(), + offer: Some(SDP.into()), + ..Default::default() + }; + tokio::spawn(async move { layer.do_invite(opt, sender).await }) + } + fn clean(&self) { + assert!( + self.errors.lock().unwrap().is_empty(), + "{:?}", + self.errors.lock().unwrap() + ); + } +} + +async fn answer( + peer: &UdpSocket, + addr: SocketAddr, + request: &Request, + code: u16, + timer: Option<&str>, + update: bool, +) -> Response { + let mut r = Response::try_from( + response( + request, + code, + "Test", + &format!("sip:peer@{}", peer.local_addr().unwrap()), + ) + .as_str(), + ) + .unwrap(); + if let Some(timer) = timer { + r.headers.unique_push(Header::SessionExpires(timer.into())); + } + if update { + r.headers.push(Header::Allow("INVITE, UPDATE, BYE".into())); + } + if code == 200 && request.method == Method::Invite { + r.body = SDP.into(); + r.headers + .unique_push(Header::ContentType("application/sdp".into())); + r.headers + .unique_push(Header::ContentLength((SDP.len() as u32).into())); + } + peer.send_to(r.to_string().as_bytes(), addr).await.unwrap(); + r +} + +async fn established( + timer: &str, + update: bool, + cfg: SessionTimerConfig, +) -> (Node, InviteDialog, UdpSocket, Request, SocketAddr) { + let node = Node::new(Some(cfg)).await.unwrap(); + let peer = UdpSocket::bind("127.0.0.1:0").await.unwrap(); + let future = node.invite(&peer); + let (request, addr) = recv_request(&peer, Method::Invite).await; + assert!(request.header_contains_token("Supported", "timer")); + answer(&peer, addr, &request, 200, Some(timer), update).await; + recv_request(&peer, Method::Ack).await; + let (dialog, _) = future.await.unwrap().unwrap(); + (node, dialog, peer, request, addr) +} + +async fn advance(seconds: u64) { + // Keep an executor task runnable so Tokio cannot automatically jump beyond + // the requested instant while real UDP peers are between packets. + let busy = tokio::spawn(async { + loop { + tokio::task::yield_now().await; + } + }); + tokio::task::yield_now().await; + tokio::time::pause(); + tokio::time::advance(Duration::from_secs(seconds)).await; + tokio::time::resume(); + busy.abort(); + for _ in 0..5 { + tokio::task::yield_now().await; + } +} + +async fn finished(dialog: &InviteDialog) { + for _ in 0..100 { + if !dialog.session_timer_status().unwrap().worker_running { + return; + } + tokio::task::yield_now().await; + } + panic!("session timer task did not stop"); +} + +#[tokio::test] +async fn session_timer_update_refresh_resets_only_on_success() { + let (node, dialog, peer, _, _) = established("90;refresher=uac", true, config()).await; + advance(45).await; + let (request, addr) = recv_request(&peer, Method::Update).await; + assert!(request.body.is_empty()); + assert_eq!( + request.session_expires_header().unwrap().value(), + "90;refresher=uac" + ); + answer(&peer, addr, &request, 200, Some("90;refresher=uac"), true).await; + tokio::time::sleep(Duration::from_millis(10)).await; + assert!(dialog.session_timer_status().unwrap().remaining > Duration::from_secs(89)); + advance(45).await; + let (request, addr) = recv_request(&peer, Method::Update).await; + answer(&peer, addr, &request, 488, None, true).await; + tokio::time::sleep(Duration::from_millis(10)).await; + assert!(dialog.state().is_confirmed()); + advance(46).await; + let (bye, addr) = recv_request(&peer, Method::Bye).await; + answer(&peer, addr, &bye, 200, None, false).await; + finished(&dialog).await; + assert_eq!(dialog.session_timer_status().unwrap().refreshes, 2); + assert_eq!(dialog.session_timer_status().unwrap().expirations, 1); + node.clean(); +} + +#[tokio::test] +async fn session_timer_reinvite_reuses_negotiated_sdp_and_ack() { + let (node, dialog, peer, initial, _) = established("90;refresher=uac", false, config()).await; + advance(45).await; + let (request, addr) = recv_request(&peer, Method::Invite).await; + assert_eq!(request.body, SDP); + assert_eq!( + request.call_id_header().unwrap(), + initial.call_id_header().unwrap() + ); + assert!( + request.cseq_header().unwrap().seq().unwrap() + > initial.cseq_header().unwrap().seq().unwrap() + ); + answer(&peer, addr, &request, 200, Some("90;refresher=uac"), false).await; + recv_request(&peer, Method::Ack).await; + node.layer.remove_dialog(&dialog.id()); + finished(&dialog).await; + node.clean(); +} + +#[tokio::test] +async fn session_timer_remote_expiration_uses_rfc_grace_period() { + let (node, dialog, peer, _, _) = established("90;refresher=uas", true, config()).await; + advance(59).await; + assert!(dialog.state().is_confirmed()); + advance(2).await; + let (bye, addr) = recv_request(&peer, Method::Bye).await; + answer(&peer, addr, &bye, 200, None, false).await; + finished(&dialog).await; + node.clean(); +} + +#[tokio::test] +async fn session_timer_422_retries_with_new_transaction_and_preserves_dialog() { + let node = Node::new(Some(config())).await.unwrap(); + let peer = UdpSocket::bind("127.0.0.1:0").await.unwrap(); + let future = node.invite(&peer); + let (first, addr) = recv_request(&peer, Method::Invite).await; + let mut challenge = Response::try_from( + response( + &first, + 422, + "Session Interval Too Small", + &format!("sip:peer@{}", peer.local_addr().unwrap()), + ) + .as_str(), + ) + .unwrap(); + challenge.headers.push(Header::MinSE("120".into())); + peer.send_to(challenge.to_string().as_bytes(), addr) + .await + .unwrap(); + recv_request(&peer, Method::Ack).await; + let (second, addr) = recv_request(&peer, Method::Invite).await; + assert_eq!( + second.call_id_header().unwrap(), + first.call_id_header().unwrap() + ); + assert_eq!( + second.cseq_header().unwrap().seq().unwrap(), + first.cseq_header().unwrap().seq().unwrap() + 1 + ); + assert_ne!(second.via_header().unwrap(), first.via_header().unwrap()); + assert_eq!(second.body, first.body); + assert!(second.to_header().unwrap().tag().unwrap().is_none()); + assert_eq!( + second.session_expires_header().unwrap().value(), + "120;refresher=uac" + ); + answer(&peer, addr, &second, 200, Some("120;refresher=uac"), true).await; + recv_request(&peer, Method::Ack).await; + let (dialog, _) = future.await.unwrap().unwrap(); + assert_eq!(dialog.session_timer_status().unwrap().interval, Some(120)); + node.layer.remove_dialog(&dialog.id()); + finished(&dialog).await; + node.clean(); +} + +#[tokio::test] +async fn session_timer_missing_response_header_disables_timer() { + let (node, dialog, peer, _, _) = established("90;refresher=uac", true, config()).await; + advance(45).await; + let (request, addr) = recv_request(&peer, Method::Update).await; + answer(&peer, addr, &request, 200, None, true).await; + tokio::time::sleep(Duration::from_millis(10)).await; + assert_eq!(dialog.session_timer_status().unwrap().interval, None); + advance(100).await; + assert!(dialog.state().is_confirmed()); + node.layer.remove_dialog(&dialog.id()); + finished(&dialog).await; + node.clean(); +} + +#[tokio::test] +async fn session_timer_481_refresh_ends_session_immediately() { + let (node, dialog, peer, _, _) = established("90;refresher=uac", true, config()).await; + advance(45).await; + let (request, addr) = recv_request(&peer, Method::Update).await; + answer(&peer, addr, &request, 481, None, true).await; + let (bye, addr) = recv_request(&peer, Method::Bye).await; + answer(&peer, addr, &bye, 200, None, false).await; + finished(&dialog).await; + node.clean(); +} + +#[tokio::test] +async fn session_timer_duplicate_200_does_not_extend_deadline() { + let (node, dialog, peer, request, addr) = established("90;refresher=uas", true, config()).await; + advance(30).await; + answer(&peer, addr, &request, 200, Some("90;refresher=uas"), true).await; + recv_request(&peer, Method::Ack).await; + assert!(dialog.session_timer_status().unwrap().remaining < Duration::from_secs(61)); + advance(31).await; + let (bye, addr) = recv_request(&peer, Method::Bye).await; + answer(&peer, addr, &bye, 200, None, false).await; + finished(&dialog).await; + node.clean(); +} + +async fn recv_response(peer: &UdpSocket, code: u16) -> Response { + let mut data = [0; 8192]; + loop { + let (n, _) = tokio::time::timeout(Duration::from_secs(2), peer.recv_from(&mut data)) + .await + .unwrap() + .unwrap(); + if let SipMessage::Response(response) = + SipMessage::try_from(std::str::from_utf8(&data[..n]).unwrap()).unwrap() + { + if response.status_code.code() == 100 { + continue; + } + assert_eq!(response.status_code.code(), code, "{response}"); + return response; + } + } +} +fn incoming(node: &Node, peer: &UdpSocket, headers: &str) -> Request { + format!("INVITE {} SIP/2.0\r\nVia: SIP/2.0/UDP {};branch=z9hG4bK-timer-initial;rport\r\nFrom: ;tag=caller\r\nTo: <{}>\r\nCall-ID: session-timer-test\r\nCSeq: 1 INVITE\r\nContact: \r\nMax-Forwards: 70\r\n{}Content-Type: application/sdp\r\nContent-Length: {}\r\n\r\n{}", + node.uri, peer.local_addr().unwrap(), node.uri, peer.local_addr().unwrap(), headers, SDP.len(), std::str::from_utf8(SDP).unwrap()).as_str().try_into().unwrap() +} +async fn send(peer: &UdpSocket, node: &Node, request: &Request) { + peer.send_to( + request.to_string().as_bytes(), + node.uri.host_with_port.to_string(), + ) + .await + .unwrap(); +} +fn followup( + initial: &Request, + response: &Response, + method: Method, + seq: u32, + timer: Option<&str>, +) -> Request { + let mut request = initial.clone(); + request.method = method.clone(); + request + .headers + .unique_push(Header::CSeq(format!("{seq} {method}").into())); + request + .headers + .unique_push(Header::To(response.to_header().unwrap().clone())); + request.headers.unique_push(Header::Via( + format!( + "SIP/2.0/UDP {};branch=z9hG4bK-next-{seq}-{method};rport", + request + .contact_header() + .unwrap() + .typed() + .unwrap() + .uri + .host_with_port + ) + .into(), + )); + request.headers.retain(|h| { + !matches!( + h, + Header::SessionExpires(_) + | Header::MinSE(_) + | Header::ContentType(_) + | Header::Require(_) + ) + }); + if let Some(timer) = timer { + request.headers.push(Header::SessionExpires(timer.into())); + } + request.body.clear(); + request.headers.unique_push(Header::ContentLength(0.into())); + request +} +async fn uas(headers: &str) -> (Node, InviteDialog, UdpSocket, Request, Response) { + let mut node = Node::new(Some(config())).await.unwrap(); + let peer = UdpSocket::bind("127.0.0.1:0").await.unwrap(); + let request = incoming(&node, &peer, headers); + send(&peer, &node, &request).await; + let dialog = node.incoming.recv().await.unwrap(); + dialog + .accept( + Some(vec![Header::ContentType("application/sdp".into())]), + Some(SDP.into()), + ) + .unwrap(); + let response = recv_response(&peer, 200).await; + send( + &peer, + &node, + &followup(&request, &response, Method::Ack, 1, None), + ) + .await; + for _ in 0..100 { + if dialog.state().is_confirmed() { + break; + } + tokio::task::yield_now().await; + } + assert!(dialog.state().is_confirmed()); + (node, dialog, peer, request, response) +} + +#[tokio::test] +async fn session_timer_uas_negotiates_both_roles_and_peer_without_support() { + for (headers, expected) in [ + ( + "Supported: timer\r\nSession-Expires: 180;refresher=uac\r\n", + "90;refresher=uac", + ), + ( + "Supported: timer\r\nSession-Expires: 180;refresher=uas\r\n", + "90;refresher=uas", + ), + ( + "Supported: timer\r\nSession-Expires: 180\r\nMin-SE: 120\r\n", + "120;refresher=uas", + ), + ("Session-Expires: 90\r\n", "90;refresher=uas"), + ("", "90;refresher=uas"), + ] { + let (node, dialog, _, _, response) = uas(headers).await; + assert_eq!(response.session_expires_header().unwrap().value(), expected); + assert_eq!( + response.header_contains_token("Require", "timer"), + headers.contains("Supported") + ); + node.layer.remove_dialog(&dialog.id()); + finished(&dialog).await; + node.clean(); + } +} + +#[tokio::test] +async fn session_timer_uas_rejects_small_and_malformed_intervals() { + for (headers, code) in [ + ("Supported: timer\r\nSession-Expires: 60\r\n", 422), + ( + "Supported: timer\r\nSession-Expires: 90;refresher=bad\r\n", + 400, + ), + ( + "Supported: timer\r\nSession-Expires: 90\r\nSession-Expires: 120\r\n", + 400, + ), + ("Supported: timer\r\nSession-Expires: 4294967296\r\n", 400), + ( + "Supported: timer\r\nSession-Expires: 90;refresher=uac;refresher=uas\r\n", + 400, + ), + ( + "Supported: timer\r\nSession-Expires: 90\r\nMin-SE: 1\r\n", + 400, + ), + ] { + let node = Node::new(Some(config())).await.unwrap(); + let peer = UdpSocket::bind("127.0.0.1:0").await.unwrap(); + send(&peer, &node, &incoming(&node, &peer, headers)).await; + let response = recv_response(&peer, code).await; + if code == 422 { + assert!(response + .headers + .iter() + .any(|h| matches!(h, Header::MinSE(s) if s.value()=="90"))); + } + node.clean(); + } +} + +#[tokio::test] +async fn session_timer_disabled_does_not_advertise_and_rejects_require() { + let node = Node::new(None).await.unwrap(); + let peer = UdpSocket::bind("127.0.0.1:0").await.unwrap(); + let outbound = node.invite(&peer); + let (request, addr) = recv_request(&peer, Method::Invite).await; + assert!(request.session_expires_header().is_none()); + assert!(!request.header_contains_token("Supported", "timer")); + answer(&peer, addr, &request, 486, None, false).await; + outbound.await.unwrap().unwrap(); + send( + &peer, + &node, + &incoming(&node, &peer, "Require: timer\r\nSession-Expires: 90\r\n"), + ) + .await; + let response = recv_response(&peer, 420).await; + assert_eq!( + response.header_value("Unsupported").as_deref(), + Some("timer") + ); + node.clean(); +} + +#[tokio::test] +async fn session_timer_uas_update_refresh_and_bye_stop_worker() { + let (node, dialog, peer, initial, response) = + uas("Supported: timer\r\nSession-Expires: 90;refresher=uac\r\nAllow: UPDATE\r\n").await; + advance(50).await; + let request = followup( + &initial, + &response, + Method::Update, + 2, + Some("90;refresher=uac"), + ); + send(&peer, &node, &request).await; + let updated = recv_response(&peer, 200).await; + assert_eq!( + updated.cseq_header().unwrap().method().unwrap(), + Method::Update + ); + assert_eq!( + updated.session_expires_header().unwrap().value(), + "90;refresher=uac" + ); + assert!( + dialog.session_timer_status().unwrap().remaining > Duration::from_secs(89), + "{:?}", + dialog.session_timer_status() + ); + advance(20).await; + assert!(dialog.state().is_confirmed()); + send( + &peer, + &node, + &followup(&initial, &response, Method::Bye, 3, None), + ) + .await; + recv_response(&peer, 200).await; + finished(&dialog).await; + advance(100).await; + assert!(dialog.state().is_terminated()); + assert_eq!(dialog.session_timer_status().unwrap().refreshes, 0); + node.clean(); +} + +#[tokio::test] +async fn session_timer_uas_can_refresh_as_uac_using_update() { + let (node, dialog, peer, _, _) = + uas("Supported: timer\r\nSession-Expires: 90;refresher=uas\r\nAllow: UPDATE\r\n").await; + advance(45).await; + let (request, addr) = recv_request(&peer, Method::Update).await; + // uac/uas refers to THIS request's transaction, not the original INVITE. + assert_eq!( + request.session_expires_header().unwrap().value(), + "90;refresher=uac" + ); + answer(&peer, addr, &request, 200, Some("90;refresher=uac"), true).await; + tokio::time::sleep(Duration::from_millis(10)).await; + assert!(dialog.session_timer_status().unwrap().local_refresher); + node.layer.remove_dialog(&dialog.id()); + finished(&dialog).await; + node.clean(); +} + +#[tokio::test] +async fn session_timer_explicit_reinvite_even_when_peer_supports_update() { + let (node, dialog, peer, _, _) = established( + "90;refresher=uac", + true, + SessionTimerConfig { + refresh_method: RefreshMethod::Reinvite, + ..config() + }, + ) + .await; + advance(45).await; + let (request, addr) = recv_request(&peer, Method::Invite).await; + answer(&peer, addr, &request, 200, Some("90;refresher=uac"), true).await; + recv_request(&peer, Method::Ack).await; + node.layer.remove_dialog(&dialog.id()); + finished(&dialog).await; + node.clean(); +} + +#[test] +fn session_timer_config_respects_rfc_minimum() { + assert!(SessionTimerConfig::default().validate().is_ok()); + assert!(SessionTimerConfig { + min_se: 89, + ..Default::default() + } + .validate() + .is_err()); + assert!(SessionTimerConfig { + min_se: 120, + expires: 90, + ..Default::default() + } + .validate() + .is_err()); +} + +async fn challenge(peer: &UdpSocket, addr: SocketAddr, request: &Request, min: &str) { + let mut r = Response::try_from( + response( + request, + 422, + "Session Interval Too Small", + &format!("sip:peer@{}", peer.local_addr().unwrap()), + ) + .as_str(), + ) + .unwrap(); + r.headers.push(Header::MinSE(min.into())); + peer.send_to(r.to_string().as_bytes(), addr).await.unwrap(); +} + +#[tokio::test] +async fn session_timer_update_422_retry_preserves_expiration_until_200() { + let (node, dialog, peer, _, _) = established("90;refresher=uac", true, config()).await; + advance(45).await; + let (first, addr) = recv_request(&peer, Method::Update).await; + challenge(&peer, addr, &first, "120").await; + let (retry, addr) = recv_request(&peer, Method::Update).await; + assert_eq!( + retry.session_expires_header().unwrap().value(), + "120;refresher=uac" + ); + assert_eq!( + retry.cseq_header().unwrap().seq().unwrap(), + first.cseq_header().unwrap().seq().unwrap() + 1 + ); + assert!(dialog.session_timer_status().unwrap().remaining < Duration::from_secs(46)); + answer(&peer, addr, &retry, 200, Some("120;refresher=uac"), true).await; + tokio::time::sleep(Duration::from_millis(10)).await; + assert_eq!(dialog.session_timer_status().unwrap().interval, Some(120)); + node.layer.remove_dialog(&dialog.id()); + finished(&dialog).await; + node.clean(); +} + +#[tokio::test] +async fn session_timer_422_retries_are_bounded() { + let node = Node::new(Some(config())).await.unwrap(); + let peer = UdpSocket::bind("127.0.0.1:0").await.unwrap(); + let future = node.invite(&peer); + for min in [120, 180, 240, 300] { + let (request, addr) = recv_request(&peer, Method::Invite).await; + challenge(&peer, addr, &request, &min.to_string()).await; + recv_request(&peer, Method::Ack).await; + } + let (dialog, response) = future.await.unwrap().unwrap(); + assert_eq!(response.unwrap().status_code.code(), 422); + assert!(dialog.state().is_terminated()); + finished(&dialog).await; + node.clean(); +} + +#[tokio::test] +async fn session_timer_invalid_initial_agreement_is_acked_before_bye() { + for value in ["60;refresher=uac", "90", "90;refresher=invalid"] { + let node = Node::new(Some(config())).await.unwrap(); + let peer = UdpSocket::bind("127.0.0.1:0").await.unwrap(); + let future = node.invite(&peer); + let (request, addr) = recv_request(&peer, Method::Invite).await; + answer(&peer, addr, &request, 200, Some(value), true).await; + recv_request(&peer, Method::Ack).await; + let (bye, addr) = recv_request(&peer, Method::Bye).await; + answer(&peer, addr, &bye, 200, None, false).await; + assert!(future.await.unwrap().is_err()); + node.clean(); + } +} + +#[tokio::test] +async fn session_timer_reinvite_invalid_agreement_still_sends_ack() { + let (node, dialog, peer, _, _) = established("90;refresher=uac", false, config()).await; + advance(45).await; + let (request, addr) = recv_request(&peer, Method::Invite).await; + answer(&peer, addr, &request, 200, Some("60;refresher=uac"), false).await; + recv_request(&peer, Method::Ack).await; + let (bye, addr) = recv_request(&peer, Method::Bye).await; + answer(&peer, addr, &bye, 200, None, false).await; + finished(&dialog).await; + assert!(dialog.state().is_terminated()); + node.clean(); +} + +#[tokio::test] +async fn session_timer_lost_update_response_cannot_extend_session() { + let (node, dialog, peer, _, _) = established("90;refresher=uac", true, config()).await; + advance(45).await; + recv_request(&peer, Method::Update).await; + advance(46).await; + let (bye, addr) = recv_request(&peer, Method::Bye).await; + answer(&peer, addr, &bye, 200, None, false).await; + finished(&dialog).await; + assert_eq!(dialog.session_timer_status().unwrap().expirations, 1); + node.clean(); +} + +#[tokio::test] +async fn session_timer_glare_retry_keeps_original_deadline() { + let (node, dialog, peer, _, _) = established("90;refresher=uac", true, config()).await; + advance(45).await; + let (first, addr) = recv_request(&peer, Method::Update).await; + answer(&peer, addr, &first, 491, None, false).await; + tokio::time::sleep(Duration::from_millis(10)).await; + advance(5).await; + let (retry, addr) = recv_request(&peer, Method::Update).await; + assert!( + retry.cseq_header().unwrap().seq().unwrap() > first.cseq_header().unwrap().seq().unwrap() + ); + assert!(dialog.session_timer_status().unwrap().remaining < Duration::from_secs(41)); + answer(&peer, addr, &retry, 200, Some("90;refresher=uac"), true).await; + tokio::time::sleep(Duration::from_millis(10)).await; + node.layer.remove_dialog(&dialog.id()); + finished(&dialog).await; + node.clean(); +} + +#[tokio::test] +async fn session_timer_termination_cancels_pending_refresh() { + let (node, dialog, peer, _, _) = established("90;refresher=uac", true, config()).await; + advance(45).await; + recv_request(&peer, Method::Update).await; + node.layer.remove_dialog(&dialog.id()); + finished(&dialog).await; + let count = dialog.session_timer_status().unwrap().refreshes; + advance(180).await; + assert_eq!(dialog.session_timer_status().unwrap().refreshes, count); + assert_eq!(dialog.session_timer_status().unwrap().expirations, 0); + node.clean(); +} + +#[tokio::test] +async fn session_timer_preserves_initial_option_tags_on_refresh() { + let node = Node::new(Some(config())).await.unwrap(); + let peer = UdpSocket::bind("127.0.0.1:0").await.unwrap(); + let (dialog, task) = node + .layer + .do_invite_async( + InviteOption { + caller: node.uri.clone(), + contact: node.uri.clone(), + callee: format!("sip:peer@{}", peer.local_addr().unwrap()) + .parse() + .unwrap(), + offer: Some(SDP.into()), + headers: Some(vec![ + Header::Require("timer".into()), + Header::Supported("example".into()), + Header::ProxyRequire("example".into()), + ]), + ..Default::default() + }, + node.sender.clone(), + ) + .unwrap(); + let (initial, addr) = recv_request(&peer, Method::Invite).await; + answer(&peer, addr, &initial, 200, Some("90;refresher=uac"), true).await; + recv_request(&peer, Method::Ack).await; + task.await.unwrap().unwrap(); + advance(45).await; + let (refresh, addr) = recv_request(&peer, Method::Update).await; + for header in ["Supported", "Require", "Proxy-Require"] { + assert_eq!(refresh.header_value(header), initial.header_value(header)); + } + answer(&peer, addr, &refresh, 200, Some("90;refresher=uac"), true).await; + node.layer.remove_dialog(&dialog.id()); + finished(&dialog).await; +} + +#[tokio::test] +async fn session_timer_provider_rejection_after_200_ends_session() { + struct Media; + #[async_trait::async_trait] + impl crate::dialog::session_timer::RefreshSdp for Media { + async fn offer(&self) -> crate::Result { + Ok(crate::dialog::reinvite::AckBody::sdp(SDP)) + } + async fn answer(&self, _: &Response) -> crate::Result<()> { + Err(crate::Error::Error("unusable media answer".into())) + } + } + let (node, dialog, peer, _, _) = established( + "90;refresher=uac", + false, + SessionTimerConfig { + sdp: Some(Arc::new(Media)), + ..config() + }, + ) + .await; + advance(45).await; + let (request, addr) = recv_request(&peer, Method::Invite).await; + answer(&peer, addr, &request, 200, Some("90;refresher=uac"), false).await; + recv_request(&peer, Method::Ack).await; + let (bye, addr) = recv_request(&peer, Method::Bye).await; + answer(&peer, addr, &bye, 200, None, false).await; + finished(&dialog).await; + assert!(dialog.state().is_terminated()); + node.clean(); +} + +#[tokio::test] +async fn session_timer_incoming_refresh_updates_pending_watchdog() { + let (node, dialog, peer, initial, response) = + uas("Supported: timer\r\nSession-Expires: 90;refresher=uas\r\nAllow: UPDATE\r\n").await; + advance(45).await; + let (pending, addr) = recv_request(&peer, Method::Update).await; + advance(10).await; + send( + &peer, + &node, + &followup( + &initial, + &response, + Method::Update, + 2, + Some("90;refresher=uac"), + ), + ) + .await; + recv_response(&peer, 200).await; + advance(36).await; // Beyond the old deadline, before the renewed one. + assert!(dialog.state().is_confirmed()); + assert!(!dialog.session_timer_status().unwrap().local_refresher); + answer(&peer, addr, &pending, 200, Some("90;refresher=uas"), true).await; + tokio::time::sleep(Duration::from_millis(10)).await; + node.layer.remove_dialog(&dialog.id()); + finished(&dialog).await; + node.clean(); +} + +#[tokio::test] +async fn session_timer_endpoint_shutdown_stops_worker_with_live_dialog_handle() { + let (node, dialog, _, _, _) = established("90;refresher=uac", true, config()).await; + node.token.cancel(); + finished(&dialog).await; + assert_eq!(dialog.session_timer_status().unwrap().refreshes, 0); +} 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/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/endpoint.rs b/src/transaction/endpoint.rs index 231f1779..ee00da1d 100644 --- a/src/transaction/endpoint.rs +++ b/src/transaction/endpoint.rs @@ -778,6 +778,10 @@ impl EndpointInner { Some(self.transactions.with(|m| m.keys().cloned().collect())) } + pub(crate) fn shutdown_token(&self) -> CancellationToken { + self.cancel_token.clone() + } + pub fn get_stats(&self) -> EndpointStats { let waiting_ack = self.waiting_ack.len(); let running_transactions = self.transactions.len(); 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, diff --git a/src/transaction/transaction.rs b/src/transaction/transaction.rs index dfd46ead..83cf268d 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, @@ -195,6 +197,10 @@ pub struct Transaction { retransmission: bool, is_cleaned_up: bool, invite_reservation: Mutex>, + pub(crate) session_timer: + crate::platform::sync::Mutex>>, + pub(crate) reliable_provisional: + crate::platform::sync::Mutex>>, } impl Transaction { @@ -233,6 +239,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, @@ -244,12 +252,27 @@ impl Transaction { tu_sender, is_cleaned_up: false, invite_reservation: Mutex::new(None), + reliable_provisional: crate::platform::sync::Mutex::new(None), + session_timer: crate::platform::sync::Mutex::new(None), }; tx.endpoint_inner .attach_transaction(&tx.key, tx.tu_sender.clone()); 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 +329,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 => {} _ => { @@ -483,6 +530,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` @@ -500,6 +552,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 => {} _ => { @@ -510,6 +563,25 @@ 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 session_timer = self.session_timer.lock().clone(); + let mut response = response; + if let Some(timer) = &session_timer { + timer.prepare_response(&self.original, &mut response)?; + } let new_state = match response.status_code.kind() { StatusCodeKind::Provisional => match response.status_code { StatusCode::Trying => TransactionState::Trying, @@ -550,6 +622,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 +681,31 @@ impl Transaction { } } guard.0 = None; - self.transition(new_state).map(|_| ()) + let final_response = !matches!( + new_state, + TransactionState::Trying | TransactionState::Proceeding + ); + // Non-INVITE termination moves last_response into the endpoint cache. + let timer_response = session_timer.as_ref().and(self.last_response.clone()); + self.transition(new_state)?; + if let (Some(timer), Some(response)) = (session_timer, timer_response) { + timer.sent(&self.original, &response); + } + if let (Some(server), Some(response)) = (reliable, self.last_response.as_ref()) { + server.sent(response); + } + 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 +820,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 +912,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 +998,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 } @@ -1273,6 +1388,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; @@ -1301,6 +1422,20 @@ 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::Provisional + && self.original.method == Method::Invite + { + if let Err(error) = dialog + .checkpoint_invite_response(&self.original, &resp) + .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 +1458,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 +1483,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/dialog_checkpoint_boundaries.rs b/tests/dialog_checkpoint_boundaries.rs new file mode 100644 index 00000000..0069deec --- /dev/null +++ b/tests/dialog_checkpoint_boundaries.rs @@ -0,0 +1,230 @@ +//! Public storage hooks must observe final responses and refreshed targets before ACK. +use rsipstack::{ + dialog::{ + dialog::{Dialog, DialogSnapshot, DialogSnapshotState}, + dialog_layer::DialogLayer, + invitation::InviteOption, + invite_dialog::InviteDialog, + persistence::{ + DialogCheckpoint, DialogCheckpointReason, DialogPersistence, DialogPersistenceConfig, + }, + reinvite::ReinviteOptions, + DialogId, + }, + sip::{Header, HeadersExt, Method, Request, SipMessage, StatusCode, ToTypedHeader}, + transaction::key::TransactionRole, + transaction::EndpointBuilder, + transport::{udp::UdpConnection, TransportLayer}, +}; +use std::{sync::Arc, time::Duration}; +use tokio::{net::UdpSocket, sync::mpsc}; +use tokio_util::sync::CancellationToken; +type Result = std::result::Result>; +const WAIT: Duration = Duration::from_secs(2); + +struct Storage { + checkpoints: mpsc::UnboundedSender, + release: CancellationToken, + fail: bool, +} +#[async_trait::async_trait] +impl DialogPersistence for Storage { + async fn save(&self, checkpoint: DialogCheckpoint) -> rsipstack::Result<()> { + let wait = checkpoint.reason == DialogCheckpointReason::BeforeAck; + self.checkpoints.send(checkpoint).ok(); + if wait { + self.release.cancelled().await; + if self.fail { + return Err(rsipstack::Error::Error("injected write failure".into())); + } + } + Ok(()) + } +} +struct Stop(CancellationToken); +impl Drop for Stop { + fn drop(&mut self) { + self.0.cancel(); + } +} + +async fn boundary(role: Option, status: StatusCode, fail: bool) -> Result<()> { + let stop = Stop(CancellationToken::new()); + let transport = TransportLayer::new(stop.0.clone()); + let udp = UdpConnection::create_connection("127.0.0.1:0".parse()?, None, Some(stop.0.clone())) + .await?; + let local = udp.get_addr().get_socketaddr()?; + transport.add_transport(udp.into()); + let endpoint = Arc::new( + EndpointBuilder::new() + .with_transport_layer(transport) + .with_cancel_token(stop.0.clone()) + .build(), + ); + let layer = Arc::new(DialogLayer::new(endpoint.inner.clone())); + let (sender, mut checkpoints) = mpsc::unbounded_channel(); + let storage = Arc::new(Storage { + checkpoints: sender, + release: CancellationToken::new(), + fail, + }); + layer.set_persistence(Some(DialogPersistenceConfig::new(storage.clone())))?; + let serving = endpoint.clone(); + tokio::spawn(async move { serving.serve().await }); + let peer = UdpSocket::bind("127.0.0.1:0").await?; + let refreshed = UdpSocket::bind("127.0.0.1:0").await?; + let target = format!("sip:peer@{}", peer.local_addr()?); + let new_target = format!("sip:refreshed@{}", refreshed.local_addr()?); + let (states, _events) = mpsc::unbounded_channel(); + let dialog: InviteDialog; + if let Some(role) = role { + let local_uri = format!(";tag=local"); + let remote_uri = format!("<{target}>;tag=remote"); + let (from, to) = if role == TransactionRole::Client { + (local_uri, remote_uri) + } else { + (remote_uri, local_uri) + }; + let snapshot = DialogSnapshot::builder( + DialogId { + call_id: "checkpoints".into(), + local_tag: "local".into(), + remote_tag: "remote".into(), + }, + role, + rsipstack::sip::From::from(from).typed()?, + rsipstack::sip::To::from(to).typed()?, + target.as_str().try_into()?, + ) + .state(DialogSnapshotState::Confirmed) + .local_cseq(1) + .remote_cseq(1) + .runtime(Default::default()) + .local_contact(Some(format!("sip:local@{local}").as_str().try_into()?)) + .remote_contact(Some(format!("<{target}>").into())) + .build()?; + let id = snapshot.id.clone(); + assert!(layer.restore_from_snapshot(snapshot, states)?); + let Some(Dialog::Invite(d)) = layer.get_dialog(&id) else { + panic!("missing restored dialog") + }; + dialog = d; + let request = dialog.prepare_reinvite(None, Some(b"v=0\r\n".to_vec()))?; + let operation = dialog.clone(); + tokio::spawn(async move { + operation + .send_reinvite(request, ReinviteOptions::default()) + .await + }); + } else { + let (d, _task) = layer.do_invite_async( + InviteOption { + caller: "sip:local@example.com".try_into()?, + callee: target.as_str().try_into()?, + contact: format!("sip:local@{local}").as_str().try_into()?, + ..Default::default() + }, + states, + )?; + dialog = d; + } + let mut bytes = [0; 8192]; + let (n, source) = tokio::time::timeout(WAIT, peer.recv_from(&mut bytes)).await??; + let invite: Request = SipMessage::try_from(&bytes[..n])?.try_into()?; + assert_eq!(invite.method, Method::Invite); + let mut response = endpoint.inner.make_response(&invite, status.clone(), None); + if role.is_none() { + response + .headers + .unique_push(Header::To(format!("<{target}>;tag=remote").into())); + } + response + .headers + .push(Header::Contact(format!("<{new_target}>").into())); + response.headers.push(Header::Reason( + "SIP;cause=488;text=\"response must be durable\"".into(), + )); + peer.send_to(response.to_string().as_bytes(), source) + .await?; + let checkpoint = tokio::time::timeout(WAIT, async { + loop { + let c = checkpoints.recv().await.expect("storage channel closed"); + if c.reason == DialogCheckpointReason::BeforeAck { + break c; + } + } + }) + .await?; + assert_eq!( + checkpoint.message, + Some(SipMessage::Response(response.clone())) + ); + if role.is_some() { + assert_eq!( + checkpoint.snapshot.remote_uri.to_string(), + if status == StatusCode::OK { + new_target.clone() + } else { + target.clone() + } + ); + assert!(checkpoint.snapshot.runtime.pending.negotiations > 0); + } + let ack_peer = if status == StatusCode::OK { + &refreshed + } else { + &peer + }; + assert!( + tokio::time::timeout(Duration::from_millis(40), ack_peer.recv_from(&mut bytes)) + .await + .is_err(), + "ACK escaped before commit" + ); + storage.release.cancel(); + if fail { + tokio::time::timeout(WAIT, async { + while dialog.persistence_status().unwrap().failure.is_none() { + tokio::task::yield_now().await; + } + }) + .await?; + assert!( + tokio::time::timeout(Duration::from_millis(80), ack_peer.recv_from(&mut bytes)) + .await + .is_err(), + "failed checkpoint still sent ACK" + ); + } else { + let (n, _) = tokio::time::timeout(WAIT, ack_peer.recv_from(&mut bytes)).await??; + let ack: Request = SipMessage::try_from(&bytes[..n])?.try_into()?; + assert_eq!(ack.method, Method::Ack); + assert_eq!(ack.cseq_header()?.seq()?, invite.cseq_header()?.seq()?); + } + Ok(()) +} +#[tokio::test] +async fn initial_rejection_is_committed_before_ack() -> Result<()> { + boundary(None, StatusCode::NotAcceptableHere, false).await +} +#[tokio::test] +async fn rejected_reinvite_keeps_previous_target_before_ack() -> Result<()> { + boundary( + Some(TransactionRole::Client), + StatusCode::NotAcceptableHere, + false, + ) + .await +} +#[tokio::test] +async fn uac_refresh_target_is_committed_before_ack() -> Result<()> { + boundary(Some(TransactionRole::Client), StatusCode::OK, false).await +} +#[tokio::test] +async fn uas_refresh_target_is_committed_before_ack() -> Result<()> { + boundary(Some(TransactionRole::Server), StatusCode::OK, false).await +} +#[tokio::test] +async fn failed_rejection_checkpoint_prevents_ack() -> Result<()> { + boundary(None, StatusCode::NotAcceptableHere, true).await +} diff --git a/tests/interop/COVERAGE.md b/tests/interop/COVERAGE.md index cd20659e..11864618 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. +This matrix describes the current PR stack on upstream `895d443` (0.8.1). + +## 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 @@ -24,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 @@ -37,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 @@ -92,8 +112,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 208 external-peer test executions: +206 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. @@ -104,9 +124,10 @@ 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 | +| RFC 4028 | UAC/UAS negotiation, 422, UPDATE/re-INVITE refresh and teardown over UDP/TCP | 8 | | Session modification | hold/resume re-INVITEs, 488 rejection, UPDATE | 6 | | Termination | CANCEL/487, crossed CANCEL/200, BYE/481 | 6 | | Dialog identity | wrong local/remote tags then valid BYE | 2 | @@ -119,7 +140,8 @@ 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 | -| Known-gap probes | SHA-256; PRACK | 10 | +| Re-INVITE bridge | two PJSUA peers for hold/resume, two SIPp peers for offerless SDP, lost answer ACK | 9 | +| 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 @@ -164,14 +186,14 @@ 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 | | Routing | strict routes, several proxies, redirects, Path/Outbound flows | | Standalone applications | proxy-specific 2xx retransmission policy, forking, session modification, PRACK, authentication, disconnect recovery and media relay | | Event packages | initial SUBSCRIBE/NOTIFY races, terminal NOTIFY, PUBLISH, REFER/Replaces | -| Session extensions | session timers, full Session-ID transfer/conference flows | +| Session extensions | proxy timer policy, timer persistence, full Session-ID transfer/conference flows | | Media and scale | RTP/SRTP, codecs, ICE, DTMF media events, concurrency and soak/load tests | Add focused XML scenarios and public-API assertions for these areas as the @@ -209,9 +231,16 @@ 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. 4. Separate longer stress/soak and parser fuzzing jobs, with explicit resource limits and reproducible seeds. These are not enabled by the current runner. + +## Session timers + +Eight SIPp cases exercise RFC 4028 UAC/UAS with UPDATE and re-INVITE over +UDP/TCP. They verify 422 retry identity, negotiated intervals and refresher +changes, ACK, BYE and timer/registry cleanup. See [SESSION_TIMERS.md](SESSION_TIMERS.md) +for the API, virtual-clock library regressions and remaining integration limits. diff --git a/tests/interop/README.md b/tests/interop/README.md index 9cbd3443..26415817 100644 --- a/tests/interop/README.md +++ b/tests/interop/README.md @@ -21,21 +21,32 @@ 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 (206 tests) +bash scripts/interop/run.sh all # all 208; 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 # 89 SIPp tests, including known gaps +bash scripts/interop/run.sh sipp # 110 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 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 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 session_timer # eight RFC 4028 wire exchanges +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]`. @@ -51,6 +62,19 @@ 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 +``` + +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 @@ -58,14 +82,16 @@ scripts/interop/run.sh all` runs without downloads. This requires an existing peer cache or explicit binary overrides; Cargo's offline flag does not disable the peer download scripts. +See [SESSION_TIMERS.md](SESSION_TIMERS.md) for the opt-in timer API, failure +policy, and short regression coverage. + ## Coverage and expectations 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 this PR stack on upstream `895d443`; 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 @@ -83,8 +109,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. @@ -185,8 +211,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/SESSION_TIMERS.md b/tests/interop/SESSION_TIMERS.md new file mode 100644 index 00000000..c48d0e03 --- /dev/null +++ b/tests/interop/SESSION_TIMERS.md @@ -0,0 +1,84 @@ +# RFC 4028 session timers + +Session timers are opt-in on new INVITE dialogs. Existing dialogs and restored +snapshots are unaffected by a layer configuration change. + +```rust,ignore +use rsipstack::dialog::session_timer::SessionTimerConfig; +layer.set_session_timer(Some(SessionTimerConfig { + expires: 1800, + min_se: 90, + prefer_local: true, + ..Default::default() +}))?; +``` + +Use `None` to disable the feature for future dialogs. The default is disabled. +An enabled UAC advertises `Supported: timer`, `Session-Expires`, and `Min-SE`. +An enabled UAS validates those headers, selects a refresher, and answers an +unacceptably short interval with 422 and Min-SE. Both sides respect an explicit +refresher choice and track the agreement per dialog. An unsupported required +timer extension gets 420. Invalid or duplicate timer fields get 400. + +The absolute minimum is 90 seconds; tests do not negotiate substandard values +to run faster. 422 retries have a new branch and CSeq, preserve dialog routing +and SDP, and stop after three increasing challenges. Refresh requests preserve +the initial Supported, Require and Proxy-Require options. + +The local refresher sends at half the negotiated interval. Automatic mode uses +a bodyless UPDATE when the peer advertised UPDATE, otherwise an offered +re-INVITE with the last successfully exchanged local SDP. `RefreshMethod` +can select either method explicitly. An explicit UPDATE policy requires peer +support. Applications with externally managed SDP should provide `RefreshSdp` +to produce a current offer and consume the successful answer. Its futures must +be cancellation-safe. Incoming offers still go through normal dialog events; +only confirmed-dialog bodyless UPDATE refreshes are answered automatically. + +Only successful exchanges reset the timer, measured at received/transmitted +2xx, independently of ACK completion. Duplicate responses do not extend it. +A 2xx without Session-Expires disables the negotiated timer. 408, 481, +transaction/transport failure, or inability to generate a usable refresh ends +the dialog with BYE. Other final failures retain the original deadline; 491 +uses the RFC 3261 randomized glare retry window. The remote refresher gets the +RFC 4028 recommended expiration margin (the smaller of 32 seconds and one +third of the interval). BYE/removal stops the worker, including pending waits. +Applications must remove terminated dialogs from their registry as usual. + +`InviteDialog::session_timer_status()` exposes the last agreement, remaining +time, automatic refresh/expiration counts, and worker liveness for diagnostics. +An interval in a stopped worker is historical, not an active session. + +When dialog persistence is enabled, 422 retries retain the storage barrier and +receipt timestamps. Automatically answered bodyless UPDATE requests record a +pending negotiation before their response and commit the refreshed remote +target after completion. Storage failures prevent protected signaling from +continuing, as for other dialog operations. + +Timer agreements/deadlines are not persisted in `DialogSnapshot`. Restart +recovery must explicitly renegotiate or terminate according to application +policy. This change does not implement proxy timer policy or timer/media +coordination inside `ReinviteBridge`; that component retains its documented +extension restrictions. RTP liveness and billing duration are separate. + +## Verification + +```sh +cargo test --lib test_session_timer +bash scripts/interop/run.sh sipp session_timer +``` + +Library regressions use Tokio's controllable clock between real UDP exchanges. +They cover both refresher roles, unsupported peers, malformed headers, bounded +422 retries, UPDATE/re-INVITE, invalid successful agreements and ACK ordering, +glare, loss, changing deadlines, missing headers, and timer cancellation. +Eight independent SIPp exchanges cover UAC/UAS with UPDATE/re-INVITE over +UDP/TCP, including a UAC 422 retry and a UAS refresher change. These short wire +tests request explicit refreshes; real automatic refresh intervals belong to +the separate soak runner. + +Persistence regressions additionally cover delayed and failed storage for a +422 retry and a delayed automatic UPDATE response with a changed Contact: +`cargo test --lib persistence_`. + +Protocol reference: [RFC 4028](https://www.rfc-editor.org/rfc/rfc4028.html), +particularly sections 7, 9, and 10. 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/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() 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/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/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/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 ]]> - + + + - + + + - + + + + + + +Min-SE: 120 +Content-Length: [len] + + +]]> + + + + + + +Session-Expires: 120;refresher=uac +Require: timer +Allow: INVITE, UPDATE, BYE +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=inactive + +]]> + + + +Session-Expires: 180;refresher=uac +Require: timer +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=inactive + +]]> + + + +Content-Length: [len] + + +]]> + diff --git a/tests/interop/scenarios/session_uac_update.xml b/tests/interop/scenarios/session_uac_update.xml new file mode 100644 index 00000000..ad51d0ad --- /dev/null +++ b/tests/interop/scenarios/session_uac_update.xml @@ -0,0 +1,74 @@ + + + + +Min-SE: 120 +Content-Length: [len] + + +]]> + + + + + + +Session-Expires: 120;refresher=uac +Require: timer +Allow: INVITE, UPDATE, BYE +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=inactive + +]]> + + + +Session-Expires: 180;refresher=uac +Require: timer +Content-Length: [len] + + +]]> + + +Content-Length: [len] + + +]]> + diff --git a/tests/interop/scenarios/session_uas_invite.xml b/tests/interop/scenarios/session_uas_invite.xml new file mode 100644 index 00000000..a92b3bd9 --- /dev/null +++ b/tests/interop/scenarios/session_uas_invite.xml @@ -0,0 +1,103 @@ + + + ;tag=sipp-test +To: <[rsip_uri]> +Call-ID: [call_id] +CSeq: 1 INVITE +Max-Forwards: 70 +Contact: <[sipp_uri]> +Supported: timer +Session-Expires: 90;refresher=uac +Allow: UPDATE +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=inactive + +]]> + + + + + + +Content-Length: [len] + + +]]> + +Supported: timer +Session-Expires: 120;refresher=uas +Min-SE: 120 +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=inactive + +]]> + + + + + + +Content-Length: [len] + + +]]> + + + +Content-Length: [len] + + +]]> + + diff --git a/tests/interop/scenarios/session_uas_update.xml b/tests/interop/scenarios/session_uas_update.xml new file mode 100644 index 00000000..23bc6577 --- /dev/null +++ b/tests/interop/scenarios/session_uas_update.xml @@ -0,0 +1,82 @@ + + + ;tag=sipp-test +To: <[rsip_uri]> +Call-ID: [call_id] +CSeq: 1 INVITE +Max-Forwards: 70 +Contact: <[sipp_uri]> +Supported: timer +Session-Expires: 90;refresher=uac +Allow: UPDATE +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=inactive + +]]> + + + + + + +Content-Length: [len] + + +]]> + +Supported: timer +Session-Expires: 120;refresher=uas +Min-SE: 120 +Content-Length: [len] + + +]]> + + + + + + + + +Content-Length: [len] + + +]]> + + diff --git a/tests/interop/sipp.rs b/tests/interop/sipp.rs index e0bc6606..6ebbff3e 100644 --- a/tests/interop/sipp.rs +++ b/tests/interop/sipp.rs @@ -10,10 +10,13 @@ use std::{ process::Stdio, }; use tokio::process::{Child, Command}; +mod bridge; mod extended; mod faults; +mod prack_sdp; mod prack_uas; mod registration; +mod session_timer; mod subscription; pub(super) struct Sipp { @@ -66,18 +69,24 @@ 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" + | "prack_uas_retransmit" ) { vec!["-nr"] } else { vec![] }; let child = Command::new(binary) - .args(if scenario.starts_with("prack_uas") { - vec![local_uri.host_with_port.to_string()] - } else { - vec![] - }) + .args( + if scenario.starts_with("prack_uas") || scenario.starts_with("session_uas") { + vec![local_uri.host_with_port.to_string()] + } else { + vec![] + }, + ) .args(duplicate_flags) .current_dir(dir) .arg("-sf") @@ -162,7 +171,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, 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 + } +} diff --git a/tests/interop/sipp/extended.rs b/tests/interop/sipp/extended.rs index 8db83b89..3bbb5263 100644 --- a/tests/interop/sipp/extended.rs +++ b/tests/interop/sipp/extended.rs @@ -108,6 +108,9 @@ fn assert_alive(stack: &Stack) -> 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#" + + + + + + + + +