7 Commits

Author SHA1 Message Date
3db8945e16 refactor(mirror),feat(runtime): 支持在 mirror.lua 中通过 tools_dir 设置自定义目录;优化参数解析与 Command 构建逻辑
- 新增 Lua 动态配置 tools 目录并返回完整路径
- 将 `resolve_args` 和 `to_command` 改为接受泛型 `IntoIterator`,解耦参数来源
- 统一使用 `chain` 零拷贝合并预设参数与运行时参数,消除多余堆分配
- 提权回退分支改为直接复用 `cmd.get_args()`,修复提权时 `mr:` 别名未展开的缺陷
- 规范参数与变量命名,完善代码注释
2026-08-28 17:21:29 +08:00
219a6b3d51 refactor(validators): 优化别名解析流程
- 新增 parse_tokens 按空格切分字符串
- 其他优化
2026-08-26 17:47:21 +08:00
9e1051737a refactor: 新增别名解析流程
- 封装通用标量/数组校验与提取方法
- 将别名解析拆分为数据清洗、循环引用检测与拓扑展开三阶段
- 重命名项目为 mirror
- 其他优化
2026-08-26 11:52:55 +08:00
8aba995fb0 refactor(main): 优化 Lua 配置解析与校验逻辑,
- 优化 Lua 配置解析与校验逻辑
- 清理废弃的注释代码
2026-08-25 15:12:20 +08:00
0ac7a07133 refactor(validators,main): 重构 Lua 配置解析与校验逻辑,提取 LuaValidator 模块; 抽离进程执行与 Win32 提权逻辑
- 重构 Lua 配置解析与校验逻辑
- 将控制台事件监听与 UAC 提权执行逻辑迁移至 win.rs 模块
- 简化 main 函数,提升代码可读性与模块化程度
- 清理废弃的注释代码
2026-08-24 20:27:35 +08:00
75103dae3c fix(config): 优化 lua 数据校验逻辑
- 新增 parse_sequence 统一处理数组校验
2026-08-21 20:31:15 +08:00
c7999a90f6 fix(config): 优化 lua 数据校验逻辑
- 新增 ValueValidator 优化结构化校验逻辑
2026-08-21 17:29:40 +08:00
18 changed files with 2281 additions and 867 deletions

570
Cargo.lock generated Normal file
View File

@@ -0,0 +1,570 @@
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 4
[[package]]
name = "aho-corasick"
version = "1.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba"
dependencies = [
"memchr",
]
[[package]]
name = "anyhow"
version = "1.0.104"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
[[package]]
name = "autocfg"
version = "1.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
[[package]]
name = "bitflags"
version = "2.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
[[package]]
name = "bstr"
version = "1.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6bb31b46c14244e20ee9984b11bf5c992b91fb6939fea616e3512c8baecdbe5f"
dependencies = [
"memchr",
"serde_core",
]
[[package]]
name = "cc"
version = "1.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "509591b7bcd67f4ef775afad7662703b4935daaa6ec0e5605cfb1090b32a2b6d"
dependencies = [
"find-msvc-tools",
"shlex",
]
[[package]]
name = "cfg-if"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
[[package]]
name = "crossbeam-channel"
version = "0.5.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d85363c37faeca707aef026efa9f3b34d077bce547e48f770770625c6013679e"
dependencies = [
"crossbeam-utils",
]
[[package]]
name = "crossbeam-utils"
version = "0.8.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
[[package]]
name = "deranged"
version = "0.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
[[package]]
name = "dunce"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
[[package]]
name = "either"
version = "1.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
[[package]]
name = "find-msvc-tools"
version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d45db016d36b838f563236e9193d0ee6ce38f3f68b6c94e914b4929c96bbb890"
[[package]]
name = "lazy_static"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
[[package]]
name = "libc"
version = "0.2.189"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
[[package]]
name = "lock_api"
version = "0.4.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
dependencies = [
"scopeguard",
]
[[package]]
name = "log"
version = "0.4.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
[[package]]
name = "lua-src"
version = "550.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "75c110c2fa33f34e0de05448e1f3eb2e0631e7a69e2d8ae1586cffc9fc9f9949"
dependencies = [
"cc",
]
[[package]]
name = "luajit-src"
version = "210.7.2+b925b3e"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "920cf654b23d217c550ceea57c32cd2a413ea27b6d47ed77b5ee0cf655adefa6"
dependencies = [
"cc",
"which",
]
[[package]]
name = "matchers"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
dependencies = [
"regex-automata",
]
[[package]]
name = "memchr"
version = "2.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
[[package]]
name = "mirror"
version = "0.1.0"
dependencies = [
"anyhow",
"dunce",
"mlua",
"tinyjson",
"tracing",
"tracing-appender",
"tracing-subscriber",
"windows-sys",
]
[[package]]
name = "mlua"
version = "0.12.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ad72ffa037cf5970c9860674f32f703fda25d86cf217475fe7a79c5f9961bcaa"
dependencies = [
"bstr",
"either",
"libc",
"mlua-sys",
"num-traits",
"parking_lot",
"rustc-hash",
]
[[package]]
name = "mlua-sys"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "92136787b906d4e55cfe96cd6c62e010bb1a56889d0d6cf83eb016dbad07576b"
dependencies = [
"cc",
"cfg-if",
"libc",
"lua-src",
"luajit-src",
"pkg-config",
]
[[package]]
name = "nu-ansi-term"
version = "0.50.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
dependencies = [
"windows-sys",
]
[[package]]
name = "num-conv"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
[[package]]
name = "num-traits"
version = "0.2.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
dependencies = [
"autocfg",
]
[[package]]
name = "once_cell"
version = "1.21.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
[[package]]
name = "parking_lot"
version = "0.12.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
dependencies = [
"lock_api",
"parking_lot_core",
]
[[package]]
name = "parking_lot_core"
version = "0.9.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
dependencies = [
"cfg-if",
"libc",
"redox_syscall",
"smallvec",
"windows-link",
]
[[package]]
name = "pin-project-lite"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
[[package]]
name = "pkg-config"
version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
[[package]]
name = "powerfmt"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
[[package]]
name = "proc-macro2"
version = "1.0.107"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
dependencies = [
"unicode-ident",
]
[[package]]
name = "quote"
version = "1.0.47"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
dependencies = [
"proc-macro2",
]
[[package]]
name = "redox_syscall"
version = "0.5.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
dependencies = [
"bitflags",
]
[[package]]
name = "regex-automata"
version = "0.4.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2"
dependencies = [
"aho-corasick",
"memchr",
"regex-syntax",
]
[[package]]
name = "regex-syntax"
version = "0.8.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
[[package]]
name = "rustc-hash"
version = "2.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
[[package]]
name = "scopeguard"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
[[package]]
name = "serde_core"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
version = "1.0.229"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.3",
]
[[package]]
name = "sharded-slab"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
dependencies = [
"lazy_static",
]
[[package]]
name = "shlex"
version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
[[package]]
name = "smallvec"
version = "1.15.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
[[package]]
name = "symlink"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a7973cce6668464ea31f176d85b13c7ab3bba2cb3b77a2ed26abd7801688010a"
[[package]]
name = "syn"
version = "2.0.119"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "syn"
version = "3.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "thiserror"
version = "2.0.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f"
dependencies = [
"thiserror-impl",
]
[[package]]
name = "thiserror-impl"
version = "2.0.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.3",
]
[[package]]
name = "thread_local"
version = "1.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ad99c4c6d32803332c548b1af0540b357b3f5fc0be8f6c6bfe8b2e6ae784070"
dependencies = [
"cfg-if",
]
[[package]]
name = "time"
version = "0.3.55"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134"
dependencies = [
"deranged",
"num-conv",
"powerfmt",
"serde_core",
"time-core",
"time-macros",
]
[[package]]
name = "time-core"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109"
[[package]]
name = "time-macros"
version = "0.2.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85"
dependencies = [
"num-conv",
"time-core",
]
[[package]]
name = "tinyjson"
version = "2.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ab95735ea2c8fd51154d01e39cf13912a78071c2d89abc49a7ef102a7dd725a"
[[package]]
name = "tracing"
version = "0.1.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
dependencies = [
"pin-project-lite",
"tracing-attributes",
"tracing-core",
]
[[package]]
name = "tracing-appender"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "050686193eb999b4bb3bc2acfa891a13da00f79734704c4b8b4ef1a10b368a3c"
dependencies = [
"crossbeam-channel",
"symlink",
"thiserror",
"time",
"tracing-subscriber",
]
[[package]]
name = "tracing-attributes"
version = "0.1.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.119",
]
[[package]]
name = "tracing-core"
version = "0.1.36"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
dependencies = [
"once_cell",
"valuable",
]
[[package]]
name = "tracing-log"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
dependencies = [
"log",
"once_cell",
"tracing-core",
]
[[package]]
name = "tracing-subscriber"
version = "0.3.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
dependencies = [
"matchers",
"nu-ansi-term",
"once_cell",
"regex-automata",
"sharded-slab",
"smallvec",
"thread_local",
"tracing",
"tracing-core",
"tracing-log",
]
[[package]]
name = "unicode-ident"
version = "1.0.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
[[package]]
name = "valuable"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
[[package]]
name = "which"
version = "8.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f3ef584124b911bcc3875c2f1472e80f24361ceb789bd1c62b3e9a3df9ff43c"
dependencies = [
"libc",
]
[[package]]
name = "windows-link"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
[[package]]
name = "windows-sys"
version = "0.61.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
dependencies = [
"windows-link",
]

View File

@@ -1,5 +1,5 @@
[package] [package]
name = "rshim" name = "mirror"
version = "0.1.0" version = "0.1.0"
edition = "2024" edition = "2024"
rust-version = "1.94" rust-version = "1.94"
@@ -22,11 +22,17 @@ windows-sys = { version = "0.61.2", features = [
"Win32_System_Threading", "Win32_System_Threading",
"Win32_UI_Shell", "Win32_UI_Shell",
"Win32_UI_WindowsAndMessaging", "Win32_UI_WindowsAndMessaging",
"Win32_Globalization"
] } ] }
dunce = "1.0.5" dunce = "1.0.5"
# 日志 # 日志
tracing = "0.1.44" tracing = "0.1.44"
tracing-subscriber = { version = "0.3", features = ["env-filter"] } tracing-subscriber = { version = "0.3", features = ["env-filter","fmt"] }
tracing-appender = "0.2" tracing-appender = "0.2"
encoding_rs = "0.8.35" tinyjson="2.5.1"
[features]
default = ["args"]
args=[]

View File

@@ -20,7 +20,7 @@ fn main() {
// cargo:rerun-if-changed -> 当指定文件变化时,重新运行 xxx // cargo:rerun-if-changed -> 当指定文件变化时,重新运行 xxx
println!("cargo:rerun-if-changed=build.rs"); println!("cargo:rerun-if-changed=build.rs");
println!("cargo:rerun-if-changed=rshim.lua"); println!("cargo:rerun-if-changed=mirror.lua");
println!("cargo:rustc-env=OUTPUT_DIR={}", output_dir.display()); println!("cargo:rustc-env=OUTPUT_DIR={}", output_dir.display());
// 创建目录 // 创建目录
@@ -34,13 +34,13 @@ fn main() {
} }
// 复制文件 // 复制文件
let source = PathBuf::from(&manifest_dir).join("mimic.lua"); let source = PathBuf::from(&manifest_dir).join("mirror.lua");
let destination = output_dir.join("rshim.lua"); let destination = output_dir.join("mirror.lua");
if source.exists() { if source.exists() {
fs::copy(&source, &destination).expect("Failed to copy mimic.lua"); fs::copy(&source, &destination).expect("Failed to copy mirror.lua");
println!("Copied mimic.lua to: {:?}", destination); println!("Copied mirror.lua to: {:?}", destination);
} else { } else {
panic!("mimic.lua not found at: {:?}", source); panic!("mirror.lua not found at: {:?}", source);
} }
} }

View File

