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