shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2025-02-28 05:57:33 +03:00
Code

logind: port logind to libsystemd-bus

Browse Source
This commit is contained in:
Lennart Poettering 2013-11-05 01:10:21 +01:00
parent 6d1bd3b2bb
commit cc37738108
24 changed files with 3103 additions and 3974 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Makefile.am
View File

@ -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

12
src/libsystemd-bus/bus-util.h
View File

@ -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"

9
src/login/logind-acl.c
View File

@ -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) {

52
src/login/logind-action.c
View File

@ -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;
}

113
src/login/logind-button.c
View File

@ -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);

3
src/login/logind-button.h
View File

@ -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);

43
src/login/logind-core.c
View File

@ -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@tty%i.service", vtnr) < 0) {
log_error("Could not allocate service name.");
r = -ENOMEM;
goto finish;
}
if (asprintf(&name, "autovt@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;
}

3741
src/login/logind-dbus.c
View File

File diff suppressed because it is too large Load Diff

7
src/login/logind-device.c
View File

@ -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);
}

106
src/login/logind-inhibit.c
View File

@ -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);
hashmap_remove(i->manager->inhibitors, i->id);
inhibitor_remove_fifo(i);
free(i->who);
free(i->why);
hashmap_remove(i->manager->inhibitors, i->id);
inhibitor_remove_fifo(i);
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;

2
src/login/logind-inhibit.h
View File

