diff --git a/Cargo.lock b/Cargo.lock index 70d087ac..d59855ce 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6479,10 +6479,12 @@ dependencies = [ "log", "log4rs", "serde", + "serde_json", "sha2 0.11.1", "tokio", "tokio-util", "toml 0.9.12+spec-1.1.0", + "vnt-core", "vnt-ipc", "vnt-web", "windows-service", diff --git a/Cargo.toml b/Cargo.toml index 691b8067..cea482c1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,6 +5,7 @@ edition = "2024" license = "Apache-2.0" [dependencies] +vnt-core = { path = "vnt-core" } vnt-ipc = { path = "vnt-ipc", optional = true } vnt-web = { path = "vnt-web", optional = true } clap = { version = "4.5", features = ["derive", "env"] } @@ -17,6 +18,7 @@ log.workspace = true log4rs = "1.4" serde.workspace = true +serde_json.workspace = true anyhow.workspace = true toml.workspace = true hostname.workspace = true diff --git a/README.md b/README.md index 7f109dd6..3db87ed8 100644 --- a/README.md +++ b/README.md @@ -57,6 +57,7 @@ NAS、跨地区协作等场景。 - **ping 不通对方?** 请确认两边组网编号、服务端地址完全一致,且均已启动组网;防火墙可能拦截 ICMP,可使用共享文件夹等实际业务进行验证。 - **没有公网服务器?** 可先使用公共服务端 `vnt2.rustvnt.com:29872` 体验;正式使用建议自建服务端,以获得更好的稳定性和私密性。 - **不希望修改系统网络设置?** 可将设备模式设为 `no`(无网卡模式),仅提供流量出口和端口映射,无需管理员权限。 +- **同时装了桌面端和命令行,虚拟网里所有设备都 ping 不通?** 同一台机器、同一个组网编号只允许一个客户端运行。设备标识取自机器标识(`machine_uid`),两个客户端会算出同一个设备 ID,服务端因此把后连上的当成"同一设备的新连接"而踢掉先连上的,双方随即互相重连、无限循环——表现为全网都不通,而对端本身完全正常。现在第二个实例会被直接拒绝并打印已有客户端的状态(退出码 0),按提示退出多余的那个即可。不同组网编号互不影响。 ## 安全说明 diff --git a/src/instance_probe.rs b/src/instance_probe.rs new file mode 100644 index 00000000..97c066c4 --- /dev/null +++ b/src/instance_probe.rs @@ -0,0 +1,204 @@ +//! 抢锁失败后的探测:找出本机已有的客户端,把它的状态打印出来。 +//! +//! 单实例锁只能告诉调用方"已被占用",但用户真正需要知道的是"谁在占用、 +//! 现在是什么状态"。这里依次尝试两条路径: +//! +//! 1. `vnt2_cli` 的 ctrl IPC(完整状态),由 [`crate::main_cli`] 直接调用 +//! `vnt_ipc::client`,因此不在本模块内。 +//! 2. VNT Desktop 内核的 HTTP API:先读它写下的 `web_access.toml` 拿到 +//! 监听地址与令牌,再请求 `/api/instances` 列出实例。 +//! +//! 探测是"尽力而为"的:任何一步失败都只降级为更少的输出,不影响主流程。 + +use std::path::PathBuf; +use std::time::Duration; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; + +/// 桌面端内核未写配置时的默认监听端口。 +const DEFAULT_KERNEL_PORT: u16 = 19099; +const CONNECT_TIMEOUT: Duration = Duration::from_millis(1200); +const READ_TIMEOUT: Duration = Duration::from_millis(1500); +/// 探测响应只需要一小段 JSON,超过这个体积一律截断。 +const MAX_RESPONSE_BYTES: u64 = 64 * 1024; + +/// VNT Desktop 内核记录下来的接入信息(字段与 `web_access.toml` 对应)。 +#[derive(Debug, serde::Deserialize)] +struct KernelAccess { + #[serde(default = "default_listen_address")] + listen_address: String, + #[serde(default = "default_kernel_port")] + port: u16, + #[serde(default)] + token: String, +} + +fn default_listen_address() -> String { + "127.0.0.1".to_string() +} + +fn default_kernel_port() -> u16 { + DEFAULT_KERNEL_PORT +} + +#[derive(Debug, serde::Deserialize)] +struct ApiEnvelope { + #[serde(default)] + code: i32, + #[serde(default)] + msg: String, + data: Option, +} + +#[derive(Debug, serde::Deserialize)] +struct InstanceSummary { + #[serde(default)] + config_name: String, + #[serde(default)] + status: String, +} + +/// 探测 VNT Desktop 内核,返回可直接打印的状态描述。 +/// +/// `None` 表示没有探测到桌面端内核在运行。 +pub async fn probe_desktop_kernel() -> Option { + let access = read_kernel_access()?; + let addr = format!("{}:{}", access.listen_address, access.port); + let body = http_get_body(&addr, "/api/instances", &access.token).await?; + let envelope: ApiEnvelope> = serde_json::from_str(&body).ok()?; + if envelope.code != 0 { + return Some(format!( + "VNT Desktop 内核在 {addr} 运行,但查询实例失败:{}", + envelope.msg + )); + } + let instances = envelope.data.unwrap_or_default(); + let mut lines = vec![format!("VNT Desktop 内核在 {addr} 运行,实例:")]; + if instances.is_empty() { + lines.push(" (暂无配置)".to_string()); + } + for instance in instances { + let name = if instance.config_name.is_empty() { + "未命名配置".to_string() + } else { + instance.config_name + }; + let status = if instance.status.is_empty() { + "未知".to_string() + } else { + instance.status + }; + lines.push(format!(" - {name}:{status}")); + } + Some(lines.join("\n")) +} + +/// 读取桌面端内核写入的 `web_access.toml`。 +fn read_kernel_access() -> Option { + for path in kernel_access_candidates() { + let Ok(content) = std::fs::read_to_string(&path) else { + continue; + }; + let Ok(access) = toml::from_str::(&content) else { + continue; + }; + return Some(access); + } + None +} + +/// 桌面端数据目录的候选位置,按平台排列。 +fn kernel_access_candidates() -> Vec { + let mut candidates = Vec::new(); + if let Some(appdata) = std::env::var_os("APPDATA") { + candidates.push(PathBuf::from(&appdata).join("com.vnt.desktop").join("web_access.toml")); + } + if let Some(config) = std::env::var_os("XDG_CONFIG_HOME") { + candidates.push(PathBuf::from(&config).join("com.vnt.desktop").join("web_access.toml")); + } + if let Some(home) = std::env::var_os("HOME") { + let home = PathBuf::from(home); + candidates.push(home.join(".config/com.vnt.desktop/web_access.toml")); + candidates.push( + home.join("Library/Application Support/com.vnt.desktop/web_access.toml"), + ); + } + if let Some(local) = std::env::var_os("LOCALAPPDATA") { + candidates.push(PathBuf::from(&local).join("com.vnt.desktop").join("web_access.toml")); + } + candidates +} + +/// 最小 HTTP/1.1 GET:只取响应体。 +/// +/// 不用现成的 HTTP 客户端是刻意的——探测发生在启动失败路径上,不应引入 +/// TLS provider 之类的额外初始化负担;失败一律返回 `None` 由调用方降级。 +async fn http_get_body(addr: &str, path: &str, token: &str) -> Option { + // 令牌直接拼进请求头,先排除 CR/LF,避免注入额外的头。 + if token.bytes().any(|byte| byte == b'\r' || byte == b'\n') { + return None; + } + let mut stream = tokio::time::timeout(CONNECT_TIMEOUT, tokio::net::TcpStream::connect(addr)) + .await + .ok()? + .ok()?; + let request = format!( + "GET {path} HTTP/1.1\r\nHost: {addr}\r\nAuthorization: Bearer {token}\r\n\ + Connection: close\r\n\r\n" + ); + stream.write_all(request.as_bytes()).await.ok()?; + // 限制响应体积:探测只需要一小段 JSON,异常对端不该把内存打满。 + let mut reader = stream.take(MAX_RESPONSE_BYTES); + let mut buffer = Vec::new(); + tokio::time::timeout(READ_TIMEOUT, reader.read_to_end(&mut buffer)) + .await + .ok()? + .ok()?; + let response = String::from_utf8_lossy(&buffer); + let (head, body) = response.split_once("\r\n\r\n")?; + // 未处理分块编码:桌面端返回的是定长 JSON,分块场景直接放弃解析。 + if head.to_ascii_lowercase().contains("transfer-encoding: chunked") { + return None; + } + let status_ok = head + .lines() + .next() + .is_some_and(|line| line.contains(" 200")); + if !status_ok { + return None; + } + Some(body.trim().to_string()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn kernel_access_defaults_are_localhost() { + let access: KernelAccess = toml::from_str("").expect("空配置应可用默认值"); + assert_eq!(access.listen_address, "127.0.0.1"); + assert_eq!(access.port, DEFAULT_KERNEL_PORT); + assert!(access.token.is_empty()); + } + + #[test] + fn kernel_access_parses_desktop_file() { + let access: KernelAccess = toml::from_str( + "listen_address = \"127.0.0.1\"\nport = 19099\ntoken = \"0123456789abcdef\"\n", + ) + .expect("应能解析桌面端写入的配置"); + assert_eq!(access.port, 19099); + assert_eq!(access.token, "0123456789abcdef"); + } + + #[test] + fn instance_summary_tolerates_missing_fields() { + let envelope: ApiEnvelope> = + serde_json::from_str(r#"{"code":0,"msg":"success","data":[{"config_name":"home"}]}"#) + .expect("缺失字段应可解析"); + let instances = envelope.data.expect("data 应存在"); + assert_eq!(instances.len(), 1); + assert_eq!(instances[0].config_name, "home"); + assert!(instances[0].status.is_empty()); + } +} diff --git a/src/lib.rs b/src/lib.rs index f4ee9bc8..98616923 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1 +1,2 @@ +pub mod instance_probe; pub mod log; diff --git a/src/main_cli.rs b/src/main_cli.rs index 9f728eee..38133507 100644 --- a/src/main_cli.rs +++ b/src/main_cli.rs @@ -15,9 +15,44 @@ mod extract_wintun_dll; #[tokio::main] pub async fn main() { - if let Err(error) = main0().await { - log::error!("{error:?}"); + match main0().await { + Ok(()) => {} + Err(error) => { + // 已有实例在跑属于正常情况(用户重复启动),不算失败: + // 输出它的状态后按成功退出,避免脚本把它当成错误。 + if report_existing_client(&error).await { + return; + } + log::error!("{error:?}"); + } + } +} + +/// 若错误是单实例锁被占用,输出本机已有客户端的状态并返回 `true`。 +/// +/// 优先询问 `vnt2_cli` 的 ctrl IPC(能给出完整的服务器/地址/节点信息), +/// 拿不到再退到 VNT Desktop 内核的 HTTP API。 +async fn report_existing_client(error: &anyhow::Error) -> bool { + let Some(held) = error.downcast_ref::() else { + return false; + }; + println!("本机已有 VNT 客户端在为同一网络运行,无需重复启动。"); + println!("(单实例锁:{})", held.name); + println!(); + let ctrl_cmd = vnt_ipc::message::ipc_request::IpcCmd::AppInfo(Default::default()); + if vnt_ipc::client::run_client(ctrl_cmd, None).await.is_ok() { + return true; + } + match vnt2::instance_probe::probe_desktop_kernel().await { + Some(status) => { + println!("{status}"); + } + None => { + println!("未能查询到已有客户端的状态,请检查 VNT Desktop 是否在运行,"); + println!("或本机是否有其它 vnt2_cli / vnt2_web 进程。"); + } } + true } async fn main0() -> anyhow::Result<()> { diff --git a/src/main_web.rs b/src/main_web.rs index 2f5078e7..efa4e10b 100644 --- a/src/main_web.rs +++ b/src/main_web.rs @@ -82,6 +82,13 @@ impl DesktopKernelConfig { fn main() { if let Err(error) = run() { + // 已有实例在同一网络上注册属于正常情况(用户重复启动), + // 说明清楚后按成功退出,不把它当成程序故障。 + if let Some(held) = error.downcast_ref::() { + eprintln!("本机已有 VNT 客户端在为同一网络运行(单实例锁:{})。", held.name); + eprintln!("请先退出已有的客户端(VNT Desktop 或 vnt2_cli)再启动。"); + return; + } eprintln!("{error:#}"); std::process::exit(1); } diff --git a/vnt-core/Cargo.toml b/vnt-core/Cargo.toml index 2555aa4a..f34a7b1d 100644 --- a/vnt-core/Cargo.toml +++ b/vnt-core/Cargo.toml @@ -64,7 +64,7 @@ route_manager.workspace = true [target.'cfg(target_os = "windows")'.dependencies] winapi = { version = "0.3.9", features = ["winreg"] } widestring = "1.2" -windows-sys = { version = "0.61", features = ["Win32_Networking_WinSock"] } +windows-sys = { version = "0.61", features = ["Win32_Networking_WinSock", "Win32_Foundation", "Win32_System_Threading"] } [target.'cfg(unix)'.dependencies] libc = "0.2" diff --git a/vnt-core/src/core/mod.rs b/vnt-core/src/core/mod.rs index 9a88638a..98d5aed3 100644 --- a/vnt-core/src/core/mod.rs +++ b/vnt-core/src/core/mod.rs @@ -128,6 +128,14 @@ pub struct NetworkManager { /// FEC 编码句柄:保留它使 `fec` 开关可以在运行期双向切换 /// (policy 中是否引用该句柄决定编码是否生效) fec_encoder: FecEncoder, + /// 单实例锁:同一台机器、同一网络只允许一个客户端注册。 + /// + /// device_id 由机器标识派生,因此 cli、Desktop 内核或重复启动的进程会 + /// 派生出同一个 device_id;若它们同时加入同一网络,服务端会把后注册的 + /// 连接当作"同一设备的新连接"并踢掉先注册的那条,双方随即互相替换、 + /// 无限重连。该锁在实例创建时获取,随实例销毁释放。 + #[allow(dead_code)] + instance_lock: std::sync::Arc, } pub type NetworkInstance = NetworkManager; @@ -188,6 +196,20 @@ impl NetworkManager { app_state.nat_info.set_on_change(move || backoff.cap_all()); config.normalize()?; config.check()?; + // 抢单实例锁要早于任何建网/注册动作:抢不到说明本机已有客户端在为 + // 同一网络注册,继续下去只会与服务端互相替换会话。 + let instance_lock = match crate::utils::instance_lock::InstanceLock::acquire( + &config.network_code, + ) { + Ok(lock) => lock, + // 保留 `LockHeld` 作为错误根源,调用方可以 downcast 出结构化信息。 + Err(crate::utils::instance_lock::AcquireError::Held(held)) => { + return Err(anyhow::Error::new(held)); + } + Err(crate::utils::instance_lock::AcquireError::Io(error)) => { + return Err(anyhow::Error::new(error).context("获取单实例锁失败")); + } + }; // Install the route source before any server or gossip producer can // publish automatic routes. Every source is therefore observed even // when it changes during network task startup. @@ -496,6 +518,7 @@ impl NetworkManager { registration_status: registration_status_rx, runtime_policy: runtime_policy.clone(), fec_encoder: shared_fec_encoder, + instance_lock, }; // 连接服务器并注册:注册在实例任务组内后台进行,调用方无需关心注册 // 动作,通过 current_network 获取网段信息即可 diff --git a/vnt-core/src/nat/internal_nat/icmp_nat.rs b/vnt-core/src/nat/internal_nat/icmp_nat.rs index 56d51532..18754502 100644 --- a/vnt-core/src/nat/internal_nat/icmp_nat.rs +++ b/vnt-core/src/nat/internal_nat/icmp_nat.rs @@ -20,6 +20,27 @@ const ICMP_NAT_GC_INTERVAL: Duration = Duration::from_secs(60); /// (对端地址, identifier, sequence) -> (内网客户端地址, 创建时间) type IcmpNatMap = HashMap<(Ipv4Addr, Identifier, SequenceNumber), (Ipv4Addr, Instant)>; +/// 判断创建原始套接字失败是否只是"没有特权"。 +/// +/// 这类失败可以安全降级:ICMP NAT 只影响经由本机出口的 ping 转发, +/// TCP/UDP 组网、虚拟网内互通都不依赖它。其它错误(资源耗尽、协议不支持) +/// 必须照常上报,否则会掩盖真实故障。 +fn is_raw_socket_privilege_error(error: &std::io::Error) -> bool { + if error.kind() == std::io::ErrorKind::PermissionDenied { + return true; + } + #[cfg(unix)] + { + // Linux 缺 CAP_NET_RAW 报 EPERM;macOS 需要 root,同样可能是 EACCES。 + matches!(error.raw_os_error(), Some(code) if code == libc::EPERM || code == libc::EACCES) + } + #[cfg(windows)] + { + // ERROR_ACCESS_DENIED + error.raw_os_error() == Some(5) + } +} + pub async fn start_icmp_nat( task_group: &TaskGroup, ip_stack: &IpStack, @@ -27,12 +48,22 @@ pub async fn start_icmp_nat( network: SharedNetworkAddr, default_interface: Option, ) -> anyhow::Result<()> { - let net_icmp_socket = socket2::Socket::new( + let net_icmp_socket = match socket2::Socket::new( socket2::Domain::IPV4, socket2::Type::RAW, Some(socket2::Protocol::ICMPV4), - ) - .context("new Socket RAW ICMPV4 failed")?; + ) { + Ok(socket) => socket, + // 原始套接字需要特权(Linux 的 CAP_NET_RAW、Windows 管理员)。 + // 非特权环境(CI、容器、普通用户运行 no 模式)里 ICMP NAT 用不了, + // 但 TCP/UDP 组网与虚拟网互通不受影响,因此降级而不是让整个网络 + // 启动失败;其它错误仍然原样上报,避免掩盖真实故障。 + Err(error) if is_raw_socket_privilege_error(&error) => { + log::warn!("ICMP NAT 不可用(缺少原始套接字权限),已跳过: {error}"); + return Ok(()); + } + Err(error) => return Err(error).context("new Socket RAW ICMPV4 failed"), + }; crate::utils::socket::bind_socket_to_interface( &net_icmp_socket, default_interface.as_ref(), @@ -198,6 +229,43 @@ async fn inner_icmp_socket_recv( mod tests { use super::*; + #[test] + fn permission_denied_degrades_instead_of_failing() { + let error = std::io::Error::new(std::io::ErrorKind::PermissionDenied, "denied"); + assert!(is_raw_socket_privilege_error(&error)); + } + + #[test] + fn other_errors_are_not_treated_as_degradation() { + // 资源耗尽之类必须照常上报,不能因为"降级"而悄悄吞掉 + let error = std::io::Error::other("protocol family not supported"); + assert!(!is_raw_socket_privilege_error(&error)); + let not_found = std::io::Error::new(std::io::ErrorKind::NotFound, "no such device"); + assert!(!is_raw_socket_privilege_error(¬_found)); + } + + #[cfg(unix)] + #[test] + fn unix_eperm_and_eacces_are_privilege_errors() { + for code in [libc::EPERM, libc::EACCES] { + let error = std::io::Error::from_raw_os_error(code); + assert!( + is_raw_socket_privilege_error(&error), + "errno {code} 应视为权限不足" + ); + } + } + + #[cfg(windows)] + #[test] + fn windows_access_denied_is_privilege_error() { + let error = std::io::Error::from_raw_os_error(5); + assert!(is_raw_socket_privilege_error(&error)); + // ERROR_INVALID_FUNCTION 不代表权限问题 + let error = std::io::Error::from_raw_os_error(1); + assert!(!is_raw_socket_privilege_error(&error)); + } + fn entry( ip: &str, id: u16, diff --git a/vnt-core/src/utils/instance_lock.rs b/vnt-core/src/utils/instance_lock.rs new file mode 100644 index 00000000..36a9975d --- /dev/null +++ b/vnt-core/src/utils/instance_lock.rs @@ -0,0 +1,421 @@ +//! 单实例锁:同一台机器、同一个网络只允许一个客户端注册到服务端。 +//! +//! `device_id` 来自机器标识(`machine_uid`),因此同一台机器上无论用哪个用户、 +//! 哪个程序(`vnt2_cli`、VNT Desktop 的内置内核 `vnt2-web`)启动,派生出的 +//! device_id 都相同。两者同时加入同一网络时,服务端会把后注册的连接当成 +//! "同一设备的新连接",将先注册的那条踢掉,双方随即各自重连并再次互踢, +//! 表现为无限重连、虚拟网内所有节点都不通。 +//! +//! 这里以 `device_id + network_code` 为键加跨进程独占锁: +//! 第二个实例在启动阶段就失败,不会污染服务端状态。不同网络使用不同的键, +//! 因此一个内核管理多个互不相干的网络时不受影响。 +//! +//! 各平台实现: +//! - Windows:命名互斥体 `Global\vnt-`,进程退出时由内核自动释放。 +//! - Linux:抽象命名空间 Unix socket(`sun_path[0] == 0`),不落盘,进程崩溃自动释放。 +//! - 其它 Unix(macOS 等):`flock` 锁文件,路径在临时目录下,进程退出自动释放。 +//! - Android / iOS:宿主系统本身即单实例,直接放行。 + +use sha2::{Digest, Sha256}; +use std::fmt; +use std::io; + +/// 锁已被其它客户端实例持有。 +#[derive(Debug, Clone)] +pub struct LockHeld { + /// 实际使用的锁名,便于排查是哪个网络在占用。 + pub name: String, +} + +impl fmt::Display for LockHeld { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "another client instance holds {}", self.name) + } +} + +impl std::error::Error for LockHeld {} + +/// 抢锁失败的原因。 +#[derive(Debug)] +pub enum AcquireError { + /// 已有实例持有该网络的锁。 + Held(LockHeld), + /// 系统调用失败(不是"已被占用")。 + Io(io::Error), +} + +impl fmt::Display for AcquireError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::Held(held) => write!(f, "{held}"), + Self::Io(error) => write!(f, "acquire instance lock failed: {error}"), + } + } +} + +impl std::error::Error for AcquireError {} + +impl From for AcquireError { + fn from(error: io::Error) -> Self { + Self::Io(error) + } +} + +/// 进程级独占锁。持有期间其它**进程**无法为同一网络抢锁;最后一个句柄 +/// drop 时释放。 +/// +/// 同一进程内重复获取同一个网络的锁会共享同一把(同一进程本来就共享同一套 +/// device_id 与 client_instance_id,注册多次毫无意义),跨进程才互斥——后者 +/// 正是 cli 与 VNT Desktop 内核同时运行的场景。 +#[derive(Debug)] +pub struct InstanceLock { + name: String, + /// 仅作 RAII 卫兵:存活即持锁,Drop 时释放,因此不需要读取。 + #[allow(dead_code)] + platform: platform::PlatformLock, +} + +/// 进程内已持有的锁表,值为弱引用:外部句柄全部释放后条目失效。 +static PROCESS_LOCKS: std::sync::OnceLock< + std::sync::Mutex>>, +> = std::sync::OnceLock::new(); + +fn process_locks( +) -> &'static std::sync::Mutex>> { + PROCESS_LOCKS.get_or_init(|| std::sync::Mutex::new(std::collections::HashMap::new())) +} + +impl InstanceLock { + /// 为 `network_code` 抢锁。 + /// + /// 键由机器级 `device_id` 与 `network_code` 共同派生,因此同一台机器上 + /// 同一网络只能有一个进程持有,不同网络互不干扰。 + /// + /// 返回 `Arc`:同一进程内再次获取同一网络会拿到同一个句柄。 + pub fn acquire(network_code: &str) -> Result, AcquireError> { + let name = lock_name(network_code); + let registry = process_locks(); + // "查注册表 → 抢平台锁 → 登记"必须在同一个临界区里完成: + // 否则另一个线程可能在本线程已抢到平台锁但还没登记时查不到条目, + // 转而再次抢平台锁失败,被误判成"被其它进程占用"。 + let mut guard = registry.lock().unwrap_or_else(|error| error.into_inner()); + if let Some(existing) = guard.get(&name) { + if let Some(lock) = existing.upgrade() { + return Ok(lock); + } + guard.remove(&name); + } + let platform = match platform::PlatformLock::try_acquire(&name)? { + Ok(platform) => platform, + Err(()) => return Err(AcquireError::Held(LockHeld { name })), + }; + let lock = std::sync::Arc::new(Self { name, platform }); + guard.insert(lock.name.clone(), std::sync::Arc::downgrade(&lock)); + Ok(lock) + } + + /// 当前持有的锁名。 + pub fn name(&self) -> &str { + &self.name + } +} + +impl Drop for InstanceLock { + fn drop(&mut self) { + // 平台锁随本结构体释放;同时移除进程内的弱引用,避免下次获取时 + // 拿到已失效的条目。 + if let Ok(mut guard) = process_locks().lock() { + guard.remove(&self.name); + } + } +} + +/// 由机器标识与网络编号派生出的稳定锁名。 +/// +/// 用 SHA-256 而不是 `DefaultHasher`:同一个网络的锁必须能被不同版本、 +/// 不同程序(cli 与 Desktop 内核)算出同一个名字,而标准库哈希值不保证稳定。 +fn lock_name(network_code: &str) -> String { + let device_id = crate::utils::device_id::get_device_id().unwrap_or_default(); + let mut hasher = Sha256::new(); + hasher.update(device_id.as_bytes()); + hasher.update(b"\0"); + hasher.update(network_code.as_bytes()); + let digest = hasher.finalize(); + format!("vnt-{}", hex::encode(&digest[..8])) +} + +#[cfg(windows)] +mod platform { + use windows_sys::Win32::Foundation::{CloseHandle, ERROR_ALREADY_EXISTS, GetLastError, HANDLE}; + use windows_sys::Win32::System::Threading::CreateMutexW; + + /// 句柄是内核对象,可跨线程使用;所有权仍由本结构体独占。 + #[derive(Debug)] + pub struct PlatformLock { + handle: HANDLE, + } + + // SAFETY: `handle` 是 `CreateMutexW` 返回的有效内核句柄,只在本结构体内 + // 通过 `CloseHandle` 释放一次;HANDLE 本身可自由跨线程传递。 + unsafe impl Send for PlatformLock {} + unsafe impl Sync for PlatformLock {} + + impl PlatformLock { + /// `Ok(Ok(_))` 抢到,`Ok(Err(()))` 已被占用,`Err(_)` 为真实故障。 + pub fn try_acquire(name: &str) -> std::io::Result> { + let wide: Vec = name.encode_utf16().chain(std::iter::once(0)).collect(); + let handle = unsafe { CreateMutexW(std::ptr::null(), 0, wide.as_ptr()) }; + if handle.is_null() { + return Err(std::io::Error::last_os_error()); + } + // CreateMutexW 在名字已存在时同样返回句柄,需靠 GetLastError 区分。 + if unsafe { GetLastError() } == ERROR_ALREADY_EXISTS { + unsafe { CloseHandle(handle) }; + return Ok(Err(())); + } + Ok(Ok(Self { handle })) + } + } + + impl Drop for PlatformLock { + fn drop(&mut self) { + unsafe { CloseHandle(self.handle) }; + } + } +} + +#[cfg(target_os = "linux")] +mod platform { + use std::io; + + /// 抽象命名空间的 Unix socket:绑定成功即持有锁,`bind` 冲突即已有实例。 + /// 抽象地址不写入文件系统,进程退出(含崩溃)时由内核回收。 + #[derive(Debug)] + pub struct PlatformLock { + fd: i32, + } + + impl PlatformLock { + pub fn try_acquire(name: &str) -> io::Result> { + let name = name.as_bytes(); + // 抽象名以 sun_path[0] == 0 开头,可用长度比 sun_path 少一个字节。 + let max_len = std::mem::size_of::() + - std::mem::offset_of!(libc::sockaddr_un, sun_path) + - 1; + if name.len() > max_len { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "instance lock name too long", + )); + } + // SAFETY: socket/bind/close 都是普通系统调用,参数在下文逐一初始化。 + unsafe { + let fd = libc::socket( + libc::AF_UNIX, + libc::SOCK_STREAM | libc::SOCK_CLOEXEC, + 0, + ); + if fd < 0 { + return Err(io::Error::last_os_error()); + } + let mut addr: libc::sockaddr_un = std::mem::zeroed(); + addr.sun_family = libc::AF_UNIX as libc::sa_family_t; + addr.sun_path[0] = 0; + for (index, byte) in name.iter().enumerate() { + addr.sun_path[index + 1] = *byte as libc::c_char; + } + let len = (std::mem::size_of::() + 1 + name.len()) as libc::socklen_t; + if libc::bind(fd, &addr as *const libc::sockaddr_un as *const libc::sockaddr, len) != 0 { + let error = io::Error::last_os_error(); + libc::close(fd); + if error.raw_os_error() == Some(libc::EADDRINUSE) { + return Ok(Err(())); + } + return Err(error); + } + Ok(Ok(Self { fd })) + } + } + } + + impl Drop for PlatformLock { + fn drop(&mut self) { + // SAFETY: fd 由本结构体独占,Drop 只执行一次。 + unsafe { libc::close(self.fd) }; + } + } +} + +#[cfg(all(unix, not(target_os = "linux"), not(target_os = "android"), not(target_os = "ios")))] +mod platform { + use std::fs::OpenOptions; + use std::io; + use std::os::unix::io::AsRawFd; + + /// macOS 等平台不支持抽象 Unix socket,退化为临时目录下的 flock 文件。 + #[derive(Debug)] + pub struct PlatformLock { + _file: std::fs::File, + } + + impl PlatformLock { + pub fn try_acquire(name: &str) -> io::Result> { + let path = std::env::temp_dir().join(format!("{name}.lock")); + // 锁文件可能由同一台机器的其他用户创建,此时写打开会 EACCES; + // flock 只要求可读的 fd,因此退回只读,避免把启动整个打死。 + // truncate(false):锁语义与文件内容无关,不能把其他实例写进去的 + // 内容清掉(clippy 也要求显式声明 truncate 行为)。 + let file = match OpenOptions::new() + .create(true) + .write(true) + .truncate(false) + .open(&path) + { + Ok(file) => file, + Err(error) if error.kind() == io::ErrorKind::PermissionDenied => { + OpenOptions::new().read(true).open(&path)? + } + Err(error) => return Err(error), + }; + // SAFETY: fd 来自上面打开的文件,在 `file` 生命周期内始终有效。 + let rc = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) }; + if rc != 0 { + let error = io::Error::last_os_error(); + if error.raw_os_error() == Some(libc::EWOULDBLOCK) { + return Ok(Err(())); + } + return Err(error); + } + Ok(Ok(Self { _file: file })) + } + } +} + +/// 宿主系统保证单实例(Android / iOS),无需额外同步。 +#[cfg(any(target_os = "android", target_os = "ios"))] +mod platform { + use std::io; + + #[derive(Debug)] + pub struct PlatformLock; + + impl PlatformLock { + pub fn try_acquire(_name: &str) -> io::Result> { + Ok(Ok(Self)) + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn lock_name_is_stable_and_network_specific() { + let first = lock_name("btsd321_net"); + let second = lock_name("btsd321_net"); + assert_eq!(first, second, "同一网络的锁名必须稳定"); + assert_ne!(first, lock_name("other_net"), "不同网络必须使用不同锁名"); + assert!(first.starts_with("vnt-")); + } + + #[test] + fn same_process_shares_one_lock() { + let network = format!("lock-share-test-{}", std::process::id()); + let first = InstanceLock::acquire(&network).expect("首次抢锁"); + let second = InstanceLock::acquire(&network).expect("同进程重复获取应共享同一把锁"); + assert_eq!(first.name(), second.name()); + assert!( + std::sync::Arc::ptr_eq(&first, &second), + "同进程应拿到同一个句柄" + ); + } + + /// 不同网络必须能同时持有各自的锁:一个内核管理多个网络 + /// (Desktop 的多配置)时,不能因为单实例锁而互相阻塞。 + #[test] + fn different_networks_do_not_block_each_other() { + let first_network = format!("lock-iso-a-{}", std::process::id()); + let second_network = format!("lock-iso-b-{}", std::process::id()); + let first = InstanceLock::acquire(&first_network).expect("网络 A 抢锁"); + let second = InstanceLock::acquire(&second_network).expect("网络 B 抢锁"); + assert_ne!(first.name(), second.name()); + } + + /// 并发获取同一个网络的锁必须全部成功并共享同一个句柄。 + /// + /// 这条用例覆盖"查注册表与抢平台锁不在同一临界区"的竞态:修复前, + /// 后到的线程会查到空条目、再去抢已被占用的平台锁,被误判为外部占用。 + /// 各线程必须持锁到齐后再统一释放,否则先返回的线程会把锁 drop 掉, + /// 后到的线程自然可以重新抢到,测不出真正的竞态。 + #[test] + fn concurrent_acquires_share_the_same_lock() { + const THREADS: usize = 8; + let network = format!("lock-concurrent-{}", std::process::id()); + let barrier = std::sync::Arc::new(std::sync::Barrier::new(THREADS)); + let handles: Vec<_> = (0..THREADS) + .map(|_| { + let network = network.clone(); + let barrier = barrier.clone(); + std::thread::spawn(move || { + let lock = InstanceLock::acquire(&network).expect("并发抢锁都应成功"); + let name = lock.name().to_string(); + // 等所有线程都拿到锁,确保它们同时持有 + barrier.wait(); + name + }) + }) + .collect(); + let mut names = Vec::new(); + for handle in handles { + names.push(handle.join().expect("线程不应 panic")); + } + let first = &names[0]; + assert!( + names.iter().all(|name| name == first), + "并发获取应共享同一把锁,实际得到 {names:?}" + ); + } + + #[test] + fn releasing_allows_acquiring_again() { + let network = format!("lock-release-test-{}", std::process::id()); + { + let _held = InstanceLock::acquire(&network).expect("首次抢锁"); + } + InstanceLock::acquire(&network).expect("释放后应能重新抢到"); + } + + /// 直接验证平台层互斥:绕过进程内共享后,第二个持有者必须被拒绝。 + /// 这一层才是跨进程(cli 与 Desktop 内核同时运行)真正生效的保证。 + #[test] + fn platform_lock_rejects_second_holder() { + let name = format!("vnt-platform-test-{}", std::process::id()); + let first = platform::PlatformLock::try_acquire(&name) + .expect("系统调用不应失败") + .expect("首次应抢到平台锁"); + match platform::PlatformLock::try_acquire(&name) { + Ok(Err(())) => {} + Ok(Ok(_)) => panic!("平台锁应拒绝第二个持有者"), + Err(error) => panic!("系统调用不应失败: {error}"), + } + drop(first); + platform::PlatformLock::try_acquire(&name) + .expect("系统调用不应失败") + .expect("释放后应能重新抢到"); + } + + /// 调用方(main)靠 `downcast_ref` 识别"锁被占用",而错误从 + /// `create_network` 返回时会带上若干层 context,必须仍能取到 `LockHeld`。 + #[test] + fn lock_held_survives_context_wrapping() { + let error = anyhow::Error::new(LockHeld { + name: "vnt-test".to_string(), + }) + .context("创建网络失败"); + let held = error + .downcast_ref::() + .expect("context 包裹后仍应能 downcast 出 LockHeld"); + assert_eq!(held.name, "vnt-test"); + } +} diff --git a/vnt-core/src/utils/mod.rs b/vnt-core/src/utils/mod.rs index 61f2c343..1ddb0786 100644 --- a/vnt-core/src/utils/mod.rs +++ b/vnt-core/src/utils/mod.rs @@ -3,6 +3,7 @@ pub(crate) mod atomic64; pub mod device_id; pub(crate) mod dns_query; pub(crate) mod http_get; +pub mod instance_lock; pub(crate) mod socket; pub mod task_control; pub(crate) mod time {