From 71dfc26076f0a828959f18be7412000c37c967eb Mon Sep 17 00:00:00 2001 From: Joshua Smotritsky Date: Tue, 17 Nov 2026 19:13:11 -0500 Subject: [PATCH 1/3] fix(dialog): send CANCEL to the INVITE's destination MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A UAC INVITE sent to an explicit InviteOption::destination was cancelled to wherever the Request-URI resolved. RFC 3261 §9.1 requires the CANCEL to use the INVITE's destination address, port and transport. The dialog now keeps that destination and uses it for CANCEL. Fixes #260 --- src/dialog/dialog.rs | 9 + src/dialog/invitation.rs | 1 + src/dialog/tests/mod.rs | 1 + src/dialog/tests/test_cancel_destination.rs | 179 ++++++++++++++++++++ 4 files changed, 190 insertions(+) create mode 100644 src/dialog/tests/test_cancel_destination.rs diff --git a/src/dialog/dialog.rs b/src/dialog/dialog.rs index b2ac3a5b..de74ebe0 100644 --- a/src/dialog/dialog.rs +++ b/src/dialog/dialog.rs @@ -360,6 +360,10 @@ pub struct DialogInner { /// connection is unavailable: immune to missing received/rport params and /// valid even after the socket object died. pub(super) dialback_target: Mutex>, + /// Where a UAC dialog's initial INVITE was sent. Its CANCEL must go to + /// the same address, port and transport (RFC 3261 §9.1), whatever the + /// Request-URI resolves to. + pub(super) invite_destination: Mutex>, /// `cancel()` was called on this UAC dialog's INVITE. pub(super) cancel_requested: AtomicBool, /// That CANCEL waits for a provisional response (RFC 3261 §9.1). @@ -550,6 +554,7 @@ impl DialogInner { remote_ack: Mutex::new(None), server_connection: Mutex::new(None), dialback_target: Mutex::new(None), + invite_destination: Mutex::new(None), cancel_requested: AtomicBool::new(false), cancel_deferred: AtomicBool::new(false), initial_ack: Mutex::new(None), @@ -1278,6 +1283,9 @@ impl DialogInner { tx.force_success_ack = options.is_some() && !tx.defer_success_ack; self.reserve_invite(&tx)?; + if method == Method::Cancel { + tx.destination = self.invite_destination.lock().clone(); + } tx.dialog_route_set = Some(self.route_set.lock().clone()); let need_fallback_retry; let mut send_error = None; @@ -1872,6 +1880,7 @@ impl DialogInner { remote_ack: Mutex::new(None), server_connection: Mutex::new(None), dialback_target: Mutex::new(None), + invite_destination: Mutex::new(None), cancel_requested: AtomicBool::new(false), cancel_deferred: AtomicBool::new(false), initial_ack: Mutex::new(None), diff --git a/src/dialog/invitation.rs b/src/dialog/invitation.rs index fd350b4b..6ea1b0b8 100644 --- a/src/dialog/invitation.rs +++ b/src/dialog/invitation.rs @@ -899,6 +899,7 @@ impl DialogLayer { let uri = destination.clone().into(); *dlg_inner.remote_uri.lock() = uri; } + *dlg_inner.invite_destination.lock() = tx.destination.clone(); let dialog = InviteDialog::from_inner(Arc::new(dlg_inner)); dialog.inner.lifecycle.lock().sender = self.inner.lifecycle_sender.lock().clone(); dialog.inner.reserve_invite(&tx)?; diff --git a/src/dialog/tests/mod.rs b/src/dialog/tests/mod.rs index f30db8a0..1cf7ba86 100644 --- a/src/dialog/tests/mod.rs +++ b/src/dialog/tests/mod.rs @@ -3,6 +3,7 @@ mod test_ack_answer; mod test_authenticate; mod test_bye_during_ack; mod test_cancel_2xx_race; +mod test_cancel_destination; mod test_client_dialog; mod test_connection_affinity; mod test_cseq_concurrency; diff --git a/src/dialog/tests/test_cancel_destination.rs b/src/dialog/tests/test_cancel_destination.rs new file mode 100644 index 00000000..b0d813ce --- /dev/null +++ b/src/dialog/tests/test_cancel_destination.rs @@ -0,0 +1,179 @@ +//! A UAC dialog whose INVITE went to an explicit `InviteOption::destination` +//! (an outbound proxy or trunk next hop) must send its CANCEL to that same +//! address, port and transport (RFC 3261 §9.1), not to wherever the +//! Request-URI resolves. Here the Request-URI host does not resolve at all, +//! so a CANCEL that follows it never arrives. +use crate::dialog::{dialog::DialogState, dialog_layer::DialogLayer, invitation::InviteOption}; +use crate::sip::{prelude::HeadersExt, Method, Request, SipMessage, Uri}; +use crate::transport::{udp::UdpConnection, SipAddr, TransportLayer}; +use crate::EndpointBuilder; +use std::net::SocketAddr; +use std::sync::Arc; +use std::time::Duration; +use tokio::net::UdpSocket; +use tokio::sync::mpsc::unbounded_channel; +use tokio_util::sync::CancellationToken; + +const PEER_TAG: &str = "peer-tag"; + +/// Receive the next request with `method` on the raw peer socket within +/// `wait`, skipping anything else. +async fn recv_request(socket: &UdpSocket, method: Method, wait: Duration) -> (Request, SocketAddr) { + let mut buf = vec![0u8; 4096]; + let deadline = tokio::time::Instant::now() + wait; + loop { + let (len, from) = tokio::time::timeout_at(deadline, socket.recv_from(&mut buf)) + .await + .unwrap_or_else(|_| panic!("timeout waiting for {method}")) + .expect("recv_from failed"); + let text = std::str::from_utf8(&buf[..len]).expect("non utf-8 SIP message"); + if let Ok(SipMessage::Request(req)) = SipMessage::try_from(text) { + if req.method == method { + return (req, from); + } + } + } +} + +/// Build a response to `req` as the peer UA, adding the peer's To tag. +fn response(req: &Request, code: u16, reason: &str, contact: &str) -> String { + let to = req.to_header().unwrap().value().to_string(); + let to = if to.contains(";tag=") { + to + } else { + format!("{to};tag={PEER_TAG}") + }; + format!( + "SIP/2.0 {code} {reason}\r\n\ + Via: {}\r\n\ + From: {}\r\n\ + To: {to}\r\n\ + Call-ID: {}\r\n\ + CSeq: {}\r\n\ + Contact: <{contact}>\r\n\ + Content-Length: 0\r\n\r\n", + req.via_header().unwrap().value(), + req.from_header().unwrap().value(), + req.call_id_header().unwrap().value(), + req.cseq_header().unwrap().value(), + ) +} + +async fn reply(socket: &UdpSocket, to: SocketAddr, req: &Request, code: u16, reason: &str) { + let contact = format!("sip:bob@{}", socket.local_addr().unwrap()); + socket + .send_to(response(req, code, reason, &contact).as_bytes(), to) + .await + .expect("send_to failed"); +} + +/// A UAC whose INVITE names an unresolvable Request-URI host and goes to the +/// raw `peer` socket as its explicit next hop. +async fn setup( + token: &CancellationToken, +) -> crate::Result<(Arc, InviteOption, UdpSocket)> { + let peer = UdpSocket::bind("127.0.0.1:0").await?; + let transport_layer = 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_addr = udp.get_addr().addr.clone(); + transport_layer.add_transport(udp.into()); + let endpoint = EndpointBuilder::new() + .with_user_agent("rsipstack-test") + .with_transport_layer(transport_layer) + .with_cancel_token(token.child_token()) + .build(); + let endpoint_inner = endpoint.inner.clone(); + tokio::spawn(async move { + let _ = endpoint_inner.serve().await; + }); + let option = InviteOption { + caller: Uri::try_from("sip:alice@example.com")?, + callee: Uri::try_from("sip:+15551234567@carrier.invalid")?, + contact: Uri::try_from(format!("sip:alice@{uac_addr}").as_str())?, + destination: Some(SipAddr::from(peer.local_addr()?)), + ..Default::default() + }; + Ok(( + Arc::new(DialogLayer::new(endpoint.inner.clone())), + option, + peer, + )) +} + +/// Sends the INVITE, answers it with 180 from the peer and waits for Early. +async fn ringing( + token: &CancellationToken, +) -> crate::Result<( + Arc, + UdpSocket, + Request, + tokio::task::JoinHandle<()>, +)> { + let (dialog_layer, option, peer) = setup(token).await?; + let wait = Duration::from_secs(2); + let (state_sender, mut states) = unbounded_channel(); + let layer = dialog_layer.clone(); + let invite = tokio::spawn(async move { + let _ = layer.do_invite(option, state_sender).await; + }); + let (inv, uac) = recv_request(&peer, Method::Invite, wait).await; + assert_eq!(inv.uri.to_string(), "sip:+15551234567@carrier.invalid"); + reply(&peer, uac, &inv, 180, "Ringing").await; + tokio::time::timeout(wait, async { + while let Some(state) = states.recv().await { + if matches!(state, DialogState::Early(_, _)) { + return; + } + } + }) + .await + .expect("no Early state"); + Ok((dialog_layer, peer, inv, invite)) +} + +fn assert_cancels(cancel: &Request, invite: &Request) { + assert_eq!(cancel.uri, invite.uri); + assert_eq!( + cancel.call_id_header().unwrap().value(), + invite.call_id_header().unwrap().value() + ); + assert_eq!( + cancel.via_header().unwrap().value(), + invite.via_header().unwrap().value() + ); +} + +#[tokio::test] +async fn test_explicit_cancel_goes_to_the_invite_destination() -> crate::Result<()> { + let token = CancellationToken::new(); + let (dialog_layer, peer, inv, invite) = ringing(&token).await?; + let call_id = inv.call_id_header()?.value().to_string(); + let dialogs = dialog_layer.get_client_dialog_by_call_id(&call_id); + assert_eq!(dialogs.len(), 1); + let dialog = dialogs[0].clone(); + let cancelling = tokio::spawn(async move { dialog.cancel().await }); + let (cancel, uac) = recv_request(&peer, Method::Cancel, Duration::from_secs(2)).await; + assert_cancels(&cancel, &inv); + reply(&peer, uac, &cancel, 200, "OK").await; + cancelling.await.expect("cancel task")?; + invite.abort(); + token.cancel(); + Ok(()) +} + +#[tokio::test] +async fn test_dropped_invite_cancel_goes_to_the_invite_destination() -> crate::Result<()> { + let token = CancellationToken::new(); + let (_dialog_layer, peer, inv, invite) = ringing(&token).await?; + invite.abort(); + let _ = invite.await; + let (cancel, _) = recv_request(&peer, Method::Cancel, Duration::from_secs(2)).await; + assert_cancels(&cancel, &inv); + token.cancel(); + Ok(()) +} From 30fe23916f55240faa68ccab1b716acd0931b131 Mon Sep 17 00:00:00 2001 From: yeoleobun Date: Wed, 18 Nov 2026 11:12:06 +0800 Subject: [PATCH 2/3] Preserve the live peer address for CANCEL --- src/dialog/dialog.rs | 3 +- src/dialog/tests/test_cancel_destination.rs | 34 ++- tests/cancel_connection.rs | 266 ++++++++++++++++++++ 3 files changed, 298 insertions(+), 5 deletions(-) create mode 100644 tests/cancel_connection.rs diff --git a/src/dialog/dialog.rs b/src/dialog/dialog.rs index de74ebe0..0353a835 100644 --- a/src/dialog/dialog.rs +++ b/src/dialog/dialog.rs @@ -1283,7 +1283,8 @@ impl DialogInner { tx.force_success_ack = options.is_some() && !tx.defer_success_ack; self.reserve_invite(&tx)?; - if method == Method::Cancel { + // A live flow supplies its actual peer address to before_send. + if method == Method::Cancel && tx.connection.is_none() { tx.destination = self.invite_destination.lock().clone(); } tx.dialog_route_set = Some(self.route_set.lock().clone()); diff --git a/src/dialog/tests/test_cancel_destination.rs b/src/dialog/tests/test_cancel_destination.rs index b0d813ce..2f1429a9 100644 --- a/src/dialog/tests/test_cancel_destination.rs +++ b/src/dialog/tests/test_cancel_destination.rs @@ -4,7 +4,7 @@ //! Request-URI resolves. Here the Request-URI host does not resolve at all, //! so a CANCEL that follows it never arrives. use crate::dialog::{dialog::DialogState, dialog_layer::DialogLayer, invitation::InviteOption}; -use crate::sip::{prelude::HeadersExt, Method, Request, SipMessage, Uri}; +use crate::sip::{prelude::HeadersExt, typed::Route, Method, Request, SipMessage, Uri}; use crate::transport::{udp::UdpConnection, SipAddr, TransportLayer}; use crate::EndpointBuilder; use std::net::SocketAddr; @@ -108,13 +108,19 @@ async fn setup( /// Sends the INVITE, answers it with 180 from the peer and waits for Early. async fn ringing( token: &CancellationToken, + preloaded_route: bool, ) -> crate::Result<( Arc, UdpSocket, Request, tokio::task::JoinHandle<()>, )> { - let (dialog_layer, option, peer) = setup(token).await?; + let (dialog_layer, mut option, peer) = setup(token).await?; + if preloaded_route { + option.destination = None; + let route = Route::parse(&format!("", peer.local_addr()?))?; + option.route_set.push(route); + } let wait = Duration::from_secs(2); let (state_sender, mut states) = unbounded_channel(); let layer = dialog_layer.clone(); @@ -123,6 +129,7 @@ async fn ringing( }); let (inv, uac) = recv_request(&peer, Method::Invite, wait).await; assert_eq!(inv.uri.to_string(), "sip:+15551234567@carrier.invalid"); + assert_eq!(inv.route_header().is_some(), preloaded_route); reply(&peer, uac, &inv, 180, "Ringing").await; tokio::time::timeout(wait, async { while let Some(state) = states.recv().await { @@ -138,6 +145,7 @@ async fn ringing( fn assert_cancels(cancel: &Request, invite: &Request) { assert_eq!(cancel.uri, invite.uri); + assert_eq!(cancel.route_header(), invite.route_header()); assert_eq!( cancel.call_id_header().unwrap().value(), invite.call_id_header().unwrap().value() @@ -151,7 +159,7 @@ fn assert_cancels(cancel: &Request, invite: &Request) { #[tokio::test] async fn test_explicit_cancel_goes_to_the_invite_destination() -> crate::Result<()> { let token = CancellationToken::new(); - let (dialog_layer, peer, inv, invite) = ringing(&token).await?; + let (dialog_layer, peer, inv, invite) = ringing(&token, false).await?; let call_id = inv.call_id_header()?.value().to_string(); let dialogs = dialog_layer.get_client_dialog_by_call_id(&call_id); assert_eq!(dialogs.len(), 1); @@ -169,7 +177,7 @@ async fn test_explicit_cancel_goes_to_the_invite_destination() -> crate::Result< #[tokio::test] async fn test_dropped_invite_cancel_goes_to_the_invite_destination() -> crate::Result<()> { let token = CancellationToken::new(); - let (_dialog_layer, peer, inv, invite) = ringing(&token).await?; + let (_dialog_layer, peer, inv, invite) = ringing(&token, false).await?; invite.abort(); let _ = invite.await; let (cancel, _) = recv_request(&peer, Method::Cancel, Duration::from_secs(2)).await; @@ -177,3 +185,21 @@ async fn test_dropped_invite_cancel_goes_to_the_invite_destination() -> crate::R token.cancel(); Ok(()) } + +#[tokio::test] +async fn test_cancel_goes_to_the_preloaded_route() -> crate::Result<()> { + let token = CancellationToken::new(); + let (dialog_layer, peer, inv, invite) = ringing(&token, true).await?; + let dialog = dialog_layer + .get_client_dialog_by_call_id(inv.call_id_header()?.value()) + .pop() + .expect("early client dialog"); + let cancelling = tokio::spawn(async move { dialog.cancel().await }); + let (cancel, uac) = recv_request(&peer, Method::Cancel, Duration::from_secs(2)).await; + assert_cancels(&cancel, &inv); + reply(&peer, uac, &cancel, 200, "OK").await; + cancelling.await.expect("cancel task")?; + invite.abort(); + token.cancel(); + Ok(()) +} diff --git a/tests/cancel_connection.rs b/tests/cancel_connection.rs new file mode 100644 index 00000000..a587b62d --- /dev/null +++ b/tests/cancel_connection.rs @@ -0,0 +1,266 @@ +#![cfg(feature = "platform-tokio")] + +use rsipstack::{ + dialog::{ + dialog::{DialogState, DialogStateReceiver}, + dialog_layer::DialogLayer, + invitation::InviteOption, + }, + sip::{HeadersExt, Method, Request, SipMessage, Transport}, + transaction::endpoint::{Endpoint, MessageInspector}, + transport::{ + channel::ChannelConnection, udp::UdpConnection, SipAddr, SipConnection, TransportEvent, + TransportLayer, + }, + EndpointBuilder, +}; +use std::{ + net::SocketAddr, + sync::{Arc, Mutex}, + time::Duration, +}; +use tokio::{ + io::{AsyncBufRead, AsyncBufReadExt, AsyncWriteExt, BufReader}, + net::{TcpListener, UdpSocket}, + sync::mpsc, + time::timeout, +}; +use tokio_util::sync::CancellationToken; + +type Result = std::result::Result>; +const WAIT: Duration = Duration::from_secs(3); + +#[derive(Clone, Default)] +struct RecordedDestinations(Arc)>>>); + +impl MessageInspector for RecordedDestinations { + fn before_send(&self, msg: SipMessage, destination: Option<&SipAddr>) -> SipMessage { + if let SipMessage::Request(request) = &msg { + if matches!(request.method, Method::Invite | Method::Cancel) { + self.0 + .lock() + .unwrap() + .push((request.method.clone(), destination.cloned())); + } + } + msg + } + + fn after_received(&self, msg: SipMessage, _from: Option<&SipAddr>) -> SipMessage { + msg + } +} + +async fn endpoint( + stop: &CancellationToken, + outbound: Option, + inspector: Option, +) -> Result> { + let mut transport = TransportLayer::new(stop.child_token()); + transport.outbound = outbound; + let socket = UdpSocket::bind("127.0.0.1:0").await?; + let local = UdpConnection::from_socket(Arc::new(socket), None, Some(stop.child_token())).await?; + transport.add_transport(SipConnection::Udp(local)); + let mut builder = EndpointBuilder::new(); + builder + .with_transport_layer(transport) + .with_cancel_token(stop.child_token()); + if let Some(inspector) = inspector { + builder.with_inspector(Box::new(inspector)); + } + let endpoint = Arc::new(builder.build()); + let serving = endpoint.clone(); + tokio::spawn(async move { serving.serve().await }); + Ok(endpoint) +} + +fn invite_options(destination: SipAddr) -> Result { + Ok(InviteOption { + caller: "sip:alice@example.com".try_into()?, + callee: "sip:bob@carrier.invalid".try_into()?, + contact: "sip:alice@127.0.0.1".try_into()?, + destination: Some(destination), + ..Default::default() + }) +} + +async fn wait_for_early(states: &mut DialogStateReceiver) -> Result { + timeout(WAIT, async { + while let Some(state) = states.recv().await { + if matches!(state, DialogState::Early(..)) { + return Ok(()); + } + } + Err("state channel closed before Early") + }) + .await??; + Ok(()) +} + +fn response(request: &Request, status: &str) -> Result { + Ok(format!( + "SIP/2.0 {status}\r\n\ + Via: {}\r\n\ + From: {}\r\n\ + To: {};tag=peer\r\n\ + Call-ID: {}\r\n\ + CSeq: {}\r\n\ + Contact: \r\n\ + Content-Length: 0\r\n\r\n", + request.via_header()?.value(), + request.from_header()?.value(), + request.to_header()?.value(), + request.call_id_header()?.value(), + request.cseq_header()?.value(), + )) +} + +fn assert_cancel(invite: &Request, cancel: &Request) -> Result { + assert_eq!(invite.method, Method::Invite); + assert_eq!(cancel.method, Method::Cancel); + assert_eq!(cancel.uri, invite.uri); + assert_eq!(cancel.call_id_header()?, invite.call_id_header()?); + assert_eq!(cancel.via_header()?, invite.via_header()?); + assert_eq!(cancel.cseq_header()?.seq()?, invite.cseq_header()?.seq()?); + Ok(()) +} + +async fn read_tcp_request(reader: &mut (impl AsyncBufRead + Unpin)) -> Result { + timeout(WAIT, async { + let mut wire = Vec::new(); + loop { + let start = wire.len(); + if reader.read_until(b'\n', &mut wire).await? == 0 { + return Err("TCP connection closed before SIP request".into()); + } + if &wire[start..] == b"\r\n" { + // The INVITE and CANCEL in this test have empty bodies. + return Ok(SipMessage::try_from(wire.as_slice())?.try_into()?); + } + } + }) + .await? +} + +#[tokio::test] +async fn tcp_cancel_reuses_the_exact_invite_stream() -> Result { + let stop = CancellationToken::new(); + let _stop = stop.clone().drop_guard(); + let endpoint = endpoint(&stop, None, None).await?; + let peer = TcpListener::bind("127.0.0.1:0").await?; + let destination = SipAddr::new(Transport::Tcp, peer.local_addr()?.into()); + let layer = Arc::new(DialogLayer::new(endpoint.inner.clone())); + let (sender, mut states) = mpsc::unbounded_channel(); + let (dialog, invite_task) = layer.do_invite_async(invite_options(destination)?, sender)?; + + let (stream, _) = timeout(WAIT, peer.accept()).await??; + let (read_half, mut write_half) = stream.into_split(); + let mut reader = BufReader::new(read_half); + let invite = read_tcp_request(&mut reader).await?; + write_half + .write_all(response(&invite, "180 Ringing")?.as_bytes()) + .await?; + wait_for_early(&mut states).await?; + + let cancel_task = tokio::spawn(async move { dialog.cancel().await }); + let cancel = read_tcp_request(&mut reader).await?; + assert_cancel(&invite, &cancel)?; + write_half + .write_all(response(&cancel, "200 OK")?.as_bytes()) + .await?; + write_half + .write_all(response(&invite, "487 Request Terminated")?.as_bytes()) + .await?; + assert_eq!(read_tcp_request(&mut reader).await?.method, Method::Ack); + timeout(WAIT, cancel_task).await???; + let (_, final_response) = timeout(WAIT, invite_task).await???; + assert_eq!(final_response.unwrap().status_code.code(), 487); + Ok(()) +} + +async fn read_channel_request( + receiver: &mut mpsc::UnboundedReceiver, +) -> Result { + let event = timeout(WAIT, receiver.recv()) + .await? + .ok_or("Channel closed before SIP request")?; + match event { + TransportEvent::Incoming(SipMessage::Request(request), _, _) => Ok(request), + _ => Err("expected an outgoing request on the Channel".into()), + } +} + +#[tokio::test] +async fn channel_cancel_reuses_the_exact_invite_flow_and_reports_its_peer() -> Result { + let stop = CancellationToken::new(); + let _stop = stop.clone().drop_guard(); + let peer: SocketAddr = "127.0.0.1:42190".parse()?; + let configured: SocketAddr = "127.0.0.1:42191".parse()?; + let peer = SipAddr::new(Transport::Ws, peer.into()); + let configured = SipAddr::new(Transport::Ws, configured.into()); + let destinations = RecordedDestinations::default(); + let endpoint = endpoint(&stop, Some(peer.clone()), Some(destinations.clone())).await?; + + let (to_stack, incoming) = mpsc::unbounded_channel(); + let (outgoing, mut from_stack) = mpsc::unbounded_channel(); + let connection = SipConnection::Channel( + ChannelConnection::create_connection( + incoming, + outgoing, + peer.clone(), + Some(stop.child_token()), + ) + .await?, + ); + endpoint.inner.transport_layer.add_connection(connection.clone()); + let layer = Arc::new(DialogLayer::new(endpoint.inner.clone())); + let (sender, mut states) = mpsc::unbounded_channel(); + let (dialog, invite_task) = layer.do_invite_async(invite_options(configured)?, sender)?; + + let invite = read_channel_request(&mut from_stack).await?; + let ringing = response(&invite, "180 Ringing")?; + to_stack.send(TransportEvent::Incoming( + SipMessage::try_from(ringing.as_str())?, + connection.clone(), + peer.clone(), + ))?; + wait_for_early(&mut states).await?; + + // A fresh lookup at the same address now selects a different Channel. + let (_replacement_sender, replacement_incoming) = mpsc::unbounded_channel(); + let (replacement_outgoing, mut replacement_receiver) = mpsc::unbounded_channel(); + let replacement = SipConnection::Channel( + ChannelConnection::create_connection( + replacement_incoming, + replacement_outgoing, + peer.clone(), + Some(stop.child_token()), + ) + .await?, + ); + endpoint.inner.transport_layer.add_connection(replacement); + + let cancel_task = tokio::spawn(async move { dialog.cancel().await }); + let cancel = read_channel_request(&mut from_stack).await?; + assert_cancel(&invite, &cancel)?; + assert!(replacement_receiver.try_recv().is_err()); + for message in [ + response(&cancel, "200 OK")?, + response(&invite, "487 Request Terminated")?, + ] { + to_stack.send(TransportEvent::Incoming( + SipMessage::try_from(message.as_str())?, + connection.clone(), + peer.clone(), + ))?; + } + assert_eq!(read_channel_request(&mut from_stack).await?.method, Method::Ack); + timeout(WAIT, cancel_task).await???; + let (_, final_response) = timeout(WAIT, invite_task).await???; + assert_eq!(final_response.unwrap().status_code.code(), 487); + assert_eq!( + *destinations.0.lock().unwrap(), + [(Method::Invite, Some(peer.clone())), (Method::Cancel, Some(peer))], + ); + Ok(()) +} From a84b322c97e1ec17d0476b5f167a7e90aabbe315 Mon Sep 17 00:00:00 2001 From: yeoleobun Date: Wed, 18 Nov 2026 11:14:01 +0800 Subject: [PATCH 3/3] Match CI formatting in CANCEL regression tests --- tests/cancel_connection.rs | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/tests/cancel_connection.rs b/tests/cancel_connection.rs index a587b62d..b6fbc258 100644 --- a/tests/cancel_connection.rs +++ b/tests/cancel_connection.rs @@ -59,7 +59,8 @@ async fn endpoint( let mut transport = TransportLayer::new(stop.child_token()); transport.outbound = outbound; let socket = UdpSocket::bind("127.0.0.1:0").await?; - let local = UdpConnection::from_socket(Arc::new(socket), None, Some(stop.child_token())).await?; + let local = + UdpConnection::from_socket(Arc::new(socket), None, Some(stop.child_token())).await?; transport.add_transport(SipConnection::Udp(local)); let mut builder = EndpointBuilder::new(); builder @@ -212,7 +213,10 @@ async fn channel_cancel_reuses_the_exact_invite_flow_and_reports_its_peer() -> R ) .await?, ); - endpoint.inner.transport_layer.add_connection(connection.clone()); + endpoint + .inner + .transport_layer + .add_connection(connection.clone()); let layer = Arc::new(DialogLayer::new(endpoint.inner.clone())); let (sender, mut states) = mpsc::unbounded_channel(); let (dialog, invite_task) = layer.do_invite_async(invite_options(configured)?, sender)?; @@ -254,13 +258,19 @@ async fn channel_cancel_reuses_the_exact_invite_flow_and_reports_its_peer() -> R peer.clone(), ))?; } - assert_eq!(read_channel_request(&mut from_stack).await?.method, Method::Ack); + assert_eq!( + read_channel_request(&mut from_stack).await?.method, + Method::Ack + ); timeout(WAIT, cancel_task).await???; let (_, final_response) = timeout(WAIT, invite_task).await???; assert_eq!(final_response.unwrap().status_code.code(), 487); assert_eq!( *destinations.0.lock().unwrap(), - [(Method::Invite, Some(peer.clone())), (Method::Cancel, Some(peer))], + [ + (Method::Invite, Some(peer.clone())), + (Method::Cancel, Some(peer)) + ], ); Ok(()) }