HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/login/logind-dbus.c
Git blob: 38cb6ce3dd8e7c377cf4004e698626c8561e1006
Lines 1001–2000 of 4,785
if (r < 0)
goto fail;
session->original_type = session->type = type;
session->remote = remote;
session->vtnr = vtnr;
session->class = class;
/* Once the first session that is of a pinning class shows up we'll change the GC mode for the user
* from USER_GC_BY_ANY to USER_GC_BY_PIN, so that the user goes away once the last pinning session
* goes away. Background: we want that user@.service – when started manually – remains around (which
* itself is a non-pinning session), but gets stopped when the last pinning session goes away. */
if (SESSION_CLASS_PIN_USER(class))
user->gc_mode = USER_GC_BY_PIN;
if (!isempty(tty)) {
r = strdup_to(&session->tty, tty);
if (r < 0)
goto fail;
session->tty_validity = TTY_FROM_PAM;
}
if (!isempty(display)) {
r = strdup_to(&session->display, display);
if (r < 0)
goto fail;
}
if (!isempty(remote_user)) {
r = strdup_to(&session->remote_user, remote_user);
if (r < 0)
goto fail;
}
if (!isempty(remote_host)) {
r = strdup_to(&session->remote_host, remote_host);
if (r < 0)
goto fail;
}
if (!isempty(service)) {
r = strdup_to(&session->service, service);
if (r < 0)
goto fail;
}
if (!isempty(desktop)) {
r = strdup_to(&session->desktop, desktop);
if (r < 0)
goto fail;
}
r = strv_copy_unless_empty(extra_device_access, &session->extra_device_access);
if (r < 0)
goto fail;
if (seat) {
r = seat_attach_session(seat, session);
if (r < 0)
goto fail;
}
*ret_session = session;
return 0;
fail:
if (session)
session_add_to_gc_queue(session);
if (user)
user_add_to_gc_queue(user);
return r;
}
static int manager_create_session_by_bus(
Manager *m,
sd_bus_message *message,
sd_bus_error *error,
uid_t uid,
pid_t leader_pid,
int leader_pidfd,
const char *service,
const char *type,
const char *class,
const char *desktop,
const char *cseat,
uint32_t vtnr,
const char *tty,
const char *display,
int remote,
const char *remote_user,
const char *remote_host,
uint64_t flags) {
int r;
assert(m);
assert(message);
if (!uid_is_valid(uid))
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid UID");
if (flags != 0)
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Flags must be zero.");
_cleanup_(pidref_done) PidRef leader = PIDREF_NULL;
if (leader_pidfd >= 0)
r = pidref_set_pidfd(&leader, leader_pidfd);
else if (leader_pid == 0)
r = bus_query_sender_pidref(message, &leader);
else {
if (leader_pid < 0)
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Leader PID is not valid");
r = pidref_set_pid(&leader, leader_pid);
}
if (r < 0)
return r;
if (leader.pid == 1 || pidref_is_self(&leader))
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid leader PID");
if (leader.fd < 0)
return sd_bus_error_set_errnof(error, EUNATCH, "Leader PIDFD not available");
SessionType t;
if (isempty(type))
t = _SESSION_TYPE_INVALID;
else {
t = session_type_from_string(type);
if (t < 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
"Invalid session type %s", type);
}
SessionClass c;
if (isempty(class))
c = _SESSION_CLASS_INVALID;
else {
c = session_class_from_string(class);
if (c < 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
"Invalid session class %s", class);
if (c == SESSION_NONE)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
"Refusing session class %s", class);
}
if (isempty(desktop))
desktop = NULL;
else {
if (!string_is_safe(desktop, STRING_ALLOW_GLOBS))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
"Invalid desktop string %s", desktop);
}
Seat *seat = NULL;
if (isempty(cseat))
seat = NULL;
else {
seat = hashmap_get(m->seats, cseat);
if (!seat)
return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT,
"No seat '%s' known", cseat);
}
if (isempty(tty))
tty = NULL;
else if (tty_is_vc(tty)) {
int v;
if (!seat)
seat = m->seat0;
else if (seat != m->seat0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
"TTY %s is virtual console but seat %s is not seat0", tty, seat->id);
v = vtnr_from_tty(tty);
if (v <= 0)
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
"Cannot determine VT number from virtual console TTY %s", tty);
if (vtnr == 0)
vtnr = (uint32_t) v;
else if (vtnr != (uint32_t) v)
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS,
"Specified TTY and VT number do not match");
} else if (tty_is_console(tty)) {
if (!seat)
seat = m->seat0;
else if (seat != m->seat0)
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS,
"Console TTY specified but seat is not seat0");
if (vtnr != 0)
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS,
"Console TTY specified but VT number is not 0");
}
if (seat) {
if (seat_has_vts(seat)) {
if (!vtnr_is_valid(vtnr))
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS,
"VT number out of range");
} else {
if (vtnr != 0)
return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS,
"Seat has no VTs but VT number not 0");
}
}
Session *session;
r = manager_create_session(
m,
uid,
&leader,
service,
t,
c,
desktop,
seat,
vtnr,
tty,
display,
remote,
remote_user,
remote_host,
/* extra_device_access= */ NULL,
&session);
if (r == -EBUSY)
return sd_bus_error_set(error, BUS_ERROR_SESSION_BUSY, "Already running in a session or user slice");
if (r == -EADDRNOTAVAIL)
return sd_bus_error_set(error, BUS_ERROR_SESSION_BUSY, "Virtual terminal already occupied by a session");
if (r == -EUSERS)
return sd_bus_error_setf(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Maximum number of sessions (%" PRIu64 ") reached, refusing further sessions.", m->sessions_max);
if (r < 0)
return r;
r = sd_bus_message_enter_container(message, 'a', "(sv)");
if (r < 0)
goto fail;
r = session_start(session, message, error);
if (r < 0)
goto fail;
r = sd_bus_message_exit_container(message);
if (r < 0)
goto fail;
session->create_message = sd_bus_message_ref(message);
/* Now call into session_send_create_reply(), which will reply to this method call for us. Or it
* won't – in case we just spawned a session scope and/or user service manager, and they aren't ready
* yet. We'll call session_create_reply() again once the session scope or the user service manager is
* ready, where the function will check again if a reply is then ready to be sent, and then do so if
* all is complete - or wait again. */
r = session_send_create_reply(session, /* error= */ NULL);
if (r < 0)
goto fail;
return 1;
fail:
if (session)
session_add_to_gc_queue(session);
return r;
}
static int method_create_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *service, *type, *class, *cseat, *tty, *display, *remote_user, *remote_host, *desktop;
pid_t leader_pid;
uint32_t vtnr;
uid_t uid;
int remote, r;
assert(message);
assert_cc(sizeof(pid_t) == sizeof(uint32_t));
assert_cc(sizeof(uid_t) == sizeof(uint32_t));
r = sd_bus_message_read(
message,
"uusssssussbss",
&uid,
&leader_pid,
&service,
&type,
&class,
&desktop,
&cseat,
&vtnr,
&tty,
&display,
&remote,
&remote_user,
&remote_host);
if (r < 0)
return r;
return manager_create_session_by_bus(
userdata,
message,
error,
uid,
leader_pid,
/* leader_pidfd= */ -EBADF,
service,
type,
class,
desktop,
cseat,
vtnr,
tty,
display,
remote,
remote_user,
remote_host,
/* flags= */ 0);
}
static int method_create_session_pidfd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *service, *type, *class, *cseat, *tty, *display, *remote_user, *remote_host, *desktop;
uint64_t flags;
uint32_t vtnr;
uid_t uid;
int leader_fd = -EBADF, remote, r;
r = sd_bus_message_read(
message,
"uhsssssussbsst",
&uid,
&leader_fd,
&service,
&type,
&class,
&desktop,
&cseat,
&vtnr,
&tty,
&display,
&remote,
&remote_user,
&remote_host,
&flags);
if (r < 0)
return r;
return manager_create_session_by_bus(
userdata,
message,
error,
uid,
/* leader_pid= */ 0,
leader_fd,
service,
type,
class,
desktop,
cseat,
vtnr,
tty,
display,
remote,
remote_user,
remote_host,
flags);
}
static int method_release_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
Session *session, *sender_session;
const char *name;
int r;
assert(message);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
r = manager_get_session_from_creds(m, message, name, error, &session);
if (r < 0)
return r;
r = get_sender_session(m, message, /* consult_display= */ false, error, &sender_session);
if (r < 0)
return r;
if (session != sender_session)
return sd_bus_error_set(error, SD_BUS_ERROR_ACCESS_DENIED,
"Refused to release session, since it doesn't match the one of the client");
r = session_release(session);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int method_activate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
Session *session;
const char *name;
int r;
assert(message);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
r = manager_get_session_from_creds(m, message, name, error, &session);
if (r < 0)
return r;
/* PolicyKit is done by bus_session_method_activate() */
return bus_session_method_activate(message, session, error);
}
static int method_activate_session_on_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *session_name, *seat_name;
Manager *m = ASSERT_PTR(userdata);
Session *session;
Seat *seat;
int r;
assert(message);
/* Same as ActivateSession() but refuses to work if the seat doesn't match */
r = sd_bus_message_read(message, "ss", &session_name, &seat_name);
if (r < 0)
return r;
r = manager_get_session_from_creds(m, message, session_name, error, &session);
if (r < 0)
return r;
r = manager_get_seat_from_creds(m, message, seat_name, error, &seat);
if (r < 0)
return r;
if (session->seat != seat)
return sd_bus_error_setf(error, BUS_ERROR_SESSION_NOT_ON_SEAT,
"Session %s not on seat %s", session_name, seat_name);
r = check_polkit_chvt(message, m, error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = session_activate(session);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int method_lock_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
Session *session;
const char *name;
int r;
assert(message);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
r = manager_get_session_from_creds(m, message, name, error, &session);
if (r < 0)
return r;
return bus_session_method_lock(message, session, error);
}
static int method_lock_sessions(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
int r;
assert(message);
r = bus_verify_polkit_async(
message,
"org.freedesktop.login1.lock-sessions",
/* details= */ NULL,
&m->polkit_registry,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* Will call us back */
r = session_send_lock_all(m, streq(sd_bus_message_get_member(message), "LockSessions"));
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int method_kill_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *name;
Manager *m = ASSERT_PTR(userdata);
Session *session;
int r;
assert(message);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
r = manager_get_session_from_creds(m, message, name, error, &session);
if (r < 0)
return r;
return bus_session_method_kill(message, session, error);
}
static int method_kill_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
uint32_t uid;
User *user;
int r;
assert(message);
r = sd_bus_message_read(message, "u", &uid);
if (r < 0)
return r;
r = manager_get_user_from_creds(m, message, uid, error, &user);
if (r < 0)
return r;
return bus_user_method_kill(message, user, error);
}
static int method_terminate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
const char *name;
Session *session;
int r;
assert(message);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
r = manager_get_session_from_creds(m, message, name, error, &session);
if (r < 0)
return r;
return bus_session_method_terminate(message, session, error);
}
static int method_terminate_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
uint32_t uid;
User *user;
int r;
assert(message);
r = sd_bus_message_read(message, "u", &uid);
if (r < 0)
return r;
r = manager_get_user_from_creds(m, message, uid, error, &user);
if (r < 0)
return r;
return bus_user_method_terminate(message, user, error);
}
static int method_terminate_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
const char *name;
Seat *seat;
int r;
assert(message);
r = sd_bus_message_read(message, "s", &name);
if (r < 0)
return r;
r = manager_get_seat_from_creds(m, message, name, error, &seat);
if (r < 0)
return r;
return bus_seat_method_terminate(message, seat, error);
}
static int method_set_user_linger(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
uint32_t uid, auth_uid;
int r, enable, interactive;
assert(message);
r = sd_bus_message_read(message, "ubb", &uid, &enable, &interactive);
if (r < 0)
return r;
r = sd_bus_query_sender_creds(message,
SD_BUS_CREDS_EUID|SD_BUS_CREDS_OWNER_UID|SD_BUS_CREDS_AUGMENT,
&creds);
if (r < 0)
return r;
if (!uid_is_valid(uid)) {
/* Note that we get the owner UID of the session or user unit, not the actual client UID here! */
r = sd_bus_creds_get_owner_uid(creds, &uid);
if (r < 0)
return r;
}
/* owner_uid is racy, so for authorization we must use euid */
r = sd_bus_creds_get_euid(creds, &auth_uid);
if (r < 0)
return r;
_cleanup_free_ struct passwd *pw = NULL;
r = getpwuid_malloc(uid, &pw);
if (r < 0)
return r;
r = bus_verify_polkit_async_full(
message,
uid == auth_uid ? "org.freedesktop.login1.set-self-linger" :
"org.freedesktop.login1.set-user-linger",
/* details= */ NULL,
/* good_user= */ UID_INVALID,
interactive ? POLKIT_ALLOW_INTERACTIVE : 0,
&m->polkit_registry,
/* ret_admin= */ NULL,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
(void) mkdir_p_label("/var/lib/systemd", 0755);
r = mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0, MKDIR_WARN_MODE);
if (r < 0)
return r;
_cleanup_free_ char *escaped = NULL;
const char *path;
User *u;
escaped = cescape(pw->pw_name);
if (!escaped)
return -ENOMEM;
path = strjoina("/var/lib/systemd/linger/", escaped);
if (enable) {
r = touch(path);
if (r < 0)
return r;
if (manager_add_user_by_uid(m, uid, &u) >= 0) {
(void) user_send_changed(u, "Linger");
r = user_start(u);
if (r < 0) {
user_add_to_gc_queue(u);
return r;
}
}
} else {
r = unlink(path);
if (r < 0 && errno != ENOENT)
return -errno;
u = hashmap_get(m->users, UID_TO_PTR(uid));
if (u) {
/* Make sure that disabling lingering will terminate the user tracking if no sessions pin it. */
u->gc_mode = USER_GC_BY_PIN;
user_add_to_gc_queue(u);
(void) user_send_changed(u, "Linger");
}
}
return sd_bus_reply_method_return(message, NULL);
}
static int trigger_device(Manager *m, sd_device *parent) {
_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
int r;
assert(m);
r = sd_device_enumerator_new(&e);
if (r < 0)
return r;
r = sd_device_enumerator_allow_uninitialized(e);
if (r < 0)
return r;
if (parent) {
r = sd_device_enumerator_add_match_parent(e, parent);
if (r < 0)
return r;
}
FOREACH_DEVICE(e, d) {
r = sd_device_trigger(d, SD_DEVICE_CHANGE);
if (r < 0)
log_device_debug_errno(d, r, "Failed to trigger device, ignoring: %m");
}
return 0;
}
static int attach_device(Manager *m, const char *seat, const char *sysfs, sd_bus_error *error) {
_cleanup_(sd_device_unrefp) sd_device *d = NULL;
_cleanup_free_ char *file = NULL;
const char *id_for_seat;
int r;
assert(m);
assert(seat);
assert(sysfs);
r = sd_device_new_from_syspath(&d, sysfs);
if (r < 0)
return sd_bus_error_set_errnof(error, r, "Failed to open device '%s': %m", sysfs);
if (sd_device_has_current_tag(d, "seat") <= 0)
return sd_bus_error_set_errnof(error, ENODEV, "Device '%s' lacks 'seat' udev tag.", sysfs);
if (sd_device_get_property_value(d, "ID_FOR_SEAT", &id_for_seat) < 0)
return sd_bus_error_set_errnof(error, ENODEV, "Device '%s' lacks 'ID_FOR_SEAT' udev property.", sysfs);
if (asprintf(&file, "/etc/udev/rules.d/72-seat-%s.rules", id_for_seat) < 0)
return -ENOMEM;
r = write_string_filef(
file,
WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_ATOMIC|WRITE_STRING_FILE_MKDIR_0755|WRITE_STRING_FILE_LABEL,
"TAG==\"seat\", ENV{ID_FOR_SEAT}==\"%s\", ENV{ID_SEAT}=\"%s\"", id_for_seat, seat);
if (r < 0)
return r;
return trigger_device(m, d);
}
static int flush_devices(Manager *m) {
_cleanup_closedir_ DIR *d = NULL;
assert(m);
d = opendir("/etc/udev/rules.d");
if (!d) {
if (errno != ENOENT)
log_warning_errno(errno, "Failed to open %s: %m", "/etc/udev/rules.d");
} else
FOREACH_DIRENT_ALL(de, d, break) {
if (!dirent_is_file(de))
continue;
if (!startswith(de->d_name, "72-seat-"))
continue;
if (!endswith(de->d_name, ".rules"))
continue;
if (unlinkat(dirfd(d), de->d_name, 0) < 0)
log_warning_errno(errno, "Failed to unlink %s: %m", de->d_name);
}
return trigger_device(m, NULL);
}
static int method_attach_device(sd_bus_message *message, void *userdata, sd_bus_error *error) {
const char *sysfs, *seat;
Manager *m = ASSERT_PTR(userdata);
int interactive, r;
assert(message);
r = sd_bus_message_read(message, "ssb", &seat, &sysfs, &interactive);
if (r < 0)
return r;
if (!path_is_normalized(sysfs))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not normalized", sysfs);
if (!path_startswith(sysfs, "/sys"))
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not in /sys", sysfs);
if (seat_is_self(seat) || seat_is_auto(seat)) {
Seat *found;
r = manager_get_seat_from_creds(m, message, seat, error, &found);
if (r < 0)
return r;
seat = found->id;
} else if (!seat_name_is_valid(seat)) /* Note that a seat does not have to exist yet for this operation to succeed */
return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Seat name %s is not valid", seat);
r = bus_verify_polkit_async_full(
message,
"org.freedesktop.login1.attach-device",
/* details= */ NULL,
/* good_user= */ UID_INVALID,
interactive ? POLKIT_ALLOW_INTERACTIVE : 0,
&m->polkit_registry,
/* ret_admin= */ NULL,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
r = attach_device(m, seat, sysfs, error);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int method_flush_devices(sd_bus_message *message, void *userdata, sd_bus_error *error) {
Manager *m = ASSERT_PTR(userdata);
int interactive, r;
assert(message);
r = sd_bus_message_read(message, "b", &interactive);
if (r < 0)
return r;
r = bus_verify_polkit_async_full(
message,
"org.freedesktop.login1.flush-devices",
/* details= */ NULL,
/* good_user= */ UID_INVALID,
interactive ? POLKIT_ALLOW_INTERACTIVE : 0,
&m->polkit_registry,
/* ret_admin= */ NULL,
error);
if (r < 0)
return r;
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
r = flush_devices(m);
if (r < 0)
return r;
return sd_bus_reply_method_return(message, NULL);
}
static int bus_manager_log_shutdown(
Manager *m,
const HandleActionData *a) {
assert(m);
assert(a);
const char *message = a->message ?: "System is shutting down";
const char *log_verb = a->log_verb ? strjoina("SHUTDOWN=", a->log_verb) : NULL;
return log_struct(LOG_NOTICE,
LOG_ITEM("MESSAGE_ID=%s", a->message_id ?: SD_MESSAGE_SHUTDOWN_STR),
LOG_MESSAGE("%s%s%s%s.",
message,
m->wall_message ? " (" : "",
strempty(m->wall_message),
m->wall_message ? ")" : ""),
log_verb);
}
static int lid_switch_ignore_handler(sd_event_source *e, uint64_t usec, void *userdata) {
Manager *m = ASSERT_PTR(userdata);
assert(e);
m->lid_switch_ignore_event_source = sd_event_source_unref(m->lid_switch_ignore_event_source);
return 0;
}
int manager_set_lid_switch_ignore(Manager *m, usec_t until) {
int r;
assert(m);
if (until <= now(CLOCK_MONOTONIC))
return 0;
/* We want to ignore the lid switch for a while after each
* suspend, and after boot-up. Hence let's install a timer for
* this. As long as the event source exists we ignore the lid
* switch. */
if (m->lid_switch_ignore_event_source) {
usec_t u;
r = sd_event_source_get_time(m->lid_switch_ignore_event_source, &u);
if (r < 0)
return r;
if (until <= u)
return 0;
r = sd_event_source_set_time(m->lid_switch_ignore_event_source, until);
} else
r = sd_event_add_time(
m->event,
&m->lid_switch_ignore_event_source,
CLOCK_MONOTONIC,
until, 0,
lid_switch_ignore_handler, m);
return r;
}
static int send_prepare_for(Manager *m, const HandleActionData *a, bool _active) {
int k = 0, r, active = _active;
assert(m);
assert(a);
/* Only sleep/shutdown actions emit a signal */
if (a->inhibit_what < 0)
return 0;
assert(IN_SET(a->inhibit_what, INHIBIT_SHUTDOWN, INHIBIT_SLEEP));
/* We need to send both old and new signal for backward compatibility. The newer one allows clients
* to know which type of reboot is going to happen, as they might be doing different actions (e.g.:
* on soft-reboot), and it is sent first, so that clients know that if they receive the old one
* first then they don't have to wait for the new one, as it means it's not supported. So, do not
* change the order here, as it is an API. */
if (a->inhibit_what == INHIBIT_SHUTDOWN) {
k = sd_bus_emit_signal(m->bus,
"/org/freedesktop/login1",
"org.freedesktop.login1.Manager",
"PrepareForShutdownWithMetadata",
"ba{sv}",
active,
1,
"type",
"s",
handle_action_to_string(a->handle));
if (k < 0)
log_debug_errno(k, "Failed to emit PrepareForShutdownWithMetadata(): %m");
}
r = sd_bus_emit_signal(m->bus,
"/org/freedesktop/login1",
"org.freedesktop.login1.Manager",
a->inhibit_what == INHIBIT_SHUTDOWN ? "PrepareForShutdown" : "PrepareForSleep",
"b",
active);
if (r < 0)
log_debug_errno(r, "Failed to emit PrepareForShutdown(): %m");
return RET_GATHER(k, r);
}
static int strdup_job(sd_bus_message *reply, char **ret) {
const char *j;
char *job;
int r;
assert(reply);
assert(ret);
r = sd_bus_message_read_basic(reply, 'o', &j);
if (r < 0)
return r;
job = strdup(j);
if (!job)
return -ENOMEM;
*ret = job;
return 0;
}
static int execute_shutdown_or_sleep(
Manager *m,
const HandleActionData *a,
sd_bus_error *error) {