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