use workspace, prepare for config server and gui (#48)

easytier/src/common/config.rs

@@ -0,0 +1,425 @@
+use std::{
+    net::SocketAddr,
+    sync::{Arc, Mutex},
+};
+
+use anyhow::Context;
+use serde::{Deserialize, Serialize};
+
+#[auto_impl::auto_impl(Box, &)]
+pub trait ConfigLoader: Send + Sync {
+    fn get_id(&self) -> uuid::Uuid;
+
+    fn get_inst_name(&self) -> String;
+    fn set_inst_name(&self, name: String);
+
+    fn get_netns(&self) -> Option<String>;
+    fn set_netns(&self, ns: Option<String>);
+
+    fn get_ipv4(&self) -> Option<std::net::Ipv4Addr>;
+    fn set_ipv4(&self, addr: std::net::Ipv4Addr);
+
+    fn add_proxy_cidr(&self, cidr: cidr::IpCidr);
+    fn remove_proxy_cidr(&self, cidr: cidr::IpCidr);
+    fn get_proxy_cidrs(&self) -> Vec<cidr::IpCidr>;
+
+    fn get_network_identity(&self) -> NetworkIdentity;
+    fn set_network_identity(&self, identity: NetworkIdentity);
+
+    fn get_listener_uris(&self) -> Vec<url::Url>;
+
+    fn get_file_logger_config(&self) -> FileLoggerConfig;
+    fn set_file_logger_config(&self, config: FileLoggerConfig);
+    fn get_console_logger_config(&self) -> ConsoleLoggerConfig;
+    fn set_console_logger_config(&self, config: ConsoleLoggerConfig);
+
+    fn get_peers(&self) -> Vec<PeerConfig>;
+    fn set_peers(&self, peers: Vec<PeerConfig>);
+
+    fn get_listeners(&self) -> Vec<url::Url>;
+    fn set_listeners(&self, listeners: Vec<url::Url>);
+
+    fn get_rpc_portal(&self) -> Option<SocketAddr>;
+    fn set_rpc_portal(&self, addr: SocketAddr);
+
+    fn get_vpn_portal_config(&self) -> Option<VpnPortalConfig>;
+    fn set_vpn_portal_config(&self, config: VpnPortalConfig);
+
+    fn get_flags(&self) -> Flags;
+    fn set_flags(&self, flags: Flags);
+
+    fn dump(&self) -> String;
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+pub struct NetworkIdentity {
+    pub network_name: String,
+    pub network_secret: String,
+}
+
+impl NetworkIdentity {
+    pub fn new(network_name: String, network_secret: String) -> Self {
+        NetworkIdentity {
+            network_name,
+            network_secret,
+        }
+    }
+
+    pub fn default() -> Self {
+        Self::new("default".to_string(), "".to_string())
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+pub struct PeerConfig {
+    pub uri: url::Url,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+pub struct NetworkConfig {
+    pub cidr: String,
+    pub allow: Option<Vec<String>>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Default)]
+pub struct FileLoggerConfig {
+    pub level: Option<String>,
+    pub file: Option<String>,
+    pub dir: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Default)]
+pub struct ConsoleLoggerConfig {
+    pub level: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+pub struct VpnPortalConfig {
+    pub client_cidr: cidr::Ipv4Cidr,
+    pub wireguard_listen: SocketAddr,
+}
+
+// Flags is used to control the behavior of the program
+#[derive(derivative::Derivative, Deserialize, Serialize)]
+#[derivative(Debug, Clone, PartialEq, Default)]
+pub struct Flags {
+    #[derivative(Default(value = "\"tcp\".to_string()"))]
+    pub default_protocol: String,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+struct Config {
+    netns: Option<String>,
+    instance_name: Option<String>,
+    instance_id: Option<String>,
+    ipv4: Option<String>,
+    network_identity: Option<NetworkIdentity>,
+    listeners: Option<Vec<url::Url>>,
+
+    peer: Option<Vec<PeerConfig>>,
+    proxy_network: Option<Vec<NetworkConfig>>,
+
+    file_logger: Option<FileLoggerConfig>,
+    console_logger: Option<ConsoleLoggerConfig>,
+
+    rpc_portal: Option<SocketAddr>,
+
+    vpn_portal_config: Option<VpnPortalConfig>,
+
+    flags: Option<Flags>,
+}
+
+#[derive(Debug, Clone)]
+pub struct TomlConfigLoader {
+    config: Arc<Mutex<Config>>,
+}
+
+impl Default for TomlConfigLoader {
+    fn default() -> Self {
+        TomlConfigLoader::new_from_str("").unwrap()
+    }
+}
+
+impl TomlConfigLoader {
+    pub fn new_from_str(config_str: &str) -> Result<Self, anyhow::Error> {
+        let config = toml::de::from_str::<Config>(config_str).with_context(|| {
+            format!(
+                "failed to parse config file: {}\n{}",
+                config_str, config_str
+            )
+        })?;
+        Ok(TomlConfigLoader {
+            config: Arc::new(Mutex::new(config)),
+        })
+    }
+
+    pub fn new(config_path: &str) -> Result<Self, anyhow::Error> {
+        let config_str = std::fs::read_to_string(config_path)
+            .with_context(|| format!("failed to read config file: {}", config_path))?;
+        Self::new_from_str(&config_str)
+    }
+}
+
+impl ConfigLoader for TomlConfigLoader {
+    fn get_inst_name(&self) -> String {
+        self.config
+            .lock()
+            .unwrap()
+            .instance_name
+            .clone()
+            .unwrap_or("default".to_string())
+    }
+
+    fn set_inst_name(&self, name: String) {
+        self.config.lock().unwrap().instance_name = Some(name);
+    }
+
+    fn get_netns(&self) -> Option<String> {
+        self.config.lock().unwrap().netns.clone()
+    }
+
+    fn set_netns(&self, ns: Option<String>) {
+        self.config.lock().unwrap().netns = ns;
+    }
+
+    fn get_ipv4(&self) -> Option<std::net::Ipv4Addr> {
+        let locked_config = self.config.lock().unwrap();
+        locked_config
+            .ipv4
+            .as_ref()
+            .map(|s| s.parse().ok())
+            .flatten()
+    }
+
+    fn set_ipv4(&self, addr: std::net::Ipv4Addr) {
+        self.config.lock().unwrap().ipv4 = Some(addr.to_string());
+    }
+
+    fn add_proxy_cidr(&self, cidr: cidr::IpCidr) {
+        let mut locked_config = self.config.lock().unwrap();
+        if locked_config.proxy_network.is_none() {
+            locked_config.proxy_network = Some(vec![]);
+        }
+        let cidr_str = cidr.to_string();
+        // insert if no duplicate
+        if !locked_config
+            .proxy_network
+            .as_ref()
+            .unwrap()
+            .iter()
+            .any(|c| c.cidr == cidr_str)
+        {
+            locked_config
+                .proxy_network
+                .as_mut()
+                .unwrap()
+                .push(NetworkConfig {
+                    cidr: cidr_str,
+                    allow: None,
+                });
+        }
+    }
+
+    fn remove_proxy_cidr(&self, cidr: cidr::IpCidr) {
+        let mut locked_config = self.config.lock().unwrap();
+        if let Some(proxy_cidrs) = &mut locked_config.proxy_network {
+            let cidr_str = cidr.to_string();
+            proxy_cidrs.retain(|c| c.cidr != cidr_str);
+        }
+    }
+
+    fn get_proxy_cidrs(&self) -> Vec<cidr::IpCidr> {
+        self.config
+            .lock()
+            .unwrap()
+            .proxy_network
+            .as_ref()
+            .map(|v| {
+                v.iter()
+                    .map(|c| c.cidr.parse().unwrap())
+                    .collect::<Vec<cidr::IpCidr>>()
+            })
+            .unwrap_or_default()
+    }
+
+    fn get_id(&self) -> uuid::Uuid {
+        let mut locked_config = self.config.lock().unwrap();
+        if locked_config.instance_id.is_none() {
+            let id = uuid::Uuid::new_v4();
+            locked_config.instance_id = Some(id.to_string());
+            id
+        } else {
+            uuid::Uuid::parse_str(locked_config.instance_id.as_ref().unwrap())
+                .with_context(|| {
+                    format!(
+                        "failed to parse instance id as uuid: {}, you can use this id: {}",
+                        locked_config.instance_id.as_ref().unwrap(),
+                        uuid::Uuid::new_v4()
+                    )
+                })
+                .unwrap()
+        }
+    }
+
+    fn get_network_identity(&self) -> NetworkIdentity {
+        self.config
+            .lock()
+            .unwrap()
+            .network_identity
+            .clone()
+            .unwrap_or_else(NetworkIdentity::default)
+    }
+
+    fn set_network_identity(&self, identity: NetworkIdentity) {
+        self.config.lock().unwrap().network_identity = Some(identity);
+    }
+
+    fn get_listener_uris(&self) -> Vec<url::Url> {
+        self.config
+            .lock()
+            .unwrap()
+            .listeners
+            .clone()
+            .unwrap_or_default()
+    }
+
+    fn get_file_logger_config(&self) -> FileLoggerConfig {
+        self.config
+            .lock()
+            .unwrap()
+            .file_logger
+            .clone()
+            .unwrap_or_default()
+    }
+
+    fn set_file_logger_config(&self, config: FileLoggerConfig) {
+        self.config.lock().unwrap().file_logger = Some(config);
+    }
+
+    fn get_console_logger_config(&self) -> ConsoleLoggerConfig {
+        self.config
+            .lock()
+            .unwrap()
+            .console_logger
+            .clone()
+            .unwrap_or_default()
+    }
+
+    fn set_console_logger_config(&self, config: ConsoleLoggerConfig) {
+        self.config.lock().unwrap().console_logger = Some(config);
+    }
+
+    fn get_peers(&self) -> Vec<PeerConfig> {
+        self.config.lock().unwrap().peer.clone().unwrap_or_default()
+    }
+
+    fn set_peers(&self, peers: Vec<PeerConfig>) {
+        self.config.lock().unwrap().peer = Some(peers);
+    }
+
+    fn get_listeners(&self) -> Vec<url::Url> {
+        self.config
+            .lock()
+            .unwrap()
+            .listeners
+            .clone()
+            .unwrap_or_default()
+    }
+
+    fn set_listeners(&self, listeners: Vec<url::Url>) {
+        self.config.lock().unwrap().listeners = Some(listeners);
+    }
+
+    fn get_rpc_portal(&self) -> Option<SocketAddr> {
+        self.config.lock().unwrap().rpc_portal
+    }
+
+    fn set_rpc_portal(&self, addr: SocketAddr) {
+        self.config.lock().unwrap().rpc_portal = Some(addr);
+    }
+
+    fn get_vpn_portal_config(&self) -> Option<VpnPortalConfig> {
+        self.config.lock().unwrap().vpn_portal_config.clone()
+    }
+    fn set_vpn_portal_config(&self, config: VpnPortalConfig) {
+        self.config.lock().unwrap().vpn_portal_config = Some(config);
+    }
+
+    fn get_flags(&self) -> Flags {
+        self.config
+            .lock()
+            .unwrap()
+            .flags
+            .clone()
+            .unwrap_or_default()
+    }
+
+    fn set_flags(&self, flags: Flags) {
+        self.config.lock().unwrap().flags = Some(flags);
+    }
+
+    fn dump(&self) -> String {
+        toml::to_string_pretty(&*self.config.lock().unwrap()).unwrap()
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn full_example_test() {
+        let config_str = r#"
+instance_name = "default"
+instance_id = "87ede5a2-9c3d-492d-9bbe-989b9d07e742"
+ipv4 = "10.144.144.10"
+listeners = [ "tcp://0.0.0.0:11010", "udp://0.0.0.0:11010" ]
+
+[network_identity]
+network_name = "default"
+network_secret = ""
+
+[[peer]]
+uri = "tcp://public.kkrainbow.top:11010"
+
+[[peer]]
+uri = "udp://192.168.94.33:11010"
+
+[[proxy_network]]
+cidr = "10.147.223.0/24"
+allow = ["tcp", "udp", "icmp"]
+
+[[proxy_network]]
+cidr = "10.1.1.0/24"
+allow = ["tcp", "icmp"]
+
+[file_logger]
+level = "info"
+file = "easytier"
+dir = "/tmp/easytier"
+
+[console_logger]
+level = "warn"
+"#;
+        let ret = TomlConfigLoader::new_from_str(config_str);
+        if let Err(e) = &ret {
+            println!("{}", e);
+        } else {
+            println!("{:?}", ret.as_ref().unwrap());
+        }
+        assert!(ret.is_ok());
+
+        let ret = ret.unwrap();
+        assert_eq!("10.144.144.10", ret.get_ipv4().unwrap().to_string());
+
+        assert_eq!(
+            vec!["tcp://0.0.0.0:11010", "udp://0.0.0.0:11010"],
+            ret.get_listener_uris()
+                .iter()
+                .map(|u| u.to_string())
+                .collect::<Vec<String>>()
+        );
+
+        println!("{}", ret.dump());
+    }
+}

easytier/src/common/constants.rs

@@ -0,0 +1,24 @@
+macro_rules! define_global_var {
+    ($name:ident, $type:ty, $init:expr) => {
+        pub static $name: once_cell::sync::Lazy<tokio::sync::Mutex<$type>> =
+            once_cell::sync::Lazy::new(|| tokio::sync::Mutex::new($init));
+    };
+}
+
+#[macro_export]
+macro_rules! use_global_var {
+    ($name:ident) => {
+        crate::common::constants::$name.lock().await.to_owned()
+    };
+}
+
+#[macro_export]
+macro_rules! set_global_var {
+    ($name:ident, $val:expr) => {
+        *crate::common::constants::$name.lock().await = $val
+    };
+}
+
+define_global_var!(MANUAL_CONNECTOR_RECONNECT_INTERVAL_MS, u64, 1000);
+
+pub const UDP_HOLE_PUNCH_CONNECTOR_SERVICE_ID: u32 = 2;

easytier/src/common/error.rs

@@ -0,0 +1,45 @@
+use std::{io, result};
+
+use thiserror::Error;
+
+use crate::tunnels;
+
+use super::PeerId;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("io error")]
+    IOError(#[from] io::Error),
+    #[error("rust tun error {0}")]
+    TunError(#[from] tun::Error),
+    #[error("tunnel error {0}")]
+    TunnelError(#[from] tunnels::TunnelError),
+    #[error("Peer has no conn, PeerId: {0}")]
+    PeerNoConnectionError(PeerId),
+    #[error("RouteError: {0:?}")]
+    RouteError(Option<String>),
+    #[error("Not found")]
+    NotFound,
+    #[error("Invalid Url: {0}")]
+    InvalidUrl(String),
+    #[error("Shell Command error: {0}")]
+    ShellCommandError(String),
+    // #[error("Rpc listen error: {0}")]
+    // RpcListenError(String),
+    #[error("Rpc connect error: {0}")]
+    RpcConnectError(String),
+    #[error("Rpc error: {0}")]
+    RpcClientError(#[from] tarpc::client::RpcError),
+    #[error("Timeout error: {0}")]
+    Timeout(#[from] tokio::time::error::Elapsed),
+    #[error("url in blacklist")]
+    UrlInBlacklist,
+    #[error("unknown data store error")]
+    Unknown,
+    #[error("anyhow error: {0}")]
+    AnyhowError(#[from] anyhow::Error),
+}
+
+pub type Result<T> = result::Result<T, Error>;
+
+// impl From for std::

easytier/src/common/global_ctx.rs

@@ -0,0 +1,256 @@
+use std::sync::{Arc, Mutex};
+
+use crate::rpc::PeerConnInfo;
+use crossbeam::atomic::AtomicCell;
+
+use super::{
+    config::{ConfigLoader, Flags},
+    netns::NetNS,
+    network::IPCollector,
+    stun::{StunInfoCollector, StunInfoCollectorTrait},
+    PeerId,
+};
+
+pub type NetworkIdentity = crate::common::config::NetworkIdentity;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum GlobalCtxEvent {
+    TunDeviceReady(String),
+
+    PeerAdded(PeerId),
+    PeerRemoved(PeerId),
+    PeerConnAdded(PeerConnInfo),
+    PeerConnRemoved(PeerConnInfo),
+
+    ListenerAdded(url::Url),
+    ConnectionAccepted(String, String), // (local url, remote url)
+    ConnectionError(String, String, String), // (local url, remote url, error message)
+
+    Connecting(url::Url),
+    ConnectError(String, String), // (dst, error message)
+
+    VpnPortalClientConnected(String, String), // (portal, client ip)
+    VpnPortalClientDisconnected(String, String), // (portal, client ip)
+}
+
+type EventBus = tokio::sync::broadcast::Sender<GlobalCtxEvent>;
+type EventBusSubscriber = tokio::sync::broadcast::Receiver<GlobalCtxEvent>;
+
+pub struct GlobalCtx {
+    pub inst_name: String,
+    pub id: uuid::Uuid,
+    pub config: Box<dyn ConfigLoader>,
+    pub net_ns: NetNS,
+    pub network: NetworkIdentity,
+
+    event_bus: EventBus,
+
+    cached_ipv4: AtomicCell<Option<std::net::Ipv4Addr>>,
+    cached_proxy_cidrs: AtomicCell<Option<Vec<cidr::IpCidr>>>,
+
+    ip_collector: Arc<IPCollector>,
+
+    hotname: AtomicCell<Option<String>>,
+
+    stun_info_collection: Box<dyn StunInfoCollectorTrait>,
+
+    running_listeners: Mutex<Vec<url::Url>>,
+}
+
+impl std::fmt::Debug for GlobalCtx {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("GlobalCtx")
+            .field("inst_name", &self.inst_name)
+            .field("id", &self.id)
+            .field("net_ns", &self.net_ns.name())
+            .field("event_bus", &"EventBus")
+            .field("ipv4", &self.cached_ipv4)
+            .finish()
+    }
+}
+
+pub type ArcGlobalCtx = std::sync::Arc<GlobalCtx>;
+
+impl GlobalCtx {
+    pub fn new(config_fs: impl ConfigLoader + 'static + Send + Sync) -> Self {
+        let id = config_fs.get_id();
+        let network = config_fs.get_network_identity();
+        let net_ns = NetNS::new(config_fs.get_netns());
+
+        let (event_bus, _) = tokio::sync::broadcast::channel(100);
+
+        GlobalCtx {
+            inst_name: config_fs.get_inst_name(),
+            id,
+            config: Box::new(config_fs),
+            net_ns: net_ns.clone(),
+            network,
+
+            event_bus,
+            cached_ipv4: AtomicCell::new(None),
+            cached_proxy_cidrs: AtomicCell::new(None),
+
+            ip_collector: Arc::new(IPCollector::new(net_ns)),
+
+            hotname: AtomicCell::new(None),
+
+            stun_info_collection: Box::new(StunInfoCollector::new_with_default_servers()),
+
+            running_listeners: Mutex::new(Vec::new()),
+        }
+    }
+
+    pub fn subscribe(&self) -> EventBusSubscriber {
+        self.event_bus.subscribe()
+    }
+
+    pub fn issue_event(&self, event: GlobalCtxEvent) {
+        if self.event_bus.receiver_count() != 0 {
+            self.event_bus.send(event).unwrap();
+        } else {
+            log::warn!("No subscriber for event: {:?}", event);
+        }
+    }
+
+    pub fn get_ipv4(&self) -> Option<std::net::Ipv4Addr> {
+        if let Some(ret) = self.cached_ipv4.load() {
+            return Some(ret);
+        }
+        let addr = self.config.get_ipv4();
+        self.cached_ipv4.store(addr.clone());
+        return addr;
+    }
+
+    pub fn set_ipv4(&mut self, addr: std::net::Ipv4Addr) {
+        self.config.set_ipv4(addr);
+        self.cached_ipv4.store(None);
+    }
+
+    pub fn add_proxy_cidr(&self, cidr: cidr::IpCidr) -> Result<(), std::io::Error> {
+        self.config.add_proxy_cidr(cidr);
+        self.cached_proxy_cidrs.store(None);
+        Ok(())
+    }
+
+    pub fn remove_proxy_cidr(&self, cidr: cidr::IpCidr) -> Result<(), std::io::Error> {
+        self.config.remove_proxy_cidr(cidr);
+        self.cached_proxy_cidrs.store(None);
+        Ok(())
+    }
+
+    pub fn get_proxy_cidrs(&self) -> Vec<cidr::IpCidr> {
+        if let Some(proxy_cidrs) = self.cached_proxy_cidrs.take() {
+            self.cached_proxy_cidrs.store(Some(proxy_cidrs.clone()));
+            return proxy_cidrs;
+        }
+
+        let ret = self.config.get_proxy_cidrs();
+        self.cached_proxy_cidrs.store(Some(ret.clone()));
+        ret
+    }
+
+    pub fn get_id(&self) -> uuid::Uuid {
+        self.config.get_id()
+    }
+
+    pub fn get_network_identity(&self) -> NetworkIdentity {
+        self.config.get_network_identity()
+    }
+
+    pub fn get_ip_collector(&self) -> Arc<IPCollector> {
+        self.ip_collector.clone()
+    }
+
+    pub fn get_hostname(&self) -> Option<String> {
+        if let Some(hostname) = self.hotname.take() {
+            self.hotname.store(Some(hostname.clone()));
+            return Some(hostname);
+        }
+
+        let hostname = gethostname::gethostname().to_string_lossy().to_string();
+        self.hotname.store(Some(hostname.clone()));
+        return Some(hostname);
+    }
+
+    pub fn get_stun_info_collector(&self) -> impl StunInfoCollectorTrait + '_ {
+        self.stun_info_collection.as_ref()
+    }
+
+    #[cfg(test)]
+    pub fn replace_stun_info_collector(&self, collector: Box<dyn StunInfoCollectorTrait>) {
+        // force replace the stun_info_collection without mut and drop the old one
+        let ptr = &self.stun_info_collection as *const Box<dyn StunInfoCollectorTrait>;
+        let ptr = ptr as *mut Box<dyn StunInfoCollectorTrait>;
+        unsafe {
+            std::ptr::drop_in_place(ptr);
+            #[allow(invalid_reference_casting)]
+            std::ptr::write(ptr, collector);
+        }
+    }
+
+    pub fn get_running_listeners(&self) -> Vec<url::Url> {
+        self.running_listeners.lock().unwrap().clone()
+    }
+
+    pub fn add_running_listener(&self, url: url::Url) {
+        self.running_listeners.lock().unwrap().push(url);
+    }
+
+    pub fn get_vpn_portal_cidr(&self) -> Option<cidr::Ipv4Cidr> {
+        self.config.get_vpn_portal_config().map(|x| x.client_cidr)
+    }
+
+    pub fn get_flags(&self) -> Flags {
+        self.config.get_flags()
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use crate::common::{config::TomlConfigLoader, new_peer_id};
+
+    use super::*;
+
+    #[tokio::test]
+    async fn test_global_ctx() {
+        let config = TomlConfigLoader::default();
+        let global_ctx = GlobalCtx::new(config);
+
+        let mut subscriber = global_ctx.subscribe();
+        let peer_id = new_peer_id();
+        global_ctx.issue_event(GlobalCtxEvent::PeerAdded(peer_id.clone()));
+        global_ctx.issue_event(GlobalCtxEvent::PeerRemoved(peer_id.clone()));
+        global_ctx.issue_event(GlobalCtxEvent::PeerConnAdded(PeerConnInfo::default()));
+        global_ctx.issue_event(GlobalCtxEvent::PeerConnRemoved(PeerConnInfo::default()));
+
+        assert_eq!(
+            subscriber.recv().await.unwrap(),
+            GlobalCtxEvent::PeerAdded(peer_id.clone())
+        );
+        assert_eq!(
+            subscriber.recv().await.unwrap(),
+            GlobalCtxEvent::PeerRemoved(peer_id.clone())
+        );
+        assert_eq!(
+            subscriber.recv().await.unwrap(),
+            GlobalCtxEvent::PeerConnAdded(PeerConnInfo::default())
+        );
+        assert_eq!(
+            subscriber.recv().await.unwrap(),
+            GlobalCtxEvent::PeerConnRemoved(PeerConnInfo::default())
+        );
+    }
+
+    pub fn get_mock_global_ctx_with_network(
+        network_identy: Option<NetworkIdentity>,
+    ) -> ArcGlobalCtx {
+        let config_fs = TomlConfigLoader::default();
+        config_fs.set_inst_name(format!("test_{}", config_fs.get_id()));
+        config_fs.set_network_identity(network_identy.unwrap_or(NetworkIdentity::default()));
+        std::sync::Arc::new(GlobalCtx::new(config_fs))
+    }
+
+    pub fn get_mock_global_ctx() -> ArcGlobalCtx {
+        get_mock_global_ctx_with_network(None)
+    }
+}

easytier/src/common/ifcfg.rs

@@ -0,0 +1,358 @@
+use std::net::Ipv4Addr;
+
+use async_trait::async_trait;
+use tokio::process::Command;
+
+use super::error::Error;
+
+#[async_trait]
+pub trait IfConfiguerTrait {
+    async fn add_ipv4_route(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error>;
+    async fn remove_ipv4_route(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error>;
+    async fn add_ipv4_ip(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error>;
+    async fn set_link_status(&self, name: &str, up: bool) -> Result<(), Error>;
+    async fn remove_ip(&self, name: &str, ip: Option<Ipv4Addr>) -> Result<(), Error>;
+    async fn wait_interface_show(&self, _name: &str) -> Result<(), Error> {
+        return Ok(());
+    }
+}
+
+fn cidr_to_subnet_mask(prefix_length: u8) -> Ipv4Addr {
+    if prefix_length > 32 {
+        panic!("Invalid CIDR prefix length");
+    }
+
+    let subnet_mask: u32 = (!0u32)
+        .checked_shl(32 - u32::from(prefix_length))
+        .unwrap_or(0);
+    Ipv4Addr::new(
+        ((subnet_mask >> 24) & 0xFF) as u8,
+        ((subnet_mask >> 16) & 0xFF) as u8,
+        ((subnet_mask >> 8) & 0xFF) as u8,
+        (subnet_mask & 0xFF) as u8,
+    )
+}
+
+async fn run_shell_cmd(cmd: &str) -> Result<(), Error> {
+    let cmd_out = if cfg!(target_os = "windows") {
+        Command::new("cmd").arg("/C").arg(cmd).output().await?
+    } else {
+        Command::new("sh").arg("-c").arg(cmd).output().await?
+    };
+    let stdout = String::from_utf8_lossy(cmd_out.stdout.as_slice());
+    let stderr = String::from_utf8_lossy(cmd_out.stderr.as_slice());
+    let ec = cmd_out.status.code();
+    let succ = cmd_out.status.success();
+    tracing::info!(?cmd, ?ec, ?succ, ?stdout, ?stderr, "run shell cmd");
+
+    if !cmd_out.status.success() {
+        return Err(Error::ShellCommandError(
+            stdout.to_string() + &stderr.to_string(),
+        ));
+    }
+    Ok(())
+}
+
+pub struct MacIfConfiger {}
+#[async_trait]
+impl IfConfiguerTrait for MacIfConfiger {
+    async fn add_ipv4_route(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error> {
+        run_shell_cmd(
+            format!(
+                "route -n add {} -netmask {} -interface {} -hopcount 7",
+                address,
+                cidr_to_subnet_mask(cidr_prefix),
+                name
+            )
+            .as_str(),
+        )
+        .await
+    }
+
+    async fn remove_ipv4_route(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error> {
+        run_shell_cmd(
+            format!(
+                "route -n delete {} -netmask {} -interface {}",
+                address,
+                cidr_to_subnet_mask(cidr_prefix),
+                name
+            )
+            .as_str(),
+        )
+        .await
+    }
+
+    async fn add_ipv4_ip(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error> {
+        run_shell_cmd(
+            format!(
+                "ifconfig {} {:?}/{:?} 10.8.8.8 up",
+                name, address, cidr_prefix,
+            )
+            .as_str(),
+        )
+        .await
+    }
+
+    async fn set_link_status(&self, name: &str, up: bool) -> Result<(), Error> {
+        run_shell_cmd(format!("ifconfig {} {}", name, if up { "up" } else { "down" }).as_str())
+            .await
+    }
+
+    async fn remove_ip(&self, name: &str, ip: Option<Ipv4Addr>) -> Result<(), Error> {
+        if ip.is_none() {
+            run_shell_cmd(format!("ifconfig {} inet delete", name).as_str()).await
+        } else {
+            run_shell_cmd(
+                format!("ifconfig {} inet {} delete", name, ip.unwrap().to_string()).as_str(),
+            )
+            .await
+        }
+    }
+}
+
+pub struct LinuxIfConfiger {}
+#[async_trait]
+impl IfConfiguerTrait for LinuxIfConfiger {
+    async fn add_ipv4_route(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error> {
+        run_shell_cmd(
+            format!(
+                "ip route add {}/{} dev {} metric 65535",
+                address, cidr_prefix, name
+            )
+            .as_str(),
+        )
+        .await
+    }
+
+    async fn remove_ipv4_route(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error> {
+        run_shell_cmd(format!("ip route del {}/{} dev {}", address, cidr_prefix, name).as_str())
+            .await
+    }
+
+    async fn add_ipv4_ip(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error> {
+        run_shell_cmd(format!("ip addr add {:?}/{:?} dev {}", address, cidr_prefix, name).as_str())
+            .await
+    }
+
+    async fn set_link_status(&self, name: &str, up: bool) -> Result<(), Error> {
+        run_shell_cmd(format!("ip link set {} {}", name, if up { "up" } else { "down" }).as_str())
+            .await
+    }
+
+    async fn remove_ip(&self, name: &str, ip: Option<Ipv4Addr>) -> Result<(), Error> {
+        if ip.is_none() {
+            run_shell_cmd(format!("ip addr flush dev {}", name).as_str()).await
+        } else {
+            run_shell_cmd(
+                format!("ip addr del {:?} dev {}", ip.unwrap().to_string(), name).as_str(),
+            )
+            .await
+        }
+    }
+}
+
+#[cfg(target_os = "windows")]
+pub struct WindowsIfConfiger {}
+
+#[cfg(target_os = "windows")]
+impl WindowsIfConfiger {
+    pub fn get_interface_index(name: &str) -> Option<u32> {
+        crate::arch::windows::find_interface_index(name).ok()
+    }
+
+    async fn list_ipv4(name: &str) -> Result<Vec<Ipv4Addr>, Error> {
+        use anyhow::Context;
+        use network_interface::NetworkInterfaceConfig;
+        use std::net::IpAddr;
+        let ret = network_interface::NetworkInterface::show().with_context(|| "show interface")?;
+        let addrs = ret
+            .iter()
+            .filter_map(|x| {
+                if x.name != name {
+                    return None;
+                }
+                Some(x.addr.clone())
+            })
+            .flat_map(|x| x)
+            .map(|x| x.ip())
+            .filter_map(|x| {
+                if let IpAddr::V4(ipv4) = x {
+                    Some(ipv4)
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+
+        Ok(addrs)
+    }
+
+    async fn remove_one_ipv4(name: &str, ip: Ipv4Addr) -> Result<(), Error> {
+        run_shell_cmd(
+            format!(
+                "netsh interface ipv4 delete address {} address={}",
+                name,
+                ip.to_string()
+            )
+            .as_str(),
+        )
+        .await
+    }
+}
+
+#[cfg(target_os = "windows")]
+#[async_trait]
+impl IfConfiguerTrait for WindowsIfConfiger {
+    async fn add_ipv4_route(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error> {
+        let Some(idx) = Self::get_interface_index(name) else {
+            return Err(Error::NotFound);
+        };
+        run_shell_cmd(
+            format!(
+                "route ADD {} MASK {} 10.1.1.1 IF {} METRIC 255",
+                address,
+                cidr_to_subnet_mask(cidr_prefix),
+                idx
+            )
+            .as_str(),
+        )
+        .await
+    }
+
+    async fn remove_ipv4_route(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error> {
+        let Some(idx) = Self::get_interface_index(name) else {
+            return Err(Error::NotFound);
+        };
+        run_shell_cmd(
+            format!(
+                "route DELETE {} MASK {} IF {}",
+                address,
+                cidr_to_subnet_mask(cidr_prefix),
+                idx
+            )
+            .as_str(),
+        )
+        .await
+    }
+
+    async fn add_ipv4_ip(
+        &self,
+        name: &str,
+        address: Ipv4Addr,
+        cidr_prefix: u8,
+    ) -> Result<(), Error> {
+        run_shell_cmd(
+            format!(
+                "netsh interface ipv4 add address {} address={} mask={}",
+                name,
+                address,
+                cidr_to_subnet_mask(cidr_prefix)
+            )
+            .as_str(),
+        )
+        .await
+    }
+
+    async fn set_link_status(&self, name: &str, up: bool) -> Result<(), Error> {
+        run_shell_cmd(
+            format!(
+                "netsh interface set interface {} {}",
+                name,
+                if up { "enable" } else { "disable" }
+            )
+            .as_str(),
+        )
+        .await
+    }
+
+    async fn remove_ip(&self, name: &str, ip: Option<Ipv4Addr>) -> Result<(), Error> {
+        if ip.is_none() {
+            for ip in Self::list_ipv4(name).await?.iter() {
+                Self::remove_one_ipv4(name, *ip).await?;
+            }
+            Ok(())
+        } else {
+            Self::remove_one_ipv4(name, ip.unwrap()).await
+        }
+    }
+
+    async fn wait_interface_show(&self, name: &str) -> Result<(), Error> {
+        Ok(
+            tokio::time::timeout(std::time::Duration::from_secs(10), async move {
+                loop {
+                    if let Some(idx) = Self::get_interface_index(name) {
+                        tracing::info!(?name, ?idx, "Interface found");
+                        break;
+                    }
+                    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+                }
+                Ok::<(), Error>(())
+            })
+            .await??,
+        )
+    }
+}
+
+#[cfg(target_os = "macos")]
+pub type IfConfiger = MacIfConfiger;
+
+#[cfg(target_os = "linux")]
+pub type IfConfiger = LinuxIfConfiger;
+
+#[cfg(target_os = "windows")]
+pub type IfConfiger = WindowsIfConfiger;

easytier/src/common/mod.rs

@@ -0,0 +1,120 @@
+use std::{
+    fmt::Debug,
+    future,
+    sync::{Arc, Mutex},
+};
+use tokio::task::JoinSet;
+use tracing::Instrument;
+
+pub mod config;
+pub mod constants;
+pub mod error;
+pub mod global_ctx;
+pub mod ifcfg;
+pub mod netns;
+pub mod network;
+pub mod rkyv_util;
+pub mod stun;
+pub mod stun_codec_ext;
+
+pub fn get_logger_timer<F: time::formatting::Formattable>(
+    format: F,
+) -> tracing_subscriber::fmt::time::OffsetTime<F> {
+    unsafe {
+        time::util::local_offset::set_soundness(time::util::local_offset::Soundness::Unsound)
+    };
+    let local_offset = time::UtcOffset::current_local_offset()
+        .unwrap_or(time::UtcOffset::from_whole_seconds(0).unwrap());
+    tracing_subscriber::fmt::time::OffsetTime::new(local_offset, format)
+}
+
+pub fn get_logger_timer_rfc3339(
+) -> tracing_subscriber::fmt::time::OffsetTime<time::format_description::well_known::Rfc3339> {
+    get_logger_timer(time::format_description::well_known::Rfc3339)
+}
+
+pub type PeerId = u32;
+
+pub fn new_peer_id() -> PeerId {
+    rand::random()
+}
+
+pub fn join_joinset_background<T: Debug + Send + Sync + 'static>(
+    js: Arc<Mutex<JoinSet<T>>>,
+    origin: String,
+) {
+    let js = Arc::downgrade(&js);
+    tokio::spawn(
+        async move {
+            loop {
+                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                if js.weak_count() == 0 {
+                    tracing::info!("joinset task exit");
+                    break;
+                }
+
+                future::poll_fn(|cx| {
+                    tracing::debug!("try join joinset tasks");
+                    let Some(js) = js.upgrade() else {
+                        return std::task::Poll::Ready(());
+                    };
+
+                    let mut js = js.lock().unwrap();
+                    while !js.is_empty() {
+                        let ret = js.poll_join_next(cx);
+                        if ret.is_pending() {
+                            return std::task::Poll::Pending;
+                        }
+                    }
+
+                    std::task::Poll::Ready(())
+                })
+                .await;
+            }
+        }
+        .instrument(tracing::info_span!(
+            "join_joinset_background",
+            origin = origin
+        )),
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_join_joinset_backgroud() {
+        let js = Arc::new(Mutex::new(JoinSet::<()>::new()));
+        join_joinset_background(js.clone(), "TEST".to_owned());
+        js.try_lock().unwrap().spawn(async {
+            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+        });
+        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+        assert!(js.try_lock().unwrap().is_empty());
+
+        for _ in 0..5 {
+            js.try_lock().unwrap().spawn(async {
+                tokio::time::sleep(std::time::Duration::from_secs(3)).await;
+            });
+            tokio::task::yield_now().await;
+        }
+
+        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+
+        for _ in 0..5 {
+            js.try_lock().unwrap().spawn(async {
+                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+            });
+            tokio::task::yield_now().await;
+        }
+
+        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+        assert!(js.try_lock().unwrap().is_empty());
+
+        let weak_js = Arc::downgrade(&js);
+        drop(js);
+        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+        assert_eq!(weak_js.weak_count(), 0);
+    }
+}

easytier/src/common/netns.rs

@@ -0,0 +1,114 @@
+use futures::Future;
+
+#[cfg(target_os = "linux")]
+use nix::sched::{setns, CloneFlags};
+#[cfg(target_os = "linux")]
+use std::os::fd::AsFd;
+
+pub struct NetNSGuard {
+    #[cfg(target_os = "linux")]
+    old_ns: Option<std::fs::File>,
+}
+
+pub static ROOT_NETNS_NAME: &str = "_root_ns";
+
+#[cfg(target_os = "linux")]
+impl NetNSGuard {
+    pub fn new(ns: Option<String>) -> Box<Self> {
+        let old_ns = if ns.is_some() {
+            let old_ns = if cfg!(target_os = "linux") {
+                Some(std::fs::File::open("/proc/self/ns/net").unwrap())
+            } else {
+                None
+            };
+            Self::switch_ns(ns);
+            old_ns
+        } else {
+            None
+        };
+        Box::new(NetNSGuard { old_ns })
+    }
+
+    fn switch_ns(name: Option<String>) {
+        if name.is_none() {
+            return;
+        }
+
+        let ns_path: String;
+        let name = name.unwrap();
+        if name == ROOT_NETNS_NAME {
+            ns_path = "/proc/1/ns/net".to_string();
+        } else {
+            ns_path = format!("/var/run/netns/{}", name);
+        }
+
+        let ns = std::fs::File::open(ns_path).unwrap();
+        log::info!(
+            "[INIT NS] switching to new ns_name: {:?}, ns_file: {:?}",
+            name,
+            ns
+        );
+
+        setns(ns.as_fd(), CloneFlags::CLONE_NEWNET).unwrap();
+    }
+}
+
+#[cfg(target_os = "linux")]
+impl Drop for NetNSGuard {
+    fn drop(&mut self) {
+        if self.old_ns.is_none() {
+            return;
+        }
+        log::info!("[INIT NS] switching back to old ns, ns: {:?}", self.old_ns);
+        setns(
+            self.old_ns.as_ref().unwrap().as_fd(),
+            CloneFlags::CLONE_NEWNET,
+        )
+        .unwrap();
+    }
+}
+
+#[cfg(not(target_os = "linux"))]
+impl NetNSGuard {
+    pub fn new(_ns: Option<String>) -> Box<Self> {
+        Box::new(NetNSGuard {})
+    }
+}
+
+#[derive(Clone)]
+pub struct NetNS {
+    name: Option<String>,
+}
+
+impl NetNS {
+    pub fn new(name: Option<String>) -> Self {
+        NetNS { name }
+    }
+
+    pub async fn run_async<F, Fut, Ret>(&self, f: F) -> Ret
+    where
+        F: FnOnce() -> Fut,
+        Fut: Future<Output = Ret>,
+    {
+        // TODO: do we really need this lock
+        // let _lock = LOCK.lock().await;
+        let _guard = NetNSGuard::new(self.name.clone());
+        f().await
+    }
+
+    pub fn run<F, Ret>(&self, f: F) -> Ret
+    where
+        F: FnOnce() -> Ret,
+    {
+        let _guard = NetNSGuard::new(self.name.clone());
+        f()
+    }
+
+    pub fn guard(&self) -> Box<NetNSGuard> {
+        NetNSGuard::new(self.name.clone())
+    }
+
+    pub fn name(&self) -> Option<String> {
+        self.name.clone()
+    }
+}

easytier/src/common/network.rs

@@ -0,0 +1,243 @@
+use std::{ops::Deref, sync::Arc};
+
+use crate::rpc::peer::GetIpListResponse;
+use pnet::datalink::NetworkInterface;
+use tokio::{
+    sync::{Mutex, RwLock},
+    task::JoinSet,
+};
+
+use super::netns::NetNS;
+
+pub const CACHED_IP_LIST_TIMEOUT_SEC: u64 = 60;
+
+struct InterfaceFilter {
+    iface: NetworkInterface,
+}
+
+#[cfg(target_os = "linux")]
+impl InterfaceFilter {
+    async fn is_tun_tap_device(&self) -> bool {
+        let path = format!("/sys/class/net/{}/tun_flags", self.iface.name);
+        tokio::fs::metadata(&path).await.is_ok()
+    }
+
+    async fn has_valid_ip(&self) -> bool {
+        self.iface
+            .ips
+            .iter()
+            .map(|ip| ip.ip())
+            .any(|ip| !ip.is_loopback() && !ip.is_unspecified() && !ip.is_multicast())
+    }
+
+    async fn filter_iface(&self) -> bool {
+        tracing::trace!(
+            "filter linux iface: {:?}, is_point_to_point: {}, is_loopback: {}, is_up: {}, is_lower_up: {}, is_tun: {}, has_valid_ip: {}",
+            self.iface,
+            self.iface.is_point_to_point(),
+            self.iface.is_loopback(),
+            self.iface.is_up(),
+            self.iface.is_lower_up(),
+            self.is_tun_tap_device().await,
+            self.has_valid_ip().await
+        );
+
+        !self.iface.is_point_to_point()
+            && !self.iface.is_loopback()
+            && self.iface.is_up()
+            && self.iface.is_lower_up()
+            && !self.is_tun_tap_device().await
+            && self.has_valid_ip().await
+    }
+}
+
+#[cfg(target_os = "macos")]
+impl InterfaceFilter {
+    async fn is_interface_physical(interface_name: &str) -> bool {
+        let output = tokio::process::Command::new("networksetup")
+            .args(&["-listallhardwareports"])
+            .output()
+            .await
+            .expect("Failed to execute command");
+
+        let stdout = std::str::from_utf8(&output.stdout).expect("Invalid UTF-8");
+
+        let lines: Vec<&str> = stdout.lines().collect();
+
+        for i in 0..lines.len() {
+            let line = lines[i];
+
+            if line.contains("Device:") && line.contains(interface_name) {
+                let next_line = lines[i + 1];
+                if next_line.contains("Virtual Interface") {
+                    return false;
+                } else {
+                    return true;
+                }
+            }
+        }
+
+        false
+    }
+
+    async fn filter_iface(&self) -> bool {
+        !self.iface.is_point_to_point()
+            && !self.iface.is_loopback()
+            && self.iface.is_up()
+            && Self::is_interface_physical(&self.iface.name).await
+    }
+}
+
+#[cfg(target_os = "windows")]
+impl InterfaceFilter {
+    async fn filter_iface(&self) -> bool {
+        tracing::debug!(
+            "iface_name: {:?}, p2p: {:?}, is_up: {:?}, iface: {:?}",
+            self.iface.name,
+            self.iface.is_point_to_point(),
+            self.iface.is_up(),
+            self.iface
+        );
+        !self.iface.is_point_to_point()
+            && !self.iface.is_loopback()
+            && self
+                .iface
+                .ips
+                .iter()
+                .map(|ip| ip.ip())
+                .any(|ip| !ip.is_loopback() && !ip.is_unspecified() && !ip.is_multicast())
+            && self.iface.mac.map(|mac| !mac.is_zero()).unwrap_or(false)
+    }
+}
+
+pub async fn local_ipv4() -> std::io::Result<std::net::Ipv4Addr> {
+    let socket = tokio::net::UdpSocket::bind("0.0.0.0:0").await?;
+    socket.connect("8.8.8.8:80").await?;
+    let addr = socket.local_addr()?;
+    match addr.ip() {
+        std::net::IpAddr::V4(ip) => Ok(ip),
+        std::net::IpAddr::V6(_) => Err(std::io::Error::new(
+            std::io::ErrorKind::AddrNotAvailable,
+            "no ipv4 address",
+        )),
+    }
+}
+
+pub async fn local_ipv6() -> std::io::Result<std::net::Ipv6Addr> {
+    let socket = tokio::net::UdpSocket::bind("[::]:0").await?;
+    socket
+        .connect("[2001:4860:4860:0000:0000:0000:0000:8888]:80")
+        .await?;
+    let addr = socket.local_addr()?;
+    match addr.ip() {
+        std::net::IpAddr::V6(ip) => Ok(ip),
+        std::net::IpAddr::V4(_) => Err(std::io::Error::new(
+            std::io::ErrorKind::AddrNotAvailable,
+            "no ipv4 address",
+        )),
+    }
+}
+
+pub struct IPCollector {
+    cached_ip_list: Arc<RwLock<GetIpListResponse>>,
+    collect_ip_task: Mutex<JoinSet<()>>,
+    net_ns: NetNS,
+}
+
+impl IPCollector {
+    pub fn new(net_ns: NetNS) -> Self {
+        Self {
+            cached_ip_list: Arc::new(RwLock::new(GetIpListResponse::new())),
+            collect_ip_task: Mutex::new(JoinSet::new()),
+            net_ns,
+        }
+    }
+
+    pub async fn collect_ip_addrs(&self) -> GetIpListResponse {
+        let mut task = self.collect_ip_task.lock().await;
+        if task.is_empty() {
+            let cached_ip_list = self.cached_ip_list.clone();
+            *cached_ip_list.write().await =
+                Self::do_collect_ip_addrs(false, self.net_ns.clone()).await;
+            let net_ns = self.net_ns.clone();
+            task.spawn(async move {
+                loop {
+                    let ip_addrs = Self::do_collect_ip_addrs(true, net_ns.clone()).await;
+                    *cached_ip_list.write().await = ip_addrs;
+                    tokio::time::sleep(std::time::Duration::from_secs(CACHED_IP_LIST_TIMEOUT_SEC))
+                        .await;
+                }
+            });
+        }
+
+        return self.cached_ip_list.read().await.deref().clone();
+    }
+
+    pub async fn collect_interfaces(net_ns: NetNS) -> Vec<NetworkInterface> {
+        let _g = net_ns.guard();
+        let ifaces = pnet::datalink::interfaces();
+        let mut ret = vec![];
+        for iface in ifaces {
+            let f = InterfaceFilter {
+                iface: iface.clone(),
+            };
+
+            if !f.filter_iface().await {
+                continue;
+            }
+
+            ret.push(iface);
+        }
+
+        ret
+    }
+
+    #[tracing::instrument(skip(net_ns))]
+    async fn do_collect_ip_addrs(with_public: bool, net_ns: NetNS) -> GetIpListResponse {
+        let mut ret = crate::rpc::peer::GetIpListResponse::new();
+
+        if with_public {
+            if let Some(v4_addr) =
+                public_ip::addr_with(public_ip::http::ALL, public_ip::Version::V4).await
+            {
+                ret.public_ipv4 = v4_addr.to_string();
+            }
+
+            if let Some(v6_addr) = public_ip::addr_v6().await {
+                ret.public_ipv6 = v6_addr.to_string();
+            }
+        }
+
+        let ifaces = Self::collect_interfaces(net_ns.clone()).await;
+        let _g = net_ns.guard();
+        for iface in ifaces {
+            for ip in iface.ips {
+                let ip: std::net::IpAddr = ip.ip();
+                if ip.is_loopback() || ip.is_multicast() {
+                    continue;
+                }
+                if ip.is_ipv4() {
+                    ret.interface_ipv4s.push(ip.to_string());
+                } else if ip.is_ipv6() {
+                    ret.interface_ipv6s.push(ip.to_string());
+                }
+            }
+        }
+
+        if let Ok(v4_addr) = local_ipv4().await {
+            tracing::trace!("got local ipv4: {}", v4_addr);
+            if !ret.interface_ipv4s.contains(&v4_addr.to_string()) {
+                ret.interface_ipv4s.push(v4_addr.to_string());
+            }
+        }
+
+        if let Ok(v6_addr) = local_ipv6().await {
+            tracing::trace!("got local ipv6: {}", v6_addr);
+            if !ret.interface_ipv6s.contains(&v6_addr.to_string()) {
+                ret.interface_ipv6s.push(v6_addr.to_string());
+            }
+        }
+
+        ret
+    }
+}

easytier/src/common/rkyv_util.rs

@@ -0,0 +1,72 @@
+use rkyv::{
+    string::ArchivedString,
+    validation::{validators::DefaultValidator, CheckTypeError},
+    vec::ArchivedVec,
+    Archive, CheckBytes, Serialize,
+};
+use tokio_util::bytes::{Bytes, BytesMut};
+
+pub fn decode_from_bytes_checked<'a, T: Archive>(
+    bytes: &'a [u8],
+) -> Result<&'a T::Archived, CheckTypeError<T::Archived, DefaultValidator<'a>>>
+where
+    T::Archived: CheckBytes<DefaultValidator<'a>>,
+{
+    rkyv::check_archived_root::<T>(bytes)
+}
+
+pub fn decode_from_bytes<'a, T: Archive>(
+    bytes: &'a [u8],
+) -> Result<&'a T::Archived, CheckTypeError<T::Archived, DefaultValidator<'a>>>
+where
+    T::Archived: CheckBytes<DefaultValidator<'a>>,
+{
+    // rkyv::check_archived_root::<T>(bytes)
+    unsafe { Ok(rkyv::archived_root::<T>(bytes)) }
+}
+
+// allow deseraial T to Bytes
+pub fn encode_to_bytes<T, const N: usize>(val: &T) -> Bytes
+where
+    T: Serialize<rkyv::ser::serializers::AllocSerializer<N>>,
+{
+    let ret = rkyv::to_bytes::<_, N>(val).unwrap();
+    // let mut r = BytesMut::new();
+    // r.extend_from_slice(&ret);
+    // r.freeze()
+    ret.into_boxed_slice().into()
+}
+
+pub fn extract_bytes_from_archived_vec(raw_data: &Bytes, archived_data: &ArchivedVec<u8>) -> Bytes {
+    let ptr_range = archived_data.as_ptr_range();
+    let offset = ptr_range.start as usize - raw_data.as_ptr() as usize;
+    let len = ptr_range.end as usize - ptr_range.start as usize;
+    return raw_data.slice(offset..offset + len);
+}
+
+pub fn extract_bytes_from_archived_string(
+    raw_data: &Bytes,
+    archived_data: &ArchivedString,
+) -> Bytes {
+    let offset = archived_data.as_ptr() as usize - raw_data.as_ptr() as usize;
+    let len = archived_data.len();
+    if offset + len > raw_data.len() {
+        return Bytes::new();
+    }
+
+    return raw_data.slice(offset..offset + archived_data.len());
+}
+
+pub fn extract_bytes_mut_from_archived_vec(
+    raw_data: &mut BytesMut,
+    archived_data: &ArchivedVec<u8>,
+) -> BytesMut {
+    let ptr_range = archived_data.as_ptr_range();
+    let offset = ptr_range.start as usize - raw_data.as_ptr() as usize;
+    let len = ptr_range.end as usize - ptr_range.start as usize;
+    raw_data.split_off(offset).split_to(len)
+}
+
+pub fn vec_to_string(vec: Vec<u8>) -> String {
+    unsafe { String::from_utf8_unchecked(vec) }
+}

easytier/src/common/stun.rs

@@ -0,0 +1,550 @@
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::time::Duration;
+
+use crate::rpc::{NatType, StunInfo};
+use anyhow::Context;
+use crossbeam::atomic::AtomicCell;
+use tokio::net::{lookup_host, UdpSocket};
+use tokio::sync::RwLock;
+use tokio::task::JoinSet;
+use tracing::Level;
+
+use bytecodec::{DecodeExt, EncodeExt};
+use stun_codec::rfc5389::methods::BINDING;
+use stun_codec::rfc5780::attributes::ChangeRequest;
+use stun_codec::{Message, MessageClass, MessageDecoder, MessageEncoder};
+
+use crate::common::error::Error;
+
+use super::stun_codec_ext::*;
+
+struct HostResolverIter {
+    hostnames: Vec<String>,
+    ips: Vec<SocketAddr>,
+}
+
+impl HostResolverIter {
+    fn new(hostnames: Vec<String>) -> Self {
+        Self {
+            hostnames,
+            ips: vec![],
+        }
+    }
+
+    #[async_recursion::async_recursion]
+    async fn next(&mut self) -> Option<SocketAddr> {
+        if self.ips.is_empty() {
+            if self.hostnames.is_empty() {
+                return None;
+            }
+
+            let host = self.hostnames.remove(0);
+            match lookup_host(&host).await {
+                Ok(ips) => {
+                    self.ips = ips.collect();
+                }
+                Err(e) => {
+                    tracing::warn!(?host, ?e, "lookup host for stun failed");
+                    return self.next().await;
+                }
+            };
+        }
+
+        Some(self.ips.remove(0))
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+struct BindRequestResponse {
+    source_addr: SocketAddr,
+    send_to_addr: SocketAddr,
+    recv_from_addr: SocketAddr,
+    mapped_socket_addr: Option<SocketAddr>,
+    changed_socket_addr: Option<SocketAddr>,
+
+    ip_changed: bool,
+    port_changed: bool,
+
+    real_ip_changed: bool,
+    real_port_changed: bool,
+}
+
+impl BindRequestResponse {
+    pub fn get_mapped_addr_no_check(&self) -> &SocketAddr {
+        self.mapped_socket_addr.as_ref().unwrap()
+    }
+}
+
+#[derive(Debug, Clone)]
+struct Stun {
+    stun_server: SocketAddr,
+    req_repeat: u8,
+    resp_timeout: Duration,
+}
+
+impl Stun {
+    pub fn new(stun_server: SocketAddr) -> Self {
+        Self {
+            stun_server,
+            req_repeat: 5,
+            resp_timeout: Duration::from_millis(3000),
+        }
+    }
+
+    #[tracing::instrument(skip(self, buf))]
+    async fn wait_stun_response<'a, const N: usize>(
+        &self,
+        buf: &'a mut [u8; N],
+        udp: &UdpSocket,
+        tids: &Vec<u128>,
+        expected_ip_changed: bool,
+        expected_port_changed: bool,
+        stun_host: &SocketAddr,
+    ) -> Result<(Message<Attribute>, SocketAddr), Error> {
+        let mut now = tokio::time::Instant::now();
+        let deadline = now + self.resp_timeout;
+
+        while now < deadline {
+            let mut udp_buf = [0u8; 1500];
+            let (len, remote_addr) =
+                tokio::time::timeout(deadline - now, udp.recv_from(udp_buf.as_mut_slice()))
+                    .await??;
+            now = tokio::time::Instant::now();
+
+            if len < 20 {
+                continue;
+            }
+
+            // TODO:: we cannot borrow `buf` directly in udp recv_from, so we copy it here
+            unsafe { std::ptr::copy(udp_buf.as_ptr(), buf.as_ptr() as *mut u8, len) };
+
+            let mut decoder = MessageDecoder::<Attribute>::new();
+            let Ok(msg) = decoder
+                .decode_from_bytes(&buf[..len])
+                .with_context(|| format!("decode stun msg {:?}", buf))?
+            else {
+                continue;
+            };
+
+            tracing::debug!(b = ?&udp_buf[..len], ?tids, ?remote_addr, ?stun_host, "recv stun response, msg: {:#?}", msg);
+
+            if msg.class() != MessageClass::SuccessResponse
+                || msg.method() != BINDING
+                || !tids.contains(&tid_to_u128(&msg.transaction_id()))
+            {
+                continue;
+            }
+
+            // some stun server use changed socket even we don't ask for.
+            if expected_ip_changed && stun_host.ip() == remote_addr.ip() {
+                continue;
+            }
+
+            if expected_port_changed
+                && stun_host.ip() == remote_addr.ip()
+                && stun_host.port() == remote_addr.port()
+            {
+                continue;
+            }
+
+            return Ok((msg, remote_addr));
+        }
+
+        Err(Error::Unknown)
+    }
+
+    fn extrace_mapped_addr(msg: &Message<Attribute>) -> Option<SocketAddr> {
+        let mut mapped_addr = None;
+        for x in msg.attributes() {
+            match x {
+                Attribute::MappedAddress(addr) => {
+                    if mapped_addr.is_none() {
+                        let _ = mapped_addr.insert(addr.address());
+                    }
+                }
+                Attribute::XorMappedAddress(addr) => {
+                    if mapped_addr.is_none() {
+                        let _ = mapped_addr.insert(addr.address());
+                    }
+                }
+                _ => {}
+            }
+        }
+        mapped_addr
+    }
+
+    fn extract_changed_addr(msg: &Message<Attribute>) -> Option<SocketAddr> {
+        let mut changed_addr = None;
+        for x in msg.attributes() {
+            match x {
+                Attribute::OtherAddress(m) => {
+                    if changed_addr.is_none() {
+                        let _ = changed_addr.insert(m.address());
+                    }
+                }
+                Attribute::ChangedAddress(m) => {
+                    if changed_addr.is_none() {
+                        let _ = changed_addr.insert(m.address());
+                    }
+                }
+                _ => {}
+            }
+        }
+        changed_addr
+    }
+
+    #[tracing::instrument(ret, err, level = Level::DEBUG)]
+    pub async fn bind_request(
+        &self,
+        source_port: u16,
+        change_ip: bool,
+        change_port: bool,
+    ) -> Result<BindRequestResponse, Error> {
+        let stun_host = self.stun_server;
+        let udp = UdpSocket::bind(format!("0.0.0.0:{}", source_port)).await?;
+
+        // repeat req in case of packet loss
+        let mut tids = vec![];
+        for _ in 0..self.req_repeat {
+            let tid = rand::random::<u32>();
+            let mut buf = [0u8; 28];
+            // memset buf
+            unsafe { std::ptr::write_bytes(buf.as_mut_ptr(), 0, buf.len()) };
+
+            let mut message =
+                Message::<Attribute>::new(MessageClass::Request, BINDING, u128_to_tid(tid as u128));
+            message.add_attribute(ChangeRequest::new(change_ip, change_port));
+
+            // Encodes the message
+            let mut encoder = MessageEncoder::new();
+            let msg = encoder
+                .encode_into_bytes(message.clone())
+                .with_context(|| "encode stun message")?;
+
+            tids.push(tid as u128);
+            tracing::trace!(?message, ?msg, tid, "send stun request");
+            udp.send_to(msg.as_slice().into(), &stun_host).await?;
+        }
+
+        tracing::trace!("waiting stun response");
+        let mut buf = [0; 1620];
+        let (msg, recv_addr) = self
+            .wait_stun_response(&mut buf, &udp, &tids, change_ip, change_port, &stun_host)
+            .await?;
+
+        let changed_socket_addr = Self::extract_changed_addr(&msg);
+        let real_ip_changed = stun_host.ip() != recv_addr.ip();
+        let real_port_changed = stun_host.port() != recv_addr.port();
+
+        let resp = BindRequestResponse {
+            source_addr: udp.local_addr()?,
+            send_to_addr: stun_host,
+            recv_from_addr: recv_addr,
+            mapped_socket_addr: Self::extrace_mapped_addr(&msg),
+            changed_socket_addr,
+            ip_changed: change_ip,
+            port_changed: change_port,
+
+            real_ip_changed,
+            real_port_changed,
+        };
+
+        tracing::debug!(
+            ?stun_host,
+            ?recv_addr,
+            ?changed_socket_addr,
+            "finish stun bind request"
+        );
+
+        Ok(resp)
+    }
+}
+
+pub struct UdpNatTypeDetector {
+    stun_servers: Vec<String>,
+}
+
+impl UdpNatTypeDetector {
+    pub fn new(stun_servers: Vec<String>) -> Self {
+        Self { stun_servers }
+    }
+
+    pub async fn get_udp_nat_type(&self, mut source_port: u16) -> NatType {
+        // Like classic STUN (rfc3489). Detect NAT behavior for UDP.
+        // Modified from rfc3489. Requires at least two STUN servers.
+        let mut ret_test1_1 = None;
+        let mut ret_test1_2 = None;
+        let mut ret_test2 = None;
+        let mut ret_test3 = None;
+
+        if source_port == 0 {
+            let udp = UdpSocket::bind("0.0.0.0:0").await.unwrap();
+            source_port = udp.local_addr().unwrap().port();
+        }
+
+        let mut succ = false;
+        let mut ips = HostResolverIter::new(self.stun_servers.clone());
+        while let Some(server_ip) = ips.next().await {
+            let stun = Stun::new(server_ip.clone());
+            let ret = stun.bind_request(source_port, false, false).await;
+            if ret.is_err() {
+                // Try another STUN server
+                continue;
+            }
+            if ret_test1_1.is_none() {
+                ret_test1_1 = ret.ok();
+                continue;
+            }
+            ret_test1_2 = ret.ok();
+            let ret = stun.bind_request(source_port, true, true).await;
+            if let Ok(resp) = ret {
+                if !resp.real_ip_changed || !resp.real_port_changed {
+                    tracing::debug!(
+                        ?server_ip,
+                        ?ret,
+                        "stun bind request return with unchanged ip and port"
+                    );
+                    // Try another STUN server
+                    continue;
+                }
+            }
+            ret_test2 = ret.ok();
+            ret_test3 = stun.bind_request(source_port, false, true).await.ok();
+            tracing::debug!(?ret_test3, "stun bind request with changed port");
+            succ = true;
+            break;
+        }
+
+        if !succ {
+            return NatType::Unknown;
+        }
+
+        tracing::debug!(
+            ?ret_test1_1,
+            ?ret_test1_2,
+            ?ret_test2,
+            ?ret_test3,
+            "finish stun test, try to detect nat type"
+        );
+
+        let ret_test1_1 = ret_test1_1.unwrap();
+        let ret_test1_2 = ret_test1_2.unwrap();
+
+        if ret_test1_1.mapped_socket_addr != ret_test1_2.mapped_socket_addr {
+            return NatType::Symmetric;
+        }
+
+        if ret_test1_1.mapped_socket_addr.is_some()
+            && ret_test1_1.source_addr == ret_test1_1.mapped_socket_addr.unwrap()
+        {
+            if !ret_test2.is_none() {
+                return NatType::OpenInternet;
+            } else {
+                return NatType::SymUdpFirewall;
+            }
+        } else {
+            if let Some(ret_test2) = ret_test2 {
+                if source_port == ret_test2.get_mapped_addr_no_check().port()
+                    && source_port == ret_test1_1.get_mapped_addr_no_check().port()
+                {
+                    return NatType::NoPat;
+                } else {
+                    return NatType::FullCone;
+                }
+            } else {
+                if !ret_test3.is_none() {
+                    return NatType::Restricted;
+                } else {
+                    return NatType::PortRestricted;
+                }
+            }
+        }
+    }
+}
+
+#[async_trait::async_trait]
+#[auto_impl::auto_impl(&, Arc, Box)]
+pub trait StunInfoCollectorTrait: Send + Sync {
+    fn get_stun_info(&self) -> StunInfo;
+    async fn get_udp_port_mapping(&self, local_port: u16) -> Result<SocketAddr, Error>;
+}
+
+pub struct StunInfoCollector {
+    stun_servers: Arc<RwLock<Vec<String>>>,
+    udp_nat_type: Arc<AtomicCell<(NatType, std::time::Instant)>>,
+    redetect_notify: Arc<tokio::sync::Notify>,
+    tasks: JoinSet<()>,
+}
+
+#[async_trait::async_trait]
+impl StunInfoCollectorTrait for StunInfoCollector {
+    fn get_stun_info(&self) -> StunInfo {
+        let (typ, time) = self.udp_nat_type.load();
+        StunInfo {
+            udp_nat_type: typ as i32,
+            tcp_nat_type: 0,
+            last_update_time: time.elapsed().as_secs() as i64,
+        }
+    }
+
+    async fn get_udp_port_mapping(&self, local_port: u16) -> Result<SocketAddr, Error> {
+        let stun_servers = self.stun_servers.read().await.clone();
+        let mut ips = HostResolverIter::new(stun_servers.clone());
+        while let Some(server) = ips.next().await {
+            let stun = Stun::new(server.clone());
+            let Ok(ret) = stun.bind_request(local_port, false, false).await else {
+                tracing::warn!(?server, "stun bind request failed");
+                continue;
+            };
+            if let Some(mapped_addr) = ret.mapped_socket_addr {
+                return Ok(mapped_addr);
+            }
+        }
+        Err(Error::NotFound)
+    }
+}
+
+impl StunInfoCollector {
+    pub fn new(stun_servers: Vec<String>) -> Self {
+        let mut ret = Self {
+            stun_servers: Arc::new(RwLock::new(stun_servers)),
+            udp_nat_type: Arc::new(AtomicCell::new((
+                NatType::Unknown,
+                std::time::Instant::now(),
+            ))),
+            redetect_notify: Arc::new(tokio::sync::Notify::new()),
+            tasks: JoinSet::new(),
+        };
+
+        ret.start_stun_routine();
+
+        ret
+    }
+
+    pub fn new_with_default_servers() -> Self {
+        Self::new(Self::get_default_servers())
+    }
+
+    pub fn get_default_servers() -> Vec<String> {
+        // NOTICE: we may need to choose stun stun server based on geo location
+        // stun server cross nation may return a external ip address with high latency and loss rate
+        vec![
+            "stun.miwifi.com:3478".to_string(),
+            "stun.qq.com:3478".to_string(),
+            // "stun.chat.bilibili.com:3478".to_string(), // bilibili's stun server doesn't repond to change_ip and change_port
+            "fwa.lifesizecloud.com:3478".to_string(),
+            "stun.isp.net.au:3478".to_string(),
+            "stun.nextcloud.com:3478".to_string(),
+            "stun.freeswitch.org:3478".to_string(),
+            "stun.voip.blackberry.com:3478".to_string(),
+            "stunserver.stunprotocol.org:3478".to_string(),
+            "stun.sipnet.com:3478".to_string(),
+            "stun.radiojar.com:3478".to_string(),
+            "stun.sonetel.com:3478".to_string(),
+            "stun.voipgate.com:3478".to_string(),
+            "stun.counterpath.com:3478".to_string(),
+            "180.235.108.91:3478".to_string(),
+            "193.22.2.248:3478".to_string(),
+        ]
+    }
+
+    fn start_stun_routine(&mut self) {
+        let stun_servers = self.stun_servers.clone();
+        let udp_nat_type = self.udp_nat_type.clone();
+        let redetect_notify = self.redetect_notify.clone();
+        self.tasks.spawn(async move {
+            loop {
+                let detector = UdpNatTypeDetector::new(stun_servers.read().await.clone());
+                let old_nat_type = udp_nat_type.load().0;
+                let mut ret = NatType::Unknown;
+                for _ in 1..5 {
+                    // if nat type degrade, sleep and retry. so result can be relatively stable.
+                    ret = detector.get_udp_nat_type(0).await;
+                    if ret == NatType::Unknown || ret <= old_nat_type {
+                        break;
+                    }
+                    tokio::time::sleep(Duration::from_secs(5)).await;
+                }
+                udp_nat_type.store((ret, std::time::Instant::now()));
+
+                let sleep_sec = match ret {
+                    NatType::Unknown => 15,
+                    _ => 60,
+                };
+                tracing::info!(?ret, ?sleep_sec, "finish udp nat type detect");
+
+                tokio::select! {
+                    _ = redetect_notify.notified() => {}
+                    _ = tokio::time::sleep(Duration::from_secs(sleep_sec)) => {}
+                }
+            }
+        });
+    }
+
+    pub fn update_stun_info(&self) {
+        self.redetect_notify.notify_one();
+    }
+
+    pub async fn set_stun_servers(&self, stun_servers: Vec<String>) {
+        *self.stun_servers.write().await = stun_servers;
+        self.update_stun_info();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    pub fn enable_log() {
+        let filter = tracing_subscriber::EnvFilter::builder()
+            .with_default_directive(tracing::level_filters::LevelFilter::TRACE.into())
+            .from_env()
+            .unwrap()
+            .add_directive("tarpc=error".parse().unwrap());
+        tracing_subscriber::fmt::fmt()
+            .pretty()
+            .with_env_filter(filter)
+            .init();
+    }
+
+    #[tokio::test]
+    async fn test_stun_bind_request() {
+        // miwifi / qq seems not correctly responde to change_ip and change_port, they always try to change the src ip and port.
+        let mut ips = HostResolverIter::new(vec!["stun1.l.google.com:19302".to_string()]);
+        let stun = Stun::new(ips.next().await.unwrap());
+        // let stun = Stun::new("180.235.108.91:3478".to_string());
+        // let stun = Stun::new("193.22.2.248:3478".to_string());
+        // let stun = Stun::new("stun.chat.bilibili.com:3478".to_string());
+        // let stun = Stun::new("stun.miwifi.com:3478".to_string());
+
+        // github actions are port restricted nat, so we only test last one.
+
+        // let rs = stun.bind_request(12345, true, true).await.unwrap();
+        // assert!(rs.ip_changed);
+        // assert!(rs.port_changed);
+
+        // let rs = stun.bind_request(12345, true, false).await.unwrap();
+        // assert!(rs.ip_changed);
+        // assert!(!rs.port_changed);
+
+        // let rs = stun.bind_request(12345, false, true).await.unwrap();
+        // assert!(!rs.ip_changed);
+        // assert!(rs.port_changed);
+
+        let rs = stun.bind_request(12345, false, false).await.unwrap();
+        assert!(!rs.ip_changed);
+        assert!(!rs.port_changed);
+    }
+
+    #[tokio::test]
+    async fn test_udp_nat_type_detect() {
+        let detector = UdpNatTypeDetector::new(vec![
+            "stun.counterpath.com:3478".to_string(),
+            "180.235.108.91:3478".to_string(),
+        ]);
+        let ret = detector.get_udp_nat_type(0).await;
+
+        assert_ne!(ret, NatType::Unknown);
+    }
+}

easytier/src/common/stun_codec_ext.rs

@@ -0,0 +1,229 @@
+use std::net::SocketAddr;
+
+use stun_codec::net::{socket_addr_xor, SocketAddrDecoder, SocketAddrEncoder};
+
+use stun_codec::rfc5389::attributes::{
+    MappedAddress, Software, XorMappedAddress, XorMappedAddress2,
+};
+use stun_codec::rfc5780::attributes::{ChangeRequest, OtherAddress, ResponseOrigin};
+use stun_codec::{define_attribute_enums, AttributeType, Message, TransactionId};
+
+use bytecodec::{ByteCount, Decode, Encode, Eos, Result, SizedEncode, TryTaggedDecode};
+
+use stun_codec::macros::track;
+
+macro_rules! impl_decode {
+    ($decoder:ty, $item:ident, $and_then:expr) => {
+        impl Decode for $decoder {
+            type Item = $item;
+
+            fn decode(&mut self, buf: &[u8], eos: Eos) -> Result<usize> {
+                track!(self.0.decode(buf, eos))
+            }
+
+            fn finish_decoding(&mut self) -> Result<Self::Item> {
+                track!(self.0.finish_decoding()).and_then($and_then)
+            }
+
+            fn requiring_bytes(&self) -> ByteCount {
+                self.0.requiring_bytes()
+            }
+
+            fn is_idle(&self) -> bool {
+                self.0.is_idle()
+            }
+        }
+        impl TryTaggedDecode for $decoder {
+            type Tag = AttributeType;
+
+            fn try_start_decoding(&mut self, attr_type: Self::Tag) -> Result<bool> {
+                Ok(attr_type.as_u16() == $item::CODEPOINT)
+            }
+        }
+    };
+}
+
+macro_rules! impl_encode {
+    ($encoder:ty, $item:ty, $map_from:expr) => {
+        impl Encode for $encoder {
+            type Item = $item;
+
+            fn encode(&mut self, buf: &mut [u8], eos: Eos) -> Result<usize> {
+                track!(self.0.encode(buf, eos))
+            }
+
+            #[allow(clippy::redundant_closure_call)]
+            fn start_encoding(&mut self, item: Self::Item) -> Result<()> {
+                track!(self.0.start_encoding($map_from(item)))
+            }
+
+            fn requiring_bytes(&self) -> ByteCount {
+                self.0.requiring_bytes()
+            }
+
+            fn is_idle(&self) -> bool {
+                self.0.is_idle()
+            }
+        }
+        impl SizedEncode for $encoder {
+            fn exact_requiring_bytes(&self) -> u64 {
+                self.0.exact_requiring_bytes()
+            }
+        }
+    };
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ChangedAddress(SocketAddr);
+impl ChangedAddress {
+    /// The codepoint of the type of the attribute.
+    pub const CODEPOINT: u16 = 0x0005;
+
+    pub fn new(addr: SocketAddr) -> Self {
+        ChangedAddress(addr)
+    }
+
+    /// Returns the address of this instance.
+    pub fn address(&self) -> SocketAddr {
+        self.0
+    }
+}
+impl stun_codec::Attribute for ChangedAddress {
+    type Decoder = ChangedAddressDecoder;
+    type Encoder = ChangedAddressEncoder;
+
+    fn get_type(&self) -> AttributeType {
+        AttributeType::new(Self::CODEPOINT)
+    }
+
+    fn before_encode<A: stun_codec::Attribute>(
+        &mut self,
+        message: &Message<A>,
+    ) -> bytecodec::Result<()> {
+        self.0 = socket_addr_xor(self.0, message.transaction_id());
+        Ok(())
+    }
+
+    fn after_decode<A: stun_codec::Attribute>(
+        &mut self,
+        message: &Message<A>,
+    ) -> bytecodec::Result<()> {
+        self.0 = socket_addr_xor(self.0, message.transaction_id());
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct ChangedAddressDecoder(SocketAddrDecoder);
+impl ChangedAddressDecoder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+impl_decode!(ChangedAddressDecoder, ChangedAddress, |item| Ok(
+    ChangedAddress(item)
+));
+
+#[derive(Debug, Default)]
+pub struct ChangedAddressEncoder(SocketAddrEncoder);
+impl ChangedAddressEncoder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+impl_encode!(ChangedAddressEncoder, ChangedAddress, |item: Self::Item| {
+    item.0
+});
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SourceAddress(SocketAddr);
+impl SourceAddress {
+    /// The codepoint of the type of the attribute.
+    pub const CODEPOINT: u16 = 0x0004;
+
+    pub fn new(addr: SocketAddr) -> Self {
+        SourceAddress(addr)
+    }
+
+    /// Returns the address of this instance.
+    pub fn address(&self) -> SocketAddr {
+        self.0
+    }
+}
+impl stun_codec::Attribute for SourceAddress {
+    type Decoder = SourceAddressDecoder;
+    type Encoder = SourceAddressEncoder;
+
+    fn get_type(&self) -> AttributeType {
+        AttributeType::new(Self::CODEPOINT)
+    }
+
+    fn before_encode<A: stun_codec::Attribute>(
+        &mut self,
+        message: &Message<A>,
+    ) -> bytecodec::Result<()> {
+        self.0 = socket_addr_xor(self.0, message.transaction_id());
+        Ok(())
+    }
+
+    fn after_decode<A: stun_codec::Attribute>(
+        &mut self,
+        message: &Message<A>,
+    ) -> bytecodec::Result<()> {
+        self.0 = socket_addr_xor(self.0, message.transaction_id());
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct SourceAddressDecoder(SocketAddrDecoder);
+impl SourceAddressDecoder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+impl_decode!(SourceAddressDecoder, SourceAddress, |item| Ok(
+    SourceAddress(item)
+));
+
+#[derive(Debug, Default)]
+pub struct SourceAddressEncoder(SocketAddrEncoder);
+impl SourceAddressEncoder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+impl_encode!(SourceAddressEncoder, SourceAddress, |item: Self::Item| {
+    item.0
+});
+
+pub fn tid_to_u128(tid: &TransactionId) -> u128 {
+    let mut tid_buf = [0u8; 16];
+    // copy bytes from msg_tid to tid_buf
+    tid_buf[..tid.as_bytes().len()].copy_from_slice(tid.as_bytes());
+    u128::from_le_bytes(tid_buf)
+}
+
+pub fn u128_to_tid(tid: u128) -> TransactionId {
+    let tid_buf = tid.to_le_bytes();
+    let mut tid_arr = [0u8; 12];
+    tid_arr.copy_from_slice(&tid_buf[..12]);
+    TransactionId::new(tid_arr)
+}
+
+define_attribute_enums!(
+    Attribute,
+    AttributeDecoder,
+    AttributeEncoder,
+    [
+        Software,
+        MappedAddress,
+        XorMappedAddress,
+        XorMappedAddress2,
+        OtherAddress,
+        ChangeRequest,
+        ChangedAddress,
+        SourceAddress,
+        ResponseOrigin
+    ]
+);