Files
Thing/src-tauri/src/notes/files.rs
T

376 lines
14 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 任意文本 / 代码文件的读写:编码探测、换行探测、授权路径白名单。
//!
//! # 与笔记库的分工
//!
//! 库内笔记走 `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<Mutex<HashSet<PathBuf>>> = std::sync::OnceLock::new();
fn authorized() -> &'static Mutex<HashSet<PathBuf>> {
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<Vec<u8>, 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<FileDoc, String> {
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<FileDoc, String> {
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<String, String> {
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);
}
}