@ -52,6 +52,8 @@ typedef enum InhibitMode {
struct Inhibitor {
Manager *manager;
sd_event_source *event_source;
char *id;
char *state_file;

574
src/login/logind-seat-dbus.c
View File

@ -22,329 +22,265 @@
#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" \
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) {
#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;
_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);
if (!p)
return -ENOMEM;
} else {
id = "";
path = "/";
}
if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &id) ||
!dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &path))
return -ENOMEM;
if (!dbus_message_iter_close_container(i, &sub))
return -ENOMEM;
return 0;
return sd_bus_message_append(reply, "(so)", s->active ? s->active->id : "", p);
}
static int bus_seat_append_sessions(DBusMessageIter *i, const char *property, void *data) {
DBusMessageIter sub, sub2;
Seat *s = data;
Session *session;
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) {
assert(i);
assert(property);
Seat *s = userdata;
assert(bus);
assert(reply);
assert(s);
if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(so)", &sub))
return -ENOMEM;
return sd_bus_message_append(reply, "b", seat_can_multi_session(s));
}
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(bus);
assert(reply);
assert(s);
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;
if (!dbus_message_iter_close_container(&sub, &sub2))
return -ENOMEM;
}
if (!dbus_message_iter_close_container(i, &sub))
return -ENOMEM;
return 0;
}
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 bus_seat_append_can_tty(DBusMessageIter *i, const char *property, void *data) {
Seat *s = data;
dbus_bool_t b;
assert(i);
assert(property);
assert(s);
b = seat_can_tty(s);
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
return -ENOMEM;
return 0;
}
static int bus_seat_append_can_graphical(DBusMessageIter *i, const char *property, void *data) {
Seat *s = data;
dbus_bool_t b;
assert(i);
assert(property);
assert(s);
b = seat_can_graphical(s);
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
return -ENOMEM;
return 0;
}
static int bus_seat_append_idle_hint(DBusMessageIter *i, const char *property, void *data) {
Seat *s = data;
dbus_bool_t b;
assert(i);
assert(property);
assert(s);
b = seat_get_idle_hint(s, NULL) > 0;
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
return -ENOMEM;
return 0;
}
static int bus_seat_append_idle_hint_since(DBusMessageIter *i, const char *property, void *data) {
Seat *s = data;
dual_timestamp t;
uint64_t k;
assert(i);
assert(property);
assert(s);
seat_get_idle_hint(s, &t);
k = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &k))
return -ENOMEM;
return 0;
}
static int get_seat_for_path(Manager *m, const char *path, Seat **_s) {
_cleanup_free_ char *id = NULL;
Seat *s;
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;
}
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;
assert(s);
assert(connection);
assert(message);
dbus_error_init(&error);
if (dbus_message_is_method_call(message, "org.freedesktop.login1.Seat", "Terminate")) {
r = seat_stop_sessions(s);
r = sd_bus_message_append(reply, "(so)", session->id, p);
if (r < 0)
return bus_send_error_reply(connection, message, NULL, r);
return r;
reply = dbus_message_new_method_return(message);
if (!reply)
goto oom;
} else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Seat", "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(s->manager->sessions, name);
if (!session || session->seat != s)
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 {
const BusBoundProperties bps[] = {
{ "org.freedesktop.login1.Seat", bus_login_seat_properties, s },
{ 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_close_container(reply);
if (r < 0)
return r;
return DBUS_HANDLER_RESULT_HANDLED;
oom:
dbus_error_free(&error);
return DBUS_HANDLER_RESULT_NEED_MEMORY;
return 1;
}
static DBusHandlerResult seat_message_handler(
DBusConnection *connection,
DBusMessage *message,
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) {
Manager *m = userdata;
Seat *s;
int r;
Seat *s = userdata;
r = get_seat_for_path(m, dbus_message_get_path(message), &s);
if (r < 0) {
assert(bus);
assert(reply);
assert(s);
if (r == -ENOMEM)
return DBUS_HANDLER_RESULT_NEED_MEMORY;
if (r == -ENOENT) {
DBusError e;
dbus_error_init(&e);
dbus_set_error_const(&e, DBUS_ERROR_UNKNOWN_OBJECT, "Unknown seat");
return bus_send_error_reply(connection, message, &e, r);
}
return bus_send_error_reply(connection, message, NULL, r);
}
return seat_message_dispatch(s, connection, message);
return sd_bus_message_append(reply, "b", seat_get_idle_hint(s, NULL) > 0);
}
const DBusObjectPathVTable bus_seat_vtable = {
.message_function = seat_message_handler
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(bus);
assert(reply);
assert(s);
r = seat_get_idle_hint(s, &t);
if (r < 0)
return r;
u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
return sd_bus_message_append(reply, "t", u);
}
static int method_terminate(sd_bus *bus, sd_bus_message *message, void *userdata) {
Seat *s = userdata;
int r;
assert(bus);
assert(message);
assert(s);
r = seat_stop_sessions(s);
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(sd_bus *bus, sd_bus_message *message, void *userdata) {
Seat *s = userdata;
const char *name;
Session *session;
int r;
assert(bus);
assert(message);
assert(s);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return sd_bus_reply_method_errno(bus, message, r, NULL);
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);
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);
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);
}
const sd_bus_vtable seat_vtable[] = {
SD_BUS_VTABLE_START(0),
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),
SD_BUS_METHOD("Terminate", NULL, NULL, method_terminate, 0),
SD_BUS_METHOD("ActivateSession", "s", NULL, method_activate_session, 0),
SD_BUS_VTABLE_END
};
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;
assert(bus);
assert(path);
assert(interface);
assert(found);
assert(m);
p = startswith(path, "/org/freedesktop/login1/seat/");
if (!p)
return 0;
e = bus_path_unescape(p);
if (!e)
return -ENOMEM;
seat = hashmap_get(m->seats, e);
if (!seat)
return 0;
*found = seat;
return 1;
}
char *seat_bus_path(Seat *s) {
_cleanup_free_ char *t = NULL;
@ -357,38 +293,57 @@ char *seat_bus_path(Seat *s) {
return strappend("/org/freedesktop/login1/seat/", t);
}
int seat_node_enumerator(sd_bus *bus, const char *path, char ***nodes, void *userdata) {
_cleanup_strv_free_ char **l = NULL;
Manager *m = userdata;
Seat *seat;
Iterator i;
int r;
assert(bus);
assert(path);
assert(nodes);
HASHMAP_FOREACH(seat, m->seats, i) {
char *p;
p = seat_bus_path(seat);
if (!p)
return -ENOMEM;
r = strv_push(&l, p);
if (r < 0) {
free(p);
return r;
}
}
*nodes = l;
l = NULL;
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;
l = strv_from_stdarg_alloca(properties);
if (!dbus_connection_send(s->manager->bus, m, NULL))
return -ENOMEM;
return 0;
return sd_bus_emit_properties_changed_strv(s->manager->bus, p, "org.freedesktop.login1.Seat", l);
}

39
src/login/logind-seat.c
View File

@ -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);
if (fd < 0)
return -errno;
r = fd < 0 ? -errno : 0;
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);
}

