From a879dd1b14e4e8b34a23a7875630635cb4911a3f Mon Sep 17 00:00:00 2001 From: Luna Yao <40349250+ZnqbuZ@users.noreply.github.com> Date: Thu, 9 Apr 2026 18:22:12 +0200 Subject: [PATCH] chore: update Rust to 2024 edition (#2066) --- Cargo.toml | 4 + .../easytier-android-jni/Cargo.toml | 2 +- .../easytier-android-jni/src/lib.rs | 64 +++---- easytier-contrib/easytier-ffi/Cargo.toml | 2 +- easytier-contrib/easytier-ffi/src/lib.rs | 14 +- easytier-contrib/easytier-uptime/Cargo.toml | 2 +- .../easytier-uptime/src/api/handlers.rs | 32 ++-- .../easytier-uptime/src/api/routes.rs | 2 +- .../easytier-uptime/src/db/cleanup.rs | 4 +- .../easytier-uptime/src/db/mod.rs | 6 +- .../easytier-uptime/src/db/operations.rs | 2 +- .../easytier-uptime/src/health_checker.rs | 2 +- .../src/health_checker_manager.rs | 4 +- easytier-contrib/easytier-uptime/src/main.rs | 6 +- easytier-gui/src-tauri/Cargo.toml | 2 +- easytier-gui/src-tauri/src/elevate/linux.rs | 2 +- easytier-gui/src-tauri/src/elevate/macos.rs | 4 +- easytier-gui/src-tauri/src/elevate/windows.rs | 4 +- easytier-gui/src-tauri/src/lib.rs | 68 +++---- easytier-rpc-build/Cargo.toml | 3 +- easytier-web/Cargo.toml | 2 +- easytier-web/src/client_manager/mod.rs | 8 +- easytier-web/src/client_manager/session.rs | 50 ++--- easytier-web/src/db/mod.rs | 8 +- easytier-web/src/main.rs | 2 +- easytier-web/src/restful/auth.rs | 23 +-- .../src/restful/captcha/base/captcha.rs | 2 +- .../src/restful/captcha/builder/spec.rs | 6 +- easytier-web/src/restful/mod.rs | 12 +- easytier-web/src/restful/network.rs | 4 +- easytier-web/src/restful/oidc.rs | 25 +-- easytier-web/src/restful/rpc.rs | 6 +- easytier-web/src/restful/users.rs | 6 +- easytier-web/src/web/mod.rs | 3 +- easytier/Cargo.toml | 4 +- easytier/build.rs | 4 +- easytier/src/arch/windows.rs | 8 +- easytier/src/common/acl_processor.rs | 38 ++-- easytier/src/common/compressor.rs | 2 +- easytier/src/common/config.rs | 129 ++++++------- easytier/src/common/dns.rs | 2 +- easytier/src/common/env_parser.rs | 41 ++-- easytier/src/common/global_ctx.rs | 4 +- easytier/src/common/ifcfg/darwin.rs | 2 +- easytier/src/common/ifcfg/netlink.rs | 12 +- easytier/src/common/ifcfg/win/luid.rs | 6 +- easytier/src/common/ifcfg/windows.rs | 10 +- easytier/src/common/log.rs | 4 +- easytier/src/common/mod.rs | 12 +- easytier/src/common/netns.rs | 2 +- easytier/src/common/stats_manager.rs | 24 ++- easytier/src/common/stun.rs | 14 +- easytier/src/common/stun_codec_ext.rs | 4 +- easytier/src/common/token_bucket.rs | 2 +- .../common/tracing_rolling_appender/base.rs | 19 +- .../common/tracing_rolling_appender/mod.rs | 22 +-- easytier/src/connector/direct.rs | 32 ++-- easytier/src/connector/dns_connector.rs | 4 +- easytier/src/connector/http_connector.rs | 4 +- easytier/src/connector/manual.rs | 2 +- easytier/src/connector/mod.rs | 4 +- easytier/src/connector/tcp_hole_punch.rs | 46 +++-- .../connector/udp_hole_punch/both_easy_sym.rs | 10 +- .../src/connector/udp_hole_punch/common.rs | 10 +- easytier/src/connector/udp_hole_punch/cone.rs | 8 +- easytier/src/connector/udp_hole_punch/mod.rs | 22 ++- .../connector/udp_hole_punch/sym_to_cone.rs | 27 ++- easytier/src/core.rs | 53 +++--- easytier/src/easytier-cli.rs | 28 +-- easytier/src/easytier-core.rs | 4 +- easytier/src/gateway/fast_socks5/mod.rs | 2 +- easytier/src/gateway/fast_socks5/server.rs | 6 +- .../gateway/fast_socks5/util/target_addr.rs | 4 +- easytier/src/gateway/icmp_proxy.rs | 12 +- easytier/src/gateway/ip_reassembler.rs | 18 +- easytier/src/gateway/kcp_proxy.rs | 4 +- easytier/src/gateway/quic_proxy.rs | 24 ++- easytier/src/gateway/socks5.rs | 49 +++-- easytier/src/gateway/tcp_proxy.rs | 20 +- .../gateway/tokio_smoltcp/channel_device.rs | 2 +- easytier/src/gateway/tokio_smoltcp/mod.rs | 2 +- easytier/src/gateway/tokio_smoltcp/reactor.rs | 10 +- easytier/src/gateway/tokio_smoltcp/socket.rs | 2 +- .../gateway/tokio_smoltcp/socket_allocator.rs | 3 +- easytier/src/gateway/udp_proxy.rs | 14 +- easytier/src/gateway/wrapped_proxy.rs | 6 +- easytier/src/instance/dns_server/server.rs | 2 +- .../instance/dns_server/server_instance.rs | 49 +++-- easytier/src/instance/instance.rs | 71 +++---- easytier/src/instance/listeners.rs | 6 +- easytier/src/instance/virtual_nic.rs | 14 +- easytier/src/instance_manager.rs | 100 +++++----- easytier/src/launcher.rs | 64 ++++--- easytier/src/peer_center/instance.rs | 16 +- easytier/src/peers/acl_filter.rs | 38 ++-- easytier/src/peers/credential_manager.rs | 29 +-- easytier/src/peers/encrypt/aes_gcm.rs | 2 +- easytier/src/peers/encrypt/ring.rs | 2 +- easytier/src/peers/encrypt/xor.rs | 2 +- easytier/src/peers/foreign_network_client.rs | 4 +- easytier/src/peers/foreign_network_manager.rs | 61 +++--- easytier/src/peers/peer.rs | 8 +- easytier/src/peers/peer_conn.rs | 53 +++--- easytier/src/peers/peer_conn_ping.rs | 10 +- easytier/src/peers/peer_manager.rs | 115 ++++++------ easytier/src/peers/peer_map.rs | 7 +- easytier/src/peers/peer_ospf_route.rs | 177 +++++++++++------- easytier/src/peers/peer_rpc.rs | 10 +- easytier/src/peers/peer_session.rs | 14 +- easytier/src/peers/peer_task.rs | 2 +- easytier/src/peers/relay_peer_map.rs | 20 +- easytier/src/peers/route_trait.rs | 2 +- easytier/src/peers/tests.rs | 40 ++-- easytier/src/peers/traffic_metrics.rs | 41 ++-- easytier/src/proto/api.rs | 25 +-- easytier/src/proto/common.rs | 25 ++- easytier/src/proto/rpc_impl/bidirect.rs | 4 +- easytier/src/proto/rpc_impl/client.rs | 4 +- easytier/src/proto/rpc_impl/mod.rs | 2 +- easytier/src/proto/rpc_impl/packet.rs | 2 +- easytier/src/proto/rpc_impl/server.rs | 9 +- easytier/src/proto/rpc_impl/standalone.rs | 4 +- easytier/src/proto/tests.rs | 2 +- easytier/src/rpc_service/api.rs | 2 +- easytier/src/rpc_service/instance_manage.rs | 21 +-- easytier/src/rpc_service/logger.rs | 10 +- easytier/src/rpc_service/mod.rs | 10 +- easytier/src/rpc_service/remote_client.rs | 31 ++- easytier/src/service_manager/mod.rs | 2 +- easytier/src/tests/credential_tests.rs | 6 +- easytier/src/tests/mod.rs | 8 + easytier/src/tests/three_node.rs | 20 +- easytier/src/tunnel/common.rs | 12 +- easytier/src/tunnel/fake_tcp/mod.rs | 6 +- .../tunnel/fake_tcp/netfilter/linux_bpf.rs | 18 +- .../tunnel/fake_tcp/netfilter/macos_bpf.rs | 2 +- .../src/tunnel/fake_tcp/netfilter/pnet.rs | 4 +- .../tunnel/fake_tcp/netfilter/windivert.rs | 2 +- easytier/src/tunnel/fake_tcp/stack.rs | 4 +- easytier/src/tunnel/filter.rs | 28 ++- easytier/src/tunnel/mpsc.rs | 8 +- easytier/src/tunnel/packet_def.rs | 2 +- easytier/src/tunnel/quic.rs | 8 +- easytier/src/tunnel/ring.rs | 8 +- easytier/src/tunnel/tcp.rs | 4 +- easytier/src/tunnel/udp.rs | 16 +- easytier/src/tunnel/unix.rs | 4 +- easytier/src/tunnel/websocket.rs | 27 ++- easytier/src/tunnel/wireguard.rs | 24 +-- easytier/src/utils.rs | 2 +- easytier/src/vpn_portal/wireguard.rs | 28 +-- easytier/src/web_client/mod.rs | 7 +- easytier/src/web_client/security.rs | 4 +- easytier/src/web_client/session.rs | 2 +- tauri-plugin-vpnservice/Cargo.toml | 3 +- tauri-plugin-vpnservice/src/error.rs | 2 +- tauri-plugin-vpnservice/src/lib.rs | 2 +- tauri-plugin-vpnservice/src/mobile.rs | 2 +- 158 files changed, 1327 insertions(+), 1231 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 0768f4f7..59e3db80 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,6 +14,10 @@ exclude = [ "easytier-contrib/easytier-ohrs", # it needs ohrs sdk ] +[workspace.package] +edition = "2024" +rust-version = "1.93.0" + [profile.dev] panic = "unwind" debug = 2 diff --git a/easytier-contrib/easytier-android-jni/Cargo.toml b/easytier-contrib/easytier-android-jni/Cargo.toml index e2b9465a..5f069daa 100644 --- a/easytier-contrib/easytier-android-jni/Cargo.toml +++ b/easytier-contrib/easytier-android-jni/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "easytier-android-jni" version = "0.1.0" -edition = "2021" +edition.workspace = true [lib] crate-type = ["cdylib"] diff --git a/easytier-contrib/easytier-android-jni/src/lib.rs b/easytier-contrib/easytier-android-jni/src/lib.rs index f6ada298..a9f3731e 100644 --- a/easytier-contrib/easytier-android-jni/src/lib.rs +++ b/easytier-contrib/easytier-android-jni/src/lib.rs @@ -1,7 +1,7 @@ use easytier::proto::api::manage::{NetworkInstanceRunningInfo, NetworkInstanceRunningInfoMap}; +use jni::JNIEnv; use jni::objects::{JClass, JObjectArray, JString}; use jni::sys::{jint, jstring}; -use jni::JNIEnv; use once_cell::sync::Lazy; use std::ffi::{CStr, CString}; use std::ptr; @@ -15,7 +15,7 @@ pub struct KeyValuePair { } // 声明外部 C 函数 -extern "C" { +unsafe extern "C" { fn set_tun_fd(inst_name: *const std::ffi::c_char, fd: std::ffi::c_int) -> std::ffi::c_int; fn get_error_msg(out: *mut *const std::ffi::c_char); fn free_string(s: *const std::ffi::c_char); @@ -68,7 +68,7 @@ fn throw_exception(env: &mut JNIEnv, message: &str) { } /// 设置 TUN 文件描述符 -#[no_mangle] +#[unsafe(no_mangle)] pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_setTunFd( mut env: JNIEnv, _class: JClass, @@ -87,17 +87,17 @@ pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_setTunFd( unsafe { let result = set_tun_fd(inst_name_cstr.as_ptr(), fd); - if result != 0 { - if let Some(error) = get_last_error() { - throw_exception(&mut env, &error); - } + if result != 0 + && let Some(error) = get_last_error() + { + throw_exception(&mut env, &error); } result } } /// 解析配置 -#[no_mangle] +#[unsafe(no_mangle)] pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_parseConfig( mut env: JNIEnv, _class: JClass, @@ -115,17 +115,17 @@ pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_parseConfig( unsafe { let result = parse_config(config_cstr.as_ptr()); - if result != 0 { - if let Some(error) = get_last_error() { - throw_exception(&mut env, &error); - } + if result != 0 + && let Some(error) = get_last_error() + { + throw_exception(&mut env, &error); } result } } /// 运行网络实例 -#[no_mangle] +#[unsafe(no_mangle)] pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_runNetworkInstance( mut env: JNIEnv, _class: JClass, @@ -143,17 +143,17 @@ pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_runNetworkInstance( unsafe { let result = run_network_instance(config_cstr.as_ptr()); - if result != 0 { - if let Some(error) = get_last_error() { - throw_exception(&mut env, &error); - } + if result != 0 + && let Some(error) = get_last_error() + { + throw_exception(&mut env, &error); } result } } /// 保持网络实例 -#[no_mangle] +#[unsafe(no_mangle)] pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_retainNetworkInstance( mut env: JNIEnv, _class: JClass, @@ -165,10 +165,10 @@ pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_retainNetworkInstance( if instance_names.is_null() { unsafe { let result = retain_network_instance(ptr::null(), 0); - if result != 0 { - if let Some(error) = get_last_error() { - throw_exception(&mut env, &error); - } + if result != 0 + && let Some(error) = get_last_error() + { + throw_exception(&mut env, &error); } return result; } @@ -187,10 +187,10 @@ pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_retainNetworkInstance( if array_length == 0 { unsafe { let result = retain_network_instance(ptr::null(), 0); - if result != 0 { - if let Some(error) = get_last_error() { - throw_exception(&mut env, &error); - } + if result != 0 + && let Some(error) = get_last_error() + { + throw_exception(&mut env, &error); } return result; } @@ -234,17 +234,17 @@ pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_retainNetworkInstance( unsafe { let result = retain_network_instance(c_string_ptrs.as_ptr(), c_string_ptrs.len()); - if result != 0 { - if let Some(error) = get_last_error() { - throw_exception(&mut env, &error); - } + if result != 0 + && let Some(error) = get_last_error() + { + throw_exception(&mut env, &error); } result } } /// 收集网络信息 -#[no_mangle] +#[unsafe(no_mangle)] pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_collectNetworkInfos( mut env: JNIEnv, _class: JClass, @@ -304,7 +304,7 @@ pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_collectNetworkInfos( } /// 获取最后的错误信息 -#[no_mangle] +#[unsafe(no_mangle)] pub extern "system" fn Java_com_easytier_jni_EasyTierJNI_getLastError( env: JNIEnv, _class: JClass, diff --git a/easytier-contrib/easytier-ffi/Cargo.toml b/easytier-contrib/easytier-ffi/Cargo.toml index fff8262a..52e66241 100644 --- a/easytier-contrib/easytier-ffi/Cargo.toml +++ b/easytier-contrib/easytier-ffi/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "easytier-ffi" version = "0.1.0" -edition = "2021" +edition.workspace = true [lib] crate-type = ["cdylib"] diff --git a/easytier-contrib/easytier-ffi/src/lib.rs b/easytier-contrib/easytier-ffi/src/lib.rs index 8686e534..e9b65be4 100644 --- a/easytier-contrib/easytier-ffi/src/lib.rs +++ b/easytier-contrib/easytier-ffi/src/lib.rs @@ -30,7 +30,7 @@ fn set_error_msg(msg: &str) { /// # Safety /// Set the tun fd -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn set_tun_fd( inst_name: *const std::ffi::c_char, fd: std::ffi::c_int, @@ -59,7 +59,7 @@ pub unsafe extern "C" fn set_tun_fd( /// # Safety /// Get the last error message -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn get_error_msg(out: *mut *const std::ffi::c_char) { let msg_buf = ERROR_MSG.lock().unwrap(); if msg_buf.is_empty() { @@ -74,7 +74,7 @@ pub unsafe extern "C" fn get_error_msg(out: *mut *const std::ffi::c_char) { } } -#[no_mangle] +#[unsafe(no_mangle)] pub extern "C" fn free_string(s: *const std::ffi::c_char) { if s.is_null() { return; @@ -86,7 +86,7 @@ pub extern "C" fn free_string(s: *const std::ffi::c_char) { /// # Safety /// Parse the config -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn parse_config(cfg_str: *const std::ffi::c_char) -> std::ffi::c_int { let cfg_str = unsafe { assert!(!cfg_str.is_null()); @@ -105,7 +105,7 @@ pub unsafe extern "C" fn parse_config(cfg_str: *const std::ffi::c_char) -> std:: /// # Safety /// Run the network instance -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn run_network_instance(cfg_str: *const std::ffi::c_char) -> std::ffi::c_int { let cfg_str = unsafe { assert!(!cfg_str.is_null()); @@ -144,7 +144,7 @@ pub unsafe extern "C" fn run_network_instance(cfg_str: *const std::ffi::c_char) /// # Safety /// Retain the network instance -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn retain_network_instance( inst_names: *const *const std::ffi::c_char, length: usize, @@ -188,7 +188,7 @@ pub unsafe extern "C" fn retain_network_instance( /// # Safety /// Collect the network infos -#[no_mangle] +#[unsafe(no_mangle)] pub unsafe extern "C" fn collect_network_infos( infos: *mut KeyValuePair, max_length: usize, diff --git a/easytier-contrib/easytier-uptime/Cargo.toml b/easytier-contrib/easytier-uptime/Cargo.toml index e36e0018..9643e92f 100644 --- a/easytier-contrib/easytier-uptime/Cargo.toml +++ b/easytier-contrib/easytier-uptime/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "easytier-uptime" version = "0.1.0" -edition = "2021" +edition.workspace = true [dependencies] tokio = { version = "1.0", features = ["full"] } diff --git a/easytier-contrib/easytier-uptime/src/api/handlers.rs b/easytier-contrib/easytier-uptime/src/api/handlers.rs index 6c266611..850e09d6 100644 --- a/easytier-contrib/easytier-uptime/src/api/handlers.rs +++ b/easytier-contrib/easytier-uptime/src/api/handlers.rs @@ -1,7 +1,7 @@ use std::ops::{Div, Mul}; -use axum::extract::{Path, State}; use axum::Json; +use axum::extract::{Path, State}; use sea_orm::{ ColumnTrait, Condition, EntityTrait, IntoActiveModel, ModelTrait, Order, PaginatorTrait, QueryFilter, QueryOrder, QuerySelect, Set, TryIntoModel, @@ -14,7 +14,7 @@ use crate::api::{ models::*, }; use crate::db::entity::{self, health_records, shared_nodes}; -use crate::db::{operations::*, Db}; +use crate::db::{Db, operations::*}; use crate::health_checker_manager::HealthCheckerManager; use axum_extra::extract::Query; use std::sync::Arc; @@ -273,7 +273,7 @@ pub struct InstanceFilterParams { use crate::config::AppConfig; use axum::http::{HeaderMap, StatusCode}; use chrono::{Duration, Utc}; -use jsonwebtoken::{decode, encode, DecodingKey, EncodingKey, Header, Validation}; +use jsonwebtoken::{DecodingKey, EncodingKey, Header, Validation, decode, encode}; use serde::Serialize; #[derive(Debug, Serialize, Deserialize)] @@ -370,19 +370,19 @@ pub async fn admin_get_nodes( let ids = NodeOperations::filter_node_ids_by_tag(&app_state.db, &tag).await?; filtered_ids = Some(ids); } - if let Some(tags) = filters.tags { - if !tags.is_empty() { - let ids_any = NodeOperations::filter_node_ids_by_tags_any(&app_state.db, &tags).await?; - filtered_ids = match filtered_ids { - Some(mut existing) => { - existing.extend(ids_any); - existing.sort(); - existing.dedup(); - Some(existing) - } - None => Some(ids_any), - }; - } + if let Some(tags) = filters.tags + && !tags.is_empty() + { + let ids_any = NodeOperations::filter_node_ids_by_tags_any(&app_state.db, &tags).await?; + filtered_ids = match filtered_ids { + Some(mut existing) => { + existing.extend(ids_any); + existing.sort(); + existing.dedup(); + Some(existing) + } + None => Some(ids_any), + }; } if let Some(ids) = filtered_ids { if ids.is_empty() { diff --git a/easytier-contrib/easytier-uptime/src/api/routes.rs b/easytier-contrib/easytier-uptime/src/api/routes.rs index d7c49a93..a1a6f510 100644 --- a/easytier-contrib/easytier-uptime/src/api/routes.rs +++ b/easytier-contrib/easytier-uptime/src/api/routes.rs @@ -1,5 +1,5 @@ -use axum::routing::{delete, get, post, put}; use axum::Router; +use axum::routing::{delete, get, post, put}; use tower_http::compression::CompressionLayer; use tower_http::cors::CorsLayer; diff --git a/easytier-contrib/easytier-uptime/src/db/cleanup.rs b/easytier-contrib/easytier-uptime/src/db/cleanup.rs index 0645b1fe..14638c67 100644 --- a/easytier-contrib/easytier-uptime/src/db/cleanup.rs +++ b/easytier-contrib/easytier-uptime/src/db/cleanup.rs @@ -1,7 +1,7 @@ -use crate::db::entity::*; use crate::db::Db; +use crate::db::entity::*; use sea_orm::*; -use tokio::time::{sleep, Duration}; +use tokio::time::{Duration, sleep}; use tracing::{error, info, warn}; /// 数据清理策略配置 diff --git a/easytier-contrib/easytier-uptime/src/db/mod.rs b/easytier-contrib/easytier-uptime/src/db/mod.rs index e25a9407..bb4099bb 100644 --- a/easytier-contrib/easytier-uptime/src/db/mod.rs +++ b/easytier-contrib/easytier-uptime/src/db/mod.rs @@ -5,12 +5,12 @@ pub mod operations; use std::fmt; use sea_orm::{ - prelude::*, sea_query::OnConflict, ColumnTrait as _, DatabaseConnection, DbErr, EntityTrait, - QueryFilter as _, Set, SqlxSqliteConnector, Statement, TransactionTrait as _, + ColumnTrait as _, DatabaseConnection, DbErr, EntityTrait, QueryFilter as _, Set, + SqlxSqliteConnector, Statement, TransactionTrait as _, prelude::*, sea_query::OnConflict, }; use sea_orm_migration::MigratorTrait as _; use serde::{Deserialize, Serialize}; -use sqlx::{migrate::MigrateDatabase as _, Sqlite, SqlitePool}; +use sqlx::{Sqlite, SqlitePool, migrate::MigrateDatabase as _}; use crate::migrator; diff --git a/easytier-contrib/easytier-uptime/src/db/operations.rs b/easytier-contrib/easytier-uptime/src/db/operations.rs index 9ff5d669..7c518219 100644 --- a/easytier-contrib/easytier-uptime/src/db/operations.rs +++ b/easytier-contrib/easytier-uptime/src/db/operations.rs @@ -1,8 +1,8 @@ use crate::api::CreateNodeRequest; -use crate::db::entity::*; use crate::db::Db; use crate::db::HealthStats; use crate::db::HealthStatus; +use crate::db::entity::*; use sea_orm::*; use std::collections::{HashMap, HashSet}; diff --git a/easytier-contrib/easytier-uptime/src/health_checker.rs b/easytier-contrib/easytier-uptime/src/health_checker.rs index 25b2fdcf..49198a30 100644 --- a/easytier-contrib/easytier-uptime/src/health_checker.rs +++ b/easytier-contrib/easytier-uptime/src/health_checker.rs @@ -19,9 +19,9 @@ use sqlx::any; use tracing::{debug, error, info, instrument, warn}; use crate::db::{ + Db, HealthStatus, entity::shared_nodes, operations::{HealthOperations, NodeOperations}, - Db, HealthStatus, }; pub struct HealthCheckOneNode { diff --git a/easytier-contrib/easytier-uptime/src/health_checker_manager.rs b/easytier-contrib/easytier-uptime/src/health_checker_manager.rs index fe26f055..98681ef1 100644 --- a/easytier-contrib/easytier-uptime/src/health_checker_manager.rs +++ b/easytier-contrib/easytier-uptime/src/health_checker_manager.rs @@ -1,11 +1,11 @@ use std::{collections::HashSet, sync::Arc, time::Duration}; use anyhow::Context as _; -use tokio::time::{interval, Interval}; +use tokio::time::{Interval, interval}; use tracing::{error, info}; use crate::{ - db::{entity::shared_nodes, operations::NodeOperations, Db}, + db::{Db, entity::shared_nodes, operations::NodeOperations}, health_checker::HealthChecker, }; diff --git a/easytier-contrib/easytier-uptime/src/main.rs b/easytier-contrib/easytier-uptime/src/main.rs index 34749641..b4f7668e 100644 --- a/easytier-contrib/easytier-uptime/src/main.rs +++ b/easytier-contrib/easytier-uptime/src/main.rs @@ -10,7 +10,7 @@ mod migrator; use api::routes::create_routes; use clap::Parser; use config::AppConfig; -use db::{operations::NodeOperations, Db}; +use db::{Db, operations::NodeOperations}; use easytier::common::log; use health_checker::HealthChecker; use health_checker_manager::HealthCheckerManager; @@ -49,7 +49,9 @@ async fn main() -> anyhow::Result<()> { // 如果提供了管理员密码，设置环境变量 if let Some(password) = args.admin_password { - env::set_var("ADMIN_PASSWORD", password); + unsafe { + env::set_var("ADMIN_PASSWORD", password); + } } tracing::info!( diff --git a/easytier-gui/src-tauri/Cargo.toml b/easytier-gui/src-tauri/Cargo.toml index 6f42a322..f49aa3a2 100644 --- a/easytier-gui/src-tauri/Cargo.toml +++ b/easytier-gui/src-tauri/Cargo.toml @@ -3,7 +3,7 @@ name = "easytier-gui" version = "2.6.0" description = "EasyTier GUI" authors = ["you"] -edition = "2021" +edition.workspace = true # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html diff --git a/easytier-gui/src-tauri/src/elevate/linux.rs b/easytier-gui/src-tauri/src/elevate/linux.rs index ec97a3a2..da178c05 100644 --- a/easytier-gui/src-tauri/src/elevate/linux.rs +++ b/easytier-gui/src-tauri/src/elevate/linux.rs @@ -4,7 +4,7 @@ *--------------------------------------------------------------------------------------------*/ use super::Command; -use anyhow::{anyhow, Result}; +use anyhow::{Result, anyhow}; use std::env; use std::ffi::OsStr; use std::process::{Command as StdCommand, Output}; diff --git a/easytier-gui/src-tauri/src/elevate/macos.rs b/easytier-gui/src-tauri/src/elevate/macos.rs index fc6c2136..41b6cc48 100644 --- a/easytier-gui/src-tauri/src/elevate/macos.rs +++ b/easytier-gui/src-tauri/src/elevate/macos.rs @@ -30,10 +30,10 @@ use std::os::unix::process::ExitStatusExt; use std::path::Path; use std::ptr; -use libc::{fileno, wait, EINTR, SHUT_WR}; +use libc::{EINTR, SHUT_WR, fileno, wait}; use security_framework_sys::authorization::{ - errAuthorizationSuccess, kAuthorizationFlagDefaults, kAuthorizationFlagDestroyRights, AuthorizationCreate, AuthorizationExecuteWithPrivileges, AuthorizationFree, AuthorizationRef, + errAuthorizationSuccess, kAuthorizationFlagDefaults, kAuthorizationFlagDestroyRights, }; const ENV_PATH: &str = "PATH"; diff --git a/easytier-gui/src-tauri/src/elevate/windows.rs b/easytier-gui/src-tauri/src/elevate/windows.rs index 7678cc3a..ab421c58 100644 --- a/easytier-gui/src-tauri/src/elevate/windows.rs +++ b/easytier-gui/src-tauri/src/elevate/windows.rs @@ -11,11 +11,11 @@ use std::process::{ExitStatus, Output}; use winapi::shared::minwindef::{DWORD, LPVOID}; use winapi::um::processthreadsapi::{GetCurrentProcess, OpenProcessToken}; use winapi::um::securitybaseapi::GetTokenInformation; -use winapi::um::winnt::{TokenElevation, HANDLE, TOKEN_ELEVATION, TOKEN_QUERY}; -use windows::core::{w, HSTRING, PCWSTR}; +use winapi::um::winnt::{HANDLE, TOKEN_ELEVATION, TOKEN_QUERY, TokenElevation}; use windows::Win32::Foundation::HWND; use windows::Win32::UI::Shell::ShellExecuteW; use windows::Win32::UI::WindowsAndMessaging::SW_HIDE; +use windows::core::{HSTRING, PCWSTR, w}; /// The implementation of state check and elevated executing varies on each platform impl Command { diff --git a/easytier-gui/src-tauri/src/lib.rs b/easytier-gui/src-tauri/src/lib.rs index 35dbe6e8..2b6c613b 100644 --- a/easytier-gui/src-tauri/src/lib.rs +++ b/easytier-gui/src-tauri/src/lib.rs @@ -21,9 +21,9 @@ use easytier::{ instance_manager::NetworkInstanceManager, launcher::NetworkConfig, rpc_service::ApiRpcServer, + tunnel::TunnelListener, tunnel::ring::RingTunnelListener, tunnel::tcp::TcpTunnelListener, - tunnel::TunnelListener, utils::{self}, }; use std::ops::Deref; @@ -559,10 +559,10 @@ fn toggle_window_visibility(app: &tauri::AppHandle) { } fn get_exe_path() -> String { - if let Ok(appimage_path) = std::env::var("APPIMAGE") { - if !appimage_path.is_empty() { - return appimage_path; - } + if let Ok(appimage_path) = std::env::var("APPIMAGE") + && !appimage_path.is_empty() + { + return appimage_path; } std::env::current_exe() .map(|p| p.to_string_lossy().to_string()) @@ -596,8 +596,8 @@ mod manager { use easytier::proto::rpc_types::controller::BaseController; use easytier::rpc_service::logger::LoggerRpcService; use easytier::rpc_service::remote_client::PersistentConfig; - use easytier::tunnel::ring::RingTunnelConnector; use easytier::tunnel::TunnelConnector; + use easytier::tunnel::ring::RingTunnelConnector; use easytier::web_client::WebClientHooks; pub(super) struct GuiHooks { @@ -979,34 +979,34 @@ mod manager { .get_rpc_client(app.clone()) .ok_or_else(|| anyhow::anyhow!("RPC client not found"))?; for id in enabled_networks { - if let Ok(uuid) = id.parse() { - if !self.storage.enabled_networks.contains(&uuid) { - let config = self - .storage - .network_configs - .get(&uuid) - .map(|i| i.value().1.clone()); - let Some(config) = config else { - continue; - }; - let toml_config = config.gen_config()?; - self.pre_run_network_instance_hook(&app, &toml_config) - .await - .map_err(|e| anyhow::anyhow!(e))?; - client - .run_network_instance( - BaseController::default(), - RunNetworkInstanceRequest { - inst_id: None, - config: Some(config), - overwrite: false, - }, - ) - .await?; - self.post_run_network_instance_hook(&app, &uuid) - .await - .map_err(|e| anyhow::anyhow!(e))?; - } + if let Ok(uuid) = id.parse() + && !self.storage.enabled_networks.contains(&uuid) + { + let config = self + .storage + .network_configs + .get(&uuid) + .map(|i| i.value().1.clone()); + let Some(config) = config else { + continue; + }; + let toml_config = config.gen_config()?; + self.pre_run_network_instance_hook(&app, &toml_config) + .await + .map_err(|e| anyhow::anyhow!(e))?; + client + .run_network_instance( + BaseController::default(), + RunNetworkInstanceRequest { + inst_id: None, + config: Some(config), + overwrite: false, + }, + ) + .await?; + self.post_run_network_instance_hook(&app, &uuid) + .await + .map_err(|e| anyhow::anyhow!(e))?; } } Ok(()) diff --git a/easytier-rpc-build/Cargo.toml b/easytier-rpc-build/Cargo.toml index 9c65ec44..510d8381 100644 --- a/easytier-rpc-build/Cargo.toml +++ b/easytier-rpc-build/Cargo.toml @@ -2,13 +2,12 @@ name = "easytier-rpc-build" description = "Protobuf RPC Service Generator for EasyTier" version = "0.1.0" -edition = "2021" +edition.workspace = true homepage = "https://github.com/EasyTier/EasyTier" repository = "https://github.com/EasyTier/EasyTier" authors = ["kkrainbow"] keywords = ["vpn", "p2p", "network", "easytier"] categories = ["network-programming", "command-line-utilities"] -rust-version = "1.93.0" license-file = "LICENSE" readme = "README.md" diff --git a/easytier-web/Cargo.toml b/easytier-web/Cargo.toml index e08ed2f2..96883b54 100644 --- a/easytier-web/Cargo.toml +++ b/easytier-web/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "easytier-web" version = "2.6.0" -edition = "2021" +edition.workspace = true description = "Config server for easytier. easytier-core gets config from this and web frontend use it as restful api server." [dependencies] diff --git a/easytier-web/src/client_manager/mod.rs b/easytier-web/src/client_manager/mod.rs index 074a5631..d18c2ab0 100644 --- a/easytier-web/src/client_manager/mod.rs +++ b/easytier-web/src/client_manager/mod.rs @@ -2,8 +2,8 @@ pub mod session; pub mod storage; use std::sync::{ - atomic::{AtomicU32, Ordering}, Arc, + atomic::{AtomicU32, Ordering}, }; use dashmap::DashMap; @@ -19,11 +19,11 @@ use maxminddb::geoip2; use session::{Location, Session}; use storage::{Storage, StorageToken}; -use crate::webhook::SharedWebhookConfig; use crate::FeatureFlags; +use crate::webhook::SharedWebhookConfig; use tokio::task::JoinSet; -use crate::db::{entity::user_running_network_configs, Db, UserIdInDb}; +use crate::db::{Db, UserIdInDb, entity::user_running_network_configs}; #[derive(rust_embed::Embed)] #[folder = "resources/"] @@ -340,7 +340,7 @@ mod tests { }; use sqlx::Executor; - use crate::{client_manager::ClientManager, db::Db, FeatureFlags}; + use crate::{FeatureFlags, client_manager::ClientManager, db::Db}; #[tokio::test] async fn test_client() { diff --git a/easytier-web/src/client_manager/session.rs b/easytier-web/src/client_manager/session.rs index 2159a093..3a2e527f 100644 --- a/easytier-web/src/client_manager/session.rs +++ b/easytier-web/src/client_manager/session.rs @@ -20,11 +20,11 @@ use easytier::{ rpc_service::remote_client::{ListNetworkProps, Storage as _}, tunnel::Tunnel, }; -use tokio::sync::{broadcast, RwLock}; +use tokio::sync::{RwLock, broadcast}; use super::storage::{Storage, StorageToken, WeakRefStorage}; -use crate::webhook::SharedWebhookConfig; use crate::FeatureFlags; +use crate::webhook::SharedWebhookConfig; #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct Location { @@ -87,30 +87,30 @@ impl SessionData { impl Drop for SessionData { fn drop(&mut self) { - if let Ok(storage) = Storage::try_from(self.storage.clone()) { - if let Some(token) = self.storage_token.as_ref() { - storage.remove_client(token); + if let Ok(storage) = Storage::try_from(self.storage.clone()) + && let Some(token) = self.storage_token.as_ref() + { + storage.remove_client(token); - // Notify the webhook receiver when a node disconnects. - if self.webhook_config.is_enabled() { - let webhook = self.webhook_config.clone(); - let machine_id = token.machine_id.to_string(); - let user_id = Some(token.user_id); - let token_value = token.token.clone(); - let web_instance_id = webhook.web_instance_id.clone(); - let binding_version = self.binding_version; - tokio::spawn(async move { - webhook - .notify_node_disconnected(&crate::webhook::NodeDisconnectedRequest { - machine_id, - token: token_value, - user_id, - web_instance_id, - binding_version, - }) - .await; - }); - } + // Notify the webhook receiver when a node disconnects. + if self.webhook_config.is_enabled() { + let webhook = self.webhook_config.clone(); + let machine_id = token.machine_id.to_string(); + let user_id = Some(token.user_id); + let token_value = token.token.clone(); + let web_instance_id = webhook.web_instance_id.clone(); + let binding_version = self.binding_version; + tokio::spawn(async move { + webhook + .notify_node_disconnected(&crate::webhook::NodeDisconnectedRequest { + machine_id, + token: token_value, + user_id, + web_instance_id, + binding_version, + }) + .await; + }); } } } diff --git a/easytier-web/src/db/mod.rs b/easytier-web/src/db/mod.rs index b525a0cc..8627b505 100644 --- a/easytier-web/src/db/mod.rs +++ b/easytier-web/src/db/mod.rs @@ -8,11 +8,11 @@ use easytier::{ }; use entity::user_running_network_configs; use sea_orm::{ - prelude::Expr, sea_query::OnConflict, ColumnTrait as _, DatabaseConnection, DbErr, EntityTrait, - QueryFilter as _, Set, SqlxSqliteConnector, TransactionTrait as _, + ColumnTrait as _, DatabaseConnection, DbErr, EntityTrait, QueryFilter as _, Set, + SqlxSqliteConnector, TransactionTrait as _, prelude::Expr, sea_query::OnConflict, }; use sea_orm_migration::MigratorTrait as _; -use sqlx::{migrate::MigrateDatabase as _, types::chrono, Sqlite, SqlitePool}; +use sqlx::{Sqlite, SqlitePool, migrate::MigrateDatabase as _, types::chrono}; use uuid::Uuid; use crate::migrator; @@ -280,7 +280,7 @@ mod tests { use easytier::{proto::api::manage::NetworkConfig, rpc_service::remote_client::Storage}; use sea_orm::{ColumnTrait, EntityTrait, QueryFilter as _}; - use crate::db::{entity::user_running_network_configs, Db, ListNetworkProps}; + use crate::db::{Db, ListNetworkProps, entity::user_running_network_configs}; #[tokio::test] async fn test_user_network_config_management() { diff --git a/easytier-web/src/main.rs b/easytier-web/src/main.rs index 143ce5bc..6c741727 100644 --- a/easytier-web/src/main.rs +++ b/easytier-web/src/main.rs @@ -16,7 +16,7 @@ use easytier::{ log, network::{local_ipv4, local_ipv6}, }, - tunnel::{tcp::TcpTunnelListener, udp::UdpTunnelListener, TunnelListener}, + tunnel::{TunnelListener, tcp::TcpTunnelListener, udp::UdpTunnelListener}, utils::setup_panic_handler, }; diff --git a/easytier-web/src/restful/auth.rs b/easytier-web/src/restful/auth.rs index fb65d21c..775870b2 100644 --- a/easytier-web/src/restful/auth.rs +++ b/easytier-web/src/restful/auth.rs @@ -1,7 +1,7 @@ use axum::{ + Router, http::StatusCode, routing::{get, post, put}, - Router, }; use axum_login::login_required; use axum_messages::Message; @@ -14,8 +14,8 @@ use std::sync::Arc; use crate::FeatureFlags; use super::{ - users::{AuthSession, Credentials}, AppStateInner, + users::{AuthSession, Credentials}, }; #[derive(Debug, Deserialize, Serialize)] @@ -44,7 +44,7 @@ mod put { use axum_login::AuthUser; use easytier::proto::common::Void; - use crate::restful::{other_error, users::ChangePassword, HttpHandleError}; + use crate::restful::{HttpHandleError, other_error, users::ChangePassword}; use super::*; @@ -71,14 +71,14 @@ mod put { } mod post { - use axum::{extract::Extension, Json}; + use axum::{Json, extract::Extension}; use easytier::proto::common::Void; use crate::restful::{ - captcha::extension::{axum_tower_sessions::CaptchaAxumTowerSessionStaticExt, CaptchaUtil}, + HttpHandleError, + captcha::extension::{CaptchaUtil, axum_tower_sessions::CaptchaAxumTowerSessionStaticExt}, other_error, users::RegisterNewUser, - HttpHandleError, }; use super::*; @@ -99,7 +99,7 @@ mod post { return Err(( StatusCode::INTERNAL_SERVER_ERROR, Json::from(other_error(format!("{:?}", e))), - )) + )); } }; @@ -150,14 +150,15 @@ mod post { mod get { use crate::restful::{ + HttpHandleError, captcha::{ - builder::spec::SpecCaptcha, - extension::{axum_tower_sessions::CaptchaAxumTowerSessionExt as _, CaptchaUtil}, NewCaptcha as _, + builder::spec::SpecCaptcha, + extension::{CaptchaUtil, axum_tower_sessions::CaptchaAxumTowerSessionExt as _}, }, - other_error, HttpHandleError, + other_error, }; - use axum::{response::Response, Json}; + use axum::{Json, response::Response}; use easytier::proto::common::Void; use tower_sessions::Session; diff --git a/easytier-web/src/restful/captcha/base/captcha.rs b/easytier-web/src/restful/captcha/base/captcha.rs index 3bed68e7..6885d845 100644 --- a/easytier-web/src/restful/captcha/base/captcha.rs +++ b/easytier-web/src/restful/captcha/base/captcha.rs @@ -2,8 +2,8 @@ use super::super::base::randoms::Randoms; use super::super::utils::color::Color; use super::super::utils::font; -use base64::prelude::BASE64_STANDARD; use base64::Engine; +use base64::prelude::BASE64_STANDARD; use rusttype::Font; use std::fmt::Debug; diff --git a/easytier-web/src/restful/captcha/builder/spec.rs b/easytier-web/src/restful/captcha/builder/spec.rs index c58d01f8..c911b574 100644 --- a/easytier-web/src/restful/captcha/builder/spec.rs +++ b/easytier-web/src/restful/captcha/builder/spec.rs @@ -9,14 +9,14 @@ use super::super::{CaptchaFont, NewCaptcha}; use image::{ImageBuffer, Rgba}; use imageproc::drawing; -use rand::{rngs::ThreadRng, Rng}; +use rand::{Rng, rngs::ThreadRng}; use rusttype::{Font, Scale}; use std::io::{Cursor, Write}; use std::sync::Arc; mod color { use image::Rgba; - use rand::{rngs::ThreadRng, Rng}; + use rand::{Rng, rngs::ThreadRng}; pub fn gen_background_color(rng: &mut ThreadRng) -> Rgba { let red = rng.gen_range(200..=255); let green = rng.gen_range(200..=255); @@ -133,7 +133,7 @@ impl<'a, 'b> CaptchaBuilder<'a, 'b> { fn draw_line(&self, image: &mut ImageBuffer, Vec>, rng: &mut ThreadRng) { let line_color = color::gen_line_color(rng); - let is_h = rng.gen(); + let is_h = rng.r#gen(); let (start, end) = if is_h { let xa = rng.gen_range(0.0..(self.width as f32) / 2.0); let ya = rng.gen_range(0.0..(self.height as f32)); diff --git a/easytier-web/src/restful/mod.rs b/easytier-web/src/restful/mod.rs index 9fd2bc43..b78e9e00 100644 --- a/easytier-web/src/restful/mod.rs +++ b/easytier-web/src/restful/mod.rs @@ -8,13 +8,13 @@ mod users; use std::{net::SocketAddr, sync::Arc}; use axum::extract::Path; -use axum::http::{header, Request, StatusCode}; +use axum::http::{Request, StatusCode, header}; use axum::middleware::{self as axum_mw, Next}; use axum::response::Response; use axum::routing::{delete, post}; -use axum::{extract::State, routing::get, Extension, Json, Router}; +use axum::{Extension, Json, Router, extract::State, routing::get}; use axum_login::tower_sessions::{ExpiredDeletion, SessionManagerLayer}; -use axum_login::{login_required, AuthManagerLayerBuilder, AuthUser, AuthzBackend}; +use axum_login::{AuthManagerLayerBuilder, AuthUser, AuthzBackend, login_required}; use axum_messages::MessagesManagerLayer; use easytier::common::config::{ConfigLoader, TomlConfigLoader}; use easytier::common::scoped_task::ScopedTask; @@ -23,17 +23,17 @@ use easytier::proto::rpc_types; use network::NetworkApi; use sea_orm::DbErr; use tokio::net::TcpListener; +use tower_sessions::Expiry; use tower_sessions::cookie::time::Duration; use tower_sessions::cookie::{Key, SameSite}; -use tower_sessions::Expiry; use tower_sessions_sqlx_store::SqliteStore; use users::{AuthSession, Backend}; -use crate::client_manager::storage::StorageToken; +use crate::FeatureFlags; use crate::client_manager::ClientManager; +use crate::client_manager::storage::StorageToken; use crate::db::{Db, UserIdInDb}; use crate::webhook::SharedWebhookConfig; -use crate::FeatureFlags; /// Embed assets for web dashboard, build frontend first #[cfg(feature = "embed")] diff --git a/easytier-web/src/restful/network.rs b/easytier-web/src/restful/network.rs index e97e010b..b47f5167 100644 --- a/easytier-web/src/restful/network.rs +++ b/easytier-web/src/restful/network.rs @@ -1,7 +1,7 @@ use axum::extract::Path; use axum::http::StatusCode; use axum::routing::{delete, post}; -use axum::{extract::State, routing::get, Json, Router}; +use axum::{Json, Router, extract::State, routing::get}; use axum_login::AuthUser; use easytier::launcher::NetworkConfig; use easytier::proto::common::Void; @@ -16,7 +16,7 @@ use crate::db::UserIdInDb; use super::users::AuthSession; use super::{ - convert_db_error, other_error, AppState, AppStateInner, Error, HttpHandleError, RpcError, + AppState, AppStateInner, Error, HttpHandleError, RpcError, convert_db_error, other_error, }; fn convert_rpc_error(e: RpcError) -> (StatusCode, Json) { diff --git a/easytier-web/src/restful/oidc.rs b/easytier-web/src/restful/oidc.rs index 7796509c..efca09d4 100644 --- a/easytier-web/src/restful/oidc.rs +++ b/easytier-web/src/restful/oidc.rs @@ -4,8 +4,8 @@ use std::time::Duration; use subtle::ConstantTimeEq; -use axum::routing::get; use axum::Router; +use axum::routing::get; use openidconnect::core::{ CoreAuthDisplay, CoreAuthPrompt, CoreErrorResponseType, CoreGenderClaim, CoreJsonWebKey, CoreJweContentEncryptionAlgorithm, CoreJwsSigningAlgorithm, CoreProviderMetadata, @@ -216,7 +216,9 @@ impl OidcConfig { } = opts; if oidc_issuer_url.is_none() || oidc_client_id.is_none() || oidc_redirect_url.is_none() { - return Err(anyhow::anyhow!("--oidc-issuer-url, --oidc-client-id and --oidc-redirect-url are required when using OIDC authentication")); + return Err(anyhow::anyhow!( + "--oidc-issuer-url, --oidc-client-id and --oidc-redirect-url are required when using OIDC authentication" + )); } if oidc_username_claim.trim().is_empty() { return Err(anyhow::anyhow!("--oidc-username-claim cannot be empty")); @@ -373,18 +375,17 @@ mod route { ) .into_response(); } - if let Some(verifier) = pkce_verifier { - if let Err(e) = session + if let Some(verifier) = pkce_verifier + && let Err(e) = session .insert("oidc_pkce_verifier", verifier.secret().clone()) .await - { - tracing::error!("Failed to store pkce_verifier in session: {:?}", e); - return ( - StatusCode::INTERNAL_SERVER_ERROR, - Json(other_error("Session error")), - ) - .into_response(); - } + { + tracing::error!("Failed to store pkce_verifier in session: {:?}", e); + return ( + StatusCode::INTERNAL_SERVER_ERROR, + Json(other_error("Session error")), + ) + .into_response(); } if let Err(e) = session.insert("oidc_pkce_used", pkce_enabled).await { tracing::error!("Failed to store pkce_used in session: {:?}", e); diff --git a/easytier-web/src/restful/rpc.rs b/easytier-web/src/restful/rpc.rs index 7d2ec032..e938a87f 100644 --- a/easytier-web/src/restful/rpc.rs +++ b/easytier-web/src/restful/rpc.rs @@ -1,15 +1,15 @@ use axum::{ + Json, Router, extract::{Path, State}, http::StatusCode, routing::post, - Json, Router, }; use axum_login::AuthUser as _; use easytier::proto::rpc_types::controller::BaseController; use crate::db::UserIdInDb; -use super::{other_error, AppState, HttpHandleError}; +use super::{AppState, HttpHandleError, other_error}; #[derive(Debug, serde::Deserialize)] pub struct ProxyRpcRequest { @@ -120,7 +120,7 @@ async fn handle_proxy_rpc_by_session( return Err(( StatusCode::BAD_REQUEST, other_error(format!("Unknown service: {}", service_name)).into(), - )) + )); } }; diff --git a/easytier-web/src/restful/users.rs b/easytier-web/src/restful/users.rs index 325bf994..5ec86918 100644 --- a/easytier-web/src/restful/users.rs +++ b/easytier-web/src/restful/users.rs @@ -39,9 +39,9 @@ impl AuthUser for User { fn session_auth_hash(&self) -> &[u8] { self.db_user.password.as_bytes() // We use the password hash as the auth - // hash--what this means - // is when the user changes their password the - // auth session becomes invalid. + // hash--what this means + // is when the user changes their password the + // auth session becomes invalid. } } diff --git a/easytier-web/src/web/mod.rs b/easytier-web/src/web/mod.rs index eabe307e..934108ed 100644 --- a/easytier-web/src/web/mod.rs +++ b/easytier-web/src/web/mod.rs @@ -1,8 +1,9 @@ use axum::{ + Router, extract::State, http::header, response::{IntoResponse, Response}, - routing, Router, + routing, }; use axum_embed::ServeEmbed; use easytier::common::scoped_task::ScopedTask; diff --git a/easytier/Cargo.toml b/easytier/Cargo.toml index 410726c8..b7e53f6f 100644 --- a/easytier/Cargo.toml +++ b/easytier/Cargo.toml @@ -4,11 +4,11 @@ description = "A full meshed p2p VPN, connecting all your devices in one network homepage = "https://github.com/EasyTier/EasyTier" repository = "https://github.com/EasyTier/EasyTier" version = "2.6.0" -edition = "2021" +edition.workspace = true +rust-version.workspace = true authors = ["kkrainbow"] keywords = ["vpn", "p2p", "network", "easytier"] categories = ["network-programming", "command-line-utilities"] -rust-version = "1.93.0" license-file = "LICENSE" readme = "README.md" diff --git a/easytier/build.rs b/easytier/build.rs index 520a3f7f..5f6a74d8 100644 --- a/easytier/build.rs +++ b/easytier/build.rs @@ -86,7 +86,9 @@ impl WindowsBuild { } else { Self::download_protoc() }; - std::env::set_var("PROTOC", protoc_path); + unsafe { + std::env::set_var("PROTOC", protoc_path); + } } } diff --git a/easytier/src/arch/windows.rs b/easytier/src/arch/windows.rs index 9d97ecfc..d709d499 100644 --- a/easytier/src/arch/windows.rs +++ b/easytier/src/arch/windows.rs @@ -3,7 +3,6 @@ use std::{io, mem::ManuallyDrop, net::SocketAddr, os::windows::io::AsRawSocket}; use anyhow::Context; use network_interface::NetworkInterfaceConfig; use windows::{ - core::BSTR, Win32::{ Foundation::{BOOL, FALSE}, NetworkManagement::WindowsFirewall::{ @@ -12,15 +11,16 @@ use windows::{ NET_FW_RULE_DIR_OUT, }, Networking::WinSock::{ - htonl, setsockopt, WSAGetLastError, WSAIoctl, IPPROTO_IP, IPPROTO_IPV6, - IPV6_UNICAST_IF, IP_UNICAST_IF, SIO_UDP_CONNRESET, SOCKET, SOCKET_ERROR, + IP_UNICAST_IF, IPPROTO_IP, IPPROTO_IPV6, IPV6_UNICAST_IF, SIO_UDP_CONNRESET, SOCKET, + SOCKET_ERROR, WSAGetLastError, WSAIoctl, htonl, setsockopt, }, System::Com::{ - CoCreateInstance, CoInitializeEx, CoUninitialize, CLSCTX_ALL, COINIT_MULTITHREADED, + CLSCTX_ALL, COINIT_MULTITHREADED, CoCreateInstance, CoInitializeEx, CoUninitialize, }, System::Ole::{SafeArrayCreateVector, SafeArrayPutElement}, System::Variant::{VARENUM, VARIANT, VT_ARRAY, VT_BSTR, VT_VARIANT}, }, + core::BSTR, }; pub fn disable_connection_reset(socket: &S) -> io::Result<()> { diff --git a/easytier/src/common/acl_processor.rs b/easytier/src/common/acl_processor.rs index 3a86d98d..73376f1c 100644 --- a/easytier/src/common/acl_processor.rs +++ b/easytier/src/common/acl_processor.rs @@ -507,7 +507,7 @@ impl AclProcessor { matched_rule: Some(RuleId::Default), should_log: false, log_context: Some(AclLogContext::UnsupportedChainType), - } + }; } }; @@ -679,28 +679,28 @@ impl AclProcessor { } // Source port check - if let Some(src_port) = packet_info.src_port { - if !rule.src_port_ranges.is_empty() { - let matches = rule - .src_port_ranges - .iter() - .any(|(start, end)| src_port >= *start && src_port <= *end); - if !matches { - return false; - } + if let Some(src_port) = packet_info.src_port + && !rule.src_port_ranges.is_empty() + { + let matches = rule + .src_port_ranges + .iter() + .any(|(start, end)| src_port >= *start && src_port <= *end); + if !matches { + return false; } } // Destination port check - if let Some(dst_port) = packet_info.dst_port { - if !rule.dst_port_ranges.is_empty() { - let matches = rule - .dst_port_ranges - .iter() - .any(|(start, end)| dst_port >= *start && dst_port <= *end); - if !matches { - return false; - } + if let Some(dst_port) = packet_info.dst_port + && !rule.dst_port_ranges.is_empty() + { + let matches = rule + .dst_port_ranges + .iter() + .any(|(start, end)| dst_port >= *start && dst_port <= *end); + if !matches { + return false; } } diff --git a/easytier/src/common/compressor.rs b/easytier/src/common/compressor.rs index a5201852..d78972ee 100644 --- a/easytier/src/common/compressor.rs +++ b/easytier/src/common/compressor.rs @@ -9,7 +9,7 @@ use zstd::bulk; use zerocopy::{AsBytes as _, FromBytes as _}; -use crate::tunnel::packet_def::{CompressorAlgo, CompressorTail, ZCPacket, COMPRESSOR_TAIL_SIZE}; +use crate::tunnel::packet_def::{COMPRESSOR_TAIL_SIZE, CompressorAlgo, CompressorTail, ZCPacket}; type Error = anyhow::Error; diff --git a/easytier/src/common/config.rs b/easytier/src/common/config.rs index e4c9c5e6..a58e840f 100644 --- a/easytier/src/common/config.rs +++ b/easytier/src/common/config.rs @@ -6,10 +6,10 @@ use std::{ }; use anyhow::Context; -use base64::{prelude::BASE64_STANDARD, Engine as _}; +use base64::{Engine as _, prelude::BASE64_STANDARD}; use cfg_if::cfg_if; -use clap::builder::PossibleValue; use clap::ValueEnum; +use clap::builder::PossibleValue; use serde::{Deserialize, Serialize}; use strum::{Display, EnumString, VariantArray}; use tokio::io::AsyncReadExt as _; @@ -621,14 +621,14 @@ impl ConfigLoader for TomlConfigLoader { if locked_config.proxy_network.is_none() { locked_config.proxy_network = Some(vec![]); } - if let Some(mapped_cidr) = mapped_cidr.as_ref() { - if cidr.network_length() != mapped_cidr.network_length() { - return Err(anyhow::anyhow!( - "Mapped CIDR must have the same network length as the original CIDR: {} != {}", - cidr.network_length(), - mapped_cidr.network_length() - )); - } + if let Some(mapped_cidr) = mapped_cidr.as_ref() + && cidr.network_length() != mapped_cidr.network_length() + { + return Err(anyhow::anyhow!( + "Mapped CIDR must have the same network length as the original CIDR: {} != {}", + cidr.network_length(), + mapped_cidr.network_length() + )); } // insert if no duplicate if !locked_config @@ -881,10 +881,10 @@ impl ConfigLoader for TomlConfigLoader { let mut flag_map: serde_json::Map = Default::default(); for (key, value) in default_flags_hashmap { - if let Some(v) = cur_flags_hashmap.get(&key) { - if *v != value { - flag_map.insert(key, v.clone()); - } + if let Some(v) = cur_flags_hashmap.get(&key) + && *v != value + { + flag_map.insert(key, v.clone()); } } @@ -1089,6 +1089,7 @@ pub async fn load_config_from_file( #[cfg(test)] pub mod tests { use super::*; + use crate::tests::{remove_env_var, set_env_var}; use std::io::Write; use std::path::PathBuf; use tempfile::NamedTempFile; @@ -1212,8 +1213,8 @@ proto = "tcp" #[tokio::test] async fn test_env_var_expansion_and_readonly_flag() { // 设置测试环境变量 - std::env::set_var("TEST_SECRET", "my-test-secret-123"); - std::env::set_var("TEST_NETWORK", "test-network"); + set_env_var("TEST_SECRET", "my-test-secret-123"); + set_env_var("TEST_NETWORK", "test-network"); // 创建临时配置文件，包含环境变量占位符 let mut temp_file = NamedTempFile::new().unwrap(); @@ -1253,8 +1254,8 @@ network_secret = "${TEST_SECRET}" ); // 清理环境变量 - std::env::remove_var("TEST_SECRET"); - std::env::remove_var("TEST_NETWORK"); + remove_env_var("TEST_SECRET"); + remove_env_var("TEST_NETWORK"); } /// RPC API 安全测试（只读配置保护） @@ -1267,7 +1268,7 @@ network_secret = "${TEST_SECRET}" /// `easytier/src/rpc_service/instance_manage.rs` 中实现 #[tokio::test] async fn test_readonly_config_api_protection() { - std::env::set_var("API_TEST_SECRET", "secret-value"); + set_env_var("API_TEST_SECRET", "secret-value"); // 创建包含环境变量的配置 let mut temp_file = NamedTempFile::new().unwrap(); @@ -1298,7 +1299,7 @@ network_secret = "${API_TEST_SECRET}" "Permission flag should be set correctly" ); - std::env::remove_var("API_TEST_SECRET"); + remove_env_var("API_TEST_SECRET"); } /// CLI 参数测试（--disable-env-parsing 开关） @@ -1308,7 +1309,7 @@ network_secret = "${API_TEST_SECRET}" /// - 配置不会被标记为只读 #[tokio::test] async fn test_disable_env_parsing_flag() { - std::env::set_var("DISABLED_TEST_VAR", "should-not-expand"); + set_env_var("DISABLED_TEST_VAR", "should-not-expand"); // 创建包含环境变量占位符的配置 let mut temp_file = NamedTempFile::new().unwrap(); @@ -1346,7 +1347,7 @@ network_secret = "${DISABLED_TEST_VAR}" "Config should be NO_DELETE due to no config_dir, not env vars" ); - std::env::remove_var("DISABLED_TEST_VAR"); + remove_env_var("DISABLED_TEST_VAR"); } /// 多实例隔离测试 @@ -1357,8 +1358,8 @@ network_secret = "${DISABLED_TEST_VAR}" #[tokio::test] async fn test_multiple_instances_with_different_env_vars() { // 实例1：使用第一组环境变量 - std::env::set_var("INSTANCE_SECRET", "instance1-secret"); - std::env::set_var("INSTANCE_NAME", "instance-one"); + set_env_var("INSTANCE_SECRET", "instance1-secret"); + set_env_var("INSTANCE_NAME", "instance-one"); let mut temp_file1 = NamedTempFile::new().unwrap(); let config_content = r#" @@ -1388,8 +1389,8 @@ network_secret = "${INSTANCE_SECRET}" ); // 实例2：修改环境变量后加载同一模板 - std::env::set_var("INSTANCE_SECRET", "instance2-secret"); - std::env::set_var("INSTANCE_NAME", "instance-two"); + set_env_var("INSTANCE_SECRET", "instance2-secret"); + set_env_var("INSTANCE_NAME", "instance-two"); let mut temp_file2 = NamedTempFile::new().unwrap(); temp_file2.write_all(config_content.as_bytes()).unwrap(); @@ -1419,8 +1420,8 @@ network_secret = "${INSTANCE_SECRET}" ); // 清理 - std::env::remove_var("INSTANCE_SECRET"); - std::env::remove_var("INSTANCE_NAME"); + remove_env_var("INSTANCE_SECRET"); + remove_env_var("INSTANCE_NAME"); } /// 实际配置字段测试（network_secret、peer.uri 等） @@ -1433,11 +1434,11 @@ network_secret = "${INSTANCE_SECRET}" #[tokio::test] async fn test_real_config_fields_expansion() { // 设置各种实际场景的环境变量 - std::env::set_var("ET_SECRET", "production-secret-key"); - std::env::set_var("PEER_HOST", "peer.example.com"); - std::env::set_var("PEER_PORT", "11011"); - std::env::set_var("LISTEN_PORT", "11010"); - std::env::set_var("NETWORK_NAME", "prod-network"); + set_env_var("ET_SECRET", "production-secret-key"); + set_env_var("PEER_HOST", "peer.example.com"); + set_env_var("PEER_PORT", "11011"); + set_env_var("LISTEN_PORT", "11010"); + set_env_var("NETWORK_NAME", "prod-network"); // 创建包含多个实际字段的完整配置 let mut temp_file = NamedTempFile::new().unwrap(); @@ -1485,11 +1486,11 @@ uri = "tcp://${PEER_HOST}:${PEER_PORT}" assert!(control.is_no_delete()); // 清理环境变量 - std::env::remove_var("ET_SECRET"); - std::env::remove_var("PEER_HOST"); - std::env::remove_var("PEER_PORT"); - std::env::remove_var("LISTEN_PORT"); - std::env::remove_var("NETWORK_NAME"); + remove_env_var("ET_SECRET"); + remove_env_var("PEER_HOST"); + remove_env_var("PEER_PORT"); + remove_env_var("LISTEN_PORT"); + remove_env_var("NETWORK_NAME"); } /// 带默认值的环境变量 @@ -1499,8 +1500,8 @@ uri = "tcp://${PEER_HOST}:${PEER_PORT}" #[tokio::test] async fn test_env_var_with_default_value() { // 确保变量未定义 - std::env::remove_var("UNDEFINED_PORT"); - std::env::remove_var("UNDEFINED_SECRET"); + remove_env_var("UNDEFINED_PORT"); + remove_env_var("UNDEFINED_SECRET"); let mut temp_file = NamedTempFile::new().unwrap(); let config_content = r#" @@ -1541,7 +1542,7 @@ network_secret = "${UNDEFINED_SECRET:-default-secret}" /// - 未定义的环境变量保持原样（shellexpand 的默认行为） #[tokio::test] async fn test_undefined_env_var_without_default() { - std::env::remove_var("COMPLETELY_UNDEFINED"); + remove_env_var("COMPLETELY_UNDEFINED"); let mut temp_file = NamedTempFile::new().unwrap(); let config_content = r#" @@ -1571,6 +1572,8 @@ network_secret = "${COMPLETELY_UNDEFINED}" // 注意：由于没有实际替换发生，控制标记不应因环境变量而设置 // 但会因为其他原因（如没有 config_dir）被标记为 NO_DELETE + // 这里我们主要验证 NO_DELETE 标记的逻辑 + // 由于没有 config_dir，文件会被标记为 NO_DELETE，但不是因为环境变量 assert!(control.is_no_delete()); } @@ -1582,9 +1585,9 @@ network_secret = "${COMPLETELY_UNDEFINED}" #[tokio::test] async fn test_boolean_type_env_vars() { // 设置布尔类型的环境变量 - std::env::set_var("ENABLE_DHCP", "true"); - std::env::set_var("ENABLE_ENCRYPTION", "false"); - std::env::set_var("ENABLE_IPV6", "true"); + set_env_var("ENABLE_DHCP", "true"); + set_env_var("ENABLE_ENCRYPTION", "false"); + set_env_var("ENABLE_IPV6", "true"); let mut temp_file = NamedTempFile::new().unwrap(); let config_content = r#" @@ -1622,9 +1625,9 @@ enable_ipv6 = ${ENABLE_IPV6} assert!(control.is_no_delete()); // 清理 - std::env::remove_var("ENABLE_DHCP"); - std::env::remove_var("ENABLE_ENCRYPTION"); - std::env::remove_var("ENABLE_IPV6"); + remove_env_var("ENABLE_DHCP"); + remove_env_var("ENABLE_ENCRYPTION"); + remove_env_var("ENABLE_IPV6"); } /// 数字类型环境变量 @@ -1635,8 +1638,8 @@ enable_ipv6 = ${ENABLE_IPV6} #[tokio::test] async fn test_numeric_type_env_vars() { // 设置数字类型的环境变量 - std::env::set_var("MTU_VALUE", "1400"); - std::env::set_var("THREAD_COUNT", "4"); + set_env_var("MTU_VALUE", "1400"); + set_env_var("THREAD_COUNT", "4"); let mut temp_file = NamedTempFile::new().unwrap(); let config_content = r#" @@ -1671,8 +1674,8 @@ multi_thread_count = ${THREAD_COUNT} assert!(control.is_no_delete()); // 清理 - std::env::remove_var("MTU_VALUE"); - std::env::remove_var("THREAD_COUNT"); + remove_env_var("MTU_VALUE"); + remove_env_var("THREAD_COUNT"); } /// 混合类型环境变量 @@ -1684,12 +1687,12 @@ multi_thread_count = ${THREAD_COUNT} #[tokio::test] async fn test_mixed_type_env_vars() { // 设置不同类型的环境变量 - std::env::set_var("MIXED_SECRET", "mixed-secret-key"); - std::env::set_var("MIXED_NETWORK", "production"); - std::env::set_var("MIXED_DHCP", "true"); - std::env::set_var("MIXED_MTU", "1500"); - std::env::set_var("MIXED_ENCRYPTION", "false"); - std::env::set_var("MIXED_LISTEN_PORT", "12345"); + set_env_var("MIXED_SECRET", "mixed-secret-key"); + set_env_var("MIXED_NETWORK", "production"); + set_env_var("MIXED_DHCP", "true"); + set_env_var("MIXED_MTU", "1500"); + set_env_var("MIXED_ENCRYPTION", "false"); + set_env_var("MIXED_LISTEN_PORT", "12345"); let mut temp_file = NamedTempFile::new().unwrap(); let config_content = r#" @@ -1741,11 +1744,11 @@ enable_encryption = ${MIXED_ENCRYPTION} assert!(control.is_no_delete()); // 清理 - std::env::remove_var("MIXED_SECRET"); - std::env::remove_var("MIXED_NETWORK"); - std::env::remove_var("MIXED_DHCP"); - std::env::remove_var("MIXED_MTU"); - std::env::remove_var("MIXED_ENCRYPTION"); - std::env::remove_var("MIXED_LISTEN_PORT"); + remove_env_var("MIXED_SECRET"); + remove_env_var("MIXED_NETWORK"); + remove_env_var("MIXED_DHCP"); + remove_env_var("MIXED_MTU"); + remove_env_var("MIXED_ENCRYPTION"); + remove_env_var("MIXED_LISTEN_PORT"); } } diff --git a/easytier/src/common/dns.rs b/easytier/src/common/dns.rs index e368e640..dd7eaef1 100644 --- a/easytier/src/common/dns.rs +++ b/easytier/src/common/dns.rs @@ -1,6 +1,6 @@ use std::net::SocketAddr; -use std::sync::atomic::AtomicBool; use std::sync::Arc; +use std::sync::atomic::AtomicBool; use anyhow::Context; use hickory_proto::runtime::TokioRuntimeProvider; diff --git a/easytier/src/common/env_parser.rs b/easytier/src/common/env_parser.rs index bb65b805..15fcf5d4 100644 --- a/easytier/src/common/env_parser.rs +++ b/easytier/src/common/env_parser.rs @@ -42,10 +42,11 @@ pub fn expand_env_vars(text: &str) -> (String, bool) { #[cfg(test)] mod tests { use super::*; + use crate::tests::{remove_env_var, set_env_var}; #[test] fn test_expand_standard_syntax() { - std::env::set_var("TEST_VAR_STANDARD", "test_value"); + set_env_var("TEST_VAR_STANDARD", "test_value"); let (result, changed) = expand_env_vars("secret=${TEST_VAR_STANDARD}"); assert_eq!(result, "secret=test_value"); assert!(changed); @@ -53,7 +54,7 @@ mod tests { #[test] fn test_expand_short_syntax() { - std::env::set_var("TEST_VAR_SHORT", "short_value"); + set_env_var("TEST_VAR_SHORT", "short_value"); let (result, changed) = expand_env_vars("key=$TEST_VAR_SHORT"); assert_eq!(result, "key=short_value"); assert!(changed); @@ -62,7 +63,7 @@ mod tests { #[test] fn test_expand_with_default() { // 确保变量未定义 - std::env::remove_var("UNDEFINED_VAR_WITH_DEFAULT"); + remove_env_var("UNDEFINED_VAR_WITH_DEFAULT"); let (result, changed) = expand_env_vars("port=${UNDEFINED_VAR_WITH_DEFAULT:-8080}"); assert_eq!(result, "port=8080"); assert!(changed); @@ -84,8 +85,8 @@ mod tests { #[test] fn test_multiple_vars() { - std::env::set_var("VAR1", "value1"); - std::env::set_var("VAR2", "value2"); + set_env_var("VAR1", "value1"); + set_env_var("VAR2", "value2"); let (result, changed) = expand_env_vars("${VAR1} and ${VAR2}"); assert_eq!(result, "value1 and value2"); assert!(changed); @@ -94,7 +95,7 @@ mod tests { #[test] fn test_undefined_var_without_default() { // 确保变量未定义 - std::env::remove_var("COMPLETELY_UNDEFINED_VAR"); + remove_env_var("COMPLETELY_UNDEFINED_VAR"); let (result, changed) = expand_env_vars("value=${COMPLETELY_UNDEFINED_VAR}"); // shellexpand::env 对未定义的变量会保持原样 assert_eq!(result, "value=${COMPLETELY_UNDEFINED_VAR}"); @@ -103,8 +104,8 @@ mod tests { #[test] fn test_complex_toml_config() { - std::env::set_var("ET_SECRET", "my-secret-key"); - std::env::set_var("ET_PORT", "11010"); + set_env_var("ET_SECRET", "my-secret-key"); + set_env_var("ET_PORT", "11010"); let config = r#" [network_identity] @@ -123,7 +124,7 @@ uri = "tcp://127.0.0.1:${ET_PORT}" #[test] fn test_escape_syntax_double_dollar() { - std::env::set_var("ESCAPED_VAR", "should_not_expand"); + set_env_var("ESCAPED_VAR", "should_not_expand"); // shellexpand 使用 $$ 作为转义序列，表示字面量的单个 $ // $$ 会被转义为单个 $，不会触发变量扩展 let (result, changed) = expand_env_vars("value=$${ESCAPED_VAR}"); @@ -133,7 +134,7 @@ uri = "tcp://127.0.0.1:${ET_PORT}" #[test] fn test_escape_syntax_backslash() { - std::env::set_var("ESCAPED_VAR", "should_not_expand"); + set_env_var("ESCAPED_VAR", "should_not_expand"); // shellexpand 中反斜杠转义的行为：\$ 会展开为 \<变量值> // 这不是推荐的转义方式，此测试仅为记录实际行为 let (result, changed) = expand_env_vars(r"value=\${ESCAPED_VAR}"); @@ -143,7 +144,7 @@ uri = "tcp://127.0.0.1:${ET_PORT}" #[test] fn test_multiple_dollar_signs() { - std::env::set_var("TEST_VAR", "value"); + set_env_var("TEST_VAR", "value"); // 测试多个连续的 $ 符号 let (result1, changed1) = expand_env_vars("$$"); assert_eq!(result1, "$"); @@ -161,7 +162,7 @@ uri = "tcp://127.0.0.1:${ET_PORT}" #[test] fn test_empty_var_value() { - std::env::set_var("EMPTY_VAR", ""); + set_env_var("EMPTY_VAR", ""); let (result, changed) = expand_env_vars("value=${EMPTY_VAR}"); // 变量存在但值为空 assert_eq!(result, "value="); @@ -170,7 +171,7 @@ uri = "tcp://127.0.0.1:${ET_PORT}" #[test] fn test_default_with_special_chars() { - std::env::remove_var("UNDEFINED_SPECIAL"); + remove_env_var("UNDEFINED_SPECIAL"); // 测试默认值包含冒号、等号、空格等特殊字符 let (result, changed) = expand_env_vars("url=${UNDEFINED_SPECIAL:-http://localhost:8080}"); assert_eq!(result, "url=http://localhost:8080"); @@ -187,9 +188,9 @@ uri = "tcp://127.0.0.1:${ET_PORT}" #[test] fn test_var_name_with_numbers_underscores() { - std::env::set_var("VAR_123", "num_value"); - std::env::set_var("_VAR", "underscore_prefix"); - std::env::set_var("VAR_", "underscore_suffix"); + set_env_var("VAR_123", "num_value"); + set_env_var("_VAR", "underscore_prefix"); + set_env_var("VAR_", "underscore_suffix"); let (result1, changed1) = expand_env_vars("${VAR_123}"); assert_eq!(result1, "num_value"); @@ -214,7 +215,7 @@ uri = "tcp://127.0.0.1:${ET_PORT}" // 注意：未闭合的 ${VAR 实际上 shellexpand 会当作普通文本处理 // 它会尝试查找名为 "VAR" 的环境变量（到字符串末尾） - std::env::remove_var("VAR"); + remove_env_var("VAR"); let (result2, _changed2) = expand_env_vars("incomplete ${VAR"); // 如果 VAR 未定义，shellexpand 会返回错误或保持原样 assert_eq!(result2, "incomplete ${VAR"); @@ -224,8 +225,8 @@ uri = "tcp://127.0.0.1:${ET_PORT}" #[test] fn test_mixed_defined_undefined_vars() { - std::env::set_var("DEFINED_VAR", "defined"); - std::env::remove_var("UNDEFINED_VAR"); + set_env_var("DEFINED_VAR", "defined"); + remove_env_var("UNDEFINED_VAR"); // 混合已定义和未定义的变量 // shellexpand::env 在遇到未定义变量时会返回错误（默认行为） @@ -237,7 +238,7 @@ uri = "tcp://127.0.0.1:${ET_PORT}" #[test] fn test_nested_braces() { - std::env::set_var("OUTER", "outer_value"); + set_env_var("OUTER", "outer_value"); // 嵌套的大括号是无效语法，shellexpand::env 会返回错误 let (result, changed) = expand_env_vars("${OUTER} and ${{INNER}}"); // 由于语法错误，整个字符串保持不变 diff --git a/easytier/src/common/global_ctx.rs b/easytier/src/common/global_ctx.rs index 6a61b774..ed3a2286 100644 --- a/easytier/src/common/global_ctx.rs +++ b/easytier/src/common/global_ctx.rs @@ -1,5 +1,5 @@ use std::{ - collections::{hash_map::DefaultHasher, HashMap}, + collections::{HashMap, hash_map::DefaultHasher}, hash::Hasher, net::{IpAddr, SocketAddr}, sync::{Arc, Mutex}, @@ -10,11 +10,11 @@ use arc_swap::ArcSwap; use dashmap::DashMap; use super::{ + PeerId, config::{ConfigLoader, Flags}, netns::NetNS, network::IPCollector, stun::{StunInfoCollector, StunInfoCollectorTrait}, - PeerId, }; use crate::{ common::{ diff --git a/easytier/src/common/ifcfg/darwin.rs b/easytier/src/common/ifcfg/darwin.rs index 1da21e5e..b556b186 100644 --- a/easytier/src/common/ifcfg/darwin.rs +++ b/easytier/src/common/ifcfg/darwin.rs @@ -1,6 +1,6 @@ use std::net::Ipv4Addr; -use super::{cidr_to_subnet_mask, run_shell_cmd, Error, IfConfiguerTrait}; +use super::{Error, IfConfiguerTrait, cidr_to_subnet_mask, run_shell_cmd}; use async_trait::async_trait; use cidr::{Ipv4Inet, Ipv6Inet}; diff --git a/easytier/src/common/ifcfg/netlink.rs b/easytier/src/common/ifcfg/netlink.rs index 1c3550a2..13bad869 100644 --- a/easytier/src/common/ifcfg/netlink.rs +++ b/easytier/src/common/ifcfg/netlink.rs @@ -10,27 +10,27 @@ use anyhow::Context; use async_trait::async_trait; use cidr::{IpInet, Ipv4Inet, Ipv6Inet}; use netlink_packet_core::{ - NetlinkDeserializable, NetlinkHeader, NetlinkMessage, NetlinkPayload, NetlinkSerializable, - NLM_F_ACK, NLM_F_CREATE, NLM_F_DUMP, NLM_F_EXCL, NLM_F_REQUEST, + NLM_F_ACK, NLM_F_CREATE, NLM_F_DUMP, NLM_F_EXCL, NLM_F_REQUEST, NetlinkDeserializable, + NetlinkHeader, NetlinkMessage, NetlinkPayload, NetlinkSerializable, }; use netlink_packet_route::{ + AddressFamily, RouteNetlinkMessage, address::{AddressAttribute, AddressMessage}, route::{ RouteAddress, RouteAttribute, RouteHeader, RouteMessage, RouteProtocol, RouteScope, RouteType, }, - AddressFamily, RouteNetlinkMessage, }; -use netlink_sys::{protocols::NETLINK_ROUTE, Socket, SocketAddr}; +use netlink_sys::{Socket, SocketAddr, protocols::NETLINK_ROUTE}; use nix::{ ifaddrs::getifaddrs, - libc::{self, ifreq, ioctl, Ioctl, SIOCGIFFLAGS, SIOCGIFMTU, SIOCSIFFLAGS, SIOCSIFMTU}, + libc::{self, Ioctl, SIOCGIFFLAGS, SIOCGIFMTU, SIOCSIFFLAGS, SIOCSIFMTU, ifreq, ioctl}, net::if_::InterfaceFlags, sys::socket::SockaddrLike as _, }; use pnet::ipnetwork::ip_mask_to_prefix; -use super::{route::Route, Error, IfConfiguerTrait}; +use super::{Error, IfConfiguerTrait, route::Route}; pub(crate) fn dummy_socket() -> Result { Ok(std::net::UdpSocket::bind("0:0")?) diff --git a/easytier/src/common/ifcfg/win/luid.rs b/easytier/src/common/ifcfg/win/luid.rs index bae2316a..67405440 100644 --- a/easytier/src/common/ifcfg/win/luid.rs +++ b/easytier/src/common/ifcfg/win/luid.rs @@ -740,10 +740,6 @@ impl InterfaceLuid { // SAFETY: TODO let ret = unsafe { SetIpInterfaceEntry(&mut row) }; - if NO_ERROR == ret { - Ok(()) - } else { - Err(ret) - } + if NO_ERROR == ret { Ok(()) } else { Err(ret) } } } diff --git a/easytier/src/common/ifcfg/windows.rs b/easytier/src/common/ifcfg/windows.rs index 078219e9..35ef12f7 100644 --- a/easytier/src/common/ifcfg/windows.rs +++ b/easytier/src/common/ifcfg/windows.rs @@ -10,14 +10,14 @@ use std::{ }; use windows_sys::Win32::{ Foundation::NO_ERROR, - NetworkManagement::IpHelper::{GetIfEntry, SetIfEntry, MIB_IFROW}, + NetworkManagement::IpHelper::{GetIfEntry, MIB_IFROW, SetIfEntry}, System::Diagnostics::Debug::{ - FormatMessageW, FORMAT_MESSAGE_FROM_SYSTEM, FORMAT_MESSAGE_IGNORE_INSERTS, + FORMAT_MESSAGE_FROM_SYSTEM, FORMAT_MESSAGE_IGNORE_INSERTS, FormatMessageW, }, }; use winreg::{ - enums::{HKEY_LOCAL_MACHINE, KEY_READ, KEY_WRITE}, RegKey, + enums::{HKEY_LOCAL_MACHINE, KEY_READ, KEY_WRITE}, }; use super::{Error, IfConfiguerTrait}; @@ -331,7 +331,7 @@ impl RegistryManager { r"SYSTEM\CurrentControlSet\Services\NetBT\Parameters\Interfaces\Tcpip_"; pub fn reg_delete_obsoleted_items(dev_name: &str) -> io::Result<()> { - use winreg::{enums::HKEY_LOCAL_MACHINE, enums::KEY_ALL_ACCESS, RegKey}; + use winreg::{RegKey, enums::HKEY_LOCAL_MACHINE, enums::KEY_ALL_ACCESS}; let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); let profiles_key = hklm.open_subkey_with_flags( "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkList\\Profiles", @@ -405,7 +405,7 @@ impl RegistryManager { } pub fn reg_change_catrgory_in_profile(dev_name: &str) -> io::Result<()> { - use winreg::{enums::HKEY_LOCAL_MACHINE, enums::KEY_ALL_ACCESS, RegKey}; + use winreg::{RegKey, enums::HKEY_LOCAL_MACHINE, enums::KEY_ALL_ACCESS}; let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); let profiles_key = hklm.open_subkey_with_flags( "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkList\\Profiles", diff --git a/easytier/src/common/log.rs b/easytier/src/common/log.rs index d6058f19..9dad049a 100644 --- a/easytier/src/common/log.rs +++ b/easytier/src/common/log.rs @@ -9,11 +9,11 @@ use paste::paste; use regex::Regex; use tracing::level_filters::LevelFilter; use tracing::{Level, Metadata}; -use tracing_subscriber::filter::{filter_fn, FilterExt}; +use tracing_subscriber::Registry; +use tracing_subscriber::filter::{FilterExt, filter_fn}; use tracing_subscriber::fmt::layer; use tracing_subscriber::layer::SubscriberExt; use tracing_subscriber::util::SubscriberInitExt; -use tracing_subscriber::Registry; use tracing_subscriber::{EnvFilter, Layer}; macro_rules! __log__ { diff --git a/easytier/src/common/mod.rs b/easytier/src/common/mod.rs index 86607a54..1b8e303c 100644 --- a/easytier/src/common/mod.rs +++ b/easytier/src/common/mod.rs @@ -41,8 +41,8 @@ pub fn get_logger_timer( tracing_subscriber::fmt::time::OffsetTime::new(local_offset, format) } -pub fn get_logger_timer_rfc3339( -) -> tracing_subscriber::fmt::time::OffsetTime { +pub fn get_logger_timer_rfc3339() +-> tracing_subscriber::fmt::time::OffsetTime { get_logger_timer(time::format_description::well_known::Rfc3339) } @@ -117,10 +117,10 @@ pub fn get_machine_id() -> uuid::Uuid { .unwrap_or_else(|_| std::path::PathBuf::from("et_machine_id")); // try load from local file - if let Ok(mid) = std::fs::read_to_string(&machine_id_file) { - if let Ok(mid) = uuid::Uuid::parse_str(mid.trim()) { - return mid; - } + if let Ok(mid) = std::fs::read_to_string(&machine_id_file) + && let Ok(mid) = uuid::Uuid::parse_str(mid.trim()) + { + return mid; } #[cfg(any( diff --git a/easytier/src/common/netns.rs b/easytier/src/common/netns.rs index 95d6b3f7..25e38faf 100644 --- a/easytier/src/common/netns.rs +++ b/easytier/src/common/netns.rs @@ -1,7 +1,7 @@ use futures::Future; #[cfg(target_os = "linux")] -use nix::sched::{setns, CloneFlags}; +use nix::sched::{CloneFlags, setns}; #[cfg(target_os = "linux")] use std::os::fd::AsFd; diff --git a/easytier/src/common/stats_manager.rs b/easytier/src/common/stats_manager.rs index 2218263a..d5355759 100644 --- a/easytier/src/common/stats_manager.rs +++ b/easytier/src/common/stats_manager.rs @@ -374,7 +374,9 @@ impl UnsafeCounter { /// that no other thread is accessing this counter simultaneously. pub unsafe fn add(&self, delta: u64) { let ptr = self.value.get(); - *ptr = (*ptr).saturating_add(delta); + unsafe { + *ptr = (*ptr).saturating_add(delta); + } } /// Increment the counter by 1 @@ -382,7 +384,9 @@ impl UnsafeCounter { /// This method is unsafe because it uses UnsafeCell. The caller must ensure /// that no other thread is accessing this counter simultaneously. pub unsafe fn inc(&self) { - self.add(1); + unsafe { + self.add(1); + } } /// Get the current value of the counter @@ -391,7 +395,7 @@ impl UnsafeCounter { /// that no other thread is modifying this counter simultaneously. pub unsafe fn get(&self) -> u64 { let ptr = self.value.get(); - *ptr + unsafe { *ptr } } /// Reset the counter to zero @@ -400,7 +404,9 @@ impl UnsafeCounter { /// that no other thread is accessing this counter simultaneously. pub unsafe fn reset(&self) { let ptr = self.value.get(); - *ptr = 0; + unsafe { + *ptr = 0; + } } /// Set the counter to a specific value @@ -409,7 +415,9 @@ impl UnsafeCounter { /// that no other thread is accessing this counter simultaneously. pub unsafe fn set(&self, value: u64) { let ptr = self.value.get(); - *ptr = value; + unsafe { + *ptr = value; + } } } @@ -446,7 +454,9 @@ impl MetricData { /// that no other thread is accessing this timestamp simultaneously. unsafe fn touch(&self) { let ptr = self.last_updated.get(); - *ptr = Instant::now(); + unsafe { + *ptr = Instant::now(); + } } /// Get the last updated timestamp @@ -455,7 +465,7 @@ impl MetricData { /// that no other thread is modifying this timestamp simultaneously. unsafe fn get_last_updated(&self) -> Instant { let ptr = self.last_updated.get(); - *ptr + unsafe { *ptr } } } diff --git a/easytier/src/common/stun.rs b/easytier/src/common/stun.rs index f77e8fd7..1eebfff1 100644 --- a/easytier/src/common/stun.rs +++ b/easytier/src/common/stun.rs @@ -11,8 +11,8 @@ use crossbeam::atomic::AtomicCell; use rand::seq::IteratorRandom; use socket2::{SockAddr, SockRef}; use tokio::io::{AsyncReadExt, AsyncWriteExt}; -use tokio::net::{lookup_host, UdpSocket}; -use tokio::sync::{broadcast, Mutex}; +use tokio::net::{UdpSocket, lookup_host}; +use tokio::sync::{Mutex, broadcast}; use tokio::task::JoinSet; use tracing::{Instrument, Level}; @@ -1340,7 +1340,7 @@ impl StunInfoCollectorTrait for MockStunInfoCollector { mod tests { use crate::{ common::scoped_task::ScopedTask, - tunnel::{udp::UdpTunnelListener, TunnelListener}, + tunnel::{TunnelListener, udp::UdpTunnelListener}, }; use tokio::time::{sleep, timeout}; @@ -1404,10 +1404,10 @@ mod tests { loop { let ret = detector.detect_nat_type(0).await; println!("{:#?}, {:?}", ret, ret.as_ref().map(|x| x.nat_type())); - if let Ok(resp) = ret { - if !resp.stun_resps.is_empty() { - return; - } + if let Ok(resp) = ret + && !resp.stun_resps.is_empty() + { + return; } sleep(Duration::from_secs(1)).await; } diff --git a/easytier/src/common/stun_codec_ext.rs b/easytier/src/common/stun_codec_ext.rs index c0139951..884645af 100644 --- a/easytier/src/common/stun_codec_ext.rs +++ b/easytier/src/common/stun_codec_ext.rs @@ -1,13 +1,13 @@ use std::net::SocketAddr; use bytecodec::fixnum::{U32beDecoder, U32beEncoder}; -use stun_codec::net::{socket_addr_xor, SocketAddrDecoder, SocketAddrEncoder}; +use stun_codec::net::{SocketAddrDecoder, SocketAddrEncoder, socket_addr_xor}; use stun_codec::rfc5389::attributes::{ MappedAddress, Software, XorMappedAddress, XorMappedAddress2, }; use stun_codec::rfc5780::attributes::{OtherAddress, ResponseOrigin}; -use stun_codec::{define_attribute_enums, AttributeType, Message, TransactionId}; +use stun_codec::{AttributeType, Message, TransactionId, define_attribute_enums}; use bytecodec::{ByteCount, Decode, Encode, Eos, Result, SizedEncode, TryTaggedDecode}; diff --git a/easytier/src/common/token_bucket.rs b/easytier/src/common/token_bucket.rs index 9c706b2f..efffe030 100644 --- a/easytier/src/common/token_bucket.rs +++ b/easytier/src/common/token_bucket.rs @@ -231,7 +231,7 @@ mod tests { }; use super::*; - use tokio::time::{sleep, Duration}; + use tokio::time::{Duration, sleep}; /// Test initial state after creation #[tokio::test] diff --git a/easytier/src/common/tracing_rolling_appender/base.rs b/easytier/src/common/tracing_rolling_appender/base.rs index 99af38dc..ababc18f 100644 --- a/easytier/src/common/tracing_rolling_appender/base.rs +++ b/easytier/src/common/tracing_rolling_appender/base.rs @@ -57,17 +57,16 @@ impl Default for RollingConditionBase { impl RollingCondition for RollingConditionBase { fn should_rollover(&mut self, now: &DateTime, current_filesize: u64) -> bool { let mut rollover = false; - if let Some(frequency) = self.frequency_opt.as_ref() { - if let Some(last_write) = self.last_write_opt.as_ref() { - if frequency.equivalent_datetime(now) != frequency.equivalent_datetime(last_write) { - rollover = true; - } - } + if let Some(frequency) = self.frequency_opt.as_ref() + && let Some(last_write) = self.last_write_opt.as_ref() + && frequency.equivalent_datetime(now) != frequency.equivalent_datetime(last_write) + { + rollover = true; } - if let Some(max_size) = self.max_size_opt.as_ref() { - if current_filesize >= *max_size { - rollover = true; - } + if let Some(max_size) = self.max_size_opt.as_ref() + && current_filesize >= *max_size + { + rollover = true; } self.last_write_opt = Some(*now); rollover diff --git a/easytier/src/common/tracing_rolling_appender/mod.rs b/easytier/src/common/tracing_rolling_appender/mod.rs index bf674d3b..2074586b 100644 --- a/easytier/src/common/tracing_rolling_appender/mod.rs +++ b/easytier/src/common/tracing_rolling_appender/mod.rs @@ -81,11 +81,7 @@ where /// Determines the final filename, where n==0 indicates the current file fn filename_for(&self, n: usize) -> String { let f = self.filename.clone(); - if n > 0 { - format!("{}.{}", f, n) - } else { - f - } + if n > 0 { format!("{}.{}", f, n) } else { f } } /// Rotates old files to make room for a new one. @@ -145,14 +141,14 @@ where /// Writes data using the given datetime to calculate the rolling condition pub fn write_with_datetime(&mut self, buf: &[u8], now: &DateTime) -> io::Result { - if self.condition.should_rollover(now, self.current_filesize) { - if let Err(e) = self.rollover() { - // If we can't rollover, just try to continue writing anyway - // (better than missing data). - // This will likely used to implement logging, so - // avoid using log::warn and log to stderr directly - eprintln!("WARNING: Failed to rotate logfile {}: {}", self.filename, e); - } + if self.condition.should_rollover(now, self.current_filesize) + && let Err(e) = self.rollover() + { + // If we can't rollover, just try to continue writing anyway + // (better than missing data). + // This will likely used to implement logging, so + // avoid using log::warn and log to stderr directly + eprintln!("WARNING: Failed to rotate logfile {}: {}", self.filename, e); } self.open_writer_if_needed()?; if let Some(writer) = self.writer_opt.as_mut() { diff --git a/easytier/src/connector/direct.rs b/easytier/src/connector/direct.rs index 00a88265..6a5b63e1 100644 --- a/easytier/src/connector/direct.rs +++ b/easytier/src/connector/direct.rs @@ -5,16 +5,16 @@ use std::{ net::{IpAddr, Ipv6Addr, SocketAddr}, str::FromStr, sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }, time::{Duration, Instant}, }; use crate::{ common::{ - dns::socket_addrs, error::Error, global_ctx::ArcGlobalCtx, stun::StunInfoCollectorTrait, - PeerId, + PeerId, dns::socket_addrs, error::Error, global_ctx::ArcGlobalCtx, + stun::StunInfoCollectorTrait, }, connector::udp_hole_punch::handle_rpc_result, peers::{ @@ -31,7 +31,7 @@ use crate::{ }, rpc_types::controller::BaseController, }, - tunnel::{matches_protocol, udp::UdpTunnelConnector, IpVersion}, + tunnel::{IpVersion, matches_protocol, udp::UdpTunnelConnector}, use_global_var, }; @@ -39,7 +39,7 @@ use super::{ create_connector_by_url, should_background_p2p_with_peer, should_try_p2p_with_peer, udp_hole_punch, }; -use crate::tunnel::{matches_scheme, FromUrl, IpScheme, TunnelScheme}; +use crate::tunnel::{FromUrl, IpScheme, TunnelScheme, matches_scheme}; use anyhow::Context; use rand::Rng; use socket2::Protocol; @@ -769,12 +769,9 @@ mod tests { let port = if proto == "wg" { 11040 } else { 11041 }; if !ipv6 { - p_c.get_global_ctx().config.set_listeners(vec![format!( - "{}://0.0.0.0:{}", - proto, port - ) - .parse() - .unwrap()]); + p_c.get_global_ctx().config.set_listeners(vec![ + format!("{}://0.0.0.0:{}", proto, port).parse().unwrap(), + ]); } else { p_c.get_global_ctx() .config @@ -814,11 +811,12 @@ mod tests { .await .unwrap(); - assert!(data - .dst_listener_blacklist - .contains(&DstListenerUrlBlackListItem( - 1, - "tcp://127.0.0.1:10222".parse().unwrap() - ))); + assert!( + data.dst_listener_blacklist + .contains(&DstListenerUrlBlackListItem( + 1, + "tcp://127.0.0.1:10222".parse().unwrap() + )) + ); } } diff --git a/easytier/src/connector/dns_connector.rs b/easytier/src/connector/dns_connector.rs index f264a7d7..c41a5a53 100644 --- a/easytier/src/connector/dns_connector.rs +++ b/easytier/src/connector/dns_connector.rs @@ -3,7 +3,7 @@ use std::{net::SocketAddr, sync::Arc}; use super::{create_connector_by_url, http_connector::TunnelWithInfo}; use crate::{ common::{ - dns::{resolve_txt_record, RESOLVER}, + dns::{RESOLVER, resolve_txt_record}, error::Error, global_ctx::ArcGlobalCtx, log, @@ -14,7 +14,7 @@ use crate::{ use anyhow::Context; use dashmap::DashSet; use hickory_resolver::proto::rr::rdata::SRV; -use rand::{seq::SliceRandom, Rng as _}; +use rand::{Rng as _, seq::SliceRandom}; use strum::VariantArray; fn weighted_choice(options: &[(T, u64)]) -> Option<&T> { diff --git a/easytier/src/connector/http_connector.rs b/easytier/src/connector/http_connector.rs index dc133ae1..154b02a1 100644 --- a/easytier/src/connector/http_connector.rs +++ b/easytier/src/connector/http_connector.rs @@ -10,9 +10,9 @@ use rand::seq::SliceRandom as _; use url::Url; use crate::{ + VERSION, common::{error::Error, global_ctx::ArcGlobalCtx}, tunnel::{IpVersion, Tunnel, TunnelConnector, TunnelError, ZCPacketSink, ZCPacketStream}, - VERSION, }; use crate::proto::common::TunnelInfo; @@ -257,7 +257,7 @@ mod tests { use crate::{ common::global_ctx::tests::get_mock_global_ctx_with_network, - tunnel::{tcp::TcpTunnelListener, TunnelConnector, TunnelListener}, + tunnel::{TunnelConnector, TunnelListener, tcp::TcpTunnelListener}, }; use super::*; diff --git a/easytier/src/connector/manual.rs b/easytier/src/connector/manual.rs index 98bbc1a4..8e9fd902 100644 --- a/easytier/src/connector/manual.rs +++ b/easytier/src/connector/manual.rs @@ -7,7 +7,7 @@ use dashmap::DashSet; use tokio::{sync::mpsc, task::JoinSet, time::timeout}; use crate::{ - common::{dns::socket_addrs, join_joinset_background, PeerId}, + common::{PeerId, dns::socket_addrs, join_joinset_background}, peers::peer_conn::PeerConnId, proto::{ api::instance::{ diff --git a/easytier/src/connector/mod.rs b/easytier/src/connector/mod.rs index c6ab6a28..bfe8740c 100644 --- a/easytier/src/connector/mod.rs +++ b/easytier/src/connector/mod.rs @@ -8,8 +8,8 @@ use crate::{ connector::dns_connector::DnsTunnelConnector, proto::common::PeerFeatureFlag, tunnel::{ - self, ring::RingTunnelConnector, tcp::TcpTunnelConnector, udp::UdpTunnelConnector, FromUrl, - IpScheme, IpVersion, TunnelConnector, TunnelError, TunnelScheme, + self, FromUrl, IpScheme, IpVersion, TunnelConnector, TunnelError, TunnelScheme, + ring::RingTunnelConnector, tcp::TcpTunnelConnector, udp::UdpTunnelConnector, }, utils::BoxExt, }; diff --git a/easytier/src/connector/tcp_hole_punch.rs b/easytier/src/connector/tcp_hole_punch.rs index 7ce4f2b4..024ac163 100644 --- a/easytier/src/connector/tcp_hole_punch.rs +++ b/easytier/src/connector/tcp_hole_punch.rs @@ -9,7 +9,7 @@ use rand::Rng as _; use tokio::task::JoinSet; use crate::{ - common::{join_joinset_background, stun::StunInfoCollectorTrait, PeerId}, + common::{PeerId, join_joinset_background, stun::StunInfoCollectorTrait}, connector::udp_hole_punch::BackOff, peers::{ peer_manager::PeerManager, @@ -24,8 +24,8 @@ use crate::{ rpc_types::{self, controller::BaseController}, }, tunnel::{ - tcp::{TcpTunnelConnector, TcpTunnelListener}, TunnelConnector as _, TunnelListener as _, + tcp::{TcpTunnelConnector, TcpTunnelListener}, }, }; @@ -719,18 +719,20 @@ mod tests { tokio::time::sleep(Duration::from_secs(2)).await; - assert!(p_a - .get_peer_map() - .list_peer_conns(p_c.my_peer_id()) - .await - .map(|c| c.is_empty()) - .unwrap_or(true)); - assert!(p_c - .get_peer_map() - .list_peer_conns(p_a.my_peer_id()) - .await - .map(|c| c.is_empty()) - .unwrap_or(true)); + assert!( + p_a.get_peer_map() + .list_peer_conns(p_c.my_peer_id()) + .await + .map(|c| c.is_empty()) + .unwrap_or(true) + ); + assert!( + p_c.get_peer_map() + .list_peer_conns(p_a.my_peer_id()) + .await + .map(|c| c.is_empty()) + .unwrap_or(true) + ); } #[tokio::test] @@ -751,14 +753,18 @@ mod tests { connect_peer_manager(p_b.clone(), p_c.clone()).await; wait_route_appear(p_a.clone(), p_c.clone()).await.unwrap(); - assert!(!collect_lazy_punch_peers(p_a.clone()) - .await - .contains(&p_c.my_peer_id())); + assert!( + !collect_lazy_punch_peers(p_a.clone()) + .await + .contains(&p_c.my_peer_id()) + ); p_a.mark_recent_traffic(p_c.my_peer_id()); - assert!(collect_lazy_punch_peers(p_a.clone()) - .await - .contains(&p_c.my_peer_id())); + assert!( + collect_lazy_punch_peers(p_a.clone()) + .await + .contains(&p_c.my_peer_id()) + ); } } diff --git a/easytier/src/connector/udp_hole_punch/both_easy_sym.rs b/easytier/src/connector/udp_hole_punch/both_easy_sym.rs index 6db6c0d3..87f49538 100644 --- a/easytier/src/connector/udp_hole_punch/both_easy_sym.rs +++ b/easytier/src/connector/udp_hole_punch/both_easy_sym.rs @@ -8,9 +8,9 @@ use anyhow::Context; use tokio::sync::Mutex; use crate::{ - common::{scoped_task::ScopedTask, stun::StunInfoCollectorTrait, PeerId}, + common::{PeerId, scoped_task::ScopedTask, stun::StunInfoCollectorTrait}, connector::udp_hole_punch::common::{ - try_connect_with_socket, UdpHolePunchListener, HOLE_PUNCH_PACKET_BODY_LEN, + HOLE_PUNCH_PACKET_BODY_LEN, UdpHolePunchListener, try_connect_with_socket, }, connector::udp_hole_punch::handle_rpc_result, peers::peer_manager::PeerManager, @@ -21,7 +21,7 @@ use crate::{ }, rpc_types::{self, controller::BaseController}, }, - tunnel::{udp::new_hole_punch_packet, Tunnel}, + tunnel::{Tunnel, udp::new_hole_punch_packet}, }; use super::common::{PunchHoleServerCommon, UdpNatType, UdpSocketArray}; @@ -340,7 +340,7 @@ impl PunchBothEasySymHoleClient { #[cfg(test)] pub mod tests { use std::{ - sync::{atomic::AtomicU32, Arc}, + sync::{Arc, atomic::AtomicU32}, time::Duration, }; @@ -349,7 +349,7 @@ pub mod tests { use crate::connector::udp_hole_punch::RUN_TESTING; use crate::{ connector::udp_hole_punch::{ - tests::create_mock_peer_manager_with_mock_stun, UdpHolePunchConnector, + UdpHolePunchConnector, tests::create_mock_peer_manager_with_mock_stun, }, peers::tests::{connect_peer_manager, wait_route_appear}, proto::common::NatType, diff --git a/easytier/src/connector/udp_hole_punch/common.rs b/easytier/src/connector/udp_hole_punch/common.rs index 30b2620b..c99b8094 100644 --- a/easytier/src/connector/udp_hole_punch/common.rs +++ b/easytier/src/connector/udp_hole_punch/common.rs @@ -8,21 +8,21 @@ use crossbeam::atomic::AtomicCell; use dashmap::{DashMap, DashSet}; use rand::seq::SliceRandom as _; use tokio::{net::UdpSocket, sync::Mutex, task::JoinSet}; -use tracing::{instrument, Instrument, Level}; +use tracing::{Instrument, Level, instrument}; use zerocopy::FromBytes as _; use crate::{ common::{ - error::Error, global_ctx::ArcGlobalCtx, join_joinset_background, netns::NetNS, - stun::StunInfoCollectorTrait as _, PeerId, + PeerId, error::Error, global_ctx::ArcGlobalCtx, join_joinset_background, netns::NetNS, + stun::StunInfoCollectorTrait as _, }, defer, peers::peer_manager::PeerManager, proto::common::NatType, tunnel::{ - packet_def::{UDPTunnelHeader, UdpPacketType, UDP_TUNNEL_HEADER_SIZE}, - udp::{new_hole_punch_packet, UdpTunnelConnector, UdpTunnelListener}, Tunnel, TunnelConnCounter, TunnelListener as _, + packet_def::{UDP_TUNNEL_HEADER_SIZE, UDPTunnelHeader, UdpPacketType}, + udp::{UdpTunnelConnector, UdpTunnelListener, new_hole_punch_packet}, }, }; diff --git a/easytier/src/connector/udp_hole_punch/cone.rs b/easytier/src/connector/udp_hole_punch/cone.rs index 69b2d761..a88eb5c7 100644 --- a/easytier/src/connector/udp_hole_punch/cone.rs +++ b/easytier/src/connector/udp_hole_punch/cone.rs @@ -7,9 +7,9 @@ use anyhow::Context; use tokio::net::UdpSocket; use crate::{ - common::{scoped_task::ScopedTask, stun::StunInfoCollectorTrait, PeerId}, + common::{PeerId, scoped_task::ScopedTask, stun::StunInfoCollectorTrait}, connector::udp_hole_punch::common::{ - try_connect_with_socket, UdpSocketArray, HOLE_PUNCH_PACKET_BODY_LEN, + HOLE_PUNCH_PACKET_BODY_LEN, UdpSocketArray, try_connect_with_socket, }, connector::udp_hole_punch::handle_rpc_result, peers::peer_manager::PeerManager, @@ -20,7 +20,7 @@ use crate::{ }, rpc_types::{self, controller::BaseController}, }, - tunnel::{udp::new_hole_punch_packet, Tunnel}, + tunnel::{Tunnel, udp::new_hole_punch_packet}, }; use super::common::PunchHoleServerCommon; @@ -249,7 +249,7 @@ pub mod tests { use crate::{ connector::udp_hole_punch::{ - tests::create_mock_peer_manager_with_mock_stun, UdpHolePunchConnector, + UdpHolePunchConnector, tests::create_mock_peer_manager_with_mock_stun, }, peers::tests::{connect_peer_manager, wait_route_appear, wait_route_appear_with_cost}, proto::common::NatType, diff --git a/easytier/src/connector/udp_hole_punch/mod.rs b/easytier/src/connector/udp_hole_punch/mod.rs index 66197d01..779d428b 100644 --- a/easytier/src/connector/udp_hole_punch/mod.rs +++ b/easytier/src/connector/udp_hole_punch/mod.rs @@ -1,5 +1,5 @@ use std::{ - sync::{atomic::AtomicBool, Arc}, + sync::{Arc, atomic::AtomicBool}, time::{Duration, Instant}, }; @@ -13,7 +13,7 @@ use sym_to_cone::{PunchSymToConeHoleClient, PunchSymToConeHoleServer}; use tokio::{sync::Mutex, task::JoinHandle}; use crate::{ - common::{stun::StunInfoCollectorTrait, PeerId}, + common::{PeerId, stun::StunInfoCollectorTrait}, peers::{ peer_manager::PeerManager, peer_task::{PeerTaskLauncher, PeerTaskManager}, @@ -601,7 +601,7 @@ pub mod tests { use crate::proto::common::NatType; use crate::tunnel::common::tests::wait_for_condition; - use super::{UdpHolePunchConnector, UdpHolePunchPeerTaskLauncher, RUN_TESTING}; + use super::{RUN_TESTING, UdpHolePunchConnector, UdpHolePunchPeerTaskLauncher}; pub fn replace_stun_info_collector(peer_mgr: Arc, udp_nat_type: NatType) { let collector = Box::new(MockStunInfoCollector { udp_nat_type }); @@ -676,14 +676,18 @@ pub mod tests { connect_peer_manager(p_b.clone(), p_c.clone()).await; wait_route_appear(p_a.clone(), p_c.clone()).await.unwrap(); - assert!(!collect_lazy_punch_peers(p_a.clone()) - .await - .contains(&p_c.my_peer_id())); + assert!( + !collect_lazy_punch_peers(p_a.clone()) + .await + .contains(&p_c.my_peer_id()) + ); p_a.mark_recent_traffic(p_c.my_peer_id()); - assert!(collect_lazy_punch_peers(p_a.clone()) - .await - .contains(&p_c.my_peer_id())); + assert!( + collect_lazy_punch_peers(p_a.clone()) + .await + .contains(&p_c.my_peer_id()) + ); } } diff --git a/easytier/src/connector/udp_hole_punch/sym_to_cone.rs b/easytier/src/connector/udp_hole_punch/sym_to_cone.rs index c66bc531..fc8973b4 100644 --- a/easytier/src/connector/udp_hole_punch/sym_to_cone.rs +++ b/easytier/src/connector/udp_hole_punch/sym_to_cone.rs @@ -2,24 +2,24 @@ use std::{ net::Ipv4Addr, ops::{Div, Mul}, sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }, time::{Duration, Instant}, }; use anyhow::Context; -use rand::{seq::SliceRandom, Rng}; +use rand::{Rng, seq::SliceRandom}; use tokio::{net::UdpSocket, sync::RwLock}; use tracing::Level; use crate::{ common::{ - global_ctx::ArcGlobalCtx, scoped_task::ScopedTask, stun::StunInfoCollectorTrait, PeerId, + PeerId, global_ctx::ArcGlobalCtx, scoped_task::ScopedTask, stun::StunInfoCollectorTrait, }, connector::udp_hole_punch::{ common::{ - send_symmetric_hole_punch_packet, try_connect_with_socket, HOLE_PUNCH_PACKET_BODY_LEN, + HOLE_PUNCH_PACKET_BODY_LEN, send_symmetric_hole_punch_packet, try_connect_with_socket, }, handle_rpc_result, }, @@ -33,7 +33,7 @@ use crate::{ }, rpc_types::{self, controller::BaseController}, }, - tunnel::{udp::new_hole_punch_packet, Tunnel}, + tunnel::{Tunnel, udp::new_hole_punch_packet}, }; use super::common::{PunchHoleServerCommon, UdpNatType, UdpSocketArray}; @@ -445,16 +445,15 @@ impl PunchSymToConeHoleClient { ))?; // try direct connect first - if self.try_direct_connect.load(Ordering::Relaxed) { - if let Ok(tunnel) = try_connect_with_socket( + if self.try_direct_connect.load(Ordering::Relaxed) + && let Ok(tunnel) = try_connect_with_socket( global_ctx.clone(), Arc::new(UdpSocket::bind("0.0.0.0:0").await?), remote_mapped_addr.into(), ) .await - { - return Ok(Some(tunnel)); - } + { + return Ok(Some(tunnel)); } let stun_info = global_ctx.get_stun_info_collector().get_stun_info(); @@ -467,7 +466,7 @@ impl PunchSymToConeHoleClient { return Err(anyhow::anyhow!("failed to get public ips")); } - let tid = rand::thread_rng().gen(); + let tid = rand::thread_rng().r#gen(); let packet = new_hole_punch_packet(tid, HOLE_PUNCH_PACKET_BODY_LEN).into_bytes(); udp_array.add_intreast_tid(tid); defer! { udp_array.remove_intreast_tid(tid);} @@ -544,7 +543,7 @@ impl PunchSymToConeHoleClient { #[cfg(test)] pub mod tests { use std::{ - sync::{atomic::AtomicU32, Arc}, + sync::{Arc, atomic::AtomicU32}, time::Duration, }; @@ -552,7 +551,7 @@ pub mod tests { use crate::{ connector::udp_hole_punch::{ - tests::create_mock_peer_manager_with_mock_stun, UdpHolePunchConnector, RUN_TESTING, + RUN_TESTING, UdpHolePunchConnector, tests::create_mock_peer_manager_with_mock_stun, }, peers::tests::{connect_peer_manager, wait_route_appear, wait_route_appear_with_cost}, proto::common::NatType, @@ -617,7 +616,7 @@ pub mod tests { .await .is_ok() }, - Duration::from_secs(30), + Duration::from_secs(60), ) .await; println!("{:?}", p_a.list_routes().await); diff --git a/easytier/src/core.rs b/easytier/src/core.rs index 4f01f805..44f667d1 100644 --- a/easytier/src/core.rs +++ b/easytier/src/core.rs @@ -4,15 +4,16 @@ use std::{ net::{IpAddr, SocketAddr}, path::PathBuf, process::ExitCode, - sync::{atomic::AtomicBool, Arc}, + sync::{Arc, atomic::AtomicBool}, }; use crate::{ + ShellType, common::{ config::{ - load_config_from_file, process_secure_mode_cfg, ConfigFileControl, ConfigLoader, - ConsoleLoggerConfig, EncryptionAlgorithm, FileLoggerConfig, LoggingConfigLoader, - NetworkIdentity, PeerConfig, PortForwardConfig, TomlConfigLoader, VpnPortalConfig, + ConfigFileControl, ConfigLoader, ConsoleLoggerConfig, EncryptionAlgorithm, + FileLoggerConfig, LoggingConfigLoader, NetworkIdentity, PeerConfig, PortForwardConfig, + TomlConfigLoader, VpnPortalConfig, load_config_from_file, process_secure_mode_cfg, }, constants::EASYTIER_VERSION, log, @@ -23,7 +24,7 @@ use crate::{ proto::common::{CompressionAlgoPb, SecureModeConfig}, rpc_service::ApiRpcServer, utils::setup_panic_handler, - web_client, ShellType, + web_client, }; use anyhow::Context; use cidr::IpCidr; @@ -34,7 +35,7 @@ use tokio::io::AsyncReadExt; use crate::tunnel::IpScheme; #[cfg(feature = "jemalloc-prof")] -use jemalloc_ctl::{epoch, stats, Access as _, AsName as _}; +use jemalloc_ctl::{Access as _, AsName as _, epoch, stats}; #[cfg(target_os = "windows")] windows_service::define_windows_service!(ffi_service_main, win_service_main); @@ -741,17 +742,17 @@ impl Cli { let origin_listeners = listeners; let mut listeners: Vec = Vec::new(); - if origin_listeners.len() == 1 { - if let Ok(port) = origin_listeners[0].parse::() { - for proto in IpScheme::VARIANTS { - listeners.push(format!( - "{}://0.0.0.0:{}", - proto, - port + proto.port_offset() - )); - } - return Ok(listeners); + if origin_listeners.len() == 1 + && let Ok(port) = origin_listeners[0].parse::() + { + for proto in IpScheme::VARIANTS { + listeners.push(format!( + "{}://0.0.0.0:{}", + proto, + port + proto.port_offset() + )); } + return Ok(listeners); } for l in &origin_listeners { @@ -994,15 +995,15 @@ impl NetworkOptions { local_public_key: None, }; cfg.set_secure_mode(Some(process_secure_mode_cfg(c)?)); - } else if let Some(secure_mode) = self.secure_mode { - if secure_mode { - let c = SecureModeConfig { - enabled: secure_mode, - local_private_key: self.local_private_key.clone(), - local_public_key: self.local_public_key.clone(), - }; - cfg.set_secure_mode(Some(process_secure_mode_cfg(c)?)); - } + } else if let Some(secure_mode) = self.secure_mode + && secure_mode + { + let c = SecureModeConfig { + enabled: secure_mode, + local_private_key: self.local_private_key.clone(), + local_public_key: self.local_public_key.clone(), + }; + cfg.set_secure_mode(Some(process_secure_mode_cfg(c)?)); } let mut f = cfg.get_flags(); @@ -1134,7 +1135,7 @@ impl LoggingConfigLoader for &LoggingOptions { #[cfg(target_os = "windows")] fn win_service_set_work_dir(service_name: &std::ffi::OsString) -> anyhow::Result<()> { use crate::common::constants::WIN_SERVICE_WORK_DIR_REG_KEY; - use winreg::{enums::*, RegKey}; + use winreg::{RegKey, enums::*}; let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); let key = hklm.open_subkey_with_flags(WIN_SERVICE_WORK_DIR_REG_KEY, KEY_READ)?; diff --git a/easytier/src/easytier-cli.rs b/easytier/src/easytier-cli.rs index f4555f1f..af55343d 100644 --- a/easytier/src/easytier-cli.rs +++ b/easytier/src/easytier-cli.rs @@ -12,8 +12,8 @@ use std::{ }; use anyhow::Context; -use base64::prelude::BASE64_STANDARD; use base64::Engine as _; +use base64::prelude::BASE64_STANDARD; use cidr::Ipv4Inet; use clap::{Args, CommandFactory, Parser, Subcommand}; use dashmap::DashMap; @@ -21,8 +21,8 @@ use easytier::ShellType; use humansize::format_size; use rust_i18n::t; use service_manager::*; -use tabled::settings::{location::ByColumnName, object::Columns, Disable, Modify, Style, Width}; -use terminal_size::{terminal_size, Width as TerminalWidth}; +use tabled::settings::{Disable, Modify, Style, Width, location::ByColumnName, object::Columns}; +use terminal_size::{Width as TerminalWidth, terminal_size}; use unicode_width::UnicodeWidthStr; use easytier::service_manager::{Service, ServiceInstallOptions}; @@ -42,9 +42,7 @@ use easytier::{ InstanceConfigPatch, PatchConfigRequest, PortForwardPatch, StringPatch, UrlPatch, }, instance::{ - instance_identifier::{InstanceSelector, Selector}, - list_global_foreign_network_response, list_peer_route_pair, AclManageRpc, - AclManageRpcClientFactory, Connector, ConnectorManageRpc, + AclManageRpc, AclManageRpcClientFactory, Connector, ConnectorManageRpc, ConnectorManageRpcClientFactory, CredentialManageRpc, CredentialManageRpcClientFactory, DumpRouteRequest, ForeignNetworkEntryPb, GenerateCredentialRequest, GetAclStatsRequest, GetPrometheusStatsRequest, @@ -60,6 +58,8 @@ use easytier::{ StatsRpc, StatsRpcClientFactory, TcpProxyEntryState, TcpProxyEntryTransportType, TcpProxyRpc, TcpProxyRpcClientFactory, TrustedKeySourcePb, VpnPortalInfo, VpnPortalRpc, VpnPortalRpcClientFactory, + instance_identifier::{InstanceSelector, Selector}, + list_global_foreign_network_response, list_peer_route_pair, }, logger::{ GetLoggerConfigRequest, LogLevel, LoggerRpc, LoggerRpcClientFactory, @@ -75,8 +75,8 @@ use easytier::{ rpc_impl::standalone::StandAloneClient, rpc_types::controller::BaseController, }, - tunnel::{tcp::TcpTunnelConnector, TunnelScheme}, - utils::{cost_to_str, PeerRoutePair}, + tunnel::{TunnelScheme, tcp::TcpTunnelConnector}, + utils::{PeerRoutePair, cost_to_str}, }; rust_i18n::i18n!("locales", fallback = "en"); @@ -1972,7 +1972,12 @@ impl<'a> CommandHandler<'a> { "info" => LogLevel::Info, "debug" => LogLevel::Debug, "trace" => LogLevel::Trace, - _ => return Err(anyhow::anyhow!("Invalid log level: {}. Valid levels are: disabled, error, warning, info, debug, trace", level)), + _ => { + return Err(anyhow::anyhow!( + "Invalid log level: {}. Valid levels are: disabled, error, warning, info, debug, trace", + level + )); + } }; let client = self.get_logger_client().await?; @@ -2497,10 +2502,9 @@ fn header_indices(headers: &[String], names: &[&str]) -> Vec { if let Some(index) = headers .iter() .position(|header| header.eq_ignore_ascii_case(name)) + && !indices.contains(&index) { - if !indices.contains(&index) { - indices.push(index); - } + indices.push(index); } } indices diff --git a/easytier/src/easytier-core.rs b/easytier/src/easytier-core.rs index 656b138a..03cf30b4 100644 --- a/easytier/src/easytier-core.rs +++ b/easytier/src/easytier-core.rs @@ -13,12 +13,12 @@ static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc; #[cfg(feature = "jemalloc-prof")] #[allow(non_upper_case_globals)] -#[export_name = "malloc_conf"] +#[unsafe(export_name = "malloc_conf")] pub static malloc_conf: &[u8] = b"prof:true,prof_active:true,lg_prof_sample:19,retain:false\0"; #[cfg(not(feature = "jemalloc-prof"))] #[allow(non_upper_case_globals)] -#[export_name = "malloc_conf"] +#[unsafe(export_name = "malloc_conf")] pub static malloc_conf: &[u8] = b"retain:false\0"; rust_i18n::i18n!("locales", fallback = "en"); diff --git a/easytier/src/gateway/fast_socks5/mod.rs b/easytier/src/gateway/fast_socks5/mod.rs index 73e32e87..424f0816 100644 --- a/easytier/src/gateway/fast_socks5/mod.rs +++ b/easytier/src/gateway/fast_socks5/mod.rs @@ -46,9 +46,9 @@ use anyhow::Context; use std::fmt; use std::io; use thiserror::Error; -use util::target_addr::read_address; use util::target_addr::TargetAddr; use util::target_addr::ToTargetAddr; +use util::target_addr::read_address; use tokio::io::AsyncReadExt; diff --git a/easytier/src/gateway/fast_socks5/server.rs b/easytier/src/gateway/fast_socks5/server.rs index 82e7d52d..5eea5aaf 100644 --- a/easytier/src/gateway/fast_socks5/server.rs +++ b/easytier/src/gateway/fast_socks5/server.rs @@ -1,10 +1,10 @@ +use super::Socks5Command; use super::new_udp_header; use super::parse_udp_request; use super::read_exact; use super::util::stream::tcp_connect_with_timeout; -use super::util::target_addr::{read_address, TargetAddr}; -use super::Socks5Command; -use super::{consts, AuthenticationMethod, ReplyError, Result, SocksError}; +use super::util::target_addr::{TargetAddr, read_address}; +use super::{AuthenticationMethod, ReplyError, Result, SocksError, consts}; use anyhow::Context; use std::io; use std::net::IpAddr; diff --git a/easytier/src/gateway/fast_socks5/util/target_addr.rs b/easytier/src/gateway/fast_socks5/util/target_addr.rs index c0ac8e0c..76833a2c 100644 --- a/easytier/src/gateway/fast_socks5/util/target_addr.rs +++ b/easytier/src/gateway/fast_socks5/util/target_addr.rs @@ -1,6 +1,6 @@ +use crate::gateway::fast_socks5::SocksError; use crate::gateway::fast_socks5::consts; use crate::gateway::fast_socks5::consts::SOCKS5_ADDR_TYPE_IPV4; -use crate::gateway::fast_socks5::SocksError; use crate::read_exact; use anyhow::Context; @@ -99,7 +99,7 @@ impl TargetAddr { buf.extend_from_slice(&(addr.ip()).octets()); // ip buf.extend_from_slice(&addr.port().to_be_bytes()); // port } - TargetAddr::Domain(ref domain, port) => { + TargetAddr::Domain(domain, port) => { debug!("TargetAddr::Domain"); if domain.len() > u8::MAX as usize { return Err(SocksError::ExceededMaxDomainLen(domain.len()).into()); diff --git a/easytier/src/gateway/icmp_proxy.rs b/easytier/src/gateway/icmp_proxy.rs index 40ad3485..0e0182d2 100644 --- a/easytier/src/gateway/icmp_proxy.rs +++ b/easytier/src/gateway/icmp_proxy.rs @@ -8,29 +8,29 @@ use std::{ use anyhow::Context; use pnet::packet::{ - icmp::{self, echo_reply::MutableEchoReplyPacket, IcmpCode, IcmpTypes, MutableIcmpPacket}, + Packet, + icmp::{self, IcmpCode, IcmpTypes, MutableIcmpPacket, echo_reply::MutableEchoReplyPacket}, ip::IpNextHeaderProtocols, ipv4::Ipv4Packet, - Packet, }; use socket2::Socket; use tokio::{ - sync::{mpsc::UnboundedSender, Mutex}, + sync::{Mutex, mpsc::UnboundedSender}, task::JoinSet, }; use tracing::Instrument; use crate::{ - common::{error::Error, global_ctx::ArcGlobalCtx, PeerId}, + common::{PeerId, error::Error, global_ctx::ArcGlobalCtx}, gateway::ip_reassembler::ComposeIpv4PacketArgs, - peers::{peer_manager::PeerManager, PeerPacketFilter}, + peers::{PeerPacketFilter, peer_manager::PeerManager}, tunnel::packet_def::{PacketType, ZCPacket}, }; use super::{ - ip_reassembler::{compose_ipv4_packet, IpReassembler}, CidrSet, + ip_reassembler::{IpReassembler, compose_ipv4_packet}, }; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] diff --git a/easytier/src/gateway/ip_reassembler.rs b/easytier/src/gateway/ip_reassembler.rs index be579d7c..543429aa 100644 --- a/easytier/src/gateway/ip_reassembler.rs +++ b/easytier/src/gateway/ip_reassembler.rs @@ -1,7 +1,7 @@ use dashmap::DashMap; +use pnet::packet::Packet; use pnet::packet::ip::IpNextHeaderProtocol; use pnet::packet::ipv4::{self, Ipv4Flags, Ipv4Packet, MutableIpv4Packet}; -use pnet::packet::Packet; use std::net::Ipv4Addr; use std::time::{Duration, Instant}; @@ -45,13 +45,25 @@ impl IpPacket { // make sure the fragment doesn't overlap with existing fragments for f in &self.fragments { if f.offset <= fragment.offset && fragment.offset < f.offset + f.data.len() as u16 { - tracing::trace!("fragment overlap 1, f.offset = {}, fragment.offset = {}, f.data.len() = {}, fragment.data.len() = {}", f.offset, fragment.offset, f.data.len(), fragment.data.len()); + tracing::trace!( + "fragment overlap 1, f.offset = {}, fragment.offset = {}, f.data.len() = {}, fragment.data.len() = {}", + f.offset, + fragment.offset, + f.data.len(), + fragment.data.len() + ); return; } if fragment.offset <= f.offset && f.offset < fragment.offset + fragment.data.len() as u16 { - tracing::trace!("fragment overlap 2, f.offset = {}, fragment.offset = {}, f.data.len() = {}, fragment.data.len() = {}", f.offset, fragment.offset, f.data.len(), fragment.data.len()); + tracing::trace!( + "fragment overlap 2, f.offset = {}, fragment.offset = {}, f.data.len() = {}, fragment.data.len() = {}", + f.offset, + fragment.offset, + f.data.len(), + fragment.data.len() + ); return; } } diff --git a/easytier/src/gateway/kcp_proxy.rs b/easytier/src/gateway/kcp_proxy.rs index 37ddbab7..53dbbbfa 100644 --- a/easytier/src/gateway/kcp_proxy.rs +++ b/easytier/src/gateway/kcp_proxy.rs @@ -17,8 +17,8 @@ use prost::Message; use tokio::{select, task::JoinSet}; use super::{ - tcp_proxy::{NatDstConnector, NatDstTcpConnector, TcpProxy}, CidrSet, + tcp_proxy::{NatDstConnector, NatDstTcpConnector, TcpProxy}, }; use crate::{ common::{ @@ -27,7 +27,7 @@ use crate::{ global_ctx::{ArcGlobalCtx, GlobalCtx}, }, gateway::wrapped_proxy::{ProxyAclHandler, TcpProxyForWrappedSrcTrait}, - peers::{peer_manager::PeerManager, PeerPacketFilter}, + peers::{PeerPacketFilter, peer_manager::PeerManager}, proto::{ acl::{ChainType, Protocol}, api::instance::{ diff --git a/easytier/src/gateway/quic_proxy.rs b/easytier/src/gateway/quic_proxy.rs index 4178cc03..743a9b88 100644 --- a/easytier/src/gateway/quic_proxy.rs +++ b/easytier/src/gateway/quic_proxy.rs @@ -1,11 +1,11 @@ +use crate::common::PeerId; use crate::common::acl_processor::PacketInfo; use crate::common::global_ctx::{ArcGlobalCtx, GlobalCtx}; -use crate::common::PeerId; +use crate::gateway::CidrSet; use crate::gateway::tcp_proxy::{NatDstConnector, TcpProxy}; use crate::gateway::wrapped_proxy::{ProxyAclHandler, TcpProxyForWrappedSrcTrait}; -use crate::gateway::CidrSet; -use crate::peers::peer_manager::PeerManager; use crate::peers::PeerPacketFilter; +use crate::peers::peer_manager::PeerManager; use crate::proto::acl::{ChainType, Protocol}; use crate::proto::api::instance::{ ListTcpProxyEntryRequest, ListTcpProxyEntryResponse, TcpProxyEntry, TcpProxyEntryState, @@ -15,10 +15,10 @@ use crate::proto::peer_rpc::KcpConnData as QuicConnData; use crate::proto::rpc_types; use crate::proto::rpc_types::controller::BaseController; use crate::tunnel::packet_def::{ - PacketType, PeerManagerHeader, ZCPacket, ZCPacketType, TAIL_RESERVED_SIZE, + PacketType, PeerManagerHeader, TAIL_RESERVED_SIZE, ZCPacket, ZCPacketType, }; use crate::tunnel::quic::{client_config, endpoint_config, server_config}; -use anyhow::{anyhow, Context, Error}; +use anyhow::{Context, Error, anyhow}; use atomic_refcell::AtomicRefCell; use bytes::{BufMut, Bytes, BytesMut}; use dashmap::DashMap; @@ -36,11 +36,11 @@ use std::ptr::copy_nonoverlapping; use std::sync::{Arc, Weak}; use std::task::Poll; use std::time::Duration; -use tokio::io::{join, AsyncReadExt, Join}; +use tokio::io::{AsyncReadExt, Join, join}; use tokio::sync::mpsc::error::TrySendError; -use tokio::sync::mpsc::{channel, Receiver, Sender}; +use tokio::sync::mpsc::{Receiver, Sender, channel}; use tokio::task::JoinSet; -use tokio::time::{timeout, Instant}; +use tokio::time::{Instant, timeout}; use tokio::{join, pin, select}; use tokio_util::sync::PollSender; use tracing::{debug, error, info, instrument, trace, warn}; @@ -174,9 +174,7 @@ impl AsyncUdpSocket for QuicSocket { } trace!( "{:?} received {:?} bytes from {:?}", - self.addr, - len, - packet.addr + self.addr, len, packet.addr ); buf[0..len].copy_from_slice(&packet.payload); *meta = RecvMeta { @@ -193,7 +191,7 @@ impl AsyncUdpSocket for QuicSocket { return Poll::Ready(Err(std::io::Error::new( std::io::ErrorKind::ConnectionAborted, "socket closed", - ))) + ))); } Poll::Pending => break, } @@ -1250,7 +1248,7 @@ mod tests { // We agree that the first byte of data is (stream_index % 255) // This ensures stream data is not mixed let expected_byte = data[0] as usize; // Get the actual received marker - // Simple check of head and tail here, CRC can be used in production + // Simple check of head and tail here, CRC can be used in production if data[data.len() - 1] != data[0] { panic!("Stream data corruption"); } diff --git a/easytier/src/gateway/socks5.rs b/easytier/src/gateway/socks5.rs index ff31c4e9..7b19ffff 100644 --- a/easytier/src/gateway/socks5.rs +++ b/easytier/src/gateway/socks5.rs @@ -2,8 +2,8 @@ use std::{ any::Any, net::{IpAddr, Ipv4Addr, SocketAddr}, sync::{ - atomic::{AtomicBool, AtomicUsize, Ordering}, Arc, Weak, + atomic::{AtomicBool, AtomicUsize, Ordering}, }, time::{Duration, Instant}, }; @@ -28,7 +28,7 @@ use crate::{ util::stream::tcp_connect_with_timeout, }, ip_reassembler::IpReassembler, - tokio_smoltcp::{channel_device, BufferSize, Net, NetConfig}, + tokio_smoltcp::{BufferSize, Net, NetConfig, channel_device}, }, tunnel::{ common::setup_sokcet2, @@ -38,20 +38,20 @@ use crate::{ use anyhow::Context; use dashmap::DashMap; use pnet::packet::{ - ip::IpNextHeaderProtocols, ipv4::Ipv4Packet, tcp::TcpPacket, udp::UdpPacket, Packet, + Packet, ip::IpNextHeaderProtocols, ipv4::Ipv4Packet, tcp::TcpPacket, udp::UdpPacket, }; use tokio::{ io::{AsyncRead, AsyncWrite}, net::{TcpListener, TcpSocket, UdpSocket}, select, - sync::{mpsc, Mutex, Notify}, + sync::{Mutex, Notify, mpsc}, task::JoinSet, time::timeout, }; use crate::{ common::{error::Error, global_ctx::GlobalCtx}, - peers::{peer_manager::PeerManager, PeerPacketFilter}, + peers::{PeerPacketFilter, peer_manager::PeerManager}, }; #[cfg(feature = "kcp")] @@ -92,12 +92,10 @@ impl AsyncRead for SocksTcpStream { buf: &mut tokio::io::ReadBuf<'_>, ) -> std::task::Poll> { match self.get_mut() { - SocksTcpStream::Tcp(ref mut stream) => std::pin::Pin::new(stream).poll_read(cx, buf), - SocksTcpStream::SmolTcp(ref mut stream) => { - std::pin::Pin::new(stream).poll_read(cx, buf) - } + SocksTcpStream::Tcp(stream) => std::pin::Pin::new(stream).poll_read(cx, buf), + SocksTcpStream::SmolTcp(stream) => std::pin::Pin::new(stream).poll_read(cx, buf), #[cfg(feature = "kcp")] - SocksTcpStream::Kcp(ref mut stream) => std::pin::Pin::new(stream).poll_read(cx, buf), + SocksTcpStream::Kcp(stream) => std::pin::Pin::new(stream).poll_read(cx, buf), } } } @@ -109,12 +107,10 @@ impl AsyncWrite for SocksTcpStream { buf: &[u8], ) -> std::task::Poll> { match self.get_mut() { - SocksTcpStream::Tcp(ref mut stream) => std::pin::Pin::new(stream).poll_write(cx, buf), - SocksTcpStream::SmolTcp(ref mut stream) => { - std::pin::Pin::new(stream).poll_write(cx, buf) - } + SocksTcpStream::Tcp(stream) => std::pin::Pin::new(stream).poll_write(cx, buf), + SocksTcpStream::SmolTcp(stream) => std::pin::Pin::new(stream).poll_write(cx, buf), #[cfg(feature = "kcp")] - SocksTcpStream::Kcp(ref mut stream) => std::pin::Pin::new(stream).poll_write(cx, buf), + SocksTcpStream::Kcp(stream) => std::pin::Pin::new(stream).poll_write(cx, buf), } } @@ -123,10 +119,10 @@ impl AsyncWrite for SocksTcpStream { cx: &mut std::task::Context<'_>, ) -> std::task::Poll> { match self.get_mut() { - SocksTcpStream::Tcp(ref mut stream) => std::pin::Pin::new(stream).poll_flush(cx), - SocksTcpStream::SmolTcp(ref mut stream) => std::pin::Pin::new(stream).poll_flush(cx), + SocksTcpStream::Tcp(stream) => std::pin::Pin::new(stream).poll_flush(cx), + SocksTcpStream::SmolTcp(stream) => std::pin::Pin::new(stream).poll_flush(cx), #[cfg(feature = "kcp")] - SocksTcpStream::Kcp(ref mut stream) => std::pin::Pin::new(stream).poll_flush(cx), + SocksTcpStream::Kcp(stream) => std::pin::Pin::new(stream).poll_flush(cx), } } @@ -135,10 +131,10 @@ impl AsyncWrite for SocksTcpStream { cx: &mut std::task::Context<'_>, ) -> std::task::Poll> { match self.get_mut() { - SocksTcpStream::Tcp(ref mut stream) => std::pin::Pin::new(stream).poll_shutdown(cx), - SocksTcpStream::SmolTcp(ref mut stream) => std::pin::Pin::new(stream).poll_shutdown(cx), + SocksTcpStream::Tcp(stream) => std::pin::Pin::new(stream).poll_shutdown(cx), + SocksTcpStream::SmolTcp(stream) => std::pin::Pin::new(stream).poll_shutdown(cx), #[cfg(feature = "kcp")] - SocksTcpStream::Kcp(ref mut stream) => std::pin::Pin::new(stream).poll_shutdown(cx), + SocksTcpStream::Kcp(stream) => std::pin::Pin::new(stream).poll_shutdown(cx), } } } @@ -284,10 +280,10 @@ impl AsyncTcpConnector for Socks5AutoConnector { return Err(anyhow::anyhow!("peer manager is dropped").into()); }; - if let Some(local_addr) = self.smoltcp_net.as_ref().map(|n| n.get_address()) { - if local_addr == addr.ip() { - addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), addr.port()); - } + if let Some(local_addr) = self.smoltcp_net.as_ref().map(|n| n.get_address()) + && local_addr == addr.ip() + { + addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), addr.port()); } if self.smoltcp_net.is_none() @@ -805,7 +801,8 @@ impl Socks5Server { Ok((from_client, from_server)) => { tracing::info!( "port forward connection finished: client->server: {} bytes, server->client: {} bytes", - from_client, from_server + from_client, + from_server ); } Err(e) => { diff --git a/easytier/src/gateway/tcp_proxy.rs b/easytier/src/gateway/tcp_proxy.rs index b4095c19..3b4075c6 100644 --- a/easytier/src/gateway/tcp_proxy.rs +++ b/easytier/src/gateway/tcp_proxy.rs @@ -3,19 +3,19 @@ use cidr::Ipv4Inet; use core::panic; use crossbeam::atomic::AtomicCell; use dashmap::DashMap; -use pnet::packet::ip::IpNextHeaderProtocols; -use pnet::packet::ipv4::{Ipv4Packet, MutableIpv4Packet}; -use pnet::packet::tcp::{ipv4_checksum, MutableTcpPacket, TcpPacket}; use pnet::packet::MutablePacket; use pnet::packet::Packet; +use pnet::packet::ip::IpNextHeaderProtocols; +use pnet::packet::ipv4::{Ipv4Packet, MutableIpv4Packet}; +use pnet::packet::tcp::{MutableTcpPacket, TcpPacket, ipv4_checksum}; use socket2::{SockRef, TcpKeepalive}; use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4}; use std::sync::atomic::{AtomicBool, AtomicU16}; use std::sync::{Arc, Weak}; use std::time::{Duration, Instant}; -use tokio::io::{copy_bidirectional, AsyncRead, AsyncWrite, AsyncWriteExt}; +use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt, copy_bidirectional}; use tokio::net::{TcpListener, TcpSocket, TcpStream}; -use tokio::sync::{mpsc, Mutex}; +use tokio::sync::{Mutex, mpsc}; use tokio::task::JoinSet; use tokio::time::timeout; use tracing::Instrument; @@ -38,7 +38,7 @@ use crate::tunnel::packet_def::{PacketType, PeerManagerHeader, ZCPacket}; use super::CidrSet; #[cfg(feature = "smoltcp")] -use super::tokio_smoltcp::{self, channel_device, Net, NetConfig}; +use super::tokio_smoltcp::{self, Net, NetConfig, channel_device}; #[async_trait::async_trait] pub(crate) trait NatDstConnector: Send + Sync + Clone + 'static { @@ -347,10 +347,10 @@ impl PeerPacketFilter for TcpProxy { if let Err(e) = smoltcp_stack_sender.try_send(packet) { tracing::error!("send to smoltcp stack failed: {:?}", e); } - } else if let Some(peer_manager) = self.get_peer_manager() { - if let Err(e) = peer_manager.get_nic_channel().send(packet).await { - tracing::error!("send to nic failed: {:?}", e); - } + } else if let Some(peer_manager) = self.get_peer_manager() + && let Err(e) = peer_manager.get_nic_channel().send(packet).await + { + tracing::error!("send to nic failed: {:?}", e); } return None; } else { diff --git a/easytier/src/gateway/tokio_smoltcp/channel_device.rs b/easytier/src/gateway/tokio_smoltcp/channel_device.rs index 1285780c..b643bc49 100644 --- a/easytier/src/gateway/tokio_smoltcp/channel_device.rs +++ b/easytier/src/gateway/tokio_smoltcp/channel_device.rs @@ -5,7 +5,7 @@ use std::{ pin::Pin, task::{Context, Poll}, }; -use tokio::sync::mpsc::{channel, Receiver, Sender}; +use tokio::sync::mpsc::{Receiver, Sender, channel}; use tokio_util::sync::{PollSendError, PollSender}; use super::device::AsyncDevice; diff --git a/easytier/src/gateway/tokio_smoltcp/mod.rs b/easytier/src/gateway/tokio_smoltcp/mod.rs index 011edc14..302496fd 100644 --- a/easytier/src/gateway/tokio_smoltcp/mod.rs +++ b/easytier/src/gateway/tokio_smoltcp/mod.rs @@ -6,8 +6,8 @@ use std::{ io, net::{IpAddr, SocketAddr}, sync::{ - atomic::{AtomicU16, Ordering}, Arc, + atomic::{AtomicU16, Ordering}, }, }; diff --git a/easytier/src/gateway/tokio_smoltcp/reactor.rs b/easytier/src/gateway/tokio_smoltcp/reactor.rs index b28f5064..21a735ef 100644 --- a/easytier/src/gateway/tokio_smoltcp/reactor.rs +++ b/easytier/src/gateway/tokio_smoltcp/reactor.rs @@ -2,7 +2,7 @@ use super::{ device::{BufferDevice, Packet}, socket_allocator::{BufferSize, SocketAlloctor}, }; -use futures::{stream::iter, FutureExt, SinkExt, StreamExt}; +use futures::{FutureExt, SinkExt, StreamExt, stream::iter}; use parking_lot::{MappedMutexGuard, Mutex, MutexGuard}; use smoltcp::{ iface::{Context, Interface, SocketHandle}, @@ -92,10 +92,10 @@ async fn run( // wake up all closed sockets (smoltcp seems have a bug that it doesn't wake up closed sockets) for (_, socket) in socket_allocator.sockets().lock().iter_mut() { - if let Socket::Tcp(tcp) = socket { - if tcp.state() == smoltcp::socket::tcp::State::Closed { - tcp.abort(); - } + if let Socket::Tcp(tcp) = socket + && tcp.state() == smoltcp::socket::tcp::State::Closed + { + tcp.abort(); } } } diff --git a/easytier/src/gateway/tokio_smoltcp/socket.rs b/easytier/src/gateway/tokio_smoltcp/socket.rs index 1ff64ee6..f36e4bc3 100644 --- a/easytier/src/gateway/tokio_smoltcp/socket.rs +++ b/easytier/src/gateway/tokio_smoltcp/socket.rs @@ -1,6 +1,6 @@ use super::{reactor::Reactor, socket_allocator::SocketHandle}; use futures::future::{self, poll_fn}; -use futures::{ready, Stream}; +use futures::{Stream, ready}; pub use smoltcp::socket::tcp; use smoltcp::socket::udp; use smoltcp::wire::{IpAddress, IpEndpoint}; diff --git a/easytier/src/gateway/tokio_smoltcp/socket_allocator.rs b/easytier/src/gateway/tokio_smoltcp/socket_allocator.rs index 934d40f8..0f01678e 100644 --- a/easytier/src/gateway/tokio_smoltcp/socket_allocator.rs +++ b/easytier/src/gateway/tokio_smoltcp/socket_allocator.rs @@ -85,9 +85,8 @@ impl SocketAlloctor { vec![udp::PacketMetadata::EMPTY; self.buffer_size.udp_tx_meta_size], vec![0; self.buffer_size.udp_tx_size], ); - let udp = udp::Socket::new(rx_buffer, tx_buffer); - udp + udp::Socket::new(rx_buffer, tx_buffer) } } diff --git a/easytier/src/gateway/udp_proxy.rs b/easytier/src/gateway/udp_proxy.rs index 1f5eaaaf..5a9a98d6 100644 --- a/easytier/src/gateway/udp_proxy.rs +++ b/easytier/src/gateway/udp_proxy.rs @@ -1,6 +1,6 @@ use std::{ net::{Ipv4Addr, SocketAddr, SocketAddrV4}, - sync::{atomic::AtomicBool, Arc, Weak}, + sync::{Arc, Weak, atomic::AtomicBool}, time::Duration, }; @@ -9,12 +9,12 @@ use cidr::Ipv4Inet; use crossbeam::atomic::AtomicCell; use dashmap::DashMap; use pnet::packet::{ + Packet, ip::IpNextHeaderProtocols, ipv4::Ipv4Packet, udp::{self, MutableUdpPacket}, - Packet, }; -use tokio::sync::mpsc::{channel, error::TrySendError, Receiver, Sender}; +use tokio::sync::mpsc::{Receiver, Sender, channel, error::TrySendError}; use tokio::{ net::UdpSocket, sync::Mutex, @@ -25,16 +25,16 @@ use tokio::{ use tracing::Level; use crate::{ - common::{error::Error, global_ctx::ArcGlobalCtx, scoped_task::ScopedTask, PeerId}, - gateway::ip_reassembler::{compose_ipv4_packet, ComposeIpv4PacketArgs}, - peers::{peer_manager::PeerManager, PeerPacketFilter}, + common::{PeerId, error::Error, global_ctx::ArcGlobalCtx, scoped_task::ScopedTask}, + gateway::ip_reassembler::{ComposeIpv4PacketArgs, compose_ipv4_packet}, + peers::{PeerPacketFilter, peer_manager::PeerManager}, tunnel::{ common::{reserve_buf, setup_sokcet2}, packet_def::{PacketType, ZCPacket}, }, }; -use super::{ip_reassembler::IpReassembler, CidrSet}; +use super::{CidrSet, ip_reassembler::IpReassembler}; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] struct UdpNatKey { diff --git a/easytier/src/gateway/wrapped_proxy.rs b/easytier/src/gateway/wrapped_proxy.rs index 64eeddc7..1e5aefd8 100644 --- a/easytier/src/gateway/wrapped_proxy.rs +++ b/easytier/src/gateway/wrapped_proxy.rs @@ -4,19 +4,19 @@ use std::{ }; use pnet::packet::{ + Packet as _, ip::IpNextHeaderProtocols, ipv4::Ipv4Packet, tcp::{TcpFlags, TcpPacket}, - Packet as _, }; -use tokio::io::{copy_bidirectional, AsyncRead, AsyncWrite}; +use tokio::io::{AsyncRead, AsyncWrite, copy_bidirectional}; use tokio_util::io::InspectReader; use crate::tunnel::packet_def::{PacketType, PeerManagerHeader}; use crate::{ common::{acl_processor::PacketInfo, error::Result}, gateway::tcp_proxy::{NatDstConnector, TcpProxy}, - peers::{acl_filter::AclFilter, NicPacketFilter}, + peers::{NicPacketFilter, acl_filter::AclFilter}, proto::acl::{Action, ChainType}, tunnel::packet_def::ZCPacket, }; diff --git a/easytier/src/instance/dns_server/server.rs b/easytier/src/instance/dns_server/server.rs index fc812ff6..f9b434bb 100644 --- a/easytier/src/instance/dns_server/server.rs +++ b/easytier/src/instance/dns_server/server.rs @@ -5,11 +5,11 @@ use hickory_proto::rr::LowerName; use hickory_resolver::config::ResolverOpts; use hickory_resolver::name_server::TokioConnectionProvider; use hickory_resolver::system_conf::read_system_conf; +use hickory_server::ServerFuture; use hickory_server::authority::{AuthorityObject, Catalog, ZoneType}; use hickory_server::server::{Request, RequestHandler, ResponseHandler, ResponseInfo}; use hickory_server::store::forwarder::ForwardConfig; use hickory_server::store::{forwarder::ForwardAuthority, in_memory::InMemoryAuthority}; -use hickory_server::ServerFuture; use std::io; use std::net::SocketAddr; use std::str::FromStr; diff --git a/easytier/src/instance/dns_server/server_instance.rs b/easytier/src/instance/dns_server/server_instance.rs index 2d3129f1..91d21514 100644 --- a/easytier/src/instance/dns_server/server_instance.rs +++ b/easytier/src/instance/dns_server/server_instance.rs @@ -7,28 +7,28 @@ // all the clients will exit and let the easytier instance to launch a new server instance. use super::{ + MAGIC_DNS_INSTANCE_ADDR, config::{GeneralConfigBuilder, RunConfigBuilder}, server::Server, system_config::{OSConfig, SystemConfig}, - MAGIC_DNS_INSTANCE_ADDR, }; use crate::{ common::{ - ifcfg::{IfConfiger, IfConfiguerTrait}, PeerId, + ifcfg::{IfConfiger, IfConfiguerTrait}, }, instance::dns_server::{ config::{Record, RecordBuilder, RecordType}, server::build_authority, }, - peers::{peer_manager::PeerManager, NicPacketFilter}, + peers::{NicPacketFilter, peer_manager::PeerManager}, proto::{ api::instance::Route, common::{TunnelInfo, Void}, magic_dns::{ - dns_record::{self}, DnsRecord, DnsRecordA, DnsRecordList, GetDnsRecordResponse, HandshakeRequest, HandshakeResponse, MagicDnsServerRpc, MagicDnsServerRpcServer, UpdateDnsRecordRequest, + dns_record::{self}, }, rpc_impl::standalone::{RpcServerHook, StandAloneServer}, rpc_types::controller::{BaseController, Controller}, @@ -47,11 +47,10 @@ use pnet::packet::icmp::{IcmpTypes, MutableIcmpPacket}; use pnet::packet::ipv4::Ipv4Packet; use pnet::packet::udp::UdpPacket; use pnet::packet::{ - icmp, + MutablePacket, Packet, icmp, ip::IpNextHeaderProtocols, ipv4::{self, MutableIpv4Packet}, udp::{self, MutableUdpPacket}, - MutablePacket, Packet, }; use std::net::{SocketAddr, SocketAddrV4}; use std::sync::Mutex; @@ -528,18 +527,18 @@ impl MagicDnsServerInstance { let mut dns_server = Server::new(dns_config); dns_server.run().await?; - if !tun_inet.contains(&fake_ip) { - if let Some(tun_dev_name) = &tun_dev { - let cost = if cfg!(target_os = "windows") { - Some(4) - } else { - None - }; - let ifcfg = IfConfiger {}; - ifcfg - .add_ipv4_route(tun_dev_name, fake_ip, 32, cost) - .await?; - } + if !tun_inet.contains(&fake_ip) + && let Some(tun_dev_name) = &tun_dev + { + let cost = if cfg!(target_os = "windows") { + Some(4) + } else { + None + }; + let ifcfg = IfConfiger {}; + ifcfg + .add_ipv4_route(tun_dev_name, fake_ip, 32, cost) + .await?; } let data = Arc::new(MagicDnsServerInstanceData { @@ -587,13 +586,13 @@ impl MagicDnsServerInstance { if let Err(e) = ret { tracing::error!("Failed to close system config: {:?}", e); } - if !self.tun_inet.contains(&self.data.fake_ip) { - if let Some(tun_dev_name) = &self.data.tun_dev { - let ifcfg = IfConfiger {}; - let _ = ifcfg - .remove_ipv4_route(tun_dev_name, self.data.fake_ip, 32) - .await; - } + if !self.tun_inet.contains(&self.data.fake_ip) + && let Some(tun_dev_name) = &self.data.tun_dev + { + let ifcfg = IfConfiger {}; + let _ = ifcfg + .remove_ipv4_route(tun_dev_name, self.data.fake_ip, 32) + .await; } } diff --git a/easytier/src/instance/instance.rs b/easytier/src/instance/instance.rs index e46da50d..7a5966ce 100644 --- a/easytier/src/instance/instance.rs +++ b/easytier/src/instance/instance.rs @@ -17,12 +17,12 @@ use tokio::{sync::oneshot, task::JoinSet}; #[cfg(feature = "magic-dns")] use tokio_util::sync::CancellationToken; +use crate::common::PeerId; use crate::common::acl_processor::AclRuleBuilder; use crate::common::config::ConfigLoader; use crate::common::error::Error; use crate::common::global_ctx::{ArcGlobalCtx, GlobalCtx, GlobalCtxEvent}; use crate::common::scoped_task::ScopedTask; -use crate::common::PeerId; use crate::connector::direct::DirectConnectorManager; use crate::connector::manual::{ConnectorManagerRpcService, ManualConnectorManager}; use crate::connector::tcp_hole_punch::TcpHolePunchConnector; @@ -40,7 +40,7 @@ use crate::peers::peer_manager::{PeerManager, RouteAlgoType}; #[cfg(feature = "tun")] use crate::peers::recv_packet_from_chan; use crate::peers::rpc_service::PeerManagerRpcService; -use crate::peers::{create_packet_recv_chan, PacketRecvChanReceiver}; +use crate::peers::{PacketRecvChanReceiver, create_packet_recv_chan}; use crate::proto::api::config::{ ConfigPatchAction, ConfigRpc, GetConfigRequest, GetConfigResponse, PatchConfigRequest, PatchConfigResponse, PortForwardPatch, @@ -63,7 +63,7 @@ use crate::utils::weak_upgrade; use crate::vpn_portal::{self, VpnPortal}; #[cfg(feature = "magic-dns")] -use super::dns_server::{runner::DnsRunner, MAGIC_DNS_FAKE_IP}; +use super::dns_server::{MAGIC_DNS_FAKE_IP, runner::DnsRunner}; use super::listeners::ListenerManager; #[cfg(feature = "socks5")] @@ -272,11 +272,11 @@ impl InstanceConfigPatcher { global_ctx.set_hostname(hostname.clone()); global_ctx.config.set_hostname(Some(hostname)); } - if let Some(ipv4) = patch.ipv4 { - if !global_ctx.config.get_dhcp() { - global_ctx.set_ipv4(Some(ipv4.into())); - global_ctx.config.set_ipv4(Some(ipv4.into())); - } + if let Some(ipv4) = patch.ipv4 + && !global_ctx.config.get_dhcp() + { + global_ctx.set_ipv4(Some(ipv4.into())); + global_ctx.config.set_ipv4(Some(ipv4.into())); } if let Some(ipv6) = patch.ipv6 { global_ctx.set_ipv6(Some(ipv6.into())); @@ -667,13 +667,13 @@ impl Instance { packet_recv: Arc>, ) { #[cfg(feature = "magic-dns")] - if let Some(old_ctx) = arc_nic_ctx.lock().await.take() { - if let Some(dns_runner) = old_ctx.magic_dns { - dns_runner.dns_runner_cancel_token.cancel(); - tracing::debug!("cancelling dns runner task"); - let ret = dns_runner.dns_runner_task.await; - tracing::debug!("dns runner task cancelled, ret: {:?}", ret); - } + if let Some(old_ctx) = arc_nic_ctx.lock().await.take() + && let Some(dns_runner) = old_ctx.magic_dns + { + dns_runner.dns_runner_cancel_token.cancel(); + tracing::debug!("cancelling dns runner task"); + let ret = dns_runner.dns_runner_task.await; + tracing::debug!("dns runner task cancelled, ret: {:?}", ret); }; let mut tasks = JoinSet::new(); @@ -772,10 +772,11 @@ impl Instance { let dhcp_inet = used_ipv4.iter().next().unwrap_or(&default_ipv4_addr); // if old ip is already in this subnet and not conflicted, use it - if let Some(ip) = current_dhcp_ip { - if ip.network() == dhcp_inet.network() && !used_ipv4.contains(&ip) { - continue; - } + if let Some(ip) = current_dhcp_ip + && ip.network() == dhcp_inet.network() + && !used_ipv4.contains(&ip) + { + continue; } // find an available ip in the subnet @@ -1070,7 +1071,9 @@ impl Instance { self.peer_manager.my_peer_id() } - fn get_vpn_portal_rpc_service(&self) -> impl VpnPortalRpc + Clone { + fn get_vpn_portal_rpc_service( + &self, + ) -> impl VpnPortalRpc + Clone + use<> { #[derive(Clone)] struct VpnPortalRpcService { peer_mgr: Weak, @@ -1115,7 +1118,7 @@ impl Instance { fn get_mapped_listener_manager_rpc_service( &self, - ) -> impl MappedListenerManageRpc + Clone { + ) -> impl MappedListenerManageRpc + Clone + use<> { #[derive(Clone)] pub struct MappedListenerManagerRpcService(Weak); @@ -1146,7 +1149,7 @@ impl Instance { fn get_port_forward_manager_rpc_service( &self, - ) -> impl PortForwardManageRpc + Clone { + ) -> impl PortForwardManageRpc + Clone + use<> { #[derive(Clone)] pub struct PortForwardManagerRpcService { global_ctx: Weak, @@ -1176,7 +1179,7 @@ impl Instance { } } - fn get_stats_rpc_service(&self) -> impl StatsRpc + Clone { + fn get_stats_rpc_service(&self) -> impl StatsRpc + Clone + use<> { #[derive(Clone)] pub struct StatsRpcService { global_ctx: Weak, @@ -1242,7 +1245,7 @@ impl Instance { } } - fn get_config_service(&self) -> impl ConfigRpc + Clone { + fn get_config_service(&self) -> impl ConfigRpc + Clone + use<> { #[derive(Clone)] pub struct ConfigRpcService { patcher: InstanceConfigPatcher, @@ -1285,7 +1288,7 @@ impl Instance { } } - pub fn get_api_rpc_service(&self) -> impl InstanceRpcService { + pub fn get_api_rpc_service(&self) -> impl InstanceRpcService + use<> { use crate::proto::api::instance::*; #[derive(Clone)] @@ -1308,15 +1311,15 @@ impl Instance { #[async_trait::async_trait] impl< - A: PeerManageRpc + Send + Sync, - B: ConnectorManageRpc + Send + Sync, - C: MappedListenerManageRpc + Send + Sync, - D: VpnPortalRpc + Send + Sync, - E: AclManageRpc + Send + Sync, - F: PortForwardManageRpc + Send + Sync, - G: StatsRpc + Send + Sync, - H: ConfigRpc + Send + Sync, - > InstanceRpcService for ApiRpcServiceImpl + A: PeerManageRpc + Send + Sync, + B: ConnectorManageRpc + Send + Sync, + C: MappedListenerManageRpc + Send + Sync, + D: VpnPortalRpc + Send + Sync, + E: AclManageRpc + Send + Sync, + F: PortForwardManageRpc + Send + Sync, + G: StatsRpc + Send + Sync, + H: ConfigRpc + Send + Sync, + > InstanceRpcService for ApiRpcServiceImpl { fn get_peer_manage_service(&self) -> &dyn PeerManageRpc { &self.peer_mgr_rpc_service diff --git a/easytier/src/instance/listeners.rs b/easytier/src/instance/listeners.rs index 37f5c6a7..6f7782dd 100644 --- a/easytier/src/instance/listeners.rs +++ b/easytier/src/instance/listeners.rs @@ -17,8 +17,8 @@ use crate::{ }, peers::peer_manager::PeerManager, tunnel::{ - self, ring::RingTunnelListener, tcp::TcpTunnelListener, udp::UdpTunnelListener, IpScheme, - Tunnel, TunnelListener, TunnelScheme, + self, IpScheme, Tunnel, TunnelListener, TunnelScheme, ring::RingTunnelListener, + tcp::TcpTunnelListener, udp::UdpTunnelListener, }, utils::BoxExt, }; @@ -284,7 +284,7 @@ mod tests { use crate::{ common::global_ctx::tests::get_mock_global_ctx, - tunnel::{packet_def::ZCPacket, ring::RingTunnelConnector, TunnelConnector, TunnelError}, + tunnel::{TunnelConnector, TunnelError, packet_def::ZCPacket, ring::RingTunnelConnector}, }; use super::*; diff --git a/easytier/src/instance/virtual_nic.rs b/easytier/src/instance/virtual_nic.rs index d4e77a03..280147b4 100644 --- a/easytier/src/instance/virtual_nic.rs +++ b/easytier/src/instance/virtual_nic.rs @@ -15,18 +15,18 @@ use crate::{ log, }, instance::proxy_cidrs_monitor::ProxyCidrsMonitor, - peers::{peer_manager::PeerManager, recv_packet_from_chan, PacketRecvChanReceiver}, + peers::{PacketRecvChanReceiver, peer_manager::PeerManager, recv_packet_from_chan}, tunnel::{ - common::{reserve_buf, FramedWriter, TunnelWrapper, ZCPacketToBytes}, - packet_def::{ZCPacket, ZCPacketType, TAIL_RESERVED_SIZE}, StreamItem, Tunnel, TunnelError, ZCPacketSink, ZCPacketStream, + common::{FramedWriter, TunnelWrapper, ZCPacketToBytes, reserve_buf}, + packet_def::{TAIL_RESERVED_SIZE, ZCPacket, ZCPacketType}, }, }; use byteorder::WriteBytesExt as _; use bytes::{BufMut, BytesMut}; use cidr::{Ipv4Inet, Ipv6Inet}; -use futures::{lock::BiLock, ready, SinkExt, Stream, StreamExt}; +use futures::{SinkExt, Stream, StreamExt, lock::BiLock, ready}; use pin_project_lite::pin_project; use pnet::packet::{ipv4::Ipv4Packet, ipv6::Ipv6Packet}; use tokio::{ @@ -530,7 +530,9 @@ impl VirtualNic { Ok(_) => tracing::info!("add_self_to_firewall_allowlist successful!"), Err(error) => { log::warn!(%error, "Failed to add Easytier to firewall allowlist, Subnet proxy and KCP proxy may not work properly."); - log::warn!("You can add firewall rules manually, or use --use-smoltcp to run with user-space TCP/IP stack."); + log::warn!( + "You can add firewall rules manually, or use --use-smoltcp to run with user-space TCP/IP stack." + ); } } @@ -768,7 +770,7 @@ impl VirtualNic { Ok(()) } - pub fn get_ifcfg(&self) -> impl IfConfiguerTrait { + pub fn get_ifcfg(&self) -> impl IfConfiguerTrait + use<> { IfConfiger {} } } diff --git a/easytier/src/instance_manager.rs b/easytier/src/instance_manager.rs index 1fb3f2b5..4ad710e8 100644 --- a/easytier/src/instance_manager.rs +++ b/easytier/src/instance_manager.rs @@ -85,11 +85,11 @@ impl NetworkInstanceManager { let _t = instance_event_receiver .map(|event| ScopedTask::from(handle_event(instance_id, event))); instance_stop_notifier.notified().await; - if let Some(instance) = instance_map.get(&instance_id) { - if let Some(error) = instance.get_latest_error_msg() { - log::error!(%error, "instance {} stopped", instance_id); - instance_error_messages.insert(instance_id, error); - } + if let Some(instance) = instance_map.get(&instance_id) + && let Some(error) = instance.get_latest_error_msg() + { + log::error!(%error, "instance {} stopped", instance_id); + instance_error_messages.insert(instance_id, error); } stop_check_notifier.notify_one(); instance_stop_tasks.remove(&instance_id); @@ -543,45 +543,57 @@ mod tests { let port = crate::utils::find_free_tcp_port(10012..65534).expect("no free tcp port found"); - assert!(manager - .run_network_instance( - TomlConfigLoader::new_from_str(cfg_str).unwrap(), - true, - ConfigFileControl::STATIC_CONFIG - ) - .is_err()); - assert!(manager - .run_network_instance( - TomlConfigLoader::new_from_str(cfg_str).unwrap(), - true, - ConfigFileControl::STATIC_CONFIG - ) - .is_err()); - assert!(manager - .run_network_instance( - TomlConfigLoader::new_from_str(cfg_str) - .inspect(|c| { - c.set_listeners(vec![format!("tcp://0.0.0.0:{}", port).parse().unwrap()]); - }) - .unwrap(), - false, - ConfigFileControl::STATIC_CONFIG - ) - .is_ok()); - assert!(manager - .run_network_instance( - TomlConfigLoader::new_from_str(cfg_str).unwrap(), - true, - ConfigFileControl::STATIC_CONFIG - ) - .is_err()); - assert!(manager - .run_network_instance( - TomlConfigLoader::new_from_str(cfg_str).unwrap(), - false, - ConfigFileControl::STATIC_CONFIG - ) - .is_ok()); + assert!( + manager + .run_network_instance( + TomlConfigLoader::new_from_str(cfg_str).unwrap(), + true, + ConfigFileControl::STATIC_CONFIG + ) + .is_err() + ); + assert!( + manager + .run_network_instance( + TomlConfigLoader::new_from_str(cfg_str).unwrap(), + true, + ConfigFileControl::STATIC_CONFIG + ) + .is_err() + ); + assert!( + manager + .run_network_instance( + TomlConfigLoader::new_from_str(cfg_str) + .inspect(|c| { + c.set_listeners(vec![ + format!("tcp://0.0.0.0:{}", port).parse().unwrap(), + ]); + }) + .unwrap(), + false, + ConfigFileControl::STATIC_CONFIG + ) + .is_ok() + ); + assert!( + manager + .run_network_instance( + TomlConfigLoader::new_from_str(cfg_str).unwrap(), + true, + ConfigFileControl::STATIC_CONFIG + ) + .is_err() + ); + assert!( + manager + .run_network_instance( + TomlConfigLoader::new_from_str(cfg_str).unwrap(), + false, + ConfigFileControl::STATIC_CONFIG + ) + .is_ok() + ); std::thread::sleep(std::time::Duration::from_secs(1)); // wait instance actually started diff --git a/easytier/src/launcher.rs b/easytier/src/launcher.rs index b9061077..a5dc001f 100644 --- a/easytier/src/launcher.rs +++ b/easytier/src/launcher.rs @@ -1,12 +1,12 @@ -use crate::common::config::{process_secure_mode_cfg, ConfigFileControl, PortForwardConfig}; +use crate::common::config::{ConfigFileControl, PortForwardConfig, process_secure_mode_cfg}; use crate::proto::api::{self, manage}; use crate::proto::rpc_types::controller::BaseController; use crate::rpc_service::InstanceRpcService; use crate::{ common::{ config::{ - gen_default_flags, ConfigLoader, NetworkIdentity, PeerConfig, TomlConfigLoader, - VpnPortalConfig, + ConfigLoader, NetworkIdentity, PeerConfig, TomlConfigLoader, VpnPortalConfig, + gen_default_flags, }, constants::EASYTIER_VERSION, global_ctx::{EventBusSubscriber, GlobalCtxEvent}, @@ -19,7 +19,7 @@ use chrono::{DateTime, Local}; use std::{ collections::VecDeque, net::SocketAddr, - sync::{atomic::AtomicBool, Arc, Mutex, RwLock}, + sync::{Arc, Mutex, RwLock, atomic::AtomicBool}, }; use tokio::{ sync::{broadcast, mpsc}, @@ -272,10 +272,10 @@ impl Drop for EasyTierLauncher { fn drop(&mut self) { self.stop_flag .store(true, std::sync::atomic::Ordering::Relaxed); - if let Some(handle) = self.thread_handle.take() { - if let Err(e) = handle.join() { - println!("Error when joining thread: {:?}", e); - } + if let Some(handle) = self.thread_handle.take() + && let Err(e) = handle.join() + { + println!("Error when joining thread: {:?}", e); } } } @@ -656,12 +656,12 @@ impl NetworkConfig { cfg.set_exit_nodes(exit_nodes); } - if self.enable_socks5.unwrap_or_default() { - if let Some(socks5_port) = self.socks5_port { - cfg.set_socks5_portal(Some( - format!("socks5://0.0.0.0:{}", socks5_port).parse().unwrap(), - )); - } + if self.enable_socks5.unwrap_or_default() + && let Some(socks5_port) = self.socks5_port + { + cfg.set_socks5_portal(Some( + format!("socks5://0.0.0.0:{}", socks5_port).parse().unwrap(), + )); } if !self.mapped_listeners.is_empty() { @@ -909,11 +909,11 @@ impl NetworkConfig { result.vpn_portal_listen_port = Some(vpn_config.wireguard_listen.port() as i32); } - if let Some(routes) = config.get_routes() { - if !routes.is_empty() { - result.enable_manual_routes = Some(true); - result.routes = routes.iter().map(|r| r.to_string()).collect(); - } + if let Some(routes) = config.get_routes() + && !routes.is_empty() + { + result.enable_manual_routes = Some(true); + result.routes = routes.iter().map(|r| r.to_string()).collect(); } let exit_nodes = config.get_exit_nodes(); @@ -986,10 +986,10 @@ impl NetworkConfig { #[cfg(test)] mod tests { use crate::{ - common::config::{process_secure_mode_cfg, ConfigLoader}, + common::config::{ConfigLoader, process_secure_mode_cfg}, proto::common::SecureModeConfig, }; - use base64::prelude::{Engine as _, BASE64_STANDARD}; + use base64::prelude::{BASE64_STANDARD, Engine as _}; use rand::Rng; use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; @@ -1014,9 +1014,12 @@ mod tests { let generated_config_str = generated_config.dump(); assert_eq!( - config_str, generated_config_str, - "Generated config does not match original config:\nOriginal:\n{}\n\nGenerated:\n{}\nNetwork Config: {}\n", - config_str, generated_config_str, serde_json::to_string(&network_config).unwrap() + config_str, + generated_config_str, + "Generated config does not match original config:\nOriginal:\n{}\n\nGenerated:\n{}\nNetwork Config: {}\n", + config_str, + generated_config_str, + serde_json::to_string(&network_config).unwrap() ); Ok(()) } @@ -1033,13 +1036,13 @@ mod tests { config.set_dhcp(rng.gen_bool(0.5)); if rng.gen_bool(0.7) { - let hostname = format!("host-{}", rng.gen::()); + let hostname = format!("host-{}", rng.r#gen::()); config.set_hostname(Some(hostname)); } config.set_network_identity(crate::common::config::NetworkIdentity::new( - format!("network-{}", rng.gen::()), - format!("secret-{}", rng.gen::()), + format!("network-{}", rng.r#gen::()), + format!("secret-{}", rng.r#gen::()), )); config.set_inst_name(config.get_network_identity().network_name.clone()); @@ -1251,9 +1254,12 @@ mod tests { let generated_config_str = generated_config.dump(); assert_eq!( - config_str, generated_config_str, + config_str, + generated_config_str, "Generated config does not match original config:\nOriginal:\n{}\n\nGenerated:\n{}\nNetwork Config: {}\n", - config_str, generated_config_str, serde_json::to_string(&network_config).unwrap() + config_str, + generated_config_str, + serde_json::to_string(&network_config).unwrap() ); } diff --git a/easytier/src/peer_center/instance.rs b/easytier/src/peer_center/instance.rs index 2ce5ed46..461d74b7 100644 --- a/easytier/src/peer_center/instance.rs +++ b/easytier/src/peer_center/instance.rs @@ -12,7 +12,7 @@ use tokio::task::JoinSet; use tracing::Instrument; use crate::{ - common::{global_ctx::GlobalCtx, PeerId}, + common::{PeerId, global_ctx::GlobalCtx}, peers::{ peer_manager::PeerManager, peer_map::PeerMap, @@ -30,7 +30,7 @@ use crate::{ }, }; -use super::{server::PeerCenterServer, Digest, Error}; +use super::{Digest, Error, server::PeerCenterServer}; #[async_trait::async_trait] #[auto_impl::auto_impl(&, Arc, Box)] @@ -97,12 +97,12 @@ impl PeerCenterBase { &self, job_ctx: T, job_fn: impl Fn( - Box + Send>, - Arc>, - ) -> Fut - + Send - + Sync - + 'static, + Box + Send>, + Arc>, + ) -> Fut + + Send + + Sync + + 'static, ) { let my_peer_id = self.my_peer_id; let peer_mgr = self.peer_mgr.clone(); diff --git a/easytier/src/peers/acl_filter.rs b/easytier/src/peers/acl_filter.rs index 6b3d6263..b4271d63 100644 --- a/easytier/src/peers/acl_filter.rs +++ b/easytier/src/peers/acl_filter.rs @@ -3,14 +3,14 @@ use std::sync::atomic::Ordering; use std::time::Instant; use std::{ net::IpAddr, - sync::{atomic::AtomicBool, Arc}, + sync::{Arc, atomic::AtomicBool}, }; use arc_swap::ArcSwap; use dashmap::DashMap; use pnet::packet::ipv6::Ipv6Packet; use pnet::packet::{ - ip::IpNextHeaderProtocols, ipv4::Ipv4Packet, tcp::TcpPacket, udp::UdpPacket, Packet as _, + Packet as _, ip::IpNextHeaderProtocols, ipv4::Ipv4Packet, tcp::TcpPacket, udp::UdpPacket, }; use crate::common::scoped_task::ScopedTask; @@ -238,23 +238,23 @@ impl AclFilter { chain_type: ChainType, processor: &AclProcessor, ) { - if result.should_log { - if let Some(ref log_context) = result.log_context { - let log_message = log_context.to_message(); - tracing::info!( - src_ip = %packet_info.src_ip, - dst_ip = %packet_info.dst_ip, - src_port = packet_info.src_port, - dst_port = packet_info.dst_port, - src_group = packet_info.src_groups.join(","), - dst_group = packet_info.dst_groups.join(","), - protocol = ?packet_info.protocol, - action = ?result.action, - rule = result.matched_rule_str().as_deref().unwrap_or("unknown"), - chain_type = ?chain_type, - "ACL: {}", log_message - ); - } + if result.should_log + && let Some(ref log_context) = result.log_context + { + let log_message = log_context.to_message(); + tracing::info!( + src_ip = %packet_info.src_ip, + dst_ip = %packet_info.dst_ip, + src_port = packet_info.src_port, + dst_port = packet_info.dst_port, + src_group = packet_info.src_groups.join(","), + dst_group = packet_info.dst_groups.join(","), + protocol = ?packet_info.protocol, + action = ?result.action, + rule = result.matched_rule_str().as_deref().unwrap_or("unknown"), + chain_type = ?chain_type, + "ACL: {}", log_message + ); } // Update global statistics in the ACL processor diff --git a/easytier/src/peers/credential_manager.rs b/easytier/src/peers/credential_manager.rs index 5833948d..c003711e 100644 --- a/easytier/src/peers/credential_manager.rs +++ b/easytier/src/peers/credential_manager.rs @@ -5,8 +5,8 @@ use std::{ time::{Duration, SystemTime, UNIX_EPOCH}, }; -use base64::engine::general_purpose::STANDARD as BASE64_STANDARD; use base64::Engine; +use base64::engine::general_purpose::STANDARD as BASE64_STANDARD; use serde::{Deserialize, Serialize}; use x25519_dalek::{PublicKey, StaticSecret}; @@ -62,10 +62,10 @@ impl CredentialManager { .map(|x| x.trim().to_string()) .filter(|x| !x.is_empty()) { - if let Some(existing) = credentials.get(&id) { - if !existing.secret.is_empty() { - return (id, existing.secret.clone()); - } + if let Some(existing) = credentials.get(&id) + && !existing.secret.is_empty() + { + return (id, existing.secret.clone()); } id } else { @@ -191,10 +191,10 @@ impl CredentialManager { return; }; let creds = self.credentials.lock().unwrap(); - if let Ok(json) = serde_json::to_string_pretty(&*creds) { - if let Err(e) = std::fs::write(path, json) { - tracing::warn!(?e, "failed to save credentials to disk"); - } + if let Ok(json) = serde_json::to_string_pretty(&*creds) + && let Err(e) = std::fs::write(path, json) + { + tracing::warn!(?e, "failed to save credentials to disk"); } } @@ -386,11 +386,12 @@ mod tests { ); assert!(tc.credential.as_ref().unwrap().expiry_unix > 0); assert!(tc.verify_credential_hmac("sec")); - assert!(tc - .credential - .as_ref() - .map(|x| !x.pubkey.is_empty()) - .unwrap_or(false)); + assert!( + tc.credential + .as_ref() + .map(|x| !x.pubkey.is_empty()) + .unwrap_or(false) + ); let sk: [u8; 32] = BASE64_STANDARD.decode(&secret).unwrap().try_into().unwrap(); let pk = PublicKey::from(&StaticSecret::from(sk)).as_bytes().to_vec(); diff --git a/easytier/src/peers/encrypt/aes_gcm.rs b/easytier/src/peers/encrypt/aes_gcm.rs index a48bd38e..c1018d9f 100644 --- a/easytier/src/peers/encrypt/aes_gcm.rs +++ b/easytier/src/peers/encrypt/aes_gcm.rs @@ -137,7 +137,7 @@ impl Encryptor for AesGcmCipher { #[cfg(test)] mod tests { use crate::{ - peers::encrypt::{aes_gcm::AesGcmCipher, Encryptor}, + peers::encrypt::{Encryptor, aes_gcm::AesGcmCipher}, tunnel::packet_def::{StandardAeadTail, ZCPacket}, }; use zerocopy::FromBytes; diff --git a/easytier/src/peers/encrypt/ring.rs b/easytier/src/peers/encrypt/ring.rs index a0876468..b5177eb7 100644 --- a/easytier/src/peers/encrypt/ring.rs +++ b/easytier/src/peers/encrypt/ring.rs @@ -155,7 +155,7 @@ impl Encryptor for RingCipher { #[cfg(test)] mod tests { use crate::{ - peers::encrypt::{ring::RingCipher, Encryptor}, + peers::encrypt::{Encryptor, ring::RingCipher}, tunnel::packet_def::{StandardAeadTail, ZCPacket}, }; use zerocopy::FromBytes; diff --git a/easytier/src/peers/encrypt/xor.rs b/easytier/src/peers/encrypt/xor.rs index 3e2ddb00..a6d3165c 100644 --- a/easytier/src/peers/encrypt/xor.rs +++ b/easytier/src/peers/encrypt/xor.rs @@ -61,7 +61,7 @@ impl Encryptor for XorCipher { #[cfg(test)] mod tests { use crate::{ - peers::encrypt::{xor::XorCipher, Encryptor}, + peers::encrypt::{Encryptor, xor::XorCipher}, tunnel::packet_def::ZCPacket, }; diff --git a/easytier/src/peers/foreign_network_client.rs b/easytier/src/peers/foreign_network_client.rs index 99e2794f..9670c15e 100644 --- a/easytier/src/peers/foreign_network_client.rs +++ b/easytier/src/peers/foreign_network_client.rs @@ -1,11 +1,11 @@ use std::sync::{Arc, Mutex}; use crate::{ - common::{error::Error, global_ctx::ArcGlobalCtx, scoped_task::ScopedTask, PeerId}, + common::{PeerId, error::Error, global_ctx::ArcGlobalCtx, scoped_task::ScopedTask}, tunnel::packet_def::ZCPacket, }; -use super::{peer_conn::PeerConn, peer_map::PeerMap, peer_rpc::PeerRpcManager, PacketRecvChan}; +use super::{PacketRecvChan, peer_conn::PeerConn, peer_map::PeerMap, peer_rpc::PeerRpcManager}; pub struct ForeignNetworkClient { global_ctx: ArcGlobalCtx, diff --git a/easytier/src/peers/foreign_network_manager.rs b/easytier/src/peers/foreign_network_manager.rs index cc06d4dd..3edd9603 100644 --- a/easytier/src/peers/foreign_network_manager.rs +++ b/easytier/src/peers/foreign_network_manager.rs @@ -13,21 +13,21 @@ use std::{ use dashmap::{DashMap, DashSet}; use tokio::{ sync::{ - mpsc::{self, UnboundedReceiver, UnboundedSender}, Mutex, + mpsc::{self, UnboundedReceiver, UnboundedSender}, }, task::JoinSet, }; use crate::{ common::{ + PeerId, config::{ConfigLoader, TomlConfigLoader}, error::Error, global_ctx::{ArcGlobalCtx, GlobalCtx, GlobalCtxEvent, NetworkIdentity, TrustedKeySource}, join_joinset_background, shrink_dashmap, stats_manager::{LabelSet, LabelType, MetricName, StatsManager}, token_bucket::TokenBucket, - PeerId, }, peer_center::instance::{PeerCenterInstance, PeerMapWithPeerRpcManager}, peers::route_trait::{Route, RouteInterface}, @@ -44,7 +44,7 @@ use crate::{ }; use super::{ - create_packet_recv_chan, + PUBLIC_SERVER_HOSTNAME_PREFIX, PacketRecvChan, PacketRecvChanReceiver, create_packet_recv_chan, peer_conn::PeerConn, peer_map::PeerMap, peer_ospf_route::PeerRoute, @@ -55,10 +55,9 @@ use super::{ relay_peer_map::RelayPeerMap, route_trait::NextHopPolicy, traffic_metrics::{ - route_peer_info_instance_id, InstanceLabelKind, LogicalTrafficMetrics, - TrafficMetricRecorder, + InstanceLabelKind, LogicalTrafficMetrics, TrafficMetricRecorder, + route_peer_info_instance_id, }, - PacketRecvChan, PacketRecvChanReceiver, PUBLIC_SERVER_HOSTNAME_PREFIX, }; #[async_trait::async_trait] @@ -1454,9 +1453,11 @@ pub mod tests { .get_foreign_network_manager() .list_foreign_networks() .await; - assert!(without_trusted_keys.foreign_networks["net1"] - .trusted_keys - .is_empty()); + assert!( + without_trusted_keys.foreign_networks["net1"] + .trusted_keys + .is_empty() + ); let foreign_mgr = pm_center.get_foreign_network_manager(); wait_for_condition( @@ -1477,9 +1478,11 @@ pub mod tests { .await; let with_trusted_keys = foreign_mgr.list_foreign_networks_with_options(true).await; - assert!(!with_trusted_keys.foreign_networks["net1"] - .trusted_keys - .is_empty()); + assert!( + !with_trusted_keys.foreign_networks["net1"] + .trusted_keys + .is_empty() + ); } #[tokio::test] @@ -1558,12 +1561,14 @@ pub mod tests { assert!(client.await.unwrap().is_ok()); assert!(server.await.unwrap().is_err()); - assert!(pm_center - .get_foreign_network_manager() - .list_foreign_networks() - .await - .foreign_networks - .is_empty()); + assert!( + pm_center + .get_foreign_network_manager() + .list_foreign_networks() + .await + .foreign_networks + .is_empty() + ); } async fn foreign_network_whitelist_helper(name: String) { @@ -1651,20 +1656,24 @@ pub mod tests { .unwrap(); assert_eq!( - vec![pm_center - .get_foreign_network_manager() - .get_network_peer_id("net1") - .unwrap()], + vec![ + pm_center + .get_foreign_network_manager() + .get_network_peer_id("net1") + .unwrap() + ], pma_net1 .get_foreign_network_client() .get_peer_map() .list_peers() ); assert_eq!( - vec![pm_center - .get_foreign_network_manager() - .get_network_peer_id("net1") - .unwrap()], + vec![ + pm_center + .get_foreign_network_manager() + .get_network_peer_id("net1") + .unwrap() + ], pmb_net1 .get_foreign_network_client() .get_peer_map() diff --git a/easytier/src/peers/peer.rs b/easytier/src/peers/peer.rs index fbc15eb6..4c3b55ff 100644 --- a/easytier/src/peers/peer.rs +++ b/easytier/src/peers/peer.rs @@ -9,14 +9,14 @@ use tokio::{select, sync::mpsc}; use tracing::Instrument; use super::{ - peer_conn::{PeerConn, PeerConnId}, PacketRecvChan, + peer_conn::{PeerConn, PeerConnId}, }; use crate::{ common::{ + PeerId, error::Error, global_ctx::{ArcGlobalCtx, GlobalCtxEvent}, - PeerId, }, proto::peer_rpc::PeerIdentityType, tunnel::packet_def::ZCPacket, @@ -294,7 +294,7 @@ impl Drop for Peer { #[cfg(test)] mod tests { - use base64::prelude::{Engine as _, BASE64_STANDARD}; + use base64::prelude::{BASE64_STANDARD, Engine as _}; use rand::rngs::OsRng; use std::sync::Arc; use tokio::time::timeout; @@ -302,7 +302,7 @@ mod tests { use crate::{ common::{ config::{NetworkIdentity, PeerConfig}, - global_ctx::{tests::get_mock_global_ctx, GlobalCtx}, + global_ctx::{GlobalCtx, tests::get_mock_global_ctx}, new_peer_id, }, peers::{create_packet_recv_chan, peer_conn::PeerConn, peer_session::PeerSessionStore}, diff --git a/easytier/src/peers/peer_conn.rs b/easytier/src/peers/peer_conn.rs index 32b710f7..4aafb1b9 100644 --- a/easytier/src/peers/peer_conn.rs +++ b/easytier/src/peers/peer_conn.rs @@ -3,37 +3,37 @@ use std::{ fmt::Debug, pin::Pin, sync::{ - atomic::{AtomicU32, Ordering}, Arc, + atomic::{AtomicU32, Ordering}, }, }; use crossbeam::atomic::AtomicCell; use futures::{StreamExt, TryFutureExt}; -use base64::engine::general_purpose::STANDARD as BASE64_STANDARD; use base64::Engine as _; +use base64::engine::general_purpose::STANDARD as BASE64_STANDARD; use hmac::Mac; use prost::Message; use tokio::{ - sync::{broadcast, Mutex}, + sync::{Mutex, broadcast}, task::JoinSet, - time::{timeout, Duration}, + time::{Duration, timeout}, }; use tracing::Instrument; use zerocopy::AsBytes; -use snow::{params::NoiseParams, HandshakeState}; +use snow::{HandshakeState, params::NoiseParams}; use crate::{ common::{ + PeerId, config::{NetworkIdentity, NetworkSecretDigest}, defer, error::Error, global_ctx::ArcGlobalCtx, - PeerId, }, peers::peer_session::{PeerSessionStore, SessionKey, UpsertResponderSessionReturn}, proto::{ @@ -45,20 +45,20 @@ use crate::{ }, }, tunnel::{ + Tunnel, TunnelError, ZCPacketStream, filter::{StatsRecorderTunnelFilter, TunnelFilter, TunnelFilterChain, TunnelWithFilter}, mpsc::{MpscTunnel, MpscTunnelSender}, packet_def::{PacketType, ZCPacket}, stats::{Throughput, WindowLatency}, - Tunnel, TunnelError, ZCPacketStream, }, use_global_var, }; use super::{ + PacketRecvChan, peer_conn_ping::PeerConnPinger, peer_session::{PeerSession, PeerSessionAction}, traffic_metrics::AggregateTrafficMetrics, - PacketRecvChan, }; pub type PeerConnId = uuid::Uuid; @@ -458,12 +458,12 @@ impl PeerConn { return Err(Error::WaitRespError(format!( "conn recv error during wait handshake response, err: {:?}", e - ))) + ))); } None => { return Err(Error::WaitRespError( "conn closed during wait handshake response".to_owned(), - )) + )); } }; @@ -610,7 +610,7 @@ impl PeerConn { return Err(Error::WaitRespError(format!( "conn recv error during wait handshake response, err: {:?}", e - ))) + ))); } }; @@ -716,12 +716,11 @@ impl PeerConn { remote_network_name: &str, ) -> Result { // 1. Verify proof - if let Some(proof) = proof { - if let Some(mac) = self.global_ctx.get_secret_proof(handshake_hash) { - if mac.verify_slice(proof).is_ok() { - return Ok(SecureAuthLevel::NetworkSecretConfirmed); - } - } + if let Some(proof) = proof + && let Some(mac) = self.global_ctx.get_secret_proof(handshake_hash) + && mac.verify_slice(proof).is_ok() + { + return Ok(SecureAuthLevel::NetworkSecretConfirmed); } // 2. Check pinned pubkey @@ -848,10 +847,10 @@ impl PeerConn { .await??; self.record_control_rx(&network.network_name, msg2.buf_len() as u64); let remote_peer_id = msg2.get_src_peer_id().expect("missing src peer id"); - if let Some(hint) = self.peer_id_hint { - if hint != remote_peer_id { - return Err(Error::WaitRespError("peer_id mismatch".to_owned())); - } + if let Some(hint) = self.peer_id_hint + && hint != remote_peer_id + { + return Err(Error::WaitRespError("peer_id mismatch".to_owned())); } let msg2_pb = Self::decode_handshake_message::( PacketType::NoiseHandshakeMsg2, @@ -1604,16 +1603,16 @@ pub mod tests { use super::*; use crate::common::config::PeerConfig; - use crate::common::global_ctx::tests::get_mock_global_ctx; use crate::common::global_ctx::GlobalCtx; + use crate::common::global_ctx::tests::get_mock_global_ctx; use crate::common::new_peer_id; use crate::common::scoped_task::ScopedTask; use crate::common::stats_manager::{LabelSet, LabelType, MetricName}; use crate::peers::create_packet_recv_chan; use crate::peers::recv_packet_from_chan; use crate::tunnel::common::tests::wait_for_condition; - use crate::tunnel::filter::tests::DropSendTunnelFilter; use crate::tunnel::filter::PacketRecorderTunnelFilter; + use crate::tunnel::filter::tests::DropSendTunnelFilter; use crate::tunnel::ring::create_ring_tunnel_pair; pub fn set_secure_mode_cfg(global_ctx: &GlobalCtx, enabled: bool) { @@ -2489,9 +2488,11 @@ pub mod tests { ); // Revoke the credential - assert!(admin_ctx - .get_credential_manager() - .revoke_credential(&cred_id)); + assert!( + admin_ctx + .get_credential_manager() + .revoke_credential(&cred_id) + ); // Now try to connect with the revoked credential let (c, s) = create_ring_tunnel_pair(); diff --git a/easytier/src/peers/peer_conn_ping.rs b/easytier/src/peers/peer_conn_ping.rs index 538d1f2c..1a3cde30 100644 --- a/easytier/src/peers/peer_conn_ping.rs +++ b/easytier/src/peers/peer_conn_ping.rs @@ -1,27 +1,27 @@ use std::{ sync::{ - atomic::{AtomicU32, Ordering}, Arc, + atomic::{AtomicU32, Ordering}, }, time::Duration, }; -use rand::{thread_rng, Rng}; +use rand::{Rng, thread_rng}; use tokio::{ sync::broadcast, task::JoinSet, - time::{timeout, Interval}, + time::{Interval, timeout}, }; use tracing::Instrument; use crate::{ - common::{error::Error, PeerId}, + common::{PeerId, error::Error}, peers::traffic_metrics::AggregateTrafficMetrics, tunnel::{ + TunnelError, mpsc::MpscTunnelSender, packet_def::{PacketType, ZCPacket}, stats::{Throughput, WindowLatency}, - TunnelError, }, }; diff --git a/easytier/src/peers/peer_manager.rs b/easytier/src/peers/peer_manager.rs index 57b9ede8..8379cad6 100644 --- a/easytier/src/peers/peer_manager.rs +++ b/easytier/src/peers/peer_manager.rs @@ -1,7 +1,7 @@ use std::{ fmt::Debug, net::{IpAddr, Ipv4Addr, Ipv6Addr}, - sync::{atomic::AtomicBool, Arc, Weak}, + sync::{Arc, Weak, atomic::AtomicBool}, time::{Duration, Instant, SystemTime}, }; @@ -12,14 +12,15 @@ use dashmap::DashMap; use tokio::{ sync::{ - mpsc::{self, UnboundedReceiver, UnboundedSender}, Mutex, RwLock, + mpsc::{self, UnboundedReceiver, UnboundedSender}, }, task::JoinSet, }; use crate::{ common::{ + PeerId, compressor::{Compressor as _, DefaultCompressor}, constants::EASYTIER_VERSION, error::Error, @@ -27,24 +28,23 @@ use crate::{ shrink_dashmap, stats_manager::{CounterHandle, LabelSet, LabelType, MetricName}, stun::StunInfoCollectorTrait, - PeerId, }, peers::{ + PeerPacketFilter, peer_conn::PeerConn, peer_rpc::PeerRpcManagerTransport, peer_session::PeerSessionStore, recv_packet_from_chan, route_trait::{ForeignNetworkRouteInfoMap, MockRoute, NextHopPolicy, RouteInterface}, traffic_metrics::{ - route_peer_info_instance_id, InstanceLabelKind, LogicalTrafficMetrics, - TrafficMetricRecorder, + InstanceLabelKind, LogicalTrafficMetrics, TrafficMetricRecorder, + route_peer_info_instance_id, }, - PeerPacketFilter, }, proto::{ api::instance::{ - self, list_global_foreign_network_response::OneForeignNetwork, - ListGlobalForeignNetworkResponse, + self, ListGlobalForeignNetworkResponse, + list_global_foreign_network_response::OneForeignNetwork, }, peer_rpc::{ ForeignNetworkRouteInfoEntry, ForeignNetworkRouteInfoKey, PeerIdentityType, @@ -52,13 +52,13 @@ use crate::{ }, }, tunnel::{ - self, + self, Tunnel, TunnelConnector, packet_def::{CompressorAlgo, PacketType, ZCPacket}, - Tunnel, TunnelConnector, }, }; use super::{ + BoxNicPacketFilter, BoxPeerPacketFilter, PacketRecvChan, PacketRecvChanReceiver, create_packet_recv_chan, encrypt::{Encryptor, NullCipher}, foreign_network_client::ForeignNetworkClient, @@ -70,7 +70,6 @@ use super::{ peer_task::ExternalTaskSignal, relay_peer_map::RelayPeerMap, route_trait::{ArcRoute, Route}, - BoxNicPacketFilter, BoxPeerPacketFilter, PacketRecvChan, PacketRecvChanReceiver, }; struct RpcTransport { @@ -1408,10 +1407,10 @@ impl PeerManager { Err(Error::RouteError(None)) }; - if send_result.is_ok() { - if let Some(metrics) = direct_tx_metrics { - metrics.record_tx(dst_peer_id, packet_type, msg_len).await; - } + if send_result.is_ok() + && let Some(metrics) = direct_tx_metrics + { + metrics.record_tx(dst_peer_id, packet_type, msg_len).await; } send_result @@ -1996,7 +1995,7 @@ mod tests { use crate::{ common::{ config::Flags, - global_ctx::{tests::get_mock_global_ctx, NetworkIdentity}, + global_ctx::{NetworkIdentity, tests::get_mock_global_ctx}, stats_manager::{LabelSet, LabelType, MetricName}, }, connector::{ @@ -2020,11 +2019,11 @@ mod tests { peer_rpc::SecureAuthLevel, }, tunnel::{ + TunnelConnector, TunnelListener, common::tests::wait_for_condition, - filter::{tests::DropSendTunnelFilter, TunnelWithFilter}, + filter::{TunnelWithFilter, tests::DropSendTunnelFilter}, packet_def::{PacketType, ZCPacket}, ring::create_ring_tunnel_pair, - TunnelConnector, TunnelListener, }, }; @@ -2194,24 +2193,28 @@ mod tests { .value, 0 ); - assert!(peer_mgr - .get_global_ctx() - .stats_manager() - .get_metric( - MetricName::TrafficBytesTxByInstance, - &network_labels - .clone() - .with_label_type(LabelType::ToInstanceId("unknown".to_string())), - ) - .is_none()); - assert!(peer_mgr - .get_global_ctx() - .stats_manager() - .get_metric( - MetricName::TrafficPacketsTxByInstance, - &network_labels.with_label_type(LabelType::ToInstanceId("unknown".to_string())), - ) - .is_none()); + assert!( + peer_mgr + .get_global_ctx() + .stats_manager() + .get_metric( + MetricName::TrafficBytesTxByInstance, + &network_labels + .clone() + .with_label_type(LabelType::ToInstanceId("unknown".to_string())), + ) + .is_none() + ); + assert!( + peer_mgr + .get_global_ctx() + .stats_manager() + .get_metric( + MetricName::TrafficPacketsTxByInstance, + &network_labels.with_label_type(LabelType::ToInstanceId("unknown".to_string())), + ) + .is_none() + ); } #[tokio::test] @@ -2265,24 +2268,28 @@ mod tests { ), 0 ); - assert!(peer_mgr - .get_global_ctx() - .stats_manager() - .get_metric( - MetricName::TrafficBytesTxByInstance, - &network_labels - .clone() - .with_label_type(LabelType::ToInstanceId("unknown".to_string())), - ) - .is_none()); - assert!(peer_mgr - .get_global_ctx() - .stats_manager() - .get_metric( - MetricName::TrafficControlBytesTxByInstance, - &network_labels.with_label_type(LabelType::ToInstanceId("unknown".to_string())), - ) - .is_none()); + assert!( + peer_mgr + .get_global_ctx() + .stats_manager() + .get_metric( + MetricName::TrafficBytesTxByInstance, + &network_labels + .clone() + .with_label_type(LabelType::ToInstanceId("unknown".to_string())), + ) + .is_none() + ); + assert!( + peer_mgr + .get_global_ctx() + .stats_manager() + .get_metric( + MetricName::TrafficControlBytesTxByInstance, + &network_labels.with_label_type(LabelType::ToInstanceId("unknown".to_string())), + ) + .is_none() + ); } #[tokio::test] diff --git a/easytier/src/peers/peer_map.rs b/easytier/src/peers/peer_map.rs index 6de1103e..46e55aaf 100644 --- a/easytier/src/peers/peer_map.rs +++ b/easytier/src/peers/peer_map.rs @@ -10,22 +10,23 @@ use tokio::sync::RwLock; use crate::{ common::{ + PeerId, error::Error, global_ctx::{ArcGlobalCtx, GlobalCtxEvent, NetworkIdentity}, - shrink_dashmap, PeerId, + shrink_dashmap, }, proto::{ api::instance::{self, PeerConnInfo}, peer_rpc::{PeerIdentityType, RoutePeerInfo}, }, - tunnel::{packet_def::ZCPacket, TunnelError}, + tunnel::{TunnelError, packet_def::ZCPacket}, }; use super::{ + PacketRecvChan, peer::Peer, peer_conn::{PeerConn, PeerConnId}, route_trait::{ArcRoute, NextHopPolicy}, - PacketRecvChan, }; pub struct PeerMap { diff --git a/easytier/src/peers/peer_ospf_route.rs b/easytier/src/peers/peer_ospf_route.rs index 0a99ca29..f54841a7 100644 --- a/easytier/src/peers/peer_ospf_route.rs +++ b/easytier/src/peers/peer_ospf_route.rs @@ -3,8 +3,8 @@ use std::{ fmt::Debug, net::{IpAddr, Ipv4Addr, Ipv6Addr}, sync::{ - atomic::{AtomicBool, AtomicU32, Ordering}, Arc, Weak, + atomic::{AtomicBool, AtomicU32, Ordering}, }, time::{Duration, Instant, SystemTime}, }; @@ -14,12 +14,12 @@ use cidr::{IpCidr, Ipv4Cidr, Ipv6Cidr}; use crossbeam::atomic::AtomicCell; use dashmap::DashMap; use ordered_hash_map::OrderedHashMap; -use parking_lot::{lock_api::RwLockUpgradableReadGuard, RwLock}; +use parking_lot::{RwLock, lock_api::RwLockUpgradableReadGuard}; use petgraph::{ + Directed, algo::dijkstra, graph::{Graph, NodeIndex}, visit::{EdgeRef, IntoNodeReferences}, - Directed, }; use prefix_trie::PrefixMap; use prost::Message; @@ -32,25 +32,24 @@ use tokio::{ use crate::{ common::{ + PeerId, config::NetworkIdentity, constants::EASYTIER_VERSION, global_ctx::{ArcGlobalCtx, GlobalCtxEvent}, shrink_dashmap, stun::StunInfoCollectorTrait, - PeerId, }, peers::route_trait::{Route, RouteInterfaceBox}, proto::{ acl::GroupIdentity, common::{Ipv4Inet, NatType, StunInfo}, peer_rpc::{ - route_foreign_network_infos, route_foreign_network_summary, - sync_route_info_request::ConnInfo, ForeignNetworkRouteInfoEntry, - ForeignNetworkRouteInfoKey, OspfRouteRpc, OspfRouteRpcClientFactory, - OspfRouteRpcServer, PeerGroupInfo, PeerIdVersion, PeerIdentityType, - RouteForeignNetworkInfos, RouteForeignNetworkSummary, RoutePeerInfo, RoutePeerInfos, - SyncRouteInfoError, SyncRouteInfoRequest, SyncRouteInfoResponse, - TrustedCredentialPubkey, + ForeignNetworkRouteInfoEntry, ForeignNetworkRouteInfoKey, OspfRouteRpc, + OspfRouteRpcClientFactory, OspfRouteRpcServer, PeerGroupInfo, PeerIdVersion, + PeerIdentityType, RouteForeignNetworkInfos, RouteForeignNetworkSummary, RoutePeerInfo, + RoutePeerInfos, SyncRouteInfoError, SyncRouteInfoRequest, SyncRouteInfoResponse, + TrustedCredentialPubkey, route_foreign_network_infos, route_foreign_network_summary, + sync_route_info_request::ConnInfo, }, rpc_types::{ self, @@ -61,13 +60,13 @@ use crate::{ }; use super::{ + PeerPacketFilter, graph_algo::dijkstra_with_first_hop, peer_rpc::PeerRpcManager, route_trait::{ DefaultRouteCostCalculator, ForeignNetworkRouteInfoMap, NextHopPolicy, RouteCostCalculator, RouteCostCalculatorInterface, }, - PeerPacketFilter, }; use atomic_shim::AtomicU64; @@ -2521,13 +2520,12 @@ impl PeerRouteServiceImpl { let now = SystemTime::now(); let mut to_remove = Vec::new(); for (peer_id, peer_info) in self.synced_route_info.peer_infos.read().iter() { - if let Ok(d) = now.duration_since(peer_info.last_update.unwrap().try_into().unwrap()) { - if d > REMOVE_DEAD_PEER_INFO_AFTER + if let Ok(d) = now.duration_since(peer_info.last_update.unwrap().try_into().unwrap()) + && (d > REMOVE_DEAD_PEER_INFO_AFTER || (d > REMOVE_UNREACHABLE_PEER_INFO_AFTER - && !self.route_table.peer_reachable(*peer_id)) - { - to_remove.push(*peer_id); - } + && !self.route_table.peer_reachable(*peer_id))) + { + to_remove.push(*peer_id); } } @@ -2621,8 +2619,16 @@ impl PeerRouteServiceImpl { return true; } - tracing::debug!(?foreign_network, "sync_route request need send to peer. my_id {:?}, dst_peer_id: {:?}, peer_infos: {:?}, conn_info: {:?}, synced_route_info: {:?} session: {:?}", - my_peer_id, dst_peer_id, peer_infos, conn_info, self.synced_route_info, session); + tracing::debug!( + ?foreign_network, + "sync_route request need send to peer. my_id {:?}, dst_peer_id: {:?}, peer_infos: {:?}, conn_info: {:?}, synced_route_info: {:?} session: {:?}", + my_peer_id, + dst_peer_id, + peer_infos, + conn_info, + self.synced_route_info, + session + ); session .need_sync_initiator_info @@ -2664,7 +2670,11 @@ impl PeerRouteServiceImpl { tracing::debug!( "sync_route_info resp: {:?}, req: {:?}, session: {:?}, my_info: {:?}, next_last_sync_succ_timestamp: {:?}", - ret, sync_route_info_req, session, self.global_ctx.network, next_last_sync_succ_timestamp + ret, + sync_route_info_req, + session, + self.global_ctx.network, + next_last_sync_succ_timestamp ); match ret.as_ref() { @@ -3020,10 +3030,10 @@ impl RouteSessionManager { service_impl.my_peer_id ); // update initiator flag for previous session - if let Some(cur_peer_id_to_initiate) = cur_dst_peer_id_to_initiate { - if let Some(session) = service_impl.get_session(cur_peer_id_to_initiate) { - session.update_initiator_flag(false); - } + if let Some(cur_peer_id_to_initiate) = cur_dst_peer_id_to_initiate + && let Some(session) = service_impl.get_session(cur_peer_id_to_initiate) + { + session.update_initiator_flag(false); } cur_dst_peer_id_to_initiate = new_initiator_dst; @@ -3247,7 +3257,14 @@ impl RouteSessionManager { tracing::debug!( "handling sync_route_info rpc: from_peer_id: {:?}, is_initiator: {:?}, peer_infos: {:?}, conn_info: {:?}, synced_route_info: {:?} session: {:?}, new_route_table: {:?}", - from_peer_id, is_initiator, peer_infos, conn_info, service_impl.synced_route_info, session, service_impl.route_table); + from_peer_id, + is_initiator, + peer_infos, + conn_info, + service_impl.synced_route_info, + session, + service_impl.route_table + ); session .dst_is_initiator @@ -3622,8 +3639,8 @@ mod tests { use std::{ collections::{BTreeSet, HashMap}, sync::{ - atomic::{AtomicU32, Ordering}, Arc, + atomic::{AtomicU32, Ordering}, }, time::{Duration, SystemTime}, }; @@ -3631,14 +3648,14 @@ mod tests { use super::{PeerRoute, REMOVE_DEAD_PEER_INFO_AFTER}; use crate::{ common::{ - global_ctx::{tests::get_mock_global_ctx, GlobalCtxEvent, TrustedKeySource}, PeerId, + global_ctx::{GlobalCtxEvent, TrustedKeySource, tests::get_mock_global_ctx}, }, connector::udp_hole_punch::tests::replace_stun_info_collector, peers::{ create_packet_recv_chan, peer_manager::{PeerManager, RouteAlgoType}, - peer_ospf_route::{PeerIdVersion, PeerRouteServiceImpl, FORCE_USE_CONN_LIST}, + peer_ospf_route::{FORCE_USE_CONN_LIST, PeerIdVersion, PeerRouteServiceImpl}, route_trait::{NextHopPolicy, Route, RouteCostCalculatorInterface, RouteInterface}, tests::{connect_peer_manager, create_mock_peer_manager, wait_route_appear}, }, @@ -3917,15 +3934,21 @@ mod tests { } assert!(service_impl.synced_route_info.is_admin_peer(&admin_info)); - assert!(!service_impl - .synced_route_info - .is_admin_peer(&credential_info)); - assert!(service_impl - .synced_route_info - .is_credential_peer(credential_info.peer_id)); - assert!(!service_impl - .synced_route_info - .is_credential_peer(admin_info.peer_id)); + assert!( + !service_impl + .synced_route_info + .is_admin_peer(&credential_info) + ); + assert!( + service_impl + .synced_route_info + .is_credential_peer(credential_info.peer_id) + ); + assert!( + !service_impl + .synced_route_info + .is_credential_peer(admin_info.peer_id) + ); } #[tokio::test] @@ -3983,14 +4006,18 @@ mod tests { .synced_route_info .verify_and_update_credential_trusts(Some(network_secret)); - assert!(service_impl - .synced_route_info - .trusted_credential_pubkeys - .contains_key(&admin_key)); - assert!(!service_impl - .synced_route_info - .trusted_credential_pubkeys - .contains_key(&credential_key)); + assert!( + service_impl + .synced_route_info + .trusted_credential_pubkeys + .contains_key(&admin_key) + ); + assert!( + !service_impl + .synced_route_info + .trusted_credential_pubkeys + .contains_key(&credential_key) + ); } #[tokio::test] @@ -4055,11 +4082,13 @@ mod tests { let guard = route.service_impl.synced_route_info.peer_infos.read(); let stored = guard.get(&from_peer_id).unwrap(); - assert!(stored - .feature_flag - .as_ref() - .map(|x| x.is_credential_peer) - .unwrap_or(false)); + assert!( + stored + .feature_flag + .as_ref() + .map(|x| x.is_credential_peer) + .unwrap_or(false) + ); assert!(stored.proxy_cidrs.is_empty()); assert!(guard.get(&forwarded_peer_id).is_none()); } @@ -4118,11 +4147,13 @@ mod tests { .await .unwrap(); - assert!(!route - .service_impl - .synced_route_info - .trusted_credential_pubkeys - .contains_key(&credential_key)); + assert!( + !route + .service_impl + .synced_route_info + .trusted_credential_pubkeys + .contains_key(&credential_key) + ); } #[tokio::test] @@ -4180,10 +4211,12 @@ mod tests { .global_ctx .update_trusted_keys(global_trusted_keys, &network_name); - assert!(service_impl - .synced_route_info - .trusted_credential_pubkeys - .contains_key(&credential_pubkey)); + assert!( + service_impl + .synced_route_info + .trusted_credential_pubkeys + .contains_key(&credential_pubkey) + ); service_impl.clear_expired_peer().await; @@ -4193,16 +4226,20 @@ mod tests { TrustedKeySource::OspfCredential, )); assert!(closed_peers.lock().contains(&credential_peer_id)); - assert!(!service_impl - .synced_route_info - .peer_infos - .read() - .contains_key(&admin_peer_id)); - assert!(!service_impl - .synced_route_info - .peer_infos - .read() - .contains_key(&credential_peer_id)); + assert!( + !service_impl + .synced_route_info + .peer_infos + .read() + .contains_key(&admin_peer_id) + ); + assert!( + !service_impl + .synced_route_info + .peer_infos + .read() + .contains_key(&credential_peer_id) + ); } #[rstest::rstest] diff --git a/easytier/src/peers/peer_rpc.rs b/easytier/src/peers/peer_rpc.rs index 35f30c85..37da48cd 100644 --- a/easytier/src/peers/peer_rpc.rs +++ b/easytier/src/peers/peer_rpc.rs @@ -4,7 +4,7 @@ use futures::{SinkExt as _, StreamExt}; use tokio::task::JoinSet; use crate::{ - common::{error::Error, stats_manager::StatsManager, PeerId}, + common::{PeerId, error::Error, stats_manager::StatsManager}, proto::rpc_impl::{self, bidirect::BidirectRpcManager}, tunnel::packet_def::ZCPacket, }; @@ -109,7 +109,7 @@ pub mod tests { use tokio::sync::Mutex; use crate::{ - common::{error::Error, new_peer_id, PeerId}, + common::{PeerId, error::Error, new_peer_id}, peers::{ peer_rpc::PeerRpcManager, tests::{connect_peer_manager, create_mock_peer_manager, wait_route_appear}, @@ -119,16 +119,16 @@ pub mod tests { tests::{GreetingClientFactory, GreetingServer, GreetingService, SayHelloRequest}, }, tunnel::{ - packet_def::ZCPacket, ring::create_ring_tunnel_pair, Tunnel, ZCPacketSink, - ZCPacketStream, + Tunnel, ZCPacketSink, ZCPacketStream, packet_def::ZCPacket, + ring::create_ring_tunnel_pair, }, }; use super::PeerRpcManagerTransport; fn random_string(len: usize) -> String { - use rand::distributions::Alphanumeric; use rand::Rng; + use rand::distributions::Alphanumeric; let mut rng = rand::thread_rng(); let s: Vec = std::iter::repeat(()) .map(|()| rng.sample(Alphanumeric)) diff --git a/easytier/src/peers/peer_session.rs b/easytier/src/peers/peer_session.rs index b69e7609..1fe813f6 100644 --- a/easytier/src/peers/peer_session.rs +++ b/easytier/src/peers/peer_session.rs @@ -1,7 +1,7 @@ use std::{ sync::{ - atomic::{AtomicBool, AtomicU32, Ordering}, Arc, Mutex, RwLock, + atomic::{AtomicBool, AtomicU32, Ordering}, }, time::{SystemTime, UNIX_EPOCH}, }; @@ -10,7 +10,7 @@ use atomic_shim::AtomicU64; use crate::{ common::PeerId, - peers::encrypt::{create_encryptor, Encryptor}, + peers::encrypt::{Encryptor, create_encryptor}, tunnel::packet_def::{StandardAeadTail, ZCPacket}, }; use anyhow::anyhow; @@ -189,11 +189,11 @@ impl PeerSessionStore { PeerSessionAction::Sync | PeerSessionAction::Create => { let root_key = root_key_32.ok_or_else(|| anyhow!("missing root_key"))?; // If the existing session is invalidated, remove it so we create a fresh one - if let Some(existing) = self.sessions.get(key) { - if !existing.is_valid() { - drop(existing); - self.sessions.remove(key); - } + if let Some(existing) = self.sessions.get(key) + && !existing.is_valid() + { + drop(existing); + self.sessions.remove(key); } let session = self .sessions diff --git a/easytier/src/peers/peer_task.rs b/easytier/src/peers/peer_task.rs index 4af026a2..72371819 100644 --- a/easytier/src/peers/peer_task.rs +++ b/easytier/src/peers/peer_task.rs @@ -1,6 +1,6 @@ use std::{ result::Result, - sync::{atomic::Ordering, Arc, Mutex}, + sync::{Arc, Mutex, atomic::Ordering}, }; use atomic_shim::AtomicU64; diff --git a/easytier/src/peers/relay_peer_map.rs b/easytier/src/peers/relay_peer_map.rs index 55a40e29..441010aa 100644 --- a/easytier/src/peers/relay_peer_map.rs +++ b/easytier/src/peers/relay_peer_map.rs @@ -3,13 +3,13 @@ use std::{sync::Arc, time::Instant}; use dashmap::DashMap; use prost::Message; use snow::params::NoiseParams; -use tokio::sync::{oneshot, Mutex, OwnedMutexGuard}; -use tokio::time::{timeout, Duration}; +use tokio::sync::{Mutex, OwnedMutexGuard, oneshot}; +use tokio::time::{Duration, timeout}; use crate::peers::foreign_network_client::ForeignNetworkClient; use crate::{ common::error::Error, - common::{global_ctx::ArcGlobalCtx, PeerId}, + common::{PeerId, global_ctx::ArcGlobalCtx}, peers::peer_map::PeerMap, peers::peer_session::{PeerSession, PeerSessionAction, PeerSessionStore, SessionKey}, peers::route_trait::NextHopPolicy, @@ -274,13 +274,13 @@ impl RelayPeerMap { return Ok(()); } - if let Some(next_retry_at) = self.states.get(&dst_peer_id).and_then(|v| v.next_retry_at) { - if Instant::now() < next_retry_at { - self.pending_packets.remove(&dst_peer_id); - return Err(Error::RouteError(Some( - "relay handshake backoff".to_string(), - ))); - } + if let Some(next_retry_at) = self.states.get(&dst_peer_id).and_then(|v| v.next_retry_at) + && Instant::now() < next_retry_at + { + self.pending_packets.remove(&dst_peer_id); + return Err(Error::RouteError(Some( + "relay handshake backoff".to_string(), + ))); } let mut last_err = None; diff --git a/easytier/src/peers/route_trait.rs b/easytier/src/peers/route_trait.rs index b5b4d9b7..55691132 100644 --- a/easytier/src/peers/route_trait.rs +++ b/easytier/src/peers/route_trait.rs @@ -6,7 +6,7 @@ use std::{ use dashmap::DashMap; use crate::{ - common::{global_ctx::NetworkIdentity, PeerId}, + common::{PeerId, global_ctx::NetworkIdentity}, proto::peer_rpc::{ ForeignNetworkRouteInfoEntry, ForeignNetworkRouteInfoKey, PeerIdentityType, RouteForeignNetworkInfos, RouteForeignNetworkSummary, RoutePeerInfo, diff --git a/easytier/src/peers/tests.rs b/easytier/src/peers/tests.rs index 400c795b..647859f3 100644 --- a/easytier/src/peers/tests.rs +++ b/easytier/src/peers/tests.rs @@ -5,13 +5,13 @@ use base64::Engine as _; use crate::{ common::{ + PeerId, error::Error, global_ctx::{ - tests::{get_mock_global_ctx, get_mock_global_ctx_with_network}, NetworkIdentity, + tests::{get_mock_global_ctx, get_mock_global_ctx_with_network}, }, stats_manager::{LabelSet, LabelType, MetricName}, - PeerId, }, proto::api::instance::TrustedKeySourcePb, tunnel::{ @@ -324,12 +324,14 @@ async fn private_mode_rejects_foreign_network_with_different_secret() { ); let _ = client_ret; wait_for_public_peers_empty(client).await; - assert!(server - .get_foreign_network_manager() - .list_foreign_networks() - .await - .foreign_networks - .is_empty()); + assert!( + server + .get_foreign_network_manager() + .list_foreign_networks() + .await + .foreign_networks + .is_empty() + ); } #[tokio::test] @@ -968,8 +970,8 @@ pub async fn create_mock_peer_manager_credential( ) -> Arc { use crate::common::config::NetworkIdentity; use crate::proto::common::SecureModeConfig; - use base64::engine::general_purpose::STANDARD as BASE64_STANDARD; use base64::Engine; + use base64::engine::general_purpose::STANDARD as BASE64_STANDARD; let (s, _r) = create_packet_recv_chan(); let g = get_mock_global_ctx_with_network(Some(NetworkIdentity::new_credential(network_name))); @@ -1127,10 +1129,12 @@ async fn credential_revocation_removes_from_routes() { .await; // Now revoke the credential - assert!(admin_a - .get_global_ctx() - .get_credential_manager() - .revoke_credential(&cred_id)); + assert!( + admin_a + .get_global_ctx() + .get_credential_manager() + .revoke_credential(&cred_id) + ); // Issue event to trigger OSPF sync admin_a .get_global_ctx() @@ -1416,10 +1420,12 @@ async fn multi_admin_multi_credential_route_and_revocation_isolation() { ) .await; - assert!(admin_a - .get_global_ctx() - .get_credential_manager() - .revoke_credential(&cred1_id)); + assert!( + admin_a + .get_global_ctx() + .get_credential_manager() + .revoke_credential(&cred1_id) + ); admin_a .get_global_ctx() .issue_event(crate::common::global_ctx::GlobalCtxEvent::CredentialChanged); diff --git a/easytier/src/peers/traffic_metrics.rs b/easytier/src/peers/traffic_metrics.rs index 4812e4cf..a75006b8 100644 --- a/easytier/src/peers/traffic_metrics.rs +++ b/easytier/src/peers/traffic_metrics.rs @@ -4,9 +4,8 @@ use dashmap::DashMap; use futures::future::BoxFuture; use crate::common::{ - shrink_dashmap, + PeerId, shrink_dashmap, stats_manager::{CounterHandle, LabelSet, LabelType, MetricName, StatsManager}, - PeerId, }; use crate::proto::peer_rpc::RoutePeerInfo; use crate::tunnel::packet_def::PacketType; @@ -147,11 +146,11 @@ impl LogicalTrafficMetrics { { self.total.add_sample(bytes); - if let Some(entry) = self.per_peer.get(&peer_id) { - if entry.value().is_resolved() { - entry.value().counters().add_sample(bytes); - return; - } + if let Some(entry) = self.per_peer.get(&peer_id) + && entry.value().is_resolved() + { + entry.value().counters().add_sample(bytes); + return; } let resolved_instance_id = resolver().await; @@ -388,18 +387,22 @@ mod tests { .value, 300 ); - assert!(stats_mgr - .get_metric( - MetricName::TrafficBytesTx, - &to_instance_labels("default", UNKNOWN_INSTANCE_ID), - ) - .is_none()); - assert!(stats_mgr - .get_metric( - MetricName::TrafficBytesTx, - &to_instance_labels("default", resolved_instance_id), - ) - .is_none()); + assert!( + stats_mgr + .get_metric( + MetricName::TrafficBytesTx, + &to_instance_labels("default", UNKNOWN_INSTANCE_ID), + ) + .is_none() + ); + assert!( + stats_mgr + .get_metric( + MetricName::TrafficBytesTx, + &to_instance_labels("default", resolved_instance_id), + ) + .is_none() + ); assert_eq!( stats_mgr .get_metric( diff --git a/easytier/src/proto/api.rs b/easytier/src/proto/api.rs index 73bedce0..d3b81be6 100644 --- a/easytier/src/proto/api.rs +++ b/easytier/src/proto/api.rs @@ -110,11 +110,7 @@ pub mod instance { ret += stats.rx_bytes; } - if ret == 0 { - None - } else { - Some(ret) - } + if ret == 0 { None } else { Some(ret) } } pub fn get_tx_bytes(&self) -> Option { @@ -127,11 +123,7 @@ pub mod instance { ret += stats.tx_bytes; } - if ret == 0 { - None - } else { - Some(ret) - } + if ret == 0 { None } else { Some(ret) } } pub fn get_loss_rate(&self) -> Option { @@ -167,11 +159,7 @@ pub mod instance { } } - if ret.is_empty() { - None - } else { - Some(ret) - } + if ret.is_empty() { None } else { Some(ret) } } pub fn get_udp_nat_type(&self) -> String { @@ -366,9 +354,10 @@ mod tests { ..Default::default() }; - assert!(pair - .get_loss_rate() - .is_some_and(|loss_rate| (loss_rate - 0.4).abs() < 1e-6)); + assert!( + pair.get_loss_rate() + .is_some_and(|loss_rate| (loss_rate - 0.4).abs() < 1e-6) + ); } #[test] diff --git a/easytier/src/proto/common.rs b/easytier/src/proto/common.rs index 33a3e016..89473192 100644 --- a/easytier/src/proto/common.rs +++ b/easytier/src/proto/common.rs @@ -4,10 +4,10 @@ use std::{ }; use anyhow::Context; -use base64::{prelude::BASE64_STANDARD, Engine as _}; +use base64::{Engine as _, prelude::BASE64_STANDARD}; use strum::VariantArray; -use crate::tunnel::{packet_def::CompressorAlgo, IpScheme}; +use crate::tunnel::{IpScheme, packet_def::CompressorAlgo}; include!(concat!(env!("OUT_DIR"), "/common.rs")); @@ -288,18 +288,17 @@ impl fmt::Display for Url { fn split_tunnel_scheme(raw_scheme: &str) -> Option<(&str, &'static str, bool)> { for scheme in IpScheme::VARIANTS { let scheme: &'static str = scheme.into(); - if let Some(base) = raw_scheme.strip_suffix('6') { - if let Some(prefix) = base.strip_suffix(scheme) { - if prefix.is_empty() || prefix.ends_with('-') { - return Some((prefix, scheme, true)); - } - } + if let Some(base) = raw_scheme.strip_suffix('6') + && let Some(prefix) = base.strip_suffix(scheme) + && (prefix.is_empty() || prefix.ends_with('-')) + { + return Some((prefix, scheme, true)); } - if let Some(prefix) = raw_scheme.strip_suffix(scheme) { - if prefix.is_empty() || prefix.ends_with('-') { - return Some((prefix, scheme, false)); - } + if let Some(prefix) = raw_scheme.strip_suffix(scheme) + && (prefix.is_empty() || prefix.ends_with('-')) + { + return Some((prefix, scheme, false)); } } @@ -532,7 +531,7 @@ impl SecureModeConfig { #[cfg(test)] mod tests { - use super::{normalize_tunnel_url, TunnelInfo, Url}; + use super::{TunnelInfo, Url, normalize_tunnel_url}; fn assert_ipv6_tunnel_normalization(scheme: &str, port: u16) { let expected = format!("{scheme}6://[2001:db8::1]:{port}"); diff --git a/easytier/src/proto/rpc_impl/bidirect.rs b/easytier/src/proto/rpc_impl/bidirect.rs index ab55b8ed..9ceb436c 100644 --- a/easytier/src/proto/rpc_impl/bidirect.rs +++ b/easytier/src/proto/rpc_impl/bidirect.rs @@ -1,4 +1,4 @@ -use std::sync::{atomic::AtomicBool, Arc, Mutex}; +use std::sync::{Arc, Mutex, atomic::AtomicBool}; use futures::{SinkExt as _, StreamExt}; use tokio::{task::JoinSet, time::timeout}; @@ -6,7 +6,7 @@ use tokio::{task::JoinSet, time::timeout}; use crate::{ defer, proto::rpc_types::error::Error, - tunnel::{packet_def::PacketType, ring::create_ring_tunnel_pair, Tunnel}, + tunnel::{Tunnel, packet_def::PacketType, ring::create_ring_tunnel_pair}, }; use super::{client::Client, server::Server, service_registry::ServiceRegistry}; diff --git a/easytier/src/proto/rpc_impl/client.rs b/easytier/src/proto/rpc_impl/client.rs index 5df6a6a5..9ae04c48 100644 --- a/easytier/src/proto/rpc_impl/client.rs +++ b/easytier/src/proto/rpc_impl/client.rs @@ -12,15 +12,15 @@ use tokio_stream::StreamExt; use crate::common::shrink_dashmap; use crate::common::{ - stats_manager::{LabelSet, LabelType, MetricName, StatsManager}, PeerId, + stats_manager::{LabelSet, LabelType, MetricName, StatsManager}, }; use crate::defer; use crate::proto::common::{ CompressionAlgoPb, RpcCompressionInfo, RpcDescriptor, RpcPacket, RpcRequest, RpcResponse, }; use crate::proto::rpc_impl::packet::{ - build_rpc_packet, compress_packet, decompress_packet, BuildRpcPacketArgs, + BuildRpcPacketArgs, build_rpc_packet, compress_packet, decompress_packet, }; use crate::proto::rpc_types::controller::Controller; use crate::proto::rpc_types::descriptor::MethodDescriptor; diff --git a/easytier/src/proto/rpc_impl/mod.rs b/easytier/src/proto/rpc_impl/mod.rs index 8d7da71f..09366a36 100644 --- a/easytier/src/proto/rpc_impl/mod.rs +++ b/easytier/src/proto/rpc_impl/mod.rs @@ -1,4 +1,4 @@ -use crate::tunnel::{mpsc::MpscTunnel, Tunnel}; +use crate::tunnel::{Tunnel, mpsc::MpscTunnel}; pub type RpcController = super::rpc_types::controller::BaseController; diff --git a/easytier/src/proto/rpc_impl/packet.rs b/easytier/src/proto/rpc_impl/packet.rs index 12280538..4f8b62b7 100644 --- a/easytier/src/proto/rpc_impl/packet.rs +++ b/easytier/src/proto/rpc_impl/packet.rs @@ -1,7 +1,7 @@ use prost::Message as _; use crate::{ - common::{compressor::DefaultCompressor, PeerId}, + common::{PeerId, compressor::DefaultCompressor}, proto::{ common::{CompressionAlgoPb, RpcCompressionInfo, RpcDescriptor, RpcPacket}, rpc_types::error::Error, diff --git a/easytier/src/proto/rpc_impl/server.rs b/easytier/src/proto/rpc_impl/server.rs index 94de54c8..4b251202 100644 --- a/easytier/src/proto/rpc_impl/server.rs +++ b/easytier/src/proto/rpc_impl/server.rs @@ -11,9 +11,8 @@ use tokio_stream::StreamExt; use crate::{ common::{ - join_joinset_background, + PeerId, join_joinset_background, stats_manager::{LabelSet, LabelType, MetricName, StatsManager}, - PeerId, }, proto::{ common::{ @@ -24,16 +23,16 @@ use crate::{ rpc_types::{controller::Controller, error::Result}, }, tunnel::{ + Tunnel, ZCPacketStream, mpsc::{MpscTunnel, MpscTunnelSender}, ring::create_ring_tunnel_pair, - Tunnel, ZCPacketStream, }, }; use super::{ - packet::{build_rpc_packet, compress_packet, decompress_packet, PacketMerger}, - service_registry::ServiceRegistry, RpcController, Transport, + packet::{PacketMerger, build_rpc_packet, compress_packet, decompress_packet}, + service_registry::ServiceRegistry, }; #[derive(Debug, Clone, PartialEq, Eq, Hash)] diff --git a/easytier/src/proto/rpc_impl/standalone.rs b/easytier/src/proto/rpc_impl/standalone.rs index a392f55c..0988ad04 100644 --- a/easytier/src/proto/rpc_impl/standalone.rs +++ b/easytier/src/proto/rpc_impl/standalone.rs @@ -1,5 +1,5 @@ use std::{ - sync::{atomic::AtomicU32, Arc, Mutex}, + sync::{Arc, Mutex, atomic::AtomicU32}, time::Duration, }; @@ -204,8 +204,8 @@ mod tests { use crate::{ proto::rpc_impl::standalone::StandAloneServer, tunnel::{ - tcp::{TcpTunnelConnector, TcpTunnelListener}, TunnelConnector as _, + tcp::{TcpTunnelConnector, TcpTunnelListener}, }, }; diff --git a/easytier/src/proto/tests.rs b/easytier/src/proto/tests.rs index 8d9379e7..ee32bea3 100644 --- a/easytier/src/proto/tests.rs +++ b/easytier/src/proto/tests.rs @@ -191,8 +191,8 @@ impl TestContext { } fn random_string(len: usize) -> String { - use rand::distributions::Alphanumeric; use rand::Rng; + use rand::distributions::Alphanumeric; let mut rng = rand::thread_rng(); let s: Vec = std::iter::repeat(()) .map(|()| rng.sample(Alphanumeric)) diff --git a/easytier/src/rpc_service/api.rs b/easytier/src/rpc_service/api.rs index e414e9e9..77aafd0d 100644 --- a/easytier/src/rpc_service/api.rs +++ b/easytier/src/rpc_service/api.rs @@ -30,7 +30,7 @@ use crate::{ port_forward_manage::PortForwardManageRpcService, proxy::TcpProxyRpcService, stats::StatsRpcService, vpn_portal::VpnPortalRpcService, }, - tunnel::{tcp::TcpTunnelListener, TunnelListener}, + tunnel::{TunnelListener, tcp::TcpTunnelListener}, web_client::{DefaultHooks, WebClientHooks}, }; diff --git a/easytier/src/rpc_service/instance_manage.rs b/easytier/src/rpc_service/instance_manage.rs index 4562344e..9e69b63a 100644 --- a/easytier/src/rpc_service/instance_manage.rs +++ b/easytier/src/rpc_service/instance_manage.rs @@ -92,17 +92,16 @@ impl WebClientService for InstanceManageRpcService { ConfigFileControl::new(None, ConfigFilePermission::default()) }; - if !control.is_read_only() { - if let Some(config_file) = control.path.as_ref() { - if let Err(e) = std::fs::write(config_file, cfg.dump()) { - tracing::warn!( - "failed to write config file {}: {}", - config_file.display(), - e - ); - control.set_read_only(true); - } - } + if !control.is_read_only() + && let Some(config_file) = control.path.as_ref() + && let Err(e) = std::fs::write(config_file, cfg.dump()) + { + tracing::warn!( + "failed to write config file {}: {}", + config_file.display(), + e + ); + control.set_read_only(true); } if let Err(e) = self.hooks.pre_run_network_instance(&cfg).await { diff --git a/easytier/src/rpc_service/logger.rs b/easytier/src/rpc_service/logger.rs index 23a73cde..f46e8599 100644 --- a/easytier/src/rpc_service/logger.rs +++ b/easytier/src/rpc_service/logger.rs @@ -1,4 +1,4 @@ -use std::sync::{mpsc::Sender, Mutex, OnceLock}; +use std::sync::{Mutex, OnceLock, mpsc::Sender}; use crate::proto::{ api::logger::{ @@ -72,10 +72,10 @@ impl LoggerRpc for LoggerRpcService { } // 更新当前日志级别 - if let Some(current_level) = CURRENT_LOG_LEVEL.get() { - if let Ok(mut level) = current_level.lock() { - *level = Self::log_level_to_string(request.level()); - } + if let Some(current_level) = CURRENT_LOG_LEVEL.get() + && let Ok(mut level) = current_level.lock() + { + *level = Self::log_level_to_string(request.level()); } Ok(SetLoggerConfigResponse {}) diff --git a/easytier/src/rpc_service/mod.rs b/easytier/src/rpc_service/mod.rs index cd6ca67e..a51cd987 100644 --- a/easytier/src/rpc_service/mod.rs +++ b/easytier/src/rpc_service/mod.rs @@ -100,12 +100,10 @@ fn get_instance_service( if let Some(api::instance::instance_identifier::Selector::InstanceSelector( selector, )) = selector + && let Some(name) = selector.name.as_ref() + && v.get_inst_name() != *name { - if let Some(name) = selector.name.as_ref() { - if v.get_inst_name() != *name { - return false; - } - } + return false; } true }) @@ -118,7 +116,7 @@ fn get_instance_service( return Err(anyhow::anyhow!( "{} instances match the selector, please specify the instance ID", ids.len() - )) + )); } } }; diff --git a/easytier/src/rpc_service/remote_client.rs b/easytier/src/rpc_service/remote_client.rs index e40fcbcf..b088dde8 100644 --- a/easytier/src/rpc_service/remote_client.rs +++ b/easytier/src/rpc_service/remote_client.rs @@ -208,8 +208,8 @@ where ) -> Result> { let mut metas = std::collections::HashMap::new(); - if let Some(client) = self.get_rpc_client(identify.clone()) { - if let Ok(resp) = client + if let Some(client) = self.get_rpc_client(identify.clone()) + && let Ok(resp) = client .list_network_instance_meta( BaseController::default(), ListNetworkInstanceMetaRequest { @@ -217,12 +217,11 @@ where }, ) .await - { - for meta in resp.metas { - if let Some(inst_id) = meta.inst_id.as_ref() { - let inst_id: uuid::Uuid = (*inst_id).into(); - metas.insert(inst_id, meta); - } + { + for meta in resp.metas { + if let Some(inst_id) = meta.inst_id.as_ref() { + let inst_id: uuid::Uuid = (*inst_id).into(); + metas.insert(inst_id, meta); } } } @@ -271,8 +270,8 @@ where identify: T, inst_id: uuid::Uuid, ) -> Result> { - if let Some(client) = self.get_rpc_client(identify.clone()) { - if let Ok(resp) = client + if let Some(client) = self.get_rpc_client(identify.clone()) + && let Ok(resp) = client .get_network_instance_config( BaseController::default(), GetNetworkInstanceConfigRequest { @@ -280,11 +279,9 @@ where }, ) .await - { - if let Some(config) = resp.config { - return Ok(config); - } - } + && let Some(config) = resp.config + { + return Ok(config); } let inst_id = inst_id.to_string(); @@ -354,7 +351,7 @@ where ) -> Result<(), E>; async fn delete_network_configs(&self, identify: T, network_inst_ids: &[Uuid]) - -> Result<(), E>; + -> Result<(), E>; async fn update_network_config_state( &self, @@ -364,7 +361,7 @@ where ) -> Result<(), E>; async fn list_network_configs(&self, identify: T, props: ListNetworkProps) - -> Result, E>; + -> Result, E>; async fn get_network_config(&self, identify: T, network_inst_id: &str) -> Result, E>; } diff --git a/easytier/src/service_manager/mod.rs b/easytier/src/service_manager/mod.rs index 83486250..c1944504 100644 --- a/easytier/src/service_manager/mod.rs +++ b/easytier/src/service_manager/mod.rs @@ -351,7 +351,7 @@ mod win_service_manager { ServiceStopCtx, ServiceUninstallCtx, }; - use winreg::{enums::*, RegKey}; + use winreg::{RegKey, enums::*}; use crate::common::constants::WIN_SERVICE_WORK_DIR_REG_KEY; diff --git a/easytier/src/tests/credential_tests.rs b/easytier/src/tests/credential_tests.rs index fbbf59ef..989e2aa6 100644 --- a/easytier/src/tests/credential_tests.rs +++ b/easytier/src/tests/credential_tests.rs @@ -235,11 +235,7 @@ async fn wait_ping_reachability(src_ns: &str, dst_ip: &str, reachable: bool, tim wait_for_condition( || async { let ping_result = ping_test(src_ns, dst_ip, None).await; - if reachable { - ping_result - } else { - !ping_result - } + if reachable { ping_result } else { !ping_result } }, timeout, ) diff --git a/easytier/src/tests/mod.rs b/easytier/src/tests/mod.rs index ec55d629..7f48a63b 100644 --- a/easytier/src/tests/mod.rs +++ b/easytier/src/tests/mod.rs @@ -11,6 +11,14 @@ use std::io::IsTerminal as _; use crate::common::PeerId; use crate::peers::peer_manager::PeerManager; +pub fn set_env_var, V: AsRef>(key: K, value: V) { + unsafe { std::env::set_var(key, value) } +} + +pub fn remove_env_var>(key: K) { + unsafe { std::env::remove_var(key) } +} + pub fn get_guest_veth_name(net_ns: &str) -> &str { Box::leak(format!("veth_{}_g", net_ns).into_boxed_str()) } diff --git a/easytier/src/tests/three_node.rs b/easytier/src/tests/three_node.rs index dafabd8b..8436c0a3 100644 --- a/easytier/src/tests/three_node.rs +++ b/easytier/src/tests/three_node.rs @@ -3,11 +3,11 @@ use core::panic; use std::{ future::Future, - sync::{atomic::AtomicU32, Arc}, + sync::{Arc, atomic::AtomicU32}, time::Duration, }; -use rand::{rngs::OsRng, Rng}; +use rand::{Rng, rngs::OsRng}; use tokio::{net::UdpSocket, task::JoinSet}; use x25519_dalek::StaticSecret; @@ -846,15 +846,13 @@ pub async fn proxy_three_node_disconnect_test(#[values("tcp", "wg")] proto: &str })); wait_for_condition( || async { - let ret = !insts[2] + !insts[2] .get_peer_manager() .get_peer_map() .list_peers_with_conn() .await .iter() - .any(|r| *r == inst4.peer_id()); - - ret + .any(|r| *r == inst4.peer_id()) }, // 0 down, assume last packet is recv in -0.01 // [2, 7) send ping @@ -999,7 +997,7 @@ pub async fn foreign_network_forward_nic_data() { use std::{net::SocketAddr, str::FromStr}; use defguard_wireguard_rs::{ - host::Peer, key::Key, net::IpAddrMask, InterfaceConfiguration, WGApi, WireguardInterfaceApi, + InterfaceConfiguration, WGApi, WireguardInterfaceApi, host::Peer, key::Key, net::IpAddrMask, }; fn run_wireguard_client( @@ -2257,10 +2255,10 @@ pub async fn acl_group_base_test( #[values(true, false)] enable_quic_proxy: bool, ) { use crate::tunnel::{ + TunnelConnector, TunnelListener, common::tests::_tunnel_pingpong_netns_with_timeout, tcp::{TcpTunnelConnector, TcpTunnelListener}, udp::{UdpTunnelConnector, UdpTunnelListener}, - TunnelConnector, TunnelListener, }; use rand::Rng; @@ -2683,10 +2681,10 @@ pub async fn acl_group_self_test( #[values(true, false)] enable_quic_proxy: bool, ) { use crate::tunnel::{ + TunnelConnector, TunnelListener, common::tests::_tunnel_pingpong_netns_with_timeout, tcp::{TcpTunnelConnector, TcpTunnelListener}, udp::{UdpTunnelConnector, UdpTunnelListener}, - TunnelConnector, TunnelListener, }; use rand::Rng; @@ -2877,10 +2875,10 @@ pub async fn whitelist_test( .await; use crate::tunnel::{ + TunnelConnector, TunnelListener, common::tests::_tunnel_pingpong_netns_with_timeout, tcp::{TcpTunnelConnector, TcpTunnelListener}, udp::{UdpTunnelConnector, UdpTunnelListener}, - TunnelConnector, TunnelListener, }; use rand::Rng; @@ -3052,7 +3050,7 @@ pub async fn config_patch_test() { pub fn generate_secure_mode_config_with_key( private_key: &x25519_dalek::StaticSecret, ) -> SecureModeConfig { - use base64::{prelude::BASE64_STANDARD, Engine}; + use base64::{Engine, prelude::BASE64_STANDARD}; use x25519_dalek::PublicKey; let public = PublicKey::from(private_key); diff --git a/easytier/src/tunnel/common.rs b/easytier/src/tunnel/common.rs index b4c05ff5..f6814f6e 100644 --- a/easytier/src/tunnel/common.rs +++ b/easytier/src/tunnel/common.rs @@ -3,10 +3,10 @@ use std::{ net::{IpAddr, SocketAddr}, pin::Pin, sync::{Arc, Mutex}, - task::{ready, Poll}, + task::{Poll, ready}, }; -use futures::{stream::FuturesUnordered, Future, Sink, Stream}; +use futures::{Future, Sink, Stream, stream::FuturesUnordered}; use network_interface::NetworkInterfaceConfig as _; use pin_project_lite::pin_project; use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; @@ -18,12 +18,12 @@ use zerocopy::FromBytes as _; use super::TunnelInfo; -use crate::tunnel::packet_def::{ZCPacket, PEER_MANAGER_HEADER_SIZE}; +use crate::tunnel::packet_def::{PEER_MANAGER_HEADER_SIZE, ZCPacket}; use super::{ - buf::BufList, - packet_def::{TCPTunnelHeader, ZCPacketType, TCP_TUNNEL_HEADER_SIZE}, SinkItem, StreamItem, Tunnel, TunnelError, ZCPacketSink, ZCPacketStream, + buf::BufList, + packet_def::{TCP_TUNNEL_HEADER_SIZE, TCPTunnelHeader, ZCPacketType}, }; pub struct TunnelWrapper { @@ -454,7 +454,7 @@ pub mod tests { use crate::{ common::netns::NetNS, - tunnel::{packet_def::ZCPacket, TunnelConnector, TunnelListener}, + tunnel::{TunnelConnector, TunnelListener, packet_def::ZCPacket}, }; pub async fn _tunnel_echo_server(tunnel: Box, once: bool) { diff --git a/easytier/src/tunnel/fake_tcp/mod.rs b/easytier/src/tunnel/fake_tcp/mod.rs index 87b38be1..c255ab54 100644 --- a/easytier/src/tunnel/fake_tcp/mod.rs +++ b/easytier/src/tunnel/fake_tcp/mod.rs @@ -17,11 +17,11 @@ use tokio::{io::AsyncReadExt, net::TcpStream, sync::Mutex}; use crate::{ common::scoped_task::ScopedTask, tunnel::{ - common::TunnelWrapper, - fake_tcp::netfilter::create_tun, - packet_def::{ZCPacket, ZCPacketType, PEER_MANAGER_HEADER_SIZE, TCP_TUNNEL_HEADER_SIZE}, FromUrl, IpVersion, SinkError, SinkItem, StreamItem, Tunnel, TunnelConnector, TunnelError, TunnelInfo, TunnelListener, + common::TunnelWrapper, + fake_tcp::netfilter::create_tun, + packet_def::{PEER_MANAGER_HEADER_SIZE, TCP_TUNNEL_HEADER_SIZE, ZCPacket, ZCPacketType}, }, }; diff --git a/easytier/src/tunnel/fake_tcp/netfilter/linux_bpf.rs b/easytier/src/tunnel/fake_tcp/netfilter/linux_bpf.rs index b710fc15..0b138f91 100644 --- a/easytier/src/tunnel/fake_tcp/netfilter/linux_bpf.rs +++ b/easytier/src/tunnel/fake_tcp/netfilter/linux_bpf.rs @@ -7,8 +7,8 @@ use std::mem; use std::net::IpAddr; use std::net::SocketAddr; use std::os::fd::{AsRawFd, FromRawFd, OwnedFd}; -use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering}; use std::sync::Arc; +use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering}; use std::time::{Duration, Instant}; use tokio::sync::Mutex; @@ -182,13 +182,13 @@ fn build_tcp_filter( src_addr: Option, dst_addr: SocketAddr, ) -> io::Result> { - if let Some(src) = src_addr { - if src.is_ipv4() != dst_addr.is_ipv4() { - return Err(io::Error::new( - io::ErrorKind::InvalidInput, - "src/dst addr family mismatch", - )); - } + if let Some(src) = src_addr + && src.is_ipv4() != dst_addr.is_ipv4() + { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "src/dst addr family mismatch", + )); } let mut b = BpfBuilder::new(); @@ -637,7 +637,7 @@ mod tests { use pnet::util::MacAddr; use rand::Rng; use std::net::{IpAddr, Ipv4Addr}; - use tokio::time::{timeout, Duration}; + use tokio::time::{Duration, timeout}; fn is_root() -> bool { unsafe { libc::geteuid() == 0 } diff --git a/easytier/src/tunnel/fake_tcp/netfilter/macos_bpf.rs b/easytier/src/tunnel/fake_tcp/netfilter/macos_bpf.rs index 17278088..afc11927 100644 --- a/easytier/src/tunnel/fake_tcp/netfilter/macos_bpf.rs +++ b/easytier/src/tunnel/fake_tcp/netfilter/macos_bpf.rs @@ -7,8 +7,8 @@ use std::mem; use std::net::IpAddr; use std::net::SocketAddr; use std::os::fd::{AsRawFd, FromRawFd, OwnedFd}; -use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering}; use std::sync::Arc; +use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering}; use tokio::sync::Mutex; use tracing::{debug, info, warn}; diff --git a/easytier/src/tunnel/fake_tcp/netfilter/pnet.rs b/easytier/src/tunnel/fake_tcp/netfilter/pnet.rs index a7f4fd20..4f6e5e66 100644 --- a/easytier/src/tunnel/fake_tcp/netfilter/pnet.rs +++ b/easytier/src/tunnel/fake_tcp/netfilter/pnet.rs @@ -2,8 +2,8 @@ use std::{ io, net::{IpAddr, SocketAddr}, sync::{ - atomic::{AtomicU32, Ordering}, Arc, Weak, + atomic::{AtomicU32, Ordering}, }, }; @@ -25,10 +25,10 @@ fn filter_tcp_packet( src_addr: Option<&SocketAddr>, dst_addr: Option<&SocketAddr>, ) -> bool { + use pnet::packet::Packet; use pnet::packet::ethernet::EthernetPacket; use pnet::packet::ipv4::Ipv4Packet; use pnet::packet::tcp::TcpPacket; - use pnet::packet::Packet; let ethernet = if let Some(ethernet) = EthernetPacket::new(packet) { ethernet diff --git a/easytier/src/tunnel/fake_tcp/netfilter/windivert.rs b/easytier/src/tunnel/fake_tcp/netfilter/windivert.rs index 5aac0dcf..1d58f235 100644 --- a/easytier/src/tunnel/fake_tcp/netfilter/windivert.rs +++ b/easytier/src/tunnel/fake_tcp/netfilter/windivert.rs @@ -9,7 +9,7 @@ use tokio::sync::Mutex; use windivert::error::WinDivertError; use windivert::packet::WinDivertPacket; use windivert::prelude::{WinDivertFlags, WinDivertShutdownMode}; -use windivert::{layer, WinDivert}; +use windivert::{WinDivert, layer}; use crate::tunnel::fake_tcp::stack; diff --git a/easytier/src/tunnel/fake_tcp/stack.rs b/easytier/src/tunnel/fake_tcp/stack.rs index e6b7f27f..3173c383 100644 --- a/easytier/src/tunnel/fake_tcp/stack.rs +++ b/easytier/src/tunnel/fake_tcp/stack.rs @@ -44,14 +44,14 @@ use super::packet::*; use bytes::{Bytes, BytesMut}; use crossbeam::atomic::AtomicCell; use pnet::packet::tcp::TcpOptionNumbers; -use pnet::packet::{tcp, Packet}; +use pnet::packet::{Packet, tcp}; use pnet::util::MacAddr; use std::collections::{HashMap, HashSet}; use std::fmt; use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr}; use std::sync::{ - atomic::{AtomicU32, Ordering}, Arc, RwLock, + atomic::{AtomicU32, Ordering}, }; use tokio::sync::broadcast; use tokio::time; diff --git a/easytier/src/tunnel/filter.rs b/easytier/src/tunnel/filter.rs index 929f3537..787eeab9 100644 --- a/easytier/src/tunnel/filter.rs +++ b/easytier/src/tunnel/filter.rs @@ -98,7 +98,7 @@ where } } - fn wrap_sink(&self, sink: S) -> impl ZCPacketSink { + fn wrap_sink(filter: Arc, sink: S) -> impl ZCPacketSink { struct SinkWrapper { sink: S, filter: Arc, @@ -143,13 +143,13 @@ where } } - SinkWrapper { - sink, - filter: self.filter.clone(), - } + SinkWrapper { sink, filter } } - fn wrap_stream(&self, stream: S) -> impl ZCPacketStream { + fn wrap_stream( + filter: Arc, + stream: S, + ) -> impl ZCPacketStream { struct StreamWrapper { stream: S, filter: Arc, @@ -186,10 +186,7 @@ where } } - StreamWrapper { - stream, - filter: self.filter.clone(), - } + StreamWrapper { stream, filter } } } @@ -204,9 +201,10 @@ where fn split(&self) -> (Pin>, Pin>) { let (stream, sink) = self.inner.split(); + let filter = self.filter.clone(); ( - Box::pin(self.wrap_stream(stream)), - Box::pin(self.wrap_sink(sink)), + Box::pin(Self::wrap_stream(filter.clone(), stream)), + Box::pin(Self::wrap_sink(filter, sink)), ) } } @@ -363,9 +361,9 @@ pub mod tests { let out = filter.filter_output(); - let a = out.0 .0 .0 .1; - let b = out.0 .0 .1; - let c = out.0 .1; + let a = out.0.0.0.1; + let b = out.0.0.1; + let c = out.0.1; let _d = out.1; assert_eq!(1, a.0.len()); diff --git a/easytier/src/tunnel/mpsc.rs b/easytier/src/tunnel/mpsc.rs index 870222c0..77e77257 100644 --- a/easytier/src/tunnel/mpsc.rs +++ b/easytier/src/tunnel/mpsc.rs @@ -7,9 +7,9 @@ use tokio::time::timeout; use crate::{common::scoped_task::ScopedTask, proto::common::TunnelInfo}; -use super::{packet_def::ZCPacket, Tunnel, TunnelError, ZCPacketSink, ZCPacketStream}; +use super::{Tunnel, TunnelError, ZCPacketSink, ZCPacketStream, packet_def::ZCPacket}; -use tokio::sync::mpsc::{channel, error::TrySendError, Receiver, Sender}; +use tokio::sync::mpsc::{Receiver, Sender, channel, error::TrySendError}; // use tachyonix::{channel, Receiver, Sender, TrySendError}; use futures::SinkExt; @@ -141,9 +141,9 @@ mod tests { use futures::StreamExt; use crate::tunnel::{ - ring::{create_ring_tunnel_pair, RING_TUNNEL_CAP}, - tcp::{TcpTunnelConnector, TcpTunnelListener}, TunnelConnector, TunnelListener, + ring::{RING_TUNNEL_CAP, create_ring_tunnel_pair}, + tcp::{TcpTunnelConnector, TcpTunnelListener}, }; use super::*; diff --git a/easytier/src/tunnel/packet_def.rs b/easytier/src/tunnel/packet_def.rs index 949b3258..0103c4ff 100644 --- a/easytier/src/tunnel/packet_def.rs +++ b/easytier/src/tunnel/packet_def.rs @@ -1,9 +1,9 @@ use bytes::Bytes; use bytes::BytesMut; -use zerocopy::byteorder::*; use zerocopy::AsBytes; use zerocopy::FromBytes; use zerocopy::FromZeroes; +use zerocopy::byteorder::*; type DefaultEndian = LittleEndian; diff --git a/easytier/src/tunnel/quic.rs b/easytier/src/tunnel/quic.rs index b211d733..96ca5a6f 100644 --- a/easytier/src/tunnel/quic.rs +++ b/easytier/src/tunnel/quic.rs @@ -7,15 +7,15 @@ use std::{ }; use crate::tunnel::{ - common::{setup_sokcet2, FramedReader, FramedWriter, TunnelWrapper}, FromUrl, TunnelInfo, + common::{FramedReader, FramedWriter, TunnelWrapper, setup_sokcet2}, }; use anyhow::Context; use super::{IpVersion, Tunnel, TunnelConnector, TunnelError, TunnelListener}; use quinn::{ - congestion::BbrConfig, udp::RecvMeta, AsyncUdpSocket, ClientConfig, Connection, Endpoint, - EndpointConfig, ServerConfig, TransportConfig, UdpPoller, + AsyncUdpSocket, ClientConfig, Connection, Endpoint, EndpointConfig, ServerConfig, + TransportConfig, UdpPoller, congestion::BbrConfig, udp::RecvMeta, }; pub fn transport_config() -> Arc { @@ -309,8 +309,8 @@ impl TunnelConnector for QuicTunnelConnector { #[cfg(test)] mod tests { use crate::tunnel::{ - common::tests::{_tunnel_bench, _tunnel_pingpong}, IpVersion, TunnelConnector, + common::tests::{_tunnel_bench, _tunnel_pingpong}, }; use super::*; diff --git a/easytier/src/tunnel/ring.rs b/easytier/src/tunnel/ring.rs index 0459c393..2573bdcc 100644 --- a/easytier/src/tunnel/ring.rs +++ b/easytier/src/tunnel/ring.rs @@ -1,10 +1,10 @@ -use async_ringbuf::{traits::*, AsyncHeapCons, AsyncHeapProd, AsyncHeapRb}; +use async_ringbuf::{AsyncHeapCons, AsyncHeapProd, AsyncHeapRb, traits::*}; use crossbeam::atomic::AtomicCell; use std::{ collections::HashMap, fmt::Debug, sync::Arc, - task::{ready, Poll}, + task::{Poll, ready}, }; use async_trait::async_trait; @@ -18,8 +18,8 @@ use uuid::Uuid; use crate::tunnel::{FromUrl, IpVersion, SinkError, SinkItem}; use super::{ - build_url_from_socket_addr, common::TunnelWrapper, StreamItem, Tunnel, TunnelConnector, - TunnelError, TunnelInfo, TunnelListener, + StreamItem, Tunnel, TunnelConnector, TunnelError, TunnelInfo, TunnelListener, + build_url_from_socket_addr, common::TunnelWrapper, }; pub static RING_TUNNEL_CAP: usize = 128; diff --git a/easytier/src/tunnel/tcp.rs b/easytier/src/tunnel/tcp.rs index 70fd13b4..abcb73f6 100644 --- a/easytier/src/tunnel/tcp.rs +++ b/easytier/src/tunnel/tcp.rs @@ -7,8 +7,8 @@ use futures::stream::FuturesUnordered; use tokio::net::{TcpListener, TcpSocket, TcpStream}; use super::{ - common::{wait_for_connect_futures, FramedReader, FramedWriter, TunnelWrapper}, IpVersion, Tunnel, TunnelError, TunnelListener, + common::{FramedReader, FramedWriter, TunnelWrapper, wait_for_connect_futures}, }; const TCP_MTU_BYTES: usize = 2000; @@ -216,8 +216,8 @@ impl super::TunnelConnector for TcpTunnelConnector { #[cfg(test)] mod tests { use crate::tunnel::{ - common::tests::{_tunnel_bench, _tunnel_pingpong}, TunnelConnector, + common::tests::{_tunnel_bench, _tunnel_pingpong}, }; use super::*; diff --git a/easytier/src/tunnel/udp.rs b/easytier/src/tunnel/udp.rs index b191b7b3..6432b64f 100644 --- a/easytier/src/tunnel/udp.rs +++ b/easytier/src/tunnel/udp.rs @@ -8,7 +8,7 @@ use anyhow::Context; use async_trait::async_trait; use bytes::BytesMut; use dashmap::DashMap; -use futures::{stream::FuturesUnordered, SinkExt, StreamExt}; +use futures::{SinkExt, StreamExt, stream::FuturesUnordered}; use rand::{Rng, SeedableRng}; use zerocopy::{AsBytes, FromBytes}; @@ -19,20 +19,20 @@ use tokio::{ task::JoinSet, }; -use tracing::{instrument, Instrument}; +use tracing::{Instrument, instrument}; use super::{ - common::{setup_sokcet2, setup_sokcet2_ext, wait_for_connect_futures}, - packet_def::{UDPTunnelHeader, V6HolePunchPacket, UDP_TUNNEL_HEADER_SIZE}, - ring::{RingSink, RingStream}, FromUrl, IpVersion, Tunnel, TunnelConnCounter, TunnelError, TunnelInfo, TunnelListener, TunnelUrl, + common::{setup_sokcet2, setup_sokcet2_ext, wait_for_connect_futures}, + packet_def::{UDP_TUNNEL_HEADER_SIZE, UDPTunnelHeader, V6HolePunchPacket}, + ring::{RingSink, RingStream}, }; use crate::{ common::{join_joinset_background, scoped_task::ScopedTask, shrink_dashmap}, tunnel::{ build_url_from_socket_addr, - common::{reserve_buf, TunnelWrapper}, + common::{TunnelWrapper, reserve_buf}, packet_def::{UdpPacketType, ZCPacket, ZCPacketType}, ring::RingTunnel, }, @@ -150,8 +150,8 @@ async fn respond_stun_packet( use crate::common::stun_codec_ext::*; use bytecodec::{DecodeExt as _, EncodeExt as _}; use stun_codec::{ - rfc5389::{attributes::XorMappedAddress, methods::BINDING}, Message, MessageClass, MessageDecoder, MessageEncoder, + rfc5389::{attributes::XorMappedAddress, methods::BINDING}, }; let mut decoder = MessageDecoder::::new(); @@ -884,11 +884,11 @@ mod tests { use crate::{ common::global_ctx::tests::get_mock_global_ctx, tunnel::{ + TunnelConnector, common::{ get_interface_name_by_ip, tests::{_tunnel_bench, _tunnel_echo_server, _tunnel_pingpong, wait_for_condition}, }, - TunnelConnector, }, }; diff --git a/easytier/src/tunnel/unix.rs b/easytier/src/tunnel/unix.rs index 6c8415d2..7cba3f2a 100644 --- a/easytier/src/tunnel/unix.rs +++ b/easytier/src/tunnel/unix.rs @@ -1,13 +1,13 @@ use std::path::Path; use async_trait::async_trait; -use tokio::net::{unix::SocketAddr, UnixListener, UnixStream}; +use tokio::net::{UnixListener, UnixStream, unix::SocketAddr}; use super::TunnelInfo; use super::{ - common::{FramedReader, FramedWriter, TunnelWrapper}, IpVersion, Tunnel, TunnelError, TunnelListener, + common::{FramedReader, FramedWriter, TunnelWrapper}, }; const MAX_PACKET_SIZE: usize = 4096; diff --git a/easytier/src/tunnel/websocket.rs b/easytier/src/tunnel/websocket.rs index 1f1394ce..eed5f111 100644 --- a/easytier/src/tunnel/websocket.rs +++ b/easytier/src/tunnel/websocket.rs @@ -1,14 +1,14 @@ use super::{ - common::{setup_sokcet2, wait_for_connect_futures, TunnelWrapper}, + FromUrl, IpVersion, Tunnel, TunnelConnector, TunnelError, TunnelListener, + common::{TunnelWrapper, setup_sokcet2, wait_for_connect_futures}, insecure_tls::{get_insecure_tls_cert, init_crypto_provider}, packet_def::{ZCPacket, ZCPacketType}, - FromUrl, IpVersion, Tunnel, TunnelConnector, TunnelError, TunnelListener, }; use crate::{proto::common::TunnelInfo, tunnel::insecure_tls::get_insecure_tls_client_config}; use anyhow::Context; use bytes::BytesMut; use forwarded_header_value::ForwardedHeaderValue; -use futures::{stream::FuturesUnordered, SinkExt, StreamExt}; +use futures::{SinkExt, StreamExt, stream::FuturesUnordered}; use pnet::ipnetwork::IpNetwork; use std::{ net::SocketAddr, @@ -117,8 +117,7 @@ impl WsTunnelListener { if TRUSTED_PROXIES .iter() .any(|net| net.contains(peer_addr.ip())) - { - if let Some(forwarded) = request + && let Some(forwarded) = request .headers() .get("Forwarded") .and_then(|f| f.to_str().ok()) @@ -130,16 +129,14 @@ impl WsTunnelListener { .and_then(|f| f.to_str().ok()) .and_then(|f| ForwardedHeaderValue::from_x_forwarded_for(f).ok()) }) - { - if let Some(ip) = forwarded.remotest_forwarded_for_ip() { - remote_addr.set_host(Some(&ip.to_string())).map_err(|_| { - TunnelError::InvalidAddr(format!("invalid forwarded ip {}", ip)) - })?; - remote_addr - .query_pairs_mut() - .append_pair("proxy", &peer_addr.to_string()); - } - } + && let Some(ip) = forwarded.remotest_forwarded_for_ip() + { + remote_addr + .set_host(Some(&ip.to_string())) + .map_err(|_| TunnelError::InvalidAddr(format!("invalid forwarded ip {}", ip)))?; + remote_addr + .query_pairs_mut() + .append_pair("proxy", &peer_addr.to_string()); } let (write, read) = stream.split(); diff --git a/easytier/src/tunnel/wireguard.rs b/easytier/src/tunnel/wireguard.rs index e8833973..d1968c60 100644 --- a/easytier/src/tunnel/wireguard.rs +++ b/easytier/src/tunnel/wireguard.rs @@ -2,7 +2,7 @@ use std::{ fmt::{Debug, Formatter}, net::SocketAddr, pin::Pin, - sync::{atomic::AtomicBool, Arc}, + sync::{Arc, atomic::AtomicBool}, time::Duration, }; @@ -10,30 +10,30 @@ use anyhow::Context; use async_recursion::async_recursion; use async_trait::async_trait; use boringtun::{ - noise::{errors::WireGuardError, Tunn, TunnResult}, + noise::{Tunn, TunnResult, errors::WireGuardError}, x25519::{PublicKey, StaticSecret}, }; use bytes::BytesMut; use crossbeam::atomic::AtomicCell; use dashmap::DashMap; -use futures::{stream::FuturesUnordered, SinkExt, StreamExt}; +use futures::{SinkExt, StreamExt, stream::FuturesUnordered}; use rand::RngCore; use tokio::{net::UdpSocket, sync::Mutex, task::JoinSet}; use super::{ - common::{setup_sokcet2, setup_sokcet2_ext, wait_for_connect_futures}, - generate_digest_from_str, - packet_def::{ZCPacketType, PEER_MANAGER_HEADER_SIZE}, - ring::create_ring_tunnel_pair, FromUrl, IpVersion, Tunnel, TunnelError, TunnelInfo, TunnelListener, TunnelUrl, ZCPacketSink, ZCPacketStream, + common::{setup_sokcet2, setup_sokcet2_ext, wait_for_connect_futures}, + generate_digest_from_str, + packet_def::{PEER_MANAGER_HEADER_SIZE, ZCPacketType}, + ring::create_ring_tunnel_pair, }; use crate::{ common::shrink_dashmap, tunnel::{ build_url_from_socket_addr, common::TunnelWrapper, - packet_def::{ZCPacket, WG_TUNNEL_HEADER_SIZE}, + packet_def::{WG_TUNNEL_HEADER_SIZE, ZCPacket}, }, }; @@ -331,11 +331,7 @@ impl WgPeerData { } fn remove_ip_header<'a>(&self, packet: &'a [u8], is_v4: bool) -> &'a [u8] { - if is_v4 { - &packet[20..] - } else { - &packet[40..] - } + if is_v4 { &packet[20..] } else { &packet[40..] } } } @@ -772,8 +768,8 @@ impl super::TunnelConnector for WgTunnelConnector { pub mod tests { use super::*; use crate::tunnel::{ - common::tests::{_tunnel_bench, _tunnel_pingpong}, TunnelConnector, + common::tests::{_tunnel_bench, _tunnel_pingpong}, }; use boringtun::*; diff --git a/easytier/src/utils.rs b/easytier/src/utils.rs index 5d3fdd7d..e2b35676 100644 --- a/easytier/src/utils.rs +++ b/easytier/src/utils.rs @@ -19,7 +19,7 @@ pub fn float_to_str(f: f64, precision: usize) -> String { #[cfg(target_os = "windows")] pub fn utf8_or_gbk_to_string(s: &[u8]) -> String { - use encoding::{all::GBK, DecoderTrap, Encoding}; + use encoding::{DecoderTrap, Encoding, all::GBK}; if let Ok(utf8_str) = String::from_utf8(s.to_vec()) { utf8_str } else { diff --git a/easytier/src/vpn_portal/wireguard.rs b/easytier/src/vpn_portal/wireguard.rs index 358c1d3a..ab85ff93 100644 --- a/easytier/src/vpn_portal/wireguard.rs +++ b/easytier/src/vpn_portal/wireguard.rs @@ -4,7 +4,7 @@ use std::{ }; use anyhow::Context; -use base64::{prelude::BASE64_STANDARD, Engine}; +use base64::{Engine, prelude::BASE64_STANDARD}; use cidr::Ipv4Inet; use dashmap::DashMap; use futures::StreamExt; @@ -18,12 +18,12 @@ use crate::{ global_ctx::{ArcGlobalCtx, GlobalCtxEvent}, join_joinset_background, shrink_dashmap, }, - peers::{peer_manager::PeerManager, PeerPacketFilter}, + peers::{PeerPacketFilter, peer_manager::PeerManager}, tunnel::{ + Tunnel, TunnelListener, mpsc::{MpscTunnel, MpscTunnelSender}, packet_def::{PacketType, ZCPacket, ZCPacketType}, wireguard::{WgConfig, WgTunnelListener}, - Tunnel, TunnelListener, }, }; @@ -256,17 +256,17 @@ impl WireGuardImpl { self.start_listener(&self.listener_addr).await?; // if binding to v4 unspecified, also start a listener on v6 unspecified - if let SocketAddr::V4(v4) = &self.listener_addr { - if v4.ip().is_unspecified() { - let _ = self - .start_listener(&SocketAddr::V6(SocketAddrV6::new( - Ipv6Addr::UNSPECIFIED, - v4.port(), - 0, - 0, - ))) - .await; - } + if let SocketAddr::V4(v4) = &self.listener_addr + && v4.ip().is_unspecified() + { + let _ = self + .start_listener(&SocketAddr::V6(SocketAddrV6::new( + Ipv6Addr::UNSPECIFIED, + v4.port(), + 0, + 0, + ))) + .await; }; join_joinset_background(self.tasks.clone(), "wireguard".to_string()); diff --git a/easytier/src/web_client/mod.rs b/easytier/src/web_client/mod.rs index 47710a0c..c487d13f 100644 --- a/easytier/src/web_client/mod.rs +++ b/easytier/src/web_client/mod.rs @@ -162,7 +162,10 @@ impl WebClient { if secure_mode { connected.store(false, Ordering::Release); let wait = 1; - log::warn!("secure-mode enabled but server does not support encryption, retrying in {} seconds...", wait); + log::warn!( + "secure-mode enabled but server does not support encryption, retrying in {} seconds...", + wait + ); tokio::time::sleep(std::time::Duration::from_secs(wait)).await; continue; } @@ -238,7 +241,7 @@ pub async fn run_web_client( #[cfg(test)] mod tests { - use std::sync::{atomic::AtomicBool, Arc}; + use std::sync::{Arc, atomic::AtomicBool}; use crate::instance_manager::NetworkInstanceManager; diff --git a/easytier/src/web_client/security.rs b/easytier/src/web_client/security.rs index 27ba3869..30020024 100644 --- a/easytier/src/web_client/security.rs +++ b/easytier/src/web_client/security.rs @@ -3,14 +3,14 @@ use std::time::Duration; use bytes::BytesMut; use futures::{SinkExt, StreamExt}; -use snow::{params::NoiseParams, Builder, TransportState}; +use snow::{Builder, TransportState, params::NoiseParams}; use crate::{ proto::common::TunnelInfo, tunnel::{ + SplitTunnel, StreamItem, Tunnel, TunnelError, ZCPacketSink, ZCPacketStream, filter::{TunnelFilter, TunnelWithFilter}, packet_def::{PacketType, ZCPacket, ZCPacketType}, - SplitTunnel, StreamItem, Tunnel, TunnelError, ZCPacketSink, ZCPacketStream, }, }; diff --git a/easytier/src/web_client/session.rs b/easytier/src/web_client/session.rs index bf33bc65..fd28961b 100644 --- a/easytier/src/web_client/session.rs +++ b/easytier/src/web_client/session.rs @@ -1,7 +1,7 @@ use std::sync::{Arc, Weak}; use tokio::{ - sync::{broadcast, Mutex}, + sync::{Mutex, broadcast}, task::JoinSet, time::interval, }; diff --git a/tauri-plugin-vpnservice/Cargo.toml b/tauri-plugin-vpnservice/Cargo.toml index 61a72097..c8a92b61 100644 --- a/tauri-plugin-vpnservice/Cargo.toml +++ b/tauri-plugin-vpnservice/Cargo.toml @@ -3,8 +3,7 @@ name = "tauri-plugin-vpnservice" version = "0.0.0" authors = ["You"] description = "" -edition = "2021" -rust-version = "1.70" +edition.workspace = true exclude = ["/examples", "/webview-dist", "/webview-src", "/node_modules"] links = "tauri-plugin-vpnservice" diff --git a/tauri-plugin-vpnservice/src/error.rs b/tauri-plugin-vpnservice/src/error.rs index 177e8c26..fb57ca57 100644 --- a/tauri-plugin-vpnservice/src/error.rs +++ b/tauri-plugin-vpnservice/src/error.rs @@ -1,4 +1,4 @@ -use serde::{ser::Serializer, Serialize}; +use serde::{Serialize, ser::Serializer}; pub type Result = std::result::Result; diff --git a/tauri-plugin-vpnservice/src/lib.rs b/tauri-plugin-vpnservice/src/lib.rs index daabe6fb..d6f6b1d0 100644 --- a/tauri-plugin-vpnservice/src/lib.rs +++ b/tauri-plugin-vpnservice/src/lib.rs @@ -1,6 +1,6 @@ use tauri::{ - plugin::{Builder, TauriPlugin}, Runtime, + plugin::{Builder, TauriPlugin}, }; #[cfg(mobile)] diff --git a/tauri-plugin-vpnservice/src/mobile.rs b/tauri-plugin-vpnservice/src/mobile.rs index 21129b93..20ed1efb 100644 --- a/tauri-plugin-vpnservice/src/mobile.rs +++ b/tauri-plugin-vpnservice/src/mobile.rs @@ -1,7 +1,7 @@ use serde::de::DeserializeOwned; use tauri::{ - plugin::{PluginApi, PluginHandle}, AppHandle, Runtime, + plugin::{PluginApi, PluginHandle}, }; use crate::models::*;