diff --git a/src/dialog/dialog.rs b/src/dialog/dialog.rs index b2ac3a5b..0353a835 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,10 @@ impl DialogInner { tx.force_success_ack = options.is_some() && !tx.defer_success_ack; self.reserve_invite(&tx)?; + // 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()); let need_fallback_retry; let mut send_error = None; @@ -1872,6 +1881,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..2f1429a9 --- /dev/null +++ b/src/dialog/tests/test_cancel_destination.rs @@ -0,0 +1,205 @@ +//! 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, typed::Route, 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, + preloaded_route: bool, +) -> crate::Result<( + Arc, + UdpSocket, + Request, + tokio::task::JoinHandle<()>, +)> { + 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(); + 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"); + 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 { + 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.route_header(), invite.route_header()); + 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, 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); + 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, false).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(()) +} + +#[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..b6fbc258 --- /dev/null +++ b/tests/cancel_connection.rs @@ -0,0 +1,276 @@ +#![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(()) +}