Windows shell replacement in Rust: taskbar, file manager, NTFS search, task manager, disk cleaner. One installer exe.
Rust
//! The installer's change journal, one file per plugin: every system value a plugin changes is written down, old value first,
//! BEFORE the change; uninstall plays it back newest first. So the oldest line of a value holds the original (an update records
//! nothing new) and one playback restores everything. One change per line, the last field may contain `|`:
//! reg|<key>|<name>|- the value did not exist: undo deletes it
//! reg|<key>|<name>|<TYPE>|<data> undo writes it back (reg add /t TYPE /d data)
//! svc|<name>|<mode> undo: sc config <name> start= <mode>
#[derive(Debug, PartialEq, Clone)]
pub enum Entry {
Reg { key: String, name: String, old: Option<(String, String)> },
Svc { name: String, mode: String },
}
/// Types reg.exe writes back exactly from what `reg query` printed (DWORD data is kept as decimal).
const TYPES: [&str; 3] = ["REG_SZ", "REG_EXPAND_SZ", "REG_DWORD"];
impl Entry {
/// The journal line; None when the entry cannot be stored faithfully (then the change must not be made).
pub fn line(&self) -> Option<String> {
let ok = |s: &str| !s.contains(['\r', '\n']);
match self {
Entry::Reg { key, name, old } => {
// shortcut: no default values ((Default) prints localized text when unset), add them when a plugin needs one
if name.is_empty() || !ok(key) || !ok(name) || key.contains('|') || name.contains('|') {
return None;
}
match old {
None => Some(format!("reg|{key}|{name}|-")),
Some((ty, d)) if TYPES.contains(&ty.as_str()) && ok(d) => Some(format!("reg|{key}|{name}|{ty}|{d}")),
Some(_) => None,
}
}
Entry::Svc { name, mode } => (ok(name) && !name.contains('|') && ["auto", "delayed-auto", "demand", "disabled"].contains(&mode.as_str())).then(|| format!("svc|{name}|{mode}")),
}
}
pub fn parse(l: &str) -> Option<Entry> {
let f: Vec<&str> = l.trim_end_matches(['\r', '\n']).splitn(5, '|').collect();
let s = |i: usize| f[i].to_string();
match f.as_slice() {
["reg", _, n, "-"] if !n.is_empty() => Some(Entry::Reg { key: s(1), name: s(2), old: None }),
["reg", _, n, ty, _] if !n.is_empty() && TYPES.contains(ty) => Some(Entry::Reg { key: s(1), name: s(2), old: Some((s(3), s(4))) }),
["svc", _, _] => Some(Entry::Svc { name: s(1), mode: s(2) }).filter(|e| e.line().is_some()),
_ => None,
}
}
/// Both describe the same value or service: the later one is not recorded.
pub fn same(&self, o: &Entry) -> bool {
match (self, o) {
(Entry::Reg { key: a, name: b, .. }, Entry::Reg { key: c, name: d, .. }) => a.eq_ignore_ascii_case(c) && b.eq_ignore_ascii_case(d),
(Entry::Svc { name: a, .. }, Entry::Svc { name: b, .. }) => a.eq_ignore_ascii_case(b),
_ => false,
}
}
}
/// Every entry, oldest first. Returns the one-based line number if a record is malformed or incomplete.
pub fn parse_all(text: &str) -> Result<Vec<Entry>, usize> {
text.split_inclusive('\n')
.enumerate()
.map(|(i, line)| line.strip_suffix('\n').and_then(Entry::parse).ok_or(i + 1))
.collect()
}
/// `sc config` start mode from a service's Start and DelayedAutostart values. None = boot/system driver or unknown: never touched.
pub fn svc_mode(start: Option<u32>, delayed: Option<u32>) -> Option<&'static str> {
match (start?, delayed.unwrap_or(0)) {
(2, 0) => Some("auto"),
(2, _) => Some("delayed-auto"),
(3, _) => Some("demand"),
(4, _) => Some("disabled"),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
fn reg(old: Option<(&str, &str)>) -> Entry {
Entry::Reg { key: r"HKLM\SOFTWARE\X".into(), name: "Debugger".into(), old: old.map(|(t, d)| (t.into(), d.into())) }
}
#[test]
fn lines_round_trip() {
for e in [reg(None), reg(Some(("REG_SZ", r#""C:\a|b.exe" /x"#))), reg(Some(("REG_DWORD", "26"))), Entry::Svc { name: "WSearch".into(), mode: "delayed-auto".into() }] {
assert_eq!(Entry::parse(&e.line().unwrap()), Some(e));
}
}
#[test]
fn reads_empty_journal_and_crlf_records_in_order() {
assert_eq!(parse_all(""), Ok(vec![]));
assert_eq!(parse_all("reg|K|V|REG_SZ|a|b\r\nsvc|S|auto\r\n").unwrap(), vec![
Entry::Reg { key: "K".into(), name: "V".into(), old: Some(("REG_SZ".into(), "a|b".into())) },
Entry::Svc { name: "S".into(), mode: "auto".into() },
]);
}
#[test]
fn rejects_the_entire_journal_when_a_record_is_invalid_or_incomplete() {
assert_eq!(parse_all("reg|K|V|-\r\ngarbage\nsvc|S|auto\n"), Err(2));
assert_eq!(parse_all("svc|S|boot\n"), Err(1));
assert_eq!(parse_all("svc|S|auto\nreg|K|V|REG_SZ|partial"), Err(2));
}
#[test]
fn refuses_what_it_cannot_restore() {
assert_eq!(reg(Some(("REG_BINARY", "00ff"))).line(), None);
assert_eq!(reg(Some(("REG_SZ", "a\nb"))).line(), None);
assert_eq!(Entry::Reg { key: "K".into(), name: "".into(), old: None }.line(), None);
assert_eq!(Entry::Svc { name: "S".into(), mode: "boot".into() }.line(), None);
assert_eq!(Entry::parse("svc|S|boot"), None);
assert_eq!(Entry::parse("reg|K|V|REG_BINARY|00"), None);
}
#[test]
fn same_value_any_case() {
let other = Entry::Reg { key: r"hklm\software\x".into(), name: "DEBUGGER".into(), old: Some(("REG_SZ".into(), "y".into())) };
assert!(reg(None).same(&other));
assert!(!reg(None).same(&Entry::Svc { name: "Debugger".into(), mode: "auto".into() }));
}
#[test]
fn service_modes() {
assert_eq!(svc_mode(Some(2), None), Some("auto"));
assert_eq!(svc_mode(Some(2), Some(1)), Some("delayed-auto"));
assert_eq!(svc_mode(Some(4), Some(1)), Some("disabled"));
assert_eq!(svc_mode(Some(1), None), None);
assert_eq!(svc_mode(None, None), None);
}
}