Reset broken hosts backups during cleanup

Author: final00000000

README.md

@@ -310,7 +310,7 @@ macOS 不再走本地交叉编译脚本，而是通过 GitHub Actions 原生构
 - 首次写入系统 `hosts` 前，会在 `runtime` 目录自动创建完整备份
 - `clean-hosts` 只删除 `linuxdo-accelerator` 自己维护的 marker block
 - `restore-hosts` 会用完整备份覆盖当前 `hosts`，适合停止使用后的显式恢复
-- `cleanup` 会优先尝试恢复首次接管前的完整备份；如果完整备份缺失、状态异常或恢复失败，会退化为仅清理 marker block，并明确提示无法完整恢复原始 `hosts`
+- `cleanup` 会优先尝试恢复首次接管前的完整备份；如果完整备份缺失、损坏、状态异常或恢复失败，会退化为仅清理 marker block；遇到损坏 / 异常备份时还会顺带清掉失效备份，避免后续继续卡在错误状态
 - Windows 下会在写入前自动处理 `hosts` 的只读属性，并在写入后恢复原始文件属性
 - Windows 下对 `hosts` 原子替换增加了共享冲突重试，降低杀软 / 系统进程短暂占用导致的恢复失败概率
 - 当前恢复范围以 `hosts` 内容与常见文件属性为主，不额外恢复自定义 ACL / owner

src/hosts.rs

@@ -4,7 +4,9 @@ use std::path::PathBuf;
 use anyhow::{Context, Result};
 
 use crate::config::AppConfig;
-use crate::hosts_store::{ensure_hosts_backup, restore_hosts_from_backup, write_hosts_content};
+use crate::hosts_store::{
+    ensure_hosts_backup, restore_hosts_from_backup, validate_hosts_backup, write_hosts_content,
+};
 use crate::paths::AppPaths;
 
 const START_MARKER: &str = "# >>> linuxdo-accelerator >>>";
@@ -88,6 +90,19 @@ pub fn restore_hosts_file(paths: &AppPaths) -> Result<()> {
     }
 }
 
