use crate::registry::Grant;
use crate::uuid::BluetoothUuid;
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
const HEADER: &str = "# webbluetooth grants v1";
const WILDCARD: &str = "*";
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Stored {
pub name: Option<String>,
pub grant: Grant,
}
#[derive(Debug, Clone)]
pub struct GrantStore {
path: PathBuf,
}
impl GrantStore {
pub fn new(path: impl Into<PathBuf>) -> Self {
Self { path: path.into() }
}
pub fn path(&self) -> &Path {
&self.path
}
pub fn load(&self) -> BTreeMap<String, Stored> {
let Ok(text) = std::fs::read_to_string(&self.path) else {
return BTreeMap::new();
};
parse(&text)
}
pub fn save(&self, devices: &BTreeMap<String, Stored>) -> std::io::Result<()> {
if let Some(parent) = self.path.parent() {
if !parent.as_os_str().is_empty() {
std::fs::create_dir_all(parent)?;
}
}
let temporary = self.path.with_extension("tmp");
std::fs::write(&temporary, render(devices))?;
restrict(&temporary)?;
std::fs::rename(&temporary, &self.path)
}
}
#[cfg(unix)]
fn restrict(path: &Path) -> std::io::Result<()> {
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600))
}
#[cfg(not(unix))]
fn restrict(_path: &Path) -> std::io::Result<()> {
Ok(())
}
fn render(devices: &BTreeMap<String, Stored>) -> String {
let mut out = String::from(HEADER);
out.push('\n');
for (id, stored) in devices {
let services: Vec<&str> = if stored.grant.permits_all_services() {
vec![WILDCARD]
} else {
stored.grant.services.iter().map(|u| u.as_str()).collect()
};
let companies: Vec<String> = if stored.grant.permits_all_manufacturer_data() {
vec![WILDCARD.to_owned()]
} else {
stored
.grant
.manufacturer_data
.iter()
.map(|c| c.to_string())
.collect()
};
let name = stored.name.as_deref().unwrap_or("");
let name: String = name.chars().filter(|c| *c != '\t' && *c != '\n').collect();
out.push_str(&format!(
"{id}\t{name}\t{}\t{}\n",
services.join(","),
companies.join(",")
));
}
out
}
fn parse(text: &str) -> BTreeMap<String, Stored> {
let mut out = BTreeMap::new();
for line in text.lines() {
let line = line.trim_end_matches(['\r', '\n']);
if line.is_empty() || line.starts_with('#') {
continue;
}
let mut fields = line.split('\t');
let (Some(id), Some(name), Some(services)) = (fields.next(), fields.next(), fields.next())
else {
continue; };
let companies = fields.next().unwrap_or("");
if id.is_empty() {
continue;
}
out.insert(
id.to_owned(),
Stored {
name: (!name.is_empty()).then(|| name.to_owned()),
grant: {
let mut grant = Grant::new();
grant.services = services
.split(',')
.filter(|s| !s.is_empty())
.filter_map(|s| BluetoothUuid::parse(s).ok())
.collect();
grant.manufacturer_data = companies
.split(',')
.filter(|s| !s.is_empty())
.filter_map(|s| s.parse().ok())
.collect();
#[cfg(feature = "unrestricted")]
{
grant.all_services = services.split(',').any(|field| field == WILDCARD);
grant.all_manufacturer_data =
companies.split(',').any(|field| field == WILDCARD);
}
grant
},
},
);
}
out
}
#[cfg(test)]
mod tests {
use super::*;
fn stored(services: &[u16], companies: &[u16], name: Option<&str>) -> Stored {
Stored {
name: name.map(str::to_owned),
grant: {
let mut grant = Grant::new();
grant.services = services
.iter()
.map(|u| BluetoothUuid::from_u16(*u))
.collect();
grant.manufacturer_data = companies.to_vec();
grant
},
}
}
#[test]
fn a_grant_with_no_services_round_trips() {
let mut devices = BTreeMap::new();
devices.insert("11:22:33:44:55:66".to_owned(), stored(&[], &[], None));
assert_eq!(parse(&render(&devices)), devices);
}
#[test]
fn a_grant_survives_a_round_trip() {
let mut devices = BTreeMap::new();
devices.insert(
"AA:BB:CC:DD:EE:FF".to_owned(),
stored(&[0x180D, 0x180F], &[0x004C], Some("Heart Rate Belt")),
);
devices.insert("11:22:33:44:55:66".to_owned(), stored(&[], &[], None));
let back = parse(&render(&devices));
assert_eq!(back, devices);
}
#[test]
fn a_name_cannot_inject_another_record() {
let mut devices = BTreeMap::new();
devices.insert(
"AA:BB:CC:DD:EE:FF".to_owned(),
stored(
&[0x180F],
&[],
Some("evil\tx\t0000180d-0000-1000-8000-00805f9b34fb\n99:99:99:99:99:99\thi\t"),
),
);
let back = parse(&render(&devices));
assert_eq!(back.len(), 1, "one device in, one device out");
assert!(
!back.contains_key("99:99:99:99:99:99"),
"the name must not have created a second grant"
);
let only = back.values().next().unwrap();
assert_eq!(only.grant.services.len(), 1);
}
#[test]
fn a_damaged_store_reads_as_empty_rather_than_failing() {
assert!(parse("").is_empty());
assert!(parse("not a record").is_empty());
assert!(parse("# only a comment\n").is_empty());
let mixed = format!(
"{HEADER}\ngarbage\nAA:BB:CC:DD:EE:FF\t\t0000180f-0000-1000-8000-00805f9b34fb\t\n"
);
assert_eq!(parse(&mixed).len(), 1);
}
#[test]
fn a_malformed_uuid_is_dropped_not_guessed() {
let line = format!("{HEADER}\ndev\t\tnot-a-uuid,0000180f-0000-1000-8000-00805f9b34fb\t\n");
let back = parse(&line);
let grant = &back.get("dev").unwrap().grant;
assert_eq!(grant.services.len(), 1, "only the one that parsed");
}
#[test]
#[cfg_attr(miri, ignore = "opens a real file; Miri isolates the filesystem")]
fn saving_and_loading_uses_the_file() {
let dir = std::env::temp_dir().join(format!("wbt-grants-{}", std::process::id()));
let store = GrantStore::new(dir.join("grants.txt"));
assert!(store.load().is_empty(), "nothing stored yet");
let mut devices = BTreeMap::new();
devices.insert(
"AA:BB:CC:DD:EE:FF".to_owned(),
stored(&[0x180F], &[], Some("Belt")),
);
store.save(&devices).expect("the store should be writable");
assert_eq!(store.load(), devices);
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mode = std::fs::metadata(store.path())
.unwrap()
.permissions()
.mode();
assert_eq!(
mode & 0o777,
0o600,
"a permission store is not world-readable"
);
}
let _ = std::fs::remove_dir_all(&dir);
}
#[cfg(feature = "unrestricted")]
#[test]
fn a_wildcard_grant_survives_the_store() {
let mut devices = BTreeMap::new();
devices.insert(
"dev".to_owned(),
Stored {
name: Some("probe".to_owned()),
grant: Grant::unrestricted(),
},
);
let back = parse(&render(&devices));
let grant = &back.get("dev").unwrap().grant;
assert!(grant.permits_all_services());
assert!(grant.permits_all_manufacturer_data());
assert!(
grant.services.is_empty(),
"the wildcard is not a UUID and must not parse as one"
);
}
#[test]
fn a_wildcard_record_degrades_to_an_empty_grant() {
let text = format!("{HEADER}\ndev\tprobe\t*\t*\n");
let back = parse(&text);
let grant = &back.get("dev").unwrap().grant;
assert!(grant.services.is_empty());
assert!(grant.manufacturer_data.is_empty());
#[cfg(not(feature = "unrestricted"))]
{
assert!(!grant.permits_all_services());
assert!(!grant.permits(&BluetoothUuid::from_u16(0x180F)));
}
}
}