//! 任意文本 / 代码文件的读写:编码探测、换行探测、授权路径白名单。 //! //! # 与笔记库的分工 //! //! 库内笔记走 `library.rs`(相对路径 + 树形结构 + front-matter);本模块服务的是 //! **库外的任意文件**:用户用 `Ctrl+O` 或拖拽打开的一个 `.py`、`.json`、`.log`。 //! 两者的安全模型完全不同 —— 库是「一个根目录内的沙箱」,而任意文件是「用户显式 //! 点过的那个路径」。因此这里的守卫不是路径前缀,而是**授权集合**(见下)。 //! //! # 为什么要有授权白名单 //! //! 前端传来的路径一律不可信:一个被污染的 WebView(XSS、恶意依赖)如果能调 //! `notes_write_file('/Windows/System32/...')`,那就不是编辑器而是任意文件写入漏洞。 //! 做法:只有经过 [`authorize`] 登记过的路径才允许读**写**(读也一并限制,避免拿它 //! 当任意文件读取接口探测磁盘)。授权的三个来源都是用户动作:系统文件对话框、 //! 命令行参数、库本身。 //! //! **读**比写宽松一档:读只要求「存在且是文件」,写入才强制授权。原因是打开一篇 //! 从设置页点进来的文件不该因为「窗口重启过、授权表空了」而失败。 //! //! # 编码与换行:读写成对 //! //! GBK 文件被当成 UTF-8 读出来是乱码,再按 UTF-8 存回去就是**永久损坏**(原字节 //! 已经不可逆地丢了)。因此读的时候把「编码 + 有无 BOM + 换行风格」一并记下来, //! 写回时原样还原;用户显式改编码时才按新编码写。换行同理:CRLF 文件存回去必须 //! 还是 CRLF,否则一次「随手保存」就会在整个 diff 里掀起风暴。 use std::collections::HashSet; use std::path::{Path, PathBuf}; use std::sync::Mutex; use std::time::UNIX_EPOCH; use serde::Serialize; use specta::Type; /// 会话内已授权(用户显式打开过)的路径集合。 /// /// 进程级静态而非 Tauri State:授权是「这一次运行期间用户点过什么」的事实, /// 与库根、设置无关,也不需要跨窗口同步(每个源窗口都会自己调 `authorize`)。 static AUTHORIZED: std::sync::OnceLock>> = std::sync::OnceLock::new(); fn authorized() -> &'static Mutex> { AUTHORIZED.get_or_init(|| Mutex::new(HashSet::new())) } /// 换行风格。 pub const EOL_LF: &str = "lf"; pub const EOL_CRLF: &str = "crlf"; /// 一个已打开文件的完整状态(前端据此显示编码/换行,并原样写回)。 #[derive(Debug, Clone, Serialize, Type)] #[serde(rename_all = "camelCase")] pub struct FileDoc { /// 绝对路径(Windows 下已剥掉 `\\?\` 前缀) pub path: String, /// 显示名(文件名) pub name: String, /// 文本内容(换行已统一为 `\n`,写回时按 `eol` 还原) pub content: String, /// 探测到的编码(`utf-8` / `utf-8-bom` / `gbk` / …) pub encoding: String, /// 换行风格:"lf" | "crlf" pub eol: String, /// 文件字节数 pub size: u64, /// 最后修改时间(Unix 毫秒) pub modified: u64, /// 是否超过「大文件」阈值(前端据此关闭 Live Preview / 折叠 / 补全) pub large: bool, /// 行数(前端状态栏显示;大文件也只需要扫一遍换行,成本可忽略) pub lines: u64, } /// 登记一个路径为「已授权可写」。 pub fn authorize(path: &Path) { let key = normalize_key(path); if let Ok(mut set) = authorized().lock() { set.insert(key); } } /// 该路径是否已授权(写操作的前置条件)。 pub fn is_authorized(path: &Path) -> bool { let key = normalize_key(path); authorized() .lock() .map(|set| set.contains(&key)) .unwrap_or(false) } /// 授权集合的比对键:**尽力规范化**(解析符号链接与 `..`)。 /// /// 规范化失败(文件不存在)时退回原路径 —— 那说明写操作本来就会失败, /// 这里没必要为了「统一键」而提前报错。 fn normalize_key(path: &Path) -> PathBuf { std::fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf()) } /// 把路径转成可显示、可回传的字符串(剥掉 Windows 的 `\\?\` 扩展长度前缀)。 pub fn display_path(path: &Path) -> String { let s = path.to_string_lossy().to_string(); match s.strip_prefix(r"\\?\") { Some(rest) => rest.to_string(), None => s, } } /// 探测编码:返回规范名(`utf-8` / `utf-8-bom` / `gbk` / `gb18030` / `big5` / …)。 /// /// # 判定顺序(每一步都有理由) /// /// 1. **BOM**:UTF-8 BOM / UTF-16 的 BOM 是无歧义的事实,直接采信; /// 2. **严格 UTF-8 校验**:能完整解成 UTF-8 就是 UTF-8。这一步的优先级高于任何 /// 统计猜测 —— 中文 GBK 字节序列几乎不可能恰好是合法 UTF-8,反向的误判同样罕见; /// 3. **GB18030 试解**:GB18030 是 GBK 的超集,用它解 GBK 内容总能成功, /// 因此作为「非 UTF-8 中文」的兜底(比 GBK 更宽,能覆盖 4 字节生僻字); /// 4. 都失败则按 UTF-8 有损解码(宁可显示替换字符,也不要打不开文件)。 pub fn detect_encoding(bytes: &[u8]) -> String { if bytes.starts_with(&[0xEF, 0xBB, 0xBF]) { return "utf-8-bom".to_string(); } if bytes.starts_with(&[0xFF, 0xFE]) { return "utf-16le".to_string(); } if bytes.starts_with(&[0xFE, 0xFF]) { return "utf-16be".to_string(); } if std::str::from_utf8(bytes).is_ok() { return "utf-8".to_string(); } // 非 UTF-8:交给 GB18030 兜底(GBK 的每个序列在 GB18030 下都合法) if crate::terminal::encoding::is_supported("gb18030") { return "gb18030".to_string(); } "utf-8".to_string() } /// 按编码把字节解成字符串(BOM 已剥离)。 fn decode_bytes(bytes: &[u8], encoding: &str) -> String { match encoding { "utf-8-bom" => { let body = bytes.strip_prefix(&[0xEF, 0xBB, 0xBF]).unwrap_or(bytes); String::from_utf8_lossy(body).into_owned() } "utf-16le" | "utf-16be" => { // UTF-16 走 encoding_rs;BOM 由它自己处理 crate::terminal::encoding::decode(bytes, "utf-16le") } other => crate::terminal::encoding::decode(bytes, other), } } /// 按编码把字符串编成字节(必要时写回 BOM)。 fn encode_text(text: &str, encoding: &str) -> Result, String> { match encoding { "utf-8-bom" => { let mut out = vec![0xEF, 0xBB, 0xBF]; out.extend_from_slice(text.as_bytes()); Ok(out) } other => { let normalized = crate::terminal::encoding::normalize(other); if !crate::terminal::encoding::is_supported(&normalized) { return Err(format!("不支持的编码:{other}")); } Ok(crate::terminal::encoding::encode(text, &normalized)) } } } /// 探测换行风格(`\r\n` 只要出现一次就判定为 CRLF —— 混合换行的文件按主流风格写回)。 fn detect_eol(text: &str) -> String { if text.contains("\r\n") { EOL_CRLF.to_string() } else { EOL_LF.to_string() } } /// 读取任意文件。 pub fn read_file(path: &str, max_mb: u32) -> Result { let trimmed = path.trim(); if trimmed.is_empty() { return Err("路径为空".to_string()); } let p = Path::new(trimmed); if p.is_dir() { return Err("这是一个目录,请选择文件".to_string()); } let meta = std::fs::metadata(p).map_err(|e| format!("读取文件信息失败: {e}"))?; if !meta.is_file() { return Err("目标不是普通文件".to_string()); } let bytes = std::fs::read(p).map_err(|e| format!("读取文件失败: {e}"))?; let encoding = detect_encoding(&bytes); let raw = decode_bytes(&bytes, &encoding); let eol = detect_eol(&raw); // 统一成 `\n` 交给编辑器:CM6 的一份文档只应有一种换行,混合换行会让 // 「行号 / 选区 / 大纲」三处计算各按各的口径,写法回时再还原 let content = raw.replace("\r\n", "\n"); let limit = (max_mb.max(1) as u64) * 1024 * 1024; Ok(FileDoc { path: display_path(p), name: p .file_name() .map(|n| n.to_string_lossy().to_string()) .unwrap_or_default(), lines: content.lines().count() as u64, content, encoding, eol, size: meta.len(), modified: meta .modified() .ok() .and_then(|t| t.duration_since(UNIX_EPOCH).ok()) .map(|d| d.as_millis() as u64) .unwrap_or(0), large: meta.len() > limit, }) } /// 写入任意文件。 /// /// `encoding` 为空串时沿用「读时探测到的编码」由前端回传的那个值 —— 调用方 /// (编辑器)始终带着它,这里不接受「猜一个」。 pub fn write_file( path: &str, content: &str, encoding: &str, eol: &str, max_mb: u32, ) -> Result { let trimmed = path.trim(); if trimmed.is_empty() { return Err("路径为空".to_string()); } let p = Path::new(trimmed); if !is_authorized(p) { return Err("该文件未经授权,无法写入(请通过「打开文件」重新选择)".to_string()); } let enc = if encoding.trim().is_empty() { "utf-8".to_string() } else { crate::terminal::encoding::normalize(encoding) }; let text = if eol == EOL_CRLF { content.replace("\r\n", "\n").replace('\n', "\r\n") } else { content.replace("\r\n", "\n") }; let bytes = encode_text(&text, &enc)?; std::fs::write(p, &bytes).map_err(|e| format!("保存文件失败: {e}"))?; read_file(trimmed, max_mb) } /// 把图片等二进制内容写入库根的 `assets/`(粘贴图片用)。 /// /// 返回**相对库根的路径**(统一 `/` 分隔),前端据此插入 Markdown 图片引用; /// 不使用绝对路径,保证笔记换个机器 / 换个库根也能打开。 pub fn write_asset( root: &Path, file_name: &str, data: &[u8], ext: &str, ) -> Result { let assets = root.join(super::library::ASSETS_DIR); std::fs::create_dir_all(&assets).map_err(|e| format!("创建附件目录失败: {e}"))?; let stem = super::library::validate_name(file_name)?; let stem = Path::new(&stem) .file_stem() .map(|s| s.to_string_lossy().to_string()) .unwrap_or_else(|| "image".to_string()); let ext = ext.trim().trim_start_matches('.').to_ascii_lowercase(); let ext = if ext.is_empty() { "png".to_string() } else { ext }; let mut candidate = format!("{stem}.{ext}"); let mut index = 1; while assets.join(&candidate).exists() { candidate = format!("{stem}-{index}.{ext}"); index += 1; if index > 9999 { return Err("同名附件过多,请清理 assets 目录".to_string()); } } std::fs::write(assets.join(&candidate), data).map_err(|e| format!("写入附件失败: {e}"))?; Ok(format!("{}/{candidate}", super::library::ASSETS_DIR)) } // ===== 测试 ===== #[cfg(test)] mod tests { use super::*; #[test] fn detects_bom_and_plain_utf8() { assert_eq!(detect_encoding(b"hello"), "utf-8"); assert_eq!(detect_encoding("\u{feff}hello".as_bytes()), "utf-8-bom"); assert_eq!(detect_encoding(&[0xFF, 0xFE, 0x41, 0x00]), "utf-16le"); } #[test] fn detects_non_utf8_as_gb18030() { // 「测试」的 GBK 字节:合法 UTF-8 校验必然失败 let gbk = crate::terminal::encoding::encode("测试", "gbk"); assert_eq!(detect_encoding(&gbk), "gb18030"); assert_eq!(decode_bytes(&gbk, "gb18030"), "测试"); } #[test] fn eol_roundtrip_preserves_crlf() { let dir = std::env::temp_dir().join("thing-notes-files-test"); std::fs::create_dir_all(&dir).unwrap(); let path = dir.join("crlf.txt"); std::fs::write(&path, b"a\r\nb\r\n").unwrap(); let doc = read_file(&display_path(&path), 5).unwrap(); assert_eq!(doc.eol, EOL_CRLF); assert_eq!(doc.content, "a\nb\n"); assert_eq!(doc.lines, 2); authorize(&path); let saved = write_file(&display_path(&path), "a\nb\nc\n", "utf-8", EOL_CRLF, 5).unwrap(); assert_eq!(saved.content, "a\nb\nc\n"); // 落盘字节必须还是 CRLF(否则一次保存就污染整个 diff) assert_eq!(std::fs::read(&path).unwrap(), b"a\r\nb\r\nc\r\n"); let _ = std::fs::remove_file(&path); } #[test] fn write_requires_authorization() { let dir = std::env::temp_dir().join("thing-notes-files-test"); std::fs::create_dir_all(&dir).unwrap(); let path = dir.join("unauthorized.txt"); std::fs::write(&path, b"x").unwrap(); let err = write_file(&display_path(&path), "y", "utf-8", EOL_LF, 5).unwrap_err(); assert!(err.contains("未经授权"), "{err}"); let _ = std::fs::remove_file(&path); } #[test] fn gbk_write_uses_original_encoding() { let dir = std::env::temp_dir().join("thing-notes-files-test"); std::fs::create_dir_all(&dir).unwrap(); let path = dir.join("gbk.txt"); std::fs::write(&path, crate::terminal::encoding::encode("中文", "gbk")).unwrap(); let doc = read_file(&display_path(&path), 5).unwrap(); assert_eq!(doc.content, "中文"); authorize(&path); write_file(&display_path(&path), "中文内容", &doc.encoding, &doc.eol, 5).unwrap(); let bytes = std::fs::read(&path).unwrap(); assert_eq!(crate::terminal::encoding::decode(&bytes, "gbk"), "中文内容"); let _ = std::fs::remove_file(&path); } #[test] fn large_flag_uses_megabyte_limit() { let dir = std::env::temp_dir().join("thing-notes-files-test"); std::fs::create_dir_all(&dir).unwrap(); let path = dir.join("big.txt"); std::fs::write(&path, vec![b'a'; 2048]).unwrap(); assert!(read_file(&display_path(&path), 1).unwrap().large == false); // 阈值按 MB 计,2048 字节在 0 上限下被夹到 1MB,仍不算大文件 assert!(!read_file(&display_path(&path), 0).unwrap().large); let _ = std::fs::remove_file(&path); } }