releases/v2.4.0 (#1145)

* bump version to v2.4.0
* update tauri.
* allow try direct connect to public server

easytier/Cargo.toml

@@ -3,7 +3,7 @@ name = "easytier"
 description = "A full meshed p2p VPN, connecting all your devices in one network with one command."
 homepage = "https://github.com/EasyTier/EasyTier"
 repository = "https://github.com/EasyTier/EasyTier"
-version = "2.3.2"
+version = "2.4.0"
 edition = "2021"
 authors = ["kkrainbow"]
 keywords = ["vpn", "p2p", "network", "easytier"]

easytier/src/common/constants.rs

@@ -27,6 +27,8 @@ define_global_var!(MACHINE_UID, Option<String>, None);
 
 define_global_var!(MAX_DIRECT_CONNS_PER_PEER_IN_FOREIGN_NETWORK, u32, 3);
 
+define_global_var!(DIRECT_CONNECT_TO_PUBLIC_SERVER, bool, true);
+
 pub const UDP_HOLE_PUNCH_CONNECTOR_SERVICE_ID: u32 = 2;
 
 pub const WIN_SERVICE_WORK_DIR_REG_KEY: &str = "SOFTWARE\\EasyTier\\Service\\WorkDir";

easytier/src/connector/direct.rs

@@ -31,6 +31,7 @@ use crate::{
         rpc_types::controller::BaseController,
     },
     tunnel::{udp::UdpTunnelConnector, IpVersion},
+    use_global_var,
 };
 
 use crate::proto::cli::PeerConnInfo;
@@ -57,12 +58,14 @@ pub trait PeerManagerForDirectConnector {
 impl PeerManagerForDirectConnector for PeerManager {
     async fn list_peers(&self) -> Vec<PeerId> {
         let mut ret = vec![];
+        let allow_public_server = use_global_var!(DIRECT_CONNECT_TO_PUBLIC_SERVER);
 
         let routes = self.list_routes().await;
-        for r in routes
-            .iter()
-            .filter(|r| r.feature_flag.map(|r| !r.is_public_server).unwrap_or(true))
-        {
+        for r in routes.iter().filter(|r| {
+            r.feature_flag
+                .map(|r| allow_public_server || !r.is_public_server)
+                .unwrap_or(true)
+        }) {
             ret.push(r.peer_id);
         }
 
@@ -483,10 +486,17 @@ impl DirectConnectorManagerData {
                 self.global_ctx.get_network_name(),
             );
 
-            let ip_list = rpc_stub
+            let ip_list = match rpc_stub
                 .get_ip_list(BaseController::default(), GetIpListRequest {})
                 .await
-                .with_context(|| format!("get ip list from peer {}", dst_peer_id))?;
+                .with_context(|| format!("get ip list from peer {}", dst_peer_id))
+            {
+                Ok(ip_list) => ip_list,
+                Err(e) => {
+                    tracing::error!(?e, "failed to get ip list from peer");
+                    continue;
+                }
+            };
 
             tracing::info!(ip_list = ?ip_list, dst_peer_id = ?dst_peer_id, "got ip list");
 

easytier/src/peers/foreign_network_manager.rs

@@ -25,7 +25,6 @@ use crate::{
         error::Error,
         global_ctx::{ArcGlobalCtx, GlobalCtx, GlobalCtxEvent, NetworkIdentity},
         join_joinset_background,
-        stun::MockStunInfoCollector,
         token_bucket::TokenBucket,
         PeerId,
     },
@@ -33,7 +32,7 @@ use crate::{
     peers::route_trait::{Route, RouteInterface},
     proto::{
         cli::{ForeignNetworkEntryPb, ListForeignNetworkResponse, PeerInfo},
-        common::{LimiterConfig, NatType},
+        common::LimiterConfig,
         peer_rpc::DirectConnectorRpcServer,
     },
     tunnel::packet_def::{PacketType, ZCPacket},
@@ -159,9 +158,8 @@ impl ForeignNetworkEntry {
         config.set_hostname(Some(format!("PublicServer_{}", global_ctx.get_hostname())));
 
         let foreign_global_ctx = Arc::new(GlobalCtx::new(config));
-        foreign_global_ctx.replace_stun_info_collector(Box::new(MockStunInfoCollector {
-            udp_nat_type: NatType::Unknown,
-        }));
+        foreign_global_ctx
+            .replace_stun_info_collector(Box::new(global_ctx.get_stun_info_collector().clone()));
 
         let mut feature_flag = global_ctx.get_feature_flags();
         feature_flag.is_public_server = true;

easytier/src/peers/peer_manager.rs

@@ -81,12 +81,13 @@ impl PeerRpcManagerTransport for RpcTransport {
 
     async fn send(&self, mut msg: ZCPacket, dst_peer_id: PeerId) -> Result<(), Error> {
         let peers = self.peers.upgrade().ok_or(Error::Unknown)?;
-        // NOTE: if route info is not exchanged, this will return error. treat it as need relay
-        if !peers
-            .need_relay_by_foreign_network(dst_peer_id)
+        // NOTE: if route info is not exchanged, this will return None. treat it as public server.
+        let is_dst_peer_public_server = peers
+            .get_route_peer_info(dst_peer_id)
             .await
-            .unwrap_or(true)
-        {
+            .and_then(|x| x.feature_flag.map(|x| x.is_public_server))
+            .unwrap_or(true);
+        if !is_dst_peer_public_server {
             self.encryptor
                 .encrypt(&mut msg)
                 .with_context(|| "encrypt failed")?;