Skip to main content

active_call/
app.rs

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