use std::ptr::{null, null_mut};
use windows_sys::Win32::Foundation::{
ERROR_FILE_NOT_FOUND, ERROR_NO_MORE_ITEMS, ERROR_SUCCESS, WIN32_ERROR,
};
use windows_sys::Win32::Storage::Packaging::Appx::GetCurrentPackageFullName;
use windows_sys::Win32::System::Registry::{
RegCloseKey, RegCreateKeyExW, RegDeleteTreeW, RegEnumKeyExW, RegOpenKeyExW, RegQueryValueExW,
RegSetValueExW, HKEY, HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE, KEY_READ, KEY_WRITE,
REG_OPTION_NON_VOLATILE, REG_SZ,
};
use windows_sys::Win32::UI::Shell::{SHChangeNotify, SHCNE_ASSOCCHANGED, SHCNF_IDLIST};
use super::instance_win::wide;
use super::protocol::{command_line, command_targets};
fn notify_assoc_changed() {
unsafe { SHChangeNotify(SHCNE_ASSOCCHANGED as i32, SHCNF_IDLIST, null(), null()) };
}
pub const OWNER_VALUE: &str = "VnOwner";
#[derive(Debug, Clone)]
pub struct Hive {
pub classes: String,
pub machine: Option<String>,
pub notify: bool,
}
impl Hive {
pub fn user() -> Hive {
Hive {
classes: r"Software\Classes".into(),
machine: Some(r"Software\Classes".into()),
notify: true,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Status {
Absent,
Ours { command: String },
Foreign { owner: String },
}
struct Key(HKEY);
impl Drop for Key {
fn drop(&mut self) {
unsafe {
RegCloseKey(self.0);
}
}
}
fn open(root: HKEY, path: &str, write: bool) -> Result<Option<Key>, WIN32_ERROR> {
let mut h: HKEY = null_mut();
let r = unsafe {
RegOpenKeyExW(
root,
wide(path).as_ptr(),
0,
if write {
KEY_READ | KEY_WRITE
} else {
KEY_READ
},
&mut h,
)
};
if r == ERROR_SUCCESS {
Ok(Some(Key(h)))
} else if r == ERROR_FILE_NOT_FOUND {
Ok(None)
} else {
Err(r)
}
}
fn create(root: HKEY, path: &str) -> Result<Key, WIN32_ERROR> {
let mut h: HKEY = null_mut();
let r = unsafe {
RegCreateKeyExW(
root,
wide(path).as_ptr(),
0,
null(),
REG_OPTION_NON_VOLATILE,
KEY_READ | KEY_WRITE,
null(),
&mut h,
null_mut(),
)
};
if r == ERROR_SUCCESS {
Ok(Key(h))
} else {
Err(r)
}
}
fn read_sz(key: &Key, name: &str) -> Option<String> {
let name = wide(name);
let mut ty = 0;
let mut len = 0u32;
if unsafe { RegQueryValueExW(key.0, name.as_ptr(), null(), &mut ty, null_mut(), &mut len) }
!= ERROR_SUCCESS
{
return None;
}
if ty != REG_SZ {
return Some(String::new());
}
let mut buf = vec![0u8; len as usize + 2];
let mut len2 = buf.len() as u32;
if unsafe {
RegQueryValueExW(
key.0,
name.as_ptr(),
null(),
null_mut(),
buf.as_mut_ptr(),
&mut len2,
)
} != ERROR_SUCCESS
{
return None;
}
let wide: Vec<u16> = buf[..len2 as usize]
.chunks_exact(2)
.map(|c| u16::from_le_bytes([c[0], c[1]]))
.collect();
let end = wide.iter().position(|&c| c == 0).unwrap_or(wide.len());
Some(String::from_utf16_lossy(&wide[..end]))
}
fn write_sz(key: &Key, name: &str, value: &str) -> Result<bool, WIN32_ERROR> {
if read_sz(key, name).as_deref() == Some(value) {
return Ok(false);
}
let mut bytes: Vec<u8> = value.encode_utf16().flat_map(u16::to_le_bytes).collect();
bytes.extend_from_slice(&[0, 0]);
let r = unsafe {
RegSetValueExW(
key.0,
wide(name).as_ptr(),
0,
REG_SZ,
bytes.as_ptr(),
bytes.len() as u32,
)
};
if r == ERROR_SUCCESS {
Ok(true)
} else {
Err(r)
}
}
fn describe_owner(key: &Key, scheme: &str) -> String {
if let Some(owner) = read_sz(key, OWNER_VALUE).filter(|o| !o.is_empty()) {
return format!("the Skathi app \"{owner}\"");
}
match read_sz(key, "")
.filter(|d| !d.is_empty() && !d.eq_ignore_ascii_case(&format!("URL:{scheme}")))
{
Some(desc) => format!("another application (\"{desc}\")"),
None => "another application".into(),
}
}
pub fn status(hive: &Hive, scheme: &str, id: &str) -> Result<Status, String> {
let path = format!(r"{}\{scheme}", hive.classes);
match open(HKEY_CURRENT_USER, &path, false)
.map_err(|e| format!("reading HKCU\\{path}: {e:?}"))?
{
Some(key) => {
if read_sz(&key, OWNER_VALUE).as_deref() == Some(id) {
let command = open(
HKEY_CURRENT_USER,
&format!(r"{path}\shell\open\command"),
false,
)
.ok()
.flatten()
.and_then(|k| read_sz(&k, ""))
.unwrap_or_default();
Ok(Status::Ours { command })
} else {
Ok(Status::Foreign {
owner: describe_owner(&key, scheme),
})
}
}
None => {
if let Some(machine) = &hive.machine {
let mpath = format!(r"{machine}\{scheme}");
if let Ok(Some(_)) = open(HKEY_LOCAL_MACHINE, &mpath, false) {
return Ok(Status::Foreign {
owner: "a machine-wide registration (HKLM)".into(),
});
}
}
Ok(Status::Absent)
}
}
}
pub fn register(
hive: &Hive,
scheme: &str,
id: &str,
exe: &str,
dev_slot: Option<&str>,
) -> Result<bool, String> {
if let Status::Foreign { owner } = status(hive, scheme, id)? {
return Err(format!("the \"{scheme}\" scheme is registered to {owner}; Skathi never takes over another app's scheme"));
}
let path = format!(r"{}\{scheme}", hive.classes);
let fail = |what: &str, e: WIN32_ERROR| format!("writing HKCU\\{path}{what}: {e:?}");
let root = create(HKEY_CURRENT_USER, &path).map_err(|e| fail("", e))?;
let mut wrote = false;
wrote |= write_sz(&root, OWNER_VALUE, id).map_err(|e| fail("", e))?;
wrote |= write_sz(&root, "", &format!("URL:{scheme}")).map_err(|e| fail("", e))?;
wrote |= write_sz(&root, "URL Protocol", "").map_err(|e| fail("", e))?;
let icon = create(HKEY_CURRENT_USER, &format!(r"{path}\DefaultIcon"))
.map_err(|e| fail(r"\DefaultIcon", e))?;
wrote |= write_sz(&icon, "", &format!("\"{exe}\",0")).map_err(|e| fail(r"\DefaultIcon", e))?;
let cmd = create(HKEY_CURRENT_USER, &format!(r"{path}\shell\open\command"))
.map_err(|e| fail(r"\shell\open\command", e))?;
wrote |= write_sz(&cmd, "", &command_line(exe, dev_slot))
.map_err(|e| fail(r"\shell\open\command", e))?;
if wrote && hive.notify {
notify_assoc_changed();
}
Ok(wrote)
}
pub fn is_registered(hive: &Hive, scheme: &str, id: &str, exe: &str) -> bool {
matches!(status(hive, scheme, id), Ok(Status::Ours { command }) if command_targets(&command, exe))
}
fn delete(hive: &Hive, scheme: &str) -> bool {
let Ok(Some(classes)) = open(HKEY_CURRENT_USER, &hive.classes, true) else {
return false;
};
let ok = unsafe { RegDeleteTreeW(classes.0, wide(scheme).as_ptr()) } == ERROR_SUCCESS;
if ok && hive.notify {
notify_assoc_changed();
}
ok
}
pub fn unregister(hive: &Hive, scheme: &str, id: &str, exe: &str) -> bool {
is_registered(hive, scheme, id, exe) && delete(hive, scheme)
}
pub fn unregister_all(hive: &Hive, id: &str) -> Vec<String> {
let Ok(Some(classes)) = open(HKEY_CURRENT_USER, &hive.classes, false) else {
return Vec::new();
};
let mut ours = Vec::new();
let mut i = 0u32;
loop {
let mut name = vec![0u16; 256];
let mut len = name.len() as u32;
let r = unsafe {
RegEnumKeyExW(
classes.0,
i,
name.as_mut_ptr(),
&mut len,
null(),
null_mut(),
null_mut(),
null_mut(),
)
};
if r == ERROR_NO_MORE_ITEMS {
break;
}
i += 1;
if r != ERROR_SUCCESS {
continue;
}
let sub = String::from_utf16_lossy(&name[..len as usize]);
if sub.starts_with('.') || sub.starts_with('{') {
continue;
}
if let Ok(Some(k)) = open(
HKEY_CURRENT_USER,
&format!(r"{}\{sub}", hive.classes),
false,
) {
if read_sz(&k, OWNER_VALUE).as_deref() == Some(id) {
ours.push(sub);
}
}
}
drop(classes);
ours.into_iter().filter(|s| delete(hive, s)).collect()
}
pub fn has_package_identity() -> bool {
let mut len = 0u32;
let r = unsafe { GetCurrentPackageFullName(&mut len, std::ptr::null_mut()) };
r == 122
}
#[cfg(test)]
mod tests {
use super::*;
struct Scratch(Hive, String);
impl Scratch {
fn new(tag: &str) -> Scratch {
let base = format!(r"Software\skathi-test-{}-{tag}", std::process::id());
let hive = Hive {
classes: format!(r"{base}\Classes"),
machine: None,
notify: false,
};
create(HKEY_CURRENT_USER, &hive.classes).expect("scratch hive");
Scratch(hive, base)
}
}
impl Drop for Scratch {
fn drop(&mut self) {
if let Ok(Some(sw)) = open(HKEY_CURRENT_USER, "Software", true) {
let name = self.1.trim_start_matches(r"Software\");
unsafe {
RegDeleteTreeW(sw.0, wide(name).as_ptr());
}
}
assert!(
matches!(open(HKEY_CURRENT_USER, &self.1, false), Ok(None)),
"the scratch hive HKCU\\{} must be gone",
self.1
);
}
}
const EXE: &str = r"C:\Program Files\Notes\Notes.exe";
#[test]
fn register_writes_the_documented_shape_and_is_idempotent() {
let s = Scratch::new("shape");
assert_eq!(status(&s.0, "vntest", "gl.argon.notes"), Ok(Status::Absent));
assert_eq!(
register(&s.0, "vntest", "gl.argon.notes", EXE, None),
Ok(true)
);
assert_eq!(
register(&s.0, "vntest", "gl.argon.notes", EXE, None),
Ok(false),
"nothing changed, nothing written"
);
let root = open(
HKEY_CURRENT_USER,
&format!(r"{}\vntest", s.0.classes),
false,
)
.unwrap()
.unwrap();
assert_eq!(read_sz(&root, "").as_deref(), Some("URL:vntest"));
assert_eq!(read_sz(&root, "URL Protocol").as_deref(), Some(""));
assert_eq!(
read_sz(&root, OWNER_VALUE).as_deref(),
Some("gl.argon.notes")
);
let icon = open(
HKEY_CURRENT_USER,
&format!(r"{}\vntest\DefaultIcon", s.0.classes),
false,
)
.unwrap()
.unwrap();
assert_eq!(read_sz(&icon, "").unwrap(), format!("\"{EXE}\",0"));
assert_eq!(
status(&s.0, "vntest", "gl.argon.notes"),
Ok(Status::Ours {
command: command_line(EXE, None)
})
);
assert!(is_registered(&s.0, "vntest", "gl.argon.notes", EXE));
let moved = r"D:\Notes\Notes.exe";
assert!(!is_registered(&s.0, "vntest", "gl.argon.notes", moved));
assert_eq!(
register(&s.0, "vntest", "gl.argon.notes", moved, Some(r"C:\slot")),
Ok(true)
);
assert!(is_registered(&s.0, "vntest", "gl.argon.notes", moved));
}
#[test]
fn a_foreign_scheme_is_never_overwritten() {
let s = Scratch::new("foreign");
let k = create(HKEY_CURRENT_USER, &format!(r"{}\other", s.0.classes)).unwrap();
write_sz(&k, "", "URL:Other App Protocol").unwrap();
drop(k);
assert!(register(&s.0, "other", "gl.argon.notes", EXE, None).is_err());
assert!(
!unregister(&s.0, "other", "gl.argon.notes", EXE),
"and never deleted"
);
assert!(
open(HKEY_CURRENT_USER, &format!(r"{}\other", s.0.classes), false)
.unwrap()
.is_some()
);
register(&s.0, "theirs", "gl.argon.other", EXE, None).unwrap();
assert!(register(&s.0, "theirs", "gl.argon.notes", EXE, None).is_err());
}
#[test]
fn unregister_needs_our_marker_and_our_exe() {
let s = Scratch::new("unreg");
register(&s.0, "vntest", "gl.argon.notes", EXE, None).unwrap();
assert!(
!unregister(&s.0, "vntest", "gl.argon.notes", r"D:\elsewhere\Notes.exe"),
"another copy's"
);
assert!(
!unregister(&s.0, "vntest", "gl.argon.other", EXE),
"another app's"
);
assert!(unregister(&s.0, "vntest", "gl.argon.notes", EXE));
assert_eq!(status(&s.0, "vntest", "gl.argon.notes"), Ok(Status::Absent));
assert!(
!unregister(&s.0, "vntest", "gl.argon.notes", EXE),
"already gone"
);
}
#[test]
fn unregister_all_takes_exactly_our_keys() {
let s = Scratch::new("all");
register(&s.0, "one", "gl.argon.notes", EXE, None).unwrap();
register(&s.0, "two", "gl.argon.notes", r"D:\moved\Notes.exe", None).unwrap();
register(&s.0, "three", "gl.argon.other", EXE, None).unwrap();
create(HKEY_CURRENT_USER, &format!(r"{}\.txt", s.0.classes)).unwrap();
let mut gone = unregister_all(&s.0, "gl.argon.notes");
gone.sort();
assert_eq!(gone, vec!["one".to_string(), "two".to_string()]);
assert!(matches!(
status(&s.0, "three", "gl.argon.other"),
Ok(Status::Ours { .. })
));
}
}