use super::test_dialog_states::create_invite_request;
use crate::dialog::{
dialog::{DialogInner, DialogState, TransactionHandle},
invite_dialog::InviteDialog,
DialogId,
};
use crate::sip::{Header, HeadersExt, Method, Request, SipMessage, StatusCode};
use crate::transaction::{
key::{TransactionKey, TransactionRole},
transaction::{Transaction, TransactionEvent},
TransactionState, TransactionTimer,
};
use crate::transport::{channel::ChannelConnection, SipAddr, SipConnection, TransportEvent};
use crate::EndpointBuilder;
use futures::FutureExt;
use std::sync::Arc;
use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};
struct Fixture {
dialog: InviteDialog,
states: UnboundedReceiver<DialogState>,
conn: SipConnection,
wire: UnboundedReceiver<TransportEvent>,
}
impl Fixture {
async fn new(role: TransactionRole) -> Self {
let endpoint = EndpointBuilder::new().build();
let (_, incoming) = unbounded_channel();
let (outgoing, wire) = unbounded_channel();
let addr: SipAddr = "127.0.0.1:5060"
.parse::<std::net::SocketAddr>()
.unwrap()
.into();
let conn: SipConnection =
ChannelConnection::create_connection(incoming, outgoing, addr, None)
.await
.unwrap()
.into();
endpoint.inner.transport_layer.add_transport(conn.clone());
let (sender, states) = unbounded_channel();
let (tu, _) = unbounded_channel();
let id = DialogId {
call_id: "overlap".into(),
local_tag: if role == TransactionRole::Server {
"bob"
} else {
"alice"
}
.into(),
remote_tag: if role == TransactionRole::Server {
"alice"
} else {
"bob"
}
.into(),
};
let inner = Arc::new(
DialogInner::new(
role,
id.clone(),
request(Method::Invite, 1),
endpoint.inner,
sender,
None,
Some("sip:bob@127.0.0.1:5060".try_into().unwrap()),
tu,
)
.unwrap(),
);
inner.set_remote_target("sip:peer@127.0.0.1:5060".try_into().unwrap(), None);
inner.set_server_connection(Some(conn.clone()));
*inner.state.lock() = DialogState::Confirmed(id, Default::default());
Self {
dialog: InviteDialog::from_inner(inner),
states,
conn,
wire,
}
}
fn transaction(&self, method: Method, cseq: u32) -> Transaction {
let mut req = request(method, cseq);
if self.dialog.role() == TransactionRole::Client {
req.headers
.unique_push(Header::From("<sip:bob@example.com>;tag=bob".into()));
req.headers
.unique_push(Header::To("<sip:alice@example.com>;tag=alice".into()));
}
Transaction::new_server(
TransactionKey::from_request(&req, TransactionRole::Server).unwrap(),
req,
self.dialog.inner.endpoint_inner.clone(),
Some(self.conn.clone()),
)
}
fn update_handle(&mut self) -> TransactionHandle {
loop {
match self.states.try_recv().unwrap() {
DialogState::Updated(_, _, handle) => return handle,
DialogState::Confirmed(_, _) => (),
state => panic!("unexpected state: {state}"),
}
}
}
fn next_request(&mut self, method: Method) -> Request {
while let Ok(event) = self.wire.try_recv() {
if let TransportEvent::Incoming(SipMessage::Request(req), _, _) = event {
if req.method == method {
return req;
}
}
}
panic!("no outgoing {method}");
}
fn respond(&self, req: &Request, status: StatusCode, headers: Vec<Header>) {
let mut response = self
.dialog
.inner
.endpoint_inner
.make_response(req, status, None);
for header in headers {
response.headers.unique_push(header);
}
let key = TransactionKey::from_request(req, TransactionRole::Client).unwrap();
self.dialog
.inner
.endpoint_inner
.transactions
.get(&key)
.unwrap()
.send(TransactionEvent::Received(
response.into(),
Some(self.conn.clone()),
))
.unwrap();
}
fn assert_local_blocked(&self) {
assert!(matches!(
self.dialog.reinvite(None, None).now_or_never(),
Some(Err(crate::Error::DialogError(
_,
_,
StatusCode::RequestPending
)))
));
}
fn assert_local_can_start(&mut self) {
assert!(self.dialog.reinvite(None, None).now_or_never().is_none());
self.next_request(Method::Invite);
}
}
fn request(method: Method, cseq: u32) -> Request {
let mut req = create_invite_request("alice", "bob", "overlap");
req.uri = "sip:bob@127.0.0.1:5060".try_into().unwrap();
req.headers
.unique_push(Header::Contact("<sip:peer@127.0.0.1:5060>".into()));
req.headers.unique_push(Header::Via(
format!("SIP/2.0/UDP 127.0.0.1:5060;branch=z9hG4bK-{cseq}-{method}").into(),
));
req.headers
.unique_push(Header::CSeq(format!("{cseq} {method}").into()));
req.method = method;
req
}
#[tokio::test]
async fn second_incoming_invite_is_rejected_before_application_dispatch() {
for role in [TransactionRole::Client, TransactionRole::Server] {
let mut f = Fixture::new(role).await;
let mut first = f.transaction(Method::Invite, 10);
let mut dialog = f.dialog.clone();
let mut handling = Box::pin(dialog.handle(&mut first));
assert!(handling.as_mut().now_or_never().is_none());
let _handle = f.update_handle();
let mut second = f.transaction(Method::Invite, 11);
let outcome = f.dialog.clone().handle(&mut second).now_or_never();
assert!(
matches!(outcome, Some(Ok(()))),
"overlap reached application instead of being rejected"
);
let response = second.last_response.as_ref().unwrap();
assert_eq!(response.status_code, StatusCode::ServerInternalError);
let retry = response
.headers
.iter()
.find_map(|header| match header {
Header::RetryAfter(value) => Some(value.value().parse::<u32>().unwrap()),
_ => None,
})
.expect("500 must carry Retry-After");
assert!(retry <= 10);
assert!(f.states.try_recv().is_err());
}
}
#[tokio::test]
async fn outgoing_invite_blocks_both_outgoing_entry_points_and_incoming_glare() {
for role in [TransactionRole::Client, TransactionRole::Server] {
let mut f = Fixture::new(role).await;
let dialog = f.dialog.clone();
let mut first = Box::pin(dialog.reinvite(None, None));
assert!(first.as_mut().now_or_never().is_none());
assert!(f.wire.try_recv().is_ok(), "first INVITE was not sent");
for generic in [false, true] {
let result = if generic {
f.dialog.request(Method::Invite, None, None).now_or_never()
} else {
f.dialog.reinvite(None, None).now_or_never()
};
assert!(matches!(
result,
Some(Err(crate::Error::DialogError(
_,
_,
StatusCode::RequestPending
)))
));
}
let mut incoming = f.transaction(Method::Invite, 10);
f.dialog
.clone()
.handle(&mut incoming)
.now_or_never()
.unwrap()
.unwrap();
assert_eq!(
incoming.last_response.as_ref().unwrap().status_code,
StatusCode::RequestPending
);
assert!(f.states.try_recv().is_err());
}
}
#[tokio::test]
async fn cancelling_handler_future_keeps_reservation_until_transaction_drop() {
let mut f = Fixture::new(TransactionRole::Server).await;
let mut tx = f.transaction(Method::Invite, 10);
assert!(f.dialog.clone().handle(&mut tx).now_or_never().is_none());
let _handle = f.update_handle();
f.assert_local_blocked();
drop(tx);
f.assert_local_can_start();
f.assert_local_can_start(); }
#[tokio::test]
async fn cancelling_owned_outgoing_future_releases_its_transaction() {
let mut f = Fixture::new(TransactionRole::Client).await;
let dialog = f.dialog.clone();
let mut sending = Box::pin(dialog.reinvite(None, None));
assert!(sending.as_mut().now_or_never().is_none());
f.next_request(Method::Invite);
f.assert_local_blocked();
drop(sending);
f.assert_local_can_start();
}
#[tokio::test]
async fn server_final_response_allows_remote_retry_but_local_waits_for_ack() {
for status in [StatusCode::OK, StatusCode::NotAcceptableHere] {
let mut f = Fixture::new(TransactionRole::Server).await;
let mut first = f.transaction(Method::Invite, 10);
let first_events = first.tu_sender.clone();
let mut dialog = f.dialog.clone();
let mut handling = Box::pin(dialog.handle(&mut first));
assert!(handling.as_mut().now_or_never().is_none());
let handle = f.update_handle();
handle.reply(status.clone()).await.unwrap();
assert!(handling.as_mut().now_or_never().is_none());
f.assert_local_blocked();
let mut second = f.transaction(Method::Invite, 11);
assert!(f
.dialog
.clone()
.handle(&mut second)
.now_or_never()
.is_none());
let _second_handle = f.update_handle();
drop(second);
f.assert_local_blocked();
first_events
.send(TransactionEvent::Received(
request(Method::Ack, 9).into(),
None,
))
.unwrap();
assert!(handling.as_mut().now_or_never().is_none());
f.assert_local_blocked(); first_events
.send(TransactionEvent::Received(
request(Method::Ack, 10).into(),
None,
))
.unwrap();
assert!(matches!(handling.as_mut().now_or_never(), Some(Ok(()))));
drop(handling);
assert!(matches!(
first.state,
TransactionState::Confirmed | TransactionState::Terminated
));
f.assert_local_can_start();
drop(first); f.assert_local_can_start();
}
}
#[tokio::test]
async fn server_ack_timeout_releases_reservation() {
for status in [StatusCode::OK, StatusCode::NotAcceptableHere] {
let mut f = Fixture::new(TransactionRole::Server).await;
let mut tx = f.transaction(Method::Invite, 10);
assert!(f.dialog.clone().handle(&mut tx).now_or_never().is_none());
let _handle = f.update_handle();
tx.reply(status.clone()).await.unwrap();
f.assert_local_blocked();
let timer = if status == StatusCode::OK {
TransactionTimer::TimerL(tx.key.clone())
} else {
TransactionTimer::TimerD(tx.key.clone())
};
tx.tu_sender.send(TransactionEvent::Timer(timer)).unwrap();
assert!(matches!(tx.receive().now_or_never(), Some(None)));
assert_eq!(tx.state, TransactionState::Terminated);
f.assert_local_can_start();
}
}
#[tokio::test]
async fn client_final_response_or_timeout_allows_next_invite() {
for status in [
StatusCode::OK,
StatusCode::NotAcceptableHere,
StatusCode::RequestPending,
StatusCode::RequestTimeout,
] {
let mut f = Fixture::new(TransactionRole::Client).await;
let dialog = f.dialog.clone();
let mut sending = Box::pin(dialog.reinvite(None, None));
assert!(sending.as_mut().now_or_never().is_none());
let req = f.next_request(Method::Invite);
f.assert_local_blocked();
if status == StatusCode::RequestTimeout {
let key = TransactionKey::from_request(&req, TransactionRole::Client).unwrap();
f.dialog
.inner
.endpoint_inner
.transactions
.get(&key)
.unwrap()
.send(TransactionEvent::Timer(TransactionTimer::TimerB(key)))
.unwrap();
} else {
f.respond(
&req,
status.clone(),
vec![Header::Contact("<sip:peer@127.0.0.1:5060>".into())],
);
}
let response = sending.as_mut().now_or_never().unwrap().unwrap().unwrap();
assert_eq!(response.status_code, status);
f.assert_local_can_start();
}
}
#[tokio::test]
async fn auth_retry_reserves_its_new_invite_transaction() {
use crate::dialog::authenticate::Credential;
for status in [
StatusCode::Unauthorized,
StatusCode::ProxyAuthenticationRequired,
] {
let mut f = Fixture::new(TransactionRole::Client).await;
Arc::get_mut(&mut f.dialog.inner).unwrap().credential = Some(Credential {
username: "alice".into(),
password: "secret".into(),
..Default::default()
});
let dialog = f.dialog.clone();
let mut sending = Box::pin(dialog.reinvite(None, None));
assert!(sending.as_mut().now_or_never().is_none());
let req = f.next_request(Method::Invite);
let value = "Digest realm=\"test\", nonce=\"challenge\", algorithm=MD5";
let challenge = if status == StatusCode::Unauthorized {
Header::WwwAuthenticate(value.into())
} else {
Header::ProxyAuthenticate(value.into())
};
f.respond(&req, status, vec![challenge]);
assert!(sending.as_mut().now_or_never().is_none());
let retry = f.next_request(Method::Invite);
assert!(
retry.cseq_header().unwrap().seq().unwrap() > req.cseq_header().unwrap().seq().unwrap()
);
f.assert_local_blocked();
f.respond(
&retry,
StatusCode::OK,
vec![Header::Contact("<sip:peer@127.0.0.1:5060>".into())],
);
assert!(matches!(sending.as_mut().now_or_never(), Some(Ok(Some(_)))));
f.assert_local_can_start();
}
}
#[tokio::test]
async fn non_invite_requests_and_bye_remain_available_while_invite_pending() {
let mut f = Fixture::new(TransactionRole::Client).await;
let dialog = f.dialog.clone();
let mut sending = Box::pin(dialog.reinvite(None, None));
assert!(sending.as_mut().now_or_never().is_none());
let invite = f.next_request(Method::Invite);
for method in [Method::Info, Method::Update, Method::Options] {
let mut request = Box::pin(dialog.request(method.clone(), None, None));
assert!(request.as_mut().now_or_never().is_none());
let wire_request = f.next_request(method);
f.respond(&wire_request, StatusCode::OK, vec![]);
assert!(matches!(request.as_mut().now_or_never(), Some(Ok(Some(_)))));
f.assert_local_blocked();
}
let mut bye = Box::pin(dialog.bye());
assert!(bye.as_mut().now_or_never().is_none());
let wire_bye = f.next_request(Method::Bye);
f.respond(&wire_bye, StatusCode::OK, vec![]);
assert!(matches!(bye.as_mut().now_or_never(), Some(Ok(()))));
assert!(dialog.inner.is_terminated());
f.respond(&invite, StatusCode::NotAcceptableHere, vec![]);
assert!(matches!(sending.as_mut().now_or_never(), Some(Ok(Some(_)))));
assert!(dialog.inner.is_terminated());
assert!(matches!(
dialog.reinvite(None, None).now_or_never(),
Some(Ok(None))
));
}
#[tokio::test]
async fn simultaneous_clones_start_only_one_outgoing_invite() {
let mut f = Fixture::new(TransactionRole::Client).await;
let barrier = std::sync::Barrier::new(8);
let runtime = tokio::runtime::Handle::current();
let winners = std::thread::scope(|scope| {
let workers: Vec<_> = (0..8)
.map(|_| {
let dialog = &f.dialog;
let barrier = &barrier;
let runtime = &runtime;
scope.spawn(move || {
let _entered = runtime.enter();
let mut sending = Box::pin(dialog.reinvite(None, None));
barrier.wait();
let outcome = sending.as_mut().now_or_never();
barrier.wait(); match outcome {
None => 1,
Some(Err(crate::Error::DialogError(_, _, StatusCode::RequestPending))) => 0,
other => panic!("unexpected result: {other:?}"),
}
})
})
.collect();
workers
.into_iter()
.map(|w| w.join().unwrap())
.sum::<usize>()
});
assert_eq!(winners, 1);
f.next_request(Method::Invite);
assert!(
f.wire.try_recv().is_err(),
"more than one INVITE reached the wire"
);
f.assert_local_can_start();
}
#[tokio::test]
async fn client_accepted_retransmission_window_does_not_block_next_invite() {
let mut f = Fixture::new(TransactionRole::Client).await;
let req = request(Method::Invite, 10);
let mut tx = Transaction::new_client(
TransactionKey::from_request(&req, TransactionRole::Client).unwrap(),
req.clone(),
f.dialog.inner.endpoint_inner.clone(),
Some(f.conn.clone()),
);
f.dialog.inner.reserve_invite(&tx).unwrap();
tx.send().await.unwrap();
f.next_request(Method::Invite);
f.assert_local_blocked();
f.respond(
&req,
StatusCode::OK,
vec![Header::Contact("<sip:peer@127.0.0.1:5060>".into())],
);
assert!(matches!(
tx.receive().now_or_never(),
Some(Some(SipMessage::Response(_)))
));
assert_eq!(tx.state, TransactionState::Accepted);
f.assert_local_can_start();
let dialog = f.dialog.clone();
let mut next = Box::pin(dialog.reinvite(None, None));
assert!(next.as_mut().now_or_never().is_none());
f.respond(
&req,
StatusCode::OK,
vec![Header::Contact("<sip:peer@127.0.0.1:5060>".into())],
);
assert!(matches!(tx.receive().now_or_never(), Some(Some(_))));
drop(tx);
f.assert_local_blocked();
}