11
src/login/logind-seat.h
View File

@ -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);
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);
extern const DBusObjectPathVTable bus_seat_vtable;
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_;

1026
src/login/logind-session-dbus.c
View File

File diff suppressed because it is too large Load Diff

52
src/login/logind-session-device.c
View File

@ -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) {

123
src/login/logind-session.c
View File

@ -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");
seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
user_send_changed(s->user,
"IdleHint\0"
"IdleSinceHint\0"
"IdleSinceHintMonotonic\0");
user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL);
}
manager_send_changed(s->manager,
"IdleHint\0"
"IdleSinceHint\0"
"IdleSinceHintMonotonic\0");
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);

17
src/login/logind-session.h
View File

@ -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_;

465
src/login/logind-user-dbus.c
View File

@ -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"
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) {
#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;
User *u = userdata;
assert(i);
assert(property);
assert(bus);
assert(reply);
assert(u);
if (!dbus_message_iter_open_container(i, DBUS_TYPE_STRUCT, NULL, &sub))
p = u->display ? session_bus_path(u->display) : strdup("/");
if (!p)
return -ENOMEM;
if (u->display) {
id = u->display->id;
path = p = session_bus_path(u->display);
if (!p)
return -ENOMEM;
} else {
id = "";
path = "/";
}
if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &id) ||
!dbus_message_iter_append_basic(&sub, DBUS_TYPE_OBJECT_PATH, &path))
return -ENOMEM;
if (!dbus_message_iter_close_container(i, &sub))
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;
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);
User *u = userdata;
assert(bus);
assert(reply);
assert(u);
state = user_state_to_string(user_get_state(u));
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &state))
return -ENOMEM;
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;
}
r = sd_bus_message_append(reply, "(so)", session->id, p);
if (r < 0)
return r;
free(p);
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;
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) {
assert(i);
assert(property);
User *u = userdata;
assert(bus);
assert(reply);
assert(u);
b = user_get_idle_hint(u, NULL) > 0;
if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
return -ENOMEM;
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;
r = safe_atolu(path + 30, &lu);
if (r < 0)
return r;
u = hashmap_get(m->users, ULONG_TO_PTR(lu));
if (!u)
return -ENOENT;
*_u = u;
return 0;
}
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;
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 sd_bus_reply_method_errno(bus, message, r, NULL);
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;
}
return DBUS_HANDLER_RESULT_HANDLED;
oom:
dbus_error_free(&error);
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) {
Manager *m = userdata;
User *u;
static int method_kill(sd_bus *bus, sd_bus_message *message, void *userdata) {
User *u = userdata;
int32_t signo;
int r;
r = get_user_for_path(m, dbus_message_get_path(message), &u);
if (r < 0) {
assert(bus);
assert(message);
assert(u);
if (r == -ENOMEM)
return DBUS_HANDLER_RESULT_NEED_MEMORY;
r = sd_bus_message_read(message, "i", &signo);
if (r < 0)
return sd_bus_reply_method_errno(bus, message, r, NULL);
if (r == -ENOENT) {
DBusError e;
if (signo <= 0 || signo >= _NSIG)
return sd_bus_reply_method_errorf(bus, message, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
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 = user_kill(u, signo);
if (r < 0)
return sd_bus_reply_method_errno(bus, message, r, NULL);
return bus_send_error_reply(connection, message, NULL, r);
}
return user_message_dispatch(u, connection, message);
return sd_bus_reply_method_return(bus, message, NULL);
}
const DBusObjectPathVTable bus_user_vtable = {
.message_function = user_message_handler
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;
unsigned long lu;
const char *p;
User *user;
int r;
assert(bus);
assert(path);
assert(interface);
assert(found);
assert(m);
p = startswith(path, "/org/freedesktop/login1/user/_");
if (!p)
return 0;
r = safe_atolu(p, &lu);
if (r < 0)
return 0;
user = hashmap_get(m->users, ULONG_TO_PTR(lu));
if (!user)
return 0;
*found = user;
return 1;
}
char *user_bus_path(User *u) {
char *s;
@ -336,42 +255,57 @@ char *user_bus_path(User *u) {
return s;
}
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(bus);
assert(path);
assert(nodes);
HASHMAP_FOREACH(user, m->users, i) {
char *p;
p = user_bus_path(user);
if (!p)
return -ENOMEM;
r = strv_push(&l, p);
if (r < 0) {
free(p);
return r;
}
}
*nodes = l;
l = NULL;
return 1;
}
int user_send_signal(User *u, bool new_user) {
_cleanup_dbus_message_unref_ DBusMessage *m = NULL;
_cleanup_free_ char *p = NULL;
uint32_t uid;
assert(u);
m = dbus_message_new_signal("/org/freedesktop/login1",
"org.freedesktop.login1.Manager",
new_user ? "UserNew" : "UserRemoved");
if (!m)
return -ENOMEM;
p = user_bus_path(u);
if (!p)
return -ENOMEM;
uid = u->uid;
if (!dbus_message_append_args(
m,
DBUS_TYPE_UINT32, &uid,
DBUS_TYPE_OBJECT_PATH, &p,
DBUS_TYPE_INVALID))
return -ENOMEM;
if (!dbus_connection_send(u->manager->bus, m, NULL))
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;
l = strv_from_stdarg_alloca(properties);
if (!dbus_connection_send(u->manager->bus, m, NULL))
return -ENOMEM;
return 0;
return sd_bus_emit_properties_changed_strv(u->manager->bus, p, "org.freedesktop.login1.User", l);
}

67
src/login/logind-user.c
View File

@ -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) {

9
src/login/logind-user.h
View File

@ -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_;

525
src/login/logind.c
View File

@ -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);
}
bus_verify_polkit_async_registry_free(m->bus, m->polkit_registry);
if (m->bus_fd >= 0)
close_nointr_nofail(m->bus_fd);
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;
assert_se(m);
assert_se(fd >= 0);
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;
}
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;
}
b = hashmap_get(m->button_fds, INT_TO_PTR(fd + 1));
if (b) {
assert(b->fd == fd);
button_process(b);
return;
}
assert_not_reached("Got event for unknown fd");
}
static int manager_connect_bus(Manager *m) {
DBusError error;
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
int r;
struct epoll_event ev = {
.events = EPOLLIN,
.data.u32 = FD_BUS,
};
assert(m);
assert(!m->bus);
assert(m->bus_fd < 0);
dbus_error_init(&error);
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_open_system(&m->bus);
if (r < 0) {
log_error("Failed to connect to system bus: %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_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;
}
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_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;
}
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_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;
}
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_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_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_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;
}
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_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;
}
r = bus_method_call_with_reply(
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;
}
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;
}
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;
}
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;
}
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;
}
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 = 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;

67
src/login/logind.h
View File

@ -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);

9
src/login/pam-module.c
View File

@ -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",