Files
coa-server-manager/crates/coa-core/src/diag.rs
T

1409 lines
50 KiB
Rust

//! Diagnostics: a fixed list of read-only checks with plain-language results, a verification of the Manager's own files,
//! and a redacted diagnostic package for bug reports. Nothing here changes the server.
use std::fs;
use std::io::{Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};
use serde::Serialize;
use crate::config::parser::ConfFile;
use crate::error::{Error, Result};
use crate::fsx;
use crate::layout::{self, Classification};
use crate::process::{self, ServiceState};
use crate::registry::InstallMeta;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum Level {
Ok,
Warn,
Fail,
}
#[derive(Debug, Clone, Serialize)]
pub struct Check {
pub id: &'static str,
pub title: &'static str,
pub level: Level,
pub detail: String,
}
fn check(id: &'static str, title: &'static str, level: Level, detail: impl Into<String>) -> Check {
Check {
id,
title,
level,
detail: detail.into(),
}
}
#[derive(Debug, Serialize)]
pub struct Report {
pub checks: Vec<Check>,
pub problems: usize,
}
const MIN_FREE_BYTES: u64 = 5 * 1024 * 1024 * 1024;
pub fn run(root: &Path, meta: &InstallMeta) -> Report {
let mut c = Vec::new();
let scan = layout::scan(root);
match &scan {
Ok(r) => {
let (lvl, text) = match r.classification {
Classification::Healthy => (Level::Ok, "All expected server parts were found."),
Classification::Partial => (Level::Warn, "Some server parts are missing."),
Classification::UnknownCustom => (
Level::Warn,
"This is a custom server build; some features are limited.",
),
Classification::Incompatible => {
(Level::Fail, "This folder does not look like a CoA server.")
}
};
c.push(check("files", "Server files", lvl, text));
let missing: Vec<&str> = r
.items
.iter()
.filter(|i| {
i.status == layout::Status::Missing
&& i.key != "companions"
&& i.key != "release_info"
})
.map(|i| i.label)
.collect();
if !missing.is_empty() {
c.push(check(
"missing_parts",
"Missing parts",
Level::Warn,
missing.join(", "),
));
}
}
Err(e) => c.push(check("files", "Server files", Level::Fail, e.to_string())),
}
let ports = layout::read_ports(root);
let o = process::observe(root, &ports);
let mut services = vec![
("Database", &o.mysql),
("Login server", &o.auth),
("World server", &o.world),
];
if let Some(second) = &o.secondary_world {
services.push(("Second world", second));
}
if let Some(reborn) = &o.reborn_world {
services.push(("Warcraft Reborn world", reborn));
}
for (title, s) in services {
let (lvl, text) = match (s.state, &s.conflict) {
(ServiceState::Running, _) => (Level::Ok, "Running".to_string()),
(_, Some(conf)) => (
Level::Fail,
format!(
"Port {} is used by another program (process {}).",
conf.port, conf.pid
),
),
(ServiceState::Starting, _) => {
(Level::Warn, "Starting, not answering yet.".to_string())
}
_ => (Level::Warn, "Not running.".to_string()),
};
c.push(check(s.name, title, lvl, text));
}
// configuration files must at least be readable text the Manager can edit safely
let mut unreadable = Vec::new();
for rel in [
"Core/configs/worldserver.conf",
"Core/configs/authserver.conf",
"Settings/worldserver.conf.template",
"Settings/authserver.conf.template",
] {
let p = root.join(rel);
if p.is_file()
&& fs::read(&p)
.map(|b| ConfFile::parse_bytes(&b).is_err())
.unwrap_or(true)
{
unreadable.push(rel);
}
}
c.push(if unreadable.is_empty() {
check(
"configs",
"Configuration",
Level::Ok,
"Configuration files can be read.",
)
} else {
check(
"configs",
"Configuration",
Level::Fail,
format!("Cannot read: {}", unreadable.join(", ")),
)
});
for scope in [crate::config::Scope::Server, crate::config::Scope::Bots] {
if let Ok(v) = crate::config::load(root, scope) {
let bad: Vec<String> = v
.settings
.iter()
.filter(|s| s.problem.is_some())
.map(|s| s.meta.key.clone())
.collect();
if !bad.is_empty() {
c.push(check(
"config_values",
"Setting values",
Level::Warn,
format!("Unusable values for: {}", bad.join(", ")),
));
}
}
}
match fsx::free_space(root) {
Ok(f) if f >= MIN_FREE_BYTES => c.push(check(
"disk",
"Free disk space",
Level::Ok,
format!("{} GB free", f >> 30),
)),
Ok(f) => c.push(check(
"disk",
"Free disk space",
Level::Warn,
format!("Only {} GB free; backups and updates need room.", f >> 30),
)),
Err(e) => c.push(check("disk", "Free disk space", Level::Warn, e.to_string())),
}
let probe = root.join(".coa-write-test");
let writable = fs::write(&probe, b"x").is_ok();
let _ = fs::remove_file(&probe);
c.push(if writable { check("permissions", "Permissions", Level::Ok, "The server folder is writable.") } else { check("permissions", "Permissions", Level::Fail, "The Manager cannot write to the server folder (try another location or run once as administrator).") });
if let Some(path) = &meta.client_path {
c.push(if crate::client::detect(Path::new(path), None).is_some() {
check("client", "Game client", Level::Ok, path.clone())
} else {
check(
"client",
"Game client",
Level::Warn,
"The saved game folder was not found; choose it again in Settings.",
)
});
}
let exposure = if crate::docker::is_docker(root) {
crate::docker::exposure(root, &ports)
} else {
crate::net::exposure(&ports)
};
let exposed: Vec<&str> = exposure
.iter()
.filter(|e| {
(e.what == "database" || e.what == "server console") && e.reachable_from_network
})
.map(|e| e.what)
.collect();
c.push(if exposed.is_empty() {
check(
"exposure",
"Private services",
Level::Ok,
"Database and server console are not reachable from the network.",
)
} else {
check(
"exposure",
"Private services",
Level::Fail,
format!("Reachable from the network: {}.", exposed.join(", ")),
)
});
let problems = c.iter().filter(|x| x.level != Level::Ok).count();
Report {
checks: c,
problems,
}
}
#[derive(Debug, Serialize)]
pub struct FileProblem {
pub path: String,
pub kind: &'static str,
}
/// Compare managed files with the hashes the Manager recorded. Read-only; user files are never listed.
pub fn verify_managed(root: &Path, meta: &InstallMeta) -> Vec<FileProblem> {
let mut out = Vec::new();
for (rel, want) in &meta.original_hashes {
let lower = rel.replace('\\', "/").to_lowercase();
if lower.starts_with("mysql/data/")
|| lower.starts_with("settings/")
|| lower.starts_with("core/configs/") && !lower.ends_with(".dist")
{
continue;
}
let Ok(p) = fsx::safe_join(root, rel) else {
continue;
};
match fsx::sha256_file(&p) {
Err(_) => out.push(FileProblem {
path: rel.clone(),
kind: "missing",
}),
Ok(h) if !h.eq_ignore_ascii_case(want) => out.push(FileProblem {
path: rel.clone(),
kind: "changed",
}),
Ok(_) => {}
}
}
out
}
fn tail(path: &Path, max: u64) -> Vec<u8> {
let Ok(mut f) = fs::File::open(path) else {
return Vec::new();
};
let len = f.metadata().map(|m| m.len()).unwrap_or(0);
let _ = f.seek(SeekFrom::Start(len.saturating_sub(max)));
let mut b = Vec::new();
let _ = f.take(max).read_to_end(&mut b);
b
}
/// Keep the first line of each repeated "Missing property X" warning and report how often it came.
pub fn squash_repeated_config_warnings(text: &str) -> String {
let mut counts: Vec<(String, usize)> = Vec::new();
let mut out: Vec<&str> = Vec::new();
for line in text.lines() {
let key = line
.strip_prefix("> Config: Missing property ")
.and_then(|r| r.split_whitespace().next());
match key {
Some(k) => match counts.iter_mut().find(|(n, _)| n == k) {
Some((_, c)) => *c += 1,
None => {
counts.push((k.to_string(), 1));
out.push(line);
}
},
None => out.push(line),
}
}
let mut s = out.join("\n");
for (k, c) in counts.iter().filter(|(_, c)| *c > 1) {
s.push_str(&format!(
"
[Manager: \"Missing property {k}\" was logged {c} times in this excerpt]"
));
}
s
}
pub const SENSITIVE: &[&str] = &[
"password",
"passwd",
"secret",
"token",
"apikey",
"api_key",
"databaseinfo",
"private_key",
"privkey",
"signing_key",
"secret_key",
"seed",
"salt",
"verifier",
"srp_",
"session_key",
"sessionkey",
"pin",
"transfer_pin",
"bearer",
"authorization:",
"character_body",
"chunk_payload",
"payload_b64",
"tunnel_body",
"tunnel_msg",
"packet_body",
"relay_payload",
"noise_key",
"cipher_key",
"static_priv",
"ephemeral_priv",
"remoteaccess",
"ra.password",
];
/// Transparent wrapper that redacts contents when formatted with Display or Debug.
#[derive(Clone, Copy, PartialEq, Eq, Default)]
pub struct Redacted<T>(pub T);
impl<T> std::fmt::Debug for Redacted<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "[REDACTED]")
}
}
impl<T> std::fmt::Display for Redacted<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "[REDACTED]")
}
}
impl<T> std::ops::Deref for Redacted<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<T> std::ops::DerefMut for Redacted<T> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
/// Helper for tests and audit to scan an arbitrary text or archive for sentinel secrets.
/// Returns the list of sentinel matches found.
pub fn scan_for_sentinels(text: &str, sentinels: &[&str]) -> Vec<String> {
let mut found = Vec::new();
for s in sentinels {
if !s.is_empty() && text.contains(s) {
found.push((*s).to_string());
}
}
found
}
/// Remove things that must never leave the machine from log text.
pub fn redact(text: &str) -> String {
let mut out = Vec::new();
for line in text.lines() {
let l = line.to_lowercase();
let sensitive = SENSITIVE.iter().any(|k| {
if *k == "pin" {
l.match_indices("pin")
.any(|(at, _)| at == 0 || !l.as_bytes()[at - 1].is_ascii_alphanumeric())
} else {
l.contains(k)
}
});
out.push(if sensitive {
"[line removed: may contain a secret]".to_string()
} else {
line.to_string()
});
}
out.join("\n")
}
/// The same for JSON: values under a sensitive key and strings that look like `password=...` are replaced, and the
/// result stays valid JSON (removing a whole line would break the file for whoever reads it). Text that is not JSON
/// falls back to the line rule.
pub fn redact_json(text: &str) -> String {
fn scrub(v: &mut serde_json::Value) {
use serde_json::Value;
match v {
Value::Object(map) => {
for (key, value) in map.iter_mut() {
let k = key.to_lowercase();
if SENSITIVE.iter().any(|s| k.contains(s))
&& !value.is_object()
&& !value.is_array()
{
*value = Value::String("[redacted]".into());
} else {
scrub(value);
}
}
}
Value::Array(items) => items.iter_mut().for_each(scrub),
Value::String(s) => {
let l = s.to_lowercase();
if [
"password=",
"passwd=",
"secret=",
"token=",
"apikey=",
"api_key=",
"password:",
"salt=",
"verifier=",
"pin=",
"bearer ",
"private_key=",
"privkey=",
"key=",
"seed=",
"session_key=",
"payload=",
]
.iter()
.any(|k| l.contains(k))
{
*s = "[redacted]".into();
}
}
_ => {}
}
}
match serde_json::from_str::<serde_json::Value>(text) {
Ok(mut v) => {
scrub(&mut v);
serde_json::to_string_pretty(&v).unwrap_or_else(|_| redact(text))
}
Err(_) => redact(text),
}
}
/// Keep the events of a `wevtutil ... /f:text` listing that mention one of `needles` (compared without case), in the
/// order listed, at most `max` of them.
pub fn filter_event_blocks(listing: &str, needles: &[&str], max: usize) -> String {
let mut blocks: Vec<Vec<&str>> = Vec::new();
for line in listing.lines() {
if line.starts_with("Event[") || blocks.is_empty() {
blocks.push(Vec::new());
}
if let Some(b) = blocks.last_mut() {
b.push(line);
}
}
blocks
.into_iter()
.map(|b| b.join("\n"))
.filter(|b| {
let l = b.to_lowercase();
needles.iter().any(|n| l.contains(n))
})
.take(max)
.collect::<Vec<_>>()
.join("\n\n")
}
/// Drop the lines of an event listing that name the person or the computer.
pub fn drop_identity_lines(listing: &str) -> String {
listing
.lines()
.filter(|l| {
let t = l.trim_start();
!(t.starts_with("User:") || t.starts_with("User Name:") || t.starts_with("Computer:"))
})
.collect::<Vec<_>>()
.join("\n")
}
/// `wevtutil /uni:true` writes UTF-16 with a byte order mark; anything else is read as UTF-8 (lossy).
fn decode_console_output(bytes: &[u8]) -> String {
if bytes.starts_with(&[0xFF, 0xFE]) {
let units: Vec<u16> = bytes[2..]
.as_chunks::<2>()
.0
.iter()
.map(|c| u16::from_le_bytes([c[0], c[1]]))
.collect();
String::from_utf16_lossy(&units)
} else {
String::from_utf8_lossy(bytes).into_owned()
}
}
/// Crashes and hangs Windows recorded for the server programs in the last two weeks. This is the only trace of a crash
/// that ends the process without the server's own crash report (a stack buffer overrun, for example). The lines that
/// name the user and the computer are left out.
#[cfg(windows)]
fn windows_events() -> String {
use std::os::windows::process::CommandExt;
let query = "*[System[(Provider[@Name='Application Error' or @Name='Windows Error Reporting' or @Name='Application Hang']) and TimeCreated[timediff(@SystemTime) <= 1209600000]]]";
let out = std::process::Command::new("wevtutil")
.args([
"qe",
"Application",
&format!("/q:{query}"),
"/c:300",
"/rd:true",
"/f:text",
"/uni:true",
])
.creation_flags(0x0800_0000)
.output();
match out {
Ok(o) if o.status.success() => {
let text = filter_event_blocks(
&decode_console_output(&o.stdout),
&[
"worldserver",
"authserver",
"mysqld",
"coa server manager",
"coa-server-manager",
],
40,
);
if text.is_empty() {
"No crash or hang of the server programs was recorded by Windows in the last 14 days.".into()
} else {
drop_identity_lines(&text)
}
}
Ok(o) => format!(
"Windows event log could not be read: {}",
decode_console_output(&o.stderr).trim()
),
Err(e) => format!("Windows event log could not be read: {e}"),
}
}
#[cfg(not(windows))]
fn windows_events() -> String {
String::new()
}
/// Newest files of a folder with the given extension (compared without case): path, size, modified time.
fn newest_files(dir: &Path, ext: &str, limit: usize) -> Vec<(PathBuf, u64, std::time::SystemTime)> {
let Ok(rd) = fs::read_dir(dir) else {
return Vec::new();
};
let mut v: Vec<_> = rd
.flatten()
.filter(|e| {
e.path()
.extension()
.is_some_and(|x| x.eq_ignore_ascii_case(ext))
})
.filter_map(|e| {
let m = e.metadata().ok()?;
m.is_file().then(|| {
(
e.path(),
m.len(),
m.modified().unwrap_or(std::time::UNIX_EPOCH),
)
})
})
.collect();
v.sort_by(|a, b| b.2.cmp(&a.2));
v.truncate(limit);
v
}
/// Which server programs run right now and from where, next to what the Manager made of it. A program started from a
/// folder or a copy the Manager does not know shows up here even when the Manager reports "port in use".
fn processes_report(root: &Path, ports: &layout::Ports) -> String {
let here = root.to_string_lossy().to_lowercase().replace('/', "\\");
let listen = process::listeners_detailed();
let mut out = String::from("Server programs running now (any folder):\n");
let found = process::find_by_file_names(&["worldserver.exe", "authserver.exe", "mysqld.exe"]);
if found.is_empty() {
out.push_str(" none\n");
}
for p in found {
let ports_of: Vec<String> = listen
.iter()
.filter(|l| l.pid == p.pid)
.map(|l| l.port.to_string())
.collect();
let inside = p.exe.to_lowercase().replace('/', "\\").starts_with(&here);
out.push_str(&format!(
" pid {} {} | listening on: {} | {}\n",
p.pid,
p.exe,
if ports_of.is_empty() {
"-".into()
} else {
ports_of.join(", ")
},
if inside {
"inside this server folder"
} else {
"OUTSIDE this server folder"
}
));
}
let o = process::observe(root, ports);
out.push_str("\nThe Manager's view:\n");
for s in [
Some(&o.mysql),
Some(&o.auth),
Some(&o.world),
o.secondary_world.as_ref(),
o.reborn_world.as_ref(),
]
.into_iter()
.flatten()
{
out.push_str(&format!(
" {:<16} {:?} port {} {}{}\n",
s.name,
s.state,
s.port,
s.pid.map(|p| format!("pid {p}")).unwrap_or_default(),
s.conflict
.as_ref()
.map(|c| format!(
" | port held by pid {} {}",
c.pid,
c.exe.clone().unwrap_or_default()
))
.unwrap_or_default()
));
}
out
}
/// Zip with what a maintainer needs to debug a problem, with secrets removed. Returns the number of files inside.
/// One call collects everything: the Manager's and the server's logs, crash reports and small crash dumps, Windows'
/// own record of crashes, the update journals, the running server programs and the settings the client depends on.
pub fn export_package(
root: &Path,
meta_dir: &Path,
manager_log: &Path,
meta: &InstallMeta,
report: &Report,
out_zip: &Path,
) -> Result<usize> {
const DUMP_FILE_MAX: u64 = 30 * 1024 * 1024;
let file = fs::File::create(out_zip)?;
let mut zip = zip::ZipWriter::new(file);
let opts = zip::write::SimpleFileOptions::default()
.compression_method(zip::CompressionMethod::Deflated);
let mut n = 0;
let mut add = |name: &str, bytes: &[u8]| -> Result<()> {
zip.start_file(name, opts)
.map_err(|e| Error::Invalid(e.to_string()))?;
zip.write_all(bytes)?;
n += 1;
Ok(())
};
let ports = layout::read_ports(root);
let summary = serde_json::json!({
"manager": crate::MANAGER_VERSION,
"exported_utc": chrono::Utc::now().to_rfc3339(),
"core": meta.core,
"bots": meta.bots,
"squid_bots": crate::squid::release(root),
"kind": meta.kind,
"layout": meta.layout,
"checks": report.checks,
"wow_client_set": meta.client_path.is_some(),
});
add(
"summary.json",
serde_json::to_string_pretty(&summary)?.as_bytes(),
)?;
let owner = fs::read_to_string(meta_dir.join("update-lock-owner.json"))
.ok()
.and_then(|text| serde_json::from_str::<serde_json::Value>(&redact_json(&text)).ok());
let maintenance = serde_json::json!({
"lockFilePresent": meta_dir.join("update.lock").is_file(),
"lastRecordedOwner": owner,
"note": "The lock file and owner record may remain after completion. Their presence does not establish whether the OS lock is currently held."
});
add(
"maintenance.json",
serde_json::to_string_pretty(&maintenance)?.as_bytes(),
)?;
for (realm, prefix) in [("primary", ""), ("secondary", ".realms/secondary/"), ("reborn", ".realms/reborn/")] {
let state = root.join(format!("{prefix}.state"));
if let Ok(owner) = fs::read_to_string(state.join("control-owner.json")) {
add(&format!("launcher/{realm}/control-owner.json"), redact_json(&owner).as_bytes())?;
}
for (path, _, _) in newest_files(&state.join("diagnostics"), "jsonl", 20)
.into_iter()
.filter(|(path, _, _)| path.file_name().is_some_and(|name| name.to_string_lossy().starts_with("manage-")))
.take(5)
{
let bytes = tail(&path, 512 * 1024);
let entries: Vec<serde_json::Value> = String::from_utf8_lossy(&bytes).lines().map(|line| {
serde_json::from_str(&redact_json(line)).unwrap_or_else(|_| serde_json::Value::String(redact(line)))
}).collect();
add(&format!("launcher/{realm}/{}.json", path.file_stem().unwrap_or_default().to_string_lossy()),
serde_json::to_string_pretty(&entries)?.as_bytes())?;
}
}
// Logs. The newest update logs of the repack's own updater are added under their own names.
let mut logs: Vec<(String, PathBuf)> = vec![
("manager.log".into(), manager_log.to_path_buf()),
(
"manager-install.log".into(),
meta_dir.join("logs/manager.log"),
),
("Server.log.tail".into(), root.join("Core/Logs/Server.log")),
("Errors.log.tail".into(), root.join("Core/Logs/Errors.log")),
("Auth.log.tail".into(), root.join("Core/Logs/Auth.log")),
(
"world-console.log.tail".into(),
root.join("Core/Logs/world-console.log"),
),
(
"CoaBots.log.tail".into(),
root.join("Core/Logs/CoaBots.log"),
),
(
"Playerbots.log.tail".into(),
root.join("Core/Logs/Playerbots.log"),
),
(
"supervisor.log.tail".into(),
root.join("Core/Logs/supervisor.log"),
),
(
"mysql-error.log.tail".into(),
root.join("mysql/logs/mysql-error.log"),
),
];
let updater_logs = newest_files(&root.join("Core/Logs"), "log", usize::MAX)
.into_iter()
.filter(|(p, _, _)| {
p.file_name()
.is_some_and(|f| f.to_string_lossy().to_lowercase().starts_with("update-"))
});
for (p, _, _) in updater_logs.take(2) {
logs.push((
format!(
"{}.tail",
p.file_name().unwrap_or_default().to_string_lossy()
),
p,
));
}
for (name, path) in logs {
// A module that reads a missing setting on every tick fills a log with one warning, thousands of times; read far
// enough back to see past that, fold the repeats, then keep the last part.
let bytes = tail(&path, 8 * 1024 * 1024);
if !bytes.is_empty() {
let text = squash_repeated_config_warnings(&String::from_utf8_lossy(&bytes));
let keep = text.len().saturating_sub(512 * 1024);
let start = (keep..text.len())
.find(|i| text.is_char_boundary(*i))
.unwrap_or(text.len());
add(&name, redact(&text[start..]).as_bytes())?;
}
}
// Crash reports of the server (text, and the small dumps next to them), and what Windows recorded for the programs.
let crashes = root.join("Core/Crashes");
let mut listing = String::new();
for (p, len, _) in newest_files(&crashes, "txt", 10) {
let name = p
.file_name()
.unwrap_or_default()
.to_string_lossy()
.into_owned();
listing.push_str(&format!("{name} ({len} bytes)\n"));
let text = String::from_utf8_lossy(&tail(&p, 1024 * 1024)).into_owned();
add(&format!("crashes/{name}"), redact(&text).as_bytes())?;
}
for (p, len, _) in newest_files(&crashes, "dmp", 3) {
let name = p
.file_name()
.unwrap_or_default()
.to_string_lossy()
.into_owned();
if len > DUMP_FILE_MAX {
listing.push_str(&format!(
"{name} ({len} bytes) not included: larger than {} MB\n",
DUMP_FILE_MAX >> 20
));
} else if let Ok(bytes) = fs::read(&p) {
listing.push_str(&format!("{name} ({len} bytes) included\n"));
add(&format!("crashes/{name}"), &bytes)?;
}
}
add(
"crashes.txt",
if listing.is_empty() {
"No crash reports in Core/Crashes.".to_string()
} else {
listing
}
.as_bytes(),
)?;
let events = windows_events();
if !events.is_empty() {
add("windows-events.txt", events.as_bytes())?;
}
add("processes.txt", processes_report(root, &ports).as_bytes())?;
// The newest update journals: the state of each update and the reason it failed.
for (path, size, _) in newest_files(&meta_dir.join("diagnostics"), "json", usize::MAX)
.into_iter()
.filter(|(path, _, _)| {
path.file_name().is_some_and(|name| {
let name = name.to_string_lossy();
name.starts_with("schema-validation-")
|| name.starts_with("database-recovery-")
|| name.starts_with("database-rehearsal-")
|| name.starts_with("database-restore-")
|| name.starts_with("database-repair-")
})
})
.take(10)
{
if size <= 4 * 1024 * 1024 {
if let Ok(text) = fs::read_to_string(&path) {
add(
&format!("schema/{}", path.file_name().unwrap().to_string_lossy()),
redact_json(&text).as_bytes(),
)?;
}
}
}
let mut journals: Vec<_> = fs::read_dir(meta_dir.join("updates"))
.into_iter()
.flatten()
.flatten()
.filter(|e| {
e.file_type().is_ok_and(|t| t.is_dir())
&& e.file_name()
.to_string_lossy()
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_'))
})
.collect();
journals.sort_by_key(|e| std::cmp::Reverse(e.file_name()));
for e in journals.into_iter().take(5) {
if let Ok(text) = fs::read_to_string(e.path().join("txn.json")) {
add(
&format!("updates/{}-txn.json", e.file_name().to_string_lossy()),
redact_json(&text).as_bytes(),
)?;
}
}
// Which files the server's own configuration folders hold, and the two CoA switches that decide whether the game
// client can talk to the world server at all.
let mut present = String::new();
for dir in ["Core/configs", "Core/configs/modules", "Core/Logs"] {
if let Ok(rd) = fs::read_dir(root.join(dir)) {
let mut names: Vec<String> = rd
.flatten()
.filter(|e| e.path().is_file())
.map(|e| {
format!(
"{dir}/{} ({} bytes)",
e.file_name().to_string_lossy(),
e.metadata().map(|m| m.len()).unwrap_or(0)
)
})
.collect();
names.sort();
present.push_str(&names.join("\n"));
present.push('\n');
}
}
add("files.txt", present.as_bytes())?;
if let Ok(b) = fs::read(root.join("Core/configs/modules/coa.conf")) {
if let Ok(c) = ConfFile::parse_bytes(&b) {
let wanted = [
"CoA.Enable",
"CoA.AllowRemoteClients",
"CoA.MapClass10ToWarrior",
];
let lines: Vec<String> = c
.entries()
.filter(|(k, _)| wanted.contains(k))
.map(|(k, v)| format!("{k} = {v}"))
.collect();
add("coa.conf.txt", lines.join("\n").as_bytes())?;
}
}
// Which settings exist, never their values.
if let Ok(b) = fs::read(root.join("Core/configs/worldserver.conf")) {
if let Ok(c) = ConfFile::parse_bytes(&b) {
let keys: Vec<&str> = c.entries().map(|(k, _)| k).collect();
add("worldserver.conf.keys.txt", keys.join("\n").as_bytes())?;
}
}
if let Ok(b) = fs::read(root.join("RELEASE.json")) {
add(
"RELEASE.json",
redact_json(&String::from_utf8_lossy(&b)).as_bytes(),
)?;
}
if let Ok(b) = fs::read(meta_dir.join("logs/database-checks.json")) {
add(
"database-checks.json",
redact_json(&String::from_utf8_lossy(&b)).as_bytes(),
)?;
}
zip.finish().map_err(|e| Error::Invalid(e.to_string()))?;
Ok(n)
}
pub fn stamp() -> String {
chrono::Local::now().format("%Y%m%d-%H%M%S").to_string()
}
#[cfg(windows)]
pub fn desktop_or_temp() -> PathBuf {
let d = std::env::var_os("USERPROFILE")
.map(PathBuf::from)
.unwrap_or_else(std::env::temp_dir)
.join("Desktop");
if d.is_dir() {
d
} else {
std::env::temp_dir()
}
}
/// Where a file meant for the person goes on Linux: the desktop folder they have (the XDG user directories file names it), else
/// `~/Desktop`, else `~/Downloads`, else the temporary folder.
#[cfg(not(windows))]
pub fn desktop_or_temp() -> PathBuf {
let Some(home) = std::env::var_os("HOME").map(PathBuf::from) else {
return std::env::temp_dir();
};
let dirs = std::fs::read_to_string(home.join(".config/user-dirs.dirs")).ok();
pick_desktop(&home, dirs.as_deref(), &|p| p.is_dir())
}
#[cfg(not(windows))]
fn pick_desktop(home: &Path, user_dirs: Option<&str>, exists: &dyn Fn(&Path) -> bool) -> PathBuf {
let named = user_dirs.and_then(|t| {
t.lines().find_map(|l| {
let v = l.trim().strip_prefix("XDG_DESKTOP_DIR=")?.trim_matches('"');
Some(PathBuf::from(v.replace("$HOME", &home.to_string_lossy())))
})
});
// A user without a desktop sets XDG_DESKTOP_DIR to the home folder itself: that is not a place to drop files into.
[
named,
Some(home.join("Desktop")),
Some(home.join("Downloads")),
]
.into_iter()
.flatten()
.filter(|p| p != home)
.find(|p| exists(p))
.unwrap_or_else(std::env::temp_dir)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::registry::{InstallKind, InstallMeta};
#[cfg(not(windows))]
#[test]
fn the_desktop_folder_on_linux_follows_the_users_own_directories() {
let home = Path::new("/home/ana");
let only =
|wanted: &'static [&'static str]| move |p: &Path| wanted.contains(&p.to_str().unwrap());
let dirs =
"# comment\nXDG_DOWNLOAD_DIR=\"$HOME/Downloads\"\nXDG_DESKTOP_DIR=\"$HOME/Bureau\"\n";
assert_eq!(
pick_desktop(
home,
Some(dirs),
&only(&["/home/ana/Bureau", "/home/ana/Desktop"])
),
PathBuf::from("/home/ana/Bureau")
);
assert_eq!(
pick_desktop(home, None, &only(&["/home/ana/Desktop"])),
PathBuf::from("/home/ana/Desktop")
);
assert_eq!(
pick_desktop(home, Some(dirs), &only(&["/home/ana/Downloads"])),
PathBuf::from("/home/ana/Downloads")
);
assert_eq!(pick_desktop(home, None, &only(&[])), std::env::temp_dir());
// No desktop: the user directories file names the home folder itself.
let none = "XDG_DESKTOP_DIR=\"$HOME/\"\n";
assert_eq!(
pick_desktop(
home,
Some(none),
&only(&["/home/ana", "/home/ana/Downloads"])
),
PathBuf::from("/home/ana/Downloads")
);
}
#[test]
fn repeated_config_warnings_are_folded() {
let t = "start
> Config: Missing property A.B in config file x or module config, add y
> Config: Missing property A.B in config file x
real error
> Config: Missing property C.D in config file x
> Config: Missing property A.B in config file x";
let out = squash_repeated_config_warnings(t);
assert_eq!(
out.matches("Missing property A.B in config file").count(),
1
);
assert!(out.contains("real error") && out.contains("C.D"));
assert!(out.contains("\"Missing property A.B\" was logged 3 times"));
assert!(!out.contains("C.D\" was logged"));
}
#[test]
fn redaction_removes_lines_that_could_carry_secrets() {
let t = redact("normal line\nLoginDatabaseInfo = \"127.0.0.1;3307;acore;PASS;db\"\nRa.Password=abc\nother");
assert!(t.contains("normal line") && t.contains("other"));
assert!(!t.contains("PASS") && !t.contains("abc"));
}
#[test]
fn stop_diagnostics_survive_while_portable_pins_remain_hidden() {
let ordinary = "MySQL is still stopping; wait before copying the repack.";
assert_eq!(redact(ordinary), ordinary);
for secret in [
"PIN: 123456",
"pin=123456",
"transfer_pin=123456",
"PIN123456",
] {
let output = redact(&format!("{ordinary}\n{secret}"));
assert!(output.contains(ordinary));
assert!(!output.contains("123456"));
}
}
#[test]
fn json_redaction_keeps_the_file_valid_and_hides_the_secrets() {
let t = redact_json(
r#"{"id":"rev_20261006_token_cache","password":"hunter2","nested":{"apiKey":"k","note":"login with password=abc"},"list":[{"secret":1},"ok"]}"#,
);
let v: serde_json::Value = serde_json::from_str(&t).expect("still JSON");
assert_eq!(
v["id"], "rev_20261006_token_cache",
"an id that merely contains a word is kept"
);
assert_eq!(v["password"], "[redacted]");
assert_eq!(v["nested"]["apiKey"], "[redacted]");
assert_eq!(v["nested"]["note"], "[redacted]");
assert_eq!(v["list"][0]["secret"], "[redacted]");
assert_eq!(v["list"][1], "ok");
assert!(!t.contains("hunter2") && !t.contains("abc"));
assert!(
redact_json("not json\nPassword=1").contains("[line removed"),
"text falls back to the line rule"
);
}
#[test]
fn windows_events_are_filtered_to_the_server_programs() {
let listing = "Event[0]:\n Provider Name: Application Error\n Description: Faulting application name: worldserver.exe, version: 0.0.0.0\n\nEvent[1]:\n Provider Name: Application Error\n Description: Faulting application name: notepad.exe\n\nEvent[2]:\n Description: Faulting application name: MYSQLD.EXE\n";
let out = filter_event_blocks(listing, &["worldserver", "mysqld"], 10);
assert!(
out.contains("worldserver.exe")
&& out.contains("MYSQLD.EXE")
&& !out.contains("notepad")
);
assert_eq!(
filter_event_blocks(listing, &["worldserver", "mysqld"], 1)
.matches("Event[")
.count(),
1
);
}
#[test]
fn event_text_loses_the_user_and_computer_lines_and_reads_utf16() {
let out = drop_identity_lines("Event[0]\n Source: Application Error\n User: S-1-5-21-1\n User Name: PC\\Dion\n Computer: PC\n Description: worldserver.exe");
assert!(out.contains("Source") && out.contains("worldserver.exe"));
assert!(!out.contains("S-1-5") && !out.contains("Dion") && !out.contains("Computer"));
let mut bytes = vec![0xFF, 0xFE];
for u in "Сбой worldserver".encode_utf16() {
bytes.extend_from_slice(&u.to_le_bytes());
}
assert_eq!(decode_console_output(&bytes), "Сбой worldserver");
assert_eq!(decode_console_output(b"plain"), "plain");
}
#[test]
fn the_package_carries_crash_reports_update_journals_and_the_process_view() {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("srv");
layout::testkit::fake_repack(&root);
fs::create_dir_all(root.join("Core/Crashes")).unwrap();
fs::write(
root.join("Core/Crashes/567e_worldserver.exe_[4-10_21-25-31].txt"),
"Exception code: C0000005\nRCX:0\n",
)
.unwrap();
fs::write(
root.join("Core/Crashes/567e_worldserver.exe_[4-10_21-25-31].dmp"),
b"MDMP-small",
)
.unwrap();
fs::write(root.join("Core/Logs/CoaBots.log"), "bot line\n").unwrap();
fs::write(
root.join("Core/Logs/update-1.8-20261005.log"),
"updater line\n",
)
.unwrap();
let meta_dir = d.path().join("srv.manager");
fs::create_dir_all(meta_dir.join("updates/20261006-082021-0_261006_1-abc")).unwrap();
fs::write(meta_dir.join("updates/20261006-082021-0_261006_1-abc/txn.json"), r#"{"state":"rolled-back","message":"Database update 2026_02_24_00 failed: duplicate column"}"#).unwrap();
fs::create_dir_all(meta_dir.join("updates/not a journal!")).unwrap();
let meta = InstallMeta::new(InstallKind::Imported, &root);
let report = run(&root, &meta);
let zip_path = d.path().join("diag.zip");
export_package(
&root,
&meta_dir,
&d.path().join("none.log"),
&meta,
&report,
&zip_path,
)
.unwrap();
let mut z = zip::ZipArchive::new(fs::File::open(&zip_path).unwrap()).unwrap();
let names: Vec<String> = (0..z.len())
.map(|i| z.by_index(i).unwrap().name().to_string())
.collect();
for want in [
"crashes.txt",
"processes.txt",
"CoaBots.log.tail",
"update-1.8-20261005.log.tail",
"updates/20261006-082021-0_261006_1-abc-txn.json",
"crashes/567e_worldserver.exe_[4-10_21-25-31].txt",
"crashes/567e_worldserver.exe_[4-10_21-25-31].dmp",
] {
assert!(
names.iter().any(|n| n == want),
"{want} is in the package: {names:?}"
);
}
assert!(!names.iter().any(|n| n.contains("not a journal")));
let mut listing = String::new();
z.by_name("crashes.txt")
.unwrap()
.read_to_string(&mut listing)
.unwrap();
assert!(listing.contains("included"));
}
#[test]
fn verify_reports_missing_and_changed_managed_files_only() {
let d = tempfile::tempdir().unwrap();
fs::write(d.path().join("ok.txt"), "a").unwrap();
fs::write(d.path().join("changed.txt"), "b").unwrap();
fs::write(d.path().join("user.txt"), "mine").unwrap();
let mut meta = InstallMeta::new(InstallKind::New, d.path());
meta.original_hashes
.insert("ok.txt".into(), fsx::sha256_bytes(b"a"));
meta.original_hashes
.insert("changed.txt".into(), fsx::sha256_bytes(b"original"));
meta.original_hashes
.insert("gone.txt".into(), fsx::sha256_bytes(b"x"));
let mut p: Vec<(String, &str)> = verify_managed(d.path(), &meta)
.into_iter()
.map(|f| (f.path, f.kind))
.collect();
p.sort();
assert_eq!(
p,
[
("changed.txt".to_string(), "changed"),
("gone.txt".to_string(), "missing")
]
);
}
#[test]
fn diagnostics_on_a_fake_repack_flag_the_stopped_services_and_pass_the_basics() {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("srv");
layout::testkit::fake_repack(&root);
let meta = InstallMeta::new(InstallKind::Imported, &root);
let r = run(&root, &meta);
let get = |id: &str| {
r.checks
.iter()
.find(|c| c.id == id)
.unwrap_or_else(|| panic!("{id}"))
};
assert_eq!(get("files").level, Level::Ok);
assert_eq!(get("permissions").level, Level::Ok);
assert_eq!(get("configs").level, Level::Ok);
assert_ne!(
get("world").level,
Level::Ok,
"a stopped server is reported, not hidden"
);
assert!(r.problems >= 3);
}
#[test]
fn exported_package_holds_no_secrets() {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("srv");
layout::testkit::fake_repack(&root);
fs::create_dir_all(root.join("Extras/SquidPlayerbots")).unwrap();
fs::write(
root.join("Extras/SquidPlayerbots/release.json"),
r#"{"tag":"v1.8","commit":"48c4786a","password":"upstream-secret"}"#,
)
.unwrap();
fs::write(
root.join("Core/Logs/Errors.log"),
"boom\nDatabase password=hunter2 rejected\n",
)
.unwrap();
fs::write(
root.join("Core/configs/worldserver.conf"),
"LoginDatabaseInfo = \"127.0.0.1;3307;acore;SECRETPW;auth\"\nRate.XP.Kill = 1\n",
)
.unwrap();
let meta_dir = d.path().join("srv.manager");
fs::create_dir_all(&meta_dir).unwrap();
fs::write(meta_dir.join("update.lock"), b"").unwrap();
fs::write(meta_dir.join("update-lock-owner.json"), r#"{"operation":"checking updates","pid":1234,"started":"2026-10-13T01:00:00Z","token":"owner-secret"}"#).unwrap();
fs::create_dir_all(meta_dir.join("diagnostics")).unwrap();
fs::write(meta_dir.join("diagnostics/schema-validation-CoA-test.json"), r#"{"problems":[{"table":"creature_display_preset","column":"display_id","detail":"default mismatch"}],"password":"schema-secret"}"#).unwrap();
fs::write(meta_dir.join("diagnostics/database-recovery-test.json"), r#"{"objects":[{"database":"acore_characters","kind":"TRIGGER","name":"user_character_trigger"}],"password":"recovery-secret"}"#).unwrap();
for prefix in ["", ".realms/secondary/", ".realms/reborn/"] {
let state = root.join(format!("{prefix}.state"));
fs::create_dir_all(state.join("diagnostics")).unwrap();
fs::write(state.join("control-owner.json"), r#"{"pid":42,"action":"start-all","password":"launcher-owner-secret"}"#).unwrap();
fs::write(state.join("diagnostics/manage-test.jsonl"), "{\"event\":\"launcher-stage-test\",\"password\":\"launcher-stage-secret\"}\n{\"event\":\"wait_ready.error\",\"port\":3307}\n").unwrap();
}
let meta = InstallMeta::new(InstallKind::Imported, &root);
let report = run(&root, &meta);
let zip_path = d.path().join("diag.zip");
let n = export_package(
&root,
&meta_dir,
&d.path().join("none.log"),
&meta,
&report,
&zip_path,
)
.unwrap();
assert!(n >= 3);
let mut z = zip::ZipArchive::new(fs::File::open(&zip_path).unwrap()).unwrap();
let mut all = String::new();
for i in 0..z.len() {
let mut s = String::new();
let _ = z.by_index(i).unwrap().read_to_string(&mut s);
all.push_str(&s);
}
assert!(
all.contains("boom") && all.contains("Rate.XP.Kill"),
"keys and ordinary log lines are included"
);
assert!(all.contains("v1.8") && all.contains("48c4786a"));
assert!(all.contains("creature_display_preset") && all.contains("default mismatch"));
assert!(!all.contains("schema-secret"));
assert!(all.contains("user_character_trigger") && all.contains("acore_characters"));
assert!(!all.contains("recovery-secret"));
assert!(all.contains("checking updates") && all.contains("1234"));
assert!(all.contains("lockFilePresent") && all.contains("does not establish"));
assert!(!all.contains("owner-secret"));
assert!(all.contains("launcher-stage-test"));
assert!(all.contains("wait_ready.error"));
assert!(!all.contains("launcher-stage-secret"));
assert_eq!(fs::read(meta_dir.join("update.lock")).unwrap(), b"");
assert!(
!all.contains("hunter2")
&& !all.contains("SECRETPW")
&& !all.contains("upstream-secret")
);
}
#[test]
fn exported_package_holds_zero_sentinel_secrets_across_all_categories() {
let d = tempfile::tempdir().unwrap();
let root = d.path().join("srv");
layout::testkit::fake_repack(&root);
let sentinels = [
"SENTINEL_ACC_PASS_12345",
"SENTINEL_LEGACY_PASS_67890",
"SENTINEL_SRP_SALT_ABCDEF",
"SENTINEL_SRP_VERIFIER_FEDCBA",
"SENTINEL_PLAYER_PRIVKEY_010203",
"SENTINEL_REALM_PRIVKEY_040506",
"SENTINEL_DB_PASS_XYZ999",
"SENTINEL_RA_PASS_RA1234",
"SENTINEL_TRANSFER_PAYLOAD_CHUNK",
"SENTINEL_PORTABLE_CHAR_BODY",
"SENTINEL_NOISE_CIPHER_KEY",
"SENTINEL_RELAY_PACKET_BODY",
"SENTINEL_TRANSFER_PIN_7777",
];
// Seed logs and configs with sensitive entries holding these sentinels
fs::write(root.join("Core/Logs/Server.log"),
"Server startup\naccount_password = SENTINEL_ACC_PASS_12345\nlegacy_password: SENTINEL_LEGACY_PASS_67890\nsalt = SENTINEL_SRP_SALT_ABCDEF\nverifier = SENTINEL_SRP_VERIFIER_FEDCBA\n"
).unwrap();
fs::write(root.join("Core/Logs/Auth.log"),
"Auth connect\nprivate_key = SENTINEL_PLAYER_PRIVKEY_010203\nsigning_key = SENTINEL_REALM_PRIVKEY_040506\nnoise_key = SENTINEL_NOISE_CIPHER_KEY\n"
).unwrap();
fs::write(root.join("Core/Logs/world-console.log"),
"Console connect\nra.password = SENTINEL_RA_PASS_RA1234\ntransfer_pin = SENTINEL_TRANSFER_PIN_7777\n"
).unwrap();
fs::write(root.join("Core/Logs/Errors.log"),
"Fatal failure\nchunk_payload = SENTINEL_TRANSFER_PAYLOAD_CHUNK\ncharacter_body = SENTINEL_PORTABLE_CHAR_BODY\ntunnel_body = SENTINEL_RELAY_PACKET_BODY\n"
).unwrap();
fs::write(
root.join("Core/configs/worldserver.conf"),
"LoginDatabaseInfo = \"127.0.0.1;3307;acore;SENTINEL_DB_PASS_XYZ999;auth\"\n",
)
.unwrap();
let meta_dir = d.path().join("srv.manager");
fs::create_dir_all(meta_dir.join("updates/20261009-120000-0_test-abc")).unwrap();
fs::write(
meta_dir.join("updates/20261009-120000-0_test-abc/txn.json"),
format!(
r#"{{"secret_token":"{}","nested":{{"transfer_pin":"{}"}}}}"#,
"SENTINEL_TRANSFER_PIN_7777", "SENTINEL_TRANSFER_PIN_7777"
),
)
.unwrap();
let meta = InstallMeta::new(InstallKind::Imported, &root);
let report = run(&root, &meta);
let zip_path = d.path().join("diag.zip");
let n = export_package(
&root,
&meta_dir,
&d.path().join("none.log"),
&meta,
&report,
&zip_path,
)
.unwrap();
assert!(n >= 3);
let mut z = zip::ZipArchive::new(fs::File::open(&zip_path).unwrap()).unwrap();
let mut bundle_content = String::new();
for i in 0..z.len() {
let mut s = String::new();
let _ = z.by_index(i).unwrap().read_to_string(&mut s);
bundle_content.push_str(&s);
bundle_content.push('\n');
}
let leaked = scan_for_sentinels(&bundle_content, &sentinels);
assert!(
leaked.is_empty(),
"Sentinel secrets leaked into diagnostic bundle: {leaked:?}"
);
}
}