Skip to main content

active_call/
app.rs

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
58/// Generates a short unique session id for incoming calls, e.g. `s.3f9a2b1c4d5e`,
59/// instead of reusing the raw SIP dialog-id string. Collisions with live
60/// sessions are retried (practically impossible with 48 bits of randomness).
61fn 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
71/// Extracts the network source of a received request from its top Via header:
72/// the IP comes from the `received` parameter (populated by our transport for
73/// NAT'd peers) or the sent-by host when it is an IP literal; the hostname is
74/// the sent-by host as written. Port is intentionally ignored (carrier source
75/// ports change between probes).
76fn 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    /// Peer source addresses learned from call traffic, used by the OPTIONS
106    /// ACL (`[options_response]`).
107    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    /// Whether an OPTIONS probe from `source_ip`/`source_host` (as extracted
138    /// from the top Via header) should be answered: the source must match the
139    /// static ACL, a registered-server host, or a peer address learned from
140    /// call traffic within the configured TTL.
141    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            // out dialog, new server dialog
317            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                    // Reject new INVITEs during graceful shutdown
321                    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                            // 481 Dialog/Transaction Does Not Exist
401                            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                                        // A websocket client may already have
530                                        // attached an ActiveCall for this session,
531                                        // but that call only starts watching the
532                                        // dialog state on its first command
533                                        // (Ringing/Accept). A far-end CANCEL before
534                                        // that command would otherwise leave the
535                                        // call in `active_calls` forever. Propagate
536                                        // the termination: report the hangup and
537                                        // tear the call down.
538                                        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        // Matching is host-kind-homogeneous: a domain callee matches domain
742        // servers, an IP callee matches IP servers.
743        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    /// Scan registered users for the first server matching `pred` that has a
762    /// credential.
763    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        // Create UDP socket with SO_REUSEPORT for graceful restarts
1092        #[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            // SO_REUSEPORT (Linux/BSD)
1109            #[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        // Use the actual bound address (important when port=0 lets OS assign a port)
1128        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        // Optional SIP over TLS transport
1168        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        // Inspector chain (outermost runs first): public-address learning
1215        // (opt-in) -> call-traffic peer learning (for the OPTIONS ACL) ->
1216        // any caller-provided inspector.
1217        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}