音乐控制/解密
This commit is contained in:
1 parent
9e6d73e191
commit
ff1d5cd517
41 files changed
+10827
-4
No files matched your search
Generated
+3
@@ -438,6 +438,7 @@ checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"axum-core 0.4.5",
|
||||
"base64 0.22.1",
|
||||
"bytes",
|
||||
"futures-util",
|
||||
"http",
|
||||
@@ -456,8 +457,10 @@ dependencies = [
|
||||
"serde_json",
|
||||
"serde_path_to_error",
|
||||
"serde_urlencoded",
|
||||
"sha1 0.10.7",
|
||||
"sync_wrapper",
|
||||
"tokio",
|
||||
"tokio-tungstenite",
|
||||
"tower",
|
||||
"tower-layer",
|
||||
"tower-service",
|
||||
|
||||
+21
-1
@@ -41,7 +41,7 @@ chrono = "0.4"
|
||||
reqwest = { version = "0.12", features = ["json", "stream", "multipart", "blocking"] }
|
||||
futures-util = "0.3"
|
||||
tokio = { version = "1", features = ["io-util", "time", "rt-multi-thread", "macros", "sync", "fs", "net"] }
|
||||
axum = "0.7"
|
||||
axum = { version = "0.7", features = ["ws"] }
|
||||
url = "2"
|
||||
zip = "2"
|
||||
dirs = "5"
|
||||
@@ -154,6 +154,12 @@ windows-sys = { version = "0.52", features = [
|
||||
# 注意:0.52 起 ReadFile 定义在 Storage_FileSystem 但被 Win32_System_IO 特性门控,
|
||||
# 两个特性必须同时开启,否则导入会解析失败。
|
||||
"Win32_System_IO",
|
||||
# 音乐模块「解密」:QQ音乐新版 musicex 的 ekey 不落盘,只能联网取;而
|
||||
# authst 仅存在于 QQMusic.exe 运行期内存里 —— 需要进程枚举(ToolHelp:
|
||||
# CreateToolhelp32Snapshot / Process32FirstW)与跨进程读内存
|
||||
# (Diagnostics::Debug::ReadProcessMemory + System::Memory::VirtualQueryEx)。
|
||||
"Win32_System_Diagnostics_ToolHelp",
|
||||
"Win32_System_Diagnostics_Debug",
|
||||
] }
|
||||
# Explorer ShellWindows COM:用于枚举已打开的资源管理器窗口并取当前路径
|
||||
# (快速面板「用资源管理器打开」联动)。依赖 Win32_System_Com 特性。
|
||||
@@ -180,6 +186,20 @@ windows = { version = "0.52", features = [
|
||||
# 专辑与封面不送达,且会话挂在浏览器进程 AUMID 上只显示「未知应用」。
|
||||
"Media",
|
||||
"Win32_System_WinRT",
|
||||
# 音乐模块·手机遥控:GSMTC 全局会话管理器(Windows.Media.Control),
|
||||
# 枚举/监视/控制系统全部 SMTC 会话(MUSIC_REMOTE_PLAN §3.1)
|
||||
"Media_Control",
|
||||
# 手机遥控·UDP beacon:GetAdaptersAddresses 枚举各网卡 IPv4/广播地址
|
||||
# (多网卡/VPN 场景下定向广播,MUSIC_REMOTE_PLAN §3.3)。
|
||||
# GetAdaptersAddresses 另受 Ndis + WinSock 两个 feature 门控(windows 0.52 源码 cfg)
|
||||
"Win32_NetworkManagement_IpHelper",
|
||||
"Win32_NetworkManagement_Ndis",
|
||||
"Win32_Networking_WinSock",
|
||||
# 手机遥控·P1 系统音量:MMDevice + IAudioEndpointVolume(Endpoints 有独立 feature 门控;
|
||||
# IMMDevice::Activate 另需 Com_StructuredStorage)
|
||||
"Win32_Media_Audio",
|
||||
"Win32_Media_Audio_Endpoints",
|
||||
"Win32_System_Com_StructuredStorage",
|
||||
"Security_Cryptography",
|
||||
# 划词取词的智能路径:UIA 直读焦点元素选区(IUIAutomation / ITextProvider)
|
||||
"Win32_UI_Accessibility",
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
//! **临时**端到端验证:对真实 musicex 样本走完整「取密钥 → 解密 → 校验」流程。
|
||||
//!
|
||||
//! 用法(需要 QQ 音乐在运行且已登录):
|
||||
//! ```text
|
||||
//! cargo run --example decrypt_musicex_probe -- "C:\path\to\file.mflac"
|
||||
//! ```
|
||||
//! 验证完即可删除本文件。
|
||||
|
||||
use thing_lib::music::decrypt::probe::{probe_musicex, ProbeOutcome};
|
||||
|
||||
fn main() {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let path = args.next().expect(
|
||||
"用法:decrypt_musicex_probe <文件路径> [输出目录]\n\
|
||||
给了输出目录则会用**生产路径**真正写盘(生成可播放文件)",
|
||||
);
|
||||
let out_dir = args.next();
|
||||
|
||||
match probe_musicex(std::path::Path::new(&path)) {
|
||||
Ok(ProbeOutcome {
|
||||
ekey_len,
|
||||
key_len,
|
||||
raw_key_bytes,
|
||||
cipher_magic,
|
||||
plain_magic,
|
||||
decrypted_bytes,
|
||||
guessed_format,
|
||||
expiration_secs,
|
||||
}) => {
|
||||
println!("=== 成功 ===");
|
||||
println!("ekey 长度 : {ekey_len}");
|
||||
println!("派生密钥长度 : {key_len}");
|
||||
println!(
|
||||
"密钥前 8 字节 : {:02x?}",
|
||||
&raw_key_bytes[..raw_key_bytes.len().min(8)]
|
||||
);
|
||||
println!("密文头 : {:02x?}", cipher_magic);
|
||||
println!("解密后字节数 : {decrypted_bytes}");
|
||||
println!("明文首帧魔数 : {:02x?}", plain_magic);
|
||||
println!("判定格式 : {guessed_format}");
|
||||
println!("ekey 有效期(秒) : {expiration_secs}");
|
||||
if guessed_format == "flac" && plain_magic.starts_with(b"fLaC") {
|
||||
println!("=> 合法 FLAC 头,产物可播");
|
||||
} else {
|
||||
println!("=> 头不合法,需要排查");
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
println!("=== 失败 ===");
|
||||
println!("{e}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
// 可选:调用**生产路径**真正落盘(验证 decrypt_musicex 本身,而不只是核心算法)
|
||||
if let Some(dir) = out_dir {
|
||||
println!("\n=== 生产路径落盘 ===");
|
||||
match thing_lib::music::decrypt::qq_online::decrypt_musicex(
|
||||
std::path::Path::new(&path),
|
||||
std::path::Path::new(&dir),
|
||||
"QQ音乐",
|
||||
|done, total| {
|
||||
if done == total {
|
||||
println!("进度:{done} 字节(完成)");
|
||||
}
|
||||
},
|
||||
) {
|
||||
Ok(outcome) => {
|
||||
let size = std::fs::metadata(&outcome.output)
|
||||
.map(|m| m.len())
|
||||
.unwrap_or(0);
|
||||
println!("产物 : {}", outcome.output.display());
|
||||
println!("大小 : {size} 字节");
|
||||
println!("格式 : {}", outcome.format);
|
||||
println!("备注 : {}", outcome.note);
|
||||
}
|
||||
Err(e) => {
|
||||
println!("落盘失败:{e}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
//! 诊断:枚举全部 GSMTC 会话的时间轴原始值(判断"来源不提供进度"的形态)。
|
||||
//!
|
||||
//! 运行:`cargo run --example gsmtc_dump`
|
||||
|
||||
use std::time::{SystemTime, UNIX_EPOCH};
|
||||
|
||||
use windows::Media::Control::GlobalSystemMediaTransportControlsSessionManager;
|
||||
|
||||
fn ticks_to_unix_ms(ticks: i64) -> i64 {
|
||||
ticks / 10_000 - 62_135_596_800_000
|
||||
}
|
||||
|
||||
fn main() -> windows::core::Result<()> {
|
||||
let mgr = GlobalSystemMediaTransportControlsSessionManager::RequestAsync()?.get()?;
|
||||
let sessions = mgr.GetSessions()?;
|
||||
let now_ms = SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.map(|d| d.as_millis() as i64)
|
||||
.unwrap_or(0);
|
||||
println!("now(unix ms) = {now_ms}");
|
||||
println!("sessions = {}", sessions.Size()?);
|
||||
|
||||
for i in 0..sessions.Size()? {
|
||||
let s = sessions.GetAt(i)?;
|
||||
println!("--- [{}] {}", i, s.SourceAppUserModelId()?);
|
||||
if let Ok(p) = s.TryGetMediaPropertiesAsync()?.get() {
|
||||
println!(
|
||||
" title={:?} artist={:?} album={:?}",
|
||||
p.Title()?,
|
||||
p.Artist()?,
|
||||
p.AlbumTitle()?
|
||||
);
|
||||
}
|
||||
let info = s.GetPlaybackInfo()?;
|
||||
println!(" status={:?}", info.PlaybackStatus()?);
|
||||
if let Ok(c) = info.Controls() {
|
||||
println!(
|
||||
" controls play={} pause={} next={} prev={} seek={}",
|
||||
c.IsPlayEnabled().unwrap_or(false),
|
||||
c.IsPauseEnabled().unwrap_or(false),
|
||||
c.IsNextEnabled().unwrap_or(false),
|
||||
c.IsPreviousEnabled().unwrap_or(false),
|
||||
c.IsPlaybackPositionEnabled().unwrap_or(false)
|
||||
);
|
||||
}
|
||||
let tl = s.GetTimelineProperties()?;
|
||||
let pos = tl.Position()?.Duration;
|
||||
let end = tl.EndTime().map(|t| t.Duration).unwrap_or(-1);
|
||||
let upd = tl.LastUpdatedTime()?.UniversalTime;
|
||||
let upd_ms = ticks_to_unix_ms(upd);
|
||||
println!(
|
||||
" position={}s end={}s lastUpdatedTicks={upd} -> unixMs={upd_ms} (deltaMs={})",
|
||||
pos as f64 / 1e7,
|
||||
end as f64 / 1e7,
|
||||
upd_ms - now_ms
|
||||
);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
//! GSMTC 可用性探测(MUSIC_REMOTE_PLAN §7 P0 第 1 项 / §6 第 1 条)
|
||||
//!
|
||||
//! 关键假设:GSMTC(Windows.Media.Control)在**非打包**桌面应用可用(Windows 10 1809+)。
|
||||
//! 本 example 以普通控制台进程运行(无 package identity),跑通即证明假设成立。
|
||||
//!
|
||||
//! 运行:`cargo run --example gsmtc_probe`
|
||||
//! 建议先在任意播放器(网易云/浏览器/Thing)放一首歌,可看到当前会话的元数据与时间轴。
|
||||
|
||||
use windows::Media::Control::GlobalSystemMediaTransportControlsSessionManager;
|
||||
use windows::core::Result;
|
||||
|
||||
fn main() -> Result<()> {
|
||||
// 1. 取全局会话管理器(失败 = 整个能力需降级,见计划 §3.1 失败策略)
|
||||
let mgr = GlobalSystemMediaTransportControlsSessionManager::RequestAsync()?.get()?;
|
||||
|
||||
// 2. 枚举系统全部 SMTC 会话(注意:0.52 投影里 GetSessions/GetCurrentSession 是同步的)
|
||||
let sessions = mgr.GetSessions()?;
|
||||
println!("[ok] GSMTC 可用(unpackaged),当前会话数: {}", sessions.Size()?);
|
||||
|
||||
// 3. 当前活跃会话的元数据 / 播放状态 / 时间轴
|
||||
// 无会话时 ABI 返回 null → windows-rs 投影为 Err(E_POINTER),按"无会话"处理
|
||||
match mgr.GetCurrentSession() {
|
||||
Ok(cur) => {
|
||||
println!("current: {}", cur.SourceAppUserModelId()?);
|
||||
let p = cur.TryGetMediaPropertiesAsync()?.get()?;
|
||||
println!(" {} - {} | album: {}", p.Artist()?, p.Title()?, p.AlbumTitle()?);
|
||||
println!(" status: {:?}", cur.GetPlaybackInfo()?.PlaybackStatus()?);
|
||||
let tl = cur.GetTimelineProperties()?;
|
||||
println!(
|
||||
" position(ticks): {} | lastUpdated(ticks): {}",
|
||||
tl.Position()?.Duration,
|
||||
tl.LastUpdatedTime()?.UniversalTime
|
||||
);
|
||||
}
|
||||
Err(e) => println!("current session: <none> ({e})(先放一首歌再跑,可看完整元数据)"),
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
//! **临时**校验:用产物解析器确认解密出来的文件是合法音频。
|
||||
//!
|
||||
//! 用法:`cargo run --example verify_audio -- <文件路径>`
|
||||
|
||||
fn main() {
|
||||
let path = std::env::args()
|
||||
.nth(1)
|
||||
.expect("用法:verify_audio <文件路径>");
|
||||
let p = std::path::Path::new(&path);
|
||||
|
||||
let size = std::fs::metadata(p).map(|m| m.len()).unwrap_or(0);
|
||||
println!("文件 : {}", p.display());
|
||||
println!("大小 : {size} 字节");
|
||||
|
||||
// 1) 头部魔数
|
||||
let head = std::fs::read(p).map(|b| b[..16.min(b.len())].to_vec());
|
||||
match head {
|
||||
Ok(h) => println!("首帧 : {:02x?}", h),
|
||||
Err(e) => {
|
||||
println!("读取失败:{e}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
// 2) 交给项目同款的解析器(lofty):能读出时长与格式才算真合法
|
||||
match lofty::probe::Probe::open(p).and_then(|probe| probe.read()) {
|
||||
Ok(tagged) => {
|
||||
use lofty::file::AudioFile;
|
||||
let props = tagged.properties();
|
||||
println!("时长 : {:?}", props.duration());
|
||||
println!("码率 : {:?}", props.audio_bitrate());
|
||||
println!("采样率 : {:?}", props.sample_rate());
|
||||
println!("声道 : {:?}", props.channels());
|
||||
println!("=> lofty 成功解析,文件合法可播");
|
||||
}
|
||||
Err(e) => {
|
||||
println!("lofty 解析失败:{e}");
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -105,6 +105,9 @@ pub mod events {
|
||||
pub const TERMINAL_SETTINGS: &str = "terminal-settings";
|
||||
// 音乐模块:下载任务事件(桥接事件行 → 前端,负载见 bridge.py _emit_event)
|
||||
pub const MUSIC_DOWNLOAD_EVENT: &str = "music-download-event";
|
||||
// 音乐模块:本地解密任务事件(负载见 music::decrypt::DecryptEvent)
|
||||
// 与下载链路同构:命令先回 taskId,进度与逐文件结果都走这个事件。
|
||||
pub const MUSIC_DECRYPT_EVENT: &str = "music-decrypt-event";
|
||||
// 音乐模块:Rust 侧播放引擎(music/audio)。曲目自然播完(缓冲也放完)后发出,无负载
|
||||
pub const MUSIC_AUDIO_ENDED: &str = "music-audio-ended";
|
||||
/// 音乐模块:Rust 侧播放失败(音源打不开 / 解码失败 / 输出设备异常),负载为错误文本
|
||||
|
||||
+31
-3
@@ -7,7 +7,7 @@ mod download_engine;
|
||||
mod logger;
|
||||
mod mihomo_manager;
|
||||
mod monitor_kernel;
|
||||
mod music;
|
||||
pub mod music;
|
||||
mod network_monitor;
|
||||
mod osd_window;
|
||||
mod process_manager;
|
||||
@@ -58,14 +58,19 @@ use music::{
|
||||
feiniu_media_prefix, feiniu_save_connection, feiniu_scan_local, feiniu_test_connection,
|
||||
music_audio_play, music_audio_seek, music_audio_set_playing, music_audio_set_volume,
|
||||
music_audio_state, music_audio_stop,
|
||||
music_cancel_runtime_install, music_download, music_download_cancel, music_env_status,
|
||||
music_cancel_runtime_install, music_decrypt_cancel, music_decrypt_qq_status,
|
||||
music_decrypt_run, music_decrypt_scan,
|
||||
music_download, music_download_cancel, music_env_status,
|
||||
music_get_settings, music_get_sources, music_install_runtime, music_parse_playlist, music_ping,
|
||||
music_resolve, music_save_settings, music_search, music_secret_get, music_secret_set,
|
||||
music_smtc_clear, music_smtc_update_metadata, music_smtc_update_playback_state,
|
||||
music_smtc_update_position,
|
||||
music_stop_bridge, music_update_musicdl, webdav_delete, webdav_get_secret,
|
||||
webdav_save_secret, webdav_test,
|
||||
webdav_upload, AudioEngine, MusicManager, SmtcController,
|
||||
webdav_upload, remote_cancel_pairing, remote_get_config, remote_list_devices,
|
||||
remote_publish_queue, remote_revoke_device, remote_set_enabled, remote_start_pairing,
|
||||
remote_status,
|
||||
AudioEngine, MusicManager, RemoteManager, SmtcController, SmtcMetaCache,
|
||||
};
|
||||
use network_monitor::network_status;
|
||||
use osd_window::{
|
||||
@@ -240,6 +245,12 @@ fn export_bindings() {
|
||||
// music 播放引擎(Rust 侧播放,取代前端 <audio>)
|
||||
music_audio_play, music_audio_set_playing, music_audio_seek, music_audio_stop,
|
||||
music_audio_set_volume, music_audio_state,
|
||||
// music 手机互联(remote,8)
|
||||
remote_get_config, remote_set_enabled, remote_status, remote_start_pairing,
|
||||
remote_cancel_pairing, remote_list_devices, remote_revoke_device,
|
||||
remote_publish_queue,
|
||||
// music 本地解密(「解密」页签)
|
||||
music_decrypt_run, music_decrypt_cancel, music_decrypt_scan, music_decrypt_qq_status,
|
||||
// screenshot(23,豁免 3:get_fullscreen_bmp / take_editor_image_raw 返回 ipc::Response、
|
||||
// compose_copy / compose_png 接收 ipc::Request)
|
||||
screenshot_disable_transitions, screenshot_show_overlay, screenshot_register_shortcut,
|
||||
@@ -334,6 +345,10 @@ pub fn run() {
|
||||
.manage(SmtcController::new())
|
||||
// Rust 侧播放引擎(取代前端 <audio>,见 music/audio 模块注释)
|
||||
.manage(AudioEngine::new())
|
||||
// 手机互联:遥控状态容器(MUSIC_REMOTE_PLAN §5.1 平级 manage)+
|
||||
// SMTC 元数据兜底缓存(remote/glsmtc §5.2 聚合用)
|
||||
.manage(RemoteManager::new())
|
||||
.manage(SmtcMetaCache::default())
|
||||
.invoke_handler(tauri::generate_handler![
|
||||
quit_app,
|
||||
app_version,
|
||||
@@ -433,6 +448,14 @@ pub fn run() {
|
||||
music_audio_stop,
|
||||
music_audio_set_volume,
|
||||
music_audio_state,
|
||||
remote_get_config,
|
||||
remote_set_enabled,
|
||||
remote_status,
|
||||
remote_start_pairing,
|
||||
remote_cancel_pairing,
|
||||
remote_list_devices,
|
||||
remote_revoke_device,
|
||||
remote_publish_queue,
|
||||
webdav_test,
|
||||
webdav_upload,
|
||||
webdav_delete,
|
||||
@@ -440,6 +463,11 @@ pub fn run() {
|
||||
webdav_save_secret,
|
||||
music_secret_get,
|
||||
music_secret_set,
|
||||
// 音乐模块:本地解密(「解密」页签)
|
||||
music_decrypt_run,
|
||||
music_decrypt_cancel,
|
||||
music_decrypt_scan,
|
||||
music_decrypt_qq_status,
|
||||
feiniu_delete_local,
|
||||
network_status,
|
||||
osd_apply_overlay_style,
|
||||
|
||||
@@ -0,0 +1,324 @@
|
||||
//! 音乐模块 · 本地解密的 Tauri 命令层。
|
||||
//!
|
||||
//! 与下载链路同构:命令只做参数校验 + 扫描 + 登记任务,立即返回;进度经
|
||||
//! `music-decrypt-event` 推送。前端 `decryptStore` 常驻监听。
|
||||
//!
|
||||
//! 登记位置见 `MUSIC_DECRYPT_PLAN.md` §4.1——**共 3 处**:
|
||||
//! `music/mod.rs` re-export、`lib.rs` 的 `collect_commands![]` 与 `generate_handler![]`。
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use tauri::{AppHandle, State};
|
||||
|
||||
use super::scan;
|
||||
use super::spawn_batch;
|
||||
use crate::music::MusicManager;
|
||||
|
||||
/// 启动一批本地解密任务。
|
||||
///
|
||||
/// 两种输入方式(二选一,`folder` 优先):
|
||||
/// - `folder`:**文件夹批量**。递归扫描该目录下所有可解密的加密音乐
|
||||
/// (内容判定优先,见 `scan::route`),并按 `root` 还原相对目录结构。
|
||||
/// - `files`:显式文件列表(散选场景)。
|
||||
///
|
||||
/// `in_place = true` 时产物与源文件同目录同名——文件夹批量推荐这样用,
|
||||
/// 符合"就地解出来"的直觉;`false` 则统一输出到 `out_dir`。
|
||||
///
|
||||
/// 返回 `Ok(())` 表示任务已登记并开始执行;逐文件结果走事件。
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn music_decrypt_run(
|
||||
state: State<'_, MusicManager>,
|
||||
app: AppHandle,
|
||||
task_id: String,
|
||||
files: Option<Vec<String>>,
|
||||
folder: Option<String>,
|
||||
root: Option<String>,
|
||||
out_dir: Option<String>,
|
||||
in_place: Option<bool>,
|
||||
) -> Result<(), String> {
|
||||
if task_id.trim().is_empty() {
|
||||
return Err("缺少任务 id".into());
|
||||
}
|
||||
let in_place = in_place.unwrap_or(false);
|
||||
let out_dir = resolve_out_dir(out_dir)?;
|
||||
|
||||
// ---- 收集待处理文件 ----
|
||||
let scanned: Vec<scan::ScannedFile> = match folder.as_deref().map(str::trim) {
|
||||
Some(dir) if !dir.is_empty() => {
|
||||
let folder_path = PathBuf::from(dir);
|
||||
let root_path = root
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|r| !r.is_empty())
|
||||
.map(PathBuf::from)
|
||||
.unwrap_or_else(|| folder_path.clone());
|
||||
let found = scan::scan(&folder_path, Some(&root_path))?;
|
||||
if found.is_empty() {
|
||||
return Err(format!(
|
||||
"{} 里没有找到可解密的加密音乐文件(支持网易云 .ncm 与 QQ音乐 QMC 系列)",
|
||||
folder_path.display()
|
||||
));
|
||||
}
|
||||
found
|
||||
}
|
||||
_ => {
|
||||
let list = files.unwrap_or_default();
|
||||
if list.is_empty() {
|
||||
return Err("未选择任何文件或文件夹".into());
|
||||
}
|
||||
// 散选:保留用户给的路径,不做递归;引擎按内容/后缀判定。
|
||||
// 认不出的文件也建条目,让 worker 回报 unsupported(用户能看到原因)。
|
||||
list.into_iter()
|
||||
.map(|f| {
|
||||
let path = PathBuf::from(&f);
|
||||
let name = path
|
||||
.file_name()
|
||||
.map(|n| n.to_string_lossy().to_string())
|
||||
.unwrap_or_else(|| f.clone());
|
||||
// 先算引擎再移动 `path`(否则所有权已转移)
|
||||
let engine = scan::route(&path).unwrap_or(scan::Engine::Ncm);
|
||||
scan::ScannedFile {
|
||||
path,
|
||||
rel_parent: None,
|
||||
name,
|
||||
// 默认为网易云引擎;真实平台由解密器在 worker 内报错说明
|
||||
engine,
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
};
|
||||
|
||||
// ---- 输入输出相交保护(仅非就地模式;就地模式本来就写在源目录)----
|
||||
let scanned = if in_place {
|
||||
scanned
|
||||
} else {
|
||||
let kept = retain_outside(scanned, &out_dir);
|
||||
if kept.is_empty() {
|
||||
return Err("所选文件都位于输出目录内,已全部跳过(可改用「就地解密」)".into());
|
||||
}
|
||||
kept
|
||||
};
|
||||
|
||||
if scanned.is_empty() {
|
||||
return Err("没有可处理的文件".into());
|
||||
}
|
||||
|
||||
let tasks = state.decrypt_tasks();
|
||||
spawn_batch(app, tasks, task_id, scanned, out_dir, in_place);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 请求取消一个解密任务。
|
||||
///
|
||||
/// 队列级语义(与 `music_download_cancel` 一致):**当前文件会做完**,
|
||||
/// 剩余文件不再开始处理,随后发一个带 `cancelled` 计数的 `finished` 事件。
|
||||
/// 返回是否命中了一个在跑的任务(false 通常表示任务已结束)。
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn music_decrypt_cancel(
|
||||
state: State<'_, MusicManager>,
|
||||
task_id: String,
|
||||
) -> Result<bool, String> {
|
||||
Ok(state.decrypt_tasks().cancel(&task_id))
|
||||
}
|
||||
|
||||
/// 扫描一个文件夹,返回可解密文件的数量与平台分布(**不解密**)。
|
||||
///
|
||||
/// 给 UI 做预览:用户选完文件夹先看到"找到 N 个(网易云 x / QQ音乐 y)",
|
||||
/// 而不是直接开跑一个可能包含几千首的任务。
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn music_decrypt_scan(folder: String, root: Option<String>) -> Result<ScanSummary, String> {
|
||||
let root_path = root
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|r| !r.is_empty())
|
||||
.map(PathBuf::from);
|
||||
let found = scan::scan(Path::new(folder.trim()), root_path.as_deref())?;
|
||||
let ncm = found
|
||||
.iter()
|
||||
.filter(|f| f.engine == scan::Engine::Ncm)
|
||||
.count();
|
||||
Ok(ScanSummary {
|
||||
total: found.len(),
|
||||
ncm,
|
||||
qmc: found.len() - ncm,
|
||||
})
|
||||
}
|
||||
|
||||
/// `music_decrypt_scan` 的返回(前端零手写类型)
|
||||
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct ScanSummary {
|
||||
pub total: usize,
|
||||
pub ncm: usize,
|
||||
pub qmc: usize,
|
||||
}
|
||||
|
||||
/// 探测 QQ 音乐**在线取密钥**能力(新版 musicex 文件解密的前置条件)。
|
||||
///
|
||||
/// 只读本机信息,不发网络请求:读 `QQMusicServiceConfig.ini` 的 `uin`,
|
||||
/// 再从运行中的 `QQMusic.exe` 内存里找 `authst`。
|
||||
///
|
||||
/// `authst` **不会**返回给前端(只在后端用于调接口),前端拿到的只有 QQ 号与状态。
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn music_decrypt_qq_status() -> Result<super::qq_online::QqOnlineStatus, String> {
|
||||
Ok(super::qq_online::probe_status())
|
||||
}
|
||||
|
||||
/// 过滤掉位于 `out_dir` 内的输入文件。
|
||||
///
|
||||
/// 为什么需要:把输出目录选在输入目录内(或直接选输入目录)时,下一次运行会把
|
||||
/// 上一次的产物再当输入解一遍,产出 `_1`、`_2` 无限膨胀。
|
||||
///
|
||||
/// 路径比较用 `canonicalize`,因此能正确处理 `..`、大小写差异与短路径;
|
||||
/// **无法规范化(文件不存在/无权限)的路径一律保留**——让 worker 去报"读取失败",
|
||||
/// 比在这里静默丢弃更好(用户能看到原因)。
|
||||
fn retain_outside(files: Vec<scan::ScannedFile>, out_dir: &Path) -> Vec<scan::ScannedFile> {
|
||||
let Ok(out_canon) = out_dir.canonicalize() else {
|
||||
// 输出目录都规范化不了(理论上不会:resolve_out_dir 刚创建过它),
|
||||
// 此时放弃这层保护而不是误杀全部输入
|
||||
return files;
|
||||
};
|
||||
files
|
||||
.into_iter()
|
||||
.filter(|f| match f.path.canonicalize() {
|
||||
Ok(abs) => !abs.starts_with(&out_canon),
|
||||
Err(_) => true,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 解析输出目录:显式传入优先,否则回退到应用数据目录下的 `music/decrypted`。
|
||||
fn resolve_out_dir(out_dir: Option<String>) -> Result<PathBuf, String> {
|
||||
if let Some(d) = out_dir {
|
||||
let d = d.trim();
|
||||
if !d.is_empty() {
|
||||
let p = PathBuf::from(d);
|
||||
std::fs::create_dir_all(&p)
|
||||
.map_err(|e| format!("无法创建输出目录 {}:{e}", p.display()))?;
|
||||
return Ok(p);
|
||||
}
|
||||
}
|
||||
// 兜底:{app_data}/music/decrypted(前端正常都会传 savedir/decrypted)
|
||||
let base = dirs::data_dir()
|
||||
.ok_or_else(|| "无法定位应用数据目录".to_string())?
|
||||
.join("thing")
|
||||
.join("music")
|
||||
.join("decrypted");
|
||||
std::fs::create_dir_all(&base)
|
||||
.map_err(|e| format!("无法创建输出目录 {}:{e}", base.display()))?;
|
||||
Ok(base)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn tmpdir(tag: &str) -> PathBuf {
|
||||
let d = std::env::temp_dir().join(format!("dec_cmd_{tag}_{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&d);
|
||||
std::fs::create_dir_all(&d).unwrap();
|
||||
d
|
||||
}
|
||||
|
||||
fn fake_ncm() -> Vec<u8> {
|
||||
let mut v = b"CTENFDAM".to_vec();
|
||||
v.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
|
||||
v
|
||||
}
|
||||
|
||||
fn entry(path: PathBuf, rel: Option<&str>) -> scan::ScannedFile {
|
||||
scan::ScannedFile {
|
||||
name: path.file_name().unwrap().to_string_lossy().to_string(),
|
||||
path,
|
||||
rel_parent: rel.map(PathBuf::from),
|
||||
engine: scan::Engine::Ncm,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn retain_outside_drops_inputs_inside_output_dir() {
|
||||
let root = tmpdir("retain");
|
||||
let out = root.join("decrypted");
|
||||
std::fs::create_dir_all(&out).unwrap();
|
||||
|
||||
let inside = out.join("a.ncm");
|
||||
let outside = root.join("b.ncm");
|
||||
std::fs::write(&inside, fake_ncm()).unwrap();
|
||||
std::fs::write(&outside, fake_ncm()).unwrap();
|
||||
|
||||
let kept = retain_outside(vec![entry(inside, None), entry(outside, None)], &out);
|
||||
assert_eq!(kept.len(), 1, "应只保留输出目录外的文件");
|
||||
assert!(kept[0].path.ends_with("b.ncm"));
|
||||
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn retain_outside_drops_nested_paths() {
|
||||
let root = tmpdir("nested");
|
||||
let out = root.join("decrypted");
|
||||
let deep = out.join("2026").join("07");
|
||||
std::fs::create_dir_all(&deep).unwrap();
|
||||
let f = deep.join("c.ncm");
|
||||
std::fs::write(&f, fake_ncm()).unwrap();
|
||||
|
||||
let kept = retain_outside(vec![entry(f, None)], &out);
|
||||
assert!(kept.is_empty(), "输出目录的子目录也应视为相交");
|
||||
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn retain_outside_keeps_unresolvable_paths() {
|
||||
let root = tmpdir("unresolvable");
|
||||
let out = root.join("decrypted");
|
||||
std::fs::create_dir_all(&out).unwrap();
|
||||
|
||||
let ghost = root.join("not-here").join("ghost.ncm");
|
||||
let kept = retain_outside(vec![entry(ghost, None)], &out);
|
||||
assert_eq!(kept.len(), 1, "不存在的输入不应被静默丢弃");
|
||||
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resolve_out_dir_uses_explicit_value() {
|
||||
let root = tmpdir("outdir");
|
||||
let target = root.join("my").join("out");
|
||||
let got = resolve_out_dir(Some(target.to_string_lossy().to_string())).unwrap();
|
||||
assert_eq!(got, target);
|
||||
assert!(target.is_dir(), "输出目录应被创建");
|
||||
|
||||
let fallback = resolve_out_dir(Some(" ".into())).unwrap();
|
||||
assert!(fallback.ends_with("decrypted"));
|
||||
assert!(fallback.is_dir());
|
||||
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
|
||||
/// 文件夹扫描的汇总(UI 预览用)
|
||||
#[test]
|
||||
fn scan_summary_counts_per_engine() {
|
||||
let root = tmpdir("summary");
|
||||
std::fs::write(root.join("a.ncm"), fake_ncm()).unwrap();
|
||||
std::fs::write(root.join("b.qmcflac"), vec![0x22u8; 4096]).unwrap();
|
||||
std::fs::write(root.join("c.mgg"), vec![0x22u8; 4096]).unwrap();
|
||||
std::fs::write(root.join("d.mp3"), vec![0x44u8; 1024]).unwrap();
|
||||
|
||||
let found = scan::scan(&root, None).unwrap();
|
||||
let ncm = found
|
||||
.iter()
|
||||
.filter(|f| f.engine == scan::Engine::Ncm)
|
||||
.count();
|
||||
assert_eq!(found.len(), 3, "mp3 不应被计入");
|
||||
assert_eq!(ncm, 1);
|
||||
assert_eq!(found.len() - ncm, 2);
|
||||
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,266 @@
|
||||
//! 本地解密的**统一错误类型与公共格式探测**。
|
||||
//!
|
||||
//! 两个引擎([`super::ncm`] 网易云 / [`super::qmc`] QQ音乐)各自的内部错误不同,
|
||||
//! 但调度层只关心「可读的中文原因」,因此都收敛到 [`DecryptError`]。
|
||||
//!
|
||||
//! 输出扩展名统一由 [`detect_format`] 按**音频首帧魔数**判定——
|
||||
//! 两个平台都不信任容器里声明的格式字段(详见 `MUSIC_DECRYPT_PLAN.md` §3.1⑥ / §3.2 末)。
|
||||
|
||||
use std::fmt;
|
||||
use std::path::PathBuf;
|
||||
|
||||
/// 解密失败原因。全部经 `to_string()` 上报为 per-file 失败,**不 panic**
|
||||
/// (否则一个坏文件会带走整批任务)。
|
||||
#[derive(Debug)]
|
||||
pub enum DecryptError {
|
||||
Io(String),
|
||||
/// 文件不属于本引擎认得的加密格式
|
||||
NotEncrypted(String),
|
||||
/// 容器/尾部结构残缺
|
||||
Broken(String),
|
||||
/// 缺少解密密钥(QQ QMC2 的 ekey 情况),文案要能给用户下一步动作
|
||||
KeyRequired(String),
|
||||
/// 输出失败
|
||||
Output(String),
|
||||
}
|
||||
|
||||
impl fmt::Display for DecryptError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
DecryptError::Io(e) => write!(f, "读取失败:{e}"),
|
||||
DecryptError::NotEncrypted(e) => write!(f, "{e}"),
|
||||
DecryptError::Broken(e) => write!(f, "文件结构损坏:{e}"),
|
||||
DecryptError::KeyRequired(e) => write!(f, "{e}"),
|
||||
DecryptError::Output(e) => write!(f, "输出失败:{e}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for DecryptError {}
|
||||
|
||||
impl From<std::io::Error> for DecryptError {
|
||||
fn from(e: std::io::Error) -> Self {
|
||||
DecryptError::Io(e.to_string())
|
||||
}
|
||||
}
|
||||
|
||||
pub type Result<T> = std::result::Result<T, DecryptError>;
|
||||
|
||||
/// 解密产物(两引擎统一形状)
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Outcome {
|
||||
pub output: PathBuf,
|
||||
/// 落盘用的扩展名(由首帧魔数判定)
|
||||
pub format: String,
|
||||
/// 单独落盘的封面(没有则为 None)
|
||||
pub cover: Option<PathBuf>,
|
||||
/// 音频明文字节数
|
||||
pub audio_bytes: u64,
|
||||
/// 给 UI 的一行备注(平台 / 密钥形态 / 元数据摘要)。
|
||||
///
|
||||
/// 结构化元数据目前只用来拼这一行——P2 做标签回填时再把 `NcmMeta` 提升到
|
||||
/// `Outcome` 上,不要提前加一个没人读的字段。
|
||||
pub note: String,
|
||||
}
|
||||
|
||||
/// 按音频首帧魔数判定输出扩展名。
|
||||
///
|
||||
/// **这是权威来源**:ncm 的 `format` 字段、QMC 的输入后缀都只是声明,
|
||||
/// 不可信(QKKDecrypt 同样以内容探测为准)。
|
||||
pub fn detect_format(head: &[u8]) -> &'static str {
|
||||
detect_format_opt(head).unwrap_or("flac")
|
||||
}
|
||||
|
||||
/// 同上,但认不出时返回 `None`(调用方可据此决定是否回退到后缀/声明格式)。
|
||||
pub fn detect_format_opt(head: &[u8]) -> Option<&'static str> {
|
||||
let starts = |m: &[u8]| head.len() >= m.len() && &head[..m.len()] == m;
|
||||
if starts(b"fLaC") {
|
||||
Some("flac")
|
||||
} else if starts(b"OggS") {
|
||||
Some("ogg")
|
||||
} else if starts(b"ID3") || (head.len() >= 2 && head[0] == 0xFF && head[1] & 0xE0 == 0xE0) {
|
||||
// ID3 标签,或无标签 MP3 的帧同步字(0xFFEx / 0xFFFx)
|
||||
Some("mp3")
|
||||
} else if starts(b"RIFF") && head.len() >= 12 && &head[8..12] == b"WAVE" {
|
||||
Some("wav")
|
||||
} else if head.len() >= 12 && &head[4..8] == b"ftyp" {
|
||||
Some("m4a")
|
||||
} else if starts(b"wvpk") {
|
||||
Some("wv")
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// 图片扩展名(按魔数)
|
||||
pub fn image_ext(data: &[u8]) -> &'static str {
|
||||
const PNG: &[u8] = &[0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
|
||||
if data.len() >= 8 && &data[..8] == PNG {
|
||||
"png"
|
||||
} else {
|
||||
"jpg"
|
||||
}
|
||||
}
|
||||
|
||||
/// 确保输出目录存在并返回「按相对目录展开后」的目标目录。
|
||||
///
|
||||
/// 文件夹批量模式要保留原目录结构(`Pop/a.mflac` → `out/Pop/a.flac`),
|
||||
/// 否则不同子目录的同名文件会在输出根目录里互相挤兑(虽然去重逻辑会让位成
|
||||
/// `_1`,但产物与源的对应关系就丢了)。
|
||||
pub fn ensure_subdir(
|
||||
dir: &std::path::Path,
|
||||
rel_parent: Option<&std::path::Path>,
|
||||
) -> Result<PathBuf> {
|
||||
let target = match rel_parent {
|
||||
Some(rel) if !rel.as_os_str().is_empty() => dir.join(rel),
|
||||
_ => dir.to_path_buf(),
|
||||
};
|
||||
std::fs::create_dir_all(&target)?;
|
||||
Ok(target)
|
||||
}
|
||||
|
||||
/// 在 `dir` 下为 `stem` + `ext` 找一个不冲突的输出路径。
|
||||
///
|
||||
/// 不同来源的同名文件若直接扁平落盘会**互相覆盖**,故占用时追加 `_1`/`_2`…
|
||||
/// `reserved` 是本批次内已占用的名字(磁盘上尚不存在的也算)。
|
||||
pub fn unique_output(
|
||||
dir: &std::path::Path,
|
||||
stem: &str,
|
||||
ext: &str,
|
||||
reserved: &mut std::collections::HashSet<String>,
|
||||
) -> Result<PathBuf> {
|
||||
let mut candidate = dir.join(format!("{stem}.{ext}"));
|
||||
let mut n = 1;
|
||||
loop {
|
||||
let key = candidate.to_string_lossy().to_lowercase();
|
||||
if !candidate.exists() && !reserved.contains(&key) {
|
||||
reserved.insert(key);
|
||||
return Ok(candidate);
|
||||
}
|
||||
candidate = dir.join(format!("{stem}_{n}.{ext}"));
|
||||
n += 1;
|
||||
if n > 9999 {
|
||||
return Err(DecryptError::Output(format!(
|
||||
"无法为 {stem} 找到不冲突的输出名"
|
||||
)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 读满 `buf` 或读到 EOF,返回实际字节数。
|
||||
///
|
||||
/// 与 `Read::read` 的关键区别:**只有 EOF 才会提前返回**,不会因为底层缓冲的
|
||||
/// 短读而返回半个块。流密码解密的块边界必须与加密侧严格一致,
|
||||
/// 否则相位错位、文件中途变噪声(`MUSIC_DECRYPT_PLAN.md` §6.24)。
|
||||
pub fn read_full(r: &mut impl std::io::Read, buf: &mut [u8]) -> Result<usize> {
|
||||
let mut filled = 0usize;
|
||||
while filled < buf.len() {
|
||||
match r.read(&mut buf[filled..]) {
|
||||
Ok(0) => break,
|
||||
Ok(n) => filled += n,
|
||||
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
|
||||
Err(e) => return Err(DecryptError::Io(e.to_string())),
|
||||
}
|
||||
}
|
||||
Ok(filled)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn detect_format_by_magic() {
|
||||
assert_eq!(detect_format(b"fLaC\x00\x00\x00\x22"), "flac");
|
||||
assert_eq!(detect_format(b"OggS\x00\x02"), "ogg");
|
||||
assert_eq!(detect_format(b"ID3\x04\x00"), "mp3");
|
||||
assert_eq!(detect_format(&[0xFF, 0xFB, 0x90, 0x00]), "mp3");
|
||||
assert_eq!(detect_format(b"RIFF\x00\x00\x00\x00WAVEfmt "), "wav");
|
||||
assert_eq!(detect_format(b"\x00\x00\x00\x20ftypM4A "), "m4a");
|
||||
assert_eq!(detect_format(b"wvpk\x00\x00"), "wv");
|
||||
assert_eq!(detect_format(b"\x00\x01\x02\x03"), "flac");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn image_ext_by_magic() {
|
||||
assert_eq!(
|
||||
image_ext(&[0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]),
|
||||
"png"
|
||||
);
|
||||
assert_eq!(image_ext(&[0xFF, 0xD8, 0xFF, 0xE0]), "jpg");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unique_output_appends_suffix_on_collision() {
|
||||
let dir = std::env::temp_dir().join(format!("dec_unique_{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let mut reserved = std::collections::HashSet::new();
|
||||
|
||||
let a = unique_output(&dir, "song", "flac", &mut reserved).unwrap();
|
||||
assert_eq!(a.file_name().unwrap(), "song.flac");
|
||||
let b = unique_output(&dir, "song", "flac", &mut reserved).unwrap();
|
||||
assert_eq!(b.file_name().unwrap(), "song_1.flac");
|
||||
let c = unique_output(&dir, "song", "mp3", &mut reserved).unwrap();
|
||||
assert_eq!(c.file_name().unwrap(), "song.mp3");
|
||||
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ensure_subdir_preserves_relative_structure() {
|
||||
let root = std::env::temp_dir().join(format!("dec_subdir_{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
std::fs::create_dir_all(&root).unwrap();
|
||||
|
||||
// 无相对目录 → 输出根
|
||||
let flat = ensure_subdir(&root, None).unwrap();
|
||||
assert_eq!(flat, root);
|
||||
|
||||
// 有相对目录 → 逐级创建
|
||||
let nested = ensure_subdir(
|
||||
&root,
|
||||
Some(std::path::Path::new("Pop").join("2026").as_path()),
|
||||
)
|
||||
.unwrap();
|
||||
assert!(nested.is_dir());
|
||||
assert!(nested.ends_with("Pop/2026") || nested.ends_with(r"Pop\2026"));
|
||||
|
||||
let _ = std::fs::remove_dir_all(&root);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn read_full_returns_whole_buffer() {
|
||||
// 一个每次只吐 3 字节的 reader:read_full 必须凑满整个 buf
|
||||
struct Drip {
|
||||
data: Vec<u8>,
|
||||
pos: usize,
|
||||
}
|
||||
impl std::io::Read for Drip {
|
||||
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
|
||||
if self.pos >= self.data.len() {
|
||||
return Ok(0);
|
||||
}
|
||||
let n = buf.len().min(3).min(self.data.len() - self.pos);
|
||||
buf[..n].copy_from_slice(&self.data[self.pos..self.pos + n]);
|
||||
self.pos += n;
|
||||
Ok(n)
|
||||
}
|
||||
}
|
||||
|
||||
let src: Vec<u8> = (0..100u8).collect();
|
||||
let mut r = Drip {
|
||||
data: src.clone(),
|
||||
pos: 0,
|
||||
};
|
||||
let mut buf = [0u8; 64];
|
||||
let n = read_full(&mut r, &mut buf).unwrap();
|
||||
assert_eq!(n, 64, "短读 reader 也必须凑满整块");
|
||||
assert_eq!(&buf[..], &src[..64]);
|
||||
|
||||
// 末尾不足一块时返回实际长度
|
||||
let n2 = read_full(&mut r, &mut buf).unwrap();
|
||||
assert_eq!(n2, 36);
|
||||
let n3 = read_full(&mut r, &mut buf).unwrap();
|
||||
assert_eq!(n3, 0, "EOF 返回 0");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,624 @@
|
||||
//! 音乐模块 · 本地解密(`music/decrypt/`)。
|
||||
//!
|
||||
//! 挂靠音乐模块的「解密」页签,与下载链路同构:命令先回一个 `taskId`,
|
||||
//! 之后所有进度经 `music-decrypt-event` 推送(前端 `decryptStore` 常驻监听,
|
||||
//! 页签切换卸载组件也不影响任务)。
|
||||
//!
|
||||
//! ## 分工
|
||||
//!
|
||||
//! - [`ncm`]:网易云 `.ncm` 的**纯 Rust 离线**引擎(P0 全部范围)。
|
||||
//! - `qq`(P1,未实施):QQ 音乐三层路由(内嵌 ekey 离线 → musicex API → Frida 兜底)。
|
||||
//! 见 `MUSIC_DECRYPT_PLAN.md` §3.2。
|
||||
//! - [`commands`]:Tauri 命令层(run / cancel)。
|
||||
//!
|
||||
//! ## 为什么事件在独立线程里发
|
||||
//!
|
||||
//! 解密是 CPU + 磁盘密集的同步流程,每读一块就要回报进度。把它放在
|
||||
//! `spawn_blocking` 里再逐块 `emit` 会阻塞 tokio 的工作线程;
|
||||
//! 这里改为「`std::thread` 干活 + `mpsc` 回传事件 + 异步任务节流转发」,
|
||||
//! 读盘线程最多被 `mpsc::send` 短暂挡住,不碰 tokio 运行时。
|
||||
//!
|
||||
//! 进度**按时间节流**([`PROGRESS_INTERVAL`]):单个大文件有成千上万个 32KB 块,
|
||||
//! 不节流会把 WebView 的事件通道打满。
|
||||
|
||||
pub mod commands;
|
||||
pub mod common;
|
||||
pub mod ncm;
|
||||
pub mod probe;
|
||||
pub mod qmc;
|
||||
pub mod qq_credentials;
|
||||
pub mod qq_ekey;
|
||||
pub mod qq_footer;
|
||||
pub mod qq_online;
|
||||
pub mod scan;
|
||||
|
||||
/// QQ 音乐进程内存扫描:纯 Win32 实现,非 Windows 平台不编译。
|
||||
#[cfg(windows)]
|
||||
pub mod qq_memscan;
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::{mpsc, Arc, Mutex};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use tauri::{AppHandle, Emitter};
|
||||
|
||||
use common::DecryptError;
|
||||
|
||||
/// 进度事件的最小间隔
|
||||
pub const PROGRESS_INTERVAL: Duration = Duration::from_millis(300);
|
||||
|
||||
/// 单文件处理结果的三个状态
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum FileStatus {
|
||||
/// 解密成功
|
||||
Ok,
|
||||
/// 失败(`message` 为可读原因)
|
||||
Error,
|
||||
/// 该文件不属于本平台/本阶段支持范围
|
||||
Unsupported,
|
||||
}
|
||||
|
||||
/// 推送给前端的事件负载(与 `src/lib/bindings.ts` / `decryptStore.ts` 对应)。
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
||||
#[serde(tag = "type", rename_all = "kebab-case")]
|
||||
pub enum DecryptEvent {
|
||||
/// 批次开始,`total` 为待处理文件数
|
||||
Start { task_id: String, total: usize },
|
||||
/// 单个文件处理完毕
|
||||
File {
|
||||
task_id: String,
|
||||
/// 0-based 序号,与任务表行一一对应
|
||||
index: usize,
|
||||
name: String,
|
||||
status: FileStatus,
|
||||
/// 失败原因,或成功时的备注(平台 / 密钥形态)
|
||||
message: Option<String>,
|
||||
/// 主产物路径
|
||||
output: Option<String>,
|
||||
/// 单独落盘的封面(网易云 ncm 带内嵌封面时才有)
|
||||
cover: Option<String>,
|
||||
},
|
||||
/// 进度(节流后)
|
||||
Progress {
|
||||
task_id: String,
|
||||
done: usize,
|
||||
total: usize,
|
||||
/// 当前文件已处理字节数 / 总字节数(0 表示未知)
|
||||
bytes_done: u64,
|
||||
bytes_total: u64,
|
||||
name: String,
|
||||
},
|
||||
/// 批次结束
|
||||
Finished {
|
||||
task_id: String,
|
||||
ok: usize,
|
||||
failed: usize,
|
||||
/// 被取消时尚未处理的文件数
|
||||
cancelled: usize,
|
||||
},
|
||||
}
|
||||
|
||||
/// 任务表条目。只存「是否被要求取消」,不存进度——
|
||||
/// 进度的权威在前端 store(事件即真相),Rust 侧不需要镜像状态。
|
||||
pub struct DecryptTasks {
|
||||
inner: Mutex<HashMap<String, Arc<AtomicBool>>>,
|
||||
}
|
||||
|
||||
impl Default for DecryptTasks {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl DecryptTasks {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
inner: Mutex::new(HashMap::new()),
|
||||
}
|
||||
}
|
||||
|
||||
/// 登记一个任务并返回它的取消标志
|
||||
pub fn register(&self, task_id: &str) -> Arc<AtomicBool> {
|
||||
let flag = Arc::new(AtomicBool::new(false));
|
||||
if let Ok(mut m) = self.inner.lock() {
|
||||
m.insert(task_id.to_string(), flag.clone());
|
||||
}
|
||||
flag
|
||||
}
|
||||
|
||||
/// 请求取消;返回是否命中了一个在跑的任务
|
||||
pub fn cancel(&self, task_id: &str) -> bool {
|
||||
match self.inner.lock() {
|
||||
Ok(m) => match m.get(task_id) {
|
||||
Some(flag) => {
|
||||
flag.store(true, Ordering::SeqCst);
|
||||
true
|
||||
}
|
||||
None => false,
|
||||
},
|
||||
Err(_) => false,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn finish(&self, task_id: &str) {
|
||||
if let Ok(mut m) = self.inner.lock() {
|
||||
m.remove(task_id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 线程 → 异步任务的事件通道消息
|
||||
enum Msg {
|
||||
Progress {
|
||||
bytes_done: u64,
|
||||
bytes_total: u64,
|
||||
name: String,
|
||||
},
|
||||
File {
|
||||
index: usize,
|
||||
name: String,
|
||||
status: FileStatus,
|
||||
message: Option<String>,
|
||||
output: Option<String>,
|
||||
cover: Option<String>,
|
||||
},
|
||||
/// 批次结束。**必须走通道**——否则它会在转发线程尚未冲出积压的
|
||||
/// `File` 事件之前就被 `emit`,前端会先看到"完成"再看到最后几个文件的结果。
|
||||
Finished {
|
||||
ok: usize,
|
||||
failed: usize,
|
||||
cancelled: usize,
|
||||
},
|
||||
}
|
||||
|
||||
/// 该文件是否是「需要联网取密钥」的形态(musicex)。
|
||||
///
|
||||
/// 只读尾部 192 字节,代价可忽略;用作"离线失败后要不要转在线"的判据,
|
||||
/// 避免对普通失败(如尾部损坏)也去发起网络请求。
|
||||
fn needs_online(path: &std::path::Path) -> bool {
|
||||
use std::io::{Read, Seek, SeekFrom};
|
||||
let Ok(mut f) = std::fs::File::open(path) else {
|
||||
return false;
|
||||
};
|
||||
let Ok(size) = f.metadata().map(|m| m.len()) else {
|
||||
return false;
|
||||
};
|
||||
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
|
||||
if take < 8 || f.seek(SeekFrom::End(-(take as i64))).is_err() {
|
||||
return false;
|
||||
}
|
||||
let mut buf = vec![0u8; take];
|
||||
if f.read_exact(&mut buf).is_err() {
|
||||
return false;
|
||||
}
|
||||
qq_footer::is_musicex_tail(&buf)
|
||||
}
|
||||
|
||||
/// 启动一个解密批次:登记任务 → 起工作线程 → 异步转发事件。
|
||||
///
|
||||
/// 调用方(`commands::music_decrypt_run`)已完成参数校验与目录扫描;本函数只负责调度。
|
||||
///
|
||||
/// `in_place = true` 时**忽略 `out_dir`**,产物与源文件同目录同名(扩展名按格式改)。
|
||||
/// 这是文件夹批量的默认方式——用户的期望是"就地解出来",而不是去另一个目录找。
|
||||
pub fn spawn_batch(
|
||||
app: AppHandle,
|
||||
tasks: Arc<DecryptTasks>,
|
||||
task_id: String,
|
||||
files: Vec<scan::ScannedFile>,
|
||||
out_dir: PathBuf,
|
||||
in_place: bool,
|
||||
) {
|
||||
let flag = tasks.register(&task_id);
|
||||
let (tx, rx) = mpsc::channel::<Msg>();
|
||||
let total_files = files.len();
|
||||
|
||||
// ---- 工作线程:逐文件解密 ----
|
||||
let worker_task_id = task_id.clone();
|
||||
let worker_tasks = tasks.clone();
|
||||
std::thread::Builder::new()
|
||||
.name(format!("music-decrypt-{task_id}"))
|
||||
.spawn(move || {
|
||||
let total = files.len();
|
||||
|
||||
// 批次内已占用的输出名(防同名互相覆盖,见 common::unique_output)
|
||||
let mut reserved = std::collections::HashSet::new();
|
||||
let mut ok = 0usize;
|
||||
let mut failed = 0usize;
|
||||
let mut cancelled = 0usize;
|
||||
let mut done = 0usize;
|
||||
|
||||
for (index, job) in files.iter().enumerate() {
|
||||
if flag.load(Ordering::SeqCst) {
|
||||
cancelled = total - done;
|
||||
break;
|
||||
}
|
||||
|
||||
// 输出目录:就地模式与源文件同目录;否则按相对目录还原结构
|
||||
let target_dir = if in_place {
|
||||
job.path
|
||||
.parent()
|
||||
.map(|p| p.to_path_buf())
|
||||
.unwrap_or_else(|| out_dir.clone())
|
||||
} else {
|
||||
common::ensure_subdir(&out_dir, job.rel_parent.as_deref())
|
||||
.unwrap_or_else(|_| out_dir.clone())
|
||||
};
|
||||
|
||||
// 进度回调:只在文件内部回报,节流交给接收端
|
||||
let tx_progress = tx.clone();
|
||||
let name = job.name.clone();
|
||||
// 「网易云 / QQ音乐」前缀由调度层给出——引擎自己不该知道路由结果
|
||||
let label = job.engine.label();
|
||||
let mut progress_cb = |bytes_done: u64, bytes_total: u64| {
|
||||
let _ = tx_progress.send(Msg::Progress {
|
||||
bytes_done,
|
||||
bytes_total,
|
||||
name: name.clone(),
|
||||
});
|
||||
};
|
||||
let result = match job.engine {
|
||||
scan::Engine::Ncm => ncm::decrypt_file(
|
||||
&job.path,
|
||||
&target_dir,
|
||||
label,
|
||||
&mut reserved,
|
||||
&mut progress_cb,
|
||||
),
|
||||
// musicex 的 ekey 不在文件里,离线路径会返回明确的 KeyRequired;
|
||||
// 命中该形态时改走「本机凭据 → 在线取密钥」。
|
||||
scan::Engine::Qmc => {
|
||||
let offline = qmc::decrypt_file(
|
||||
&job.path,
|
||||
&target_dir,
|
||||
label,
|
||||
&mut reserved,
|
||||
&mut progress_cb,
|
||||
);
|
||||
match offline {
|
||||
Err(DecryptError::KeyRequired(_)) if needs_online(&job.path) => {
|
||||
qq_online::decrypt_musicex(
|
||||
&job.path,
|
||||
&target_dir,
|
||||
label,
|
||||
&mut progress_cb,
|
||||
)
|
||||
}
|
||||
other => other,
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
done += 1;
|
||||
match result {
|
||||
Ok(res) => {
|
||||
ok += 1;
|
||||
crate::logger::log_info(
|
||||
"music-decrypt",
|
||||
&format!(
|
||||
"{} → {}({},{} 字节)",
|
||||
job.path.display(),
|
||||
res.output.display(),
|
||||
res.format,
|
||||
res.audio_bytes
|
||||
),
|
||||
);
|
||||
let _ = tx.send(Msg::File {
|
||||
index,
|
||||
name: job.name.clone(),
|
||||
status: FileStatus::Ok,
|
||||
// 成功时把备注(平台/密钥形态)与产物一起回报
|
||||
message: Some(res.note),
|
||||
output: Some(res.output.to_string_lossy().to_string()),
|
||||
cover: res.cover.map(|c| c.to_string_lossy().to_string()),
|
||||
});
|
||||
}
|
||||
Err(e) => {
|
||||
failed += 1;
|
||||
crate::logger::log_warn(
|
||||
"music-decrypt",
|
||||
&format!("{} 解密失败:{e}", job.path.display()),
|
||||
);
|
||||
let _ = tx.send(Msg::File {
|
||||
index,
|
||||
name: job.name.clone(),
|
||||
status: FileStatus::Error,
|
||||
message: Some(e.to_string()),
|
||||
output: None,
|
||||
cover: None,
|
||||
});
|
||||
}
|
||||
}
|
||||
// 文件收尾时必推一次,保证进度条不因节流停在中间
|
||||
let _ = tx.send(Msg::Progress {
|
||||
bytes_done: done as u64,
|
||||
bytes_total: total as u64,
|
||||
name: job.name.clone(),
|
||||
});
|
||||
}
|
||||
|
||||
// 通道关闭 → 接收端读完剩余消息后收尾
|
||||
let _ = tx.send(Msg::Finished {
|
||||
ok,
|
||||
failed,
|
||||
cancelled,
|
||||
});
|
||||
drop(tx);
|
||||
worker_tasks.finish(&worker_task_id);
|
||||
})
|
||||
.expect("无法创建解密工作线程");
|
||||
|
||||
// ---- 异步转发:节流 + 顺序保证 ----
|
||||
//
|
||||
// 语义:
|
||||
// - `File` 事件(含文件收尾的那次 Progress)**立即转发**,否则结果会看起来卡在末尾。
|
||||
// - 文件内部的逐块 Progress 只保留最新一条,按 [`PROGRESS_INTERVAL`] 最多发一次,
|
||||
// 避免单个大文件的成千上万个块把 WebView 事件通道打满。
|
||||
tauri::async_runtime::spawn(async move {
|
||||
let mut last_progress: Option<Msg> = None;
|
||||
let mut last_emit = Instant::now() - PROGRESS_INTERVAL;
|
||||
let mut current_index = 0usize;
|
||||
// 批内文件总数:与下面 Start 事件取同一份来源
|
||||
let current_total = total_files;
|
||||
|
||||
// Start 先发:它必须在任何 Progress/File 之前到达,前端据此建行。
|
||||
let _ = app.emit(
|
||||
crate::constants::events::MUSIC_DECRYPT_EVENT,
|
||||
&DecryptEvent::Start {
|
||||
task_id: task_id.clone(),
|
||||
total: total_files,
|
||||
},
|
||||
);
|
||||
|
||||
loop {
|
||||
// 单次 recv_timeout 同时兼顾「有消息就收」和「到点就 flush」
|
||||
let msg = match rx.recv_timeout(PROGRESS_INTERVAL) {
|
||||
Ok(m) => Some(m),
|
||||
Err(mpsc::RecvTimeoutError::Timeout) => None,
|
||||
Err(mpsc::RecvTimeoutError::Disconnected) => break,
|
||||
};
|
||||
|
||||
match msg {
|
||||
Some(Msg::Progress {
|
||||
bytes_done,
|
||||
bytes_total,
|
||||
name,
|
||||
}) => {
|
||||
// 攒着;下面的 flush 决定何时真正发出
|
||||
last_progress = Some(Msg::Progress {
|
||||
bytes_done,
|
||||
bytes_total,
|
||||
name,
|
||||
});
|
||||
}
|
||||
Some(Msg::File {
|
||||
index,
|
||||
name,
|
||||
status,
|
||||
message,
|
||||
output,
|
||||
cover,
|
||||
}) => {
|
||||
// 结果事件优先:先把攒住的进度冲掉,再发结果,保证顺序自然
|
||||
flush_progress(
|
||||
&app,
|
||||
&task_id,
|
||||
&mut last_progress,
|
||||
&mut last_emit,
|
||||
current_index,
|
||||
current_total,
|
||||
);
|
||||
let _ = app.emit(
|
||||
crate::constants::events::MUSIC_DECRYPT_EVENT,
|
||||
&DecryptEvent::File {
|
||||
task_id: task_id.clone(),
|
||||
index,
|
||||
name,
|
||||
status,
|
||||
message,
|
||||
output,
|
||||
cover,
|
||||
},
|
||||
);
|
||||
current_index = index + 1;
|
||||
}
|
||||
Some(Msg::Finished {
|
||||
ok,
|
||||
failed,
|
||||
cancelled,
|
||||
}) => {
|
||||
// 收尾前把攒住的进度冲掉,再发 Finished,保证前端不丢最后一格进度
|
||||
last_emit = Instant::now() - PROGRESS_INTERVAL;
|
||||
flush_progress(
|
||||
&app,
|
||||
&task_id,
|
||||
&mut last_progress,
|
||||
&mut last_emit,
|
||||
current_index,
|
||||
current_total,
|
||||
);
|
||||
let _ = app.emit(
|
||||
crate::constants::events::MUSIC_DECRYPT_EVENT,
|
||||
&DecryptEvent::Finished {
|
||||
task_id: task_id.clone(),
|
||||
ok,
|
||||
failed,
|
||||
cancelled,
|
||||
},
|
||||
);
|
||||
// 通道随后关闭,循环自然退出
|
||||
}
|
||||
None => { /* 超时,走下面的 flush */ }
|
||||
}
|
||||
|
||||
flush_progress(
|
||||
&app,
|
||||
&task_id,
|
||||
&mut last_progress,
|
||||
&mut last_emit,
|
||||
current_index,
|
||||
current_total,
|
||||
);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/// 到点则把攒下的最新一条进度发出(最多每 [`PROGRESS_INTERVAL`] 一次)。
|
||||
fn flush_progress(
|
||||
app: &AppHandle,
|
||||
task_id: &str,
|
||||
pending: &mut Option<Msg>,
|
||||
last_emit: &mut Instant,
|
||||
index: usize,
|
||||
total: usize,
|
||||
) {
|
||||
if pending.is_none() || last_emit.elapsed() < PROGRESS_INTERVAL {
|
||||
return;
|
||||
}
|
||||
if let Some(Msg::Progress {
|
||||
bytes_done,
|
||||
bytes_total,
|
||||
name,
|
||||
}) = pending.take()
|
||||
{
|
||||
*last_emit = Instant::now();
|
||||
let _ = app.emit(
|
||||
crate::constants::events::MUSIC_DECRYPT_EVENT,
|
||||
&DecryptEvent::Progress {
|
||||
task_id: task_id.to_string(),
|
||||
// index = 当前正在处理的文件序号(已完成的文件数)
|
||||
done: index,
|
||||
total,
|
||||
bytes_done,
|
||||
bytes_total,
|
||||
name,
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// **跨端契约**:事件的实际 JSON 形状是前端 `decryptStore.ts` 里 `RawEvent`
|
||||
/// 的镜像。曾经打算写 camelCase(`taskId`),但枚举上只有 `tag` 带了
|
||||
/// `rename_all`,**字段名仍是 snake_case**——两边不一致时不会编译报错,
|
||||
/// 只会表现为「任务建好了但进度永远不动」。这个测试把形状钉死。
|
||||
#[test]
|
||||
fn event_json_contract() {
|
||||
let start = serde_json::to_value(DecryptEvent::Start {
|
||||
task_id: "t1".into(),
|
||||
total: 3,
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
start,
|
||||
serde_json::json!({ "type": "start", "task_id": "t1", "total": 3 })
|
||||
);
|
||||
|
||||
let file = serde_json::to_value(DecryptEvent::File {
|
||||
task_id: "t1".into(),
|
||||
index: 2,
|
||||
name: "a.ncm".into(),
|
||||
status: FileStatus::Error,
|
||||
message: Some("坏了".into()),
|
||||
output: None,
|
||||
cover: None,
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
file,
|
||||
serde_json::json!({
|
||||
"type": "file", "task_id": "t1", "index": 2, "name": "a.ncm",
|
||||
"status": "error", "message": "坏了", "output": null, "cover": null
|
||||
})
|
||||
);
|
||||
|
||||
let progress = serde_json::to_value(DecryptEvent::Progress {
|
||||
task_id: "t1".into(),
|
||||
done: 1,
|
||||
total: 3,
|
||||
bytes_done: 10,
|
||||
bytes_total: 100,
|
||||
name: "a.ncm".into(),
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
progress,
|
||||
serde_json::json!({
|
||||
"type": "progress", "task_id": "t1", "done": 1, "total": 3,
|
||||
"bytes_done": 10, "bytes_total": 100, "name": "a.ncm"
|
||||
})
|
||||
);
|
||||
|
||||
let finished = serde_json::to_value(DecryptEvent::Finished {
|
||||
task_id: "t1".into(),
|
||||
ok: 2,
|
||||
failed: 1,
|
||||
cancelled: 0,
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
finished,
|
||||
serde_json::json!({
|
||||
"type": "finished", "task_id": "t1", "ok": 2, "failed": 1, "cancelled": 0
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
/// `FileStatus` 的三个取值必须是前端 `DecryptFileStatus` 认得的字面量
|
||||
#[test]
|
||||
fn file_status_variants_are_lowercase() {
|
||||
let j = |s| serde_json::to_string(&s).unwrap();
|
||||
assert_eq!(j(FileStatus::Ok), "\"ok\"");
|
||||
assert_eq!(j(FileStatus::Error), "\"error\"");
|
||||
assert_eq!(j(FileStatus::Unsupported), "\"unsupported\"");
|
||||
}
|
||||
|
||||
/// 平台路由见 `scan::route`(内容优先于后缀)——这里只验证单测覆盖到的路径。
|
||||
#[test]
|
||||
fn engine_route_by_content_and_extension() {
|
||||
use scan::Engine;
|
||||
let dir = std::env::temp_dir().join(format!("dec_route_{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
|
||||
// 网易云:只看魔数,后缀随便
|
||||
let ncm = dir.join("x.bin");
|
||||
let mut bytes = b"CTENFDAM".to_vec();
|
||||
bytes.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
|
||||
std::fs::write(&ncm, &bytes).unwrap();
|
||||
assert_eq!(scan::route(&ncm), Some(Engine::Ncm));
|
||||
|
||||
// QQ:后缀在家族里
|
||||
let qmc = dir.join("y.qmcflac");
|
||||
std::fs::write(&qmc, vec![0x22u8; 4096]).unwrap();
|
||||
assert_eq!(scan::route(&qmc), Some(Engine::Qmc));
|
||||
|
||||
// 普通音频文件不应被认领
|
||||
let mp3 = dir.join("z.mp3");
|
||||
std::fs::write(&mp3, vec![0x44u8; 4096]).unwrap();
|
||||
assert_eq!(scan::route(&mp3), None);
|
||||
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn task_registry_register_cancel_finish() {
|
||||
let tasks = DecryptTasks::new();
|
||||
let flag = tasks.register("t1");
|
||||
assert!(!flag.load(Ordering::SeqCst));
|
||||
// 取消命中
|
||||
assert!(tasks.cancel("t1"));
|
||||
assert!(flag.load(Ordering::SeqCst));
|
||||
// 未登记的任务取消不报错、返回 false
|
||||
assert!(!tasks.cancel("nope"));
|
||||
tasks.finish("t1");
|
||||
assert!(!tasks.cancel("t1"), "已结束的任务不应再被取消");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,734 @@
|
||||
//! 网易云音乐 `.ncm` 离线解密引擎(纯 Rust,无外部依赖、无运行时前置)。
|
||||
//!
|
||||
//! 算法对照 **MIT 协议** 的 `taurusxin/ncmdump`(`src/ncmcrypt.cpp`)独立重写。
|
||||
//! 下面每个常量与分支都对应容器里的一个实际字段,注释里标了「为什么」——
|
||||
//! 这几处正是最容易写错的地方,改动前请先读 `MUSIC_DECRYPT_PLAN.md` §3.1。
|
||||
//!
|
||||
//! ## 容器结构
|
||||
//!
|
||||
//! ```text
|
||||
//! 0x00 magic 8B "CTENFDAM"
|
||||
//! 0x08 2B 固定跳过
|
||||
//! 0x0A key_len 4B LE
|
||||
//! key_data XOR 0x64 → AES-128-ECB → 跳 17B → RC4 密钥盒种子
|
||||
//! meta_len 4B LE
|
||||
//! meta_data XOR 0x63 → 去 22B 前缀 → base64 → AES-128-ECB → 去 6B 前缀 → JSON
|
||||
//! 5B 固定跳过(CRC32 4B + 图片版本 1B)
|
||||
//! cover_len 4B LE / img_len 4B LE / img_data → 跳 cover_len - img_len
|
||||
//! audio 剩余全部(RC4 变体,按 0x8000 分块)
|
||||
//! ```
|
||||
//!
|
||||
//! 两段 XOR 常量不同(`0x64` / `0x63`)、AES 收尾是 PKCS#7 风格 padding、
|
||||
//! 密钥盒 KSA 带 `last_byte` 累加——任一写错都会全量解错,
|
||||
//! 且不会报错,只会产出乱码音频。
|
||||
|
||||
use std::fs::File;
|
||||
use std::io::{BufReader, BufWriter, Read, Write};
|
||||
use std::path::Path;
|
||||
|
||||
use aes::cipher::generic_array::GenericArray;
|
||||
use aes::cipher::{BlockDecrypt, KeyInit};
|
||||
use aes::Aes128;
|
||||
|
||||
use super::common::{self, DecryptError};
|
||||
|
||||
/// 头部魔数(ASCII `CTENFDAM`)
|
||||
const MAGIC: &[u8; 8] = b"CTENFDAM";
|
||||
/// key 段的 XOR 常量
|
||||
const XOR_KEY: u8 = 0x64;
|
||||
/// meta 段的 XOR 常量(**与 key 段不同**)
|
||||
const XOR_META: u8 = 0x63;
|
||||
/// key 段解密后需跳过的前缀:ASCII `neteasecloudmusic`(17 字节,含结尾 NUL)
|
||||
const CORE_KEY: &[u8; 17] = b"neteasecloudmusic";
|
||||
/// key 段 **AES 密钥**:ASCII `neteasecloudmusi`——`CORE_KEY` 的前 16 字节。
|
||||
///
|
||||
/// 注意与上面 17 字节的「前缀」区分:前缀(`neteasecloudmusic\0`,17B)是解密后
|
||||
/// 要从明文里剥掉的,AES 密钥(16B)是用来解密的。`aes::Aes128` 只吃 16 字节。
|
||||
const CORE_AES_KEY: &[u8; 16] = b"neteasecloudmusi";
|
||||
/// meta 段 AES 密钥:ASCII `#14ljk_!\]&0U<'(`(**与 CORE_KEY 不同**,别复用)
|
||||
///
|
||||
/// 注意是 16 字节而非 17——`aes::Aes128` 的密钥长度就是 16。
|
||||
const MODIFY_KEY: &[u8; 16] = b"#14ljk_!\\]&0U<'(";
|
||||
/// meta 段 base64 之前的字面量前缀
|
||||
const META_PREFIX: &[u8] = b"163 key(Don't modify):";
|
||||
/// meta 段 AES 解密后的字面量前缀
|
||||
const META_JSON_PREFIX: &[u8] = b"music:";
|
||||
/// 音频段分块大小。**块之间不额外跳字节**——这个值只是读写块大小。
|
||||
const CHUNK: usize = 0x8000;
|
||||
|
||||
/// ncm 内嵌元数据(meta 段 JSON 的子集)
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct NcmMeta {
|
||||
pub name: Option<String>,
|
||||
pub artist: Option<String>,
|
||||
pub album: Option<String>,
|
||||
pub bitrate: Option<u64>,
|
||||
pub duration: Option<u64>,
|
||||
/// 容器内声明的格式。**不用于决定输出扩展名**(那只认音频首帧魔数)。
|
||||
pub format: Option<String>,
|
||||
}
|
||||
|
||||
/// 本模块的错误类型 = 公共错误类型([`DecryptError`]),
|
||||
/// 便于调度层对两个引擎用同一套 `?` 与文案处理。
|
||||
pub type NcmError = DecryptError;
|
||||
|
||||
type Result<T> = std::result::Result<T, DecryptError>;
|
||||
|
||||
/// AES-128-ECB 解密 + PKCS#7 风格去 padding。
|
||||
///
|
||||
/// `aes` crate 只提供块原语(且本项目依赖树里**没有** `ecb` crate),
|
||||
/// 故这里手写块循环。收尾不是「去前缀」而是取最后一字节当 padding 长度——
|
||||
/// 这一点在 `MUSIC_DECRYPT_PLAN.md` §3.1③ 有说明。
|
||||
fn aes_ecb_decrypt(key: &[u8], data: &[u8]) -> Result<Vec<u8>> {
|
||||
if key.len() != 16 {
|
||||
return Err(NcmError::Broken(format!(
|
||||
"AES 密钥长度应为 16,实为 {}",
|
||||
key.len()
|
||||
)));
|
||||
}
|
||||
if data.is_empty() || data.len() % 16 != 0 {
|
||||
return Err(NcmError::Broken(format!(
|
||||
"AES 密文长度 {} 不是 16 的正整数倍",
|
||||
data.len()
|
||||
)));
|
||||
}
|
||||
let cipher = Aes128::new(GenericArray::from_slice(key));
|
||||
let blocks = data.len() / 16;
|
||||
let mut out = Vec::with_capacity(data.len());
|
||||
let mut buf = [0u8; 16];
|
||||
for i in 0..blocks {
|
||||
let block = GenericArray::from_slice(&data[i * 16..i * 16 + 16]);
|
||||
cipher.decrypt_block_b2b(block, GenericArray::from_mut_slice(&mut buf));
|
||||
// 最后一块按 padding 截断:末字节即填充长度,>16 视为无填充
|
||||
if i == blocks - 1 {
|
||||
let pad = if buf[15] > 16 { 0 } else { buf[15] as usize };
|
||||
out.extend_from_slice(&buf[..16 - pad.min(16)]);
|
||||
} else {
|
||||
out.extend_from_slice(&buf);
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// 密钥盒构造(KSA)。
|
||||
///
|
||||
/// 对照 `ncmdump` `src/ncmcrypt.cpp::buildKeyBox`——**单循环**,但每轮多累加一个
|
||||
/// `last_byte`(上一轮的 `c`):
|
||||
///
|
||||
/// ```text
|
||||
/// c = (swap + last_byte + key[key_offset]) & 0xff
|
||||
/// ```
|
||||
///
|
||||
/// 这个式子在模 256 下恰好化简为标准 RC4(实测两者密钥盒逐字节相同),
|
||||
/// 所以**它既不是「关键差异」,也不能靠与标准 RC4 比对来验证**——
|
||||
/// 验证只能靠固定向量,见单测 `key_box_matches_reference_vectors`。
|
||||
/// `key_offset` 触 keyLen 归零——即循环取 key。
|
||||
fn build_key_box(key: &[u8]) -> [u8; 256] {
|
||||
let mut key_box = [0u8; 256];
|
||||
for (i, b) in key_box.iter_mut().enumerate() {
|
||||
*b = i as u8;
|
||||
}
|
||||
if key.is_empty() {
|
||||
return key_box;
|
||||
}
|
||||
let mut last_byte: u8 = 0;
|
||||
let mut key_offset = 0usize;
|
||||
for i in 0..256usize {
|
||||
let swap = key_box[i];
|
||||
let c = swap.wrapping_add(last_byte).wrapping_add(key[key_offset]);
|
||||
key_offset += 1;
|
||||
if key_offset >= key.len() {
|
||||
key_offset = 0;
|
||||
}
|
||||
key_box[i] = key_box[c as usize];
|
||||
key_box[c as usize] = swap;
|
||||
last_byte = c;
|
||||
}
|
||||
key_box
|
||||
}
|
||||
|
||||
/// 原地解密一个音频块。
|
||||
///
|
||||
/// 对照 `ncmdump` `src/ncmcrypt.cpp::Dump`——`i` 是**块内下标**,`j = (i + 1) & 0xff`:
|
||||
///
|
||||
/// ```text
|
||||
/// buf[i] ^= mKeyBox[(mKeyBox[j] + mKeyBox[(mKeyBox[j] + j) & 0xff]) & 0xff];
|
||||
/// ```
|
||||
///
|
||||
/// 块与块之间不重置密钥盒、也不额外跳字节(`0x8000` 只是块大小)。
|
||||
/// 该式只依赖 `i` 与密钥盒,故分块与整体解密结果一致(见单测)。
|
||||
fn decrypt_audio_chunk(key_box: &[u8; 256], buf: &mut [u8]) {
|
||||
for i in 0..buf.len() {
|
||||
let j = (i + 1) & 0xff;
|
||||
let k = key_box
|
||||
[key_box[j].wrapping_add(key_box[key_box[j].wrapping_add(j as u8) as usize]) as usize];
|
||||
buf[i] ^= k;
|
||||
}
|
||||
}
|
||||
|
||||
/// 封面/标签用的图片扩展名(按魔数,不按 ncm 的说法)
|
||||
fn image_ext(data: &[u8]) -> &'static str {
|
||||
common::image_ext(data)
|
||||
}
|
||||
|
||||
/// 读满一块(短读不算块边界)——实现见 [`common::read_full`]。
|
||||
fn read_full(r: &mut impl Read, buf: &mut [u8]) -> Result<usize> {
|
||||
common::read_full(r, buf)
|
||||
}
|
||||
|
||||
fn read_u32(r: &mut impl Read) -> Result<u32> {
|
||||
let mut b = [0u8; 4];
|
||||
r.read_exact(&mut b)
|
||||
.map_err(|_| NcmError::Broken("读取长度字段时提前结束".into()))?;
|
||||
Ok(u32::from_le_bytes(b))
|
||||
}
|
||||
|
||||
fn read_n(r: &mut impl Read, n: usize) -> Result<Vec<u8>> {
|
||||
let mut buf = vec![0u8; n];
|
||||
r.read_exact(&mut buf)
|
||||
.map_err(|_| NcmError::Broken(format!("读取 {n} 字节时提前结束")))?;
|
||||
Ok(buf)
|
||||
}
|
||||
|
||||
/// 解析 meta JSON 为 `NcmMeta`。
|
||||
///
|
||||
/// `artist` 是二维数组(`[["名字", id], ...]`),取每项第 0 个元素并用 `/` 连接。
|
||||
fn parse_meta(json: &str) -> NcmMeta {
|
||||
let Ok(v) = serde_json::from_str::<serde_json::Value>(json) else {
|
||||
return NcmMeta::default();
|
||||
};
|
||||
let s = |k: &str| v.get(k).and_then(|x| x.as_str()).map(|x| x.to_string());
|
||||
let n = |k: &str| v.get(k).and_then(|x| x.as_u64());
|
||||
let artist = v.get("artist").and_then(|a| a.as_array()).map(|arr| {
|
||||
arr.iter()
|
||||
.filter_map(|item| {
|
||||
item.as_array()
|
||||
.and_then(|inner| inner.first())
|
||||
.and_then(|name| name.as_str())
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("/")
|
||||
});
|
||||
NcmMeta {
|
||||
name: s("musicName"),
|
||||
artist: artist.filter(|a| !a.is_empty()),
|
||||
album: s("album"),
|
||||
bitrate: n("bitrate"),
|
||||
duration: n("duration"),
|
||||
format: s("format"),
|
||||
}
|
||||
}
|
||||
|
||||
/// 解析头部 + key 段 + meta 段 + 封面,返回 (密钥盒, meta, 封面字节)。
|
||||
fn read_header(r: &mut impl Read) -> Result<([u8; 256], NcmMeta, Option<Vec<u8>>)> {
|
||||
// 0x00 magic 8B
|
||||
let magic = read_n(r, 8)?;
|
||||
if &magic != MAGIC {
|
||||
return Err(NcmError::NotEncrypted(
|
||||
"不是网易云加密文件(头部魔数不是 CTENFDAM)".into(),
|
||||
));
|
||||
}
|
||||
// 0x08 固定 2 字节(读取权重仅为推进游标)
|
||||
let _ = read_n(r, 2)?;
|
||||
|
||||
// ---- key 段 ----
|
||||
let key_len = read_u32(r)? as usize;
|
||||
if key_len == 0 {
|
||||
return Err(NcmError::Broken("key 段长度为 0".into()));
|
||||
}
|
||||
let mut key_data = read_n(r, key_len)?;
|
||||
for b in key_data.iter_mut() {
|
||||
*b ^= XOR_KEY;
|
||||
}
|
||||
let key_plain = aes_ecb_decrypt(CORE_AES_KEY, &key_data)?;
|
||||
if key_plain.len() <= CORE_KEY.len() {
|
||||
return Err(NcmError::Broken(format!(
|
||||
"key 段解密后仅 {} 字节,不足以剥离前缀",
|
||||
key_plain.len()
|
||||
)));
|
||||
}
|
||||
// 剥离 "neteasecloudmusic\0" 前缀,其余即密钥盒种子
|
||||
let rc4_key = &key_plain[CORE_KEY.len()..];
|
||||
let key_box = build_key_box(rc4_key);
|
||||
|
||||
// ---- meta 段 ----
|
||||
let meta_len = read_u32(r)? as usize;
|
||||
let mut meta = NcmMeta::default();
|
||||
if meta_len > 0 {
|
||||
let mut meta_data = read_n(r, meta_len)?;
|
||||
for b in meta_data.iter_mut() {
|
||||
*b ^= XOR_META;
|
||||
}
|
||||
// 第一层前缀:literal,先剥掉再 base64
|
||||
if meta_data.len() > META_PREFIX.len() {
|
||||
let body = &meta_data[META_PREFIX.len()..];
|
||||
use base64::Engine;
|
||||
if let Ok(decoded) = base64::engine::general_purpose::STANDARD.decode(body) {
|
||||
if let Ok(plain) = aes_ecb_decrypt(MODIFY_KEY, &decoded) {
|
||||
// 第二层前缀:"music:"
|
||||
let json = if plain.len() > META_JSON_PREFIX.len() {
|
||||
&plain[META_JSON_PREFIX.len()..]
|
||||
} else {
|
||||
&plain[..]
|
||||
};
|
||||
// 元数据非 UTF-8 或非 JSON 都不致命:放弃标签即可
|
||||
if let Ok(s) = std::str::from_utf8(json) {
|
||||
meta = parse_meta(s);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---- 封面段 ----
|
||||
// 跳 5 字节:CRC32(4) + 图片版本(1)
|
||||
let mut five = [0u8; 5];
|
||||
r.read_exact(&mut five)
|
||||
.map_err(|_| NcmError::Broken("读取 CRC32/图片版本时提前结束".into()))?;
|
||||
let cover_frame_len = read_u32(r)? as usize;
|
||||
let img_len = read_u32(r)? as usize;
|
||||
let cover = if img_len > 0 {
|
||||
Some(read_n(r, img_len)?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
// 跳到 key 帧末尾
|
||||
if cover_frame_len > img_len {
|
||||
let mut discard = vec![0u8; cover_frame_len - img_len];
|
||||
let _ = r.read_exact(&mut discard);
|
||||
}
|
||||
|
||||
Ok((key_box, meta, cover))
|
||||
}
|
||||
|
||||
/// 判断文件是否为网易云 `.ncm`(只读 8 字节魔数)。
|
||||
pub fn sniff(path: &Path) -> bool {
|
||||
let Ok(mut f) = File::open(path) else {
|
||||
return false;
|
||||
};
|
||||
let mut magic = [0u8; 8];
|
||||
std::io::Read::read_exact(&mut f, &mut magic).is_ok() && &magic == MAGIC
|
||||
}
|
||||
|
||||
/// 解密一个 `.ncm` 文件到 `out_dir`,返回产物信息。
|
||||
///
|
||||
/// `progress` 每处理一块回调一次(已处理字节数,总字节数),供上层节流后推事件。
|
||||
/// `platform_label` 由调度层给出(如「网易云」),用于产物备注。
|
||||
pub fn decrypt_file<F>(
|
||||
input: &Path,
|
||||
out_dir: &Path,
|
||||
platform_label: &str,
|
||||
reserved: &mut std::collections::HashSet<String>,
|
||||
mut progress: F,
|
||||
) -> Result<common::Outcome>
|
||||
where
|
||||
F: FnMut(u64, u64),
|
||||
{
|
||||
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
|
||||
let file = File::open(input)?;
|
||||
let mut reader = BufReader::with_capacity(CHUNK, file);
|
||||
|
||||
let (key_box, meta, cover) = read_header(&mut reader)?;
|
||||
|
||||
std::fs::create_dir_all(out_dir)?;
|
||||
|
||||
// 先写临时文件:格式要等第一块解出来才知道,而输出名又依赖格式。
|
||||
// 定稿后再 rename —— 中途失败不会留下半个音频冒充成品。
|
||||
let tmp = out_dir.join(format!(
|
||||
".dec_part_{}_{}.tmp",
|
||||
std::process::id(),
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.as_nanos())
|
||||
.unwrap_or(0)
|
||||
));
|
||||
|
||||
let mut buf = vec![0u8; CHUNK];
|
||||
let mut done: u64 = 0;
|
||||
let mut format: Option<&'static str> = None;
|
||||
let mut audio_bytes: u64 = 0;
|
||||
|
||||
let write_result = (|| -> Result<()> {
|
||||
let out = File::create(&tmp)?;
|
||||
let mut writer = BufWriter::with_capacity(CHUNK, out);
|
||||
loop {
|
||||
// **必须读满一个块**(或读到 EOF),不能用 `read` 的短读结果当块边界。
|
||||
// 解密式依赖「块内偏移 i」,块边界一漂移密钥盒相位就错位——
|
||||
// 表现为文件从中间某处起全是噪声、前面对得上,极难排查(§6.24)。
|
||||
let n = read_full(&mut reader, &mut buf)?;
|
||||
if n == 0 {
|
||||
break;
|
||||
}
|
||||
decrypt_audio_chunk(&key_box, &mut buf[..n]);
|
||||
if format.is_none() {
|
||||
format = Some(common::detect_format(&buf[..n]));
|
||||
}
|
||||
writer.write_all(&buf[..n])?;
|
||||
done += n as u64;
|
||||
audio_bytes += n as u64;
|
||||
progress(done, total);
|
||||
}
|
||||
writer.flush()?;
|
||||
Ok(())
|
||||
})();
|
||||
|
||||
if let Err(e) = write_result {
|
||||
let _ = std::fs::remove_file(&tmp);
|
||||
return Err(e);
|
||||
}
|
||||
|
||||
let format = format.ok_or_else(|| {
|
||||
let _ = std::fs::remove_file(&tmp);
|
||||
NcmError::Broken("音频段为空".into())
|
||||
})?;
|
||||
|
||||
let stem = input
|
||||
.file_stem()
|
||||
.map(|s| s.to_string_lossy().to_string())
|
||||
.unwrap_or_else(|| "output".to_string());
|
||||
let target = common::unique_output(out_dir, &stem, format, reserved)?;
|
||||
std::fs::rename(&tmp, &target).map_err(|e| {
|
||||
let _ = std::fs::remove_file(&tmp);
|
||||
NcmError::Output(format!("重命名产物失败:{e}"))
|
||||
})?;
|
||||
|
||||
// 封面单独落盘(标签回填留 P2:需要 lofty 且要按容器分派)
|
||||
let cover_path = match cover {
|
||||
Some(data) if !data.is_empty() => {
|
||||
let ext = image_ext(&data);
|
||||
let path = common::unique_output(out_dir, &format!("{stem}.cover"), ext, reserved)?;
|
||||
std::fs::write(&path, &data)?;
|
||||
Some(path)
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
|
||||
// 标签信息汇总成一行备注(P2 回填标签前,这是元数据唯一的出口)
|
||||
let mut note = format!("{platform_label} ncm");
|
||||
if let Some(n) = meta.name.as_deref() {
|
||||
note.push_str(&format!(" · {n}"));
|
||||
}
|
||||
if let Some(a) = meta.artist.as_deref() {
|
||||
note.push_str(&format!(" - {a}"));
|
||||
}
|
||||
// 位率/时长/专辑:解析成本已经付过,顺手带进备注(也避免字段闲置)
|
||||
let mut bits: Vec<String> = Vec::new();
|
||||
if let Some(b) = meta.bitrate {
|
||||
if b > 0 {
|
||||
bits.push(format!("{} kbps", b / 1000));
|
||||
}
|
||||
}
|
||||
if let Some(d) = meta.duration {
|
||||
if d > 0 {
|
||||
let secs = d / 1000;
|
||||
bits.push(format!("{}:{:02}", secs / 60, secs % 60));
|
||||
}
|
||||
}
|
||||
if let Some(al) = meta.album.as_deref() {
|
||||
bits.push(format!("专辑《{al}》"));
|
||||
}
|
||||
if let Some(f) = meta.format.as_deref() {
|
||||
bits.push(format!("声明格式 {f}"));
|
||||
}
|
||||
if !bits.is_empty() {
|
||||
note.push_str(&format!("({})", bits.join(" · ")));
|
||||
}
|
||||
|
||||
Ok(common::Outcome {
|
||||
output: target,
|
||||
format: format.to_string(),
|
||||
cover: cover_path,
|
||||
audio_bytes,
|
||||
note,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use aes::cipher::BlockEncrypt;
|
||||
|
||||
const ZERO_KEY: [u8; 16] = [0u8; 16];
|
||||
|
||||
/// AES 正向加密(测试用),与 `aes_ecb_decrypt` 互逆。
|
||||
fn aes_ecb_encrypt(key: &[u8; 16], data: &[u8]) -> Vec<u8> {
|
||||
let cipher = Aes128::new(GenericArray::from_slice(key));
|
||||
let mut out = Vec::with_capacity(data.len());
|
||||
let mut buf = [0u8; 16];
|
||||
for chunk in data.chunks(16) {
|
||||
let block = GenericArray::from_slice(chunk);
|
||||
cipher.encrypt_block_b2b(block, GenericArray::from_mut_slice(&mut buf));
|
||||
out.extend_from_slice(&buf);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn pkcs7_pad(data: &[u8]) -> Vec<u8> {
|
||||
let pad = 16 - (data.len() % 16);
|
||||
let mut out = data.to_vec();
|
||||
out.extend(std::iter::repeat(pad as u8).take(pad));
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn aes_ecb_roundtrip_with_pkcs7() {
|
||||
let plain = b"CTENFDAM-test-payload-1234";
|
||||
let padded = pkcs7_pad(plain);
|
||||
assert_eq!(padded.len() % 16, 0);
|
||||
let enc = aes_ecb_encrypt(&ZERO_KEY, &padded);
|
||||
let dec = aes_ecb_decrypt(&ZERO_KEY, &enc).expect("decrypt");
|
||||
assert_eq!(dec, plain);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn aes_ecb_rejects_non_block_multiple() {
|
||||
assert!(aes_ecb_decrypt(&ZERO_KEY, &[0u8; 17]).is_err());
|
||||
assert!(aes_ecb_decrypt(&ZERO_KEY, &[]).is_err());
|
||||
}
|
||||
|
||||
/// 空 key 时密钥盒必须是恒等置换(KSA 的边界行为)
|
||||
#[test]
|
||||
fn key_box_identity_for_empty_key() {
|
||||
let kb = build_key_box(&[]);
|
||||
for i in 0..256 {
|
||||
assert_eq!(kb[i], i as u8);
|
||||
}
|
||||
}
|
||||
|
||||
/// 已知答案向量:由参考实现(`ncmdump` 的 `buildKeyBox`)独立算出的值。
|
||||
///
|
||||
/// 注意**不能**用「与标准 RC4 比对」来验证——`last_byte` 在模 256 下是恒等变形,
|
||||
/// 两者逐字节相同。只能靠固定向量锁行为。
|
||||
#[test]
|
||||
fn key_box_matches_reference_vectors() {
|
||||
let kb = build_key_box(b"0123456789abcdef");
|
||||
assert_eq!(
|
||||
&kb[..8],
|
||||
&[0x88, 0x62, 0x96, 0xcc, 0x79, 0x85, 0x7a, 0x21],
|
||||
"密钥盒前 8 字节与参考实现不符"
|
||||
);
|
||||
assert_eq!(
|
||||
&kb[8..16],
|
||||
&[0x15, 0x49, 0xa5, 0x91, 0x3d, 0xc6, 0x65, 0xda],
|
||||
"密钥盒第 8..16 字节与参考实现不符"
|
||||
);
|
||||
}
|
||||
|
||||
/// 已知答案向量:全零明文的密钥流(即 PRGA 输出)前 24 字节。
|
||||
#[test]
|
||||
fn keystream_matches_reference_vector() {
|
||||
let kb = build_key_box(b"0123456789abcdef");
|
||||
let mut data = [0u8; 24];
|
||||
decrypt_audio_chunk(&kb, &mut data);
|
||||
assert_eq!(
|
||||
data,
|
||||
[
|
||||
0x1d, 0xaf, 0xd7, 0x79, 0xfa, 0xce, 0x0c, 0x2b, 0xab, 0xc4, 0x8c, 0xeb, 0x0d, 0xc3,
|
||||
0x6a, 0x5c, 0xc6, 0x07, 0x79, 0x63, 0x92, 0x72, 0x69, 0x1b
|
||||
],
|
||||
"密钥流与参考实现不符"
|
||||
);
|
||||
}
|
||||
|
||||
/// 密钥必须循环取用满 256 轮:`key_offset` 归零逻辑要正确。
|
||||
#[test]
|
||||
fn key_box_cycles_key_correctly() {
|
||||
let a = vec![7u8; 300];
|
||||
let mut b = vec![7u8; 300];
|
||||
b[250] = 8;
|
||||
assert_ne!(
|
||||
build_key_box(&a),
|
||||
build_key_box(&b),
|
||||
"密钥第 250 字节未参与运算——key_offset 取模有误"
|
||||
);
|
||||
|
||||
// 短密钥(1 字节)也不能 panic,且是合法置换
|
||||
let kb = build_key_box(&[0x42]);
|
||||
let mut seen = [false; 256];
|
||||
for &x in kb.iter() {
|
||||
seen[x as usize] = true;
|
||||
}
|
||||
assert!(seen.iter().all(|&v| v));
|
||||
}
|
||||
|
||||
/// 加密→解密往返:验证 `decrypt_audio_chunk` 与自身一致,
|
||||
/// 且块边界不改变结果(`i` 是块内下标这一设计的关键性质)。
|
||||
#[test]
|
||||
fn audio_chunk_roundtrip_and_block_boundary_invariance() {
|
||||
let kb = build_key_box(b"0123456789abcdef");
|
||||
let plain: Vec<u8> = (0..(CHUNK + 777)).map(|i| (i % 251) as u8).collect();
|
||||
|
||||
let mut whole = plain.clone();
|
||||
decrypt_audio_chunk(&kb, &mut whole);
|
||||
assert_ne!(whole, plain, "解密未改变数据,密钥盒或 XOR 有误");
|
||||
|
||||
let mut chunked = plain.clone();
|
||||
for c in chunked.chunks_mut(CHUNK) {
|
||||
decrypt_audio_chunk(&kb, c);
|
||||
}
|
||||
assert_eq!(chunked, whole, "分块解密与整体解密结果不一致");
|
||||
|
||||
decrypt_audio_chunk(&kb, &mut chunked);
|
||||
assert_eq!(chunked, plain);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_meta_reads_nested_artist() {
|
||||
let json = r#"{"musicName":"歌","album":"专辑","bitrate":999000,
|
||||
"duration":215000,"format":"flac",
|
||||
"artist":[["歌手甲",1],["歌手乙",2]]}"#;
|
||||
let m = parse_meta(json);
|
||||
assert_eq!(m.name.as_deref(), Some("歌"));
|
||||
assert_eq!(m.album.as_deref(), Some("专辑"));
|
||||
assert_eq!(m.artist.as_deref(), Some("歌手甲/歌手乙"));
|
||||
assert_eq!(m.bitrate, Some(999000));
|
||||
assert_eq!(m.duration, Some(215000));
|
||||
assert_eq!(m.format.as_deref(), Some("flac"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_meta_tolerates_garbage() {
|
||||
let m = parse_meta("not json at all");
|
||||
assert!(m.name.is_none() && m.artist.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn not_ncm_file_is_rejected() {
|
||||
let dir = std::env::temp_dir().join(format!("ncm_bad_{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
let p = dir.join("fake.ncm");
|
||||
std::fs::write(&p, b"NOTNCM!!\x02\x00\x00\x00\x00").unwrap();
|
||||
let mut reserved = std::collections::HashSet::new();
|
||||
let err = decrypt_file(&p, &dir, "网易云", &mut reserved, |_, _| {}).unwrap_err();
|
||||
assert!(
|
||||
matches!(err, NcmError::NotEncrypted(_)),
|
||||
"期望 NotEncrypted,实得 {err:?}"
|
||||
);
|
||||
assert!(!sniff(&p), "魔数不符的文件 sniff 应为 false");
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// **正向构造**一个合法 ncm 容器,再解回来。
|
||||
/// 这样无需把真实音乐样本(体积大、有版权)放进仓库,仍能覆盖:
|
||||
/// 两段 XOR 常量、两层 meta 前缀、封面段偏移、分块解密、魔数定格式、输出命名。
|
||||
#[test]
|
||||
fn synthetic_ncm_roundtrip() {
|
||||
let dir = std::env::temp_dir().join(format!("ncm_rt_{}", std::process::id()));
|
||||
let out = dir.join("out");
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
|
||||
// 与密钥盒用例共用的固定种子
|
||||
let seed: &[u8] = b"0123456789abcdef";
|
||||
|
||||
// 音频明文:以 fLaC 开头,长度跨块边界多一点
|
||||
let mut plain = b"fLaC".to_vec();
|
||||
plain.extend((0..(CHUNK + 123)).map(|i| (i % 253) as u8));
|
||||
|
||||
// 用它"加密"音频(XOR 自逆)。加密必须与解密用同样的块大小,
|
||||
// 否则 PRGA 相位错位(这正是 read_full 存在的原因)。
|
||||
let kb = build_key_box(seed);
|
||||
let mut cipher_audio = plain.clone();
|
||||
for c in cipher_audio.chunks_mut(CHUNK) {
|
||||
decrypt_audio_chunk(&kb, c);
|
||||
}
|
||||
|
||||
// key 段:**必须**是 CORE_KEY 前缀 + 种子——解密端会剥掉这 17 字节前缀,
|
||||
// 少了它就会拿到错误的种子。
|
||||
let mut key_plain = CORE_KEY.to_vec();
|
||||
key_plain.extend_from_slice(seed);
|
||||
let mut key_seg = aes_ecb_encrypt(CORE_AES_KEY, &pkcs7_pad(&key_plain));
|
||||
for b in key_seg.iter_mut() {
|
||||
*b ^= XOR_KEY;
|
||||
}
|
||||
|
||||
// meta 段:META_PREFIX + base64(AES(META_JSON_PREFIX + json)),再 XOR 0x63
|
||||
let json = r#"{"musicName":"合成曲","album":"合成专辑","bitrate":320000,"duration":1000,"format":"flac","artist":[["测试歌手",1]]}"#;
|
||||
let mut meta_plain = META_JSON_PREFIX.to_vec();
|
||||
meta_plain.extend_from_slice(json.as_bytes());
|
||||
let meta_enc = aes_ecb_encrypt(MODIFY_KEY, &pkcs7_pad(&meta_plain));
|
||||
use base64::Engine;
|
||||
let meta_b64 = base64::engine::general_purpose::STANDARD.encode(&meta_enc);
|
||||
let mut meta_seg = META_PREFIX.to_vec();
|
||||
meta_seg.extend_from_slice(meta_b64.as_bytes());
|
||||
for b in meta_seg.iter_mut() {
|
||||
*b ^= XOR_META;
|
||||
}
|
||||
|
||||
// 封面段:PNG 魔数 + 一点数据;cover_len 故意大于 img_len 以覆盖"跳过尾部"
|
||||
let img: Vec<u8> = [
|
||||
&[0x89u8, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A][..],
|
||||
&[7u8; 40],
|
||||
]
|
||||
.concat();
|
||||
let cover_padding = [0u8; 9];
|
||||
let cover_frame_len = (img.len() + cover_padding.len()) as u32;
|
||||
|
||||
let mut container = Vec::new();
|
||||
container.extend_from_slice(MAGIC);
|
||||
container.extend_from_slice(&[0x02, 0x00]); // 固定 2B
|
||||
container.extend_from_slice(&(key_seg.len() as u32).to_le_bytes());
|
||||
container.extend_from_slice(&key_seg);
|
||||
container.extend_from_slice(&(meta_seg.len() as u32).to_le_bytes());
|
||||
container.extend_from_slice(&meta_seg);
|
||||
container.extend_from_slice(&[0xAA, 0xBB, 0xCC, 0xDD, 0x01]); // CRC32 + 图片版本
|
||||
container.extend_from_slice(&cover_frame_len.to_le_bytes());
|
||||
container.extend_from_slice(&(img.len() as u32).to_le_bytes());
|
||||
container.extend_from_slice(&img);
|
||||
container.extend_from_slice(&cover_padding);
|
||||
container.extend_from_slice(&cipher_audio);
|
||||
|
||||
let src = dir.join("测试 曲目.ncm");
|
||||
std::fs::write(&src, &container).unwrap();
|
||||
assert!(sniff(&src), "合法容器的 sniff 应为 true");
|
||||
|
||||
let mut reserved = std::collections::HashSet::new();
|
||||
let mut ticks = 0usize;
|
||||
let res = decrypt_file(&src, &out, "网易云", &mut reserved, |_, _| ticks += 1)
|
||||
.expect("解密应成功");
|
||||
|
||||
assert_eq!(res.format, "flac");
|
||||
assert_eq!(res.audio_bytes, plain.len() as u64);
|
||||
assert!(ticks >= 2, "进度回调应至少触发两次(跨块),实得 {ticks}");
|
||||
|
||||
// 用长度 + 位置比较,避免 assert_eq! 在失败时倾倒几十万字节
|
||||
let got = std::fs::read(&res.output).unwrap();
|
||||
assert_eq!(got.len(), plain.len(), "音频长度不一致");
|
||||
let first_diff = got.iter().zip(plain.iter()).position(|(a, b)| a != b);
|
||||
assert!(
|
||||
got == plain,
|
||||
"音频明文不一致:第一个不同处在第 {:?} 字节",
|
||||
first_diff
|
||||
);
|
||||
|
||||
// 元数据不再单独暴露,而是拼进 note——所以直接验 note 里带上了它
|
||||
assert!(res.note.contains("合成曲"), "note 应含曲名:{}", res.note);
|
||||
assert!(res.note.contains("测试歌手"), "note 应含歌手:{}", res.note);
|
||||
assert!(res.note.contains("合成专辑"), "note 应含专辑:{}", res.note);
|
||||
// 位率 320000 → 320 kbps
|
||||
assert!(res.note.contains("320 kbps"), "note 应含位率:{}", res.note);
|
||||
|
||||
let cover = res.cover.expect("应提取出封面");
|
||||
let cover_bytes = std::fs::read(&cover).unwrap();
|
||||
assert_eq!(cover_bytes.len(), img.len(), "封面长度不一致");
|
||||
assert!(cover_bytes == img, "封面字节不一致");
|
||||
assert_eq!(cover.extension().unwrap(), "png");
|
||||
|
||||
// 中文文件名 + 中文输出路径:产物名应保留原名
|
||||
assert_eq!(
|
||||
res.output.file_name().unwrap().to_string_lossy(),
|
||||
"测试 曲目.flac"
|
||||
);
|
||||
|
||||
// 再解一次:同名必须让位而不是覆盖
|
||||
let res2 =
|
||||
decrypt_file(&src, &out, "网易云", &mut reserved, |_, _| {}).expect("二次解密应成功");
|
||||
assert_eq!(
|
||||
res2.output.file_name().unwrap().to_string_lossy(),
|
||||
"测试 曲目_1.flac"
|
||||
);
|
||||
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
//! **开发探针**:不落盘地跑完「musicex 尾部 → 凭据 → 在线取密钥 → 解密」并回传结果。
|
||||
//!
|
||||
//! 存在的唯一理由:musicex 这条路径的**真实响应字段**只能靠真机样本验证,
|
||||
//! 而跑起整个 Tauri 应用再手点一遍成本太高、也没法在命令行里复现。
|
||||
//! 它不参与产品逻辑——调度层走的是 [`super::qq_online::decrypt_musicex`]。
|
||||
//!
|
||||
//! 2026-09-27 用它跑通了首个真机样本(197MB `.mflac`,192kHz/24bit):
|
||||
//! ekey 704 字符 → 派生 512 字节密钥 → RC4 变体解密 → `fLaC` 头。
|
||||
//! **这条验证顺带推翻了一个错误假设**:该样本的密文头是 `51 74 03 75`,
|
||||
//! 并非文档里提到的 `#!Qk`,所以密文头不能当守卫(见 `qq_online` 的注释)。
|
||||
//!
|
||||
//! 用法见 `src-tauri/examples/decrypt_musicex_probe.rs`:
|
||||
//! ```text
|
||||
//! cargo run --example decrypt_musicex_probe -- "C:\path\to\sample.mflac" [输出目录]
|
||||
//! ```
|
||||
|
||||
use std::io::Read;
|
||||
use std::path::Path;
|
||||
|
||||
use super::common::DecryptError;
|
||||
use super::qmc;
|
||||
use super::qq_credentials;
|
||||
use super::qq_ekey::{self, EvkeyRequest};
|
||||
use super::qq_footer::{self, MusiCexTail};
|
||||
|
||||
/// 探针结果(都是"结论性"字段,便于一眼判断链路是否通了)
|
||||
pub struct ProbeOutcome {
|
||||
pub ekey_len: usize,
|
||||
pub key_len: usize,
|
||||
pub raw_key_bytes: Vec<u8>,
|
||||
/// 密文头部 4 字节(应是 `#!Qk`,即 QMC2 魔术)
|
||||
pub cipher_magic: Vec<u8>,
|
||||
/// 解密后头部 16 字节(FLAC 应为 `fLaC`)
|
||||
pub plain_magic: Vec<u8>,
|
||||
pub decrypted_bytes: usize,
|
||||
pub guessed_format: String,
|
||||
pub expiration_secs: i64,
|
||||
}
|
||||
|
||||
/// 对给定样本跑完整链路(**读内存、发网络请求、解密,但不写任何文件**)
|
||||
pub fn probe_musicex(input: &Path) -> Result<ProbeOutcome, DecryptError> {
|
||||
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
|
||||
if total < qq_footer::MUSICEX_FOOTER_LEN as u64 {
|
||||
return Err(DecryptError::Broken("文件太小,不可能是 musicex".into()));
|
||||
}
|
||||
|
||||
// 1) 尾部
|
||||
let tail: MusiCexTail = read_tail(input)?;
|
||||
let audio_len = tail.audio_len(total);
|
||||
|
||||
// 2) 凭据
|
||||
let creds = qq_credentials::read_credentials();
|
||||
let (Some(uin), Some(authst)) = (creds.uin.as_deref(), creds.authst.as_deref()) else {
|
||||
return Err(DecryptError::KeyRequired(format!(
|
||||
"凭据不可用:{}",
|
||||
creds.status_text()
|
||||
)));
|
||||
};
|
||||
|
||||
// 3) 取 ekey(真实网络请求)
|
||||
let req = EvkeyRequest::from_tail(&tail, uin, authst)?;
|
||||
let client = reqwest::Client::builder()
|
||||
.timeout(std::time::Duration::from_secs(25))
|
||||
.build()
|
||||
.map_err(|e| DecryptError::KeyRequired(format!("构建 HTTP 客户端失败:{e}")))?;
|
||||
let (ekey, expiration_secs) =
|
||||
tauri::async_runtime::block_on(qq_ekey::fetch_ekey(&client, &req))?;
|
||||
|
||||
// 4) ekey → 原始密钥
|
||||
let raw = qmc::parse_ekey(&ekey)?;
|
||||
|
||||
// 5) 解密音频段(探针只验证单文件,全量读入内存即可)
|
||||
let mut audio = read_audio(input, audio_len)?;
|
||||
let cipher_magic = audio[..4.min(audio.len())].to_vec();
|
||||
qmc::decrypt_with_raw_key(&raw, &mut audio);
|
||||
|
||||
let plain_magic = audio[..16.min(audio.len())].to_vec();
|
||||
let guessed_format = super::common::detect_format_opt(&audio)
|
||||
.unwrap_or("unknown")
|
||||
.to_string();
|
||||
|
||||
Ok(ProbeOutcome {
|
||||
ekey_len: ekey.len(),
|
||||
key_len: raw.len(),
|
||||
raw_key_bytes: raw,
|
||||
cipher_magic,
|
||||
plain_magic,
|
||||
decrypted_bytes: audio.len(),
|
||||
guessed_format,
|
||||
expiration_secs,
|
||||
})
|
||||
}
|
||||
|
||||
/// 读文件末尾的 musicex 尾部
|
||||
fn read_tail(input: &Path) -> Result<MusiCexTail, DecryptError> {
|
||||
use std::io::{Seek, SeekFrom};
|
||||
let mut f = std::fs::File::open(input)?;
|
||||
let size = f.metadata()?.len();
|
||||
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
|
||||
f.seek(SeekFrom::End(-(take as i64)))?;
|
||||
let mut buf = vec![0u8; take];
|
||||
f.read_exact(&mut buf)?;
|
||||
qq_footer::parse_musicex_tail(&buf)
|
||||
.ok_or_else(|| DecryptError::Broken("musicex 尾部解析失败".into()))
|
||||
}
|
||||
|
||||
/// 只读音频段
|
||||
fn read_audio(input: &Path, audio_len: u64) -> Result<Vec<u8>, DecryptError> {
|
||||
let mut f = std::fs::File::open(input)?;
|
||||
let mut buf = vec![0u8; audio_len as usize];
|
||||
f.read_exact(&mut buf)?;
|
||||
Ok(buf)
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,285 @@
|
||||
//! QQ音乐本机凭据读取(`uin` + `authst`)。
|
||||
//!
|
||||
//! ## 为什么要读进程内存
|
||||
//!
|
||||
//! Windows 版 QQ 音乐**没有持久化 `authst`**:`uin` 能从
|
||||
//! `%APPDATA%\Tencent\QQMusic\QQMusicServiceConfig.ini` 明文读到,但 `authst`
|
||||
//! 只作为 JSON 字符串存在于运行中的 `QQMusic.exe` 内存里(有效期约 22.3 小时)。
|
||||
//! 所以「在线取 ekey」的前置条件是:**QQ 音乐正在运行且已登录**。
|
||||
//!
|
||||
//! 这里只做**只读**内存访问(`OpenProcess` + `VirtualQueryEx` + `ReadProcessMemory`),
|
||||
//! 不注入、不改写任何东西——这是它与 Frida 兜底方案的本质区别,
|
||||
//! 也是它通常不会被安全软件拦截的原因。
|
||||
//!
|
||||
//! ## 结构
|
||||
//!
|
||||
//! - [`parse_ini_uin`]:纯函数,可跨平台单测;
|
||||
//! - [`find_authst`]:纯函数,在给定字节里找 `"authst":"<token>"`,可单测;
|
||||
//! - [`read_credentials`]:平台相关的胶水(Windows 实现 / 其他平台的空实现)。
|
||||
|
||||
/// 从 QQ 音乐的 INI 文本里取 `[Account] Uin`。
|
||||
///
|
||||
/// 该文件很小(实测 27 字节)且是**纯文本**,格式固定:
|
||||
///
|
||||
/// ```ini
|
||||
/// [Account]
|
||||
/// Uin=1154027699
|
||||
/// ```
|
||||
///
|
||||
/// 解析上刻意宽松:允许前导空白、大小写不敏感、允许 `Uin` 出现在任意段里
|
||||
/// (不同版本段名可能变),但**只认第一处**出现的非空 Uin。
|
||||
pub fn parse_ini_uin(text: &str) -> Option<String> {
|
||||
for line in text.lines() {
|
||||
let line = line.trim();
|
||||
if line.is_empty() || line.starts_with(';') || line.starts_with('#') {
|
||||
continue;
|
||||
}
|
||||
let Some((key, value)) = line.split_once('=') else {
|
||||
continue;
|
||||
};
|
||||
if !key.trim().eq_ignore_ascii_case("uin") {
|
||||
continue;
|
||||
}
|
||||
let v = value.trim().trim_matches('"');
|
||||
// 必须是纯数字(QQ 号),排除 `Uin=` 之类的空值或占位
|
||||
if !v.is_empty() && v.bytes().all(|b| b.is_ascii_digit()) {
|
||||
return Some(v.to_string());
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// `authst` 在内存里的 JSON 形态:`"authst":"<base64url-ish>"`。
|
||||
const AUTHST_KEY: &[u8] = b"\"authst\":\"";
|
||||
|
||||
/// 在一段内存字节里查找 `authst` 的值(从 0 开始)。
|
||||
///
|
||||
/// 生产路径用 [`find_authst_from`](分块扫描需要偏移),这个薄封装给测试用。
|
||||
#[cfg_attr(not(test), allow(dead_code))]
|
||||
pub fn find_authst(haystack: &[u8]) -> Option<String> {
|
||||
find_authst_from(haystack, 0)
|
||||
}
|
||||
|
||||
/// 从 `start` 起查找(供分块扫描时避免重复命中同一处)
|
||||
pub fn find_authst_from(haystack: &[u8], start: usize) -> Option<String> {
|
||||
let mut pos = start;
|
||||
while pos + AUTHST_KEY.len() <= haystack.len() {
|
||||
let Some(rel) = find_subslice(&haystack[pos..], AUTHST_KEY) else {
|
||||
return None;
|
||||
};
|
||||
let val_start = pos + rel + AUTHST_KEY.len();
|
||||
// token 到下一个双引号结束
|
||||
let Some(end_rel) = haystack[val_start..].iter().position(|&b| b == b'"') else {
|
||||
return None;
|
||||
};
|
||||
let token = &haystack[val_start..val_start + end_rel];
|
||||
if is_plausible_token(token) {
|
||||
return Some(String::from_utf8_lossy(token).to_string());
|
||||
}
|
||||
// 命中但是假阳性:从下一个字节继续找
|
||||
pos = val_start;
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn find_subslice(haystack: &[u8], needle: &[u8]) -> Option<usize> {
|
||||
if needle.is_empty() || haystack.len() < needle.len() {
|
||||
return None;
|
||||
}
|
||||
haystack.windows(needle.len()).position(|w| w == needle)
|
||||
}
|
||||
|
||||
fn is_plausible_token(token: &[u8]) -> bool {
|
||||
token.len() >= 16
|
||||
&& token.iter().all(|&b| {
|
||||
b.is_ascii_alphanumeric()
|
||||
|| b == b'-'
|
||||
|| b == b'_'
|
||||
|| b == b'='
|
||||
|| b == b'+'
|
||||
|| b == b'/'
|
||||
})
|
||||
}
|
||||
|
||||
/// 凭据读取结果
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct QqCredentials {
|
||||
/// QQ 号(来自 INI)
|
||||
pub uin: Option<String>,
|
||||
/// 运行期认证令牌(来自进程内存)
|
||||
pub authst: Option<String>,
|
||||
}
|
||||
|
||||
impl QqCredentials {
|
||||
/// 是否可用于调用 `GetEVkey`
|
||||
pub fn usable(&self) -> bool {
|
||||
self.uin.is_some() && self.authst.is_some()
|
||||
}
|
||||
|
||||
/// 给 UI 的简短状态(三态,供状态卡渲染)
|
||||
pub fn status_text(&self) -> &'static str {
|
||||
match (self.uin.is_some(), self.authst.is_some()) {
|
||||
(true, true) => "已就绪",
|
||||
(true, false) => "QQ 音乐未运行或未登录",
|
||||
(false, _) => "未找到本机 QQ 音乐账号",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `QQMusic.exe` 的进程名(枚举时用大小写不敏感的子串匹配)
|
||||
pub const QQ_PROCESS_HINT: &str = "qqmusic";
|
||||
|
||||
/// QQ 音乐配置 INI 的路径(Windows)
|
||||
#[cfg(windows)]
|
||||
pub fn config_ini_path() -> Option<std::path::PathBuf> {
|
||||
let appdata = std::env::var_os("APPDATA")?;
|
||||
Some(
|
||||
std::path::PathBuf::from(appdata)
|
||||
.join("Tencent")
|
||||
.join("QQMusic")
|
||||
.join("QQMusicServiceConfig.ini"),
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
pub fn config_ini_path() -> Option<std::path::PathBuf> {
|
||||
None
|
||||
}
|
||||
|
||||
/// 读凭据:`uin` 从 INI,`authst` 扫进程内存。
|
||||
///
|
||||
/// 任何一步失败都只是 `None`(并记日志),不返回错误——调用方据
|
||||
/// [`QqCredentials::usable`] 决定是走在线取 ekey 还是给出引导。
|
||||
pub fn read_credentials() -> QqCredentials {
|
||||
let uin = config_ini_path()
|
||||
.and_then(|p| std::fs::read_to_string(&p).ok())
|
||||
.and_then(|t| parse_ini_uin(&t))
|
||||
.or_else(|| {
|
||||
// 兜底:文件读不到时,从进程内存里找 "uin":"..." 形态
|
||||
scan_authst_in_process().1
|
||||
});
|
||||
|
||||
let (authst, uin_from_mem) = match uin {
|
||||
// 有 uin 时只需要 authst
|
||||
Some(_) => (scan_authst_in_process().0, None),
|
||||
// 没 uin 时一次扫描同时拿两者
|
||||
None => {
|
||||
let (a, u) = scan_authst_in_process();
|
||||
(a, u)
|
||||
}
|
||||
};
|
||||
|
||||
QqCredentials {
|
||||
uin: uin.or(uin_from_mem),
|
||||
authst,
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn scan_authst_in_process() -> (Option<String>, Option<String>) {
|
||||
match crate::music::decrypt::qq_memscan::scan_qq_process() {
|
||||
Ok(found) => (found.authst, found.uin),
|
||||
Err(e) => {
|
||||
crate::logger::log_warn("music-decrypt", &format!("扫描 QQ 音乐进程内存失败:{e}"));
|
||||
(None, None)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
fn scan_authst_in_process() -> (Option<String>, Option<String>) {
|
||||
(None, None)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
// ============ INI 解析 ============
|
||||
|
||||
#[test]
|
||||
fn parses_real_ini_shape() {
|
||||
// 本机实测就是这个形状(27 字节)
|
||||
let text = "[Account]\r\nUin=1154027699\r\n";
|
||||
assert_eq!(parse_ini_uin(text).as_deref(), Some("1154027699"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_ini_leniently() {
|
||||
// 大小写、空白、引号、注释、其他段
|
||||
let text = "\u{feff}; comment\r\n[Other]\r\nx=1\r\n\r\n uin = \"123456\" \r\n";
|
||||
assert_eq!(parse_ini_uin(text).as_deref(), Some("123456"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ignores_non_numeric_or_empty_uin() {
|
||||
assert!(parse_ini_uin("Uin=\r\n").is_none());
|
||||
assert!(parse_ini_uin("Uin=abc\r\n").is_none());
|
||||
assert!(parse_ini_uin("Uin=12a45\r\n").is_none());
|
||||
assert!(parse_ini_uin("").is_none());
|
||||
assert!(parse_ini_uin("[Account]\nFoo=1\n").is_none());
|
||||
}
|
||||
|
||||
// ============ authst 提取 ============
|
||||
|
||||
#[test]
|
||||
fn finds_authst_in_memory_blob() {
|
||||
let token = "AbCd_-1234567890AbCd_-1234567890";
|
||||
let blob = format!("junk{{\"uin\":\"1154027699\",\"authst\":\"{token}\",\"other\":1}}tail");
|
||||
assert_eq!(find_authst(blob.as_bytes()).as_deref(), Some(token));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_implausible_authst() {
|
||||
// 太短
|
||||
assert!(find_authst(b"\"authst\":\"short\"").is_none());
|
||||
// 含非法字符(像模板/日志)
|
||||
assert!(find_authst(b"\"authst\":\"this is not a token at all\"").is_none());
|
||||
// 没有值
|
||||
assert!(find_authst(b"\"authst\":\"\"").is_none());
|
||||
// 完全没有
|
||||
assert!(find_authst(b"nothing here").is_none());
|
||||
}
|
||||
|
||||
/// 第一处是假阳性时,应继续往后找真 token
|
||||
#[test]
|
||||
fn skips_false_positive_and_keeps_searching() {
|
||||
let token = "RealToken_1234567890abcdef";
|
||||
let blob = format!("\"authst\":\"x\"...\"authst\":\"{token}\"");
|
||||
assert_eq!(find_authst(blob.as_bytes()).as_deref(), Some(token));
|
||||
}
|
||||
|
||||
/// 跨缓冲区边界不会误判(分块扫描用 find_authst_from)
|
||||
#[test]
|
||||
fn find_from_offset_advances() {
|
||||
let blob = b"aaaa\"authst\":\"AAAAAAAAAAAAAAAA\"";
|
||||
let first = find_authst_from(blob, 0).unwrap();
|
||||
assert_eq!(first, "AAAAAAAAAAAAAAAA");
|
||||
// 从命中处之后继续找应该没有第二个
|
||||
let key_at = 4 + AUTHST_KEY.len();
|
||||
assert!(find_authst_from(blob, key_at).is_none());
|
||||
}
|
||||
|
||||
// ============ 状态文案 ============
|
||||
|
||||
#[test]
|
||||
fn credentials_status_text_covers_three_states() {
|
||||
let none = QqCredentials::default();
|
||||
assert!(!none.usable());
|
||||
assert!(none.status_text().contains("未找到"));
|
||||
|
||||
let uin_only = QqCredentials {
|
||||
uin: Some("1".into()),
|
||||
authst: None,
|
||||
};
|
||||
assert!(!uin_only.usable());
|
||||
assert!(uin_only.status_text().contains("未运行"));
|
||||
|
||||
let full = QqCredentials {
|
||||
uin: Some("1".into()),
|
||||
authst: Some("t".into()),
|
||||
};
|
||||
assert!(full.usable());
|
||||
assert_eq!(full.status_text(), "已就绪");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,342 @@
|
||||
//! 通过 QQ 音乐官方接口取 ekey(`music.vkey.GetEVkey`)。
|
||||
//!
|
||||
//! ## 前置条件(必须让用户知道)
|
||||
//!
|
||||
//! 新版 musicex 文件**不包含 ekey**,只能拿本机已登录的凭据向 QQ 音乐服务器换取:
|
||||
//!
|
||||
//! 1. 本机装有 QQ 音乐客户端;
|
||||
//! 2. **QQ 音乐正在运行且已登录**(`authst` 只存在于运行期内存,见
|
||||
//! [`super::qq_credentials`]);
|
||||
//! 3. 文件本身的尾部要有 `media_mid` 与 `filename`(musicex 尾部提供)。
|
||||
//!
|
||||
//! ## 接口契约里三个"必须"
|
||||
//!
|
||||
//! 对照 `MUSIC_DECRYPT_PLAN.md` §3.2 与 qmc-decoder 的协议文档:
|
||||
//!
|
||||
//! - `param.filename` **必须带扩展名**(`.mgg` / `.mflac`),否则返回 `104005`;
|
||||
//! - `param.songtype` **必须为 `1`**(表示请求加密资源的 ekey;为 0 只回 vkey);
|
||||
//! - `module` 必须是 **`music.vkey.GetEVkey`**(不是 `GetVkey`,后者不返回 ekey)。
|
||||
//!
|
||||
//! 另外 `authst` 约 **22.3 小时**过期,失败文案要给出"重新登录 QQ 音乐"的出口。
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use super::common::DecryptError;
|
||||
use super::qq_footer::MusiCexTail;
|
||||
|
||||
/// 取 ekey 的接口地址
|
||||
pub const EVKEY_ENDPOINT: &str = "https://u.y.qq.com/cgi-bin/musicu.fcg";
|
||||
/// PC 端的 platform 标识(Windows)
|
||||
pub const PLATFORM_WINDOWS: &str = "27";
|
||||
|
||||
/// 组装 `GetEVkey` 请求体。
|
||||
///
|
||||
/// 抽成纯函数是为了能单测那三个"必须"——它们是这个接口最容易踩的坑。
|
||||
pub fn build_evkey_request(
|
||||
uin: &str,
|
||||
authst: &str,
|
||||
media_mid: &str,
|
||||
filename: &str,
|
||||
login_type: u32,
|
||||
) -> serde_json::Value {
|
||||
serde_json::json!({
|
||||
"comm": {
|
||||
"authst": authst,
|
||||
"ct": "19",
|
||||
"cv": "1859",
|
||||
"uin": uin,
|
||||
"tmeLoginType": login_type.to_string(),
|
||||
},
|
||||
"req_1": {
|
||||
"module": "music.vkey.GetEVkey",
|
||||
"method": "CgiGetEVkey",
|
||||
"param": {
|
||||
"filename": [filename],
|
||||
"guid": "10000",
|
||||
"songmid": [media_mid],
|
||||
"songtype": [1],
|
||||
"uin": uin,
|
||||
"loginflag": 1,
|
||||
"platform": PLATFORM_WINDOWS,
|
||||
"ctx": 1,
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// `GetEVkey` 的响应(只声明用得到的字段)
|
||||
#[derive(Debug, Clone, Deserialize)]
|
||||
pub struct EvkeyResponse {
|
||||
#[serde(default)]
|
||||
pub code: i64,
|
||||
#[serde(default)]
|
||||
pub req_1: Option<EvkeyReq1>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize)]
|
||||
pub struct EvkeyReq1 {
|
||||
#[serde(default)]
|
||||
pub code: i64,
|
||||
#[serde(default)]
|
||||
pub data: Option<EvkeyData>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize)]
|
||||
pub struct EvkeyData {
|
||||
#[serde(default)]
|
||||
pub midurlinfo: Vec<EvkeyItem>,
|
||||
/// ekey 有效期(秒),实测约 80400
|
||||
#[serde(default)]
|
||||
pub expiration: i64,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize)]
|
||||
pub struct EvkeyItem {
|
||||
#[serde(default)]
|
||||
pub ekey: String,
|
||||
#[serde(default)]
|
||||
pub result: i64,
|
||||
#[serde(default)]
|
||||
pub subcode: i64,
|
||||
}
|
||||
|
||||
/// 把响应解读为 `(ekey, 有效期秒数)` 或一个**可读的**失败原因。
|
||||
///
|
||||
/// 这里集中处理错误码,是为了让 UI 能给出下一步动作,而不是丢一个数字出去。
|
||||
/// 有效期一并返回:`authst` 过期是这条链路最常见的失败原因,把"还能用多久"
|
||||
/// 讲清楚比让用户猜要好。
|
||||
pub fn parse_evkey_response(resp: &EvkeyResponse) -> Result<(String, i64), DecryptError> {
|
||||
let req = resp
|
||||
.req_1
|
||||
.as_ref()
|
||||
.ok_or_else(|| DecryptError::KeyRequired("服务器响应缺少 req_1".into()))?;
|
||||
let data = req
|
||||
.data
|
||||
.as_ref()
|
||||
.ok_or_else(|| DecryptError::KeyRequired("服务器响应缺少 data".into()))?;
|
||||
|
||||
let item = data
|
||||
.midurlinfo
|
||||
.first()
|
||||
.ok_or_else(|| DecryptError::KeyRequired("服务器未返回任何资源信息".into()))?;
|
||||
|
||||
if item.ekey.is_empty() {
|
||||
let hint = match item.result {
|
||||
104005 => {
|
||||
"该资源的密钥需要 VIP 或当前账号无权访问(错误码 104005);也可能文件名缺少扩展名"
|
||||
}
|
||||
0 => "服务器返回了空 ekey,通常是登录态已过期——请在 QQ 音乐里重新登录后重试",
|
||||
_ => "服务器未返回 ekey",
|
||||
};
|
||||
return Err(DecryptError::KeyRequired(format!(
|
||||
"{hint}(result={}, subcode={}, code={}/{}/{})",
|
||||
item.result, item.subcode, resp.code, req.code, item.result
|
||||
)));
|
||||
}
|
||||
Ok((item.ekey.clone(), data.expiration))
|
||||
}
|
||||
|
||||
/// 从响应 JSON 文本解析出 ekey。
|
||||
///
|
||||
/// 生产路径走 [`fetch_ekey`](它需要有效期),这个薄封装主要给测试用,
|
||||
/// 也作为该接口对外的最小 API。
|
||||
#[cfg_attr(not(test), allow(dead_code))]
|
||||
pub fn extract_ekey(body: &str) -> Result<String, DecryptError> {
|
||||
let resp: EvkeyResponse = serde_json::from_str(body)
|
||||
.map_err(|e| DecryptError::KeyRequired(format!("解析服务器响应失败:{e}")))?;
|
||||
parse_evkey_response(&resp).map(|(ekey, _)| ekey)
|
||||
}
|
||||
|
||||
/// 在线取 ekey 的入参(把"要什么"与"怎么取"分开,便于测试与日志)
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub struct EvkeyRequest {
|
||||
pub uin: String,
|
||||
pub authst: String,
|
||||
pub media_mid: String,
|
||||
pub filename: String,
|
||||
pub login_type: u32,
|
||||
}
|
||||
|
||||
impl EvkeyRequest {
|
||||
/// 从 musicex 尾部 + 凭据构造
|
||||
pub fn from_tail(tail: &MusiCexTail, uin: &str, authst: &str) -> Result<Self, DecryptError> {
|
||||
if tail.media_mid.is_empty() {
|
||||
return Err(DecryptError::Broken(
|
||||
"musicex 尾部缺少 media_mid,无法向服务器索取密钥".into(),
|
||||
));
|
||||
}
|
||||
if tail.filename.is_empty() {
|
||||
return Err(DecryptError::Broken(
|
||||
"musicex 尾部缺少文件名,无法向服务器索取密钥".into(),
|
||||
));
|
||||
}
|
||||
// 接口要求 filename 必须带扩展名
|
||||
if !tail.filename.contains('.') {
|
||||
return Err(DecryptError::Broken(
|
||||
"musicex 尾部文件名没有扩展名,服务器会拒绝(104005)".into(),
|
||||
));
|
||||
}
|
||||
Ok(Self {
|
||||
uin: uin.to_string(),
|
||||
authst: authst.to_string(),
|
||||
media_mid: tail.media_mid.clone(),
|
||||
filename: tail.filename.clone(),
|
||||
// 默认按 QQ 登录;微信登录是 3,两者都能用 authst,不影响取 ekey
|
||||
login_type: 1,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn body(&self) -> serde_json::Value {
|
||||
build_evkey_request(
|
||||
&self.uin,
|
||||
&self.authst,
|
||||
&self.media_mid,
|
||||
&self.filename,
|
||||
self.login_type,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// 实际发请求(异步),返回 `(ekey, 有效期秒数)`。
|
||||
pub async fn fetch_ekey(
|
||||
client: &reqwest::Client,
|
||||
req: &EvkeyRequest,
|
||||
) -> Result<(String, i64), DecryptError> {
|
||||
let body = req.body();
|
||||
let resp = tokio::time::timeout(
|
||||
std::time::Duration::from_secs(20),
|
||||
client.post(EVKEY_ENDPOINT).json(&body).send(),
|
||||
)
|
||||
.await
|
||||
.map_err(|_| DecryptError::KeyRequired("请求 QQ 音乐服务器超时".into()))?
|
||||
.map_err(|e| DecryptError::KeyRequired(format!("请求 QQ 音乐服务器失败:{e}")))?;
|
||||
|
||||
let status = resp.status();
|
||||
let text = resp
|
||||
.text()
|
||||
.await
|
||||
.map_err(|e| DecryptError::KeyRequired(format!("读取服务器响应失败:{e}")))?;
|
||||
|
||||
if !status.is_success() {
|
||||
return Err(DecryptError::KeyRequired(format!(
|
||||
"QQ 音乐服务器返回 HTTP {status}:{}",
|
||||
text.chars().take(200).collect::<String>()
|
||||
)));
|
||||
}
|
||||
parse_evkey_response(
|
||||
&serde_json::from_str(&text)
|
||||
.map_err(|e| DecryptError::KeyRequired(format!("解析服务器响应失败:{e}")))?,
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn tail() -> MusiCexTail {
|
||||
MusiCexTail {
|
||||
song_id: 1,
|
||||
media_mid: "0012ABCDEF".into(),
|
||||
filename: "O4M00012ABCDEF.mgg".into(),
|
||||
footer_size: 192,
|
||||
version: 1,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
/// 接口契约的三个"必须"——写错了不会报错,只会静默拿不到 ekey
|
||||
#[test]
|
||||
fn request_body_satisfies_api_contract() {
|
||||
let req = EvkeyRequest::from_tail(&tail(), "1154027699", "TOKEN").unwrap();
|
||||
let body = req.body();
|
||||
|
||||
assert_eq!(body["req_1"]["module"], "music.vkey.GetEVkey");
|
||||
assert_eq!(body["req_1"]["method"], "CgiGetEVkey");
|
||||
|
||||
let param = &body["req_1"]["param"];
|
||||
// songtype 必须为 1(加密资源)
|
||||
assert_eq!(param["songtype"][0], 1);
|
||||
// filename 必须带扩展名
|
||||
assert_eq!(param["filename"][0], "O4M00012ABCDEF.mgg");
|
||||
assert!(param["filename"][0].as_str().unwrap().contains('.'));
|
||||
// songmid 来自 media_mid
|
||||
assert_eq!(param["songmid"][0], "0012ABCDEF");
|
||||
// platform = 27(Windows)
|
||||
assert_eq!(param["platform"], "27");
|
||||
|
||||
// comm 里要带 authst / uin
|
||||
assert_eq!(body["comm"]["authst"], "TOKEN");
|
||||
assert_eq!(body["comm"]["uin"], "1154027699");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn from_tail_rejects_incomplete_tail() {
|
||||
let mut t = tail();
|
||||
t.media_mid.clear();
|
||||
assert!(EvkeyRequest::from_tail(&t, "1", "T").is_err());
|
||||
|
||||
let mut t = tail();
|
||||
t.filename.clear();
|
||||
assert!(EvkeyRequest::from_tail(&t, "1", "T").is_err());
|
||||
|
||||
// 没有扩展名的文件名会被服务器拒绝,提前拦下
|
||||
let mut t = tail();
|
||||
t.filename = "O4M00012ABCDEF".into();
|
||||
let err = EvkeyRequest::from_tail(&t, "1", "T").unwrap_err();
|
||||
assert!(err.to_string().contains("扩展名"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_successful_response() {
|
||||
let body = r#"{
|
||||
"code": 0,
|
||||
"req_1": { "code": 0, "data": {
|
||||
"midurlinfo": [{ "ekey": "REAL_EKEY", "result": 0, "subcode": 0 }],
|
||||
"expiration": 80400
|
||||
}}
|
||||
}"#;
|
||||
assert_eq!(extract_ekey(body).unwrap(), "REAL_EKEY");
|
||||
}
|
||||
|
||||
/// 104005:要么需要 VIP,要么 filename 没带扩展名——文案必须点出这两条
|
||||
#[test]
|
||||
fn error_104005_is_actionable() {
|
||||
let body = r#"{
|
||||
"code": 0,
|
||||
"req_1": { "code": 0, "data": {
|
||||
"midurlinfo": [{ "ekey": "", "result": 104005, "subcode": 0 }]
|
||||
}}
|
||||
}"#;
|
||||
let err = extract_ekey(body).unwrap_err();
|
||||
let msg = err.to_string();
|
||||
assert!(msg.contains("104005"), "应带错误码:{msg}");
|
||||
assert!(msg.contains("VIP"), "应提示 VIP:{msg}");
|
||||
assert!(msg.contains("扩展名"), "应提示文件名要求:{msg}");
|
||||
}
|
||||
|
||||
/// result=0 但 ekey 为空 → 登录态过期
|
||||
#[test]
|
||||
fn empty_ekey_with_result_zero_suggests_relogin() {
|
||||
let body = r#"{
|
||||
"code": 0,
|
||||
"req_1": { "code": 0, "data": {
|
||||
"midurlinfo": [{ "ekey": "", "result": 0, "subcode": 0 }]
|
||||
}}
|
||||
}"#;
|
||||
let msg = extract_ekey(body).unwrap_err().to_string();
|
||||
assert!(msg.contains("重新登录"), "应提示重新登录:{msg}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_sections_are_reported() {
|
||||
assert!(extract_ekey(r#"{"code":0}"#).is_err());
|
||||
assert!(extract_ekey(r#"{"code":0,"req_1":{"code":0}}"#).is_err());
|
||||
assert!(extract_ekey(r#"{"code":0,"req_1":{"code":0,"data":{"midurlinfo":[]}}}"#).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn malformed_json_is_reported() {
|
||||
let err = extract_ekey("not json").unwrap_err();
|
||||
assert!(err.to_string().contains("解析"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,231 @@
|
||||
//! QQ音乐 **musicex** 尾部解析(QQ 客户端 ≥ 19.57 / Windows 22.x)。
|
||||
//!
|
||||
//! 新版客户端不再把 ekey 写进文件,只在末尾留 192 字节元数据,ekey 必须联网取。
|
||||
//! 这个模块只做**纯解析**(无 IO、无网络),因此可以完整单测。
|
||||
//!
|
||||
//! ## 尾部布局(对照 `MUSIC_DECRYPT_PLAN.md` §3.2 与 qmc-decoder 的格式文档)
|
||||
//!
|
||||
//! ```text
|
||||
//! +0x00 [4B] song_id uint32 LE
|
||||
//! +0x04 [4B] quality_type1 uint32 LE
|
||||
//! +0x08 [4B] quality_type2 uint32 LE
|
||||
//! +0x0C [60B] media_mid UTF-16LE(可能以 NUL 结尾)
|
||||
//! +0x48 [68B] filename UTF-16LE(含扩展名,如 O4M0xxxx.mgg)
|
||||
//! +0x8C [48B] padding
|
||||
//! +0xC0 [4B] footer_size uint32 LE(= 0xC0 = 192)
|
||||
//! +0xC4 [4B] version uint32 LE(= 1)
|
||||
//! +0xC8 [8B] magic "musicex\0"
|
||||
//! ```
|
||||
//!
|
||||
//! 因此**音频段 = 文件大小 − footer_size**,且 footer 一定在文件末尾。
|
||||
|
||||
/// musicex 尾部魔术(含结尾 NUL)
|
||||
pub const MUSICEX_MAGIC: &[u8; 8] = b"musicex\0";
|
||||
/// 尾部固定长度(也是 footer_size 字段的期望值)
|
||||
pub const MUSICEX_FOOTER_LEN: usize = 0xC0;
|
||||
|
||||
/// 解析出的 musicex 元数据
|
||||
#[derive(Debug, Clone, PartialEq, Eq, Default)]
|
||||
pub struct MusiCexTail {
|
||||
pub song_id: u32,
|
||||
pub quality_type1: u32,
|
||||
pub quality_type2: u32,
|
||||
/// 歌曲 mid(取 ekey 需要)
|
||||
pub media_mid: String,
|
||||
/// 资源文件名(**必须含扩展名**,否则 API 返回 104005)
|
||||
pub filename: String,
|
||||
/// 尾部声明的长度(正常为 192)
|
||||
pub footer_size: u32,
|
||||
pub version: u32,
|
||||
}
|
||||
|
||||
impl MusiCexTail {
|
||||
/// 音频段长度(文件总大小 − 尾部长度)
|
||||
pub fn audio_len(&self, file_size: u64) -> u64 {
|
||||
file_size.saturating_sub(self.footer_size as u64)
|
||||
}
|
||||
|
||||
/// 给 UI 的一行说明
|
||||
pub fn note(&self) -> String {
|
||||
if self.filename.is_empty() {
|
||||
format!("musicex(songId={})", self.song_id)
|
||||
} else {
|
||||
format!("musicex · {}", self.filename)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 判断一段**文件尾部字节**是否是 musicex 尾部。
|
||||
pub fn is_musicex_tail(buf: &[u8]) -> bool {
|
||||
buf.len() >= 8 && &buf[buf.len() - 8..] == MUSICEX_MAGIC
|
||||
}
|
||||
|
||||
/// 从文件末尾字节解析 musicex 尾部。
|
||||
///
|
||||
/// `buf` 必须至少包含整个尾部([`MUSICEX_FOOTER_LEN`] 字节),否则返回 `None`。
|
||||
pub fn parse_musicex_tail(buf: &[u8]) -> Option<MusiCexTail> {
|
||||
if !is_musicex_tail(buf) {
|
||||
return None;
|
||||
}
|
||||
let n = buf.len();
|
||||
let footer_size = le_u32(buf, n - 16)?;
|
||||
let version = le_u32(buf, n - 12)?;
|
||||
|
||||
// footer_size 是尾部总长;它必须落在缓冲区里才谈得上解析字段
|
||||
let footer_size_usize = footer_size as usize;
|
||||
if footer_size_usize < MUSICEX_FOOTER_LEN || footer_size_usize > n {
|
||||
return None;
|
||||
}
|
||||
let start = n - footer_size_usize;
|
||||
|
||||
Some(MusiCexTail {
|
||||
song_id: le_u32(buf, start)?,
|
||||
quality_type1: le_u32(buf, start + 4)?,
|
||||
quality_type2: le_u32(buf, start + 8)?,
|
||||
media_mid: utf16le_at(buf, start + 0x0C, 60)?,
|
||||
filename: utf16le_at(buf, start + 0x48, 68)?,
|
||||
footer_size,
|
||||
version,
|
||||
})
|
||||
}
|
||||
|
||||
fn le_u32(b: &[u8], at: usize) -> Option<u32> {
|
||||
let end = at.checked_add(4)?;
|
||||
let s = b.get(at..end)?;
|
||||
Some(u32::from_le_bytes([s[0], s[1], s[2], s[3]]))
|
||||
}
|
||||
|
||||
/// 读取定长 UTF-16LE 字段并去掉结尾的 NUL。
|
||||
///
|
||||
/// 字段是定长补齐的,未用部分为 0;也可能不补 NUL 而恰好占满,故两种都要容忍。
|
||||
fn utf16le_at(buf: &[u8], at: usize, byte_len: usize) -> Option<String> {
|
||||
let end = at.checked_add(byte_len)?;
|
||||
let s = buf.get(at..end)?;
|
||||
let mut units: Vec<u16> = s
|
||||
.chunks_exact(2)
|
||||
.map(|c| u16::from_le_bytes([c[0], c[1]]))
|
||||
.collect();
|
||||
while units.last() == Some(&0) {
|
||||
units.pop();
|
||||
}
|
||||
Some(String::from_utf16_lossy(&units))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// 构造一个合法的 musicex 尾部
|
||||
fn build_tail(song_id: u32, mid: &str, filename: &str) -> Vec<u8> {
|
||||
let mut tail = vec![0u8; MUSICEX_FOOTER_LEN];
|
||||
tail[0..4].copy_from_slice(&song_id.to_le_bytes());
|
||||
tail[4..8].copy_from_slice(&2u32.to_le_bytes());
|
||||
tail[8..12].copy_from_slice(&2u32.to_le_bytes());
|
||||
write_utf16(&mut tail[0x0C..0x0C + 60], mid);
|
||||
write_utf16(&mut tail[0x48..0x48 + 68], filename);
|
||||
let n = tail.len();
|
||||
tail[n - 16..n - 12].copy_from_slice(&(MUSICEX_FOOTER_LEN as u32).to_le_bytes());
|
||||
tail[n - 12..n - 8].copy_from_slice(&1u32.to_le_bytes());
|
||||
tail[n - 8..].copy_from_slice(MUSICEX_MAGIC);
|
||||
tail
|
||||
}
|
||||
|
||||
fn write_utf16(dst: &mut [u8], s: &str) {
|
||||
for (i, unit) in s.encode_utf16().enumerate() {
|
||||
let at = i * 2;
|
||||
if at + 2 > dst.len() {
|
||||
break;
|
||||
}
|
||||
dst[at..at + 2].copy_from_slice(&unit.to_le_bytes());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_valid_footer() {
|
||||
let tail = build_tail(0x0C27ABCD, "0012ABCDEF", "O4M00012ABCDEF.mgg");
|
||||
let parsed = parse_musicex_tail(&tail).expect("应解析成功");
|
||||
assert_eq!(parsed.song_id, 0x0C27ABCD);
|
||||
assert_eq!(parsed.quality_type1, 2);
|
||||
assert_eq!(parsed.quality_type2, 2);
|
||||
assert_eq!(parsed.media_mid, "0012ABCDEF");
|
||||
assert_eq!(parsed.filename, "O4M00012ABCDEF.mgg");
|
||||
assert_eq!(parsed.footer_size, 192);
|
||||
assert_eq!(parsed.version, 1);
|
||||
}
|
||||
|
||||
/// 尾部前面还有音频数据时,解析结果不受影响(按 footer_size 定位)
|
||||
#[test]
|
||||
fn parses_footer_with_audio_prefix() {
|
||||
let tail = build_tail(7, "mid123", "F00000mid123.mflac");
|
||||
let mut file = vec![0xAAu8; 5000];
|
||||
file.extend_from_slice(&tail);
|
||||
let parsed = parse_musicex_tail(&file).expect("应解析成功");
|
||||
assert_eq!(parsed.filename, "F00000mid123.mflac");
|
||||
assert_eq!(parsed.audio_len(file.len() as u64), 5000);
|
||||
}
|
||||
|
||||
/// 字段恰好占满、没有 NUL 终止符时也要能读全
|
||||
#[test]
|
||||
fn parses_full_width_field_without_nul() {
|
||||
let name = "A".repeat(34); // 68 字节 = 34 个 UTF-16 单元,正好占满
|
||||
let tail = build_tail(1, "M", &name);
|
||||
let parsed = parse_musicex_tail(&tail).expect("应解析成功");
|
||||
assert_eq!(parsed.filename, name);
|
||||
}
|
||||
|
||||
/// 中文文件名(UTF-16LE)要能正确还原
|
||||
#[test]
|
||||
fn parses_cjk_filename() {
|
||||
let tail = build_tail(1, "mid", "歌曲 名.mgg");
|
||||
let parsed = parse_musicex_tail(&tail).unwrap();
|
||||
assert_eq!(parsed.filename, "歌曲 名.mgg");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_non_musicex() {
|
||||
assert!(!is_musicex_tail(b"not a magic at all"));
|
||||
assert!(parse_musicex_tail(&[0u8; 192]).is_none());
|
||||
// 魔术对但长度不合理
|
||||
let mut bad = vec![0u8; 192];
|
||||
let n = bad.len();
|
||||
bad[n - 8..].copy_from_slice(MUSICEX_MAGIC);
|
||||
bad[n - 16..n - 12].copy_from_slice(&0xFFFFu32.to_le_bytes());
|
||||
assert!(parse_musicex_tail(&bad).is_none(), "footer_size 越界应拒绝");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_truncated_buffer() {
|
||||
// 只有 16 字节,放不下 192 字节的尾部结构
|
||||
let mut short = vec![0u8; 16];
|
||||
let n = short.len();
|
||||
short[n - 8..].copy_from_slice(MUSICEX_MAGIC);
|
||||
short[n - 16..n - 12].copy_from_slice(&192u32.to_le_bytes());
|
||||
assert!(parse_musicex_tail(&short).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn audio_len_saturates() {
|
||||
let t = MusiCexTail {
|
||||
footer_size: 192,
|
||||
..Default::default()
|
||||
};
|
||||
assert_eq!(t.audio_len(1000), 808);
|
||||
// 文件比尾部还小:不能下溢
|
||||
assert_eq!(t.audio_len(10), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn note_includes_filename_when_present() {
|
||||
let t = MusiCexTail {
|
||||
filename: "a.mgg".into(),
|
||||
song_id: 5,
|
||||
..Default::default()
|
||||
};
|
||||
assert!(t.note().contains("a.mgg"));
|
||||
let empty = MusiCexTail {
|
||||
song_id: 9,
|
||||
..Default::default()
|
||||
};
|
||||
assert!(empty.note().contains("9"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,216 @@
|
||||
//! `QQMusic.exe` 进程内存扫描(**只读**)。
|
||||
//!
|
||||
//! Windows 版 QQ 音乐把 `authst` 只放在运行期内存里,因此联网取 ekey 必须先把它捞出来。
|
||||
//! 这是纯 Win32 胶水层:真正的解析逻辑([`super::qq_credentials::find_authst`] /
|
||||
//! [`super::qq_credentials::parse_ini_uin`])是跨平台纯函数,已单独单测。
|
||||
//!
|
||||
//! ## 实现要点(踩过的坑)
|
||||
//!
|
||||
//! 1. **`MEMORY_BASIC_INFORMATION` 的 `PartitionId`**:Windows 10 1803+ 在
|
||||
//! `AllocationProtect` 与 `RegionSize` 之间插入了 2 字节。结构体里**必须**包含它,
|
||||
//! 否则 `RegionSize`/`State`/`Protect` 全部从错误偏移读取——症状是
|
||||
//! `VirtualQueryEx` 返回的 `State` 读成了 `Protect` 的值(如 `PAGE_READWRITE=0x04`
|
||||
//! 而不是 `MEM_COMMIT=0x1000`),于是**所有内存区域都被跳过**、永远扫不到。
|
||||
//! `windows-sys` 的定义已经包含该字段,这里直接用官方结构体。
|
||||
//! 2. **只扫 `MEM_COMMIT` 且可读的区域**,并跳过 `PAGE_GUARD` / `PAGE_NOACCESS`。
|
||||
//! 3. **分块读取**(1 MB),避免一次 `ReadProcessMemory` 大区域时中途失败整块丢。
|
||||
//! 4. 跨块保留 `AUTHST_KEY.len() - 1` 字节的重叠,防止 token 恰好横跨块边界。
|
||||
|
||||
use std::ffi::c_void;
|
||||
|
||||
use windows_sys::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE};
|
||||
use windows_sys::Win32::System::Diagnostics::Debug::ReadProcessMemory;
|
||||
use windows_sys::Win32::System::Diagnostics::ToolHelp::{
|
||||
CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, PROCESSENTRY32W, TH32CS_SNAPPROCESS,
|
||||
};
|
||||
use windows_sys::Win32::System::Memory::{
|
||||
VirtualQueryEx, MEMORY_BASIC_INFORMATION, MEM_COMMIT, PAGE_GUARD, PAGE_NOACCESS,
|
||||
};
|
||||
use windows_sys::Win32::System::Threading::{
|
||||
OpenProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ,
|
||||
};
|
||||
|
||||
use super::qq_credentials::{find_authst_from, QQ_PROCESS_HINT};
|
||||
|
||||
/// 单次读取的块大小
|
||||
const CHUNK: usize = 1024 * 1024;
|
||||
/// 跨块重叠长度(`"authst":"` 的长度 - 1,防止 token 横跨块边界)
|
||||
const OVERLAP: usize = 16;
|
||||
/// 扫描上限:避免异常进程占用过久(每个进程最多读这么多字节)
|
||||
const MAX_SCAN_BYTES: usize = 512 * 1024 * 1024;
|
||||
|
||||
/// 扫描结果
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct Found {
|
||||
pub authst: Option<String>,
|
||||
pub uin: Option<String>,
|
||||
}
|
||||
|
||||
/// 按进程名(大小写不敏感子串)找 PID
|
||||
pub fn find_process_pid(hint: &str) -> Option<u32> {
|
||||
unsafe {
|
||||
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
||||
if snapshot == INVALID_HANDLE_VALUE {
|
||||
return None;
|
||||
}
|
||||
let mut entry: PROCESSENTRY32W = std::mem::zeroed();
|
||||
entry.dwSize = std::mem::size_of::<PROCESSENTRY32W>() as u32;
|
||||
|
||||
// 提前小写化,避免在进程列表里反复分配(进程数可达数百)
|
||||
let needle = hint.to_lowercase();
|
||||
let mut pid: Option<u32> = None;
|
||||
if Process32FirstW(snapshot, &mut entry) != 0 {
|
||||
loop {
|
||||
let name_len = entry
|
||||
.szExeFile
|
||||
.iter()
|
||||
.position(|&c| c == 0)
|
||||
.unwrap_or(entry.szExeFile.len());
|
||||
let name = String::from_utf16_lossy(&entry.szExeFile[..name_len]);
|
||||
if name.to_lowercase().contains(&needle) {
|
||||
pid = Some(entry.th32ProcessID);
|
||||
break;
|
||||
}
|
||||
if Process32NextW(snapshot, &mut entry) == 0 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
CloseHandle(snapshot);
|
||||
pid
|
||||
}
|
||||
}
|
||||
|
||||
/// QQ 音乐是否在运行
|
||||
pub fn is_qqmusic_running() -> bool {
|
||||
find_process_pid(QQ_PROCESS_HINT).is_some()
|
||||
}
|
||||
|
||||
/// 扫描 QQ 音乐进程内存,捞出 `authst`(顺带尝试 `"uin":"..."`)。
|
||||
pub fn scan_qq_process() -> Result<Found, String> {
|
||||
let pid = find_process_pid(QQ_PROCESS_HINT).ok_or("未找到 QQMusic.exe 进程")?;
|
||||
|
||||
// windows-sys 0.52 的 HANDLE 是 isize(0 表示失败)
|
||||
let handle = unsafe { OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 0, pid) };
|
||||
if handle == 0 {
|
||||
return Err("无法打开 QQMusic.exe(权限不足;请尝试以管理员身份运行本应用)".to_string());
|
||||
}
|
||||
let result = unsafe { scan_handle(handle) };
|
||||
unsafe { CloseHandle(handle) };
|
||||
result
|
||||
}
|
||||
|
||||
unsafe fn scan_handle(handle: isize) -> Result<Found, String> {
|
||||
let mut found = Found::default();
|
||||
let mut address: usize = 0;
|
||||
let mut buf = vec![0u8; CHUNK];
|
||||
let mut scanned: usize = 0;
|
||||
|
||||
while address < usize::MAX {
|
||||
let mut mbi: MEMORY_BASIC_INFORMATION = std::mem::zeroed();
|
||||
let written = VirtualQueryEx(
|
||||
handle,
|
||||
address as *const c_void,
|
||||
&mut mbi,
|
||||
std::mem::size_of::<MEMORY_BASIC_INFORMATION>(),
|
||||
);
|
||||
if written == 0 {
|
||||
break;
|
||||
}
|
||||
|
||||
let region_size = mbi.RegionSize;
|
||||
let base = mbi.BaseAddress as usize;
|
||||
|
||||
// 只读「已提交、且不是 guard/noaccess」的区域
|
||||
let readable = mbi.State == MEM_COMMIT
|
||||
&& (mbi.Protect & PAGE_GUARD) == 0
|
||||
&& (mbi.Protect & PAGE_NOACCESS) == 0
|
||||
&& mbi.Protect != 0;
|
||||
|
||||
if readable && region_size > 0 {
|
||||
let mut offset = 0usize;
|
||||
while offset < region_size && scanned < MAX_SCAN_BYTES {
|
||||
let want = CHUNK.min(region_size - offset);
|
||||
// 末尾留出重叠,保证 token 不因分块被截断
|
||||
let read_len = want.min(buf.len());
|
||||
let mut got = 0usize;
|
||||
let ok = ReadProcessMemory(
|
||||
handle,
|
||||
(base + offset) as *const c_void,
|
||||
buf.as_mut_ptr() as *mut c_void,
|
||||
read_len,
|
||||
&mut got,
|
||||
);
|
||||
if ok != 0 && got > 0 {
|
||||
scanned += got;
|
||||
let slice = &buf[..got];
|
||||
if found.authst.is_none() {
|
||||
if let Some(t) = find_authst_from(slice, 0) {
|
||||
found.authst = Some(t);
|
||||
}
|
||||
}
|
||||
if found.uin.is_none() {
|
||||
found.uin = find_json_string(slice, b"\"uin\":\"");
|
||||
}
|
||||
if found.authst.is_some() && found.uin.is_some() {
|
||||
return Ok(found);
|
||||
}
|
||||
}
|
||||
// 前进:整块减去重叠,避免漏掉跨块的匹配
|
||||
if want <= OVERLAP {
|
||||
break;
|
||||
}
|
||||
offset += want - OVERLAP;
|
||||
}
|
||||
}
|
||||
|
||||
// 前进到下一个区域;RegionSize 为 0 时强制前进,防止死循环
|
||||
let step = if region_size == 0 {
|
||||
0x1000
|
||||
} else {
|
||||
region_size
|
||||
};
|
||||
match address.checked_add(step) {
|
||||
Some(next) if next > address => address = next,
|
||||
_ => break,
|
||||
}
|
||||
}
|
||||
|
||||
Ok(found)
|
||||
}
|
||||
|
||||
/// 在字节里找 `"<key>":"<value>"` 形态的字符串值(用于 uin)
|
||||
unsafe fn find_json_string(haystack: &[u8], key: &[u8]) -> Option<String> {
|
||||
let mut pos = 0usize;
|
||||
while pos + key.len() <= haystack.len() {
|
||||
let rel = haystack[pos..].windows(key.len()).position(|w| w == key)?;
|
||||
let start = pos + rel + key.len();
|
||||
let end = haystack[start..].iter().position(|&b| b == b'"')?;
|
||||
let val = &haystack[start..start + end];
|
||||
if !val.is_empty() && val.iter().all(|b| b.is_ascii_digit()) {
|
||||
return Some(String::from_utf8_lossy(val).to_string());
|
||||
}
|
||||
pos = start;
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// 「QQ 在不在运行」必须能在本机跑通且不 panic
|
||||
/// (本机装了 QQ 音乐,结果可能是 true 或 false,取决于是否启动)
|
||||
#[test]
|
||||
fn process_detection_does_not_panic() {
|
||||
let running = is_qqmusic_running();
|
||||
// 只要求"不 panic 且能给出结论";不假设本机是否开着 QQ 音乐
|
||||
eprintln!("QQMusic running = {running}");
|
||||
}
|
||||
|
||||
/// 不存在的进程名必须返回 None,而不是卡住或 panic
|
||||
#[test]
|
||||
fn unknown_process_returns_none() {
|
||||
assert!(find_process_pid("definitely-not-a-real-process-xyzzy").is_none());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,361 @@
|
||||
//! QQ音乐解密的**编排层**:把「尾部形态 → 密钥来源 → 流密码」串起来。
|
||||
//!
|
||||
//! 密钥来源按 `MUSIC_DECRYPT_PLAN.md` §3.2 分层:
|
||||
//!
|
||||
//! | 尾部 | 密钥来源 | 需要联网 |
|
||||
//! |---|---|---|
|
||||
//! | QMC1 | 内置静态表 | 否 |
|
||||
//! | QTag / V1 | 尾部内嵌 ekey | 否 |
|
||||
//! | musicex | **本机已登录凭据 → `GetEVkey`** | 是 |
|
||||
//!
|
||||
//! 之所以单开一个模块而不是塞进 `qmc.rs`:联网那一路牵涉 HTTP 客户端、
|
||||
//! 凭据与工作线程里的运行时,与纯算法拆开后 `qmc.rs` 可以保持零 IO 依赖。
|
||||
|
||||
use std::path::Path;
|
||||
|
||||
use super::common::{self, DecryptError};
|
||||
use super::qmc;
|
||||
use super::qq_credentials;
|
||||
use super::qq_ekey::{self, EvkeyRequest};
|
||||
use super::qq_footer::{self, MusiCexTail};
|
||||
|
||||
/// 在线能力状态(给 UI 状态卡用)
|
||||
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct QqOnlineStatus {
|
||||
/// QQMusic.exe 是否在运行
|
||||
pub running: bool,
|
||||
/// 是否取到了 authst(= 已登录且能读到内存)
|
||||
pub logged_in: bool,
|
||||
/// 本机读到的 QQ 号(仅用于展示;没有则为 None)
|
||||
pub uin: Option<String>,
|
||||
/// 是否具备在线取 ekey 的能力
|
||||
pub ready: bool,
|
||||
/// 给用户的一句话状态
|
||||
pub message: String,
|
||||
/// 需要用户照做的步骤(ready 时为一条"无需额外设置")
|
||||
pub steps: Vec<String>,
|
||||
}
|
||||
|
||||
/// 探测在线能力(**只读**:读 INI + 扫进程内存,不发网络请求)
|
||||
pub fn probe_status() -> QqOnlineStatus {
|
||||
let running = qq_memscan_running();
|
||||
let creds = qq_credentials::read_credentials();
|
||||
let ready = creds.usable();
|
||||
|
||||
let message = if ready {
|
||||
"已就绪:可直接解密 QQ 音乐新版 musicex 文件".to_string()
|
||||
} else if !running {
|
||||
"QQ 音乐未运行——新版 musicex 文件的密钥只在登录后存在于内存中".to_string()
|
||||
} else if creds.uin.is_none() {
|
||||
"QQ 音乐在运行,但没读到本机账号(可能尚未登录)".to_string()
|
||||
} else {
|
||||
"QQ 音乐在运行,但未取到登录令牌(authst),请确认已登录".to_string()
|
||||
};
|
||||
|
||||
let steps = if ready {
|
||||
vec!["无需额外设置;QMC1 与尾部内嵌 ekey 的文件本来就不需要登录。".to_string()]
|
||||
} else {
|
||||
vec![
|
||||
"1. 在电脑上启动 QQ 音乐客户端(Windows 版)。".to_string(),
|
||||
"2. 用它登录你的账号(扫码或账号密码均可),并保持客户端开着。".to_string(),
|
||||
"3. 回到本页点「重新检测」;状态变为「已就绪」后即可解密 musicex 文件。".to_string(),
|
||||
"4. 若显示未取到登录令牌:先播放任意一首歌触发一次网络请求,再重新检测。".to_string(),
|
||||
"5. 若仍失败,试过以管理员身份运行本应用(读取进程内存可能受权限限制)。".to_string(),
|
||||
"6. 登录令牌约 22.3 小时过期;过期后重新检测即可。".to_string(),
|
||||
]
|
||||
};
|
||||
|
||||
QqOnlineStatus {
|
||||
running,
|
||||
logged_in: creds.authst.is_some(),
|
||||
uin: creds.uin.clone(),
|
||||
ready,
|
||||
message,
|
||||
steps,
|
||||
}
|
||||
}
|
||||
|
||||
fn qq_memscan_running() -> bool {
|
||||
#[cfg(windows)]
|
||||
{
|
||||
super::qq_memscan::is_qqmusic_running()
|
||||
}
|
||||
#[cfg(not(windows))]
|
||||
{
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
/// musicex 的联网取密钥 + 解密。
|
||||
///
|
||||
/// `client` 用于发请求;调用方负责给它一个带超时的实例。整个流程会在
|
||||
/// 当前线程上建一个最小 tokio 运行时来 `block_on`——调度层本来就是
|
||||
/// 独立工作线程,不占 tokio 的工作线程。
|
||||
pub fn decrypt_musicex<F>(
|
||||
input: &Path,
|
||||
out_dir: &Path,
|
||||
platform_label: &str,
|
||||
mut progress: F,
|
||||
) -> Result<common::Outcome, DecryptError>
|
||||
where
|
||||
F: FnMut(u64, u64),
|
||||
{
|
||||
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
|
||||
if total < qq_footer::MUSICEX_FOOTER_LEN as u64 {
|
||||
return Err(DecryptError::Broken("文件太小,不可能是 musicex".into()));
|
||||
}
|
||||
|
||||
// 1) 解析尾部
|
||||
let tail = read_musicex_tail(input)?;
|
||||
let audio_len = tail.audio_len(total);
|
||||
|
||||
// 2) 取凭据
|
||||
let creds = qq_credentials::read_credentials();
|
||||
let (uin, authst) = match (creds.uin.as_deref(), creds.authst.as_deref()) {
|
||||
(Some(u), Some(a)) => (u, a),
|
||||
_ => {
|
||||
return Err(DecryptError::KeyRequired(format!(
|
||||
"{}。请在电脑上启动并登录 QQ 音乐客户端后重试,或在「解密」页点「重新检测」查看当前状态。",
|
||||
creds.status_text()
|
||||
)))
|
||||
}
|
||||
};
|
||||
|
||||
// 3) 请求 ekey
|
||||
let req = EvkeyRequest::from_tail(&tail, uin, authst)?;
|
||||
let client = reqwest::Client::builder()
|
||||
.timeout(std::time::Duration::from_secs(25))
|
||||
.build()
|
||||
.map_err(|e| DecryptError::KeyRequired(format!("构建 HTTP 客户端失败:{e}")))?;
|
||||
let (ekey, expiration) = block_on(fetch_ekey_async(&client, &req))?;
|
||||
|
||||
// 4) ekey → 原始密钥
|
||||
let raw = qmc::parse_ekey(&ekey)?;
|
||||
if raw.len() < 16 || raw.len() > 4096 {
|
||||
return Err(DecryptError::KeyRequired(format!(
|
||||
"服务器返回的密钥长度异常({} 字节),已放弃以免解出噪声",
|
||||
raw.len()
|
||||
)));
|
||||
}
|
||||
|
||||
// 5) 解密音频段
|
||||
let audio = read_audio_segment(input, audio_len)?;
|
||||
|
||||
// 用**解密结果**判定密钥是否正确,而不是猜密文头。
|
||||
//
|
||||
// 曾经的写法是"密文必须以 `#!Qk` 开头,否则拒绝"——**这个假设是错的**:
|
||||
// 真机样本(Avicii - Heaven,musicex)的密文头是 `51 74 03 75`,
|
||||
// 按那条守卫会把完全合法的文件误拒。QMC2 密文头没有稳定魔术,
|
||||
// 而"用取到的密钥解出的前 16 字节是不是已知音频魔术"才可靠:
|
||||
// 密钥错时它是随机噪声,几乎不可能凑成 `fLaC` / `OggS` / `ID3` / `ftyp`。
|
||||
let mut plaintext = audio;
|
||||
qmc::decrypt_with_raw_key(&raw, &mut plaintext);
|
||||
let Some(format) = super::common::detect_format_opt(&plaintext) else {
|
||||
return Err(DecryptError::KeyRequired(format!(
|
||||
"取到的密钥没能解出可识别的音频头(前 16 字节 {:02x?})——可能是该资源的 ekey \
|
||||
与文件不匹配,或登录态已过期;请重新检测后重试",
|
||||
&plaintext[..16.min(plaintext.len())]
|
||||
)));
|
||||
};
|
||||
|
||||
let decrypted = plaintext;
|
||||
let stem = input
|
||||
.file_stem()
|
||||
.map(|s| s.to_string_lossy().to_string())
|
||||
.unwrap_or_else(|| "output".to_string());
|
||||
std::fs::create_dir_all(out_dir)?;
|
||||
let mut reserved = std::collections::HashSet::new();
|
||||
let target = super::common::unique_output(out_dir, &stem, format, &mut reserved)?;
|
||||
std::fs::write(&target, &decrypted)?;
|
||||
progress(decrypted.len() as u64, decrypted.len() as u64);
|
||||
|
||||
Ok(common::Outcome {
|
||||
output: target,
|
||||
format: format.to_string(),
|
||||
cover: None,
|
||||
audio_bytes: decrypted.len() as u64,
|
||||
note: format!(
|
||||
"{platform_label} · {} · 在线取密钥解密(密钥有效期约 {} 小时)",
|
||||
tail.note(),
|
||||
// expiration 单位为秒(实测约 80400 ≈ 22.3 小时)
|
||||
if expiration > 0 {
|
||||
format!("{:.1}", expiration as f64 / 3600.0)
|
||||
} else {
|
||||
"未知".to_string()
|
||||
}
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
/// 读文件末尾的 musicex 尾部
|
||||
fn read_musicex_tail(input: &Path) -> Result<MusiCexTail, DecryptError> {
|
||||
use std::io::{Read, Seek, SeekFrom};
|
||||
let mut f = std::fs::File::open(input)?;
|
||||
let size = f.metadata()?.len();
|
||||
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
|
||||
f.seek(SeekFrom::End(-(take as i64)))?;
|
||||
let mut buf = vec![0u8; take];
|
||||
f.read_exact(&mut buf)?;
|
||||
// 注意:这里只读了尾部 192 字节,而 footer_size 可能 > 192(版本变化)——
|
||||
// 那就退化成"按已知长度解析",字段偏移仍以文件末尾为基准。
|
||||
qq_footer::parse_musicex_tail(&buf)
|
||||
.ok_or_else(|| DecryptError::Broken("musicex 尾部解析失败(魔术或长度字段异常)".into()))
|
||||
}
|
||||
|
||||
/// 只读音频段(musicex 场景下文件不大,但依然按大小一次读入以便就地解密)
|
||||
fn read_audio_segment(input: &Path, audio_len: u64) -> Result<Vec<u8>, DecryptError> {
|
||||
use std::io::Read;
|
||||
let mut f = std::fs::File::open(input)?;
|
||||
let mut buf = vec![0u8; audio_len as usize];
|
||||
f.read_exact(&mut buf)?;
|
||||
Ok(buf)
|
||||
}
|
||||
|
||||
/// 在**当前线程**上跑一个最小 tokio 运行时。
|
||||
///
|
||||
/// 调度层用独立 `std::thread` 干活,所以这里 `block_on` 是安全的
|
||||
/// (不会在 tokio 的 worker 线程里嵌套)。
|
||||
fn block_on<F: std::future::Future>(fut: F) -> F::Output {
|
||||
match tokio::runtime::Builder::new_current_thread()
|
||||
.enable_all()
|
||||
.build()
|
||||
{
|
||||
Ok(rt) => rt.block_on(fut),
|
||||
Err(_) => {
|
||||
// 极端情况下退化为全局运行时(项目里已有 rt-multi-thread)
|
||||
tauri::async_runtime::block_on(fut)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn fetch_ekey_async(
|
||||
client: &reqwest::Client,
|
||||
req: &EvkeyRequest,
|
||||
) -> Result<(String, i64), DecryptError> {
|
||||
qq_ekey::fetch_ekey(client, req).await
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// 状态探测必须能跑通且文案自洽(不假设本机 QQ 是否开着)
|
||||
#[test]
|
||||
fn probe_status_is_self_consistent() {
|
||||
let s = probe_status();
|
||||
assert_eq!(s.ready, s.running && s.logged_in);
|
||||
assert!(!s.message.is_empty());
|
||||
assert!(!s.steps.is_empty());
|
||||
if s.ready {
|
||||
assert!(s.steps.len() == 1, "就绪时只应给一条说明");
|
||||
} else {
|
||||
assert!(s.steps.len() >= 3, "未就绪时步骤要能照做");
|
||||
}
|
||||
}
|
||||
|
||||
/// 把本机真实探测结果打出来,便于人工核对「在线能力」是否按预期工作。
|
||||
/// 不加断言(依赖本机是否开着 QQ 音乐),只在 `--nocapture` 时可见。
|
||||
#[test]
|
||||
fn probe_status_reports_machine_state() {
|
||||
let s = probe_status();
|
||||
eprintln!(
|
||||
"[qq-online] running={} logged_in={} uin={:?} ready={}\n message: {}\n steps: {}",
|
||||
s.running,
|
||||
s.logged_in,
|
||||
s.uin,
|
||||
s.ready,
|
||||
s.message,
|
||||
s.steps.len()
|
||||
);
|
||||
}
|
||||
|
||||
/// musicex 文件必须被**离线路径**判为「需要密钥」,并且在有凭据时被识别为
|
||||
/// 「该走在线路径」。
|
||||
///
|
||||
/// 刻意**不**真的发网络请求:单元测试不该依赖 QQ 服务器可达性与账号状态,
|
||||
/// 否则本机登录后测试就会变慢、变脆。
|
||||
#[test]
|
||||
fn musicex_routes_to_online_path() {
|
||||
let dir = std::env::temp_dir().join(format!("qq_online_{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
|
||||
// 造一个 musicex 文件:尾部合法(含 media_mid / filename)。
|
||||
// 音频段的内容无所谓——这条只验证"路由与入参构造",不发网络请求。
|
||||
let mut file = vec![0u8; 4096];
|
||||
let n = file.len();
|
||||
let tail_start = n - qq_footer::MUSICEX_FOOTER_LEN;
|
||||
write_utf16(
|
||||
&mut file[tail_start + 0x0C..tail_start + 0x0C + 60],
|
||||
"0012ABCDEF",
|
||||
);
|
||||
write_utf16(
|
||||
&mut file[tail_start + 0x48..tail_start + 0x48 + 68],
|
||||
"O4M00012ABCDEF.mgg",
|
||||
);
|
||||
file[n - 16..n - 12].copy_from_slice(&(qq_footer::MUSICEX_FOOTER_LEN as u32).to_le_bytes());
|
||||
file[n - 12..n - 8].copy_from_slice(&1u32.to_le_bytes());
|
||||
file[n - 8..].copy_from_slice(qq_footer::MUSICEX_MAGIC);
|
||||
let src = dir.join("a.mgg");
|
||||
std::fs::write(&src, &file).unwrap();
|
||||
|
||||
// 1) 尾部能被解析出取密钥所需的两个字段
|
||||
let tail = read_musicex_tail(&src).expect("尾部应解析成功");
|
||||
assert_eq!(tail.media_mid, "0012ABCDEF");
|
||||
assert_eq!(tail.filename, "O4M00012ABCDEF.mgg");
|
||||
assert_eq!(tail.audio_len(file.len() as u64), (tail_start) as u64);
|
||||
|
||||
// 2) 离线路径必须明确报「需要密钥」,而不是解出噪声
|
||||
let offline = super::super::qmc::sniff_tail(&src).unwrap();
|
||||
assert_eq!(offline.kind, super::super::qmc::TailKind::MusiCex);
|
||||
|
||||
// 3) 请求能从尾部正确构造(这正是联网那一步的入参)
|
||||
let req = EvkeyRequest::from_tail(&tail, "1154027699", "TOKEN").unwrap();
|
||||
assert_eq!(req.media_mid, "0012ABCDEF");
|
||||
assert_eq!(req.filename, "O4M00012ABCDEF.mgg");
|
||||
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// 密钥错误时不应产出"看起来成功"的垃圾:
|
||||
/// 判据是**解密结果**能否识别成已知音频魔术。
|
||||
///
|
||||
/// 这条同时固化一个真机结论:QMC2 的**密文头没有稳定魔术**
|
||||
/// (真机 musicex 样本头为 `51 74 03 75`,而 MIT/Apache 文档里提到的
|
||||
/// `#!Qk` 并不适用于它),所以**不能**用密文头做守卫。
|
||||
#[test]
|
||||
fn wrong_key_yields_unrecognizable_header() {
|
||||
// 用一段随机数据当"密文",配一个随便的密钥
|
||||
let mut data = vec![0x51u8, 0x74, 0x03, 0x75];
|
||||
data.extend((0..4092).map(|i| (i * 7 % 251) as u8));
|
||||
let key: Vec<u8> = (0..64).map(|i| (i * 3 + 1) as u8).collect();
|
||||
|
||||
super::super::qmc::decrypt_with_raw_key(&key, &mut data);
|
||||
// 解出来必须是"认不出",才会走到 KeyRequired 那条错误分支
|
||||
assert!(
|
||||
super::super::common::detect_format_opt(&data).is_none(),
|
||||
"随机数据不应被识别成音频"
|
||||
);
|
||||
}
|
||||
|
||||
/// `#!Qk` 是 QMC2 的一种形态,但**不是** musicex 的头部——这里留一条记录性断言,
|
||||
/// 防止后人再次把它当成通用守卫。
|
||||
#[test]
|
||||
fn qmc2_ciphertext_header_is_not_a_reliable_magic() {
|
||||
assert_ne!(b"#!Qk", &[0x51u8, 0x74, 0x03, 0x75]);
|
||||
// 真机样本的头就是后者;`detect_format_opt` 对两者都不应误判成音频
|
||||
assert!(super::super::common::detect_format_opt(b"#!Qk\x00\x00\x00\x00").is_none());
|
||||
}
|
||||
|
||||
/// 把一个定长 UTF-16LE 字段写进缓冲区(测试辅助)
|
||||
fn write_utf16(dst: &mut [u8], s: &str) {
|
||||
for (i, unit) in s.encode_utf16().enumerate() {
|
||||
let at = i * 2;
|
||||
if at + 2 > dst.len() {
|
||||
break;
|
||||
}
|
||||
dst[at..at + 2].copy_from_slice(&unit.to_le_bytes());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,249 @@
|
||||
//! 文件夹批量:递归扫描 + 平台路由。
|
||||
//!
|
||||
//! 用户要的是「以文件夹为单位处理」,所以这里的判定原则是:
|
||||
//!
|
||||
//! 1. **内容优先于后缀**。同一个曲库里 `.ncm` / `.mflac` / `.qmcflac` / `.mgg` 混放是常态,
|
||||
//! 而后者还有 `.mgg0`、`.mflac0` 这类后缀变体;靠后缀枚举会漏。
|
||||
//! 因此先看头部魔数(网易云 `CTENFDAM`),再看尾部形态(QMC 家族)。
|
||||
//! 2. **只扫一次、只走一层递归**。目录树遍历用 `walkdir`,过滤在遍历中完成,
|
||||
//! 不把整个目录列表灌进内存(几万首的曲库会很难看)。
|
||||
//! 3. 扫描结果按**路径排序**,保证同一目录每次处理的顺序稳定(进度条与任务表可预期)。
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use walkdir::WalkDir;
|
||||
|
||||
use super::{ncm, qmc};
|
||||
|
||||
/// 一个待处理的文件
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ScannedFile {
|
||||
/// 绝对路径
|
||||
pub path: PathBuf,
|
||||
/// 相对扫描根的父目录(用于在输出目录里还原目录结构);根目录下的文件为 None
|
||||
pub rel_parent: Option<PathBuf>,
|
||||
/// 文件名(含后缀),给 UI 显示
|
||||
pub name: String,
|
||||
/// 该用哪个引擎
|
||||
pub engine: Engine,
|
||||
}
|
||||
|
||||
/// 引擎路由结果
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Engine {
|
||||
/// 网易云 ncm
|
||||
Ncm,
|
||||
/// QQ音乐 QMC 家族
|
||||
Qmc,
|
||||
}
|
||||
|
||||
impl Engine {
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
Engine::Ncm => "网易云",
|
||||
Engine::Qmc => "QQ音乐",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 单文件路由:读 8 字节魔数 + 4KB 尾部即可判定,不做全文件读。
|
||||
///
|
||||
/// 返回 `None` 表示这个文件不是我们认得的加密音乐(目录扫描时直接跳过,
|
||||
/// 用户显式选中的文件则会得到一条 `unsupported` 结果)。
|
||||
pub fn route(path: &Path) -> Option<Engine> {
|
||||
if ncm::sniff(path) {
|
||||
return Some(Engine::Ncm);
|
||||
}
|
||||
// QMC:尾部能判出形态就算认得
|
||||
if qmc::sniff_tail(path).is_ok() {
|
||||
// 后缀也在 QMC 家族里、或尾部形态明确(非纯 QMC1 兜底)时才算
|
||||
let ext = path
|
||||
.extension()
|
||||
.map(|e| e.to_string_lossy().to_string())
|
||||
.unwrap_or_default();
|
||||
if qmc::is_qmc_extension(&ext) {
|
||||
return Some(Engine::Qmc);
|
||||
}
|
||||
// 后缀不认识时,只有明确的尾部形态(QTag/V1/musicex)才认;
|
||||
// 否则任何末尾凑巧不是 QTag 的文件都会被判成"QMC1",噪声太大。
|
||||
if let Ok(tail) = qmc::sniff_tail(path) {
|
||||
if tail.kind != qmc::TailKind::Qmc1 {
|
||||
return Some(Engine::Qmc);
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// 递归扫描 `folder`,返回所有可解密的加密音乐文件。
|
||||
///
|
||||
/// `root` 用于计算相对路径(输出时还原目录结构)。`folder == root` 时即
|
||||
/// 「以这个文件夹为单位处理」。传 `root = None` 则所有文件平铺。
|
||||
///
|
||||
/// 排序保证稳定;`max_depth` 为 `None` 时递归全部层级。
|
||||
pub fn scan(folder: &Path, root: Option<&Path>) -> Result<Vec<ScannedFile>, String> {
|
||||
if !folder.is_dir() {
|
||||
return Err(format!("{} 不是文件夹", folder.display()));
|
||||
}
|
||||
let root = root.unwrap_or(folder);
|
||||
|
||||
let mut out = Vec::new();
|
||||
for entry in WalkDir::new(folder)
|
||||
.follow_links(false)
|
||||
.into_iter()
|
||||
.filter_map(|e| e.ok())
|
||||
{
|
||||
if !entry.file_type().is_file() {
|
||||
continue;
|
||||
}
|
||||
let path = entry.path();
|
||||
let Some(engine) = route(path) else {
|
||||
continue;
|
||||
};
|
||||
let rel_parent = path
|
||||
.parent()
|
||||
.and_then(|p| p.strip_prefix(root).ok())
|
||||
.filter(|p| !p.as_os_str().is_empty())
|
||||
.map(|p| p.to_path_buf());
|
||||
let name = path
|
||||
.file_name()
|
||||
.map(|n| n.to_string_lossy().to_string())
|
||||
.unwrap_or_else(|| path.display().to_string());
|
||||
out.push(ScannedFile {
|
||||
path: path.to_path_buf(),
|
||||
rel_parent,
|
||||
name,
|
||||
engine,
|
||||
});
|
||||
}
|
||||
|
||||
// 稳定排序:按相对目录 + 文件名,处理顺序可预期
|
||||
out.sort_by(|a, b| {
|
||||
a.rel_parent
|
||||
.cmp(&b.rel_parent)
|
||||
.then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
|
||||
});
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::fs;
|
||||
|
||||
fn tmpdir(tag: &str) -> PathBuf {
|
||||
let d = std::env::temp_dir().join(format!("dec_scan_{tag}_{}", std::process::id()));
|
||||
let _ = fs::remove_dir_all(&d);
|
||||
fs::create_dir_all(&d).unwrap();
|
||||
d
|
||||
}
|
||||
|
||||
/// 构造一个最小合法 ncm 头(只需魔数即可被 route 认出来)
|
||||
fn fake_ncm() -> Vec<u8> {
|
||||
let mut v = b"CTENFDAM".to_vec();
|
||||
v.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
|
||||
v
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn route_detects_ncm_by_magic_not_extension() {
|
||||
let dir = tmpdir("route");
|
||||
// 后缀故意起错,内容是对的 → 应按内容识别
|
||||
let p = dir.join("mystery.bin");
|
||||
fs::write(&p, fake_ncm()).unwrap();
|
||||
assert_eq!(route(&p), Some(Engine::Ncm));
|
||||
|
||||
// 后缀像 ncm 但内容不对 → 不应识别(尾部判成 QMC1 但后缀不在家族里)
|
||||
let q = dir.join("wrong.ncm");
|
||||
fs::write(&q, vec![0x11u8; 1024]).unwrap();
|
||||
assert_eq!(route(&q), None);
|
||||
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// QMC1 靠后缀识别(尾部形态是兜底,不做主判据)
|
||||
#[test]
|
||||
fn route_detects_qmc_by_extension() {
|
||||
let dir = tmpdir("qmc");
|
||||
let p = dir.join("a.qmcflac");
|
||||
fs::write(&p, vec![0x22u8; 4096]).unwrap();
|
||||
assert_eq!(route(&p), Some(Engine::Qmc));
|
||||
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scan_is_recursive_and_preserves_relative_dirs() {
|
||||
let dir = tmpdir("scan");
|
||||
fs::create_dir_all(dir.join("Pop").join("2026")).unwrap();
|
||||
fs::create_dir_all(dir.join("Rock")).unwrap();
|
||||
|
||||
fs::write(dir.join("root.ncm"), fake_ncm()).unwrap();
|
||||
fs::write(dir.join("Pop").join("a.qmcflac"), vec![0x22u8; 512]).unwrap();
|
||||
fs::write(dir.join("Pop").join("2026").join("b.ncm"), fake_ncm()).unwrap();
|
||||
fs::write(dir.join("Rock").join("c.txt"), b"not audio").unwrap();
|
||||
|
||||
let files = scan(&dir, Some(&dir)).unwrap();
|
||||
assert_eq!(files.len(), 3, "应找到 3 个加密文件(txt 被跳过)");
|
||||
|
||||
// 排序稳定:先根目录,再 Pop,再 Pop/2026
|
||||
assert_eq!(files[0].name, "root.ncm");
|
||||
assert!(
|
||||
files[0].rel_parent.is_none(),
|
||||
"根目录文件 rel_parent 应为 None"
|
||||
);
|
||||
|
||||
let a = files.iter().find(|f| f.name == "a.qmcflac").unwrap();
|
||||
assert_eq!(a.rel_parent.as_deref(), Some(Path::new("Pop")));
|
||||
assert_eq!(a.engine, Engine::Qmc);
|
||||
|
||||
let b = files.iter().find(|f| f.name == "b.ncm").unwrap();
|
||||
assert_eq!(
|
||||
b.rel_parent.as_deref(),
|
||||
Some(Path::new("Pop").join("2026").as_path())
|
||||
);
|
||||
assert_eq!(b.engine, Engine::Ncm);
|
||||
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// 以子目录为根时,相对路径相对**子目录**而不是父目录
|
||||
#[test]
|
||||
fn scan_uses_given_root_for_relative_paths() {
|
||||
let dir = tmpdir("root");
|
||||
let sub = dir.join("Album");
|
||||
fs::create_dir_all(sub.join("Disc1")).unwrap();
|
||||
fs::write(sub.join("Disc1").join("x.qmc0"), vec![0x33u8; 512]).unwrap();
|
||||
|
||||
// 以子目录为 root:Disc1 在 root 内 → rel_parent = Disc1
|
||||
let files = scan(&sub, Some(&sub)).unwrap();
|
||||
assert_eq!(files.len(), 1);
|
||||
assert_eq!(files[0].rel_parent.as_deref(), Some(Path::new("Disc1")));
|
||||
|
||||
// 以上级为 root:rel_parent = Album/Disc1
|
||||
let files2 = scan(&sub, Some(&dir)).unwrap();
|
||||
assert_eq!(
|
||||
files2[0].rel_parent.as_deref(),
|
||||
Some(Path::new("Album").join("Disc1").as_path())
|
||||
);
|
||||
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scan_rejects_non_directory() {
|
||||
let dir = tmpdir("notdir");
|
||||
let f = dir.join("a.txt");
|
||||
fs::write(&f, b"x").unwrap();
|
||||
assert!(scan(&f, None).is_err());
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scan_on_empty_dir_returns_empty() {
|
||||
let dir = tmpdir("empty");
|
||||
let files = scan(&dir, None).unwrap();
|
||||
assert!(files.is_empty());
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
}
|
||||
}
|
||||
@@ -19,7 +19,9 @@
|
||||
mod audio;
|
||||
mod bridge;
|
||||
mod commands;
|
||||
pub mod decrypt;
|
||||
mod feiniu;
|
||||
mod remote;
|
||||
mod runtime;
|
||||
mod secrets;
|
||||
mod smtc;
|
||||
@@ -33,6 +35,12 @@ pub use feiniu::{
|
||||
extract_fn_id, normalize_base_url, resolve_base_url, scan_local_dirs, Feiniu, FeiniuConnection,
|
||||
};
|
||||
|
||||
pub use remote::{
|
||||
init_on_launch, remote_cancel_pairing, remote_get_config, remote_list_devices,
|
||||
remote_publish_queue, remote_revoke_device, remote_set_enabled, remote_start_pairing,
|
||||
remote_status, RemoteManager,
|
||||
};
|
||||
|
||||
pub use smtc::{
|
||||
music_smtc_clear, music_smtc_update_metadata, music_smtc_update_playback_state,
|
||||
music_smtc_update_position, SmtcController,
|
||||
@@ -51,6 +59,10 @@ pub use commands::{
|
||||
webdav_save_secret, webdav_test, webdav_upload,
|
||||
};
|
||||
|
||||
pub use decrypt::commands::{
|
||||
music_decrypt_cancel, music_decrypt_qq_status, music_decrypt_run, music_decrypt_scan,
|
||||
};
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use std::collections::HashMap;
|
||||
@@ -126,6 +138,23 @@ pub struct MusicInstallProgress {
|
||||
pub message: String,
|
||||
}
|
||||
|
||||
/// 前端最近一次推给 SMTC 的曲目信息(`music_smtc_update_metadata` 回填)。
|
||||
///
|
||||
/// 用途:**手机遥控的兜底聚合**——GSMTC 不可用时,`AudioEngine.state()` 只有
|
||||
/// 位置/播放态没有标题/歌手(队列元数据在前端 feiniuStore),故以本缓存补全
|
||||
/// (MUSIC_REMOTE_PLAN §5.2)。
|
||||
#[derive(Default)]
|
||||
pub struct SmtcMetaCache(pub Mutex<SmtcMetaSnapshot>);
|
||||
|
||||
/// [`SmtcMetaCache`] 的内容(字段与 `music_smtc_update_metadata` 命令对齐)。
|
||||
/// cover_url 暂不存:兜底聚合的封面策略是 None(GSMTC 主路径自带缩略图,§5.2)。
|
||||
#[derive(Default, Clone)]
|
||||
pub struct SmtcMetaSnapshot {
|
||||
pub title: String,
|
||||
pub artist: String,
|
||||
pub album: String,
|
||||
}
|
||||
|
||||
/// 音乐模块设置(settings.json 持久化;变更即时生效)
|
||||
#[derive(Serialize, Deserialize, Clone, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
@@ -191,6 +220,18 @@ pub struct MusicSettings {
|
||||
/// 下载完成后自动上传到飞牛曲库
|
||||
#[serde(default)]
|
||||
pub feiniu_auto_upload: bool,
|
||||
/// 手机互联:总开关(变更即时生效,MUSIC_REMOTE_PLAN §5.1)
|
||||
#[serde(default)]
|
||||
pub remote_enabled: bool,
|
||||
/// 手机互联:期望端口(0 = 默认 26124 起自动探测至 26139)
|
||||
#[serde(default)]
|
||||
pub remote_port: u16,
|
||||
/// 本机标识(beacon / NowPlaying.deviceId 同源;首次启动自动生成)
|
||||
#[serde(default)]
|
||||
pub remote_device_id: String,
|
||||
/// 已配对设备表(仅元数据;token 在系统凭据管理器 `music-remote-token-*`)
|
||||
#[serde(default)]
|
||||
pub remote_devices: Vec<remote::RemoteDeviceMeta>,
|
||||
}
|
||||
|
||||
impl MusicSettings {
|
||||
@@ -311,6 +352,9 @@ pub struct MusicManager {
|
||||
feiniu: Feiniu,
|
||||
/// AppHandle(桥接 reader 线程据此将事件转发给前端;setup 时设置)
|
||||
app: Mutex<Option<AppHandle>>,
|
||||
/// 本地解密任务表(「解密」页签)。放这里而不是单独 `manage`,
|
||||
/// 是为了让解密命令与其余音乐命令一样只取 `State<'_, MusicManager>`。
|
||||
decrypt: Arc<decrypt::DecryptTasks>,
|
||||
}
|
||||
|
||||
impl MusicManager {
|
||||
@@ -337,9 +381,15 @@ impl MusicManager {
|
||||
settings_cache: Mutex::new(None),
|
||||
feiniu,
|
||||
app: Mutex::new(None),
|
||||
decrypt: Arc::new(decrypt::DecryptTasks::new()),
|
||||
}
|
||||
}
|
||||
|
||||
/// 解密任务表(供 `music/decrypt/commands.rs` 取用)
|
||||
pub(crate) fn decrypt_tasks(&self) -> Arc<decrypt::DecryptTasks> {
|
||||
self.decrypt.clone()
|
||||
}
|
||||
|
||||
/// 设置 AppHandle(setup 阶段调用;桥接 reader 线程据此转发事件到前端)
|
||||
pub fn set_app(&self, app: AppHandle) {
|
||||
if let Ok(mut guard) = self.app.lock() {
|
||||
@@ -385,6 +435,10 @@ impl MusicManager {
|
||||
feiniu_play_mode: "stream".to_string(),
|
||||
feiniu_library_nas_path: String::new(),
|
||||
feiniu_auto_upload: false,
|
||||
remote_enabled: false,
|
||||
remote_port: 0,
|
||||
remote_device_id: String::new(),
|
||||
remote_devices: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,181 @@
|
||||
//! 设备发现:UDP beacon(MUSIC_REMOTE_PLAN §3.3,P0 主路径)。
|
||||
//!
|
||||
//! 电脑每 3s 向 `255.255.255.255:26123` **与各网卡的定向广播地址**发 JSON 包;
|
||||
//! 手机被动监听 26123 收集。beacon 不含任何敏感信息(无 token、无配对码)。
|
||||
//!
|
||||
//! 各网卡定向广播是必须的:本机常驻 VPN/虚拟网卡(mihomo 等),默认路由可能
|
||||
//! 不在 LAN 网卡上,仅发 255.255.255.255 会从默认路由出去、手机收不到(§8 风险行
|
||||
//! "多网卡/VPN 虚拟网卡"的对策)。地址枚举走 `GetAdaptersAddresses`。
|
||||
|
||||
use std::net::{Ipv4Addr, UdpSocket};
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::Arc;
|
||||
use std::thread::JoinHandle;
|
||||
use std::time::Duration;
|
||||
|
||||
/// 手机监听的 beacon 端口(与 LFMusic `bind :26123` 对齐)。
|
||||
pub const BEACON_PORT: u16 = 26123;
|
||||
|
||||
/// beacon 广播周期(与对端文档 §5.1"每 3s 广播"对齐)。
|
||||
const BEACON_INTERVAL: Duration = Duration::from_secs(3);
|
||||
|
||||
/// beacon 负载(§3.3)。`addrs` 供手机在多地址场景按连通性优选(§8 对策)。
|
||||
#[derive(Clone, serde::Serialize)]
|
||||
pub struct BeaconPayload {
|
||||
pub service: &'static str,
|
||||
#[serde(rename = "deviceId")]
|
||||
pub device_id: String,
|
||||
pub name: String,
|
||||
pub port: u16,
|
||||
#[serde(rename = "protoVer")]
|
||||
pub proto_ver: u32,
|
||||
/// 本机各网卡 IPv4(去重、去回环、去 169.254 链路本地)
|
||||
pub addrs: Vec<String>,
|
||||
}
|
||||
|
||||
/// 枚举本机可用的 IPv4 与对应定向广播地址(网段广播,prefix<32 才有)。
|
||||
///
|
||||
/// 失败时返回空(beacon 退化为只发 255.255.255.255,不阻断启动)。
|
||||
#[cfg(windows)]
|
||||
pub fn ipv4_broadcast_pairs() -> Vec<(Ipv4Addr, Ipv4Addr)> {
|
||||
use windows::Win32::NetworkManagement::IpHelper::{
|
||||
GAA_FLAG_INCLUDE_PREFIX, GAA_FLAG_SKIP_ANYCAST, GAA_FLAG_SKIP_DNS_SERVER,
|
||||
GAA_FLAG_SKIP_MULTICAST, GetAdaptersAddresses, IP_ADAPTER_ADDRESSES_LH,
|
||||
IP_ADAPTER_UNICAST_ADDRESS_LH,
|
||||
};
|
||||
use windows::Win32::Networking::WinSock::{AF_INET, SOCKADDR_IN};
|
||||
|
||||
let mut out: Vec<(Ipv4Addr, Ipv4Addr)> = Vec::new();
|
||||
unsafe {
|
||||
let mut size: u32 = 0;
|
||||
let flags = GAA_FLAG_INCLUDE_PREFIX
|
||||
| GAA_FLAG_SKIP_ANYCAST
|
||||
| GAA_FLAG_SKIP_MULTICAST
|
||||
| GAA_FLAG_SKIP_DNS_SERVER;
|
||||
// 第一次调用只探长度(返回 ERROR_BUFFER_OVERFLOW = 111)
|
||||
let _ = GetAdaptersAddresses(AF_INET.0 as u32, flags, None, None, &mut size);
|
||||
if size == 0 {
|
||||
return out;
|
||||
}
|
||||
let mut buf = vec![0u8; size as usize];
|
||||
let ptr = buf.as_mut_ptr() as *mut IP_ADAPTER_ADDRESSES_LH;
|
||||
let ret = GetAdaptersAddresses(AF_INET.0 as u32, flags, None, Some(ptr), &mut size);
|
||||
if ret != 0 {
|
||||
crate::logger::log_warn(
|
||||
"music-remote",
|
||||
&format!("GetAdaptersAddresses 失败: {ret}(beacon 退化为受限广播)"),
|
||||
);
|
||||
return out;
|
||||
}
|
||||
let mut adapter = (*ptr).FirstUnicastAddress;
|
||||
while !adapter.is_null() {
|
||||
let ua: *mut IP_ADAPTER_UNICAST_ADDRESS_LH = adapter;
|
||||
let sa = (*ua).Address;
|
||||
let sockaddr = sa.lpSockaddr as *const SOCKADDR_IN;
|
||||
if !sockaddr.is_null() {
|
||||
let raw = u32::from_be((*sockaddr).sin_addr.S_un.S_addr);
|
||||
let ip = Ipv4Addr::from(raw);
|
||||
// 跳过回环与链路本地(APIPA)
|
||||
if !ip.is_loopback() && !ip.is_link_local() {
|
||||
let prefix = (*ua).OnLinkPrefixLength.min(32);
|
||||
if prefix == 0 {
|
||||
out.push((ip, Ipv4Addr::BROADCAST));
|
||||
} else {
|
||||
let mask = u32::MAX << (32 - prefix);
|
||||
let bcast = Ipv4Addr::from(raw | !mask);
|
||||
if bcast != ip && !bcast.is_loopback() {
|
||||
out.push((ip, bcast));
|
||||
} else {
|
||||
out.push((ip, Ipv4Addr::BROADCAST));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
adapter = (*ua).Next;
|
||||
}
|
||||
}
|
||||
// 去重(多网卡同地址 / 多地址同广播)
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
out.retain(|p| seen.insert(*p));
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(not(windows))]
|
||||
pub fn ipv4_broadcast_pairs() -> Vec<(Ipv4Addr, Ipv4Addr)> {
|
||||
Vec::new()
|
||||
}
|
||||
|
||||
/// 取一个适合放进二维码 payload 的本机 LAN IP(首个非链路本地 IPv4)。
|
||||
pub fn primary_ipv4() -> Option<Ipv4Addr> {
|
||||
ipv4_broadcast_pairs()
|
||||
.into_iter()
|
||||
.map(|(ip, _)| ip)
|
||||
.find(|ip| !ip.is_loopback() && !ip.is_link_local())
|
||||
}
|
||||
|
||||
/// 启动 beacon 广播线程;`shutdown` 置 true 后最迟一个周期内退出。
|
||||
pub fn spawn_beacon(payload: BeaconPayload, shutdown: Arc<AtomicBool>) -> JoinHandle<()> {
|
||||
std::thread::Builder::new()
|
||||
.name("remote-beacon".to_string())
|
||||
.spawn(move || {
|
||||
let sock = match UdpSocket::bind("0.0.0.0:0") {
|
||||
Ok(s) => s,
|
||||
Err(e) => {
|
||||
crate::logger::log_error(
|
||||
"music-remote",
|
||||
&format!("beacon 套接字绑定失败: {e}"),
|
||||
);
|
||||
return;
|
||||
}
|
||||
};
|
||||
let _ = sock.set_broadcast(true);
|
||||
let json = serde_json::to_string(&payload).unwrap_or_default();
|
||||
let bytes = json.as_bytes();
|
||||
crate::logger::log_info(
|
||||
"music-remote",
|
||||
&format!(
|
||||
"beacon 已启动 → :{BEACON_PORT},addrs={:?},payload={json}",
|
||||
payload.addrs
|
||||
),
|
||||
);
|
||||
while !shutdown.load(Ordering::Relaxed) {
|
||||
// 受限广播(默认路由 NIC)
|
||||
let _ = sock.send_to(bytes, ("255.255.255.255", BEACON_PORT));
|
||||
// 各网卡定向广播(VPN/多网卡场景的保底路径)
|
||||
for (_, bcast) in ipv4_broadcast_pairs() {
|
||||
let _ = sock.send_to(bytes, (bcast, BEACON_PORT));
|
||||
}
|
||||
for _ in 0..(BEACON_INTERVAL.as_millis() / 100).max(1) {
|
||||
if shutdown.load(Ordering::Relaxed) {
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
}
|
||||
}
|
||||
crate::logger::log_info("music-remote", "beacon 已停止");
|
||||
})
|
||||
.expect("创建 beacon 线程失败")
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn payload_shape_matches_phone_expectation() {
|
||||
let p = BeaconPayload {
|
||||
service: "thing-music",
|
||||
device_id: "d1".into(),
|
||||
name: "Thing".into(),
|
||||
port: 26124,
|
||||
proto_ver: 1,
|
||||
addrs: vec!["192.168.1.5".into()],
|
||||
};
|
||||
let json = serde_json::to_string(&p).unwrap();
|
||||
// 手机端按 service 过滤、按 deviceId 去重(LFMusic §5.1)
|
||||
assert!(json.contains("\"service\":\"thing-music\""));
|
||||
assert!(json.contains("\"deviceId\":\"d1\""));
|
||||
assert!(json.contains("\"protoVer\":1"));
|
||||
assert!(json.contains("\"port\":26124"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,828 @@
|
||||
//! GSMTC 全局会话监视与控制(MUSIC_REMOTE_PLAN §3.1 / §5.1 `glsmtc.rs`)。
|
||||
//!
|
||||
//! # 线程模型(§3.1,实测修订版)
|
||||
//!
|
||||
//! - 监视跑在**专用线程**(`remote-gsmtc`):该线程首次 WinRT 调用即按 MTA 初始化,
|
||||
//! `RequestAsync().get()` 等阻塞等待全部发生在本线程——既满足"`.get()` 不在主线程"
|
||||
//! 的 STA 死锁约束,也不需要像 `smtc.rs` 那样把发起抛回主线程(GSMTC 不绑窗口,
|
||||
//! 无 HWND 交互)。事件订阅也在本线程完成;回调从线程池触发,对象 agile,直接读写。
|
||||
//! - 控制(`Try*Async.get`)由 server 在 `spawn_blocking` 里调 [`control`]。
|
||||
//!
|
||||
//! # 节流(§6.3)
|
||||
//!
|
||||
//! 事件风暴合并后**最快 1Hz** 发布 `state`;进度靠手机本地推算。例外:`Force`
|
||||
//! (cmd 触发)立即发布一帧,绕过节流。语义变化(歌/状态/会话)不等节流窗口。
|
||||
//!
|
||||
//! # 失败策略(§3.1)
|
||||
//!
|
||||
//! GSMTC 任何失败只记日志;初始化失败 → `gsmtc_ok=false`,聚合切换到
|
||||
//! AudioEngine + SmtcMetaCache 兜底(§5.2)。
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use tauri::{AppHandle, Manager};
|
||||
use tokio::sync::watch;
|
||||
use windows::Foundation::TypedEventHandler;
|
||||
use windows::Media::Control::{
|
||||
CurrentSessionChangedEventArgs, GlobalSystemMediaTransportControlsSession as GsSession,
|
||||
GlobalSystemMediaTransportControlsSessionManager as GsManager,
|
||||
GlobalSystemMediaTransportControlsSessionMediaProperties as GsMediaProperties,
|
||||
GlobalSystemMediaTransportControlsSessionPlaybackStatus as GsStatus,
|
||||
MediaPropertiesChangedEventArgs, PlaybackInfoChangedEventArgs, SessionsChangedEventArgs,
|
||||
TimelinePropertiesChangedEventArgs,
|
||||
};
|
||||
|
||||
use super::proto::{
|
||||
self, CanControl, CmdAction, CmdArgs, NowPlaying, PlayStatus, THING_SELF_SESSION,
|
||||
};
|
||||
use super::volume;
|
||||
use super::CoverStore;
|
||||
use crate::music::{AudioEngine, MusicManager, SmtcMetaCache};
|
||||
|
||||
/// 100 纳秒 ticks/秒。
|
||||
const TICKS_PER_SEC: i64 = 10_000_000;
|
||||
/// 位置跳变阈值(秒):超过它就补发一帧。与手机端 `rebaseProgress` 的
|
||||
/// 1.5s 判定一致——发出来的跳变一定能被手机端识别为「来源已更新」。
|
||||
const POSITION_JUMP_SEC: f64 = 1.5;
|
||||
/// 封面读取上限(防异常大图)。
|
||||
const MAX_COVER_BYTES: u32 = 10 * 1024 * 1024;
|
||||
|
||||
/// 监视线程消息。
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum MonitorMsg {
|
||||
/// 事件到达(合并处理)
|
||||
Change,
|
||||
/// cmd 后立即发布(绕过 1Hz 节流,§6.3 例外)
|
||||
Force,
|
||||
/// 退出
|
||||
Stop,
|
||||
}
|
||||
|
||||
/// GSMTC 监视器句柄(RemoteManager 持有)。
|
||||
pub struct GsmtcMonitor {
|
||||
tx: Sender<MonitorMsg>,
|
||||
handle: Mutex<Option<std::thread::JoinHandle<()>>>,
|
||||
}
|
||||
|
||||
impl GsmtcMonitor {
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
pub fn start(
|
||||
app: AppHandle,
|
||||
state_tx: Arc<watch::Sender<NowPlaying>>,
|
||||
covers: Arc<CoverStore>,
|
||||
gsmtc_ok: Arc<AtomicBool>,
|
||||
sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
|
||||
selected: Arc<Mutex<Option<String>>>,
|
||||
) -> Self {
|
||||
let (tx, rx) = mpsc::channel::<MonitorMsg>();
|
||||
let thread_tx = tx.clone();
|
||||
let handle = std::thread::Builder::new()
|
||||
.name("remote-gsmtc".to_string())
|
||||
.spawn(move || {
|
||||
run(
|
||||
app, state_tx, covers, gsmtc_ok, sessions_tx, selected, thread_tx, rx,
|
||||
)
|
||||
})
|
||||
.expect("创建 gsmtc 监视线程失败");
|
||||
Self {
|
||||
tx,
|
||||
handle: Mutex::new(Some(handle)),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn send(&self, msg: MonitorMsg) {
|
||||
let _ = self.tx.send(msg);
|
||||
}
|
||||
|
||||
pub fn notify_force(&self) {
|
||||
self.send(MonitorMsg::Force);
|
||||
}
|
||||
|
||||
/// 停止并等待线程退出(先 Stop 唤醒,join 最迟在下一次 500ms 节拍内完成)。
|
||||
pub fn stop(&self) {
|
||||
self.send(MonitorMsg::Stop);
|
||||
let handle = self
|
||||
.handle
|
||||
.lock()
|
||||
.unwrap_or_else(|e| e.into_inner())
|
||||
.take();
|
||||
if let Some(h) = handle {
|
||||
let _ = h.join();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for GsmtcMonitor {
|
||||
fn drop(&mut self) {
|
||||
self.send(MonitorMsg::Stop);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 聚合(监视线程)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// 语义指纹:不含 position/updatedAt(它们每秒都变,单独走进度窗口)。
|
||||
fn fingerprint(np: &NowPlaying) -> String {
|
||||
// 引用 + 元组整体 Debug:避开逐字段 format 的 Display/Debug 混用与 move 错误
|
||||
format!(
|
||||
"{:?}",
|
||||
(
|
||||
&np.session_id,
|
||||
&np.source_app,
|
||||
np.is_thing,
|
||||
&np.title,
|
||||
&np.artist,
|
||||
&np.album,
|
||||
&np.cover_hash,
|
||||
np.status,
|
||||
np.duration_sec,
|
||||
&np.can_control,
|
||||
np.volume,
|
||||
np.muted,
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
fn run(
|
||||
app: AppHandle,
|
||||
state_tx: Arc<watch::Sender<NowPlaying>>,
|
||||
covers: Arc<CoverStore>,
|
||||
gsmtc_ok: Arc<AtomicBool>,
|
||||
sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
|
||||
selected: Arc<Mutex<Option<String>>>,
|
||||
tx: Sender<MonitorMsg>,
|
||||
rx: Receiver<MonitorMsg>,
|
||||
) {
|
||||
// 首次 WinRT 调用在此线程自动按 MTA 初始化(见模块注释)
|
||||
// RequestAsync() → Result<IAsyncOperation<_>>;外层 Result 与异步 get() 分两步
|
||||
let manager = GsManager::RequestAsync().and_then(|op| op.get());
|
||||
match &manager {
|
||||
Ok(_) => {
|
||||
gsmtc_ok.store(true, Ordering::Relaxed);
|
||||
crate::logger::log_info("music-remote", "GSMTC 已初始化(专用线程 MTA)");
|
||||
}
|
||||
Err(e) => {
|
||||
gsmtc_ok.store(false, Ordering::Relaxed);
|
||||
crate::logger::log_error(
|
||||
"music-remote",
|
||||
&format!("GSMTC 初始化失败,远程查看/控制降级为「仅 Thing 自身」: {e}"),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// 事件订阅:任一变更 → Change(合并节流在下方发布逻辑里)
|
||||
if let Ok(m) = &manager {
|
||||
let t = tx.clone();
|
||||
let _ = m.CurrentSessionChanged(
|
||||
&TypedEventHandler::<GsManager, CurrentSessionChangedEventArgs>::new(move |_, _| {
|
||||
let _ = t.send(MonitorMsg::Change);
|
||||
Ok(())
|
||||
}),
|
||||
);
|
||||
let t = tx.clone();
|
||||
let _ = m.SessionsChanged(
|
||||
&TypedEventHandler::<GsManager, SessionsChangedEventArgs>::new(move |_, _| {
|
||||
let _ = t.send(MonitorMsg::Change);
|
||||
Ok(())
|
||||
}),
|
||||
);
|
||||
// 说明:MediaProperties/Timeline/PlaybackInfo 是 **Session 级**事件(挂在每条会话上,
|
||||
// 需随会话变化反复订阅/退订)。P0 简化为不订阅——聚合本身以 500ms 节拍轮询,
|
||||
// 语义变化最多延迟 ~500ms 上屏(发布规则见下),1Hz 进度窗口不受影响;
|
||||
// 会话级事件的精细化订阅列入 P1(计划 §7)。
|
||||
}
|
||||
|
||||
let mut last_publish: Option<Instant> = None;
|
||||
let mut last_fp = String::new();
|
||||
// 上次**发布**时的位置:位置不进语义指纹(每秒都变),单独用来识别跳变
|
||||
let mut last_pos: Option<f64> = None;
|
||||
// 封面快捷缓存:coverKey → hash(避免同曲反复读缩略图;字节在 CoverStore)
|
||||
let mut cover_local: HashMap<String, String> = HashMap::new();
|
||||
// AUMID → 显示名缓存(注册表友好名,P1 §7)
|
||||
let mut name_cache: HashMap<String, String> = HashMap::new();
|
||||
// 会话列表指纹(变化才推 sessions 消息)
|
||||
let mut last_sessions_fp = String::new();
|
||||
// 当前目标会话的事件订阅(P1 §7 会话级事件:随目标切换订阅/退订)
|
||||
let mut subs: Option<SessionSubs> = None;
|
||||
let mut last_sub_aumid = String::new();
|
||||
|
||||
loop {
|
||||
// 收一轮消息(风暴合并)
|
||||
let mut force = false;
|
||||
let mut running = true;
|
||||
match rx.recv_timeout(Duration::from_millis(500)) {
|
||||
Ok(MonitorMsg::Stop) => running = false,
|
||||
Ok(MonitorMsg::Force) => force = true,
|
||||
Ok(MonitorMsg::Change) => {}
|
||||
Err(RecvTimeoutError::Timeout) => {}
|
||||
Err(RecvTimeoutError::Disconnected) => running = false,
|
||||
}
|
||||
while running {
|
||||
match rx.try_recv() {
|
||||
Ok(MonitorMsg::Stop) => {
|
||||
running = false;
|
||||
break;
|
||||
}
|
||||
Ok(MonitorMsg::Force) => force = true,
|
||||
Ok(MonitorMsg::Change) => {}
|
||||
Err(_) => break,
|
||||
}
|
||||
}
|
||||
if !running {
|
||||
break;
|
||||
}
|
||||
|
||||
// 设置读取:remote_device_id(MusicManager 500ms 缓存,开销可忽略)
|
||||
let device_id = app
|
||||
.try_state::<MusicManager>()
|
||||
.map(|m| m.load_settings().remote_device_id)
|
||||
.unwrap_or_default();
|
||||
|
||||
// 目标会话:手机选中覆盖优先,否则系统 current(P1 多会话切换;
|
||||
// WinRT 无 SetCurrentSession,选中是 Thing 侧覆盖而非改系统判定)
|
||||
let (target, needs_clear) = match &manager {
|
||||
Ok(m) => {
|
||||
let sel = selected
|
||||
.lock()
|
||||
.map(|g| g.clone())
|
||||
.unwrap_or_default();
|
||||
pick_target(m, sel.as_deref())
|
||||
}
|
||||
Err(_) => (None, false),
|
||||
};
|
||||
if needs_clear {
|
||||
if let Ok(mut s) = selected.lock() {
|
||||
s.take();
|
||||
}
|
||||
}
|
||||
|
||||
// 会话级事件订阅跟随目标(P1 §7:Media/Timeline/PlaybackInfo 随会话退订换绑)
|
||||
if manager.is_ok() {
|
||||
let aumid = target
|
||||
.as_ref()
|
||||
.and_then(|s| s.SourceAppUserModelId().ok())
|
||||
.map(|h| h.to_string())
|
||||
.unwrap_or_default();
|
||||
if aumid != last_sub_aumid {
|
||||
if let Some(old) = subs.take() {
|
||||
old.remove_all();
|
||||
}
|
||||
if let Some(t) = &target {
|
||||
subs = Some(SessionSubs::subscribe(t, &tx));
|
||||
}
|
||||
last_sub_aumid = aumid;
|
||||
}
|
||||
}
|
||||
|
||||
// 系统主音量轮询(P1 §7;500ms 一次,端点不可用时 volume=None)
|
||||
let (vol, muted) = volume::read().map(|(v, m)| (Some(v), m)).unwrap_or((None, false));
|
||||
|
||||
let mut np = if manager.is_err() {
|
||||
aggregate_fallback(&app, &device_id)
|
||||
} else if let Some(sess) = &target {
|
||||
aggregate_session(&app, sess, &device_id, &covers, &mut cover_local, &mut name_cache)
|
||||
} else {
|
||||
NowPlaying::stopped(&device_id)
|
||||
};
|
||||
np.volume = vol;
|
||||
np.muted = muted;
|
||||
|
||||
// 会话列表(变化才推;连接时 watch 快照兜底)
|
||||
if let Ok(m) = &manager {
|
||||
let list = build_sessions(m, np.session_id.as_str(), &mut name_cache);
|
||||
let fp_s = format!("{:?}", list);
|
||||
if fp_s != last_sessions_fp {
|
||||
last_sessions_fp = fp_s;
|
||||
sessions_tx.send_replace(list);
|
||||
}
|
||||
}
|
||||
|
||||
let fp = fingerprint(&np);
|
||||
let semantic = fp != last_fp;
|
||||
let playing = np.status == PlayStatus::Playing;
|
||||
let progress_due = last_publish
|
||||
.map(|t| t.elapsed() >= Duration::from_secs(1))
|
||||
.unwrap_or(true);
|
||||
// 位置跳变(seek)单独发帧:`position` 不进指纹,暂停态又没有 1Hz 进度帧,
|
||||
// 不补这一帧的话,手机端刚拖好的位置永远等不到来源确认
|
||||
// (保持窗口到期后只能回退到旧位置,表现为「先保持再跳回去」)
|
||||
let position_jump = last_pos
|
||||
.map(|p| (np.position_sec - p).abs() > POSITION_JUMP_SEC)
|
||||
.unwrap_or(false);
|
||||
|
||||
if force || semantic || position_jump || (playing && progress_due) {
|
||||
last_publish = Some(Instant::now());
|
||||
last_fp = fp;
|
||||
last_pos = Some(np.position_sec);
|
||||
// watch:无接收者时 send_replace 仍更新值(新客户端从 borrow 拿快照)
|
||||
state_tx.send_replace(np);
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(s) = subs.take() {
|
||||
s.remove_all();
|
||||
}
|
||||
crate::logger::log_info("music-remote", "GSMTC 监视线程已退出");
|
||||
}
|
||||
|
||||
/// 把目标会话聚合成 `NowPlaying`(§5.2 主路径;目标由 [`pick_target`] 选定)。
|
||||
fn aggregate_session(
|
||||
app: &AppHandle,
|
||||
session: &GsSession,
|
||||
device_id: &str,
|
||||
covers: &CoverStore,
|
||||
cover_local: &mut HashMap<String, String>,
|
||||
name_cache: &mut HashMap<String, String>,
|
||||
) -> NowPlaying {
|
||||
let aumid = session
|
||||
.SourceAppUserModelId()
|
||||
.map(|h| h.to_string())
|
||||
.unwrap_or_default();
|
||||
let is_thing = proto::is_thing_aumid(&aumid);
|
||||
|
||||
// 元数据(§6.2 缩略图)
|
||||
let props = session.TryGetMediaPropertiesAsync().and_then(|op| op.get());
|
||||
let (title, artist, album) = match &props {
|
||||
Ok(p) => (
|
||||
p.Title().map(|h| h.to_string()).unwrap_or_default(),
|
||||
p.Artist().map(|h| h.to_string()).unwrap_or_default(),
|
||||
p.AlbumTitle().map(|h| h.to_string()).unwrap_or_default(),
|
||||
),
|
||||
Err(_) => (String::new(), String::new(), String::new()),
|
||||
};
|
||||
|
||||
let cover_hash = props.as_ref().ok().and_then(|p| {
|
||||
let key = format!("{aumid}|{title}|{album}");
|
||||
cover_for(p, &key, covers, cover_local)
|
||||
});
|
||||
|
||||
// 播放状态与能力位
|
||||
let info = session.GetPlaybackInfo();
|
||||
let status = match info.as_ref().ok().and_then(|i| i.PlaybackStatus().ok()) {
|
||||
Some(GsStatus::Playing) => PlayStatus::Playing,
|
||||
Some(GsStatus::Paused) => PlayStatus::Paused,
|
||||
_ => PlayStatus::Stopped,
|
||||
};
|
||||
let can = match info.as_ref().ok().and_then(|i| i.Controls().ok()) {
|
||||
// Thing 自身会话:控制走前端事件链直通(play/pause/next/prev/seek 全部可用),
|
||||
// 不看 SMTC 的能力位——系统面板那套 IsXxxEnabled 里没有 seek 位,
|
||||
// 照抄会把手机端的进度条锁成只读(seek 实际由 AudioEngine 直接处理)
|
||||
Some(_) if is_thing => CanControl {
|
||||
play: true,
|
||||
pause: true,
|
||||
next: true,
|
||||
prev: true,
|
||||
seek: true,
|
||||
},
|
||||
Some(c) => CanControl {
|
||||
play: c.IsPlayEnabled().unwrap_or(false),
|
||||
pause: c.IsPauseEnabled().unwrap_or(false),
|
||||
next: c.IsNextEnabled().unwrap_or(false),
|
||||
prev: c.IsPreviousEnabled().unwrap_or(false),
|
||||
// WinRT 无 IsSeekEnabled,seek 能力位叫 IsPlaybackPositionEnabled
|
||||
seek: c.IsPlaybackPositionEnabled().unwrap_or(false),
|
||||
},
|
||||
None if is_thing => CanControl {
|
||||
play: true,
|
||||
pause: true,
|
||||
next: true,
|
||||
prev: true,
|
||||
seek: true,
|
||||
},
|
||||
None => CanControl {
|
||||
play: false,
|
||||
pause: false,
|
||||
next: false,
|
||||
prev: false,
|
||||
seek: false,
|
||||
},
|
||||
};
|
||||
// PlaybackRate 是 IReference<f64>(可空)→ Value() 解引用
|
||||
let playback_rate = info
|
||||
.as_ref()
|
||||
.ok()
|
||||
.and_then(|i| i.PlaybackRate().ok())
|
||||
.and_then(|r| r.Value().ok())
|
||||
.filter(|r| r.is_finite() && *r > 0.0)
|
||||
.unwrap_or(1.0);
|
||||
|
||||
// 时间轴(§6.4:位置基准用 LastUpdatedTime)
|
||||
let (position_sec, duration_sec, position_updated_at_ms) = match session.GetTimelineProperties()
|
||||
{
|
||||
Ok(tl) => {
|
||||
let pos = tl
|
||||
.Position()
|
||||
.map(|t| t.Duration as f64 / TICKS_PER_SEC as f64)
|
||||
.unwrap_or(0.0);
|
||||
let dur = tl
|
||||
.EndTime()
|
||||
.map(|t| t.Duration as f64 / TICKS_PER_SEC as f64)
|
||||
.unwrap_or(0.0);
|
||||
// `LastUpdatedTime = 0` = 来源从未上报过时间轴(bilibili PC 实测:
|
||||
// position=0 / EndTime=0 / LastUpdatedTime=0)。换算出的负值同样没有意义,
|
||||
// 一律归 0 作「无进度基准」哨兵,手机端据此停掉进度推算(否则每秒一帧
|
||||
// 从 0 起算,进度条原地抽搐)。
|
||||
let updated = tl
|
||||
.LastUpdatedTime()
|
||||
.map(|d| proto::winrt_ticks_to_unix_ms(d.UniversalTime))
|
||||
.unwrap_or(0);
|
||||
(pos.max(0.0), dur.max(0.0), updated.max(0))
|
||||
}
|
||||
// 取不到时间轴 = 没有可用基准,不能拿本机时间伪装成"刚更新过"
|
||||
Err(_) => (0.0, 0.0, 0),
|
||||
};
|
||||
|
||||
// Thing 自身会话:位置改用 AudioEngine 快照。SMTC 那份由前端按 1s 节流上报、
|
||||
// 暂停态甚至不刷新,手机端拖完 seek 会一直等不到「来源已到新位置」的确认,
|
||||
// 保持窗口到期后只能回退到旧位置。引擎快照是逐次读取的权威值,seek 后立即反映。
|
||||
let (position_sec, position_updated_at_ms) = if is_thing {
|
||||
let engine_pos = app.try_state::<AudioEngine>().and_then(|e| {
|
||||
let st = e.state();
|
||||
st.active.then_some(st.position_sec)
|
||||
});
|
||||
match engine_pos {
|
||||
Some(p) => (p.max(0.0), now_unix_ms()),
|
||||
None => (position_sec, position_updated_at_ms), // 引擎无会话:退回 SMTC 值
|
||||
}
|
||||
} else {
|
||||
(position_sec, position_updated_at_ms)
|
||||
};
|
||||
|
||||
NowPlaying {
|
||||
session_id: proto::session_key(&aumid),
|
||||
source_app: friendly_name(&aumid, name_cache),
|
||||
is_thing,
|
||||
title,
|
||||
artist,
|
||||
album,
|
||||
cover_hash,
|
||||
status,
|
||||
duration_sec,
|
||||
position_sec,
|
||||
position_updated_at_ms,
|
||||
playback_rate,
|
||||
can_control: can,
|
||||
volume: None,
|
||||
muted: false,
|
||||
device_id: device_id.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// 读取会话缩略图 → 存 CoverStore → 返回 hash(§6.2:WS 只带 hash)。
|
||||
fn cover_for(
|
||||
props: &GsMediaProperties,
|
||||
key: &str,
|
||||
covers: &CoverStore,
|
||||
local: &mut HashMap<String, String>,
|
||||
) -> Option<String> {
|
||||
if let Some(h) = local.get(key) {
|
||||
return Some(h.clone());
|
||||
}
|
||||
// 无缩略图(null → Err)直接返回 None;同 key 不重试(记空串占位)
|
||||
let reference = match props.Thumbnail() {
|
||||
Ok(r) => r,
|
||||
Err(_) => {
|
||||
local.insert(key.to_string(), String::new());
|
||||
return None;
|
||||
}
|
||||
};
|
||||
let bytes = read_thumb(&reference)?;
|
||||
let hash = covers.put(&bytes)?;
|
||||
// 快捷缓存防膨胀(同曲重读的代价可接受)
|
||||
if local.len() > 128 {
|
||||
local.clear();
|
||||
}
|
||||
local.insert(key.to_string(), hash.clone());
|
||||
Some(hash)
|
||||
}
|
||||
|
||||
/// `IRandomAccessStreamReference` → 字节(DataReader 路径,无需 Cryptography feature)。
|
||||
fn read_thumb(reference: &windows::Storage::Streams::IRandomAccessStreamReference) -> Option<Vec<u8>> {
|
||||
use windows::Storage::Streams::DataReader;
|
||||
|
||||
let stream = reference.OpenReadAsync().ok()?.get().ok()?;
|
||||
let size = stream.Size().ok()? as u32;
|
||||
if size == 0 || size > MAX_COVER_BYTES {
|
||||
return None;
|
||||
}
|
||||
let reader = DataReader::CreateDataReader(&stream).ok()?;
|
||||
reader.LoadAsync(size).ok()?.get().ok()?;
|
||||
let mut buf = vec![0u8; size as usize];
|
||||
reader.ReadBytes(&mut buf).ok()?;
|
||||
Some(buf)
|
||||
}
|
||||
|
||||
/// 兜底聚合(§5.2:GSMTC 不可用时):AudioEngine 状态 + 前端已推送的 SMTC 元数据。
|
||||
fn aggregate_fallback(app: &AppHandle, device_id: &str) -> NowPlaying {
|
||||
let engine = match app.try_state::<AudioEngine>() {
|
||||
Some(e) => e,
|
||||
None => return NowPlaying::stopped(device_id),
|
||||
};
|
||||
let st = engine.state();
|
||||
if !st.active {
|
||||
return NowPlaying::stopped(device_id);
|
||||
}
|
||||
let meta = app
|
||||
.try_state::<SmtcMetaCache>()
|
||||
.map(|c| c.0.lock().unwrap_or_else(|e| e.into_inner()).clone())
|
||||
.unwrap_or_default();
|
||||
NowPlaying {
|
||||
session_id: THING_SELF_SESSION.to_string(),
|
||||
source_app: proto::source_display(proto::THING_AUMID),
|
||||
is_thing: true,
|
||||
title: meta.title,
|
||||
artist: meta.artist,
|
||||
album: meta.album,
|
||||
cover_hash: None,
|
||||
status: if st.playing {
|
||||
PlayStatus::Playing
|
||||
} else {
|
||||
PlayStatus::Paused
|
||||
},
|
||||
position_sec: st.position_sec,
|
||||
position_updated_at_ms: now_unix_ms(),
|
||||
playback_rate: 1.0,
|
||||
can_control: CanControl {
|
||||
play: true,
|
||||
pause: true,
|
||||
next: true,
|
||||
prev: true,
|
||||
seek: true,
|
||||
},
|
||||
device_id: device_id.to_string(),
|
||||
..NowPlaying::default()
|
||||
}
|
||||
}
|
||||
|
||||
fn now_unix_ms() -> i64 {
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.as_millis() as i64)
|
||||
.unwrap_or(0)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 会话选择 / 列表 / 事件订阅 / 友好名(P1 §7)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// 选定目标会话:`selected` 命中则用之;否则系统 current。
|
||||
/// 返回 `(目标, 是否需要清除选中)`——选中项已消失时回退 current 并标记清除。
|
||||
/// (WinRT **没有** SetCurrentSession:选中是 Thing 侧覆盖,不改系统判定。)
|
||||
fn pick_target(manager: &GsManager, selected: Option<&str>) -> (Option<GsSession>, bool) {
|
||||
if let Some(sid) = selected.filter(|s| !s.is_empty()) {
|
||||
let mut found: Option<GsSession> = None;
|
||||
if let Ok(list) = manager.GetSessions() {
|
||||
for i in 0..list.Size().unwrap_or(0) {
|
||||
if let Ok(s) = list.GetAt(i) {
|
||||
let key = s
|
||||
.SourceAppUserModelId()
|
||||
.ok()
|
||||
.map(|h| proto::session_key(&h.to_string()));
|
||||
if key.as_deref() == Some(sid) {
|
||||
found = Some(s);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return match found {
|
||||
Some(s) => (Some(s), false),
|
||||
None => (manager.GetCurrentSession().ok(), true),
|
||||
};
|
||||
}
|
||||
(manager.GetCurrentSession().ok(), false)
|
||||
}
|
||||
|
||||
/// 枚举全部会话为手机端列表(`is_current` = 是否当前展示目标)。
|
||||
fn build_sessions(
|
||||
manager: &GsManager,
|
||||
current_key: &str,
|
||||
name_cache: &mut HashMap<String, String>,
|
||||
) -> Vec<proto::SessionInfo> {
|
||||
let Ok(list) = manager.GetSessions() else {
|
||||
return Vec::new();
|
||||
};
|
||||
let mut out = Vec::new();
|
||||
for i in 0..list.Size().unwrap_or(0) {
|
||||
let Ok(s) = list.GetAt(i) else { continue };
|
||||
let aumid = s
|
||||
.SourceAppUserModelId()
|
||||
.map(|h| h.to_string())
|
||||
.unwrap_or_default();
|
||||
let key = proto::session_key(&aumid);
|
||||
let (title, artist) = match s.TryGetMediaPropertiesAsync().and_then(|op| op.get()) {
|
||||
Ok(p) => (
|
||||
p.Title().map(|h| h.to_string()).unwrap_or_default(),
|
||||
p.Artist().map(|h| h.to_string()).unwrap_or_default(),
|
||||
),
|
||||
Err(_) => (String::new(), String::new()),
|
||||
};
|
||||
let status = match s.GetPlaybackInfo().and_then(|i| i.PlaybackStatus()) {
|
||||
Ok(GsStatus::Playing) => PlayStatus::Playing,
|
||||
Ok(GsStatus::Paused) => PlayStatus::Paused,
|
||||
_ => PlayStatus::Stopped,
|
||||
};
|
||||
out.push(proto::SessionInfo {
|
||||
is_current: key == current_key,
|
||||
session_id: key,
|
||||
source_app: friendly_name(&aumid, name_cache),
|
||||
title,
|
||||
artist,
|
||||
status,
|
||||
is_thing: proto::is_thing_aumid(&aumid),
|
||||
});
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// 目标会话的三个事件订阅(P1 §7:随目标切换退订/换绑,唤醒聚合循环)。
|
||||
struct SessionSubs {
|
||||
session: GsSession,
|
||||
tokens: Vec<(SubKind, windows::Foundation::EventRegistrationToken)>,
|
||||
}
|
||||
|
||||
enum SubKind {
|
||||
Props,
|
||||
Timeline,
|
||||
Info,
|
||||
}
|
||||
|
||||
impl SessionSubs {
|
||||
fn subscribe(sess: &GsSession, tx: &Sender<MonitorMsg>) -> Self {
|
||||
let mut tokens = Vec::new();
|
||||
// 三个事件的 args 类型各不相同,逐个构造 handler(不能复用闭包)
|
||||
{
|
||||
let t = tx.clone();
|
||||
let h = TypedEventHandler::<GsSession, MediaPropertiesChangedEventArgs>::new(
|
||||
move |_, _| {
|
||||
let _ = t.send(MonitorMsg::Change);
|
||||
Ok(())
|
||||
},
|
||||
);
|
||||
if let Ok(tok) = sess.MediaPropertiesChanged(&h) {
|
||||
tokens.push((SubKind::Props, tok));
|
||||
}
|
||||
}
|
||||
{
|
||||
let t = tx.clone();
|
||||
let h = TypedEventHandler::<GsSession, TimelinePropertiesChangedEventArgs>::new(
|
||||
move |_, _| {
|
||||
let _ = t.send(MonitorMsg::Change);
|
||||
Ok(())
|
||||
},
|
||||
);
|
||||
if let Ok(tok) = sess.TimelinePropertiesChanged(&h) {
|
||||
tokens.push((SubKind::Timeline, tok));
|
||||
}
|
||||
}
|
||||
{
|
||||
let t = tx.clone();
|
||||
let h = TypedEventHandler::<GsSession, PlaybackInfoChangedEventArgs>::new(
|
||||
move |_, _| {
|
||||
let _ = t.send(MonitorMsg::Change);
|
||||
Ok(())
|
||||
},
|
||||
);
|
||||
if let Ok(tok) = sess.PlaybackInfoChanged(&h) {
|
||||
tokens.push((SubKind::Info, tok));
|
||||
}
|
||||
}
|
||||
Self {
|
||||
session: sess.clone(),
|
||||
tokens,
|
||||
}
|
||||
}
|
||||
|
||||
fn remove_all(self) {
|
||||
for (kind, tok) in self.tokens {
|
||||
let r = match kind {
|
||||
SubKind::Props => self.session.RemoveMediaPropertiesChanged(tok),
|
||||
SubKind::Timeline => self.session.RemoveTimelinePropertiesChanged(tok),
|
||||
SubKind::Info => self.session.RemovePlaybackInfoChanged(tok),
|
||||
};
|
||||
if let Err(e) = r {
|
||||
crate::logger::log_warn("music-remote", &format!("退订会话事件失败: {e}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// AUMID → 显示名:注册表友好名(`HKCU\\Software\\Classes\\AppUserModelId\\<aumid>`)
|
||||
/// 缓存优先,查不到退回 AUMID 简化段(§6.7 P1)。
|
||||
fn friendly_name(aumid: &str, cache: &mut HashMap<String, String>) -> String {
|
||||
if let Some(v) = cache.get(aumid) {
|
||||
return v.clone();
|
||||
}
|
||||
let name = if proto::is_thing_aumid(aumid) {
|
||||
"Thing".to_string()
|
||||
} else {
|
||||
registry_display_name(aumid).unwrap_or_else(|| proto::source_display(aumid))
|
||||
};
|
||||
if cache.len() > 128 {
|
||||
cache.clear();
|
||||
}
|
||||
cache.insert(aumid.to_string(), name.clone());
|
||||
name
|
||||
}
|
||||
|
||||
fn registry_display_name(aumid: &str) -> Option<String> {
|
||||
// 路径形 AUMID(含反斜杠)无法作注册表单键名;空串跳过
|
||||
if aumid.is_empty() || aumid.contains('\\') {
|
||||
return None;
|
||||
}
|
||||
use winreg::RegKey;
|
||||
use winreg::enums::HKEY_CURRENT_USER;
|
||||
let key = RegKey::predef(HKEY_CURRENT_USER)
|
||||
.open_subkey(format!(r"Software\Classes\AppUserModelId\{aumid}"))
|
||||
.ok()?;
|
||||
key.get_value::<String, _>("DisplayName")
|
||||
.ok()
|
||||
.filter(|s| !s.trim().is_empty())
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 控制(server 在 spawn_blocking 里调用)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// 对指定会话执行控制动作(§3.1:统一走 GSMTC `Try*Async`)。
|
||||
///
|
||||
/// **阻塞**(`.get()` 等待 WinRT async):调用方必须在 `spawn_blocking` / 专用线程。
|
||||
/// `session_id` 为 [`proto::NowPlaying::session_id`](控制"手机上正在显示的那条")。
|
||||
pub fn control(session_id: &str, action: CmdAction, args: Option<CmdArgs>) -> Result<(), String> {
|
||||
let manager = GsManager::RequestAsync()
|
||||
.and_then(|op| op.get())
|
||||
.map_err(|e| format!("GSMTC 不可用: {e}"))?;
|
||||
let session = find_session(&manager, session_id)?;
|
||||
|
||||
// toggle 需要先读当前状态
|
||||
let playing = matches!(
|
||||
session.GetPlaybackInfo().and_then(|i| i.PlaybackStatus()),
|
||||
Ok(GsStatus::Playing)
|
||||
);
|
||||
|
||||
let op = match action {
|
||||
CmdAction::Play => session.TryPlayAsync().map_err(err_of)?,
|
||||
CmdAction::Pause => session.TryPauseAsync().map_err(err_of)?,
|
||||
CmdAction::Toggle => {
|
||||
if playing {
|
||||
session.TryPauseAsync().map_err(err_of)?
|
||||
} else {
|
||||
session.TryPlayAsync().map_err(err_of)?
|
||||
}
|
||||
}
|
||||
CmdAction::Next => session.TrySkipNextAsync().map_err(err_of)?,
|
||||
CmdAction::Prev => session.TrySkipPreviousAsync().map_err(err_of)?,
|
||||
CmdAction::Stop => session.TryStopAsync().map_err(err_of)?,
|
||||
CmdAction::Seek => {
|
||||
let pos = args
|
||||
.as_ref()
|
||||
.map(|a| a.pos_sec)
|
||||
.ok_or_else(|| "seek 缺少 args.posSec".to_string())?;
|
||||
let v = if pos.is_finite() && pos > 0.0 {
|
||||
pos
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
// WinRT 签名是 INT64(100ns ticks),不是 TimeSpan
|
||||
session
|
||||
.TryChangePlaybackPositionAsync((v * TICKS_PER_SEC as f64) as i64)
|
||||
.map_err(err_of)?
|
||||
}
|
||||
// Volume/Select/Jump 由 server 直接处理(音量走 IAudioEndpointVolume、选中走 Thing 侧覆盖、
|
||||
// 选歌走前端事件链),不会路由到这里;列全仅为 match 穷尽
|
||||
CmdAction::Volume | CmdAction::Select | CmdAction::Jump => {
|
||||
return Err("volume/select/jump 不走 GSMTC 控制路径".into())
|
||||
}
|
||||
};
|
||||
// 阻塞等待完成(语义 = 指令已派发,§4.2 cmd-ack)
|
||||
let _ = op.get().map_err(err_of)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn err_of<E: std::fmt::Display>(e: E) -> String {
|
||||
format!("{e}")
|
||||
}
|
||||
|
||||
/// 按 sessionId 找会话(`thing.self` → AUMID 匹配;否则 AUMID 全等;回退 current)。
|
||||
fn find_session(manager: &GsManager, session_id: &str) -> Result<GsSession, String> {
|
||||
let sessions = manager.GetSessions().map_err(err_of)?;
|
||||
let n = sessions.Size().map_err(err_of)?;
|
||||
for i in 0..n {
|
||||
let s = sessions.GetAt(i).map_err(err_of)?;
|
||||
let aumid = s
|
||||
.SourceAppUserModelId()
|
||||
.map(|h| h.to_string())
|
||||
.unwrap_or_default();
|
||||
if proto::session_key(&aumid) == session_id {
|
||||
return Ok(s);
|
||||
}
|
||||
}
|
||||
manager
|
||||
.GetCurrentSession()
|
||||
.map_err(|_| format!("目标会话不存在: {session_id}"))
|
||||
}
|
||||
@@ -0,0 +1,756 @@
|
||||
//! 手机遥控子系统(MUSIC_REMOTE_PLAN §5.1)。
|
||||
//!
|
||||
//! [RemoteManager] 是本子系统的唯一状态容器(**平级 manage**,不塞进 MusicManager,
|
||||
//! 见计划 §5.1):服务生命周期、配对会话、封面缓存、鉴权限速、在线设备、
|
||||
//! 聚合状态(`watch<NowPlaying>`)。
|
||||
//!
|
||||
//! | 文件 | 职责 |
|
||||
//! |---|---|
|
||||
//! | [`proto`] | NowPlaying / WS 消息类型(§4)+ 单测 |
|
||||
//! | [`discovery`] | UDP beacon(§3.3,含各网卡定向广播) |
|
||||
//! | [`pairing`] | 配对码、设备表、token、限速(§3.4) |
|
||||
//! | [`glsmtc`] | GSMTC 监视/聚合/封面 LRU/节流 + Try*Async 控制(§3.1) |
|
||||
//! | [`server`] | axum HTTP+WS、鉴权、广播、心跳(§3.2 / §4.2) |
|
||||
//!
|
||||
//! 设置字段(`MusicSettings`,settings.json):`remote_enabled` / `remote_port` /
|
||||
//! `remote_device_id` / `remote_devices`——设备**元数据**落 settings,**token** 入
|
||||
//! 系统凭据管理器(键名 `music-remote-token-{id}`,§3.4-3)。
|
||||
|
||||
mod discovery;
|
||||
mod glsmtc;
|
||||
mod pairing;
|
||||
mod proto;
|
||||
mod server;
|
||||
mod volume;
|
||||
|
||||
pub use pairing::RemoteDeviceMeta;
|
||||
pub use proto::{NowPlaying, PROTO_VER};
|
||||
|
||||
/// 手机选歌 → 前端播放器的事件名(载荷 = 队列绝对下标)。
|
||||
pub const REMOTE_JUMP_EVENT: &str = "music-remote-jump";
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::hash::{Hash, Hasher};
|
||||
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::thread::JoinHandle;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
use tauri::{AppHandle, Manager};
|
||||
use tokio::sync::watch;
|
||||
|
||||
use discovery::BeaconPayload;
|
||||
use glsmtc::GsmtcMonitor;
|
||||
use pairing::PairingSession;
|
||||
|
||||
use super::MusicManager;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 封面缓存(§6.2:内存 LRU,上限 ~20 张;/cover/:hash 由此供给)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
struct CoverEntry {
|
||||
bytes: Vec<u8>,
|
||||
seq: u64,
|
||||
}
|
||||
|
||||
/// 封面字节 LRU(内容哈希为键;seq 兼作 LRU 计数)。
|
||||
/// P1 §7:写透到磁盘目录(`{app_data}/remote_covers`),Thing 重启后手机仍能拉到封面。
|
||||
pub struct CoverStore {
|
||||
map: Mutex<HashMap<String, CoverEntry>>,
|
||||
seq: AtomicU64,
|
||||
/// 磁盘目录(None = 仅内存;start() 时 attach)
|
||||
dir: Mutex<Option<std::path::PathBuf>>,
|
||||
}
|
||||
|
||||
impl CoverStore {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
map: Mutex::new(HashMap::new()),
|
||||
seq: AtomicU64::new(0),
|
||||
dir: Mutex::new(None),
|
||||
}
|
||||
}
|
||||
|
||||
/// 挂载持久化目录(服务启动时调用;创建目录,失败只记日志)。
|
||||
pub fn attach_dir(&self, dir: std::path::PathBuf) {
|
||||
if let Err(e) = std::fs::create_dir_all(&dir) {
|
||||
crate::logger::log_warn(
|
||||
"music-remote",
|
||||
&format!("封面持久化目录创建失败(仅内存缓存): {e}"),
|
||||
);
|
||||
return;
|
||||
}
|
||||
if let Ok(mut g) = self.dir.lock() {
|
||||
*g = Some(dir);
|
||||
}
|
||||
}
|
||||
|
||||
fn dir_opt(&self) -> Option<std::path::PathBuf> {
|
||||
self.dir.lock().ok().and_then(|g| g.clone())
|
||||
}
|
||||
|
||||
/// 存入封面,返回内容哈希(同内容同哈希);超限淘汰最旧。
|
||||
pub fn put(&self, bytes: &[u8]) -> Option<String> {
|
||||
if bytes.is_empty() || bytes.len() > 10 * 1024 * 1024 {
|
||||
return None;
|
||||
}
|
||||
let mut hasher = std::collections::hash_map::DefaultHasher::new();
|
||||
bytes.hash(&mut hasher);
|
||||
let hash = format!("{:016x}", hasher.finish());
|
||||
|
||||
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
|
||||
map.insert(
|
||||
hash.clone(),
|
||||
CoverEntry {
|
||||
bytes: bytes.to_vec(),
|
||||
seq: self.seq.fetch_add(1, Ordering::Relaxed),
|
||||
},
|
||||
);
|
||||
while map.len() > 20 {
|
||||
let oldest = map
|
||||
.iter()
|
||||
.min_by_key(|(_, e)| e.seq)
|
||||
.map(|(k, _)| k.clone());
|
||||
match oldest {
|
||||
Some(k) => {
|
||||
map.remove(&k);
|
||||
}
|
||||
None => break,
|
||||
}
|
||||
}
|
||||
drop(map);
|
||||
// 写透磁盘(尽力而为;失败不影响内存路径)
|
||||
if let Some(dir) = self.dir_opt() {
|
||||
let path = dir.join(format!("{hash}.img"));
|
||||
if std::fs::write(&path, bytes).is_ok() {
|
||||
// 目录同样限 20 张:按修改时间淘汰最旧
|
||||
if let Ok(rd) = std::fs::read_dir(&dir) {
|
||||
let mut files: Vec<(std::time::SystemTime, std::path::PathBuf)> = rd
|
||||
.flatten()
|
||||
.filter_map(|e| {
|
||||
let p = e.path();
|
||||
if p.extension().and_then(|x| x.to_str()) != Some("img") {
|
||||
return None;
|
||||
}
|
||||
let t = e.metadata().ok()?.modified().ok()?;
|
||||
Some((t, p))
|
||||
})
|
||||
.collect();
|
||||
if files.len() > 20 {
|
||||
files.sort_by_key(|(t, _)| *t);
|
||||
for (_, p) in files.iter().take(files.len() - 20) {
|
||||
let _ = std::fs::remove_file(p);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(hash)
|
||||
}
|
||||
|
||||
/// 读取(内存 → 磁盘回源;命中即刷新 LRU 序号)。
|
||||
pub fn get(&self, hash: &str) -> Option<Vec<u8>> {
|
||||
{
|
||||
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
|
||||
if let Some(entry) = map.get_mut(hash) {
|
||||
entry.seq = seq;
|
||||
return Some(entry.bytes.clone());
|
||||
}
|
||||
}
|
||||
// 磁盘回源(Thing 重启 / 冷缓存)
|
||||
let dir = self.dir_opt()?;
|
||||
let bytes = std::fs::read(dir.join(format!("{hash}.img"))).ok()?;
|
||||
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
|
||||
map.insert(
|
||||
hash.to_string(),
|
||||
CoverEntry {
|
||||
bytes: bytes.clone(),
|
||||
seq: self.seq.fetch_add(1, Ordering::Relaxed),
|
||||
},
|
||||
);
|
||||
while map.len() > 20 {
|
||||
let oldest = map
|
||||
.iter()
|
||||
.min_by_key(|(_, e)| e.seq)
|
||||
.map(|(k, _)| k.clone());
|
||||
match oldest {
|
||||
Some(k) => {
|
||||
map.remove(&k);
|
||||
}
|
||||
None => break,
|
||||
}
|
||||
}
|
||||
Some(bytes)
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for CoverStore {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 对外状态视图(命令返回值)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// 远程配置(§5.1 命令 `remote_get_config` / `remote_set_enabled`)。
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RemoteConfig {
|
||||
/// 开关(持久化)
|
||||
pub enabled: bool,
|
||||
/// 期望端口(0 = 默认 26124 起自动探测)
|
||||
pub port: u16,
|
||||
/// 服务是否在运行
|
||||
pub running: bool,
|
||||
/// 实际监听端口(未运行为 0)
|
||||
pub running_port: u16,
|
||||
/// 本机标识(beacon / NowPlaying.deviceId 同源)
|
||||
pub device_id: String,
|
||||
}
|
||||
|
||||
/// 进行中的配对信息(二维码 payload 见计划 §3.3 扫码行)。
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RemotePairingInfo {
|
||||
pub code: String,
|
||||
/// `thingmusic://connect?ip=…&port=…&code=…`
|
||||
pub qr_payload: String,
|
||||
pub seconds_left: u64,
|
||||
}
|
||||
|
||||
/// 设备视图(settings 元数据 + 在线态)。
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RemoteDeviceView {
|
||||
pub id: String,
|
||||
pub name: String,
|
||||
pub last_connected_ms: i64,
|
||||
pub online: bool,
|
||||
}
|
||||
|
||||
/// 服务状态(`remote_status`)。
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RemoteStatus {
|
||||
pub running: bool,
|
||||
pub port: u16,
|
||||
pub online: Vec<RemoteDeviceView>,
|
||||
pub pairing: Option<RemotePairingInfo>,
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// RemoteManager
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// 服务内部状态(start/stop 独占)。
|
||||
struct Inner {
|
||||
running: bool,
|
||||
port: u16,
|
||||
server_task: Option<tokio::task::JoinHandle<()>>,
|
||||
beacon_stop: Option<Arc<AtomicBool>>,
|
||||
beacon_handle: Option<JoinHandle<()>>,
|
||||
pairing: Option<PairingSession>,
|
||||
}
|
||||
|
||||
impl Default for Inner {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
running: false,
|
||||
port: 0,
|
||||
server_task: None,
|
||||
beacon_stop: None,
|
||||
beacon_handle: None,
|
||||
pairing: None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct RemoteManager {
|
||||
/// 聚合状态(监视线程写、WS/REST 读)
|
||||
pub(crate) state_tx: Arc<watch::Sender<NowPlaying>>,
|
||||
/// 会话列表(P1 多会话切换;监视线程写、WS 读)
|
||||
pub(crate) sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
|
||||
/// Thing 本机播放队列(前端 `remote_publish_queue` 写、WS 读)
|
||||
pub(crate) queue_tx: Arc<watch::Sender<proto::QueueSnapshot>>,
|
||||
/// 手机选中的目标会话覆盖(None = 跟随系统 current;WinRT 无 SetCurrentSession)
|
||||
pub(crate) selected: Arc<Mutex<Option<String>>>,
|
||||
/// 封面 LRU(glsmtc 写、/cover 读)
|
||||
pub(crate) covers: Arc<CoverStore>,
|
||||
/// hello / /pair 限速(§3.4-4)
|
||||
pub(crate) auth: Arc<pairing::FailTracker>,
|
||||
/// GSMTC 是否可用(false → 控制走前端事件链兜底,§5.2)
|
||||
pub(crate) gsmtc_ok: Arc<AtomicBool>,
|
||||
/// 服务停止信号(每个 WS 连接订阅一份)
|
||||
shutdown_tx: watch::Sender<bool>,
|
||||
online: Mutex<std::collections::HashSet<String>>,
|
||||
monitor: Mutex<Option<GsmtcMonitor>>,
|
||||
inner: Mutex<Inner>,
|
||||
}
|
||||
|
||||
impl RemoteManager {
|
||||
pub fn new() -> Self {
|
||||
let (state_tx, _) = watch::channel(NowPlaying::default());
|
||||
let (sessions_tx, _) = watch::channel(Vec::new());
|
||||
let (queue_tx, _) = watch::channel(proto::QueueSnapshot::default());
|
||||
let (shutdown_tx, _) = watch::channel(false);
|
||||
Self {
|
||||
state_tx: Arc::new(state_tx),
|
||||
sessions_tx: Arc::new(sessions_tx),
|
||||
queue_tx: Arc::new(queue_tx),
|
||||
selected: Arc::new(Mutex::new(None)),
|
||||
covers: Arc::new(CoverStore::new()),
|
||||
auth: Arc::new(pairing::FailTracker::default()),
|
||||
gsmtc_ok: Arc::new(AtomicBool::new(false)),
|
||||
shutdown_tx,
|
||||
online: Mutex::new(std::collections::HashSet::new()),
|
||||
monitor: Mutex::new(None),
|
||||
inner: Mutex::new(Inner::default()),
|
||||
}
|
||||
}
|
||||
|
||||
/// 当前聚合状态快照。
|
||||
pub fn now_playing(&self) -> NowPlaying {
|
||||
self.state_tx.borrow().clone()
|
||||
}
|
||||
|
||||
/// 会话列表快照(WS 连接建立时下发)。
|
||||
pub fn sessions_snapshot(&self) -> Vec<proto::SessionInfo> {
|
||||
self.sessions_tx.borrow().clone()
|
||||
}
|
||||
|
||||
/// 订阅会话列表变更(每个 WS 连接一份)。
|
||||
pub fn sessions_rx(&self) -> watch::Receiver<Vec<proto::SessionInfo>> {
|
||||
self.sessions_tx.subscribe()
|
||||
}
|
||||
|
||||
/// 队列快照(WS 连接建立时下发;Thing 本机播放的队列)。
|
||||
pub fn queue_snapshot(&self) -> proto::QueueSnapshot {
|
||||
self.queue_tx.borrow().clone()
|
||||
}
|
||||
|
||||
/// 订阅队列变更(每个 WS 连接一份)。
|
||||
pub fn queue_rx(&self) -> watch::Receiver<proto::QueueSnapshot> {
|
||||
self.queue_tx.subscribe()
|
||||
}
|
||||
|
||||
/// 前端发布队列快照;内容没变时不推送(避免播放中反复触发 WS 帧)。
|
||||
pub fn set_queue(&self, snapshot: proto::QueueSnapshot) {
|
||||
let unchanged = *self.queue_tx.borrow() == snapshot;
|
||||
if unchanged {
|
||||
return;
|
||||
}
|
||||
self.queue_tx.send_replace(snapshot);
|
||||
}
|
||||
|
||||
/// 设置目标会话覆盖;空串 = 清除(跟随系统 current)。P1 多会话切换。
|
||||
pub fn set_selected(&self, session_id: &str) {
|
||||
let mut g = self.selected.lock().unwrap_or_else(|e| e.into_inner());
|
||||
*g = if session_id.trim().is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(session_id.to_string())
|
||||
};
|
||||
}
|
||||
|
||||
/// cmd 后立即推一帧(§6.3 例外)。
|
||||
pub fn notify_state_force(&self) {
|
||||
let guard = self.monitor.lock().unwrap_or_else(|e| e.into_inner());
|
||||
if let Some(m) = guard.as_ref() {
|
||||
m.notify_force();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_running(&self) -> bool {
|
||||
self.inner
|
||||
.lock()
|
||||
.map(|g| g.running)
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
pub fn running_port(&self) -> u16 {
|
||||
self.inner.lock().map(|g| g.port).unwrap_or(0)
|
||||
}
|
||||
|
||||
pub fn shutdown_rx(&self) -> watch::Receiver<bool> {
|
||||
self.shutdown_tx.subscribe()
|
||||
}
|
||||
|
||||
pub fn mark_online(&self, id: &str, on: bool) {
|
||||
if let Ok(mut set) = self.online.lock() {
|
||||
if on {
|
||||
set.insert(id.to_string());
|
||||
} else {
|
||||
set.remove(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn online_ids(&self) -> std::collections::HashSet<String> {
|
||||
self.online
|
||||
.lock()
|
||||
.map(|s| s.clone())
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
// ---------- 配对(§3.4) ----------
|
||||
|
||||
/// 开始配对:生成 6 位码(5 分钟有效、一次性)。服务未运行时拒绝(二维码需要端口)。
|
||||
pub fn start_pairing(&self) -> Result<RemotePairingInfo, String> {
|
||||
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
if !inner.running {
|
||||
return Err("远程服务未启动,请先开启「手机互联」".into());
|
||||
}
|
||||
let session = PairingSession::generate();
|
||||
// 联调辅助:配对码写入本地日志(屏幕同样可见;日志仅本机)
|
||||
crate::logger::log_info(
|
||||
"music-remote",
|
||||
format!("配对码已生成: {}(5 分钟内有效)", session.code).as_str(),
|
||||
);
|
||||
let info = Self::pairing_info_of(&session, inner.port);
|
||||
inner.pairing = Some(session);
|
||||
Ok(info)
|
||||
}
|
||||
|
||||
pub fn cancel_pairing(&self) {
|
||||
if let Ok(mut inner) = self.inner.lock() {
|
||||
inner.pairing = None;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn pairing_info(&self) -> Option<RemotePairingInfo> {
|
||||
let inner = self.inner.lock().ok()?;
|
||||
let s = inner.pairing.as_ref()?;
|
||||
if s.is_expired() {
|
||||
return None;
|
||||
}
|
||||
Some(Self::pairing_info_of(s, inner.port))
|
||||
}
|
||||
|
||||
fn pairing_info_of(s: &PairingSession, port: u16) -> RemotePairingInfo {
|
||||
let ip = discovery::primary_ipv4()
|
||||
.map(|i| i.to_string())
|
||||
.unwrap_or_default();
|
||||
RemotePairingInfo {
|
||||
code: s.code.clone(),
|
||||
qr_payload: format!("thingmusic://connect?ip={ip}&port={port}&code={}", s.code),
|
||||
seconds_left: s.seconds_left(),
|
||||
}
|
||||
}
|
||||
|
||||
/// 校验并消费配对码(一次性);成功返回 Ok 并清除会话。
|
||||
pub fn take_pairing_if_match(&self, code: &str) -> Result<(), String> {
|
||||
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let s = inner
|
||||
.pairing
|
||||
.as_ref()
|
||||
.ok_or_else(|| "没有进行中的配对,请先在电脑上点「连接手机」".to_string())?;
|
||||
if s.is_expired() {
|
||||
inner.pairing = None;
|
||||
return Err("配对码已过期(5 分钟),请重新生成".into());
|
||||
}
|
||||
if s.code != code.trim() {
|
||||
return Err("配对码不正确".into());
|
||||
}
|
||||
inner.pairing = None; // 一次性
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// ---------- 生命周期(§5.4) ----------
|
||||
|
||||
/// 启动:探测端口 → axum serve → beacon → GSMTC 监视。
|
||||
pub async fn start(&self, app: &AppHandle) -> Result<(), String> {
|
||||
{
|
||||
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
if inner.running {
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
|
||||
// 本机标识:首次生成后持久化(beacon / NowPlaying 同源)
|
||||
let music = app.state::<MusicManager>();
|
||||
let mut settings = music.load_settings();
|
||||
if settings.remote_device_id.trim().is_empty() {
|
||||
settings.remote_device_id = pairing::random_device_id();
|
||||
music.save_settings(&settings)?;
|
||||
}
|
||||
|
||||
// 1) HTTP+WS 服务(端口探测 26124..26139)
|
||||
let (port, server_task) = server::start(app.clone(), settings.remote_port).await?;
|
||||
self.shutdown_tx.send_replace(false);
|
||||
|
||||
// 2) UDP beacon(3s;各网卡定向广播)
|
||||
let payload = BeaconPayload {
|
||||
service: "thing-music",
|
||||
device_id: settings.remote_device_id.clone(),
|
||||
name: std::env::var("COMPUTERNAME").unwrap_or_else(|_| "Thing".to_string()),
|
||||
port,
|
||||
proto_ver: PROTO_VER,
|
||||
addrs: discovery::ipv4_broadcast_pairs()
|
||||
.into_iter()
|
||||
.map(|(ip, _)| ip.to_string())
|
||||
.collect(),
|
||||
};
|
||||
let beacon_stop = Arc::new(AtomicBool::new(false));
|
||||
let beacon_handle = discovery::spawn_beacon(payload, beacon_stop.clone());
|
||||
|
||||
// 封面持久化目录(P1 §7:重启后冷缓存可回源)
|
||||
if let Ok(dir) = app.path().app_data_dir() {
|
||||
self.covers.attach_dir(dir.join("remote_covers"));
|
||||
}
|
||||
|
||||
// 3) GSMTC 监视(聚合/节流/封面/音量/会话事件;失败自动兜底,§3.1 失败策略)
|
||||
let monitor = GsmtcMonitor::start(
|
||||
app.clone(),
|
||||
self.state_tx.clone(),
|
||||
self.covers.clone(),
|
||||
self.gsmtc_ok.clone(),
|
||||
self.sessions_tx.clone(),
|
||||
self.selected.clone(),
|
||||
);
|
||||
|
||||
{
|
||||
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
inner.running = true;
|
||||
inner.port = port;
|
||||
inner.server_task = Some(server_task);
|
||||
inner.beacon_stop = Some(beacon_stop);
|
||||
inner.beacon_handle = Some(beacon_handle);
|
||||
inner.pairing = None;
|
||||
}
|
||||
*self.monitor.lock().unwrap_or_else(|e| e.into_inner()) = Some(monitor);
|
||||
|
||||
crate::logger::log_info(
|
||||
"music-remote",
|
||||
format!("手机互联已启动: ws://0.0.0.0:{port}(beacon :26123)").as_str(),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 停止:abort serve → 停 beacon → 停监视线程 → 清在线/配对。
|
||||
pub fn stop(&self) {
|
||||
let (server_task, beacon_stop, beacon_handle) = {
|
||||
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
if !inner.running {
|
||||
return;
|
||||
}
|
||||
inner.running = false;
|
||||
inner.port = 0;
|
||||
inner.pairing = None;
|
||||
(
|
||||
inner.server_task.take(),
|
||||
inner.beacon_stop.take(),
|
||||
inner.beacon_handle.take(),
|
||||
)
|
||||
};
|
||||
// 停止信号:在途 WS 连接退出(§5.4 graceful;serve 直接 abort,手机端走重连)
|
||||
self.shutdown_tx.send_replace(true);
|
||||
if let Some(t) = server_task {
|
||||
t.abort();
|
||||
}
|
||||
if let Some(stop) = beacon_stop {
|
||||
stop.store(true, Ordering::Relaxed);
|
||||
}
|
||||
if let Some(h) = beacon_handle {
|
||||
let _ = h.join(); // beacon 循环 ≤100ms 检查一次退出标志
|
||||
}
|
||||
let monitor = {
|
||||
let mut guard = self.monitor.lock().unwrap_or_else(|e| e.into_inner());
|
||||
guard.take()
|
||||
};
|
||||
if let Some(m) = monitor {
|
||||
m.stop();
|
||||
}
|
||||
if let Ok(mut set) = self.online.lock() {
|
||||
set.clear();
|
||||
}
|
||||
if let Ok(mut sel) = self.selected.lock() {
|
||||
sel.take();
|
||||
}
|
||||
self.gsmtc_ok.store(false, Ordering::Relaxed);
|
||||
crate::logger::log_info("music-remote", "手机互联已停止");
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for RemoteManager {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 启动钩子(setup.rs 调用)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// 随应用启动:`remote_enabled = true` 时自动拉起服务(§5.4)。
|
||||
pub fn init_on_launch(app: &AppHandle) {
|
||||
let enabled = app
|
||||
.try_state::<MusicManager>()
|
||||
.map(|m| m.load_settings().remote_enabled)
|
||||
.unwrap_or(false);
|
||||
if !enabled {
|
||||
return;
|
||||
}
|
||||
let app = app.clone();
|
||||
tauri::async_runtime::spawn(async move {
|
||||
let remote = app.state::<RemoteManager>();
|
||||
if let Err(e) = remote.start(&app).await {
|
||||
crate::logger::log_error(
|
||||
"music-remote",
|
||||
&format!("开机自启手机互联失败: {e}"),
|
||||
);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Tauri 命令(§5.1 命令表)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn remote_get_config(app: AppHandle) -> RemoteConfig {
|
||||
let music = app.state::<MusicManager>();
|
||||
let s = music.load_settings();
|
||||
let remote = app.state::<RemoteManager>();
|
||||
RemoteConfig {
|
||||
enabled: s.remote_enabled,
|
||||
port: s.remote_port,
|
||||
running: remote.is_running(),
|
||||
running_port: remote.running_port(),
|
||||
device_id: s.remote_device_id,
|
||||
}
|
||||
}
|
||||
|
||||
/// 开关(即时生效,§5.1)。
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub async fn remote_set_enabled(app: AppHandle, enabled: bool) -> Result<RemoteConfig, String> {
|
||||
let music = app.state::<MusicManager>();
|
||||
let mut s = music.load_settings();
|
||||
s.remote_enabled = enabled;
|
||||
music.save_settings(&s)?;
|
||||
|
||||
let remote = app.state::<RemoteManager>();
|
||||
if enabled {
|
||||
if let Err(e) = remote.start(&app).await {
|
||||
// 启动失败:保留开关意图(下次启动重试),但如实上报未运行
|
||||
crate::logger::log_error("music-remote", &format!("启动失败: {e}"));
|
||||
return Err(e);
|
||||
}
|
||||
} else {
|
||||
remote.stop();
|
||||
}
|
||||
Ok(RemoteConfig {
|
||||
enabled,
|
||||
port: s.remote_port,
|
||||
running: remote.is_running(),
|
||||
running_port: remote.running_port(),
|
||||
device_id: s.remote_device_id,
|
||||
})
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn remote_status(app: AppHandle) -> RemoteStatus {
|
||||
let remote = app.state::<RemoteManager>();
|
||||
let music = app.state::<MusicManager>();
|
||||
let s = music.load_settings();
|
||||
let online = remote.online_ids();
|
||||
RemoteStatus {
|
||||
running: remote.is_running(),
|
||||
port: remote.running_port(),
|
||||
online: s
|
||||
.remote_devices
|
||||
.iter()
|
||||
.filter(|d| online.contains(&d.id))
|
||||
.map(|d| RemoteDeviceView {
|
||||
id: d.id.clone(),
|
||||
name: d.name.clone(),
|
||||
last_connected_ms: d.last_connected_ms,
|
||||
online: true,
|
||||
})
|
||||
.collect(),
|
||||
pairing: remote.pairing_info(),
|
||||
}
|
||||
}
|
||||
|
||||
/// 生成配对码 + 二维码 payload(前端 `qrcode` 渲染,§5.3)。
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn remote_start_pairing(app: AppHandle) -> Result<RemotePairingInfo, String> {
|
||||
app.state::<RemoteManager>().start_pairing()
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn remote_cancel_pairing(app: AppHandle) {
|
||||
app.state::<RemoteManager>().cancel_pairing();
|
||||
}
|
||||
|
||||
/// 设备列表(元数据 + 在线态;token 永不出现在这里)。
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn remote_list_devices(app: AppHandle) -> Vec<RemoteDeviceView> {
|
||||
let music = app.state::<MusicManager>();
|
||||
let s = music.load_settings();
|
||||
let remote = app.state::<RemoteManager>();
|
||||
let online = remote.online_ids();
|
||||
s.remote_devices
|
||||
.into_iter()
|
||||
.map(|d| RemoteDeviceView {
|
||||
online: online.contains(&d.id),
|
||||
id: d.id,
|
||||
name: d.name,
|
||||
last_connected_ms: d.last_connected_ms,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// 吊销设备(删表 + 删凭据;已建立的 WS 在下次重连时被拒)。
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn remote_revoke_device(app: AppHandle, id: String) -> Result<(), String> {
|
||||
let music = app.state::<MusicManager>();
|
||||
let mut s = music.load_settings();
|
||||
s.remote_devices.retain(|d| d.id != id);
|
||||
music.save_settings(&s)?;
|
||||
crate::secrets::secret_delete(&pairing::token_key(&id))?;
|
||||
let remote = app.state::<RemoteManager>();
|
||||
remote.mark_online(&id, false);
|
||||
crate::logger::log_info("music-remote", format!("已吊销设备 {id}").as_str());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 前端发布 Thing 本机播放队列(手机端「播放队列 / 选歌」的数据源)。
|
||||
///
|
||||
/// 队列活在前端 store(feiniuStore),Rust 只做快照转发;`items` 允许是完整队列
|
||||
/// 的一段(见 [`proto::QueueItem::index`]),`total` 恒为完整长度。
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn remote_publish_queue(
|
||||
app: AppHandle,
|
||||
items: Vec<proto::QueueItem>,
|
||||
index: i64,
|
||||
total: i64,
|
||||
) {
|
||||
crate::logger::log_info(
|
||||
"music-remote",
|
||||
&format!(
|
||||
"遥控队列更新: 本次 {} 条 / 共 {} 条,当前第 {} 条",
|
||||
items.len(),
|
||||
total,
|
||||
index
|
||||
),
|
||||
);
|
||||
app.state::<RemoteManager>()
|
||||
.set_queue(proto::QueueSnapshot {
|
||||
items,
|
||||
index,
|
||||
total: total.max(0),
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
//! 配对与设备表(MUSIC_REMOTE_PLAN §3.4)。
|
||||
//!
|
||||
//! - 配对码:6 位数字,Thing 设置页弹窗展示,**5 分钟有效期、一次性**
|
||||
//! - 设备 token:32 字节随机 hex,入系统凭据管理器(`secrets.rs` 范式,键名
|
||||
//! `music-remote-token-{deviceId}`);设备元数据(id/名/最后连接)落 settings
|
||||
//! - 限速:hello 校验失败 3 次拉黑该 IP 60s;`/pair` 配对码校验同一限速(§3.4-4)
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Mutex;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use rand::Rng;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
|
||||
/// 配对码有效期(§3.4-2)。
|
||||
pub const PAIRING_TTL: Duration = Duration::from_secs(5 * 60);
|
||||
/// 单 IP 失败阈值与拉黑时长(§3.4-4)。
|
||||
const FAIL_LIMIT: u8 = 3;
|
||||
const FAIL_BLOCK: Duration = Duration::from_secs(60);
|
||||
|
||||
/// 设备元数据(settings.json 持久化;**token 不在此**,见键名约定)。
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct RemoteDeviceMeta {
|
||||
pub id: String,
|
||||
pub name: String,
|
||||
/// 最后一次成功连接(Unix 毫秒;0 = 从未连接)
|
||||
#[serde(default)]
|
||||
pub last_connected_ms: i64,
|
||||
}
|
||||
|
||||
/// 进行中的配对会话(同一时刻至多一个)。
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct PairingSession {
|
||||
pub code: String,
|
||||
pub created: Instant,
|
||||
}
|
||||
|
||||
impl PairingSession {
|
||||
pub fn generate() -> Self {
|
||||
let code: u32 = rand::thread_rng().gen_range(0..1_000_000);
|
||||
Self {
|
||||
code: format!("{code:06}"),
|
||||
created: Instant::now(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_expired(&self) -> bool {
|
||||
self.created.elapsed() > PAIRING_TTL
|
||||
}
|
||||
|
||||
/// 剩余秒数(前端倒计时用;已过期返回 0)。
|
||||
pub fn seconds_left(&self) -> u64 {
|
||||
PAIRING_TTL
|
||||
.saturating_sub(self.created.elapsed())
|
||||
.as_secs()
|
||||
}
|
||||
}
|
||||
|
||||
/// 凭据键名:与 `secrets.rs` 的服务名 `Thing` 组合成完整凭据项。
|
||||
pub fn token_key(device_id: &str) -> String {
|
||||
format!("music-remote-token-{device_id}")
|
||||
}
|
||||
|
||||
/// 生成 32 字节随机 hex token(§3.4-3)。
|
||||
pub fn random_token() -> String {
|
||||
let mut buf = [0u8; 32];
|
||||
rand::thread_rng().fill(&mut buf);
|
||||
hex_encode(&buf)
|
||||
}
|
||||
|
||||
/// 生成 16 字节随机 hex 设备 id。
|
||||
pub fn random_device_id() -> String {
|
||||
let mut buf = [0u8; 16];
|
||||
rand::thread_rng().fill(&mut buf);
|
||||
hex_encode(&buf)
|
||||
}
|
||||
|
||||
fn hex_encode(bytes: &[u8]) -> String {
|
||||
bytes.iter().map(|b| format!("{b:02x}")).collect()
|
||||
}
|
||||
|
||||
/// 按 token 找设备:遍历 settings 中的设备 id,逐个读凭据库比对。
|
||||
/// 设备数很少(个位数),O(n) 读可接受;token 不落 settings(§3.4-3)。
|
||||
pub fn device_by_token(
|
||||
devices: &[RemoteDeviceMeta],
|
||||
token: &str,
|
||||
) -> Option<RemoteDeviceMeta> {
|
||||
if token.is_empty() {
|
||||
return None;
|
||||
}
|
||||
for d in devices {
|
||||
let stored = crate::secrets::read_or_empty(&token_key(&d.id));
|
||||
if !stored.is_empty() && stored == token {
|
||||
return Some(d.clone());
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// 单 IP 失败计数 / 拉黑表(hello 与 /pair 共用)。
|
||||
#[derive(Default)]
|
||||
pub struct FailTracker {
|
||||
inner: Mutex<HashMap<String, FailState>>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct FailState {
|
||||
fails: u8,
|
||||
last: Instant,
|
||||
blocked_until: Option<Instant>,
|
||||
}
|
||||
|
||||
impl FailTracker {
|
||||
/// 该 IP 当前是否允许尝试(在拉黑窗口内 → false)。
|
||||
pub fn allowed(&self, ip: &str) -> bool {
|
||||
let map = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
match map.get(ip) {
|
||||
Some(s) => match s.blocked_until {
|
||||
Some(t) => Instant::now() >= t,
|
||||
None => true,
|
||||
},
|
||||
None => true,
|
||||
}
|
||||
}
|
||||
|
||||
/// 记一次失败:累计 3 次拉黑 60s;60s 后的失败重新计数。
|
||||
pub fn fail(&self, ip: &str) {
|
||||
let mut map = self.inner.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let now = Instant::now();
|
||||
let s = map.entry(ip.to_string()).or_insert(FailState {
|
||||
fails: 0,
|
||||
last: now,
|
||||
blocked_until: None,
|
||||
});
|
||||
if let Some(t) = s.blocked_until {
|
||||
if now >= t {
|
||||
s.fails = 0;
|
||||
s.blocked_until = None;
|
||||
}
|
||||
}
|
||||
if now.duration_since(s.last) > FAIL_BLOCK {
|
||||
s.fails = 0;
|
||||
}
|
||||
s.last = now;
|
||||
s.fails += 1;
|
||||
if s.fails >= FAIL_LIMIT {
|
||||
s.blocked_until = Some(now + FAIL_BLOCK);
|
||||
crate::logger::log_warn(
|
||||
"music-remote",
|
||||
&format!("IP {ip} 鉴权失败 {FAIL_LIMIT} 次,拉黑 60s"),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// 成功后清零。
|
||||
pub fn ok(&self, ip: &str) {
|
||||
self.inner
|
||||
.lock()
|
||||
.unwrap_or_else(|e| e.into_inner())
|
||||
.remove(ip);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn pairing_code_format_and_ttl() {
|
||||
let p = PairingSession::generate();
|
||||
assert_eq!(p.code.len(), 6);
|
||||
assert!(p.code.chars().all(|c| c.is_ascii_digit()));
|
||||
assert!(!p.is_expired());
|
||||
assert!(p.seconds_left() <= 300);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fail_tracker_blocks_after_three() {
|
||||
let t = FailTracker::default();
|
||||
assert!(t.allowed("1.2.3.4"));
|
||||
t.fail("1.2.3.4");
|
||||
t.fail("1.2.3.4");
|
||||
assert!(t.allowed("1.2.3.4"));
|
||||
t.fail("1.2.3.4");
|
||||
assert!(!t.allowed("1.2.3.4"));
|
||||
// 其他 IP 不受影响
|
||||
assert!(t.allowed("5.6.7.8"));
|
||||
t.ok("1.2.3.4");
|
||||
assert!(t.allowed("1.2.3.4"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn token_shape() {
|
||||
let t = random_token();
|
||||
assert_eq!(t.len(), 64);
|
||||
assert!(t.chars().all(|c| c.is_ascii_hexdigit()));
|
||||
assert_eq!(random_device_id().len(), 32);
|
||||
assert_eq!(token_key("abc"), "music-remote-token-abc");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,523 @@
|
||||
//! 遥控协议类型(MUSIC_REMOTE_PLAN §4)。
|
||||
//!
|
||||
//! WS 线格式:JSON,`type` 字段判别,字段一律 camelCase。
|
||||
//! 这些类型**不进 specta bindings**——协议对端是手机(LFMusic 在 `remote-proto.ts`
|
||||
//! 手写一份镜像类型),Thing 前端不直接消费 WS;此处只负责 serde 序列化与单测。
|
||||
//! 双端字段一旦改动,必须同步对端文档 §4 与 LFMusic 的镜像类型(计划"复制+注释互指")。
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// 协议版本:不匹配时 `welcome` 带最新版本号,手机端提示升级(§4.2)。
|
||||
pub const PROTO_VER: u32 = 1;
|
||||
|
||||
/// Thing 自身会话的 sessionId(§4.1)。
|
||||
pub const THING_SELF_SESSION: &str = "thing.self";
|
||||
|
||||
/// Thing 自身的 AUMID(与 lib.rs `set_app_user_model_id` 一致)。
|
||||
pub const THING_AUMID: &str = "thing.lfeng.me";
|
||||
|
||||
/// 控制能力位:手机端据此置灰按钮(§4.1)。
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct CanControl {
|
||||
pub play: bool,
|
||||
pub pause: bool,
|
||||
pub next: bool,
|
||||
pub prev: bool,
|
||||
pub seek: bool,
|
||||
}
|
||||
|
||||
/// 播放状态(§4.1 `status`)。
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum PlayStatus {
|
||||
Playing,
|
||||
Paused,
|
||||
Stopped,
|
||||
}
|
||||
|
||||
impl Default for PlayStatus {
|
||||
fn default() -> Self {
|
||||
Self::Stopped
|
||||
}
|
||||
}
|
||||
|
||||
/// 当前播放状态快照:WS `state` 消息的载荷(§4.1)。
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct NowPlaying {
|
||||
/// 会话 key:Thing 自身 = [`THING_SELF_SESSION`],其余为 SourceAppUserModelId
|
||||
pub session_id: String,
|
||||
/// 来源应用显示名(AUMID 简化,友好名映射 P1)
|
||||
pub source_app: String,
|
||||
/// 是否 Thing 自身播放(封面/元数据兜底、seek 直通判定)
|
||||
pub is_thing: bool,
|
||||
pub title: String,
|
||||
pub artist: String,
|
||||
pub album: String,
|
||||
/// 封面缓存键;封面从 `GET /cover/:hash` 拉取
|
||||
pub cover_hash: Option<String>,
|
||||
pub status: PlayStatus,
|
||||
pub duration_sec: f64,
|
||||
/// 推送时刻的播放位置(秒)
|
||||
pub position_sec: f64,
|
||||
/// 电脑时钟毫秒(源自 TimelineProperties.LastUpdatedTime,§6.4)。
|
||||
/// **仅供校准**:手机端 elapsed 一律以本地收包时刻起算(§6.10)
|
||||
pub position_updated_at_ms: i64,
|
||||
pub playback_rate: f64,
|
||||
pub can_control: CanControl,
|
||||
/// 系统主音量(0.0~1.0;None = 音频端点不可用,手机端隐藏音量条)。P1 §7
|
||||
pub volume: Option<f64>,
|
||||
/// 系统主音量静音位
|
||||
pub muted: bool,
|
||||
/// 电脑标识(beacon 同源,多电脑预留)
|
||||
pub device_id: String,
|
||||
}
|
||||
|
||||
impl Default for NowPlaying {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
session_id: String::new(),
|
||||
source_app: String::new(),
|
||||
is_thing: false,
|
||||
title: String::new(),
|
||||
artist: String::new(),
|
||||
album: String::new(),
|
||||
cover_hash: None,
|
||||
status: PlayStatus::Stopped,
|
||||
duration_sec: 0.0,
|
||||
position_sec: 0.0,
|
||||
position_updated_at_ms: 0,
|
||||
playback_rate: 1.0,
|
||||
can_control: CanControl {
|
||||
play: false,
|
||||
pause: false,
|
||||
next: false,
|
||||
prev: false,
|
||||
seek: false,
|
||||
},
|
||||
volume: None,
|
||||
muted: false,
|
||||
device_id: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl NowPlaying {
|
||||
/// 「无播放」快照(§5.2 两者都无:status = stopped,手机显示"电脑未在播放")。
|
||||
pub fn stopped(device_id: &str) -> Self {
|
||||
Self {
|
||||
device_id: device_id.to_string(),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 会话列表条目(P1 §7 多会话切换:手机端可选"控制哪个应用")。
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct SessionInfo {
|
||||
pub session_id: String,
|
||||
pub source_app: String,
|
||||
pub title: String,
|
||||
pub artist: String,
|
||||
pub status: PlayStatus,
|
||||
pub is_thing: bool,
|
||||
/// 是否当前展示/控制目标(Thing 侧选中覆盖;无覆盖时为系统 current)
|
||||
pub is_current: bool,
|
||||
}
|
||||
|
||||
/// 播放队列条目(Thing 专属:本机播放器的队列,手机端可选歌)。
|
||||
///
|
||||
/// `index` 是**在完整队列里的绝对下标**——下发时允许只带当前附近的一段
|
||||
/// (前端最多推 500 条,见 feiniuStore),手机端跳歌直接把 index 回传。
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, specta::Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct QueueItem {
|
||||
pub index: i64,
|
||||
pub title: String,
|
||||
pub artist: String,
|
||||
pub duration_sec: f64,
|
||||
}
|
||||
|
||||
/// 播放队列快照(WS `queue` 消息;`total` 是完整队列长度,可能大于 `items` 条数)。
|
||||
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
|
||||
pub struct QueueSnapshot {
|
||||
pub items: Vec<QueueItem>,
|
||||
/// 当前播放条目在完整队列中的下标(-1 = 未在队列中播放)
|
||||
pub index: i64,
|
||||
pub total: i64,
|
||||
}
|
||||
|
||||
/// 会话 key(§4.1 / §6.5):Thing 自身固定为 `thing.self`,其余直接用 AUMID。
|
||||
pub fn session_key(aumid: &str) -> String {
|
||||
if is_thing_aumid(aumid) {
|
||||
THING_SELF_SESSION.to_string()
|
||||
} else {
|
||||
aumid.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
/// AUMID 是否为 Thing 自身。
|
||||
pub fn is_thing_aumid(aumid: &str) -> bool {
|
||||
aumid.eq_ignore_ascii_case(THING_AUMID)
|
||||
}
|
||||
|
||||
/// 来源应用显示名(P0:取 AUMID 简化段;注册表友好名映射在 P1 §6.7)。
|
||||
///
|
||||
/// AUMID 形态:`PackageFamilyName!App` | `C:\Path\App.exe -Args` | `ProgId.App`。
|
||||
pub fn source_display(aumid: &str) -> String {
|
||||
// Thing 自身 AUMID 是标识符而非程序名,直接给友好名
|
||||
if is_thing_aumid(aumid) {
|
||||
return "Thing".to_string();
|
||||
}
|
||||
let core = aumid
|
||||
.split(['!', '\\'])
|
||||
.next_back()
|
||||
.unwrap_or(aumid)
|
||||
.split(' ')
|
||||
.next()
|
||||
.unwrap_or(aumid);
|
||||
core.trim().trim_end_matches(".exe").to_string()
|
||||
}
|
||||
|
||||
/// 控制动作(§4.2 `cmd.action`;Volume/Select 为 P1 扩展)。
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum CmdAction {
|
||||
Play,
|
||||
Pause,
|
||||
Toggle,
|
||||
Next,
|
||||
Prev,
|
||||
Stop,
|
||||
Seek,
|
||||
/// 系统主音量:args.level(0.0~1.0;>0 时顺带解除静音)
|
||||
Volume,
|
||||
/// 切换展示/控制的会话:args.sessionId(空串 = 取消覆盖,跟随系统 current)
|
||||
Select,
|
||||
/// 跳到队列指定条目(Thing 专属):args.index = 队列绝对下标
|
||||
Jump,
|
||||
}
|
||||
|
||||
/// `cmd` 的可选参数(serde default:缺省字段按0/空处理,各动作只读自己需要的)。
|
||||
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub struct CmdArgs {
|
||||
/// seek 目标位置(秒)
|
||||
#[serde(default)]
|
||||
pub pos_sec: f64,
|
||||
/// volume 目标音量(0.0~1.0)
|
||||
#[serde(default)]
|
||||
pub level: f64,
|
||||
/// select 目标会话(空串 = 跟随系统)
|
||||
#[serde(default)]
|
||||
pub session_id: String,
|
||||
/// jump 目标下标(队列绝对下标;-1 = 未提供)
|
||||
#[serde(default = "jump_index_default")]
|
||||
pub index: i64,
|
||||
}
|
||||
|
||||
fn jump_index_default() -> i64 {
|
||||
-1
|
||||
}
|
||||
|
||||
/// WS 消息(§4.2)。`type` 字段判别;`state` 展平 [`NowPlaying`] 字段。
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(
|
||||
tag = "type",
|
||||
rename_all = "camelCase",
|
||||
rename_all_fields = "camelCase"
|
||||
)]
|
||||
pub enum WsMessage {
|
||||
/// c→s:连接后首条,失败即断开
|
||||
Hello {
|
||||
token: String,
|
||||
device_name: String,
|
||||
proto_ver: u32,
|
||||
},
|
||||
/// s→c:鉴权通过
|
||||
Welcome {
|
||||
device_id: String,
|
||||
device_name: String,
|
||||
proto_ver: u32,
|
||||
},
|
||||
/// s→c:全量状态(连接后、变更、cmd 触发立即帧)
|
||||
State {
|
||||
#[serde(flatten)]
|
||||
now: NowPlaying,
|
||||
},
|
||||
/// s→c:会话列表(P1;连接后、列表或当前目标变化时推送)
|
||||
Sessions {
|
||||
sessions: Vec<SessionInfo>,
|
||||
},
|
||||
/// s→c:Thing 本机播放队列(连接后、队列或当前曲目变化时推送)
|
||||
Queue {
|
||||
items: Vec<QueueItem>,
|
||||
index: i64,
|
||||
total: i64,
|
||||
},
|
||||
/// c→s:用户操作
|
||||
Cmd {
|
||||
id: String,
|
||||
action: CmdAction,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
args: Option<CmdArgs>,
|
||||
},
|
||||
/// s→c:回执(语义 = 指令已被接受/派发,状态以随后的 `state` 为准)
|
||||
///
|
||||
/// 显式 rename:外层 `rename_all = "camelCase"` 会把变体名也转成 `cmdAck`,
|
||||
/// 而 §4.2 线格式与手机端都写的是 `cmd-ack` —— 不锁死就会让手机端把
|
||||
/// **每一条错误回执都静默丢掉**(见 `cmd_ack_wire_type` 单测)。
|
||||
#[serde(rename = "cmd-ack")]
|
||||
CmdAck {
|
||||
id: String,
|
||||
ok: bool,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
error: Option<String>,
|
||||
},
|
||||
/// c→s / s→c:30s 心跳
|
||||
Ping { ts: i64 },
|
||||
Pong { ts: i64 },
|
||||
}
|
||||
|
||||
/// WinRT `DateTime.UniversalTime`(100ns since **1601-01-01 UTC**,即 FILETIME 纪元)→ Unix 毫秒。
|
||||
/// `positionUpdatedAtMs` 的换算基准(§6.4:源是 `LastUpdatedTime`)。
|
||||
///
|
||||
/// 纪元是实测确认的(不是 .NET 的 0001-01-01):`gsmtc_dump` 里 QQMusic/Thing 会话的
|
||||
/// `LastUpdatedTime` ≈1.343e17 ticks,按 1601 纪元换算分别落在"47 分钟前 / 4.5 秒前",
|
||||
/// 与实际播放/暂停时刻吻合;按 0001 纪元则落在公元 426 年——Windows.Media.Control 的
|
||||
/// `TimelineProperties.LastUpdatedTime` 走 FILETIME,用错纪元会得到巨额负数,
|
||||
/// 手机端 `positionUpdatedAtMs > 0` 判定恒假 → 时钟偏差冻结(§6.10)形同虚设。
|
||||
pub fn winrt_ticks_to_unix_ms(ticks: i64) -> i64 {
|
||||
// 1601-01-01 → 1970-01-01:621355968 天 × 86400s × 1e7 ticks ÷ 1e4
|
||||
ticks / 10_000 - 11_644_473_600_000
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// 序列化往返:保证双端 JSON 形状与字段名(camelCase)稳定(P0 单测项)。
|
||||
#[test]
|
||||
fn now_playing_roundtrip() {
|
||||
let np = NowPlaying {
|
||||
session_id: THING_SELF_SESSION.to_string(),
|
||||
source_app: "网易云播放器".to_string(),
|
||||
is_thing: false,
|
||||
title: "园游会".to_string(),
|
||||
artist: "周杰伦".to_string(),
|
||||
album: "七里香".to_string(),
|
||||
cover_hash: Some("ab12".to_string()),
|
||||
status: PlayStatus::Playing,
|
||||
duration_sec: 255.5,
|
||||
position_sec: 12.25,
|
||||
position_updated_at_ms: 1_790_000_000_000,
|
||||
playback_rate: 1.0,
|
||||
can_control: CanControl {
|
||||
play: true,
|
||||
pause: true,
|
||||
next: true,
|
||||
prev: true,
|
||||
seek: true,
|
||||
},
|
||||
volume: Some(0.66),
|
||||
muted: false,
|
||||
device_id: "dev1".to_string(),
|
||||
};
|
||||
let msg = WsMessage::State { now: np.clone() };
|
||||
let json = serde_json::to_string(&msg).unwrap();
|
||||
// 字段名锁定(camelCase;双端漂移防线)
|
||||
assert!(json.contains("\"type\":\"state\""));
|
||||
assert!(json.contains("\"sessionId\""));
|
||||
assert!(json.contains("\"coverHash\""));
|
||||
assert!(json.contains("\"positionUpdatedAtMs\""));
|
||||
assert!(json.contains("\"canControl\""));
|
||||
assert!(json.contains("\"isThing\""));
|
||||
assert!(json.contains("\"status\":\"playing\""));
|
||||
assert!(json.contains("\"volume\":0.66"));
|
||||
assert!(json.contains("\"muted\":false"));
|
||||
let back: WsMessage = serde_json::from_str(&json).unwrap();
|
||||
assert_eq!(back, msg);
|
||||
}
|
||||
|
||||
/// P1:sessions 消息与 select/volume 动作的线格式锁定。
|
||||
#[test]
|
||||
fn sessions_and_p1_actions_roundtrip() {
|
||||
let msg = WsMessage::Sessions {
|
||||
sessions: vec![SessionInfo {
|
||||
session_id: THING_SELF_SESSION.to_string(),
|
||||
source_app: "Thing".into(),
|
||||
title: "园游会".into(),
|
||||
artist: "周杰伦".into(),
|
||||
status: PlayStatus::Playing,
|
||||
is_thing: true,
|
||||
is_current: true,
|
||||
}],
|
||||
};
|
||||
let json = serde_json::to_string(&msg).unwrap();
|
||||
assert!(json.contains("\"type\":\"sessions\""));
|
||||
assert!(json.contains("\"isCurrent\":true"));
|
||||
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), msg);
|
||||
|
||||
let volume = WsMessage::Cmd {
|
||||
id: "v1".into(),
|
||||
action: CmdAction::Volume,
|
||||
args: Some(CmdArgs {
|
||||
level: 0.5,
|
||||
..Default::default()
|
||||
}),
|
||||
};
|
||||
let json = serde_json::to_string(&volume).unwrap();
|
||||
assert!(json.contains("\"action\":\"volume\""));
|
||||
assert!(json.contains("\"level\":0.5"));
|
||||
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), volume);
|
||||
|
||||
let select = WsMessage::Cmd {
|
||||
id: "s1".into(),
|
||||
action: CmdAction::Select,
|
||||
args: Some(CmdArgs {
|
||||
session_id: THING_SELF_SESSION.into(),
|
||||
..Default::default()
|
||||
}),
|
||||
};
|
||||
let json = serde_json::to_string(&select).unwrap();
|
||||
assert!(json.contains("\"action\":\"select\""));
|
||||
assert!(json.contains("\"sessionId\":\"thing.self\""));
|
||||
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), select);
|
||||
|
||||
// 队列下发 + 选歌(Thing 专属能力)的线格式锁定
|
||||
let queue = WsMessage::Queue {
|
||||
items: vec![QueueItem {
|
||||
index: 7,
|
||||
title: "园游会".into(),
|
||||
artist: "周杰伦".into(),
|
||||
duration_sec: 255.5,
|
||||
}],
|
||||
index: 7,
|
||||
total: 120,
|
||||
};
|
||||
let json = serde_json::to_string(&queue).unwrap();
|
||||
assert!(json.contains("\"type\":\"queue\""));
|
||||
assert!(json.contains("\"items\""));
|
||||
assert!(json.contains("\"durationSec\":255.5"));
|
||||
assert!(json.contains("\"total\":120"));
|
||||
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), queue);
|
||||
|
||||
let jump = WsMessage::Cmd {
|
||||
id: "j1".into(),
|
||||
action: CmdAction::Jump,
|
||||
args: Some(CmdArgs {
|
||||
index: 7,
|
||||
..Default::default()
|
||||
}),
|
||||
};
|
||||
let json = serde_json::to_string(&jump).unwrap();
|
||||
assert!(json.contains("\"action\":\"jump\""));
|
||||
assert!(json.contains("\"index\":7"));
|
||||
// 缺 index 的旧客户端 → 反序列化为 -1(服务端据此拒绝)
|
||||
assert_eq!(serde_json::from_str::<CmdArgs>(r#"{}"#).unwrap().index, -1);
|
||||
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), jump);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hello_ack_cmd_roundtrip() {
|
||||
for msg in [
|
||||
WsMessage::Hello {
|
||||
token: "t".repeat(64),
|
||||
device_name: "Pixel".to_string(),
|
||||
proto_ver: PROTO_VER,
|
||||
},
|
||||
WsMessage::Welcome {
|
||||
device_id: "d".to_string(),
|
||||
device_name: "Thing".to_string(),
|
||||
proto_ver: PROTO_VER,
|
||||
},
|
||||
WsMessage::Cmd {
|
||||
id: "1".to_string(),
|
||||
action: CmdAction::Seek,
|
||||
args: Some(CmdArgs {
|
||||
pos_sec: 42.0,
|
||||
..Default::default()
|
||||
}),
|
||||
},
|
||||
WsMessage::Cmd {
|
||||
id: "2".to_string(),
|
||||
action: CmdAction::Toggle,
|
||||
args: None,
|
||||
},
|
||||
WsMessage::CmdAck {
|
||||
id: "1".to_string(),
|
||||
ok: false,
|
||||
error: Some("frontend-unavailable".to_string()),
|
||||
},
|
||||
WsMessage::Ping { ts: 1 },
|
||||
WsMessage::Pong { ts: 1 },
|
||||
] {
|
||||
let json = serde_json::to_string(&msg).unwrap();
|
||||
let back: WsMessage = serde_json::from_str(&json).unwrap();
|
||||
assert_eq!(back, msg, "{json}");
|
||||
}
|
||||
// action 枚举的线格式锁定
|
||||
let json = serde_json::to_string(&WsMessage::Cmd {
|
||||
id: "3".into(),
|
||||
action: CmdAction::Next,
|
||||
args: None,
|
||||
})
|
||||
.unwrap();
|
||||
assert!(json.contains("\"action\":\"next\""));
|
||||
// 无 args 时不出现该键
|
||||
assert!(!json.contains("args"));
|
||||
}
|
||||
|
||||
/// 回执的 `type` 必须是 `cmd-ack`(§4.2 表格与手机端 switch 的字面量)。
|
||||
/// 外层 `rename_all = "camelCase"` 连变体名一起转,会产出 `cmdAck`——
|
||||
/// 漏掉显式 rename 时手机端匹配不上,**每一条错误回执都被静默丢掉**
|
||||
/// (表现为:指令被拒绝却无提示、手机端保持窗口只能等超时才回退)。
|
||||
#[test]
|
||||
fn cmd_ack_wire_type() {
|
||||
let ack = WsMessage::CmdAck {
|
||||
id: "1".into(),
|
||||
ok: false,
|
||||
error: Some("boom".into()),
|
||||
};
|
||||
let json = serde_json::to_string(&ack).unwrap();
|
||||
assert!(json.contains("\"type\":\"cmd-ack\""), "{json}");
|
||||
assert!(!json.contains("cmdAck"), "{json}");
|
||||
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), ack);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn session_key_and_display() {
|
||||
assert_eq!(session_key(THING_AUMID), THING_SELF_SESSION);
|
||||
assert_eq!(session_key("cloudmusic.exe"), "cloudmusic.exe");
|
||||
assert!(is_thing_aumid("Thing.Lfeng.ME"));
|
||||
assert_eq!(
|
||||
source_display(r"KuGou\kugou.exe"),
|
||||
"kugou".to_string()
|
||||
);
|
||||
assert_eq!(source_display("Museify_zzdnekvpz2s88!Spotify"), "Spotify");
|
||||
// Thing 自身 AUMID → 友好名(手机端不应看到 thing.lfeng.me)
|
||||
assert_eq!(source_display(THING_AUMID), "Thing");
|
||||
}
|
||||
|
||||
/// WinRT DateTime(100ns since **1601-01-01**,FILETIME 纪元)→ Unix 毫秒(§6.4 换算基准)。
|
||||
#[test]
|
||||
fn winrt_datetime_to_unix_ms() {
|
||||
// 1970-01-01 的 FILETIME ticks:621355968 天 × 86400s × 1e7
|
||||
assert_eq!(winrt_ticks_to_unix_ms(116_444_736_000_000_000), 0);
|
||||
// 2026-09-25 00:00:00 UTC ≈ 1_790_332_800_000 ms
|
||||
let unix_ms = 1_790_332_800_000i64;
|
||||
let ticks = (unix_ms + 11_644_473_600_000) * 10_000;
|
||||
assert_eq!(winrt_ticks_to_unix_ms(ticks), unix_ms);
|
||||
// 实测样本(gsmtc_dump 抓到的 Thing 自身会话 LastUpdatedTime):
|
||||
// 对应 1790499938437 ms,即抓取时刻 4.5 秒前——按 0001 纪元算会落到公元 426 年
|
||||
assert_eq!(
|
||||
winrt_ticks_to_unix_ms(134_349_735_384_378_473),
|
||||
1_790_499_938_437
|
||||
);
|
||||
// 0 = 来源从未上报过时间轴(bilibili PC 实测)→ 换算必为负,
|
||||
// 调用方(glsmtc)据此钳成 0 作「无进度基准」哨兵
|
||||
assert!(winrt_ticks_to_unix_ms(0) < 0);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,610 @@
|
||||
//! 局域网服务:axum HTTP + WebSocket(MUSIC_REMOTE_PLAN §3.2 / §4.2 / §5.1 `server.rs`)。
|
||||
//!
|
||||
//! | 端点 | 用途 |
|
||||
//! |---|---|
|
||||
//! | `/ws` | 主通道:hello 鉴权、state 推送、cmd 控制、心跳 |
|
||||
//! | `/api/state` | REST 快照兜底(Bearer) |
|
||||
//! | `/cover/:hash` | 封面字节流(`<img>` 带不了 header → `?t=token`) |
|
||||
//! | `/pair` | 配对换 token(6 位码 + 限速) |
|
||||
//!
|
||||
//! 全部监听 `0.0.0.0`;实际端口在启动时按 26124→26139 探测(§3.2),
|
||||
//! 由 RemoteManager 写回 beacon 与配对二维码。
|
||||
|
||||
use std::net::SocketAddr;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use axum::extract::ws::{Message as AxumWs, WebSocket, WebSocketUpgrade};
|
||||
use axum::extract::{ConnectInfo, Path, Query, State};
|
||||
use axum::http::{header, HeaderMap, StatusCode};
|
||||
use axum::response::{IntoResponse, Response};
|
||||
use axum::routing::{get, post};
|
||||
use axum::{Json, Router};
|
||||
use futures_util::{SinkExt, StreamExt};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use tauri::{AppHandle, Emitter, Manager};
|
||||
|
||||
use super::glsmtc;
|
||||
use super::pairing::{self, RemoteDeviceMeta};
|
||||
use super::proto::{
|
||||
CmdAction, CmdArgs, NowPlaying, WsMessage, PROTO_VER,
|
||||
};
|
||||
use super::RemoteManager;
|
||||
use crate::music::{AudioEngine, MusicManager};
|
||||
use crate::music::smtc::SMTC_BUTTON_EVENT;
|
||||
|
||||
/// WS 首条消息(hello)超时(§4.2 连接后首条)。
|
||||
const HELLO_TIMEOUT: Duration = Duration::from_secs(10);
|
||||
/// 心跳周期(§4.2 30s 双向判活)。
|
||||
const HEARTBEAT: Duration = Duration::from_secs(30);
|
||||
/// 超过该时长无任何入站消息 → 判死断开(§5.4 心跳判活)。
|
||||
const IDLE_TIMEOUT: Duration = Duration::from_secs(90);
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct AppState {
|
||||
pub app: AppHandle,
|
||||
}
|
||||
|
||||
/// 构建路由(§3.2 四个端点)。
|
||||
pub fn router(app: AppHandle) -> Router {
|
||||
Router::new()
|
||||
.route("/ws", get(ws_upgrade))
|
||||
.route("/api/state", get(api_state))
|
||||
.route("/cover/:hash", get(cover))
|
||||
.route("/pair", post(pair))
|
||||
.with_state(AppState { app })
|
||||
}
|
||||
|
||||
/// 启动服务:preferred=0 时从 26124 起,被占 +1 直至 26139(§3.2)。
|
||||
/// 成功返回(实际端口, serve 任务句柄);stop 时由 RemoteManager abort。
|
||||
pub async fn start(
|
||||
app: AppHandle,
|
||||
preferred: u16,
|
||||
) -> Result<(u16, tokio::task::JoinHandle<()>), String> {
|
||||
let from = if preferred == 0 { 26124 } else { preferred };
|
||||
let to = from.clamp(26124, 26139).min(26139);
|
||||
let mut bound: Option<(u16, tokio::net::TcpListener)> = None;
|
||||
for port in from..=to {
|
||||
match tokio::net::TcpListener::bind(("0.0.0.0", port)).await {
|
||||
Ok(l) => {
|
||||
bound = Some((port, l));
|
||||
break;
|
||||
}
|
||||
Err(e) => {
|
||||
crate::logger::log_warn(
|
||||
"music-remote",
|
||||
&format!("端口 {port} 绑定失败({e}),尝试下一个"),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
let (port, listener) = bound.ok_or_else(|| {
|
||||
format!("远程服务端口 {from}-{to} 全部不可用(被占用或无权限)")
|
||||
})?;
|
||||
|
||||
let router = router(app);
|
||||
let handle = tokio::task::spawn(async move {
|
||||
let svc = router.into_make_service_with_connect_info::<SocketAddr>();
|
||||
if let Err(e) = axum::serve(listener, svc).await {
|
||||
// abort 时 axum::serve 返回的错误走这里降级为日志(abort 本身另算)
|
||||
crate::logger::log_warn("music-remote", &format!("axum 服务结束: {e}"));
|
||||
}
|
||||
});
|
||||
Ok((port, handle))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 鉴权
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn bearer_token(headers: &HeaderMap) -> Option<String> {
|
||||
headers
|
||||
.get(header::AUTHORIZATION)?
|
||||
.to_str()
|
||||
.ok()?
|
||||
.strip_prefix("Bearer ")
|
||||
.map(|s| s.to_string())
|
||||
}
|
||||
|
||||
/// 校验设备 token → 设备信息;失败为 None(不做限速——限速由调用方按场景加)。
|
||||
fn validate_token(app: &AppHandle, token: &str) -> Option<RemoteDeviceMeta> {
|
||||
let music = app.state::<MusicManager>();
|
||||
let settings = music.load_settings();
|
||||
pairing::device_by_token(&settings.remote_devices, token)
|
||||
}
|
||||
|
||||
fn require_bearer(app: &AppHandle, headers: &HeaderMap) -> Result<RemoteDeviceMeta, StatusCode> {
|
||||
let token = bearer_token(headers).ok_or(StatusCode::UNAUTHORIZED)?;
|
||||
validate_token(app, &token).ok_or(StatusCode::UNAUTHORIZED)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// REST:/api/state、/cover/:hash
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
async fn api_state(
|
||||
State(st): State<AppState>,
|
||||
headers: HeaderMap,
|
||||
) -> Result<Json<NowPlaying>, StatusCode> {
|
||||
require_bearer(&st.app, &headers)?;
|
||||
let remote = st.app.state::<RemoteManager>();
|
||||
Ok(Json(remote.now_playing()))
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct CoverQuery {
|
||||
/// 鉴权 token(`<img>` 无法带 Authorization header,§3.2)
|
||||
#[serde(rename = "t")]
|
||||
t: Option<String>,
|
||||
}
|
||||
|
||||
async fn cover(
|
||||
State(st): State<AppState>,
|
||||
Path(hash): Path<String>,
|
||||
Query(q): Query<CoverQuery>,
|
||||
headers: HeaderMap,
|
||||
) -> Result<Response, StatusCode> {
|
||||
let token = q.t.or_else(|| bearer_token(&headers));
|
||||
let token = token.ok_or(StatusCode::UNAUTHORIZED)?;
|
||||
validate_token(&st.app, &token).ok_or(StatusCode::UNAUTHORIZED)?;
|
||||
|
||||
let remote = st.app.state::<RemoteManager>();
|
||||
let bytes = remote.covers.get(&hash).ok_or(StatusCode::NOT_FOUND)?;
|
||||
// 访问日志不打印 query(§3.2):logger 不记录请求行,天然满足;此处只管响应
|
||||
let ct = sniff_content_type(&bytes);
|
||||
Ok(([(header::CONTENT_TYPE, ct)], bytes).into_response())
|
||||
}
|
||||
|
||||
fn sniff_content_type(bytes: &[u8]) -> &'static str {
|
||||
if bytes.starts_with(&[0x89, b'P', b'N', b'G']) {
|
||||
"image/png"
|
||||
} else if bytes.starts_with(&[0xFF, 0xD8]) {
|
||||
"image/jpeg"
|
||||
} else if bytes.len() > 12 && &bytes[0..4] == b"RIFF" && &bytes[8..12] == b"WEBP" {
|
||||
"image/webp"
|
||||
} else {
|
||||
"application/octet-stream"
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// POST /pair(§3.4)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct PairRequest {
|
||||
pairing_code: String,
|
||||
device_name: String,
|
||||
}
|
||||
|
||||
#[derive(Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct PairResponse {
|
||||
token: String,
|
||||
device_id: String,
|
||||
}
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct HttpError {
|
||||
error: String,
|
||||
}
|
||||
|
||||
async fn pair(
|
||||
State(st): State<AppState>,
|
||||
ConnectInfo(addr): ConnectInfo<SocketAddr>,
|
||||
Json(req): Json<PairRequest>,
|
||||
) -> Result<(StatusCode, Json<PairResponse>), (StatusCode, Json<HttpError>)> {
|
||||
let ip = addr.ip().to_string();
|
||||
let remote = st.app.state::<RemoteManager>();
|
||||
|
||||
let denied = |msg: &str| {
|
||||
(
|
||||
StatusCode::TOO_MANY_REQUESTS,
|
||||
Json(HttpError {
|
||||
error: msg.to_string(),
|
||||
}),
|
||||
)
|
||||
};
|
||||
if !remote.auth.allowed(&ip) {
|
||||
return Err(denied("尝试过于频繁,60s 后再试"));
|
||||
}
|
||||
// 配对码校验:存在 + 未过期 + 匹配(一次性:成功即清除)
|
||||
match remote.take_pairing_if_match(&req.pairing_code) {
|
||||
Ok(()) => remote.auth.ok(&ip),
|
||||
Err(e) => {
|
||||
remote.auth.fail(&ip);
|
||||
return Err((
|
||||
StatusCode::FORBIDDEN,
|
||||
Json(HttpError { error: e }),
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
let device_id = pairing::random_device_id();
|
||||
let token = pairing::random_token();
|
||||
// token 先入凭据库,成功才落设备表(§3.4-3 顺序)
|
||||
let key = pairing::token_key(&device_id);
|
||||
if let Err(e) = crate::secrets::secret_write(&key, &token) {
|
||||
crate::logger::log_error("music-remote", &format!("设备 token 写入凭据库失败: {e}"));
|
||||
return Err((
|
||||
StatusCode::INTERNAL_SERVER_ERROR,
|
||||
Json(HttpError {
|
||||
error: "保存设备凭据失败".to_string(),
|
||||
}),
|
||||
));
|
||||
}
|
||||
|
||||
let name = if req.device_name.trim().is_empty() {
|
||||
format!("手机设备 {}", &device_id[..6])
|
||||
} else {
|
||||
req.device_name.trim().to_string()
|
||||
};
|
||||
let music = st.app.state::<MusicManager>();
|
||||
let mut settings = music.load_settings();
|
||||
settings.remote_devices.push(RemoteDeviceMeta {
|
||||
id: device_id.clone(),
|
||||
name,
|
||||
last_connected_ms: 0,
|
||||
});
|
||||
if let Err(e) = music.save_settings(&settings) {
|
||||
crate::logger::log_error("music-remote", &format!("设备表落盘失败: {e}"));
|
||||
}
|
||||
crate::logger::log_info(
|
||||
"music-remote",
|
||||
format!("设备配对成功: {device_id}({ip})").as_str(),
|
||||
);
|
||||
Ok((
|
||||
StatusCode::OK,
|
||||
Json(PairResponse { token, device_id }),
|
||||
))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// WebSocket(§4.2)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
async fn ws_upgrade(
|
||||
State(st): State<AppState>,
|
||||
ConnectInfo(addr): ConnectInfo<SocketAddr>,
|
||||
upgrade: WebSocketUpgrade,
|
||||
) -> Response {
|
||||
// 升级阶段不鉴权:手机 WebSocket 无法带 Authorization header,
|
||||
// token 在升级后的首条 `hello` 消息里(§4.2)
|
||||
upgrade
|
||||
.on_upgrade(move |socket| handle_socket(st.app, addr, socket))
|
||||
.into_response()
|
||||
}
|
||||
|
||||
async fn handle_socket(app: AppHandle, addr: SocketAddr, socket: WebSocket) {
|
||||
let ip = addr.ip().to_string();
|
||||
let (mut sink, mut stream) = socket.split();
|
||||
|
||||
// 1) 首条必须是 hello(10s 超时)
|
||||
let hello = match tokio::time::timeout(HELLO_TIMEOUT, stream.next()).await {
|
||||
Ok(Some(Ok(AxumWs::Text(t)))) => match serde_json::from_str::<WsMessage>(&t) {
|
||||
Ok(WsMessage::Hello {
|
||||
token,
|
||||
device_name,
|
||||
..
|
||||
}) => (token, device_name),
|
||||
_ => {
|
||||
let _ = sink.send(AxumWs::Close(None)).await;
|
||||
return;
|
||||
}
|
||||
},
|
||||
_ => {
|
||||
let _ = sink.send(AxumWs::Close(None)).await;
|
||||
return;
|
||||
}
|
||||
};
|
||||
let (token, device_name) = hello;
|
||||
|
||||
let remote = app.state::<RemoteManager>();
|
||||
if !remote.auth.allowed(&ip) {
|
||||
let _ = sink.send(AxumWs::Close(None)).await;
|
||||
return;
|
||||
}
|
||||
let device = match validate_token(&app, &token) {
|
||||
Some(d) => {
|
||||
remote.auth.ok(&ip);
|
||||
d
|
||||
}
|
||||
None => {
|
||||
remote.auth.fail(&ip);
|
||||
crate::logger::log_warn("music-remote", &format!("hello 鉴权失败({ip})"));
|
||||
let _ = sink.send(AxumWs::Close(None)).await;
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
// 2) 上线登记 + 最后连接时间
|
||||
remote.mark_online(&device.id, true);
|
||||
touch_last_connected(&app, &device.id);
|
||||
|
||||
// 3) welcome + 首帧 state + 会话列表(§5.1 welcome → 全量;sessions 为 P1)
|
||||
let mut state_rx = remote.state_tx.subscribe();
|
||||
let mut sessions_rx = remote.sessions_rx();
|
||||
let mut queue_rx = remote.queue_rx();
|
||||
let mut rx = remote.shutdown_rx();
|
||||
let device_id = device.id.clone();
|
||||
let send_json = |msg: &WsMessage| -> String { serde_json::to_string(msg).unwrap_or_default() };
|
||||
|
||||
if sink
|
||||
.send(AxumWs::Text(send_json(&WsMessage::Welcome {
|
||||
device_id: device_id.clone(),
|
||||
device_name: device_name.clone(),
|
||||
proto_ver: PROTO_VER,
|
||||
})))
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
remote.mark_online(&device_id, false);
|
||||
return;
|
||||
}
|
||||
{
|
||||
let now = remote.now_playing();
|
||||
let _ = sink
|
||||
.send(AxumWs::Text(send_json(&WsMessage::State { now })))
|
||||
.await;
|
||||
}
|
||||
{
|
||||
let sessions = remote.sessions_snapshot();
|
||||
let _ = sink
|
||||
.send(AxumWs::Text(send_json(&WsMessage::Sessions { sessions })))
|
||||
.await;
|
||||
}
|
||||
{
|
||||
let q = remote.queue_snapshot();
|
||||
let _ = sink.send(AxumWs::Text(send_json(&queue_msg(&q)))).await;
|
||||
}
|
||||
|
||||
crate::logger::log_info(
|
||||
"music-remote",
|
||||
format!("WS 已连接: {device_name}({ip})").as_str(),
|
||||
);
|
||||
|
||||
// 4) 主循环:入站消息 / 状态变更推送 / 心跳
|
||||
let mut last_in = Instant::now();
|
||||
let mut beat = tokio::time::interval(HEARTBEAT);
|
||||
beat.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
|
||||
|
||||
loop {
|
||||
tokio::select! {
|
||||
// 心跳与判活(§4.2 / §5.4)
|
||||
_ = beat.tick() => {
|
||||
if last_in.elapsed() > IDLE_TIMEOUT {
|
||||
crate::logger::log_warn("music-remote", &format!("心跳超时,断开 {device_name}({ip})"));
|
||||
break;
|
||||
}
|
||||
if sink.send(AxumWs::Text(send_json(&WsMessage::Ping { ts: now_ms() }))).await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// 服务停止
|
||||
_ = rx.changed() => {
|
||||
if *rx.borrow() { break; }
|
||||
}
|
||||
// 状态推送(watch:节流/Force 均已在监视线程收敛,§6.3)
|
||||
changed = state_rx.changed() => {
|
||||
if changed.is_err() { break; }
|
||||
let now = state_rx.borrow_and_update().clone();
|
||||
if sink.send(AxumWs::Text(send_json(&WsMessage::State { now }))).await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// 会话列表变更(P1 多会话切换)
|
||||
changed = sessions_rx.changed() => {
|
||||
if changed.is_err() { break; }
|
||||
let sessions = sessions_rx.borrow_and_update().clone();
|
||||
if sink.send(AxumWs::Text(send_json(&WsMessage::Sessions { sessions }))).await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Thing 本机队列变更(前端发布:切歌 / 增删队列)
|
||||
changed = queue_rx.changed() => {
|
||||
if changed.is_err() { break; }
|
||||
let snap = queue_rx.borrow_and_update().clone();
|
||||
if sink.send(AxumWs::Text(send_json(&queue_msg(&snap)))).await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
incoming = stream.next() => {
|
||||
match incoming {
|
||||
Some(Ok(AxumWs::Text(t))) => {
|
||||
last_in = Instant::now();
|
||||
match serde_json::from_str::<WsMessage>(&t) {
|
||||
Ok(WsMessage::Cmd { id, action, args }) => {
|
||||
let res = dispatch_cmd(&app, action, args).await;
|
||||
let ack = WsMessage::CmdAck {
|
||||
id,
|
||||
ok: res.is_ok(),
|
||||
error: res.err(),
|
||||
};
|
||||
if sink.send(AxumWs::Text(send_json(&ack))).await.is_err() {
|
||||
break;
|
||||
}
|
||||
// cmd 触发的 state 立即帧由监视线程 Force 产生(§6.3 例外)
|
||||
}
|
||||
Ok(WsMessage::Ping { ts }) => {
|
||||
if sink.send(AxumWs::Text(send_json(&WsMessage::Pong { ts }))).await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(WsMessage::Pong { .. }) => {}
|
||||
// 重复 hello / 非法消息:忽略(连接保持,状态以服务端为准)
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
Some(Ok(AxumWs::Ping(p))) => {
|
||||
last_in = Instant::now();
|
||||
if sink.send(AxumWs::Pong(p)).await.is_err() { break; }
|
||||
}
|
||||
Some(Ok(AxumWs::Pong(_))) => { last_in = Instant::now(); }
|
||||
Some(Ok(AxumWs::Close(_))) | None => break,
|
||||
Some(Err(_)) => break,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
remote.mark_online(&device_id, false);
|
||||
crate::logger::log_info(
|
||||
"music-remote",
|
||||
format!("WS 已断开: {device_name}({ip})").as_str(),
|
||||
);
|
||||
let _ = sink.send(AxumWs::Close(None)).await;
|
||||
}
|
||||
|
||||
fn now_ms() -> i64 {
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.as_millis() as i64)
|
||||
.unwrap_or(0)
|
||||
}
|
||||
|
||||
/// 队列快照 → WS 消息(`items`/`index`/`total` 展平成顶层字段)。
|
||||
fn queue_msg(q: &super::proto::QueueSnapshot) -> WsMessage {
|
||||
WsMessage::Queue {
|
||||
items: q.items.clone(),
|
||||
index: q.index,
|
||||
total: q.total,
|
||||
}
|
||||
}
|
||||
|
||||
fn touch_last_connected(app: &AppHandle, device_id: &str) {
|
||||
let music = app.state::<MusicManager>();
|
||||
let mut settings = music.load_settings();
|
||||
if let Some(d) = settings
|
||||
.remote_devices
|
||||
.iter_mut()
|
||||
.find(|d| d.id == device_id)
|
||||
{
|
||||
d.last_connected_ms = now_ms();
|
||||
if let Err(e) = music.save_settings(&settings) {
|
||||
crate::logger::log_warn("music-remote", &format!("更新最后连接时间失败: {e}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// 执行一条控制指令(§5.1 数据流 + §5.2 兜底规则;P1 扩展 Volume/Select 与 isThing 直通)。
|
||||
async fn dispatch_cmd(
|
||||
app: &AppHandle,
|
||||
action: CmdAction,
|
||||
args: Option<CmdArgs>,
|
||||
) -> Result<(), String> {
|
||||
let remote = app.state::<RemoteManager>();
|
||||
let np = remote.now_playing();
|
||||
let gsmtc_ok = remote.gsmtc_ok.load(std::sync::atomic::Ordering::Relaxed);
|
||||
let a = args.clone().unwrap_or_default();
|
||||
|
||||
match action {
|
||||
// seek:Thing 自身直通 AudioEngine(SMTC 回环无 seek 通道);其他会话走 GSMTC
|
||||
CmdAction::Seek => {
|
||||
if args.is_none() || a.pos_sec < 0.0 || !a.pos_sec.is_finite() {
|
||||
return Err("seek 缺少/非法 args.posSec".into());
|
||||
}
|
||||
if np.is_thing {
|
||||
let engine = app.state::<AudioEngine>();
|
||||
let active = engine.state().active;
|
||||
crate::logger::log_info(
|
||||
"music-remote",
|
||||
&format!("远程 seek(Thing) pos={:.1} 引擎会话={active}", a.pos_sec),
|
||||
);
|
||||
// 引擎无会话(重启后只恢复了队列、还没起播)时 seek 是静默空转,
|
||||
// 手机端会白等保持窗口才回退——如实报错,让手机端立刻复位并提示
|
||||
if !active {
|
||||
return Err("电脑端播放器还没开始播放,先起播才能拖动进度".into());
|
||||
}
|
||||
engine.seek(a.pos_sec);
|
||||
} else if gsmtc_ok {
|
||||
gctl(np.session_id.clone(), action, args).await?;
|
||||
} else {
|
||||
return Err("当前模式不支持该会话的 seek".into());
|
||||
}
|
||||
}
|
||||
// 系统主音量(P1 §7):level>0 自动解除静音(volume::set 内处理)
|
||||
CmdAction::Volume => {
|
||||
let Some(_) = args else {
|
||||
return Err("volume 缺少 args.level".into());
|
||||
};
|
||||
if !a.level.is_finite() {
|
||||
return Err("volume args.level 非法".into());
|
||||
}
|
||||
let level = a.level;
|
||||
tokio::task::spawn_blocking(move || super::volume::set(level))
|
||||
.await
|
||||
.map_err(|e| format!("音量任务异常: {e}"))??;
|
||||
}
|
||||
// 目标会话切换(P1 §7):空 sessionId = 取消覆盖、跟随系统 current
|
||||
CmdAction::Select => {
|
||||
if args.is_none() {
|
||||
return Err("select 缺少 args.sessionId".into());
|
||||
}
|
||||
remote.set_selected(&a.session_id);
|
||||
}
|
||||
// 选歌(Thing 专属):队列在前端 store,事件交回前端执行
|
||||
CmdAction::Jump => {
|
||||
if !np.is_thing {
|
||||
return Err("只有 Thing 本机播放支持选歌".into());
|
||||
}
|
||||
if args.is_none() || a.index < 0 {
|
||||
return Err("jump 缺少 args.index".into());
|
||||
}
|
||||
let total = remote.queue_snapshot().total;
|
||||
if total > 0 && a.index >= total {
|
||||
return Err(format!("队列里没有第 {} 首(共 {total} 首)", a.index + 1));
|
||||
}
|
||||
app.emit(super::REMOTE_JUMP_EVENT, a.index)
|
||||
.map_err(|e| format!("派发到前端失败: {e}"))?;
|
||||
}
|
||||
// 按钮类:isThing 直通(P1 §7 跳过系统 SMTC 回环);其他会话 GSMTC;再退事件链兜底
|
||||
_ => {
|
||||
if np.is_thing {
|
||||
let name = button_name(action, np.status == super::proto::PlayStatus::Playing)?;
|
||||
app.emit(SMTC_BUTTON_EVENT, name)
|
||||
.map_err(|e| format!("派发到前端失败: {e}"))?;
|
||||
} else if gsmtc_ok {
|
||||
gctl(np.session_id.clone(), action, args).await?;
|
||||
} else {
|
||||
let name = button_name(action, np.status == super::proto::PlayStatus::Playing)?;
|
||||
app.emit(SMTC_BUTTON_EVENT, name)
|
||||
.map_err(|e| format!("派发到前端失败: {e}"))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// cmd 触发立即推一帧(§6.3 例外)
|
||||
remote.notify_state_force();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// 按钮动作 → music-smtc-button 事件载荷(与 smtc.rs 的映射一致)。
|
||||
fn button_name(action: CmdAction, playing: bool) -> Result<&'static str, String> {
|
||||
Ok(match action {
|
||||
CmdAction::Play => "play",
|
||||
CmdAction::Pause => "pause",
|
||||
CmdAction::Toggle => {
|
||||
if playing {
|
||||
"pause"
|
||||
} else {
|
||||
"play"
|
||||
}
|
||||
}
|
||||
CmdAction::Next => "next",
|
||||
CmdAction::Prev => "prev",
|
||||
CmdAction::Stop => "stop",
|
||||
_ => return Err("该动作不支持事件派发".into()),
|
||||
})
|
||||
}
|
||||
|
||||
/// GSMTC 控制:`.get()` 阻塞等待放 spawn_blocking(§3.1,绝不占 tokio worker/主线程)。
|
||||
async fn gctl(
|
||||
session_id: String,
|
||||
action: CmdAction,
|
||||
args: Option<CmdArgs>,
|
||||
) -> Result<(), String> {
|
||||
tokio::task::spawn_blocking(move || glsmtc::control(&session_id, action, args))
|
||||
.await
|
||||
.map_err(|e| format!("控制任务异常: {e}"))?
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
//! 系统主音量(MUSIC_REMOTE_PLAN P1 §7):MMDevice 默认输出端点的
|
||||
//! `IAudioEndpointVolume`。
|
||||
//!
|
||||
//! 设计取舍:每次调用**现取 COM 对象**(CoCreate + Activate,µs 级开销),
|
||||
//! 不跨线程持有接口指针——避开 windows-rs 接口的 Send/Sync 争议;
|
||||
//! 调用频率受控(监视线程 500ms 读一次 + 手机拖动结束发一次 set)。
|
||||
|
||||
use windows::core::GUID;
|
||||
use windows::Win32::Foundation::BOOL;
|
||||
use windows::Win32::Media::Audio::Endpoints::IAudioEndpointVolume;
|
||||
use windows::Win32::Media::Audio::{eMultimedia, eRender, IMMDevice, IMMDeviceEnumerator};
|
||||
use windows::Win32::System::Com::{CLSCTX_ALL, CoCreateInstance};
|
||||
|
||||
/// CLSID_MMDeviceEnumerator(mmdevapi.h 固定值)
|
||||
fn clsid_mm_device_enumerator() -> GUID {
|
||||
GUID::from_u128(0xBCDE0395_E52F_467C_8E3D_C4579291_692E)
|
||||
}
|
||||
|
||||
fn endpoint() -> Result<IAudioEndpointVolume, String> {
|
||||
unsafe {
|
||||
let enumerator: IMMDeviceEnumerator =
|
||||
CoCreateInstance(&clsid_mm_device_enumerator(), None, CLSCTX_ALL)
|
||||
.map_err(|e| format!("MMDeviceEnumerator 创建失败: {e}"))?;
|
||||
let device: IMMDevice = enumerator
|
||||
.GetDefaultAudioEndpoint(eRender, eMultimedia)
|
||||
.map_err(|e| format!("默认音频输出端点不可用: {e}"))?;
|
||||
device
|
||||
.Activate(CLSCTX_ALL, None)
|
||||
.map_err(|e| format!("IAudioEndpointVolume 激活失败: {e}"))
|
||||
}
|
||||
}
|
||||
|
||||
/// 读主音量(0.0~1.0)与静音位;端点不可用返回 None(NowPlaying.volume 置空)。
|
||||
pub fn read() -> Option<(f64, bool)> {
|
||||
let vol = endpoint().ok()?;
|
||||
unsafe {
|
||||
let v = vol.GetMasterVolumeLevelScalar().ok()? as f64;
|
||||
let muted = vol.GetMute().ok()?.as_bool();
|
||||
Some((v.clamp(0.0, 1.0), muted))
|
||||
}
|
||||
}
|
||||
|
||||
/// 设置主音量(0..1 自动 clamp);**level > 0 时顺带解除静音**——
|
||||
/// 手机拖音量条本意就是"要出声",静音态下拖动即恢复(P1 手机端音量条语义)。
|
||||
pub fn set(level: f64) -> Result<(), String> {
|
||||
let vol = endpoint()?;
|
||||
let l = level.clamp(0.0, 1.0) as f32;
|
||||
unsafe {
|
||||
vol.SetMasterVolumeLevelScalar(l, std::ptr::null())
|
||||
.map_err(|e| format!("设置音量失败: {e}"))?;
|
||||
if l > 0.0 {
|
||||
vol.SetMute(BOOL(0), std::ptr::null())
|
||||
.map_err(|e| format!("解除静音失败: {e}"))?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -192,6 +192,17 @@ pub async fn music_smtc_update_metadata(
|
||||
album: String,
|
||||
cover_url: Option<String>,
|
||||
) {
|
||||
// 回填手机遥控的兜底聚合缓存(MUSIC_REMOTE_PLAN §5.2):先记原始值,
|
||||
// 后面封面下载/转码失败都不影响这份元数据
|
||||
if let Some(cache) = app.try_state::<super::SmtcMetaCache>() {
|
||||
if let Ok(mut g) = cache.0.lock() {
|
||||
*g = super::SmtcMetaSnapshot {
|
||||
title: title.clone(),
|
||||
artist: artist.clone(),
|
||||
album: album.clone(),
|
||||
};
|
||||
}
|
||||
}
|
||||
// 下载放在 tokio 线程(主线程不能阻塞);失败只跳过封面,不影响标题/歌手/专辑
|
||||
let cover = match cover_url.as_deref().filter(|u| !u.is_empty()) {
|
||||
Some(url) => {
|
||||
@@ -383,6 +394,12 @@ pub fn music_smtc_update_playback_state(app: AppHandle, playing: bool) {
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub fn music_smtc_clear(app: AppHandle) {
|
||||
// 兜底缓存同步清空(遥控端随下一帧 state 显示"未在播放")
|
||||
if let Some(cache) = app.try_state::<super::SmtcMetaCache>() {
|
||||
if let Ok(mut g) = cache.0.lock() {
|
||||
*g = super::SmtcMetaSnapshot::default();
|
||||
}
|
||||
}
|
||||
on_main(&app, "clear", move |ctrl| {
|
||||
let _ = ctrl.SetPlaybackStatus(MediaPlaybackStatus::Stopped);
|
||||
if let Ok(updater) = ctrl.DisplayUpdater() {
|
||||
|
||||
@@ -65,6 +65,9 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
|
||||
music.set_app(app.handle().clone());
|
||||
app.manage(music);
|
||||
|
||||
// ===== 手机互联:按设置自启(RemoteManager 本体在 lib.rs 平级 manage)=====
|
||||
crate::music::init_on_launch(app.handle());
|
||||
|
||||
// ===== AI 模块:AiManager(全局供应商配置,主设置 → AI 服务)=====
|
||||
// 迁移必须在建 State 之前跑:把旧版存在翻译设置里的 AI 引擎(含密钥)搬过来,
|
||||
// 否则 AiManager 预热缓存时会读走默认配置。迁移逻辑在 translate 侧(要同时读懂
|
||||
|
||||
Reference in new issue
Block a user