#![expect(clippy::result_large_err)]
use std::{
net::SocketAddr,
sync::{Arc, atomic::AtomicU16},
time::Duration,
};
use tokio::{select, sync::mpsc};
use tokio_util::sync::CancellationToken;
use rsipstack::{
EndpointBuilder, Result,
dialog::{
authenticate::Credential,
dialog::{Dialog, DialogState, DialogStateReceiver, DialogStateSender},
dialog_layer::DialogLayer,
registration::Registration,
server_dialog::ServerInviteDialog,
},
sip::{self, Auth, Header, HeadersExt as _, Method, Scheme, StatusCode, Uri},
transaction::{TransactionReceiver, endpoint::EndpointInnerRef},
transport::{SipAddr, TransportLayer, udp::UdpConnection},
};
#[cfg(feature = "sound")]
pub mod sound;
pub struct DialogEvent {
pub id: String,
pub kind: DialogEventKind,
}
pub enum DialogEventKind {
Started,
Ended,
Input(u8),
}
pub struct Config {
pub bind_addr: String,
pub remote_addr: String,
pub credential: Credential,
}
pub enum OnCallAction {
Reject,
Accept,
}
pub enum CallEvent {
Input { digit: u8, end: bool },
}
pub enum CallAction {
#[cfg(feature = "sound")]
Play(sound::Sound),
}
pub struct Hangup;
pub trait CallHandler: Sync + Send + Clone + 'static {
fn on_call(&self, user: String) -> impl Future<Output = OnCallAction>;
fn handle_call(
&self,
user: String,
incoming: mpsc::Receiver<CallEvent>,
outgoing: mpsc::Sender<CallAction>,
) -> impl Future<Output = Hangup> + Send;
}
pub async fn run(
config: Config,
cancel_token: CancellationToken,
sip_handler: impl CallHandler,
) -> Result<()> {
let connection = UdpConnection::create_connection(
config.bind_addr.parse()?,
Some(config.remote_addr.parse()?),
Some(cancel_token.child_token()),
)
.await?;
let transport_layer = TransportLayer::new(cancel_token.clone());
transport_layer.add_transport(rsipstack::transport::SipConnection::Udp(connection));
let endpoint = EndpointBuilder::new()
.with_transport_layer(transport_layer)
.with_cancel_token(cancel_token.clone())
.build();
let incoming = endpoint.incoming_transactions()?;
let dialog_layer = Arc::new(DialogLayer::new(endpoint.inner.clone()));
let (state_sender, state_receiver) = dialog_layer.new_dialog_state_channel();
let first_addr = endpoint
.get_addrs()
.first()
.ok_or(rsipstack::Error::Error("no address found".to_string()))?
.clone();
let contact = Uri {
scheme: Some(Scheme::Sip),
auth: Some(Auth {
user: config.credential.username.clone(),
password: None,
}),
host_with_port: first_addr.addr,
params: vec![],
headers: vec![],
};
let sip_server = Uri::try_from(format!("sip:{}", config.remote_addr)).ok();
select! {
_ = endpoint.serve() => {
log::debug!("user agent finished");
}
r = process_registration(endpoint.inner.clone(), sip_server, config.credential.clone(), cancel_token.clone()) => {
log::debug!("register loop finished: {r:?}");
}
r = process_incoming_request(dialog_layer.clone(), incoming, sip_handler.clone(), state_sender.clone(), contact.clone()) => {
log::debug!("serve loop finished: {r:?}");
}
r = process_dialog(dialog_layer.clone(), state_receiver, sip_handler.clone(), cancel_token.clone()) => {
log::debug!("dialog loop finished: {r:?}");
}
_ = cancel_token.cancelled() => {
log::debug!("token cancelled")
}
}
Ok(())
}
async fn process_registration(
endpoint: EndpointInnerRef,
sip_server: Option<Uri>,
credential: Credential,
cancel_token: CancellationToken,
) -> rsipstack::Result<()> {
let sip_server = match sip_server {
Some(uri) => uri,
None => {
cancel_token.cancelled().await;
return Ok(());
}
};
let mut registration = Registration::new(endpoint, Some(credential));
const ATTEMPTS: u32 = 3;
let mut attempts_left = ATTEMPTS;
loop {
let resp = registration.register(sip_server.clone(), None).await?;
if resp.status_code != StatusCode::OK {
log::error!("received response: {}", resp);
attempts_left = attempts_left.saturating_sub(1);
if attempts_left > 0 {
log::debug!(
"retrying register, attempt {}/{ATTEMPTS}",
ATTEMPTS - attempts_left
);
tokio::time::sleep(Duration::from_millis(100)).await;
continue;
} else {
return Err(rsipstack::Error::Error("Failed to register".to_string()));
}
} else {
attempts_left = ATTEMPTS;
}
tokio::time::sleep(Duration::from_secs(registration.expires().max(50) as u64)).await;
}
}
async fn process_incoming_request(
dialog_layer: Arc<DialogLayer>,
mut incoming: TransactionReceiver,
sip_handler: impl CallHandler,
state_sender: DialogStateSender,
contact: Uri,
) -> rsipstack::Result<()> {
while let Some(mut tx) = incoming.recv().await {
log::debug!("Received transaction: {:?}", tx.key);
if tx.original.to_header()?.tag()?.as_ref().is_some() {
match dialog_layer.match_dialog(&tx) {
Some(mut d) => {
tokio::spawn(async move {
d.handle(&mut tx).await?;
Ok::<_, rsipstack::Error>(())
});
continue;
}
None => {
log::error!("dialog not found: {}", tx.original);
tx.reply(StatusCode::CallTransactionDoesNotExist).await?;
continue;
}
}
}
match tx.original.method {
Method::Invite | Method::Ack => {
let action = if tx.original.method != Method::Invite {
OnCallAction::Accept
} else {
let caller = get_caller(&tx.original.headers);
sip_handler.on_call(caller.to_owned()).await
};
match action {
OnCallAction::Reject => {
log::info!("Rejecting incoming call: {}", tx.original);
tx.reply(StatusCode::BusyHere).await?;
continue;
}
OnCallAction::Accept => {
let mut dialog = match dialog_layer.get_or_create_server_invite(
&tx,
state_sender.clone(),
None,
Some(contact.clone()),
) {
Ok(d) => d,
Err(e) => {
log::error!("Failed to obtain dialog: {:?}", e);
tx.reply(StatusCode::CallTransactionDoesNotExist).await?;
continue;
}
};
tokio::spawn(async move {
dialog.handle(&mut tx).await?;
Ok::<_, rsipstack::Error>(())
});
}
}
}
_ => {
log::debug!("Received request: {:?}", tx.original.method);
tx.reply(StatusCode::OK).await?;
}
}
}
Ok::<_, rsipstack::Error>(())
}
fn get_caller(headers: &sip::Headers) -> &str {
headers
.iter()
.find_map(|header| match header {
Header::From(from) => from.0.split('"').nth(1),
_ => None,
})
.unwrap_or("unknown")
}
async fn process_dialog(
dialog_layer: Arc<DialogLayer>,
state_receiver: DialogStateReceiver,
sip_handler: impl CallHandler,
cancel_token: CancellationToken,
) -> rsipstack::Result<()> {
let mut state_receiver = state_receiver;
while let Some(state) = state_receiver.recv().await {
match state {
DialogState::Calling(id) => {
log::debug!("Calling dialog {}", id);
let dialog = match dialog_layer.get_dialog(&id) {
Some(d) => d,
None => {
log::debug!("Dialog not found {}", id);
continue;
}
};
match dialog {
Dialog::ServerInvite(dialog) => {
process_invite(dialog, sip_handler.clone(), cancel_token.clone()).await?;
}
Dialog::ClientInvite(_) => {
log::debug!("Client invite dialog {}", id);
}
Dialog::ServerSubscription(_) => {
log::debug!("Server subscription dialog {}", id);
}
Dialog::ClientSubscription(_) => {
log::debug!("Client subscription dialog {}", id);
}
Dialog::ServerPublication(_) => {
log::debug!("Server publication dialog {}", id);
}
Dialog::ClientPublication(_) => {
log::debug!("Client publication dialog {}", id);
}
}
}
DialogState::Early(id, resp) => {
log::debug!("Early dialog {} {}", id, resp);
}
DialogState::Terminated(id, reason) => {
log::debug!("Dialog terminated {} {:?}", id, reason);
dialog_layer.remove_dialog(&id);
}
_ => {
log::debug!("Received dialog state: {}", state);
}
}
}
Ok(())
}
async fn process_invite(
dialog: ServerInviteDialog,
sip_handler: impl CallHandler,
cancel_token: CancellationToken,
) -> rsipstack::Result<()> {
let ssrc = rand::random::<u32>();
let body = String::from_utf8_lossy(dialog.initial_request().body()).to_string();
let offer = match sdp_rs::SessionDescription::try_from(body.as_str()) {
Ok(s) => s,
Err(e) => {
log::error!("Failed to parse offer SDP: {:?} {}", e, body);
return Err(rsipstack::Error::Error("Failed to parse SDP".to_string()));
}
};
let participant = get_caller(&dialog.initial_request().headers).to_owned();
let peer_addr = match offer.connection {
Some(c) => c.connection_address.base,
None => {
log::error!("No connection address in offer SDP");
return Err(rsipstack::Error::Error(
"No connection address in offer SDP".to_string(),
));
}
};
let peer_port = offer
.media_descriptions
.first()
.map(|m| m.media.port)
.ok_or(rsipstack::Error::Error(
"No audio port in offer SDP".to_string(),
))?;
let payload_type = offer
.media_descriptions
.first()
.and_then(|m| m.media.fmt.parse::<u8>().ok());
let (conn, answer, conn_port) =
build_rtp_conn(payload_type.unwrap_or(0), cancel_token.clone()).await?;
let headers = vec![Header::ContentType("application/sdp".into())];
dialog.ringing(Some(headers), Some(answer.clone().into()))?;
let rtp_token = dialog.cancel_token().child_token();
let sip_handler = sip_handler.clone();
tokio::spawn(async move {
let punch_addr = format!("{}:{}", peer_addr, conn_port);
let peer_addr = format!("{}:{}", peer_addr, peer_port);
let peer_addr = SipAddr {
addr: peer_addr.try_into().expect("peer_addr"),
r#type: Some(sip::transport::Transport::Udp),
};
let punch_addr = SipAddr {
addr: punch_addr.try_into().expect("punch_addr"),
r#type: Some(sip::transport::Transport::Udp),
};
let headers = vec![Header::ContentType("application/sdp".into())];
match dialog.accept(Some(headers), Some(answer.clone().into())) {
Ok(_) => log::debug!(
"Accepted call with answer SDP peer address: {} port: {} payload_type: {}",
peer_addr,
peer_port,
payload_type.unwrap_or(0)
),
Err(e) => {
log::error!("Failed to accept call: {:?}", e);
return;
}
}
process_rtp(
conn,
rtp_token,
sip_handler,
payload_type,
&peer_addr,
&punch_addr,
participant,
ssrc,
)
.await
.expect("reading rtp");
log::debug!("answer receiver finished");
dialog.bye().await.expect("send BYE");
});
Ok(())
}
#[expect(clippy::too_many_arguments)]
#[cfg_attr(not(feature = "sound"), expect(unused))]
pub async fn process_rtp(
conn: UdpConnection,
token: CancellationToken,
handler: impl CallHandler,
payload_type: Option<u8>,
peer_addr: &SipAddr,
punch_addr: &SipAddr,
participant: String,
ssrc: u32,
) -> rsipstack::Result<()> {
let mut successful = 0;
const PUNCH_PACKETS: u32 = 3;
while successful < PUNCH_PACKETS {
if let Err(err) = conn.send_raw(&[0u8; 12], peer_addr).await {
log::error!("Failed to send empty packet: {err}");
} else {
successful += 1;
}
tokio::time::sleep(Duration::from_millis(20)).await;
}
let mut successful = 0;
while successful < PUNCH_PACKETS {
if let Err(err) = conn.send_raw(&[0u8; 12], punch_addr).await {
log::error!("Failed to send empty packet: {err}");
} else {
successful += 1;
}
tokio::time::sleep(Duration::from_millis(20)).await;
}
let mut detector = DtmfDetector::new(payload_type);
let mut mbuf = vec![0; 1500];
let (incoming_tx, incoming_rx) = mpsc::channel(10);
let (outgoing_tx, mut outgoing_rx) = mpsc::channel(10);
let mut current_output = None::<(tokio::task::JoinHandle<(u32, u16)>, CancellationToken)>;
let mut ts = 0;
let mut seq = 0;
select! {
_ = token.cancelled() => {
log::debug!("RTP session cancelled");
}
Hangup = handler.handle_call(participant, incoming_rx, outgoing_tx) => {
log::info!("hanging up")
}
_ = async {
loop {
select! {
res = conn.recv_raw(&mut mbuf) => {
let (len, _addr) = match res {
Ok(r) => r,
Err(e) => {
log::error!("Failed to receive RTP: {e}");
break;
}
};
if let Some(event) = detector.process_packet(&mbuf[..len]) && incoming_tx.send(event).await.is_err() {
break;
}
}
Some(action) = outgoing_rx.recv() => {
match action {
#[cfg(feature = "sound")]
CallAction::Play(sound) => {
if let Some((join_handle, cancel_token)) = current_output.take() {
cancel_token.cancel();
if let Ok(new) = join_handle.await {
(ts, seq) = new;
}
}
let cancel_token = token.child_token();
let cancel_token_clone = cancel_token.clone();
let peer_addr = peer_addr.clone();
let conn = conn.clone();
let join_handle = tokio::spawn(async move {
sound::play_sound(sound, conn, cancel_token, ssrc, ts, seq, peer_addr, payload_type.unwrap_or(0)).await
});
current_output = Some((join_handle, cancel_token_clone));
},
}
}
}
}
} => {
log::debug!("hangup due to error");
}
};
Ok(())
}
async fn build_rtp_conn(
payload_type: u8,
cancel_token: CancellationToken,
) -> rsipstack::Result<(UdpConnection, String, u16)> {
let mut conn = None;
static START_PORT: AtomicU16 = AtomicU16::new(0);
let mut port = 10000 + START_PORT.fetch_add(2, std::sync::atomic::Ordering::Relaxed) % 200;
for _ in 0..100 {
let local = SocketAddr::new("0.0.0.0".parse().unwrap(), port);
if let Ok(c) =
UdpConnection::create_connection(local, None, Some(cancel_token.clone())).await
{
conn = Some(c);
break;
} else {
log::error!("Failed to bind RTP socket, port: {port}");
}
port = 10000 + (port + 2) % 200;
}
if conn.is_none() {
return Err(rsipstack::Error::Error(
"Failed to bind RTP socket".to_string(),
));
}
let conn = conn.unwrap();
let codec = payload_type;
let codec_name = match codec {
0 => "PCMU",
8 => "PCMA",
_ => "Unknown",
};
let socketaddr: SocketAddr = conn.get_addr().addr.to_owned().try_into()?;
let sdp = format!(
"v=0\r\n\
o=- 0 0 IN IP4 {}\r\n\
s=rsipstack example\r\n\
c=IN IP4 {}\r\n\
t=0 0\r\n\
m=audio {} RTP/AVP {codec} 101\r\n\
a=rtpmap:{codec} {codec_name}/8000\r\n\
a=rtpmap:101 telephone-event/8000\r\n\
a=fmtp:101 0-16\r\n\
a=sendrecv\r\n",
socketaddr.ip(),
socketaddr.ip(),
socketaddr.port(),
);
log::debug!("RTP socket: {:?} {}", conn.get_addr(), sdp);
Ok((conn, sdp, port))
}
pub struct DtmfDetector {
dtmf_payload_type: Option<u8>,
inputs: [bool; 13],
}
impl DtmfDetector {
pub fn new(dtmf_payload_type: Option<u8>) -> Self {
Self {
dtmf_payload_type,
inputs: [false; 13],
}
}
pub fn process_packet(&mut self, packet: &[u8]) -> Option<CallEvent> {
let (pt, payload) = parse_rtp_packet(packet)?;
if self
.dtmf_payload_type
.is_some_and(|dtmf_payload_type| pt != dtmf_payload_type)
{
return None;
}
let (digit, end) = parse_dtmf_event(payload)?;
if let Some(state) = self.inputs.get_mut(digit as usize) {
match (end, *state) {
(true, true) => {
*state = false;
}
(false, false) => *state = true,
(true, false) | (false, true) => return None,
}
if end && *state {
*state = false;
}
}
Some(CallEvent::Input { digit, end })
}
}
fn parse_rtp_packet(data: &[u8]) -> Option<(u8, &[u8])> {
if data.len() < 12 {
return None;
}
let payload_type = data[1] & 0x7F;
Some((payload_type, &data[12..]))
}
fn parse_dtmf_event(payload: &[u8]) -> Option<(u8, bool)> {
if payload.len() < 4 {
return None;
}
let event = payload[0];
let end = (payload[1] & 0x80) != 0;
Some((event, end))
}