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, ¤t,));
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(¤t, ¤t,));
403 }
404}