mod parse;
#[cfg(test)]
mod tests;
use std::cell::RefCell;
use std::collections::{HashMap, HashSet};
use std::ffi::OsStr;
use std::fs::File;
use std::io::Read;
use std::os::unix::fs::MetadataExt;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::rc::{Rc, Weak};
use std::sync::Once;
use std::time::{Duration, Instant};
use calloop::timer::TimeoutAction;
use crabshell_reactive::{ReadSignal, Signal, untrack};
use crabshell_ui::Cx;
use inotify::{EventMask, WatchMask};
use zbus::OwnedObjectPath;
use zbus::names::WellKnownName;
use crate::dbus::{CALL_TIMEOUT, set_changed};
use crate::watch::{self, Change, Watch};
use crate::{Shared, activation, spawn};
const LINK: WatchMask = WatchMask::DONT_FOLLOW
.union(WatchMask::ATTRIB)
.union(WatchMask::DELETE_SELF)
.union(WatchMask::MOVE_SELF);
const APPLICATION: &str = "org.freedesktop.Application";
const SETTLE: Duration = Duration::from_millis(100);
const MAX_FILE: u64 = 64 * 1024;
const MAX_ENTRIES: usize = 10_000;
#[derive(Clone, Debug, PartialEq)]
pub struct DesktopEntry {
pub id: String,
pub name: String,
pub generic_name: String,
pub comment: String,
pub icon: String,
pub exec: String,
pub dbus_activatable: bool,
pub terminal: bool,
pub categories: Vec<String>,
pub keywords: Vec<String>,
pub no_display: bool,
pub startup_wm_class: String,
pub working_dir: Option<PathBuf>,
pub actions: Vec<DesktopAction>,
pub path: PathBuf,
}
#[derive(Clone, Debug, PartialEq)]
pub struct DesktopAction {
pub id: String,
pub name: String,
pub icon: String,
pub exec: String,
}
#[derive(Default)]
pub(crate) struct Sources {
pub(crate) dirs: Vec<PathBuf>,
pub(crate) desktops: Vec<String>,
pub(crate) locale: String,
pub(crate) path: Vec<PathBuf>,
}
impl Sources {
pub(crate) fn system() -> Sources {
let var = |name| std::env::var_os(name).filter(|value| !value.is_empty());
let home = var("XDG_DATA_HOME")
.map(PathBuf::from)
.filter(|dir| dir.is_absolute())
.or_else(|| var("HOME").map(|home| PathBuf::from(home).join(".local/share")));
let data_dirs = var("XDG_DATA_DIRS").unwrap_or_else(|| "/usr/local/share:/usr/share".into());
let dirs = home.into_iter().chain(std::env::split_paths(&data_dirs));
let desktops = std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default();
let locale = ["LC_ALL", "LC_MESSAGES", "LANG"]
.into_iter()
.find_map(|name| std::env::var(name).ok().filter(|value| !value.is_empty()));
Sources {
dirs: dirs
.filter(|dir| dir.is_absolute())
.map(|dir| dir.join("applications"))
.collect(),
desktops: desktops
.split(':')
.filter(|desktop| !desktop.is_empty())
.map(str::to_owned)
.collect(),
locale: locale.unwrap_or_default(),
path: var("PATH").map_or_else(Vec::new, |path| std::env::split_paths(&path).collect()),
}
}
}
#[derive(Clone)]
pub struct DesktopEntries {
service: Option<Rc<Service>>,
applications: ReadSignal<Vec<DesktopEntry>>,
}
impl DesktopEntries {
pub fn applications(&self) -> ReadSignal<Vec<DesktopEntry>> {
self.applications
}
pub fn lookup(&self, app_id: &str) -> Option<DesktopEntry> {
let found = self
.applications
.try_with(|apps| lookup(apps, app_id).cloned());
found.flatten()
}
pub fn launch(&self, id: &str) {
self.launch_with(id, None);
}
pub fn launch_action(&self, id: &str, action: &str) {
self.launch_with(id, Some(action));
}
fn launch_with(&self, id: &str, action: Option<&str>) {
let Some(service) = &self.service else {
return;
};
let find = |apps: &Vec<DesktopEntry>| apps.iter().find(|app| app.id == id).cloned();
match untrack(|| self.applications.try_with(find)).flatten() {
Some(app) => launch(service, &app, action),
None => tracing::warn!(id, "no application has this ID, so nothing starts"),
}
}
}
fn lookup<'a>(apps: &'a [DesktopEntry], app_id: &str) -> Option<&'a DesktopEntry> {
if app_id.is_empty() {
return None;
}
let last_part = |app: &&DesktopEntry| {
let part = app.id.rsplit('.').next();
part.is_some_and(|part| part.eq_ignore_ascii_case(app_id))
};
apps
.iter()
.find(|app| app.id == app_id)
.or_else(|| apps.iter().find(|app| app.id.eq_ignore_ascii_case(app_id)))
.or_else(|| {
apps
.iter()
.find(|app| app.startup_wm_class.eq_ignore_ascii_case(app_id))
})
.or_else(|| apps.iter().find(last_part))
}
fn launch(service: &Rc<Service>, app: &DesktopEntry, action: Option<&str>) {
let id = app.id.as_str();
let exec = match action {
None => &app.exec,
Some(action) => match app.actions.iter().find(|found| found.id == action) {
Some(found) => &found.exec,
None => {
return tracing::warn!(
id,
action,
"the application has no such action, so nothing starts"
);
}
},
};
let (shared, then) = (&service.shared, Rc::clone(service));
let (app, exec, action) = (app.clone(), exec.clone(), action.map(str::to_owned));
activation::with_token(shared, Some(id), move |token| {
start(&then, app, exec, action, token);
});
}
fn start(
service: &Rc<Service>,
app: DesktopEntry,
exec: String,
action: Option<String>,
token: Option<String>,
) {
let id = app.id.as_str();
if !app.dbus_activatable {
return run(service, &app, &exec, token.as_deref());
}
let Some(path) = object_path(id) else {
tracing::warn!(
id,
"the application's ID isn't a D-Bus name, so it can't start over D-Bus"
);
return run(service, &app, &exec, token.as_deref());
};
let Some(address) = service.shared.config.session_bus.clone() else {
tracing::warn!(id, "no session bus to start the application over D-Bus");
return run(service, &app, &exec, token.as_deref());
};
let service = Rc::clone(service);
let shared = Rc::clone(&service.shared);
shared.spawn(async move {
let token = token.as_deref();
let activated = activate(
&service.shared,
address,
&app.id,
path,
action.as_deref(),
token,
);
match activated.await {
Ok(()) => {}
Err((error, true)) => {
tracing::warn!(id = app.id, %error, "couldn't start the application over D-Bus");
run(&service, &app, &exec, token);
}
Err((error, false)) => tracing::warn!(
id = app.id,
%error,
"the application didn't answer its start over D-Bus; not running its Exec"
),
}
});
}
fn object_path(id: &str) -> Option<OwnedObjectPath> {
WellKnownName::try_from(id).ok()?;
let path = format!("/{}", id.replace('.', "/").replace('-', "_"));
OwnedObjectPath::try_from(path).ok()
}
async fn activate(
shared: &Shared,
address: zbus::Address,
id: &str,
path: OwnedObjectPath,
action: Option<&str>,
token: Option<&str>,
) -> Result<(), (zbus::Error, bool)> {
let built = zbus::connection::Builder::address(address).build().await;
let connection = built.map_err(|error| (error, true))?;
let mut platform_data = HashMap::<&str, zbus::Variant<'_>>::new();
if let Some(token) = token {
platform_data.insert("activation-token", token.into());
platform_data.insert("desktop-startup-id", token.into());
}
let (destination, interface) = (Some(id), Some(APPLICATION));
let reply = match action {
None => {
let body = (platform_data,);
let call = connection.call_method(destination, &path, interface, "Activate", &body);
shared.timeout(CALL_TIMEOUT, call).await
}
Some(action) => {
let body = (action, Vec::<zbus::Variant<'_>>::new(), platform_data);
let call = connection.call_method(destination, &path, interface, "ActivateAction", &body);
shared.timeout(CALL_TIMEOUT, call).await
}
};
reply.map(drop).map_err(|error| {
let refused = refused(&error);
(error, refused)
})
}
fn refused(error: &zbus::Error) -> bool {
const REFUSALS: [&str; 4] = [
"org.freedesktop.DBus.Error.ServiceUnknown",
"org.freedesktop.DBus.Error.NameHasNoOwner",
"org.freedesktop.DBus.Error.UnknownObject",
"org.freedesktop.DBus.Error.UnknownMethod",
];
match error {
zbus::Error::MethodError(name, _, _) => REFUSALS.contains(&name.as_str()),
zbus::Error::FDO(error) => matches!(
**error,
zbus::fdo::Error::ServiceUnknown(_)
| zbus::fdo::Error::NameHasNoOwner(_)
| zbus::fdo::Error::UnknownObject(_)
| zbus::fdo::Error::UnknownMethod(_)
),
_ => false,
}
}
fn run(service: &Service, app: &DesktopEntry, exec: &str, token: Option<&str>) {
let (id, shared) = (app.id.as_str(), &service.shared);
if exec.is_empty() {
return tracing::warn!(
id,
"the application has no Exec to fall back on, so nothing starts"
);
}
let argv = match parse::command_line(exec, app) {
Ok(argv) => argv,
Err(why) => return tracing::warn!(id, exec, why, "a malformed Exec, so nothing starts"),
};
if let Err(why) = parse::split_exec(exec)
&& service.split_logged.borrow_mut().insert(id.to_owned())
{
tracing::info!(
id,
exec,
why,
"an Exec the spec refuses, split as a shell would"
);
}
let mut command = if app.terminal {
let path = &shared.config.desktop_entries.path;
let Some(terminal) = parse::find("xdg-terminal-exec", path) else {
return tracing::warn!(
id,
"a terminal application, and xdg-terminal-exec isn't on PATH, so nothing starts"
);
};
let mut command = Command::new(terminal);
command.args(&argv);
command
} else {
let mut command = Command::new(&argv[0]);
command.args(&argv[1..]);
command
};
if let Some(dir) = &app.working_dir {
command.current_dir(dir);
}
if let Some(token) = token {
activation::set_env(&mut command, token);
}
let _ = spawn::spawn(shared, &mut command);
}
pub(crate) fn desktop_entries(cx: &Cx) -> DesktopEntries {
let Some(service) = cx.service::<Service>() else {
static LOGGED: Once = Once::new();
LOGGED.call_once(|| {
tracing::warn!("cx.desktop_entries() needs the services the shell provides; it stays empty");
});
return DesktopEntries {
service: None,
applications: cx.signal(Vec::new()).read_only(),
};
};
service.start()
}
pub(crate) struct Service {
shared: Rc<Shared>,
state: RefCell<Option<State>>,
split_logged: RefCell<HashSet<String>>,
}
struct State {
applications: Signal<Vec<DesktopEntry>>,
watches: Vec<Watch>,
waiting: bool,
changed_at: Option<Instant>,
logged: Logged,
}
#[derive(Clone, Copy, Default)]
struct Logged {
big: bool,
long: bool,
many: bool,
}
impl Service {
pub(crate) fn new(shared: Rc<Shared>) -> Service {
Service {
shared,
state: RefCell::new(None),
split_logged: RefCell::default(),
}
}
fn start(self: &Rc<Self>) -> DesktopEntries {
let started = self.state.borrow().as_ref().map(|state| state.applications);
let applications = started.unwrap_or_else(|| {
let applications = self.shared.root.signal(Vec::new());
*self.state.borrow_mut() = Some(State {
applications,
watches: Vec::new(),
waiting: false,
changed_at: None,
logged: Logged::default(),
});
self.read_later();
applications
});
DesktopEntries {
service: Some(Rc::clone(self)),
applications: applications.read_only(),
}
}
fn changed(self: &Rc<Self>) {
let waiting = {
let mut state = self.state.borrow_mut();
let Some(state) = state.as_mut() else {
return;
};
state.changed_at = Some(Instant::now());
state.waiting
};
if !waiting {
self.read_later();
}
}
fn read_later(self: &Rc<Self>) {
let Some(event_loop) = self.shared.event_loop() else {
return;
};
let settled = |state: &State| state.changed_at.map(|at| at + SETTLE);
let at = {
let mut state = self.state.borrow_mut();
let Some(state) = state.as_mut() else {
return;
};
state.waiting = true;
settled(state).unwrap_or_else(Instant::now)
};
let service = Rc::clone(self);
let tick = Box::new(move || {
let at = service.state.borrow().as_ref().and_then(settled);
match at {
Some(at) if at > Instant::now() => TimeoutAction::ToInstant(at),
_ => {
service.read();
TimeoutAction::Drop
}
}
});
if event_loop.insert_timer(at, tick).is_none()
&& let Some(state) = self.state.borrow_mut().as_mut()
{
state.waiting = false;
}
}
fn read(self: &Rc<Self>) {
let (applications, logged) = {
let mut state = self.state.borrow_mut();
let Some(state) = state.as_mut() else {
return;
};
state.waiting = false;
state.changed_at = None;
(state.applications, state.logged)
};
if applications.try_with(|_| ()).is_none() {
return;
}
let sources = &self.shared.config.desktop_entries;
let mut scan = Scan {
service: Rc::downgrade(self),
shared: &self.shared,
sources,
locales: parse::locales(&sources.locale),
watches: Vec::new(),
visited: HashSet::new(),
seen: HashSet::new(),
entries: Vec::new(),
logged,
};
for root in &sources.dirs {
scan.root(root);
}
let Scan {
mut entries,
watches,
logged,
..
} = scan;
entries.sort_by_cached_key(|app| (app.name.to_lowercase(), app.id.clone()));
let old = {
let mut state = self.state.borrow_mut();
let Some(state) = state.as_mut() else {
return;
};
state.logged = logged;
std::mem::replace(&mut state.watches, watches)
};
drop(old);
set_changed(applications, entries);
}
}
struct Scan<'a> {
service: Weak<Service>,
shared: &'a Rc<Shared>,
sources: &'a Sources,
locales: Vec<String>,
watches: Vec<Watch>,
visited: HashSet<(u64, u64)>,
seen: HashSet<String>,
entries: Vec<DesktopEntry>,
logged: Logged,
}
impl Scan<'_> {
fn root(&mut self, root: &Path) {
self.links(root);
if root.is_dir() {
return self.dir(root, root);
}
if let (Some(parent), Some(name)) = (
root.parent().filter(|parent| parent.is_dir()),
root.file_name(),
) {
let name = name.to_owned();
self.watch(parent, watch::DIRECTORY, move |change| {
change.name.as_ref().is_none_or(|changed| *changed == name)
});
}
}
fn links(&mut self, root: &Path) {
let mut paths = vec![root.to_owned()];
let mut links = 0;
while let Some(path) = paths.pop() {
let mut prefix = PathBuf::new();
let mut components = path.components();
while let Some(component) = components.next() {
prefix.push(component);
let Ok(target) = std::fs::read_link(&prefix) else {
continue;
};
links += 1;
let (Some(dir), true) = (prefix.parent(), links <= 40) else {
return;
};
self.watch(&prefix, LINK, |_| true);
paths.push(dir.join(target).join(components.as_path()));
break;
}
}
}
fn watch(&mut self, path: &Path, mask: WatchMask, counts: impl Fn(&Change) -> bool + 'static) {
let service = self.service.clone();
let on_change = move |change: &Change| {
if let Some(service) = service.upgrade().filter(|_| counts(change)) {
service.changed();
}
};
match watch::watch(self.shared, path, mask, on_change) {
Ok(watch) => self.watches.push(watch),
Err(error) => {
tracing::warn!(%error, path = %path.display(), "can't watch a directory of applications or a link on the way")
}
}
}
fn dir(&mut self, root: &Path, dir: &Path) {
let Ok(meta) = dir.metadata() else {
return;
};
if !self.visited.insert((meta.dev(), meta.ino())) {
return;
}
self.watch(dir, watch::DIRECTORY, |change| {
let name = change.name.as_ref().map(Path::new);
let entry = name.is_some_and(|name| name.extension() == Some(OsStr::new("desktop")));
let linked = !change.mask.contains(EventMask::CLOSE_WRITE)
&& name.is_some_and(|name| name.extension() != Some(OsStr::new("cache")));
name.is_none() || entry || linked || change.mask.contains(EventMask::ISDIR)
});
let Ok(read) = std::fs::read_dir(dir) else {
return;
};
let mut paths: Vec<PathBuf> = read.flatten().map(|entry| entry.path()).collect();
paths.sort();
for path in paths {
match path.metadata() {
Ok(meta) if meta.is_dir() => self.dir(root, &path),
Ok(meta) if meta.is_file() && path.extension() == Some(OsStr::new("desktop")) => {
self.file(root, &path);
}
_ => {}
}
}
}
fn file(&mut self, root: &Path, path: &Path) {
let Some(id) = id(root, path) else {
return;
};
if self.seen.contains(&id) {
return;
}
let shown = path.display();
if self.seen.len() == MAX_ENTRIES {
if !std::mem::replace(&mut self.logged.many, true) {
tracing::warn!(path = %shown, "over {MAX_ENTRIES} desktop entries; the rest are left out");
}
return;
}
self.seen.insert(id.clone());
let mut bytes = Vec::new();
let read = File::open(path).and_then(|file| file.take(MAX_FILE + 1).read_to_end(&mut bytes));
if let Err(error) = read {
return tracing::info!(%error, path = %shown, "can't read a desktop entry");
}
if bytes.len() as u64 > MAX_FILE {
if !std::mem::replace(&mut self.logged.big, true) {
tracing::warn!(path = %shown, "a desktop entry over 64 KiB is left out");
}
return;
}
let Ok(text) = String::from_utf8(bytes) else {
return tracing::info!(path = %shown, "a desktop entry that isn't UTF-8 is left out");
};
let (groups, long) = parse::groups(&text);
if long && !std::mem::replace(&mut self.logged.long, true) {
tracing::warn!(path = %shown, "a line over 4 KiB in a desktop entry is left out");
}
let entry = parse::entry(id, path.to_owned(), &groups, self.sources, &self.locales);
self.entries.extend(entry);
}
}
fn id(root: &Path, path: &Path) -> Option<String> {
let relative = path.strip_prefix(root).ok()?.to_str()?;
Some(relative.strip_suffix(".desktop")?.replace('/', "-"))
}