summaryrefslogtreecommitdiff
path: root/src/platform/freedesktop
diff options
context:
space:
mode:
Diffstat (limited to 'src/platform/freedesktop')
-rw-r--r--src/platform/freedesktop/dbus.c187
-rw-r--r--src/platform/freedesktop/dbus.h16
-rw-r--r--src/platform/freedesktop/desktop.c150
-rw-r--r--src/platform/freedesktop/meson.build1
4 files changed, 354 insertions, 0 deletions
diff --git a/src/platform/freedesktop/dbus.c b/src/platform/freedesktop/dbus.c
new file mode 100644
index 0000000..abca900
--- /dev/null
+++ b/src/platform/freedesktop/dbus.c
@@ -0,0 +1,187 @@
+#define _GNU_SOURCE
+#include "platform/freedesktop/dbus.h"
+
+#if YASL_HAS_DBUS
+
+#include <dbus/dbus.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+/* The portal may need activation on first use; bound how long a query blocks. */
+#define PORTAL_TIMEOUT_MS 1000
+
+static DBusConnection *bus;
+
+/* The session bus address, without libdbus's X11 autolaunch fallback. */
+static char *session_address(void)
+{
+ const char *env = getenv("DBUS_SESSION_BUS_ADDRESS");
+ if (env && *env) return strdup(env);
+ const char *run = getenv("XDG_RUNTIME_DIR");
+ if (!run || !*run) return NULL;
+ char path[4096];
+ struct stat st;
+ if (snprintf(path, sizeof(path), "%s/bus", run) >= (int)sizeof(path) ||
+ stat(path, &st) != 0 || !S_ISSOCK(st.st_mode))
+ return NULL;
+ char *escaped = dbus_address_escape_value(path);
+ if (!escaped) return NULL;
+ char *address = NULL;
+ if (asprintf(&address, "unix:path=%s", escaped) < 0) address = NULL;
+ dbus_free(escaped);
+ return address;
+}
+
+static DBusConnection *session_bus(void)
+{
+ if (bus && dbus_connection_get_is_connected(bus)) return bus;
+ if (bus) {
+ dbus_connection_close(bus);
+ dbus_connection_unref(bus);
+ bus = NULL;
+ }
+ char *address = session_address();
+ if (!address) return NULL;
+ DBusError err;
+ dbus_error_init(&err);
+ DBusConnection *c = dbus_connection_open_private(address, &err);
+ free(address);
+ if (!c) {
+ dbus_error_free(&err);
+ return NULL;
+ }
+ dbus_connection_set_exit_on_disconnect(c, FALSE);
+ if (!dbus_bus_register(c, &err)) {
+ dbus_error_free(&err);
+ dbus_connection_close(c);
+ dbus_connection_unref(c);
+ return NULL;
+ }
+ bus = c;
+ return bus;
+}
+
+bool bus_notify(const char *app, const char *title, const char *body)
+{
+ DBusConnection *c = session_bus();
+ if (!c) return false;
+ DBusMessage *msg = dbus_message_new_method_call("org.freedesktop.Notifications",
+ "/org/freedesktop/Notifications", "org.freedesktop.Notifications", "Notify");
+ if (!msg) return false;
+
+ const char *icon = "";
+ dbus_uint32_t replaces = 0;
+ dbus_int32_t expire = -1;
+ DBusMessageIter it, sub, entry, value;
+ dbus_message_iter_init_append(msg, &it);
+ bool ok = dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &app) &&
+ dbus_message_iter_append_basic(&it, DBUS_TYPE_UINT32, &replaces) &&
+ dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &icon) &&
+ dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &title) &&
+ dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &body);
+ /* No actions. */
+ ok = ok && dbus_message_iter_open_container(&it, DBUS_TYPE_ARRAY, "s", &sub) &&
+ dbus_message_iter_close_container(&it, &sub);
+ /* Hints: desktop-entry names the application's .desktop file. */
+ const char *hint = "desktop-entry";
+ ok = ok && dbus_message_iter_open_container(&it, DBUS_TYPE_ARRAY, "{sv}", &sub) &&
+ dbus_message_iter_open_container(&sub, DBUS_TYPE_DICT_ENTRY, NULL, &entry) &&
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &hint) &&
+ dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, "s", &value) &&
+ dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &app) &&
+ dbus_message_iter_close_container(&entry, &value) &&
+ dbus_message_iter_close_container(&sub, &entry) &&
+ dbus_message_iter_close_container(&it, &sub);
+ ok = ok && dbus_message_iter_append_basic(&it, DBUS_TYPE_INT32, &expire);
+
+ if (ok) {
+ dbus_message_set_no_reply(msg, TRUE);
+ ok = dbus_connection_send(c, msg, NULL);
+ if (ok) dbus_connection_flush(c);
+ }
+ dbus_message_unref(msg);
+ return ok;
+}
+
+/* Read an integer from it, unwrapping variants: Settings.Read nests one more. */
+static bool iter_int(DBusMessageIter *it, int64_t *out)
+{
+ DBusMessageIter inner[4];
+ int depth = 0;
+ while (dbus_message_iter_get_arg_type(it) == DBUS_TYPE_VARIANT && depth < 4) {
+ dbus_message_iter_recurse(it, &inner[depth]);
+ it = &inner[depth++];
+ }
+ DBusBasicValue v;
+ switch (dbus_message_iter_get_arg_type(it)) {
+ case DBUS_TYPE_BYTE: dbus_message_iter_get_basic(it, &v); *out = v.byt; return true;
+ case DBUS_TYPE_BOOLEAN: dbus_message_iter_get_basic(it, &v); *out = v.bool_val; return true;
+ case DBUS_TYPE_INT16: dbus_message_iter_get_basic(it, &v); *out = v.i16; return true;
+ case DBUS_TYPE_UINT16: dbus_message_iter_get_basic(it, &v); *out = v.u16; return true;
+ case DBUS_TYPE_INT32: dbus_message_iter_get_basic(it, &v); *out = v.i32; return true;
+ case DBUS_TYPE_UINT32: dbus_message_iter_get_basic(it, &v); *out = v.u32; return true;
+ case DBUS_TYPE_INT64: dbus_message_iter_get_basic(it, &v); *out = v.i64; return true;
+ case DBUS_TYPE_UINT64:
+ dbus_message_iter_get_basic(it, &v);
+ if (v.u64 > INT64_MAX) return false;
+ *out = (int64_t)v.u64;
+ return true;
+ default: return false;
+ }
+}
+
+bool portal_read_int(const char *ns, const char *key, int64_t *out)
+{
+ DBusConnection *c = session_bus();
+ if (!c) return false;
+ /* ReadOne is portal version 2; older portals only have Read. */
+ static const char *const methods[] = {"ReadOne", "Read"};
+ for (int i = 0; i < 2; i++) {
+ DBusMessage *msg = dbus_message_new_method_call("org.freedesktop.portal.Desktop",
+ "/org/freedesktop/portal/desktop", "org.freedesktop.portal.Settings", methods[i]);
+ if (!msg) return false;
+ if (!dbus_message_append_args(msg, DBUS_TYPE_STRING, &ns, DBUS_TYPE_STRING, &key,
+ DBUS_TYPE_INVALID)) {
+ dbus_message_unref(msg);
+ return false;
+ }
+ DBusError err;
+ dbus_error_init(&err);
+ DBusMessage *reply = dbus_connection_send_with_reply_and_block(c, msg,
+ PORTAL_TIMEOUT_MS, &err);
+ dbus_message_unref(msg);
+ if (!reply) {
+ bool retry = dbus_error_has_name(&err, DBUS_ERROR_UNKNOWN_METHOD);
+ dbus_error_free(&err);
+ if (retry) continue;
+ return false;
+ }
+ DBusMessageIter it;
+ bool ok = dbus_message_iter_init(reply, &it) && iter_int(&it, out);
+ dbus_message_unref(reply);
+ return ok;
+ }
+ return false;
+}
+
+#else
+
+bool bus_notify(const char *app, const char *title, const char *body)
+{
+ (void)app;
+ (void)title;
+ (void)body;
+ return false;
+}
+
+bool portal_read_int(const char *ns, const char *key, int64_t *out)
+{
+ (void)ns;
+ (void)key;
+ (void)out;
+ return false;
+}
+
+#endif
diff --git a/src/platform/freedesktop/dbus.h b/src/platform/freedesktop/dbus.h
new file mode 100644
index 0000000..3b1662b
--- /dev/null
+++ b/src/platform/freedesktop/dbus.h
@@ -0,0 +1,16 @@
+#ifndef YASL_FREEDESKTOP_DBUS_H
+#define YASL_FREEDESKTOP_DBUS_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+/* Session-bus helpers. The first call opens a private connection that later
+ * calls reuse. Each returns false when YASL is built without libdbus-1 or no
+ * session bus is reachable. Call from one thread at a time. */
+
+/* Send org.freedesktop.Notifications.Notify without waiting for a reply. */
+bool bus_notify(const char *app, const char *title, const char *body);
+/* Read an integer setting through the XDG Settings portal, waiting briefly. */
+bool portal_read_int(const char *ns, const char *key, int64_t *out);
+
+#endif
diff --git a/src/platform/freedesktop/desktop.c b/src/platform/freedesktop/desktop.c
new file mode 100644
index 0000000..a8b9bc7
--- /dev/null
+++ b/src/platform/freedesktop/desktop.c
@@ -0,0 +1,150 @@
+#define _GNU_SOURCE
+#include "common/desktop.h"
+#include "platform/freedesktop/dbus.h"
+#include "yasl/desktop.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/syscall.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+extern char **environ;
+
+static size_t copy_str(char *buf, size_t cap, const char *s)
+{
+ size_t len = strlen(s);
+ if (!len || len >= cap) return 0;
+ memcpy(buf, s, len + 1);
+ return len;
+}
+
+/* Find an executable in PATH, like execvp but before forking. */
+static bool find_program(const char *name, char *out, size_t cap)
+{
+ const char *path = getenv("PATH");
+ if (!path || !*path) path = "/usr/local/bin:/usr/bin:/bin";
+ size_t name_len = strlen(name);
+ while (*path) {
+ const char *end = strchr(path, ':');
+ size_t dir_len = end ? (size_t)(end - path) : strlen(path);
+ if (dir_len && dir_len + 1 + name_len < cap) {
+ memcpy(out, path, dir_len);
+ out[dir_len] = '/';
+ memcpy(out + dir_len + 1, name, name_len + 1);
+ if (access(out, X_OK) == 0) return true;
+ }
+ if (!end) break;
+ path = end + 1;
+ }
+ return false;
+}
+
+bool desktop_open_uri(const char *uri)
+{
+ char program[4096];
+ if (!find_program("xdg-open", program, sizeof(program))) return false;
+ char *argv[] = {"xdg-open", (char *)uri, NULL};
+
+ /* Prepare everything before fork: the children of a threaded process may
+ * only make async-signal-safe calls. */
+ struct sigaction dfl = {.sa_handler = SIG_DFL};
+ sigemptyset(&dfl.sa_mask);
+ sigset_t none;
+ sigemptyset(&none);
+ long max_fd = sysconf(_SC_OPEN_MAX);
+ if (max_fd < 0 || max_fd > 65536) max_fd = 65536;
+
+ /* The middle child exits at once, so the opener is reparented away from
+ * the application and never needs reaping here. */
+ pid_t pid = fork();
+ if (pid < 0) return false;
+ if (pid == 0) {
+ setsid();
+ pid_t opener = fork();
+ if (opener != 0) _exit(opener < 0 ? 1 : 0);
+ for (int sig = 1; sig < NSIG; sig++)
+ if (sig != SIGKILL && sig != SIGSTOP) sigaction(sig, &dfl, NULL);
+ sigprocmask(SIG_SETMASK, &none, NULL);
+ int null = open("/dev/null", O_RDONLY);
+ if (null > 0) {
+ dup2(null, STDIN_FILENO);
+ close(null);
+ }
+ /* Keep application descriptors, such as pty masters, out of the opener. */
+#ifdef SYS_close_range
+ if (syscall(SYS_close_range, 3u, ~0u, 0u) != 0)
+#endif
+ for (int fd = 3; fd < max_fd; fd++) close(fd);
+ execve(program, argv, environ);
+ _exit(127);
+ }
+
+ int status;
+ pid_t done;
+ do {
+ done = waitpid(pid, &status, 0);
+ } while (done < 0 && errno == EINTR);
+ /* An application reaper can collect the middle child first. */
+ if (done < 0) return errno == ECHILD;
+ return WIFEXITED(status) && WEXITSTATUS(status) == 0;
+}
+
+bool desktop_notify(const char *app_id, const char *title, const char *body)
+{
+ return bus_notify(app_id ? app_id : "yasl", title, body);
+}
+
+uint32_t desktop_appearance(void)
+{
+ uint32_t flags = 0;
+ bool portal = false;
+ int64_t value;
+ if (portal_read_int("org.freedesktop.appearance", "color-scheme", &value)) {
+ portal = true;
+ if (value == 1) flags |= YASL_APPEARANCE_DARK;
+ else if (value == 2) flags |= YASL_APPEARANCE_LIGHT;
+ }
+ if (portal_read_int("org.freedesktop.appearance", "contrast", &value)) {
+ portal = true;
+ if (value == 1) flags |= YASL_APPEARANCE_HIGH_CONTRAST;
+ }
+ if (portal) return flags;
+
+ /* GTK_THEME is "Name" or "Name:variant", as in "Adwaita:dark". */
+ const char *theme = getenv("GTK_THEME");
+ if (!theme) return 0;
+ if (strstr(theme, "HighContrast")) flags |= YASL_APPEARANCE_HIGH_CONTRAST;
+ if (strstr(theme, ":dark") || strstr(theme, "HighContrastInverse"))
+ flags |= YASL_APPEARANCE_DARK;
+ return flags;
+}
+
+size_t desktop_executable_path(char *buf, size_t cap)
+{
+ /* readlink truncates silently, so a full buffer may hold a cut path. */
+ ssize_t len = readlink("/proc/self/exe", buf, cap);
+ if (len <= 0 || (size_t)len >= cap) return 0;
+ buf[len] = '\0';
+ return (size_t)len;
+}
+
+size_t desktop_resource_dir(char *buf, size_t cap)
+{
+ (void)buf;
+ (void)cap;
+ return 0;
+}
+
+size_t desktop_default_locale(char *buf, size_t cap)
+{
+ static const char *const vars[] = {"LC_ALL", "LC_CTYPE", "LANG"};
+ for (size_t i = 0; i < sizeof(vars) / sizeof(vars[0]); i++) {
+ const char *v = getenv(vars[i]);
+ if (v && *v) return copy_str(buf, cap, v);
+ }
+ return copy_str(buf, cap, "C.UTF-8");
+}
diff --git a/src/platform/freedesktop/meson.build b/src/platform/freedesktop/meson.build
new file mode 100644
index 0000000..6f43895
--- /dev/null
+++ b/src/platform/freedesktop/meson.build
@@ -0,0 +1 @@
+sources += files('desktop.c', 'dbus.c')
generated by cgit v1.2.3 (git 2.39.1) at 2026-10-25 07:43:24 +0000