@@ -1,6 +1,6 @@
-- mimic.lua (总控制台) -- mirror.lua (总控制台)
-- __SHIM_DIR__ 已经在 Rust 中注入完毕,并且是正斜杠格式 (例如 C:/Tools) -- __MIRROR_DIR__ 已经在 Rust 中注入完毕,并且是正斜杠格式 (例如 C:/Tools)
local base_dir = __SHIM_DIR__ local base_dir = __MIRROR_DIR__
-- 1. 自定义局部变量,方便复用与后续维护 -- 1. 自定义局部变量,方便复用与后续维护
local python_home = base_dir .. "/tools/python39" local python_home = base_dir .. "/tools/python39"
@@ -13,6 +13,8 @@ return {
target = base_dir .. "/tools/numa/numa.exe", target = base_dir .. "/tools/numa/numa.exe",
-- 追加参数 -- 追加参数
args = { "--help" }, args = { "--help" },
aliases = {},
-- 注入环境变量,使用 get_env 获取宿主机当前值 -- 注入环境变量,使用 get_env 获取宿主机当前值
env = { env = {
PATH = { base_dir .. "/tools/numa", get_env("PATH") } PATH = { base_dir .. "/tools/numa", get_env("PATH") }

View File

@@ -1,491 +0,0 @@
use mlua::{FromLua, Lua, LuaString, ObjectLike, Table, Value};
use std::collections::HashMap;
use std::ffi::OsString;
use std::fmt;
use std::fmt::Display;
use std::path::PathBuf;
use std::process::Command;
/// 构造一个带上下文的 FromLua 转换错误,便于定位配置问题
fn conversion_error(message: impl Into<String>) -> mlua::Error {
mlua::Error::FromLuaConversionError {
from: "Lua value",
to: "ShimConfig".into(),
message: Some(message.into()),
}
}
/// 将 Lua 字符串转为 Rust 字符串;非 UTF-8 按系统默认的 ANSI/OEM (如 GBK) 进行安全解码
fn lua_string_2_os_string(s: LuaString) -> mlua::Result<OsString> {
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(
"路径包含无效/不支持的字节编码".into(),
));
}
Ok(OsString::from(cow.as_ref()))
}
}
/// 按连续整数下标遍历表的序列部分;存在空洞或非序列键时返回错误,避免静默截断
/// 值分流与上下文分发枚举
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ValueShunt<'a> {
/// 命令行参数元素:仅支持一维基础标量,禁止嵌套 Table
Args,
/// 环境变量值:支持基础标量及多维嵌套 Table递归展平
Env(&'a str),
}
impl<'a> Display for ValueShunt<'a> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Args => write!(f, "命令行参数 (args)"),
Self::Env(name) => write!(f, "环境变量 ({name})"),
}
}
}
impl<'a> ValueShunt<'a> {
fn parse_sequence(&self, tbl: &Table, out: &mut Vec<OsString>) -> mlua::Result<()> {
self.validate_each_sequence_item(tbl, |item| self.collect_into(item, out))
}
fn validate_each_sequence_item(
&self,
tbl: &Table,
mut f: impl FnMut(Value) -> mlua::Result<()>,
) -> mlua::Result<()> {
let mut index = 1i64;
loop {
let item: Value = tbl.raw_get(index)?;
if matches!(item, Value::Nil) {
break;
}
f(item)?;
index += 1;
}
// 校验剩余键:只允许已经被遍历的连续整数键
for pair in tbl.pairs::<Value, Value>() {
let (key, _) = pair?;
match key {
Value::Integer(i) if i >= 1 && i < index => {}
Value::Integer(_) => {
return Err(conversion_error(format!(
"{}{} 个元素为 nil 或不存在(请检查是否漏写引号或变量未定义)",
self, index
)));
}
_ => {
// let label = match self {
// ValueShunt::Args => "命令行参数 (args)".to_string(),
// ValueShunt::Env(n) => format!("环境变量 [{n}]"),
// };
return Err(conversion_error(format!(
"{} 必须是纯列表,不能包含键值对/字典结构",
self
)));
}
}
}
Ok(())
}
}
impl<'a> ValueShunt<'a> {
/// 递归/标量收集实现
pub fn collect_into(&self, value: Value, out: &mut Vec<OsString>) -> mlua::Result<()> {
match value {
Value::Nil => {}
Value::String(s) => out.push(lua_string_2_os_string(s)?),
Value::Integer(i) => out.push(OsString::from(i.to_string())),
Value::Number(n) => {
tracing::warn!(context = %self, value = %n, "浮点数将按十进制格式转换为字符串");
out.push(OsString::from(n.to_string()));
}
Value::Boolean(b) => {
tracing::warn!(context = %self, value = %b, "布尔值将转换为字符串");
out.push(OsString::from(b.to_string()));
}
// 嵌套 Table 仅在 EnvValue 下允许递归展开(支持 get_env("PATH") 等返回的子表)
// Value::Table(tbl) if *self == Self::Env(_) => {
// self.validate_each_sequence_item(&tbl, |item| self.collect_into(item, out))?;
// }
Value::Table(tbl) => {
match self {
Self::Args => {
return Err(conversion_error(format!(
"{} 不支持 {} 类型, 仅支持 string/number/boolean",
self,
tbl.to_string()?
)));
}
Self::Env(_) => {
self.validate_each_sequence_item(&tbl, |item| {
self.collect_into(item, out)
})?;
}
}
// self.validate_each_sequence_item(&tbl, |item| self.collect_into(item, out))?;
}
other => {
return Err(conversion_error(format!(
"{} 不支持 {} 类型, 仅支持 string/number/boolean 或包含这些类型的数组/嵌套数组",
self,
other.type_name(),
)));
}
}
Ok(())
}
}
/// 校验环境变量名的合法性Windows 约束:非空、不含 '='、不含 NUL
fn validate_env_var_name(key_val: &Value, val: &Value) -> mlua::Result<String> {
let key = match key_val {
Value::String(s) => s.to_str()?.to_string(),
_ => {
return Err(conversion_error(format!(
r#"env 配置解析失败:值: {} (类型: {}) 无效的键值!
示例 HOME="/home" 或 PATH = {{ "C:/tools/", "D:/Windows"}}"#,
val.to_string()?,
val.type_name()
)));
}
};
if key.is_empty() {
return Err(conversion_error("环境变量名不能为空"));
}
if key.contains('=') {
return Err(conversion_error(format!(
"环境变量名 [{}] 不能包含 '='",
key
)));
}
if key.contains('\0') {
return Err(conversion_error(format!(
"环境变量名 [{}] 不能包含 NUL 字符",
key
)));
}
Ok(key)
}
/// 递归将任意 Lua Value 展开为扁平的字符串片段列表
// fn collect_env_segments(value: Value, out: &mut Vec<OsString>) -> mlua::Result<()>{OK(())}
#[derive(Debug, Clone, Default)]
pub struct ShimConfig {
pub target: PathBuf,
pub args: Vec<OsString>,
pub env: HashMap<String, OsString>,
}
impl ShimConfig {
/// 根据配置快速构建准备执行的 Command 对象
pub fn to_command<I, S>(&self, runtime_args: I) -> Command
where
I: IntoIterator<Item = S>,
S: AsRef<std::ffi::OsStr>,
{
let mut cmd = Command::new(&self.target);
// 1. 先追加配置里固定的默认参数 (例如: node, --max-old-space-size=4096)
cmd.args(&self.args);
// 2. 透传外部动态运行时参数
cmd.args(runtime_args);
for (key, val) in &self.env {
// 直接应用环境变量Lua 端已经处理好字符串拼接或列表合并)
cmd.env(key, val);
}
cmd
}
}
/// 实现 FromLua Trait由 mlua 自动处理 Table 转换
impl FromLua for ShimConfig {
fn from_lua(value: Value, _lua: &Lua) -> mlua::Result<Self> {
// 脚本返回必须是一个 Table 变体
let table = match value {
Value::Table(t) => t,
_ => {
return Err(conversion_error(format!(
"期望得到一个 Lua Table 配置对象,实际是 {}",
value.type_name()
)));
}
};
// 必填字段: target严格限定为字符串避免数字被 mlua 宽松转为字符串后掩盖错误)
let target = match table.get::<Value>("target")? {
Value::String(s) => lua_string_2_os_string(s)?,
Value::Nil => {
return Err(conversion_error("缺少必填字段 target应为字符串路径"));
}
other => {
return Err(conversion_error(format!(
"target 需为有效的路径且类型必须是字符串,实际类型是 {}",
other.type_name()
)));
}
};
let mut args = Vec::new();
// 可选字段: args缺失或 nil 时默认空列表;保留空字符串参数,与提权路径的 "" 语义一致)
match table.get::<Option<Value>>("args")? {
None | Some(Value::Nil) => {}
Some(Value::Table(tbl)) => ValueShunt::Args.parse_sequence(&tbl, &mut args)?,
Some(other) => {
return Err(conversion_error(format!(
"args 必须是数组列表,实际类型是 {}",
other.type_name()
)));
}
};
// 可选字段: env只允许缺失/nil其他类型由 Option<Table> 转换报错,不再静默忽略)
let env_table = table.get::<Option<Value>>("env")?;
println!("env_table:{:?}", env_table);
let mut env = HashMap::new();
match env_table {
None | Some(Value::Nil) => {}
Some(Value::Table(tbl)) => {
for pair in tbl.pairs::<Value, Value>() {
let (name, value) = pair?;
let name = validate_env_var_name(&name, &value)?;
println!("==========={name}:{:?}", value);
let mut parts = Vec::new();
ValueShunt::Env(&name).collect_into(value, &mut parts)?;
// 空数组/空串也显式设置(空值表示清空该变量),
// 与“未配置该变量(继承宿主环境)”相区分
let joined_os_str = std::env::join_paths(parts).map_err(|e| {
conversion_error(format!(
"环境变量 [{}] 的值无法用系统路径分隔符拼接: {}",
name, e
))
})?;
// 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
)));
}
}
#[cfg(windows)]
{
use std::os::windows::ffi::OsStrExt;
if joined_os_str.encode_wide().any(|c| c == 0) {
return Err(conversion_error(format!(
"环境变量 [{}] 的值不能包含 NUL 字符",
name
)));
}
}
env.insert(name, joined_os_str);
}
}
Some(other) => {
return Err(conversion_error(format!(
"env 必须是键值表 (table),实际类型是 {}",
other.type_name()
)));
}
}
println!("环境变量结果:{:?}", env);
Ok(ShimConfig {
target: PathBuf::from(target),
args,
env,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
fn parse(src: &str) -> mlua::Result<ShimConfig> {
let lua = Lua::new();
// 模拟 runtime 注入的 get_env返回按平台分隔符拆分的段数组空变量返回空表
let get_env = lua
.create_function(|lua, key: String| -> mlua::Result<Table> {
let value = std::env::var(key).unwrap_or_default();
let segments: Vec<String> = 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::<Value>()?;
let t = ShimConfig::from_lua(value, &lua);
println!("读取出的数据:{:?}", t.clone()?);
t
}
#[test]
fn parses_basic_config() {
let cfg = parse(
r#"
return {
target = "C:/tools/git.exe",
args = { "--no-pager" },
env = {
PATH = { "C:/tools/git/bin", "C:/Windows", get_env("PATH") },
HOME = "C:/tools/home",
CONST = 3,
BOOL = true
}
}
"#,
)
.unwrap();
assert_eq!(cfg.target, PathBuf::from("C:/tools/git.exe"));
assert_eq!(cfg.args, vec!["--no-pager"]);
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}"
);
}
#[test]
fn missing_args_and_env_are_empty() {
let cfg = parse(r#"return { target = "t.exe" }"#).unwrap();
assert!(cfg.args.is_empty());
assert!(cfg.env.is_empty());
}
#[test]
fn keeps_empty_args() {
let cfg = parse(r#"return { target = "t.exe", args = { "" } }"#).unwrap();
assert_eq!(cfg.args, vec![""]);
}
#[test]
fn keeps_empty_env_value() {
let cfg = parse(r#"return { target = "t.exe", env = { FOO = "" } }"#).unwrap();
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").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]
fn rejects_wrong_env_type() {
assert!(parse(r#"return { target = "t.exe", env = "PATH=C:/x" }"#).is_err());
}
#[test]
fn rejects_sparse_env_array() {
assert!(parse(r#"return { target = "t.exe", env = { P = { "a", nil, "b" } } }"#).is_err());
}
#[test]
fn rejects_mixed_key_env_array() {
assert!(parse(r#"return { target = "t.exe", env = { P = { a = "b" } } }"#).is_err());
}
#[test]
fn rejects_invalid_env_key() {
assert!(parse(r#"return { target = "t.exe", env = { ["FOO=1"] = "x" } }"#).is_err());
assert!(parse(r#"return { target = "t.exe", env = { [""] = "x" } }"#).is_err());
}
#[test]
fn rejects_nul_in_env_value() {
assert!(parse(r#"return { target = "t.exe", env = { P = { string.char(0) } } }"#).is_err());
}
#[test]
fn rejects_quote_in_env_value() {
// Windows 的 join_paths 对含双引号的路径元素返回错误
assert!(
parse(r#"return { target = "t.exe", env = { P = { string.char(34) } } }"#).is_err()
);
}
#[test]
fn rejects_unsupported_env_value_type() {
assert!(parse(r#"return { target = "t.exe", env = { F = function() end } }"#).is_err());
}
#[test]
fn missing_target_is_error() {
assert!(parse(r#"return { args = { "x" } }"#).is_err());
}
#[test]
fn rejects_non_string_target() {
assert!(parse(r#"return { target = 123 }"#).is_err());
assert!(parse(r#"return { target = false }"#).is_err());
}
#[test]
fn rejects_non_string_args_element() {
// ValueShunt::Args 允许基础标量(数字/布尔)转字符串,仅禁止嵌套表
let cfg = parse(r#"return { target = "t.exe", args = { 1, true } }"#).unwrap();
assert_eq!(cfg.args, vec!["1", "true"]);
}
#[test]
fn rejects_sparse_args() {
assert!(parse(r#"return { target = "t.exe", args = { "a", nil, "b" } }"#).is_err());
}
#[test]
fn rejects_non_table_args() {
assert!(parse(r#"return { target = "t.exe", args = "-B" }"#).is_err());
}
}

25
src/error.rs Normal file
View File

@@ -0,0 +1,25 @@
// 构造一个带上下文的 FromLua 转换错误,便于定位配置问题
/// 配置校验错误
pub fn validation_error(message: impl Into<String>) -> mlua::Error {
mlua::Error::RuntimeError(message.into())
}
/// 将底层 Lua 语法错误转换为用户友好的提示
pub fn syntax_error(err: mlua::Error) -> mlua::Error {
match &err {
mlua::Error::SyntaxError { message, .. } => {
if message.contains("invalid escape sequence") || message.contains("unfinished string")
{
return validation_error(format!(
"配置文件语法错误:检测到非法的字符串转义。\n\
提示:在 Windows 路径末尾或字符串中使用反斜杠 '\\' 时:\n\
1. 请使用双反斜杠转义,例如: \"D:\\\\CNWei\\\\CNW\\\\Rust\\\\\"\n\
2. 或使用 Lua 原始字符串 (Raw String),例如: [[D:\\CNWei\\CNW\\Rust\\]]\n\
底层错误: {}",
message
));
}
}
_ => {}
}
err
}

View File

@@ -11,20 +11,20 @@ pub struct Layout {
impl Layout { impl Layout {
/// 自动解析目录布局: /// 自动解析目录布局:
/// 1. 优先使用环境变量 RSHIM_HOME /// 1. 优先使用环境变量 MIRROR_HOME
/// 2. 兜底回退到当前垫片可执行文件所在目录推断 (exe -> bin -> root) /// 2. 兜底回退到当前垫片可执行文件所在目录推断 (exe -> bin -> root)
pub fn discover(current_exe: &Path) -> Result<Self> { pub fn discover(current_exe: &Path) -> Result<Self> {
// 策略 1: 环境变量优先 // 策略 1: 环境变量优先
if let Ok(home_val) = env::var("MIMIC_HOME") { if let Ok(home_val) = env::var("MIRROR_HOME") {
let trimmed = home_val.trim(); let trimmed = home_val.trim();
if !trimmed.is_empty() { if !trimmed.is_empty() {
debug!(home = %trimmed, "检测到 MIMIC_HOME采用环境变量配置"); debug!(home = %trimmed, "检测到 MIRROR_HOME采用环境变量配置");
return Self::from_base_dir(PathBuf::from(trimmed)); return Self::from_base_dir(PathBuf::from(trimmed));
} }
} }
// 策略 2: 相对路径自动推断兜底 // 策略 2: 相对路径自动推断兜底
debug!("未配置 MIMIC_HOME尝试从当前可执行文件路径推断根目录"); debug!("未配置 MIRROR_HOME尝试从当前可执行文件路径推断根目录");
Self::from_executable(current_exe) Self::from_executable(current_exe)
} }
@@ -36,7 +36,7 @@ impl Layout {
let bin_dir = base_dir.join("bin"); let bin_dir = base_dir.join("bin");
let tools_dir = base_dir.join("tools"); let tools_dir = base_dir.join("tools");
let lua_file = base_dir.join("mimic.lua"); let lua_file = base_dir.join("../mirror.lua");
Ok(Self { Ok(Self {
base_dir, base_dir,

View File

@@ -1,11 +1,23 @@
mod config; extern crate core;
mod layout;
mod logger; pub mod error;
mod runtime; mod layout;
mod shim; mod loader;
mod loader; mod logger;
mod mirror;
mod runtime;
mod spec;
pub mod sys;
mod utils;
mod validators;
pub use config::ShimConfig;
pub use layout::Layout; pub use layout::Layout;
pub use mirror::Mirror;
pub use runtime::LuaRuntime; pub use runtime::LuaRuntime;
pub use shim::Shim; pub use spec::MirrorSpec;
// pub use sys::{
// ERROR_ELEVATION_REQUIRED, EXIT_FAILED_LOAD_SHIM, EXIT_FAILED_SPAWN_PROG, EXIT_FAILED_WAIT_PROG,
// EXIT_PROG_TERMINATED, execute_elevated, set_console_ctrl_handler,
// };
pub use utils::{lua_string_2_os_string, normalize_path_for_lua, parse_tokens};

99
src/loader.rs Normal file
View File

@@ -0,0 +1,99 @@
use crate::spec::MirrorSpec;
use crate::{Layout, LuaRuntime};
use anyhow::{Context, Result, bail};
use mlua::Table;
use std::path::PathBuf;
use tracing::{debug, trace, warn};
pub enum Source {
Lua(LuaRuntime),
Json,
}
/// MirrorSpec 加载器,统一对外暴露多源解析接口
pub struct SpecLoader;
impl SpecLoader {
pub fn resolve_spec(source: &Source, layout: &Layout, target_name: &str) -> Result<MirrorSpec> {
match source {
Source::Lua(r) => Self::resolve_lua_spec(&r, layout, target_name),
Source::Json => Self::load_from_json(layout),
}
}
/// 从 Lua 脚本字符串加载 ShimSpec
fn resolve_lua_spec(
runtime: &LuaRuntime,
layout: &Layout,
target_name: &str,
) -> Result<MirrorSpec> {
// 策略 1: 尝试加载全局配置文件 mirror.lua
let global_config = layout.base_dir.join("mirror.lua");
if global_config.is_file() {
trace!(path = %global_config.display(), "发现全局配置文件,尝试解析");
let root_table: Table = runtime.eval_script(&global_config)?;
// 检查 mirror.lua 中是否存在以 target_name 命名的 Table 节点
if root_table
.contains_key(target_name)
.context("检查全局配置失败")?
{
let target_val: MirrorSpec = root_table
.get(target_name)
.with_context(|| format!("解析配置 [{}] 失败: ", target_name))?;
debug!(
target = %target_name,
source = %global_config.display(),
"成功从全局配置文件中匹配到目标工具"
);
return Ok(target_val);
}
// 穿透:若全局配置文件存在但未包含当前程序的 key继续向下探查
trace!(target = %target_name, "全局配置文件中未包含该目标,继续探查独立配置");
}
let tools_dir: Option<PathBuf> = runtime.tools_dir()?;
// 策略 2: 降级寻找独立文件 ({exe}.lua)优先顺序tools/ > root/
let target_filename = format!("{}.lua", target_name);
let effective_tools_dir = match tools_dir {
Some(t) => {
if t.is_absolute() {
t.join(&target_filename)
} else {
layout.base_dir.join(t).join(&target_filename)
}
}
None => layout.tools_dir.join(&target_filename),
};
let candidates = [
// layout.tools_dir.join(&target_filename),
effective_tools_dir,
layout.base_dir.join(&target_filename),
];
for config_path in &candidates {
if config_path.is_file() {
debug!(path = %config_path.display(), "找到独立配置文件,开始加载");
// 直接泛型反序列化为 MirrorSpec
return runtime.eval_script::<MirrorSpec>(config_path);
}
trace!(path = %config_path.display(), "独立配置文件不存在,跳过");
}
// 策略 3: 所有查找失败,抛出错误
warn!(target = %target_name, "未找到任何匹配的配置文件");
bail!(
"未找到关于 '{}' 的配置。请检查 mirror.lua 或特定的 {}.lua 文件",
target_name,
target_name
);
}
/// 从 Lua 脚本文件加载 ShimSpec
fn load_from_json(layout: &Layout) -> Result<MirrorSpec> {
todo!("实现json来源")
}
}

View File

@@ -1,54 +1,9 @@
use rshim::Shim; use mirror::Mirror;
use std::os::windows::ffi::OsStrExt; use mirror::sys::*;
use std::{env, ffi::CString, mem::size_of, path::Path, process::exit, ptr::null_mut}; use std::ffi::OsString;
use std::{env, process::exit};
use tracing_subscriber::{EnvFilter, fmt}; 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},
System::{
Com::{COINIT_APARTMENTTHREADED, COINIT_DISABLE_OLE1DDE, CoInitializeEx},
Console::{
CTRL_BREAK_EVENT, CTRL_C_EVENT, CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT,
CTRL_SHUTDOWN_EVENT, SetConsoleCtrlHandler,
},
Threading::{GetExitCodeProcess, INFINITE, WaitForSingleObject},
},
UI::{
Shell::{
SEE_MASK_NOASYNC, SEE_MASK_NOCLOSEPROCESS, SHELLEXECUTEINFOA, ShellExecuteExA,
},
WindowsAndMessaging::SW_NORMAL,
},
},
core::BOOL,
};
unsafe extern "system" fn console_ctrl_handler(evt: u32) -> BOOL {
match evt {
CTRL_C_EVENT => TRUE, //eprintln!("ctrl_c handled!"),
CTRL_BREAK_EVENT => TRUE, //eprintln!("ctrl_break handled!"),
CTRL_CLOSE_EVENT => TRUE, //eprintln!("ctrl_close handled!"),
CTRL_LOGOFF_EVENT => TRUE, //eprintln!("ctrl_logoff handled!"),
CTRL_SHUTDOWN_EVENT => TRUE, //eprintln!("ctrl_shutdown handled!"),
other => {
eprintln!("未知的系统事件编号: {},未处理!", other);
FALSE
}
}
}
const EXIT_FAILED_LOAD_SHIM: i32 = 1;
const EXIT_FAILED_SPAWN_PROG: i32 = 2;
const EXIT_FAILED_WAIT_PROG: i32 = 3;
const EXIT_PROG_TERMINATED: i32 = 4;
const ERROR_ELEVATION_REQUIRED: i32 = 740;
fn main() { fn main() {
//初始化日志:输出到 stderr避免污染 shim 子进程的 stdout //初始化日志:输出到 stderr避免污染 shim 子进程的 stdout
fmt() fmt()
@@ -57,48 +12,50 @@ fn main() {
EnvFilter::try_from_env("SHIM_LOG").unwrap_or_else(|_| EnvFilter::new("warn")), EnvFilter::try_from_env("SHIM_LOG").unwrap_or_else(|_| EnvFilter::new("warn")),
) )
.init(); .init();
// 2. 注册 Windows 控制台信号
let res: BOOL = unsafe { SetConsoleCtrlHandler(Some(console_ctrl_handler), TRUE) }; set_console_ctrl_handler();
if res == FALSE { // 3. 解析调用参数与代理 Mirror 配置
eprintln!("警告: 注册控制台中断事件处理器失败。");
}
let calling_args: Vec<_> = env::args_os().skip(1).collect(); let calling_args: Vec<_> = env::args_os().skip(1).collect();
let shim = match Shim::load() { let mr = match Mirror::new() {
Ok(v) => v, Ok(v) => v,
Err(e) => { Err(e) => {
eprintln!("加载代理(shim)配置时发生错误: {}", e); eprintln!("加载代理(mirror)配置时发生错误: {}", e);
exit(EXIT_FAILED_LOAD_SHIM); exit(EXIT_FAILED_LOAD_SHIM);
} }
}; };
let combined_args = mr.spec.args.iter().chain(calling_args.iter());
// 构建 Command复用 ShimConfig::to_command含 args/env 注入),避免重复逻辑 // 构建 Command复用 ShimConfig::to_command含 args/env 注入),避免重复逻辑
let mut cmd = shim.to_command(&calling_args); let mut cmd = mr.to_command(combined_args);
// 提权回退时需要完整参数:配置默认参数 + 调用方透传参数
let mut args = shim.args.clone();
args.extend_from_slice(&calling_args);
let mut child = match cmd.spawn() { let mut child = match cmd.spawn() {
Ok(v) => v, Ok(v) => v,
Err(e) if e.raw_os_error() == Some(ERROR_ELEVATION_REQUIRED) => { Err(e) if e.raw_os_error() == Some(ERROR_ELEVATION_REQUIRED) => {
exit(execute_elevated(&shim.target, &args, Some(&shim.env))) // 提权回退时需要完整参数:配置默认参数 + 调用方透传参数
let elevated_args: Vec<OsString> = cmd.get_args().map(|s| s.to_os_string()).collect();
exit(execute_elevated(
&mr.spec.target,
&elevated_args,
Some(&mr.spec.env),
))
} }
Err(e) => { Err(e) => {
eprintln!( eprintln!(
"启动目标程序 [{}] 时发生错误: {}", "启动目标程序 [{}] 时发生错误: {}",
shim.target.to_string_lossy(), mr.spec.target.to_string_lossy(),
e e
); );
exit(EXIT_FAILED_SPAWN_PROG); exit(EXIT_FAILED_SPAWN_PROG);
} }
}; };
// 5. 等待子进程退出
let status = match child.wait() { let status = match child.wait() {
Ok(v) => v, Ok(v) => v,
Err(e) => { Err(e) => {
eprintln!( eprintln!(
"等待目标程序 [{}] 执行完毕时发生错误: {}", "等待目标程序 [{}] 执行完毕时发生错误: {}",
shim.target.to_string_lossy(), mr.spec.target.to_string_lossy(),
e e
); );
exit(EXIT_FAILED_WAIT_PROG); exit(EXIT_FAILED_WAIT_PROG);
@@ -106,130 +63,3 @@ fn main() {
}; };
exit(status.code().unwrap_or(EXIT_PROG_TERMINATED)) exit(status.code().unwrap_or(EXIT_PROG_TERMINATED))
} }
// 辅助函数:将任意 OsStr 转换为以 \0 结尾的 UTF-16 宽字符向量 (Vec<u16>)
fn to_wide_null(s: impl AsRef<OsStr>) -> Vec<u16> {
s.as_ref().encode_wide().chain(std::iter::once(0)).collect()
}
fn execute_elevated(
program: &Path,
args: &[OsString],
env_vars: Option<&std::collections::HashMap<String, OsString>>,
) -> i32 {
// 若提权启动,在此处将环境变量设置给当前进程(即将弹窗 UAC 的进程,随后会被子进程继承)
if let Some(env_map) = env_vars {
for (k, v) in env_map {
unsafe {
env::set_var(k, v);
}
}
}
// 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_os.push("\"");
for c in arg_str.chars() {
match c {
'\\' => arguments_os.push("\\\\"),
'"' => arguments_os.push("\\\""),
_ => arguments_os.push(c.to_string()),
}
}
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 mut info = SHELLEXECUTEINFOW {
cbSize: size_of::<SHELLEXECUTEINFOW>() 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::<SHELLEXECUTEINFOA>() as u32;
// info.fMask = SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS;
// info.lpVerb = runas.as_ptr().cast::<u8>();
// info.lpFile = program.as_ptr().cast::<u8>();
// info.lpParameters = arguments.as_ptr().cast::<u8>();
// info.nShow = SW_NORMAL;
let res = unsafe {
CoInitializeEx(
null_mut(),
(COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE) as u32,
);
// ShellExecuteExA(&mut info as *mut _)
ShellExecuteExW(&mut info)
};
if res == FALSE || info.hProcess == null_mut() {
return EXIT_FAILED_SPAWN_PROG;
}
// 5. 等待提权子进程执行结束并获取退出状态码
let mut exit_code: u32 = 0;
unsafe {
WaitForSingleObject(info.hProcess, INFINITE);
let ok = GetExitCodeProcess(info.hProcess, &mut exit_code);
CloseHandle(info.hProcess); // 释放进程句柄,防止资源泄露
if ok == FALSE {
return EXIT_FAILED_WAIT_PROG;
}
}
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
}

105
src/mirror.rs Normal file
View File

@@ -0,0 +1,105 @@
use crate::loader::Source;
use crate::loader::SpecLoader;
use crate::{Layout, LuaRuntime, MirrorSpec};
use anyhow::{Context, Result};
use std::collections::HashMap;
use std::env;
use std::ffi::OsString;
use std::process::Command;
use tracing::debug;
pub struct Mirror {
pub spec: MirrorSpec,
pub layout: Layout,
pub target_name: String,
}
impl Mirror {
pub fn new() -> Result<Self> {
let current_exe = env::current_exe().context("获取代理程序路径失败: {}")?;
debug!("当前目录 {}", current_exe.display());
let target_name = current_exe
.file_stem()
.and_then(|s| s.to_str())
.with_context(|| format!("无法从路径 [{}] 提取有效的程序名称", current_exe.display()))?
.to_lowercase();
debug!(
target_name = %target_name,
current_exe = %current_exe.display(),
"开始加载 Mirror 配置"
);
let layout = Layout::discover(&current_exe)?;
debug!(
root_dir = %layout.base_dir.display(),
bin_dir = %layout.bin_dir.display(),
tools_dir = %layout.tools_dir.display(),
"Mirror 目录布局解析完成"
);
let runtime = LuaRuntime::new(&layout)?;
let spec = SpecLoader::resolve_spec(&Source::Lua(runtime), &layout, &target_name)?;
Ok(Self {
spec,
layout,
target_name,
})
}
/// 1. 核心参数路由解析Delegation 到 Spec 的路由逻辑)
fn resolve_args<I, S>(&self, args: I, aliases: &HashMap<String, Vec<OsString>>) -> Vec<OsString>
where
I: IntoIterator<Item = S>,
S: AsRef<std::ffi::OsStr>,
{
let arg_iter = args.into_iter();
// 1. 预分配容量:利用迭代器的下限提示,避免多次 Realloc
let (lower_bound, _) = arg_iter.size_hint();
let mut expanded_args: Vec<OsString> = Vec::with_capacity(lower_bound);
for i in arg_iter {
let os_str = i.as_ref();
let arg_str = os_str.to_string_lossy();
// 检查参数是否带有 mr: 前缀
if let Some(alias_key) = arg_str.strip_prefix("mr:") {
// 如果在加载期打平好的字典中找到了对应的别名,直接展开追加
if let Some(alias_values) = aliases.get(alias_key) {
expanded_args.extend(alias_values.iter().cloned());
} else {
// 如果找不到对应的别名,按原样参数追加
expanded_args.push(os_str.to_os_string());
}
} else {
// 普通参数,直接追加
expanded_args.push(os_str.to_os_string());
}
}
expanded_args
}
pub fn to_command<I, S>(&self, combined_args: I) -> Command
where
I: IntoIterator<Item = S>,
S: AsRef<std::ffi::OsStr>,
{
let mut cmd = Command::new(&self.spec.target);
// 2. 传入预打平的别名字典,查表并展开所有以 `mr:` 为前缀的别名
let final_args = self.resolve_args(combined_args, &self.spec.aliases);
println!("拼接后的命令行参数{:?}",final_args);
// 3. 将解析展开后的无环参数一次性注入 Command
cmd.args(&final_args);
// 4. 注入配置好的环境变量
for (key, val) in &self.spec.env {
// 直接应用环境变量Lua 端已经处理好字符串拼接或列表合并)
cmd.env(key, val);
}
cmd
}
}

View File

@@ -1,15 +1,15 @@
use crate::{ShimConfig, Layout}; use crate::Layout;
use anyhow::{Context, Result, anyhow, bail}; use crate::error::syntax_error;
use crate::utils::normalize_path_for_lua;
use anyhow::{Context, Result};
use mlua::{FromLua, Lua, StdLib, Table, Value}; use mlua::{FromLua, Lua, StdLib, Table, Value};
use std::ffi::OsStr; use std::path::{Path, PathBuf};
use std::path::Path;
use std::{env, fs}; use std::{env, fs};
/// 将 Path 转换为适合 Lua 使用的安全字符串路径
fn normalize_path_for_lua(path: &Path) -> String { const MIRROR_DIR: &str = "__MIRROR_DIR__";
// 自动将 Windows UNC 规范路径转回传统路径 const MIRROR_TOOLS_DIR: &str = "__MIRROR_TOOLS_DIR__";
let simplified = dunce::simplified(path); // const MIRROR_LOG_LEVEL: &str = "__MIRROR_LOG_LEVEL__";
simplified.to_string_lossy().replace('\\', "/") const MIRROR_LOG_DIR: &str = "__MIRROR_LOG_DIR__";
}
pub struct LuaRuntime { pub struct LuaRuntime {
lua: Lua, lua: Lua,
@@ -25,20 +25,66 @@ impl LuaRuntime {
) )
.context("初始化 Lua 失败")?; .context("初始化 Lua 失败")?;
let globals = lua.globals();
// 统一使用 POSIX 风格路径规范化路径字符串 // 统一使用 POSIX 风格路径规范化路径字符串
let base_dir = normalize_path_for_lua(&layout.base_dir); let base_dir = normalize_path_for_lua(&layout.base_dir);
let tools_dir = normalize_path_for_lua(&layout.tools_dir); let tools_dir = normalize_path_for_lua(&layout.tools_dir);
// 1. 注入锚点变量 __SHIM_DIR__shim 安装根目录) // 1. 注入锚点变量 __MIRROR_DIR__shim 安装根目录)
globals Self::register_mirror_dir(&lua, &base_dir)?;
.set("__SHIM_DIR__", base_dir.clone())
.context("设置 __SHIM_DIR__ 环境变量失败")?;
// 2. 安全暴露 get_env 供配置读取环境变量 // 2. 安全暴露 get_env 供配置读取环境变量
// 返回按平台路径分隔符拆分后的段数组(自动剥离引号包裹), // 返回按平台路径分隔符拆分后的段数组(自动剥离引号包裹),
// 便于 PATH 等列表变量直接嵌入数组PATH = { prefix, get_env("PATH") } // 便于 PATH 等列表变量直接嵌入数组PATH = { prefix, get_env("PATH") }
Self::register_get_env(&lua)?;
// 3. 初始化并配置安全/容错的 require 机制
Self::setup_require(&lua, &base_dir, &tools_dir)?;
Ok(Self { lua })
}
/// 执行指定脚本文件,直接返回完整的 Lua Table
pub fn eval_script<T: FromLua>(&self, path: impl AsRef<Path>) -> Result<T> {
let path = path.as_ref();
let bytes =
fs::read(path).with_context(|| format!("无法读取配置文件: {}", path.display()))?;
let code = String::from_utf8(bytes).with_context(|| {
format!(
"{} 不是有效的 UTF-8 文件(请将 Lua 配置文件保存为 UTF-8 编码)",
path.display()
)
})?;
tracing::trace!("code {:?}", code);
// 使用 @<path> 格式标记 Chunk 名称,确保 Lua 报错时能精确回溯到对应的源文件名与行号。
let chunk_name = format!("@{}", path.display());
self.lua
.load(&code)
.set_name(&chunk_name)
.eval::<T>()
.map_err(syntax_error)
.with_context(|| format!("执行 Lua 配置文件失败: {}", path.display()))
}
pub fn tools_dir(&self) -> Result<Option<PathBuf>> {
self.lua
.globals()
.get(MIRROR_TOOLS_DIR)
.context(format!("设置 {MIRROR_TOOLS_DIR} 失败"))
}
}
impl LuaRuntime {
/// 注入全局锚点变量
fn register_mirror_dir(lua: &Lua, base_dir: &str) -> Result<()> {
lua.globals()
.set(MIRROR_DIR, base_dir)
.context(format!("设置 {MIRROR_DIR} 环境变量失败"))?;
Ok(())
}
///注入 get_env 供配置读取环境变量
fn register_get_env(lua: &Lua) -> Result<()> {
let globals = lua.globals();
let get_env = lua let get_env = lua
.create_function(|lua, key: String| -> mlua::Result<Table> { .create_function(|lua, key: String| -> mlua::Result<Table> {
// 缺失变量视为空字符串,拆分后得到空表(不贡献任何路径段) // 缺失变量视为空字符串,拆分后得到空表(不贡献任何路径段)
@@ -73,8 +119,39 @@ impl LuaRuntime {
globals globals
.set("get_env", get_env) .set("get_env", get_env)
.context("挂载 get_env 全局函数失败")?; .context("挂载 get_env 全局函数失败")?;
Ok(())
}
// 3. 配置 package.path确保 require 行为正常 /// 通用的路径注册闭包生成器
fn register_dir_reset_fn(
lua: &Lua,
global_fn_name: &str,
target_global_key: &'static str,
) -> Result<()> {
let get_env = lua.create_function(move |lua, rel_path: String| {
let clean_path = rel_path.trim().trim_start_matches('/');
lua.globals().set(target_global_key, clean_path)?;
Ok(())
})?;
// 4. 将函数绑定至 Lua 全局作用域,供 Lua 调用
lua.globals().set(global_fn_name, get_env)?;
Ok(())
}
fn register_reset_tools_dir(lua: &Lua) -> Result<()> {
Self::register_dir_reset_fn(lua, "reset_tools_dir", MIRROR_TOOLS_DIR)
}
fn register_reset_log_dir(lua: &Lua) -> Result<()> {
Self::register_dir_reset_fn(lua, "reset_log_dir", MIRROR_LOG_DIR)
}
/// 配置 package.path 并包装 require拦截加载失败以提高容错性
fn setup_require(lua: &Lua, base_dir: &str, tools_dir: &str) -> Result<()> {
let globals = lua.globals();
// 1. 安全加固并拓展 package 搜索路径
if let Ok(package) = globals.get::<Table>("package") { if let Ok(package) = globals.get::<Table>("package") {
let _ = package.set("cpath", ""); let _ = package.set("cpath", "");
let _ = package.set("loadlib", Value::Nil); let _ = package.set("loadlib", Value::Nil);
@@ -88,19 +165,14 @@ impl LuaRuntime {
} }
} }
// 4. 包装 require:配置模块缺失/加载失败时记录日志并跳过该条目, // 2. 获取原生 require 并通过闭包直接持有(无需向全局表注入备份变量)
// 而不是让整个 mimic.lua 解析失败(排查问题时日志可见)
let original_require: mlua::Function = globals let original_require: mlua::Function = globals
.get("require") .get("require")
.context("获取内置 require 函数失败")?; .context("获取内置 require 函数失败")?;
globals
.set("_rshim_original_require", &original_require)
.context("备份原始 require 函数失败")?;
let wrapped_require = lua let wrapped_require = lua
.create_function(|lua, module: String| -> mlua::Result<Value> { .create_function(move |_lua, module: String| -> mlua::Result<Value> {
let original: mlua::Function = lua.globals().get("_rshim_original_require")?; match original_require.call::<Value>(module.as_str()) {
match original.call::<Value>(module.clone()) {
Ok(value) => Ok(value), Ok(value) => Ok(value),
Err(e) => { Err(e) => {
tracing::warn!( tracing::warn!(
@@ -114,43 +186,18 @@ impl LuaRuntime {
}) })
.context("创建包装版 require 函数失败")?; .context("创建包装版 require 函数失败")?;
// 3. 覆盖全局 require
globals globals
.set("require", wrapped_require) .set("require", wrapped_require)
.context("重载 require 函数失败")?; .context("重载 require 函数失败")?;
Ok(Self { lua }) Ok(())
} }
/// 执行指定脚本文件,直接返回完整的 Lua Table
pub fn eval_script<T: FromLua>(&self, path: impl AsRef<Path>) -> Result<T> {
let path = path.as_ref();
// println!("path {:?}", path);
let bytes =
fs::read(path).with_context(|| format!("无法读取配置文件: {}", path.display()))?;
let code = String::from_utf8(bytes).with_context(|| {
format!(
"{} 不是有效的 UTF-8 文件(请将 Lua 配置文件保存为 UTF-8 编码)",
path.display()
)
})?;
println!("code {:?}", code);
let chunk_name = format!("@{}", path.display());
self.lua
.load(&code)
.set_name(&chunk_name)
.eval::<T>()
// .map_err(|e| anyhow!(e.to_string()))
.with_context(|| format!("执行 Lua 配置文件失败: {}", path.display()))
} }
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
use crate::Layout; use crate::{Layout, MirrorSpec};
fn test_layout() -> Layout { fn test_layout() -> Layout {
let root = std::env::temp_dir().join("rshim-test-layout"); let root = std::env::temp_dir().join("rshim-test-layout");
@@ -230,7 +277,7 @@ mod tests {
// 复现用户场景PATH = { base_dir .. "/tools/numa", get_env("PATH") } // 复现用户场景PATH = { base_dir .. "/tools/numa", get_env("PATH") }
// 宿主 PATH 即使含双引号,也应拆分后正常拼接,而不是报错 // 宿主 PATH 即使含双引号,也应拆分后正常拼接,而不是报错
let runtime = LuaRuntime::new(&test_layout()).unwrap(); let runtime = LuaRuntime::new(&test_layout()).unwrap();
let cfg: ShimConfig = runtime let cfg: MirrorSpec = runtime
.lua .lua
.load( .load(
r#" r#"

View File

@@ -1,101 +0,0 @@
use crate::{LuaRuntime, ShimConfig, Layout};
use anyhow::{Context, Result, bail};
use mlua::{Table, Value};
use std::env;
use tracing::{debug, trace, warn};
pub struct Shim;
impl Shim {
pub fn load() -> Result<ShimConfig> {
let current_exe = env::current_exe().context("获取代理程序路径失败: {}")?;
debug!("当前目录 {}", current_exe.display());
let target_name = current_exe
.file_stem()
.and_then(|s| s.to_str())
.with_context(|| format!("无法从路径 [{}] 提取有效的程序名称", current_exe.display()))?
.to_lowercase();
debug!(
target_name = %target_name,
current_exe = %current_exe.display(),
"开始加载 Shim 配置"
);
let layout = Layout::discover(&current_exe)?;
debug!(
root_dir = %layout.base_dir.display(),
bin_dir = %layout.bin_dir.display(),
tools_dir = %layout.tools_dir.display(),
"Shim 目录布局解析完成"
);
let runtime = LuaRuntime::new(&layout)?;
Self::resolve_config(&runtime, &layout, &target_name)
}
fn resolve_config(
runtime: &LuaRuntime,
paths: &Layout,
target_name: &str,
) -> Result<ShimConfig> {
// 策略 1: 尝试加载全局配置文件 mimic.lua
let global_config = paths.base_dir.join("rshim.lua");
// if !global_config.is_file() {
// bail!(
// "未找到主配置文件: [{}],请确保在安装根目录创建 rshim.lua",
// global_config.display()
// );
// }
if global_config.is_file() {
trace!(path = %global_config.display(), "发现全局配置文件,尝试解析");
let root_table: Table = runtime.eval_script(&global_config)?;
// 检查 mimic.lua 中是否存在以 target_name 命名的 Table 节点
if root_table
.contains_key(target_name)
.context("检查全局配置失败")?
{
let target_val: ShimConfig = root_table
.get(target_name)
.with_context(|| format!("解析配置 [{}] 失败: ", target_name))?;
debug!(
target = %target_name,
source = %global_config.display(),
"成功从全局配置文件中匹配到目标工具"
);
return Ok(target_val);
}
// 穿透:若全局配置文件存在但未包含当前程序的 key继续向下探查
trace!(target = %target_name, "全局配置文件中未包含该目标,继续探查独立配置");
}
// 策略 2: 降级寻找独立文件 ({exe}.lua)优先顺序tools/ > root/
let target_filename = format!("{}.lua", target_name);
let candidates = [
paths.tools_dir.join(&target_filename),
paths.base_dir.join(&target_filename),
];
for config_path in &candidates {
if config_path.is_file() {
debug!(path = %config_path.display(), "找到独立配置文件,开始加载");
// 直接泛型反序列化为 ShimConfig
return runtime.eval_script::<ShimConfig>(config_path);
}
trace!(path = %config_path.display(), "独立配置文件不存在,跳过");
}
// 策略 3: 所有查找失败,抛出错误
warn!(target = %target_name, "未找到任何匹配的配置文件");
bail!(
"未找到关于 '{}' 的配置。请检查 mimic.lua 或特定的 {}.lua 文件",
target_name,
target_name
);
}
}

109
src/spec.rs Normal file
View File

@@ -0,0 +1,109 @@
use crate::error::validation_error;
use crate::validators::{JsonValidator, LuaValidator};
use anyhow::{Result, anyhow};
use mlua::{FromLua, Lua, Value};
use std::collections::HashMap;
use std::ffi::OsString;
use std::path::PathBuf;
use std::str::FromStr;
use tinyjson::JsonValue;
#[derive(Debug, Clone, Default)]
pub struct MirrorSpec {
pub target: PathBuf,
pub args: Vec<OsString>,
pub aliases: HashMap<String, Vec<OsString>>,
pub env: HashMap<String, OsString>,
}
/// 实现 FromLua Trait由 mlua 自动处理 Table 转换
impl FromLua for MirrorSpec {
fn from_lua(value: Value, _lua: &Lua) -> mlua::Result<Self> {
// 脚本返回必须是一个 Table 变体
let table = match value {
Value::Table(t) => t,
_ => {
return Err(validation_error(format!(
"期望得到一个 Lua Table 配置对象,实际是 {}",
value.type_name()
)));
}
};
// 必填字段: target严格限定为字符串避免数字被 mlua 宽松转为字符串后掩盖错误)
let target = match table.get::<Option<Value>>("target")? {
None | Some(Value::Nil) => {
return Err(validation_error("缺少必填字段 target应为字符串路径"));
}
Some(target_val) => LuaValidator::parse_target(&target_val)?,
};
// 可选字段: args缺失或 nil 时默认空列表;保留空字符串参数,与提权路径的 "" 语义一致)
let args = match table.get::<Option<Value>>("args")? {
None | Some(Value::Nil) => Vec::new(),
Some(args_val) => LuaValidator::parse_args(&args_val)?,
};
// 可选字段: env只允许缺失/nil其他类型由 Option<Table> 转换报错,不再静默忽略)
let env = match table.get::<Option<Value>>("env")? {
None | Some(Value::Nil) => HashMap::new(),
Some(env_val) => LuaValidator::parse_env(&env_val)?,
};
// 可选字段: aliases只允许缺失/nil其他类型由 Option<Table> 转换报错,不再静默忽略)
let aliases = match table.get::<Option<Value>>("aliases")? {
None | Some(Value::Nil) => HashMap::new(),
Some(env_val) => LuaValidator::parse_aliases(&env_val)?,
};
// println!("环境变量结果:{:?}", env);
Ok(MirrorSpec {
target,
args,
aliases,
env,
})
}
}
impl TryFrom<&str> for MirrorSpec {
type Error = anyhow::Error;
fn try_from(json_str: &str) -> Result<Self> {
// 1. 解析 JSON 字符串为 JsonValue 树
let root = JsonValue::from_str(json_str).map_err(|e| anyhow!("JSON 语法错误: {}", e))?;
// 根节点必须是一个 JSON Object
let map: &HashMap<String, JsonValue> = root
.get()
.ok_or_else(|| anyhow!("JSON 根节点必须是 Object 对象"))?;
// 1. target (必填)
let target_val = map
.get("target")
.ok_or_else(|| anyhow!("缺少必填字段: target"))?;
let target = JsonValidator::parse_target(target_val)?;
// 2. args (选填)
let args = match map.get("args") {
Some(args_val) => JsonValidator::parse_args(args_val)?,
None => Vec::new(),
};
// 3. env (选填)
let env = match map.get("env") {
Some(env_val) => JsonValidator::parse_env(env_val)?,
None => HashMap::new(),
};
let aliases = match map.get("aliases") {
Some(env_val) => JsonValidator::parse_aliases(env_val)?,
None => HashMap::new(),
};
Ok(MirrorSpec {
target,
args,
aliases,
env,
})
}
}

6
src/sys.rs Normal file
View File

@@ -0,0 +1,6 @@
mod win;
pub use win::{
ERROR_ELEVATION_REQUIRED, EXIT_FAILED_LOAD_SHIM, EXIT_FAILED_SPAWN_PROG, EXIT_FAILED_WAIT_PROG,
EXIT_PROG_TERMINATED, execute_elevated, set_console_ctrl_handler,
};

152
src/sys/win.rs Normal file
View File

@@ -0,0 +1,152 @@
use std::os::windows::ffi::OsStrExt;
use std::{env, mem::size_of, path::Path, ptr::null_mut};
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},
System::{
Com::{COINIT_APARTMENTTHREADED, COINIT_DISABLE_OLE1DDE, CoInitializeEx},
Console::{
CTRL_BREAK_EVENT, CTRL_C_EVENT, CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT,
CTRL_SHUTDOWN_EVENT, SetConsoleCtrlHandler,
},
Threading::{GetExitCodeProcess, INFINITE, WaitForSingleObject},
},
UI::{
Shell::{SEE_MASK_NOASYNC, SEE_MASK_NOCLOSEPROCESS},
WindowsAndMessaging::SW_NORMAL,
},
},
core::BOOL,
};
pub const EXIT_FAILED_LOAD_SHIM: i32 = 1;
pub const EXIT_FAILED_SPAWN_PROG: i32 = 2;
pub const EXIT_FAILED_WAIT_PROG: i32 = 3;
pub const EXIT_PROG_TERMINATED: i32 = 4;
pub const ERROR_ELEVATION_REQUIRED: i32 = 740;
unsafe extern "system" fn console_ctrl_handler(evt: u32) -> BOOL {
match evt {
CTRL_C_EVENT => TRUE, //eprintln!("ctrl_c handled!"),
CTRL_BREAK_EVENT => TRUE, //eprintln!("ctrl_break handled!"),
CTRL_CLOSE_EVENT => TRUE, //eprintln!("ctrl_close handled!"),
CTRL_LOGOFF_EVENT => TRUE, //eprintln!("ctrl_logoff handled!"),
CTRL_SHUTDOWN_EVENT => TRUE, //eprintln!("ctrl_shutdown handled!"),
other => {
eprintln!("未知的系统事件编号: {},未处理!", other);
FALSE
}
}
}
pub fn set_console_ctrl_handler() {
let res: BOOL = unsafe { SetConsoleCtrlHandler(Some(console_ctrl_handler), TRUE) };
if res == FALSE {
eprintln!("警告: 注册控制台中断事件处理器失败。");
}
}
fn to_wide_null(s: impl AsRef<OsStr>) -> Vec<u16> {
s.as_ref().encode_wide().chain(std::iter::once(0)).collect()
}
pub fn execute_elevated(
program: &Path,
args: &[OsString],
env_vars: Option<&std::collections::HashMap<String, OsString>>,
) -> i32 {
// 若提权启动,在此处将环境变量设置给当前进程(即将弹窗 UAC 的进程,随后会被子进程继承)
if let Some(env_map) = env_vars {
for (k, v) in env_map {
unsafe {
env::set_var(k, v);
}
}
}
// 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_os.push("\"");
for c in arg_str.chars() {
match c {
'\\' => arguments_os.push("\\\\"),
'"' => arguments_os.push("\\\""),
_ => arguments_os.push(c.to_string()),
}
}
arguments_os.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 mut info = SHELLEXECUTEINFOW {
cbSize: size_of::<SHELLEXECUTEINFOW>() 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::<SHELLEXECUTEINFOA>() as u32;
// info.fMask = SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS;
// info.lpVerb = runas.as_ptr().cast::<u8>();
// info.lpFile = program.as_ptr().cast::<u8>();
// info.lpParameters = arguments.as_ptr().cast::<u8>();
// info.nShow = SW_NORMAL;
let res = unsafe {
CoInitializeEx(
null_mut(),
(COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE) as u32,
);
// ShellExecuteExA(&mut info as *mut _)
ShellExecuteExW(&mut info)
};
if res == FALSE || info.hProcess == null_mut() {
return EXIT_FAILED_SPAWN_PROG;
}
// 5. 等待提权子进程执行结束并获取退出状态码
let mut exit_code: u32 = 0;
unsafe {
WaitForSingleObject(info.hProcess, INFINITE);
let ok = GetExitCodeProcess(info.hProcess, &mut exit_code);
CloseHandle(info.hProcess); // 释放进程句柄,防止资源泄露
if ok == FALSE {
return EXIT_FAILED_WAIT_PROG;
}
}
exit_code as i32
}

233
src/utils.rs Normal file
View File

@@ -0,0 +1,233 @@
use mlua::LuaString;
use std::ffi::OsString;
use std::path::Path;
/// 将 Path 转换为适合 Lua 使用的安全字符串路径
pub fn normalize_path_for_lua(path: &Path) -> String {
// 自动将 Windows UNC 规范路径转回传统路径
let simplified = dunce::simplified(path);
simplified.to_string_lossy().replace('\\', "/")
}
/// 将 Lua 字符串转为 Rust 字符串;非 UTF-8 按系统默认的 ANSI/OEM (如 GBK) 进行安全解码
pub fn lua_string_2_os_string(s: &LuaString) -> mlua::Result<OsString> {
let raw_bytes = &s.as_bytes();
// 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));
}
unsafe {
use std::os::windows::ffi::OsStringExt;
use windows_sys::Win32::Globalization::{
CP_ACP, MB_ERR_INVALID_CHARS, MultiByteToWideChar,
};
if raw_bytes.is_empty() {
return Ok(OsString::new());
}
let len = MultiByteToWideChar(
CP_ACP,
MB_ERR_INVALID_CHARS,
raw_bytes.as_ptr(),
raw_bytes.len() as i32,
std::ptr::null_mut(),
0,
);
if len <= 0 {
// 构造一个带上下文的 FromLua 转换错误,便于定位配置问题
return Err(mlua::Error::FromLuaConversionError {
from: "LuaString",
to: "OsString".to_string(),
message: Some(
format!("字符串{:?}包含无效或当前系统无法识别的编码字节", s).to_string(),
),
});
}
let mut buf = vec![0u16; len as usize];
MultiByteToWideChar(
CP_ACP,
MB_ERR_INVALID_CHARS,
raw_bytes.as_ptr(),
raw_bytes.len() as i32,
buf.as_mut_ptr(),
len,
);
Ok(OsString::from_wide(&buf))
}
}
}
/// 将输入的字符串按 Shell 规则切分为独立的 CLI 参数 Token
/// - 自动过滤连续空格
/// - 支持单引号 `'...'` 和双引号 `"..."` 包裹包含空格的参数
pub fn parse_tokens(input: &str) -> Vec<OsString> {
let mut tokens = Vec::new();
let mut current_token = String::new();
let mut in_quote: Option<char> = None;
let mut chars = input.chars().peekable();
while let Some(ch) = chars.next() {
match (ch, in_quote) {
// 处理转义字符 (例如 \")
('\\', _quote) => {
if let Some(&next_ch) = chars.peek() {
let should_escape = if cfg!(windows) {
// Windows 策略:只有在转义引号、反斜杠本身时才剥离 \
// (如果在双引号内部,空格也不应该被 \ 转义)
next_ch == '"' || next_ch == '\'' || next_ch == '\\'
} else {
// Unix 策略:标准 Shell 转义(引号、反斜杠、空格等)
next_ch == '"'
|| next_ch == '\''
|| next_ch == '\\'
|| next_ch.is_whitespace()
};
if should_escape {
chars.next(); // 消耗掉下一个字符
current_token.push(next_ch);
} else {
// 保留 Windows 路径分隔符或未知转义中的 \
current_token.push('\\');
}
} else {
// 结尾孤立的 \
current_token.push('\\');
}
}
// 遇到引号:开启或关闭引号包裹
('"' | '\'', None) => {
in_quote = Some(ch);
}
('"' | '\'', Some(q)) if q == ch => {
in_quote = None;
}
// 引号外部遇到空白字符:切分出一个完整的 Token
(ch, None) if ch.is_whitespace() => {
if !current_token.is_empty() {
tokens.push(OsString::from(std::mem::take(&mut current_token)));
}
}
// 其他字符或引号内部字符:直接追加
(ch, _) => {
current_token.push(ch);
}
}
}
// 收尾最后一个 Token
if !current_token.is_empty() {
tokens.push(OsString::from(current_token));
}
tokens
}
#[cfg(test)]
mod tests {
use super::*;
use std::ffi::OsString;
/// 辅助宏:简化声明与断言对比
macro_rules! assert_tokens {
($input:expr, $expected:expr) => {
let actual = parse_tokens($input);
let expected_os: Vec<OsString> = $expected.into_iter().map(OsString::from).collect();
assert_eq!(
actual, expected_os,
"\n测试输入: {:?}\n期望输出: {:?}\n实际输出: {:?}",
$input, expected_os, actual
);
};
}
#[test]
fn test_parse_tokens_basic_split() {
// 场景 1基础多参数拆分空格分隔
assert_tokens!("cargo run --verbose", vec!["cargo", "run", "--verbose"]);
assert_tokens!("git status", vec!["git", "status"]);
}
#[test]
fn test_parse_tokens_multi_alias_ref() {
// 场景 2多别名混合与组合引用
assert_tokens!(
"mr:run --bin mr:base_flags",
vec!["mr:run", "--bin", "mr:base_flags"]
);
assert_tokens!(
"mr:app1 mr:app2 --flag",
vec!["mr:app1", "mr:app2", "--flag"]
);
}
#[test]
fn test_parse_tokens_continuous_whitespaces() {
// 场景 3连续多空格与制表符过滤
assert_tokens!(
"mr:run --bin \t my_app",
vec!["mr:run", "--bin", "my_app"]
);
assert_tokens!(" cargo build ", vec!["cargo", "build"]);
}
#[test]
fn test_parse_tokens_double_quotes() {
// 场景 4双引号包裹包含空格的参数
assert_tokens!(
"git commit -m \"fix a bug\"",
vec!["git", "commit", "-m", "fix a bug"]
);
assert_tokens!("echo \"hello world\"", vec!["echo", "hello world"]);
}
#[test]
fn test_parse_tokens_single_quotes() {
// 场景 5单引号包裹包含空格的参数
assert_tokens!(
"gcc -O2 'my file.c' -o app",
vec!["gcc", "-O2", "my file.c", "-o", "app"]
);
assert_tokens!(
"python 'script with space.py'",
vec!["python", "script with space.py"]
);
}
#[test]
fn test_parse_tokens_escaped_characters() {
// 场景 6反斜杠转义字符
assert_tokens!("echo hello\\ world", vec!["echo", "hello\\", "world"]);
assert_tokens!(
"echo \"hello \\\"world\\\"\"",
vec!["echo", "hello \"world\""]
);
}
#[test]
fn test_parse_tokens_single_scalar_and_edge_cases() {
// 场景 7单标量参数与边界情况
assert_tokens!("git", vec!["git"]);
assert_tokens!("8000", vec!["8000"]);
assert_tokens!("", Vec::<&str>::new());
assert_tokens!(" ", Vec::<&str>::new());
}
#[test]
fn test_parse_tokens_unclosed_quotes() {
// 场景 8未闭合引号的容错处理会尽量追加到当前 Token 中)
assert_tokens!("echo \"hello world", vec!["echo", "hello world"]);
}
}

810
src/validators.rs Normal file
View File

@@ -0,0 +1,810 @@
use crate::error::validation_error;
use crate::{lua_string_2_os_string, parse_tokens};
use anyhow::{Context, Result, anyhow};
use mlua::{LuaString, Table, Value};
use std::collections::{HashMap, HashSet};
use std::ffi::OsString;
use std::fmt;
use std::path::PathBuf;
use std::str::FromStr;
use tinyjson::JsonValue;
/// Lua 值校验器:针对不同上下文定义校验规则
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LuaValidator {
/// 目标程序路径:必须是字符串路径
Target,
/// 命令行参数元素:仅支持一维基础标量,禁止嵌套 Table
Args,
/// 环境变量值:支持基础标量及多维嵌套 Table递归展平
Env,
Aliases,
}
impl fmt::Display for LuaValidator {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Target => write!(f, "目标路径 (target)"),
Self::Args => write!(f, "命令行参数 (args)"),
Self::Env => write!(f, "环境变量 (env)"),
Self::Aliases => write!(f, "命令行别名 (aliases)"),
}
}
}
impl LuaValidator {
fn parse_sequence(&self, index: i64, item: &Value) -> mlua::Result<()> {
match item {
Value::String(_) | Value::Integer(_) | Value::Number(_) | Value::Boolean(_) => Ok(()),
Value::Table(tbl) => match self {
Self::Env | Self::Aliases => self.validate_sequence_table(tbl),
Self::Args => Err(validation_error(format!(
"{} 仅支持一维数组,不能包含嵌套 Table,索引位置: {index}",
self
))),
Self::Target => Err(validation_error(format!("{} 仅支持字符串", self))),
},
other => Err(validation_error(format!(
"{}{} 个元素类型无效: {}",
self,
index,
other.type_name()
))),
}
}
/// 校验 Table 是否为严格连续的纯数组,并递归校验其内部元素
fn validate_sequence_table(&self, tbl: &Table) -> mlua::Result<()> {
let mut index = 1i64;
// 1. 顺序遍历连续整数索引 1..N
loop {
let item: Value = tbl.raw_get(index)?;
if matches!(&item, Value::Nil) {
break;
}
self.parse_sequence(index, &item)?;
index += 1;
}
// 2. 查漏:校验是否存在空洞索引或字典键 (Key-Value 键值对)
for pair in tbl.pairs::<Value, Value>() {
let (key, _) = pair?;
match key {
Value::Integer(i) if i >= 1 && i < index => {} // 已遍历放行
Value::Integer(_) => {
return Err(validation_error(format!(
"{}{} 个元素为 nil 或不存在(请检查漏写引号或变量未定义)",
self, index
)));
}
_ => {
return Err(validation_error(format!(
"{} 必须是纯列表,不能包含键值对/字典结构",
self
)));
}
}
}
Ok(())
}
/// 底层 NUL 字符跨平台安全检查
fn ensure_no_nul(context: &impl fmt::Display, os_str: &std::ffi::OsStr) -> mlua::Result<()> {
#[cfg(unix)]
{
use std::os::unix::ffi::OsStrExt;
if os_str.as_bytes().contains(&0) {
return Err(conversion_error(format!(
"{} 的值不能包含 NUL 字符",
context
)));
}
}
#[cfg(windows)]
{
use std::os::windows::ffi::OsStrExt;
if os_str.encode_wide().any(|c| c == 0) {
return Err(validation_error(format!(
"{} 的值不能包含 NUL 字符",
context
)));
}
}
Ok(())
}
/// 【纯粹数据转换与展开】将已通过校验的 Value 递归解析为 OsString 动态数组
fn collect_value_into(&self, value: &Value, out: &mut Vec<OsString>) -> mlua::Result<()> {
match value {
Value::Nil => {}
Value::String(s) => {
let os_str = lua_string_2_os_string(s)?;
match self {
Self::Args | Self::Aliases => {
if let Some(str_ref) = os_str.to_str() {
// 使用 Tokenizer 切分空格与引号
out.extend(parse_tokens(str_ref));
} else {
// 对于无法转为 UTF-8 的特殊二进制数据,作为整体追加
out.push(os_str);
}
}
Self::Env => {
out.push(os_str);
}
Self::Target => {}
}
}
Value::Integer(i) => out.push(OsString::from(i.to_string())),
Value::Number(n) => {
tracing::warn!(%self, value = %n, "浮点数将按十进制格式转换为字符串");
out.push(OsString::from(n.to_string()));
}
Value::Boolean(b) => {
tracing::warn!(%self, value = %b, "布尔值将转换为字符串");
out.push(OsString::from(b.to_string()));
}
Value::Table(tbl) => {
let mut index = 1i64;
loop {
let item: Value = tbl.raw_get(index)?;
if matches!(item, Value::Nil) {
break;
}
Self::collect_value_into(self, &item, out)?;
index += 1;
}
}
_ => unreachable!("传入收集器的 Value 应已通过 validate 校验"),
}
Ok(())
}
fn parse_name(name: &Value) -> mlua::Result<String> {
let name_str = match name {
Value::String(s) => match s.to_str() {
Ok(str_ref) => str_ref.to_string(),
Err(_) => return Err(validation_error("环境变量名必须是合法的 UTF-8 字符串")),
},
other => {
return Err(validation_error(format!(
"环境变量键名类型错误:期望 string实际是 {}",
other.type_name()
)));
}
};
if name_str.is_empty() {
return Err(validation_error("环境变量名不能为空"));
}
if name_str.contains('=') {
return Err(validation_error(format!(
"环境变量名 [{}] 不能包含 '='",
name_str
)));
}
if name_str.contains('\0') {
return Err(validation_error(format!(
"环境变量名 [{}] 不能包含 NUL 字符",
name_str
)));
}
Ok(name_str)
}
fn parse_val(&self, name: &str, value: &Value) -> mlua::Result<()> {
match value {
Value::Nil
| Value::String(_)
| Value::Integer(_)
| Value::Number(_)
| Value::Boolean(_) => Ok(()),
Value::Table(tbl) => self.validate_sequence_table(tbl),
other => Err(validation_error(format!(
"{} [{}]不支持 {} 类型, 仅支持 string/number/boolean 或嵌套数组",
self,
name,
other.type_name()
))),
}
}
}
impl LuaValidator {
/// 解析并校验 `target`
pub fn parse_target(value: &Value) -> mlua::Result<PathBuf> {
let ctx = Self::Target;
match value {
Value::String(s) => {
let os_str = lua_string_2_os_string(&s)?;
Self::ensure_no_nul(&ctx, &os_str)?;
Ok(PathBuf::from(os_str))
}
Value::Nil => Err(validation_error("缺少必填字段 target应为字符串路径")),
other => Err(validation_error(format!(
"{} 需为有效的路径且类型必须是字符串,实际类型是 {}",
ctx,
other.type_name()
))),
}
}
/// 解析并校验 `args`
pub fn parse_args(value: &Value) -> mlua::Result<Vec<OsString>> {
{
println!("跟踪args1{}", value.type_name());
#[cfg(not(feature = "args"))]
Ok(Vec::new())
}
#[cfg(feature = "args")]
{
println!("跟踪args1{}", value.type_name());
let ctx = Self::Args;
match value {
Value::Table(tbl) => {
ctx.validate_sequence_table(tbl)?;
let capacity = tbl.raw_len().min(128);
let mut raw_parts = Vec::with_capacity(capacity);
Self::collect_value_into(&ctx, value, &mut raw_parts)?;
for part in &raw_parts {
Self::ensure_no_nul(&ctx, &part)?;
}
Ok(raw_parts)
}
other => Err(validation_error(format!(
"{} 必须是数组列表,实际类型是 {}",
ctx,
other.type_name()
)))?,
}
}
}
/// 校验环境变量名的合法性Windows 约束:非空、不含 '='、不含 NUL
fn parse_env_name(name: &Value) -> mlua::Result<String> {
Self::parse_name(name)
}
/// 解析、校验并拼接单个环境变量键值对 (`key`, `value`) -> (`OsString`)
fn parse_env_val(
context: &LuaValidator,
name: &str,
raw_val: &Value,
) -> mlua::Result<OsString> {
context.parse_val(name, raw_val)?;
// let ctx = format!("{} [{}]", context, name);
let capacity = match raw_val {
Value::Table(t) => t.raw_len().min(128),
Value::Nil => 0,
_ => 1,
};
let mut parts = Vec::with_capacity(capacity);
Self::collect_value_into(&context, raw_val, &mut parts)?;
// context.collect_value_into(raw_val, &mut parts)?;
// 校验每个展开元素的 NUL 字符
for part in &parts {
Self::ensure_no_nul(&name, part)?;
}
// 3. 使用系统路径分隔符拼接数组列表
let joined_os_str = std::env::join_paths(parts).map_err(|e| {
validation_error(format!("{} 的值无法用系统路径分隔符拼接: {}", context, e))
})?;
Ok(joined_os_str)
}
/// 解析整个 `env` Table直接返回安全的环境变量 Map
pub fn parse_env(value: &Value) -> mlua::Result<HashMap<String, OsString>> {
let ctx = Self::Env;
let Value::Table(tbl) = value else {
// 这里作为防御性校验,外部虽然 match 过了,但内层仍保持强类型安全
return Err(validation_error(format!(
"{} 必须是键值表 (table),实际类型是 {}",
ctx,
value.type_name()
)));
};
let mut env_map = HashMap::new();
let mut n = 0i32;
for pair in tbl.pairs::<Value, Value>() {
n += 1;
let (raw_key, raw_val) = pair?;
println!("env {} {}", n, raw_val.type_name());
// 1. 解析并校验 Key拿到安全的 String
let key = Self::parse_env_name(&raw_key)?;
// 2. 借用 &name 传递给 Value 解析器作为上下文
let val = Self::parse_env_val(&ctx, &key, &raw_val)?;
env_map.insert(key, val);
}
Ok(env_map)
}
}
impl LuaValidator {
/// 校验环境变量名的合法性Windows 约束:非空、不含 '='、不含 NUL
fn parse_aliases_name(name: &Value) -> mlua::Result<String> {
Self::parse_name(name)
}
fn parse_aliases_val(
context: &LuaValidator,
name: &str,
raw_val: &Value,
) -> mlua::Result<Vec<OsString>> {
context.parse_val(name, raw_val)?;
// let ctx = format!("{} [{}]", context, name);
// 预估容量:标量为 1表取其实际长度设置上限以防止异常输入
let capacity = match raw_val {
Value::Table(t) => (t.raw_len() as usize).min(16),
Value::Nil => 0,
_ => 1,
};
let mut parts = Vec::with_capacity(capacity);
Self::collect_value_into(context, raw_val, &mut parts)?;
Ok(parts)
}
/// 解析并打平别名表 (aliases)
/// - 支持输入为 Nil / None / Table
/// - 别名的值支持String, Number, Boolean, Nil, " " 空白串, Table(连续数组)
/// - 字符串作为整体参数保存,仅做 trim() 清理首尾空格,不按空格拆分
/// - 包含拓扑展开与死环检测
pub fn parse_aliases(value: &Value) -> mlua::Result<HashMap<String, Vec<OsString>>> {
let ctx = Self::Aliases;
// 1. 处理 nil / None 的情况,直接返回空 HashMap
let Value::Table(table) = value else {
return Err(validation_error(format!(
"{} 必须是键值表 (table) ,当前类型: {}",
ctx,
value.type_name()
)));
};
// 阶段一:提取原始别名映射 (Raw Extraction)
let mut raw_aliases: HashMap<String, Vec<OsString>> = HashMap::new();
for pair in table.pairs::<Value, Value>() {
let (raw_key, raw_val) = pair?;
let key = Self::parse_aliases_name(&raw_key)?;
let val = Self::parse_aliases_val(&ctx, &key, &raw_val)?;
raw_aliases.insert(key, val);
}
// 阶段二:递归拓扑打平与循环引用检测 (Flattening & Cycle Detection)
let mut visited_stack = HashSet::new();
for key in raw_aliases.keys() {
visited_stack.clear();
Self::detect_alias_cycle(key, &raw_aliases, &mut visited_stack)?;
}
// 阶段三:无环前提下的高效展开
let mut flattened_aliases: HashMap<String, Vec<OsString>> =
HashMap::with_capacity(raw_aliases.len());
let mut resolved_args = Vec::new();
for key in raw_aliases.keys() {
resolved_args.clear();
Self::expand_alias_dfs(key, &raw_aliases, &mut resolved_args);
flattened_aliases.insert(key.clone(), resolved_args.clone());
}
Ok(flattened_aliases)
}
/// 仅用于校验别名依赖图中是否存在死循环(不消耗额外的参数拼接内存)
fn detect_alias_cycle(
current_key: &str,
raw_aliases: &HashMap<String, Vec<OsString>>,
visited_stack: &mut HashSet<String>,
) -> mlua::Result<()> {
// 递归栈中再次遇到相同的 Key说明存在死循环
if visited_stack.contains(current_key) {
return Err(validation_error(format!(
"配置加载失败: 检测到别名循环嵌套依赖 'mr:{}'",
current_key
)));
}
if let Some(args) = raw_aliases.get(current_key) {
// 压栈
visited_stack.insert(current_key.to_string());
for arg in args {
let arg_str = arg.to_string_lossy();
if let Some(sub_key) = arg_str.strip_prefix("mr:") {
// 如果引用的子别名在映射表中存在,则深度优先校验
if raw_aliases.contains_key(sub_key) {
Self::detect_alias_cycle(sub_key, raw_aliases, visited_stack)?;
}
}
}
// 出栈(回溯)
visited_stack.remove(current_key);
}
Ok(())
}
/// 安全拓扑展开:在保证绝对无环的前提下递归展开 mr: 前缀参数
fn expand_alias_dfs(
current_key: &str,
raw_aliases: &HashMap<String, Vec<OsString>>,
out: &mut Vec<OsString>,
) {
if let Some(args) = raw_aliases.get(current_key) {
for arg in args {
let arg_str = arg.to_string_lossy();
if let Some(sub_key) = arg_str.strip_prefix("mr:") {
if raw_aliases.contains_key(sub_key) {
// 安全地直接递归展开,无需再检查死循环
Self::expand_alias_dfs(sub_key, raw_aliases, out);
} else {
// 找不到对应的别名,按原样参数输出
out.push(arg.clone());
}
} else {
// 普通参数,直接输出
out.push(arg.clone());
}
}
}
}
}
/// 专用于 JSON (tinyjson) 的类型校验与字段提取器
//当前JsonValidator还为完全可用后期会对其lua配置特别需要处理动态函数生成的值如get_env("PATH")
// 数据结构:{
// "target": "C:/tools/git.exe",
// "args": [
// "--no-pager",
// 2,
// true
// ],
// "env": {
// "PATH": ["C:/tools/git/bin", "C:/Windows"],
// "HOME": "C:/tools/home",
// "CONST": 3,
// "BOOL": true
// }
// }
pub struct JsonValidator;
impl JsonValidator {
/// 校验并解析 target (必填,非空字符串)
pub fn parse_target(val: &JsonValue) -> Result<PathBuf> {
let s: &String = val
.get()
.ok_or_else(|| anyhow!("字段 'target' 必须是字符串"))?;
if s.trim().is_empty() {
return Err(anyhow!("字段 'target' 不能为空字符串"));
}
Ok(PathBuf::from(s))
}
/// 校验并解析 args (选填,必须为字符串数组)
pub fn parse_args(val: &JsonValue) -> Result<Vec<OsString>> {
let args_vec: &Vec<JsonValue> =
val.get().ok_or_else(|| anyhow!("字段 'args' 必须是数组"))?;
args_vec
.iter()
.map(|item| {
let s: &String = item
.get()
.ok_or_else(|| anyhow!("'args' 数组内的元素必须全为字符串"))?;
Ok(OsString::from(s))
})
.collect()
}
/// 校验并解析 env (选填,必须为 KV 对象)
pub fn parse_env(val: &JsonValue) -> Result<HashMap<String, OsString>> {
let env_map: &HashMap<String, JsonValue> = val
.get()
.ok_or_else(|| anyhow!("字段 'env' 必须是 Object 键值对"))?;
let mut result = HashMap::new();
for (k, v) in env_map {
let mut segments = Vec::new();
Self::collect_env_segments(v, &mut segments)?;
if !segments.is_empty() {
// 根据操作系统自动拼接环境变量分隔符 (Windows 为 ';', Unix 为 ':')
#[cfg(windows)]
let sep = std::ffi::OsStr::new(";");
#[cfg(not(windows))]
let sep = std::ffi::OsStr::new(":");
let joined = segments.join(sep);
result.insert(k.clone(), joined);
}
}
Ok(result)
}
pub fn parse_aliases(val: &JsonValue) -> Result<HashMap<String, Vec<OsString>>> {
todo!()
}
// =========================================================================
// 私有辅助方法
// =========================================================================
/// 单个标量节点转换为 OsString (支持 String, Number, Boolean)
fn value_to_os_string(val: &JsonValue, ctx: &str) -> Result<OsString> {
if let Some(s) = val.get::<String>() {
Ok(OsString::from(s))
} else if let Some(n) = val.get::<f64>() {
Ok(OsString::from(n.to_string()))
} else if let Some(b) = val.get::<bool>() {
Ok(OsString::from(b.to_string()))
} else {
Err(anyhow!("{} 内只支持字符串、数字或布尔类型", ctx))
}
}
/// 递归打平 env 节点中的数组/标量值
fn collect_env_segments(val: &JsonValue, segments: &mut Vec<OsString>) -> Result<()> {
if let Some(arr) = val.get::<Vec<JsonValue>>() {
for item in arr {
Self::collect_env_segments(item, segments)?;
}
} else {
let parsed_segment = Self::value_to_os_string(val, "'env' 节点的 Value")?;
segments.push(parsed_segment);
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::MirrorSpec;
use mlua::{FromLua, Lua};
fn parse(src: &str) -> mlua::Result<MirrorSpec> {
let lua = Lua::new();
// 模拟 runtime 注入的 get_env返回按平台分隔符拆分的段数组空变量返回空表
let get_env = lua
.create_function(|lua, key: String| -> mlua::Result<Table> {
let value = std::env::var(key).unwrap_or_default();
let segments: Vec<String> = 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::<Value>()?;
let t = MirrorSpec::from_lua(value, &lua);
println!("读取出的数据:{:?}", t.clone()?);
t
}
#[test]
fn parses_basic_config() {
let cfg = parse(
r#"
return {
target = "C:/tools/git.exe",
args = { "--no-pager",2},
env = {
PATH = { "C:/tools/git/bin", "C:/Windows", get_env("PATH")},
HOME = "C:/tools/home",
CONST = 3,
BOOL = true,
},
aliases = {
-- 1. 整体字符串(会自动 trim 首尾空格,保留为单个参数)
st = "status -s",
-- 2. 连续数组表 (Sequence Table)
lg = { "log", "--oneline", "-n", 10 },
-- 3. 标量数字与布尔值支持
v = 1,
quiet = true,
-- 4. 嵌套别名组合(加载期会自动展开并进行死环检测)
base_log = "log --graph",
all_log = { "mr:base_log", "--all","D:\\CNWei\\CNW\\Rust","D:/CNWei/CNW/Rust/" ,[[D:\CNWei\CNW\Rust\]]},
-- 5. nil 或空字符串(解析为空参数列表)
empty_alias = nil,
blank = " "
}
}
"#,
)
.unwrap();
assert_eq!(cfg.target, PathBuf::from("C:/tools/git.exe"));
// assert_eq!(cfg.args, vec!["--no-pager", "2"]);
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}"
);
// ==================== aliases 断言校验 ====================
// 1. 整体字符串保留原样trim 后),不切分空格
assert_eq!(
cfg.aliases.get("st").unwrap(),
&vec![OsString::from("status"), OsString::from("-s")]
);
// 2. 连续数组表:按顺序转为 OsString 列表
assert_eq!(
cfg.aliases.get("lg").unwrap(),
&vec![
OsString::from("log"),
OsString::from("--oneline"),
OsString::from("-n"),
OsString::from("10")
]
);
// 3. 标量数字与布尔值支持
assert_eq!(cfg.aliases.get("v").unwrap(), &vec![OsString::from("1")]);
assert_eq!(
cfg.aliases.get("quiet").unwrap(),
&vec![OsString::from("true")]
);
// 4. 嵌套别名组合:加载期递归拓扑打平
// base_log 本身为 "log --graph"
assert_eq!(
cfg.aliases.get("base_log").unwrap(),
&vec![OsString::from("log"), OsString::from("--graph")]
);
// all_log 展开 mr:base_log 替换为 "log --graph",追加 "--all"
assert_eq!(
cfg.aliases.get("all_log").unwrap(),
&vec![
OsString::from("log"),
OsString::from("--graph"),
OsString::from("--all"),
OsString::from("D:\\CNWei\\CNW\\Rust"),
OsString::from("D:/CNWei/CNW/Rust/"),
OsString::from("D:\\CNWei\\CNW\\Rust\\"),
]
);
// 5. nil 与纯空白字符串:解析为空 Vec
assert_eq!(cfg.aliases.get("blank").unwrap(), &Vec::<OsString>::new());
// nil 键在遍历表时会被当作空或不存在,不产生 key 或值为空 Vec
assert!(
cfg.aliases
.get("empty_alias")
.map_or(true, |v| v.is_empty())
);
}
#[test]
fn missing_args_and_env_are_empty() {
let cfg = parse(r#"return { target = "t.exe" }"#).unwrap();
assert!(cfg.args.is_empty());
assert!(cfg.env.is_empty());
}
#[test]
fn keeps_empty_args() {
let cfg = parse(r#"return { target = "t.exe", args = { "" } }"#).unwrap();
assert_eq!(cfg.args, vec![""]);
}
#[test]
fn keeps_empty_env_value() {
let cfg = parse(r#"return { target = "t.exe", env = { FOO = "" } }"#).unwrap();
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").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]
fn rejects_wrong_env_type() {
assert!(parse(r#"return { target = "t.exe", env = "PATH=C:/x" }"#).is_err());
}
#[test]
fn rejects_sparse_env_array() {
assert!(parse(r#"return { target = "t.exe", env = { P = { "a", nil, "b" } } }"#).is_err());
}
#[test]
fn rejects_mixed_key_env_array() {
assert!(parse(r#"return { target = "t.exe", env = { P = { a = "b" } } }"#).is_err());
}
#[test]
fn rejects_invalid_env_key() {
assert!(parse(r#"return { target = "t.exe", env = { ["FOO=1"] = "x" } }"#).is_err());
assert!(parse(r#"return { target = "t.exe", env = { [""] = "x" } }"#).is_err());
}
#[test]
fn rejects_nul_in_env_value() {
assert!(parse(r#"return { target = "t.exe", env = { P = { string.char(0) } } }"#).is_err());
}
#[test]
fn rejects_quote_in_env_value() {
// Windows 的 join_paths 对含双引号的路径元素返回错误
assert!(
parse(r#"return { target = "t.exe", env = { P = { string.char(34) } } }"#).is_err()
);
}
#[test]
fn rejects_unsupported_env_value_type() {
assert!(parse(r#"return { target = "t.exe", env = { F = function() end } }"#).is_err());
}
#[test]
fn missing_target_is_error() {
assert!(parse(r#"return { args = { "x" } }"#).is_err());
}
#[test]
fn rejects_non_string_target() {
assert!(parse(r#"return { target = 123 }"#).is_err());
assert!(parse(r#"return { target = false }"#).is_err());
}
#[test]
fn rejects_non_string_args_element() {
// ValueShunt::Args 允许基础标量(数字/布尔)转字符串,仅禁止嵌套表
let cfg = parse(r#"return { target = "t.exe", args = { 1, true } }"#).unwrap();
assert_eq!(cfg.args, vec!["1", "true"]);
}
#[test]
fn rejects_sparse_args() {
assert!(parse(r#"return { target = "t.exe", args = { "a", nil, "b" } }"#).is_err());
}
#[test]
fn rejects_non_table_args() {
assert!(parse(r#"return { target = "t.exe", args = "-B" }"#).is_err());
}
}