diff options
Diffstat (limited to 'dbus.c')
| -rw-r--r-- | dbus.c | 240 |
1 files changed, 240 insertions, 0 deletions
@@ -0,0 +1,240 @@ +#include "dbus.h" + +#include <dbus/dbus.h> +#include <wayland-server-core.h> + +#include <stddef.h> +#include <stdint.h> +#include <stdio.h> +#if defined __linux__ +#include <sys/eventfd.h> +#elif defined(__FreeBSD__) || defined(__OpenBSD__) +#include <sys/event.h> +#endif +#include <unistd.h> + +int efd = -1; + +static int +dwl_dbus_dispatch(int fd, unsigned int mask, void *data) +{ + DBusConnection *conn = data; + + uint64_t dispatch_pending; + DBusDispatchStatus status; + + status = dbus_connection_dispatch(conn); + + /* + * Don't clear pending flag if message queue wasn't + * fully drained + */ + if (status != DBUS_DISPATCH_COMPLETE) + return 0; + + if (read(fd, &dispatch_pending, sizeof(uint64_t)) < 0) + perror("read"); + + return 0; +} + +static int +dwl_dbus_watch_handle(int fd, uint32_t mask, void *data) +{ + DBusWatch *watch = data; + + uint32_t flags = 0; + + if (!dbus_watch_get_enabled(watch)) + return 0; + + if (mask & WL_EVENT_READABLE) + flags |= DBUS_WATCH_READABLE; + if (mask & WL_EVENT_WRITABLE) + flags |= DBUS_WATCH_WRITABLE; + if (mask & WL_EVENT_HANGUP) + flags |= DBUS_WATCH_HANGUP; + if (mask & WL_EVENT_ERROR) + flags |= DBUS_WATCH_ERROR; + + dbus_watch_handle(watch, flags); + + return 0; +} + +static dbus_bool_t +dwl_dbus_add_watch(DBusWatch *watch, void *data) +{ + struct wl_event_loop *loop = data; + + int fd; + struct wl_event_source *watch_source; + uint32_t mask = 0, flags; + + if (!dbus_watch_get_enabled(watch)) + return TRUE; + + flags = dbus_watch_get_flags(watch); + if (flags & DBUS_WATCH_READABLE) + mask |= WL_EVENT_READABLE; + if (flags & DBUS_WATCH_WRITABLE) + mask |= WL_EVENT_WRITABLE; + + fd = dbus_watch_get_unix_fd(watch); + watch_source = wl_event_loop_add_fd(loop, fd, mask, + dwl_dbus_watch_handle, watch); + + dbus_watch_set_data(watch, watch_source, NULL); + + return TRUE; +} + +static void +dwl_dbus_remove_watch(DBusWatch *watch, void *data) +{ + struct wl_event_source *watch_source = dbus_watch_get_data(watch); + + if (watch_source) + wl_event_source_remove(watch_source); +} + +static int +dwl_dbus_timeout_handle(void *data) +{ + DBusTimeout *timeout = data; + + if (dbus_timeout_get_enabled(timeout)) + dbus_timeout_handle(timeout); + + return 0; +} + +static dbus_bool_t +dwl_dbus_add_timeout(DBusTimeout *timeout, void *data) +{ + struct wl_event_loop *loop = data; + + int r, interval; + struct wl_event_source *timeout_source; + + if (!dbus_timeout_get_enabled(timeout)) + return TRUE; + + interval = dbus_timeout_get_interval(timeout); + + timeout_source = wl_event_loop_add_timer( + loop, dwl_dbus_timeout_handle, timeout); + + r = wl_event_source_timer_update(timeout_source, interval); + if (r < 0) { + wl_event_source_remove(timeout_source); + return FALSE; + } + + dbus_timeout_set_data(timeout, timeout_source, NULL); + + return TRUE; +} + +static void +dwl_dbus_remove_timeout(DBusTimeout *timeout, void *data) +{ + struct wl_event_source *timeout_source; + + timeout_source = dbus_timeout_get_data(timeout); + + if (timeout_source) { + wl_event_source_timer_update(timeout_source, 0); + wl_event_source_remove(timeout_source); + } +} + +static void +dwl_dbus_adjust_timeout(DBusTimeout *timeout, void *data) +{ + int interval; + struct wl_event_source *timeout_source; + + timeout_source = dbus_timeout_get_data(timeout); + + if (timeout_source) { + interval = dbus_timeout_get_interval(timeout); + wl_event_source_timer_update(timeout_source, interval); + } +} + +static void +dwl_dbus_dispatch_status(DBusConnection *conn, DBusDispatchStatus status, void *data) +{ + if (status == DBUS_DISPATCH_DATA_REMAINS) { + uint64_t dispatch_pending = 1; + if (write(efd, &dispatch_pending, sizeof(uint64_t)) < 0) + perror("write"); + } +} + +struct wl_event_source * +startbus(DBusConnection *conn, struct wl_event_loop *loop) +{ + struct wl_event_source *bus_source = NULL; + uint64_t dispatch_pending = 1; + + dbus_connection_set_exit_on_disconnect(conn, FALSE); + +#if defined __linux__ + efd = eventfd(0, EFD_CLOEXEC); +#elif defined(__FreeBSD__) || defined(__OpenBSD__) + efd = kqueue(); +#endif + if (efd < 0) + goto fail; + + dbus_connection_set_dispatch_status_function(conn, dwl_dbus_dispatch_status, NULL, NULL); + + if (!dbus_connection_set_watch_functions(conn, dwl_dbus_add_watch, + dwl_dbus_remove_watch, + NULL, loop, NULL)) { + goto fail; + } + + if (!dbus_connection_set_timeout_functions( + conn, dwl_dbus_add_timeout, dwl_dbus_remove_timeout, + dwl_dbus_adjust_timeout, loop, NULL)) { + goto fail; + } + + bus_source = wl_event_loop_add_fd(loop, efd, WL_EVENT_READABLE, dwl_dbus_dispatch, conn); + if (!bus_source) + goto fail; + + if (dbus_connection_get_dispatch_status(conn) == DBUS_DISPATCH_DATA_REMAINS) + if (write(efd, &dispatch_pending, sizeof(uint64_t)) < 0) + perror("write"); + + return bus_source; + +fail: + if (bus_source) + wl_event_source_remove(bus_source); + if (efd >= 0) { + close(efd); + efd = -1; + } + dbus_connection_set_timeout_functions(conn, NULL, NULL, NULL, NULL, NULL); + dbus_connection_set_watch_functions(conn, NULL, NULL, NULL, NULL, NULL); + dbus_connection_set_dispatch_status_function(conn, NULL, NULL, NULL); + + return NULL; +} + +void +stopbus(DBusConnection *conn, struct wl_event_source *bus_source) +{ + wl_event_source_remove(bus_source); + close(efd); + efd = -1; + + dbus_connection_set_watch_functions(conn, NULL, NULL, NULL, NULL, NULL); + dbus_connection_set_timeout_functions(conn, NULL, NULL, NULL, NULL, NULL); + dbus_connection_set_dispatch_status_function(conn, NULL, NULL, NULL); +} |