turn_rs/router/mod.rs
1pub mod channels;
2pub mod interfaces;
3pub mod nodes;
4pub mod nonces;
5pub mod ports;
6
7#[rustfmt::skip]
8use crate::Observer;
9use self::{
10 channels::Channels,
11 interfaces::{Interface, Interfaces},
12 nodes::Nodes,
13 nonces::Nonces,
14 ports::Ports,
15};
16
17use std::{net::SocketAddr, sync::Arc, thread, time::Duration};
18
19/// Router State Tree.
20///
21/// this state management example maintains the status of all
22/// nodes in the current service and adds a node grouping model.
23/// it is necessary to specify a group for each node.
24///
25/// The state between groups is isolated. However,
26/// it should be noted that the node key only supports
27/// long-term valid passwords，does not support short-term
28/// valid passwords.
29pub struct Router {
30 realm: String,
31 observer: Arc<dyn Observer>,
32 ports: Ports,
33 nonces: Nonces,
34 nodes: Nodes,
35 channels: Channels,
36 interfaces: Interfaces,
37}
38
39impl Router {
40 /// create a router.
41 ///
42 /// # Examples
43 ///
44 /// ```
45 /// use std::sync::Arc;
46 /// use turn_rs::router::*;
47 /// use turn_rs::*;
48 ///
49 /// struct ObserverTest;
50 /// impl Observer for ObserverTest {}
51 ///
52 /// Router::new("test".to_string(), Arc::new(ObserverTest));
53 /// ```
54 pub fn new(realm: String, observer: Arc<dyn Observer>) -> Arc<Self> {
55 let this = Arc::new(Self {
56 interfaces: Interfaces::default(),
57 channels: Channels::default(),
58 nonces: Nonces::default(),
59 ports: Ports::default(),
60 nodes: Nodes::default(),
61 observer,
62 realm,
63 });
64
65 let this_ = Arc::downgrade(&this);
66 thread::spawn(move || {
67 while let Some(this) = this_.upgrade() {
68 thread::sleep(Duration::from_secs(60));
69 this.nodes.get_deaths().iter().for_each(|a| {
70 this.remove(a);
71 });
72
73 this.channels.get_deaths().iter().for_each(|c| {
74 this.channels.remove(*c);
75 });
76 }
77 });
78
79 this
80 }
81
82 /// get router capacity.
83 ///
84 /// # Examples
85 ///
86 /// ```
87 /// use std::sync::Arc;
88 /// use turn_rs::router::*;
89 /// use turn_rs::*;
90 ///
91 /// struct ObserverTest;
92 /// impl Observer for ObserverTest {}
93 ///
94 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
95 /// assert_eq!(router.capacity(), 16383);
96 /// ```
97 pub fn capacity(&self) -> usize {
98 self.ports.capacity()
99 }
100
101 /// get router allocate size.
102 ///
103 /// # Examples
104 ///
105 /// ```
106 /// use std::sync::Arc;
107 /// use turn_rs::router::*;
108 /// use turn_rs::*;
109 ///
110 /// struct ObserverTest;
111 /// impl Observer for ObserverTest {}
112 ///
113 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
114 /// assert_eq!(router.len(), 0);
115 /// ```
116 pub fn len(&self) -> usize {
117 self.ports.len()
118 }
119
120 /// get router allocate size is empty.
121 ///
122 /// # Examples
123 ///
124 /// ```
125 /// use std::sync::Arc;
126 /// use turn_rs::router::*;
127 /// use turn_rs::*;
128 ///
129 /// struct ObserverTest;
130 /// impl Observer for ObserverTest {}
131 ///
132 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
133 /// assert_eq!(router.is_empty(), true);
134 /// ```
135 pub fn is_empty(&self) -> bool {
136 self.ports.len() == 0
137 }
138
139 /// get addr interface.
140 ///
141 /// # Examples
142 ///
143 /// ```
144 /// use std::net::SocketAddr;
145 /// use std::sync::Arc;
146 /// use turn_rs::router::*;
147 /// use turn_rs::*;
148 ///
149 /// struct ObserverTest;
150 ///
151 /// impl Observer for ObserverTest {
152 /// fn get_password_blocking(
153 /// &self,
154 /// _: &SocketAddr,
155 /// _: &str,
156 /// ) -> Option<String> {
157 /// Some("test".to_string())
158 /// }
159 /// }
160 ///
161 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
162 /// let secret = [
163 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
164 /// 239,
165 /// ];
166 ///
167 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
168 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
169 ///
170 /// assert_eq!(key.as_slice(), &secret);
171 ///
172 /// let interface = router.get_interface(&addr).unwrap();
173 /// assert_eq!(interface.addr, addr);
174 /// ```
175 pub fn get_interface(&self, addr: &SocketAddr) -> Option<Arc<Interface>> {
176 self.interfaces.get_ref(addr)
177 }
178
179 /// get user list.
180 ///
181 /// # Examples
182 ///
183 /// ```
184 /// use std::net::SocketAddr;
185 /// use std::sync::Arc;
186 /// use turn_rs::router::*;
187 /// use turn_rs::*;
188 ///
189 /// struct ObserverTest;
190 ///
191 /// impl Observer for ObserverTest {
192 /// fn get_password_blocking(
193 /// &self,
194 /// _: &SocketAddr,
195 /// _: &str,
196 /// ) -> Option<String> {
197 /// Some("test".to_string())
198 /// }
199 /// }
200 ///
201 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
202 /// let secret = [
203 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
204 /// 239,
205 /// ];
206 ///
207 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
208 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
209 ///
210 /// assert_eq!(key.as_slice(), &secret);
211 ///
212 /// let users = router.get_users(0, 10);
213 /// assert_eq!(users.as_slice(), &[("test".to_string(), vec![addr])]);
214 /// ```
215 pub fn get_users(&self, skip: usize, limit: usize) -> Vec<(String, Vec<SocketAddr>)> {
216 self.nodes.get_users(skip, limit)
217 }
218
219 /// get node.
220 ///
221 /// # Examples
222 ///
223 /// ```
224 /// use std::net::SocketAddr;
225 /// use std::sync::Arc;
226 /// use turn_rs::router::*;
227 /// use turn_rs::*;
228 ///
229 /// struct ObserverTest;
230 ///
231 /// impl Observer for ObserverTest {
232 /// fn get_password_blocking(
233 /// &self,
234 /// _: &SocketAddr,
235 /// _: &str,
236 /// ) -> Option<String> {
237 /// Some("test".to_string())
238 /// }
239 /// }
240 ///
241 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
242 /// let secret = [
243 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
244 /// 239,
245 /// ];
246 ///
247 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
248 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
249 ///
250 /// assert_eq!(key.as_slice(), &secret);
251 ///
252 /// let node = router.get_node(&addr).unwrap();
253 /// assert_eq!(node.username.as_str(), "test");
254 /// assert_eq!(node.password.as_str(), "test");
255 /// assert_eq!(node.secret.as_slice(), &secret);
256 /// assert_eq!(node.channels, vec![]);
257 /// assert_eq!(node.ports, vec![]);
258 /// ```
259 pub fn get_node(&self, addr: &SocketAddr) -> Option<nodes::Node> {
260 self.nodes.get_node(addr)
261 }
262
263 /// get node bound list.
264 ///
265 /// # Examples
266 ///
267 /// ```
268 /// use std::net::SocketAddr;
269 /// use std::sync::Arc;
270 /// use turn_rs::router::*;
271 /// use turn_rs::*;
272 ///
273 /// struct ObserverTest;
274 ///
275 /// impl Observer for ObserverTest {
276 /// fn get_password_blocking(
277 /// &self,
278 /// _: &SocketAddr,
279 /// _: &str,
280 /// ) -> Option<String> {
281 /// Some("test".to_string())
282 /// }
283 /// }
284 ///
285 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
286 /// let secret = [
287 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
288 /// 239,
289 /// ];
290 ///
291 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
292 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
293 ///
294 /// assert_eq!(key.as_slice(), &secret);
295 ///
296 /// let ret = router.get_node_addrs("test");
297 /// assert_eq!(ret, vec![addr]);
298 /// ```
299 pub fn get_node_addrs(&self, username: &str) -> Vec<SocketAddr> {
300 self.nodes.get_addrs(username)
301 }
302
303 /// get the nonce of the node SocketAddr.
304 ///
305 /// # Examples
306 ///
307 /// ```
308 /// use std::net::SocketAddr;
309 /// use std::sync::Arc;
310 /// use turn_rs::router::*;
311 /// use turn_rs::*;
312 ///
313 /// struct ObserverTest;
314 ///
315 /// impl Observer for ObserverTest {
316 /// fn get_password_blocking(
317 /// &self,
318 /// _: &SocketAddr,
319 /// _: &str,
320 /// ) -> Option<String> {
321 /// Some("test".to_string())
322 /// }
323 /// }
324 ///
325 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
326 /// let secret = [
327 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
328 /// 239,
329 /// ];
330 ///
331 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
332 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
333 ///
334 /// assert_eq!(key.as_slice(), &secret);
335 ///
336 /// let nonce = router.get_nonce(&addr);
337 /// assert_eq!(nonce.len(), 16);
338 /// ```
339 pub fn get_nonce(&self, addr: &SocketAddr) -> Arc<String> {
340 self.nonces.get(addr)
341 }
342
343 /// get the password of the node SocketAddr.
344 ///
345 /// require remote control service to distribute keys.
346 ///
347 /// # Examples
348 ///
349 /// ```
350 /// use std::net::SocketAddr;
351 /// use std::sync::Arc;
352 /// use turn_rs::router::*;
353 /// use turn_rs::*;
354 ///
355 /// struct ObserverTest;
356 ///
357 /// impl Observer for ObserverTest {
358 /// fn get_password_blocking(
359 /// &self,
360 /// _: &SocketAddr,
361 /// _: &str,
362 /// ) -> Option<String> {
363 /// Some("test".to_string())
364 /// }
365 /// }
366 ///
367 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
368 /// let secret = [
369 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
370 /// 239,
371 /// ];
372 ///
373 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
374 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
375 ///
376 /// assert_eq!(key.as_slice(), &secret);
377 /// ```
378 pub fn get_key_block(
379 &self,
380 addr: &SocketAddr,
381 interface: &SocketAddr,
382 external: &SocketAddr,
383 username: &str,
384 ) -> Option<Arc<[u8; 16]>> {
385 let key = self.nodes.get_secret(addr);
386 if key.is_some() {
387 return key;
388 }
389
390 let pwd = self.observer.get_password_blocking(addr, username)?;
391 let key = self.nodes.insert(addr, &self.realm, username, &pwd)?;
392 self.interfaces.insert(*addr, *interface, *external);
393 Some(key)
394 }
395
396 /// get the password of the node SocketAddr.
397 ///
398 /// require remote control service to distribute keys.
399 pub async fn get_key(
400 &self,
401 addr: &SocketAddr,
402 interface: &SocketAddr,
403 external: &SocketAddr,
404 username: &str,
405 ) -> Option<Arc<[u8; 16]>> {
406 let key = self.nodes.get_secret(addr);
407 if key.is_some() {
408 return key;
409 }
410
411 let pwd = self.observer.get_password(addr, username).await?;
412 let key = self.nodes.insert(addr, &self.realm, username, &pwd)?;
413 self.interfaces.insert(*addr, *interface, *external);
414 Some(key)
415 }
416
417 /// obtain the peer address bound to the current
418 /// node according to the channel number.
419 ///
420 /// # Examples
421 ///
422 /// ```
423 /// use std::net::SocketAddr;
424 /// use std::sync::Arc;
425 /// use turn_rs::router::*;
426 /// use turn_rs::*;
427 ///
428 /// struct ObserverTest;
429 ///
430 /// impl Observer for ObserverTest {
431 /// fn get_password_blocking(
432 /// &self,
433 /// _: &SocketAddr,
434 /// _: &str,
435 /// ) -> Option<String> {
436 /// Some("test".to_string())
437 /// }
438 /// }
439 ///
440 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
441 /// let secret = [
442 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
443 /// 239,
444 /// ];
445 ///
446 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
447 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
448 ///
449 /// assert_eq!(key.as_slice(), &secret);
450 ///
451 /// let port = router.alloc_port(&addr).unwrap();
452 /// assert!(router.bind_port(&addr, port).is_some());
453 /// assert_eq!(router.get_port_bound(port), Some(addr));
454 /// ```
455 pub fn get_channel_bound(&self, addr: &SocketAddr, channel: u16) -> Option<SocketAddr> {
456 self.channels.get_bound(addr, channel)
457 }
458
459 /// obtain the peer address bound to the current
460 /// node according to the port number.
461 ///
462 /// # Examples
463 ///
464 /// ```
465 /// use std::net::SocketAddr;
466 /// use std::sync::Arc;
467 /// use turn_rs::router::*;
468 /// use turn_rs::*;
469 ///
470 /// struct ObserverTest;
471 ///
472 /// impl Observer for ObserverTest {
473 /// fn get_password_blocking(
474 /// &self,
475 /// _: &SocketAddr,
476 /// _: &str,
477 /// ) -> Option<String> {
478 /// Some("test".to_string())
479 /// }
480 /// }
481 ///
482 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
483 /// let secret = [
484 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
485 /// 239,
486 /// ];
487 ///
488 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
489 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
490 ///
491 /// assert_eq!(key.as_slice(), &secret);
492 ///
493 /// let port = router.alloc_port(&addr).unwrap();
494 /// assert!(router.bind_port(&addr, port).is_some());
495 /// assert_eq!(router.get_port_bound(port), Some(addr));
496 /// ```
497 pub fn get_port_bound(&self, port: u16) -> Option<SocketAddr> {
498 self.ports.get(port)
499 }
500
501 /// get node the port.
502 ///
503 /// # Examples
504 ///
505 /// ```
506 /// use std::net::SocketAddr;
507 /// use std::sync::Arc;
508 /// use turn_rs::router::*;
509 /// use turn_rs::*;
510 ///
511 /// struct ObserverTest;
512 ///
513 /// impl Observer for ObserverTest {
514 /// fn get_password_blocking(
515 /// &self,
516 /// _: &SocketAddr,
517 /// _: &str,
518 /// ) -> Option<String> {
519 /// Some("test".to_string())
520 /// }
521 /// }
522 ///
523 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
524 /// let peer = "127.0.0.1:8081".parse::<SocketAddr>().unwrap();
525 /// let secret = [
526 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
527 /// 239,
528 /// ];
529 ///
530 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
531 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
532 ///
533 /// assert_eq!(key.as_slice(), &secret);
534 ///
535 /// let port = router.alloc_port(&addr).unwrap();
536 /// assert!(router.bind_port(&addr, port).is_some());
537 /// assert!(router.bind_port(&peer, port).is_some());
538 /// assert_eq!(router.get_bound_port(&addr, &peer), Some(port));
539 /// ```
540 pub fn get_bound_port(&self, addr: &SocketAddr, peer: &SocketAddr) -> Option<u16> {
541 self.ports.get_bound(addr, peer)
542 }
543
544 /// alloc a port from State.
545 ///
546 /// In all cases, the server SHOULD only allocate ports from the range
547 /// 49152 - 65535 (the Dynamic and/or Private Port range [PORT-NUMBERS]),
548 /// unless the TURN server application knows, through some means not
549 /// specified here, that other applications running on the same host as
550 /// the TURN server application will not be impacted by allocating ports
551 /// outside this range. This condition can often be satisfied by running
552 /// the TURN server application on a dedicated machine and/or by
553 /// arranging that any other applications on the machine allocate ports
554 /// before the TURN server application starts. In any case, the TURN
555 /// server SHOULD NOT allocate ports in the range 0 - 1023 (the Well-
556 /// Known Port range) to discourage clients from using TURN to run
557 /// standard services.
558 ///
559 /// NOTE: The use of randomized port assignments to avoid certain
560 /// types of attacks is described in [RFC6056]. It is RECOMMENDED
561 /// that a TURN server implement a randomized port assignment
562 /// algorithm from [RFC6056]. This is especially applicable to
563 /// servers that choose to pre-allocate a number of ports from the
564 /// underlying OS and then later assign them to allocations; for
565 /// example, a server may choose this technique to implement the
566 /// EVEN-PORT attribute.
567 ///
568 /// The server determines the initial value of the time-to-expiry field
569 /// as follows. If the request contains a LIFETIME attribute, then the
570 /// server computes the minimum of the client's proposed lifetime and the
571 /// server's maximum allowed lifetime. If this computed value is greater
572 /// than the default lifetime, then the server uses the computed lifetime
573 /// as the initial value of the time-to-expiry field. Otherwise, the
574 /// server uses the default lifetime. It is RECOMMENDED that the server
575 /// use a maximum allowed lifetime value of no more than 3600 seconds (1
576 /// hour). Servers that implement allocation quotas or charge users for
577 /// allocations in some way may wish to use a smaller maximum allowed
578 /// lifetime (perhaps as small as the default lifetime) to more quickly
579 /// remove orphaned allocations (that is, allocations where the
580 /// corresponding client has crashed or terminated, or the client
581 /// connection has been lost for some reason). Also, note that the time-
582 /// to-expiry is recomputed with each successful Refresh request, and
583 /// thus, the value computed here applies only until the first refresh.
584 ///
585 /// # Examples
586 ///
587 /// ```
588 /// use std::net::SocketAddr;
589 /// use std::sync::Arc;
590 /// use turn_rs::router::*;
591 /// use turn_rs::*;
592 ///
593 /// struct ObserverTest;
594 ///
595 /// impl Observer for ObserverTest {
596 /// fn get_password_blocking(
597 /// &self,
598 /// _: &SocketAddr,
599 /// _: &str,
600 /// ) -> Option<String> {
601 /// Some("test".to_string())
602 /// }
603 /// }
604 ///
605 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
606 /// let secret = [
607 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
608 /// 239,
609 /// ];
610 ///
611 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
612 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
613 ///
614 /// assert_eq!(key.as_slice(), &secret);
615 /// assert!(router.alloc_port(&addr).is_some());
616 /// ```
617 pub fn alloc_port(&self, addr: &SocketAddr) -> Option<u16> {
618 let port = self.ports.alloc(addr)?;
619 self.nodes.push_port(addr, port);
620 Some(port)
621 }
622
623 /// bind port for State.
624 ///
625 /// A server need not do anything special to implement
626 /// idempotency of CreatePermission requests over UDP using the
627 /// "stateless stack approach". Retransmitted CreatePermission
628 /// requests will simply refresh the permissions.
629 ///
630 /// # Examples
631 ///
632 /// ```
633 /// use std::net::SocketAddr;
634 /// use std::sync::Arc;
635 /// use turn_rs::router::*;
636 /// use turn_rs::*;
637 ///
638 /// struct ObserverTest;
639 ///
640 /// impl Observer for ObserverTest {
641 /// fn get_password_blocking(
642 /// &self,
643 /// _: &SocketAddr,
644 /// _: &str,
645 /// ) -> Option<String> {
646 /// Some("test".to_string())
647 /// }
648 /// }
649 ///
650 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
651 /// let secret = [
652 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
653 /// 239,
654 /// ];
655 ///
656 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
657 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
658 ///
659 /// assert_eq!(key.as_slice(), &secret);
660 ///
661 /// let port = router.alloc_port(&addr).unwrap();
662 /// assert!(router.bind_port(&addr, port).is_some());
663 /// ```
664 pub fn bind_port(&self, addr: &SocketAddr, port: u16) -> Option<()> {
665 self.ports.bound(addr, port)
666 }
667
668 /// bind channel number for State.
669 ///
670 /// A server need not do anything special to implement
671 /// idempotency of ChannelBind requests over UDP using the
672 /// "stateless stack approach". Retransmitted ChannelBind requests
673 /// will simply refresh the channel binding and the corresponding
674 /// permission. Furthermore, the client must wait 5 minutes before
675 /// binding a previously bound channel number or peer address to a
676 /// different channel, eliminating the possibility that the
677 /// transaction would initially fail but succeed on a
678 /// retransmission.
679 ///
680 /// # Examples
681 ///
682 /// ```
683 /// use std::net::SocketAddr;
684 /// use std::sync::Arc;
685 /// use turn_rs::router::*;
686 /// use turn_rs::*;
687 ///
688 /// struct ObserverTest;
689 ///
690 /// impl Observer for ObserverTest {
691 /// fn get_password_blocking(
692 /// &self,
693 /// _: &SocketAddr,
694 /// _: &str,
695 /// ) -> Option<String> {
696 /// Some("test".to_string())
697 /// }
698 /// }
699 ///
700 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
701 /// let secret = [
702 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
703 /// 239,
704 /// ];
705 ///
706 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
707 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
708 ///
709 /// assert_eq!(key.as_slice(), &secret);
710 ///
711 /// let port = router.alloc_port(&addr).unwrap();
712 /// assert!(router.bind_channel(&addr, port, 0x4000).is_some());
713 /// ```
714 pub fn bind_channel(&self, addr: &SocketAddr, port: u16, channel: u16) -> Option<()> {
715 let source = self.ports.get(port)?;
716 self.channels.insert(addr, channel, &source)?;
717 self.nodes.push_channel(addr, channel)?;
718 Some(())
719 }
720
721 /// refresh node lifetime.
722 ///
723 /// The server computes a value called the "desired lifetime" as follows:
724 /// if the request contains a LIFETIME attribute and the attribute value
725 /// is zero, then the "desired lifetime" is zero. Otherwise, if the
726 /// request contains a LIFETIME attribute, then the server computes the
727 /// minimum of the client's requested lifetime and the server's maximum
728 /// allowed lifetime. If this computed value is greater than the default
729 /// lifetime, then the "desired lifetime" is the computed value.
730 /// Otherwise, the "desired lifetime" is the default lifetime.
731 ///
732 /// Subsequent processing depends on the "desired lifetime" value:
733 ///
734 /// * If the "desired lifetime" is zero, then the request succeeds and the
735 /// allocation is deleted.
736 ///
737 /// * If the "desired lifetime" is non-zero, then the request succeeds and
738 /// the allocation's time-to-expiry is set to the "desired lifetime".
739 ///
740 /// If the request succeeds, then the server sends a success response
741 /// containing:
742 ///
743 /// * A LIFETIME attribute containing the current value of the time-to-
744 /// expiry timer.
745 ///
746 /// NOTE: A server need not do anything special to implement
747 /// idempotency of Refresh requests over UDP using the "stateless
748 /// stack approach". Retransmitted Refresh requests with a non-
749 /// zero "desired lifetime" will simply refresh the allocation. A
750 /// retransmitted Refresh request with a zero "desired lifetime"
751 /// will cause a 437 (Allocation Mismatch) response if the
752 /// allocation has already been deleted, but the client will treat
753 /// this as equivalent to a success response (see below).
754 ///
755 /// # Examples
756 ///
757 /// ```
758 /// use std::net::SocketAddr;
759 /// use std::sync::Arc;
760 /// use turn_rs::router::*;
761 /// use turn_rs::*;
762 ///
763 /// struct ObserverTest;
764 ///
765 /// impl Observer for ObserverTest {
766 /// fn get_password_blocking(
767 /// &self,
768 /// _: &SocketAddr,
769 /// _: &str,
770 /// ) -> Option<String> {
771 /// Some("test".to_string())
772 /// }
773 /// }
774 ///
775 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
776 /// let secret = [
777 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
778 /// 239,
779 /// ];
780 ///
781 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
782 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
783 ///
784 /// assert_eq!(key.as_slice(), &secret);
785 /// router.refresh(&addr, 0);
786 ///
787 /// assert!(router.get_node(&addr).is_none());
788 /// ```
789 pub fn refresh(&self, addr: &SocketAddr, delay: u32) {
790 if delay > 0 {
791 self.nodes.set_lifetime(addr, delay);
792 } else {
793 self.remove(addr);
794 }
795 }
796
797 /// remove a node.
798 ///
799 /// # Examples
800 ///
801 /// ```
802 /// use std::net::SocketAddr;
803 /// use std::sync::Arc;
804 /// use turn_rs::router::*;
805 /// use turn_rs::*;
806 ///
807 /// struct ObserverTest;
808 ///
809 /// impl Observer for ObserverTest {
810 /// fn get_password_blocking(
811 /// &self,
812 /// _: &SocketAddr,
813 /// _: &str,
814 /// ) -> Option<String> {
815 /// Some("test".to_string())
816 /// }
817 /// }
818 ///
819 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
820 /// let secret = [
821 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
822 /// 239,
823 /// ];
824 ///
825 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
826 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
827 ///
828 /// assert_eq!(key.as_slice(), &secret);
829 /// assert!(router.remove(&addr).is_some());
830 /// assert!(router.get_node(&addr).is_none());
831 /// ```
832 pub fn remove(&self, addr: &SocketAddr) -> Option<()> {
833 let node = self.nodes.remove(addr)?;
834 self.ports.remove(addr, &node.ports);
835 for c in node.channels {
836 self.channels.remove(c);
837 }
838
839 self.nonces.remove(addr);
840 self.interfaces.remove(addr);
841 self.observer.abort(addr, &node.username);
842 Some(())
843 }
844
845 /// remove a node from username.
846 ///
847 /// # Examples
848 ///
849 /// ```
850 /// use std::net::SocketAddr;
851 /// use std::sync::Arc;
852 /// use turn_rs::router::*;
853 /// use turn_rs::*;
854 ///
855 /// struct ObserverTest;
856 ///
857 /// impl Observer for ObserverTest {
858 /// fn get_password_blocking(
859 /// &self,
860 /// _: &SocketAddr,
861 /// _: &str,
862 /// ) -> Option<String> {
863 /// Some("test".to_string())
864 /// }
865 /// }
866 ///
867 /// let addr = "127.0.0.1:8080".parse::<SocketAddr>().unwrap();
868 /// let secret = [
869 /// 174, 238, 187, 253, 117, 209, 73, 157, 36, 56, 143, 91, 155, 16, 224,
870 /// 239,
871 /// ];
872 ///
873 /// let router = Router::new("test".to_string(), Arc::new(ObserverTest));
874 /// let key = router.get_key_block(&addr, &addr, &addr, "test").unwrap();
875 ///
876 /// assert_eq!(key.as_slice(), &secret);
877 /// router.remove_from_user("test");
878 ///
879 /// assert!(router.get_node(&addr).is_none());
880 /// ```
881 pub fn remove_from_user(&self, u: &str) {
882 for addr in self.nodes.get_addrs(u) {
883 self.remove(&addr);
884 }
885 }
886}