1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
8 #include "sd-messages.h"
10 #include "alloc-util.h"
11 #include "audit-util.h"
13 #include "bus-common-errors.h"
14 #include "bus-error.h"
15 #include "bus-get-properties.h"
16 #include "bus-locator.h"
17 #include "bus-polkit.h"
18 #include "bus-unit-util.h"
20 #include "cgroup-util.h"
21 #include "device-util.h"
22 #include "dirent-util.h"
23 #include "efi-loader.h"
28 #include "fileio-label.h"
30 #include "format-util.h"
32 #include "logind-dbus.h"
33 #include "logind-polkit.h"
34 #include "logind-seat-dbus.h"
35 #include "logind-session-dbus.h"
36 #include "logind-user-dbus.h"
38 #include "missing_capability.h"
40 #include "parse-util.h"
41 #include "path-util.h"
42 #include "process-util.h"
43 #include "reboot-util.h"
44 #include "selinux-util.h"
45 #include "sleep-config.h"
47 #include "stdio-util.h"
49 #include "terminal-util.h"
50 #include "tmpfile-util.h"
51 #include "unit-name.h"
52 #include "user-util.h"
53 #include "utmp-wtmp.h"
56 static int get_sender_session(
58 sd_bus_message
*message
,
63 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
64 Session
*session
= NULL
;
68 /* Acquire the sender's session. This first checks if the sending process is inside a session itself,
69 * and returns that. If not and 'consult_display' is true, this returns the display session of the
70 * owning user of the caller. */
72 r
= sd_bus_query_sender_creds(message
,
73 SD_BUS_CREDS_SESSION
|SD_BUS_CREDS_AUGMENT
|
74 (consult_display
? SD_BUS_CREDS_OWNER_UID
: 0), &creds
);
78 r
= sd_bus_creds_get_session(creds
, &name
);
83 if (consult_display
) {
86 r
= sd_bus_creds_get_owner_uid(creds
, &uid
);
93 user
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
95 session
= user
->display
;
99 session
= hashmap_get(m
->sessions
, name
);
102 return sd_bus_error_setf(error
, BUS_ERROR_NO_SESSION_FOR_PID
,
104 "Caller does not belong to any known session and doesn't own any suitable session." :
105 "Caller does not belong to any known session.");
111 int manager_get_session_from_creds(
113 sd_bus_message
*message
,
123 if (SEAT_IS_SELF(name
)) /* the caller's own session */
124 return get_sender_session(m
, message
, false, error
, ret
);
125 if (SEAT_IS_AUTO(name
)) /* The caller's own session if they have one, otherwise their user's display session */
126 return get_sender_session(m
, message
, true, error
, ret
);
128 session
= hashmap_get(m
->sessions
, name
);
130 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SESSION
, "No session '%s' known", name
);
136 static int get_sender_user(Manager
*m
, sd_bus_message
*message
, sd_bus_error
*error
, User
**ret
) {
137 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
142 /* Note that we get the owner UID of the session, not the actual client UID here! */
143 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_OWNER_UID
|SD_BUS_CREDS_AUGMENT
, &creds
);
147 r
= sd_bus_creds_get_owner_uid(creds
, &uid
);
154 user
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
157 return sd_bus_error_setf(error
, BUS_ERROR_NO_USER_FOR_PID
,
158 "Caller does not belong to any logged in or lingering user");
164 int manager_get_user_from_creds(Manager
*m
, sd_bus_message
*message
, uid_t uid
, sd_bus_error
*error
, User
**ret
) {
170 if (!uid_is_valid(uid
))
171 return get_sender_user(m
, message
, error
, ret
);
173 user
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
175 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_USER
,
176 "User ID "UID_FMT
" is not logged in or lingering", uid
);
182 int manager_get_seat_from_creds(
184 sd_bus_message
*message
,
195 if (SEAT_IS_SELF(name
) || SEAT_IS_AUTO(name
)) {
198 /* Use these special seat names as session names */
199 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
203 seat
= session
->seat
;
205 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
, "Session '%s' has no seat.", session
->id
);
207 seat
= hashmap_get(m
->seats
, name
);
209 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
, "No seat '%s' known", name
);
216 static int return_test_polkit(
217 sd_bus_message
*message
,
220 const char **details
,
228 r
= bus_test_polkit(message
, capability
, action
, details
, good_user
, &challenge
, e
);
235 result
= "challenge";
239 return sd_bus_reply_method_return(message
, "s", result
);
242 static int property_get_idle_hint(
245 const char *interface
,
246 const char *property
,
247 sd_bus_message
*reply
,
249 sd_bus_error
*error
) {
251 Manager
*m
= userdata
;
257 return sd_bus_message_append(reply
, "b", manager_get_idle_hint(m
, NULL
) > 0);
260 static int property_get_idle_since_hint(
263 const char *interface
,
264 const char *property
,
265 sd_bus_message
*reply
,
267 sd_bus_error
*error
) {
269 Manager
*m
= userdata
;
270 dual_timestamp t
= DUAL_TIMESTAMP_NULL
;
276 manager_get_idle_hint(m
, &t
);
278 return sd_bus_message_append(reply
, "t", streq(property
, "IdleSinceHint") ? t
.realtime
: t
.monotonic
);
281 static int property_get_inhibited(
284 const char *interface
,
285 const char *property
,
286 sd_bus_message
*reply
,
288 sd_bus_error
*error
) {
290 Manager
*m
= userdata
;
297 w
= manager_inhibit_what(m
, streq(property
, "BlockInhibited") ? INHIBIT_BLOCK
: INHIBIT_DELAY
);
299 return sd_bus_message_append(reply
, "s", inhibit_what_to_string(w
));
302 static int property_get_preparing(
305 const char *interface
,
306 const char *property
,
307 sd_bus_message
*reply
,
309 sd_bus_error
*error
) {
311 Manager
*m
= userdata
;
318 if (streq(property
, "PreparingForShutdown"))
319 b
= m
->action_what
& INHIBIT_SHUTDOWN
;
321 b
= m
->action_what
& INHIBIT_SLEEP
;
323 return sd_bus_message_append(reply
, "b", b
);
326 static int property_get_scheduled_shutdown(
329 const char *interface
,
330 const char *property
,
331 sd_bus_message
*reply
,
333 sd_bus_error
*error
) {
335 Manager
*m
= userdata
;
342 r
= sd_bus_message_open_container(reply
, 'r', "st");
346 r
= sd_bus_message_append(reply
, "st", m
->scheduled_shutdown_type
, m
->scheduled_shutdown_timeout
);
350 return sd_bus_message_close_container(reply
);
353 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_handle_action
, handle_action
, HandleAction
);
354 static BUS_DEFINE_PROPERTY_GET(property_get_docked
, "b", Manager
, manager_is_docked_or_external_displays
);
355 static BUS_DEFINE_PROPERTY_GET(property_get_lid_closed
, "b", Manager
, manager_is_lid_closed
);
356 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_on_external_power
, "b", manager_is_on_external_power
);
357 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_compat_user_tasks_max
, "t", CGROUP_LIMIT_MAX
);
358 static BUS_DEFINE_PROPERTY_GET_REF(property_get_hashmap_size
, "t", Hashmap
*, (uint64_t) hashmap_size
);
360 static int method_get_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
361 _cleanup_free_
char *p
= NULL
;
362 Manager
*m
= userdata
;
370 r
= sd_bus_message_read(message
, "s", &name
);
374 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
378 p
= session_bus_path(session
);
382 return sd_bus_reply_method_return(message
, "o", p
);
385 /* Get login session of a process. This is not what you are looking for these days,
386 * as apps may instead belong to a user service unit. This includes terminal
387 * emulators and hence command-line apps. */
388 static int method_get_session_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
389 _cleanup_free_
char *p
= NULL
;
390 Session
*session
= NULL
;
391 Manager
*m
= userdata
;
398 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
400 r
= sd_bus_message_read(message
, "u", &pid
);
407 r
= manager_get_session_from_creds(m
, message
, NULL
, error
, &session
);
411 r
= manager_get_session_by_pid(m
, pid
, &session
);
416 return sd_bus_error_setf(error
, BUS_ERROR_NO_SESSION_FOR_PID
,
417 "PID "PID_FMT
" does not belong to any known session", pid
);
420 p
= session_bus_path(session
);
424 return sd_bus_reply_method_return(message
, "o", p
);
427 static int method_get_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
428 _cleanup_free_
char *p
= NULL
;
429 Manager
*m
= userdata
;
437 r
= sd_bus_message_read(message
, "u", &uid
);
441 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
445 p
= user_bus_path(user
);
449 return sd_bus_reply_method_return(message
, "o", p
);
452 static int method_get_user_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
453 _cleanup_free_
char *p
= NULL
;
454 Manager
*m
= userdata
;
462 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
464 r
= sd_bus_message_read(message
, "u", &pid
);
471 r
= manager_get_user_from_creds(m
, message
, UID_INVALID
, error
, &user
);
475 r
= manager_get_user_by_pid(m
, pid
, &user
);
479 return sd_bus_error_setf(error
, BUS_ERROR_NO_USER_FOR_PID
,
480 "PID "PID_FMT
" does not belong to any logged in user or lingering user",
484 p
= user_bus_path(user
);
488 return sd_bus_reply_method_return(message
, "o", p
);
491 static int method_get_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
492 _cleanup_free_
char *p
= NULL
;
493 Manager
*m
= userdata
;
501 r
= sd_bus_message_read(message
, "s", &name
);
505 r
= manager_get_seat_from_creds(m
, message
, name
, error
, &seat
);
509 p
= seat_bus_path(seat
);
513 return sd_bus_reply_method_return(message
, "o", p
);
516 static int method_list_sessions(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
517 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
518 Manager
*m
= userdata
;
525 r
= sd_bus_message_new_method_return(message
, &reply
);
529 r
= sd_bus_message_open_container(reply
, 'a', "(susso)");
533 HASHMAP_FOREACH(session
, m
->sessions
) {
534 _cleanup_free_
char *p
= NULL
;
536 p
= session_bus_path(session
);
540 r
= sd_bus_message_append(reply
, "(susso)",
542 (uint32_t) session
->user
->user_record
->uid
,
543 session
->user
->user_record
->user_name
,
544 session
->seat
? session
->seat
->id
: "",
550 r
= sd_bus_message_close_container(reply
);
554 return sd_bus_send(NULL
, reply
, NULL
);
557 static int method_list_users(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
558 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
559 Manager
*m
= userdata
;
566 r
= sd_bus_message_new_method_return(message
, &reply
);
570 r
= sd_bus_message_open_container(reply
, 'a', "(uso)");
574 HASHMAP_FOREACH(user
, m
->users
) {
575 _cleanup_free_
char *p
= NULL
;
577 p
= user_bus_path(user
);
581 r
= sd_bus_message_append(reply
, "(uso)",
582 (uint32_t) user
->user_record
->uid
,
583 user
->user_record
->user_name
,
589 r
= sd_bus_message_close_container(reply
);
593 return sd_bus_send(NULL
, reply
, NULL
);
596 static int method_list_seats(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
597 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
598 Manager
*m
= userdata
;
605 r
= sd_bus_message_new_method_return(message
, &reply
);
609 r
= sd_bus_message_open_container(reply
, 'a', "(so)");
613 HASHMAP_FOREACH(seat
, m
->seats
) {
614 _cleanup_free_
char *p
= NULL
;
616 p
= seat_bus_path(seat
);
620 r
= sd_bus_message_append(reply
, "(so)", seat
->id
, p
);
625 r
= sd_bus_message_close_container(reply
);
629 return sd_bus_send(NULL
, reply
, NULL
);
632 static int method_list_inhibitors(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
633 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
634 Manager
*m
= userdata
;
635 Inhibitor
*inhibitor
;
641 r
= sd_bus_message_new_method_return(message
, &reply
);
645 r
= sd_bus_message_open_container(reply
, 'a', "(ssssuu)");
649 HASHMAP_FOREACH(inhibitor
, m
->inhibitors
) {
651 r
= sd_bus_message_append(reply
, "(ssssuu)",
652 strempty(inhibit_what_to_string(inhibitor
->what
)),
653 strempty(inhibitor
->who
),
654 strempty(inhibitor
->why
),
655 strempty(inhibit_mode_to_string(inhibitor
->mode
)),
656 (uint32_t) inhibitor
->uid
,
657 (uint32_t) inhibitor
->pid
);
662 r
= sd_bus_message_close_container(reply
);
666 return sd_bus_send(NULL
, reply
, NULL
);
669 static int method_create_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
670 const char *service
, *type
, *class, *cseat
, *tty
, *display
, *remote_user
, *remote_host
, *desktop
;
671 _cleanup_free_
char *id
= NULL
;
672 Session
*session
= NULL
;
673 uint32_t audit_id
= 0;
674 Manager
*m
= userdata
;
688 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
689 assert_cc(sizeof(uid_t
) == sizeof(uint32_t));
691 r
= sd_bus_message_read(message
, "uusssssussbss",
692 &uid
, &leader
, &service
, &type
, &class, &desktop
, &cseat
,
693 &vtnr
, &tty
, &display
, &remote
, &remote_user
, &remote_host
);
697 if (!uid_is_valid(uid
))
698 return sd_bus_error_set(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid UID");
699 if (leader
< 0 || leader
== 1 || leader
== getpid_cached())
700 return sd_bus_error_set(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid leader PID");
703 t
= _SESSION_TYPE_INVALID
;
705 t
= session_type_from_string(type
);
707 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
708 "Invalid session type %s", type
);
712 c
= _SESSION_CLASS_INVALID
;
714 c
= session_class_from_string(class);
716 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
717 "Invalid session class %s", class);
720 if (isempty(desktop
))
723 if (!string_is_safe(desktop
))
724 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
725 "Invalid desktop string %s", desktop
);
731 seat
= hashmap_get(m
->seats
, cseat
);
733 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
,
734 "No seat '%s' known", cseat
);
737 if (tty_is_vc(tty
)) {
742 else if (seat
!= m
->seat0
)
743 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
744 "TTY %s is virtual console but seat %s is not seat0", tty
, seat
->id
);
746 v
= vtnr_from_tty(tty
);
748 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
749 "Cannot determine VT number from virtual console TTY %s", tty
);
753 else if (vtnr
!= (uint32_t) v
)
754 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
755 "Specified TTY and VT number do not match");
757 } else if (tty_is_console(tty
)) {
761 else if (seat
!= m
->seat0
)
762 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
763 "Console TTY specified but seat is not seat0");
766 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
767 "Console TTY specified but VT number is not 0");
771 if (seat_has_vts(seat
)) {
772 if (vtnr
<= 0 || vtnr
> 63)
773 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
774 "VT number out of range");
777 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
778 "Seat has no VTs but VT number not 0");
782 if (t
== _SESSION_TYPE_INVALID
) {
783 if (!isempty(display
))
785 else if (!isempty(tty
))
788 t
= SESSION_UNSPECIFIED
;
791 if (c
== _SESSION_CLASS_INVALID
) {
792 if (t
== SESSION_UNSPECIFIED
)
793 c
= SESSION_BACKGROUND
;
799 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
801 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
805 r
= sd_bus_creds_get_pid(creds
, (pid_t
*) &leader
);
810 /* Check if we are already in a logind session. Or if we are in user@.service
811 * which is a special PAM session that avoids creating a logind session. */
812 r
= manager_get_user_by_pid(m
, leader
, NULL
);
816 return sd_bus_error_setf(error
, BUS_ERROR_SESSION_BUSY
,
817 "Already running in a session or user slice");
820 * Old gdm and lightdm start the user-session on the same VT as
821 * the greeter session. But they destroy the greeter session
822 * after the user-session and want the user-session to take
823 * over the VT. We need to support this for
824 * backwards-compatibility, so make sure we allow new sessions
825 * on a VT that a greeter is running on. Furthermore, to allow
826 * re-logins, we have to allow a greeter to take over a used VT for
827 * the exact same reasons.
829 if (c
!= SESSION_GREETER
&&
831 vtnr
< m
->seat0
->position_count
&&
832 m
->seat0
->positions
[vtnr
] &&
833 m
->seat0
->positions
[vtnr
]->class != SESSION_GREETER
)
834 return sd_bus_error_set(error
, BUS_ERROR_SESSION_BUSY
, "Already occupied by a session");
836 if (hashmap_size(m
->sessions
) >= m
->sessions_max
)
837 return sd_bus_error_setf(error
, SD_BUS_ERROR_LIMITS_EXCEEDED
,
838 "Maximum number of sessions (%" PRIu64
") reached, refusing further sessions.",
841 (void) audit_session_from_pid(leader
, &audit_id
);
842 if (audit_session_is_valid(audit_id
)) {
843 /* Keep our session IDs and the audit session IDs in sync */
845 if (asprintf(&id
, "%"PRIu32
, audit_id
) < 0)
848 /* Wut? There's already a session by this name and we didn't find it above? Weird, then let's
849 * not trust the audit data and let's better register a new ID */
850 if (hashmap_contains(m
->sessions
, id
)) {
851 log_warning("Existing logind session ID %s used by new audit session, ignoring.", id
);
852 audit_id
= AUDIT_SESSION_INVALID
;
861 if (asprintf(&id
, "c%lu", ++m
->session_counter
) < 0)
864 } while (hashmap_contains(m
->sessions
, id
));
867 /* The generated names should not clash with 'auto' or 'self' */
868 assert(!SESSION_IS_SELF(id
));
869 assert(!SESSION_IS_AUTO(id
));
871 /* If we are not watching utmp already, try again */
872 manager_reconnect_utmp(m
);
874 r
= manager_add_user_by_uid(m
, uid
, &user
);
878 r
= manager_add_session(m
, id
, &session
);
882 session_set_user(session
, user
);
883 r
= session_set_leader(session
, leader
);
887 session
->original_type
= session
->type
= t
;
889 session
->remote
= remote
;
890 session
->vtnr
= vtnr
;
893 session
->tty
= strdup(tty
);
899 session
->tty_validity
= TTY_FROM_PAM
;
902 if (!isempty(display
)) {
903 session
->display
= strdup(display
);
904 if (!session
->display
) {
910 if (!isempty(remote_user
)) {
911 session
->remote_user
= strdup(remote_user
);
912 if (!session
->remote_user
) {
918 if (!isempty(remote_host
)) {
919 session
->remote_host
= strdup(remote_host
);
920 if (!session
->remote_host
) {
926 if (!isempty(service
)) {
927 session
->service
= strdup(service
);
928 if (!session
->service
) {
934 if (!isempty(desktop
)) {
935 session
->desktop
= strdup(desktop
);
936 if (!session
->desktop
) {
943 r
= seat_attach_session(seat
, session
);
948 r
= sd_bus_message_enter_container(message
, 'a', "(sv)");
952 r
= session_start(session
, message
, error
);
956 r
= sd_bus_message_exit_container(message
);
960 session
->create_message
= sd_bus_message_ref(message
);
962 /* Now, let's wait until the slice unit and stuff got created. We send the reply back from
963 * session_send_create_reply(). */
969 session_add_to_gc_queue(session
);
972 user_add_to_gc_queue(user
);
977 static int method_release_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
978 Manager
*m
= userdata
;
986 r
= sd_bus_message_read(message
, "s", &name
);
990 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
994 r
= session_release(session
);
998 return sd_bus_reply_method_return(message
, NULL
);
1001 static int method_activate_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1002 Manager
*m
= userdata
;
1010 r
= sd_bus_message_read(message
, "s", &name
);
1014 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1018 /* PolicyKit is done by bus_session_method_activate() */
1020 return bus_session_method_activate(message
, session
, error
);
1023 static int method_activate_session_on_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1024 const char *session_name
, *seat_name
;
1025 Manager
*m
= userdata
;
1033 /* Same as ActivateSession() but refuses to work if the seat doesn't match */
1035 r
= sd_bus_message_read(message
, "ss", &session_name
, &seat_name
);
1039 r
= manager_get_session_from_creds(m
, message
, session_name
, error
, &session
);
1043 r
= manager_get_seat_from_creds(m
, message
, seat_name
, error
, &seat
);
1047 if (session
->seat
!= seat
)
1048 return sd_bus_error_setf(error
, BUS_ERROR_SESSION_NOT_ON_SEAT
,
1049 "Session %s not on seat %s", session_name
, seat_name
);
1051 r
= check_polkit_chvt(message
, m
, error
);
1055 return 1; /* Will call us back */
1057 r
= session_activate(session
);
1061 return sd_bus_reply_method_return(message
, NULL
);
1064 static int method_lock_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1065 Manager
*m
= userdata
;
1073 r
= sd_bus_message_read(message
, "s", &name
);
1077 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1081 return bus_session_method_lock(message
, session
, error
);
1084 static int method_lock_sessions(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1085 Manager
*m
= userdata
;
1091 r
= bus_verify_polkit_async(
1094 "org.freedesktop.login1.lock-sessions",
1098 &m
->polkit_registry
,
1103 return 1; /* Will call us back */
1105 r
= session_send_lock_all(m
, streq(sd_bus_message_get_member(message
), "LockSessions"));
1109 return sd_bus_reply_method_return(message
, NULL
);
1112 static int method_kill_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1114 Manager
*m
= userdata
;
1121 r
= sd_bus_message_read(message
, "s", &name
);
1125 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1129 return bus_session_method_kill(message
, session
, error
);
1132 static int method_kill_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1133 Manager
*m
= userdata
;
1141 r
= sd_bus_message_read(message
, "u", &uid
);
1145 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
1149 return bus_user_method_kill(message
, user
, error
);
1152 static int method_terminate_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1153 Manager
*m
= userdata
;
1161 r
= sd_bus_message_read(message
, "s", &name
);
1165 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1169 return bus_session_method_terminate(message
, session
, error
);
1172 static int method_terminate_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1173 Manager
*m
= userdata
;
1181 r
= sd_bus_message_read(message
, "u", &uid
);
1185 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
1189 return bus_user_method_terminate(message
, user
, error
);
1192 static int method_terminate_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1193 Manager
*m
= userdata
;
1201 r
= sd_bus_message_read(message
, "s", &name
);
1205 r
= manager_get_seat_from_creds(m
, message
, name
, error
, &seat
);
1209 return bus_seat_method_terminate(message
, seat
, error
);
1212 static int method_set_user_linger(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1213 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
1214 _cleanup_free_
char *cc
= NULL
;
1215 Manager
*m
= userdata
;
1216 int r
, b
, interactive
;
1219 uint32_t uid
, auth_uid
;
1224 r
= sd_bus_message_read(message
, "ubb", &uid
, &b
, &interactive
);
1228 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
|
1229 SD_BUS_CREDS_OWNER_UID
|SD_BUS_CREDS_AUGMENT
, &creds
);
1233 if (!uid_is_valid(uid
)) {
1234 /* Note that we get the owner UID of the session or user unit,
1235 * not the actual client UID here! */
1236 r
= sd_bus_creds_get_owner_uid(creds
, &uid
);
1241 /* owner_uid is racy, so for authorization we must use euid */
1242 r
= sd_bus_creds_get_euid(creds
, &auth_uid
);
1249 return errno_or_else(ENOENT
);
1251 r
= bus_verify_polkit_async(
1254 uid
== auth_uid
? "org.freedesktop.login1.set-self-linger" :
1255 "org.freedesktop.login1.set-user-linger",
1259 &m
->polkit_registry
,
1264 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1266 (void) mkdir_p_label("/var/lib/systemd", 0755);
1267 r
= mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0, MKDIR_WARN_MODE
);
1271 cc
= cescape(pw
->pw_name
);
1275 path
= strjoina("/var/lib/systemd/linger/", cc
);
1283 if (manager_add_user_by_uid(m
, uid
, &u
) >= 0)
1290 if (r
< 0 && errno
!= ENOENT
)
1293 u
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
1295 user_add_to_gc_queue(u
);
1298 return sd_bus_reply_method_return(message
, NULL
);
1301 static int trigger_device(Manager
*m
, sd_device
*d
) {
1302 _cleanup_(sd_device_enumerator_unrefp
) sd_device_enumerator
*e
= NULL
;
1307 r
= sd_device_enumerator_new(&e
);
1311 r
= sd_device_enumerator_allow_uninitialized(e
);
1316 r
= sd_device_enumerator_add_match_parent(e
, d
);
1321 FOREACH_DEVICE(e
, d
) {
1322 r
= sd_device_trigger(d
, SD_DEVICE_CHANGE
);
1324 log_device_debug_errno(d
, r
, "Failed to trigger device, ignoring: %m");
1330 static int attach_device(Manager
*m
, const char *seat
, const char *sysfs
) {
1331 _cleanup_(sd_device_unrefp
) sd_device
*d
= NULL
;
1332 _cleanup_free_
char *rule
= NULL
, *file
= NULL
;
1333 const char *id_for_seat
;
1340 r
= sd_device_new_from_syspath(&d
, sysfs
);
1344 if (sd_device_has_current_tag(d
, "seat") <= 0)
1347 if (sd_device_get_property_value(d
, "ID_FOR_SEAT", &id_for_seat
) < 0)
1350 if (asprintf(&file
, "/etc/udev/rules.d/72-seat-%s.rules", id_for_seat
) < 0)
1353 if (asprintf(&rule
, "TAG==\"seat\", ENV{ID_FOR_SEAT}==\"%s\", ENV{ID_SEAT}=\"%s\"", id_for_seat
, seat
) < 0)
1356 (void) mkdir_p_label("/etc/udev/rules.d", 0755);
1357 r
= write_string_file_atomic_label(file
, rule
);
1361 return trigger_device(m
, d
);
1364 static int flush_devices(Manager
*m
) {
1365 _cleanup_closedir_
DIR *d
= NULL
;
1369 d
= opendir("/etc/udev/rules.d");
1371 if (errno
!= ENOENT
)
1372 log_warning_errno(errno
, "Failed to open /etc/udev/rules.d: %m");
1376 FOREACH_DIRENT_ALL(de
, d
, break) {
1377 dirent_ensure_type(d
, de
);
1378 if (!dirent_is_file(de
))
1381 if (!startswith(de
->d_name
, "72-seat-"))
1384 if (!endswith(de
->d_name
, ".rules"))
1387 if (unlinkat(dirfd(d
), de
->d_name
, 0) < 0)
1388 log_warning_errno(errno
, "Failed to unlink %s: %m", de
->d_name
);
1392 return trigger_device(m
, NULL
);
1395 static int method_attach_device(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1396 const char *sysfs
, *seat
;
1397 Manager
*m
= userdata
;
1403 r
= sd_bus_message_read(message
, "ssb", &seat
, &sysfs
, &interactive
);
1407 if (!path_is_normalized(sysfs
))
1408 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Path %s is not normalized", sysfs
);
1409 if (!path_startswith(sysfs
, "/sys"))
1410 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Path %s is not in /sys", sysfs
);
1412 if (SEAT_IS_SELF(seat
) || SEAT_IS_AUTO(seat
)) {
1415 r
= manager_get_seat_from_creds(m
, message
, seat
, error
, &found
);
1421 } else if (!seat_name_is_valid(seat
)) /* Note that a seat does not have to exist yet for this operation to succeed */
1422 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Seat name %s is not valid", seat
);
1424 r
= bus_verify_polkit_async(
1427 "org.freedesktop.login1.attach-device",
1431 &m
->polkit_registry
,
1436 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1438 r
= attach_device(m
, seat
, sysfs
);
1442 return sd_bus_reply_method_return(message
, NULL
);
1445 static int method_flush_devices(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1446 Manager
*m
= userdata
;
1452 r
= sd_bus_message_read(message
, "b", &interactive
);
1456 r
= bus_verify_polkit_async(
1459 "org.freedesktop.login1.flush-devices",
1463 &m
->polkit_registry
,
1468 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1470 r
= flush_devices(m
);
1474 return sd_bus_reply_method_return(message
, NULL
);
1477 static int have_multiple_sessions(
1485 /* Check for other users' sessions. Greeter sessions do not
1486 * count, and non-login sessions do not count either. */
1487 HASHMAP_FOREACH(session
, m
->sessions
)
1488 if (session
->class == SESSION_USER
&&
1489 session
->user
->user_record
->uid
!= uid
)
1495 static int bus_manager_log_shutdown(
1497 const char *unit_name
) {
1504 if (streq(unit_name
, SPECIAL_POWEROFF_TARGET
)) {
1505 p
= "MESSAGE=System is powering down";
1506 q
= "SHUTDOWN=power-off";
1507 } else if (streq(unit_name
, SPECIAL_REBOOT_TARGET
)) {
1508 p
= "MESSAGE=System is rebooting";
1509 q
= "SHUTDOWN=reboot";
1510 } else if (streq(unit_name
, SPECIAL_HALT_TARGET
)) {
1511 p
= "MESSAGE=System is halting";
1512 q
= "SHUTDOWN=halt";
1513 } else if (streq(unit_name
, SPECIAL_KEXEC_TARGET
)) {
1514 p
= "MESSAGE=System is rebooting with kexec";
1515 q
= "SHUTDOWN=kexec";
1517 p
= "MESSAGE=System is shutting down";
1521 if (isempty(m
->wall_message
))
1522 p
= strjoina(p
, ".");
1524 p
= strjoina(p
, " (", m
->wall_message
, ").");
1526 return log_struct(LOG_NOTICE
,
1527 "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_STR
,
1532 static int lid_switch_ignore_handler(sd_event_source
*e
, uint64_t usec
, void *userdata
) {
1533 Manager
*m
= userdata
;
1538 m
->lid_switch_ignore_event_source
= sd_event_source_unref(m
->lid_switch_ignore_event_source
);
1542 int manager_set_lid_switch_ignore(Manager
*m
, usec_t until
) {
1547 if (until
<= now(CLOCK_MONOTONIC
))
1550 /* We want to ignore the lid switch for a while after each
1551 * suspend, and after boot-up. Hence let's install a timer for
1552 * this. As long as the event source exists we ignore the lid
1555 if (m
->lid_switch_ignore_event_source
) {
1558 r
= sd_event_source_get_time(m
->lid_switch_ignore_event_source
, &u
);
1565 r
= sd_event_source_set_time(m
->lid_switch_ignore_event_source
, until
);
1567 r
= sd_event_add_time(
1569 &m
->lid_switch_ignore_event_source
,
1572 lid_switch_ignore_handler
, m
);
1577 static int send_prepare_for(Manager
*m
, InhibitWhat w
, bool _active
) {
1578 int active
= _active
;
1581 assert(IN_SET(w
, INHIBIT_SHUTDOWN
, INHIBIT_SLEEP
));
1583 return sd_bus_emit_signal(m
->bus
,
1584 "/org/freedesktop/login1",
1585 "org.freedesktop.login1.Manager",
1586 w
== INHIBIT_SHUTDOWN
? "PrepareForShutdown" : "PrepareForSleep",
1591 static int execute_shutdown_or_sleep(
1594 const char *unit_name
,
1595 sd_bus_error
*error
) {
1597 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1603 assert(w
< _INHIBIT_WHAT_MAX
);
1606 if (w
== INHIBIT_SHUTDOWN
)
1607 bus_manager_log_shutdown(m
, unit_name
);
1609 r
= bus_call_method(
1615 "ss", unit_name
, "replace-irreversibly");
1619 r
= sd_bus_message_read(reply
, "o", &p
);
1623 r
= free_and_strdup(&m
->action_job
, p
);
1627 m
->action_unit
= unit_name
;
1630 /* Make sure the lid switch is ignored for a while */
1631 manager_set_lid_switch_ignore(m
, usec_add(now(CLOCK_MONOTONIC
), m
->holdoff_timeout_usec
));
1636 /* Tell people that they now may take a lock again */
1637 (void) send_prepare_for(m
, w
, false);
1642 int manager_dispatch_delayed(Manager
*manager
, bool timeout
) {
1644 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1645 Inhibitor
*offending
= NULL
;
1650 if (manager
->action_what
== 0 || manager
->action_job
)
1653 if (manager_is_inhibited(manager
, manager
->action_what
, INHIBIT_DELAY
, NULL
, false, false, 0, &offending
)) {
1654 _cleanup_free_
char *comm
= NULL
, *u
= NULL
;
1659 (void) get_process_comm(offending
->pid
, &comm
);
1660 u
= uid_to_name(offending
->uid
);
1662 log_notice("Delay lock is active (UID "UID_FMT
"/%s, PID "PID_FMT
"/%s) but inhibitor timeout is reached.",
1663 offending
->uid
, strna(u
),
1664 offending
->pid
, strna(comm
));
1667 /* Actually do the operation */
1668 r
= execute_shutdown_or_sleep(manager
, manager
->action_what
, manager
->action_unit
, &error
);
1670 log_warning("Error during inhibitor-delayed operation (already returned success to client): %s",
1671 bus_error_message(&error
, r
));
1673 manager
->action_unit
= NULL
;
1674 manager
->action_what
= 0;
1681 static int manager_inhibit_timeout_handler(
1686 Manager
*manager
= userdata
;
1690 assert(manager
->inhibit_timeout_source
== s
);
1692 r
= manager_dispatch_delayed(manager
, true);
1693 return (r
< 0) ? r
: 0;
1696 static int delay_shutdown_or_sleep(
1699 const char *unit_name
) {
1705 assert(w
< _INHIBIT_WHAT_MAX
);
1708 if (m
->inhibit_timeout_source
) {
1709 r
= sd_event_source_set_time_relative(m
->inhibit_timeout_source
, m
->inhibit_delay_max
);
1711 return log_error_errno(r
, "sd_event_source_set_time_relative() failed: %m");
1713 r
= sd_event_source_set_enabled(m
->inhibit_timeout_source
, SD_EVENT_ONESHOT
);
1715 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
1717 r
= sd_event_add_time_relative(
1719 &m
->inhibit_timeout_source
,
1720 CLOCK_MONOTONIC
, m
->inhibit_delay_max
, 0,
1721 manager_inhibit_timeout_handler
, m
);
1726 m
->action_unit
= unit_name
;
1732 int bus_manager_shutdown_or_sleep_now_or_later(
1734 const char *unit_name
,
1736 sd_bus_error
*error
) {
1738 _cleanup_free_
char *load_state
= NULL
;
1745 assert(w
< _INHIBIT_WHAT_MAX
);
1746 assert(!m
->action_job
);
1748 r
= unit_load_state(m
->bus
, unit_name
, &load_state
);
1752 if (!streq(load_state
, "loaded"))
1753 return log_notice_errno(SYNTHETIC_ERRNO(EACCES
),
1754 "Unit %s is %s, refusing operation.",
1755 unit_name
, load_state
);
1757 /* Tell everybody to prepare for shutdown/sleep */
1758 (void) send_prepare_for(m
, w
, true);
1761 m
->inhibit_delay_max
> 0 &&
1762 manager_is_inhibited(m
, w
, INHIBIT_DELAY
, NULL
, false, false, 0, NULL
);
1765 /* Shutdown is delayed, keep in mind what we
1766 * want to do, and start a timeout */
1767 r
= delay_shutdown_or_sleep(m
, w
, unit_name
);
1769 /* Shutdown is not delayed, execute it
1771 r
= execute_shutdown_or_sleep(m
, w
, unit_name
, error
);
1776 static int verify_shutdown_creds(
1778 sd_bus_message
*message
,
1781 const char *action_multiple_sessions
,
1782 const char *action_ignore_inhibit
,
1784 sd_bus_error
*error
) {
1786 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
1787 bool multiple_sessions
, blocked
, interactive
;
1794 assert(w
<= _INHIBIT_WHAT_MAX
);
1796 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
, &creds
);
1800 r
= sd_bus_creds_get_euid(creds
, &uid
);
1804 r
= have_multiple_sessions(m
, uid
);
1808 multiple_sessions
= r
> 0;
1809 blocked
= manager_is_inhibited(m
, w
, INHIBIT_BLOCK
, NULL
, false, true, uid
, NULL
);
1810 interactive
= flags
& SD_LOGIND_INTERACTIVE
;
1812 if (multiple_sessions
&& action_multiple_sessions
) {
1813 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action_multiple_sessions
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1817 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1821 /* We don't check polkit for root here, because you can't be more privileged than root */
1822 if (uid
== 0 && (flags
& SD_LOGIND_ROOT_CHECK_INHIBITORS
))
1823 return sd_bus_error_setf(error
, SD_BUS_ERROR_ACCESS_DENIED
,
1824 "Access denied to root due to active block inhibitor");
1826 if (action_ignore_inhibit
) {
1827 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action_ignore_inhibit
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1831 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1835 if (!multiple_sessions
&& !blocked
&& action
) {
1836 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1840 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1846 static int method_do_shutdown_or_sleep(
1848 sd_bus_message
*message
,
1849 const char *unit_name
,
1852 const char *action_multiple_sessions
,
1853 const char *action_ignore_inhibit
,
1854 const char *sleep_verb
,
1856 sd_bus_error
*error
) {
1865 assert(w
<= _INHIBIT_WHAT_MAX
);
1868 /* New style method: with flags parameter (and interactive bool in the bus message header) */
1869 r
= sd_bus_message_read(message
, "t", &flags
);
1872 if ((flags
& ~SD_LOGIND_SHUTDOWN_AND_SLEEP_FLAGS_PUBLIC
) != 0)
1873 return sd_bus_error_set(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid flags parameter");
1874 if (!streq(unit_name
, SPECIAL_REBOOT_TARGET
) && (flags
& SD_LOGIND_REBOOT_VIA_KEXEC
))
1875 return sd_bus_error_set(error
, SD_BUS_ERROR_INVALID_ARGS
, "Reboot via kexec is only applicable with reboot operations");
1877 /* Old style method: no flags parameter, but interactive bool passed as boolean in
1878 * payload. Let's convert this argument to the new-style flags parameter for our internal
1882 r
= sd_bus_message_read(message
, "b", &interactive
);
1886 flags
= interactive
? SD_LOGIND_INTERACTIVE
: 0;
1889 if ((flags
& SD_LOGIND_REBOOT_VIA_KEXEC
) && kexec_loaded())
1890 unit_name
= SPECIAL_KEXEC_TARGET
;
1892 /* Don't allow multiple jobs being executed at the same time */
1893 if (m
->action_what
> 0)
1894 return sd_bus_error_setf(error
, BUS_ERROR_OPERATION_IN_PROGRESS
,
1895 "There's already a shutdown or sleep operation in progress");
1898 r
= can_sleep(sleep_verb
);
1900 return sd_bus_error_set(error
, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED
,
1901 "Not enough swap space for hibernation");
1903 return sd_bus_error_setf(error
, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED
,
1904 "Sleep verb \"%s\" not supported", sleep_verb
);
1909 r
= verify_shutdown_creds(m
, message
, w
, action
, action_multiple_sessions
,
1910 action_ignore_inhibit
, flags
, error
);
1914 r
= bus_manager_shutdown_or_sleep_now_or_later(m
, unit_name
, w
, error
);
1918 return sd_bus_reply_method_return(message
, NULL
);
1921 static int method_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1922 Manager
*m
= userdata
;
1924 return method_do_shutdown_or_sleep(
1926 SPECIAL_POWEROFF_TARGET
,
1928 "org.freedesktop.login1.power-off",
1929 "org.freedesktop.login1.power-off-multiple-sessions",
1930 "org.freedesktop.login1.power-off-ignore-inhibit",
1932 sd_bus_message_is_method_call(message
, NULL
, "PowerOffWithFlags"),
1936 static int method_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1937 Manager
*m
= userdata
;
1939 return method_do_shutdown_or_sleep(
1941 SPECIAL_REBOOT_TARGET
,
1943 "org.freedesktop.login1.reboot",
1944 "org.freedesktop.login1.reboot-multiple-sessions",
1945 "org.freedesktop.login1.reboot-ignore-inhibit",
1947 sd_bus_message_is_method_call(message
, NULL
, "RebootWithFlags"),
1951 static int method_halt(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1952 Manager
*m
= userdata
;
1954 return method_do_shutdown_or_sleep(
1956 SPECIAL_HALT_TARGET
,
1958 "org.freedesktop.login1.halt",
1959 "org.freedesktop.login1.halt-multiple-sessions",
1960 "org.freedesktop.login1.halt-ignore-inhibit",
1962 sd_bus_message_is_method_call(message
, NULL
, "HaltWithFlags"),
1966 static int method_suspend(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1967 Manager
*m
= userdata
;
1969 return method_do_shutdown_or_sleep(
1971 SPECIAL_SUSPEND_TARGET
,
1973 "org.freedesktop.login1.suspend",
1974 "org.freedesktop.login1.suspend-multiple-sessions",
1975 "org.freedesktop.login1.suspend-ignore-inhibit",
1977 sd_bus_message_is_method_call(message
, NULL
, "SuspendWithFlags"),
1981 static int method_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1982 Manager
*m
= userdata
;
1984 return method_do_shutdown_or_sleep(
1986 SPECIAL_HIBERNATE_TARGET
,
1988 "org.freedesktop.login1.hibernate",
1989 "org.freedesktop.login1.hibernate-multiple-sessions",
1990 "org.freedesktop.login1.hibernate-ignore-inhibit",
1992 sd_bus_message_is_method_call(message
, NULL
, "HibernateWithFlags"),
1996 static int method_hybrid_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1997 Manager
*m
= userdata
;
1999 return method_do_shutdown_or_sleep(
2001 SPECIAL_HYBRID_SLEEP_TARGET
,
2003 "org.freedesktop.login1.hibernate",
2004 "org.freedesktop.login1.hibernate-multiple-sessions",
2005 "org.freedesktop.login1.hibernate-ignore-inhibit",
2007 sd_bus_message_is_method_call(message
, NULL
, "HybridSleepWithFlags"),
2011 static int method_suspend_then_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2012 Manager
*m
= userdata
;
2014 return method_do_shutdown_or_sleep(
2016 SPECIAL_SUSPEND_THEN_HIBERNATE_TARGET
,
2018 "org.freedesktop.login1.hibernate",
2019 "org.freedesktop.login1.hibernate-multiple-sessions",
2020 "org.freedesktop.login1.hibernate-ignore-inhibit",
2022 sd_bus_message_is_method_call(message
, NULL
, "SuspendThenHibernateWithFlags"),
2026 static int nologin_timeout_handler(
2031 Manager
*m
= userdata
;
2033 log_info("Creating /run/nologin, blocking further logins...");
2036 create_shutdown_run_nologin_or_warn() >= 0;
2041 static int update_schedule_file(Manager
*m
) {
2042 _cleanup_free_
char *temp_path
= NULL
;
2043 _cleanup_fclose_
FILE *f
= NULL
;
2048 r
= mkdir_safe_label("/run/systemd/shutdown", 0755, 0, 0, MKDIR_WARN_MODE
);
2050 return log_error_errno(r
, "Failed to create shutdown subdirectory: %m");
2052 r
= fopen_temporary("/run/systemd/shutdown/scheduled", &f
, &temp_path
);
2054 return log_error_errno(r
, "Failed to save information about scheduled shutdowns: %m");
2056 (void) fchmod(fileno(f
), 0644);
2062 m
->scheduled_shutdown_timeout
,
2063 m
->enable_wall_messages
,
2064 m
->scheduled_shutdown_type
);
2066 if (!isempty(m
->wall_message
)) {
2067 _cleanup_free_
char *t
= NULL
;
2069 t
= cescape(m
->wall_message
);
2075 fprintf(f
, "WALL_MESSAGE=%s\n", t
);
2078 r
= fflush_and_check(f
);
2082 if (rename(temp_path
, "/run/systemd/shutdown/scheduled") < 0) {
2090 (void) unlink(temp_path
);
2091 (void) unlink("/run/systemd/shutdown/scheduled");
2093 return log_error_errno(r
, "Failed to write information about scheduled shutdowns: %m");
2096 static void reset_scheduled_shutdown(Manager
*m
) {
2099 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
2100 m
->wall_message_timeout_source
= sd_event_source_unref(m
->wall_message_timeout_source
);
2101 m
->nologin_timeout_source
= sd_event_source_unref(m
->nologin_timeout_source
);
2103 m
->scheduled_shutdown_type
= mfree(m
->scheduled_shutdown_type
);
2104 m
->scheduled_shutdown_timeout
= 0;
2105 m
->shutdown_dry_run
= false;
2107 if (m
->unlink_nologin
) {
2108 (void) unlink_or_warn("/run/nologin");
2109 m
->unlink_nologin
= false;
2112 (void) unlink("/run/systemd/shutdown/scheduled");
2115 static int manager_scheduled_shutdown_handler(
2120 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2121 Manager
*m
= userdata
;
2127 if (isempty(m
->scheduled_shutdown_type
))
2130 if (streq(m
->scheduled_shutdown_type
, "poweroff"))
2131 target
= SPECIAL_POWEROFF_TARGET
;
2132 else if (streq(m
->scheduled_shutdown_type
, "reboot"))
2133 target
= SPECIAL_REBOOT_TARGET
;
2134 else if (streq(m
->scheduled_shutdown_type
, "kexec"))
2135 target
= SPECIAL_KEXEC_TARGET
;
2136 else if (streq(m
->scheduled_shutdown_type
, "halt"))
2137 target
= SPECIAL_HALT_TARGET
;
2139 assert_not_reached("unexpected shutdown type");
2141 /* Don't allow multiple jobs being executed at the same time */
2142 if (m
->action_what
> 0) {
2144 log_error("Scheduled shutdown to %s failed: shutdown or sleep operation already in progress", target
);
2148 if (m
->shutdown_dry_run
) {
2149 /* We do not process delay inhibitors here. Otherwise, we
2150 * would have to be considered "in progress" (like the check
2151 * above) for some seconds after our admin has seen the final
2154 bus_manager_log_shutdown(m
, target
);
2155 log_info("Running in dry run, suppressing action.");
2156 reset_scheduled_shutdown(m
);
2161 r
= bus_manager_shutdown_or_sleep_now_or_later(m
, target
, INHIBIT_SHUTDOWN
, &error
);
2163 log_error_errno(r
, "Scheduled shutdown to %s failed: %m", target
);
2170 reset_scheduled_shutdown(m
);
2174 static int method_schedule_shutdown(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2175 Manager
*m
= userdata
;
2176 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2177 const char *action_multiple_sessions
= NULL
;
2178 const char *action_ignore_inhibit
= NULL
;
2179 const char *action
= NULL
;
2183 bool dry_run
= false;
2188 r
= sd_bus_message_read(message
, "st", &type
, &elapse
);
2192 if (startswith(type
, "dry-")) {
2197 if (streq(type
, "poweroff")) {
2198 action
= "org.freedesktop.login1.power-off";
2199 action_multiple_sessions
= "org.freedesktop.login1.power-off-multiple-sessions";
2200 action_ignore_inhibit
= "org.freedesktop.login1.power-off-ignore-inhibit";
2201 } else if (STR_IN_SET(type
, "reboot", "kexec")) {
2202 action
= "org.freedesktop.login1.reboot";
2203 action_multiple_sessions
= "org.freedesktop.login1.reboot-multiple-sessions";
2204 action_ignore_inhibit
= "org.freedesktop.login1.reboot-ignore-inhibit";
2205 } else if (streq(type
, "halt")) {
2206 action
= "org.freedesktop.login1.halt";
2207 action_multiple_sessions
= "org.freedesktop.login1.halt-multiple-sessions";
2208 action_ignore_inhibit
= "org.freedesktop.login1.halt-ignore-inhibit";
2210 return sd_bus_error_set(error
, SD_BUS_ERROR_INVALID_ARGS
, "Unsupported shutdown type");
2212 r
= verify_shutdown_creds(m
, message
, INHIBIT_SHUTDOWN
, action
, action_multiple_sessions
,
2213 action_ignore_inhibit
, 0, error
);
2217 if (m
->scheduled_shutdown_timeout_source
) {
2218 r
= sd_event_source_set_time(m
->scheduled_shutdown_timeout_source
, elapse
);
2220 return log_error_errno(r
, "sd_event_source_set_time() failed: %m");
2222 r
= sd_event_source_set_enabled(m
->scheduled_shutdown_timeout_source
, SD_EVENT_ONESHOT
);
2224 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
2226 r
= sd_event_add_time(m
->event
, &m
->scheduled_shutdown_timeout_source
,
2227 CLOCK_REALTIME
, elapse
, 0, manager_scheduled_shutdown_handler
, m
);
2229 return log_error_errno(r
, "sd_event_add_time() failed: %m");
2232 r
= free_and_strdup(&m
->scheduled_shutdown_type
, type
);
2234 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
2238 m
->shutdown_dry_run
= dry_run
;
2240 if (m
->nologin_timeout_source
) {
2241 r
= sd_event_source_set_time(m
->nologin_timeout_source
, elapse
);
2243 return log_error_errno(r
, "sd_event_source_set_time() failed: %m");
2245 r
= sd_event_source_set_enabled(m
->nologin_timeout_source
, SD_EVENT_ONESHOT
);
2247 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
2249 r
= sd_event_add_time(m
->event
, &m
->nologin_timeout_source
,
2250 CLOCK_REALTIME
, elapse
- 5 * USEC_PER_MINUTE
, 0, nologin_timeout_handler
, m
);
2252 return log_error_errno(r
, "sd_event_add_time() failed: %m");
2255 m
->scheduled_shutdown_timeout
= elapse
;
2257 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_AUGMENT
|SD_BUS_CREDS_TTY
|SD_BUS_CREDS_UID
, &creds
);
2259 const char *tty
= NULL
;
2261 (void) sd_bus_creds_get_uid(creds
, &m
->scheduled_shutdown_uid
);
2262 (void) sd_bus_creds_get_tty(creds
, &tty
);
2264 r
= free_and_strdup(&m
->scheduled_shutdown_tty
, tty
);
2266 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
2271 r
= manager_setup_wall_message_timer(m
);
2275 r
= update_schedule_file(m
);
2279 return sd_bus_reply_method_return(message
, NULL
);
2282 static int method_cancel_scheduled_shutdown(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2283 Manager
*m
= userdata
;
2289 cancelled
= m
->scheduled_shutdown_type
!= NULL
;
2290 reset_scheduled_shutdown(m
);
2292 if (cancelled
&& m
->enable_wall_messages
) {
2293 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2294 _cleanup_free_
char *username
= NULL
;
2295 const char *tty
= NULL
;
2299 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_AUGMENT
|SD_BUS_CREDS_TTY
|SD_BUS_CREDS_UID
, &creds
);
2301 (void) sd_bus_creds_get_uid(creds
, &uid
);
2302 (void) sd_bus_creds_get_tty(creds
, &tty
);
2305 username
= uid_to_name(uid
);
2306 utmp_wall("The system shutdown has been cancelled",
2307 username
, tty
, logind_wall_tty_filter
, m
);
2310 return sd_bus_reply_method_return(message
, "b", cancelled
);
2313 static int method_can_shutdown_or_sleep(
2315 sd_bus_message
*message
,
2318 const char *action_multiple_sessions
,
2319 const char *action_ignore_inhibit
,
2320 const char *sleep_verb
,
2321 sd_bus_error
*error
) {
2323 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2324 HandleAction handle
;
2325 bool multiple_sessions
, challenge
, blocked
;
2326 const char *result
= NULL
;
2333 assert(w
<= _INHIBIT_WHAT_MAX
);
2335 assert(action_multiple_sessions
);
2336 assert(action_ignore_inhibit
);
2339 r
= can_sleep(sleep_verb
);
2340 if (IN_SET(r
, 0, -ENOSPC
))
2341 return sd_bus_reply_method_return(message
, "s", "na");
2346 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
, &creds
);
2350 r
= sd_bus_creds_get_euid(creds
, &uid
);
2354 r
= have_multiple_sessions(m
, uid
);
2358 multiple_sessions
= r
> 0;
2359 blocked
= manager_is_inhibited(m
, w
, INHIBIT_BLOCK
, NULL
, false, true, uid
, NULL
);
2361 handle
= handle_action_from_string(sleep_verb
);
2365 target
= manager_target_for_action(handle
);
2367 _cleanup_free_
char *load_state
= NULL
;
2369 r
= unit_load_state(m
->bus
, target
, &load_state
);
2373 if (!streq(load_state
, "loaded")) {
2380 if (multiple_sessions
) {
2381 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action_multiple_sessions
, NULL
, UID_INVALID
, &challenge
, error
);
2388 result
= "challenge";
2394 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action_ignore_inhibit
, NULL
, UID_INVALID
, &challenge
, error
);
2401 } else if (challenge
) {
2402 if (!result
|| streq(result
, "yes"))
2403 result
= "challenge";
2408 if (!multiple_sessions
&& !blocked
) {
2409 /* If neither inhibit nor multiple sessions
2410 * apply then just check the normal policy */
2412 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action
, NULL
, UID_INVALID
, &challenge
, error
);
2419 result
= "challenge";
2425 return sd_bus_reply_method_return(message
, "s", result
);
2428 static int method_can_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2429 Manager
*m
= userdata
;
2431 return method_can_shutdown_or_sleep(
2434 "org.freedesktop.login1.power-off",
2435 "org.freedesktop.login1.power-off-multiple-sessions",
2436 "org.freedesktop.login1.power-off-ignore-inhibit",
2441 static int method_can_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2442 Manager
*m
= userdata
;
2444 return method_can_shutdown_or_sleep(
2447 "org.freedesktop.login1.reboot",
2448 "org.freedesktop.login1.reboot-multiple-sessions",
2449 "org.freedesktop.login1.reboot-ignore-inhibit",
2454 static int method_can_halt(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2455 Manager
*m
= userdata
;
2457 return method_can_shutdown_or_sleep(
2460 "org.freedesktop.login1.halt",
2461 "org.freedesktop.login1.halt-multiple-sessions",
2462 "org.freedesktop.login1.halt-ignore-inhibit",
2467 static int method_can_suspend(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2468 Manager
*m
= userdata
;
2470 return method_can_shutdown_or_sleep(
2473 "org.freedesktop.login1.suspend",
2474 "org.freedesktop.login1.suspend-multiple-sessions",
2475 "org.freedesktop.login1.suspend-ignore-inhibit",
2480 static int method_can_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2481 Manager
*m
= userdata
;
2483 return method_can_shutdown_or_sleep(
2486 "org.freedesktop.login1.hibernate",
2487 "org.freedesktop.login1.hibernate-multiple-sessions",
2488 "org.freedesktop.login1.hibernate-ignore-inhibit",
2493 static int method_can_hybrid_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2494 Manager
*m
= userdata
;
2496 return method_can_shutdown_or_sleep(
2499 "org.freedesktop.login1.hibernate",
2500 "org.freedesktop.login1.hibernate-multiple-sessions",
2501 "org.freedesktop.login1.hibernate-ignore-inhibit",
2506 static int method_can_suspend_then_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2507 Manager
*m
= userdata
;
2509 return method_can_shutdown_or_sleep(
2512 "org.freedesktop.login1.hibernate",
2513 "org.freedesktop.login1.hibernate-multiple-sessions",
2514 "org.freedesktop.login1.hibernate-ignore-inhibit",
2515 "suspend-then-hibernate",
2519 static int property_get_reboot_parameter(
2522 const char *interface
,
2523 const char *property
,
2524 sd_bus_message
*reply
,
2526 sd_bus_error
*error
) {
2527 _cleanup_free_
char *parameter
= NULL
;
2534 r
= read_reboot_parameter(¶meter
);
2538 return sd_bus_message_append(reply
, "s", parameter
);
2541 static int method_set_reboot_parameter(
2542 sd_bus_message
*message
,
2544 sd_bus_error
*error
) {
2546 Manager
*m
= userdata
;
2553 r
= sd_bus_message_read(message
, "s", &arg
);
2557 r
= detect_container();
2561 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
,
2562 "Reboot parameter not supported in containers, refusing.");
2564 r
= bus_verify_polkit_async(message
,
2566 "org.freedesktop.login1.set-reboot-parameter",
2570 &m
->polkit_registry
,
2575 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2577 r
= update_reboot_parameter_and_warn(arg
, false);
2581 return sd_bus_reply_method_return(message
, NULL
);
2584 static int method_can_reboot_parameter(
2585 sd_bus_message
*message
,
2587 sd_bus_error
*error
) {
2589 _unused_ Manager
*m
= userdata
;
2595 r
= detect_container();
2598 if (r
> 0) /* Inside containers, specifying a reboot parameter, doesn't make much sense */
2599 return sd_bus_reply_method_return(message
, "s", "na");
2601 return return_test_polkit(
2604 "org.freedesktop.login1.set-reboot-parameter",
2610 static int property_get_reboot_to_firmware_setup(
2613 const char *interface
,
2614 const char *property
,
2615 sd_bus_message
*reply
,
2617 sd_bus_error
*error
) {
2624 r
= getenv_bool("SYSTEMD_REBOOT_TO_FIRMWARE_SETUP");
2626 /* EFI case: let's see what is currently configured in the EFI variables */
2627 r
= efi_get_reboot_to_firmware();
2628 if (r
< 0 && r
!= -EOPNOTSUPP
)
2629 log_warning_errno(r
, "Failed to determine reboot-to-firmware-setup state: %m");
2631 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP: %m");
2633 /* Non-EFI case: let's see whether /run/systemd/reboot-to-firmware-setup exists. */
2634 if (access("/run/systemd/reboot-to-firmware-setup", F_OK
) < 0) {
2635 if (errno
!= ENOENT
)
2636 log_warning_errno(errno
, "Failed to check whether /run/systemd/reboot-to-firmware-setup exists: %m");
2643 return sd_bus_message_append(reply
, "b", r
> 0);
2646 static int method_set_reboot_to_firmware_setup(
2647 sd_bus_message
*message
,
2649 sd_bus_error
*error
) {
2651 Manager
*m
= userdata
;
2658 r
= sd_bus_message_read(message
, "b", &b
);
2662 r
= getenv_bool("SYSTEMD_REBOOT_TO_FIRMWARE_SETUP");
2664 /* EFI case: let's see what the firmware supports */
2666 r
= efi_reboot_to_firmware_supported();
2667 if (r
== -EOPNOTSUPP
)
2668 return sd_bus_error_set(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Firmware does not support boot into firmware.");
2674 } else if (r
<= 0) {
2675 /* non-EFI case: $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP is set to off */
2678 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP: %m");
2680 return sd_bus_error_set(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Firmware does not support boot into firmware.");
2682 /* non-EFI case: $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP is set to on */
2685 r
= bus_verify_polkit_async(message
,
2687 "org.freedesktop.login1.set-reboot-to-firmware-setup",
2691 &m
->polkit_registry
,
2696 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2699 r
= efi_set_reboot_to_firmware(b
);
2704 r
= touch("/run/systemd/reboot-to-firmware-setup");
2708 if (unlink("/run/systemd/reboot-to-firmware-setup") < 0 && errno
!= ENOENT
)
2713 return sd_bus_reply_method_return(message
, NULL
);
2716 static int method_can_reboot_to_firmware_setup(
2717 sd_bus_message
*message
,
2719 sd_bus_error
*error
) {
2721 _unused_ Manager
*m
= userdata
;
2727 r
= getenv_bool("SYSTEMD_REBOOT_TO_FIRMWARE_SETUP");
2729 /* EFI case: let's see what the firmware supports */
2731 r
= efi_reboot_to_firmware_supported();
2733 if (r
!= -EOPNOTSUPP
)
2734 log_warning_errno(r
, "Failed to determine whether reboot to firmware is supported: %m");
2736 return sd_bus_reply_method_return(message
, "s", "na");
2739 } else if (r
<= 0) {
2740 /* Non-EFI case: let's trust $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP */
2743 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP: %m");
2745 return sd_bus_reply_method_return(message
, "s", "na");
2748 return return_test_polkit(
2751 "org.freedesktop.login1.set-reboot-to-firmware-setup",
2757 static int property_get_reboot_to_boot_loader_menu(
2760 const char *interface
,
2761 const char *property
,
2762 sd_bus_message
*reply
,
2764 sd_bus_error
*error
) {
2766 uint64_t x
= UINT64_MAX
;
2773 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU");
2775 /* EFI case: returns the current value of LoaderConfigTimeoutOneShot. Three cases are distuingished:
2777 * 1. Variable not set, boot into boot loader menu is not enabled (we return UINT64_MAX to the user)
2778 * 2. Variable set to "0", boot into boot loader menu is enabled with no timeout (we return 0 to the user)
2779 * 3. Variable set to numeric value formatted in ASCII, boot into boot loader menu with the specified timeout in seconds
2782 r
= efi_loader_get_config_timeout_one_shot(&x
);
2785 log_warning_errno(r
, "Failed to read LoaderConfigTimeoutOneShot variable, ignoring: %m");
2789 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU: %m");
2791 _cleanup_free_
char *v
= NULL
;
2793 /* Non-EFI case, let's process /run/systemd/reboot-to-boot-loader-menu. */
2795 r
= read_one_line_file("/run/systemd/reboot-to-boot-loader-menu", &v
);
2798 log_warning_errno(r
, "Failed to read /run/systemd/reboot-to-boot-loader-menu: %m");
2800 r
= safe_atou64(v
, &x
);
2802 log_warning_errno(r
, "Failed to parse /run/systemd/reboot-to-boot-loader-menu: %m");
2806 return sd_bus_message_append(reply
, "t", x
);
2809 static int method_set_reboot_to_boot_loader_menu(
2810 sd_bus_message
*message
,
2812 sd_bus_error
*error
) {
2814 Manager
*m
= userdata
;
2822 r
= sd_bus_message_read(message
, "t", &x
);
2826 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU");
2830 /* EFI case: let's see if booting into boot loader menu is supported. */
2832 r
= efi_loader_get_features(&features
);
2834 log_warning_errno(r
, "Failed to determine whether reboot to boot loader menu is supported: %m");
2835 if (r
< 0 || !FLAGS_SET(features
, EFI_LOADER_FEATURE_CONFIG_TIMEOUT_ONE_SHOT
))
2836 return sd_bus_error_set(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Boot loader does not support boot into boot loader menu.");
2840 } else if (r
<= 0) {
2841 /* non-EFI case: $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU is set to off */
2844 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU: %m");
2846 return sd_bus_error_set(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Boot loader does not support boot into boot loader menu.");
2848 /* non-EFI case: $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU is set to on */
2851 r
= bus_verify_polkit_async(message
,
2853 "org.freedesktop.login1.set-reboot-to-boot-loader-menu",
2857 &m
->polkit_registry
,
2862 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2865 if (x
== UINT64_MAX
)
2866 r
= efi_set_variable(EFI_VENDOR_LOADER
, "LoaderConfigTimeoutOneShot", NULL
, 0);
2868 char buf
[DECIMAL_STR_MAX(uint64_t) + 1];
2869 xsprintf(buf
, "%" PRIu64
, DIV_ROUND_UP(x
, USEC_PER_SEC
)); /* second granularity */
2871 r
= efi_set_variable_string(EFI_VENDOR_LOADER
, "LoaderConfigTimeoutOneShot", buf
);
2876 if (x
== UINT64_MAX
) {
2877 if (unlink("/run/systemd/reboot-to-boot-loader-menu") < 0 && errno
!= ENOENT
)
2880 char buf
[DECIMAL_STR_MAX(uint64_t) + 1];
2882 xsprintf(buf
, "%" PRIu64
, x
); /* µs granularity */
2884 r
= write_string_file_atomic_label("/run/systemd/reboot-to-boot-loader-menu", buf
);
2890 return sd_bus_reply_method_return(message
, NULL
);
2893 static int method_can_reboot_to_boot_loader_menu(
2894 sd_bus_message
*message
,
2896 sd_bus_error
*error
) {
2898 _unused_ Manager
*m
= userdata
;
2904 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU");
2906 uint64_t features
= 0;
2908 /* EFI case, let's see if booting into boot loader menu is supported. */
2910 r
= efi_loader_get_features(&features
);
2912 log_warning_errno(r
, "Failed to determine whether reboot to boot loader menu is supported: %m");
2913 if (r
< 0 || !FLAGS_SET(features
, EFI_LOADER_FEATURE_CONFIG_TIMEOUT_ONE_SHOT
))
2914 return sd_bus_reply_method_return(message
, "s", "na");
2916 } else if (r
<= 0) {
2917 /* Non-EFI case: let's trust $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU */
2920 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU: %m");
2922 return sd_bus_reply_method_return(message
, "s", "na");
2925 return return_test_polkit(
2928 "org.freedesktop.login1.set-reboot-to-boot-loader-menu",
2934 static int property_get_reboot_to_boot_loader_entry(
2937 const char *interface
,
2938 const char *property
,
2939 sd_bus_message
*reply
,
2941 sd_bus_error
*error
) {
2943 _cleanup_free_
char *v
= NULL
;
2944 Manager
*m
= userdata
;
2945 const char *x
= NULL
;
2952 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY");
2954 /* EFI case: let's read the LoaderEntryOneShot variable */
2956 r
= efi_loader_update_entry_one_shot_cache(&m
->efi_loader_entry_one_shot
, &m
->efi_loader_entry_one_shot_stat
);
2959 log_warning_errno(r
, "Failed to read LoaderEntryOneShot variable, ignoring: %m");
2961 x
= m
->efi_loader_entry_one_shot
;
2964 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY: %m");
2967 /* Non-EFI case, let's process /run/systemd/reboot-to-boot-loader-entry. */
2969 r
= read_one_line_file("/run/systemd/reboot-to-boot-loader-entry", &v
);
2972 log_warning_errno(r
, "Failed to read /run/systemd/reboot-to-boot-loader-entry, ignoring: %m");
2973 } else if (!efi_loader_entry_name_valid(v
))
2974 log_warning("/run/systemd/reboot-to-boot-loader-entry is not valid, ignoring.");
2979 return sd_bus_message_append(reply
, "s", x
);
2982 static int boot_loader_entry_exists(Manager
*m
, const char *id
) {
2983 _cleanup_(boot_config_free
) BootConfig config
= {};
2989 r
= boot_entries_load_config_auto(NULL
, NULL
, &config
);
2990 if (r
< 0 && r
!= -ENOKEY
) /* don't complain if no GPT is found, hence skip ENOKEY */
2993 r
= manager_read_efi_boot_loader_entries(m
);
2995 (void) boot_entries_augment_from_loader(&config
, m
->efi_boot_loader_entries
, true);
2997 return boot_config_has_entry(&config
, id
);
3000 static int method_set_reboot_to_boot_loader_entry(
3001 sd_bus_message
*message
,
3003 sd_bus_error
*error
) {
3005 Manager
*m
= userdata
;
3013 r
= sd_bus_message_read(message
, "s", &v
);
3019 else if (efi_loader_entry_name_valid(v
)) {
3020 r
= boot_loader_entry_exists(m
, v
);
3024 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Boot loader entry '%s' is not known.", v
);
3026 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Boot loader entry name '%s' is not valid, refusing.", v
);
3028 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY");
3032 /* EFI case: let's see if booting into boot loader entry is supported. */
3034 r
= efi_loader_get_features(&features
);
3036 log_warning_errno(r
, "Failed to determine whether reboot into boot loader entry is supported: %m");
3037 if (r
< 0 || !FLAGS_SET(features
, EFI_LOADER_FEATURE_ENTRY_ONESHOT
))
3038 return sd_bus_error_set(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Loader does not support boot into boot loader entry.");
3042 } else if (r
<= 0) {
3043 /* non-EFI case: $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY is set to off */
3046 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY: %m");
3048 return sd_bus_error_set(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Loader does not support boot into boot loader entry.");
3050 /* non-EFI case: $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY is set to on */
3053 r
= bus_verify_polkit_async(message
,
3055 "org.freedesktop.login1.set-reboot-to-boot-loader-entry",
3059 &m
->polkit_registry
,
3064 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
3069 r
= efi_set_variable(EFI_VENDOR_LOADER
, "LoaderEntryOneShot", NULL
, 0);
3071 r
= efi_set_variable_string(EFI_VENDOR_LOADER
, "LoaderEntryOneShot", v
);
3076 if (unlink("/run/systemd/reboot-to-boot-loader-entry") < 0 && errno
!= ENOENT
)
3079 r
= write_string_file_atomic_label("/run/systemd/reboot-boot-to-loader-entry", v
);
3085 return sd_bus_reply_method_return(message
, NULL
);
3088 static int method_can_reboot_to_boot_loader_entry(
3089 sd_bus_message
*message
,
3091 sd_bus_error
*error
) {
3093 _unused_ Manager
*m
= userdata
;
3099 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY");
3101 uint64_t features
= 0;
3103 /* EFI case, let's see if booting into boot loader entry is supported. */
3105 r
= efi_loader_get_features(&features
);
3107 log_warning_errno(r
, "Failed to determine whether reboot to boot loader entry is supported: %m");
3108 if (r
< 0 || !FLAGS_SET(features
, EFI_LOADER_FEATURE_ENTRY_ONESHOT
))
3109 return sd_bus_reply_method_return(message
, "s", "na");
3111 } else if (r
<= 0) {
3112 /* Non-EFI case: let's trust $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY */
3115 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY: %m");
3117 return sd_bus_reply_method_return(message
, "s", "na");
3120 return return_test_polkit(
3123 "org.freedesktop.login1.set-reboot-to-boot-loader-entry",
3129 static int property_get_boot_loader_entries(
3132 const char *interface
,
3133 const char *property
,
3134 sd_bus_message
*reply
,
3136 sd_bus_error
*error
) {
3138 _cleanup_(boot_config_free
) BootConfig config
= {};
3139 Manager
*m
= userdata
;
3147 r
= boot_entries_load_config_auto(NULL
, NULL
, &config
);
3148 if (r
< 0 && r
!= -ENOKEY
) /* don't complain if there's no GPT found */
3151 r
= manager_read_efi_boot_loader_entries(m
);
3153 (void) boot_entries_augment_from_loader(&config
, m
->efi_boot_loader_entries
, true);
3155 r
= sd_bus_message_open_container(reply
, 'a', "s");
3159 for (i
= 0; i
< config
.n_entries
; i
++) {
3160 BootEntry
*e
= config
.entries
+ i
;
3162 r
= sd_bus_message_append(reply
, "s", e
->id
);
3167 return sd_bus_message_close_container(reply
);
3170 static int method_set_wall_message(
3171 sd_bus_message
*message
,
3173 sd_bus_error
*error
) {
3176 Manager
*m
= userdata
;
3178 unsigned enable_wall_messages
;
3183 r
= sd_bus_message_read(message
, "sb", &wall_message
, &enable_wall_messages
);
3187 /* Short-circuit the operation if the desired state is already in place, to
3188 * avoid an unnecessary polkit permission check. */
3189 if (streq_ptr(m
->wall_message
, empty_to_null(wall_message
)) &&
3190 m
->enable_wall_messages
== enable_wall_messages
)
3193 r
= bus_verify_polkit_async(message
,
3195 "org.freedesktop.login1.set-wall-message",
3199 &m
->polkit_registry
,
3204 return 1; /* Will call us back */
3206 r
= free_and_strdup(&m
->wall_message
, empty_to_null(wall_message
));
3210 m
->enable_wall_messages
= enable_wall_messages
;
3213 return sd_bus_reply_method_return(message
, NULL
);
3216 static int method_inhibit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
3217 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
3218 const char *who
, *why
, *what
, *mode
;
3219 _cleanup_free_
char *id
= NULL
;
3220 _cleanup_close_
int fifo_fd
= -1;
3221 Manager
*m
= userdata
;
3231 r
= sd_bus_message_read(message
, "ssss", &what
, &who
, &why
, &mode
);
3235 w
= inhibit_what_from_string(what
);
3237 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
3238 "Invalid what specification %s", what
);
3240 mm
= inhibit_mode_from_string(mode
);
3242 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
3243 "Invalid mode specification %s", mode
);
3245 /* Delay is only supported for shutdown/sleep */
3246 if (mm
== INHIBIT_DELAY
&& (w
& ~(INHIBIT_SHUTDOWN
|INHIBIT_SLEEP
)))
3247 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
3248 "Delay inhibitors only supported for shutdown and sleep");
3250 /* Don't allow taking delay locks while we are already
3251 * executing the operation. We shouldn't create the impression
3252 * that the lock was successful if the machine is about to go
3253 * down/suspend any moment. */
3254 if (m
->action_what
& w
)
3255 return sd_bus_error_setf(error
, BUS_ERROR_OPERATION_IN_PROGRESS
,
3256 "The operation inhibition has been requested for is already running");
3258 r
= bus_verify_polkit_async(
3261 w
== INHIBIT_SHUTDOWN
? (mm
== INHIBIT_BLOCK
? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
3262 w
== INHIBIT_SLEEP
? (mm
== INHIBIT_BLOCK
? "org.freedesktop.login1.inhibit-block-sleep" : "org.freedesktop.login1.inhibit-delay-sleep") :
3263 w
== INHIBIT_IDLE
? "org.freedesktop.login1.inhibit-block-idle" :
3264 w
== INHIBIT_HANDLE_POWER_KEY
? "org.freedesktop.login1.inhibit-handle-power-key" :
3265 w
== INHIBIT_HANDLE_SUSPEND_KEY
? "org.freedesktop.login1.inhibit-handle-suspend-key" :
3266 w
== INHIBIT_HANDLE_REBOOT_KEY
? "org.freedesktop.login1.inhibit-handle-reboot-key" :
3267 w
== INHIBIT_HANDLE_HIBERNATE_KEY
? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
3268 "org.freedesktop.login1.inhibit-handle-lid-switch",
3272 &m
->polkit_registry
,
3277 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
3279 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
|SD_BUS_CREDS_PID
, &creds
);
3283 r
= sd_bus_creds_get_euid(creds
, &uid
);
3287 r
= sd_bus_creds_get_pid(creds
, &pid
);
3291 if (hashmap_size(m
->inhibitors
) >= m
->inhibitors_max
)
3292 return sd_bus_error_setf(error
, SD_BUS_ERROR_LIMITS_EXCEEDED
,
3293 "Maximum number of inhibitors (%" PRIu64
") reached, refusing further inhibitors.",
3299 if (asprintf(&id
, "%lu", ++m
->inhibit_counter
) < 0)
3302 } while (hashmap_get(m
->inhibitors
, id
));
3304 _cleanup_(inhibitor_freep
) Inhibitor
*i
= NULL
;
3305 r
= manager_add_inhibitor(m
, id
, &i
);
3313 i
->why
= strdup(why
);
3314 i
->who
= strdup(who
);
3316 if (!i
->why
|| !i
->who
)
3319 fifo_fd
= inhibitor_create_fifo(i
);
3323 r
= inhibitor_start(i
);
3328 return sd_bus_reply_method_return(message
, "h", fifo_fd
);
3331 static const sd_bus_vtable manager_vtable
[] = {
3332 SD_BUS_VTABLE_START(0),
3334 SD_BUS_WRITABLE_PROPERTY("EnableWallMessages", "b", NULL
, NULL
, offsetof(Manager
, enable_wall_messages
), 0),
3335 SD_BUS_WRITABLE_PROPERTY("WallMessage", "s", NULL
, NULL
, offsetof(Manager
, wall_message
), 0),
3337 SD_BUS_PROPERTY("NAutoVTs", "u", NULL
, offsetof(Manager
, n_autovts
), SD_BUS_VTABLE_PROPERTY_CONST
),
3338 SD_BUS_PROPERTY("KillOnlyUsers", "as", NULL
, offsetof(Manager
, kill_only_users
), SD_BUS_VTABLE_PROPERTY_CONST
),
3339 SD_BUS_PROPERTY("KillExcludeUsers", "as", NULL
, offsetof(Manager
, kill_exclude_users
), SD_BUS_VTABLE_PROPERTY_CONST
),
3340 SD_BUS_PROPERTY("KillUserProcesses", "b", NULL
, offsetof(Manager
, kill_user_processes
), SD_BUS_VTABLE_PROPERTY_CONST
),
3341 SD_BUS_PROPERTY("RebootParameter", "s", property_get_reboot_parameter
, 0, 0),
3342 SD_BUS_PROPERTY("RebootToFirmwareSetup", "b", property_get_reboot_to_firmware_setup
, 0, 0),
3343 SD_BUS_PROPERTY("RebootToBootLoaderMenu", "t", property_get_reboot_to_boot_loader_menu
, 0, 0),
3344 SD_BUS_PROPERTY("RebootToBootLoaderEntry", "s", property_get_reboot_to_boot_loader_entry
, 0, 0),
3345 SD_BUS_PROPERTY("BootLoaderEntries", "as", property_get_boot_loader_entries
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
3346 SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
3347 SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
3348 SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
3349 SD_BUS_PROPERTY("BlockInhibited", "s", property_get_inhibited
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
3350 SD_BUS_PROPERTY("DelayInhibited", "s", property_get_inhibited
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
3351 SD_BUS_PROPERTY("InhibitDelayMaxUSec", "t", NULL
, offsetof(Manager
, inhibit_delay_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
3352 SD_BUS_PROPERTY("UserStopDelayUSec", "t", NULL
, offsetof(Manager
, user_stop_delay
), SD_BUS_VTABLE_PROPERTY_CONST
),
3353 SD_BUS_PROPERTY("HandlePowerKey", "s", property_get_handle_action
, offsetof(Manager
, handle_power_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
3354 SD_BUS_PROPERTY("HandleSuspendKey", "s", property_get_handle_action
, offsetof(Manager
, handle_suspend_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
3355 SD_BUS_PROPERTY("HandleHibernateKey", "s", property_get_handle_action
, offsetof(Manager
, handle_hibernate_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
3356 SD_BUS_PROPERTY("HandleLidSwitch", "s", property_get_handle_action
, offsetof(Manager
, handle_lid_switch
), SD_BUS_VTABLE_PROPERTY_CONST
),
3357 SD_BUS_PROPERTY("HandleLidSwitchExternalPower", "s", property_get_handle_action
, offsetof(Manager
, handle_lid_switch_ep
), SD_BUS_VTABLE_PROPERTY_CONST
),
3358 SD_BUS_PROPERTY("HandleLidSwitchDocked", "s", property_get_handle_action
, offsetof(Manager
, handle_lid_switch_docked
), SD_BUS_VTABLE_PROPERTY_CONST
),
3359 SD_BUS_PROPERTY("HoldoffTimeoutUSec", "t", NULL
, offsetof(Manager
, holdoff_timeout_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
3360 SD_BUS_PROPERTY("IdleAction", "s", property_get_handle_action
, offsetof(Manager
, idle_action
), SD_BUS_VTABLE_PROPERTY_CONST
),
3361 SD_BUS_PROPERTY("IdleActionUSec", "t", NULL
, offsetof(Manager
, idle_action_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
3362 SD_BUS_PROPERTY("PreparingForShutdown", "b", property_get_preparing
, 0, 0),
3363 SD_BUS_PROPERTY("PreparingForSleep", "b", property_get_preparing
, 0, 0),
3364 SD_BUS_PROPERTY("ScheduledShutdown", "(st)", property_get_scheduled_shutdown
, 0, 0),
3365 SD_BUS_PROPERTY("Docked", "b", property_get_docked
, 0, 0),
3366 SD_BUS_PROPERTY("LidClosed", "b", property_get_lid_closed
, 0, 0),
3367 SD_BUS_PROPERTY("OnExternalPower", "b", property_get_on_external_power
, 0, 0),
3368 SD_BUS_PROPERTY("RemoveIPC", "b", bus_property_get_bool
, offsetof(Manager
, remove_ipc
), SD_BUS_VTABLE_PROPERTY_CONST
),
3369 SD_BUS_PROPERTY("RuntimeDirectorySize", "t", NULL
, offsetof(Manager
, runtime_dir_size
), SD_BUS_VTABLE_PROPERTY_CONST
),
3370 SD_BUS_PROPERTY("RuntimeDirectoryInodesMax", "t", NULL
, offsetof(Manager
, runtime_dir_inodes
), SD_BUS_VTABLE_PROPERTY_CONST
),
3371 SD_BUS_PROPERTY("InhibitorsMax", "t", NULL
, offsetof(Manager
, inhibitors_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
3372 SD_BUS_PROPERTY("NCurrentInhibitors", "t", property_get_hashmap_size
, offsetof(Manager
, inhibitors
), 0),
3373 SD_BUS_PROPERTY("SessionsMax", "t", NULL
, offsetof(Manager
, sessions_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
3374 SD_BUS_PROPERTY("NCurrentSessions", "t", property_get_hashmap_size
, offsetof(Manager
, sessions
), 0),
3375 SD_BUS_PROPERTY("UserTasksMax", "t", property_get_compat_user_tasks_max
, 0, SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_HIDDEN
),
3377 SD_BUS_METHOD_WITH_NAMES("GetSession",
3379 SD_BUS_PARAM(session_id
),
3381 SD_BUS_PARAM(object_path
),
3383 SD_BUS_VTABLE_UNPRIVILEGED
),
3384 SD_BUS_METHOD_WITH_NAMES("GetSessionByPID",
3388 SD_BUS_PARAM(object_path
),
3389 method_get_session_by_pid
,
3390 SD_BUS_VTABLE_UNPRIVILEGED
),
3391 SD_BUS_METHOD_WITH_NAMES("GetUser",
3395 SD_BUS_PARAM(object_path
),
3397 SD_BUS_VTABLE_UNPRIVILEGED
),
3398 SD_BUS_METHOD_WITH_NAMES("GetUserByPID",
3402 SD_BUS_PARAM(object_path
),
3403 method_get_user_by_pid
,
3404 SD_BUS_VTABLE_UNPRIVILEGED
),
3405 SD_BUS_METHOD_WITH_NAMES("GetSeat",
3407 SD_BUS_PARAM(seat_id
),
3409 SD_BUS_PARAM(object_path
),
3411 SD_BUS_VTABLE_UNPRIVILEGED
),
3412 SD_BUS_METHOD_WITH_NAMES("ListSessions",
3415 SD_BUS_PARAM(sessions
),
3416 method_list_sessions
,
3417 SD_BUS_VTABLE_UNPRIVILEGED
),
3418 SD_BUS_METHOD_WITH_NAMES("ListUsers",
3421 SD_BUS_PARAM(users
),
3423 SD_BUS_VTABLE_UNPRIVILEGED
),
3424 SD_BUS_METHOD_WITH_NAMES("ListSeats",
3427 SD_BUS_PARAM(seats
),
3429 SD_BUS_VTABLE_UNPRIVILEGED
),
3430 SD_BUS_METHOD_WITH_NAMES("ListInhibitors",
3433 SD_BUS_PARAM(inhibitors
),
3434 method_list_inhibitors
,
3435 SD_BUS_VTABLE_UNPRIVILEGED
),
3436 SD_BUS_METHOD_WITH_NAMES("CreateSession",
3437 "uusssssussbssa(sv)",
3440 SD_BUS_PARAM(service
)
3443 SD_BUS_PARAM(desktop
)
3444 SD_BUS_PARAM(seat_id
)
3447 SD_BUS_PARAM(display
)
3448 SD_BUS_PARAM(remote
)
3449 SD_BUS_PARAM(remote_user
)
3450 SD_BUS_PARAM(remote_host
)
3451 SD_BUS_PARAM(properties
),
3453 SD_BUS_PARAM(session_id
)
3454 SD_BUS_PARAM(object_path
)
3455 SD_BUS_PARAM(runtime_path
)
3456 SD_BUS_PARAM(fifo_fd
)
3458 SD_BUS_PARAM(seat_id
)
3460 SD_BUS_PARAM(existing
),
3461 method_create_session
,
3463 SD_BUS_METHOD_WITH_NAMES("ReleaseSession",
3465 SD_BUS_PARAM(session_id
),
3467 method_release_session
,
3469 SD_BUS_METHOD_WITH_NAMES("ActivateSession",
3471 SD_BUS_PARAM(session_id
),
3473 method_activate_session
,
3474 SD_BUS_VTABLE_UNPRIVILEGED
),
3475 SD_BUS_METHOD_WITH_NAMES("ActivateSessionOnSeat",
3477 SD_BUS_PARAM(session_id
)
3478 SD_BUS_PARAM(seat_id
),
3480 method_activate_session_on_seat
,
3481 SD_BUS_VTABLE_UNPRIVILEGED
),
3482 SD_BUS_METHOD_WITH_NAMES("LockSession",
3484 SD_BUS_PARAM(session_id
),
3486 method_lock_session
,
3487 SD_BUS_VTABLE_UNPRIVILEGED
),
3488 SD_BUS_METHOD_WITH_NAMES("UnlockSession",
3490 SD_BUS_PARAM(session_id
),
3492 method_lock_session
,
3493 SD_BUS_VTABLE_UNPRIVILEGED
),
3494 SD_BUS_METHOD("LockSessions",
3497 method_lock_sessions
,
3498 SD_BUS_VTABLE_UNPRIVILEGED
),
3499 SD_BUS_METHOD("UnlockSessions",
3502 method_lock_sessions
,
3503 SD_BUS_VTABLE_UNPRIVILEGED
),
3504 SD_BUS_METHOD_WITH_NAMES("KillSession",
3506 SD_BUS_PARAM(session_id
)
3508 SD_BUS_PARAM(signal_number
),
3510 method_kill_session
,
3511 SD_BUS_VTABLE_UNPRIVILEGED
),
3512 SD_BUS_METHOD_WITH_NAMES("KillUser",
3515 SD_BUS_PARAM(signal_number
),
3518 SD_BUS_VTABLE_UNPRIVILEGED
),
3519 SD_BUS_METHOD_WITH_NAMES("TerminateSession",
3521 SD_BUS_PARAM(session_id
),
3523 method_terminate_session
,
3524 SD_BUS_VTABLE_UNPRIVILEGED
),
3525 SD_BUS_METHOD_WITH_NAMES("TerminateUser",
3529 method_terminate_user
,
3530 SD_BUS_VTABLE_UNPRIVILEGED
),
3531 SD_BUS_METHOD_WITH_NAMES("TerminateSeat",
3533 SD_BUS_PARAM(seat_id
),
3535 method_terminate_seat
,
3536 SD_BUS_VTABLE_UNPRIVILEGED
),
3537 SD_BUS_METHOD_WITH_NAMES("SetUserLinger",
3540 SD_BUS_PARAM(enable
)
3541 SD_BUS_PARAM(interactive
),
3543 method_set_user_linger
,
3544 SD_BUS_VTABLE_UNPRIVILEGED
),
3545 SD_BUS_METHOD_WITH_NAMES("AttachDevice",
3547 SD_BUS_PARAM(seat_id
)
3548 SD_BUS_PARAM(sysfs_path
)
3549 SD_BUS_PARAM(interactive
),
3551 method_attach_device
,
3552 SD_BUS_VTABLE_UNPRIVILEGED
),
3553 SD_BUS_METHOD_WITH_NAMES("FlushDevices",
3555 SD_BUS_PARAM(interactive
),
3557 method_flush_devices
,
3558 SD_BUS_VTABLE_UNPRIVILEGED
),
3559 SD_BUS_METHOD_WITH_NAMES("PowerOff",
3561 SD_BUS_PARAM(interactive
),
3564 SD_BUS_VTABLE_UNPRIVILEGED
),
3565 SD_BUS_METHOD_WITH_NAMES("PowerOffWithFlags",
3567 SD_BUS_PARAM(flags
),
3570 SD_BUS_VTABLE_UNPRIVILEGED
),
3571 SD_BUS_METHOD_WITH_NAMES("Reboot",
3573 SD_BUS_PARAM(interactive
),
3576 SD_BUS_VTABLE_UNPRIVILEGED
),
3577 SD_BUS_METHOD_WITH_NAMES("RebootWithFlags",
3579 SD_BUS_PARAM(flags
),
3582 SD_BUS_VTABLE_UNPRIVILEGED
),
3583 SD_BUS_METHOD_WITH_NAMES("Halt",
3585 SD_BUS_PARAM(interactive
),
3588 SD_BUS_VTABLE_UNPRIVILEGED
),
3589 SD_BUS_METHOD_WITH_NAMES("HaltWithFlags",
3591 SD_BUS_PARAM(flags
),
3594 SD_BUS_VTABLE_UNPRIVILEGED
),
3595 SD_BUS_METHOD_WITH_NAMES("Suspend",
3597 SD_BUS_PARAM(interactive
),
3600 SD_BUS_VTABLE_UNPRIVILEGED
),
3601 SD_BUS_METHOD_WITH_NAMES("SuspendWithFlags",
3603 SD_BUS_PARAM(flags
),
3606 SD_BUS_VTABLE_UNPRIVILEGED
),
3607 SD_BUS_METHOD_WITH_NAMES("Hibernate",
3609 SD_BUS_PARAM(interactive
),
3612 SD_BUS_VTABLE_UNPRIVILEGED
),
3613 SD_BUS_METHOD_WITH_NAMES("HibernateWithFlags",
3615 SD_BUS_PARAM(flags
),
3618 SD_BUS_VTABLE_UNPRIVILEGED
),
3619 SD_BUS_METHOD_WITH_NAMES("HybridSleep",
3621 SD_BUS_PARAM(interactive
),
3623 method_hybrid_sleep
,
3624 SD_BUS_VTABLE_UNPRIVILEGED
),
3625 SD_BUS_METHOD_WITH_NAMES("HybridSleepWithFlags",
3627 SD_BUS_PARAM(flags
),
3629 method_hybrid_sleep
,
3630 SD_BUS_VTABLE_UNPRIVILEGED
),
3631 SD_BUS_METHOD_WITH_NAMES("SuspendThenHibernate",
3633 SD_BUS_PARAM(interactive
),
3635 method_suspend_then_hibernate
,
3636 SD_BUS_VTABLE_UNPRIVILEGED
),
3637 SD_BUS_METHOD_WITH_NAMES("SuspendThenHibernateWithFlags",
3639 SD_BUS_PARAM(flags
),
3641 method_suspend_then_hibernate
,
3642 SD_BUS_VTABLE_UNPRIVILEGED
),
3643 SD_BUS_METHOD_WITH_NAMES("CanPowerOff",
3646 SD_BUS_PARAM(result
),
3647 method_can_poweroff
,
3648 SD_BUS_VTABLE_UNPRIVILEGED
),
3649 SD_BUS_METHOD_WITH_NAMES("CanReboot",
3652 SD_BUS_PARAM(result
),
3654 SD_BUS_VTABLE_UNPRIVILEGED
),
3655 SD_BUS_METHOD_WITH_NAMES("CanHalt",
3658 SD_BUS_PARAM(result
),
3660 SD_BUS_VTABLE_UNPRIVILEGED
),
3661 SD_BUS_METHOD_WITH_NAMES("CanSuspend",
3664 SD_BUS_PARAM(result
),
3666 SD_BUS_VTABLE_UNPRIVILEGED
),
3667 SD_BUS_METHOD_WITH_NAMES("CanHibernate",
3670 SD_BUS_PARAM(result
),
3671 method_can_hibernate
,
3672 SD_BUS_VTABLE_UNPRIVILEGED
),
3673 SD_BUS_METHOD_WITH_NAMES("CanHybridSleep",
3676 SD_BUS_PARAM(result
),
3677 method_can_hybrid_sleep
,
3678 SD_BUS_VTABLE_UNPRIVILEGED
),
3679 SD_BUS_METHOD_WITH_NAMES("CanSuspendThenHibernate",
3682 SD_BUS_PARAM(result
),
3683 method_can_suspend_then_hibernate
,
3684 SD_BUS_VTABLE_UNPRIVILEGED
),
3685 SD_BUS_METHOD_WITH_NAMES("ScheduleShutdown",
3690 method_schedule_shutdown
,
3691 SD_BUS_VTABLE_UNPRIVILEGED
),
3692 SD_BUS_METHOD_WITH_NAMES("CancelScheduledShutdown",
3695 SD_BUS_PARAM(cancelled
),
3696 method_cancel_scheduled_shutdown
,
3697 SD_BUS_VTABLE_UNPRIVILEGED
),
3698 SD_BUS_METHOD_WITH_NAMES("Inhibit",
3705 SD_BUS_PARAM(pipe_fd
),
3707 SD_BUS_VTABLE_UNPRIVILEGED
),
3708 SD_BUS_METHOD_WITH_NAMES("CanRebootParameter",
3711 SD_BUS_PARAM(result
),
3712 method_can_reboot_parameter
,
3713 SD_BUS_VTABLE_UNPRIVILEGED
),
3714 SD_BUS_METHOD_WITH_NAMES("SetRebootParameter",
3716 SD_BUS_PARAM(parameter
),
3718 method_set_reboot_parameter
,
3719 SD_BUS_VTABLE_UNPRIVILEGED
),
3720 SD_BUS_METHOD_WITH_NAMES("CanRebootToFirmwareSetup",
3723 SD_BUS_PARAM(result
),
3724 method_can_reboot_to_firmware_setup
,
3725 SD_BUS_VTABLE_UNPRIVILEGED
),
3726 SD_BUS_METHOD_WITH_NAMES("SetRebootToFirmwareSetup",
3728 SD_BUS_PARAM(enable
),
3730 method_set_reboot_to_firmware_setup
,
3731 SD_BUS_VTABLE_UNPRIVILEGED
),
3732 SD_BUS_METHOD_WITH_NAMES("CanRebootToBootLoaderMenu",
3735 SD_BUS_PARAM(result
),
3736 method_can_reboot_to_boot_loader_menu
,
3737 SD_BUS_VTABLE_UNPRIVILEGED
),
3738 SD_BUS_METHOD_WITH_NAMES("SetRebootToBootLoaderMenu",
3740 SD_BUS_PARAM(timeout
),
3742 method_set_reboot_to_boot_loader_menu
,
3743 SD_BUS_VTABLE_UNPRIVILEGED
),
3744 SD_BUS_METHOD_WITH_NAMES("CanRebootToBootLoaderEntry",
3747 SD_BUS_PARAM(result
),
3748 method_can_reboot_to_boot_loader_entry
,
3749 SD_BUS_VTABLE_UNPRIVILEGED
),
3750 SD_BUS_METHOD_WITH_NAMES("SetRebootToBootLoaderEntry",
3752 SD_BUS_PARAM(boot_loader_entry
),
3754 method_set_reboot_to_boot_loader_entry
,
3755 SD_BUS_VTABLE_UNPRIVILEGED
),
3756 SD_BUS_METHOD_WITH_NAMES("SetWallMessage",
3758 SD_BUS_PARAM(wall_message
)
3759 SD_BUS_PARAM(enable
),
3761 method_set_wall_message
,
3762 SD_BUS_VTABLE_UNPRIVILEGED
),
3764 SD_BUS_SIGNAL_WITH_NAMES("SessionNew",
3766 SD_BUS_PARAM(session_id
)
3767 SD_BUS_PARAM(object_path
),
3769 SD_BUS_SIGNAL_WITH_NAMES("SessionRemoved",
3771 SD_BUS_PARAM(session_id
)
3772 SD_BUS_PARAM(object_path
),
3774 SD_BUS_SIGNAL_WITH_NAMES("UserNew",
3777 SD_BUS_PARAM(object_path
),
3779 SD_BUS_SIGNAL_WITH_NAMES("UserRemoved",
3782 SD_BUS_PARAM(object_path
),
3784 SD_BUS_SIGNAL_WITH_NAMES("SeatNew",
3786 SD_BUS_PARAM(seat_id
)
3787 SD_BUS_PARAM(object_path
),
3789 SD_BUS_SIGNAL_WITH_NAMES("SeatRemoved",
3791 SD_BUS_PARAM(seat_id
)
3792 SD_BUS_PARAM(object_path
),
3794 SD_BUS_SIGNAL_WITH_NAMES("PrepareForShutdown",
3796 SD_BUS_PARAM(start
),
3798 SD_BUS_SIGNAL_WITH_NAMES("PrepareForSleep",
3800 SD_BUS_PARAM(start
),
3806 const BusObjectImplementation manager_object
= {
3807 "/org/freedesktop/login1",
3808 "org.freedesktop.login1.Manager",
3809 .vtables
= BUS_VTABLES(manager_vtable
),
3810 .children
= BUS_IMPLEMENTATIONS(&seat_object
,
3815 static int session_jobs_reply(Session
*s
, uint32_t jid
, const char *unit
, const char *result
) {
3822 if (result
&& !streq(result
, "done")) {
3823 _cleanup_(sd_bus_error_free
) sd_bus_error e
= SD_BUS_ERROR_NULL
;
3825 sd_bus_error_setf(&e
, BUS_ERROR_JOB_FAILED
,
3826 "Job %u for unit '%s' failed with '%s'", jid
, unit
, result
);
3827 return session_send_create_reply(s
, &e
);
3830 return session_send_create_reply(s
, NULL
);
3833 int match_job_removed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
3834 const char *path
, *result
, *unit
;
3835 Manager
*m
= userdata
;
3844 r
= sd_bus_message_read(message
, "uoss", &id
, &path
, &unit
, &result
);
3846 bus_log_parse_error(r
);
3850 if (m
->action_job
&& streq(m
->action_job
, path
)) {
3851 log_info("Operation '%s' finished.", inhibit_what_to_string(m
->action_what
));
3853 /* Tell people that they now may take a lock again */
3854 (void) send_prepare_for(m
, m
->action_what
, false);
3856 m
->action_job
= mfree(m
->action_job
);
3857 m
->action_unit
= NULL
;
3862 session
= hashmap_get(m
->session_units
, unit
);
3864 if (streq_ptr(path
, session
->scope_job
)) {
3865 session
->scope_job
= mfree(session
->scope_job
);
3866 (void) session_jobs_reply(session
, id
, unit
, result
);
3868 session_save(session
);
3869 user_save(session
->user
);
3872 session_add_to_gc_queue(session
);
3875 user
= hashmap_get(m
->user_units
, unit
);
3877 if (streq_ptr(path
, user
->service_job
)) {
3878 user
->service_job
= mfree(user
->service_job
);
3880 LIST_FOREACH(sessions_by_user
, session
, user
->sessions
)
3881 (void) session_jobs_reply(session
, id
, unit
, NULL
/* don't propagate user service failures to the client */);
3886 user_add_to_gc_queue(user
);
3892 int match_unit_removed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
3893 const char *path
, *unit
;
3894 Manager
*m
= userdata
;
3902 r
= sd_bus_message_read(message
, "so", &unit
, &path
);
3904 bus_log_parse_error(r
);
3908 session
= hashmap_get(m
->session_units
, unit
);
3910 session_add_to_gc_queue(session
);
3912 user
= hashmap_get(m
->user_units
, unit
);
3914 user_add_to_gc_queue(user
);
3919 int match_properties_changed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
3920 _cleanup_free_
char *unit
= NULL
;
3921 Manager
*m
= userdata
;
3930 path
= sd_bus_message_get_path(message
);
3934 r
= unit_name_from_dbus_path(path
, &unit
);
3935 if (r
== -EINVAL
) /* not a unit */
3942 session
= hashmap_get(m
->session_units
, unit
);
3944 session_add_to_gc_queue(session
);
3946 user
= hashmap_get(m
->user_units
, unit
);
3948 user_add_to_gc_queue(user
);
3953 int match_reloading(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
3954 Manager
*m
= userdata
;
3961 r
= sd_bus_message_read(message
, "b", &b
);
3963 bus_log_parse_error(r
);
3970 /* systemd finished reloading, let's recheck all our sessions */
3971 log_debug("System manager has been reloaded, rechecking sessions...");
3973 HASHMAP_FOREACH(session
, m
->sessions
)
3974 session_add_to_gc_queue(session
);
3979 int manager_send_changed(Manager
*manager
, const char *property
, ...) {
3984 l
= strv_from_stdarg_alloca(property
);
3986 return sd_bus_emit_properties_changed_strv(
3988 "/org/freedesktop/login1",
3989 "org.freedesktop.login1.Manager",
3993 static int strdup_job(sd_bus_message
*reply
, char **job
) {
3998 r
= sd_bus_message_read(reply
, "o", &j
);
4010 int manager_start_scope(
4015 const char *description
,
4018 const char *requires_mounts_for
,
4019 sd_bus_message
*more_properties
,
4020 sd_bus_error
*error
,
4023 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
, *reply
= NULL
;
4032 r
= bus_message_new_method_call(manager
->bus
, &m
, bus_systemd_mgr
, "StartTransientUnit");
4036 r
= sd_bus_message_append(m
, "ss", strempty(scope
), "fail");
4040 r
= sd_bus_message_open_container(m
, 'a', "(sv)");
4044 if (!isempty(slice
)) {
4045 r
= sd_bus_message_append(m
, "(sv)", "Slice", "s", slice
);
4050 if (!isempty(description
)) {
4051 r
= sd_bus_message_append(m
, "(sv)", "Description", "s", description
);
4056 STRV_FOREACH(i
, wants
) {
4057 r
= sd_bus_message_append(m
, "(sv)", "Wants", "as", 1, *i
);
4062 STRV_FOREACH(i
, after
) {
4063 r
= sd_bus_message_append(m
, "(sv)", "After", "as", 1, *i
);
4068 if (!empty_or_root(requires_mounts_for
)) {
4069 r
= sd_bus_message_append(m
, "(sv)", "RequiresMountsFor", "as", 1, requires_mounts_for
);
4074 /* Make sure that the session shells are terminated with SIGHUP since bash and friends tend to ignore
4076 r
= sd_bus_message_append(m
, "(sv)", "SendSIGHUP", "b", true);
4080 r
= sd_bus_message_append(m
, "(sv)", "PIDs", "au", 1, pid
);
4084 /* disable TasksMax= for the session scope, rely on the slice setting for it */
4085 r
= sd_bus_message_append(m
, "(sv)", "TasksMax", "t", UINT64_MAX
);
4087 return bus_log_create_error(r
);
4089 if (more_properties
) {
4090 /* If TasksMax also appears here, it will overwrite the default value set above */
4091 r
= sd_bus_message_copy(m
, more_properties
, true);
4096 r
= sd_bus_message_close_container(m
);
4100 r
= sd_bus_message_append(m
, "a(sa(sv))", 0);
4104 r
= sd_bus_call(manager
->bus
, m
, 0, error
, &reply
);
4108 return strdup_job(reply
, job
);
4111 int manager_start_unit(Manager
*manager
, const char *unit
, sd_bus_error
*error
, char **job
) {
4112 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
4119 r
= bus_call_method(
4125 "ss", unit
, "replace");
4129 return strdup_job(reply
, job
);
4132 int manager_stop_unit(Manager
*manager
, const char *unit
, const char *job_mode
, sd_bus_error
*error
, char **ret_job
) {
4133 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
4140 r
= bus_call_method(
4146 "ss", unit
, job_mode
?: "fail");
4148 if (sd_bus_error_has_names(error
, BUS_ERROR_NO_SUCH_UNIT
,
4149 BUS_ERROR_LOAD_FAILED
)) {
4152 sd_bus_error_free(error
);
4159 return strdup_job(reply
, ret_job
);
4162 int manager_abandon_scope(Manager
*manager
, const char *scope
, sd_bus_error
*ret_error
) {
4163 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
4164 _cleanup_free_
char *path
= NULL
;
4170 path
= unit_dbus_path_from_name(scope
);
4174 r
= sd_bus_call_method(
4176 "org.freedesktop.systemd1",
4178 "org.freedesktop.systemd1.Scope",
4184 if (sd_bus_error_has_names(&error
, BUS_ERROR_NO_SUCH_UNIT
,
4185 BUS_ERROR_LOAD_FAILED
,
4186 BUS_ERROR_SCOPE_NOT_RUNNING
))
4189 sd_bus_error_move(ret_error
, &error
);
4196 int manager_kill_unit(Manager
*manager
, const char *unit
, KillWho who
, int signo
, sd_bus_error
*error
) {
4200 return bus_call_method(
4206 "ssi", unit
, who
== KILL_LEADER
? "main" : "all", signo
);
4209 int manager_unit_is_active(Manager
*manager
, const char *unit
, sd_bus_error
*ret_error
) {
4210 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
4211 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
4212 _cleanup_free_
char *path
= NULL
;
4219 path
= unit_dbus_path_from_name(unit
);
4223 r
= sd_bus_get_property(
4225 "org.freedesktop.systemd1",
4227 "org.freedesktop.systemd1.Unit",
4233 /* systemd might have dropped off momentarily, let's
4234 * not make this an error */
4235 if (sd_bus_error_has_names(&error
, SD_BUS_ERROR_NO_REPLY
,
4236 SD_BUS_ERROR_DISCONNECTED
))
4239 /* If the unit is already unloaded then it's not
4241 if (sd_bus_error_has_names(&error
, BUS_ERROR_NO_SUCH_UNIT
,
4242 BUS_ERROR_LOAD_FAILED
))
4245 sd_bus_error_move(ret_error
, &error
);
4249 r
= sd_bus_message_read(reply
, "s", &state
);
4253 return !STR_IN_SET(state
, "inactive", "failed");
4256 int manager_job_is_active(Manager
*manager
, const char *path
, sd_bus_error
*ret_error
) {
4257 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
4258 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
4264 r
= sd_bus_get_property(
4266 "org.freedesktop.systemd1",
4268 "org.freedesktop.systemd1.Job",
4274 if (sd_bus_error_has_names(&error
, SD_BUS_ERROR_NO_REPLY
,
4275 SD_BUS_ERROR_DISCONNECTED
))
4278 if (sd_bus_error_has_name(&error
, SD_BUS_ERROR_UNKNOWN_OBJECT
))
4281 sd_bus_error_move(ret_error
, &error
);
4285 /* We don't actually care about the state really. The fact
4286 * that we could read the job state is enough for us */