+pub fn validate_hosts_backup_file(paths: &AppPaths) -> Result<()> {
+    #[cfg(target_os = "android")]
+    {
+        let _ = paths;
+        return Ok(());
+    }
+
+    #[cfg(not(target_os = "android"))]
+    {
+        validate_hosts_backup(paths, &hosts_path())
+    }
+}
+
 #[cfg(not(target_os = "android"))]
 fn render_managed_hosts(original: &str, config: &AppConfig) -> String {
     let newline = detect_newline(original);

src/hosts_store.rs

@@ -45,7 +45,10 @@ pub(crate) enum BackupState {
 
 pub(crate) fn ensure_hosts_backup(paths: &AppPaths, source_path: &Path) -> Result<()> {
     match backup_state(paths) {
-        BackupState::Ready => return Ok(()),
+        BackupState::Ready => {
+            validate_hosts_backup(paths, source_path)?;
+            return Ok(());
+        }
         BackupState::Inconsistent => {
             bail!(
                 "hosts backup state is inconsistent; expected both {} and {}",
@@ -118,23 +121,7 @@ pub(crate) fn restore_hosts_from_backup(
     source_path: &Path,
     current_content: &str,
 ) -> Result<()> {
-    match backup_state(paths) {
-        BackupState::Ready => {}
-        BackupState::Missing => {
-            bail!(
-                "hosts backup is unavailable; expected both {} and {}",
-                paths.hosts_backup_path.display(),
-                paths.hosts_backup_meta_path.display()
-            );
-        }
-        BackupState::Inconsistent => {
-            bail!(
-                "hosts backup state is inconsistent; expected both {} and {}",
-                paths.hosts_backup_path.display(),
-                paths.hosts_backup_meta_path.display()
-            );
-        }
-    }
+    validate_hosts_backup(paths, source_path)?;
 
     let backup = fs::read_to_string(&paths.hosts_backup_path)
         .with_context(|| format!("failed to read {}", paths.hosts_backup_path.display()))?;
@@ -179,6 +166,61 @@ pub(crate) fn backup_state(paths: &AppPaths) -> BackupState {
     }
 }
 
+pub(crate) fn validate_hosts_backup(paths: &AppPaths, source_path: &Path) -> Result<()> {
+    match backup_state(paths) {
+        BackupState::Ready => {}
+        BackupState::Missing => {
+            bail!(
+                "hosts backup is unavailable; expected both {} and {}",
+                paths.hosts_backup_path.display(),
+                paths.hosts_backup_meta_path.display()
+            );
+        }
+        BackupState::Inconsistent => {
+            bail!(
+                "hosts backup state is inconsistent; expected both {} and {}",
+                paths.hosts_backup_path.display(),
+                paths.hosts_backup_meta_path.display()
+            );
+        }
+    }
+
+    let _ = fs::read_to_string(&paths.hosts_backup_path)
+        .with_context(|| format!("failed to read {}", paths.hosts_backup_path.display()))?;
+    let meta = load_backup_meta(paths)?;
+    if !source_path_matches(source_path, &meta.source_path) {
+        bail!(
+            "hosts backup source path mismatch; expected {}, got {}",
+            source_path.display(),
+            meta.source_path
+        );
+    }
+    Ok(())
+}
+
+pub(crate) fn clear_hosts_backup(paths: &AppPaths) -> Result<()> {
+    let backup_temp_path = temp_backup_path(&paths.hosts_backup_path);
+    let meta_temp_path = temp_backup_path(&paths.hosts_backup_meta_path);
+    let mut errors = Vec::new();
+
+    for path in [
+        &paths.hosts_backup_path,
+        &paths.hosts_backup_meta_path,
+        &backup_temp_path,
+        &meta_temp_path,
+    ] {
+        if let Err(error) = cleanup_temp_file(path) {
+            errors.push(format!("failed to remove {}: {error:#}", path.display()));
+        }
+    }
+
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        bail!(errors.join("; "));
+    }
+}
+
 fn load_backup_meta(paths: &AppPaths) -> Result<HostsBackupMeta> {
     let raw = fs::read(&paths.hosts_backup_meta_path)
         .with_context(|| format!("failed to read {}", paths.hosts_backup_meta_path.display()))?;
@@ -451,7 +493,8 @@ mod tests {
     use std::sync::atomic::{AtomicU64, Ordering};
 
     use super::{
-        ensure_hosts_backup, load_backup_meta, restore_hosts_from_backup, write_hosts_content,
+        BackupState, backup_state, clear_hosts_backup, ensure_hosts_backup, load_backup_meta,
+        restore_hosts_from_backup, validate_hosts_backup, write_hosts_content,
     };
     use crate::paths::AppPaths;
 
@@ -548,6 +591,52 @@ mod tests {
         cleanup_test_dir(&test_dir);
     }
 
+    #[test]
+    fn validate_hosts_backup_rejects_broken_metadata() {
+        let test_dir = create_test_dir("validate_hosts_backup_rejects_broken_metadata");
+        let paths = test_paths(&test_dir);
+        std::fs::create_dir_all(&paths.runtime_dir).unwrap();
+        let source_path = test_dir.join("hosts");
+
+        std::fs::write(&source_path, "original").unwrap();
+        std::fs::write(&paths.hosts_backup_path, "backup").unwrap();
+        std::fs::write(&paths.hosts_backup_meta_path, "{not-json").unwrap();
+
+        let error = validate_hosts_backup(&paths, &source_path).unwrap_err();
+        assert!(
+            error
+                .to_string()
+                .contains("failed to parse hosts backup metadata")
+        );
+
+        cleanup_test_dir(&test_dir);
+    }
+
+    #[test]
+    fn clear_hosts_backup_removes_partial_and_temp_files() {
+        let test_dir = create_test_dir("clear_hosts_backup_removes_partial_and_temp_files");
+        let paths = test_paths(&test_dir);
+        std::fs::create_dir_all(&paths.runtime_dir).unwrap();
+
+        std::fs::write(&paths.hosts_backup_path, "backup").unwrap();
+        let backup_temp_path = paths
+            .hosts_backup_path
+            .with_file_name("hosts.backup.linuxdo-accelerator.tmp");
+        let meta_temp_path = paths
+            .hosts_backup_meta_path
+            .with_file_name("hosts.backup.json.linuxdo-accelerator.tmp");
+        std::fs::write(&backup_temp_path, "temp").unwrap();
+        std::fs::write(&meta_temp_path, "temp").unwrap();
+
+        clear_hosts_backup(&paths).unwrap();
+
+        assert_eq!(backup_state(&paths), BackupState::Missing);
+        assert!(!backup_temp_path.exists());
+        assert!(!meta_temp_path.exists());
+
+        cleanup_test_dir(&test_dir);
+    }
+
     #[cfg(windows)]
     #[test]
     fn windows_retryable_replace_errors_cover_common_lock_cases() {

src/service.rs

@@ -6,8 +6,10 @@ use anyhow::{Result, bail};
 
 use crate::certs::{ensure_bundle, load_or_create_bundle};
 use crate::config::AppConfig;
-use crate::hosts::{apply_hosts, backup_hosts_file, remove_hosts, restore_hosts_file};
-use crate::hosts_store::{BackupState, backup_state};
+use crate::hosts::{
+    apply_hosts, backup_hosts_file, remove_hosts, restore_hosts_file, validate_hosts_backup_file,
+};
+use crate::hosts_store::{BackupState, backup_state, clear_hosts_backup};
 use crate::paths::AppPaths;
 use crate::platform::{
     ensure_elevated, ensure_loopback_alias, install_ca, is_process_running, remove_loopback_alias,
@@ -376,19 +378,38 @@ fn terminate_running_service(paths: &AppPaths) -> Result<()> {
 
 fn cleanup_hosts_state(paths: &AppPaths) -> (String, Option<String>) {
     match backup_state(paths) {
-        BackupState::Ready => match restore_hosts_file(paths) {
-            Ok(()) => ("恢复原始 hosts".to_string(), None),
-            Err(error) => match remove_hosts(paths) {
-                Ok(()) => (
-                    "清理托管 hosts 规则（完整恢复失败）".to_string(),
-                    Some(format!(
-                        "failed to fully restore original hosts backup: {error:#}; cleanup fell back to removing the managed hosts block"
-                    )),
-                ),
+        BackupState::Ready => match validate_hosts_backup_file(paths) {
+            Ok(()) => match restore_hosts_file(paths) {
+                Ok(()) => ("恢复原始 hosts".to_string(), None),
+                Err(error) => match remove_hosts(paths) {
+                    Ok(()) => (
+                        "清理托管 hosts 规则（完整恢复失败）".to_string(),
+                        Some(format!(
+                            "failed to fully restore original hosts backup: {error:#}; cleanup fell back to removing the managed hosts block"
+                        )),
+                    ),
+                    Err(remove_error) => (
+                        "hosts 未清理".to_string(),
+                        Some(format!(
+                            "failed to fully restore original hosts backup: {error:#}; fallback removal also failed: {remove_error:#}"
+                        )),
+                    ),
+                },
+            },
+            Err(validation_error) => match remove_hosts(paths) {
+                Ok(()) => match clear_hosts_backup(paths) {
+                    Ok(()) => ("清理托管 hosts 规则并重置损坏的备份状态".to_string(), None),
+                    Err(clear_error) => (
+                        "清理托管 hosts 规则（备份损坏）".to_string(),
+                        Some(format!(
+                            "hosts backup is invalid: {validation_error:#}; managed hosts block was removed but clearing stale backup artifacts failed: {clear_error:#}"
+                        )),
+                    ),
+                },
                 Err(remove_error) => (
                     "hosts 未清理".to_string(),
                     Some(format!(
-                        "failed to fully restore original hosts backup: {error:#}; fallback removal also failed: {remove_error:#}"
+                        "hosts backup is invalid: {validation_error:#}; fallback removal failed: {remove_error:#}"
                     )),
                 ),
             },
@@ -401,14 +422,15 @@ fn cleanup_hosts_state(paths: &AppPaths) -> (String, Option<String>) {
             ),
         },
         BackupState::Inconsistent => match remove_hosts(paths) {
-            Ok(()) => (
-                "清理托管 hosts 规则（备份状态异常）".to_string(),
-                Some(format!(
-                    "hosts backup state is inconsistent; original hosts could not be fully restored (expected both {} and {})",
-                    paths.hosts_backup_path.display(),
-                    paths.hosts_backup_meta_path.display()
-                )),
-            ),
+            Ok(()) => match clear_hosts_backup(paths) {
+                Ok(()) => ("清理托管 hosts 规则并重置异常备份状态".to_string(), None),
+                Err(clear_error) => (
+                    "清理托管 hosts 规则（备份状态异常）".to_string(),
+                    Some(format!(
+                        "hosts backup state is inconsistent; managed hosts block was removed but clearing stale backup artifacts failed: {clear_error:#}"
+                    )),
+                ),
+            },
             Err(error) => (
                 "hosts 未清理".to_string(),
                 Some(format!(