From e3cb065b35c1c1e0a81f706a6b23f0ec488e7768 Mon Sep 17 00:00:00 2001 From: CNWei Date: Tue, 18 Aug 2026 11:15:30 +0800 Subject: [PATCH] =?UTF-8?q?fix(shim):=20=E4=BC=98=E5=8C=96=E9=85=8D?= =?UTF-8?q?=E7=BD=AE=E8=A7=A3=E6=9E=90=E3=80=81=E8=B7=A8=E5=B9=B3=E5=8F=B0?= =?UTF-8?q?=E7=BC=96=E7=A0=81=E4=B8=8E=20UAC=20=E6=8F=90=E6=9D=83=E9=80=BB?= =?UTF-8?q?=E8=BE=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 使用 `OsString`/`PathBuf` 替代 `String`，实现跨平台无损编码与命令行参数透传 - 完善 `FromLua` 转换与边界校验，拦截空洞 (`nil`) 及非整数键 - 修复环境变量拼接时由于内置分隔符导致的 `join_paths` 报错 - 优化 Windows 下 UAC 提权执行逻辑，改用宽字符 API (`ShellExecuteExW`) --- Cargo.toml | 3 +- build.rs | 4 +- shims.lua | 10 +++ src/config.rs | 173 +++++++++++++++++++++++++++++++++++-------------- src/main.rs | 138 +++++++++++++++++++++++++++++---------- src/runtime.rs | 130 +++++++++++++++++++++++++++++++++++-- src/shim.rs | 2 +- 7 files changed, 370 insertions(+), 90 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 977a0ed..c1cbe8a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,7 +2,7 @@ name = "rshim" version = "0.1.0" edition = "2024" -rust-version = "1.85" +rust-version = "1.94" license = "MIT OR Unlicense" description = "A fast, safe Rust shim launcher for Scoop" @@ -29,3 +29,4 @@ dunce = "1.0.5" tracing = "0.1.44" tracing-subscriber = { version = "0.3", features = ["env-filter"] } tracing-appender = "0.2" +encoding_rs = "0.8.35" diff --git a/build.rs b/build.rs index fb4c4c0..1905fc7 100644 --- a/build.rs +++ b/build.rs @@ -20,7 +20,7 @@ fn main() { // cargo:rerun-if-changed -> 当指定文件变化时，重新运行 xxx println!("cargo:rerun-if-changed=build.rs"); - println!("cargo:rerun-if-changed=shims.lua"); + println!("cargo:rerun-if-changed=rshim.lua"); println!("cargo:rustc-env=OUTPUT_DIR={}", output_dir.display()); // 创建目录 @@ -35,7 +35,7 @@ fn main() { // 复制文件 let source = PathBuf::from(&manifest_dir).join("shims.lua"); - let destination = output_dir.join("shims.lua"); + let destination = output_dir.join("rshim.lua"); if source.exists() { fs::copy(&source, &destination).expect("Failed to copy shims.lua"); diff --git a/shims.lua b/shims.lua index 6f20176..be57aae 100644 --- a/shims.lua +++ b/shims.lua @@ -9,6 +9,16 @@ return { --------------------------------------------------- -- 1. 标准相对路径 + 正斜杠拼接 (最推荐，绿色便携) --------------------------------------------------- + ["numa"] = { + target = base_dir .. "/tools/numa/numa.exe", + -- 追加参数 + args = { "--help" }, + -- 注入环境变量，使用 get_env 获取宿主机当前值 + env = { + PATH = { base_dir .. "/tools/numa", get_env("PATH") } + } + }, + ["git"] = { target = base_dir .. "/git/bin/git.exe", -- 追加参数 diff --git a/src/config.rs b/src/config.rs index 3166845..900d924 100644 --- a/src/config.rs +++ b/src/config.rs @@ -1,25 +1,43 @@ -use mlua::{FromLua, Lua, Table, Value}; +use mlua::{FromLua, Lua, LuaString, ObjectLike, Table, Value}; use std::collections::HashMap; +use std::ffi::OsString; use std::path::PathBuf; use std::process::Command; /// 构造一个带上下文的 FromLua 转换错误，便于定位配置问题 fn conversion_error(message: impl Into) -> mlua::Error { mlua::Error::FromLuaConversionError { - from: "Lua value".into(), + from: "Lua value", to: "ShimConfig".into(), message: Some(message.into()), } } /// 将 Lua 字符串转为 Rust 字符串；非 UTF-8 字节替换为 U+FFFD 并告警 -fn lua_string_to_string(s: mlua::LuaString) -> String { - match s.to_str() { - Ok(str_val) => str_val.to_string(), - Err(_) => { - tracing::warn!("配置字符串包含非 UTF-8 字节，已替换为 U+FFFD"); - s.to_string_lossy() +fn lua_string_to_os_string(s: LuaString) -> Result { + let raw_bytes = &s.as_bytes().to_vec(); + // 1. Unix 平台：直接零拷贝透传原始字节（无损支持任意编码） + #[cfg(unix)] + { + use std::os::unix::ffi::OsStrExt; + Ok(OsStr::from_bytes(raw_bytes).to_os_string()) + } + // 2. Windows 平台：优先按 UTF-8 解码，失败则按当前系统本地代码页 (ANSI/GBK) 转换 + #[cfg(windows)] + { + // 先尝试标准的 UTF-8 + if let Ok(utf8_str) = std::str::from_utf8(raw_bytes) { + return Ok(OsString::from(utf8_str)); } + + // 非 UTF-8 时，按系统默认的 ANSI/OEM (如 GBK) 进行安全解码 + let (cow, _, had_errors) = encoding_rs::GBK.decode(raw_bytes); + if had_errors { + return Err(mlua::Error::RuntimeError( + "Path contains invalid/unsupported byte encoding".into(), + )); + } + Ok(OsString::from(cow.as_ref())) } } @@ -74,20 +92,20 @@ fn validate_env_key(key: &str) -> mlua::Result<()> { } /// 递归将任意 Lua Value 展开为扁平的字符串片段列表 -fn collect_env_strings(value: Value, out: &mut Vec) -> mlua::Result<()> { +fn collect_env_strings(value: Value, out: &mut Vec) -> mlua::Result<()> { match value { // 1. 字符串 - Value::String(s) => out.push(lua_string_to_string(s)), + Value::String(s) => out.push(lua_string_to_os_string(s)?), // 2. 整数与浮点数 - Value::Integer(i) => out.push(i.to_string()), + Value::Integer(i) => out.push(OsString::from(i.to_string())), Value::Number(n) => { tracing::warn!(value = %n, "环境变量中的浮点数将按十进制格式转换为字符串"); - out.push(n.to_string()); + out.push(OsString::from(n.to_string())); } // 3. 布尔值 Value::Boolean(b) => { tracing::warn!(value = %b, "环境变量中的布尔值将转换为字符串"); - out.push(b.to_string()); + out.push(OsString::from(b.to_string())); } // 4. 表/数组：必须是连续整数下标的纯序列，递归解包（支持任意深度的嵌套数组） Value::Table(tbl) => for_each_sequence_item(&tbl, |item| collect_env_strings(item, out))?, @@ -108,8 +126,8 @@ fn collect_env_strings(value: Value, out: &mut Vec) -> mlua::Result<()> #[derive(Debug, Clone, Default)] pub struct ShimConfig { pub target: PathBuf, - pub args: Vec, - pub env: HashMap, + pub args: Vec, + pub env: HashMap, } impl ShimConfig { @@ -139,6 +157,7 @@ impl ShimConfig { /// 实现 FromLua Trait，由 mlua 自动处理 Table 转换 impl FromLua for ShimConfig { fn from_lua(value: Value, _lua: &Lua) -> mlua::Result { + // 脚本返回必须是一个 Table 变体 let table = match value { Value::Table(t) => t, _ => { @@ -151,25 +170,41 @@ impl FromLua for ShimConfig { // 必填字段: target（严格限定为字符串，避免数字被 mlua 宽松转为字符串后掩盖错误） let target = match table.get::("target")? { - Value::String(s) => lua_string_to_string(s), + Value::String(s) => lua_string_to_os_string(s)?, Value::Nil => { return Err(conversion_error("缺少必填字段 target（应为字符串路径）")); } other => { return Err(conversion_error(format!( - "target 必须是字符串，实际是 {}", + "target 需为有效的路径且类型必须是字符串，实际类型是 {}", other.type_name() ))); } }; // 可选字段: args（缺失或 nil 时默认空列表；保留空字符串参数，与提权路径的 "" 语义一致） + // let args = match table.get::>("args")? { + // None => Vec::new(), + // Some(Value::Table(tbl)) => { + // let mut args = Vec::new(); + // for_each_sequence_item(&tbl, |item| match item { + // Value::String(s) => { + // args.push(lua_string_to_string(s)); + // Ok(()) + // } + // other => Err(conversion_error(format!( + // "args 数组元素必须是字符串，实际是 {}", + // other.type_name() + // ))), + // })?; + // args + // } let args = match table.get::>("args")? { None => Vec::new(), Some(Value::Table(tbl)) => { let mut args = Vec::new(); for_each_sequence_item(&tbl, |item| match item { Value::String(s) => { - args.push(lua_string_to_string(s)); + args.push(lua_string_to_os_string(s)?); Ok(()) } other => Err(conversion_error(format!( @@ -187,7 +222,7 @@ impl FromLua for ShimConfig { } }; // 可选字段: env（只允许缺失/nil，其他类型由 Option 转换报错，不再静默忽略） - let env_table: Option
= table.get("env")?; + let env_table = table.get::>("env")?; println!("env_table:{:?}", env_table); let mut env = HashMap::new(); if let Some(env_table) = env_table { @@ -200,25 +235,36 @@ impl FromLua for ShimConfig { // 空数组/空串也显式设置（空值表示清空该变量）， // 与“未配置该变量（继承宿主环境）”相区分 - let joined_os_str = - std::env::join_paths(parts.iter().map(PathBuf::from)).map_err(|e| { - conversion_error(format!( - "环境变量 [{}] 的值无法用系统路径分隔符拼接: {}", - key, e - )) - })?; - println!("环境变量拼接结果：{:?}", joined_os_str); - - let joined_str = joined_os_str.into_string().map_err(|_| { - conversion_error(format!("环境变量 [{}] 的值不是合法文本", key)) + let joined_os_str = std::env::join_paths(parts).map_err(|e| { + conversion_error(format!( + "环境变量 [{}] 的值无法用系统路径分隔符拼接: {}", + key, e + )) })?; - if joined_str.contains('\0') { - return Err(conversion_error(format!( - "环境变量 [{}] 的值不能包含 NUL 字符", - key - ))); + println!("环境变量拼接结果：{:?}", joined_os_str); + // 检查是否包含非法 NUL 字符 + #[cfg(unix)] + { + use std::os::unix::ffi::OsStrExt; + if joined_os_str.as_bytes().contains(&0) { + return Err(conversion_error(format!( + "环境变量 [{}] 的值不能包含 NUL 字符", + key + ))); + } } - env.insert(key, joined_str); + #[cfg(windows)] + { + use std::os::windows::ffi::OsStrExt; + if joined_os_str.encode_wide().any(|c| c == 0) { + return Err(conversion_error(format!( + "环境变量 [{}] 的值不能包含 NUL 字符", + key + ))); + } + } + + env.insert(key, joined_os_str); } } println!("环境变量结果：{:?}", env); @@ -236,8 +282,26 @@ mod tests { fn parse(src: &str) -> mlua::Result { let lua = Lua::new(); + // 模拟 runtime 注入的 get_env：返回按平台分隔符拆分的段数组（空变量返回空表） + let get_env = lua + .create_function(|lua, key: String| -> mlua::Result
{ + let value = std::env::var(key).unwrap_or_default(); + let segments: Vec = if value.is_empty() { + Vec::new() + } else { + std::env::split_paths(std::ffi::OsStr::new(&value)) + .map(|p| p.to_string_lossy().into_owned()) + .collect() + }; + lua.create_sequence_from(segments) + }) + .unwrap(); + lua.globals().set("get_env", get_env).unwrap(); + let value = lua.load(src).eval::()?; - ShimConfig::from_lua(value, &lua) + let t = ShimConfig::from_lua(value, &lua); + println!("读取出的数据：{:?}", t.clone()?); + t } #[test] @@ -248,8 +312,10 @@ mod tests { target = "C:/tools/git.exe", args = { "--no-pager" }, env = { - PATH = { "C:/tools/git/bin", "C:/Windows" }, + PATH = { "C:/tools/git/bin", "C:/Windows",get_env("PATH") }, HOME = "C:/tools/home", + CONST = 3, + BOOL = true } } "#, @@ -257,13 +323,13 @@ mod tests { .unwrap(); assert_eq!(cfg.target, PathBuf::from("C:/tools/git.exe")); assert_eq!(cfg.args, vec!["--no-pager"]); - assert_eq!( - cfg.env.get("HOME").map(String::as_str), - Some("C:/tools/home") - ); - assert_eq!( - cfg.env.get("PATH").map(String::as_str), - Some("C:/tools/git/bin;C:/Windows") + assert_eq!(cfg.env.get("HOME").unwrap().to_str(), Some("C:/tools/home")); + // PATH 前缀来自配置，随后附加 get_env("PATH") 拆出的宿主 PATH 段 + let path = cfg.env.get("PATH").unwrap().to_str().unwrap(); + assert!( + path == "C:/tools/git/bin;C:/Windows" + || path.starts_with("C:/tools/git/bin;C:/Windows;"), + "unexpected PATH: {path}" ); } @@ -283,13 +349,26 @@ mod tests { #[test] fn keeps_empty_env_value() { let cfg = parse(r#"return { target = "t.exe", env = { FOO = "" } }"#).unwrap(); - assert_eq!(cfg.env.get("FOO").map(String::as_str), Some("")); + assert_eq!(cfg.env.get("FOO").unwrap().to_str(), Some("")); } #[test] fn empty_array_clears_env_var() { let cfg = parse(r#"return { target = "t.exe", env = { PATH = {} } }"#).unwrap(); - assert_eq!(cfg.env.get("PATH").map(String::as_str), Some("")); + assert_eq!(cfg.env.get("PATH").unwrap().to_str(), Some("")); + } + + #[test] + fn expands_nested_env_array() { + // get_env("PATH") 现在返回拆分后的段数组，嵌套表应被递归展开 + let cfg = parse( + r#"return { target = "t.exe", env = { PATH = { "C:/a", { "C:/b", "C:/c" } } } }"#, + ) + .unwrap(); + assert_eq!( + cfg.env.get("PATH").unwrap().to_str(), + Some("C:/a;C:/b;C:/c") + ); } #[test] diff --git a/src/main.rs b/src/main.rs index d17e8e1..38349a6 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,8 +1,13 @@ -use std::{env, ffi::CString, mem::size_of, path::Path, process::exit, ptr::null_mut}; - use rshim::Shim; +use std::os::windows::ffi::OsStrExt; +use std::{env, ffi::CString, mem::size_of, path::Path, process::exit, ptr::null_mut}; use tracing_subscriber::{EnvFilter, fmt}; +use std::ffi::{OsStr, OsString}; + +use windows_sys::Win32::UI::Shell::{SHELLEXECUTEINFOW, ShellExecuteExW}; + +use windows_sys::Win32::Foundation::CloseHandle; use windows_sys::{ Win32::{ Foundation::{FALSE, TRUE}, @@ -58,7 +63,7 @@ fn main() { eprintln!("警告: 注册控制台中断事件处理器失败。"); } - let calling_args: Vec<_> = env::args().skip(1).collect(); + let calling_args: Vec<_> = env::args_os().skip(1).collect(); let shim = match Shim::load() { Ok(v) => v, Err(e) => { @@ -74,7 +79,7 @@ fn main() { let mut args = shim.args.clone(); args.extend_from_slice(&calling_args); - let mut cmd = match cmd.spawn() { + let mut child = match cmd.spawn() { Ok(v) => v, Err(e) if e.raw_os_error() == Some(ERROR_ELEVATION_REQUIRED) => { exit(execute_elevated(&shim.target, &args, Some(&shim.env))) @@ -88,7 +93,7 @@ fn main() { exit(EXIT_FAILED_SPAWN_PROG); } }; - let status = match cmd.wait() { + let status = match child.wait() { Ok(v) => v, Err(e) => { eprintln!( @@ -101,11 +106,15 @@ fn main() { }; exit(status.code().unwrap_or(EXIT_PROG_TERMINATED)) } +// 辅助函数：将任意 OsStr 转换为以 \0 结尾的 UTF-16 宽字符向量 (Vec) +fn to_wide_null(s: impl AsRef) -> Vec { + s.as_ref().encode_wide().chain(std::iter::once(0)).collect() +} fn execute_elevated( program: &Path, - args: &[String], - env_vars: Option<&std::collections::HashMap>, + args: &[OsString], + env_vars: Option<&std::collections::HashMap>, ) -> i32 { // 若提权启动，在此处将环境变量设置给当前进程（即将弹窗 UAC 的进程，随后会被子进程继承） if let Some(env_map) = env_vars { @@ -115,53 +124,112 @@ fn execute_elevated( } } } - - let runas = CString::new("runas").unwrap(); - let program = CString::new(program.to_str().unwrap()).unwrap(); - let mut arguments = String::new(); - for arg in args.iter() { - arguments.push(' '); - if arg.len() == 0 { - arguments.push_str("\"\""); - } else if arg.find(&[' ', '\t', '"'][..]).is_none() { - arguments.push_str(&arg); + // 2. 将参数列表按 Windows 命令行规则拼装为单个命令行字符串 + let mut arguments_os = OsString::new(); + for (i, arg) in args.iter().enumerate() { + if i > 0 { + arguments_os.push(" "); + } + let arg_str = arg.to_string_lossy(); + if arg_str.is_empty() { + arguments_os.push("\"\""); + } else if !arg_str.contains([' ', '\t', '"']) { + arguments_os.push(arg); } else { - arguments.push('"'); - for c in arg.chars() { + // 包含空格或引号时进行标准转义包裹 + arguments_os.push("\""); + for c in arg_str.chars() { match c { - '\\' => arguments.push_str("\\\\"), - '"' => arguments.push_str("\\\""), - c => arguments.push(c), + '\\' => arguments_os.push("\\\\"), + '"' => arguments_os.push("\\\""), + _ => arguments_os.push(c.to_string()), } } - arguments.push('"'); + arguments_os.push("\""); } } + // let runas = CString::new("runas").unwrap(); + // let program = CString::new(program.to_str().unwrap()).unwrap(); + // let mut arguments = String::new(); + // for arg in args.iter() { + // arguments.push(' '); + // if arg.len() == 0 { + // arguments.push_str("\"\""); + // } else if arg.find(&[' ', '\t', '"'][..]).is_none() { + // arguments.push_str(&arg); + // } else { + // arguments.push('"'); + // for c in arg.chars() { + // match c { + // '\\' => arguments.push_str("\\\\"), + // '"' => arguments.push_str("\\\""), + // c => arguments.push(c), + // } + // } + // arguments.push('"'); + // } + // } + // 3. 准备 Windows 宽字符参数 + let runas = to_wide_null("runas"); + let program_wide = to_wide_null(program.as_os_str()); + let arguments_wide = to_wide_null(&arguments_os); - let arguments = CString::new(&arguments[..]).unwrap(); - let mut info = SHELLEXECUTEINFOA::default(); - info.cbSize = size_of::() as u32; - info.fMask = SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS; - info.lpVerb = runas.as_ptr().cast::(); - info.lpFile = program.as_ptr().cast::(); - info.lpParameters = arguments.as_ptr().cast::(); - info.nShow = SW_NORMAL; + let mut info = SHELLEXECUTEINFOW { + cbSize: size_of::() as u32, + fMask: SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS, + hwnd: null_mut(), + lpVerb: runas.as_ptr(), + lpFile: program_wide.as_ptr(), + lpParameters: arguments_wide.as_ptr(), + lpDirectory: null_mut(), + nShow: SW_NORMAL as i32, + hInstApp: null_mut(), + lpIDList: null_mut(), + lpClass: null_mut(), + hkeyClass: null_mut(), + dwHotKey: 0, + Anonymous: unsafe { std::mem::zeroed() }, + hProcess: null_mut(), + }; + // let arguments = CString::new(&arguments[..]).unwrap(); + // let mut info = SHELLEXECUTEINFOA::default(); + // info.cbSize = size_of::() as u32; + // info.fMask = SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS; + // info.lpVerb = runas.as_ptr().cast::(); + // info.lpFile = program.as_ptr().cast::(); + // info.lpParameters = arguments.as_ptr().cast::(); + // info.nShow = SW_NORMAL; let res = unsafe { CoInitializeEx( null_mut(), (COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE) as u32, ); - ShellExecuteExA(&mut info as *mut _) + // ShellExecuteExA(&mut info as *mut _) + ShellExecuteExW(&mut info) }; if res == FALSE || info.hProcess == null_mut() { return EXIT_FAILED_SPAWN_PROG; } - let mut code: u32 = 0; + // 5. 等待提权子进程执行结束并获取退出状态码 + let mut exit_code: u32 = 0; unsafe { WaitForSingleObject(info.hProcess, INFINITE); - if GetExitCodeProcess(info.hProcess, &mut code as *mut _) == FALSE { + let ok = GetExitCodeProcess(info.hProcess, &mut exit_code); + CloseHandle(info.hProcess); // 释放进程句柄，防止资源泄露 + + if ok == FALSE { return EXIT_FAILED_WAIT_PROG; } } - code as i32 + + exit_code as i32 + + // let mut code: u32 = 0; + // unsafe { + // WaitForSingleObject(info.hProcess, INFINITE); + // if GetExitCodeProcess(info.hProcess, &mut code as *mut _) == FALSE { + // return EXIT_FAILED_WAIT_PROG; + // } + // } + // code as i32 } diff --git a/src/runtime.rs b/src/runtime.rs index 651fb10..0122a10 100644 --- a/src/runtime.rs +++ b/src/runtime.rs @@ -1,6 +1,7 @@ use crate::error::ShimError; use crate::{ShimConfig, ShimLayout}; use mlua::{FromLua, Lua, StdLib, Table, Value}; +use std::ffi::OsStr; use std::path::Path; use std::{env, fs}; /// 将 Path 转换为适合 Lua 使用的安全字符串路径 @@ -36,9 +37,36 @@ impl LuaRuntime { .map_err(|e| ShimError::Environment(e.to_string()))?; // 2. 安全暴露 get_env 供配置读取环境变量 + // 返回按平台路径分隔符拆分后的段数组（自动剥离引号包裹）， + // 便于 PATH 等列表变量直接嵌入数组：PATH = { prefix, get_env("PATH") } let get_env = lua - .create_function(|_, key: String| -> mlua::Result { - Ok(env::var(key).unwrap_or_default()) + .create_function(|lua, key: String| -> mlua::Result
{ + // 缺失变量视为空字符串，拆分后得到空表（不贡献任何路径段） + let value = env::var_os(key).unwrap_or_default(); + // 空输入返回空表；否则按平台分隔符拆分（split_paths 会剥离引号包裹） + if value.is_empty() { + return lua.create_table(); + } + let table = lua.create_table()?; + for (i, p) in env::split_paths(&value).enumerate() { + // 3. 跨平台提取原始字节并转为 LuaString，保证 100% 无损 + #[cfg(unix)] + let lua_str = { + use std::os::unix::ffi::OsStrExt; + lua.create_string(p.as_os_str().as_bytes())? + }; + + #[cfg(windows)] + let lua_str = { + // Windows 路径是 UTF-16，转成字符串或保持其字节表达 + let s = p.to_string_lossy(); + lua.create_string(s.as_bytes())? + }; + + table.set(i + 1, lua_str)?; + } + + Ok(table) }) .map_err(|e| ShimError::Environment(e.to_string()))?; @@ -96,7 +124,7 @@ impl LuaRuntime { /// 执行指定脚本文件，直接返回完整的 Lua Table pub fn eval_script(&self, path: impl AsRef) -> Result { let path = path.as_ref(); - + // println!("path {:?}", path); let bytes = fs::read(path)?; let code = String::from_utf8(bytes).map_err(|e| { ShimError::InvalidConfig(format!( @@ -105,7 +133,7 @@ impl LuaRuntime { e.utf8_error() )) })?; - + println!("code {:?}", code); let chunk_name = format!("@{}", path.display()); self.lua @@ -159,4 +187,98 @@ mod tests { .unwrap(); assert!(matches!(value, Value::Boolean(true))); } + + #[test] + fn get_env_returns_split_table() { + let runtime = LuaRuntime::new(&test_layout()).unwrap(); + let value: Value = runtime + .lua + .load(r#"return get_env("PATH")"#) + .eval() + .unwrap(); + let table = match value { + Value::Table(t) => t, + other => panic!("expected table, got {}", other.type_name()), + }; + assert!( + table.raw_len() >= 1, + "PATH should have at least one segment" + ); + + // split_paths 会剥离引号包裹，拆分段不应再含双引号 + for i in 1..=table.raw_len() { + let seg: String = table.raw_get(i).unwrap(); + assert!( + !seg.contains('"'), + "segment should not contain quote: {seg:?}" + ); + } + } + + #[test] + fn get_env_missing_returns_empty_table() { + let runtime = LuaRuntime::new(&test_layout()).unwrap(); + let value: Value = runtime + .lua + .load(r#"return get_env("RSHIM_TEST_NO_SUCH_VAR_12345")"#) + .eval() + .unwrap(); + match value { + Value::Table(t) => assert_eq!(t.raw_len(), 0), + other => panic!("expected table, got {}", other.type_name()), + } + } + + #[test] + fn path_with_get_env_joins_without_quote_error() { + // 复现用户场景：PATH = { base_dir .. "/tools/numa", get_env("PATH") } + // 宿主 PATH 即使含双引号，也应拆分后正常拼接，而不是报错 + let runtime = LuaRuntime::new(&test_layout()).unwrap(); + let cfg: ShimConfig = runtime + .lua + .load( + r#" + return { + target = __SHIM_DIR__ .. "/tools/numa/numa.exe", + args = { "--help" }, + env = { + PATH = { __SHIM_DIR__ .. "/tools/numa", get_env("PATH") } + } + } + "#, + ) + .eval() + .unwrap(); + + let path = cfg.env.get("PATH").unwrap().to_str().unwrap(); + let prefix = std::env::temp_dir() + .join("rshim-test-layout") + .to_string_lossy() + .replace('\\', "/") + + "/tools/numa;"; + assert!(path.starts_with(&prefix), "unexpected PATH: {path}"); + + // 宿主 PATH 的段应被附加在配置前缀之后 + let host = std::env::var("PATH").unwrap_or_default(); + if !host.is_empty() { + let host_first = std::env::split_paths(&host) + .next() + .unwrap() + .to_string_lossy() + .into_owned(); + assert!( + path.contains(&host_first), + "missing host PATH segment: {host_first}" + ); + } + + // 宿主 PATH 里引号包裹的畸形段（如 "D:\\...\\bin;"）应被原样保留， + // 而不是让整个配置加载失败 + if host.contains('"') { + assert!( + path.contains('"'), + "quoted host segments should be preserved" + ); + } + } } diff --git a/src/shim.rs b/src/shim.rs index 989a591..7410e63 100644 --- a/src/shim.rs +++ b/src/shim.rs @@ -49,7 +49,7 @@ impl Shim { target_name: &str, ) -> Result { // 策略 1: 尝试加载全局配置文件 shims.lua - let global_config = paths.root_dir.join("shims.lua"); + let global_config = paths.root_dir.join("rshim.lua"); if global_config.is_file() { trace!(path = %global_config.display(), "发现全局配置文件，尝试解析"); let root_table: Table = runtime.eval_script(&global_config)?;