HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/login/logind-dbus.c

180,924 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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