use super::{
authenticate::Credential,
dialog::{DialogInner, DialogStateSender},
dialog_layer::DialogLayer,
invite_dialog::InviteDialog,
};
use crate::prelude::*;
use crate::sip::{
prelude::{HeadersExt, ToTypedHeader},
uri::ParamsExt,
Request, Response, SipMessage, StatusCodeKind,
};
use crate::{
dialog::{
dialog::{Dialog, DialogState, TerminatedReason},
dialog_layer::DialogLayerInnerRef,
DialogId,
},
transaction::{
key::{TransactionKey, TransactionRole},
make_tag,
transaction::Transaction,
},
transport::SipAddr,
Result,
};
use futures::FutureExt;
use tracing::{debug, info, warn};
#[derive(Default, Clone)]
pub struct InviteOption {
pub caller_display_name: Option<String>,
pub caller_params: Vec<crate::sip::uri::Param>,
pub caller: crate::sip::Uri,
pub callee: crate::sip::Uri,
pub destination: Option<SipAddr>,
pub content_type: Option<String>,
pub offer: Option<Vec<u8>>,
pub contact: crate::sip::Uri,
pub credential: Option<Credential>,
pub headers: Option<Vec<crate::sip::Header>>,
pub support_prack: bool,
pub call_id: Option<String>,
pub session_id: Option<String>,
pub route_set: Vec<crate::sip::typed::Route>,
}
pub struct DialogGuard {
pub dialog_layer_inner: DialogLayerInnerRef,
pub id: DialogId,
}
impl DialogGuard {
pub fn new(dialog_layer: &Arc<DialogLayer>, id: DialogId) -> Self {
Self {
dialog_layer_inner: dialog_layer.inner.clone(),
id,
}
}
}
impl Drop for DialogGuard {
fn drop(&mut self) {
let dlg = match self.dialog_layer_inner.dialogs.remove(&self.id.to_string()) {
Some(dlg) => dlg,
None => return,
};
let _handle = crate::platform::spawn(async move {
if let Err(e) = dlg.hangup().await {
info!(id = %dlg.id(), error = %e, "failed to hangup dialog");
}
});
}
}
pub(super) struct DialogGuardForUnconfirmed {
pub dialog_layer_inner: DialogLayerInnerRef,
pub id: DialogId,
invite_tx: Option<Transaction>,
started: bool,
dialog: Option<InviteDialog>,
}
impl Drop for DialogGuardForUnconfirmed {
fn drop(&mut self) {
if self.dialog.is_none() {
return;
}
let client_dialog = match self.dialog_layer_inner.dialogs.remove(&self.id.to_string()) {
Some(Dialog::Invite(client_dialog)) => client_dialog,
Some(_) => return,
None => match self.dialog.take() {
Some(client_dialog) => client_dialog,
None => return,
},
};
if !self.started {
client_dialog.inner.transition(DialogState::Terminated(
client_dialog.id(),
TerminatedReason::UacCancel,
));
return;
}
match client_dialog.state() {
DialogState::Terminated(_, _) => {}
state @ (DialogState::Calling(_)
| DialogState::Trying(_)
| DialogState::Early(_, _)) => {
let calling = matches!(state, DialogState::Calling(_));
let invite_tx = self.invite_tx.take();
if calling || invite_tx.is_none() {
client_dialog.inner.transition(DialogState::Terminated(
client_dialog.id(),
TerminatedReason::UacCancel,
));
}
let Some(mut invite_tx) = invite_tx else {
return;
};
debug!(%self.id, "unconfirmed dialog dropped, cancelling it");
let _handle = crate::platform::spawn(async move {
if calling {
invite_tx.stop_retransmissions();
let window = invite_tx.endpoint_inner.option.t1x64;
let first = wait_response(&mut invite_tx, window, false).await;
if !first
.as_ref()
.is_some_and(|r| r.status_code.kind() == StatusCodeKind::Provisional)
{
drop(invite_tx);
bye_if_2xx(&client_dialog, first).await;
return;
}
}
let final_window = invite_tx.endpoint_inner.option.t1x64;
invite_tx.stop_retransmissions();
let cancel_dialog = client_dialog.clone();
let _handle = crate::platform::spawn(async move {
if let Err(e) = cancel_dialog.send_cancel().await {
warn!(id = %cancel_dialog.id(), error = %e, "dialog cancel failed");
}
});
if !calling {
client_dialog.inner.transition(DialogState::Terminated(
client_dialog.id(),
TerminatedReason::UacCancel,
));
debug!(id = %client_dialog.id(), "dialog terminated");
}
let final_response = wait_response(&mut invite_tx, final_window, true).await;
drop(invite_tx);
bye_if_2xx(&client_dialog, final_response).await;
});
}
DialogState::Confirmed(_, _) => {}
_ => {}
}
}
}
async fn wait_response(
invite_tx: &mut Transaction,
limit: core::time::Duration,
final_only: bool,
) -> Option<Response> {
let wait = async {
while let Some(msg) = invite_tx.receive().await {
if let SipMessage::Response(resp) = msg {
if !final_only || resp.status_code.kind() != StatusCodeKind::Provisional {
return Some(resp);
}
}
}
None
};
crate::platform::timeout(limit, wait).await.ok().flatten()
}
pub(super) async fn bye_if_2xx(client_dialog: &InviteDialog, resp: Option<Response>) {
if let Some(resp) = resp.filter(|r| r.status_code.kind() == StatusCodeKind::Successful) {
info!(id = %client_dialog.id(), "2xx after CANCEL, sending BYE");
if let Err(e) = client_dialog.bye_2xx_after_cancel(&resp).await {
warn!(id = %client_dialog.id(), error = %e, "BYE after CANCEL failed");
}
}
}
pub type InviteAsyncResult = Result<(DialogId, Option<Response>)>;
impl DialogLayer {
pub fn make_invite_request(&self, opt: &InviteOption) -> Result<Request> {
let last_seq = self.increment_last_seq();
let to = crate::sip::typed::To {
display_name: None,
uri: opt.callee.clone(),
params: vec![],
};
let recipient = to.uri.clone();
let from = crate::sip::typed::From {
display_name: opt.caller_display_name.clone(),
uri: opt.caller.clone(),
params: opt.caller_params.clone(),
}
.with_tag(make_tag());
let call_id = opt
.call_id
.as_ref()
.map(|id| crate::sip::headers::CallId::from(id.clone()));
let target_transport = opt
.destination
.as_ref()
.and_then(|d| d.r#type)
.or_else(|| opt.callee.transport().cloned())
.filter(|t| *t != crate::sip::Transport::Udp);
let transport_addr = target_transport.and_then(|transport| {
let listens = self.endpoint.transport_layer.get_listen_addrs();
listens
.iter()
.find(|a| a.r#type == Some(transport))
.cloned()
.or_else(|| {
let mut addr = listens.first().cloned()?;
addr.r#type = Some(transport);
Some(addr)
})
});
let via = self.endpoint.get_via(transport_addr.clone(), None)?;
let mut request = self.endpoint.make_request(
crate::sip::Method::Invite,
recipient,
via,
from,
to,
last_seq,
call_id,
);
for route in &opt.route_set {
request.headers.push(route.clone().into());
}
let caller_built_contact = opt
.contact
.params
.iter()
.any(|p| matches!(p, crate::sip::Param::Transport(_)));
let contact = if let Some(addr) = transport_addr.as_ref().filter(|_| !caller_built_contact)
{
let mut uri = opt.contact.clone();
uri.host_with_port = addr.addr.clone();
if !uri
.params
.iter()
.any(|p| matches!(p, crate::sip::Param::Transport(_)))
{
uri.params.push(crate::sip::Param::Transport(
addr.r#type.unwrap_or(crate::sip::Transport::Tcp),
));
}
if addr.r#type == Some(crate::sip::Transport::Tls) {
uri.scheme = Some(crate::sip::Scheme::Sips);
}
crate::sip::typed::Contact {
display_name: None,
uri,
params: vec![],
}
} else {
crate::sip::typed::Contact {
display_name: None,
uri: opt.contact.clone(),
params: vec![],
}
};
request
.headers
.unique_push(crate::sip::Header::Contact(contact.into()));
request.headers.unique_push(crate::sip::Header::ContentType(
opt.content_type
.clone()
.unwrap_or("application/sdp".to_string())
.into(),
));
if opt.support_prack {
request
.headers
.unique_push(crate::sip::Header::Supported("100rel".into()));
}
if self.endpoint.option.history_info_enabled {
let already = request
.headers
.iter()
.chain(opt.headers.iter().flatten())
.any(|h| {
matches!(h, crate::sip::Header::Supported(s)
if s.value().split(',').any(|t| t.trim().eq_ignore_ascii_case("histinfo")))
});
if !already {
request
.headers
.push(crate::sip::Header::Supported("histinfo".into()));
}
}
if let Some(raw) = opt.session_id.as_deref() {
let uuid = crate::sip::headers::SessionId::normalize(raw)?;
request
.headers
.unique_push(crate::sip::headers::SessionId::from_local(&uuid)?.into());
}
if let Some(headers) = opt.headers.as_ref() {
for header in headers {
match header {
crate::sip::Header::MaxForwards(_) | crate::sip::Header::ContentType(_) => {
request.headers.unique_push(header.clone())
}
_ => request.headers.push(header.clone()),
}
}
}
Ok(request)
}
pub async fn do_invite(
&self,
opt: InviteOption,
state_sender: DialogStateSender,
) -> Result<(InviteDialog, Option<Response>)> {
let (dialog, tx) = self.create_client_invite_dialog(opt, state_sender)?;
let id = dialog.id();
self.inner
.dialogs
.insert(id.to_string(), Dialog::Invite(dialog.clone()));
let mut guard = DialogGuardForUnconfirmed {
dialog_layer_inner: self.inner.clone(),
id: id.clone(),
invite_tx: Some(tx),
started: true,
dialog: Some(dialog.clone()),
};
let tx = guard
.invite_tx
.as_mut()
.expect("transcation should be avaible");
let r = dialog
.process_invite_with_registration(tx, |new_id| {
self.inner.dialogs.with_mut(|dialogs| {
dialogs.remove(&id.to_string());
dialogs.insert(new_id.to_string(), Dialog::Invite(dialog.clone()));
});
})
.boxed()
.await;
guard.dialog = None;
if !dialog.inner.is_confirmed() {
self.inner.dialogs.remove(&id.to_string());
}
match r {
Ok((new_dialog_id, resp)) => {
match resp {
Some(ref r)
if r.status_code.kind() == crate::sip::StatusCodeKind::Successful =>
{
if let Some(mut tx) = guard.invite_tx.take() {
let dlg = dialog.clone();
let confirmed_tag = new_dialog_id.remote_tag.clone();
crate::platform::spawn(async move {
let mut seen_forks: Vec<String> = Vec::new();
while let Some(msg) = tx.receive().await {
dlg.end_forked_branch(&msg, &confirmed_tag, &mut seen_forks)
.await;
}
debug!(id = %new_dialog_id, "accepted transaction drained (Timer M expired)");
});
}
}
_ => {}
}
Ok((dialog, resp))
}
Err(e) => Err(e),
}
}
pub fn do_invite_async(
self: &Arc<Self>,
opt: InviteOption,
state_sender: DialogStateSender,
) -> Result<(InviteDialog, crate::platform::JoinHandle<InviteAsyncResult>)> {
let (dialog, tx) = self.create_client_invite_dialog(opt, state_sender)?;
let id0 = dialog.id();
self.inner
.dialogs
.insert(id0.to_string(), Dialog::Invite(dialog.clone()));
let inner = self.inner.clone();
let dialog_clone = dialog.clone();
let mut guard = DialogGuardForUnconfirmed {
dialog_layer_inner: inner.clone(),
id: id0.clone(),
invite_tx: Some(tx),
started: false,
dialog: Some(dialog_clone.clone()),
};
let handle = crate::platform::spawn_with_result(async move {
guard.started = true;
let invite_tx = guard
.invite_tx
.as_mut()
.expect("transaction should be available");
let r = dialog_clone
.process_invite_with_registration(invite_tx, |new_id| {
inner.dialogs.with_mut(|dialogs| {
dialogs.remove(&id0.to_string());
dialogs.insert(new_id.to_string(), Dialog::Invite(dialog_clone.clone()));
});
})
.boxed()
.await;
guard.dialog = None;
let mut tx = guard
.invite_tx
.take()
.expect("transaction should be available");
if !dialog_clone.inner.is_confirmed() {
inner.dialogs.remove(&id0.to_string());
}
match &r {
Ok((new_id, resp_opt)) => {
let is_2xx = resp_opt
.as_ref()
.map(|resp| {
resp.status_code.kind() == crate::sip::StatusCodeKind::Successful
})
.unwrap_or(false);
if is_2xx {
let confirmed_id = new_id.clone();
let confirmed_tag = new_id.remote_tag.clone();
let forked_dlg = dialog_clone.clone();
crate::platform::spawn(async move {
let mut seen_forks: Vec<String> = Vec::new();
while let Some(msg) = tx.receive().await {
forked_dlg
.end_forked_branch(&msg, &confirmed_tag, &mut seen_forks)
.await;
}
debug!(id = %confirmed_id, "accepted transaction drained (Timer M expired)");
});
}
}
Err(e) => debug!(%id0, error = %e, "async invite failed"),
}
r
});
Ok((dialog, handle))
}
pub fn create_client_invite_dialog(
&self,
opt: InviteOption,
state_sender: DialogStateSender,
) -> Result<(InviteDialog, Transaction)> {
let mut request = self.make_invite_request(&opt)?;
request.body = opt.offer.unwrap_or_default();
request
.headers
.unique_push(crate::sip::Header::ContentLength(
(request.body.len() as u32).into(),
));
let key = TransactionKey::from_request(&request, TransactionRole::Client)?;
let mut tx = Transaction::new_client(key, request.clone(), self.endpoint.clone(), None);
if opt.destination.is_some() {
tx.destination = opt.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();
}
}
}
let id = DialogId::try_from(&tx)?;
let local_contact = request
.contact_header()
.ok()
.and_then(|c| c.typed().ok().map(|ct| ct.uri))
.or(Some(opt.contact));
let dlg_inner = DialogInner::new(
TransactionRole::Client,
id.clone(),
request.clone(),
self.endpoint.clone(),
state_sender,
opt.credential,
local_contact,
tx.tu_sender.clone(),
)?;
if let Some(destination) = &tx.destination {
let uri = destination.clone().into();
*dlg_inner.remote_uri.lock() = uri;
}
let dialog = InviteDialog::from_inner(Arc::new(dlg_inner));
dialog.inner.reserve_invite(&tx)?;
Ok((dialog, tx))
}
}