1use crate::{
2 call::{ActiveCallRef, refer_headers::ReferHeaderResolver, sip::Invitation},
3 callrecord::{
4 CallRecordFormatter, CallRecordManagerBuilder, CallRecordSender, DefaultCallRecordFormatter,
5 },
6 config::Config,
7 locator::RewriteTargetLocator,
8 sipflow::{SipFlow, SipFlowUploadHook},
9 useragent::{
10 RegisterOption,
11 invitation::{
12 FnCreateInvitationHandler, PendingDialog, PendingDialogGuard,
13 default_create_invite_handler,
14 },
15 peer_learning::{PeerAddressLearner, SharedLearnedPeers},
16 public_address::{
17 LearningMessageInspector, SharedPublicAddress, build_contact, build_public_contact_uri,
18 find_local_addr_for_uri,
19 },
20 registration::{RegistrationHandle, UserCredential},
21 },
22};
23
24use crate::media::{cache::set_cache_dir, engine::StreamEngine};
25use anyhow::Result;
26use arc_swap::ArcSwap;
27use async_trait::async_trait;
28use chrono::{DateTime, Local};
29use futures::FutureExt;
30use humantime::parse_duration;
31use rsipstack::rsip::prelude::HeadersExt;
32use rsipstack::rsip::{Accept, Method, typed};
33use rsipstack::transaction::{
34 Endpoint, TransactionReceiver,
35 endpoint::{TargetLocator, TransportEventInspector},
36};
37use rsipstack::transport::transport_layer::DomainResolver;
38use rsipstack::{dialog::dialog_layer::DialogLayer, transaction::endpoint::MessageInspector};
39use rsipstack::{
40 rsip::{Host, HostWithPort},
41 transport::SipAddr,
42};
43use std::future::pending;
44use std::panic::{AssertUnwindSafe, catch_unwind};
45use std::str::FromStr;
46use std::sync::{Arc, RwLock};
47use std::time::Duration;
48use std::{collections::HashMap, net::SocketAddr};
49use std::{collections::HashSet, time::Instant};
50use std::{
51 path::Path,
52 sync::atomic::{AtomicBool, AtomicU64, Ordering},
53};
54use tokio::select;
55use tokio::sync::Mutex;
56use tokio_util::sync::CancellationToken;
57use tracing::{debug, info, warn};
58
59fn generate_short_session_id(invitation: &Invitation) -> String {
63 loop {
64 let uuid = uuid::Uuid::new_v4().simple().to_string();
65 let session_id = format!("s.{}", &uuid);
66 if !invitation.session_exists(&session_id) {
67 return session_id;
68 }
69 }
70}
71
72fn extract_via_source(request: &rsipstack::rsip::Request) -> (Option<std::net::IpAddr>, String) {
78 use rsipstack::rsip::ToTypedHeader;
79 let Ok(via) = request.via_header().and_then(|v| v.typed()) else {
80 return (None, String::new());
81 };
82 let source_ip = via
83 .received()
84 .and_then(|r| r.ok())
85 .or_else(|| match &via.sent_by().host {
86 rsipstack::rsip::Host::IpAddr(ip) => Some(*ip),
87 _ => None,
88 });
89 (source_ip, via.sent_by().host.to_string())
90}
91
92pub struct AppStateInner {
93 pub config: Arc<Config>,
94 pub token: CancellationToken,
95 pub stream_engine: Arc<StreamEngine>,
96 pub callrecord_sender: Option<CallRecordSender>,
97 pub endpoint: Endpoint,
98 pub registration_handles: Mutex<HashMap<String, CancellationToken>>,
99 pub alive_users: Arc<RwLock<HashSet<String>>>,
100 pub dialog_layer: Arc<DialogLayer>,
101 pub create_invitation_handler: Option<FnCreateInvitationHandler>,
102 pub invitation: Invitation,
103 pub routing_state: Arc<crate::call::RoutingState>,
104 pub pending_playbooks: Arc<Mutex<HashMap<String, (String, Instant)>>>,
105 pub sip_flow: Option<Arc<SipFlow>>,
108 pub learned_public_address: SharedPublicAddress,
109 pub learned_peers: crate::useragent::peer_learning::SharedLearnedPeers,
112 pub refer_header_resolver: Option<std::sync::Arc<dyn ReferHeaderResolver>>,
115
116 pub active_calls: Arc<std::sync::Mutex<HashMap<String, ActiveCallRef>>>,
117 pub total_calls: AtomicU64,
118 pub total_failed_calls: AtomicU64,
119 pub uptime: DateTime<Local>,
120 pub shutting_down: Arc<AtomicBool>,
121}
122
123pub type AppState = Arc<AppStateInner>;
124
125pub struct AppStateBuilder {
126 pub config: Option<Config>,
127 pub stream_engine: Option<Arc<StreamEngine>>,
128 pub callrecord_sender: Option<CallRecordSender>,
129 pub callrecord_formatter: Option<Arc<dyn CallRecordFormatter>>,
130 pub cancel_token: Option<CancellationToken>,
131 pub create_invitation_handler: Option<FnCreateInvitationHandler>,
132 pub config_path: Option<String>,
133
134 pub message_inspector: Option<Box<dyn MessageInspector>>,
135 pub target_locator: Option<Box<dyn TargetLocator>>,
136 pub transport_inspector: Option<Box<dyn TransportEventInspector>>,
137 pub refer_header_resolver: Option<std::sync::Arc<dyn ReferHeaderResolver>>,
138 pub sip_flow: Option<Arc<SipFlow>>,
142}
143
144impl AppStateInner {
145 pub fn auto_learn_public_address_enabled(&self) -> bool {
146 self.config.auto_learn_public_address.unwrap_or(false)
147 }
148
149 pub fn options_source_allowed(
154 &self,
155 source_ip: Option<std::net::IpAddr>,
156 source_host: &str,
157 ) -> bool {
158 if self.config.options_matches_static(source_ip, source_host) {
159 return true;
160 }
161 if !self.config.options_auto_learn() {
162 return false;
163 }
164 let ttl = self.config.options_learn_ttl();
165 match source_ip {
166 Some(ip) => self.learned_peers.contains_within(&ip, ttl),
167 None => false,
168 }
169 }
170
171 pub fn get_dump_events_file(&self, session_id: &String) -> String {
172 let recorder_root = self.config.recorder_path();
173 let root = Path::new(&recorder_root);
174 if !root.exists() {
175 match std::fs::create_dir_all(root) {
176 Ok(_) => {
177 info!("created dump events root: {}", root.to_string_lossy());
178 }
179 Err(e) => {
180 warn!(
181 "Failed to create dump events root: {} {}",
182 e,
183 root.to_string_lossy()
184 );
185 }
186 }
187 }
188 root.join(format!("{}.events.jsonl", session_id))
189 .to_string_lossy()
190 .to_string()
191 }
192
193 pub fn get_recorder_file(&self, session_id: &String) -> String {
194 let recorder_root = self.config.recorder_path();
195 let root = Path::new(&recorder_root);
196 if !root.exists() {
197 match std::fs::create_dir_all(root) {
198 Ok(_) => {
199 info!("created recorder root: {}", root.to_string_lossy());
200 }
201 Err(e) => {
202 warn!(
203 "Failed to create recorder root: {} {}",
204 e,
205 root.to_string_lossy()
206 );
207 }
208 }
209 }
210 let desired_ext = self.config.recorder_format().extension();
211 let mut filename = session_id.clone();
212 if !filename
213 .to_lowercase()
214 .ends_with(&format!(".{}", desired_ext.to_lowercase()))
215 {
216 filename = format!("{}.{}", filename, desired_ext);
217 }
218 root.join(filename).to_string_lossy().to_string()
219 }
220
221 pub async fn serve(self: Arc<Self>) -> Result<()> {
222 let incoming_txs = self.endpoint.incoming_transactions()?;
223 let token = self.token.child_token();
224 let endpoint_inner = self.endpoint.inner.clone();
225 let dialog_layer = self.dialog_layer.clone();
226 let app_state_clone = self.clone();
227
228 match self.start_registration().await {
229 Ok(count) => {
230 info!("registration started, count: {}", count);
231 }
232 Err(e) => {
233 warn!("failed to start registration: {:?}", e);
234 }
235 }
236
237 let pending_cleanup_state = self.clone();
238 let pending_cleanup_token = token.clone();
239 crate::spawn(async move {
240 let mut interval = tokio::time::interval(Duration::from_secs(60));
241 let ttl = Duration::from_secs(300);
242 loop {
243 tokio::select! {
244 _ = pending_cleanup_token.cancelled() => break,
245 _ = interval.tick() => {
246 let mut pending = pending_cleanup_state.pending_playbooks.lock().await;
247 let before = pending.len();
248 pending.retain(|_, (_, created_at)| created_at.elapsed() < ttl);
249 let removed = before - pending.len();
250 if removed > 0 {
251 info!(removed, remaining = pending.len(), "cleaned up stale pending_playbooks entries");
252 }
253 }
254 }
255 }
256 });
257
258 tokio::select! {
259 _ = token.cancelled() => {
260 info!("cancelled");
261 }
262 result = endpoint_inner.serve() => {
263 if let Err(e) = result {
264 info!("endpoint serve error: {:?}", e);
265 }
266 }
267 result = app_state_clone.process_incoming_request(dialog_layer.clone(), incoming_txs) => {
268 if let Err(e) = result {
269 info!("process incoming request error: {:?}", e);
270 }
271 },
272 }
273
274 let total_secs = self.config.graceful_shutdown_timeout.unwrap_or(30);
275 let timeout = self
276 .config
277 .graceful_shutdown
278 .map(|_| Duration::from_secs(total_secs));
279
280 match self.stop_registration(timeout).await {
281 Ok(_) => {
282 info!("registration stopped, waiting for clear");
283 }
284 Err(e) => {
285 warn!("failed to stop registration: {:?}", e);
286 }
287 }
288 info!("stopping");
289 Ok(())
290 }
291
292 async fn process_incoming_request(
293 self: Arc<Self>,
294 dialog_layer: Arc<DialogLayer>,
295 mut incoming: TransactionReceiver,
296 ) -> Result<()> {
297 while let Some(mut tx) = incoming.recv().await {
298 let key: &rsipstack::transaction::key::TransactionKey = &tx.key;
299 info!(?key, "received transaction");
300 if tx.original.to_header()?.tag()?.as_ref().is_some() {
301 match dialog_layer.match_dialog(&tx) {
302 Some(mut d) => {
303 crate::spawn(async move {
304 match d.handle(&mut tx).await {
305 Ok(_) => (),
306 Err(e) => {
307 info!("error handling transaction: {:?}", e);
308 }
309 }
310 });
311 continue;
312 }
313 None => {
314 info!("dialog not found: {}", tx.original);
315 match tx
316 .reply(rsipstack::rsip::StatusCode::CallTransactionDoesNotExist)
317 .await
318 {
319 Ok(_) => (),
320 Err(e) => {
321 info!("error replying to request: {:?}", e);
322 }
323 }
324 continue;
325 }
326 }
327 }
328 let (state_sender, state_receiver) = dialog_layer.new_dialog_state_channel();
330 match tx.original.method {
331 rsipstack::rsip::Method::Invite | rsipstack::rsip::Method::Ack => {
332 if self.shutting_down.load(Ordering::Relaxed) {
334 info!(?key, "rejecting INVITE during graceful shutdown");
335 match tx
336 .reply_with(
337 rsipstack::rsip::StatusCode::ServiceUnavailable,
338 vec![rsipstack::rsip::Header::Other(
339 "Reason".into(),
340 "SIP;cause=503;text=\"Server shutting down\"".into(),
341 )],
342 None,
343 )
344 .await
345 {
346 Ok(_) => (),
347 Err(e) => {
348 info!("error replying to request: {:?}", e);
349 }
350 }
351 continue;
352 }
353
354 let invitation_handler = match self.create_invitation_handler {
355 Some(ref create_invitation_handler) => {
356 create_invitation_handler(self.config.handler.as_ref()).ok()
357 }
358 _ => default_create_invite_handler(
359 self.config.handler.as_ref(),
360 Some(self.clone()),
361 ),
362 };
363 let invitation_handler = match invitation_handler {
364 Some(h) => h,
365 None => {
366 info!(?key, "no invite handler configured, rejecting INVITE");
367 match tx
368 .reply_with(
369 rsipstack::rsip::StatusCode::ServiceUnavailable,
370 vec![rsipstack::rsip::Header::Other(
371 "Reason".into(),
372 "SIP;cause=503;text=\"No invite handler configured\""
373 .into(),
374 )],
375 None,
376 )
377 .await
378 {
379 Ok(_) => (),
380 Err(e) => {
381 info!("error replying to request: {:?}", e);
382 }
383 }
384 continue;
385 }
386 };
387 let local_addr = tx
388 .connection
389 .as_ref()
390 .map(|connection| connection.get_addr().clone())
391 .or_else(|| dialog_layer.endpoint.get_addrs().first().cloned());
392 let contact_username =
393 tx.original.uri.auth.as_ref().map(|auth| auth.user.as_str());
394 let contact = local_addr.as_ref().map(|addr| {
395 build_public_contact_uri(
396 &self.learned_public_address,
397 self.auto_learn_public_address_enabled(),
398 addr,
399 contact_username,
400 None,
401 )
402 });
403
404 let dialog = match dialog_layer.get_or_create_server_invite(
405 &tx,
406 state_sender,
407 None,
408 contact,
409 ) {
410 Ok(d) => d,
411 Err(e) => {
412 info!("failed to obtain dialog: {:?}", e);
414 match tx
415 .reply(rsipstack::rsip::StatusCode::CallTransactionDoesNotExist)
416 .await
417 {
418 Ok(_) => (),
419 Err(e) => {
420 info!("error replying to request: {:?}", e);
421 }
422 }
423 continue;
424 }
425 };
426
427 let dialog_id = dialog.id();
428 let dialog_id_str = dialog_id.to_string();
429 let session_id = if dialog_id_str.len() > 64 { generate_short_session_id(&self.invitation) } else { dialog_id_str.clone() };
430 if let Some(flow) = self.sip_flow.as_ref() {
433 flow.associate(&session_id, &dialog_id.call_id);
434 }
435 let dialog_id_for_cleanup = dialog_id.clone();
436 let token = self.token.child_token();
437 let pending_dialog = PendingDialog {
438 token: token.clone(),
439 dialog: dialog.clone(),
440 state_receiver,
441 };
442
443 let guard = Arc::new(PendingDialogGuard::new_with_session(
444 self.invitation.clone(),
445 dialog_id,
446 session_id.clone(),
447 pending_dialog,
448 ));
449
450 let accept_timeout = self
451 .config
452 .accept_timeout
453 .as_ref()
454 .and_then(|t| parse_duration(t).ok())
455 .unwrap_or_else(|| Duration::from_secs(60));
456
457 let mut dialog_ref = dialog.clone();
458 let routing_state = self.routing_state.clone();
459 let dialog_for_reject = dialog.clone();
460 let invitation_for_cleanup = self.invitation.clone();
461 let active_calls_for_task = self.active_calls.clone();
462 let session_id_for_task = session_id.clone();
463 crate::spawn(async move {
464 info!(
465 session_id = session_id_for_task,
466 id = dialog_id_str,
467 "incoming invite task started"
468 );
469 let _pending_guard = guard;
470 let token_ref = token.clone();
471 let accept_timeout_sleep = tokio::time::sleep(accept_timeout);
472 let invite_handler = invitation_handler.on_invite(
473 session_id_for_task.clone(),
474 token.clone(),
475 dialog.clone(),
476 routing_state,
477 );
478 let dialog_handle = dialog_ref.handle(&mut tx);
479 tokio::pin!(accept_timeout_sleep);
480 tokio::pin!(invite_handler);
481 tokio::pin!(dialog_handle);
482
483 let mut cancel_done = false;
484 let mut accept_timeout_done = false;
485 let mut invite_done = false;
486 loop {
487 let mut reject_request = None;
488
489 select! {
490 _ = token_ref.cancelled(), if !cancel_done => {
491 cancel_done = true;
492 reject_request = Some((
493 rsipstack::rsip::StatusCode::ServiceUnavailable,
494 "invite cancelled".to_string(),
495 "cancelled",
496 ));
497 }
498 _ = &mut accept_timeout_sleep, if !accept_timeout_done
499 && dialog_for_reject.state().can_cancel() => {
500 accept_timeout_done = true;
501 reject_request = Some((
502 rsipstack::rsip::StatusCode::RequestTimeout,
503 "accept timeout".to_string(),
504 "accept timeout",
505 ));
506 }
507 result = &mut invite_handler, if !invite_done => {
508 invite_done = true;
509 match result {
510 Ok(_) => {
511 info!(id = dialog_id_str, "invite handler completed");
512 }
513 Err(e) => {
514 info!(id = dialog_id_str, "error handling invite: {:?}", e);
515 reject_request = Some((
516 rsipstack::rsip::StatusCode::ServiceUnavailable,
517 format!("Failed to process invite: {}", e),
518 "invite handler error",
519 ));
520 }
521 }
522 }
523 result = &mut dialog_handle => {
524 match result {
525 Ok(_) => {
526 info!(id = dialog_id_str, "dialog handling finished");
527 }
528 Err(e) => {
529 info!(
530 id = dialog_id_str,
531 "dialog handling ended with error: {:?}", e
532 );
533 }
534 }
535 if let rsipstack::dialog::dialog::DialogState::Terminated(
536 _,
537 reason,
538 ) = dialog_for_reject.state()
539 {
540 info!(
541 id = dialog_id_str,
542 "terminated invite dialog finished, cancelling invite token"
543 );
544 token_ref.cancel();
545
546 let maybe_call = active_calls_for_task
556 .lock()
557 .unwrap()
558 .get(&session_id_for_task)
559 .cloned();
560 if let Some(call) = maybe_call {
561 let has_reason = call
562 .progress
563 .load_full()
564 .hangup_reason
565 .is_some();
566 if !has_reason {
567 let term =
568 crate::call::state::CallProgress::termination(
569 Some(&reason),
570 );
571 call.leg().update_progress(|p| {
572 p.last_status_code = term.status_code;
573 p.set_hangup_reason(
574 term.hangup_reason.clone(),
575 );
576 });
577 let event = call.leg().build_hangup_event(
578 call.session_id.clone(),
579 Some(term.initiator.to_string()),
580 );
581 call.event_sender.send(event).ok();
582 }
583 call.cancel_token.cancel();
584 }
585 }
586 info!(id = dialog_id_str, "incoming invite task finished");
587 break;
588 }
589 }
590
591 if let Some((code, reason, source)) = reject_request {
592 if dialog_for_reject.state().can_cancel() {
593 info!(
594 id = dialog_id_str,
595 ?code,
596 %reason,
597 source,
598 "rejecting invite"
599 );
600 if let Err(e) =
601 dialog_for_reject.reject(Some(code), Some(reason))
602 {
603 info!(
604 id = dialog_id_str,
605 "error rejecting invite: {:?}", e
606 );
607 }
608 invitation_for_cleanup.get_pending_call(&dialog_id_for_cleanup);
609 invitation_for_cleanup
610 .dialog_layer
611 .remove_dialog(&dialog_id_for_cleanup);
612 }
613 }
614 }
615 });
616 }
617 rsipstack::rsip::Method::Options => {
618 if self.config.options_response_enabled() {
619 let (source_ip, source_host) = extract_via_source(&tx.original);
620 if self.options_source_allowed(source_ip, &source_host) {
621 info!(?key, %source_host, "responding to out-of-dialog OPTIONS request");
622 let mut headers = vec![
623 {
624 let allow_header: rsipstack::rsip::Header =
625 typed::Allow::from(Method::all()).into();
626 allow_header
627 },
628 rsipstack::rsip::Header::Accept(Accept::new("application/sdp")),
629 ];
630 let extra_headers = self.config.options_extra_headers();
631 if !extra_headers.is_empty() {
632 headers.extend(crate::sip_util::sip_headers_from_map(
633 &extra_headers.into_iter().collect::<HashMap<_, _>>(),
634 ));
635 }
636 match tx
637 .reply_with(rsipstack::rsip::StatusCode::OK, headers, None)
638 .await
639 {
640 Ok(_) => (),
641 Err(e) => {
642 info!("error replying to OPTIONS: {:?}", e);
643 }
644 }
645 } else {
646 debug!(
647 ?key,
648 %source_host,
649 "dropping OPTIONS probe from non-allowed source"
650 );
651 }
652 } else {
653 info!(?key, "ignoring out-of-dialog OPTIONS request");
654 }
655 continue;
656 }
657 rsipstack::rsip::Method::Refer => {
658 info!(?key, "ignoring out-of-dialog REFER");
659 match tx.reply(rsipstack::rsip::StatusCode::BadRequest).await {
660 Ok(_) => (),
661 Err(e) => {
662 info!("error replying to out-of-dialog REFER: {:?}", e);
663 }
664 }
665 continue;
666 }
667 _ => {
668 info!(?key, "received request: {:?}", tx.original.method);
669 match tx.reply(rsipstack::rsip::StatusCode::OK).await {
670 Ok(_) => (),
671 Err(e) => {
672 info!("error replying to request: {:?}", e);
673 }
674 }
675 }
676 }
677 }
678 Ok(())
679 }
680
681 pub fn stop(&self) {
682 if self.shutting_down.swap(true, Ordering::Relaxed) {
683 return;
684 }
685 info!("stopping, marking as shutting down");
686 self.token.cancel();
687 }
688
689 pub async fn graceful_stop(&self, total_timeout_secs: u64) -> Result<()> {
690 if self.shutting_down.swap(true, Ordering::Relaxed) {
691 return Ok(());
692 }
693
694 info!("graceful stopping, marking as shutting down");
695 let timeout = Duration::from_secs(total_timeout_secs);
696
697 let (reg_result, ()) = tokio::join!(
698 self.stop_registration(Some(timeout)),
699 self.wait_for_active_calls(timeout),
700 );
701 if let Err(e) = reg_result {
702 warn!("stop_registration error: {}", e);
703 }
704 self.token.cancel();
705 Ok(())
706 }
707
708 async fn wait_for_active_calls(&self, timeout: Duration) {
709 let active_calls = self.active_calls.clone();
710 let check_loop = async move {
711 let mut last_count = usize::MAX;
712 loop {
713 let count = active_calls.lock().unwrap().len();
714 if count == 0 {
715 break;
716 }
717 if count != last_count {
718 info!(active_calls = count, "waiting for active calls to finish");
719 last_count = count;
720 }
721 tokio::time::sleep(Duration::from_millis(500)).await;
722 }
723 };
724 match tokio::time::timeout(timeout, check_loop).await {
725 Ok(()) => info!("all active calls finished"),
726 Err(_) => warn!("timed out waiting for active calls to finish, forcing shutdown"),
727 }
728 }
729
730 pub async fn start_registration(&self) -> Result<usize> {
731 let mut count = 0;
732 if let Some(register_users) = &self.config.register_users {
733 for option in register_users.iter() {
734 match self.register(option.clone()).await {
735 Ok(_) => {
736 count += 1;
737 }
738 Err(e) => {
739 warn!("failed to register user: {:?} {:?}", e, option);
740 }
741 }
742 }
743 }
744 Ok(count)
745 }
746
747 pub fn find_credentials_for_callee(&self, callee: &str) -> Option<UserCredential> {
748 let callee_uri = crate::sip_util::ensure_sip_scheme(callee.to_string());
749
750 let parsed_callee = match rsipstack::rsip::Uri::try_from(callee_uri.as_str()) {
751 Ok(uri) => uri,
752 Err(e) => {
753 warn!("failed to parse callee URI: {} {:?}", callee, e);
754 return None;
755 }
756 };
757
758 match &parsed_callee.host_with_port.host {
761 rsipstack::rsip::Host::Domain(domain) => {
762 let domain = domain.0.clone();
763 self.find_credentials(
764 callee,
765 &format!("domain {}", domain),
766 |host| matches!(host, rsipstack::rsip::Host::Domain(d) if d.0 == domain),
767 )
768 }
769 rsipstack::rsip::Host::IpAddr(ip) => {
770 let ip = *ip;
771 self.find_credentials(callee, "IP match", move |host| {
772 matches!(host, rsipstack::rsip::Host::IpAddr(server_ip) if *server_ip == ip)
773 })
774 }
775 }
776 }
777
778 fn find_credentials(
781 &self,
782 callee: &str,
783 match_type: &str,
784 pred: impl Fn(&rsipstack::rsip::Host) -> bool,
785 ) -> Option<UserCredential> {
786 let register_users = self.config.register_users.as_ref()?;
787 for option in register_users.iter() {
788 let server = crate::sip_util::ensure_sip_scheme(option.server.clone());
789
790 let parsed_server = match rsipstack::rsip::Uri::try_from(server.as_str()) {
791 Ok(uri) => uri,
792 Err(e) => {
793 warn!("failed to parse server URI: {} {:?}", option.server, e);
794 continue;
795 }
796 };
797
798 if pred(&parsed_server.host_with_port.host) {
799 if let Some(cred) = &option.credential {
800 info!(
801 callee,
802 username = cred.username,
803 server = option.server,
804 match_type,
805 "Auto-injecting credentials from registered user for outbound call"
806 );
807 return Some(cred.clone());
808 }
809 }
810 }
811 None
812 }
813
814 pub async fn stop_registration(&self, wait_for_clear: Option<Duration>) -> Result<()> {
815 {
816 let mut handles = self.registration_handles.lock().await;
817 for (_, cancel_token) in handles.drain() {
818 cancel_token.cancel();
819 }
820 }
821
822 if let Some(duration) = wait_for_clear {
823 let live_users = self.alive_users.clone();
824 let check_loop = async move {
825 loop {
826 let is_empty = {
827 let users = live_users
828 .read()
829 .map_err(|_| anyhow::anyhow!("Lock poisoned"))?;
830 users.is_empty()
831 };
832 if is_empty {
833 break;
834 }
835 tokio::time::sleep(Duration::from_millis(50)).await;
836 }
837 Ok::<(), anyhow::Error>(())
838 };
839 match tokio::time::timeout(duration, check_loop).await {
840 Ok(_) => {}
841 Err(e) => {
842 warn!("failed to wait for clear: {}", e);
843 return Err(anyhow::anyhow!("failed to wait for clear: {}", e));
844 }
845 }
846 }
847 Ok(())
848 }
849
850 pub async fn register(&self, option: RegisterOption) -> Result<()> {
851 let user = option.aor();
852 let server = crate::sip_util::ensure_sip_scheme(option.server.clone());
853 let sip_server = match rsipstack::rsip::Uri::try_from(server) {
854 Ok(uri) => uri,
855 Err(e) => {
856 warn!("failed to parse server: {} {:?}", e, option.server);
857 return Err(anyhow::anyhow!("failed to parse server: {}", e));
858 }
859 };
860 let cancel_token = self.token.child_token();
861 let credential = option.credential.clone().map(|c| c.into());
862 let registration = rsipstack::dialog::registration::Registration::new(
863 self.endpoint.inner.clone(),
864 credential,
865 );
866 let mut handle = RegistrationHandle {
867 registration,
868 option,
869 cancel_token: cancel_token.clone(),
870 start_time: Instant::now(),
871 last_update: Instant::now(),
872 last_response: None,
873 };
874 self.registration_handles
875 .lock()
876 .await
877 .insert(user.clone(), cancel_token);
878 tracing::debug!(user = user.as_str(), "starting registration task");
879 let alive_users = self.alive_users.clone();
880
881 crate::spawn(async move {
882 handle.start_time = Instant::now();
883 let cancel_token = handle.cancel_token.clone();
884 let addrs = handle.registration.endpoint.get_addrs();
885 let local_bind_addr = if let Some(addr) = find_local_addr_for_uri(&addrs, &sip_server) {
886 addr
887 } else {
888 warn!(
889 user = user.as_str(),
890 server = %sip_server,
891 "failed to get local bind address for registration transport"
892 );
893 alive_users.write().unwrap().remove(&user);
894 return;
895 };
896 let user = handle.option.aor();
897 alive_users.write().unwrap().remove(&user);
898 let mut contact_address = local_bind_addr.addr.clone();
899 let mut contact = build_contact(
900 &local_bind_addr,
901 Some(contact_address.clone()),
902 Some(handle.option.username.as_str()),
903 None,
904 );
905 let mut should_register = true;
906 let mut timer = pending().boxed();
907
908 loop {
909 select! {
910 _ = cancel_token.cancelled() => {
911 break;
912 }
913 _ = timer.as_mut(), if !should_register => {
914 should_register = true;
915 timer = Box::pin(pending());
916 }
917 result = handle.do_register(&sip_server, None, &contact), if should_register => {
918 match result {
919 Ok((expires, new_addr)) => {
920 if handle
921 .should_retry_registration_now(
922 &local_bind_addr,
923 &contact_address,
924 new_addr.as_ref(),
925 )
926 {
927 if let Some(next_contact_address) = new_addr {
928 info!(
929 user = user.as_str(),
930 current_contact = %contact_address,
931 next_contact = %next_contact_address,
932 "public address changed, retrying registration immediately",
933 );
934 contact_address = next_contact_address;
935 contact = build_contact(
936 &local_bind_addr,
937 Some(contact_address.clone()),
938 Some(handle.option.username.as_str()),
939 None,
940 );
941 continue;
942 }
943 }
944 info!(
945 user = user.as_str(),
946 expires = expires,
947 contact = %contact_address,
948 alive_users = alive_users.read().unwrap().len(),
949 "registration refreshed",
950 );
951 alive_users.write().unwrap().insert(user.clone());
952 should_register = false;
953 timer = Box::pin(tokio::time::sleep(Duration::from_secs(
954 (expires * 3 / 4) as u64,
955 )));
956 }
957 Err(e) => {
958 warn!(
959 user = user.as_str(),
960 alive_users = alive_users.read().unwrap().len(),
961 "registration failed: {:?}", e
962 );
963 should_register = false;
964 timer = Box::pin(tokio::time::sleep(Duration::from_secs(60)));
965 }
966 }
967 }
968 }
969 }
970 handle
971 .do_register(&sip_server, Some(0), &contact)
972 .await
973 .ok();
974 alive_users.write().unwrap().remove(&user);
975 });
976 Ok(())
977 }
978}
979
980impl Drop for AppStateInner {
981 fn drop(&mut self) {
982 self.stop();
983 }
984}
985
986struct SimpleDomainResolver;
987
988#[async_trait]
989impl DomainResolver for SimpleDomainResolver {
990 async fn resolve(&self, target: &SipAddr) -> rsipstack::Result<SipAddr> {
991 match &target.addr.host {
992 Host::Domain(domain) => {
993 let port: u16 = target.addr.port.map(|p| p.value()).unwrap_or(5060);
994 let addr_str = format!("{}:{}", domain, port);
995 match tokio::net::lookup_host(&addr_str).await {
996 Ok(mut addrs) => {
997 if let Some(addr) = addrs.next() {
998 Ok(SipAddr {
999 r#type: target.r#type,
1000 addr: HostWithPort {
1001 host: Host::IpAddr(addr.ip()),
1002 port: Some(rsipstack::rsip::Port(addr.port())),
1003 },
1004 })
1005 } else {
1006 Err(rsipstack::Error::DnsResolutionError(format!(
1007 "no addresses found for {}",
1008 domain
1009 )))
1010 }
1011 }
1012 Err(e) => Err(rsipstack::Error::DnsResolutionError(format!(
1013 "DNS resolution failed for {}: {}",
1014 domain, e
1015 ))),
1016 }
1017 }
1018 _ => Ok(target.clone()),
1019 }
1020 }
1021}
1022
1023impl AppStateBuilder {
1024 pub fn new() -> Self {
1025 Self {
1026 config: None,
1027 stream_engine: None,
1028 callrecord_sender: None,
1029 callrecord_formatter: None,
1030 cancel_token: None,
1031 create_invitation_handler: None,
1032 config_path: None,
1033 message_inspector: None,
1034 target_locator: None,
1035 transport_inspector: None,
1036 refer_header_resolver: None,
1037 sip_flow: None,
1038 }
1039 }
1040
1041 pub fn with_config(mut self, config: Config) -> Self {
1042 self.config = Some(config);
1043 self
1044 }
1045
1046 pub fn with_stream_engine(mut self, stream_engine: Arc<StreamEngine>) -> Self {
1047 self.stream_engine = Some(stream_engine);
1048 self
1049 }
1050
1051 pub fn with_callrecord_sender(mut self, sender: CallRecordSender) -> Self {
1052 self.callrecord_sender = Some(sender);
1053 self
1054 }
1055
1056 pub fn with_cancel_token(mut self, token: CancellationToken) -> Self {
1057 self.cancel_token = Some(token);
1058 self
1059 }
1060
1061 pub fn with_config_metadata(mut self, path: Option<String>) -> Self {
1062 self.config_path = path;
1063 self
1064 }
1065
1066 pub fn with_inspector(&mut self, inspector: Box<dyn MessageInspector>) -> &mut Self {
1067 self.message_inspector = Some(inspector);
1068 self
1069 }
1070 pub fn with_target_locator(&mut self, locator: Box<dyn TargetLocator>) -> &mut Self {
1071 self.target_locator = Some(locator);
1072 self
1073 }
1074
1075 pub fn with_transport_inspector(
1076 &mut self,
1077 inspector: Box<dyn TransportEventInspector>,
1078 ) -> &mut Self {
1079 self.transport_inspector = Some(inspector);
1080 self
1081 }
1082
1083 pub fn with_refer_header_resolver(
1087 mut self,
1088 resolver: std::sync::Arc<dyn ReferHeaderResolver>,
1089 ) -> Self {
1090 self.refer_header_resolver = Some(resolver);
1091 self
1092 }
1093
1094 pub fn with_sipflow(mut self, sip_flow: Arc<SipFlow>) -> Self {
1097 self.sip_flow = Some(sip_flow);
1098 self
1099 }
1100
1101 pub async fn build(mut self) -> Result<AppState> {
1102 let config: Arc<Config> = Arc::new(self.config.unwrap_or_default());
1103 let token = self
1104 .cancel_token
1105 .unwrap_or_else(|| CancellationToken::new());
1106 let _ = set_cache_dir(&config.media_cache_path);
1107 let local_ip = if !config.addr.is_empty() {
1108 std::net::IpAddr::from_str(config.addr.as_str())?
1109 } else {
1110 crate::net_tool::get_first_non_loopback_interface()?
1111 };
1112 let transport_layer = match catch_unwind(AssertUnwindSafe(|| {
1113 rsipstack::transport::TransportLayer::new(token.clone())
1114 })) {
1115 Ok(tl) => tl,
1116 Err(_) => {
1117 warn!(
1118 "failed to initialize default DNS resolver with hickory-resolver, falling back to simple resolver via tokio::net::lookup_host"
1119 );
1120 rsipstack::transport::TransportLayer::new_with_domain_resolver(
1121 token.clone(),
1122 Box::new(SimpleDomainResolver),
1123 )
1124 }
1125 };
1126 let local_addr: SocketAddr = format!("{}:{}", local_ip, config.udp_port).parse()?;
1127
1128 #[cfg(unix)]
1130 let std_socket = {
1131 use socket2::{Domain, Protocol, SockAddr, Socket, Type};
1132
1133 let domain = if local_addr.is_ipv4() {
1134 Domain::IPV4
1135 } else {
1136 Domain::IPV6
1137 };
1138 let socket = Socket::new(domain, Type::DGRAM, Some(Protocol::UDP))
1139 .map_err(|err| anyhow::anyhow!("Failed to create UDP socket: {}", err))?;
1140
1141 socket
1142 .set_reuse_address(true)
1143 .map_err(|err| anyhow::anyhow!("Failed to set SO_REUSEADDR: {}", err))?;
1144
1145 #[cfg(not(any(target_os = "solaris", target_os = "illumos", target_os = "cygwin")))]
1147 socket
1148 .set_reuse_port(true)
1149 .map_err(|err| anyhow::anyhow!("Failed to set SO_REUSEPORT: {}", err))?;
1150
1151 socket
1152 .bind(&SockAddr::from(local_addr))
1153 .map_err(|err| anyhow::anyhow!("Failed to bind UDP socket: {}", err))?;
1154
1155 let std_socket: std::net::UdpSocket = socket.into();
1156 std_socket
1157 };
1158
1159 #[cfg(not(unix))]
1160 let std_socket = std::net::UdpSocket::bind(local_addr)?;
1161
1162 std_socket.set_nonblocking(true)?;
1163 let tokio_socket = tokio::net::UdpSocket::from_std(std_socket)?;
1164 let actual_addr = tokio_socket.local_addr()?;
1166 let bind_addr = rsipstack::transport::SipConnection::resolve_bind_address(actual_addr);
1167 let mut learned_public_address: SharedPublicAddress =
1168 Arc::new(ArcSwap::from_pointee(bind_addr.into()));
1169 let learned_peers =
1170 SharedLearnedPeers::new(crate::useragent::peer_learning::LEARNED_PEERS_CAPACITY);
1171
1172 let udp_inner = rsipstack::transport::udp::UdpInner {
1173 conn: std::sync::Arc::new(tokio_socket),
1174 addr: rsipstack::transport::SipAddr {
1175 r#type: Some(rsipstack::rsip::transport::Transport::Udp),
1176 addr: bind_addr.into(),
1177 },
1178 };
1179
1180 let external = config
1181 .external_ip
1182 .as_ref()
1183 .map(|ip| {
1184 format!("{}:{}", ip, actual_addr.port())
1185 .parse()
1186 .map_err(|e| anyhow::anyhow!("Failed to parse external address: {}", e))
1187 })
1188 .transpose()?;
1189
1190 let udp_conn = rsipstack::transport::udp::UdpConnection::attach(
1191 udp_inner,
1192 external,
1193 Some(token.child_token()),
1194 )
1195 .await;
1196
1197 info!(
1198 "start useragent, addr: {} (SO_REUSEPORT enabled)",
1199 udp_conn.get_addr()
1200 );
1201
1202 transport_layer.add_transport(udp_conn.into());
1203
1204 if let Some(tls_port) = config.tls_port {
1206 let tls_addr: std::net::SocketAddr = format!("{}:{}", local_ip, tls_port).parse()?;
1207 let mut tls_cfg = rsipstack::transport::tls::TlsConfig::default();
1208 if let Some(ref cert_path) = config.tls_cert_file {
1209 tls_cfg.cert = Some(
1210 std::fs::read(cert_path)
1211 .map_err(|e| anyhow::anyhow!("tls_cert_file: {}", e))?,
1212 );
1213 }
1214 if let Some(ref key_path) = config.tls_key_file {
1215 tls_cfg.key = Some(
1216 std::fs::read(key_path).map_err(|e| anyhow::anyhow!("tls_key_file: {}", e))?,
1217 );
1218 }
1219 let external_tls_addr = config
1220 .external_ip
1221 .as_ref()
1222 .and_then(|ip| format!("{}:{}", ip, tls_port).parse().ok());
1223 match rsipstack::transport::tls::TlsListenerConnection::new(
1224 tls_addr,
1225 external_tls_addr,
1226 tls_cfg,
1227 )
1228 .await
1229 {
1230 Ok(tls_conn) => {
1231 transport_layer.add_transport(tls_conn.into());
1232 info!("TLS SIP transport started on {}:{}", local_ip, tls_port);
1233 }
1234 Err(e) => {
1235 return Err(anyhow::anyhow!("Failed to start TLS SIP transport: {}", e));
1236 }
1237 }
1238 }
1239
1240 let endpoint_option = rsipstack::transaction::endpoint::EndpointOption::default();
1241 let mut endpoint_builder = rsipstack::EndpointBuilder::new();
1242 if let Some(ref user_agent) = config.useragent {
1243 endpoint_builder.with_user_agent(user_agent.as_str());
1244 }
1245
1246 let mut endpoint_builder = endpoint_builder
1247 .with_cancel_token(token.child_token())
1248 .with_transport_layer(transport_layer)
1249 .with_option(endpoint_option);
1250
1251 let mut next_inspector = self.message_inspector.take();
1255 if config.options_auto_learn() {
1256 info!("learning call-traffic peer addresses for OPTIONS ACL");
1257 next_inspector = Some(Box::new(PeerAddressLearner::new_with_next(
1258 learned_peers.clone(),
1259 next_inspector,
1260 )));
1261 }
1262 if config.auto_learn_public_address.unwrap_or_default() {
1263 let inspector = LearningMessageInspector::new(bind_addr.into(), next_inspector);
1264 learned_public_address = inspector.shared_public_address();
1265 next_inspector = Some(Box::new(inspector));
1266 }
1267
1268 let sip_flow = match self.sip_flow.take() {
1273 Some(flow) => Some(flow),
1274 None => match config.sipflow.as_ref().filter(|c| c.enabled()) {
1275 Some(sipflow_config) => {
1276 info!(
1277 max_calls = sipflow_config.max_calls(),
1278 max_items_per_call = sipflow_config.max_items_per_call(),
1279 upload = sipflow_config.upload.is_some(),
1280 "sipflow signaling capture enabled"
1281 );
1282 Some(Arc::new(SipFlow::new(
1283 sipflow_config.clone(),
1284 bind_addr.to_string(),
1285 None,
1286 )))
1287 }
1288 None => None,
1289 },
1290 };
1291 if let Some(flow) = sip_flow.as_ref() {
1292 flow.set_next(next_inspector.take());
1293 next_inspector = Some(Box::new(SipFlow::clone(flow)));
1294 }
1295
1296 if let Some(inspector) = next_inspector {
1297 endpoint_builder = endpoint_builder.with_inspector(inspector);
1298 }
1299 if let Some(locator) = self.target_locator {
1300 endpoint_builder.with_target_locator(locator);
1301 } else if let Some(ref rules) = config.rewrites {
1302 endpoint_builder
1303 .with_target_locator(Box::new(RewriteTargetLocator::new(rules.clone())));
1304 }
1305
1306 if let Some(inspector) = self.transport_inspector {
1307 endpoint_builder = endpoint_builder.with_transport_inspector(inspector);
1308 }
1309
1310 let endpoint = endpoint_builder.build();
1311 let dialog_layer = Arc::new(DialogLayer::new(endpoint.inner.clone()));
1312
1313 let stream_engine = self.stream_engine.unwrap_or_default();
1314
1315 let callrecord_formatter = if let Some(formatter) = self.callrecord_formatter {
1316 formatter
1317 } else {
1318 let formatter = if let Some(ref callrecord) = config.callrecord {
1319 DefaultCallRecordFormatter::new_with_config(callrecord)
1320 } else {
1321 DefaultCallRecordFormatter::default()
1322 };
1323 Arc::new(formatter)
1324 };
1325
1326 let callrecord_sender = if let Some(sender) = self.callrecord_sender {
1327 Some(sender)
1328 } else if let Some(ref callrecord) = config.callrecord {
1329 let builder = CallRecordManagerBuilder::new()
1330 .with_cancel_token(token.child_token())
1331 .with_config(callrecord.clone())
1332 .with_max_concurrent(32)
1333 .with_formatter(callrecord_formatter.clone());
1334 let builder = match sip_flow.as_ref() {
1336 Some(flow) => builder.with_hook(Arc::new(SipFlowUploadHook {
1337 flow: flow.clone(),
1338 upload: config
1339 .sipflow
1340 .as_ref()
1341 .and_then(|c| c.upload.clone()),
1342 })),
1343 None => builder,
1344 };
1345
1346 let mut callrecord_manager = builder.build();
1347 let sender = callrecord_manager.sender.clone();
1348 crate::spawn(async move {
1349 callrecord_manager.serve().await;
1350 });
1351 Some(sender)
1352 } else {
1353 None
1354 };
1355
1356 let app_state = Arc::new(AppStateInner {
1357 config,
1358 token,
1359 stream_engine,
1360 callrecord_sender,
1361 endpoint,
1362 registration_handles: Mutex::new(HashMap::new()),
1363 alive_users: Arc::new(RwLock::new(HashSet::new())),
1364 dialog_layer: dialog_layer.clone(),
1365 create_invitation_handler: self.create_invitation_handler,
1366 invitation: Invitation::new(dialog_layer),
1367 routing_state: Arc::new(crate::call::RoutingState::new()),
1368 pending_playbooks: Arc::new(Mutex::new(HashMap::new())),
1369 sip_flow,
1370 learned_public_address,
1371 learned_peers,
1372 refer_header_resolver: self.refer_header_resolver,
1373 active_calls: Arc::new(std::sync::Mutex::new(HashMap::new())),
1374 total_calls: AtomicU64::new(0),
1375 total_failed_calls: AtomicU64::new(0),
1376 uptime: Local::now(),
1377 shutting_down: Arc::new(AtomicBool::new(false)),
1378 });
1379
1380 Ok(app_state)
1381 }
1382}