cyfs_bdt/tunnel/
tunnel.rs

1use std::any::Any;
2use async_trait::{async_trait};
3use cyfs_base::*;
4use crate::{types::*, protocol};
5
6#[derive(Eq, PartialEq, Debug, Clone)]
7pub enum ProxyType {
8    None, 
9    Active(DeviceId), 
10    Passive(DeviceId)
11}
12
13impl ProxyType {
14    pub fn device_id(&self) -> Option<&DeviceId> {
15        match self {
16            Self::None => None, 
17            Self::Active(device_id) => Some(device_id), 
18            Self::Passive(device_id) => Some(device_id)
19        }
20    }
21}
22
23#[derive(PartialEq, Eq, Debug)]
24pub enum TunnelState {
25    Connecting, 
26    Active(Timestamp), 
27    Dead, 
28}
29
30#[async_trait]
31pub trait Tunnel: Send + Sync + std::fmt::Display {
32    fn as_any(&self) -> &dyn Any;
33    fn local(&self) -> &Endpoint;
34    fn remote(&self) -> &Endpoint;
35    fn state(&self) -> TunnelState; 
36    fn proxy(&self) -> ProxyType;
37    fn send_package(&self, packages: protocol::DynamicPackage) -> Result<usize, BuckyError>;
38    fn raw_data_header_len(&self) -> usize;
39    fn send_raw_data(&self, data: &mut [u8]) -> Result<usize, BuckyError>;
40    fn ptr_eq(&self, other: &DynamicTunnel) -> bool;
41    fn retain_keeper(&self);
42    fn release_keeper(&self);
43    fn mark_dead(&self, former_state: TunnelState);
44    fn reset(&self);
45    fn mtu(&self) -> usize;
46}
47
48
49pub struct DynamicTunnel(Box<dyn Tunnel>);
50impl DynamicTunnel {
51    pub fn new<T: 'static + Tunnel>(tunnel: T) -> Self {
52        Self(Box::new(tunnel))
53    }
54
55    pub fn clone_as_tunnel<T: 'static + Tunnel + Clone>(&self) -> T {
56        self.0.as_any().downcast_ref::<T>().unwrap().clone()
57    }
58
59    pub fn mtu(&self) -> usize {
60        self.0.mtu()
61    }
62}
63
64impl Clone for DynamicTunnel {
65    fn clone(&self) -> Self {
66        use super::udp;
67        use super::tcp;
68
69        if self.as_ref().local().is_udp() {
70            Self::new(self.clone_as_tunnel::<udp::Tunnel>())
71        } else if self.as_ref().local().is_tcp() {
72            Self::new(self.clone_as_tunnel::<tcp::Tunnel>())
73        } else {
74            unreachable!()
75        }
76    }
77}
78
79impl AsRef<Box<dyn Tunnel>> for DynamicTunnel {
80    fn as_ref(&self) -> &Box<dyn Tunnel> {
81        &self.0
82    } 
83}
84
85
86pub trait TunnelOwner: Send + Sync {
87    fn sync_tunnel_state(&self, tunnel: &DynamicTunnel, former_state: TunnelState, new_state: TunnelState);
88    fn clone_as_tunnel_owner(&self) -> Box<dyn TunnelOwner>;
89}
90