diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/libsystemd-terminal/sysview-internal.h | 140 | ||||
| -rw-r--r-- | src/libsystemd-terminal/sysview.c | 1471 | ||||
| -rw-r--r-- | src/libsystemd-terminal/sysview.h | 151 |
3 files changed, 1762 insertions, 0 deletions
diff --git a/src/libsystemd-terminal/sysview-internal.h b/src/libsystemd-terminal/sysview-internal.h new file mode 100644 index 0000000000..5aee9f67d8 --- /dev/null +++ b/src/libsystemd-terminal/sysview-internal.h @@ -0,0 +1,140 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com> + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see <http://www.gnu.org/licenses/>. +***/ + +#pragma once + +#include <inttypes.h> +#include <libudev.h> +#include <stdbool.h> +#include <stdlib.h> +#include <systemd/sd-bus.h> +#include <systemd/sd-event.h> +#include "hashmap.h" +#include "list.h" +#include "macro.h" +#include "sysview.h" +#include "util.h" + +/* + * Devices + */ + +struct sysview_device { + sysview_seat *seat; + const char *name; + unsigned int type; + + union { + struct { + struct udev_device *ud; + } evdev, drm; + }; +}; + +sysview_device *sysview_find_device(sysview_context *c, const char *name); + +int sysview_device_new(sysview_device **out, sysview_seat *seat, const char *name); +sysview_device *sysview_device_free(sysview_device *device); + +DEFINE_TRIVIAL_CLEANUP_FUNC(sysview_device*, sysview_device_free); + +/* + * Sessions + */ + +struct sysview_session { + sysview_seat *seat; + char *name; + char *path; + + sd_bus_slot *slot_take_control; + + bool custom : 1; + bool public : 1; + bool wants_control : 1; + bool has_control : 1; +}; + +sysview_session *sysview_find_session(sysview_context *c, const char *name); + +int sysview_session_new(sysview_session **out, sysview_seat *seat, const char *name); +sysview_session *sysview_session_free(sysview_session *session); + +DEFINE_TRIVIAL_CLEANUP_FUNC(sysview_session*, sysview_session_free); + +/* + * Seats + */ + +struct sysview_seat { + sysview_context *context; + char *name; + + Hashmap *session_map; + Hashmap *device_map; + + bool scanned : 1; + bool public : 1; +}; + +sysview_seat *sysview_find_seat(sysview_context *c, const char *name); + +int sysview_seat_new(sysview_seat **out, sysview_context *c, const char *name); +sysview_seat *sysview_seat_free(sysview_seat *seat); + +DEFINE_TRIVIAL_CLEANUP_FUNC(sysview_seat*, sysview_seat_free); + +/* + * Contexts + */ + +struct sysview_context { + sd_event *event; + sd_bus *sysbus; + struct udev *ud; + uint64_t custom_sid; + + Hashmap *seat_map; + Hashmap *session_map; + Hashmap *device_map; + + sd_event_source *scan_src; + sysview_event_fn event_fn; + void *userdata; + + /* udev scanner */ + struct udev_monitor *ud_monitor; + sd_event_source *ud_monitor_src; + + /* logind scanner */ + sd_bus_slot *ld_slot_manager_signal; + sd_bus_slot *ld_slot_list_seats; + sd_bus_slot *ld_slot_list_sessions; + + bool scan_logind : 1; + bool scan_evdev : 1; + bool scan_drm : 1; + bool running : 1; + bool scanned : 1; + bool rescan : 1; +}; + +int sysview_context_rescan(sysview_context *c); diff --git a/src/libsystemd-terminal/sysview.c b/src/libsystemd-terminal/sysview.c new file mode 100644 index 0000000000..d885cb4d4a --- /dev/null +++ b/src/libsystemd-terminal/sysview.c @@ -0,0 +1,1471 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com> + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see <http://www.gnu.org/licenses/>. +***/ + +#include <inttypes.h> +#include <libudev.h> +#include <stdbool.h> +#include <stdlib.h> +#include <systemd/sd-bus.h> +#include <systemd/sd-event.h> +#include <systemd/sd-login.h> +#include "bus-util.h" +#include "event-util.h" +#include "macro.h" +#include "set.h" +#include "sysview.h" +#include "sysview-internal.h" +#include "udev-util.h" +#include "util.h" + +static int context_raise_session_control(sysview_context *c, sysview_session *session, int error); + +/* + * Devices + */ + +sysview_device *sysview_find_device(sysview_context *c, const char *name) { + assert_return(c, NULL); + assert_return(name, NULL); + + return hashmap_get(c->device_map, name); +} + +int sysview_device_new(sysview_device **out, sysview_seat *seat, const char *name) { + _cleanup_(sysview_device_freep) sysview_device *device = NULL; + int r; + + assert_return(seat, -EINVAL); + assert_return(name, -EINVAL); + + device = new0(sysview_device, 1); + if (!device) + return -ENOMEM; + + device->seat = seat; + device->type = (unsigned)-1; + + device->name = strdup(name); + if (!device->name) + return -ENOMEM; + + r = hashmap_put(seat->context->device_map, device->name, device); + if (r < 0) + return r; + + r = hashmap_put(seat->device_map, device->name, device); + if (r < 0) + return r; + + if (out) + *out = device; + device = NULL; + return 0; +} + +sysview_device *sysview_device_free(sysview_device *device) { + if (!device) + return NULL; + + if (device->name) { + hashmap_remove_value(device->seat->device_map, device->name, device); + hashmap_remove_value(device->seat->context->device_map, device->name, device); + } + + switch (device->type) { + case SYSVIEW_DEVICE_EVDEV: + device->evdev.ud = udev_device_unref(device->evdev.ud); + break; + case SYSVIEW_DEVICE_DRM: + device->drm.ud = udev_device_unref(device->drm.ud); + break; + } + + free(device); + + return NULL; +} + +unsigned int sysview_device_get_type(sysview_device *device) { + assert_return(device, (unsigned)-1); + + return device->type; +} + +struct udev_device *sysview_device_get_ud(sysview_device *device) { + assert_return(device, NULL); + + switch (device->type) { + case SYSVIEW_DEVICE_EVDEV: + return device->evdev.ud; + case SYSVIEW_DEVICE_DRM: + return device->drm.ud; + default: + assert_return(0, NULL); + } +} + +static int device_new_ud(sysview_device **out, sysview_seat *seat, unsigned int type, struct udev_device *ud) { + _cleanup_(sysview_device_freep) sysview_device *device = NULL; + int r; + + assert_return(seat, -EINVAL); + assert_return(ud, -EINVAL); + + r = sysview_device_new(&device, seat, udev_device_get_syspath(ud)); + if (r < 0) + return r; + + device->type = type; + + switch (type) { + case SYSVIEW_DEVICE_EVDEV: + device->evdev.ud = udev_device_ref(ud); + break; + case SYSVIEW_DEVICE_DRM: + device->drm.ud = udev_device_ref(ud); + break; + default: + assert_not_reached("sysview: invalid udev-device type"); + } + + if (out) + *out = device; + device = NULL; + return 0; +} + +/* + * Sessions + */ + +sysview_session *sysview_find_session(sysview_context *c, const char *name) { + assert_return(c, NULL); + assert_return(name, NULL); + + return hashmap_get(c->session_map, name); +} + +int sysview_session_new(sysview_session **out, sysview_seat *seat, const char *name) { + _cleanup_(sysview_session_freep) sysview_session *session = NULL; + int r; + + assert_return(seat, -EINVAL); + + session = new0(sysview_session, 1); + if (!session) + return -ENOMEM; + + session->seat = seat; + + if (name) { + /* + * If a name is given, we require it to be a logind session + * name. The session will be put in managed mode and we use + * logind to request controller access. + */ + + session->name = strdup(name); + if (!session->name) + return -ENOMEM; + + r = sd_bus_path_encode("/org/freedesktop/login1/session", + session->name, &session->path); + if (r < 0) + return r; + + session->custom = false;; + } else { + /* + * No session name was given. We assume this is an unmanaged + * session controlled by the application. We don't use logind + * at all and leave session management to the application. The + * name of the session-object is set to a unique random string + * that does not clash with the logind namespace. + */ + + r = asprintf(&session->name, "@custom%" PRIu64, + ++seat->context->custom_sid); + if (r < 0) + return -ENOMEM; + + session->custom = true; + } + + r = hashmap_put(seat->context->session_map, session->name, session); + if (r < 0) + return r; + + r = hashmap_put(seat->session_map, session->name, session); + if (r < 0) + return r; + + if (out) + *out = session; + session = NULL; + return 0; +} + +sysview_session *sysview_session_free(sysview_session *session) { + if (!session) + return NULL; + + assert(!session->public); + assert(!session->wants_control); + + if (session->name) { + hashmap_remove_value(session->seat->session_map, session->name, session); + hashmap_remove_value(session->seat->context->session_map, session->name, session); + } + + free(session->path); + free(session->name); + free(session); + + return NULL; +} + +const char *sysview_session_get_name(sysview_session *session) { + assert_return(session, NULL); + + return session->name; +} + +static int session_take_control_fn(sd_bus *bus, + sd_bus_message *reply, + void *userdata, + sd_bus_error *ret_error) { + sysview_session *session = userdata; + int error; + + session->slot_take_control = sd_bus_slot_unref(session->slot_take_control); + + if (sd_bus_message_is_method_error(reply, NULL)) { + const sd_bus_error *e = sd_bus_message_get_error(reply); + + log_debug("sysview: %s: TakeControl failed: %s: %s", + session->name, e->name, e->message); + error = sd_bus_error_get_errno(e); + } else { + session->has_control = true; + error = 0; + } + + return context_raise_session_control(session->seat->context, session, error); +} + +int sysview_session_take_control(sysview_session *session) { + _cleanup_bus_message_unref_ sd_bus_message *m = NULL; + int r; + + assert_return(session, -EINVAL); + assert_return(!session->custom, -EINVAL); + + if (session->wants_control) + return 0; + + r = sd_bus_message_new_method_call(session->seat->context->sysbus, + &m, + "org.freedesktop.login1", + session->path, + "org.freedesktop.login1.Session", + "TakeControl"); + if (r < 0) + return r; + + r = sd_bus_message_append(m, "b", 0); + if (r < 0) + return r; + + r = sd_bus_call_async(session->seat->context->sysbus, + &session->slot_take_control, + m, + session_take_control_fn, + session, + 0); + if (r < 0) + return r; + + session->wants_control = true; + return 0; +} + +void sysview_session_release_control(sysview_session *session) { + _cleanup_bus_message_unref_ sd_bus_message *m = NULL; + int r; + + assert(session); + assert(!session->custom); + + if (!session->wants_control) + return; + + session->wants_control = false; + + if (!session->has_control && !session->slot_take_control) + return; + + session->has_control = false; + session->slot_take_control = sd_bus_slot_unref(session->slot_take_control); + + r = sd_bus_message_new_method_call(session->seat->context->sysbus, + &m, + "org.freedesktop.login1", + session->path, + "org.freedesktop.login1.Session", + "ReleaseControl"); + if (r >= 0) + r = sd_bus_send(session->seat->context->sysbus, m, NULL); + + if (r < 0 && r != -ENOTCONN) + log_debug("sysview: %s: cannot send ReleaseControl: %s", + session->name, strerror(-r)); +} + +/* + * Seats + */ + +sysview_seat *sysview_find_seat(sysview_context *c, const char *name) { + assert_return(c, NULL); + assert_return(name, NULL); + + return hashmap_get(c->seat_map, name); +} + +int sysview_seat_new(sysview_seat **out, sysview_context *c, const char *name) { + _cleanup_(sysview_seat_freep) sysview_seat *seat = NULL; + int r; + + assert_return(c, -EINVAL); + assert_return(name, -EINVAL); + + seat = new0(sysview_seat, 1); + if (!seat) + return -ENOMEM; + + seat->context = c; + + seat->name = strdup(name); + if (!seat->name) + return -ENOMEM; + + seat->session_map = hashmap_new(string_hash_func, string_compare_func); + if (!seat->session_map) + return -ENOMEM; + + seat->device_map = hashmap_new(string_hash_func, string_compare_func); + if (!seat->device_map) + return -ENOMEM; + + r = hashmap_put(c->seat_map, seat->name, seat); + if (r < 0) + return r; + + if (out) + *out = seat; + seat = NULL; + return 0; +} + +sysview_seat *sysview_seat_free(sysview_seat *seat) { + if (!seat) + return NULL; + + assert(!seat->public); + assert(hashmap_size(seat->device_map) == 0); + assert(hashmap_size(seat->session_map) == 0); + + if (seat->name) + hashmap_remove_value(seat->context->seat_map, seat->name, seat); + + hashmap_free(seat->device_map); + hashmap_free(seat->session_map); + free(seat->name); + free(seat); + + return NULL; +} + +const char *sysview_seat_get_name(sysview_seat *seat) { + assert_return(seat, NULL); + + return seat->name; +} + +/* + * Contexts + */ + +static int context_raise(sysview_context *c, sysview_event *event, int def) { + return c->running ? c->event_fn(c, c->userdata, event) : def; +} + +static int context_raise_seat_add(sysview_context *c, sysview_seat *seat) { + sysview_event event = { + .type = SYSVIEW_EVENT_SEAT_ADD, + .seat_add = { + .seat = seat, + } + }; + + return context_raise(c, &event, 0); +} + +static int context_raise_seat_remove(sysview_context *c, sysview_seat *seat) { + sysview_event event = { + .type = SYSVIEW_EVENT_SEAT_REMOVE, + .seat_remove = { + .seat = seat, + } + }; + + return context_raise(c, &event, 0); +} + +static int context_raise_session_filter(sysview_context *c, + const char *id, + const char *seatid, + const char *username, + unsigned int uid) { + sysview_event event = { + .type = SYSVIEW_EVENT_SESSION_FILTER, + .session_filter = { + .id = id, + .seatid = seatid, + .username = username, + .uid = uid, + } + }; + + return context_raise(c, &event, 1); +} + +static int context_raise_session_add(sysview_context *c, sysview_session *session) { + sysview_event event = { + .type = SYSVIEW_EVENT_SESSION_ADD, + .session_add = { + .session = session, + } + }; + + return context_raise(c, &event, 0); +} + +static int context_raise_session_remove(sysview_context *c, sysview_session *session) { + sysview_event event = { + .type = SYSVIEW_EVENT_SESSION_REMOVE, + .session_remove = { + .session = session, + } + }; + + return context_raise(c, &event, 0); +} + +static int context_raise_session_control(sysview_context *c, sysview_session *session, int error) { + sysview_event event = { + .type = SYSVIEW_EVENT_SESSION_CONTROL, + .session_control = { + .session = session, + .error = error, + } + }; + + return context_raise(c, &event, 0); +} + +static int context_raise_session_attach(sysview_context *c, sysview_session *session, sysview_device *device) { + sysview_event event = { + .type = SYSVIEW_EVENT_SESSION_ATTACH, + .session_attach = { + .session = session, + .device = device, + } + }; + + return context_raise(c, &event, 0); +} + +static int context_raise_session_detach(sysview_context *c, sysview_session *session, sysview_device *device) { + sysview_event event = { + .type = SYSVIEW_EVENT_SESSION_DETACH, + .session_detach = { + .session = session, + .device = device, + } + }; + + return context_raise(c, &event, 0); +} + +static int context_add_device(sysview_context *c, sysview_device *device) { + sysview_session *session; + int r, error = 0; + Iterator i; + + assert(c); + assert(device); + + log_debug("sysview: add device '%s' on seat '%s'", + device->name, device->seat->name); + + HASHMAP_FOREACH(session, device->seat->session_map, i) { + if (!session->public) + continue; + + r = context_raise_session_attach(c, session, device); + if (r != 0) + error = r; + } + + if (error < 0) + log_debug("sysview: error while adding device '%s': %s", + device->name, strerror(-r)); + return error; +} + +static int context_remove_device(sysview_context *c, sysview_device *device) { + sysview_session *session; + int r, error = 0; + Iterator i; + + assert(c); + assert(device); + + log_debug("sysview: remove device '%s'", device->name); + + HASHMAP_FOREACH(session, device->seat->session_map, i) { + if (!session->public) + continue; + + r = context_raise_session_detach(c, session, device); + if (r != 0) + error = r; + } + + if (error < 0) + log_debug("sysview: error while removing device '%s': %s", + device->name, strerror(-r)); + sysview_device_free(device); + return error; +} + +static int context_add_session(sysview_context *c, sysview_seat *seat, const char *id) { + sysview_session *session; + sysview_device *device; + int r, error = 0; + Iterator i; + + assert(c); + assert(seat); + assert(id); + + session = sysview_find_session(c, id); + if (session) + return 0; + + log_debug("sysview: add session '%s' on seat '%s'", id, seat->name); + + r = sysview_session_new(&session, seat, id); + if (r < 0) + goto error; + + if (!seat->scanned) { + r = sysview_context_rescan(c); + if (r < 0) + goto error; + } + + if (seat->public) { + session->public = true; + r = context_raise_session_add(c, session); + if (r != 0) { + session->public = false; + goto error; + } + + HASHMAP_FOREACH(device, seat->device_map, i) { + r = context_raise_session_attach(c, session, device); + if (r != 0) + error = r; + } + + r = error; + if (r != 0) + goto error; + } + + return 0; + +error: + if (r < 0) + log_debug("sysview: error while adding session '%s': %s", + id, strerror(-r)); + return r; +} + +static int context_remove_session(sysview_context *c, sysview_session *session) { + sysview_device *device; + int r, error = 0; + Iterator i; + + assert(c); + assert(session); + + log_debug("sysview: remove session '%s'", session->name); + + if (session->public) { + HASHMAP_FOREACH(device, session->seat->device_map, i) { + r = context_raise_session_detach(c, session, device); + if (r != 0) + error = r; + } + + session->public = false; + r = context_raise_session_remove(c, session); + if (r != 0) + error = r; + } + + if (!session->custom) + sysview_session_release_control(session); + + if (error < 0) + log_debug("sysview: error while removing session '%s': %s", + session->name, strerror(-error)); + sysview_session_free(session); + return error; +} + +static int context_add_seat(sysview_context *c, const char *id) { + sysview_seat *seat; + int r; + + assert(c); + assert(id); + + seat = sysview_find_seat(c, id); + if (seat) + return 0; + + log_debug("sysview: add seat '%s'", id); + + r = sysview_seat_new(&seat, c, id); + if (r < 0) + goto error; + + seat->public = true; + r = context_raise_seat_add(c, seat); + if (r != 0) { + seat->public = false; + goto error; + } + + return 0; + +error: + if (r < 0) + log_debug("sysview: error while adding seat '%s': %s", + id, strerror(-r)); + return r; +} + +static int context_remove_seat(sysview_context *c, sysview_seat *seat) { + sysview_session *session; + sysview_device *device; + int r, error = 0; + + assert(c); + assert(seat); + + log_debug("sysview: remove seat '%s'", seat->name); + + while ((device = hashmap_first(seat->device_map))) { + r = context_remove_device(c, device); + if (r != 0) + error = r; + } + + while ((session = hashmap_first(seat->session_map))) { + r = context_remove_session(c, session); + if (r != 0) + error = r; + } + + if (seat->public) { + seat->public = false; + r = context_raise_seat_remove(c, seat); + if (r != 0) + error = r; + } + + if (error < 0) + log_debug("sysview: error while removing seat '%s': %s", + seat->name, strerror(-error)); + sysview_seat_free(seat); + return error; +} + +int sysview_context_new(sysview_context **out, + unsigned int flags, + sd_event *event, + sd_bus *sysbus, + struct udev *ud) { + _cleanup_(sysview_context_freep) sysview_context *c = NULL; + int r; + + assert_return(out, -EINVAL); + assert_return(event, -EINVAL); + + log_debug("sysview: new"); + + c = new0(sysview_context, 1); + if (!c) + return -ENOMEM; + + c->event = sd_event_ref(event); + if (flags & SYSVIEW_CONTEXT_SCAN_LOGIND) + c->scan_logind = true; + if (flags & SYSVIEW_CONTEXT_SCAN_EVDEV) + c->scan_evdev = true; + if (flags & SYSVIEW_CONTEXT_SCAN_DRM) + c->scan_drm = true; + + if (sysbus) { + c->sysbus = sd_bus_ref(sysbus); + } else if (c->scan_logind) { + r = sd_bus_open_system(&c->sysbus); + if (r < 0) + return r; + } + + if (ud) { + c->ud = udev_ref(ud); + } else if (c->scan_evdev || c->scan_drm) { + errno = 0; + c->ud = udev_new(); + if (!c->ud) + return errno > 0 ? -errno : -EFAULT; + } + + c->seat_map = hashmap_new(string_hash_func, string_compare_func); + if (!c->seat_map) + return -ENOMEM; + + c->session_map = hashmap_new(string_hash_func, string_compare_func); + if (!c->session_map) + return -ENOMEM; + + c->device_map = hashmap_new(string_hash_func, string_compare_func); + if (!c->device_map) + return -ENOMEM; + + *out = c; + c = NULL; + return 0; +} + +sysview_context *sysview_context_free(sysview_context *c) { + if (!c) + return NULL; + + log_debug("sysview: free"); + + sysview_context_stop(c); + + assert(hashmap_size(c->device_map) == 0); + assert(hashmap_size(c->session_map) == 0); + assert(hashmap_size(c->seat_map) == 0); + + hashmap_free(c->device_map); + hashmap_free(c->session_map); + hashmap_free(c->seat_map); + c->ud = udev_unref(c->ud); + c->sysbus = sd_bus_unref(c->sysbus); + c->event = sd_event_unref(c->event); + free(c); + + return NULL; +} + +static int context_ud_prepare_monitor(sysview_context *c, struct udev_monitor *m) { + int r; + + if (c->scan_evdev) { + r = udev_monitor_filter_add_match_subsystem_devtype(m, "input", NULL); + if (r < 0) + return r; + } + + if (c->scan_drm) { + r = udev_monitor_filter_add_match_subsystem_devtype(m, "drm", NULL); + if (r < 0) + return r; + } + + return r; +} + +static int context_ud_prepare_scan(sysview_context *c, struct udev_enumerate *e) { + int r; + + if (c->scan_evdev) { + r = udev_enumerate_add_match_subsystem(e, "input"); + if (r < 0) + return r; + } + + if (c->scan_drm) { + r = udev_enumerate_add_match_subsystem(e, "drm"); + if (r < 0) + return r; + } + + r = udev_enumerate_add_match_is_initialized(e); + if (r < 0) + return r; + + return 0; +} + +static int context_ud_hotplug(sysview_context *c, struct udev_device *d) { + const char *syspath, *sysname, *subsystem, *action, *seatname; + sysview_device *device; + int r; + + syspath = udev_device_get_syspath(d); + sysname = udev_device_get_sysname(d); + subsystem = udev_device_get_subsystem(d); + action = udev_device_get_action(d); + + /* not interested in custom devices without syspath/etc */ + if (!syspath || !sysname || !subsystem) + return 0; + + device = sysview_find_device(c, syspath); + + if (streq_ptr(action, "remove")) { + if (!device) + return 0; + + return context_remove_device(c, device); + } else if (streq_ptr(action, "change")) { + if (!device) + return 0; + + /* TODO: send REFRESH event */ + } else if (!action || streq_ptr(action, "add")) { + struct udev_device *p; + unsigned int type, t; + sysview_seat *seat; + + if (device) + return 0; + + if (streq(subsystem, "input") && startswith(sysname, "event") && safe_atou(sysname + 5, &t) >= 0) + type = SYSVIEW_DEVICE_EVDEV; + else if (streq(subsystem, "drm") && startswith(sysname, "card") && safe_atou(sysname + 4, &t) >= 0) + type = SYSVIEW_DEVICE_DRM; + else + type = (unsigned)-1; + + if (type >= SYSVIEW_DEVICE_CNT) + return 0; + + p = d; + seatname = NULL; + while ((p = udev_device_get_parent(p))) { + seatname = udev_device_get_property_value(p, "ID_SEAT"); + if (seatname) + break; + } + + seat = sysview_find_seat(c, seatname ? : "seat0"); + if (!seat) + return 0; + + r = device_new_ud(&device, seat, type, d); + if (r < 0) { + log_debug("sysview: cannot create device for udev-device '%s': %s", + syspath, strerror(-r)); + return r; + } + + return context_add_device(c, device); + } + + return 0; +} + +static int context_ud_monitor_fn(sd_event_source *s, + int fd, + uint32_t revents, + void *userdata) { + sysview_context *c = userdata; + struct udev_device *d; + int r; + + if (revents & EPOLLIN) { + while ((d = udev_monitor_receive_device(c->ud_monitor))) { + r = context_ud_hotplug(c, d); + udev_device_unref(d); + if (r != 0) + return r; + } + + /* as long as EPOLLIN is signalled, read pending data */ + return 0; + } + + if (revents & (EPOLLHUP | EPOLLERR)) { + log_debug("sysview: HUP on udev-monitor"); + c->ud_monitor_src = sd_event_source_unref(c->ud_monitor_src); + } + + return 0; +} + +static int context_ud_start(sysview_context *c) { + int r, fd; + + if (!c->ud) + return 0; + + errno = 0; + c->ud_monitor = udev_monitor_new_from_netlink(c->ud, "udev"); + if (!c->ud_monitor) + return errno > 0 ? -errno : -EFAULT; + + r = context_ud_prepare_monitor(c, c->ud_monitor); + if (r < 0) + return r; + + r = udev_monitor_enable_receiving(c->ud_monitor); + if (r < 0) + return r; + + fd = udev_monitor_get_fd(c->ud_monitor); + r = sd_event_add_io(c->event, + &c->ud_monitor_src, + fd, + EPOLLHUP | EPOLLERR | EPOLLIN, + context_ud_monitor_fn, + c); + if (r < 0) + return r; + + return 0; +} + +static void context_ud_stop(sysview_context *c) { + c->ud_monitor_src = sd_event_source_unref(c->ud_monitor_src); + c->ud_monitor = udev_monitor_unref(c->ud_monitor); +} + +static int context_ud_scan(sysview_context *c) { + _cleanup_(udev_enumerate_unrefp) struct udev_enumerate *e = NULL; + struct udev_list_entry *entry; + struct udev_device *d; + int r; + + if (!c->ud_monitor) + return 0; + + errno = 0; + e = udev_enumerate_new(c->ud); + if (!e) + return errno > 0 ? -errno : -EFAULT; + + r = context_ud_prepare_scan(c, e); + if (r < 0) + return r; + + r = udev_enumerate_scan_devices(e); + if (r < 0) + return r; + + udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) { + const char *name; + + name = udev_list_entry_get_name(entry); + + errno = 0; + d = udev_device_new_from_syspath(c->ud, name); + if (!d) { + r = errno > 0 ? -errno : -EFAULT; + log_debug("sysview: cannot create udev-device for %s: %s", + name, strerror(-r)); + continue; + } + + r = context_ud_hotplug(c, d); + udev_device_unref(d); + if (r != 0) + return r; + } + + return 0; +} + +static int context_ld_seat_new(sysview_context *c, sd_bus_message *signal) { + const char *id, *path; + int r; + + r = sd_bus_message_read(signal, "so", &id, &path); + if (r < 0) { + log_debug("sysview: cannot parse SeatNew from logind: %s", + strerror(-r)); + return r; + } + + return context_add_seat(c, id); +} + +static int context_ld_seat_removed(sysview_context *c, sd_bus_message *signal) { + const char *id, *path; + sysview_seat *seat; + int r; + + r = sd_bus_message_read(signal, "so", &id, &path); + if (r < 0) { + log_debug("sysview: cannot parse SeatRemoved from logind: %s", + strerror(-r)); + return r; + } + + seat = sysview_find_seat(c, id); + if (!seat) + return 0; + + return context_remove_seat(c, seat); +} + +static int context_ld_session_new(sysview_context *c, sd_bus_message *signal) { + _cleanup_free_ char *seatid = NULL, *username = NULL; + const char *id, *path; + sysview_seat *seat; + uid_t uid; + int r; + + r = sd_bus_message_read(signal, "so", &id, &path); + if (r < 0) { + log_debug("sysview: cannot parse SessionNew from logind: %s", + strerror(-r)); + return r; + } + + /* + * As the dbus message didn't contain enough information, we + * read missing bits via sd-login. Note that this might race session + * destruction, so we handle ENOENT properly. + */ + + /* ENOENT is also returned for sessions without seats */ + r = sd_session_get_seat(id, &seatid); + if (r == -ENOENT) + return 0; + else if (r < 0) + goto error; + + seat = sysview_find_seat(c, seatid); + if (!seat) + return 0; + + r = sd_session_get_uid(id, &uid); + if (r == -ENOENT) + return 0; + else if (r < 0) + goto error; + + username = lookup_uid(uid); + if (!username) { + r = -ENOMEM; + goto error; + } + + r = context_raise_session_filter(c, id, seatid, username, uid); + if (r <= 0) { + if (r < 0) + log_debug("sysview: cannot filter new session '%s' on seat '%s': %s", + id, seatid, strerror(-r)); + return r; + } + + return context_add_session(c, seat, id); + +error: + log_debug("sysview: failed retrieving information for new session '%s': %s", + id, strerror(-r)); + return r; +} + +static int context_ld_session_removed(sysview_context *c, sd_bus_message *signal) { + sysview_session *session; + const char *id, *path; + int r; + + r = sd_bus_message_read(signal, "so", &id, &path); + if (r < 0) { + log_debug("sysview: cannot parse SessionRemoved from logind: %s", + strerror(-r)); + return r; + } + + session = sysview_find_session(c, id); + if (!session) + return 0; + + return context_remove_session(c, session); +} + +static int context_ld_manager_signal_fn(sd_bus *bus, + sd_bus_message *signal, + void *userdata, + sd_bus_error *ret_error) { + sysview_context *c = userdata; + + if (sd_bus_message_is_signal(signal, "org.freedesktop.login1.Manager", "SeatNew")) + return context_ld_seat_new(c, signal); + else if (sd_bus_message_is_signal(signal, "org.freedesktop.login1.Manager", "SeatRemoved")) + return context_ld_seat_removed(c, signal); + else if (sd_bus_message_is_signal(signal, "org.freedesktop.login1.Manager", "SessionNew")) + return context_ld_session_new(c, signal); + else if (sd_bus_message_is_signal(signal, "org.freedesktop.login1.Manager", "SessionRemoved")) + return context_ld_session_removed(c, signal); + else + return 0; +} + +static int context_ld_start(sysview_context *c) { + int r; + + if (!c->scan_logind) + return 0; + + r = sd_bus_add_match(c->sysbus, + &c->ld_slot_manager_signal, + "type='signal'," + "sender='org.freedesktop.login1'," + "interface='org.freedesktop.login1.Manager'," + "path='/org/freedesktop/login1'", + context_ld_manager_signal_fn, + c); + if (r < 0) + return r; + + return 0; +} + +static void context_ld_stop(sysview_context *c) { + c->ld_slot_list_sessions = sd_bus_slot_unref(c->ld_slot_list_sessions); + c->ld_slot_list_seats = sd_bus_slot_unref(c->ld_slot_list_seats); + c->ld_slot_manager_signal = sd_bus_slot_unref(c->ld_slot_manager_signal); +} + +static int context_ld_list_seats_fn(sd_bus *bus, + sd_bus_message *reply, + void *userdata, + sd_bus_error *ret_error) { + sysview_context *c = userdata; + int r; + + c->ld_slot_list_seats = sd_bus_slot_unref(c->ld_slot_list_seats); + + if (sd_bus_message_is_method_error(reply, NULL)) { + const sd_bus_error *error = sd_bus_message_get_error(reply); + + log_debug("sysview: ListSeats on logind failed: %s: %s", + error->name, error->message); + return sd_bus_error_get_errno(error); + } + + r = sd_bus_message_enter_container(reply, 'a', "(so)"); + if (r < 0) + goto error; + + while ((r = sd_bus_message_enter_container(reply, 'r', "so")) > 0) { + const char *id, *path; + + r = sd_bus_message_read(reply, "so", &id, &path); + if (r < 0) + goto error; + + r = context_add_seat(c, id); + if (r != 0) + return r; + + r = sd_bus_message_exit_container(reply); + if (r < 0) + goto error; + } + + if (r < 0) + goto error; + + r = sd_bus_message_exit_container(reply); + if (r < 0) + return r; + + return 0; + +error: + log_debug("sysview: erroneous ListSeats response from logind: %s", + strerror(-r)); + return r; +} + +static int context_ld_list_sessions_fn(sd_bus *bus, + sd_bus_message *reply, + void *userdata, + sd_bus_error *ret_error) { + sysview_context *c = userdata; + int r; + + c->ld_slot_list_sessions = sd_bus_slot_unref(c->ld_slot_list_sessions); + + if (sd_bus_message_is_method_error(reply, NULL)) { + const sd_bus_error *error = sd_bus_message_get_error(reply); + + log_debug("sysview: ListSessions on logind failed: %s: %s", + error->name, error->message); + return sd_bus_error_get_errno(error); + } + + r = sd_bus_message_enter_container(reply, 'a', "(susso)"); + if (r < 0) + goto error; + + while ((r = sd_bus_message_enter_container(reply, 'r', "susso")) > 0) { + const char *id, *username, *seatid, *path; + sysview_seat *seat; + unsigned int uid; + + r = sd_bus_message_read(reply, + "susso", + &id, + &uid, + &username, + &seatid, + &path); + if (r < 0) + goto error; + + seat = sysview_find_seat(c, seatid); + if (seat) { + r = context_raise_session_filter(c, id, seatid, username, uid); + if (r < 0) { + log_debug("sysview: cannot filter listed session '%s' on seat '%s': %s", + id, seatid, strerror(-r)); + return r; + } else if (r > 0) { + r = context_add_session(c, seat, id); + if (r != 0) + return r; + } + } + + r = sd_bus_message_exit_container(reply); + if (r < 0) + goto error; + } + + if (r < 0) + goto error; + + r = sd_bus_message_exit_container(reply); + if (r < 0) + return r; + + return 0; + +error: + log_debug("sysview: erroneous ListSessions response from logind: %s", + strerror(-r)); + return r; +} + +static int context_ld_scan(sysview_context *c) { + _cleanup_bus_message_unref_ sd_bus_message *m = NULL; + int r; + + if (!c->ld_slot_manager_signal) + return 0; + + /* request seat list */ + + r = sd_bus_message_new_method_call(c->sysbus, + &m, + "org.freedesktop.login1", + "/org/freedesktop/login1", + "org.freedesktop.login1.Manager", + "ListSeats"); + if (r < 0) + return r; + + r = sd_bus_call_async(c->sysbus, + &c->ld_slot_list_seats, + m, + context_ld_list_seats_fn, + c, + 0); + if (r < 0) + return r; + + /* request session list */ + + m = sd_bus_message_unref(m); + r = sd_bus_message_new_method_call(c->sysbus, + &m, + "org.freedesktop.login1", + "/org/freedesktop/login1", + "org.freedesktop.login1.Manager", + "ListSessions"); + if (r < 0) + return r; + + r = sd_bus_call_async(c->sysbus, + &c->ld_slot_list_sessions, + m, + context_ld_list_sessions_fn, + c, + 0); + if (r < 0) + return r; + + return 0; +} + +bool sysview_context_is_running(sysview_context *c) { + return c && c->running; +} + +int sysview_context_start(sysview_context *c, sysview_event_fn event_fn, void *userdata) { + int r; + + assert_return(c, -EINVAL); + assert_return(event_fn, -EINVAL); + + if (c->running) + return -EALREADY; + + log_debug("sysview: start"); + + c->running = true; + c->event_fn = event_fn; + c->userdata = userdata; + + r = context_ld_start(c); + if (r < 0) + goto error; + + r = context_ud_start(c); + if (r < 0) + goto error; + + r = sysview_context_rescan(c); + if (r < 0) + goto error; + + return 0; + +error: + sysview_context_stop(c); + return r; +} + +void sysview_context_stop(sysview_context *c) { + sysview_session *session; + sysview_device *device; + sysview_seat *seat; + + assert(c); + + if (!c->running) + return; + + log_debug("sysview: stop"); + + c->running = false; + c->scanned = false; + c->event_fn = NULL; + c->userdata = NULL; + c->scan_src = sd_event_source_unref(c->scan_src); + context_ud_stop(c); + context_ld_stop(c); + + /* + * Event-callbacks are already cleared, hence we can safely ignore + * return codes of the context_remove_*() helpers. They cannot be + * originated from user-callbacks, so we already handled them. + */ + + while ((device = hashmap_first(c->device_map))) + context_remove_device(c, device); + + while ((session = hashmap_first(c->session_map))) + context_remove_session(c, session); + + while ((seat = hashmap_first(c->seat_map))) + context_remove_seat(c, seat); +} + +static int context_scan_fn(sd_event_source *s, void *userdata) { + sysview_context *c = userdata; + sysview_seat *seat; + Iterator i; + int r; + + if (!c->scanned) { + r = context_ld_scan(c); + if (r < 0) { + log_debug("sysview: logind scan failed: %s", strerror(-r)); + return r; + } + } + + /* skip device scans if no sessions are available */ + if (hashmap_size(c->session_map) > 0) { + r = context_ud_scan(c); + if (r < 0) { + log_debug("sysview: udev scan failed: %s", strerror(-r)); + return r; + } + + HASHMAP_FOREACH(seat, c->seat_map, i) + seat->scanned = true; + } + + c->scanned = true; + + return 0; +} + +int sysview_context_rescan(sysview_context *c) { + assert(c); + + if (!c->running) + return 0; + + if (c->scan_src) + return sd_event_source_set_enabled(c->scan_src, SD_EVENT_ONESHOT); + else + return sd_event_add_defer(c->event, &c->scan_src, context_scan_fn, c); +} diff --git a/src/libsystemd-terminal/sysview.h b/src/libsystemd-terminal/sysview.h new file mode 100644 index 0000000000..de6ff371db --- /dev/null +++ b/src/libsystemd-terminal/sysview.h @@ -0,0 +1,151 @@ +/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/ + +/*** + This file is part of systemd. + + Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com> + + systemd is free software; you can redistribute it and/or modify it + under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation; either version 2.1 of the License, or + (at your option) any later version. + + systemd is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with systemd; If not, see <http://www.gnu.org/licenses/>. +***/ + +/* + * System View + * The sysview interface scans and monitors the system for seats, sessions and + * devices. It basically mirrors the state of logind on the application side. + * It's meant as base for session services that require managed device access. + * The logind controller API is employed to allow unprivileged access to all + * devices of a user. + * Furthermore, the sysview interface can be used for system services that run + * in situations where logind is not available, but session-like services are + * needed. For instance, the initrd does not run logind but might require + * graphics access. It cannot run session services, though. The sysview + * interface pretends that a session is available and provides the same + * interface as to normal session services. + */ + +#pragma once + +#include <inttypes.h> +#include <libudev.h> +#include <stdbool.h> +#include <stdlib.h> +#include <systemd/sd-bus.h> +#include <systemd/sd-event.h> +#include "util.h" + +typedef struct sysview_event sysview_event; +typedef struct sysview_device sysview_device; +typedef struct sysview_session sysview_session; +typedef struct sysview_seat sysview_seat; +typedef struct sysview_context sysview_context; + +/* + * Events + */ + +enum { + SYSVIEW_EVENT_SEAT_ADD, + SYSVIEW_EVENT_SEAT_REMOVE, + + SYSVIEW_EVENT_SESSION_FILTER, + SYSVIEW_EVENT_SESSION_ADD, + SYSVIEW_EVENT_SESSION_REMOVE, + SYSVIEW_EVENT_SESSION_ATTACH, + SYSVIEW_EVENT_SESSION_DETACH, + SYSVIEW_EVENT_SESSION_CONTROL, +}; + +struct sysview_event { + unsigned int type; + + union { + struct { + sysview_seat *seat; + } seat_add, seat_remove; + + struct { + const char *id; + const char *seatid; + const char *username; + unsigned int uid; + } session_filter; + + struct { + sysview_session *session; + } session_add, session_remove; + + struct { + sysview_session *session; + sysview_device *device; + } session_attach, session_detach; + + struct { + sysview_session *session; + int error; + } session_control; + }; +}; + +typedef int (*sysview_event_fn) (sysview_context *c, void *userdata, sysview_event *e); + +/* + * Devices + */ + +enum { + SYSVIEW_DEVICE_EVDEV, + SYSVIEW_DEVICE_DRM, + SYSVIEW_DEVICE_CNT +}; + +unsigned int sysview_device_get_type(sysview_device *device); +struct udev_device *sysview_device_get_ud(sysview_device *device); + +/* + * Sessions + */ + +const char *sysview_session_get_name(sysview_session *session); + +int sysview_session_take_control(sysview_session *session); +void sysview_session_release_control(sysview_session *session); + +/* + * Seats + */ + +const char *sysview_seat_get_name(sysview_seat *seat); + +/* + * Contexts + */ + +enum { + SYSVIEW_CONTEXT_SCAN_LOGIND = (1 << 0), + SYSVIEW_CONTEXT_SCAN_EVDEV = (1 << 1), + SYSVIEW_CONTEXT_SCAN_DRM = (1 << 2), +}; + +int sysview_context_new(sysview_context **out, + unsigned int flags, + sd_event *event, + sd_bus *sysbus, + struct udev *ud); +sysview_context *sysview_context_free(sysview_context *c); + +DEFINE_TRIVIAL_CLEANUP_FUNC(sysview_context*, sysview_context_free); + +bool sysview_context_is_running(sysview_context *c); +int sysview_context_start(sysview_context *c, sysview_event_fn event_fn, void *userdata); +void sysview_context_stop(sysview_context *c); |