Skip to main content

active_call/useragent/
public_address.rs

1use arc_swap::ArcSwap;
2use rsipstack::rsip::{headers::ToTypedHeader, prelude::HeadersExt};
3use rsipstack::transaction::endpoint::MessageInspector;
4use rsipstack::transport::SipAddr;
5use std::{net::IpAddr, sync::Arc};
6
7pub type SharedPublicAddress = Arc<ArcSwap<rsipstack::rsip::HostWithPort>>;
8
9pub fn normalize_transport(
10    transport: Option<&rsipstack::rsip::Transport>,
11) -> rsipstack::rsip::Transport {
12    transport
13        .cloned()
14        .unwrap_or(rsipstack::rsip::Transport::Udp)
15}
16
17pub fn transport_for_uri(uri: &rsipstack::rsip::Uri) -> rsipstack::rsip::Transport {
18    if matches!(uri.scheme, Some(rsipstack::rsip::Scheme::Sips)) {
19        return rsipstack::rsip::Transport::Tls;
20    }
21
22    uri.params
23        .iter()
24        .find_map(|param| match param {
25            rsipstack::rsip::Param::Transport(transport) => Some(transport.clone()),
26            _ => None,
27        })
28        .unwrap_or(rsipstack::rsip::Transport::Udp)
29}
30
31pub fn find_local_addr_for_uri(addrs: &[SipAddr], uri: &rsipstack::rsip::Uri) -> Option<SipAddr> {
32    let transport = transport_for_uri(uri);
33    addrs
34        .iter()
35        .find(|addr| normalize_transport(addr.r#type.as_ref()) == transport)
36        .cloned()
37}
38
39pub fn contact_needs_public_resolution(contact: &rsipstack::rsip::Uri) -> bool {
40    if contact.scheme.is_none() {
41        return true;
42    }
43
44    match &contact.host_with_port.host {
45        rsipstack::rsip::Host::Domain(domain) => {
46            let host = domain.to_string();
47            host.eq_ignore_ascii_case("localhost")
48        }
49        rsipstack::rsip::Host::IpAddr(ip) => is_local_or_unspecified(ip),
50    }
51}
52
53pub fn build_contact_uri(
54    local_addr: &SipAddr,
55    learned_addr: Option<rsipstack::rsip::HostWithPort>,
56    username: Option<&str>,
57    template: Option<&rsipstack::rsip::Uri>,
58) -> rsipstack::rsip::Uri {
59    let mut uri = template
60        .cloned()
61        .unwrap_or_else(|| rsipstack::rsip::Uri::from(local_addr));
62
63    uri.host_with_port = learned_addr.unwrap_or_else(|| local_addr.addr.clone());
64    if uri.scheme.is_none() {
65        uri.scheme = Some(match local_addr.r#type {
66            Some(rsipstack::rsip::Transport::Tls)
67            | Some(rsipstack::rsip::Transport::Wss)
68            | Some(rsipstack::rsip::Transport::TlsSctp) => rsipstack::rsip::Scheme::Sips,
69            _ => rsipstack::rsip::Scheme::Sip,
70        });
71    }
72
73    if uri.auth.is_none() {
74        if let Some(username) = username.filter(|value| !value.is_empty()) {
75            uri.auth = Some(rsipstack::rsip::Auth {
76                user: username.to_string(),
77                password: None,
78            });
79        }
80    }
81
82    uri
83}
84
85pub fn build_contact(
86    local_addr: &SipAddr,
87    contact_address: Option<rsipstack::rsip::HostWithPort>,
88    username: Option<&str>,
89    template: Option<&rsipstack::rsip::Uri>,
90) -> rsipstack::rsip::typed::Contact {
91    let contact_uri = build_contact_uri(local_addr, contact_address, username, template);
92    rsipstack::rsip::typed::Contact {
93        display_name: None,
94        uri: contact_uri,
95        params: vec![],
96    }
97}
98
99pub fn build_public_contact_uri(
100    learned_public_address: &SharedPublicAddress,
101    auto_learn_public_address: bool,
102    local_addr: &SipAddr,
103    username: Option<&str>,
104    template: Option<&rsipstack::rsip::Uri>,
105) -> rsipstack::rsip::Uri {
106    let selected_addr = if auto_learn_public_address
107        && normalize_transport(local_addr.r#type.as_ref()) == rsipstack::rsip::Transport::Udp
108    {
109        Some(learned_public_address.load_full().as_ref().clone())
110    } else {
111        Some(local_addr.addr.clone())
112    };
113    build_contact_uri(local_addr, selected_addr, username, template)
114}
115
116pub struct LearningMessageInspector {
117    learned_public_address: SharedPublicAddress,
118    next: Option<Box<dyn MessageInspector>>,
119}
120
121impl LearningMessageInspector {
122    pub fn new(
123        initial_address: rsipstack::rsip::HostWithPort,
124        next: Option<Box<dyn MessageInspector>>,
125    ) -> Self {
126        Self {
127            learned_public_address: Arc::new(ArcSwap::from_pointee(initial_address)),
128            next,
129        }
130    }
131
132    pub fn shared_public_address(&self) -> SharedPublicAddress {
133        self.learned_public_address.clone()
134    }
135}
136
137impl MessageInspector for LearningMessageInspector {
138    fn before_send(
139        &self,
140        msg: rsipstack::rsip::SipMessage,
141        dest: Option<&SipAddr>,
142    ) -> rsipstack::rsip::SipMessage {
143        if let Some(next) = &self.next {
144            next.before_send(msg, dest)
145        } else {
146            msg
147        }
148    }
149
150    fn after_received(
151        &self,
152        msg: rsipstack::rsip::SipMessage,
153        from: Option<&SipAddr>,
154    ) -> rsipstack::rsip::SipMessage {
155        if let rsipstack::rsip::SipMessage::Response(response) = &msg
156            && let Ok(via) = response.via_header()
157            && let Ok(via) = via.typed()
158            && via.transport == rsipstack::rsip::Transport::Udp
159            && let Some(host_with_port) = response.via_received()
160        {
161            self.learned_public_address
162                .rcu(|previous: &Arc<rsipstack::rsip::HostWithPort>| {
163                    if should_update_address(previous.as_ref(), &host_with_port) {
164                        Arc::new(host_with_port.clone())
165                    } else {
166                        previous.clone()
167                    }
168                });
169        }
170
171        if let Some(next) = &self.next {
172            next.after_received(msg, from)
173        } else {
174            msg
175        }
176    }
177}
178
179pub fn should_update_address(
180    previous: &rsipstack::rsip::HostWithPort,
181    current: &rsipstack::rsip::HostWithPort,
182) -> bool {
183    if previous == current {
184        return false;
185    }
186
187    let previous_is_public = is_public_address(previous);
188    let current_is_public = is_public_address(current);
189    (!previous_is_public && current_is_public)
190        || (previous_is_public && current_is_public && previous != current)
191}
192
193fn is_public_address(host_with_port: &rsipstack::rsip::HostWithPort) -> bool {
194    match &host_with_port.host {
195        rsipstack::rsip::Host::Domain(domain) => {
196            !domain.to_string().eq_ignore_ascii_case("localhost")
197        }
198        rsipstack::rsip::Host::IpAddr(ip) => !is_local_or_unspecified(ip),
199    }
200}
201
202fn is_local_or_unspecified(ip: &IpAddr) -> bool {
203    ip.is_loopback() || ip.is_unspecified()
204}
205
206#[cfg(test)]
207mod tests {
208    use super::{
209        SharedPublicAddress, build_contact, build_contact_uri, build_public_contact_uri,
210        contact_needs_public_resolution, find_local_addr_for_uri, should_update_address,
211        transport_for_uri,
212    };
213    use arc_swap::ArcSwap;
214    use rsipstack::rsip::transport::Transport;
215    use rsipstack::transaction::endpoint::MessageInspector;
216    use rsipstack::transport::SipAddr;
217    use std::sync::Arc;
218
219    #[test]
220    fn learns_public_address_from_response_via() {
221        let response: rsipstack::rsip::Response = concat!(
222            "SIP/2.0 401 Unauthorized\r\n",
223            "Via: SIP/2.0/UDP 10.0.0.1:5060;branch=z9hG4bK-1;received=203.0.113.10;rport=62000\r\n",
224            "Content-Length: 0\r\n",
225            "\r\n"
226        )
227        .try_into()
228        .unwrap();
229
230        let inspector = super::LearningMessageInspector::new(
231            "127.0.0.1:5060"
232                .parse::<std::net::SocketAddr>()
233                .unwrap()
234                .into(),
235            None,
236        );
237        let cache = inspector.shared_public_address();
238        inspector.after_received(
239            rsipstack::rsip::SipMessage::Response(response),
240            Some(&SipAddr {
241                r#type: Some(Transport::Udp),
242                addr: "10.0.0.1:5060"
243                    .parse::<std::net::SocketAddr>()
244                    .unwrap()
245                    .into(),
246            }),
247        );
248        assert_eq!(cache.load_full().as_ref().to_string(), "203.0.113.10:62000");
249    }
250
251    #[test]
252    fn builds_contact_using_learned_public_address() {
253        let local_addr = SipAddr {
254            r#type: Some(Transport::Udp),
255            addr: "10.0.0.5:5060"
256                .parse::<std::net::SocketAddr>()
257                .unwrap()
258                .into(),
259        };
260        let template: rsipstack::rsip::Uri = "sip:alice@127.0.0.1:5060".try_into().unwrap();
261        let learned_addr = Some(
262            "203.0.113.10:62000"
263                .parse::<std::net::SocketAddr>()
264                .unwrap()
265                .into(),
266        );
267
268        let contact = build_contact_uri(&local_addr, learned_addr, Some("alice"), Some(&template));
269        assert_eq!(contact.to_string(), "sip:alice@203.0.113.10:62000");
270    }
271
272    #[test]
273    fn identifies_contacts_that_need_resolution() {
274        let local_contact: rsipstack::rsip::Uri = "sip:alice@127.0.0.1:5060".try_into().unwrap();
275        let remote_contact: rsipstack::rsip::Uri =
276            "sip:alice@203.0.113.10:62000".try_into().unwrap();
277        assert!(contact_needs_public_resolution(&local_contact));
278        assert!(!contact_needs_public_resolution(&remote_contact));
279    }
280
281    #[test]
282    fn selects_local_addr_for_uri_transport() {
283        let addrs = vec![
284            SipAddr {
285                r#type: Some(Transport::Udp),
286                addr: "10.0.0.5:5060"
287                    .parse::<std::net::SocketAddr>()
288                    .unwrap()
289                    .into(),
290            },
291            SipAddr {
292                r#type: Some(Transport::Tls),
293                addr: "10.0.0.5:5061"
294                    .parse::<std::net::SocketAddr>()
295                    .unwrap()
296                    .into(),
297            },
298        ];
299
300        let uri: rsipstack::rsip::Uri = "sips:alice@example.com".try_into().unwrap();
301        let selected = find_local_addr_for_uri(&addrs, &uri).unwrap();
302
303        assert_eq!(selected.to_string(), "TLS 10.0.0.5:5061");
304    }
305
306    #[test]
307    fn builds_public_contact_from_shared_cache() {
308        let cache: SharedPublicAddress = Arc::new(ArcSwap::from_pointee(
309            "203.0.113.20:62000"
310                .parse::<std::net::SocketAddr>()
311                .unwrap()
312                .into(),
313        ));
314        let local_addr = SipAddr {
315            r#type: Some(Transport::Udp),
316            addr: "10.0.0.5:5060"
317                .parse::<std::net::SocketAddr>()
318                .unwrap()
319                .into(),
320        };
321
322        let contact = build_public_contact_uri(&cache, true, &local_addr, Some("alice"), None);
323        assert_eq!(contact.to_string(), "sip:alice@203.0.113.20:62000");
324    }
325
326    #[test]
327    fn builds_typed_contact() {
328        let local_addr = SipAddr {
329            r#type: Some(Transport::Udp),
330            addr: "10.0.0.5:5060"
331                .parse::<std::net::SocketAddr>()
332                .unwrap()
333                .into(),
334        };
335        let contact = build_contact(
336            &local_addr,
337            Some(
338                "203.0.113.20:62000"
339                    .parse::<std::net::SocketAddr>()
340                    .unwrap()
341                    .into(),
342            ),
343            Some("alice"),
344            None,
345        );
346        assert_eq!(contact.to_string(), "<sip:alice@203.0.113.20:62000>");
347    }
348
349    #[test]
350    fn keeps_configured_contact_for_tls() {
351        let cache: SharedPublicAddress = Arc::new(ArcSwap::from_pointee(
352            "203.0.113.20:62000"
353                .parse::<std::net::SocketAddr>()
354                .unwrap()
355                .into(),
356        ));
357        let local_addr = SipAddr {
358            r#type: Some(Transport::Tls),
359            addr: "10.0.0.5:5061"
360                .parse::<std::net::SocketAddr>()
361                .unwrap()
362                .into(),
363        };
364
365        let contact = build_public_contact_uri(&cache, true, &local_addr, Some("alice"), None);
366        assert_eq!(
367            contact.to_string(),
368            "sips:alice@10.0.0.5:5061;transport=TLS"
369        );
370    }
371
372    #[test]
373    fn infers_transport_from_uri() {
374        let sips_uri: rsipstack::rsip::Uri = "sips:alice@example.com".try_into().unwrap();
375        let tcp_uri: rsipstack::rsip::Uri =
376            "sip:alice@example.com;transport=tcp".try_into().unwrap();
377        assert_eq!(transport_for_uri(&sips_uri), Transport::Tls);
378        assert_eq!(transport_for_uri(&tcp_uri), Transport::Tcp);
379    }
380
381    #[test]
382    fn updates_learned_address_from_local_to_public() {
383        let previous: rsipstack::rsip::HostWithPort = "127.0.0.1:5060"
384            .parse::<std::net::SocketAddr>()
385            .unwrap()
386            .into();
387        let current: rsipstack::rsip::HostWithPort = "203.0.113.10:62000"
388            .parse::<std::net::SocketAddr>()
389            .unwrap()
390            .into();
391
392        assert!(should_update_address(&previous, &current,));
393    }
394
395    #[test]
396    fn does_not_update_learned_address_when_unchanged() {
397        let current: rsipstack::rsip::HostWithPort = "203.0.113.10:62000"
398            .parse::<std::net::SocketAddr>()
399            .unwrap()
400            .into();
401
402        assert!(!should_update_address(&current, &current,));
403    }
404}