use super::{
authenticate::{handle_client_authenticate, Credential},
DialogId,
};
use crate::prelude::*;
use crate::sip::prelude::HeadersExt;
use crate::sip::{Header, Param, Response, SipMessage, StatusCode};
use crate::{
transaction::{
endpoint::EndpointInnerRef,
key::{TransactionKey, TransactionRole},
make_call_id, make_tag,
transaction::Transaction,
},
transport::{SipAddr, SipConnection},
Result,
};
use tracing::debug;
pub struct Registration {
pub last_seq: u32,
pub endpoint: EndpointInnerRef,
pub credential: Option<Credential>,
pub contact: Option<crate::sip::typed::Contact>,
pub allow: Option<crate::sip::headers::Allow>,
pub public_address: Option<crate::sip::HostWithPort>,
pub call_id: crate::sip::headers::CallId,
pub outbound_proxy: Option<core::net::SocketAddr>,
pub service_route: Vec<crate::sip::typed::ServiceRoute>,
pub granted_expires: Option<u32>,
pub extra_headers: Vec<Header>,
}
impl Registration {
pub fn new(endpoint: EndpointInnerRef, credential: Option<Credential>) -> Self {
let call_id = make_call_id(
endpoint.option.callid_suffix.as_deref(),
endpoint.option.callid_format,
);
Self {
last_seq: 0,
endpoint,
credential,
contact: None,
allow: None,
public_address: None,
call_id,
outbound_proxy: None,
service_route: Vec::new(),
granted_expires: None,
extra_headers: Vec::new(),
}
}
pub fn discovered_public_address(&self) -> Option<crate::sip::HostWithPort> {
self.public_address.clone()
}
pub fn service_route(&self) -> &[crate::sip::typed::ServiceRoute] {
&self.service_route
}
pub fn preloaded_route_set(&self) -> Vec<crate::sip::typed::Route> {
self.service_route.iter().cloned().map(Into::into).collect()
}
pub fn expires(&self) -> u32 {
self.granted_expires.unwrap_or(50)
}
fn outbound_proxy_target(&self, server: &crate::sip::Uri) -> Option<SipAddr> {
let mut proxy = SipAddr::from(self.outbound_proxy?);
proxy.r#type = server.params.iter().find_map(|p| match p {
Param::Transport(t) => Some(*t),
_ => None,
});
Some(proxy)
}
pub async fn register(
&mut self,
server: crate::sip::Uri,
expires: Option<u32>,
) -> Result<Response> {
self.last_seq += 1;
let mut to = crate::sip::typed::To {
display_name: None,
uri: server.clone(),
params: vec![],
};
if let Some(cred) = &self.credential {
to.uri.auth = Some(crate::sip::Auth {
user: cred.username.clone(),
password: None,
});
}
let from = crate::sip::typed::From {
display_name: None,
uri: to.uri.clone(),
params: vec![],
}
.with_tag(make_tag());
let proxy_target = self.outbound_proxy_target(&server);
let via_target = match &proxy_target {
Some(proxy) => Ok(proxy.clone()),
None => SipAddr::try_from(&server),
};
let via = match via_target {
Ok(target_addr) => {
match self
.endpoint
.transport_layer
.lookup(&target_addr, None)
.await
{
Ok((connection, _resolved)) => self
.endpoint
.get_via(Some(connection.get_addr().clone()), None)?,
Err(_) => self.endpoint.get_via(None, None)?,
}
}
Err(_) => self.endpoint.get_via(None, None)?,
};
let mut contact = self.contact.clone().unwrap_or_else(|| {
let contact_host_with_port = self
.public_address
.clone()
.unwrap_or_else(|| via.uri.host_with_port.clone());
crate::sip::typed::Contact {
display_name: None,
uri: crate::sip::Uri {
auth: to.uri.auth.clone(),
scheme: Some(crate::sip::Scheme::Sip),
host_with_port: contact_host_with_port,
params: vec![],
headers: vec![],
},
params: vec![],
}
});
if expires.is_some() {
contact.params.retain(|p| !matches!(p, Param::Expires(_)));
}
let mut request = self.endpoint.make_request(
crate::sip::Method::Register,
server,
via,
from,
to,
self.last_seq,
None,
);
let contact_for_retry = contact.clone();
let mut sent_contact = contact.clone();
request.headers.unique_push(self.call_id.clone().into());
request.headers.unique_push(contact.into());
if let Some(allow) = &self.allow {
request.headers.unique_push(allow.clone().into());
}
request
.headers
.unique_push(Header::Supported("path, outbound".into()));
if let Some(expires) = expires {
request
.headers
.unique_push(crate::sip::headers::Expires::from(expires).into());
}
for extra in &self.extra_headers {
request
.headers
.retain(|h| !h.name().eq_ignore_ascii_case(extra.name()));
request.headers.push(extra.clone());
}
let key = TransactionKey::from_request(&request, TransactionRole::Client)?;
let mut tx = Transaction::new_client(key, request, self.endpoint.clone(), None);
if proxy_target.is_some() {
tx.destination = proxy_target;
}
tx.send().await?;
let mut auth_sent = false;
while let Some(msg) = tx.receive().await {
match msg {
SipMessage::Response(resp) => match resp.status_code {
StatusCode::Trying => {
continue;
}
StatusCode::ProxyAuthenticationRequired | StatusCode::Unauthorized => {
let received = resp.via_header().ok().and_then(|via| {
SipConnection::parse_target_from_via(via)
.ok()
.map(|(_, host_with_port)| host_with_port)
});
if self.public_address != received {
debug!(
old = ?self.public_address,
new = ?received,
"updated public address from 401 response"
);
self.public_address = received;
if let Some(ref mut contact) = self.contact {
if let Some(ref pa) = self.public_address {
contact.uri.host_with_port = pa.clone();
}
} else {
self.contact = None;
}
}
if auth_sent {
debug!(status = %resp.status_code, "received auth response after auth sent");
return Ok(resp);
}
if let Some(cred) = &self.credential {
self.last_seq += 1;
tx = handle_client_authenticate(self.last_seq, &tx, resp, cred).await?;
if let Some(ref pa) = self.public_address {
let new_contact_uri = crate::sip::Uri {
auth: contact_for_retry.uri.auth.clone(),
scheme: Some(crate::sip::Scheme::Sip),
host_with_port: pa.clone(),
params: contact_for_retry.uri.params.clone(),
headers: vec![],
};
let mut new_contact = contact_for_retry.clone();
new_contact.uri = new_contact_uri;
tx.original
.headers
.retain(|h| !matches!(h, crate::sip::Header::Contact(_)));
sent_contact = new_contact.clone();
tx.original.headers.unique_push(new_contact.into());
}
tx.send().await?;
auth_sent = true;
continue;
} else {
debug!(status = %resp.status_code, "received auth response without credential");
return Ok(resp);
}
}
StatusCode::OK => {
let received = resp.via_header().ok().and_then(|via| {
SipConnection::parse_target_from_via(via)
.ok()
.map(|(_, host_with_port)| host_with_port)
});
if self.public_address != received {
debug!(
old = ?self.public_address,
new = ?received,
"discovered public IP"
);
self.public_address = received;
}
self.service_route = resp.typed_service_route_headers().unwrap_or_default();
self.granted_expires =
Some(granted_expiration(&resp, &sent_contact, expires));
debug!(
status = %resp.status_code,
contact = ?self.contact.as_ref().map(|c| c.uri.to_string()),
service_route = self.service_route.len(),
"registration do_request done"
);
return Ok(resp);
}
_ => {
debug!(status = %resp.status_code, "registration do_request done");
return Ok(resp);
}
},
_ => break,
}
}
Err(crate::Error::DialogError(
"registration transaction is already terminated".to_string(),
DialogId::try_from(&tx)?,
StatusCode::BadRequest,
))
}
pub fn create_nat_aware_contact(
username: &str,
public_address: Option<crate::sip::HostWithPort>,
local_address: &SipAddr,
) -> crate::sip::typed::Contact {
let contact_host_with_port = public_address.unwrap_or_else(|| local_address.clone().into());
let params = vec![];
crate::sip::typed::Contact {
display_name: None,
uri: crate::sip::Uri {
scheme: Some(crate::sip::Scheme::Sip),
auth: Some(crate::sip::Auth {
user: username.to_string(),
password: None,
}),
host_with_port: contact_host_with_port,
params,
headers: vec![],
},
params: vec![],
}
}
}
pub(crate) fn granted_expiration(
resp: &Response,
ours: &crate::sip::typed::Contact,
requested: Option<u32>,
) -> u32 {
if requested == Some(0) {
return 0;
}
let header_or_requested = || {
resp.expires_header()
.and_then(|h| h.value().trim().parse::<u32>().ok())
.or(requested)
.unwrap_or(3600)
};
let contacts = resp.typed_contact_headers().unwrap_or_default();
let matched: Vec<_> = contacts
.iter()
.filter(|c| contact_uri_matches(&c.uri, &ours.uri))
.collect();
if !matched.is_empty() {
return matched
.iter()
.filter_map(|c| c.expires())
.min()
.unwrap_or_else(header_or_requested);
}
if let [only] = contacts.as_slice() {
if let Some(expires) = only.expires() {
return expires;
}
}
header_or_requested()
}
fn contact_uri_matches(a: &crate::sip::Uri, b: &crate::sip::Uri) -> bool {
use crate::sip::uri::Scheme;
let scheme = |u: &crate::sip::Uri| u.scheme.clone().unwrap_or(Scheme::Sip);
let user = |u: &crate::sip::Uri| u.auth.as_ref().map(|a| a.user.clone());
let port = |u: &crate::sip::Uri| {
u.host_with_port
.port
.as_ref()
.map(|p| p.value().to_owned())
.unwrap_or(if scheme(u) == Scheme::Sips {
5061
} else {
5060
})
};
let transport = |u: &crate::sip::Uri| {
u.params
.iter()
.find_map(|p| match p {
Param::Transport(t) => Some(*t),
_ => None,
})
.unwrap_or(crate::sip::Transport::Udp)
};
scheme(a) == scheme(b)
&& user(a) == user(b)
&& a.host_with_port
.host
.to_string()
.eq_ignore_ascii_case(&b.host_with_port.host.to_string())
&& port(a) == port(b)
&& transport(a) == transport(b)
}
#[cfg(test)]
mod tests {
use super::granted_expiration;
use crate::sip::{typed::Contact, Response};
fn ok(extra: &str) -> Response {
format!(
"SIP/2.0 200 OK\r\n\
Via: SIP/2.0/UDP 192.0.2.10:5060;branch=z9hG4bK-test\r\n\
From: <sip:1001@example.com>;tag=a\r\n\
To: <sip:1001@example.com>;tag=b\r\n\
CSeq: 2 REGISTER\r\n\
Call-ID: reg-test\r\n\
{extra}\
Content-Length: 0\r\n\r\n"
)
.as_str()
.try_into()
.unwrap()
}
fn ours() -> Contact {
Contact::parse("<sip:1001@198.51.100.20:5060>").unwrap()
}
#[test]
fn picks_our_binding_among_other_devices() {
let resp = ok("Contact: <sip:1001@203.0.113.7:5080>;expires=60, \
<sip:1001@198.51.100.20:5060>;expires=1800\r\nExpires: 3600\r\n");
assert_eq!(granted_expiration(&resp, &ours(), Some(300)), 1800);
}
#[test]
fn matching_tolerates_default_port_transport_and_host_case() {
let ours = Contact::parse("<sip:1001@Host.Example.com;transport=udp>").unwrap();
let resp = ok("Contact: <sip:1001@host.example.com:5060;ob>;expires=900, \
<sip:1001@host.example.com:5060;transport=tcp>;expires=60\r\n");
assert_eq!(granted_expiration(&resp, &ours, Some(300)), 900);
}
#[test]
fn our_binding_without_param_uses_expires_header_then_requested() {
let resp = ok("Contact: <sip:1001@198.51.100.20:5060>\r\nExpires: 1200\r\n");
assert_eq!(granted_expiration(&resp, &ours(), Some(300)), 1200);
let resp = ok("Contact: <sip:1001@198.51.100.20:5060>\r\n");
assert_eq!(granted_expiration(&resp, &ours(), Some(300)), 300);
}
#[test]
fn unmatched_lone_contact_is_taken_as_ours() {
let resp = ok("Contact: <sip:1001@10.0.0.9:5062>;expires=600\r\nExpires: 3600\r\n");
assert_eq!(granted_expiration(&resp, &ours(), Some(300)), 600);
}
#[test]
fn unmatched_multiple_contacts_fall_back_to_header_then_requested() {
let contacts = "Contact: <sip:1001@10.0.0.9:5062>;expires=600, \
<sip:1001@10.0.0.8:5062>;expires=60\r\n";
let resp = ok(&format!("{contacts}Expires: 1500\r\n"));
assert_eq!(granted_expiration(&resp, &ours(), Some(300)), 1500);
assert_eq!(granted_expiration(&ok(contacts), &ours(), Some(300)), 300);
}
#[test]
fn nothing_specified_defaults_to_3600_and_unregister_is_zero() {
assert_eq!(granted_expiration(&ok(""), &ours(), None), 3600);
let resp = ok("Contact: <sip:1001@198.51.100.20:5060>;expires=1800\r\n");
assert_eq!(granted_expiration(&resp, &ours(), Some(0)), 0);
}
}
#[derive(Debug)]
pub enum RefreshOutcome<'a> {
Registered(&'a Response),
Rejected(&'a Response),
Failed(&'a crate::Error),
}
pub fn refresh_interval(expires: u32) -> core::time::Duration {
core::time::Duration::from_millis((u64::from(expires) * 3 / 4 * 1000).max(1000))
}
pub fn backoff_interval(failures: u32) -> core::time::Duration {
const MIN_MS: u64 = 1_000;
const MAX_MS: u64 = 60_000;
core::time::Duration::from_millis((MIN_MS << failures.min(6)).min(MAX_MS))
}
impl Registration {
pub async fn keep_alive<E>(
&mut self,
server: crate::sip::Uri,
expires: u32,
token: crate::platform::CancellationToken,
mut on_result: E,
) where
E: FnMut(RefreshOutcome<'_>),
{
let refresh = refresh_interval(expires);
let mut failures: u32 = 0;
loop {
match self.register(server.clone(), Some(expires)).await {
Ok(resp) if resp.status_code.kind() == crate::sip::StatusCodeKind::Successful => {
failures = 0;
on_result(RefreshOutcome::Registered(&resp));
}
Ok(resp) => {
failures += 1;
on_result(RefreshOutcome::Rejected(&resp));
}
Err(e) => {
failures += 1;
on_result(RefreshOutcome::Failed(&e));
}
}
let wait = if failures == 0 {
refresh
} else {
backoff_interval(failures - 1)
};
let sleep_fut = crate::platform::sleep(wait);
let mut sleep_fut = core::pin::pin!(sleep_fut);
let cancelled = token.cancelled();
let mut cancelled = core::pin::pin!(cancelled);
if matches!(
crate::platform::select2(&mut sleep_fut, &mut cancelled).await,
crate::platform::Either::B(_)
) {
return;
}
}
}
}
#[cfg(test)]
mod keep_alive_tests {
use super::*;
#[test]
fn refresh_interval_is_75_percent_with_floor() {
assert_eq!(refresh_interval(600), core::time::Duration::from_secs(450));
assert_eq!(refresh_interval(1), core::time::Duration::from_secs(1));
assert_eq!(refresh_interval(2), core::time::Duration::from_secs(1));
}
#[test]
fn backoff_doubles_and_caps() {
assert_eq!(backoff_interval(0), core::time::Duration::from_secs(1));
assert_eq!(backoff_interval(1), core::time::Duration::from_secs(2));
assert_eq!(backoff_interval(3), core::time::Duration::from_secs(8));
assert_eq!(backoff_interval(10), core::time::Duration::from_secs(60));
}
}