bump version to v2.2.4 (#697)

* enable sni for tls client
* update test case
* fix public_ip parse bug

.github/workflows/docker.yml

@@ -11,7 +11,7 @@ on:
       image_tag:
         description: 'Tag for this image build'
         type: string
-        default: 'v2.2.3'
+        default: 'v2.2.4'
         required: true
       mark_latest:
         description: 'Mark this image as latest'

.github/workflows/install_rust.sh

@@ -36,7 +36,7 @@ if [[ $OS =~ ^ubuntu.*$ ]]; then
 
     if [ -n "$MUSL_URI" ]; then
         mkdir -p ./musl_gcc
-        wget -c https://musl.cc/${MUSL_URI}-cross.tgz -P ./musl_gcc/
+        wget --inet4-only -c https://musl.cc/${MUSL_URI}-cross.tgz -P ./musl_gcc/
         tar zxf ./musl_gcc/${MUSL_URI}-cross.tgz -C ./musl_gcc/
         sudo ln -s $(pwd)/musl_gcc/${MUSL_URI}-cross/bin/*gcc /usr/bin/
         sudo ln -s $(pwd)/musl_gcc/${MUSL_URI}-cross/${MUSL_URI}/include/ /usr/include/musl-cross

.github/workflows/release.yml

@@ -21,7 +21,7 @@ on:
       version:
         description: 'Version for this release'
         type: string
-        default: 'v2.2.3'
+        default: 'v2.2.4'
         required: true
       make_latest:
         description: 'Mark this release as latest'

Cargo.lock

@@ -1876,7 +1876,7 @@ checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
 
 [[package]]
 name = "easytier"
-version = "2.2.3"
+version = "2.2.4"
 dependencies = [
  "aes-gcm",
  "anyhow",
@@ -1978,7 +1978,7 @@ dependencies = [
 
 [[package]]
 name = "easytier-gui"
-version = "2.2.3"
+version = "2.2.4"
 dependencies = [
  "anyhow",
  "chrono",
@@ -2023,7 +2023,7 @@ dependencies = [
 
 [[package]]
 name = "easytier-web"
-version = "2.2.3"
+version = "2.2.4"
 dependencies = [
  "anyhow",
  "async-trait",

easytier-gui/package.json

@@ -1,7 +1,7 @@
 {
   "name": "easytier-gui",
   "type": "module",
-  "version": "2.2.3",
+  "version": "2.2.4",
   "private": true,
   "packageManager": "pnpm@9.12.1+sha512.e5a7e52a4183a02d5931057f7a0dbff9d5e9ce3161e33fa68ae392125b79282a8a8a470a51dfc8a0ed86221442eb2fb57019b0990ed24fab519bf0e1bc5ccfc4",
   "scripts": {

easytier-gui/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "easytier-gui"
-version = "2.2.3"
+version = "2.2.4"
 description = "EasyTier GUI"
 authors = ["you"]
 edition = "2021"

easytier-gui/src-tauri/tauri.conf.json

@@ -17,7 +17,7 @@
     "createUpdaterArtifacts": false
   },
   "productName": "easytier-gui",
-  "version": "2.2.3",
+  "version": "2.2.4",
   "identifier": "com.kkrainbow.easytier",
   "plugins": {},
   "app": {

easytier-web/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "easytier-web"
-version = "2.2.3"
+version = "2.2.4"
 edition = "2021"
 description = "Config server for easytier. easytier-core gets config from this and web frontend use it as restful api server."
 

easytier-web/frontend-lib/src/components/Status.vue

@@ -303,9 +303,9 @@ function showEventLogs() {
 
 <template>
   <div class="frontend-lib">
-    <Dialog v-model:visible="dialogVisible" modal :header="t(dialogHeader)" class="w-2/3 h-auto max-h-full"
+    <Dialog v-model:visible="dialogVisible" modal :header="t(dialogHeader)" class="w-full h-auto max-h-full"
       :baseZIndex="2000">
-      <ScrollPanel v-if="dialogHeader === 'vpn_portal_config'" class="w-2/3">
+      <ScrollPanel v-if="dialogHeader === 'vpn_portal_config'">
         <pre>{{ dialogContent }}</pre>
       </ScrollPanel>
       <Timeline v-else :value="dialogContent">

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.2.3"
+version = "2.2.4"
 edition = "2021"
 authors = ["kkrainbow"]
 keywords = ["vpn", "p2p", "network", "easytier"]

easytier/src/connector/direct.rs

@@ -24,6 +24,7 @@ use crate::{
         },
         rpc_types::controller::BaseController,
     },
+    tunnel::IpVersion,
 };
 
 use crate::proto::cli::PeerConnInfo;
@@ -175,7 +176,7 @@ impl DirectConnectorManager {
         dst_peer_id: PeerId,
         addr: String,
     ) -> Result<(), Error> {
-        let connector = create_connector_by_url(&addr, &data.global_ctx).await?;
+        let connector = create_connector_by_url(&addr, &data.global_ctx, IpVersion::Both).await?;
         let (peer_id, conn_id) = timeout(
             std::time::Duration::from_secs(3),
             data.peer_manager.try_direct_connect(connector),
@@ -271,7 +272,7 @@ impl DirectConnectorManager {
 
         let mut tasks = bounded_join_set::JoinSet::new(2);
 
-        let listener_host = listener.socket_addrs(|| None).unwrap().pop();
+        let listener_host = listener.socket_addrs(|| None)?.pop();
         match listener_host {
             Some(SocketAddr::V4(s_addr)) => {
                 if s_addr.ip().is_unspecified() {

easytier/src/connector/dns_connector.rs

@@ -91,8 +91,8 @@ impl DNSTunnelConnector {
                 )
             })?;
 
-        let mut connector = create_connector_by_url(url.as_str(), &self.global_ctx).await?;
-        connector.set_ip_version(self.ip_version);
+        let connector =
+            create_connector_by_url(url.as_str(), &self.global_ctx, self.ip_version).await?;
         Ok(connector)
     }
 
@@ -179,8 +179,8 @@ impl DNSTunnelConnector {
             )
         })?;
 
-        let mut connector = create_connector_by_url(url.as_str(), &self.global_ctx).await?;
-        connector.set_ip_version(self.ip_version);
+        let connector =
+            create_connector_by_url(url.as_str(), &self.global_ctx, self.ip_version).await?;
         Ok(connector)
     }
 }
@@ -242,8 +242,18 @@ mod tests {
         let url = "txt://txt.easytier.cn";
         let global_ctx = get_mock_global_ctx();
         let mut connector = DNSTunnelConnector::new(url.parse().unwrap(), global_ctx);
-        let ret = connector.connect().await.unwrap();
-        println!("{:?}", ret.info());
+        connector.set_ip_version(IpVersion::V4);
+        for _ in 0..5 {
+            match connector.connect().await {
+                Ok(ret) => {
+                    println!("{:?}", ret.info());
+                    return;
+                }
+                Err(e) => {
+                    println!("{:?}", e);
+                }
+            }
+        }
     }
 
     #[tokio::test]
@@ -251,7 +261,17 @@ mod tests {
         let url = "srv://easytier.cn";
         let global_ctx = get_mock_global_ctx();
         let mut connector = DNSTunnelConnector::new(url.parse().unwrap(), global_ctx);
-        let ret = connector.connect().await.unwrap();
-        println!("{:?}", ret.info());
+        connector.set_ip_version(IpVersion::V4);
+        for _ in 0..5 {
+            match connector.connect().await {
+                Ok(ret) => {
+                    println!("{:?}", ret.info());
+                    return;
+                }
+                Err(e) => {
+                    println!("{:?}", e);
+                }
+            }
+        }
     }
 }

easytier/src/connector/http_connector.rs

@@ -92,14 +92,24 @@ impl HttpTunnelConnector {
             if !query.is_empty() {
                 tracing::info!("try to create connector by url: {}", query[0]);
                 self.redirect_type = HttpRedirectType::RedirectToQuery;
-                return create_connector_by_url(&query[0].to_string(), &self.global_ctx).await;
+                return create_connector_by_url(
+                    &query[0].to_string(),
+                    &self.global_ctx,
+                    self.ip_version,
+                )
+                .await;
             } else if let Some(new_url) = url_str
                 .strip_prefix(format!("{}://", url.scheme()).as_str())
                 .and_then(|x| Url::parse(x).ok())
             {
                 // stripe the scheme and create connector by url
                 self.redirect_type = HttpRedirectType::RedirectToUrl;
-                return create_connector_by_url(new_url.as_str(), &self.global_ctx).await;
+                return create_connector_by_url(
+                    new_url.as_str(),
+                    &self.global_ctx,
+                    self.ip_version,
+                )
+                .await;
             }
             return Err(Error::InvalidUrl(format!(
                 "no valid connector url found in url: {}",
@@ -107,7 +117,8 @@ impl HttpTunnelConnector {
             )));
         } else {
             self.redirect_type = HttpRedirectType::RedirectToUrl;
-            return create_connector_by_url(new_url.as_str(), &self.global_ctx).await;
+            return create_connector_by_url(new_url.as_str(), &self.global_ctx, self.ip_version)
+                .await;
         }
     }
 
@@ -137,7 +148,7 @@ impl HttpTunnelConnector {
                 continue;
             }
             self.redirect_type = HttpRedirectType::BodyUrls;
-            return create_connector_by_url(line, &self.global_ctx).await;
+            return create_connector_by_url(line, &self.global_ctx, self.ip_version).await;
         }
 
         Err(Error::InvalidUrl(format!(

easytier/src/connector/manual.rs

@@ -106,7 +106,7 @@ impl ManualConnectorManager {
     }
 
     pub async fn add_connector_by_url(&self, url: &str) -> Result<(), Error> {
-        self.add_connector(create_connector_by_url(url, &self.global_ctx).await?);
+        self.add_connector(create_connector_by_url(url, &self.global_ctx, IpVersion::Both).await?);
         Ok(())
     }
 

easytier/src/connector/mod.rs

@@ -13,7 +13,7 @@ use crate::{
     common::{error::Error, global_ctx::ArcGlobalCtx, network::IPCollector},
     tunnel::{
         check_scheme_and_get_socket_addr, ring::RingTunnelConnector, tcp::TcpTunnelConnector,
-        udp::UdpTunnelConnector, TunnelConnector,
+        udp::UdpTunnelConnector, IpVersion, TunnelConnector,
     },
 };
 
@@ -55,11 +55,12 @@ async fn set_bind_addr_for_peer_connector(
 pub async fn create_connector_by_url(
     url: &str,
     global_ctx: &ArcGlobalCtx,
+    ip_version: IpVersion,
 ) -> Result<Box<dyn TunnelConnector + 'static>, Error> {
     let url = url::Url::parse(url).map_err(|_| Error::InvalidUrl(url.to_owned()))?;
-    match url.scheme() {
+    let mut connector: Box<dyn TunnelConnector + 'static> = match url.scheme() {
         "tcp" => {
-            let dst_addr = check_scheme_and_get_socket_addr::<SocketAddr>(&url, "tcp")?;
+            let dst_addr = check_scheme_and_get_socket_addr::<SocketAddr>(&url, "tcp", ip_version)?;
             let mut connector = TcpTunnelConnector::new(url);
             if global_ctx.config.get_flags().bind_device {
                 set_bind_addr_for_peer_connector(
@@ -69,10 +70,10 @@ pub async fn create_connector_by_url(
                 )
                 .await;
             }
-            return Ok(Box::new(connector));
+            Box::new(connector)
         }
         "udp" => {
-            let dst_addr = check_scheme_and_get_socket_addr::<SocketAddr>(&url, "udp")?;
+            let dst_addr = check_scheme_and_get_socket_addr::<SocketAddr>(&url, "udp", ip_version)?;
             let mut connector = UdpTunnelConnector::new(url);
             if global_ctx.config.get_flags().bind_device {
                 set_bind_addr_for_peer_connector(
@@ -82,20 +83,20 @@ pub async fn create_connector_by_url(
                 )
                 .await;
             }
-            return Ok(Box::new(connector));
+            Box::new(connector)
         }
         "http" | "https" => {
             let connector = HttpTunnelConnector::new(url, global_ctx.clone());
-            return Ok(Box::new(connector));
+            Box::new(connector)
         }
         "ring" => {
-            check_scheme_and_get_socket_addr::<uuid::Uuid>(&url, "ring")?;
+            check_scheme_and_get_socket_addr::<uuid::Uuid>(&url, "ring", IpVersion::Both)?;
             let connector = RingTunnelConnector::new(url);
-            return Ok(Box::new(connector));
+            Box::new(connector)
         }
         #[cfg(feature = "quic")]
         "quic" => {
-            let dst_addr = check_scheme_and_get_socket_addr::<SocketAddr>(&url, "quic")?;
+            let dst_addr = check_scheme_and_get_socket_addr::<SocketAddr>(&url, "quic", ip_version)?;
             let mut connector = QUICTunnelConnector::new(url);
             if global_ctx.config.get_flags().bind_device {
                 set_bind_addr_for_peer_connector(
@@ -105,11 +106,11 @@ pub async fn create_connector_by_url(
                 )
                 .await;
             }
-            return Ok(Box::new(connector));
+            Box::new(connector)
         }
         #[cfg(feature = "wireguard")]
         "wg" => {
-            let dst_addr = check_scheme_and_get_socket_addr::<SocketAddr>(&url, "wg")?;
+            let dst_addr = check_scheme_and_get_socket_addr::<SocketAddr>(&url, "wg", ip_version)?;
             let nid = global_ctx.get_network_identity();
             let wg_config = WgConfig::new_from_network_identity(
                 &nid.network_name,
@@ -124,12 +125,12 @@ pub async fn create_connector_by_url(
                 )
                 .await;
             }
-            return Ok(Box::new(connector));
+            Box::new(connector)
         }
         #[cfg(feature = "websocket")]
         "ws" | "wss" => {
-            use crate::tunnel::{FromUrl, IpVersion};
-            let dst_addr = SocketAddr::from_url(url.clone(), IpVersion::Both)?;
+            use crate::tunnel::FromUrl;
+            let dst_addr = SocketAddr::from_url(url.clone(), ip_version)?;
             let mut connector = crate::tunnel::websocket::WSTunnelConnector::new(url);
             if global_ctx.config.get_flags().bind_device {
                 set_bind_addr_for_peer_connector(
@@ -139,14 +140,17 @@ pub async fn create_connector_by_url(
                 )
                 .await;
             }
-            return Ok(Box::new(connector));
+            Box::new(connector)
         }
         "txt" | "srv" => {
             let connector = dns_connector::DNSTunnelConnector::new(url, global_ctx.clone());
-            return Ok(Box::new(connector));
+            Box::new(connector)
         }
         _ => {
             return Err(Error::InvalidUrl(url.into()));
         }
-    }
+    };
+    connector.set_ip_version(ip_version);
+
+    Ok(connector)
 }

easytier/src/connector/udp_hole_punch/sym_to_cone.rs

@@ -434,7 +434,7 @@ impl PunchSymToConeHoleClient {
         let public_ips: Vec<Ipv4Addr> = stun_info
             .public_ip
             .iter()
-            .map(|x| x.parse().unwrap())
+            .filter_map(|x| x.parse().ok())
             .collect();
         if public_ips.is_empty() {
             return Err(anyhow::anyhow!("failed to get public ips"));

easytier/src/easytier-core.rs

@@ -30,7 +30,7 @@ use easytier::{
         self,
         common::{CompressionAlgoPb, NatType},
     },
-    tunnel::PROTO_PORT_OFFSET,
+    tunnel::{IpVersion, PROTO_PORT_OFFSET},
     utils::{init_logger, setup_panic_handler},
     web_client,
 };
@@ -870,7 +870,7 @@ async fn run_main(cli: Cli) -> anyhow::Result<()> {
         flags.bind_device = false;
         global_ctx.set_flags(flags);
         let _wc = web_client::WebClient::new(
-            create_connector_by_url(c_url.as_str(), &global_ctx).await?,
+            create_connector_by_url(c_url.as_str(), &global_ctx, IpVersion::Both).await?,
             token.to_string(),
         );
         tokio::signal::ctrl_c().await.unwrap();

easytier/src/peers/peer_manager.rs

@@ -1130,6 +1130,7 @@ mod tests {
         let connector1 = create_connector_by_url(
             format!("{}://127.0.0.1:31013", proto1).as_str(),
             &peer_mgr_a.get_global_ctx(),
+            crate::tunnel::IpVersion::Both,
         )
         .await
         .unwrap();
@@ -1148,6 +1149,7 @@ mod tests {
         let connector2 = create_connector_by_url(
             format!("{}://127.0.0.1:31014", proto2).as_str(),
             &peer_mgr_b.get_global_ctx(),
+            crate::tunnel::IpVersion::Both,
         )
         .await
         .unwrap();

easytier/src/tunnel/insecure_tls.rs

@@ -70,7 +70,7 @@ pub fn get_insecure_tls_client_config() -> rustls::ClientConfig {
         .dangerous()
         .with_custom_certificate_verifier(SkipServerVerification::new(provider.clone()))
         .with_no_client_auth();
-    config.enable_sni = false;
+    config.enable_sni = true;
     config.enable_early_data = false;
     config
 }

easytier/src/tunnel/mod.rs

@@ -193,6 +193,7 @@ where
 pub(crate) fn check_scheme_and_get_socket_addr<T>(
     url: &url::Url,
     scheme: &str,
+    ip_version: IpVersion,
 ) -> Result<T, TunnelError>
 where
     T: FromUrl,
@@ -201,7 +202,7 @@ where
         return Err(TunnelError::InvalidProtocol(url.scheme().to_string()));
     }
 
-    Ok(T::from_url(url.clone(), IpVersion::Both)?)
+    Ok(T::from_url(url.clone(), ip_version)?)
 }
 
 fn default_port(scheme: &str) -> Option<u16> {

easytier/src/tunnel/quic.rs

@@ -84,7 +84,8 @@ impl QUICTunnelListener {
 #[async_trait::async_trait]
 impl TunnelListener for QUICTunnelListener {
     async fn listen(&mut self) -> Result<(), TunnelError> {
-        let addr = check_scheme_and_get_socket_addr::<SocketAddr>(&self.addr, "quic")?;
+        let addr =
+            check_scheme_and_get_socket_addr::<SocketAddr>(&self.addr, "quic", IpVersion::Both)?;
         let (endpoint, server_cert) = make_server_endpoint(addr).unwrap();
         self.endpoint = Some(endpoint);
         self.server_cert = Some(server_cert);

easytier/src/tunnel/ring.rs

@@ -231,7 +231,11 @@ fn get_tunnel_for_server(conn: Arc<Connection>) -> impl Tunnel {
 
 impl RingTunnelListener {
     fn get_addr(&self) -> Result<uuid::Uuid, TunnelError> {
-        check_scheme_and_get_socket_addr::<Uuid>(&self.listerner_addr, "ring")
+        check_scheme_and_get_socket_addr::<Uuid>(
+            &self.listerner_addr,
+            "ring",
+            super::IpVersion::Both,
+        )
     }
 }
 
@@ -284,7 +288,11 @@ impl RingTunnelConnector {
 #[async_trait]
 impl TunnelConnector for RingTunnelConnector {
     async fn connect(&mut self) -> Result<Box<dyn Tunnel>, super::TunnelError> {
-        let remote_addr = check_scheme_and_get_socket_addr::<Uuid>(&self.remote_addr, "ring")?;
+        let remote_addr = check_scheme_and_get_socket_addr::<Uuid>(
+            &self.remote_addr,
+            "ring",
+            super::IpVersion::Both,
+        )?;
         let entry = CONNECTION_MAP
             .lock()
             .await

easytier/src/tunnel/tcp.rs

@@ -58,7 +58,8 @@ impl TcpTunnelListener {
 impl TunnelListener for TcpTunnelListener {
     async fn listen(&mut self) -> Result<(), TunnelError> {
         self.listener = None;
-        let addr = check_scheme_and_get_socket_addr::<SocketAddr>(&self.addr, "tcp")?;
+        let addr =
+            check_scheme_and_get_socket_addr::<SocketAddr>(&self.addr, "tcp", IpVersion::Both)?;
 
         let socket2_socket = socket2::Socket::new(
             socket2::Domain::for_address(addr),

easytier/src/tunnel/udp.rs

@@ -473,7 +473,11 @@ impl UdpTunnelListener {
 #[async_trait]
 impl TunnelListener for UdpTunnelListener {
     async fn listen(&mut self) -> Result<(), super::TunnelError> {
-        let addr = super::check_scheme_and_get_socket_addr::<SocketAddr>(&self.addr, "udp")?;
+        let addr = super::check_scheme_and_get_socket_addr::<SocketAddr>(
+            &self.addr,
+            "udp",
+            IpVersion::Both,
+        )?;
 
         let socket2_socket = socket2::Socket::new(
             socket2::Domain::for_address(addr),
@@ -957,6 +961,7 @@ mod tests {
             let addr = check_scheme_and_get_socket_addr::<SocketAddr>(
                 &format!("udp://{}:11111", ip.to_string()).parse().unwrap(),
                 "udp",
+                IpVersion::Both,
             )
             .unwrap();
             let socket2_socket = socket2::Socket::new(

easytier/src/tunnel/websocket.rs

@@ -183,6 +183,7 @@ impl WSTunnelConnector {
     ) -> Result<Box<dyn Tunnel>, TunnelError> {
         let is_wss = is_wss(&addr)?;
         let socket_addr = SocketAddr::from_url(addr.clone(), ip_version)?;
+        let domain = addr.domain();
         let host = socket_addr.ip();
         let stream = tcp_socket.connect(socket_addr).await?;
 
@@ -203,8 +204,16 @@ impl WSTunnelConnector {
             init_crypto_provider();
             let tls_conn =
                 tokio_rustls::TlsConnector::from(Arc::new(get_insecure_tls_client_config()));
+            let domain_or_ip = match domain {
+                None => {
+                    host.to_string()
+                }
+                Some(domain) => {
+                    domain.to_string()
+                }
+            };
             let stream = tls_conn
-                .connect(host.to_string().try_into().unwrap(), stream)
+                .connect(domain_or_ip.try_into().unwrap(), stream)
                 .await?;
             MaybeTlsStream::Rustls(stream)
         } else {

easytier/src/tunnel/wireguard.rs

@@ -547,7 +547,8 @@ impl WgTunnelListener {
 #[async_trait]
 impl TunnelListener for WgTunnelListener {
     async fn listen(&mut self) -> Result<(), super::TunnelError> {
-        let addr = check_scheme_and_get_socket_addr::<SocketAddr>(&self.addr, "wg")?;
+        let addr =
+            check_scheme_and_get_socket_addr::<SocketAddr>(&self.addr, "wg", IpVersion::Both)?;
         let socket2_socket = socket2::Socket::new(
             socket2::Domain::for_address(addr),
             socket2::Type::DGRAM,