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