[systemd-commits] 9 commits - Makefile.am TODO src/libsystemd-bus src/locale src/login src/machine src/systemd
Lennart Poettering
lennart at kemper.freedesktop.org
Tue Nov 5 01:13:12 CET 2013
Makefile.am | 5
TODO | 3
src/libsystemd-bus/bus-error.c | 13
src/libsystemd-bus/bus-objects.c | 12
src/libsystemd-bus/bus-util.c | 30
src/libsystemd-bus/bus-util.h | 18
src/locale/localed.c | 14
src/login/logind-acl.c | 9
src/login/logind-action.c | 52
src/login/logind-button.c | 113 -
src/login/logind-button.h | 3
src/login/logind-core.c | 43
src/login/logind-dbus.c | 3429 ++++++++++++++++----------------------
src/login/logind-device.c | 7
src/login/logind-inhibit.c | 106 -
src/login/logind-inhibit.h | 2
src/login/logind-seat-dbus.c | 498 ++---
src/login/logind-seat.c | 39
src/login/logind-seat.h | 11
src/login/logind-session-dbus.c | 994 ++++-------
src/login/logind-session-device.c | 52
src/login/logind-session.c | 127 -
src/login/logind-session.h | 17
src/login/logind-user-dbus.c | 451 ++--
src/login/logind-user.c | 67
src/login/logind-user.h | 9
src/login/logind.c | 515 ++---
src/login/logind.h | 67
src/login/pam-module.c | 9
src/login/user-sessions.c | 21
src/machine/machine-dbus.c | 6
src/machine/machine.c | 2
src/machine/machine.h | 2
src/machine/machined-dbus.c | 31
src/machine/machined.c | 8
src/machine/machined.h | 1
src/systemd/sd-event.h | 7
37 files changed, 2983 insertions(+), 3810 deletions(-)
New commits:
commit cc3773810855956bad92337cee8fa193584ab62e
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Nov 5 01:10:21 2013 +0100
logind: port logind to libsystemd-bus
diff --git a/Makefile.am b/Makefile.am
index 1d74a5c..80577e7 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -3811,16 +3811,15 @@ libsystemd_logind_core_la_SOURCES = \
src/login/login-shared.h
libsystemd_logind_core_la_CFLAGS = \
- $(AM_CFLAGS) \
- $(DBUS_CFLAGS)
+ $(AM_CFLAGS)
libsystemd_logind_core_la_LIBADD = \
libsystemd-label.la \
libsystemd-audit.la \
libsystemd-shared.la \
libsystemd-daemon.la \
- libsystemd-dbus.la \
libsystemd-id128-internal.la \
+ libsystemd-bus.la \
libudev.la
if HAVE_ACL
diff --git a/src/libsystemd-bus/bus-util.h b/src/libsystemd-bus/bus-util.h
index b05cac1..c4cd8dd 100644
--- a/src/libsystemd-bus/bus-util.h
+++ b/src/libsystemd-bus/bus-util.h
@@ -109,3 +109,15 @@ DEFINE_TRIVIAL_CLEANUP_FUNC(sd_bus_message*, sd_bus_message_unref);
#define BUS_ERROR_NO_SUCH_MACHINE "org.freedesktop.machine1.NoSuchMachine"
#define BUS_ERROR_NO_MACHINE_FOR_PID "org.freedesktop.machine1.NoMachineForPID"
#define BUS_ERROR_MACHINE_EXISTS "org.freedesktop.machine1.MachineExists"
+
+#define BUS_ERROR_NO_SUCH_SESSION "org.freedesktop.login1.NoSuchSession"
+#define BUS_ERROR_NO_SESSION_FOR_PID "org.freedesktop.login1.NoSessionForPID"
+#define BUS_ERROR_NO_SUCH_USER "org.freedesktop.login1.NoSuchUser"
+#define BUS_ERROR_NO_USER_FOR_PID "org.freedesktop.login1.NoUserForPID"
+#define BUS_ERROR_NO_SUCH_SEAT "org.freedesktop.login1.NoSuchSeat"
+#define BUS_ERROR_SESSION_NOT_ON_SEAT "org.freedesktop.login1.SessionNotOnSeat"
+#define BUS_ERROR_NOT_IN_CONTROL "org.freedesktop.login1.NotInControl"
+#define BUS_ERROR_DEVICE_IS_TAKEN "org.freedesktop.login1.DeviceIsTaken"
+#define BUS_ERROR_DEVICE_NOT_TAKEN "org.freedesktop.login1.DeviceNotTaken"
+#define BUS_ERROR_OPERATION_IN_PROGRESS "org.freedesktop.login1.OperationInProgress"
+#define BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED "org.freedesktop.login1.SleepVerbNotSupported"
diff --git a/src/login/logind-acl.c b/src/login/logind-acl.c
index 25abcbc..2df2ba2 100644
--- a/src/login/logind-acl.c
+++ b/src/login/logind-acl.c
@@ -20,15 +20,15 @@
***/
#include <assert.h>
-#include <sys/acl.h>
-#include <acl/libacl.h>
#include <errno.h>
#include <string.h>
+#include <sys/acl.h>
+#include <acl/libacl.h>
-#include "logind-acl.h"
#include "util.h"
#include "acl-util.h"
#include "set.h"
+#include "logind-acl.h"
static int flush_acl(acl_t acl) {
acl_entry_t i;
@@ -190,9 +190,8 @@ int devnode_acl_all(struct udev *udev,
assert(udev);
nodes = set_new(string_hash_func, string_compare_func);
- if (!nodes) {
+ if (!nodes)
return -ENOMEM;
- }
e = udev_enumerate_new(udev);
if (!e) {
diff --git a/src/login/logind-action.c b/src/login/logind-action.c
index 74114ee..cb64df0 100644
--- a/src/login/logind-action.c
+++ b/src/login/logind-action.c
@@ -21,13 +21,13 @@
#include <unistd.h>
-#include <systemd/sd-messages.h>
-
+#include "sd-messages.h"
#include "conf-parser.h"
#include "special.h"
-#include "dbus-common.h"
-#include "logind-action.h"
#include "sleep-config.h"
+#include "bus-util.h"
+#include "bus-error.h"
+#include "logind-action.h"
int manager_handle_action(
Manager *m,
@@ -56,24 +56,34 @@ int manager_handle_action(
[HANDLE_HYBRID_SLEEP] = SPECIAL_HYBRID_SLEEP_TARGET
};
- DBusError error;
- int r;
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
InhibitWhat inhibit_operation;
bool supported;
+ int r;
assert(m);
- if (m->action_what) {
- log_debug("Action already in progress, ignoring.");
- return -EALREADY;
- }
-
/* If the key handling is turned off, don't do anything */
if (handle == HANDLE_IGNORE) {
log_debug("Refusing operation, as it is turned off.");
return 0;
}
+ /* If the key handling is inhibited, don't do anything */
+ if (inhibit_key > 0) {
+ if (manager_is_inhibited(m, inhibit_key, INHIBIT_BLOCK, NULL, true, false, 0)) {
+ log_debug("Refusing operation, %s is inhibited.", inhibit_what_to_string(inhibit_key));
+ return 0;
+ }
+ }
+
+ /* Locking is handled differently from the rest. */
+ if (handle == HANDLE_LOCK) {
+ log_info("Locking sessions...");
+ session_send_lock_all(m, true);
+ return 1;
+ }
+
if (handle == HANDLE_SUSPEND)
supported = can_sleep("suspend") > 0;
else if (handle == HANDLE_HIBERNATE)
@@ -90,19 +100,9 @@ int manager_handle_action(
return -ENOTSUP;
}
- /* If the key handling is inhibited, don't do anything */
- if (inhibit_key > 0) {
- if (manager_is_inhibited(m, inhibit_key, INHIBIT_BLOCK, NULL, true, false, 0)) {
- log_debug("Refusing operation, %s is inhibited.", inhibit_what_to_string(inhibit_key));
- return 0;
- }
- }
-
- /* Locking is handled differently from the rest. */
- if (handle == HANDLE_LOCK) {
- log_info("Locking sessions...");
- session_send_lock_all(m, true);
- return 1;
+ if (m->action_what) {
+ log_debug("Action already in progress, ignoring.");
+ return -EALREADY;
}
inhibit_operation = handle == HANDLE_SUSPEND || handle == HANDLE_HIBERNATE || handle == HANDLE_HYBRID_SLEEP ? INHIBIT_SLEEP : INHIBIT_SHUTDOWN;
@@ -124,11 +124,9 @@ int manager_handle_action(
log_info("%s", message_table[handle]);
- dbus_error_init(&error);
r = bus_manager_shutdown_or_sleep_now_or_later(m, target_table[handle], inhibit_operation, &error);
if (r < 0) {
- log_error("Failed to execute operation: %s", bus_error_message(&error));
- dbus_error_free(&error);
+ log_error("Failed to execute operation: %s", bus_error_message(&error, r));
return r;
}
diff --git a/src/login/logind-button.c b/src/login/logind-button.c
index ea45c28..7ea4e4f 100644
--- a/src/login/logind-button.c
+++ b/src/login/logind-button.c
@@ -26,14 +26,12 @@
#include <sys/ioctl.h>
#include <unistd.h>
#include <linux/input.h>
-#include <sys/epoll.h>
+#include "sd-messages.h"
#include "conf-parser.h"
#include "util.h"
-#include "logind-button.h"
#include "special.h"
-#include "dbus-common.h"
-#include "sd-messages.h"
+#include "logind-button.h"
Button* button_new(Manager *m, const char *name) {
Button *b;
@@ -68,10 +66,9 @@ void button_free(Button *b) {
hashmap_remove(b->manager->buttons, b->name);
- if (b->fd >= 0) {
- hashmap_remove(b->manager->button_fds, INT_TO_PTR(b->fd + 1));
- assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
+ sd_event_source_unref(b->event_source);
+ if (b->fd >= 0) {
/* If the device has been unplugged close() returns
* ENODEV, let's ignore this, hence we don't use
* close_nointr_nofail() */
@@ -99,62 +96,6 @@ int button_set_seat(Button *b, const char *sn) {
return 0;
}
-int button_open(Button *b) {
- char name[256], *p;
- struct epoll_event ev;
- int r;
-
- assert(b);
-
- if (b->fd >= 0) {
- close(b->fd);
- b->fd = -1;
- }
-
- p = strappend("/dev/input/", b->name);
- if (!p)
- return log_oom();
-
- b->fd = open(p, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
- free(p);
- if (b->fd < 0) {
- log_warning("Failed to open %s: %m", b->name);
- return -errno;
- }
-
- if (ioctl(b->fd, EVIOCGNAME(sizeof(name)), name) < 0) {
- log_error("Failed to get input name: %m");
- r = -errno;
- goto fail;
- }
-
- zero(ev);
- ev.events = EPOLLIN;
- ev.data.u32 = FD_OTHER_BASE + b->fd;
-
- if (epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_ADD, b->fd, &ev) < 0) {
- log_error("Failed to add to epoll: %m");
- r = -errno;
- goto fail;
- }
-
- r = hashmap_put(b->manager->button_fds, INT_TO_PTR(b->fd + 1), b);
- if (r < 0) {
- log_error("Failed to add to hash map: %s", strerror(-r));
- assert_se(epoll_ctl(b->manager->epoll_fd, EPOLL_CTL_DEL, b->fd, NULL) == 0);
- goto fail;
- }
-
- log_info("Watching system buttons on /dev/input/%s (%s)", b->name, name);
-
- return 0;
-
-fail:
- close(b->fd);
- b->fd = -1;
- return r;
-}
-
static int button_handle(
Button *b,
InhibitWhat inhibit_key,
@@ -175,10 +116,13 @@ static int button_handle(
return r;
}
-int button_process(Button *b) {
+static int button_dispatch(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+ Button *b = userdata;
struct input_event ev;
ssize_t l;
+ assert(s);
+ assert(fd == b->fd);
assert(b);
l = read(b->fd, &ev, sizeof(ev));
@@ -251,6 +195,47 @@ int button_process(Button *b) {
return 0;
}
+int button_open(Button *b) {
+ char *p, name[256];
+ int r;
+
+ assert(b);
+
+ if (b->fd >= 0) {
+ close(b->fd);
+ b->fd = -1;
+ }
+
+ p = strappenda("/dev/input/", b->name);
+
+ b->fd = open(p, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
+ if (b->fd < 0) {
+ log_warning("Failed to open %s: %m", b->name);
+ return -errno;
+ }
+
+ if (ioctl(b->fd, EVIOCGNAME(sizeof(name)), name) < 0) {
+ log_error("Failed to get input name: %m");
+ r = -errno;
+ goto fail;
+ }
+
+ r = sd_event_add_io(b->manager->event, b->fd, EPOLLIN, button_dispatch, b, &b->event_source);
+ if (r < 0) {
+ log_error("Failed to add button event: %s", strerror(-r));
+ goto fail;
+ }
+
+ log_info("Watching system buttons on /dev/input/%s (%s)", b->name, name);
+
+ return 0;
+
+fail:
+ close(b->fd);
+ b->fd = -1;
+ return r;
+}
+
int button_recheck(Button *b) {
assert(b);
diff --git a/src/login/logind-button.h b/src/login/logind-button.h
index 1c5a845..83bf1fc 100644
--- a/src/login/logind-button.h
+++ b/src/login/logind-button.h
@@ -31,6 +31,8 @@ typedef struct Button Button;
struct Button {
Manager *manager;
+ sd_event_source *event_source;
+
char *name;
char *seat;
int fd;
@@ -41,7 +43,6 @@ struct Button {
Button* button_new(Manager *m, const char *name);
void button_free(Button*b);
int button_open(Button *b);
-int button_process(Button *b);
int button_recheck(Button *b);
int button_set_seat(Button *b, const char *sn);
diff --git a/src/login/logind-core.c b/src/login/logind-core.c
index 36999ac..6506f22 100644
--- a/src/login/logind-core.c
+++ b/src/login/logind-core.c
@@ -27,9 +27,12 @@
#include <unistd.h>
#include <linux/vt.h>
-#include "logind.h"
-#include "dbus-common.h"
#include "strv.h"
+#include "cgroup-util.h"
+#include "audit.h"
+#include "bus-util.h"
+#include "bus-error.h"
+#include "logind.h"
int manager_add_device(Manager *m, const char *sysfs, bool master, Device **_device) {
Device *d;
@@ -213,14 +216,14 @@ int manager_watch_busname(Manager *m, const char *name) {
assert(m);
assert(name);
- if (hashmap_get(m->busnames, name))
+ if (set_get(m->busnames, (char*) name))
return 0;
n = strdup(name);
if (!n)
return -ENOMEM;
- r = hashmap_put(m->busnames, n, n);
+ r = set_put(m->busnames, n);
if (r < 0) {
free(n);
return r;
@@ -232,22 +235,16 @@ int manager_watch_busname(Manager *m, const char *name) {
void manager_drop_busname(Manager *m, const char *name) {
Session *session;
Iterator i;
- char *key;
assert(m);
assert(name);
- if (!hashmap_get(m->busnames, name))
- return;
-
/* keep it if the name still owns a controller */
HASHMAP_FOREACH(session, m->sessions, i)
if (session_is_controller(session, name))
return;
- key = hashmap_remove(m->busnames, name);
- if (key)
- free(key);
+ free(set_remove(m->busnames, (char*) name));
}
int manager_process_seat_device(Manager *m, struct udev_device *d) {
@@ -466,9 +463,9 @@ static int vt_is_busy(int vtnr) {
}
int manager_spawn_autovt(Manager *m, int vtnr) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ _cleanup_free_ char *name = NULL;
int r;
- char *name = NULL;
- const char *mode = "fail";
assert(m);
assert(vtnr >= 1);
@@ -489,26 +486,20 @@ int manager_spawn_autovt(Manager *m, int vtnr) {
return -EBUSY;
}
- if (asprintf(&name, "autovt at tty%i.service", vtnr) < 0) {
- log_error("Could not allocate service name.");
- r = -ENOMEM;
- goto finish;
- }
+ if (asprintf(&name, "autovt at tty%i.service", vtnr) < 0)
+ return log_oom();
- r = bus_method_call_with_reply (
+ r = sd_bus_call_method(
m->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"StartUnit",
+ &error,
NULL,
- NULL,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_STRING, &mode,
- DBUS_TYPE_INVALID);
-
-finish:
- free(name);
+ "ss", name, "fail");
+ if (r < 0)
+ log_error("Failed to start %s: %s", name, bus_error_message(&error, r));
return r;
}
diff --git a/src/login/logind-dbus.c b/src/login/logind-dbus.c
index 890c5c6..6471678 100644
--- a/src/login/logind-dbus.c
+++ b/src/login/logind-dbus.c
@@ -24,429 +24,490 @@
#include <unistd.h>
#include <pwd.h>
-#include "logind.h"
-#include "dbus-common.h"
+#include "sd-id128.h"
+#include "sd-messages.h"
#include "strv.h"
#include "mkdir.h"
#include "path-util.h"
-#include "polkit.h"
#include "special.h"
#include "sleep-config.h"
-#include "systemd/sd-id128.h"
-#include "systemd/sd-messages.h"
#include "fileio-label.h"
#include "label.h"
#include "utf8.h"
#include "unit-name.h"
-#include "bus-errors.h"
#include "virt.h"
+#include "audit.h"
+#include "bus-util.h"
+#include "bus-error.h"
+#include "logind.h"
-#define BUS_MANAGER_INTERFACE \
- " <interface name=\"org.freedesktop.login1.Manager\">\n" \
- " <method name=\"GetSession\">\n" \
- " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"session\" type=\"o\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"GetSessionByPID\">\n" \
- " <arg name=\"pid\" type=\"u\" direction=\"in\"/>\n" \
- " <arg name=\"session\" type=\"o\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"GetUser\">\n" \
- " <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
- " <arg name=\"user\" type=\"o\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"GetUserByPID\">\n" \
- " <arg name=\"pid\" type=\"u\" direction=\"in\"/>\n" \
- " <arg name=\"user\" type=\"o\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"GetSeat\">\n" \
- " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"seat\" type=\"o\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"ListSessions\">\n" \
- " <arg name=\"sessions\" type=\"a(susso)\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"ListUsers\">\n" \
- " <arg name=\"users\" type=\"a(uso)\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"ListSeats\">\n" \
- " <arg name=\"seats\" type=\"a(so)\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"CreateSession\">\n" \
- " <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
- " <arg name=\"leader\" type=\"u\" direction=\"in\"/>\n" \
- " <arg name=\"service\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"type\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"class\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"seat\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"vtnr\" type=\"u\" direction=\"in\"/>\n" \
- " <arg name=\"tty\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"display\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"remote\" type=\"b\" direction=\"in\"/>\n" \
- " <arg name=\"remote_user\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"remote_host\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"scope_properties\" type=\"a(sv)\" direction=\"in\"/>\n" \
- " <arg name=\"id\" type=\"s\" direction=\"out\"/>\n" \
- " <arg name=\"path\" type=\"o\" direction=\"out\"/>\n" \
- " <arg name=\"runtime_path\" type=\"o\" direction=\"out\"/>\n" \
- " <arg name=\"fd\" type=\"h\" direction=\"out\"/>\n" \
- " <arg name=\"seat\" type=\"s\" direction=\"out\"/>\n" \
- " <arg name=\"vtnr\" type=\"u\" direction=\"out\"/>\n" \
- " <arg name=\"existing\" type=\"b\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"ReleaseSession\">\n" \
- " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"ActivateSession\">\n" \
- " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"ActivateSessionOnSeat\">\n" \
- " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"seat\" type=\"s\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"LockSession\">\n" \
- " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"UnlockSession\">\n" \
- " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"LockSessions\"/>\n" \
- " <method name=\"UnlockSessions\"/>\n" \
- " <method name=\"KillSession\">\n" \
- " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"who\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"signal\" type=\"s\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"KillUser\">\n" \
- " <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
- " <arg name=\"signal\" type=\"s\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"TerminateSession\">\n" \
- " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"TerminateUser\">\n" \
- " <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"TerminateSeat\">\n" \
- " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"SetUserLinger\">\n" \
- " <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
- " <arg name=\"b\" type=\"b\" direction=\"in\"/>\n" \
- " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"AttachDevice\">\n" \
- " <arg name=\"seat\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"sysfs\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"FlushDevices\">\n" \
- " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"PowerOff\">\n" \
- " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"Reboot\">\n" \
- " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"Suspend\">\n" \
- " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"Hibernate\">\n" \
- " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"HybridSleep\">\n" \
- " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
- " </method>\n" \
- " <method name=\"CanPowerOff\">\n" \
- " <arg name=\"result\" type=\"s\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"CanReboot\">\n" \
- " <arg name=\"result\" type=\"s\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"CanSuspend\">\n" \
- " <arg name=\"result\" type=\"s\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"CanHibernate\">\n" \
- " <arg name=\"result\" type=\"s\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"CanHybridSleep\">\n" \
- " <arg name=\"result\" type=\"s\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"Inhibit\">\n" \
- " <arg name=\"what\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"who\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"why\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
- " <arg name=\"fd\" type=\"h\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"ListInhibitors\">\n" \
- " <arg name=\"inhibitors\" type=\"a(ssssuu)\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <signal name=\"SessionNew\">\n" \
- " <arg name=\"id\" type=\"s\"/>\n" \
- " <arg name=\"path\" type=\"o\"/>\n" \
- " </signal>\n" \
- " <signal name=\"SessionRemoved\">\n" \
- " <arg name=\"id\" type=\"s\"/>\n" \
- " <arg name=\"path\" type=\"o\"/>\n" \
- " </signal>\n" \
- " <signal name=\"UserNew\">\n" \
- " <arg name=\"uid\" type=\"u\"/>\n" \
- " <arg name=\"path\" type=\"o\"/>\n" \
- " </signal>\n" \
- " <signal name=\"UserRemoved\">\n" \
- " <arg name=\"uid\" type=\"u\"/>\n" \
- " <arg name=\"path\" type=\"o\"/>\n" \
- " </signal>\n" \
- " <signal name=\"SeatNew\">\n" \
- " <arg name=\"id\" type=\"s\"/>\n" \
- " <arg name=\"path\" type=\"o\"/>\n" \
- " </signal>\n" \
- " <signal name=\"SeatRemoved\">\n" \
- " <arg name=\"id\" type=\"s\"/>\n" \
- " <arg name=\"path\" type=\"o\"/>\n" \
- " </signal>\n" \
- " <signal name=\"PrepareForShutdown\">\n" \
- " <arg name=\"active\" type=\"b\"/>\n" \
- " </signal>\n" \
- " <signal name=\"PrepareForSleep\">\n" \
- " <arg name=\"active\" type=\"b\"/>\n" \
- " </signal>\n" \
- " <property name=\"NAutoVTs\" type=\"u\" access=\"read\"/>\n" \
- " <property name=\"KillOnlyUsers\" type=\"as\" access=\"read\"/>\n" \
- " <property name=\"KillExcludeUsers\" type=\"as\" access=\"read\"/>\n" \
- " <property name=\"KillUserProcesses\" type=\"b\" access=\"read\"/>\n" \
- " <property name=\"IdleHint\" type=\"b\" access=\"read\"/>\n" \
- " <property name=\"IdleSinceHint\" type=\"t\" access=\"read\"/>\n" \
- " <property name=\"IdleSinceHintMonotonic\" type=\"t\" access=\"read\"/>\n" \
- " <property name=\"BlockInhibited\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"DelayInhibited\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"InhibitDelayMaxUSec\" type=\"t\" access=\"read\"/>\n" \
- " <property name=\"HandlePowerKey\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"HandleSuspendKey\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"HandleHibernateKey\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"HandleLidSwitch\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"IdleAction\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"IdleActionUSec\" type=\"t\" access=\"read\"/>\n" \
- " <property name=\"PreparingForShutdown\" type=\"b\" access=\"read\"/>\n" \
- " <property name=\"PreparingForSleep\" type=\"b\" access=\"read\"/>\n" \
- " </interface>\n"
-
-#define INTROSPECTION_BEGIN \
- DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
- "<node>\n" \
- BUS_MANAGER_INTERFACE \
- BUS_PROPERTIES_INTERFACE \
- BUS_PEER_INTERFACE \
- BUS_INTROSPECTABLE_INTERFACE
-
-#define INTROSPECTION_END \
- "</node>\n"
-
-#define INTERFACES_LIST \
- BUS_GENERIC_INTERFACES_LIST \
- "org.freedesktop.login1.Manager\0"
-
-static int bus_manager_append_idle_hint(DBusMessageIter *i, const char *property, void *data) {
- Manager *m = data;
- dbus_bool_t b;
-
- assert(i);
- assert(property);
- assert(m);
+static int property_get_idle_hint(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
- b = manager_get_idle_hint(m, NULL) > 0;
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
- return -ENOMEM;
+ Manager *m = userdata;
- return 0;
+ assert(bus);
+ assert(reply);
+ assert(m);
+
+ return sd_bus_message_append(reply, "b", manager_get_idle_hint(m, NULL) > 0);
}
-static int bus_manager_append_idle_hint_since(DBusMessageIter *i, const char *property, void *data) {
- Manager *m = data;
+static int property_get_idle_since_hint(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ Manager *m = userdata;
dual_timestamp t;
- uint64_t u;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(reply);
assert(m);
manager_get_idle_hint(m, &t);
- u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
- return -ENOMEM;
-
- return 0;
+ return sd_bus_message_append(reply, "t", streq(property, "IdleSinceHint") ? t.realtime : t.monotonic);
}
-static int bus_manager_append_inhibited(DBusMessageIter *i, const char *property, void *data) {
- Manager *m = data;
+static int property_get_inhibited(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ Manager *m = userdata;
InhibitWhat w;
- const char *p;
- w = manager_inhibit_what(m, streq(property, "BlockInhibited") ? INHIBIT_BLOCK : INHIBIT_DELAY);
- p = inhibit_what_to_string(w);
+ assert(bus);
+ assert(reply);
+ assert(m);
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &p))
- return -ENOMEM;
+ w = manager_inhibit_what(m, streq(property, "BlockInhibited") ? INHIBIT_BLOCK : INHIBIT_DELAY);
- return 0;
+ return sd_bus_message_append(reply, "s", inhibit_what_to_string(w));
}
-static int bus_manager_append_preparing(DBusMessageIter *i, const char *property, void *data) {
- Manager *m = data;
- dbus_bool_t b;
+static int property_get_preparing(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ Manager *m = userdata;
+ bool b;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(reply);
+ assert(m);
if (streq(property, "PreparingForShutdown"))
b = !!(m->action_what & INHIBIT_SHUTDOWN);
else
b = !!(m->action_what & INHIBIT_SLEEP);
- dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b);
- return 0;
+ return sd_bus_message_append(reply, "b", b);
}
-static int bus_manager_create_session(Manager *m, DBusMessage *message) {
+static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_handle_action, handle_action, HandleAction);
- const char *type, *class, *cseat, *tty, *display, *remote_user, *remote_host, *service;
- uint32_t uid, leader, audit_id = 0;
- _cleanup_free_ char *id = NULL;
+static int method_get_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_free_ char *p = NULL;
+ Manager *m = userdata;
+ const char *name;
+ Session *session;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "s", &name);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ session = hashmap_get(m->sessions, name);
+ if (!session)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+ p = session_bus_path(session);
+ if (!p)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+ return sd_bus_reply_method_return(bus, message, "o", p);
+}
+
+static int method_get_session_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_free_ char *p = NULL;
Session *session = NULL;
+ Manager *m = userdata;
+ uint32_t pid;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "u", &pid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ r = manager_get_session_by_pid(m, pid, &session);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+ if (!session)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SESSION_FOR_PID, "PID %lu does not belong to any known session", (unsigned long) pid);
+
+ p = session_bus_path(session);
+ if (!p)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+ return sd_bus_reply_method_return(bus, message, "o", p);
+}
+
+static int method_get_user(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_free_ char *p = NULL;
+ Manager *m = userdata;
+ uint32_t uid;
+ User *user;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "u", &uid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
+ if (!user)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_USER, "No user '%lu' known or logged in", (unsigned long) uid);
+
+ p = user_bus_path(user);
+ if (!p)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+ return sd_bus_reply_method_return(bus, message, "o", p);
+}
+
+static int method_get_user_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_free_ char *p = NULL;
+ Manager *m = userdata;
User *user = NULL;
- Seat *seat = NULL;
- DBusMessageIter iter;
- dbus_bool_t remote;
- uint32_t vtnr = 0;
- SessionType t;
- SessionClass c;
- bool b;
+ uint32_t pid;
int r;
+ assert(bus);
+ assert(message);
assert(m);
+
+ r = sd_bus_message_read(message, "u", &pid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ r = manager_get_user_by_pid(m, pid, &user);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+ if (!user)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_USER_FOR_PID, "PID %lu does not belong to any known or logged in user", (unsigned long) pid);
+
+ p = user_bus_path(user);
+ if (!p)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+ return sd_bus_reply_method_return(bus, message, "o", p);
+}
+
+static int method_get_seat(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_free_ char *p = NULL;
+ Manager *m = userdata;
+ const char *name;
+ Seat *seat;
+ int r;
+
+ assert(bus);
assert(message);
+ assert(m);
- if (!dbus_message_iter_init(message, &iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
- return -EINVAL;
+ r = sd_bus_message_read(message, "s", &name);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- dbus_message_iter_get_basic(&iter, &uid);
+ seat = hashmap_get(m->seats, name);
+ if (!seat)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", name);
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
- return -EINVAL;
+ p = seat_bus_path(seat);
+ if (!p)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
- dbus_message_iter_get_basic(&iter, &leader);
+ return sd_bus_reply_method_return(bus, message, "o", p);
+}
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
- return -EINVAL;
+static int method_list_sessions(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+ Manager *m = userdata;
+ Session *session;
+ Iterator i;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
- dbus_message_iter_get_basic(&iter, &service);
+ r = sd_bus_message_new_method_return(bus, message, &reply);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
- return -EINVAL;
+ r = sd_bus_message_open_container(reply, 'a', "(susso)");
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ HASHMAP_FOREACH(session, m->sessions, i) {
+ _cleanup_free_ char *p = NULL;
+
+ p = session_bus_path(session);
+ if (!p)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+ r = sd_bus_message_append(reply, "(susso)",
+ session->id,
+ (uint32_t) session->user->uid,
+ session->user->name,
+ session->seat ? session->seat->id : "",
+ p);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+ }
+
+ r = sd_bus_message_close_container(reply);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ return sd_bus_send(bus, reply, NULL);
+}
+
+static int method_list_users(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+ Manager *m = userdata;
+ User *user;
+ Iterator i;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_new_method_return(bus, message, &reply);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ r = sd_bus_message_open_container(reply, 'a', "(uso)");
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ HASHMAP_FOREACH(user, m->users, i) {
+ _cleanup_free_ char *p = NULL;
+
+ p = user_bus_path(user);
+ if (!p)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+ r = sd_bus_message_append(reply, "(uso)",
+ (uint32_t) user->uid,
+ user->name,
+ p);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+ }
+
+ r = sd_bus_message_close_container(reply);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ return sd_bus_send(bus, reply, NULL);
+}
+
+static int method_list_seats(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+ Manager *m = userdata;
+ Seat *seat;
+ Iterator i;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_new_method_return(bus, message, &reply);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ r = sd_bus_message_open_container(reply, 'a', "(so)");
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ HASHMAP_FOREACH(seat, m->seats, i) {
+ _cleanup_free_ char *p = NULL;
+
+ p = seat_bus_path(seat);
+ if (!p)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+
+ r = sd_bus_message_append(reply, "so", seat->id, p);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+ }
+
+ r = sd_bus_message_close_container(reply);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ return sd_bus_send(bus, reply, NULL);
+}
+
+static int method_list_inhibitors(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+ Manager *m = userdata;
+ Inhibitor *inhibitor;
+ Iterator i;
+ int r;
+
+ r = sd_bus_message_new_method_return(bus, message, &reply);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ r = sd_bus_message_open_container(reply, 'a', "(ssssuu)");
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ HASHMAP_FOREACH(inhibitor, m->inhibitors, i) {
+
+ r = sd_bus_message_append(reply, "ssssuu",
+ strempty(inhibit_what_to_string(inhibitor->what)),
+ strempty(inhibitor->who),
+ strempty(inhibitor->why),
+ strempty(inhibit_mode_to_string(inhibitor->mode)),
+ (uint32_t) inhibitor->uid,
+ (uint32_t) inhibitor->pid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+ }
+
+ r = sd_bus_message_close_container(reply);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ return sd_bus_send(bus, reply, NULL);
+}
+
+static int method_create_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ const char *service, *type, *class, *cseat, *tty, *display, *remote_user, *remote_host;
+ uint32_t uid, leader, audit_id = 0;
+ _cleanup_free_ char *id = NULL;
+ Session *session = NULL;
+ Manager *m = userdata;
+ User *user = NULL;
+ Seat *seat = NULL;
+ int remote;
+ uint32_t vtnr = 0;
+ SessionType t;
+ SessionClass c;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "uussssussbss", &uid, &leader, &service, &type, &class, &cseat, &vtnr, &tty, &display, &remote, &remote_user, &remote_host);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ if (leader == 1)
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid leader PID");
- dbus_message_iter_get_basic(&iter, &type);
if (isempty(type))
t = _SESSION_TYPE_INVALID;
else {
t = session_type_from_string(type);
if (t < 0)
- return -EINVAL;
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid session type %s", type);
}
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
- return -EINVAL;
-
- dbus_message_iter_get_basic(&iter, &class);
if (isempty(class))
c = _SESSION_CLASS_INVALID;
else {
c = session_class_from_string(class);
if (c < 0)
- return -EINVAL;
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid session class %s", class);
}
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
- return -EINVAL;
-
- dbus_message_iter_get_basic(&iter, &cseat);
-
if (isempty(cseat))
seat = NULL;
else {
seat = hashmap_get(m->seats, cseat);
if (!seat)
- return -ENOENT;
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", seat);
}
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
- return -EINVAL;
-
- dbus_message_iter_get_basic(&iter, &vtnr);
-
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
- return -EINVAL;
-
- dbus_message_iter_get_basic(&iter, &tty);
-
if (tty_is_vc(tty)) {
int v;
if (!seat)
seat = m->seat0;
else if (seat != m->seat0)
- return -EINVAL;
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "TTY %s is virtual console but seat %s is not seat0", tty, seat);
v = vtnr_from_tty(tty);
-
if (v <= 0)
- return v < 0 ? v : -EINVAL;
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Cannot determine VT number from virtual console TTY %s", tty);
if (vtnr <= 0)
vtnr = (uint32_t) v;
else if (vtnr != (uint32_t) v)
- return -EINVAL;
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Specified TTY and VT number do not match");
+
} else if (tty_is_console(tty)) {
if (!seat)
seat = m->seat0;
else if (seat != m->seat0)
- return -EINVAL;
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Console TTY specified but seat is not seat0");
if (vtnr != 0)
- return -EINVAL;
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Console TTY specified but VT number is not 0");
}
if (seat) {
if (seat_has_vts(seat)) {
if (vtnr > 63)
- return -EINVAL;
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "VT number out of range");
} else {
if (vtnr != 0)
- return -EINVAL;
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Seat has no VTs but VT number not 0");
}
}
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
- return -EINVAL;
-
- dbus_message_iter_get_basic(&iter, &display);
-
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
- return -EINVAL;
+ r = sd_bus_message_enter_container(message, 'a', "(sv)");
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
if (t == _SESSION_TYPE_INVALID) {
if (!isempty(display))
@@ -464,90 +525,48 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
c = SESSION_BACKGROUND;
}
- dbus_message_iter_get_basic(&iter, &remote);
-
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
- return -EINVAL;
-
- dbus_message_iter_get_basic(&iter, &remote_user);
-
- if (!dbus_message_iter_next(&iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
- return -EINVAL;
-
- dbus_message_iter_get_basic(&iter, &remote_host);
-
if (leader <= 0) {
- leader = bus_get_unix_process_id(m->bus, dbus_message_get_sender(message), NULL);
- if (leader == 0)
- return -EINVAL;
+ assert_cc(sizeof(uint32_t) == sizeof(pid_t));
+
+ r = sd_bus_get_owner_pid(bus, sd_bus_message_get_sender(message), (pid_t*) &leader);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
}
manager_get_session_by_pid(m, leader, &session);
if (session) {
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
_cleanup_free_ char *path = NULL;
_cleanup_close_ int fifo_fd = -1;
- dbus_bool_t exists;
/* Session already exists, client is probably
* something like "su" which changes uid but is still
* the same session */
fifo_fd = session_create_fifo(session);
- if (fifo_fd < 0) {
- r = fifo_fd;
- goto fail;
- }
+ if (fifo_fd < 0)
+ return sd_bus_reply_method_errno(bus, message, fifo_fd, NULL);
path = session_bus_path(session);
- if (!path) {
- r = -ENOMEM;
- goto fail;
- }
-
- reply = dbus_message_new_method_return(message);
- if (!reply) {
- r = -ENOMEM;
- goto fail;
- }
-
- cseat = session->seat ? session->seat->id : "";
- vtnr = session->vtnr;
- exists = true;
-
- b = dbus_message_append_args(
- reply,
- DBUS_TYPE_STRING, &session->id,
- DBUS_TYPE_OBJECT_PATH, &path,
- DBUS_TYPE_STRING, &session->user->runtime_path,
- DBUS_TYPE_UNIX_FD, &fifo_fd,
- DBUS_TYPE_STRING, &cseat,
- DBUS_TYPE_UINT32, &vtnr,
- DBUS_TYPE_BOOLEAN, &exists,
- DBUS_TYPE_INVALID);
- if (!b) {
- r = -ENOMEM;
- goto fail;
- }
-
- if (!dbus_connection_send(m->bus, reply, NULL)) {
- r = -ENOMEM;
- goto fail;
- }
+ if (!path)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
- return 0;
+ return sd_bus_reply_method_return(
+ bus, message, "soshsub",
+ session->id,
+ path,
+ session->user->runtime_path,
+ fifo_fd,
+ session->seat ? session->seat->id : "",
+ (uint32_t) session->vtnr,
+ true);
}
audit_session_from_pid(leader, &audit_id);
if (audit_id > 0) {
/* Keep our session IDs and the audit session IDs in sync */
- if (asprintf(&id, "%lu", (unsigned long) audit_id) < 0) {
- r = -ENOMEM;
- goto fail;
- }
+ if (asprintf(&id, "%lu", (unsigned long) audit_id) < 0)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
/* Wut? There's already a session by this name and we
* didn't find it above? Weird, then let's not trust
@@ -567,21 +586,23 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
free(id);
id = NULL;
- if (asprintf(&id, "c%lu", ++m->session_counter) < 0) {
- r = -ENOMEM;
- goto fail;
- }
+ if (asprintf(&id, "c%lu", ++m->session_counter) < 0)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
} while (hashmap_get(m->sessions, id));
}
r = manager_add_user_by_uid(m, uid, &user);
- if (r < 0)
+ if (r < 0) {
+ r = sd_bus_reply_method_errno(bus, message, r, NULL);
goto fail;
+ }
r = manager_add_session(m, id, &session);
- if (r < 0)
+ if (r < 0) {
+ r = sd_bus_reply_method_errno(bus, message, r, NULL);
goto fail;
+ }
session_set_user(session, user);
@@ -595,7 +616,7 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
if (!isempty(tty)) {
session->tty = strdup(tty);
if (!session->tty) {
- r = -ENOMEM;
+ r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
goto fail;
}
}
@@ -603,7 +624,7 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
if (!isempty(display)) {
session->display = strdup(display);
if (!session->display) {
- r = -ENOMEM;
+ r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
goto fail;
}
}
@@ -611,7 +632,7 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
if (!isempty(remote_user)) {
session->remote_user = strdup(remote_user);
if (!session->remote_user) {
- r = -ENOMEM;
+ r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
goto fail;
}
}
@@ -619,7 +640,7 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
if (!isempty(remote_host)) {
session->remote_host = strdup(remote_host);
if (!session->remote_host) {
- r = -ENOMEM;
+ r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
goto fail;
}
}
@@ -627,28 +648,32 @@ static int bus_manager_create_session(Manager *m, DBusMessage *message) {
if (!isempty(service)) {
session->service = strdup(service);
if (!session->service) {
- r = -ENOMEM;
+ r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
goto fail;
}
}
if (seat) {
r = seat_attach_session(seat, session);
- if (r < 0)
+ if (r < 0) {
+ r = sd_bus_reply_method_errno(bus, message, r, NULL);
goto fail;
+ }
}
r = session_start(session);
- if (r < 0)
+ if (r < 0) {
+ r = sd_bus_reply_method_errno(bus, message, r, NULL);
goto fail;
+ }
- session->create_message = dbus_message_ref(message);
+ session->create_message = sd_bus_message_ref(message);
/* Now, let's wait until the slice unit and stuff got
* created. We send the reply back from
* session_send_create_reply().*/
- return 0;
+ return 1;
fail:
if (session)
@@ -660,156 +685,349 @@ fail:
return r;
}
-static int bus_manager_inhibit(
- Manager *m,
- DBusConnection *connection,
- DBusMessage *message,
- DBusError *error,
- DBusMessage **_reply) {
+static int method_release_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
+ Session *session;
+ const char *name;
+ int r;
- Inhibitor *i = NULL;
- char *id = NULL;
- const char *who, *why, *what, *mode;
- pid_t pid;
- InhibitWhat w;
- InhibitMode mm;
- unsigned long ul;
- int r, fifo_fd = -1;
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "s", &name);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ session = hashmap_get(m->sessions, name);
+ if (!session)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+ /* We use the FIFO to detect stray sessions where the process
+ invoking PAM dies abnormally. We need to make sure that
+ that process is not killed if at the clean end of the
+ session it closes the FIFO. Hence, with this call
+ explicitly turn off the FIFO logic, so that the PAM code
+ can finish clean up on its own */
+ session_remove_fifo(session);
+ session_save(session);
+ user_save(session->user);
+
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_activate_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
+ Session *session;
+ const char *name;
+ int r;
+ assert(bus);
+ assert(message);
assert(m);
- assert(connection);
+
+ r = sd_bus_message_read(message, "s", &name);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ session = hashmap_get(m->sessions, name);
+ if (!session)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+ r = session_activate(session);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_activate_session_on_seat(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ const char *session_name, *seat_name;
+ Manager *m = userdata;
+ Session *session;
+ Seat *seat;
+ int r;
+
+ assert(bus);
assert(message);
- assert(error);
- assert(_reply);
-
- if (!dbus_message_get_args(
- message,
- error,
- DBUS_TYPE_STRING, &what,
- DBUS_TYPE_STRING, &who,
- DBUS_TYPE_STRING, &why,
- DBUS_TYPE_STRING, &mode,
- DBUS_TYPE_INVALID)) {
- r = -EIO;
- goto fail;
- }
+ assert(m);
- w = inhibit_what_from_string(what);
- if (w <= 0) {
- r = -EINVAL;
- goto fail;
- }
+ /* Same as ActivateSession() but refuses to work if
+ * the seat doesn't match */
- mm = inhibit_mode_from_string(mode);
- if (mm < 0) {
- r = -EINVAL;
- goto fail;
- }
+ r = sd_bus_message_read(message, "ss", &session_name, &seat_name);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- /* Delay is only supported for shutdown/sleep */
- if (mm == INHIBIT_DELAY && (w & ~(INHIBIT_SHUTDOWN|INHIBIT_SLEEP))) {
- r = -EINVAL;
- goto fail;
- }
+ session = hashmap_get(m->sessions, session_name);
+ if (!session)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", session_name);
- /* Don't allow taking delay locks while we are already
- * executing the operation. We shouldn't create the impression
- * that the lock was successful if the machine is about to go
- * down/suspend any moment. */
- if (m->action_what & w) {
- r = -EALREADY;
- goto fail;
- }
+ seat = hashmap_get(m->seats, seat_name);
+ if (!seat)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", seat_name);
- r = verify_polkit(connection, message,
- w == INHIBIT_SHUTDOWN ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
- w == INHIBIT_SLEEP ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-sleep" : "org.freedesktop.login1.inhibit-delay-sleep") :
- w == INHIBIT_IDLE ? "org.freedesktop.login1.inhibit-block-idle" :
- w == INHIBIT_HANDLE_POWER_KEY ? "org.freedesktop.login1.inhibit-handle-power-key" :
- w == INHIBIT_HANDLE_SUSPEND_KEY ? "org.freedesktop.login1.inhibit-handle-suspend-key" :
- w == INHIBIT_HANDLE_HIBERNATE_KEY ? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
- "org.freedesktop.login1.inhibit-handle-lid-switch",
- false, NULL, error);
+ if (session->seat != seat)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_SESSION_NOT_ON_SEAT, "Session %s not on seat %s", session_name, seat_name);
+
+ r = session_activate(session);
if (r < 0)
- goto fail;
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
- if (ul == (unsigned long) -1) {
- r = -EIO;
- goto fail;
- }
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
- pid = bus_get_unix_process_id(connection, dbus_message_get_sender(message), error);
- if (pid <= 0) {
- r = -EIO;
- goto fail;
- }
+static int method_lock_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
+ Session *session;
+ const char *name;
+ int r;
- do {
- free(id);
- id = NULL;
+ assert(bus);
+ assert(message);
+ assert(m);
- if (asprintf(&id, "%lu", ++m->inhibit_counter) < 0) {
- r = -ENOMEM;
- goto fail;
- }
- } while (hashmap_get(m->inhibitors, id));
+ r = sd_bus_message_read(message, "s", &name);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- r = manager_add_inhibitor(m, id, &i);
- free(id);
+ session = hashmap_get(m->sessions, name);
+ if (!session)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+ r = session_send_lock(session, streq(sd_bus_message_get_member(message), "LockSession"));
if (r < 0)
- goto fail;
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- i->what = w;
- i->mode = mm;
- i->pid = pid;
- i->uid = (uid_t) ul;
- i->why = strdup(why);
- i->who = strdup(who);
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
- if (!i->why || !i->who) {
- r = -ENOMEM;
- goto fail;
- }
+static int method_lock_sessions(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
+ int r;
- fifo_fd = inhibitor_create_fifo(i);
- if (fifo_fd < 0) {
- r = fifo_fd;
- goto fail;
- }
+ assert(bus);
+ assert(message);
+ assert(m);
- reply = dbus_message_new_method_return(message);
- if (!reply) {
- r = -ENOMEM;
- goto fail;
- }
+ r = session_send_lock_all(m, streq(sd_bus_message_get_member(message), "LockSessions"));
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- if (!dbus_message_append_args(
- reply,
- DBUS_TYPE_UNIX_FD, &fifo_fd,
- DBUS_TYPE_INVALID)) {
- r = -ENOMEM;
- goto fail;
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_kill_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ const char *name, *swho;
+ Manager *m = userdata;
+ Session *session;
+ int32_t signo;
+ KillWho who;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "ssi", &name, &swho, &signo);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ if (isempty(swho))
+ who = KILL_ALL;
+ else {
+ who = kill_who_from_string(swho);
+ if (who < 0)
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho);
}
- close_nointr_nofail(fifo_fd);
- *_reply = reply;
- reply = NULL;
+ if (signo <= 0 || signo >= _NSIG)
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
- inhibitor_start(i);
+ session = hashmap_get(m->sessions, name);
+ if (!session)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
- return 0;
+ r = session_kill(session, who, signo);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
-fail:
- if (i)
- inhibitor_free(i);
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
- if (fifo_fd >= 0)
- close_nointr_nofail(fifo_fd);
+static int method_kill_user(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
+ uint32_t uid;
+ int32_t signo;
+ User *user;
+ int r;
- return r;
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "ui", &uid, &signo);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ if (signo <= 0 || signo >= _NSIG)
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
+
+ user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
+ if (!user)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_USER, "No user '%lu' known or logged in", (unsigned long) uid);
+
+ r = user_kill(user, signo);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_terminate_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
+ const char *name;
+ Session *session;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "s", &name);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ session = hashmap_get(m->sessions, name);
+ if (!session)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
+
+ r = session_stop(session);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_terminate_user(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
+ uint32_t uid;
+ User *user;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "u", &uid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
+ if (!user)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_USER, "No user '%lu' known or logged in", (unsigned long) uid);
+
+ r = user_stop(user);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_terminate_seat(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
+ const char *name;
+ Seat *seat;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "s", &name);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ seat = hashmap_get(m->seats, name);
+ if (!seat)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", name);
+
+ r = seat_stop_sessions(seat);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_set_user_linger(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ _cleanup_free_ char *cc = NULL;
+ Manager *m = userdata;
+ int b, r;
+ struct passwd *pw;
+ const char *path;
+ uint32_t uid;
+ int interactive;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "ubb", &uid, &b, &interactive);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ errno = 0;
+ pw = getpwuid(uid);
+ if (!pw)
+ return sd_bus_reply_method_errno(bus, message, errno ? errno : ENOENT, NULL);
+
+ r = bus_verify_polkit_async(bus,
+ &m->polkit_registry,
+ message,
+ "org.freedesktop.login1.set-user-linger",
+ interactive,
+ &error,
+ method_set_user_linger, m);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, &error);
+ if (r == 0)
+ return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
+
+ mkdir_p_label("/var/lib/systemd", 0755);
+
+ r = mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ cc = cescape(pw->pw_name);
+ if (!cc)
+ return sd_bus_reply_method_errno(bus, message, ENOMEM, NULL);
+
+ path = strappenda("/var/lib/systemd/linger/", cc);
+ if (b) {
+ User *u;
+
+ r = touch(path);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ if (manager_add_user_by_uid(m, uid, &u) >= 0)
+ user_start(u);
+
+ } else {
+ User *u;
+
+ r = unlink(path);
+ if (r < 0 && errno != ENOENT)
+ return sd_bus_reply_method_errno(bus, message, errno, NULL);
+
+ u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
+ if (u)
+ user_add_to_gc_queue(u);
+ }
+
+ return sd_bus_reply_method_return(bus, message, NULL);
}
static int trigger_device(Manager *m, struct udev_device *d) {
@@ -839,7 +1057,7 @@ static int trigger_device(Manager *m, struct udev_device *d) {
first = udev_enumerate_get_list_entry(e);
udev_list_entry_foreach(item, first) {
- char *t;
+ _cleanup_free_ char *t = NULL;
const char *p;
p = udev_list_entry_get_name(item);
@@ -851,7 +1069,6 @@ static int trigger_device(Manager *m, struct udev_device *d) {
}
write_string_file(t, "change");
- free(t);
}
r = 0;
@@ -864,9 +1081,9 @@ finish:
}
static int attach_device(Manager *m, const char *seat, const char *sysfs) {
- struct udev_device *d;
_cleanup_free_ char *rule = NULL, *file = NULL;
const char *id_for_seat;
+ struct udev_device *d;
int r;
assert(m);
@@ -944,6 +1161,77 @@ static int flush_devices(Manager *m) {
return trigger_device(m, NULL);
}
+static int method_attach_device(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ const char *sysfs, *seat;
+ Manager *m = userdata;
+ int interactive, r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "ssb", &seat, &sysfs, &interactive);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ if (!path_startswith(sysfs, "/sys"))
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not in /sys", sysfs);
+
+ if (!seat_name_is_valid(seat))
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Seat %s is not valid", seat);
+
+ r = bus_verify_polkit_async(bus,
+ &m->polkit_registry,
+ message,
+ "org.freedesktop.login1.attach-device",
+ interactive,
+ &error,
+ method_attach_device, m);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, &error);
+ if (r == 0)
+ return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
+
+ r = attach_device(m, seat, sysfs);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_flush_devices(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ Manager *m = userdata;
+ int interactive, r;
+
+ assert(bus);
+ assert(message);
+ assert(m);
+
+ r = sd_bus_message_read(message, "b", &interactive);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ r = bus_verify_polkit_async(bus,
+ &m->polkit_registry,
+ message,
+ "org.freedesktop.login1.flush-devices",
+ interactive,
+ &error,
+ method_flush_devices, m);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, &error);
+ if (r == 0)
+ return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
+
+ r = flush_devices(m);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, &error);
+
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
+
static int have_multiple_sessions(
Manager *m,
uid_t uid) {
@@ -1003,12 +1291,12 @@ static int execute_shutdown_or_sleep(
Manager *m,
InhibitWhat w,
const char *unit_name,
- DBusError *error) {
+ sd_bus_error *error) {
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
- const char *mode = "replace-irreversibly", *p;
- int r;
+ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+ const char *p;
char *c;
+ int r;
assert(m);
assert(w >= 0);
@@ -1017,26 +1305,21 @@ static int execute_shutdown_or_sleep(
bus_manager_log_shutdown(m, w, unit_name);
- r = bus_method_call_with_reply(
+ r = sd_bus_call_method(
m->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"StartUnit",
- &reply,
error,
- DBUS_TYPE_STRING, &unit_name,
- DBUS_TYPE_STRING, &mode,
- DBUS_TYPE_INVALID);
+ &reply,
+ "ss", unit_name, "replace-irreversibly");
if (r < 0)
return r;
- if (!dbus_message_get_args(
- reply,
- error,
- DBUS_TYPE_OBJECT_PATH, &p,
- DBUS_TYPE_INVALID))
- return -EINVAL;
+ r = sd_bus_message_read(reply, "o", &p);
+ if (r < 0)
+ return r;
c = strdup(p);
if (!c)
@@ -1067,145 +1350,33 @@ static int delay_shutdown_or_sleep(
return 0;
}
-static int bus_manager_can_shutdown_or_sleep(
- Manager *m,
- DBusConnection *connection,
- DBusMessage *message,
- InhibitWhat w,
- const char *action,
- const char *action_multiple_sessions,
- const char *action_ignore_inhibit,
- const char *sleep_verb,
- DBusError *error,
- DBusMessage **_reply) {
+static int send_prepare_for(Manager *m, InhibitWhat w, bool _active) {
- bool multiple_sessions, challenge, blocked, b;
- const char *result = NULL;
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
- int r;
- unsigned long ul;
-
- assert(m);
- assert(connection);
- assert(message);
- assert(w >= 0);
- assert(w <= _INHIBIT_WHAT_MAX);
- assert(action);
- assert(action_multiple_sessions);
- assert(action_ignore_inhibit);
- assert(error);
- assert(_reply);
-
- if (sleep_verb) {
- r = can_sleep(sleep_verb);
- if (r < 0)
- return r;
- if (r == 0) {
- result = "na";
- goto finish;
- }
- }
-
- ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
- if (ul == (unsigned long) -1)
- return -EIO;
-
- r = have_multiple_sessions(m, (uid_t) ul);
- if (r < 0)
- return r;
-
- multiple_sessions = r > 0;
- blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, (uid_t) ul);
-
- if (multiple_sessions) {
- r = verify_polkit(connection, message, action_multiple_sessions, false, &challenge, error);
- if (r < 0)
- return r;
-
- if (r > 0)
- result = "yes";
- else if (challenge)
- result = "challenge";
- else
- result = "no";
- }
-
- if (blocked) {
- r = verify_polkit(connection, message, action_ignore_inhibit, false, &challenge, error);
- if (r < 0)
- return r;
-
- if (r > 0 && !result)
- result = "yes";
- else if (challenge && (!result || streq(result, "yes")))
- result = "challenge";
- else
- result = "no";
- }
-
- if (!multiple_sessions && !blocked) {
- /* If neither inhibit nor multiple sessions
- * apply then just check the normal policy */
-
- r = verify_polkit(connection, message, action, false, &challenge, error);
- if (r < 0)
- return r;
-
- if (r > 0)
- result = "yes";
- else if (challenge)
- result = "challenge";
- else
- result = "no";
- }
-
-finish:
- reply = dbus_message_new_method_return(message);
- if (!reply)
- return -ENOMEM;
-
- b = dbus_message_append_args(
- reply,
- DBUS_TYPE_STRING, &result,
- DBUS_TYPE_INVALID);
- if (!b)
- return -ENOMEM;
-
- *_reply = reply;
- reply = NULL;
- return 0;
-}
-
-static int send_prepare_for(Manager *m, InhibitWhat w, bool _active) {
- static const char * const signal_name[_INHIBIT_WHAT_MAX] = {
- [INHIBIT_SHUTDOWN] = "PrepareForShutdown",
- [INHIBIT_SLEEP] = "PrepareForSleep"
- };
-
- dbus_bool_t active = _active;
- _cleanup_dbus_message_unref_ DBusMessage *message = NULL;
+ static const char * const signal_name[_INHIBIT_WHAT_MAX] = {
+ [INHIBIT_SHUTDOWN] = "PrepareForShutdown",
+ [INHIBIT_SLEEP] = "PrepareForSleep"
+ };
+
+ int active = _active;
assert(m);
assert(w >= 0);
assert(w < _INHIBIT_WHAT_MAX);
assert(signal_name[w]);
- message = dbus_message_new_signal("/org/freedesktop/login1", "org.freedesktop.login1.Manager", signal_name[w]);
- if (!message)
- return -ENOMEM;
-
- if (!dbus_message_append_args(message, DBUS_TYPE_BOOLEAN, &active, DBUS_TYPE_INVALID) ||
- !dbus_connection_send(m->bus, message, NULL))
- return -ENOMEM;
-
- return 0;
+ return sd_bus_emit_signal(m->bus,
+ "/org/freedesktop/login1",
+ "org.freedesktop.login1.Manager",
+ signal_name[w],
+ "b",
+ &active);
}
int bus_manager_shutdown_or_sleep_now_or_later(
Manager *m,
const char *unit_name,
InhibitWhat w,
- DBusError *error) {
+ sd_bus_error *error) {
bool delayed;
int r;
@@ -1235,27 +1406,23 @@ int bus_manager_shutdown_or_sleep_now_or_later(
return r;
}
-static int bus_manager_do_shutdown_or_sleep(
+static int method_do_shutdown_or_sleep(
Manager *m,
- DBusConnection *connection,
- DBusMessage *message,
+ sd_bus_message *message,
const char *unit_name,
InhibitWhat w,
const char *action,
const char *action_multiple_sessions,
const char *action_ignore_inhibit,
const char *sleep_verb,
- DBusError *error,
- DBusMessage **_reply) {
+ sd_bus_message_handler_t method) {
- dbus_bool_t interactive;
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
bool multiple_sessions, blocked;
- DBusMessage *reply = NULL;
- int r;
- unsigned long ul;
+ int interactive, r;
+ uid_t uid;
assert(m);
- assert(connection);
assert(message);
assert(unit_name);
assert(w >= 0);
@@ -1263,1254 +1430,664 @@ static int bus_manager_do_shutdown_or_sleep(
assert(action);
assert(action_multiple_sessions);
assert(action_ignore_inhibit);
- assert(error);
- assert(_reply);
+ assert(method);
+
+ r = sd_bus_message_read(message, "b", &interactive);
+ if (r < 0)
+ return sd_bus_reply_method_errno(m->bus, message, r, NULL);
/* Don't allow multiple jobs being executed at the same time */
if (m->action_what)
- return -EALREADY;
-
- if (!dbus_message_get_args(
- message,
- error,
- DBUS_TYPE_BOOLEAN, &interactive,
- DBUS_TYPE_INVALID))
- return -EINVAL;
+ return sd_bus_reply_method_errorf(m->bus, message, BUS_ERROR_OPERATION_IN_PROGRESS, "There's already a shutdown or sleep operation in progress");
if (sleep_verb) {
r = can_sleep(sleep_verb);
if (r < 0)
- return r;
+ return sd_bus_reply_method_errno(m->bus, message, r, NULL);
if (r == 0)
- return -ENOTSUP;
+ return sd_bus_reply_method_errorf(m->bus, message, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED, "Sleep verb not supported");
}
- ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
- if (ul == (unsigned long) -1)
- return -EIO;
+ r = sd_bus_get_owner_uid(m->bus, sd_bus_message_get_sender(message), &uid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(m->bus, message, r, NULL);
- r = have_multiple_sessions(m, (uid_t) ul);
+ r = have_multiple_sessions(m, uid);
if (r < 0)
- return r;
+ return sd_bus_reply_method_errno(m->bus, message, r, NULL);
multiple_sessions = r > 0;
- blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, (uid_t) ul);
+ blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, uid);
if (multiple_sessions) {
- r = verify_polkit(connection, message, action_multiple_sessions, interactive, NULL, error);
+ r = bus_verify_polkit_async(m->bus, &m->polkit_registry, message,
+ action_multiple_sessions, interactive, &error, method, m);
if (r < 0)
- return r;
+ return sd_bus_reply_method_errno(m->bus, message, r, &error);
}
if (blocked) {
- r = verify_polkit(connection, message, action_ignore_inhibit, interactive, NULL, error);
+ r = bus_verify_polkit_async(m->bus, &m->polkit_registry, message,
+ action_ignore_inhibit, interactive, &error, method, m);
if (r < 0)
- return r;
+ return sd_bus_reply_method_errno(m->bus, message, r, &error);
}
if (!multiple_sessions && !blocked) {
- r = verify_polkit(connection, message, action, interactive, NULL, error);
+ r = bus_verify_polkit_async(m->bus, &m->polkit_registry, message,
+ action, interactive, &error, method, m);
if (r < 0)
- return r;
+ return sd_bus_reply_method_errno(m->bus, message, r, &error);
}
- r = bus_manager_shutdown_or_sleep_now_or_later(m, unit_name, w, error);
+ r = bus_manager_shutdown_or_sleep_now_or_later(m, unit_name, w, &error);
if (r < 0)
- return r;
+ return sd_bus_reply_method_errno(m->bus, message, r, &error);
- reply = dbus_message_new_method_return(message);
- if (!reply)
- return -ENOMEM;
-
- *_reply = reply;
- return 0;
+ return sd_bus_reply_method_return(m->bus, message, NULL);
}
-static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_manager_append_handle_action, handle_action, HandleAction);
-
-static const BusProperty bus_login_manager_properties[] = {
- { "NAutoVTs", bus_property_append_unsigned, "u", offsetof(Manager, n_autovts) },
- { "KillOnlyUsers", bus_property_append_strv, "as", offsetof(Manager, kill_only_users), true },
- { "KillExcludeUsers", bus_property_append_strv, "as", offsetof(Manager, kill_exclude_users), true },
- { "KillUserProcesses", bus_property_append_bool, "b", offsetof(Manager, kill_user_processes) },
- { "IdleHint", bus_manager_append_idle_hint, "b", 0 },
- { "IdleSinceHint", bus_manager_append_idle_hint_since, "t", 0 },
- { "IdleSinceHintMonotonic", bus_manager_append_idle_hint_since, "t", 0 },
- { "BlockInhibited", bus_manager_append_inhibited, "s", 0 },
- { "DelayInhibited", bus_manager_append_inhibited, "s", 0 },
- { "InhibitDelayMaxUSec", bus_property_append_usec, "t", offsetof(Manager, inhibit_delay_max) },
- { "HandlePowerKey", bus_manager_append_handle_action, "s", offsetof(Manager, handle_power_key) },
- { "HandleSuspendKey", bus_manager_append_handle_action, "s", offsetof(Manager, handle_suspend_key) },
- { "HandleHibernateKey", bus_manager_append_handle_action, "s", offsetof(Manager, handle_hibernate_key)},
- { "HandleLidSwitch", bus_manager_append_handle_action, "s", offsetof(Manager, handle_lid_switch) },
- { "IdleAction", bus_manager_append_handle_action, "s", offsetof(Manager, idle_action) },
- { "IdleActionUSec", bus_property_append_usec, "t", offsetof(Manager, idle_action_usec) },
- { "PreparingForShutdown", bus_manager_append_preparing, "b", 0 },
- { "PreparingForSleep", bus_manager_append_preparing, "b", 0 },
- { NULL, }
-};
-
-static DBusHandlerResult manager_message_handler(
- DBusConnection *connection,
- DBusMessage *message,
- void *userdata) {
-
+static int method_poweroff(sd_bus *bus, sd_bus_message *message, void *userdata) {
Manager *m = userdata;
- DBusError error;
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
- int r;
-
- assert(connection);
- assert(message);
- assert(m);
-
- dbus_error_init(&error);
-
- if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetSession")) {
- const char *name;
- char *p;
- Session *session;
- bool b;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- session = hashmap_get(m->sessions, name);
- if (!session)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- p = session_bus_path(session);
- if (!p)
- goto oom;
-
- b = dbus_message_append_args(
- reply,
- DBUS_TYPE_OBJECT_PATH, &p,
- DBUS_TYPE_INVALID);
- free(p);
-
- if (!b)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetSessionByPID")) {
- uint32_t pid;
- char *p;
- Session *session;
- bool b;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_UINT32, &pid,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- r = manager_get_session_by_pid(m, pid, &session);
- if (r <= 0)
- return bus_send_error_reply(connection, message, NULL, r < 0 ? r : -ENOENT);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- p = session_bus_path(session);
- if (!p)
- goto oom;
-
- b = dbus_message_append_args(
- reply,
- DBUS_TYPE_OBJECT_PATH, &p,
- DBUS_TYPE_INVALID);
- free(p);
-
- if (!b)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetUser")) {
- uint32_t uid;
- char *p;
- User *user;
- bool b;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_UINT32, &uid,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
- if (!user)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- p = user_bus_path(user);
- if (!p)
- goto oom;
-
- b = dbus_message_append_args(
- reply,
- DBUS_TYPE_OBJECT_PATH, &p,
- DBUS_TYPE_INVALID);
- free(p);
-
- if (!b)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetUserByPID")) {
- uint32_t pid;
- char *p;
- User *user;
- bool b;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_UINT32, &pid,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- r = manager_get_user_by_pid(m, pid, &user);
- if (r <= 0)
- return bus_send_error_reply(connection, message, NULL, r < 0 ? r : -ENOENT);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- p = user_bus_path(user);
- if (!p)
- goto oom;
-
- b = dbus_message_append_args(
- reply,
- DBUS_TYPE_OBJECT_PATH, &p,
- DBUS_TYPE_INVALID);
- free(p);
-
- if (!b)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetSeat")) {
- const char *name;
- char *p;
- Seat *seat;
- bool b;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- seat = hashmap_get(m->seats, name);
- if (!seat)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- p = seat_bus_path(seat);
- if (!p)
- goto oom;
-
- b = dbus_message_append_args(
- reply,
- DBUS_TYPE_OBJECT_PATH, &p,
- DBUS_TYPE_INVALID);
- free(p);
-
- if (!b)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListSessions")) {
- char *p;
- Session *session;
- Iterator i;
- DBusMessageIter iter, sub;
- const char *empty = "";
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- dbus_message_iter_init_append(reply, &iter);
-
- if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(susso)", &sub))
- goto oom;
-
- HASHMAP_FOREACH(session, m->sessions, i) {
- DBusMessageIter sub2;
- uint32_t uid;
-
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
- goto oom;
-
- uid = session->user->uid;
-
- p = session_bus_path(session);
- if (!p)
- goto oom;
-
- if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &session->id) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &uid) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &session->user->name) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, session->seat ? (const char**) &session->seat->id : &empty) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) {
- free(p);
- goto oom;
- }
-
- free(p);
-
- if (!dbus_message_iter_close_container(&sub, &sub2))
- goto oom;
- }
-
- if (!dbus_message_iter_close_container(&iter, &sub))
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListUsers")) {
- User *user;
- Iterator i;
- DBusMessageIter iter, sub;
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- dbus_message_iter_init_append(reply, &iter);
-
- if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(uso)", &sub))
- goto oom;
-
- HASHMAP_FOREACH(user, m->users, i) {
- _cleanup_free_ char *p = NULL;
- DBusMessageIter sub2;
- uint32_t uid;
-
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
- goto oom;
-
- uid = user->uid;
-
- p = user_bus_path(user);
- if (!p)
- goto oom;
-
- if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &uid) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &user->name) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) {
- free(p);
- goto oom;
- }
-
- if (!dbus_message_iter_close_container(&sub, &sub2))
- goto oom;
- }
-
- if (!dbus_message_iter_close_container(&iter, &sub))
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListSeats")) {
- Seat *seat;
- Iterator i;
- DBusMessageIter iter, sub;
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- dbus_message_iter_init_append(reply, &iter);
-
- if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(so)", &sub))
- goto oom;
-
- HASHMAP_FOREACH(seat, m->seats, i) {
- _cleanup_free_ char *p = NULL;
- DBusMessageIter sub2;
-
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
- goto oom;
-
- p = seat_bus_path(seat);
- if (!p)
- goto oom;
-
- if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &seat->id) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) {
- free(p);
- goto oom;
- }
-
- if (!dbus_message_iter_close_container(&sub, &sub2))
- goto oom;
- }
-
- if (!dbus_message_iter_close_container(&iter, &sub))
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListInhibitors")) {
- Inhibitor *inhibitor;
- Iterator i;
- DBusMessageIter iter, sub;
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- dbus_message_iter_init_append(reply, &iter);
-
- if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ssssuu)", &sub))
- goto oom;
-
- HASHMAP_FOREACH(inhibitor, m->inhibitors, i) {
- DBusMessageIter sub2;
- dbus_uint32_t uid, pid;
- const char *what, *who, *why, *mode;
-
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
- goto oom;
-
- what = strempty(inhibit_what_to_string(inhibitor->what));
- who = strempty(inhibitor->who);
- why = strempty(inhibitor->why);
- mode = strempty(inhibit_mode_to_string(inhibitor->mode));
- uid = (dbus_uint32_t) inhibitor->uid;
- pid = (dbus_uint32_t) inhibitor->pid;
-
- if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &what) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &who) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &why) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &mode) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &uid) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &pid))
- goto oom;
-
- if (!dbus_message_iter_close_container(&sub, &sub2))
- goto oom;
- }
-
- if (!dbus_message_iter_close_container(&iter, &sub))
- goto oom;
-
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Inhibit")) {
-
- r = bus_manager_inhibit(m, connection, message, &error, &reply);
-
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
-
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CreateSession")) {
-
- r = bus_manager_create_session(m, message);
-
- /* Don't delay the work on OOM here, since it might be
- * triggered by a low RLIMIT_NOFILE here (since we
- * send a dupped fd to the client), and we'd rather
- * see this fail quickly then be retried later */
-
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ReleaseSession")) {
- const char *name;
- Session *session;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- session = hashmap_get(m->sessions, name);
- if (!session)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
-
- /* We use the FIFO to detect stray sessions where the
- process invoking PAM dies abnormally. We need to make
- sure that that process is not killed if at the clean
- end of the session it closes the FIFO. Hence, with
- this call explicitly turn off the FIFO logic, so that
- the PAM code can finish clean up on its own */
- session_remove_fifo(session);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ActivateSession")) {
- const char *name;
- Session *session;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- session = hashmap_get(m->sessions, name);
- if (!session)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
-
- r = session_activate(session);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ActivateSessionOnSeat")) {
- const char *session_name, *seat_name;
- Session *session;
- Seat *seat;
-
- /* Same as ActivateSession() but refuses to work if
- * the seat doesn't match */
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &session_name,
- DBUS_TYPE_STRING, &seat_name,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- session = hashmap_get(m->sessions, session_name);
- if (!session)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
-
- seat = hashmap_get(m->seats, seat_name);
- if (!seat)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
-
- if (session->seat != seat)
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- r = session_activate(session);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "LockSession") ||
- dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "UnlockSession")) {
- const char *name;
- Session *session;
+ return method_do_shutdown_or_sleep(
+ m, message,
+ SPECIAL_POWEROFF_TARGET,
+ INHIBIT_SHUTDOWN,
+ "org.freedesktop.login1.power-off",
+ "org.freedesktop.login1.power-off-multiple-sessions",
+ "org.freedesktop.login1.power-off-ignore-inhibit",
+ NULL,
+ method_poweroff);
+}
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+static int method_reboot(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
- session = hashmap_get(m->sessions, name);
- if (!session)
- return bus_send_error_reply(connection, message, NULL, -ENOENT);
+ return method_do_shutdown_or_sleep(
+ m, message,
+ SPECIAL_REBOOT_TARGET,
+ INHIBIT_SHUTDOWN,
+ "org.freedesktop.login1.reboot",
+ "org.freedesktop.login1.reboot-multiple-sessions",
+ "org.freedesktop.login1.reboot-ignore-inhibit",
+ NULL,
+ method_reboot);
+}
- if (session_send_lock(session, streq(dbus_message_get_member(message), "LockSession")) < 0)
- goto oom;
+static int method_suspend(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
+ return method_do_shutdown_or_sleep(
+ m, message,
+ SPECIAL_SUSPEND_TARGET,
+ INHIBIT_SLEEP,
+ "org.freedesktop.login1.suspend",
+ "org.freedesktop.login1.suspend-multiple-sessions",
+ "org.freedesktop.login1.suspend-ignore-inhibit",
+ "suspend",
+ method_suspend);
+}
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "LockSessions") ||
- dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "UnlockSessions")) {
+static int method_hibernate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
- r = session_send_lock_all(m, streq(dbus_message_get_member(message), "LockSessions"));
- if (r < 0)
- bus_send_error_reply(connection, message, NULL, r);
+ return method_do_shutdown_or_sleep(
+ m, message,
+ SPECIAL_HIBERNATE_TARGET,
+ INHIBIT_SLEEP,
+ "org.freedesktop.login1.hibernate",
+ "org.freedesktop.login1.hibernate-multiple-sessions",
+ "org.freedesktop.login1.hibernate-ignore-inhibit",
+ "hibernate",
+ method_hibernate);
+}
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
+static int method_hybrid_sleep(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "KillSession")) {
- const char *swho;
- int32_t signo;
- KillWho who;
- const char *name;
- Session *session;
+ return method_do_shutdown_or_sleep(
+ m, message,
+ SPECIAL_HYBRID_SLEEP_TARGET,
+ INHIBIT_SLEEP,
+ "org.freedesktop.login1.hibernate",
+ "org.freedesktop.login1.hibernate-multiple-sessions",
+ "org.freedesktop.login1.hibernate-ignore-inhibit",
+ "hybrid-sleep",
+ method_hybrid_sleep);
+}
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_STRING, &swho,
- DBUS_TYPE_INT32, &signo,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- if (isempty(swho))
- who = KILL_ALL;
- else {
- who = kill_who_from_string(swho);
- if (who < 0)
- return bus_send_error_reply(connection, message, &error, -EINVAL);
- }
+static int method_can_shutdown_or_sleep(
+ Manager *m,
+ sd_bus_message *message,
+ InhibitWhat w,
+ const char *action,
+ const char *action_multiple_sessions,
+ const char *action_ignore_inhibit,
+ const char *sleep_verb) {
- if (signo <= 0 || signo >= _NSIG)
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ bool multiple_sessions, challenge, blocked;
+ const char *result = NULL;
+ uid_t uid;
+ int r;
- session = hashmap_get(m->sessions, name);
- if (!session)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
+ assert(m);
+ assert(message);
+ assert(w >= 0);
+ assert(w <= _INHIBIT_WHAT_MAX);
+ assert(action);
+ assert(action_multiple_sessions);
+ assert(action_ignore_inhibit);
- r = session_kill(session, who, signo);
+ if (sleep_verb) {
+ r = can_sleep(sleep_verb);
if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "KillUser")) {
- uint32_t uid;
- User *user;
- int32_t signo;
+ return sd_bus_reply_method_errno(m->bus, message, r, NULL);
+ if (r == 0)
+ return sd_bus_reply_method_return(m->bus, message, "s", "na");
+ }
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_UINT32, &uid,
- DBUS_TYPE_INT32, &signo,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+ r = sd_bus_get_owner_uid(m->bus, sd_bus_message_get_sender(message), &uid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(m->bus, message, r, NULL);
- if (signo <= 0 || signo >= _NSIG)
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+ r = have_multiple_sessions(m, uid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(m->bus, message, r, NULL);
- user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
- if (!user)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
+ multiple_sessions = r > 0;
+ blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, uid);
- r = user_kill(user, signo);
+ if (multiple_sessions) {
+ r = bus_verify_polkit(m->bus, message, action_multiple_sessions, false, &challenge, &error);
if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateSession")) {
- const char *name;
- Session *session;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+ return sd_bus_reply_method_errno(m->bus, message, r, &error);
- session = hashmap_get(m->sessions, name);
- if (!session)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
+ if (r > 0)
+ result = "yes";
+ else if (challenge)
+ result = "challenge";
+ else
+ result = "no";
+ }
- r = session_stop(session);
+ if (blocked) {
+ r = bus_verify_polkit(m->bus, message, action_ignore_inhibit, false, &challenge, &error);
if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
+ return sd_bus_reply_method_errno(m->bus, message, r, &error);
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateUser")) {
- uint32_t uid;
- User *user;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_UINT32, &uid,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+ if (r > 0 && !result)
+ result = "yes";
+ else if (challenge && (!result || streq(result, "yes")))
+ result = "challenge";
+ else
+ result = "no";
+ }
- user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
- if (!user)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
+ if (!multiple_sessions && !blocked) {
+ /* If neither inhibit nor multiple sessions
+ * apply then just check the normal policy */
- r = user_stop(user);
+ r = bus_verify_polkit(m->bus, message, action, false, &challenge, &error);
if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
+ return sd_bus_reply_method_errno(m->bus, message, r, &error);
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
+ if (r > 0)
+ result = "yes";
+ else if (challenge)
+ result = "challenge";
+ else
+ result = "no";
+ }
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateSeat")) {
- const char *name;
- Seat *seat;
+ return sd_bus_reply_method_return(m->bus, message, "s", result);
+}
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+static int method_can_poweroff(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
- seat = hashmap_get(m->seats, name);
- if (!seat)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
+ return method_can_shutdown_or_sleep(
+ m, message,
+ INHIBIT_SHUTDOWN,
+ "org.freedesktop.login1.power-off",
+ "org.freedesktop.login1.power-off-multiple-sessions",
+ "org.freedesktop.login1.power-off-ignore-inhibit",
+ NULL);
+}
- r = seat_stop_sessions(seat);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
+static int method_can_reboot(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
+ return method_can_shutdown_or_sleep(
+ m, message,
+ INHIBIT_SHUTDOWN,
+ "org.freedesktop.login1.reboot",
+ "org.freedesktop.login1.reboot-multiple-sessions",
+ "org.freedesktop.login1.reboot-ignore-inhibit",
+ NULL);
+}
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "SetUserLinger")) {
- uint32_t uid;
- struct passwd *pw;
- dbus_bool_t b, interactive;
- char *path;
+static int method_can_suspend(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_UINT32, &uid,
- DBUS_TYPE_BOOLEAN, &b,
- DBUS_TYPE_BOOLEAN, &interactive,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- errno = 0;
- pw = getpwuid(uid);
- if (!pw)
- return bus_send_error_reply(connection, message, NULL, errno ? -errno : -EINVAL);
-
- r = verify_polkit(connection, message, "org.freedesktop.login1.set-user-linger", interactive, NULL, &error);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
+ return method_can_shutdown_or_sleep(
+ m, message,
+ INHIBIT_SLEEP,
+ "org.freedesktop.login1.suspend",
+ "org.freedesktop.login1.suspend-multiple-sessions",
+ "org.freedesktop.login1.suspend-ignore-inhibit",
+ "suspend");
+}
- mkdir_p_label("/var/lib/systemd", 0755);
+static int method_can_hibernate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
- r = mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
+ return method_can_shutdown_or_sleep(
+ m, message,
+ INHIBIT_SLEEP,
+ "org.freedesktop.login1.hibernate",
+ "org.freedesktop.login1.hibernate-multiple-sessions",
+ "org.freedesktop.login1.hibernate-ignore-inhibit",
+ "hibernate");
+}
- path = strappend("/var/lib/systemd/linger/", pw->pw_name);
- if (!path)
- goto oom;
+static int method_can_hybrid_sleep(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
- if (b) {
- User *u;
+ return method_can_shutdown_or_sleep(
+ m, message,
+ INHIBIT_SLEEP,
+ "org.freedesktop.login1.hibernate",
+ "org.freedesktop.login1.hibernate-multiple-sessions",
+ "org.freedesktop.login1.hibernate-ignore-inhibit",
+ "hybrid-sleep");
+}
- r = touch(path);
- free(path);
+static int method_inhibit(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ const char *who, *why, *what, *mode;
+ _cleanup_free_ char *id = NULL;
+ _cleanup_close_ int fifo_fd = -1;
+ Manager *m = userdata;
+ Inhibitor *i = NULL;
+ InhibitMode mm;
+ InhibitWhat w;
+ pid_t pid;
+ uid_t uid;
+ int r;
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
+ assert(bus);
+ assert(message);
+ assert(m);
- if (manager_add_user_by_uid(m, uid, &u) >= 0)
- user_start(u);
+ r = sd_bus_message_read(message, "ssss", &what, &who, &why, &mode);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- } else {
- User *u;
+ w = inhibit_what_from_string(what);
+ if (w <= 0)
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid what specification %s", what);
- r = unlink(path);
- free(path);
+ mm = inhibit_mode_from_string(mode);
+ if (mm < 0)
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid mode specification %s", mode);
- if (r < 0 && errno != ENOENT)
- return bus_send_error_reply(connection, message, &error, -errno);
+ /* Delay is only supported for shutdown/sleep */
+ if (mm == INHIBIT_DELAY && (w & ~(INHIBIT_SHUTDOWN|INHIBIT_SLEEP)))
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Delay inhibitors only supported for shutdown and sleep");
- u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
- if (u)
- user_add_to_gc_queue(u);
- }
+ /* Don't allow taking delay locks while we are already
+ * executing the operation. We shouldn't create the impression
+ * that the lock was successful if the machine is about to go
+ * down/suspend any moment. */
+ if (m->action_what & w)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_OPERATION_IN_PROGRESS, "The operation inhibition has been requested for is already running");
+
+ r = bus_verify_polkit_async(bus, &m->polkit_registry, message,
+ w == INHIBIT_SHUTDOWN ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
+ w == INHIBIT_SLEEP ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-sleep" : "org.freedesktop.login1.inhibit-delay-sleep") :
+ w == INHIBIT_IDLE ? "org.freedesktop.login1.inhibit-block-idle" :
+ w == INHIBIT_HANDLE_POWER_KEY ? "org.freedesktop.login1.inhibit-handle-power-key" :
+ w == INHIBIT_HANDLE_SUSPEND_KEY ? "org.freedesktop.login1.inhibit-handle-suspend-key" :
+ w == INHIBIT_HANDLE_HIBERNATE_KEY ? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
+ "org.freedesktop.login1.inhibit-handle-lid-switch",
+ false, &error, method_inhibit, m);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, &error);
+ if (r == 0)
+ return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
+ r = sd_bus_get_owner_uid(m->bus, sd_bus_message_get_sender(message), &uid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "AttachDevice")) {
- const char *sysfs, *seat;
- dbus_bool_t interactive;
+ r = sd_bus_get_owner_pid(m->bus, sd_bus_message_get_sender(message), &pid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &seat,
- DBUS_TYPE_STRING, &sysfs,
- DBUS_TYPE_BOOLEAN, &interactive,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+ do {
+ free(id);
+ id = NULL;
- if (!path_startswith(sysfs, "/sys") || !seat_name_is_valid(seat))
- return bus_send_error_reply(connection, message, NULL, -EINVAL);
+ if (asprintf(&id, "%lu", ++m->inhibit_counter) < 0)
+ return sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
- r = verify_polkit(connection, message, "org.freedesktop.login1.attach-device", interactive, NULL, &error);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
+ } while (hashmap_get(m->inhibitors, id));
- r = attach_device(m, seat, sysfs);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, -EINVAL);
+ r = manager_add_inhibitor(m, id, &i);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
+ i->what = w;
+ i->mode = mm;
+ i->pid = pid;
+ i->uid = uid;
+ i->why = strdup(why);
+ i->who = strdup(who);
+ if (!i->why || !i->who) {
+ r = sd_bus_reply_method_errno(bus, message, -ENOMEM, NULL);
+ goto fail;
+ }
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "FlushDevices")) {
- dbus_bool_t interactive;
+ fifo_fd = inhibitor_create_fifo(i);
+ if (fifo_fd < 0) {
+ r = sd_bus_reply_method_errno(bus, message, fifo_fd, NULL);
+ goto fail;
+ }
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_BOOLEAN, &interactive,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+ inhibitor_start(i);
- r = verify_polkit(connection, message, "org.freedesktop.login1.flush-devices", interactive, NULL, &error);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
+ return sd_bus_reply_method_return(bus, message, "h", fifo_fd);
- r = flush_devices(m);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, -EINVAL);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "PowerOff")) {
-
- r = bus_manager_do_shutdown_or_sleep(
- m, connection, message,
- SPECIAL_POWEROFF_TARGET,
- INHIBIT_SHUTDOWN,
- "org.freedesktop.login1.power-off",
- "org.freedesktop.login1.power-off-multiple-sessions",
- "org.freedesktop.login1.power-off-ignore-inhibit",
- NULL,
- &error, &reply);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Reboot")) {
- r = bus_manager_do_shutdown_or_sleep(
- m, connection, message,
- SPECIAL_REBOOT_TARGET,
- INHIBIT_SHUTDOWN,
- "org.freedesktop.login1.reboot",
- "org.freedesktop.login1.reboot-multiple-sessions",
- "org.freedesktop.login1.reboot-ignore-inhibit",
- NULL,
- &error, &reply);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Suspend")) {
- r = bus_manager_do_shutdown_or_sleep(
- m, connection, message,
- SPECIAL_SUSPEND_TARGET,
- INHIBIT_SLEEP,
- "org.freedesktop.login1.suspend",
- "org.freedesktop.login1.suspend-multiple-sessions",
- "org.freedesktop.login1.suspend-ignore-inhibit",
- "suspend",
- &error, &reply);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Hibernate")) {
- r = bus_manager_do_shutdown_or_sleep(
- m, connection, message,
- SPECIAL_HIBERNATE_TARGET,
- INHIBIT_SLEEP,
- "org.freedesktop.login1.hibernate",
- "org.freedesktop.login1.hibernate-multiple-sessions",
- "org.freedesktop.login1.hibernate-ignore-inhibit",
- "hibernate",
- &error, &reply);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "HybridSleep")) {
- r = bus_manager_do_shutdown_or_sleep(
- m, connection, message,
- SPECIAL_HYBRID_SLEEP_TARGET,
- INHIBIT_SLEEP,
- "org.freedesktop.login1.hibernate",
- "org.freedesktop.login1.hibernate-multiple-sessions",
- "org.freedesktop.login1.hibernate-ignore-inhibit",
- "hybrid-sleep",
- &error, &reply);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanPowerOff")) {
-
- r = bus_manager_can_shutdown_or_sleep(
- m, connection, message,
- INHIBIT_SHUTDOWN,
- "org.freedesktop.login1.power-off",
- "org.freedesktop.login1.power-off-multiple-sessions",
- "org.freedesktop.login1.power-off-ignore-inhibit",
- NULL,
- &error, &reply);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanReboot")) {
- r = bus_manager_can_shutdown_or_sleep(
- m, connection, message,
- INHIBIT_SHUTDOWN,
- "org.freedesktop.login1.reboot",
- "org.freedesktop.login1.reboot-multiple-sessions",
- "org.freedesktop.login1.reboot-ignore-inhibit",
- NULL,
- &error, &reply);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanSuspend")) {
- r = bus_manager_can_shutdown_or_sleep(
- m, connection, message,
- INHIBIT_SLEEP,
- "org.freedesktop.login1.suspend",
- "org.freedesktop.login1.suspend-multiple-sessions",
- "org.freedesktop.login1.suspend-ignore-inhibit",
- "suspend",
- &error, &reply);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanHibernate")) {
- r = bus_manager_can_shutdown_or_sleep(
- m, connection, message,
- INHIBIT_SLEEP,
- "org.freedesktop.login1.hibernate",
- "org.freedesktop.login1.hibernate-multiple-sessions",
- "org.freedesktop.login1.hibernate-ignore-inhibit",
- "hibernate",
- &error, &reply);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanHybridSleep")) {
- r = bus_manager_can_shutdown_or_sleep(
- m, connection, message,
- INHIBIT_SLEEP,
- "org.freedesktop.login1.hibernate",
- "org.freedesktop.login1.hibernate-multiple-sessions",
- "org.freedesktop.login1.hibernate-ignore-inhibit",
- "hybrid-sleep",
- &error, &reply);
- if (r < 0)
- return bus_send_error_reply(connection, message, &error, r);
+fail:
+ if (i)
+ inhibitor_free(i);
- } else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
- char *introspection = NULL;
- FILE *f;
- Iterator i;
- Session *session;
- Seat *seat;
- User *user;
- size_t size;
- char *p;
+ return r;
+}
- if (!(reply = dbus_message_new_method_return(message)))
- goto oom;
+const sd_bus_vtable manager_vtable[] = {
+ SD_BUS_VTABLE_START(0),
+
+ SD_BUS_PROPERTY("NAutoVTs", "u", NULL, offsetof(Manager, n_autovts), 0),
+ SD_BUS_PROPERTY("KillOnlyUsers", "as", NULL, offsetof(Manager, kill_only_users), 0),
+ SD_BUS_PROPERTY("KillExcludeUsers", "as", NULL, offsetof(Manager, kill_exclude_users), 0),
+ SD_BUS_PROPERTY("KillUserProcesses", "b", NULL, offsetof(Manager, kill_user_processes), 0),
+ SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("BlockInhibited", "s", property_get_inhibited, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("DelayInhibited", "s", property_get_inhibited, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("InhibitDelayMaxUSec", "t", NULL, offsetof(Manager, inhibit_delay_max), 0),
+ SD_BUS_PROPERTY("HandlePowerKey", "s", property_get_handle_action, offsetof(Manager, handle_power_key), 0),
+ SD_BUS_PROPERTY("HandleSuspendKey", "s", property_get_handle_action, offsetof(Manager, handle_suspend_key), 0),
+ SD_BUS_PROPERTY("HandleHibernateKey", "s", property_get_handle_action, offsetof(Manager, handle_hibernate_key), 0),
+ SD_BUS_PROPERTY("HandleLidSwitch", "s", property_get_handle_action, offsetof(Manager, handle_lid_switch), 0),
+ SD_BUS_PROPERTY("IdleAction", "s", property_get_handle_action, offsetof(Manager, idle_action), 0),
+ SD_BUS_PROPERTY("IdleActionUSec", "t", NULL, offsetof(Manager, idle_action_usec), 0),
+ SD_BUS_PROPERTY("PreparingForShutdown", "b", property_get_preparing, 0, 0),
+ SD_BUS_PROPERTY("PreparingForSleep", "b", property_get_preparing, 0, 0),
+
+ SD_BUS_METHOD("GetSession", "s", "o", method_get_session, 0),
+ SD_BUS_METHOD("GetSessionByPID", "u", "o", method_get_session_by_pid, 0),
+ SD_BUS_METHOD("GetUser", "u", "o", method_get_user, 0),
+ SD_BUS_METHOD("GetUserByPID", "u", "o", method_get_user_by_pid, 0),
+ SD_BUS_METHOD("GetSeat", "s", "o", method_get_seat, 0),
+ SD_BUS_METHOD("ListSessions", NULL, "a(susso)", method_list_sessions, 0),
+ SD_BUS_METHOD("ListUsers", NULL, "a(uso)", method_list_users, 0),
+ SD_BUS_METHOD("ListSeats", NULL, "a(so)", method_list_seats, 0),
+ SD_BUS_METHOD("ListInhibitors", NULL, "a(ssssuu)", method_list_inhibitors, 0),
+ SD_BUS_METHOD("CreateSession", "uussssussbssa(sv)", "soshsub", method_create_session, 0),
+ SD_BUS_METHOD("ReleaseSession", "s", NULL, method_release_session, 0),
+ SD_BUS_METHOD("ActivateSession", "s", NULL, method_activate_session, 0),
+ SD_BUS_METHOD("ActivateSessionOnSeat", "ss", NULL, method_activate_session_on_seat, 0),
+ SD_BUS_METHOD("LockSession", "s", NULL, method_lock_session, 0),
+ SD_BUS_METHOD("UnlockSession", "s", NULL, method_lock_session, 0),
+ SD_BUS_METHOD("LockSessions", NULL, NULL, method_lock_sessions, 0),
+ SD_BUS_METHOD("UnlockSessions", NULL, NULL, method_lock_sessions, 0),
+ SD_BUS_METHOD("KillSession", "ssi", NULL, method_kill_session, 0),
+ SD_BUS_METHOD("KillUser", "ui", NULL, method_kill_user, 0),
+ SD_BUS_METHOD("TerminateSession", "s", NULL, method_terminate_session, 0),
+ SD_BUS_METHOD("TerminateUser", "u", NULL, method_terminate_user, 0),
+ SD_BUS_METHOD("TerminateSeat", "s", NULL, method_terminate_seat, 0),
+ SD_BUS_METHOD("SetUserLinger", "ubb", NULL, method_set_user_linger, 0),
+ SD_BUS_METHOD("AttachDevice", "ssb", NULL, method_attach_device, 0),
+ SD_BUS_METHOD("FlushDevices", "b", NULL, method_flush_devices, 0),
+ SD_BUS_METHOD("PowerOff", "b", NULL, method_poweroff, 0),
+ SD_BUS_METHOD("Reboot", "b", NULL, method_reboot, 0),
+ SD_BUS_METHOD("Suspend", "b", NULL, method_suspend, 0),
+ SD_BUS_METHOD("Hibernate", "b", NULL, method_hibernate, 0),
+ SD_BUS_METHOD("HybridSleep", "b", NULL, method_hybrid_sleep, 0),
+ SD_BUS_METHOD("CanPowerOff", NULL, "s", method_can_poweroff, 0),
+ SD_BUS_METHOD("CanReboot", NULL, "s", method_can_reboot, 0),
+ SD_BUS_METHOD("CanSuspend", NULL, "s", method_can_suspend, 0),
+ SD_BUS_METHOD("CanHibernate", NULL, "s", method_can_hibernate, 0),
+ SD_BUS_METHOD("CanHybridSleep", NULL, "s", method_can_hybrid_sleep, 0),
+ SD_BUS_METHOD("Inhibit", "ssss", "h", method_inhibit, 0),
+
+ SD_BUS_SIGNAL("SessionNew", "so", 0),
+ SD_BUS_SIGNAL("SessionRemoved", "so", 0),
+ SD_BUS_SIGNAL("UserNew", "uo", 0),
+ SD_BUS_SIGNAL("UserRemoved", "uo", 0),
+ SD_BUS_SIGNAL("SeatNew", "so", 0),
+ SD_BUS_SIGNAL("SeatRemoved", "so", 0),
+ SD_BUS_SIGNAL("PrepareForShutdown", "b", 0),
+ SD_BUS_SIGNAL("PrepareForSleep", "b", 0),
+
+ SD_BUS_VTABLE_END
+};
- /* We roll our own introspection code here, instead of
- * relying on bus_default_message_handler() because we
- * need to generate our introspection string
- * dynamically. */
+int match_job_removed(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ const char *path, *result, *unit;
+ Manager *m = userdata;
+ Session *session;
+ uint32_t id;
+ User *user;
+ int r;
- if (!(f = open_memstream(&introspection, &size)))
- goto oom;
+ assert(bus);
+ assert(message);
+ assert(m);
- fputs(INTROSPECTION_BEGIN, f);
+ r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
+ if (r < 0) {
+ log_error("Failed to parse JobRemoved message: %s", strerror(-r));
+ return 0;
+ }
- HASHMAP_FOREACH(seat, m->seats, i) {
- p = bus_path_escape(seat->id);
+ if (m->action_job && streq(m->action_job, path)) {
+ log_info("Operation finished.");
- if (p) {
- fprintf(f, "<node name=\"seat/%s\"/>", p);
- free(p);
- }
- }
+ /* Tell people that they now may take a lock again */
+ send_prepare_for(m, m->action_what, false);
- HASHMAP_FOREACH(user, m->users, i)
- fprintf(f, "<node name=\"user/_%llu\"/>", (unsigned long long) user->uid);
+ free(m->action_job);
+ m->action_job = NULL;
+ m->action_unit = NULL;
+ m->action_what = 0;
+ return 0;
+ }
- HASHMAP_FOREACH(session, m->sessions, i) {
- p = bus_path_escape(session->id);
+ session = hashmap_get(m->session_units, unit);
+ if (session) {
- if (p) {
- fprintf(f, "<node name=\"session/%s\"/>", p);
- free(p);
- }
+ if (streq_ptr(path, session->scope_job)) {
+ free(session->scope_job);
+ session->scope_job = NULL;
}
- fputs(INTROSPECTION_END, f);
+ if (session->started) {
+ if (streq(result, "done"))
+ session_send_create_reply(session, NULL);
+ else {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
- if (ferror(f)) {
- fclose(f);
- free(introspection);
- goto oom;
- }
+ sd_bus_error_setf(&error, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
+ session_send_create_reply(session, &error);
+ }
+ } else
+ session_save(session);
- fclose(f);
+ session_add_to_gc_queue(session);
+ }
- if (!introspection)
- goto oom;
+ user = hashmap_get(m->user_units, unit);
+ if (user) {
- if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID)) {
- free(introspection);
- goto oom;
+ if (streq_ptr(path, user->service_job)) {
+ free(user->service_job);
+ user->service_job = NULL;
}
- free(introspection);
- } else {
- const BusBoundProperties bps[] = {
- { "org.freedesktop.login1.Manager", bus_login_manager_properties, m },
- { NULL, }
- };
- return bus_default_message_handler(connection, message, NULL, INTERFACES_LIST, bps);
- }
+ if (streq_ptr(path, user->slice_job)) {
+ free(user->slice_job);
+ user->slice_job = NULL;
+ }
- if (reply) {
- if (!bus_maybe_send_reply(connection, message, reply))
- goto oom;
+ user_save(user);
+ user_add_to_gc_queue(user);
}
- return DBUS_HANDLER_RESULT_HANDLED;
-
-oom:
- dbus_error_free(&error);
-
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
+ return 0;
}
-const DBusObjectPathVTable bus_manager_vtable = {
- .message_function = manager_message_handler
-};
-
-DBusHandlerResult bus_message_filter(
- DBusConnection *connection,
- DBusMessage *message,
- void *userdata) {
-
+int match_unit_removed(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ const char *path, *unit;
Manager *m = userdata;
- DBusError error;
+ Session *session;
+ User *user;
+ int r;
- assert(m);
- assert(connection);
+ assert(bus);
assert(message);
+ assert(m);
- dbus_error_init(&error);
-
- log_debug("Got message: %s %s %s", strna(dbus_message_get_sender(message)), strna(dbus_message_get_interface(message)), strna(dbus_message_get_member(message)));
-
- if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
- const char *path, *result, *unit;
- uint32_t id;
-
- if (!dbus_message_get_args(message, &error,
- DBUS_TYPE_UINT32, &id,
- DBUS_TYPE_OBJECT_PATH, &path,
- DBUS_TYPE_STRING, &unit,
- DBUS_TYPE_STRING, &result,
- DBUS_TYPE_INVALID)) {
- log_error("Failed to parse JobRemoved message: %s", bus_error_message(&error));
- goto finish;
- }
-
- if (m->action_job && streq(m->action_job, path)) {
- log_info("Operation finished.");
-
- /* Tell people that they now may take a lock again */
- send_prepare_for(m, m->action_what, false);
-
- free(m->action_job);
- m->action_job = NULL;
- m->action_unit = NULL;
- m->action_what = 0;
+ r = sd_bus_message_read(message, "so", &unit, &path);
+ if (r < 0) {
+ log_error("Failed to parse UnitRemoved message: %s", strerror(-r));
+ return 0;
+ }
- } else {
- Session *s;
- User *u;
-
- s = hashmap_get(m->session_units, unit);
- if (s) {
- if (streq_ptr(path, s->scope_job)) {
- free(s->scope_job);
- s->scope_job = NULL;
-
- if (s->started) {
- if (streq(result, "done"))
- session_send_create_reply(s, NULL);
- else {
- dbus_set_error(&error, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
- session_send_create_reply(s, &error);
- }
- } else
- session_save(s);
- }
-
- session_add_to_gc_queue(s);
- }
+ session = hashmap_get(m->session_units, unit);
+ if (session)
+ session_add_to_gc_queue(session);
- u = hashmap_get(m->user_units, unit);
- if (u) {
- if (streq_ptr(path, u->service_job)) {
- free(u->service_job);
- u->service_job = NULL;
- }
+ user = hashmap_get(m->user_units, unit);
+ if (user)
+ user_add_to_gc_queue(user);
- if (streq_ptr(path, u->slice_job)) {
- free(u->slice_job);
- u->slice_job = NULL;
- }
+ return 0;
+}
- user_save(u);
- user_add_to_gc_queue(u);
- }
- }
+int match_properties_changed(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ _cleanup_free_ char *unit = NULL;
+ Manager *m = userdata;
+ const char *path;
+ Session *session;
+ User *user;
- } else if (dbus_message_is_signal(message, "org.freedesktop.DBus.Properties", "PropertiesChanged")) {
+ assert(bus);
+ assert(message);
+ assert(m);
- _cleanup_free_ char *unit = NULL;
- const char *path;
+ path = sd_bus_message_get_path(message);
+ if (!path)
+ return 0;
- path = dbus_message_get_path(message);
- if (!path)
- goto finish;
+ unit_name_from_dbus_path(path, &unit);
+ if (!unit)
+ return 0;
- unit_name_from_dbus_path(path, &unit);
- if (unit) {
- Session *s;
- User *u;
+ session = hashmap_get(m->session_units, unit);
+ if (session)
+ session_add_to_gc_queue(session);
- s = hashmap_get(m->session_units, unit);
- if (s)
- session_add_to_gc_queue(s);
+ user = hashmap_get(m->user_units, unit);
+ if (user)
+ user_add_to_gc_queue(user);
- u = hashmap_get(m->user_units, unit);
- if (u)
- user_add_to_gc_queue(u);
- }
+ return 0;
+}
- } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitRemoved")) {
+int match_reloading(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Manager *m = userdata;
+ Session *session;
+ Iterator i;
+ int b, r;
- const char *path, *unit;
- Session *session;
- User *user;
+ assert(bus);
- if (!dbus_message_get_args(message, &error,
- DBUS_TYPE_STRING, &unit,
- DBUS_TYPE_OBJECT_PATH, &path,
- DBUS_TYPE_INVALID)) {
- log_error("Failed to parse UnitRemoved message: %s", bus_error_message(&error));
- goto finish;
- }
+ r = sd_bus_message_read(message, "b", &b);
+ if (r < 0) {
+ log_error("Failed to parse Reloading message: %s", strerror(-r));
+ return 0;
+ }
- session = hashmap_get(m->session_units, unit);
- if (session)
- session_add_to_gc_queue(session);
+ if (b)
+ return 0;
- user = hashmap_get(m->user_units, unit);
- if (user)
- user_add_to_gc_queue(user);
+ /* systemd finished reloading, let's recheck all our sessions */
+ log_debug("System manager has been reloaded, rechecking sessions...");
- } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "Reloading")) {
- dbus_bool_t b;
+ HASHMAP_FOREACH(session, m->sessions, i)
+ session_add_to_gc_queue(session);
- if (!dbus_message_get_args(message, &error,
- DBUS_TYPE_BOOLEAN, &b,
- DBUS_TYPE_INVALID)) {
- log_error("Failed to parse Reloading message: %s", bus_error_message(&error));
- goto finish;
- }
+ return 0;
+}
- /* systemd finished reloading, let's recheck all our sessions */
- if (!b) {
- Session *session;
- Iterator i;
+int match_name_owner_changed(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ const char *name, *old, *new;
+ Manager *m = userdata;
+ Session *session;
+ Iterator i;
+ int r;
- log_debug("System manager has been reloaded, rechecking sessions...");
- HASHMAP_FOREACH(session, m->sessions, i)
- session_add_to_gc_queue(session);
- }
+ char *key;
- } else if (dbus_message_is_signal(message, DBUS_INTERFACE_DBUS, "NameOwnerChanged")) {
- const char *name, *old, *new;
- char *key;
+ r = sd_bus_message_read(message, "sss", &name, &old, &new);
+ if (r < 0) {
+ log_error("Failed to parse NameOwnerChanged message: %s", strerror(-r));
+ return 0;
+ }
- if (!dbus_message_get_args(message, &error,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_STRING, &old,
- DBUS_TYPE_STRING, &new,
- DBUS_TYPE_INVALID)) {
- log_error("Failed to parse NameOwnerChanged message: %s", bus_error_message(&error));
- goto finish;
- }
+ if (isempty(old) || !isempty(new))
+ return 0;
- /* drop all controllers owned by this name */
- if (*old && !*new && (key = hashmap_remove(m->busnames, old))) {
- Session *session;
- Iterator i;
+ key = set_remove(m->busnames, (char*) old);
+ if (!key)
+ return 0;
- free(key);
+ /* Drop all controllers owned by this name */
- HASHMAP_FOREACH(session, m->sessions, i)
- if (session_is_controller(session, old))
- session_drop_controller(session);
- }
- }
+ free(key);
-finish:
- dbus_error_free(&error);
+ HASHMAP_FOREACH(session, m->sessions, i)
+ if (session_is_controller(session, old))
+ session_drop_controller(session);
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ return 0;
}
-int manager_send_changed(Manager *manager, const char *properties) {
- _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
+int manager_send_changed(Manager *manager, const char *property, ...) {
+ char **l;
assert(manager);
- m = bus_properties_changed_new("/org/freedesktop/login1",
- "org.freedesktop.login1.Manager",
- properties);
- if (!m)
- return -ENOMEM;
-
- if (!dbus_connection_send(manager->bus, m, NULL))
- return -ENOMEM;
+ l = strv_from_stdarg_alloca(property);
- return 0;
+ return sd_bus_emit_properties_changed_strv(
+ manager->bus,
+ "/org/freedesktop/login1",
+ "org.freedesktop.login1.Manager",
+ l);
}
int manager_dispatch_delayed(Manager *manager) {
- DBusError error;
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
assert(manager);
@@ -2528,11 +2105,9 @@ int manager_dispatch_delayed(Manager *manager) {
}
/* Actually do the operation */
- dbus_error_init(&error);
r = execute_shutdown_or_sleep(manager, manager->action_what, manager->action_unit, &error);
if (r < 0) {
- log_warning("Failed to send delayed message: %s", bus_error(&error, r));
- dbus_error_free(&error);
+ log_warning("Failed to send delayed message: %s", bus_error_message(&error, r));
manager->action_unit = NULL;
manager->action_what = 0;
@@ -2550,87 +2125,56 @@ int manager_start_scope(
const char *description,
const char *after,
const char *kill_mode,
- DBusError *error,
+ sd_bus_error *error,
char **job) {
- const char *timeout_stop_property = "TimeoutStopUSec", *send_sighup_property = "SendSIGHUP", *pids_property = "PIDs";
- _cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;
- DBusMessageIter iter, sub, sub2, sub3, sub4;
- uint64_t timeout = 500 * USEC_PER_MSEC;
- dbus_bool_t send_sighup = true;
- const char *fail = "fail";
- uint32_t u;
+ _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
+ int r;
assert(manager);
assert(scope);
assert(pid > 1);
- if (!slice)
- slice = "";
-
- m = dbus_message_new_method_call(
+ r = sd_bus_message_new_method_call(
+ manager->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "StartTransientUnit");
- if (!m)
- return log_oom();
+ "StartTransientUnit",
+ &m);
+ if (r < 0)
+ return r;
- dbus_message_iter_init_append(m, &iter);
+ r = sd_bus_message_append(m, "ss", strempty(scope), "fail");
+ if (r < 0)
+ return r;
- if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &scope) ||
- !dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &fail) ||
- !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sv)", &sub))
- return log_oom();
+ r = sd_bus_message_open_container(m, 'a', "(sv)");
+ if (r < 0)
+ return r;
if (!isempty(slice)) {
- const char *slice_property = "Slice";
-
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &slice_property) ||
- !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "s", &sub3) ||
- !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &slice) ||
- !dbus_message_iter_close_container(&sub2, &sub3) ||
- !dbus_message_iter_close_container(&sub, &sub2))
- return log_oom();
+ r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
+ if (r < 0)
+ return r;
}
if (!isempty(description)) {
- const char *description_property = "Description";
-
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &description_property) ||
- !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "s", &sub3) ||
- !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &description) ||
- !dbus_message_iter_close_container(&sub2, &sub3) ||
- !dbus_message_iter_close_container(&sub, &sub2))
- return log_oom();
+ r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
+ if (r < 0)
+ return r;
}
- if (!isempty(after)) {
- const char *after_property = "After";
-
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &after_property) ||
- !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "as", &sub3) ||
- !dbus_message_iter_open_container(&sub3, DBUS_TYPE_ARRAY, "s", &sub4) ||
- !dbus_message_iter_append_basic(&sub4, DBUS_TYPE_STRING, &after) ||
- !dbus_message_iter_close_container(&sub3, &sub4) ||
- !dbus_message_iter_close_container(&sub2, &sub3) ||
- !dbus_message_iter_close_container(&sub, &sub2))
- return log_oom();
+ if (!isempty(description)) {
+ r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after);
+ if (r < 0)
+ return r;
}
if (!isempty(kill_mode)) {
- const char *kill_mode_property = "KillMode";
-
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &kill_mode_property) ||
- !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "s", &sub3) ||
- !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_STRING, &kill_mode) ||
- !dbus_message_iter_close_container(&sub2, &sub3) ||
- !dbus_message_iter_close_container(&sub, &sub2))
- return log_oom();
+ r = sd_bus_message_append(m, "(sv)", "KillMode", "s", kill_mode);
+ if (r < 0)
+ return r;
}
/* cgroup empty notification is not available in containers
@@ -2638,48 +2182,35 @@ int manager_start_scope(
* stop timeout for sessions, so that we don't wait
* forever. */
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &timeout_stop_property) ||
- !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "t", &sub3) ||
- !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_UINT64, &timeout) ||
- !dbus_message_iter_close_container(&sub2, &sub3) ||
- !dbus_message_iter_close_container(&sub, &sub2))
- return log_oom();
+ r = sd_bus_message_append(m, "(sv)", "TimeoutStopUSec", "t", 500 * USEC_PER_MSEC);
+ if (r < 0)
+ return r;
/* Make sure that the session shells are terminated with
* SIGHUP since bash and friends tend to ignore SIGTERM */
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &send_sighup_property) ||
- !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "b", &sub3) ||
- !dbus_message_iter_append_basic(&sub3, DBUS_TYPE_BOOLEAN, &send_sighup) ||
- !dbus_message_iter_close_container(&sub2, &sub3) ||
- !dbus_message_iter_close_container(&sub, &sub2))
- return log_oom();
-
- u = pid;
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &pids_property) ||
- !dbus_message_iter_open_container(&sub2, DBUS_TYPE_VARIANT, "au", &sub3) ||
- !dbus_message_iter_open_container(&sub3, DBUS_TYPE_ARRAY, "u", &sub4) ||
- !dbus_message_iter_append_basic(&sub4, DBUS_TYPE_UINT32, &u) ||
- !dbus_message_iter_close_container(&sub3, &sub4) ||
- !dbus_message_iter_close_container(&sub2, &sub3) ||
- !dbus_message_iter_close_container(&sub, &sub2))
- return log_oom();
-
- if (!dbus_message_iter_close_container(&iter, &sub))
- return log_oom();
-
- reply = dbus_connection_send_with_reply_and_block(manager->bus, m, -1, error);
- if (!reply)
- return -EIO;
+ r = sd_bus_message_append(m, "(sv)", "SendSIGHUP", "b", true);
+ if (r < 0)
+ return r;
+
+ r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, pid);
+ if (r < 0)
+ return r;
+
+ r = sd_bus_message_close_container(m);
+ if (r < 0)
+ return r;
+
+ r = sd_bus_send_with_reply_and_block(manager->bus, m, 0, error, &reply);
+ if (r < 0)
+ return r;
if (job) {
const char *j;
char *copy;
- if (!dbus_message_get_args(reply, error, DBUS_TYPE_OBJECT_PATH, &j, DBUS_TYPE_INVALID))
- return -EIO;
+ r = sd_bus_message_read(reply, "o", &j);
+ if (r < 0)
+ return r;
copy = strdup(j);
if (!copy)
@@ -2688,43 +2219,35 @@ int manager_start_scope(
*job = copy;
}
- return 0;
+ return 1;
}
-int manager_start_unit(Manager *manager, const char *unit, DBusError *error, char **job) {
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
- const char *fail = "fail";
+int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
+ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
int r;
assert(manager);
assert(unit);
- r = bus_method_call_with_reply(
+ r = sd_bus_call_method(
manager->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"StartUnit",
- &reply,
error,
- DBUS_TYPE_STRING, &unit,
- DBUS_TYPE_STRING, &fail,
- DBUS_TYPE_INVALID);
- if (r < 0) {
- log_error("Failed to start unit %s: %s", unit, bus_error(error, r));
+ &reply,
+ "ss", unit, "fail");
+ if (r < 0)
return r;
- }
if (job) {
const char *j;
char *copy;
- if (!dbus_message_get_args(reply, error,
- DBUS_TYPE_OBJECT_PATH, &j,
- DBUS_TYPE_INVALID)) {
- log_error("Failed to parse reply.");
- return -EIO;
- }
+ r = sd_bus_message_read(reply, "o", &j);
+ if (r < 0)
+ return r;
copy = strdup(j);
if (!copy)
@@ -2733,40 +2256,36 @@ int manager_start_unit(Manager *manager, const char *unit, DBusError *error, cha
*job = copy;
}
- return 0;
+ return 1;
}
-int manager_stop_unit(Manager *manager, const char *unit, DBusError *error, char **job) {
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
- const char *fail = "fail";
+int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
+ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
int r;
assert(manager);
assert(unit);
- r = bus_method_call_with_reply(
+ r = sd_bus_call_method(
manager->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"StopUnit",
- &reply,
error,
- DBUS_TYPE_STRING, &unit,
- DBUS_TYPE_STRING, &fail,
- DBUS_TYPE_INVALID);
+ &reply,
+ "ss", unit, "fail");
if (r < 0) {
- if (dbus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
- dbus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
+ if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
+ sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
if (job)
*job = NULL;
- dbus_error_free(error);
+ sd_bus_error_free(error);
return 0;
}
- log_error("Failed to stop unit %s: %s", unit, bus_error(error, r));
return r;
}
@@ -2774,12 +2293,9 @@ int manager_stop_unit(Manager *manager, const char *unit, DBusError *error, char
const char *j;
char *copy;
- if (!dbus_message_get_args(reply, error,
- DBUS_TYPE_OBJECT_PATH, &j,
- DBUS_TYPE_INVALID)) {
- log_error("Failed to parse reply.");
- return -EIO;
- }
+ r = sd_bus_message_read(reply, "o", &j);
+ if (r < 0)
+ return r;
copy = strdup(j);
if (!copy)
@@ -2791,106 +2307,97 @@ int manager_stop_unit(Manager *manager, const char *unit, DBusError *error, char
return 1;
}
-int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, DBusError *error) {
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
- const char *w;
- int r;
-
+int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error) {
assert(manager);
assert(unit);
- w = who == KILL_LEADER ? "process" : "cgroup";
- assert_cc(sizeof(signo) == sizeof(int32_t));
-
- r = bus_method_call_with_reply(
+ return sd_bus_call_method(
manager->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"KillUnit",
- &reply,
error,
- DBUS_TYPE_STRING, &unit,
- DBUS_TYPE_STRING, &w,
- DBUS_TYPE_INT32, &signo,
- DBUS_TYPE_INVALID);
- if (r < 0) {
- log_error("Failed to stop unit %s: %s", unit, bus_error(error, r));
- return r;
- }
-
- return 0;
+ NULL,
+ "ssi", unit, who == KILL_LEADER ? "main" : "all", signo);
}
int manager_unit_is_active(Manager *manager, const char *unit) {
-
- const char *interface = "org.freedesktop.systemd1.Unit";
- const char *property = "ActiveState";
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_free_ char *path = NULL;
- DBusMessageIter iter, sub;
const char *state;
- DBusError error;
int r;
assert(manager);
assert(unit);
- dbus_error_init(&error);
-
path = unit_dbus_path_from_name(unit);
if (!path)
return -ENOMEM;
- r = bus_method_call_with_reply(
+ r = sd_bus_get_property(
manager->bus,
"org.freedesktop.systemd1",
path,
- "org.freedesktop.DBus.Properties",
- "Get",
- &reply,
+ "org.freedesktop.systemd1.Unit",
+ "ActiveState",
&error,
- DBUS_TYPE_STRING, &interface,
- DBUS_TYPE_STRING, &property,
- DBUS_TYPE_INVALID);
+ &reply,
+ "s");
if (r < 0) {
- if (dbus_error_has_name(&error, DBUS_ERROR_NO_REPLY) ||
- dbus_error_has_name(&error, DBUS_ERROR_DISCONNECTED)) {
- /* systemd might have droppped off
- * momentarily, let's not make this an
- * error */
-
- dbus_error_free(&error);
+ /* systemd might have droppped off momentarily, let's
+ * not make this an error */
+ if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
+ sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
return true;
- }
- if (dbus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
- dbus_error_has_name(&error, BUS_ERROR_LOAD_FAILED)) {
- /* If the unit is already unloaded then it's
- * not active */
-
- dbus_error_free(&error);
+ /* If the unit is already unloaded then it's not
+ * active */
+ if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
+ sd_bus_error_has_name(&error, BUS_ERROR_LOAD_FAILED))
return false;
- }
- log_error("Failed to query ActiveState: %s", bus_error(&error, r));
- dbus_error_free(&error);
return r;
}
- if (!dbus_message_iter_init(reply, &iter) ||
- dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
- log_error("Failed to parse reply.");
+ r = sd_bus_message_read(reply, "s", &state);
+ if (r < 0)
return -EINVAL;
- }
- dbus_message_iter_recurse(&iter, &sub);
- if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
- log_error("Failed to parse reply.");
- return -EINVAL;
+ return !streq(state, "inactive") && !streq(state, "failed");
+}
+
+int manager_job_is_active(Manager *manager, const char *path) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+ int r;
+
+ assert(manager);
+ assert(path);
+
+ r = sd_bus_get_property(
+ manager->bus,
+ "org.freedesktop.systemd1",
+ path,
+ "org.freedesktop.systemd1.Job",
+ "State",
+ &error,
+ &reply,
+ "s");
+ if (r < 0) {
+ if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
+ sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
+ return true;
+
+ if (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT))
+ return false;
+
+ return r;
}
- dbus_message_iter_get_basic(&sub, &state);
+ /* We don't actually care about the state really. The fact
+ * that we could read the job state is enough for us */
- return !streq(state, "inactive") && !streq(state, "failed");
+ return true;
}
diff --git a/src/login/logind-device.c b/src/login/logind-device.c
index 9ff91ba..c5fe92b 100644
--- a/src/login/logind-device.c
+++ b/src/login/logind-device.c
@@ -22,8 +22,8 @@
#include <assert.h>
#include <string.h>
-#include "logind-device.h"
#include "util.h"
+#include "logind-device.h"
Device* device_new(Manager *m, const char *sysfs, bool master) {
Device *d;
@@ -68,6 +68,7 @@ void device_free(Device *d) {
void device_detach(Device *d) {
Seat *s;
SessionDevice *sd;
+
assert(d);
if (!d->seat)
@@ -82,7 +83,7 @@ void device_detach(Device *d) {
if (!seat_has_master_device(s)) {
seat_add_to_gc_queue(s);
- seat_send_changed(s, "CanGraphical\0");
+ seat_send_changed(s, "CanGraphical", NULL);
}
}
@@ -121,5 +122,5 @@ void device_attach(Device *d, Seat *s) {
}
if (!had_master && d->master)
- seat_send_changed(s, "CanGraphical\0");
+ seat_send_changed(s, "CanGraphical", NULL);
}
diff --git a/src/login/logind-inhibit.c b/src/login/logind-inhibit.c
index e770883..3bc4642 100644
--- a/src/login/logind-inhibit.c
+++ b/src/login/logind-inhibit.c
@@ -21,7 +21,6 @@
#include <errno.h>
#include <fcntl.h>
-#include <sys/epoll.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
@@ -64,12 +63,13 @@ Inhibitor* inhibitor_new(Manager *m, const char* id) {
void inhibitor_free(Inhibitor *i) {
assert(i);
- free(i->who);
- free(i->why);
-
hashmap_remove(i->manager->inhibitors, i->id);
+
inhibitor_remove_fifo(i);
+ free(i->who);
+ free(i->why);
+
if (i->state_file) {
unlink(i->state_file);
free(i->state_file);
@@ -79,9 +79,9 @@ void inhibitor_free(Inhibitor *i) {
}
int inhibitor_save(Inhibitor *i) {
- char *temp_path, *cc;
+ _cleanup_free_ char *temp_path = NULL;
+ _cleanup_fclose_ FILE *f = NULL;
int r;
- FILE *f;
assert(i);
@@ -107,23 +107,23 @@ int inhibitor_save(Inhibitor *i) {
(unsigned long) i->pid);
if (i->who) {
+ _cleanup_free_ char *cc = NULL;
+
cc = cescape(i->who);
if (!cc)
r = -ENOMEM;
- else {
+ else
fprintf(f, "WHO=%s\n", cc);
- free(cc);
- }
}
if (i->why) {
+ _cleanup_free_ char *cc = NULL;
+
cc = cescape(i->why);
if (!cc)
r = -ENOMEM;
- else {
+ else
fprintf(f, "WHY=%s\n", cc);
- free(cc);
- }
}
if (i->fifo_path)
@@ -137,9 +137,6 @@ int inhibitor_save(Inhibitor *i) {
unlink(temp_path);
}
- fclose(f);
- free(temp_path);
-
finish:
if (r < 0)
log_error("Failed to save inhibit data for %s: %s", i->id, strerror(-r));
@@ -164,7 +161,7 @@ int inhibitor_start(Inhibitor *i) {
i->started = true;
- manager_send_changed(i->manager, i->mode == INHIBIT_BLOCK ? "BlockInhibited\0" : "DelayInhibited\0");
+ manager_send_changed(i->manager, i->mode == INHIBIT_BLOCK ? "BlockInhibited" : "DelayInhibited", NULL);
return 0;
}
@@ -183,16 +180,14 @@ int inhibitor_stop(Inhibitor *i) {
i->started = false;
- manager_send_changed(i->manager, i->mode == INHIBIT_BLOCK ? "BlockInhibited\0" : "DelayInhibited\0");
+ manager_send_changed(i->manager, i->mode == INHIBIT_BLOCK ? "BlockInhibited" : "DelayInhibited", NULL);
return 0;
}
int inhibitor_load(Inhibitor *i) {
- InhibitWhat w;
- InhibitMode mm;
- int r;
- char *cc,
+
+ _cleanup_free_ char
*what = NULL,
*uid = NULL,
*pid = NULL,
@@ -200,6 +195,11 @@ int inhibitor_load(Inhibitor *i) {
*why = NULL,
*mode = NULL;
+ InhibitWhat w;
+ InhibitMode mm;
+ char *cc;
+ int r;
+
r = parse_env_file(i->state_file, NEWLINE,
"WHAT", &what,
"UID", &uid,
@@ -210,7 +210,7 @@ int inhibitor_load(Inhibitor *i) {
"FIFO", &i->fifo_path,
NULL);
if (r < 0)
- goto finish;
+ return r;
w = what ? inhibit_what_from_string(what) : 0;
if (w >= 0)
@@ -223,21 +223,19 @@ int inhibitor_load(Inhibitor *i) {
if (uid) {
r = parse_uid(uid, &i->uid);
if (r < 0)
- goto finish;
+ return r;
}
if (pid) {
r = parse_pid(pid, &i->pid);
if (r < 0)
- goto finish;
+ return r;
}
if (who) {
cc = cunescape(who);
- if (!cc) {
- r = -ENOMEM;
- goto finish;
- }
+ if (!cc)
+ return -ENOMEM;
free(i->who);
i->who = cc;
@@ -245,10 +243,8 @@ int inhibitor_load(Inhibitor *i) {
if (why) {
cc = cunescape(why);
- if (!cc) {
- r = -ENOMEM;
- goto finish;
- }
+ if (!cc)
+ return -ENOMEM;
free(i->why);
i->why = cc;
@@ -262,14 +258,20 @@ int inhibitor_load(Inhibitor *i) {
close_nointr_nofail(fd);
}
-finish:
- free(what);
- free(uid);
- free(pid);
- free(who);
- free(why);
+ return 0;
+}
- return r;
+static int inhibitor_dispatch_fifo(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+ Inhibitor *i = userdata;
+
+ assert(s);
+ assert(fd == i->fifo_fd);
+ assert(i);
+
+ inhibitor_stop(i);
+ inhibitor_free(i);
+
+ return 0;
}
int inhibitor_create_fifo(Inhibitor *i) {
@@ -283,7 +285,8 @@ int inhibitor_create_fifo(Inhibitor *i) {
if (r < 0)
return r;
- if (asprintf(&i->fifo_path, "/run/systemd/inhibit/%s.ref", i->id) < 0)
+ i->fifo_path = strjoin("/run/systemd/inhibit/", i->id, ".ref", NULL);
+ if (!i->fifo_path)
return -ENOMEM;
if (mkfifo(i->fifo_path, 0600) < 0 && errno != EEXIST)
@@ -292,21 +295,19 @@ int inhibitor_create_fifo(Inhibitor *i) {
/* Open reading side */
if (i->fifo_fd < 0) {
- struct epoll_event ev = {};
-
i->fifo_fd = open(i->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
if (i->fifo_fd < 0)
return -errno;
+ }
- r = hashmap_put(i->manager->inhibitor_fds, INT_TO_PTR(i->fifo_fd + 1), i);
+ if (!i->event_source) {
+ r = sd_event_add_io(i->manager->event, i->fifo_fd, 0, inhibitor_dispatch_fifo, i, &i->event_source);
if (r < 0)
return r;
- ev.events = 0;
- ev.data.u32 = FD_OTHER_BASE + i->fifo_fd;
-
- if (epoll_ctl(i->manager->epoll_fd, EPOLL_CTL_ADD, i->fifo_fd, &ev) < 0)
- return -errno;
+ r = sd_event_source_set_priority(i->event_source, SD_PRIORITY_IDLE);
+ if (r < 0)
+ return r;
}
/* Open writing side */
@@ -320,9 +321,10 @@ int inhibitor_create_fifo(Inhibitor *i) {
void inhibitor_remove_fifo(Inhibitor *i) {
assert(i);
+ if (i->event_source)
+ i->event_source = sd_event_source_unref(i->event_source);
+
if (i->fifo_fd >= 0) {
- assert_se(hashmap_remove(i->manager->inhibitor_fds, INT_TO_PTR(i->fifo_fd + 1)) == i);
- assert_se(epoll_ctl(i->manager->epoll_fd, EPOLL_CTL_DEL, i->fifo_fd, NULL) == 0);
close_nointr_nofail(i->fifo_fd);
i->fifo_fd = -1;
}
@@ -341,7 +343,7 @@ InhibitWhat manager_inhibit_what(Manager *m, InhibitMode mm) {
assert(m);
- HASHMAP_FOREACH(i, m->inhibitor_fds, j)
+ HASHMAP_FOREACH(i, m->inhibitors, j)
if (i->mode == mm)
what |= i->what;
@@ -381,7 +383,7 @@ bool manager_is_inhibited(
assert(m);
assert(w > 0 && w < _INHIBIT_WHAT_MAX);
- HASHMAP_FOREACH(i, m->inhibitor_fds, j) {
+ HASHMAP_FOREACH(i, m->inhibitors, j) {
if (!(i->what & w))
continue;
diff --git a/src/login/logind-inhibit.h b/src/login/logind-inhibit.h
index 4c158ee..ed3b2eb 100644
--- a/src/login/logind-inhibit.h
+++ b/src/login/logind-inhibit.h
@@ -52,6 +52,8 @@ typedef enum InhibitMode {
struct Inhibitor {
Manager *manager;
+ sd_event_source *event_source;
+
char *id;
char *state_file;
diff --git a/src/login/logind-seat-dbus.c b/src/login/logind-seat-dbus.c
index 230f7f0..e9f8d26 100644
--- a/src/login/logind-seat-dbus.c
+++ b/src/login/logind-seat-dbus.c
@@ -22,373 +22,328 @@
#include <errno.h>
#include <string.h>
+#include "util.h"
+#include "bus-util.h"
+#include "strv.h"
#include "logind.h"
#include "logind-seat.h"
-#include "dbus-common.h"
-#include "util.h"
-#define BUS_SEAT_INTERFACE \
- " <interface name=\"org.freedesktop.login1.Seat\">\n" \
- " <method name=\"Terminate\"/>\n" \
- " <method name=\"ActivateSession\">\n" \
- " <arg name=\"id\" type=\"s\"/>\n" \
- " </method>\n" \
- " <property name=\"Id\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"ActiveSession\" type=\"so\" access=\"read\"/>\n" \
- " <property name=\"CanMultiSession\" type=\"b\" access=\"read\"/>\n" \
- " <property name=\"CanTTY\" type=\"b\" access=\"read\"/>\n" \
- " <property name=\"CanGraphical\" type=\"b\" access=\"read\"/>\n" \
- " <property name=\"Sessions\" type=\"a(so)\" access=\"read\"/>\n" \
- " <property name=\"IdleHint\" type=\"b\" access=\"read\"/>\n" \
- " <property name=\"IdleSinceHint\" type=\"t\" access=\"read\"/>\n" \
- " <property name=\"IdleSinceHintMonotonic\" type=\"t\" access=\"read\"/>\n" \
- " </interface>\n" \
-
-#define INTROSPECTION \
- DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
- "<node>\n" \
- BUS_SEAT_INTERFACE \
- BUS_PROPERTIES_INTERFACE \
- BUS_PEER_INTERFACE \
- BUS_INTROSPECTABLE_INTERFACE \
- "</node>\n"
-
-#define INTERFACES_LIST \
- BUS_GENERIC_INTERFACES_LIST \
- "org.freedesktop.login1.Seat\0"
-
-static int bus_seat_append_active(DBusMessageIter *i, const char *property, void *data) {
- DBusMessageIter sub;
- Seat *s = data;
- const char *id, *path;
+static int property_get_active_session(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
_cleanup_free_ char *p = NULL;
+ Seat *s = userdata;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(reply);
assert(s);
- if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
+ p = s->active ? session_bus_path(s->active) : strdup("/");
+ if (!p)
return -ENOMEM;
- if (s->active) {
- id = s->active->id;
- path = p = session_bus_path(s->active);
+ return sd_bus_message_append(reply, "(so)", s->active ? s->active->id : "", p);
+}
- if (!p)
- return -ENOMEM;
- } else {
- id = "";
- path = "/";
- }
+static int property_get_can_multi_session(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
- if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &id) ||
- !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &path))
- return -ENOMEM;
+ Seat *s = userdata;
- if (!dbus_message_iter_close_container(i, &sub))
- return -ENOMEM;
+ assert(bus);
+ assert(reply);
+ assert(s);
- return 0;
+ return sd_bus_message_append(reply, "b", seat_can_multi_session(s));
}
-static int bus_seat_append_sessions(DBusMessageIter *i, const char *property, void *data) {
- DBusMessageIter sub, sub2;
- Seat *s = data;
+static int property_get_can_tty(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ Seat *s = userdata;
+
+ assert(bus);
+ assert(reply);
+ assert(s);
+
+ return sd_bus_message_append(reply, "b", seat_can_tty(s));
+}
+
+static int property_get_can_graphical(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ Seat *s = userdata;
+
+ assert(bus);
+ assert(reply);
+ assert(s);
+
+ return sd_bus_message_append(reply, "b", seat_can_tty(s));
+}
+
+static int property_get_sessions(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ Seat *s = userdata;
Session *session;
+ int r;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(reply);
assert(s);
- if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(so)", &sub))
- return -ENOMEM;
+ r = sd_bus_message_open_container(reply, 'a', "(so)");
+ if (r < 0)
+ return r;
LIST_FOREACH(sessions_by_seat, session, s->sessions) {
_cleanup_free_ char *p = NULL;
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
- return -ENOMEM;
-
p = session_bus_path(session);
if (!p)
return -ENOMEM;
- if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &session->id) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p))
- return -ENOMEM;
+ r = sd_bus_message_append(reply, "(so)", session->id, p);
+ if (r < 0)
+ return r;
- if (!dbus_message_iter_close_container(&sub, &sub2))
- return -ENOMEM;
}
- if (!dbus_message_iter_close_container(i, &sub))
- return -ENOMEM;
+ r = sd_bus_message_close_container(reply);
+ if (r < 0)
+ return r;
- return 0;
+ return 1;
}
-static int bus_seat_append_can_multi_session(DBusMessageIter *i, const char *property, void *data) {
- Seat *s = data;
- dbus_bool_t b;
-
- assert(i);
- assert(property);
- assert(s);
-
- b = seat_can_multi_session(s);
-
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
- return -ENOMEM;
-
- return 0;
-}
+static int property_get_idle_hint(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
-static int bus_seat_append_can_tty(DBusMessageIter *i, const char *property, void *data) {
- Seat *s = data;
- dbus_bool_t b;
+ Seat *s = userdata;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(reply);
assert(s);
- b = seat_can_tty(s);
-
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
- return -ENOMEM;
-
- return 0;
+ return sd_bus_message_append(reply, "b", seat_get_idle_hint(s, NULL) > 0);
}
-static int bus_seat_append_can_graphical(DBusMessageIter *i, const char *property, void *data) {
- Seat *s = data;
- dbus_bool_t b;
+static int property_get_idle_since_hint(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ Seat *s = userdata;
+ dual_timestamp t;
+ uint64_t u;
+ int r;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(reply);
assert(s);
- b = seat_can_graphical(s);
+ r = seat_get_idle_hint(s, &t);
+ if (r < 0)
+ return r;
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
- return -ENOMEM;
+ u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
- return 0;
+ return sd_bus_message_append(reply, "t", u);
}
-static int bus_seat_append_idle_hint(DBusMessageIter *i, const char *property, void *data) {
- Seat *s = data;
- dbus_bool_t b;
+static int method_terminate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Seat *s = userdata;
+ int r;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(message);
assert(s);
- b = seat_get_idle_hint(s, NULL) > 0;
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
- return -ENOMEM;
+ r = seat_stop_sessions(s);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- return 0;
+ return sd_bus_reply_method_return(bus, message, NULL);
}
-static int bus_seat_append_idle_hint_since(DBusMessageIter *i, const char *property, void *data) {
- Seat *s = data;
- dual_timestamp t;
- uint64_t k;
+static int method_activate_session(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Seat *s = userdata;
+ const char *name;
+ Session *session;
+ int r;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(message);
assert(s);
- seat_get_idle_hint(s, &t);
- k = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
+ r = sd_bus_message_read(message, "s", &name);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &k))
- return -ENOMEM;
+ session = hashmap_get(s->manager->sessions, name);
+ if (!session)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
- return 0;
-}
+ if (session->seat != s)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_SESSION_NOT_ON_SEAT, "Session %s not on seat %s", name, s->id);
-static int get_seat_for_path(Manager *m, const char *path, Seat **_s) {
- _cleanup_free_ char *id = NULL;
- Seat *s;
+ r = session_activate(session);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- assert(m);
- assert(path);
- assert(_s);
-
- if (!startswith(path, "/org/freedesktop/login1/seat/"))
- return -EINVAL;
-
- id = bus_path_unescape(path + 29);
- if (!id)
- return -ENOMEM;
-
- s = hashmap_get(m->seats, id);
- if (!s)
- return -ENOENT;
-
- *_s = s;
- return 0;
+ return sd_bus_reply_method_return(bus, message, NULL);
}
-static const BusProperty bus_login_seat_properties[] = {
- { "Id", bus_property_append_string, "s", offsetof(Seat, id), true },
- { "ActiveSession", bus_seat_append_active, "(so)", 0 },
- { "CanMultiSession", bus_seat_append_can_multi_session, "b", 0 },
- { "CanTTY", bus_seat_append_can_tty, "b", 0 },
- { "CanGraphical", bus_seat_append_can_graphical, "b", 0 },
- { "Sessions", bus_seat_append_sessions, "a(so)", 0 },
- { "IdleHint", bus_seat_append_idle_hint, "b", 0 },
- { "IdleSinceHint", bus_seat_append_idle_hint_since, "t", 0 },
- { "IdleSinceHintMonotonic", bus_seat_append_idle_hint_since, "t", 0 },
- { NULL, }
-};
-
-static DBusHandlerResult seat_message_dispatch(
- Seat *s,
- DBusConnection *connection,
- DBusMessage *message) {
-
- DBusError error;
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
- int r;
+const sd_bus_vtable seat_vtable[] = {
+ SD_BUS_VTABLE_START(0),
- assert(s);
- assert(connection);
- assert(message);
+ SD_BUS_PROPERTY("Id", "s", NULL, offsetof(Seat, id), 0),
+ SD_BUS_PROPERTY("ActiveSession", "(so)", property_get_active_session, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("CanMultiSession", "b", property_get_can_multi_session, 0, 0),
+ SD_BUS_PROPERTY("CanTTY", "b", property_get_can_tty, 0, 0),
+ SD_BUS_PROPERTY("CanGraphical", "b", property_get_can_graphical, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("Sessions", "a(so)", property_get_sessions, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
- dbus_error_init(&error);
+ SD_BUS_METHOD("Terminate", NULL, NULL, method_terminate, 0),
+ SD_BUS_METHOD("ActivateSession", "s", NULL, method_activate_session, 0),
- if (dbus_message_is_method_call(message, "org.freedesktop.login1.Seat", "Terminate")) {
+ SD_BUS_VTABLE_END
+};
- r = seat_stop_sessions(s);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
+int seat_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *userdata) {
+ _cleanup_free_ char *e = NULL;
+ Manager *m = userdata;
+ Seat *seat;
+ const char *p;
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
+ assert(bus);
+ assert(path);
+ assert(interface);
+ assert(found);
+ assert(m);
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Seat", "ActivateSession")) {
- const char *name;
- Session *session;
+ p = startswith(path, "/org/freedesktop/login1/seat/");
+ if (!p)
+ return 0;
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &name,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+ e = bus_path_unescape(p);
+ if (!e)
+ return -ENOMEM;
- session = hashmap_get(s->manager->sessions, name);
- if (!session || session->seat != s)
- return bus_send_error_reply(connection, message, &error, -ENOENT);
+ seat = hashmap_get(m->seats, e);
+ if (!seat)
+ return 0;
- r = session_activate(session);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
- } else {
- const BusBoundProperties bps[] = {
- { "org.freedesktop.login1.Seat", bus_login_seat_properties, s },
- { NULL, }
- };
- return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
- }
+ *found = seat;
+ return 1;
+}
- if (reply) {
- if (!bus_maybe_send_reply(connection, message, reply))
- goto oom;
- }
+char *seat_bus_path(Seat *s) {
+ _cleanup_free_ char *t = NULL;
- return DBUS_HANDLER_RESULT_HANDLED;
+ assert(s);
-oom:
- dbus_error_free(&error);
+ t = bus_path_escape(s->id);
+ if (!t)
+ return NULL;
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
+ return strappend("/org/freedesktop/login1/seat/", t);
}
-static DBusHandlerResult seat_message_handler(
- DBusConnection *connection,
- DBusMessage *message,
- void *userdata) {
-
+int seat_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata) {
+ _cleanup_strv_free_ char **l = NULL;
Manager *m = userdata;
- Seat *s;
+ Seat *seat;
+ Iterator i;
int r;
- r = get_seat_for_path(m, dbus_message_get_path(message), &s);
- if (r < 0) {
+ assert(bus);
+ assert(path);
+ assert(nodes);
- if (r == -ENOMEM)
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
+ HASHMAP_FOREACH(seat, m->seats, i) {
+ char *p;
- if (r == -ENOENT) {
- DBusError e;
+ p = seat_bus_path(seat);
+ if (!p)
+ return -ENOMEM;
- dbus_error_init(&e);
- dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown seat");
- return bus_send_error_reply(connection, message, &e, r);
+ r = strv_push(&l, p);
+ if (r < 0) {
+ free(p);
+ return r;
}
-
- return bus_send_error_reply(connection, message, NULL, r);
}
- return seat_message_dispatch(s, connection, message);
-}
-
-const DBusObjectPathVTable bus_seat_vtable = {
- .message_function = seat_message_handler
-};
-
-char *seat_bus_path(Seat *s) {
- _cleanup_free_ char *t = NULL;
-
- assert(s);
-
- t = bus_path_escape(s->id);
- if (!t)
- return NULL;
+ *nodes = l;
+ l = NULL;
- return strappend("/org/freedesktop/login1/seat/", t);
+ return 1;
}
int seat_send_signal(Seat *s, bool new_seat) {
- _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
_cleanup_free_ char *p = NULL;
assert(s);
- m = dbus_message_new_signal("/org/freedesktop/login1",
- "org.freedesktop.login1.Manager",
- new_seat ? "SeatNew" : "SeatRemoved");
- if (!m)
- return -ENOMEM;
-
p = seat_bus_path(s);
if (!p)
return -ENOMEM;
- if (!dbus_message_append_args(
- m,
- DBUS_TYPE_STRING, &s->id,
- DBUS_TYPE_OBJECT_PATH, &p,
- DBUS_TYPE_INVALID))
- return -ENOMEM;
-
- if (!dbus_connection_send(s->manager->bus, m, NULL))
- return -ENOMEM;
-
- return 0;
+ return sd_bus_emit_signal(
+ s->manager->bus,
+ "/org/freedesktop/login1",
+ "org.freedesktop.login1.Manager",
+ new_seat ? "SeatNew" : "SeatRemoved",
+ "so", s->id, p);
}
-int seat_send_changed(Seat *s, const char *properties) {
- _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
+int seat_send_changed(Seat *s, const char *properties, ...) {
_cleanup_free_ char *p = NULL;
+ char **l;
assert(s);
@@ -399,12 +354,7 @@ int seat_send_changed(Seat *s, const char *properties) {
if (!p)
return -ENOMEM;
- m = bus_properties_changed_new(p, "org.freedesktop.login1.Seat", properties);
- if (!m)
- return -ENOMEM;
-
- if (!dbus_connection_send(s->manager->bus, m, NULL))
- return -ENOMEM;
+ l = strv_from_stdarg_alloca(properties);
- return 0;
+ return sd_bus_emit_properties_changed_strv(s->manager->bus, p, "org.freedesktop.login1.Seat", l);
}
diff --git a/src/login/logind-seat.c b/src/login/logind-seat.c
index 6f3299b..b30c4ce 100644
--- a/src/login/logind-seat.c
+++ b/src/login/logind-seat.c
@@ -27,8 +27,8 @@
#include <linux/vt.h>
#include <string.h>
-#include "systemd/sd-id128.h"
-#include "systemd/sd-messages.h"
+#include "sd-id128.h"
+#include "sd-messages.h"
#include "logind-seat.h"
#include "logind-acl.h"
#include "util.h"
@@ -84,9 +84,9 @@ void seat_free(Seat *s) {
}
int seat_save(Seat *s) {
+ _cleanup_free_ char *temp_path = NULL;
+ _cleanup_fclose_ FILE *f = NULL;
int r;
- FILE *f;
- char *temp_path;
assert(s);
@@ -151,9 +151,6 @@ int seat_save(Seat *s) {
unlink(temp_path);
}
- fclose(f);
- free(temp_path);
-
finish:
if (r < 0)
log_error("Failed to save seat data for %s: %s", s->id, strerror(-r));
@@ -170,8 +167,8 @@ int seat_load(Seat *s) {
}
static int vt_allocate(int vtnr) {
- int fd, r;
- char *p;
+ _cleanup_free_ char *p = NULL;
+ _cleanup_close_ int fd = -1;
assert(vtnr >= 1);
@@ -179,14 +176,10 @@ static int vt_allocate(int vtnr) {
return -ENOMEM;
fd = open_terminal(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
- free(p);
-
- r = fd < 0 ? -errno : 0;
+ if (fd < 0)
+ return -errno;
- if (fd >= 0)
- close_nointr_nofail(fd);
-
- return r;
+ return 0;
}
int seat_preallocate_vts(Seat *s) {
@@ -248,18 +241,18 @@ int seat_set_active(Seat *s, Session *session) {
if (old_active) {
session_device_pause_all(old_active);
- session_send_changed(old_active, "Active\0");
+ session_send_changed(old_active, "Active", NULL);
}
seat_apply_acls(s, old_active);
if (session && session->started) {
- session_send_changed(session, "Active\0");
+ session_send_changed(session, "Active", NULL);
session_device_resume_all(session);
}
if (!session || session->started)
- seat_send_changed(s, "ActiveSession\0");
+ seat_send_changed(s, "ActiveSession", NULL);
seat_save(s);
@@ -417,7 +410,7 @@ int seat_attach_session(Seat *s, Session *session) {
session->seat = s;
LIST_PREPEND(sessions_by_seat, s->sessions, session);
- seat_send_changed(s, "Sessions\0");
+ seat_send_changed(s, "Sessions", NULL);
/* On seats with VTs, the VT logic defines which session is active. On
* seats without VTs, we automatically activate the first session. */
@@ -515,14 +508,14 @@ int seat_get_idle_hint(Seat *s, dual_timestamp *t) {
return idle_hint;
}
-int seat_check_gc(Seat *s, bool drop_not_started) {
+bool seat_check_gc(Seat *s, bool drop_not_started) {
assert(s);
if (drop_not_started && !s->started)
- return 0;
+ return false;
if (seat_is_seat0(s))
- return 1;
+ return true;
return seat_has_master_device(s);
}
diff --git a/src/login/logind-seat.h b/src/login/logind-seat.h
index be6db6e..0547dec 100644
--- a/src/login/logind-seat.h
+++ b/src/login/logind-seat.h
@@ -75,13 +75,16 @@ int seat_start(Seat *s);
int seat_stop(Seat *s);
int seat_stop_sessions(Seat *s);
-int seat_check_gc(Seat *s, bool drop_not_started);
+bool seat_check_gc(Seat *s, bool drop_not_started);
void seat_add_to_gc_queue(Seat *s);
bool seat_name_is_valid(const char *name);
-char *seat_bus_path(Seat *s);
-extern const DBusObjectPathVTable bus_seat_vtable;
+extern const sd_bus_vtable seat_vtable[];
+
+int seat_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata);
+int seat_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *seatdata);
+char *seat_bus_path(Seat *s);
int seat_send_signal(Seat *s, bool new_seat);
-int seat_send_changed(Seat *s, const char *properties);
+int seat_send_changed(Seat *s, const char *properties, ...) _sentinel_;
diff --git a/src/login/logind-session-dbus.c b/src/login/logind-session-dbus.c
index be4e01c..cda6a0a 100644
--- a/src/login/logind-session-dbus.c
+++ b/src/login/logind-session-dbus.c
@@ -22,191 +22,151 @@
#include <errno.h>
#include <string.h>
+#include "util.h"
+#include "strv.h"
+#include "bus-util.h"
+
#include "logind.h"
#include "logind-session.h"
#include "logind-session-device.h"
-#include "dbus-common.h"
-#include "util.h"
-#define BUS_SESSION_INTERFACE \
- " <interface name=\"org.freedesktop.login1.Session\">\n" \
- " <method name=\"Terminate\"/>\n" \
- " <method name=\"Activate\"/>\n" \
- " <method name=\"Lock\"/>\n" \
- " <method name=\"Unlock\"/>\n" \
- " <method name=\"SetIdleHint\">\n" \
- " <arg name=\"b\" type=\"b\"/>\n" \
- " </method>\n" \
- " <method name=\"Kill\">\n" \
- " <arg name=\"who\" type=\"s\"/>\n" \
- " <arg name=\"signal\" type=\"s\"/>\n" \
- " </method>\n" \
- " <method name=\"TakeControl\">\n" \
- " <arg name=\"force\" type=\"b\"/>\n" \
- " </method>\n" \
- " <method name=\"ReleaseControl\"/>\n" \
- " <method name=\"TakeDevice\">\n" \
- " <arg name=\"major\" type=\"u\" direction=\"in\"/>\n" \
- " <arg name=\"minor\" type=\"u\" direction=\"in\"/>\n" \
- " <arg name=\"fd\" type=\"h\" direction=\"out\"/>\n" \
- " <arg name=\"paused\" type=\"b\" direction=\"out\"/>\n" \
- " </method>\n" \
- " <method name=\"ReleaseDevice\">\n" \
- " <arg name=\"major\" type=\"u\"/>\n" \
- " <arg name=\"minor\" type=\"u\"/>\n" \
- " </method>\n" \
- " <method name=\"PauseDeviceComplete\">\n" \
- " <arg name=\"major\" type=\"u\"/>\n" \
- " <arg name=\"minor\" type=\"u\"/>\n" \
- " </method>\n" \
- " <signal name=\"PauseDevice\">\n" \
- " <arg name=\"major\" type=\"u\"/>\n" \
- " <arg name=\"minor\" type=\"u\"/>\n" \
- " <arg name=\"type\" type=\"s\"/>\n" \
- " </signal>\n" \
- " <signal name=\"ResumeDevice\">\n" \
- " <arg name=\"major\" type=\"u\"/>\n" \
- " <arg name=\"minor\" type=\"u\"/>\n" \
- " <arg name=\"fd\" type=\"h\"/>\n" \
- " </signal>\n" \
- " <signal name=\"Lock\"/>\n" \
- " <signal name=\"Unlock\"/>\n" \
- " <property name=\"Id\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"User\" type=\"(uo)\" access=\"read\"/>\n" \
- " <property name=\"Name\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Timestamp\" type=\"t\" access=\"read\"/>\n" \
- " <property name=\"TimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
- " <property name=\"VTNr\" type=\"u\" access=\"read\"/>\n" \
- " <property name=\"Seat\" type=\"(so)\" access=\"read\"/>\n" \
- " <property name=\"TTY\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Display\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Remote\" type=\"b\" access=\"read\"/>\n" \
- " <property name=\"RemoteHost\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"RemoteUser\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Service\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Scope\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Leader\" type=\"u\" access=\"read\"/>\n" \
- " <property name=\"Audit\" type=\"u\" access=\"read\"/>\n" \
- " <property name=\"Type\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Class\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Active\" type=\"b\" access=\"read\"/>\n" \
- " <property name=\"State\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"IdleHint\" type=\"b\" access=\"read\"/>\n" \
- " <property name=\"IdleSinceHint\" type=\"t\" access=\"read\"/>\n" \
- " <property name=\"IdleSinceHintMonotonic\" type=\"t\" access=\"read\"/>\n" \
- " </interface>\n"
-
-#define INTROSPECTION \
- DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
- "<node>\n" \
- BUS_SESSION_INTERFACE \
- BUS_PROPERTIES_INTERFACE \
- BUS_PEER_INTERFACE \
- BUS_INTROSPECTABLE_INTERFACE \
- "</node>\n"
-
-#define INTERFACES_LIST \
- BUS_GENERIC_INTERFACES_LIST \
- "org.freedesktop.login1.Session\0"
-
-static int bus_session_append_seat(DBusMessageIter *i, const char *property, void *data) {
- DBusMessageIter sub;
- Session *s = data;
- const char *id, *path;
- char *p = NULL;
-
- assert(i);
- assert(property);
+static int property_get_user(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ _cleanup_free_ char *p = NULL;
+ Session *s = userdata;
+
+ assert(bus);
+ assert(reply);
assert(s);
- if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
+ p = user_bus_path(s->user);
+ if (!p)
return -ENOMEM;
- if (s->seat) {
- id = s->seat->id;
- path = p = seat_bus_path(s->seat);
+ return sd_bus_message_append(reply, "(uo)", (uint32_t) s->user->uid, p);
+}
- if (!p)
- return -ENOMEM;
- } else {
- id = "";
- path = "/";
- }
+static int property_get_name(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
- if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &id) ||
- !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &path))
- return -ENOMEM;
+ Session *s = userdata;
- if (!dbus_message_iter_close_container(i, &sub))
- return -ENOMEM;
+ assert(bus);
+ assert(reply);
+ assert(s);
- return 0;
+ return sd_bus_message_append(reply, "s", s->user->name);
}
-static int bus_session_append_user(DBusMessageIter *i, const char *property, void *data) {
- DBusMessageIter sub;
- User *u = data;
- _cleanup_free_ char *p = NULL;
+static int property_get_seat(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
- assert(i);
- assert(property);
- assert(u);
+ _cleanup_free_ char *p = NULL;
+ Session *s = userdata;
- if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
- return -ENOMEM;
+ assert(bus);
+ assert(reply);
+ assert(s);
- p = user_bus_path(u);
+ p = s->seat ? seat_bus_path(s->seat) : strdup("/");
if (!p)
return -ENOMEM;
- if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_UINT32, &u->uid) ||
- !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &p))
- return -ENOMEM;
+ return sd_bus_message_append(reply, "(so)", s->seat ? s->seat->id : "", p);
+}
- if (!dbus_message_iter_close_container(i, &sub))
- return -ENOMEM;
+static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_type, session_type, SessionType);
+static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_class, session_class, SessionClass);
- return 0;
-}
+static int property_get_active(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
-static int bus_session_append_active(DBusMessageIter *i, const char *property, void *data) {
- Session *s = data;
- dbus_bool_t b;
+ Session *s = userdata;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(reply);
assert(s);
- b = session_is_active(s);
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
- return -ENOMEM;
-
- return 0;
+ return sd_bus_message_append(reply, "b", session_is_active(s));
}
-static int bus_session_append_idle_hint(DBusMessageIter *i, const char *property, void *data) {
- Session *s = data;
- int b;
+static int property_get_state(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
- assert(i);
- assert(property);
+ Session *s = userdata;
+
+ assert(bus);
+ assert(reply);
assert(s);
- b = session_get_idle_hint(s, NULL) > 0;
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
- return -ENOMEM;
+ return sd_bus_message_append(reply, "s", session_state_to_string(session_get_state(s)));
+}
+
+static int property_get_idle_hint(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
- return 0;
+ Session *s = userdata;
+
+ assert(bus);
+ assert(reply);
+ assert(s);
+
+ return sd_bus_message_append(reply, "b", session_get_idle_hint(s, NULL) > 0);
}
-static int bus_session_append_idle_hint_since(DBusMessageIter *i, const char *property, void *data) {
- Session *s = data;
+static int property_get_idle_since_hint(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ Session *s = userdata;
dual_timestamp t;
uint64_t u;
int r;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(reply);
assert(s);
r = session_get_idle_hint(s, &t);
@@ -215,382 +175,323 @@ static int bus_session_append_idle_hint_since(DBusMessageIter *i, const char *pr
u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
- return -ENOMEM;
-
- return 0;
+ return sd_bus_message_append(reply, "t", u);
}
-static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_session_append_type, session_type, SessionType);
-static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_session_append_class, session_class, SessionClass);
-
-static int bus_session_append_state(DBusMessageIter *i, const char *property, void *data) {
- Session *s = data;
- const char *state;
+static int method_terminate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Session *s = userdata;
+ int r;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(message);
assert(s);
- state = session_state_to_string(session_get_state(s));
-
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state))
- return -ENOMEM;
+ r = session_stop(s);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- return 0;
+ return sd_bus_reply_method_return(bus, message, NULL);
}
-static int get_session_for_path(Manager *m, const char *path, Session **_s) {
- _cleanup_free_ char *id = NULL;
- Session *s;
+static int method_activate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Session *s = userdata;
+ int r;
- assert(m);
- assert(path);
- assert(_s);
+ assert(bus);
+ assert(message);
+ assert(s);
- if (!startswith(path, "/org/freedesktop/login1/session/"))
- return -EINVAL;
+ r = session_activate(s);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- id = bus_path_unescape(path + 32);
- if (!id)
- return -ENOMEM;
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_lock(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Session *s = userdata;
+ int r;
+
+ assert(bus);
+ assert(message);
+ assert(s);
- s = hashmap_get(m->sessions, id);
- if (!s)
- return -ENOENT;
+ r = session_send_lock(s, streq(sd_bus_message_get_member(message), "Lock"));
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- *_s = s;
- return 0;
+ return sd_bus_reply_method_return(bus, message, NULL);
}
-static const BusProperty bus_login_session_properties[] = {
- { "Id", bus_property_append_string, "s", offsetof(Session, id), true },
- { "Timestamp", bus_property_append_usec, "t", offsetof(Session, timestamp.realtime) },
- { "TimestampMonotonic", bus_property_append_usec, "t", offsetof(Session, timestamp.monotonic) },
- { "VTNr", bus_property_append_uint32, "u", offsetof(Session, vtnr) },
- { "Seat", bus_session_append_seat, "(so)", 0 },
- { "TTY", bus_property_append_string, "s", offsetof(Session, tty), true },
- { "Display", bus_property_append_string, "s", offsetof(Session, display), true },
- { "Remote", bus_property_append_bool, "b", offsetof(Session, remote) },
- { "RemoteUser", bus_property_append_string, "s", offsetof(Session, remote_user), true },
- { "RemoteHost", bus_property_append_string, "s", offsetof(Session, remote_host), true },
- { "Service", bus_property_append_string, "s", offsetof(Session, service), true },
- { "Scope", bus_property_append_string, "s", offsetof(Session, scope), true },
- { "Leader", bus_property_append_pid, "u", offsetof(Session, leader) },
- { "Audit", bus_property_append_uint32, "u", offsetof(Session, audit_id) },
- { "Type", bus_session_append_type, "s", offsetof(Session, type) },
- { "Class", bus_session_append_class, "s", offsetof(Session, class) },
- { "Active", bus_session_append_active, "b", 0 },
- { "State", bus_session_append_state, "s", 0 },
- { "IdleHint", bus_session_append_idle_hint, "b", 0 },
- { "IdleSinceHint", bus_session_append_idle_hint_since, "t", 0 },
- { "IdleSinceHintMonotonic", bus_session_append_idle_hint_since, "t", 0 },
- { NULL, }
-};
+static int method_set_idle_hint(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Session *s = userdata;
+ uid_t uid;
+ int r, b;
-static const BusProperty bus_login_session_user_properties[] = {
- { "User", bus_session_append_user, "(uo)", 0 },
- { "Name", bus_property_append_string, "s", offsetof(User, name), true },
- { NULL, }
-};
+ assert(bus);
+ assert(message);
+ assert(s);
+
+ r = sd_bus_message_read(message, "b", &b);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
-static DBusHandlerResult session_message_dispatch(
- Session *s,
- DBusConnection *connection,
- DBusMessage *message) {
+ r = sd_bus_get_owner_uid(bus, sd_bus_message_get_sender(message), &uid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ if (uid != 0 && uid != s->user->uid)
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_ACCESS_DENIED, "Only owner of session my set idle hint");
+
+ session_set_idle_hint(s, b);
- DBusError error;
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
+
+static int method_kill(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Session *s = userdata;
+ const char *swho;
+ int32_t signo;
+ KillWho who;
int r;
- assert(s);
- assert(connection);
+ assert(bus);
assert(message);
+ assert(s);
- dbus_error_init(&error);
+ r = sd_bus_message_read(message, "si", &swho, &signo);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ if (isempty(swho))
+ who = KILL_ALL;
+ else {
+ who = kill_who_from_string(swho);
+ if (who < 0)
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho);
+ }
- if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "Terminate")) {
+ if (signo <= 0 || signo >= _NSIG)
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
- r = session_stop(s);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
+ r = session_kill(s, who, signo);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "Activate")) {
+static int method_take_control(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Session *s = userdata;
+ int r, force;
+ uid_t uid;
- r = session_activate(s);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
+ assert(bus);
+ assert(message);
+ assert(s);
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
+ r = sd_bus_message_read(message, "b", &force);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "Lock") ||
- dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "Unlock")) {
+ r = sd_bus_get_owner_uid(bus, sd_bus_message_get_sender(message), &uid);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- if (session_send_lock(s, streq(dbus_message_get_member(message), "Lock")) < 0)
- goto oom;
+ if (uid != 0 && (force || uid != s->user->uid))
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_ACCESS_DENIED, "Only owner of session may take control");
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
+ r = session_set_controller(s, sd_bus_message_get_sender(message), force);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "SetIdleHint")) {
- dbus_bool_t b;
- unsigned long ul;
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_BOOLEAN, &b,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+static int method_release_control(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Session *s = userdata;
- ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), &error);
- if (ul == (unsigned long) -1)
- return bus_send_error_reply(connection, message, &error, -EIO);
+ assert(bus);
+ assert(message);
+ assert(s);
- if (ul != 0 && ul != s->user->uid)
- return bus_send_error_reply(connection, message, NULL, -EPERM);
+ if (!session_is_controller(s, sd_bus_message_get_sender(message)))
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
- session_set_idle_hint(s, b);
+ session_drop_controller(s);
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "Kill")) {
- const char *swho;
- int32_t signo;
- KillWho who;
+static int method_take_device(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Session *s = userdata;
+ uint32_t major, minor;
+ SessionDevice *sd;
+ dev_t dev;
+ int r;
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_STRING, &swho,
- DBUS_TYPE_INT32, &signo,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+ assert(bus);
+ assert(message);
+ assert(s);
- if (isempty(swho))
- who = KILL_ALL;
- else {
- who = kill_who_from_string(swho);
- if (who < 0)
- return bus_send_error_reply(connection, message, &error, -EINVAL);
- }
+ r = sd_bus_message_read(message, "uu", &major, &minor);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ if (!session_is_controller(s, sd_bus_message_get_sender(message)))
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
+
+ dev = makedev(major, minor);
+ sd = hashmap_get(s->devices, &dev);
+ if (sd)
+ /* We don't allow retrieving a device multiple times.
+ * The related ReleaseDevice call is not ref-counted.
+ * The caller should use dup() if it requires more
+ * than one fd (it would be functionally
+ * equivalent). */
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_DEVICE_IS_TAKEN, "Device already taken");
+
+ r = session_device_new(s, dev, &sd);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- if (signo <= 0 || signo >= _NSIG)
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- r = session_kill(s, who, signo);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "TakeControl")) {
- dbus_bool_t force;
- unsigned long ul;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_BOOLEAN, &force,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), &error);
- if (ul == (unsigned long) -1)
- return bus_send_error_reply(connection, message, &error, -EIO);
-
- if (ul != 0 && (force || ul != s->user->uid))
- return bus_send_error_reply(connection, message, NULL, -EPERM);
-
- r = session_set_controller(s, bus_message_get_sender_with_fallback(message), force);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "ReleaseControl")) {
- const char *sender = bus_message_get_sender_with_fallback(message);
-
- if (!session_is_controller(s, sender))
- return bus_send_error_reply(connection, message, NULL, -EPERM);
-
- session_drop_controller(s);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "TakeDevice")) {
- SessionDevice *sd;
- bool b;
- dbus_bool_t paused;
- uint32_t major, minor;
- dev_t dev;
-
- if (!session_is_controller(s, bus_message_get_sender_with_fallback(message)))
- return bus_send_error_reply(connection, message, NULL, -EPERM);
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_UINT32, &major,
- DBUS_TYPE_UINT32, &minor,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- dev = makedev(major, minor);
- sd = hashmap_get(s->devices, &dev);
- if (sd) {
- /* We don't allow retrieving a device multiple times.
- * The related ReleaseDevice call is not ref-counted.
- * The caller should use dup() if it requires more than
- * one fd (it would be functionally equivalent). */
- return bus_send_error_reply(connection, message, &error, -EBUSY);
- }
+ r = sd_bus_reply_method_return(bus, message, "hb", sd->fd, !sd->active);
+ if (r < 0)
+ session_device_free(sd);
- r = session_device_new(s, dev, &sd);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
+ return r;
+}
- reply = dbus_message_new_method_return(message);
- if (!reply) {
- session_device_free(sd);
- goto oom;
- }
+static int method_release_device(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Session *s = userdata;
+ uint32_t major, minor;
+ SessionDevice *sd;
+ dev_t dev;
+ int r;
- paused = !sd->active;
- b = dbus_message_append_args(
- reply,
- DBUS_TYPE_UNIX_FD, &sd->fd,
- DBUS_TYPE_BOOLEAN, &paused,
- DBUS_TYPE_INVALID);
- if (!b) {
- session_device_free(sd);
- return bus_send_error_reply(connection, message, NULL, -ENOMEM);
- }
+ assert(bus);
+ assert(message);
+ assert(s);
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "ReleaseDevice")) {
- SessionDevice *sd;
- uint32_t major, minor;
- dev_t dev;
+ r = sd_bus_message_read(message, "uu", &major, &minor);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- if (!session_is_controller(s, bus_message_get_sender_with_fallback(message)))
- return bus_send_error_reply(connection, message, NULL, -EPERM);
+ if (!session_is_controller(s, sd_bus_message_get_sender(message)))
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_UINT32, &major,
- DBUS_TYPE_UINT32, &minor,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
+ dev = makedev(major, minor);
+ sd = hashmap_get(s->devices, &dev);
+ if (!sd)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_DEVICE_NOT_TAKEN, "Device not taken");
- dev = makedev(major, minor);
- sd = hashmap_get(s->devices, &dev);
- if (!sd)
- return bus_send_error_reply(connection, message, NULL, -ENODEV);
+ session_device_free(sd);
+ return sd_bus_reply_method_return(bus, message, NULL);
+}
- session_device_free(sd);
+static int method_pause_device_complete(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ Session *s = userdata;
+ uint32_t major, minor;
+ SessionDevice *sd;
+ dev_t dev;
+ int r;
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Session", "PauseDeviceComplete")) {
- SessionDevice *sd;
- uint32_t major, minor;
- dev_t dev;
-
- if (!session_is_controller(s, bus_message_get_sender_with_fallback(message)))
- return bus_send_error_reply(connection, message, NULL, -EPERM);
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_UINT32, &major,
- DBUS_TYPE_UINT32, &minor,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- dev = makedev(major, minor);
- sd = hashmap_get(s->devices, &dev);
- if (!sd)
- return bus_send_error_reply(connection, message, NULL, -ENODEV);
-
- session_device_complete_pause(sd);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else {
- const BusBoundProperties bps[] = {
- { "org.freedesktop.login1.Session", bus_login_session_properties, s },
- { "org.freedesktop.login1.Session", bus_login_session_user_properties, s->user },
- { NULL, }
- };
- return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
- }
+ assert(bus);
+ assert(message);
+ assert(s);
- if (reply) {
- if (!bus_maybe_send_reply(connection, message, reply))
- goto oom;
- }
+ r = sd_bus_message_read(message, "uu", &major, &minor);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
+
+ if (!session_is_controller(s, sd_bus_message_get_sender(message)))
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_NOT_IN_CONTROL, "You are not in control of this session");
- return DBUS_HANDLER_RESULT_HANDLED;
+ dev = makedev(major, minor);
+ sd = hashmap_get(s->devices, &dev);
+ if (!sd)
+ return sd_bus_reply_method_errorf(bus, message, BUS_ERROR_DEVICE_NOT_TAKEN, "Device not taken");
-oom:
- dbus_error_free(&error);
+ session_device_complete_pause(sd);
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
+ return sd_bus_reply_method_return(bus, message, NULL);
}
-static DBusHandlerResult session_message_handler(
- DBusConnection *connection,
- DBusMessage *message,
- void *userdata) {
+const sd_bus_vtable session_vtable[] = {
+ SD_BUS_VTABLE_START(0),
+
+ SD_BUS_PROPERTY("Id", "s", NULL, offsetof(Session, id), 0),
+ SD_BUS_PROPERTY("User", "(uo)", property_get_user, 0, 0),
+ SD_BUS_PROPERTY("Name", "s", property_get_name, 0, 0),
+ SD_BUS_PROPERTY("Timestamp", "t", NULL, offsetof(Session, timestamp.realtime), 0),
+ SD_BUS_PROPERTY("TimestampMonotonic", "t", NULL, offsetof(Session, timestamp.monotonic), 0),
+ SD_BUS_PROPERTY("VTNr", "u", NULL, offsetof(Session, vtnr), 0),
+ SD_BUS_PROPERTY("Seat", "(so)", property_get_seat, 0, 0),
+ SD_BUS_PROPERTY("TTY", "s", NULL, offsetof(Session, tty), 0),
+ SD_BUS_PROPERTY("Display", "s", NULL, offsetof(Session, display), 0),
+ SD_BUS_PROPERTY("Remote", "b", bus_property_get_bool, offsetof(Session, remote), 0),
+ SD_BUS_PROPERTY("RemoteHost", "s", NULL, offsetof(Session, remote_host), 0),
+ SD_BUS_PROPERTY("RemoteUser", "s", NULL, offsetof(Session, remote_user), 0),
+ SD_BUS_PROPERTY("Service", "s", NULL, offsetof(Session, service), 0),
+ SD_BUS_PROPERTY("Scope", "s", NULL, offsetof(Session, scope), 0),
+ SD_BUS_PROPERTY("Leader", "u", bus_property_get_pid, offsetof(Session, leader), 0),
+ SD_BUS_PROPERTY("Audit", "u", NULL, offsetof(Session, audit_id), 0),
+ SD_BUS_PROPERTY("Type", "s", property_get_type, offsetof(Session, type), 0),
+ SD_BUS_PROPERTY("Class", "s", property_get_class, offsetof(Session, class), 0),
+ SD_BUS_PROPERTY("Active", "b", property_get_active, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("State", "s", property_get_state, 0, 0),
+ SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+
+ SD_BUS_METHOD("Terminate", NULL, NULL, method_terminate, 0),
+ SD_BUS_METHOD("Activate", NULL, NULL, method_activate, 0),
+ SD_BUS_METHOD("Lock", NULL, NULL, method_lock, 0),
+ SD_BUS_METHOD("Unlock", NULL, NULL, method_lock, 0),
+ SD_BUS_METHOD("SetIdleHint", "b", NULL, method_set_idle_hint, 0),
+ SD_BUS_METHOD("Kill", "si", NULL, method_kill, 0),
+ SD_BUS_METHOD("TakeControl", "b", NULL, method_take_control, 0),
+ SD_BUS_METHOD("ReleaseControl", NULL, NULL, method_release_control, 0),
+ SD_BUS_METHOD("TakeDevice", "uu", "hb", method_take_device, 0),
+ SD_BUS_METHOD("ReleaseDevice", "uu", NULL, method_release_device, 0),
+ SD_BUS_METHOD("PauseDeviceComplete", "uu", NULL, method_pause_device_complete, 0),
+
+ SD_BUS_SIGNAL("PauseDevice", "uus", 0),
+ SD_BUS_SIGNAL("ResumeDevice", "uuh", 0),
+ SD_BUS_SIGNAL("Lock", NULL, 0),
+ SD_BUS_SIGNAL("Unlock", NULL, 0),
+
+ SD_BUS_VTABLE_END
+};
+int session_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *userdata) {
+ _cleanup_free_ char *e = NULL;
Manager *m = userdata;
- Session *s;
- int r;
-
- r = get_session_for_path(m, dbus_message_get_path(message), &s);
- if (r < 0) {
+ Session *session;
+ const char *p;
- if (r == -ENOMEM)
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
+ assert(bus);
+ assert(path);
+ assert(interface);
+ assert(found);
+ assert(m);
- if (r == -ENOENT) {
- DBusError e;
+ p = startswith(path, "/org/freedesktop/login1/session/");
+ if (!p)
+ return 0;
- dbus_error_init(&e);
- dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown session");
- return bus_send_error_reply(connection, message, &e, r);
- }
+ e = bus_path_unescape(p);
+ if (!e)
+ return -ENOMEM;
- return bus_send_error_reply(connection, message, NULL, r);
- }
+ session = hashmap_get(m->sessions, e);
+ if (!session)
+ return 0;
- return session_message_dispatch(s, connection, message);
+ *found = session;
+ return 1;
}
-const DBusObjectPathVTable bus_session_vtable = {
- .message_function = session_message_handler
-};
-
char *session_bus_path(Session *s) {
_cleanup_free_ char *t = NULL;
@@ -603,39 +504,57 @@ char *session_bus_path(Session *s) {
return strappend("/org/freedesktop/login1/session/", t);
}
+int session_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata) {
+ _cleanup_strv_free_ char **l = NULL;
+ Manager *m = userdata;
+ Session *session;
+ Iterator i;
+ int r;
+
+ assert(bus);
+ assert(path);
+ assert(nodes);
+
+ HASHMAP_FOREACH(session, m->sessions, i) {
+ char *p;
+
+ p = session_bus_path(session);
+ if (!p)
+ return -ENOMEM;
+
+ r = strv_push(&l, p);
+ if (r < 0) {
+ free(p);
+ return r;
+ }
+ }
+
+ *nodes = l;
+ l = NULL;
+
+ return 1;
+}
+
int session_send_signal(Session *s, bool new_session) {
- _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
_cleanup_free_ char *p = NULL;
assert(s);
- m = dbus_message_new_signal("/org/freedesktop/login1",
- "org.freedesktop.login1.Manager",
- new_session ? "SessionNew" : "SessionRemoved");
-
- if (!m)
- return -ENOMEM;
-
p = session_bus_path(s);
if (!p)
return -ENOMEM;
- if (!dbus_message_append_args(
- m,
- DBUS_TYPE_STRING, &s->id,
- DBUS_TYPE_OBJECT_PATH, &p,
- DBUS_TYPE_INVALID))
- return -ENOMEM;
-
- if (!dbus_connection_send(s->manager->bus, m, NULL))
- return -ENOMEM;
-
- return 0;
+ return sd_bus_emit_signal(
+ s->manager->bus,
+ "/org/freedesktop/login1",
+ "org.freedesktop.login1.Manager",
+ new_session ? "SessionNew" : "SessionRemoved",
+ "so", s->id, p);
}
-int session_send_changed(Session *s, const char *properties) {
- _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
+int session_send_changed(Session *s, const char *properties, ...) {
_cleanup_free_ char *p = NULL;
+ char **l;
assert(s);
@@ -646,19 +565,12 @@ int session_send_changed(Session *s, const char *properties) {
if (!p)
return -ENOMEM;
- m = bus_properties_changed_new(p, "org.freedesktop.login1.Session", properties);
- if (!m)
- return -ENOMEM;
-
- if (!dbus_connection_send(s->manager->bus, m, NULL))
- return -ENOMEM;
+ l = strv_from_stdarg_alloca(properties);
- return 0;
+ return sd_bus_emit_properties_changed_strv(s->manager->bus, p, "org.freedesktop.login1.Session", l);
}
int session_send_lock(Session *s, bool lock) {
- _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
- bool b;
_cleanup_free_ char *p = NULL;
assert(s);
@@ -667,16 +579,12 @@ int session_send_lock(Session *s, bool lock) {
if (!p)
return -ENOMEM;
- m = dbus_message_new_signal(p, "org.freedesktop.login1.Session", lock ? "Lock" : "Unlock");
-
- if (!m)
- return -ENOMEM;
-
- b = dbus_connection_send(s->manager->bus, m, NULL);
- if (!b)
- return -ENOMEM;
-
- return 0;
+ return sd_bus_emit_signal(
+ s->manager->bus,
+ p,
+ "org.freedesktop.login1.Session",
+ lock ? "Lock" : "Unlock",
+ NULL);
}
int session_send_lock_all(Manager *m, bool lock) {
@@ -697,80 +605,46 @@ int session_send_lock_all(Manager *m, bool lock) {
return r;
}
-int session_send_create_reply(Session *s, DBusError *error) {
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+int session_send_create_reply(Session *s, sd_bus_error *error) {
+ _cleanup_bus_message_unref_ sd_bus_message *c = NULL;
+ _cleanup_close_ int fifo_fd = -1;
+ _cleanup_free_ char *p = NULL;
assert(s);
- if (!s->create_message)
- return 0;
-
/* This is called after the session scope was successfully
* created, and finishes where bus_manager_create_session()
* left off. */
- if (error) {
- DBusError buffer;
-
- dbus_error_init(&buffer);
+ if (!s->create_message)
+ return 0;
- if (!dbus_error_is_set(error)) {
- dbus_set_error_const(&buffer, DBUS_ERROR_INVALID_ARGS, "Invalid Arguments");
- error = &buffer;
- }
+ c = s->create_message;
+ s->create_message = NULL;
- reply = dbus_message_new_error(s->create_message, error->name, error->message);
- dbus_error_free(&buffer);
-
- if (!reply)
- return log_oom();
- } else {
- _cleanup_close_ int fifo_fd = -1;
- _cleanup_free_ char *path = NULL;
- const char *cseat;
- uint32_t vtnr;
- dbus_bool_t exists;
-
- fifo_fd = session_create_fifo(s);
- if (fifo_fd < 0) {
- log_error("Failed to create fifo: %s", strerror(-fifo_fd));
- return fifo_fd;
- }
+ if (error)
+ return sd_bus_reply_method_error(s->manager->bus, c, error);
- path = session_bus_path(s);
- if (!path)
- return log_oom();
-
- reply = dbus_message_new_method_return(s->create_message);
- if (!reply)
- return log_oom();
-
- cseat = s->seat ? s->seat->id : "";
- vtnr = s->vtnr;
- exists = false;
-
- if (!dbus_message_append_args(
- reply,
- DBUS_TYPE_STRING, &s->id,
- DBUS_TYPE_OBJECT_PATH, &path,
- DBUS_TYPE_STRING, &s->user->runtime_path,
- DBUS_TYPE_UNIX_FD, &fifo_fd,
- DBUS_TYPE_STRING, &cseat,
- DBUS_TYPE_UINT32, &vtnr,
- DBUS_TYPE_BOOLEAN, &exists,
- DBUS_TYPE_INVALID))
- return log_oom();
- }
-
- /* Update the state file before we notify the client about the
- * result */
+ /* Update the session state file before we notify the client
+ * about the result. */
session_save(s);
- if (!dbus_connection_send(s->manager->bus, reply, NULL))
- return log_oom();
+ fifo_fd = session_create_fifo(s);
+ if (fifo_fd < 0)
+ return fifo_fd;
- dbus_message_unref(s->create_message);
- s->create_message = NULL;
+ p = session_bus_path(s);
+ if (!p)
+ return -ENOMEM;
- return 0;
+ return sd_bus_reply_method_return(
+ s->manager->bus, c,
+ "soshsub",
+ s->id,
+ p,
+ s->user->runtime_path,
+ fifo_fd,
+ s->seat ? s->seat->id : "",
+ (uint32_t) s->vtnr,
+ false);
}
diff --git a/src/login/logind-session-device.c b/src/login/logind-session-device.c
index f1578bd..b2ef8cc 100644
--- a/src/login/logind-session-device.c
+++ b/src/login/logind-session-device.c
@@ -30,10 +30,10 @@
#include <sys/types.h>
#include <unistd.h>
-#include "dbus-common.h"
-#include "logind-session-device.h"
#include "util.h"
#include "missing.h"
+#include "bus-util.h"
+#include "logind-session-device.h"
enum SessionDeviceNotifications {
SESSION_DEVICE_RESUME,
@@ -42,11 +42,12 @@ enum SessionDeviceNotifications {
SESSION_DEVICE_RELEASE,
};
-static void session_device_notify(SessionDevice *sd, enum SessionDeviceNotifications type) {
- _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
+static int session_device_notify(SessionDevice *sd, enum SessionDeviceNotifications type) {
+ _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
_cleanup_free_ char *path = NULL;
const char *t = NULL;
uint32_t major, minor;
+ int r;
assert(sd);
@@ -54,29 +55,29 @@ static void session_device_notify(SessionDevice *sd, enum SessionDeviceNotificat
minor = minor(sd->dev);
if (!sd->session->controller)
- return;
+ return 0;
path = session_bus_path(sd->session);
if (!path)
- return;
+ return -ENOMEM;
- m = dbus_message_new_signal(path,
- "org.freedesktop.login1.Session",
- (type == SESSION_DEVICE_RESUME) ? "ResumeDevice" : "PauseDevice");
+ r = sd_bus_message_new_signal(
+ sd->session->manager->bus, path,
+ "org.freedesktop.login1.Session",
+ (type == SESSION_DEVICE_RESUME) ? "ResumeDevice" : "PauseDevice",
+ &m);
if (!m)
- return;
+ return r;
- if (!dbus_message_set_destination(m, sd->session->controller))
- return;
+ r = sd_bus_message_set_destination(m, sd->session->controller);
+ if (r < 0)
+ return r;
switch (type) {
case SESSION_DEVICE_RESUME:
- if (!dbus_message_append_args(m,
- DBUS_TYPE_UINT32, &major,
- DBUS_TYPE_UINT32, &minor,
- DBUS_TYPE_UNIX_FD, &sd->fd,
- DBUS_TYPE_INVALID))
- return;
+ r = sd_bus_message_append(m, "uuh", major, minor, sd->fd);
+ if (r < 0)
+ return r;
break;
case SESSION_DEVICE_TRY_PAUSE:
t = "pause";
@@ -88,17 +89,16 @@ static void session_device_notify(SessionDevice *sd, enum SessionDeviceNotificat
t = "gone";
break;
default:
- return;
+ return -EINVAL;
}
- if (t && !dbus_message_append_args(m,
- DBUS_TYPE_UINT32, &major,
- DBUS_TYPE_UINT32, &minor,
- DBUS_TYPE_STRING, &t,
- DBUS_TYPE_INVALID))
- return;
+ if (t) {
+ r = sd_bus_message_append(m, "uus", major, minor, t);
+ if (r < 0)
+ return r;
+ }
- dbus_connection_send(sd->session->manager->bus, m, NULL);
+ return sd_bus_send(sd->session->manager->bus, m, NULL);
}
static int sd_eviocrevoke(int fd) {
diff --git a/src/login/logind-session.c b/src/login/logind-session.c
index 8a021f3..65cc6f3 100644
--- a/src/login/logind-session.c
+++ b/src/login/logind-session.c
@@ -22,18 +22,18 @@
#include <errno.h>
#include <string.h>
#include <unistd.h>
-#include <sys/epoll.h>
#include <fcntl.h>
-#include <systemd/sd-id128.h>
-#include <systemd/sd-messages.h>
-
+#include "sd-id128.h"
+#include "sd-messages.h"
#include "strv.h"
#include "util.h"
#include "mkdir.h"
#include "path-util.h"
#include "fileio.h"
-#include "dbus-common.h"
+#include "audit.h"
+#include "bus-util.h"
+#include "bus-error.h"
#include "logind-session.h"
static unsigned devt_hash_func(const void *p) {
@@ -98,6 +98,8 @@ void session_free(Session *s) {
if (s->in_gc_queue)
LIST_REMOVE(gc_queue, s->manager->session_gc_queue, s);
+ session_remove_fifo(s);
+
session_drop_controller(s);
while ((sd = hashmap_first(s->devices)))
@@ -128,8 +130,7 @@ void session_free(Session *s) {
free(s->scope_job);
- if (s->create_message)
- dbus_message_unref(s->create_message);
+ sd_bus_message_unref(s->create_message);
free(s->tty);
free(s->display);
@@ -138,7 +139,6 @@ void session_free(Session *s) {
free(s->service);
hashmap_remove(s->manager->sessions, s->id);
- session_remove_fifo(s);
free(s->state_file);
free(s);
@@ -153,8 +153,8 @@ void session_set_user(Session *s, User *u) {
}
int session_save(Session *s) {
- _cleanup_fclose_ FILE *f = NULL;
_cleanup_free_ char *temp_path = NULL;
+ _cleanup_fclose_ FILE *f = NULL;
int r = 0;
assert(s);
@@ -494,16 +494,14 @@ done:
}
static int session_start_scope(Session *s) {
- DBusError error;
int r;
assert(s);
assert(s->user);
assert(s->user->slice);
- dbus_error_init(&error);
-
if (!s->scope) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ char *description = NULL;
const char *kill_mode;
char *scope, *job;
@@ -521,9 +519,7 @@ static int session_start_scope(Session *s) {
r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "systemd-user-sessions.service", kill_mode, &error, &job);
if (r < 0) {
log_error("Failed to start session scope %s: %s %s",
- scope, bus_error(&error, r), error.name);
- dbus_error_free(&error);
-
+ scope, bus_error_message(&error, r), error.name);
free(scope);
return r;
} else {
@@ -589,32 +585,29 @@ int session_start(Session *s) {
seat_save(s->seat);
if (s->seat->active == s)
- seat_send_changed(s->seat, "Sessions\0ActiveSession\0");
+ seat_send_changed(s->seat, "Sessions", "ActiveSession", NULL);
else
- seat_send_changed(s->seat, "Sessions\0");
+ seat_send_changed(s->seat, "Sessions", NULL);
}
- user_send_changed(s->user, "Sessions\0");
+ user_send_changed(s->user, "Sessions", NULL);
return 0;
}
static int session_stop_scope(Session *s) {
- DBusError error;
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
char *job;
int r;
assert(s);
- dbus_error_init(&error);
-
if (!s->scope)
return 0;
r = manager_stop_unit(s->manager, s->scope, &error, &job);
if (r < 0) {
- log_error("Failed to stop session scope: %s", bus_error(&error, r));
- dbus_error_free(&error);
+ log_error("Failed to stop session scope: %s", bus_error_message(&error, r));
return r;
}
@@ -656,6 +649,7 @@ int session_stop(Session *s) {
r = session_stop_scope(s);
session_save(s);
+ user_save(s->user);
return r;
}
@@ -698,11 +692,11 @@ int session_finalize(Session *s) {
if (s->seat->active == s)
seat_set_active(s->seat, NULL);
- seat_send_changed(s->seat, "Sessions\0");
+ seat_send_changed(s->seat, "Sessions", NULL);
seat_save(s->seat);
}
- user_send_changed(s->user, "Sessions\0");
+ user_send_changed(s->user, "Sessions", NULL);
user_save(s->user);
return r;
@@ -816,26 +810,27 @@ void session_set_idle_hint(Session *s, bool b) {
s->idle_hint = b;
dual_timestamp_get(&s->idle_hint_timestamp);
- session_send_changed(s,
- "IdleHint\0"
- "IdleSinceHint\0"
- "IdleSinceHintMonotonic\0");
+ session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
if (s->seat)
- seat_send_changed(s->seat,
- "IdleHint\0"
- "IdleSinceHint\0"
- "IdleSinceHintMonotonic\0");
-
- user_send_changed(s->user,
- "IdleHint\0"
- "IdleSinceHint\0"
- "IdleSinceHintMonotonic\0");
-
- manager_send_changed(s->manager,
- "IdleHint\0"
- "IdleSinceHint\0"
- "IdleSinceHintMonotonic\0");
+ seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
+
+ user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
+ manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
+}
+
+static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) {
+ Session *s = userdata;
+
+ assert(s);
+ assert(s->fifo_fd == fd);
+
+ /* EOF on the FIFO means the session died abnormally. */
+
+ session_remove_fifo(s);
+ session_stop(s);
+
+ return 1;
}
int session_create_fifo(Session *s) {
@@ -858,21 +853,20 @@ int session_create_fifo(Session *s) {
/* Open reading side */
if (s->fifo_fd < 0) {
- struct epoll_event ev = {};
-
s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
if (s->fifo_fd < 0)
return -errno;
- r = hashmap_put(s->manager->session_fds, INT_TO_PTR(s->fifo_fd + 1), s);
+ }
+
+ if (!s->fifo_event_source) {
+ r = sd_event_add_io(s->manager->event, s->fifo_fd, 0, session_dispatch_fifo, s, &s->fifo_event_source);
if (r < 0)
return r;
- ev.events = 0;
- ev.data.u32 = FD_OTHER_BASE + s->fifo_fd;
-
- if (epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_ADD, s->fifo_fd, &ev) < 0)
- return -errno;
+ r = sd_event_source_set_priority(s->fifo_event_source, SD_PRIORITY_IDLE);
+ if (r < 0)
+ return r;
}
/* Open writing side */
@@ -886,14 +880,12 @@ int session_create_fifo(Session *s) {
void session_remove_fifo(Session *s) {
assert(s);
+ if (s->fifo_event_source)
+ s->fifo_event_source = sd_event_source_unref(s->fifo_event_source);
+
if (s->fifo_fd >= 0) {
- assert_se(hashmap_remove(s->manager->session_fds, INT_TO_PTR(s->fifo_fd + 1)) == s);
- assert_se(epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_DEL, s->fifo_fd, NULL) == 0);
close_nointr_nofail(s->fifo_fd);
s->fifo_fd = -1;
-
- session_save(s);
- user_save(s->user);
}
if (s->fifo_path) {
@@ -903,33 +895,33 @@ void session_remove_fifo(Session *s) {
}
}
-int session_check_gc(Session *s, bool drop_not_started) {
+bool session_check_gc(Session *s, bool drop_not_started) {
int r;
assert(s);
if (drop_not_started && !s->started)
- return 0;
+ return false;
if (!s->user)
- return 0;
+ return false;
if (s->fifo_fd >= 0) {
r = pipe_eof(s->fifo_fd);
if (r < 0)
- return r;
+ return true;
if (r == 0)
- return 1;
+ return true;
}
- if (s->scope_job)
- return 1;
+ if (s->scope_job && manager_job_is_active(s->manager, s->scope_job))
+ return true;
- if (s->scope)
- return manager_unit_is_active(s->manager, s->scope) != 0;
+ if (s->scope && manager_unit_is_active(s->manager, s->scope))
+ return true;
- return 0;
+ return false;
}
void session_add_to_gc_queue(Session *s) {
@@ -969,8 +961,7 @@ int session_kill(Session *s, KillWho who, int signo) {
return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
}
-bool session_is_controller(Session *s, const char *sender)
-{
+bool session_is_controller(Session *s, const char *sender) {
assert(s);
return streq_ptr(s->controller, sender);
diff --git a/src/login/logind-session.h b/src/login/logind-session.h
index f175a89..bcbd4e5 100644
--- a/src/login/logind-session.h
+++ b/src/login/logind-session.h
@@ -98,6 +98,8 @@ struct Session {
int fifo_fd;
char *fifo_path;
+ sd_event_source *fifo_event_source;
+
bool idle_hint;
dual_timestamp idle_hint_timestamp;
@@ -105,7 +107,7 @@ struct Session {
bool started:1;
bool closing:1;
- DBusMessage *create_message;
+ sd_bus_message *create_message;
char *controller;
Hashmap *devices;
@@ -119,7 +121,7 @@ struct Session {
Session *session_new(Manager *m, const char *id);
void session_free(Session *s);
void session_set_user(Session *s, User *u);
-int session_check_gc(Session *s, bool drop_not_started);
+bool session_check_gc(Session *s, bool drop_not_started);
void session_add_to_gc_queue(Session *s);
int session_activate(Session *s);
bool session_is_active(Session *s);
@@ -134,18 +136,19 @@ int session_save(Session *s);
int session_load(Session *s);
int session_kill(Session *s, KillWho who, int signo);
-char *session_bus_path(Session *s);
-
SessionState session_get_state(Session *u);
-extern const DBusObjectPathVTable bus_session_vtable;
+extern const sd_bus_vtable session_vtable[];
+int session_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata);
+int session_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *userdata);
+char *session_bus_path(Session *s);
int session_send_signal(Session *s, bool new_session);
-int session_send_changed(Session *s, const char *properties);
+int session_send_changed(Session *s, const char *properties, ...) _sentinel_;
int session_send_lock(Session *s, bool lock);
int session_send_lock_all(Manager *m, bool lock);
-int session_send_create_reply(Session *s, DBusError *error);
+int session_send_create_reply(Session *s, sd_bus_error *error);
const char* session_state_to_string(SessionState t) _const_;
SessionState session_state_from_string(const char *s) _pure_;
diff --git a/src/login/logind-user-dbus.c b/src/login/logind-user-dbus.c
index fa2ecba..fc71fcf 100644
--- a/src/login/logind-user-dbus.c
+++ b/src/login/logind-user-dbus.c
@@ -22,309 +22,228 @@
#include <errno.h>
#include <string.h>
+#include "strv.h"
+#include "bus-util.h"
+
#include "logind.h"
#include "logind-user.h"
-#include "dbus-common.h"
-
-#define BUS_USER_INTERFACE \
- " <interface name=\"org.freedesktop.login1.User\">\n" \
- " <method name=\"Terminate\"/>\n" \
- " <method name=\"Kill\">\n" \
- " <arg name=\"signal\" type=\"s\"/>\n" \
- " </method>\n" \
- " <property name=\"UID\" type=\"u\" access=\"read\"/>\n" \
- " <property name=\"GID\" type=\"u\" access=\"read\"/>\n" \
- " <property name=\"Name\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Timestamp\" type=\"t\" access=\"read\"/>\n" \
- " <property name=\"TimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
- " <property name=\"RuntimePath\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Service\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Slice\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Display\" type=\"(so)\" access=\"read\"/>\n" \
- " <property name=\"State\" type=\"s\" access=\"read\"/>\n" \
- " <property name=\"Sessions\" type=\"a(so)\" access=\"read\"/>\n" \
- " <property name=\"IdleHint\" type=\"b\" access=\"read\"/>\n" \
- " <property name=\"IdleSinceHint\" type=\"t\" access=\"read\"/>\n" \
- " <property name=\"IdleSinceHintMonotonic\" type=\"t\" access=\"read\"/>\n" \
- " </interface>\n"
-
-#define INTROSPECTION \
- DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
- "<node>\n" \
- BUS_USER_INTERFACE \
- BUS_PROPERTIES_INTERFACE \
- BUS_PEER_INTERFACE \
- BUS_INTROSPECTABLE_INTERFACE \
- "</node>\n"
-
-#define INTERFACES_LIST \
- BUS_GENERIC_INTERFACES_LIST \
- "org.freedesktop.login1.User\0"
-
-static int bus_user_append_display(DBusMessageIter *i, const char *property, void *data) {
- DBusMessageIter sub;
- User *u = data;
- const char *id, *path;
- _cleanup_free_ char *p = NULL;
-
- assert(i);
- assert(property);
- assert(u);
- if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
- return -ENOMEM;
-
- if (u->display) {
- id = u->display->id;
- path = p = session_bus_path(u->display);
+static int property_get_display(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
- if (!p)
- return -ENOMEM;
- } else {
- id = "";
- path = "/";
- }
+ _cleanup_free_ char *p = NULL;
+ User *u = userdata;
- if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &id) ||
- !dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &path))
- return -ENOMEM;
+ assert(bus);
+ assert(reply);
+ assert(u);
- if (!dbus_message_iter_close_container(i, &sub))
+ p = u->display ? session_bus_path(u->display) : strdup("/");
+ if (!p)
return -ENOMEM;
- return 0;
+ return sd_bus_message_append(reply, "(so)", u->display ? u->display->id : "", p);
}
-static int bus_user_append_state(DBusMessageIter *i, const char *property, void *data) {
- User *u = data;
- const char *state;
-
- assert(i);
- assert(property);
- assert(u);
+static int property_get_state(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
- state = user_state_to_string(user_get_state(u));
+ User *u = userdata;
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state))
- return -ENOMEM;
+ assert(bus);
+ assert(reply);
+ assert(u);
- return 0;
+ return sd_bus_message_append(reply, "s", user_state_to_string(user_get_state(u)));
}
-static int bus_user_append_sessions(DBusMessageIter *i, const char *property, void *data) {
- DBusMessageIter sub, sub2;
- User *u = data;
+static int property_get_sessions(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ User *u = userdata;
Session *session;
+ int r;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(reply);
assert(u);
- if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(so)", &sub))
- return -ENOMEM;
+ r = sd_bus_message_open_container(reply, 'a', "(so)");
+ if (r < 0)
+ return r;
LIST_FOREACH(sessions_by_user, session, u->sessions) {
- char *p;
-
- if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
- return -ENOMEM;
+ _cleanup_free_ char *p = NULL;
p = session_bus_path(session);
if (!p)
return -ENOMEM;
- if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &session->id) ||
- !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) {
- free(p);
- return -ENOMEM;
- }
-
- free(p);
+ r = sd_bus_message_append(reply, "(so)", session->id, p);
+ if (r < 0)
+ return r;
- if (!dbus_message_iter_close_container(&sub, &sub2))
- return -ENOMEM;
}
- if (!dbus_message_iter_close_container(i, &sub))
- return -ENOMEM;
+ r = sd_bus_message_close_container(reply);
+ if (r < 0)
+ return r;
- return 0;
+ return 1;
}
-static int bus_user_append_idle_hint(DBusMessageIter *i, const char *property, void *data) {
- User *u = data;
- dbus_bool_t b;
-
- assert(i);
- assert(property);
- assert(u);
+static int property_get_idle_hint(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
- b = user_get_idle_hint(u, NULL) > 0;
+ User *u = userdata;
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
- return -ENOMEM;
+ assert(bus);
+ assert(reply);
+ assert(u);
- return 0;
+ return sd_bus_message_append(reply, "b", user_get_idle_hint(u, NULL) > 0);
}
-static int bus_user_append_idle_hint_since(DBusMessageIter *i, const char *property, void *data) {
- User *u = data;
+static int property_get_idle_since_hint(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ User *u = userdata;
dual_timestamp t;
uint64_t k;
- assert(i);
- assert(property);
+ assert(bus);
+ assert(reply);
assert(u);
user_get_idle_hint(u, &t);
k = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
- if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &k))
- return -ENOMEM;
-
- return 0;
+ return sd_bus_message_append(reply, "t", k);
}
-static int get_user_for_path(Manager *m, const char *path, User **_u) {
- User *u;
- unsigned long lu;
+static int method_terminate(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ User *u = userdata;
int r;
- assert(m);
- assert(path);
- assert(_u);
-
- if (!startswith(path, "/org/freedesktop/login1/user/_"))
- return -EINVAL;
+ assert(bus);
+ assert(message);
+ assert(u);
- r = safe_atolu(path + 30, &lu);
+ r = user_stop(u);
if (r < 0)
- return r;
-
- u = hashmap_get(m->users, ULONG_TO_PTR(lu));
- if (!u)
- return -ENOENT;
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- *_u = u;
- return 0;
+ return sd_bus_reply_method_return(bus, message, NULL);
}
-static const BusProperty bus_login_user_properties[] = {
- { "UID", bus_property_append_uid, "u", offsetof(User, uid) },
- { "GID", bus_property_append_gid, "u", offsetof(User, gid) },
- { "Name", bus_property_append_string, "s", offsetof(User, name), true },
- { "Timestamp", bus_property_append_usec, "t", offsetof(User, timestamp.realtime) },
- { "TimestampMonotonic", bus_property_append_usec, "t", offsetof(User, timestamp.monotonic) },
- { "RuntimePath", bus_property_append_string, "s", offsetof(User, runtime_path), true },
- { "Service", bus_property_append_string, "s", offsetof(User, service), true },
- { "Slice", bus_property_append_string, "s", offsetof(User, slice), true },
- { "Display", bus_user_append_display, "(so)", 0 },
- { "State", bus_user_append_state, "s", 0 },
- { "Sessions", bus_user_append_sessions, "a(so)", 0 },
- { "IdleHint", bus_user_append_idle_hint, "b", 0 },
- { "IdleSinceHint", bus_user_append_idle_hint_since, "t", 0 },
- { "IdleSinceHintMonotonic", bus_user_append_idle_hint_since, "t", 0 },
- { NULL, }
-};
-
-static DBusHandlerResult user_message_dispatch(
- User *u,
- DBusConnection *connection,
- DBusMessage *message) {
-
- DBusError error;
- _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
+static int method_kill(sd_bus *bus, sd_bus_message *message, void *userdata) {
+ User *u = userdata;
+ int32_t signo;
int r;
- assert(u);
- assert(connection);
+ assert(bus);
assert(message);
+ assert(u);
- if (dbus_message_is_method_call(message, "org.freedesktop.login1.User", "Terminate")) {
-
- r = user_stop(u);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
- } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.User", "Kill")) {
- int32_t signo;
-
- if (!dbus_message_get_args(
- message,
- &error,
- DBUS_TYPE_INT32, &signo,
- DBUS_TYPE_INVALID))
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- if (signo <= 0 || signo >= _NSIG)
- return bus_send_error_reply(connection, message, &error, -EINVAL);
-
- r = user_kill(u, signo);
- if (r < 0)
- return bus_send_error_reply(connection, message, NULL, r);
-
- reply = dbus_message_new_method_return(message);
- if (!reply)
- goto oom;
-
- } else {
- const BusBoundProperties bps[] = {
- { "org.freedesktop.login1.User", bus_login_user_properties, u },
- { NULL, }
- };
-
- return bus_default_message_handler(connection, message, INTROSPECTION, INTERFACES_LIST, bps);
- }
-
- if (reply) {
- if (!bus_maybe_send_reply(connection, message, reply))
- goto oom;
- }
+ r = sd_bus_message_read(message, "i", &signo);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- return DBUS_HANDLER_RESULT_HANDLED;
+ if (signo <= 0 || signo >= _NSIG)
+ return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
-oom:
- dbus_error_free(&error);
+ r = user_kill(u, signo);
+ if (r < 0)
+ return sd_bus_reply_method_errno(bus, message, r, NULL);
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
+ return sd_bus_reply_method_return(bus, message, NULL);
}
-static DBusHandlerResult user_message_handler(
- DBusConnection *connection,
- DBusMessage *message,
- void *userdata) {
+const sd_bus_vtable user_vtable[] = {
+ SD_BUS_VTABLE_START(0),
+
+ SD_BUS_PROPERTY("UID", "u", bus_property_get_uid, offsetof(User, uid), 0),
+ SD_BUS_PROPERTY("GID", "u", bus_property_get_gid, offsetof(User, gid), 0),
+ SD_BUS_PROPERTY("Name", "s", NULL, offsetof(User, name), 0),
+ SD_BUS_PROPERTY("Timestamp", "t", NULL, offsetof(User, timestamp.realtime), 0),
+ SD_BUS_PROPERTY("TimestampMonotonic", "t", NULL, offsetof(User, timestamp.monotonic), 0),
+ SD_BUS_PROPERTY("RuntimePath", "s", NULL, offsetof(User, runtime_path), 0),
+ SD_BUS_PROPERTY("Service", "s", NULL, offsetof(User, service), 0),
+ SD_BUS_PROPERTY("Slice", "s", NULL, offsetof(User, slice), 0),
+ SD_BUS_PROPERTY("Display", "(so)", property_get_display, 0, 0),
+ SD_BUS_PROPERTY("State", "s", property_get_state, 0, 0),
+ SD_BUS_PROPERTY("Sessions", "a(so)", property_get_sessions, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+
+ SD_BUS_METHOD("Terminate", NULL, NULL, method_terminate, 0),
+ SD_BUS_METHOD("Kill", "i", NULL, method_kill, 0),
+
+ SD_BUS_VTABLE_END
+};
+int user_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *userdata) {
+
+ _cleanup_free_ char *e = NULL;
Manager *m = userdata;
- User *u;
+ unsigned long lu;
+ const char *p;
+ User *user;
int r;
- r = get_user_for_path(m, dbus_message_get_path(message), &u);
- if (r < 0) {
-
- if (r == -ENOMEM)
- return DBUS_HANDLER_RESULT_NEED_MEMORY;
+ assert(bus);
+ assert(path);
+ assert(interface);
+ assert(found);
+ assert(m);
- if (r == -ENOENT) {
- DBusError e;
+ p = startswith(path, "/org/freedesktop/login1/user/_");
+ if (!p)
+ return 0;
- dbus_error_init(&e);
- dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown user");
- return bus_send_error_reply(connection, message, &e, r);
- }
+ r = safe_atolu(p, &lu);
+ if (r < 0)
+ return 0;
- return bus_send_error_reply(connection, message, NULL, r);
- }
+ user = hashmap_get(m->users, ULONG_TO_PTR(lu));
+ if (!user)
+ return 0;
- return user_message_dispatch(u, connection, message);
+ *found = user;
+ return 1;
}
-const DBusObjectPathVTable bus_user_vtable = {
- .message_function = user_message_handler
-};
-
char *user_bus_path(User *u) {
char *s;
@@ -336,42 +255,57 @@ char *user_bus_path(User *u) {
return s;
}
-int user_send_signal(User *u, bool new_user) {
- _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
- _cleanup_free_ char *p = NULL;
- uint32_t uid;
+int user_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata) {
+ _cleanup_strv_free_ char **l = NULL;
+ Manager *m = userdata;
+ User *user;
+ Iterator i;
+ int r;
- assert(u);
+ assert(bus);
+ assert(path);
+ assert(nodes);
- m = dbus_message_new_signal("/org/freedesktop/login1",
- "org.freedesktop.login1.Manager",
- new_user ? "UserNew" : "UserRemoved");
+ HASHMAP_FOREACH(user, m->users, i) {
+ char *p;
- if (!m)
- return -ENOMEM;
+ p = user_bus_path(user);
+ if (!p)
+ return -ENOMEM;
- p = user_bus_path(u);
- if (!p)
- return -ENOMEM;
+ r = strv_push(&l, p);
+ if (r < 0) {
+ free(p);
+ return r;
+ }
+ }
- uid = u->uid;
+ *nodes = l;
+ l = NULL;
- if (!dbus_message_append_args(
- m,
- DBUS_TYPE_UINT32, &uid,
- DBUS_TYPE_OBJECT_PATH, &p,
- DBUS_TYPE_INVALID))
- return -ENOMEM;
+ return 1;
+}
+
+int user_send_signal(User *u, bool new_user) {
+ _cleanup_free_ char *p = NULL;
- if (!dbus_connection_send(u->manager->bus, m, NULL))
+ assert(u);
+
+ p = user_bus_path(u);
+ if (!p)
return -ENOMEM;
- return 0;
+ return sd_bus_emit_signal(
+ u->manager->bus,
+ "/org/freedesktop/login1",
+ "org.freedesktop.login1.Manager",
+ new_user ? "UserNew" : "UserRemoved",
+ "uo", (uint32_t) u->uid, p);
}
-int user_send_changed(User *u, const char *properties) {
- _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
+int user_send_changed(User *u, const char *properties, ...) {
_cleanup_free_ char *p = NULL;
+ char **l;
assert(u);
@@ -382,12 +316,7 @@ int user_send_changed(User *u, const char *properties) {
if (!p)
return -ENOMEM;
- m = bus_properties_changed_new(p, "org.freedesktop.login1.User", properties);
- if (!m)
- return -ENOMEM;
-
- if (!dbus_connection_send(u->manager->bus, m, NULL))
- return -ENOMEM;
+ l = strv_from_stdarg_alloca(properties);
- return 0;
+ return sd_bus_emit_properties_changed_strv(u->manager->bus, p, "org.freedesktop.login1.User", l);
}
diff --git a/src/login/logind-user.c b/src/login/logind-user.c
index 54ee1cb..bfbdfaf 100644
--- a/src/login/logind-user.c
+++ b/src/login/logind-user.c
@@ -25,13 +25,13 @@
#include "util.h"
#include "mkdir.h"
-#include "cgroup-util.h"
#include "hashmap.h"
#include "strv.h"
#include "fileio.h"
#include "special.h"
#include "unit-name.h"
-#include "dbus-common.h"
+#include "bus-util.h"
+#include "bus-error.h"
#include "logind-user.h"
User* user_new(Manager *m, uid_t uid, gid_t gid, const char *name) {
@@ -329,15 +329,13 @@ static int user_mkdir_runtime_path(User *u) {
}
static int user_start_slice(User *u) {
- DBusError error;
char *job;
int r;
assert(u);
- dbus_error_init(&error);
-
if (!u->slice) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
char lu[DECIMAL_STR_MAX(unsigned long) + 1], *slice;
sprintf(lu, "%lu", (unsigned long) u->uid);
@@ -347,9 +345,7 @@ static int user_start_slice(User *u) {
r = manager_start_unit(u->manager, slice, &error, &job);
if (r < 0) {
- log_error("Failed to start user slice: %s", bus_error(&error, r));
- dbus_error_free(&error);
-
+ log_error("Failed to start user slice: %s", bus_error_message(&error, r));
free(slice);
} else {
u->slice = slice;
@@ -366,14 +362,12 @@ static int user_start_slice(User *u) {
}
static int user_start_service(User *u) {
- DBusError error;
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
char *job;
int r;
assert(u);
- dbus_error_init(&error);
-
if (!u->service) {
char lu[DECIMAL_STR_MAX(unsigned long) + 1], *service;
sprintf(lu, "%lu", (unsigned long) u->uid);
@@ -384,9 +378,7 @@ static int user_start_service(User *u) {
r = manager_start_unit(u->manager, service, &error, &job);
if (r < 0) {
- log_error("Failed to start user service: %s", bus_error(&error, r));
- dbus_error_free(&error);
-
+ log_error("Failed to start user service: %s", bus_error_message(&error, r));
free(service);
} else {
u->service = service;
@@ -441,21 +433,18 @@ int user_start(User *u) {
}
static int user_stop_slice(User *u) {
- DBusError error;
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
char *job;
int r;
assert(u);
- dbus_error_init(&error);
-
if (!u->slice)
return 0;
r = manager_stop_unit(u->manager, u->slice, &error, &job);
if (r < 0) {
- log_error("Failed to stop user slice: %s", bus_error(&error, r));
- dbus_error_free(&error);
+ log_error("Failed to stop user slice: %s", bus_error_message(&error, r));
return r;
}
@@ -466,21 +455,18 @@ static int user_stop_slice(User *u) {
}
static int user_stop_service(User *u) {
- DBusError error;
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
char *job;
int r;
assert(u);
- dbus_error_init(&error);
-
if (!u->service)
return 0;
r = manager_stop_unit(u->manager, u->service, &error, &job);
if (r < 0) {
- log_error("Failed to stop user service: %s", bus_error(&error, r));
- dbus_error_free(&error);
+ log_error("Failed to stop user service: %s", bus_error_message(&error, r));
return r;
}
@@ -602,40 +588,43 @@ int user_get_idle_hint(User *u, dual_timestamp *t) {
}
static int user_check_linger_file(User *u) {
- char *p;
- int r;
+ _cleanup_free_ char *cc = NULL;
+ char *p = NULL;
- if (asprintf(&p, "/var/lib/systemd/linger/%s", u->name) < 0)
+ cc = cescape(u->name);
+ if (!cc)
return -ENOMEM;
- r = access(p, F_OK) >= 0;
- free(p);
+ p = strappenda("/var/lib/systemd/linger/", cc);
- return r;
+ return access(p, F_OK) >= 0;
}
-int user_check_gc(User *u, bool drop_not_started) {
+bool user_check_gc(User *u, bool drop_not_started) {
assert(u);
if (drop_not_started && !u->started)
- return 0;
+ return false;
if (u->sessions)
- return 1;
+ return true;
if (user_check_linger_file(u) > 0)
- return 1;
+ return true;
- if (u->slice_job || u->service_job)
- return 1;
+ if (u->slice_job && manager_job_is_active(u->manager, u->slice_job))
+ return true;
+
+ if (u->service_job && manager_job_is_active(u->manager, u->service_job))
+ return true;
if (u->slice && manager_unit_is_active(u->manager, u->slice) != 0)
- return 1;
+ return true;
if (u->service && manager_unit_is_active(u->manager, u->service) != 0)
- return 1;
+ return true;
- return 0;
+ return false;
}
void user_add_to_gc_queue(User *u) {
diff --git a/src/login/logind-user.h b/src/login/logind-user.h
index b9171d3..de7ba6d 100644
--- a/src/login/logind-user.h
+++ b/src/login/logind-user.h
@@ -69,7 +69,7 @@ struct User {
User* user_new(Manager *m, uid_t uid, gid_t gid, const char *name);
void user_free(User *u);
-int user_check_gc(User *u, bool drop_not_started);
+bool user_check_gc(User *u, bool drop_not_started);
void user_add_to_gc_queue(User *u);
int user_start(User *u);
int user_stop(User *u);
@@ -80,12 +80,13 @@ int user_save(User *u);
int user_load(User *u);
int user_kill(User *u, int signo);
+extern const sd_bus_vtable user_vtable[];
+int user_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata);
+int user_object_find(sd_bus *bus, const char *path, const char *interface, void **found, void *userdata);
char *user_bus_path(User *s);
-extern const DBusObjectPathVTable bus_user_vtable;
-
int user_send_signal(User *u, bool new_user);
-int user_send_changed(User *u, const char *properties);
+int user_send_changed(User *u, const char *properties, ...) _sentinel_;
const char* user_state_to_string(UserState s) _const_;
UserState user_state_from_string(const char *s) _pure_;
diff --git a/src/login/logind.c b/src/login/logind.c
index 06db2db..e334beb 100644
--- a/src/login/logind.c
+++ b/src/login/logind.c
@@ -24,32 +24,26 @@
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
-#include <sys/epoll.h>
#include <linux/vt.h>
#include <sys/timerfd.h>
-#include <systemd/sd-daemon.h>
-
-#include "logind.h"
-#include "dbus-common.h"
-#include "dbus-loop.h"
+#include "sd-daemon.h"
#include "strv.h"
#include "conf-parser.h"
#include "mkdir.h"
+#include "bus-util.h"
+#include "bus-error.h"
+#include "logind.h"
Manager *manager_new(void) {
Manager *m;
+ int r;
m = new0(Manager, 1);
if (!m)
return NULL;
m->console_active_fd = -1;
- m->bus_fd = -1;
- m->udev_seat_fd = -1;
- m->udev_vcsa_fd = -1;
- m->udev_button_fd = -1;
- m->epoll_fd = -1;
m->reserve_vt_fd = -1;
m->n_autovts = 6;
@@ -61,7 +55,6 @@ Manager *manager_new(void) {
m->handle_lid_switch = HANDLE_SUSPEND;
m->lid_switch_ignore_inhibited = true;
- m->idle_action_fd = -1;
m->idle_action_usec = 30 * USEC_PER_MINUTE;
m->idle_action = HANDLE_IGNORE;
m->idle_action_not_before_usec = now(CLOCK_MONOTONIC);
@@ -72,18 +65,15 @@ Manager *manager_new(void) {
m->users = hashmap_new(trivial_hash_func, trivial_compare_func);
m->inhibitors = hashmap_new(string_hash_func, string_compare_func);
m->buttons = hashmap_new(string_hash_func, string_compare_func);
- m->busnames = hashmap_new(string_hash_func, string_compare_func);
m->user_units = hashmap_new(string_hash_func, string_compare_func);
m->session_units = hashmap_new(string_hash_func, string_compare_func);
- m->session_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
- m->inhibitor_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
- m->button_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
+ m->busnames = set_new(string_hash_func, string_compare_func);
if (!m->devices || !m->seats || !m->sessions || !m->users || !m->inhibitors || !m->buttons || !m->busnames ||
!m->user_units || !m->session_units ||
- !m->session_fds || !m->inhibitor_fds || !m->button_fds) {
+ !m->busnames) {
manager_free(m);
return NULL;
}
@@ -100,6 +90,12 @@ Manager *manager_new(void) {
return NULL;
}
+ r = sd_event_new(&m->event);
+ if (r < 0) {
+ manager_free(m);
+ return NULL;
+ }
+
return m;
}
@@ -110,7 +106,6 @@ void manager_free(Manager *m) {
Seat *s;
Inhibitor *i;
Button *b;
- char *n;
assert(m);
@@ -132,23 +127,25 @@ void manager_free(Manager *m) {
while ((b = hashmap_first(m->buttons)))
button_free(b);
- while ((n = hashmap_first(m->busnames)))
- free(hashmap_remove(m->busnames, n));
-
hashmap_free(m->devices);
hashmap_free(m->seats);
hashmap_free(m->sessions);
hashmap_free(m->users);
hashmap_free(m->inhibitors);
hashmap_free(m->buttons);
- hashmap_free(m->busnames);
hashmap_free(m->user_units);
hashmap_free(m->session_units);
- hashmap_free(m->session_fds);
- hashmap_free(m->inhibitor_fds);
- hashmap_free(m->button_fds);
+ set_free_free(m->busnames);
+
+ sd_event_source_unref(m->idle_action_event_source);
+
+ sd_event_source_unref(m->console_active_event_source);
+ sd_event_source_unref(m->udev_seat_event_source);
+ sd_event_source_unref(m->udev_device_event_source);
+ sd_event_source_unref(m->udev_vcsa_event_source);
+ sd_event_source_unref(m->udev_button_event_source);
if (m->console_active_fd >= 0)
close_nointr_nofail(m->console_active_fd);
@@ -165,24 +162,14 @@ void manager_free(Manager *m) {
if (m->udev)
udev_unref(m->udev);
- if (m->bus) {
- dbus_connection_flush(m->bus);
- dbus_connection_close(m->bus);
- dbus_connection_unref(m->bus);
- }
-
- if (m->bus_fd >= 0)
- close_nointr_nofail(m->bus_fd);
+ bus_verify_polkit_async_registry_free(m->bus, m->polkit_registry);
- if (m->epoll_fd >= 0)
- close_nointr_nofail(m->epoll_fd);
+ sd_bus_unref(m->bus);
+ sd_event_unref(m->event);
if (m->reserve_vt_fd >= 0)
close_nointr_nofail(m->reserve_vt_fd);
- if (m->idle_action_fd >= 0)
- close_nointr_nofail(m->idle_action_fd);
-
strv_free(m->kill_only_users);
strv_free(m->kill_exclude_users);
@@ -500,7 +487,8 @@ int manager_enumerate_inhibitors(Manager *m) {
return r;
}
-int manager_dispatch_seat_udev(Manager *m) {
+static int manager_dispatch_seat_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+ Manager *m = userdata;
struct udev_device *d;
int r;
@@ -516,7 +504,8 @@ int manager_dispatch_seat_udev(Manager *m) {
return r;
}
-static int manager_dispatch_device_udev(Manager *m) {
+static int manager_dispatch_device_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+ Manager *m = userdata;
struct udev_device *d;
int r;
@@ -532,7 +521,8 @@ static int manager_dispatch_device_udev(Manager *m) {
return r;
}
-int manager_dispatch_vcsa_udev(Manager *m) {
+static int manager_dispatch_vcsa_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+ Manager *m = userdata;
struct udev_device *d;
int r = 0;
const char *name;
@@ -556,7 +546,8 @@ int manager_dispatch_vcsa_udev(Manager *m) {
return r;
}
-int manager_dispatch_button_udev(Manager *m) {
+static int manager_dispatch_button_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+ Manager *m = userdata;
struct udev_device *d;
int r;
@@ -572,9 +563,12 @@ int manager_dispatch_button_udev(Manager *m) {
return r;
}
-int manager_dispatch_console(Manager *m) {
+static int manager_dispatch_console(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+ Manager *m = userdata;
+
assert(m);
assert(m->seat0);
+ assert(m->console_active_fd == fd);
seat_read_active_vt(m->seat0);
@@ -604,178 +598,155 @@ static int manager_reserve_vt(Manager *m) {
return 0;
}
-static void manager_dispatch_other(Manager *m, int fd) {
- Session *s;
- Inhibitor *i;
- Button *b;
+static int manager_connect_bus(Manager *m) {
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ int r;
- assert_se(m);
- assert_se(fd >= 0);
+ assert(m);
+ assert(!m->bus);
- s = hashmap_get(m->session_fds, INT_TO_PTR(fd + 1));
- if (s) {
- assert(s->fifo_fd == fd);
- session_remove_fifo(s);
- session_stop(s);
- return;
+ r = sd_bus_open_system(&m->bus);
+ if (r < 0) {
+ log_error("Failed to connect to system bus: %s", strerror(-r));
+ return r;
}
- i = hashmap_get(m->inhibitor_fds, INT_TO_PTR(fd + 1));
- if (i) {
- assert(i->fifo_fd == fd);
- inhibitor_stop(i);
- inhibitor_free(i);
- return;
+ r = sd_bus_add_object_vtable(m->bus, "/org/freedesktop/login1", "org.freedesktop.login1.Manager", manager_vtable, m);
+ if (r < 0) {
+ log_error("Failed to add manager object vtable: %s", strerror(-r));
+ return r;
}
- b = hashmap_get(m->button_fds, INT_TO_PTR(fd + 1));
- if (b) {
- assert(b->fd == fd);
- button_process(b);
- return;
+ r = sd_bus_add_fallback_vtable(m->bus, "/org/freedesktop/login1/seat", "org.freedesktop.login1.Seat", seat_vtable, seat_object_find, m);
+ if (r < 0) {
+ log_error("Failed to add seat object vtable: %s", strerror(-r));
+ return r;
}
- assert_not_reached("Got event for unknown fd");
-}
-
-static int manager_connect_bus(Manager *m) {
- DBusError error;
- int r;
- struct epoll_event ev = {
- .events = EPOLLIN,
- .data.u32 = FD_BUS,
- };
+ r = sd_bus_add_node_enumerator(m->bus, "/org/freedesktop/login1/seat", seat_node_enumerator, m);
+ if (r < 0) {
+ log_error("Failed to add seat enumerator: %s", strerror(-r));
+ return r;
+ }
- assert(m);
- assert(!m->bus);
- assert(m->bus_fd < 0);
+ r = sd_bus_add_fallback_vtable(m->bus, "/org/freedesktop/login1/session", "org.freedesktop.login1.Session", session_vtable, session_object_find, m);
+ if (r < 0) {
+ log_error("Failed to add session object vtable: %s", strerror(-r));
+ return r;
+ }
- dbus_error_init(&error);
+ r = sd_bus_add_node_enumerator(m->bus, "/org/freedesktop/login1/session", session_node_enumerator, m);
+ if (r < 0) {
+ log_error("Failed to add session enumerator: %s", strerror(-r));
+ return r;
+ }
- m->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
- if (!m->bus) {
- log_error("Failed to get system D-Bus connection: %s", bus_error_message(&error));
- r = -ECONNREFUSED;
- goto fail;
+ r = sd_bus_add_fallback_vtable(m->bus, "/org/freedesktop/login1/user", "org.freedesktop.login1.User", user_vtable, user_object_find, m);
+ if (r < 0) {
+ log_error("Failed to add user object vtable: %s", strerror(-r));
+ return r;
}
- if (!dbus_connection_register_object_path(m->bus, "/org/freedesktop/login1", &bus_manager_vtable, m) ||
- !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/seat", &bus_seat_vtable, m) ||
- !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/session", &bus_session_vtable, m) ||
- !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/user", &bus_user_vtable, m) ||
- !dbus_connection_add_filter(m->bus, bus_message_filter, m, NULL)) {
- r = log_oom();
- goto fail;
+ r = sd_bus_add_node_enumerator(m->bus, "/org/freedesktop/login1/user", user_node_enumerator, m);
+ if (r < 0) {
+ log_error("Failed to add user enumerator: %s", strerror(-r));
+ return r;
}
- dbus_bus_add_match(m->bus,
- "type='signal',"
- "sender='"DBUS_SERVICE_DBUS"',"
- "interface='"DBUS_INTERFACE_DBUS"',"
- "member='NameOwnerChanged',"
- "path='"DBUS_PATH_DBUS"'",
- &error);
- if (dbus_error_is_set(&error)) {
- log_error("Failed to add match for NameOwnerChanged: %s", bus_error_message(&error));
- dbus_error_free(&error);
+ r = sd_bus_add_match(m->bus,
+ "type='signal',"
+ "sender='org.freedesktop.DBus',"
+ "interface='org.freedesktop.DBus',"
+ "member='NameOwnerChanged',"
+ "path='/org/freedesktop/DBus'",
+ match_name_owner_changed, m);
+ if (r < 0) {
+ log_error("Failed to add match for NameOwnerChanged: %s", strerror(-r));
+ return r;
}
- dbus_bus_add_match(m->bus,
- "type='signal',"
- "sender='org.freedesktop.systemd1',"
- "interface='org.freedesktop.systemd1.Manager',"
- "member='JobRemoved',"
- "path='/org/freedesktop/systemd1'",
- &error);
- if (dbus_error_is_set(&error)) {
- log_error("Failed to add match for JobRemoved: %s", bus_error_message(&error));
- dbus_error_free(&error);
+ r = sd_bus_add_match(m->bus,
+ "type='signal',"
+ "sender='org.freedesktop.systemd1',"
+ "interface='org.freedesktop.systemd1.Manager',"
+ "member='JobRemoved',"
+ "path='/org/freedesktop/systemd1'",
+ match_job_removed, m);
+ if (r < 0) {
+ log_error("Failed to add match for JobRemoved: %s", strerror(-r));
+ return r;
}
- dbus_bus_add_match(m->bus,
- "type='signal',"
- "sender='org.freedesktop.systemd1',"
- "interface='org.freedesktop.systemd1.Manager',"
- "member='UnitRemoved',"
- "path='/org/freedesktop/systemd1'",
- &error);
- if (dbus_error_is_set(&error)) {
- log_error("Failed to add match for UnitRemoved: %s", bus_error_message(&error));
- dbus_error_free(&error);
+ r = sd_bus_add_match(m->bus,
+ "type='signal',"
+ "sender='org.freedesktop.systemd1',"
+ "interface='org.freedesktop.systemd1.Manager',"
+ "member='UnitRemoved',"
+ "path='/org/freedesktop/systemd1'",
+ match_unit_removed, m);
+ if (r < 0) {
+ log_error("Failed to add match for UnitRemoved: %s", strerror(-r));
+ return r;
}
- dbus_bus_add_match(m->bus,
- "type='signal',"
- "sender='org.freedesktop.systemd1',"
- "interface='org.freedesktop.DBus.Properties',"
- "member='PropertiesChanged'",
- &error);
- if (dbus_error_is_set(&error)) {
- log_error("Failed to add match for PropertiesChanged: %s", bus_error_message(&error));
- dbus_error_free(&error);
+ r = sd_bus_add_match(m->bus,
+ "type='signal',"
+ "sender='org.freedesktop.systemd1',"
+ "interface='org.freedesktop.DBus.Properties',"
+ "member='PropertiesChanged'",
+ match_properties_changed, m);
+ if (r < 0) {
+ log_error("Failed to add match for PropertiesChanged: %s", strerror(-r));
+ return r;
}
- dbus_bus_add_match(m->bus,
- "type='signal',"
- "sender='org.freedesktop.systemd1',"
- "interface='org.freedesktop.systemd1.Manager',"
- "member='Reloading',"
- "path='/org/freedesktop/systemd1'",
- &error);
- if (dbus_error_is_set(&error)) {
- log_error("Failed to add match for Reloading: %s", bus_error_message(&error));
- dbus_error_free(&error);
+ r = sd_bus_add_match(m->bus,
+ "type='signal',"
+ "sender='org.freedesktop.systemd1',"
+ "interface='org.freedesktop.systemd1.Manager',"
+ "member='Reloading',"
+ "path='/org/freedesktop/systemd1'",
+ match_reloading, m);
+ if (r < 0) {
+ log_error("Failed to add match for Reloading: %s", strerror(-r));
+ return r;
}
- r = bus_method_call_with_reply(
+ r = sd_bus_call_method(
m->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"Subscribe",
- NULL,
&error,
- DBUS_TYPE_INVALID);
+ NULL, NULL);
if (r < 0) {
- log_error("Failed to enable subscription: %s", bus_error(&error, r));
- dbus_error_free(&error);
+ log_error("Failed to enable subscription: %s", bus_error_message(&error, r));
+ return r;
}
- r = dbus_bus_request_name(m->bus, "org.freedesktop.login1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error);
- if (dbus_error_is_set(&error)) {
- log_error("Failed to register name on bus: %s", bus_error_message(&error));
- r = -EIO;
- goto fail;
+ r = sd_bus_request_name(m->bus, "org.freedesktop.login1", SD_BUS_NAME_DO_NOT_QUEUE);
+ if (r < 0) {
+ log_error("Failed to register name: %s", strerror(-r));
+ return r;
}
- if (r != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
+ if (r != SD_BUS_NAME_PRIMARY_OWNER) {
log_error("Failed to acquire name.");
- r = -EEXIST;
- goto fail;
+ return -EEXIST;
}
- m->bus_fd = bus_loop_open(m->bus);
- if (m->bus_fd < 0) {
- r = m->bus_fd;
- goto fail;
+ r = sd_bus_attach_event(m->bus, m->event, 0);
+ if (r < 0) {
+ log_error("Failed to attach bus to event loop: %s", strerror(-r));
+ return r;
}
- if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->bus_fd, &ev) < 0)
- goto fail;
-
return 0;
-
-fail:
- dbus_error_free(&error);
-
- return r;
}
static int manager_connect_console(Manager *m) {
- struct epoll_event ev = {
- .events = 0,
- .data.u32 = FD_CONSOLE,
- };
+ int r;
assert(m);
assert(m->console_active_fd < 0);
@@ -783,10 +754,8 @@ static int manager_connect_console(Manager *m) {
/* On certain architectures (S390 and Xen, and containers),
/dev/tty0 does not exist, so don't fail if we can't open
it. */
- if (access("/dev/tty0", F_OK) < 0) {
- m->console_active_fd = -1;
+ if (access("/dev/tty0", F_OK) < 0)
return 0;
- }
m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
if (m->console_active_fd < 0) {
@@ -800,18 +769,17 @@ static int manager_connect_console(Manager *m) {
return -errno;
}
- if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->console_active_fd, &ev) < 0)
- return -errno;
+ r = sd_event_add_io(m->event, m->console_active_fd, 0, manager_dispatch_console, m, &m->console_active_event_source);
+ if (r < 0) {
+ log_error("Failed to watch foreground console");
+ return r;
+ }
return 0;
}
static int manager_connect_udev(Manager *m) {
int r;
- struct epoll_event ev = {
- .events = EPOLLIN,
- .data.u32 = FD_SEAT_UDEV,
- };
assert(m);
assert(!m->udev_seat_monitor);
@@ -831,10 +799,9 @@ static int manager_connect_udev(Manager *m) {
if (r < 0)
return r;
- m->udev_seat_fd = udev_monitor_get_fd(m->udev_seat_monitor);
-
- if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_seat_fd, &ev) < 0)
- return -errno;
+ r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_seat_monitor), EPOLLIN, manager_dispatch_seat_udev, m, &m->udev_seat_event_source);
+ if (r < 0)
+ return r;
m->udev_device_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
if (!m->udev_device_monitor)
@@ -856,12 +823,9 @@ static int manager_connect_udev(Manager *m) {
if (r < 0)
return r;
- m->udev_device_fd = udev_monitor_get_fd(m->udev_device_monitor);
- zero(ev);
- ev.events = EPOLLIN;
- ev.data.u32 = FD_DEVICE_UDEV;
- if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_device_fd, &ev) < 0)
- return -errno;
+ r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_device_monitor), EPOLLIN, manager_dispatch_device_udev, m, &m->udev_device_event_source);
+ if (r < 0)
+ return r;
/* Don't watch keys if nobody cares */
if (m->handle_power_key != HANDLE_IGNORE ||
@@ -885,13 +849,9 @@ static int manager_connect_udev(Manager *m) {
if (r < 0)
return r;
- m->udev_button_fd = udev_monitor_get_fd(m->udev_button_monitor);
-
- zero(ev);
- ev.events = EPOLLIN;
- ev.data.u32 = FD_BUTTON_UDEV;
- if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_button_fd, &ev) < 0)
- return -errno;
+ r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_button_monitor), EPOLLIN, manager_dispatch_button_udev, m, &m->udev_button_event_source);
+ if (r < 0)
+ return r;
}
/* Don't bother watching VCSA devices, if nobody cares */
@@ -909,13 +869,9 @@ static int manager_connect_udev(Manager *m) {
if (r < 0)
return r;
- m->udev_vcsa_fd = udev_monitor_get_fd(m->udev_vcsa_monitor);
-
- zero(ev);
- ev.events = EPOLLIN;
- ev.data.u32 = FD_VCSA_UDEV;
- if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_vcsa_fd, &ev) < 0)
- return -errno;
+ r = sd_event_add_io(m->event, udev_monitor_get_fd(m->udev_vcsa_monitor), EPOLLIN, manager_dispatch_vcsa_udev, m, &m->udev_vcsa_event_source);
+ if (r < 0)
+ return r;
}
return 0;
@@ -932,7 +888,7 @@ void manager_gc(Manager *m, bool drop_not_started) {
LIST_REMOVE(gc_queue, m->seat_gc_queue, seat);
seat->in_gc_queue = false;
- if (seat_check_gc(seat, drop_not_started) == 0) {
+ if (!seat_check_gc(seat, drop_not_started)) {
seat_stop(seat);
seat_free(seat);
}
@@ -942,7 +898,7 @@ void manager_gc(Manager *m, bool drop_not_started) {
LIST_REMOVE(gc_queue, m->session_gc_queue, session);
session->in_gc_queue = false;
- if (session_check_gc(session, drop_not_started) == 0) {
+ if (!session_check_gc(session, drop_not_started)) {
session_stop(session);
session_finalize(session);
session_free(session);
@@ -953,7 +909,7 @@ void manager_gc(Manager *m, bool drop_not_started) {
LIST_REMOVE(gc_queue, m->user_gc_queue, user);
user->in_gc_queue = false;
- if (user_check_gc(user, drop_not_started) == 0) {
+ if (!user_check_gc(user, drop_not_started)) {
user_stop(user);
user_finalize(user);
user_free(user);
@@ -961,26 +917,24 @@ void manager_gc(Manager *m, bool drop_not_started) {
}
}
-int manager_dispatch_idle_action(Manager *m) {
+static int manager_dispatch_idle_action(sd_event_source *s, uint64_t t, void *userdata) {
+ Manager *m = userdata;
struct dual_timestamp since;
- struct itimerspec its = {};
+ usec_t n, elapse;
int r;
- usec_t n;
assert(m);
if (m->idle_action == HANDLE_IGNORE ||
- m->idle_action_usec <= 0) {
- r = 0;
- goto finish;
- }
+ m->idle_action_usec <= 0)
+ return 0;
n = now(CLOCK_MONOTONIC);
r = manager_get_idle_hint(m, &since);
if (r <= 0)
/* Not idle. Let's check if after a timeout it might be idle then. */
- timespec_store(&its.it_value, n + m->idle_action_usec);
+ elapse = n + m->idle_action_usec;
else {
/* Idle! Let's see if it's time to do something, or if
* we shall sleep for longer. */
@@ -993,45 +947,39 @@ int manager_dispatch_idle_action(Manager *m) {
m->idle_action_not_before_usec = n;
}
- timespec_store(&its.it_value, MAX(since.monotonic, m->idle_action_not_before_usec) + m->idle_action_usec);
+ elapse = MAX(since.monotonic, m->idle_action_not_before_usec) + m->idle_action_usec;
}
- if (m->idle_action_fd < 0) {
- struct epoll_event ev = {
- .events = EPOLLIN,
- .data.u32 = FD_IDLE_ACTION,
- };
+ if (!m->idle_action_event_source) {
- m->idle_action_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
- if (m->idle_action_fd < 0) {
- log_error("Failed to create idle action timer: %m");
- r = -errno;
- goto finish;
+ r = sd_event_add_monotonic(m->event, elapse, USEC_PER_SEC*30, manager_dispatch_idle_action, m, &m->idle_action_event_source);
+ if (r < 0) {
+ log_error("Failed to add idle event source: %s", strerror(-r));
+ return r;
}
- if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->idle_action_fd, &ev) < 0) {
- log_error("Failed to add idle action timer to epoll: %m");
- r = -errno;
- goto finish;
+ r = sd_event_source_set_priority(m->idle_action_event_source, SD_PRIORITY_IDLE+10);
+ if (r < 0) {
+ log_error("Failed to set idle event source priority: %s", strerror(-r));
+ return r;
+ }
+ } else {
+ r = sd_event_source_set_time(m->idle_action_event_source, elapse);
+ if (r < 0) {
+ log_error("Failed to set idle event timer: %s", strerror(-r));
+ return r;
}
- }
- if (timerfd_settime(m->idle_action_fd, TFD_TIMER_ABSTIME, &its, NULL) < 0) {
- log_error("Failed to reset timerfd: %m");
- r = -errno;
- goto finish;
+ r = sd_event_source_set_enabled(m->idle_action_event_source, SD_EVENT_ONESHOT);
+ if (r < 0) {
+ log_error("Failed to enable idle event timer: %s", strerror(-r));
+ return r;
+ }
}
return 0;
-
-finish:
- if (m->idle_action_fd >= 0) {
- close_nointr_nofail(m->idle_action_fd);
- m->idle_action_fd = -1;
- }
-
- return r;
}
+
int manager_startup(Manager *m) {
int r;
Seat *seat;
@@ -1041,11 +989,6 @@ int manager_startup(Manager *m) {
Iterator i;
assert(m);
- assert(m->epoll_fd <= 0);
-
- m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
- if (m->epoll_fd < 0)
- return -errno;
/* Connect to console */
r = manager_connect_console(m);
@@ -1054,8 +997,10 @@ int manager_startup(Manager *m) {
/* Connect to udev */
r = manager_connect_udev(m);
- if (r < 0)
+ if (r < 0) {
+ log_error("Failed to create udev watchers: %s", strerror(-r));
return r;
+ }
/* Connect to the bus */
r = manager_connect_bus(m);
@@ -1064,8 +1009,10 @@ int manager_startup(Manager *m) {
/* Instantiate magic seat 0 */
r = manager_add_seat(m, "seat0", &m->seat0);
- if (r < 0)
+ if (r < 0) {
+ log_error("Failed to add seat0: %s", strerror(-r));
return r;
+ }
/* Deserialize state */
r = manager_enumerate_devices(m);
@@ -1111,7 +1058,7 @@ int manager_startup(Manager *m) {
HASHMAP_FOREACH(inhibitor, m->inhibitors, i)
inhibitor_start(inhibitor);
- manager_dispatch_idle_action(m);
+ manager_dispatch_idle_action(NULL, 0, m);
return 0;
}
@@ -1137,12 +1084,18 @@ static int manager_recheck_buttons(Manager *m) {
}
int manager_run(Manager *m) {
+ int r;
+
assert(m);
for (;;) {
- struct epoll_event event;
- int n;
- int msec = -1;
+ usec_t us = (uint64_t) -1;
+
+ r = sd_event_get_state(m->event);
+ if (r < 0)
+ return r;
+ if (r == SD_EVENT_FINISHED)
+ return 0;
manager_gc(m, true);
@@ -1152,66 +1105,18 @@ int manager_run(Manager *m) {
if (manager_recheck_buttons(m) > 0)
continue;
- if (dbus_connection_dispatch(m->bus) != DBUS_DISPATCH_COMPLETE)
- continue;
-
- manager_gc(m, true);
-
if (m->action_what != 0 && !m->action_job) {
usec_t x, y;
x = now(CLOCK_MONOTONIC);
y = m->action_timestamp + m->inhibit_delay_max;
- msec = x >= y ? 0 : (int) ((y - x) / USEC_PER_MSEC);
+ us = x >= y ? 0 : y - x;
}
- n = epoll_wait(m->epoll_fd, &event, 1, msec);
- if (n < 0) {
- if (errno == EINTR || errno == EAGAIN)
- continue;
-
- log_error("epoll() failed: %m");
- return -errno;
- }
-
- if (n == 0)
- continue;
-
- switch (event.data.u32) {
-
- case FD_SEAT_UDEV:
- manager_dispatch_seat_udev(m);
- break;
-
- case FD_DEVICE_UDEV:
- manager_dispatch_device_udev(m);
- break;
-
- case FD_VCSA_UDEV:
- manager_dispatch_vcsa_udev(m);
- break;
-
- case FD_BUTTON_UDEV:
- manager_dispatch_button_udev(m);
- break;
-
- case FD_CONSOLE:
- manager_dispatch_console(m);
- break;
-
- case FD_IDLE_ACTION:
- manager_dispatch_idle_action(m);
- break;
-
- case FD_BUS:
- bus_loop_dispatch(m->bus_fd);
- break;
-
- default:
- if (event.data.u32 >= FD_OTHER_BASE)
- manager_dispatch_other(m, event.data.u32 - FD_OTHER_BASE);
- }
+ r = sd_event_run(m->event, us);
+ if (r < 0)
+ return r;
}
return 0;
diff --git a/src/login/logind.h b/src/login/logind.h
index 9e6296c..9a3b9a8 100644
--- a/src/login/logind.h
+++ b/src/login/logind.h
@@ -23,14 +23,14 @@
#include <stdbool.h>
#include <inttypes.h>
-#include <dbus/dbus.h>
#include <libudev.h>
+#include "sd-event.h"
+#include "sd-bus.h"
#include "util.h"
-#include "audit.h"
#include "list.h"
#include "hashmap.h"
-#include "cgroup-util.h"
+#include "set.h"
typedef struct Manager Manager;
@@ -43,7 +43,8 @@ typedef struct Manager Manager;
#include "logind-action.h"
struct Manager {
- DBusConnection *bus;
+ sd_event *event;
+ sd_bus *bus;
Hashmap *devices;
Hashmap *seats;
@@ -51,7 +52,8 @@ struct Manager {
Hashmap *users;
Hashmap *inhibitors;
Hashmap *buttons;
- Hashmap *busnames;
+
+ Set *busnames;
LIST_HEAD(Seat, seat_gc_queue);
LIST_HEAD(Session, session_gc_queue);
@@ -60,14 +62,13 @@ struct Manager {
struct udev *udev;
struct udev_monitor *udev_seat_monitor, *udev_device_monitor, *udev_vcsa_monitor, *udev_button_monitor;
- int udev_seat_fd;
- int udev_device_fd;
- int udev_vcsa_fd;
- int udev_button_fd;
+ sd_event_source *console_active_event_source;
+ sd_event_source *udev_seat_event_source;
+ sd_event_source *udev_device_event_source;
+ sd_event_source *udev_vcsa_event_source;
+ sd_event_source *udev_button_event_source;
int console_active_fd;
- int bus_fd;
- int epoll_fd;
unsigned n_autovts;
@@ -85,10 +86,6 @@ struct Manager {
Hashmap *session_units;
Hashmap *user_units;
- Hashmap *session_fds;
- Hashmap *inhibitor_fds;
- Hashmap *button_fds;
-
usec_t inhibit_delay_max;
/* If an action is currently being executed or is delayed,
@@ -105,7 +102,7 @@ struct Manager {
char *action_job;
usec_t action_timestamp;
- int idle_action_fd; /* the timer_fd */
+ sd_event_source *idle_action_event_source;
usec_t idle_action_usec;
usec_t idle_action_not_before_usec;
HandleAction idle_action;
@@ -119,17 +116,8 @@ struct Manager {
bool suspend_key_ignore_inhibited;
bool hibernate_key_ignore_inhibited;
bool lid_switch_ignore_inhibited;
-};
-enum {
- FD_SEAT_UDEV,
- FD_DEVICE_UDEV,
- FD_VCSA_UDEV,
- FD_BUTTON_UDEV,
- FD_CONSOLE,
- FD_BUS,
- FD_IDLE_ACTION,
- FD_OTHER_BASE
+ Hashmap *polkit_registry;
};
Manager *manager_new(void);
@@ -147,12 +135,6 @@ int manager_add_inhibitor(Manager *m, const char* id, Inhibitor **_inhibitor);
int manager_process_seat_device(Manager *m, struct udev_device *d);
int manager_process_button_device(Manager *m, struct udev_device *d);
-int manager_dispatch_seat_udev(Manager *m);
-int manager_dispatch_vcsa_udev(Manager *m);
-int manager_dispatch_button_udev(Manager *m);
-int manager_dispatch_console(Manager *m);
-int manager_dispatch_idle_action(Manager *m);
-
int manager_enumerate_devices(Manager *m);
int manager_enumerate_buttons(Manager *m);
int manager_enumerate_seats(Manager *m);
@@ -173,21 +155,26 @@ int manager_get_idle_hint(Manager *m, dual_timestamp *t);
int manager_get_user_by_pid(Manager *m, pid_t pid, User **user);
int manager_get_session_by_pid(Manager *m, pid_t pid, Session **session);
-extern const DBusObjectPathVTable bus_manager_vtable;
+extern const sd_bus_vtable manager_vtable[];
-DBusHandlerResult bus_message_filter(DBusConnection *c, DBusMessage *message, void *userdata);
+int match_job_removed(sd_bus *bus, sd_bus_message *message, void *userdata);
+int match_unit_removed(sd_bus *bus, sd_bus_message *message, void *userdata);
+int match_properties_changed(sd_bus *bus, sd_bus_message *message, void *userdata);
+int match_reloading(sd_bus *bus, sd_bus_message *message, void *userdata);
+int match_name_owner_changed(sd_bus *bus, sd_bus_message *message, void *userdata);
-int bus_manager_shutdown_or_sleep_now_or_later(Manager *m, const char *unit_name, InhibitWhat w, DBusError *error);
+int bus_manager_shutdown_or_sleep_now_or_later(Manager *m, const char *unit_name, InhibitWhat w, sd_bus_error *error);
-int manager_send_changed(Manager *manager, const char *properties);
+int manager_send_changed(Manager *manager, const char *property, ...) _sentinel_;
int manager_dispatch_delayed(Manager *manager);
-int manager_start_scope(Manager *manager, const char *scope, pid_t pid, const char *slice, const char *description, const char *after, const char *kill_mode, DBusError *error, char **job);
-int manager_start_unit(Manager *manager, const char *unit, DBusError *error, char **job);
-int manager_stop_unit(Manager *manager, const char *unit, DBusError *error, char **job);
-int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, DBusError *error);
+int manager_start_scope(Manager *manager, const char *scope, pid_t pid, const char *slice, const char *description, const char *after, const char *kill_mode, sd_bus_error *error, char **job);
+int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job);
+int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job);
+int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error);
int manager_unit_is_active(Manager *manager, const char *unit);
+int manager_job_is_active(Manager *manager, const char *path);
/* gperf lookup function */
const struct ConfigPerfItem* logind_gperf_lookup(const char *key, unsigned length);
diff --git a/src/login/pam-module.c b/src/login/pam-module.c
index 973daf7..81ec15f 100644
--- a/src/login/pam-module.c
+++ b/src/login/pam-module.c
@@ -187,7 +187,7 @@ _public_ PAM_EXTERN int pam_sm_open_session(
const char *username, *id, *object_path, *runtime_path, *service = NULL, *tty = NULL, *display = NULL, *remote_user = NULL, *remote_host = NULL, *seat = NULL, *type = NULL, *class = NULL, *class_pam = NULL, *cvtnr = NULL;
DBusError error;
uint32_t uid, pid;
- DBusMessageIter iter;
+ DBusMessageIter iter, sub;
int session_fd = -1;
DBusConnection *bus = NULL;
DBusMessage *m = NULL, *reply = NULL;
@@ -372,6 +372,13 @@ _public_ PAM_EXTERN int pam_sm_open_session(
dbus_message_iter_init_append(m, &iter);
+ if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sv)", &sub) ||
+ !dbus_message_iter_close_container(&iter, &sub)) {
+ pam_syslog(handle, LOG_ERR, "Could not attach parameters to message.");
+ r = PAM_BUF_ERR;
+ goto finish;
+ }
+
if (debug)
pam_syslog(handle, LOG_DEBUG, "Asking logind to create session: "
"uid=%u pid=%u service=%s type=%s class=%s seat=%s vtnr=%u tty=%s display=%s remote=%s remote_user=%s remote_host=%s",
commit 6d1bd3b2bbae29dbd3862fdb9af2b472b01c480e
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Nov 5 00:53:46 2013 +0100
localed: mark bus properties as change emitting
Otherwise sd_bus_emit_properties_changed() will refuse sending out
change signals
diff --git a/src/locale/localed.c b/src/locale/localed.c
index 2d9891a..61a3015 100644
--- a/src/locale/localed.c
+++ b/src/locale/localed.c
@@ -1040,13 +1040,13 @@ static int method_set_x11_keyboard(sd_bus *bus, sd_bus_message *m, void *userdat
static const sd_bus_vtable locale_vtable[] = {
SD_BUS_VTABLE_START(0),
- SD_BUS_PROPERTY("Locale", "as", property_get_locale, 0, 0),
- SD_BUS_PROPERTY("X11Layout", "s", NULL, offsetof(Context, x11_layout), 0),
- SD_BUS_PROPERTY("X11Model", "s", NULL, offsetof(Context, x11_model), 0),
- SD_BUS_PROPERTY("X11Variant", "s", NULL, offsetof(Context, x11_variant), 0),
- SD_BUS_PROPERTY("X11Options", "s", NULL, offsetof(Context, x11_options), 0),
- SD_BUS_PROPERTY("VConsoleKeymap", "s", NULL, offsetof(Context, vc_keymap), 0),
- SD_BUS_PROPERTY("VConsoleKeymapToggle", "s", NULL, offsetof(Context, vc_keymap_toggle), 0),
+ SD_BUS_PROPERTY("Locale", "as", property_get_locale, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("X11Layout", "s", NULL, offsetof(Context, x11_layout), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("X11Model", "s", NULL, offsetof(Context, x11_model), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("X11Variant", "s", NULL, offsetof(Context, x11_variant), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("X11Options", "s", NULL, offsetof(Context, x11_options), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("VConsoleKeymap", "s", NULL, offsetof(Context, vc_keymap), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
+ SD_BUS_PROPERTY("VConsoleKeymapToggle", "s", NULL, offsetof(Context, vc_keymap_toggle), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
SD_BUS_METHOD("SetLocale", "asb", NULL, method_set_locale, 0),
SD_BUS_METHOD("SetVConsoleKeyboard", "ssbb", NULL, method_set_vc_keyboard, 0),
SD_BUS_METHOD("SetX11Keyboard", "ssssbb", NULL, method_set_x11_keyboard, 0),
commit fe5af61253ab8531c6d683da77546fe97be69b38
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Nov 5 00:53:19 2013 +0100
user-sessions: modernizations
diff --git a/src/login/user-sessions.c b/src/login/user-sessions.c
index 45fb427..ca5de41 100644
--- a/src/login/user-sessions.c
+++ b/src/login/user-sessions.c
@@ -28,7 +28,6 @@
#include "fileio.h"
int main(int argc, char*argv[]) {
- int ret = EXIT_FAILURE;
if (argc != 2) {
log_error("This program requires one argument.");
@@ -42,7 +41,7 @@ int main(int argc, char*argv[]) {
umask(0022);
if (streq(argv[1], "start")) {
- int q = 0, r = 0;
+ int r = 0;
if (unlink("/run/nologin") < 0 && errno != ENOENT) {
log_error("Failed to remove /run/nologin file: %m");
@@ -50,7 +49,6 @@ int main(int argc, char*argv[]) {
}
if (unlink("/etc/nologin") < 0 && errno != ENOENT) {
-
/* If the file doesn't exist and /etc simply
* was read-only (in which case unlink()
* returns EROFS even if the file doesn't
@@ -58,27 +56,26 @@ int main(int argc, char*argv[]) {
if (errno != EROFS || access("/etc/nologin", F_OK) >= 0) {
log_error("Failed to remove /etc/nologin file: %m");
- q = -errno;
+ return EXIT_FAILURE;
}
}
- if (r < 0 || q < 0)
- goto finish;
+ if (r < 0)
+ return EXIT_FAILURE;
} else if (streq(argv[1], "stop")) {
int r;
r = write_string_file_atomic("/run/nologin", "System is going down.");
- if (r < 0)
+ if (r < 0) {
log_error("Failed to create /run/nologin: %s", strerror(-r));
+ return EXIT_FAILURE;
+ }
} else {
log_error("Unknown verb %s.", argv[1]);
- goto finish;
+ return EXIT_FAILURE;
}
- ret = EXIT_SUCCESS;
-
-finish:
- return ret;
+ return EXIT_SUCCESS;
}
commit a658cafa98ab55ea948c29bc87eb3945d515fb41
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Nov 5 00:52:46 2013 +0100
machined: simplifications
diff --git a/src/machine/machine-dbus.c b/src/machine/machine-dbus.c
index 150a3f7..ddd6b4b 100644
--- a/src/machine/machine-dbus.c
+++ b/src/machine/machine-dbus.c
@@ -210,13 +210,13 @@ int machine_send_create_reply(Machine *m, sd_bus_error *error) {
c = m->create_message;
m->create_message = NULL;
+ if (error)
+ return sd_bus_reply_method_error(m->manager->bus, c, error);
+
/* Update the machine state file before we notify the client
* about the result. */
machine_save(m);
- if (error)
- return sd_bus_reply_method_error(m->manager->bus, c, error);
-
p = machine_bus_path(m);
if (!p)
return -ENOMEM;
diff --git a/src/machine/machine.c b/src/machine/machine.c
index be669f0..a33a111 100644
--- a/src/machine/machine.c
+++ b/src/machine/machine.c
@@ -338,7 +338,7 @@ int machine_stop(Machine *m) {
return r;
}
-int machine_check_gc(Machine *m, bool drop_not_started) {
+bool machine_check_gc(Machine *m, bool drop_not_started) {
assert(m);
if (drop_not_started && !m->started)
diff --git a/src/machine/machine.h b/src/machine/machine.h
index bfb28d1..99ee258 100644
--- a/src/machine/machine.h
+++ b/src/machine/machine.h
@@ -80,7 +80,7 @@ struct Machine {
Machine* machine_new(Manager *manager, const char *name);
void machine_free(Machine *m);
-int machine_check_gc(Machine *m, bool drop_not_started);
+bool machine_check_gc(Machine *m, bool drop_not_started);
void machine_add_to_gc_queue(Machine *m);
int machine_start(Machine *m, sd_bus_message *properties, sd_bus_error *error);
int machine_stop(Machine *m);
diff --git a/src/machine/machined-dbus.c b/src/machine/machined-dbus.c
index 6035597..b552662 100644
--- a/src/machine/machined-dbus.c
+++ b/src/machine/machined-dbus.c
@@ -335,9 +335,9 @@ const sd_bus_vtable manager_vtable[] = {
};
int machine_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata) {
+ _cleanup_strv_free_ char **l = NULL;
Machine *machine = NULL;
Manager *m = userdata;
- char **l = NULL;
Iterator i;
int r;
@@ -360,6 +360,8 @@ int machine_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *
}
*nodes = l;
+ l = NULL;
+
return 1;
}
@@ -456,6 +458,8 @@ int match_unit_removed(sd_bus *bus, sd_bus_message *message, void *userdata) {
int match_reloading(sd_bus *bus, sd_bus_message *message, void *userdata) {
Manager *m = userdata;
+ Machine *machine;
+ Iterator i;
int b, r;
assert(bus);
@@ -466,16 +470,14 @@ int match_reloading(sd_bus *bus, sd_bus_message *message, void *userdata) {
return 0;
}
- /* systemd finished reloading, let's recheck all our machines */
- if (!b) {
- Machine *machine;
- Iterator i;
+ if (b)
+ return 0;
- log_debug("System manager has been reloaded, rechecking machines...");
+ /* systemd finished reloading, let's recheck all our machines */
+ log_debug("System manager has been reloaded, rechecking machines...");
- HASHMAP_FOREACH(machine, m->machines, i)
- machine_add_to_gc_queue(machine);
- }
+ HASHMAP_FOREACH(machine, m->machines, i)
+ machine_add_to_gc_queue(machine);
return 0;
}
@@ -507,7 +509,7 @@ int manager_start_scope(
if (r < 0)
return r;
- r = sd_bus_message_append(m, "ss", scope, "fail");
+ r = sd_bus_message_append(m, "ss", strempty(scope), "fail");
if (r < 0)
return r;
@@ -620,23 +622,18 @@ int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, c
}
int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error) {
- _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
- int r;
-
assert(manager);
assert(unit);
- r = sd_bus_call_method(
+ return sd_bus_call_method(
manager->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"KillUnit",
error,
- &reply,
+ NULL,
"ssi", unit, who == KILL_LEADER ? "main" : "all", signo);
-
- return r;
}
int manager_unit_is_active(Manager *manager, const char *unit) {
diff --git a/src/machine/machined.c b/src/machine/machined.c
index 6391551..25de0d5 100644
--- a/src/machine/machined.c
+++ b/src/machine/machined.c
@@ -47,13 +47,13 @@ Manager *manager_new(void) {
m->machines = hashmap_new(string_hash_func, string_compare_func);
m->machine_units = hashmap_new(string_hash_func, string_compare_func);
- r = sd_event_new(&m->event);
- if (r < 0) {
+ if (!m->machines || !m->machine_units) {
manager_free(m);
return NULL;
}
- if (!m->machines || !m->machine_units) {
+ r = sd_event_new(&m->event);
+ if (r < 0) {
manager_free(m);
return NULL;
}
@@ -284,7 +284,7 @@ void manager_gc(Manager *m, bool drop_not_started) {
LIST_REMOVE(gc_queue, m->machine_gc_queue, machine);
machine->in_gc_queue = false;
- if (machine_check_gc(machine, drop_not_started) == 0) {
+ if (!machine_check_gc(machine, drop_not_started)) {
machine_stop(machine);
machine_free(machine);
}
diff --git a/src/machine/machined.h b/src/machine/machined.h
index c47a468..dfb63bd 100644
--- a/src/machine/machined.h
+++ b/src/machine/machined.h
@@ -48,7 +48,6 @@ Manager *manager_new(void);
void manager_free(Manager *m);
int manager_add_machine(Manager *m, const char *name, Machine **_machine);
-
int manager_enumerate_machines(Manager *m);
int manager_startup(Manager *m);
commit 6ee69bab116f6691dbd04debba5d47dc97d2a6cc
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Nov 5 00:51:14 2013 +0100
event: add some well-defined priority values of event sources
diff --git a/src/systemd/sd-event.h b/src/systemd/sd-event.h
index 6ac2de8..46d1d05 100644
--- a/src/systemd/sd-event.h
+++ b/src/systemd/sd-event.h
@@ -53,6 +53,13 @@ enum {
SD_EVENT_FINISHED
};
+enum {
+ /* And everything inbetween and outside is good too */
+ SD_PRIORITY_IMPORTANT = -100,
+ SD_PRIORITY_NORMAL = 0,
+ SD_PRIORITY_IDLE = 100
+};
+
typedef int (*sd_io_handler_t)(sd_event_source *s, int fd, uint32_t revents, void *userdata);
typedef int (*sd_time_handler_t)(sd_event_source *s, uint64_t usec, void *userdata);
typedef int (*sd_signal_handler_t)(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata);
commit e65040306900e36aaa84b52428be3490bf107850
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Nov 5 00:50:34 2013 +0100
bus: make it easy to serialize C99 bools and uids/gids/pids via vtable properties
diff --git a/src/libsystemd-bus/bus-util.c b/src/libsystemd-bus/bus-util.c
index bb5dd29..ad1cb1a 100644
--- a/src/libsystemd-bus/bus-util.c
+++ b/src/libsystemd-bus/bus-util.c
@@ -789,3 +789,33 @@ int bus_open_transport(BusTransport transport, const char *host, bool user, sd_b
return r;
}
+
+int bus_property_get_bool(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ int b = *(bool*) userdata;
+
+ return sd_bus_message_append_basic(reply, 'b', &b);
+}
+
+int bus_property_get_uid(
+ sd_bus *bus,
+ const char *path,
+ const char *interface,
+ const char *property,
+ sd_bus_message *reply,
+ sd_bus_error *error,
+ void *userdata) {
+
+ assert_cc(sizeof(uint32_t) == sizeof(uid_t));
+ assert_cc(sizeof(uint32_t) == sizeof(gid_t));
+ assert_cc(sizeof(uint32_t) == sizeof(pid_t));
+
+ return sd_bus_message_append_basic(reply, 'u', userdata);
+}
diff --git a/src/libsystemd-bus/bus-util.h b/src/libsystemd-bus/bus-util.h
index ddb9264..b05cac1 100644
--- a/src/libsystemd-bus/bus-util.h
+++ b/src/libsystemd-bus/bus-util.h
@@ -62,6 +62,12 @@ int bus_open_transport(BusTransport transport, const char *host, bool user, sd_b
int bus_generic_print_property(const char *name, sd_bus_message *property, bool all);
+int bus_property_get_bool(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, sd_bus_error *error, void *userdata);
+int bus_property_get_uid(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, sd_bus_error *error, void *userdata);
+
+#define bus_property_get_gid bus_property_get_uid
+#define bus_property_get_pid bus_property_get_uid
+
DEFINE_TRIVIAL_CLEANUP_FUNC(sd_bus*, sd_bus_unref);
DEFINE_TRIVIAL_CLEANUP_FUNC(sd_bus_message*, sd_bus_message_unref);
commit c13c7de3bf419db3ae93a9acd2d95a5a19e408ed
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Nov 5 00:49:50 2013 +0100
bus: support implicit serialization of strv string arrays within vtables
diff --git a/src/libsystemd-bus/bus-objects.c b/src/libsystemd-bus/bus-objects.c
index 05d0015..92781e9 100644
--- a/src/libsystemd-bus/bus-objects.c
+++ b/src/libsystemd-bus/bus-objects.c
@@ -312,7 +312,6 @@ static int invoke_property_get(
sd_bus_error *error,
void *userdata) {
- int r;
const void *p;
assert(bus);
@@ -327,6 +326,9 @@ static int invoke_property_get(
/* Automatic handling if no callback is defined. */
+ if (streq(v->x.property.signature, "as"))
+ return sd_bus_message_append_strv(m, *(char***) userdata);
+
assert(signature_is_single(v->x.property.signature, false));
assert(bus_type_is_basic(v->x.property.signature[0]));
@@ -347,11 +349,7 @@ static int invoke_property_get(
break;
}
- r = sd_bus_message_append_basic(m, v->x.property.signature[0], p);
- if (r < 0)
- return r;
-
- return 1;
+ return sd_bus_message_append_basic(m, v->x.property.signature[0], p);
}
static int invoke_property_set(
@@ -1587,7 +1585,7 @@ static int add_object_vtable_internal(
if (!member_name_is_valid(v->x.property.member) ||
!signature_is_single(v->x.property.signature, false) ||
- !(v->x.property.get || bus_type_is_basic(v->x.property.signature[0])) ||
+ !(v->x.property.get || bus_type_is_basic(v->x.property.signature[0]) || streq(v->x.property.signature, "as")) ||
v->flags & SD_BUS_VTABLE_METHOD_NO_REPLY ||
(v->flags & SD_BUS_VTABLE_PROPERTY_INVALIDATE_ONLY && !(v->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE))) {
r = -EINVAL;
commit c9b6cb28c35e18649575b82466d7d6eb29aa5196
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Nov 5 00:49:19 2013 +0100
bus: dbus-daemons' access messages are a bit too verbose
diff --git a/src/libsystemd-bus/bus-error.c b/src/libsystemd-bus/bus-error.c
index c347b10..35e2614 100644
--- a/src/libsystemd-bus/bus-error.c
+++ b/src/libsystemd-bus/bus-error.c
@@ -448,11 +448,18 @@ int sd_bus_error_set_errnof(sd_bus_error *e, int error, const char *format, ...)
const char *bus_error_message(const sd_bus_error *e, int error) {
+ if (e) {
+ /* Sometimes the D-Bus server is a little bit too verbose with
+ * its error messages, so let's override them here */
+ if (sd_bus_error_has_name(e, SD_BUS_ERROR_ACCESS_DENIED))
+ return "Access denied";
+
+ if (e->message)
+ return e->message;
+ }
+
if (error < 0)
error = -error;
- if (e && e->message)
- return e->message;
-
return strerror(error);
}
commit 90e071d1d59be05fcba66561439c3ca67c80ee20
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Nov 5 00:48:47 2013 +0100
update TODO
diff --git a/TODO b/TODO
index 7ad00f7..fb0ff63 100644
--- a/TODO
+++ b/TODO
@@ -415,11 +415,14 @@ Features:
* timer units:
- configurable jitter for timer events
+ - Adjust timers to be triggered at the same time as sd-event timers
- timer events with system resume
- timer units should get the ability to trigger when:
o CLOCK_REALTIME makes jumps (TFD_TIMER_CANCEL_ON_SET)
o DST changes
- Support 2012-02~4 as syntax for specifying the fourth to last day of the month.
+ - Modulate timer frequency based on battery state
+ - anacron-like feature
* update the kernel's TZ (sys_tz) when DST changes
More information about the systemd-commits
mailing list