1 /* SPDX-License-Identifier: LGPL-2.1+ */
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-polkit.h"
16 #include "bus-unit-util.h"
18 #include "cgroup-util.h"
19 #include "device-util.h"
20 #include "dirent-util.h"
21 #include "efi-loader.h"
26 #include "fileio-label.h"
28 #include "format-util.h"
30 #include "logind-dbus.h"
31 #include "logind-seat-dbus.h"
32 #include "logind-session-dbus.h"
33 #include "logind-user-dbus.h"
35 #include "missing_capability.h"
37 #include "parse-util.h"
38 #include "path-util.h"
39 #include "process-util.h"
40 #include "reboot-util.h"
41 #include "selinux-util.h"
42 #include "sleep-config.h"
44 #include "stdio-util.h"
46 #include "terminal-util.h"
47 #include "tmpfile-util.h"
48 #include "unit-name.h"
49 #include "user-util.h"
50 #include "utmp-wtmp.h"
53 static int get_sender_session(
55 sd_bus_message
*message
,
60 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
61 Session
*session
= NULL
;
65 /* Acquire the sender's session. This first checks if the sending process is inside a session itself,
66 * and returns that. If not and 'consult_display' is true, this returns the display session of the
67 * owning user of the caller. */
69 r
= sd_bus_query_sender_creds(message
,
70 SD_BUS_CREDS_SESSION
|SD_BUS_CREDS_AUGMENT
|
71 (consult_display
? SD_BUS_CREDS_OWNER_UID
: 0), &creds
);
75 r
= sd_bus_creds_get_session(creds
, &name
);
80 if (consult_display
) {
83 r
= sd_bus_creds_get_owner_uid(creds
, &uid
);
90 user
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
92 session
= user
->display
;
96 session
= hashmap_get(m
->sessions
, name
);
99 return sd_bus_error_setf(error
, BUS_ERROR_NO_SESSION_FOR_PID
,
101 "Caller does not belong to any known session and doesn't own any suitable session." :
102 "Caller does not belong to any known session.");
108 int manager_get_session_from_creds(
110 sd_bus_message
*message
,
120 if (SEAT_IS_SELF(name
)) /* the caller's own session */
121 return get_sender_session(m
, message
, false, error
, ret
);
122 if (SEAT_IS_AUTO(name
)) /* The caller's own session if they have one, otherwise their user's display session */
123 return get_sender_session(m
, message
, true, error
, ret
);
125 session
= hashmap_get(m
->sessions
, name
);
127 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SESSION
, "No session '%s' known", name
);
133 static int get_sender_user(Manager
*m
, sd_bus_message
*message
, sd_bus_error
*error
, User
**ret
) {
134 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
139 /* Note that we get the owner UID of the session, not the actual client UID here! */
140 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_OWNER_UID
|SD_BUS_CREDS_AUGMENT
, &creds
);
144 r
= sd_bus_creds_get_owner_uid(creds
, &uid
);
151 user
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
154 return sd_bus_error_setf(error
, BUS_ERROR_NO_USER_FOR_PID
,
155 "Caller does not belong to any logged in or lingering user");
161 int manager_get_user_from_creds(Manager
*m
, sd_bus_message
*message
, uid_t uid
, sd_bus_error
*error
, User
**ret
) {
167 if (!uid_is_valid(uid
))
168 return get_sender_user(m
, message
, error
, ret
);
170 user
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
172 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_USER
,
173 "User ID "UID_FMT
" is not logged in or lingering", uid
);
179 int manager_get_seat_from_creds(
181 sd_bus_message
*message
,
192 if (SEAT_IS_SELF(name
) || SEAT_IS_AUTO(name
)) {
195 /* Use these special seat names as session names */
196 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
200 seat
= session
->seat
;
202 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
, "Session '%s' has no seat.", session
->id
);
204 seat
= hashmap_get(m
->seats
, name
);
206 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
, "No seat '%s' known", name
);
213 static int return_test_polkit(
214 sd_bus_message
*message
,
217 const char **details
,
225 r
= bus_test_polkit(message
, capability
, action
, details
, good_user
, &challenge
, e
);
232 result
= "challenge";
236 return sd_bus_reply_method_return(message
, "s", result
);
239 static int property_get_idle_hint(
242 const char *interface
,
243 const char *property
,
244 sd_bus_message
*reply
,
246 sd_bus_error
*error
) {
248 Manager
*m
= userdata
;
254 return sd_bus_message_append(reply
, "b", manager_get_idle_hint(m
, NULL
) > 0);
257 static int property_get_idle_since_hint(
260 const char *interface
,
261 const char *property
,
262 sd_bus_message
*reply
,
264 sd_bus_error
*error
) {
266 Manager
*m
= userdata
;
267 dual_timestamp t
= DUAL_TIMESTAMP_NULL
;
273 manager_get_idle_hint(m
, &t
);
275 return sd_bus_message_append(reply
, "t", streq(property
, "IdleSinceHint") ? t
.realtime
: t
.monotonic
);
278 static int property_get_inhibited(
281 const char *interface
,
282 const char *property
,
283 sd_bus_message
*reply
,
285 sd_bus_error
*error
) {
287 Manager
*m
= userdata
;
294 w
= manager_inhibit_what(m
, streq(property
, "BlockInhibited") ? INHIBIT_BLOCK
: INHIBIT_DELAY
);
296 return sd_bus_message_append(reply
, "s", inhibit_what_to_string(w
));
299 static int property_get_preparing(
302 const char *interface
,
303 const char *property
,
304 sd_bus_message
*reply
,
306 sd_bus_error
*error
) {
308 Manager
*m
= userdata
;
315 if (streq(property
, "PreparingForShutdown"))
316 b
= m
->action_what
& INHIBIT_SHUTDOWN
;
318 b
= m
->action_what
& INHIBIT_SLEEP
;
320 return sd_bus_message_append(reply
, "b", b
);
323 static int property_get_scheduled_shutdown(
326 const char *interface
,
327 const char *property
,
328 sd_bus_message
*reply
,
330 sd_bus_error
*error
) {
332 Manager
*m
= userdata
;
339 r
= sd_bus_message_open_container(reply
, 'r', "st");
343 r
= sd_bus_message_append(reply
, "st", m
->scheduled_shutdown_type
, m
->scheduled_shutdown_timeout
);
347 return sd_bus_message_close_container(reply
);
350 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_handle_action
, handle_action
, HandleAction
);
351 static BUS_DEFINE_PROPERTY_GET(property_get_docked
, "b", Manager
, manager_is_docked_or_external_displays
);
352 static BUS_DEFINE_PROPERTY_GET(property_get_lid_closed
, "b", Manager
, manager_is_lid_closed
);
353 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_on_external_power
, "b", manager_is_on_external_power
);
354 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_compat_user_tasks_max
, "t", CGROUP_LIMIT_MAX
);
355 static BUS_DEFINE_PROPERTY_GET_REF(property_get_hashmap_size
, "t", Hashmap
*, (uint64_t) hashmap_size
);
357 static int method_get_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
358 _cleanup_free_
char *p
= NULL
;
359 Manager
*m
= userdata
;
367 r
= sd_bus_message_read(message
, "s", &name
);
371 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
375 p
= session_bus_path(session
);
379 return sd_bus_reply_method_return(message
, "o", p
);
382 /* Get login session of a process. This is not what you are looking for these days,
383 * as apps may instead belong to a user service unit. This includes terminal
384 * emulators and hence command-line apps. */
385 static int method_get_session_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
386 _cleanup_free_
char *p
= NULL
;
387 Session
*session
= NULL
;
388 Manager
*m
= userdata
;
395 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
397 r
= sd_bus_message_read(message
, "u", &pid
);
404 r
= manager_get_session_from_creds(m
, message
, NULL
, error
, &session
);
408 r
= manager_get_session_by_pid(m
, pid
, &session
);
413 return sd_bus_error_setf(error
, BUS_ERROR_NO_SESSION_FOR_PID
,
414 "PID "PID_FMT
" does not belong to any known session", pid
);
417 p
= session_bus_path(session
);
421 return sd_bus_reply_method_return(message
, "o", p
);
424 static int method_get_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
425 _cleanup_free_
char *p
= NULL
;
426 Manager
*m
= userdata
;
434 r
= sd_bus_message_read(message
, "u", &uid
);
438 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
442 p
= user_bus_path(user
);
446 return sd_bus_reply_method_return(message
, "o", p
);
449 static int method_get_user_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
450 _cleanup_free_
char *p
= NULL
;
451 Manager
*m
= userdata
;
459 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
461 r
= sd_bus_message_read(message
, "u", &pid
);
468 r
= manager_get_user_from_creds(m
, message
, UID_INVALID
, error
, &user
);
472 r
= manager_get_user_by_pid(m
, pid
, &user
);
476 return sd_bus_error_setf(error
, BUS_ERROR_NO_USER_FOR_PID
,
477 "PID "PID_FMT
" does not belong to any logged in user or lingering user",
481 p
= user_bus_path(user
);
485 return sd_bus_reply_method_return(message
, "o", p
);
488 static int method_get_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
489 _cleanup_free_
char *p
= NULL
;
490 Manager
*m
= userdata
;
498 r
= sd_bus_message_read(message
, "s", &name
);
502 r
= manager_get_seat_from_creds(m
, message
, name
, error
, &seat
);
506 p
= seat_bus_path(seat
);
510 return sd_bus_reply_method_return(message
, "o", p
);
513 static int method_list_sessions(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
514 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
515 Manager
*m
= userdata
;
523 r
= sd_bus_message_new_method_return(message
, &reply
);
527 r
= sd_bus_message_open_container(reply
, 'a', "(susso)");
531 HASHMAP_FOREACH(session
, m
->sessions
, i
) {
532 _cleanup_free_
char *p
= NULL
;
534 p
= session_bus_path(session
);
538 r
= sd_bus_message_append(reply
, "(susso)",
540 (uint32_t) session
->user
->user_record
->uid
,
541 session
->user
->user_record
->user_name
,
542 session
->seat
? session
->seat
->id
: "",
548 r
= sd_bus_message_close_container(reply
);
552 return sd_bus_send(NULL
, reply
, NULL
);
555 static int method_list_users(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
556 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
557 Manager
*m
= userdata
;
565 r
= sd_bus_message_new_method_return(message
, &reply
);
569 r
= sd_bus_message_open_container(reply
, 'a', "(uso)");
573 HASHMAP_FOREACH(user
, m
->users
, i
) {
574 _cleanup_free_
char *p
= NULL
;
576 p
= user_bus_path(user
);
580 r
= sd_bus_message_append(reply
, "(uso)",
581 (uint32_t) user
->user_record
->uid
,
582 user
->user_record
->user_name
,
588 r
= sd_bus_message_close_container(reply
);
592 return sd_bus_send(NULL
, reply
, NULL
);
595 static int method_list_seats(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
596 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
597 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
, i
) {
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
;
642 r
= sd_bus_message_new_method_return(message
, &reply
);
646 r
= sd_bus_message_open_container(reply
, 'a', "(ssssuu)");
650 HASHMAP_FOREACH(inhibitor
, m
->inhibitors
, i
) {
652 r
= sd_bus_message_append(reply
, "(ssssuu)",
653 strempty(inhibit_what_to_string(inhibitor
->what
)),
654 strempty(inhibitor
->who
),
655 strempty(inhibitor
->why
),
656 strempty(inhibit_mode_to_string(inhibitor
->mode
)),
657 (uint32_t) inhibitor
->uid
,
658 (uint32_t) inhibitor
->pid
);
663 r
= sd_bus_message_close_container(reply
);
667 return sd_bus_send(NULL
, reply
, NULL
);
670 static int method_create_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
671 const char *service
, *type
, *class, *cseat
, *tty
, *display
, *remote_user
, *remote_host
, *desktop
;
672 _cleanup_free_
char *id
= NULL
;
673 Session
*session
= NULL
;
674 uint32_t audit_id
= 0;
675 Manager
*m
= userdata
;
689 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
690 assert_cc(sizeof(uid_t
) == sizeof(uint32_t));
692 r
= sd_bus_message_read(message
, "uusssssussbss",
693 &uid
, &leader
, &service
, &type
, &class, &desktop
, &cseat
,
694 &vtnr
, &tty
, &display
, &remote
, &remote_user
, &remote_host
);
698 if (!uid_is_valid(uid
))
699 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid UID");
700 if (leader
< 0 || leader
== 1 || leader
== getpid_cached())
701 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid leader PID");
704 t
= _SESSION_TYPE_INVALID
;
706 t
= session_type_from_string(type
);
708 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
709 "Invalid session type %s", type
);
713 c
= _SESSION_CLASS_INVALID
;
715 c
= session_class_from_string(class);
717 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
718 "Invalid session class %s", class);
721 if (isempty(desktop
))
724 if (!string_is_safe(desktop
))
725 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
726 "Invalid desktop string %s", desktop
);
732 seat
= hashmap_get(m
->seats
, cseat
);
734 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
,
735 "No seat '%s' known", cseat
);
738 if (tty_is_vc(tty
)) {
743 else if (seat
!= m
->seat0
)
744 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
745 "TTY %s is virtual console but seat %s is not seat0", tty
, seat
->id
);
747 v
= vtnr_from_tty(tty
);
749 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
750 "Cannot determine VT number from virtual console TTY %s", tty
);
754 else if (vtnr
!= (uint32_t) v
)
755 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
756 "Specified TTY and VT number do not match");
758 } else if (tty_is_console(tty
)) {
762 else if (seat
!= m
->seat0
)
763 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
764 "Console TTY specified but seat is not seat0");
767 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
768 "Console TTY specified but VT number is not 0");
772 if (seat_has_vts(seat
)) {
773 if (vtnr
<= 0 || vtnr
> 63)
774 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
775 "VT number out of range");
778 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
779 "Seat has no VTs but VT number not 0");
783 if (t
== _SESSION_TYPE_INVALID
) {
784 if (!isempty(display
))
786 else if (!isempty(tty
))
789 t
= SESSION_UNSPECIFIED
;
792 if (c
== _SESSION_CLASS_INVALID
) {
793 if (t
== SESSION_UNSPECIFIED
)
794 c
= SESSION_BACKGROUND
;
800 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
802 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
806 r
= sd_bus_creds_get_pid(creds
, (pid_t
*) &leader
);
811 /* Check if we are already in a logind session. Or if we are in user@.service
812 * which is a special PAM session that avoids creating a logind session. */
813 r
= manager_get_user_by_pid(m
, leader
, NULL
);
817 return sd_bus_error_setf(error
, BUS_ERROR_SESSION_BUSY
,
818 "Already running in a session or user slice");
821 * Old gdm and lightdm start the user-session on the same VT as
822 * the greeter session. But they destroy the greeter session
823 * after the user-session and want the user-session to take
824 * over the VT. We need to support this for
825 * backwards-compatibility, so make sure we allow new sessions
826 * on a VT that a greeter is running on. Furthermore, to allow
827 * re-logins, we have to allow a greeter to take over a used VT for
828 * the exact same reasons.
830 if (c
!= SESSION_GREETER
&&
832 vtnr
< m
->seat0
->position_count
&&
833 m
->seat0
->positions
[vtnr
] &&
834 m
->seat0
->positions
[vtnr
]->class != SESSION_GREETER
)
835 return sd_bus_error_setf(error
, BUS_ERROR_SESSION_BUSY
, "Already occupied by a session");
837 if (hashmap_size(m
->sessions
) >= m
->sessions_max
)
838 return sd_bus_error_setf(error
, SD_BUS_ERROR_LIMITS_EXCEEDED
,
839 "Maximum number of sessions (%" PRIu64
") reached, refusing further sessions.",
842 (void) audit_session_from_pid(leader
, &audit_id
);
843 if (audit_session_is_valid(audit_id
)) {
844 /* Keep our session IDs and the audit session IDs in sync */
846 if (asprintf(&id
, "%"PRIu32
, audit_id
) < 0)
849 /* Wut? There's already a session by this name and we didn't find it above? Weird, then let's
850 * not trust the audit data and let's better register a new ID */
851 if (hashmap_contains(m
->sessions
, id
)) {
852 log_warning("Existing logind session ID %s used by new audit session, ignoring.", id
);
853 audit_id
= AUDIT_SESSION_INVALID
;
862 if (asprintf(&id
, "c%lu", ++m
->session_counter
) < 0)
865 } while (hashmap_contains(m
->sessions
, id
));
868 /* The generated names should not clash with 'auto' or 'self' */
869 assert(!SESSION_IS_SELF(id
));
870 assert(!SESSION_IS_AUTO(id
));
872 /* If we are not watching utmp already, try again */
873 manager_reconnect_utmp(m
);
875 r
= manager_add_user_by_uid(m
, uid
, &user
);
879 r
= manager_add_session(m
, id
, &session
);
883 session_set_user(session
, user
);
884 r
= session_set_leader(session
, leader
);
888 session
->original_type
= session
->type
= t
;
890 session
->remote
= remote
;
891 session
->vtnr
= vtnr
;
894 session
->tty
= strdup(tty
);
900 session
->tty_validity
= TTY_FROM_PAM
;
903 if (!isempty(display
)) {
904 session
->display
= strdup(display
);
905 if (!session
->display
) {
911 if (!isempty(remote_user
)) {
912 session
->remote_user
= strdup(remote_user
);
913 if (!session
->remote_user
) {
919 if (!isempty(remote_host
)) {
920 session
->remote_host
= strdup(remote_host
);
921 if (!session
->remote_host
) {
927 if (!isempty(service
)) {
928 session
->service
= strdup(service
);
929 if (!session
->service
) {
935 if (!isempty(desktop
)) {
936 session
->desktop
= strdup(desktop
);
937 if (!session
->desktop
) {
944 r
= seat_attach_session(seat
, session
);
949 r
= sd_bus_message_enter_container(message
, 'a', "(sv)");
953 r
= session_start(session
, message
, error
);
957 r
= sd_bus_message_exit_container(message
);
961 session
->create_message
= sd_bus_message_ref(message
);
963 /* Now, let's wait until the slice unit and stuff got created. We send the reply back from
964 * session_send_create_reply(). */
970 session_add_to_gc_queue(session
);
973 user_add_to_gc_queue(user
);
978 static int method_release_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
979 Manager
*m
= userdata
;
987 r
= sd_bus_message_read(message
, "s", &name
);
991 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
995 r
= session_release(session
);
999 return sd_bus_reply_method_return(message
, NULL
);
1002 static int method_activate_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1003 Manager
*m
= userdata
;
1011 r
= sd_bus_message_read(message
, "s", &name
);
1015 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1019 /* PolicyKit is done by bus_session_method_activate() */
1021 return bus_session_method_activate(message
, session
, error
);
1024 static int method_activate_session_on_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1025 const char *session_name
, *seat_name
;
1026 Manager
*m
= userdata
;
1034 /* Same as ActivateSession() but refuses to work if the seat doesn't match */
1036 r
= sd_bus_message_read(message
, "ss", &session_name
, &seat_name
);
1040 r
= manager_get_session_from_creds(m
, message
, session_name
, error
, &session
);
1044 r
= manager_get_seat_from_creds(m
, message
, seat_name
, error
, &seat
);
1048 if (session
->seat
!= seat
)
1049 return sd_bus_error_setf(error
, BUS_ERROR_SESSION_NOT_ON_SEAT
,
1050 "Session %s not on seat %s", session_name
, seat_name
);
1052 r
= bus_verify_polkit_async(
1055 "org.freedesktop.login1.chvt",
1059 &m
->polkit_registry
,
1064 return 1; /* Will call us back */
1066 r
= session_activate(session
);
1070 return sd_bus_reply_method_return(message
, NULL
);
1073 static int method_lock_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1074 Manager
*m
= userdata
;
1082 r
= sd_bus_message_read(message
, "s", &name
);
1086 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1090 return bus_session_method_lock(message
, session
, error
);
1093 static int method_lock_sessions(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1094 Manager
*m
= userdata
;
1100 r
= bus_verify_polkit_async(
1103 "org.freedesktop.login1.lock-sessions",
1107 &m
->polkit_registry
,
1112 return 1; /* Will call us back */
1114 r
= session_send_lock_all(m
, streq(sd_bus_message_get_member(message
), "LockSessions"));
1118 return sd_bus_reply_method_return(message
, NULL
);
1121 static int method_kill_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1123 Manager
*m
= userdata
;
1130 r
= sd_bus_message_read(message
, "s", &name
);
1134 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1138 return bus_session_method_kill(message
, session
, error
);
1141 static int method_kill_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1142 Manager
*m
= userdata
;
1150 r
= sd_bus_message_read(message
, "u", &uid
);
1154 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
1158 return bus_user_method_kill(message
, user
, error
);
1161 static int method_terminate_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1162 Manager
*m
= userdata
;
1170 r
= sd_bus_message_read(message
, "s", &name
);
1174 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1178 return bus_session_method_terminate(message
, session
, error
);
1181 static int method_terminate_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1182 Manager
*m
= userdata
;
1190 r
= sd_bus_message_read(message
, "u", &uid
);
1194 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
1198 return bus_user_method_terminate(message
, user
, error
);
1201 static int method_terminate_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1202 Manager
*m
= userdata
;
1210 r
= sd_bus_message_read(message
, "s", &name
);
1214 r
= manager_get_seat_from_creds(m
, message
, name
, error
, &seat
);
1218 return bus_seat_method_terminate(message
, seat
, error
);
1221 static int method_set_user_linger(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1222 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
1223 _cleanup_free_
char *cc
= NULL
;
1224 Manager
*m
= userdata
;
1225 int r
, b
, interactive
;
1228 uint32_t uid
, auth_uid
;
1233 r
= sd_bus_message_read(message
, "ubb", &uid
, &b
, &interactive
);
1237 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
|
1238 SD_BUS_CREDS_OWNER_UID
|SD_BUS_CREDS_AUGMENT
, &creds
);
1242 if (!uid_is_valid(uid
)) {
1243 /* Note that we get the owner UID of the session or user unit,
1244 * not the actual client UID here! */
1245 r
= sd_bus_creds_get_owner_uid(creds
, &uid
);
1250 /* owner_uid is racy, so for authorization we must use euid */
1251 r
= sd_bus_creds_get_euid(creds
, &auth_uid
);
1258 return errno_or_else(ENOENT
);
1260 r
= bus_verify_polkit_async(
1263 uid
== auth_uid
? "org.freedesktop.login1.set-self-linger" :
1264 "org.freedesktop.login1.set-user-linger",
1268 &m
->polkit_registry
,
1273 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1275 (void) mkdir_p_label("/var/lib/systemd", 0755);
1276 r
= mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0, MKDIR_WARN_MODE
);
1280 cc
= cescape(pw
->pw_name
);
1284 path
= strjoina("/var/lib/systemd/linger/", cc
);
1292 if (manager_add_user_by_uid(m
, uid
, &u
) >= 0)
1299 if (r
< 0 && errno
!= ENOENT
)
1302 u
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
1304 user_add_to_gc_queue(u
);
1307 return sd_bus_reply_method_return(message
, NULL
);
1310 static int trigger_device(Manager
*m
, sd_device
*d
) {
1311 _cleanup_(sd_device_enumerator_unrefp
) sd_device_enumerator
*e
= NULL
;
1316 r
= sd_device_enumerator_new(&e
);
1320 r
= sd_device_enumerator_allow_uninitialized(e
);
1325 r
= sd_device_enumerator_add_match_parent(e
, d
);
1330 FOREACH_DEVICE(e
, d
) {
1331 _cleanup_free_
char *t
= NULL
;
1334 r
= sd_device_get_syspath(d
, &p
);
1338 t
= path_join(p
, "uevent");
1342 (void) write_string_file(t
, "change", WRITE_STRING_FILE_DISABLE_BUFFER
);
1348 static int attach_device(Manager
*m
, const char *seat
, const char *sysfs
) {
1349 _cleanup_(sd_device_unrefp
) sd_device
*d
= NULL
;
1350 _cleanup_free_
char *rule
= NULL
, *file
= NULL
;
1351 const char *id_for_seat
;
1358 r
= sd_device_new_from_syspath(&d
, sysfs
);
1362 if (sd_device_has_tag(d
, "seat") <= 0)
1365 if (sd_device_get_property_value(d
, "ID_FOR_SEAT", &id_for_seat
) < 0)
1368 if (asprintf(&file
, "/etc/udev/rules.d/72-seat-%s.rules", id_for_seat
) < 0)
1371 if (asprintf(&rule
, "TAG==\"seat\", ENV{ID_FOR_SEAT}==\"%s\", ENV{ID_SEAT}=\"%s\"", id_for_seat
, seat
) < 0)
1374 (void) mkdir_p_label("/etc/udev/rules.d", 0755);
1375 r
= write_string_file_atomic_label(file
, rule
);
1379 return trigger_device(m
, d
);
1382 static int flush_devices(Manager
*m
) {
1383 _cleanup_closedir_
DIR *d
;
1387 d
= opendir("/etc/udev/rules.d");
1389 if (errno
!= ENOENT
)
1390 log_warning_errno(errno
, "Failed to open /etc/udev/rules.d: %m");
1394 FOREACH_DIRENT_ALL(de
, d
, break) {
1395 dirent_ensure_type(d
, de
);
1396 if (!dirent_is_file(de
))
1399 if (!startswith(de
->d_name
, "72-seat-"))
1402 if (!endswith(de
->d_name
, ".rules"))
1405 if (unlinkat(dirfd(d
), de
->d_name
, 0) < 0)
1406 log_warning_errno(errno
, "Failed to unlink %s: %m", de
->d_name
);
1410 return trigger_device(m
, NULL
);
1413 static int method_attach_device(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1414 const char *sysfs
, *seat
;
1415 Manager
*m
= userdata
;
1421 r
= sd_bus_message_read(message
, "ssb", &seat
, &sysfs
, &interactive
);
1425 if (!path_is_normalized(sysfs
))
1426 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Path %s is not normalized", sysfs
);
1427 if (!path_startswith(sysfs
, "/sys"))
1428 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Path %s is not in /sys", sysfs
);
1430 if (SEAT_IS_SELF(seat
) || SEAT_IS_AUTO(seat
)) {
1433 r
= manager_get_seat_from_creds(m
, message
, seat
, error
, &found
);
1439 } else if (!seat_name_is_valid(seat
)) /* Note that a seat does not have to exist yet for this operation to succeed */
1440 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Seat name %s is not valid", seat
);
1442 r
= bus_verify_polkit_async(
1445 "org.freedesktop.login1.attach-device",
1449 &m
->polkit_registry
,
1454 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1456 r
= attach_device(m
, seat
, sysfs
);
1460 return sd_bus_reply_method_return(message
, NULL
);
1463 static int method_flush_devices(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1464 Manager
*m
= userdata
;
1470 r
= sd_bus_message_read(message
, "b", &interactive
);
1474 r
= bus_verify_polkit_async(
1477 "org.freedesktop.login1.flush-devices",
1481 &m
->polkit_registry
,
1486 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1488 r
= flush_devices(m
);
1492 return sd_bus_reply_method_return(message
, NULL
);
1495 static int have_multiple_sessions(
1504 /* Check for other users' sessions. Greeter sessions do not
1505 * count, and non-login sessions do not count either. */
1506 HASHMAP_FOREACH(session
, m
->sessions
, i
)
1507 if (session
->class == SESSION_USER
&&
1508 session
->user
->user_record
->uid
!= uid
)
1514 static int bus_manager_log_shutdown(
1516 const char *unit_name
) {
1523 if (streq(unit_name
, SPECIAL_POWEROFF_TARGET
)) {
1524 p
= "MESSAGE=System is powering down";
1525 q
= "SHUTDOWN=power-off";
1526 } else if (streq(unit_name
, SPECIAL_REBOOT_TARGET
)) {
1527 p
= "MESSAGE=System is rebooting";
1528 q
= "SHUTDOWN=reboot";
1529 } else if (streq(unit_name
, SPECIAL_HALT_TARGET
)) {
1530 p
= "MESSAGE=System is halting";
1531 q
= "SHUTDOWN=halt";
1532 } else if (streq(unit_name
, SPECIAL_KEXEC_TARGET
)) {
1533 p
= "MESSAGE=System is rebooting with kexec";
1534 q
= "SHUTDOWN=kexec";
1536 p
= "MESSAGE=System is shutting down";
1540 if (isempty(m
->wall_message
))
1541 p
= strjoina(p
, ".");
1543 p
= strjoina(p
, " (", m
->wall_message
, ").");
1545 return log_struct(LOG_NOTICE
,
1546 "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_STR
,
1551 static int lid_switch_ignore_handler(sd_event_source
*e
, uint64_t usec
, void *userdata
) {
1552 Manager
*m
= userdata
;
1557 m
->lid_switch_ignore_event_source
= sd_event_source_unref(m
->lid_switch_ignore_event_source
);
1561 int manager_set_lid_switch_ignore(Manager
*m
, usec_t until
) {
1566 if (until
<= now(CLOCK_MONOTONIC
))
1569 /* We want to ignore the lid switch for a while after each
1570 * suspend, and after boot-up. Hence let's install a timer for
1571 * this. As long as the event source exists we ignore the lid
1574 if (m
->lid_switch_ignore_event_source
) {
1577 r
= sd_event_source_get_time(m
->lid_switch_ignore_event_source
, &u
);
1584 r
= sd_event_source_set_time(m
->lid_switch_ignore_event_source
, until
);
1586 r
= sd_event_add_time(
1588 &m
->lid_switch_ignore_event_source
,
1591 lid_switch_ignore_handler
, m
);
1596 static int send_prepare_for(Manager
*m
, InhibitWhat w
, bool _active
) {
1597 int active
= _active
;
1600 assert(IN_SET(w
, INHIBIT_SHUTDOWN
, INHIBIT_SLEEP
));
1602 return sd_bus_emit_signal(m
->bus
,
1603 "/org/freedesktop/login1",
1604 "org.freedesktop.login1.Manager",
1605 w
== INHIBIT_SHUTDOWN
? "PrepareForShutdown" : "PrepareForSleep",
1610 static int execute_shutdown_or_sleep(
1613 const char *unit_name
,
1614 sd_bus_error
*error
) {
1616 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1622 assert(w
< _INHIBIT_WHAT_MAX
);
1625 if (w
== INHIBIT_SHUTDOWN
)
1626 bus_manager_log_shutdown(m
, unit_name
);
1628 r
= bus_call_method(
1634 "ss", unit_name
, "replace-irreversibly");
1638 r
= sd_bus_message_read(reply
, "o", &p
);
1642 r
= free_and_strdup(&m
->action_job
, p
);
1646 m
->action_unit
= unit_name
;
1649 /* Make sure the lid switch is ignored for a while */
1650 manager_set_lid_switch_ignore(m
, now(CLOCK_MONOTONIC
) + m
->holdoff_timeout_usec
);
1655 /* Tell people that they now may take a lock again */
1656 (void) send_prepare_for(m
, w
, false);
1661 int manager_dispatch_delayed(Manager
*manager
, bool timeout
) {
1663 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1664 Inhibitor
*offending
= NULL
;
1669 if (manager
->action_what
== 0 || manager
->action_job
)
1672 if (manager_is_inhibited(manager
, manager
->action_what
, INHIBIT_DELAY
, NULL
, false, false, 0, &offending
)) {
1673 _cleanup_free_
char *comm
= NULL
, *u
= NULL
;
1678 (void) get_process_comm(offending
->pid
, &comm
);
1679 u
= uid_to_name(offending
->uid
);
1681 log_notice("Delay lock is active (UID "UID_FMT
"/%s, PID "PID_FMT
"/%s) but inhibitor timeout is reached.",
1682 offending
->uid
, strna(u
),
1683 offending
->pid
, strna(comm
));
1686 /* Actually do the operation */
1687 r
= execute_shutdown_or_sleep(manager
, manager
->action_what
, manager
->action_unit
, &error
);
1689 log_warning("Error during inhibitor-delayed operation (already returned success to client): %s",
1690 bus_error_message(&error
, r
));
1692 manager
->action_unit
= NULL
;
1693 manager
->action_what
= 0;
1700 static int manager_inhibit_timeout_handler(
1705 Manager
*manager
= userdata
;
1709 assert(manager
->inhibit_timeout_source
== s
);
1711 r
= manager_dispatch_delayed(manager
, true);
1712 return (r
< 0) ? r
: 0;
1715 static int delay_shutdown_or_sleep(
1718 const char *unit_name
) {
1725 assert(w
< _INHIBIT_WHAT_MAX
);
1728 timeout_val
= now(CLOCK_MONOTONIC
) + m
->inhibit_delay_max
;
1730 if (m
->inhibit_timeout_source
) {
1731 r
= sd_event_source_set_time(m
->inhibit_timeout_source
, timeout_val
);
1733 return log_error_errno(r
, "sd_event_source_set_time() failed: %m");
1735 r
= sd_event_source_set_enabled(m
->inhibit_timeout_source
, SD_EVENT_ONESHOT
);
1737 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
1739 r
= sd_event_add_time(m
->event
, &m
->inhibit_timeout_source
, CLOCK_MONOTONIC
,
1740 timeout_val
, 0, manager_inhibit_timeout_handler
, m
);
1745 m
->action_unit
= unit_name
;
1751 int bus_manager_shutdown_or_sleep_now_or_later(
1753 const char *unit_name
,
1755 sd_bus_error
*error
) {
1757 _cleanup_free_
char *load_state
= NULL
;
1764 assert(w
< _INHIBIT_WHAT_MAX
);
1765 assert(!m
->action_job
);
1767 r
= unit_load_state(m
->bus
, unit_name
, &load_state
);
1771 if (!streq(load_state
, "loaded"))
1772 return log_notice_errno(SYNTHETIC_ERRNO(EACCES
),
1773 "Unit %s is %s, refusing operation.",
1774 unit_name
, load_state
);
1776 /* Tell everybody to prepare for shutdown/sleep */
1777 (void) send_prepare_for(m
, w
, true);
1780 m
->inhibit_delay_max
> 0 &&
1781 manager_is_inhibited(m
, w
, INHIBIT_DELAY
, NULL
, false, false, 0, NULL
);
1784 /* Shutdown is delayed, keep in mind what we
1785 * want to do, and start a timeout */
1786 r
= delay_shutdown_or_sleep(m
, w
, unit_name
);
1788 /* Shutdown is not delayed, execute it
1790 r
= execute_shutdown_or_sleep(m
, w
, unit_name
, error
);
1795 static int verify_shutdown_creds(
1797 sd_bus_message
*message
,
1801 const char *action_multiple_sessions
,
1802 const char *action_ignore_inhibit
,
1803 sd_bus_error
*error
) {
1805 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
1806 bool multiple_sessions
, blocked
;
1813 assert(w
<= _INHIBIT_WHAT_MAX
);
1815 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
, &creds
);
1819 r
= sd_bus_creds_get_euid(creds
, &uid
);
1823 r
= have_multiple_sessions(m
, uid
);
1827 multiple_sessions
= r
> 0;
1828 blocked
= manager_is_inhibited(m
, w
, INHIBIT_BLOCK
, NULL
, false, true, uid
, NULL
);
1830 if (multiple_sessions
&& action_multiple_sessions
) {
1831 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action_multiple_sessions
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1835 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1838 if (blocked
&& action_ignore_inhibit
) {
1839 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action_ignore_inhibit
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1843 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1846 if (!multiple_sessions
&& !blocked
&& action
) {
1847 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1851 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1857 static int method_do_shutdown_or_sleep(
1859 sd_bus_message
*message
,
1860 const char *unit_name
,
1863 const char *action_multiple_sessions
,
1864 const char *action_ignore_inhibit
,
1865 const char *sleep_verb
,
1866 sd_bus_error
*error
) {
1874 assert(w
<= _INHIBIT_WHAT_MAX
);
1876 r
= sd_bus_message_read(message
, "b", &interactive
);
1880 /* Don't allow multiple jobs being executed at the same time */
1881 if (m
->action_what
> 0)
1882 return sd_bus_error_setf(error
, BUS_ERROR_OPERATION_IN_PROGRESS
,
1883 "There's already a shutdown or sleep operation in progress");
1886 r
= can_sleep(sleep_verb
);
1888 return sd_bus_error_set(error
, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED
,
1889 "Not enough swap space for hibernation");
1891 return sd_bus_error_setf(error
, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED
,
1892 "Sleep verb \"%s\" not supported", sleep_verb
);
1897 r
= verify_shutdown_creds(m
, message
, w
, interactive
, action
, action_multiple_sessions
,
1898 action_ignore_inhibit
, error
);
1902 r
= bus_manager_shutdown_or_sleep_now_or_later(m
, unit_name
, w
, error
);
1906 return sd_bus_reply_method_return(message
, NULL
);
1909 static int method_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1910 Manager
*m
= userdata
;
1912 return method_do_shutdown_or_sleep(
1914 SPECIAL_POWEROFF_TARGET
,
1916 "org.freedesktop.login1.power-off",
1917 "org.freedesktop.login1.power-off-multiple-sessions",
1918 "org.freedesktop.login1.power-off-ignore-inhibit",
1923 static int method_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1924 Manager
*m
= userdata
;
1926 return method_do_shutdown_or_sleep(
1928 SPECIAL_REBOOT_TARGET
,
1930 "org.freedesktop.login1.reboot",
1931 "org.freedesktop.login1.reboot-multiple-sessions",
1932 "org.freedesktop.login1.reboot-ignore-inhibit",
1937 static int method_halt(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1938 Manager
*m
= userdata
;
1940 return method_do_shutdown_or_sleep(
1942 SPECIAL_HALT_TARGET
,
1944 "org.freedesktop.login1.halt",
1945 "org.freedesktop.login1.halt-multiple-sessions",
1946 "org.freedesktop.login1.halt-ignore-inhibit",
1951 static int method_suspend(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1952 Manager
*m
= userdata
;
1954 return method_do_shutdown_or_sleep(
1956 SPECIAL_SUSPEND_TARGET
,
1958 "org.freedesktop.login1.suspend",
1959 "org.freedesktop.login1.suspend-multiple-sessions",
1960 "org.freedesktop.login1.suspend-ignore-inhibit",
1965 static int method_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1966 Manager
*m
= userdata
;
1968 return method_do_shutdown_or_sleep(
1970 SPECIAL_HIBERNATE_TARGET
,
1972 "org.freedesktop.login1.hibernate",
1973 "org.freedesktop.login1.hibernate-multiple-sessions",
1974 "org.freedesktop.login1.hibernate-ignore-inhibit",
1979 static int method_hybrid_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1980 Manager
*m
= userdata
;
1982 return method_do_shutdown_or_sleep(
1984 SPECIAL_HYBRID_SLEEP_TARGET
,
1986 "org.freedesktop.login1.hibernate",
1987 "org.freedesktop.login1.hibernate-multiple-sessions",
1988 "org.freedesktop.login1.hibernate-ignore-inhibit",
1993 static int method_suspend_then_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1994 Manager
*m
= userdata
;
1996 return method_do_shutdown_or_sleep(
1998 SPECIAL_SUSPEND_THEN_HIBERNATE_TARGET
,
2000 "org.freedesktop.login1.hibernate",
2001 "org.freedesktop.login1.hibernate-multiple-sessions",
2002 "org.freedesktop.login1.hibernate-ignore-inhibit",
2007 static int nologin_timeout_handler(
2012 Manager
*m
= userdata
;
2014 log_info("Creating /run/nologin, blocking further logins...");
2017 create_shutdown_run_nologin_or_warn() >= 0;
2022 static int update_schedule_file(Manager
*m
) {
2023 _cleanup_free_
char *temp_path
= NULL
;
2024 _cleanup_fclose_
FILE *f
= NULL
;
2029 r
= mkdir_safe_label("/run/systemd/shutdown", 0755, 0, 0, MKDIR_WARN_MODE
);
2031 return log_error_errno(r
, "Failed to create shutdown subdirectory: %m");
2033 r
= fopen_temporary("/run/systemd/shutdown/scheduled", &f
, &temp_path
);
2035 return log_error_errno(r
, "Failed to save information about scheduled shutdowns: %m");
2037 (void) fchmod(fileno(f
), 0644);
2043 m
->scheduled_shutdown_timeout
,
2044 m
->enable_wall_messages
,
2045 m
->scheduled_shutdown_type
);
2047 if (!isempty(m
->wall_message
)) {
2048 _cleanup_free_
char *t
;
2050 t
= cescape(m
->wall_message
);
2056 fprintf(f
, "WALL_MESSAGE=%s\n", t
);
2059 r
= fflush_and_check(f
);
2063 if (rename(temp_path
, "/run/systemd/shutdown/scheduled") < 0) {
2071 (void) unlink(temp_path
);
2072 (void) unlink("/run/systemd/shutdown/scheduled");
2074 return log_error_errno(r
, "Failed to write information about scheduled shutdowns: %m");
2077 static void reset_scheduled_shutdown(Manager
*m
) {
2080 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
2081 m
->wall_message_timeout_source
= sd_event_source_unref(m
->wall_message_timeout_source
);
2082 m
->nologin_timeout_source
= sd_event_source_unref(m
->nologin_timeout_source
);
2084 m
->scheduled_shutdown_type
= mfree(m
->scheduled_shutdown_type
);
2085 m
->scheduled_shutdown_timeout
= 0;
2086 m
->shutdown_dry_run
= false;
2088 if (m
->unlink_nologin
) {
2089 (void) unlink_or_warn("/run/nologin");
2090 m
->unlink_nologin
= false;
2093 (void) unlink("/run/systemd/shutdown/scheduled");
2096 static int manager_scheduled_shutdown_handler(
2101 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2102 Manager
*m
= userdata
;
2108 if (isempty(m
->scheduled_shutdown_type
))
2111 if (streq(m
->scheduled_shutdown_type
, "poweroff"))
2112 target
= SPECIAL_POWEROFF_TARGET
;
2113 else if (streq(m
->scheduled_shutdown_type
, "reboot"))
2114 target
= SPECIAL_REBOOT_TARGET
;
2115 else if (streq(m
->scheduled_shutdown_type
, "halt"))
2116 target
= SPECIAL_HALT_TARGET
;
2118 assert_not_reached("unexpected shutdown type");
2120 /* Don't allow multiple jobs being executed at the same time */
2121 if (m
->action_what
> 0) {
2123 log_error("Scheduled shutdown to %s failed: shutdown or sleep operation already in progress", target
);
2127 if (m
->shutdown_dry_run
) {
2128 /* We do not process delay inhibitors here. Otherwise, we
2129 * would have to be considered "in progress" (like the check
2130 * above) for some seconds after our admin has seen the final
2133 bus_manager_log_shutdown(m
, target
);
2134 log_info("Running in dry run, suppressing action.");
2135 reset_scheduled_shutdown(m
);
2140 r
= bus_manager_shutdown_or_sleep_now_or_later(m
, target
, INHIBIT_SHUTDOWN
, &error
);
2142 log_error_errno(r
, "Scheduled shutdown to %s failed: %m", target
);
2149 reset_scheduled_shutdown(m
);
2153 static int method_schedule_shutdown(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2154 Manager
*m
= userdata
;
2155 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2156 const char *action_multiple_sessions
= NULL
;
2157 const char *action_ignore_inhibit
= NULL
;
2158 const char *action
= NULL
;
2162 bool dry_run
= false;
2167 r
= sd_bus_message_read(message
, "st", &type
, &elapse
);
2171 if (startswith(type
, "dry-")) {
2176 if (streq(type
, "poweroff")) {
2177 action
= "org.freedesktop.login1.power-off";
2178 action_multiple_sessions
= "org.freedesktop.login1.power-off-multiple-sessions";
2179 action_ignore_inhibit
= "org.freedesktop.login1.power-off-ignore-inhibit";
2180 } else if (streq(type
, "reboot")) {
2181 action
= "org.freedesktop.login1.reboot";
2182 action_multiple_sessions
= "org.freedesktop.login1.reboot-multiple-sessions";
2183 action_ignore_inhibit
= "org.freedesktop.login1.reboot-ignore-inhibit";
2184 } else if (streq(type
, "halt")) {
2185 action
= "org.freedesktop.login1.halt";
2186 action_multiple_sessions
= "org.freedesktop.login1.halt-multiple-sessions";
2187 action_ignore_inhibit
= "org.freedesktop.login1.halt-ignore-inhibit";
2189 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Unsupported shutdown type");
2191 r
= verify_shutdown_creds(m
, message
, INHIBIT_SHUTDOWN
, false,
2192 action
, action_multiple_sessions
, action_ignore_inhibit
, error
);
2196 if (m
->scheduled_shutdown_timeout_source
) {
2197 r
= sd_event_source_set_time(m
->scheduled_shutdown_timeout_source
, elapse
);
2199 return log_error_errno(r
, "sd_event_source_set_time() failed: %m");
2201 r
= sd_event_source_set_enabled(m
->scheduled_shutdown_timeout_source
, SD_EVENT_ONESHOT
);
2203 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
2205 r
= sd_event_add_time(m
->event
, &m
->scheduled_shutdown_timeout_source
,
2206 CLOCK_REALTIME
, elapse
, 0, manager_scheduled_shutdown_handler
, m
);
2208 return log_error_errno(r
, "sd_event_add_time() failed: %m");
2211 r
= free_and_strdup(&m
->scheduled_shutdown_type
, type
);
2213 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
2217 m
->shutdown_dry_run
= dry_run
;
2219 if (m
->nologin_timeout_source
) {
2220 r
= sd_event_source_set_time(m
->nologin_timeout_source
, elapse
);
2222 return log_error_errno(r
, "sd_event_source_set_time() failed: %m");
2224 r
= sd_event_source_set_enabled(m
->nologin_timeout_source
, SD_EVENT_ONESHOT
);
2226 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
2228 r
= sd_event_add_time(m
->event
, &m
->nologin_timeout_source
,
2229 CLOCK_REALTIME
, elapse
- 5 * USEC_PER_MINUTE
, 0, nologin_timeout_handler
, m
);
2231 return log_error_errno(r
, "sd_event_add_time() failed: %m");
2234 m
->scheduled_shutdown_timeout
= elapse
;
2236 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_AUGMENT
|SD_BUS_CREDS_TTY
|SD_BUS_CREDS_UID
, &creds
);
2238 const char *tty
= NULL
;
2240 (void) sd_bus_creds_get_uid(creds
, &m
->scheduled_shutdown_uid
);
2241 (void) sd_bus_creds_get_tty(creds
, &tty
);
2243 r
= free_and_strdup(&m
->scheduled_shutdown_tty
, tty
);
2245 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
2250 r
= manager_setup_wall_message_timer(m
);
2254 r
= update_schedule_file(m
);
2258 return sd_bus_reply_method_return(message
, NULL
);
2261 static int method_cancel_scheduled_shutdown(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2262 Manager
*m
= userdata
;
2268 cancelled
= m
->scheduled_shutdown_type
!= NULL
;
2269 reset_scheduled_shutdown(m
);
2271 if (cancelled
&& m
->enable_wall_messages
) {
2272 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2273 _cleanup_free_
char *username
= NULL
;
2274 const char *tty
= NULL
;
2278 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_AUGMENT
|SD_BUS_CREDS_TTY
|SD_BUS_CREDS_UID
, &creds
);
2280 (void) sd_bus_creds_get_uid(creds
, &uid
);
2281 (void) sd_bus_creds_get_tty(creds
, &tty
);
2284 username
= uid_to_name(uid
);
2285 utmp_wall("The system shutdown has been cancelled",
2286 username
, tty
, logind_wall_tty_filter
, m
);
2289 return sd_bus_reply_method_return(message
, "b", cancelled
);
2292 static int method_can_shutdown_or_sleep(
2294 sd_bus_message
*message
,
2297 const char *action_multiple_sessions
,
2298 const char *action_ignore_inhibit
,
2299 const char *sleep_verb
,
2300 sd_bus_error
*error
) {
2302 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2303 HandleAction handle
;
2304 bool multiple_sessions
, challenge
, blocked
;
2305 const char *result
= NULL
;
2312 assert(w
<= _INHIBIT_WHAT_MAX
);
2314 assert(action_multiple_sessions
);
2315 assert(action_ignore_inhibit
);
2318 r
= can_sleep(sleep_verb
);
2319 if (IN_SET(r
, 0, -ENOSPC
))
2320 return sd_bus_reply_method_return(message
, "s", "na");
2325 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
, &creds
);
2329 r
= sd_bus_creds_get_euid(creds
, &uid
);
2333 r
= have_multiple_sessions(m
, uid
);
2337 multiple_sessions
= r
> 0;
2338 blocked
= manager_is_inhibited(m
, w
, INHIBIT_BLOCK
, NULL
, false, true, uid
, NULL
);
2340 handle
= handle_action_from_string(sleep_verb
);
2344 target
= manager_target_for_action(handle
);
2346 _cleanup_free_
char *load_state
= NULL
;
2348 r
= unit_load_state(m
->bus
, target
, &load_state
);
2352 if (!streq(load_state
, "loaded")) {
2359 if (multiple_sessions
) {
2360 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action_multiple_sessions
, NULL
, UID_INVALID
, &challenge
, error
);
2367 result
= "challenge";
2373 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action_ignore_inhibit
, NULL
, UID_INVALID
, &challenge
, error
);
2380 } else if (challenge
) {
2381 if (!result
|| streq(result
, "yes"))
2382 result
= "challenge";
2387 if (!multiple_sessions
&& !blocked
) {
2388 /* If neither inhibit nor multiple sessions
2389 * apply then just check the normal policy */
2391 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action
, NULL
, UID_INVALID
, &challenge
, error
);
2398 result
= "challenge";
2404 return sd_bus_reply_method_return(message
, "s", result
);
2407 static int method_can_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2408 Manager
*m
= userdata
;
2410 return method_can_shutdown_or_sleep(
2413 "org.freedesktop.login1.power-off",
2414 "org.freedesktop.login1.power-off-multiple-sessions",
2415 "org.freedesktop.login1.power-off-ignore-inhibit",
2420 static int method_can_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2421 Manager
*m
= userdata
;
2423 return method_can_shutdown_or_sleep(
2426 "org.freedesktop.login1.reboot",
2427 "org.freedesktop.login1.reboot-multiple-sessions",
2428 "org.freedesktop.login1.reboot-ignore-inhibit",
2433 static int method_can_halt(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2434 Manager
*m
= userdata
;
2436 return method_can_shutdown_or_sleep(
2439 "org.freedesktop.login1.halt",
2440 "org.freedesktop.login1.halt-multiple-sessions",
2441 "org.freedesktop.login1.halt-ignore-inhibit",
2446 static int method_can_suspend(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2447 Manager
*m
= userdata
;
2449 return method_can_shutdown_or_sleep(
2452 "org.freedesktop.login1.suspend",
2453 "org.freedesktop.login1.suspend-multiple-sessions",
2454 "org.freedesktop.login1.suspend-ignore-inhibit",
2459 static int method_can_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2460 Manager
*m
= userdata
;
2462 return method_can_shutdown_or_sleep(
2465 "org.freedesktop.login1.hibernate",
2466 "org.freedesktop.login1.hibernate-multiple-sessions",
2467 "org.freedesktop.login1.hibernate-ignore-inhibit",
2472 static int method_can_hybrid_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2473 Manager
*m
= userdata
;
2475 return method_can_shutdown_or_sleep(
2478 "org.freedesktop.login1.hibernate",
2479 "org.freedesktop.login1.hibernate-multiple-sessions",
2480 "org.freedesktop.login1.hibernate-ignore-inhibit",
2485 static int method_can_suspend_then_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2486 Manager
*m
= userdata
;
2488 return method_can_shutdown_or_sleep(
2491 "org.freedesktop.login1.hibernate",
2492 "org.freedesktop.login1.hibernate-multiple-sessions",
2493 "org.freedesktop.login1.hibernate-ignore-inhibit",
2494 "suspend-then-hibernate",
2498 static int property_get_reboot_parameter(
2501 const char *interface
,
2502 const char *property
,
2503 sd_bus_message
*reply
,
2505 sd_bus_error
*error
) {
2506 _cleanup_free_
char *parameter
= NULL
;
2513 r
= read_reboot_parameter(¶meter
);
2517 return sd_bus_message_append(reply
, "s", parameter
);
2520 static int method_set_reboot_parameter(
2521 sd_bus_message
*message
,
2523 sd_bus_error
*error
) {
2525 Manager
*m
= userdata
;
2532 r
= sd_bus_message_read(message
, "s", &arg
);
2536 r
= detect_container();
2540 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
,
2541 "Reboot parameter not supported in containers, refusing.");
2543 r
= bus_verify_polkit_async(message
,
2545 "org.freedesktop.login1.set-reboot-parameter",
2549 &m
->polkit_registry
,
2554 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2556 r
= update_reboot_parameter_and_warn(arg
, false);
2560 return sd_bus_reply_method_return(message
, NULL
);
2563 static int method_can_reboot_parameter(
2564 sd_bus_message
*message
,
2566 sd_bus_error
*error
) {
2568 _unused_ Manager
*m
= userdata
;
2574 r
= detect_container();
2577 if (r
> 0) /* Inside containers, specifying a reboot parameter, doesn't make much sense */
2578 return sd_bus_reply_method_return(message
, "s", "na");
2580 return return_test_polkit(
2583 "org.freedesktop.login1.set-reboot-parameter",
2589 static int property_get_reboot_to_firmware_setup(
2592 const char *interface
,
2593 const char *property
,
2594 sd_bus_message
*reply
,
2596 sd_bus_error
*error
) {
2603 r
= getenv_bool("SYSTEMD_REBOOT_TO_FIRMWARE_SETUP");
2605 /* EFI case: let's see what is currently configured in the EFI variables */
2606 r
= efi_get_reboot_to_firmware();
2607 if (r
< 0 && r
!= -EOPNOTSUPP
)
2608 log_warning_errno(r
, "Failed to determine reboot-to-firmware-setup state: %m");
2610 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP: %m");
2612 /* Non-EFI case: let's see whether /run/systemd/reboot-to-firmware-setup exists. */
2613 if (access("/run/systemd/reboot-to-firmware-setup", F_OK
) < 0) {
2614 if (errno
!= ENOENT
)
2615 log_warning_errno(errno
, "Failed to check whether /run/systemd/reboot-to-firmware-setup exists: %m");
2622 return sd_bus_message_append(reply
, "b", r
> 0);
2625 static int method_set_reboot_to_firmware_setup(
2626 sd_bus_message
*message
,
2628 sd_bus_error
*error
) {
2630 Manager
*m
= userdata
;
2637 r
= sd_bus_message_read(message
, "b", &b
);
2641 r
= getenv_bool("SYSTEMD_REBOOT_TO_FIRMWARE_SETUP");
2643 /* EFI case: let's see what the firmware supports */
2645 r
= efi_reboot_to_firmware_supported();
2646 if (r
== -EOPNOTSUPP
)
2647 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Firmware does not support boot into firmware.");
2653 } else if (r
<= 0) {
2654 /* non-EFI case: $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP is set to off */
2657 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP: %m");
2659 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Firmware does not support boot into firmware.");
2661 /* non-EFI case: $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP is set to on */
2664 r
= bus_verify_polkit_async(message
,
2666 "org.freedesktop.login1.set-reboot-to-firmware-setup",
2670 &m
->polkit_registry
,
2675 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2678 r
= efi_set_reboot_to_firmware(b
);
2683 r
= touch("/run/systemd/reboot-to-firmware-setup");
2687 if (unlink("/run/systemd/reboot-to-firmware-setup") < 0 && errno
!= ENOENT
)
2692 return sd_bus_reply_method_return(message
, NULL
);
2695 static int method_can_reboot_to_firmware_setup(
2696 sd_bus_message
*message
,
2698 sd_bus_error
*error
) {
2700 _unused_ Manager
*m
= userdata
;
2706 r
= getenv_bool("SYSTEMD_REBOOT_TO_FIRMWARE_SETUP");
2708 /* EFI case: let's see what the firmware supports */
2710 r
= efi_reboot_to_firmware_supported();
2712 if (r
!= -EOPNOTSUPP
)
2713 log_warning_errno(r
, "Failed to determine whether reboot to firmware is supported: %m");
2715 return sd_bus_reply_method_return(message
, "s", "na");
2718 } else if (r
<= 0) {
2719 /* Non-EFI case: let's trust $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP */
2722 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_FIRMWARE_SETUP: %m");
2724 return sd_bus_reply_method_return(message
, "s", "na");
2727 return return_test_polkit(
2730 "org.freedesktop.login1.set-reboot-to-firmware-setup",
2736 static int property_get_reboot_to_boot_loader_menu(
2739 const char *interface
,
2740 const char *property
,
2741 sd_bus_message
*reply
,
2743 sd_bus_error
*error
) {
2745 uint64_t x
= UINT64_MAX
;
2752 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU");
2754 _cleanup_free_
char *v
= NULL
;
2756 /* EFI case: returns the current value of LoaderConfigTimeoutOneShot. Three cases are distuingished:
2758 * 1. Variable not set, boot into boot loader menu is not enabled (we return UINT64_MAX to the user)
2759 * 2. Variable set to "0", boot into boot loader menu is enabled with no timeout (we return 0 to the user)
2760 * 3. Variable set to numeric value formatted in ASCII, boot into boot loader menu with the specified timeout in seconds
2763 r
= efi_get_variable_string(EFI_VENDOR_LOADER
, "LoaderConfigTimeoutOneShot", &v
);
2766 log_warning_errno(r
, "Failed to read LoaderConfigTimeoutOneShot variable: %m");
2770 r
= safe_atou64(v
, &sec
);
2772 log_warning_errno(r
, "Failed to parse LoaderConfigTimeoutOneShot value '%s': %m", v
);
2773 else if (sec
> (USEC_INFINITY
/ USEC_PER_SEC
))
2774 log_warning("LoaderConfigTimeoutOneShot too large, ignoring: %m");
2776 x
= sec
* USEC_PER_SEC
; /* return in µs */
2780 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU: %m");
2782 _cleanup_free_
char *v
= NULL
;
2784 /* Non-EFI case, let's process /run/systemd/reboot-to-boot-loader-menu. */
2786 r
= read_one_line_file("/run/systemd/reboot-to-boot-loader-menu", &v
);
2789 log_warning_errno(r
, "Failed to read /run/systemd/reboot-to-boot-loader-menu: %m");
2791 r
= safe_atou64(v
, &x
);
2793 log_warning_errno(r
, "Failed to parse /run/systemd/reboot-to-boot-loader-menu: %m");
2797 return sd_bus_message_append(reply
, "t", x
);
2800 static int method_set_reboot_to_boot_loader_menu(
2801 sd_bus_message
*message
,
2803 sd_bus_error
*error
) {
2805 Manager
*m
= userdata
;
2813 r
= sd_bus_message_read(message
, "t", &x
);
2817 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU");
2821 /* EFI case: let's see if booting into boot loader menu is supported. */
2823 r
= efi_loader_get_features(&features
);
2825 log_warning_errno(r
, "Failed to determine whether reboot to boot loader menu is supported: %m");
2826 if (r
< 0 || !FLAGS_SET(features
, EFI_LOADER_FEATURE_CONFIG_TIMEOUT_ONE_SHOT
))
2827 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Boot loader does not support boot into boot loader menu.");
2831 } else if (r
<= 0) {
2832 /* non-EFI case: $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU is set to off */
2835 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU: %m");
2837 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Boot loader does not support boot into boot loader menu.");
2839 /* non-EFI case: $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU is set to on */
2842 r
= bus_verify_polkit_async(message
,
2844 "org.freedesktop.login1.set-reboot-to-boot-loader-menu",
2848 &m
->polkit_registry
,
2853 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2856 if (x
== UINT64_MAX
)
2857 r
= efi_set_variable(EFI_VENDOR_LOADER
, "LoaderConfigTimeoutOneShot", NULL
, 0);
2859 char buf
[DECIMAL_STR_MAX(uint64_t) + 1];
2860 xsprintf(buf
, "%" PRIu64
, DIV_ROUND_UP(x
, USEC_PER_SEC
)); /* second granularity */
2862 r
= efi_set_variable_string(EFI_VENDOR_LOADER
, "LoaderConfigTimeoutOneShot", buf
);
2867 if (x
== UINT64_MAX
) {
2868 if (unlink("/run/systemd/reboot-to-loader-menu") < 0 && errno
!= ENOENT
)
2871 char buf
[DECIMAL_STR_MAX(uint64_t) + 1];
2873 xsprintf(buf
, "%" PRIu64
, x
); /* µs granularity */
2875 r
= write_string_file_atomic_label("/run/systemd/reboot-to-loader-menu", buf
);
2881 return sd_bus_reply_method_return(message
, NULL
);
2884 static int method_can_reboot_to_boot_loader_menu(
2885 sd_bus_message
*message
,
2887 sd_bus_error
*error
) {
2889 _unused_ Manager
*m
= userdata
;
2895 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU");
2897 uint64_t features
= 0;
2899 /* EFI case, let's see if booting into boot loader menu is supported. */
2901 r
= efi_loader_get_features(&features
);
2903 log_warning_errno(r
, "Failed to determine whether reboot to boot loader menu is supported: %m");
2904 if (r
< 0 || !FLAGS_SET(features
, EFI_LOADER_FEATURE_CONFIG_TIMEOUT_ONE_SHOT
))
2905 return sd_bus_reply_method_return(message
, "s", "na");
2907 } else if (r
<= 0) {
2908 /* Non-EFI case: let's trust $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU */
2911 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU: %m");
2913 return sd_bus_reply_method_return(message
, "s", "na");
2916 return return_test_polkit(
2919 "org.freedesktop.login1.set-reboot-to-boot-loader-menu",
2925 static int property_get_reboot_to_boot_loader_entry(
2928 const char *interface
,
2929 const char *property
,
2930 sd_bus_message
*reply
,
2932 sd_bus_error
*error
) {
2934 _cleanup_free_
char *v
= NULL
;
2941 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY");
2943 /* EFI case: let's read the LoaderEntryOneShot variable */
2945 r
= efi_get_variable_string(EFI_VENDOR_LOADER
, "LoaderEntryOneShot", &v
);
2948 log_warning_errno(r
, "Failed to read LoaderEntryOneShot variable: %m");
2949 } else if (!efi_loader_entry_name_valid(v
)) {
2950 log_warning("LoaderEntryOneShot contains invalid entry name '%s', ignoring.", v
);
2954 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY: %m");
2957 /* Non-EFI case, let's process /run/systemd/reboot-to-boot-loader-entry. */
2959 r
= read_one_line_file("/run/systemd/reboot-to-boot-loader-entry", &v
);
2962 log_warning_errno(r
, "Failed to read /run/systemd/reboot-to-boot-loader-entry: %m");
2963 } else if (!efi_loader_entry_name_valid(v
)) {
2964 log_warning("/run/systemd/reboot-to-boot-loader-entry is not valid, ignoring.");
2969 return sd_bus_message_append(reply
, "s", v
);
2972 static int boot_loader_entry_exists(const char *id
) {
2973 _cleanup_(boot_config_free
) BootConfig config
= {};
2978 r
= boot_entries_load_config_auto(NULL
, NULL
, &config
);
2979 if (r
< 0 && r
!= -ENOKEY
) /* don't complain if no GPT is found, hence skip ENOKEY */
2982 (void) boot_entries_augment_from_loader(&config
, true);
2984 return boot_config_has_entry(&config
, id
);
2987 static int method_set_reboot_to_boot_loader_entry(
2988 sd_bus_message
*message
,
2990 sd_bus_error
*error
) {
2992 Manager
*m
= userdata
;
3000 r
= sd_bus_message_read(message
, "s", &v
);
3006 else if (efi_loader_entry_name_valid(v
)) {
3007 r
= boot_loader_entry_exists(v
);
3011 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Boot loader entry '%s' is not known.", v
);
3013 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Boot loader entry name '%s' is not valid, refusing.", v
);
3015 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY");
3019 /* EFI case: let's see if booting into boot loader entry is supported. */
3021 r
= efi_loader_get_features(&features
);
3023 log_warning_errno(r
, "Failed to determine whether reboot into boot loader entry is supported: %m");
3024 if (r
< 0 || !FLAGS_SET(features
, EFI_LOADER_FEATURE_ENTRY_ONESHOT
))
3025 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Loader does not support boot into boot loader entry.");
3029 } else if (r
<= 0) {
3030 /* non-EFI case: $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY is set to off */
3033 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY: %m");
3035 return sd_bus_error_setf(error
, SD_BUS_ERROR_NOT_SUPPORTED
, "Loader does not support boot into boot loader entry.");
3037 /* non-EFI case: $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY is set to on */
3040 r
= bus_verify_polkit_async(message
,
3042 "org.freedesktop.login1.set-reboot-to-boot-loader-entry",
3046 &m
->polkit_registry
,
3051 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
3056 r
= efi_set_variable(EFI_VENDOR_LOADER
, "LoaderEntryOneShot", NULL
, 0);
3058 r
= efi_set_variable_string(EFI_VENDOR_LOADER
, "LoaderEntryOneShot", v
);
3063 if (unlink("/run/systemd/reboot-to-boot-loader-entry") < 0 && errno
!= ENOENT
)
3066 r
= write_string_file_atomic_label("/run/systemd/reboot-boot-to-loader-entry", v
);
3072 return sd_bus_reply_method_return(message
, NULL
);
3075 static int method_can_reboot_to_boot_loader_entry(
3076 sd_bus_message
*message
,
3078 sd_bus_error
*error
) {
3080 _unused_ Manager
*m
= userdata
;
3086 r
= getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY");
3088 uint64_t features
= 0;
3090 /* EFI case, let's see if booting into boot loader entry is supported. */
3092 r
= efi_loader_get_features(&features
);
3094 log_warning_errno(r
, "Failed to determine whether reboot to boot loader entry is supported: %m");
3095 if (r
< 0 || !FLAGS_SET(features
, EFI_LOADER_FEATURE_ENTRY_ONESHOT
))
3096 return sd_bus_reply_method_return(message
, "s", "na");
3098 } else if (r
<= 0) {
3099 /* Non-EFI case: let's trust $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY */
3102 log_warning_errno(r
, "Failed to parse $SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY: %m");
3104 return sd_bus_reply_method_return(message
, "s", "na");
3107 return return_test_polkit(
3110 "org.freedesktop.login1.set-reboot-to-boot-loader-entry",
3116 static int property_get_boot_loader_entries(
3119 const char *interface
,
3120 const char *property
,
3121 sd_bus_message
*reply
,
3123 sd_bus_error
*error
) {
3125 _cleanup_(boot_config_free
) BootConfig config
= {};
3133 r
= boot_entries_load_config_auto(NULL
, NULL
, &config
);
3134 if (r
< 0 && r
!= -ENOKEY
) /* don't complain if there's no GPT found */
3137 (void) boot_entries_augment_from_loader(&config
, true);
3139 r
= sd_bus_message_open_container(reply
, 'a', "s");
3143 for (i
= 0; i
< config
.n_entries
; i
++) {
3144 BootEntry
*e
= config
.entries
+ i
;
3146 r
= sd_bus_message_append(reply
, "s", e
->id
);
3151 return sd_bus_message_close_container(reply
);
3154 static int method_set_wall_message(
3155 sd_bus_message
*message
,
3157 sd_bus_error
*error
) {
3160 Manager
*m
= userdata
;
3162 unsigned enable_wall_messages
;
3167 r
= sd_bus_message_read(message
, "sb", &wall_message
, &enable_wall_messages
);
3171 /* Short-circuit the operation if the desired state is already in place, to
3172 * avoid an unnecessary polkit permission check. */
3173 if (streq_ptr(m
->wall_message
, empty_to_null(wall_message
)) &&
3174 m
->enable_wall_messages
== enable_wall_messages
)
3177 r
= bus_verify_polkit_async(message
,
3179 "org.freedesktop.login1.set-wall-message",
3183 &m
->polkit_registry
,
3188 return 1; /* Will call us back */
3190 r
= free_and_strdup(&m
->wall_message
, empty_to_null(wall_message
));
3194 m
->enable_wall_messages
= enable_wall_messages
;
3197 return sd_bus_reply_method_return(message
, NULL
);
3200 static int method_inhibit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
3201 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
3202 const char *who
, *why
, *what
, *mode
;
3203 _cleanup_free_
char *id
= NULL
;
3204 _cleanup_close_
int fifo_fd
= -1;
3205 Manager
*m
= userdata
;
3206 Inhibitor
*i
= NULL
;
3216 r
= sd_bus_message_read(message
, "ssss", &what
, &who
, &why
, &mode
);
3220 w
= inhibit_what_from_string(what
);
3222 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
3223 "Invalid what specification %s", what
);
3225 mm
= inhibit_mode_from_string(mode
);
3227 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
3228 "Invalid mode specification %s", mode
);
3230 /* Delay is only supported for shutdown/sleep */
3231 if (mm
== INHIBIT_DELAY
&& (w
& ~(INHIBIT_SHUTDOWN
|INHIBIT_SLEEP
)))
3232 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
,
3233 "Delay inhibitors only supported for shutdown and sleep");
3235 /* Don't allow taking delay locks while we are already
3236 * executing the operation. We shouldn't create the impression
3237 * that the lock was successful if the machine is about to go
3238 * down/suspend any moment. */
3239 if (m
->action_what
& w
)
3240 return sd_bus_error_setf(error
, BUS_ERROR_OPERATION_IN_PROGRESS
,
3241 "The operation inhibition has been requested for is already running");
3243 r
= bus_verify_polkit_async(
3246 w
== INHIBIT_SHUTDOWN
? (mm
== INHIBIT_BLOCK
? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
3247 w
== INHIBIT_SLEEP
? (mm
== INHIBIT_BLOCK
? "org.freedesktop.login1.inhibit-block-sleep" : "org.freedesktop.login1.inhibit-delay-sleep") :
3248 w
== INHIBIT_IDLE
? "org.freedesktop.login1.inhibit-block-idle" :
3249 w
== INHIBIT_HANDLE_POWER_KEY
? "org.freedesktop.login1.inhibit-handle-power-key" :
3250 w
== INHIBIT_HANDLE_SUSPEND_KEY
? "org.freedesktop.login1.inhibit-handle-suspend-key" :
3251 w
== INHIBIT_HANDLE_HIBERNATE_KEY
? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
3252 "org.freedesktop.login1.inhibit-handle-lid-switch",
3256 &m
->polkit_registry
,
3261 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
3263 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
|SD_BUS_CREDS_PID
, &creds
);
3267 r
= sd_bus_creds_get_euid(creds
, &uid
);
3271 r
= sd_bus_creds_get_pid(creds
, &pid
);
3275 if (hashmap_size(m
->inhibitors
) >= m
->inhibitors_max
)
3276 return sd_bus_error_setf(error
, SD_BUS_ERROR_LIMITS_EXCEEDED
,
3277 "Maximum number of inhibitors (%" PRIu64
") reached, refusing further inhibitors.",
3283 if (asprintf(&id
, "%lu", ++m
->inhibit_counter
) < 0)
3286 } while (hashmap_get(m
->inhibitors
, id
));
3288 r
= manager_add_inhibitor(m
, id
, &i
);
3296 i
->why
= strdup(why
);
3297 i
->who
= strdup(who
);
3299 if (!i
->why
|| !i
->who
) {
3304 fifo_fd
= inhibitor_create_fifo(i
);
3310 r
= inhibitor_start(i
);
3314 return sd_bus_reply_method_return(message
, "h", fifo_fd
);
3323 static const sd_bus_vtable manager_vtable
[] = {
3324 SD_BUS_VTABLE_START(0),
3326 SD_BUS_WRITABLE_PROPERTY("EnableWallMessages", "b", NULL
, NULL
, offsetof(Manager
, enable_wall_messages
), 0),
3327 SD_BUS_WRITABLE_PROPERTY("WallMessage", "s", NULL
, NULL
, offsetof(Manager
, wall_message
), 0),
3329 SD_BUS_PROPERTY("NAutoVTs", "u", NULL
, offsetof(Manager
, n_autovts
), SD_BUS_VTABLE_PROPERTY_CONST
),
3330 SD_BUS_PROPERTY("KillOnlyUsers", "as", NULL
, offsetof(Manager
, kill_only_users
), SD_BUS_VTABLE_PROPERTY_CONST
),
3331 SD_BUS_PROPERTY("KillExcludeUsers", "as", NULL
, offsetof(Manager
, kill_exclude_users
), SD_BUS_VTABLE_PROPERTY_CONST
),
3332 SD_BUS_PROPERTY("KillUserProcesses", "b", NULL
, offsetof(Manager
, kill_user_processes
), SD_BUS_VTABLE_PROPERTY_CONST
),
3333 SD_BUS_PROPERTY("RebootParameter", "s", property_get_reboot_parameter
, 0, 0),
3334 SD_BUS_PROPERTY("RebootToFirmwareSetup", "b", property_get_reboot_to_firmware_setup
, 0, 0),
3335 SD_BUS_PROPERTY("RebootToBootLoaderMenu", "t", property_get_reboot_to_boot_loader_menu
, 0, 0),
3336 SD_BUS_PROPERTY("RebootToBootLoaderEntry", "s", property_get_reboot_to_boot_loader_entry
, 0, 0),
3337 SD_BUS_PROPERTY("BootLoaderEntries", "as", property_get_boot_loader_entries
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
3338 SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
3339 SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
3340 SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
3341 SD_BUS_PROPERTY("BlockInhibited", "s", property_get_inhibited
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
3342 SD_BUS_PROPERTY("DelayInhibited", "s", property_get_inhibited
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
3343 SD_BUS_PROPERTY("InhibitDelayMaxUSec", "t", NULL
, offsetof(Manager
, inhibit_delay_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
3344 SD_BUS_PROPERTY("UserStopDelayUSec", "t", NULL
, offsetof(Manager
, user_stop_delay
), SD_BUS_VTABLE_PROPERTY_CONST
),
3345 SD_BUS_PROPERTY("HandlePowerKey", "s", property_get_handle_action
, offsetof(Manager
, handle_power_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
3346 SD_BUS_PROPERTY("HandleSuspendKey", "s", property_get_handle_action
, offsetof(Manager
, handle_suspend_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
3347 SD_BUS_PROPERTY("HandleHibernateKey", "s", property_get_handle_action
, offsetof(Manager
, handle_hibernate_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
3348 SD_BUS_PROPERTY("HandleLidSwitch", "s", property_get_handle_action
, offsetof(Manager
, handle_lid_switch
), SD_BUS_VTABLE_PROPERTY_CONST
),
3349 SD_BUS_PROPERTY("HandleLidSwitchExternalPower", "s", property_get_handle_action
, offsetof(Manager
, handle_lid_switch_ep
), SD_BUS_VTABLE_PROPERTY_CONST
),
3350 SD_BUS_PROPERTY("HandleLidSwitchDocked", "s", property_get_handle_action
, offsetof(Manager
, handle_lid_switch_docked
), SD_BUS_VTABLE_PROPERTY_CONST
),
3351 SD_BUS_PROPERTY("HoldoffTimeoutUSec", "t", NULL
, offsetof(Manager
, holdoff_timeout_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
3352 SD_BUS_PROPERTY("IdleAction", "s", property_get_handle_action
, offsetof(Manager
, idle_action
), SD_BUS_VTABLE_PROPERTY_CONST
),
3353 SD_BUS_PROPERTY("IdleActionUSec", "t", NULL
, offsetof(Manager
, idle_action_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
3354 SD_BUS_PROPERTY("PreparingForShutdown", "b", property_get_preparing
, 0, 0),
3355 SD_BUS_PROPERTY("PreparingForSleep", "b", property_get_preparing
, 0, 0),
3356 SD_BUS_PROPERTY("ScheduledShutdown", "(st)", property_get_scheduled_shutdown
, 0, 0),
3357 SD_BUS_PROPERTY("Docked", "b", property_get_docked
, 0, 0),
3358 SD_BUS_PROPERTY("LidClosed", "b", property_get_lid_closed
, 0, 0),
3359 SD_BUS_PROPERTY("OnExternalPower", "b", property_get_on_external_power
, 0, 0),
3360 SD_BUS_PROPERTY("RemoveIPC", "b", bus_property_get_bool
, offsetof(Manager
, remove_ipc
), SD_BUS_VTABLE_PROPERTY_CONST
),
3361 SD_BUS_PROPERTY("RuntimeDirectorySize", "t", NULL
, offsetof(Manager
, runtime_dir_size
), SD_BUS_VTABLE_PROPERTY_CONST
),
3362 SD_BUS_PROPERTY("InhibitorsMax", "t", NULL
, offsetof(Manager
, inhibitors_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
3363 SD_BUS_PROPERTY("NCurrentInhibitors", "t", property_get_hashmap_size
, offsetof(Manager
, inhibitors
), 0),
3364 SD_BUS_PROPERTY("SessionsMax", "t", NULL
, offsetof(Manager
, sessions_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
3365 SD_BUS_PROPERTY("NCurrentSessions", "t", property_get_hashmap_size
, offsetof(Manager
, sessions
), 0),
3366 SD_BUS_PROPERTY("UserTasksMax", "t", property_get_compat_user_tasks_max
, 0, SD_BUS_VTABLE_PROPERTY_CONST
|SD_BUS_VTABLE_HIDDEN
),
3368 SD_BUS_METHOD_WITH_NAMES("GetSession",
3370 SD_BUS_PARAM(session_id
),
3372 SD_BUS_PARAM(object_path
),
3374 SD_BUS_VTABLE_UNPRIVILEGED
),
3375 SD_BUS_METHOD_WITH_NAMES("GetSessionByPID",
3379 SD_BUS_PARAM(object_path
),
3380 method_get_session_by_pid
,
3381 SD_BUS_VTABLE_UNPRIVILEGED
),
3382 SD_BUS_METHOD_WITH_NAMES("GetUser",
3386 SD_BUS_PARAM(object_path
),
3388 SD_BUS_VTABLE_UNPRIVILEGED
),
3389 SD_BUS_METHOD_WITH_NAMES("GetUserByPID",
3393 SD_BUS_PARAM(object_path
),
3394 method_get_user_by_pid
,
3395 SD_BUS_VTABLE_UNPRIVILEGED
),
3396 SD_BUS_METHOD_WITH_NAMES("GetSeat",
3398 SD_BUS_PARAM(seat_id
),
3400 SD_BUS_PARAM(object_path
),
3402 SD_BUS_VTABLE_UNPRIVILEGED
),
3403 SD_BUS_METHOD_WITH_NAMES("ListSessions",
3406 SD_BUS_PARAM(sessions
),
3407 method_list_sessions
,
3408 SD_BUS_VTABLE_UNPRIVILEGED
),
3409 SD_BUS_METHOD_WITH_NAMES("ListUsers",
3412 SD_BUS_PARAM(users
),
3414 SD_BUS_VTABLE_UNPRIVILEGED
),
3415 SD_BUS_METHOD_WITH_NAMES("ListSeats",
3418 SD_BUS_PARAM(seats
),
3420 SD_BUS_VTABLE_UNPRIVILEGED
),
3421 SD_BUS_METHOD_WITH_NAMES("ListInhibitors",
3424 SD_BUS_PARAM(inhibitors
),
3425 method_list_inhibitors
,
3426 SD_BUS_VTABLE_UNPRIVILEGED
),
3427 SD_BUS_METHOD_WITH_NAMES("CreateSession",
3428 "uusssssussbssa(sv)",
3431 SD_BUS_PARAM(service
)
3434 SD_BUS_PARAM(desktop
)
3435 SD_BUS_PARAM(seat_id
)
3438 SD_BUS_PARAM(display
)
3439 SD_BUS_PARAM(remote
)
3440 SD_BUS_PARAM(remote_user
)
3441 SD_BUS_PARAM(remote_host
)
3442 SD_BUS_PARAM(properties
),
3444 SD_BUS_PARAM(session_id
)
3445 SD_BUS_PARAM(object_path
)
3446 SD_BUS_PARAM(runtime_path
)
3447 SD_BUS_PARAM(fifo_fd
)
3449 SD_BUS_PARAM(seat_id
)
3451 SD_BUS_PARAM(existing
),
3452 method_create_session
,
3454 SD_BUS_METHOD_WITH_NAMES("ReleaseSession",
3456 SD_BUS_PARAM(session_id
),
3458 method_release_session
,
3460 SD_BUS_METHOD_WITH_NAMES("ActivateSession",
3462 SD_BUS_PARAM(session_id
),
3464 method_activate_session
,
3465 SD_BUS_VTABLE_UNPRIVILEGED
),
3466 SD_BUS_METHOD_WITH_NAMES("ActivateSessionOnSeat",
3468 SD_BUS_PARAM(session_id
)
3469 SD_BUS_PARAM(seat_id
),
3471 method_activate_session_on_seat
,
3472 SD_BUS_VTABLE_UNPRIVILEGED
),
3473 SD_BUS_METHOD_WITH_NAMES("LockSession",
3475 SD_BUS_PARAM(session_id
),
3477 method_lock_session
,
3478 SD_BUS_VTABLE_UNPRIVILEGED
),
3479 SD_BUS_METHOD_WITH_NAMES("UnlockSession",
3481 SD_BUS_PARAM(session_id
),
3483 method_lock_session
,
3484 SD_BUS_VTABLE_UNPRIVILEGED
),
3485 SD_BUS_METHOD("LockSessions",
3488 method_lock_sessions
,
3489 SD_BUS_VTABLE_UNPRIVILEGED
),
3490 SD_BUS_METHOD("UnlockSessions",
3493 method_lock_sessions
,
3494 SD_BUS_VTABLE_UNPRIVILEGED
),
3495 SD_BUS_METHOD_WITH_NAMES("KillSession",
3497 SD_BUS_PARAM(session_id
)
3499 SD_BUS_PARAM(signal_number
),
3501 method_kill_session
,
3502 SD_BUS_VTABLE_UNPRIVILEGED
),
3503 SD_BUS_METHOD_WITH_NAMES("KillUser",
3506 SD_BUS_PARAM(signal_number
),
3509 SD_BUS_VTABLE_UNPRIVILEGED
),
3510 SD_BUS_METHOD_WITH_NAMES("TerminateSession",
3512 SD_BUS_PARAM(session_id
),
3514 method_terminate_session
,
3515 SD_BUS_VTABLE_UNPRIVILEGED
),
3516 SD_BUS_METHOD_WITH_NAMES("TerminateUser",
3520 method_terminate_user
,
3521 SD_BUS_VTABLE_UNPRIVILEGED
),
3522 SD_BUS_METHOD_WITH_NAMES("TerminateSeat",
3524 SD_BUS_PARAM(seat_id
),
3526 method_terminate_seat
,
3527 SD_BUS_VTABLE_UNPRIVILEGED
),
3528 SD_BUS_METHOD_WITH_NAMES("SetUserLinger",
3531 SD_BUS_PARAM(enable
)
3532 SD_BUS_PARAM(interactive
),
3534 method_set_user_linger
,
3535 SD_BUS_VTABLE_UNPRIVILEGED
),
3536 SD_BUS_METHOD_WITH_NAMES("AttachDevice",
3538 SD_BUS_PARAM(seat_id
)
3539 SD_BUS_PARAM(sysfs_path
)
3540 SD_BUS_PARAM(interactive
),
3542 method_attach_device
,
3543 SD_BUS_VTABLE_UNPRIVILEGED
),
3544 SD_BUS_METHOD_WITH_NAMES("FlushDevices",
3546 SD_BUS_PARAM(interactive
),
3548 method_flush_devices
,
3549 SD_BUS_VTABLE_UNPRIVILEGED
),
3550 SD_BUS_METHOD_WITH_NAMES("PowerOff",
3552 SD_BUS_PARAM(interactive
),
3555 SD_BUS_VTABLE_UNPRIVILEGED
),
3556 SD_BUS_METHOD_WITH_NAMES("Reboot",
3558 SD_BUS_PARAM(interactive
),
3561 SD_BUS_VTABLE_UNPRIVILEGED
),
3562 SD_BUS_METHOD_WITH_NAMES("Halt",
3564 SD_BUS_PARAM(interactive
),
3567 SD_BUS_VTABLE_UNPRIVILEGED
),
3568 SD_BUS_METHOD_WITH_NAMES("Suspend",
3570 SD_BUS_PARAM(interactive
),
3573 SD_BUS_VTABLE_UNPRIVILEGED
),
3574 SD_BUS_METHOD_WITH_NAMES("Hibernate",
3576 SD_BUS_PARAM(interactive
),
3579 SD_BUS_VTABLE_UNPRIVILEGED
),
3580 SD_BUS_METHOD_WITH_NAMES("HybridSleep",
3582 SD_BUS_PARAM(interactive
),
3584 method_hybrid_sleep
,
3585 SD_BUS_VTABLE_UNPRIVILEGED
),
3586 SD_BUS_METHOD_WITH_NAMES("SuspendThenHibernate",
3588 SD_BUS_PARAM(interactive
),
3590 method_suspend_then_hibernate
,
3591 SD_BUS_VTABLE_UNPRIVILEGED
),
3592 SD_BUS_METHOD_WITH_NAMES("CanPowerOff",
3595 SD_BUS_PARAM(result
),
3596 method_can_poweroff
,
3597 SD_BUS_VTABLE_UNPRIVILEGED
),
3598 SD_BUS_METHOD_WITH_NAMES("CanReboot",
3601 SD_BUS_PARAM(result
),
3603 SD_BUS_VTABLE_UNPRIVILEGED
),
3604 SD_BUS_METHOD_WITH_NAMES("CanHalt",
3607 SD_BUS_PARAM(result
),
3609 SD_BUS_VTABLE_UNPRIVILEGED
),
3610 SD_BUS_METHOD_WITH_NAMES("CanSuspend",
3613 SD_BUS_PARAM(result
),
3615 SD_BUS_VTABLE_UNPRIVILEGED
),
3616 SD_BUS_METHOD_WITH_NAMES("CanHibernate",
3619 SD_BUS_PARAM(result
),
3620 method_can_hibernate
,
3621 SD_BUS_VTABLE_UNPRIVILEGED
),
3622 SD_BUS_METHOD_WITH_NAMES("CanHybridSleep",
3625 SD_BUS_PARAM(result
),
3626 method_can_hybrid_sleep
,
3627 SD_BUS_VTABLE_UNPRIVILEGED
),
3628 SD_BUS_METHOD_WITH_NAMES("CanSuspendThenHibernate",
3631 SD_BUS_PARAM(result
),
3632 method_can_suspend_then_hibernate
,
3633 SD_BUS_VTABLE_UNPRIVILEGED
),
3634 SD_BUS_METHOD_WITH_NAMES("ScheduleShutdown",
3639 method_schedule_shutdown
,
3640 SD_BUS_VTABLE_UNPRIVILEGED
),
3641 SD_BUS_METHOD_WITH_NAMES("CancelScheduledShutdown",
3644 SD_BUS_PARAM(cancelled
),
3645 method_cancel_scheduled_shutdown
,
3646 SD_BUS_VTABLE_UNPRIVILEGED
),
3647 SD_BUS_METHOD_WITH_NAMES("Inhibit",
3654 SD_BUS_PARAM(pipe_fd
),
3656 SD_BUS_VTABLE_UNPRIVILEGED
),
3657 SD_BUS_METHOD_WITH_NAMES("CanRebootParameter",
3660 SD_BUS_PARAM(result
),
3661 method_can_reboot_parameter
,
3662 SD_BUS_VTABLE_UNPRIVILEGED
),
3663 SD_BUS_METHOD_WITH_NAMES("SetRebootParameter",
3665 SD_BUS_PARAM(parameter
),
3667 method_set_reboot_parameter
,
3668 SD_BUS_VTABLE_UNPRIVILEGED
),
3669 SD_BUS_METHOD_WITH_NAMES("CanRebootToFirmwareSetup",
3672 SD_BUS_PARAM(result
),
3673 method_can_reboot_to_firmware_setup
,
3674 SD_BUS_VTABLE_UNPRIVILEGED
),
3675 SD_BUS_METHOD_WITH_NAMES("SetRebootToFirmwareSetup",
3677 SD_BUS_PARAM(enable
),
3679 method_set_reboot_to_firmware_setup
,
3680 SD_BUS_VTABLE_UNPRIVILEGED
),
3681 SD_BUS_METHOD_WITH_NAMES("CanRebootToBootLoaderMenu",
3684 SD_BUS_PARAM(result
),
3685 method_can_reboot_to_boot_loader_menu
,
3686 SD_BUS_VTABLE_UNPRIVILEGED
),
3687 SD_BUS_METHOD_WITH_NAMES("SetRebootToBootLoaderMenu",
3689 SD_BUS_PARAM(timeout
),
3691 method_set_reboot_to_boot_loader_menu
,
3692 SD_BUS_VTABLE_UNPRIVILEGED
),
3693 SD_BUS_METHOD_WITH_NAMES("CanRebootToBootLoaderEntry",
3696 SD_BUS_PARAM(result
),
3697 method_can_reboot_to_boot_loader_entry
,
3698 SD_BUS_VTABLE_UNPRIVILEGED
),
3699 SD_BUS_METHOD_WITH_NAMES("SetRebootToBootLoaderEntry",
3701 SD_BUS_PARAM(boot_loader_entry
),
3703 method_set_reboot_to_boot_loader_entry
,
3704 SD_BUS_VTABLE_UNPRIVILEGED
),
3705 SD_BUS_METHOD_WITH_NAMES("SetWallMessage",
3707 SD_BUS_PARAM(wall_message
)
3708 SD_BUS_PARAM(enable
),
3710 method_set_wall_message
,
3711 SD_BUS_VTABLE_UNPRIVILEGED
),
3713 SD_BUS_SIGNAL_WITH_NAMES("SessionNew",
3715 SD_BUS_PARAM(session_id
)
3716 SD_BUS_PARAM(object_path
),
3718 SD_BUS_SIGNAL_WITH_NAMES("SessionRemoved",
3720 SD_BUS_PARAM(session_id
)
3721 SD_BUS_PARAM(object_path
),
3723 SD_BUS_SIGNAL_WITH_NAMES("UserNew",
3726 SD_BUS_PARAM(object_path
),
3728 SD_BUS_SIGNAL_WITH_NAMES("UserRemoved",
3731 SD_BUS_PARAM(object_path
),
3733 SD_BUS_SIGNAL_WITH_NAMES("SeatNew",
3735 SD_BUS_PARAM(seat_id
)
3736 SD_BUS_PARAM(object_path
),
3738 SD_BUS_SIGNAL_WITH_NAMES("SeatRemoved",
3740 SD_BUS_PARAM(seat_id
)
3741 SD_BUS_PARAM(object_path
),
3743 SD_BUS_SIGNAL_WITH_NAMES("PrepareForShutdown",
3745 SD_BUS_PARAM(start
),
3747 SD_BUS_SIGNAL_WITH_NAMES("PrepareForSleep",
3749 SD_BUS_PARAM(start
),
3755 const BusObjectImplementation manager_object
= {
3756 "/org/freedesktop/login1",
3757 "org.freedesktop.login1.Manager",
3758 .vtables
= BUS_VTABLES(manager_vtable
),
3759 .children
= BUS_IMPLEMENTATIONS(&seat_object
,
3764 static int session_jobs_reply(Session
*s
, uint32_t jid
, const char *unit
, const char *result
) {
3771 if (result
&& !streq(result
, "done")) {
3772 _cleanup_(sd_bus_error_free
) sd_bus_error e
= SD_BUS_ERROR_NULL
;
3774 sd_bus_error_setf(&e
, BUS_ERROR_JOB_FAILED
,
3775 "Job %u for unit '%s' failed with '%s'", jid
, unit
, result
);
3776 return session_send_create_reply(s
, &e
);
3779 return session_send_create_reply(s
, NULL
);
3782 int match_job_removed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
3783 const char *path
, *result
, *unit
;
3784 Manager
*m
= userdata
;
3793 r
= sd_bus_message_read(message
, "uoss", &id
, &path
, &unit
, &result
);
3795 bus_log_parse_error(r
);
3799 if (m
->action_job
&& streq(m
->action_job
, path
)) {
3800 log_info("Operation '%s' finished.", inhibit_what_to_string(m
->action_what
));
3802 /* Tell people that they now may take a lock again */
3803 (void) send_prepare_for(m
, m
->action_what
, false);
3805 m
->action_job
= mfree(m
->action_job
);
3806 m
->action_unit
= NULL
;
3811 session
= hashmap_get(m
->session_units
, unit
);
3813 if (streq_ptr(path
, session
->scope_job
)) {
3814 session
->scope_job
= mfree(session
->scope_job
);
3815 (void) session_jobs_reply(session
, id
, unit
, result
);
3817 session_save(session
);
3818 user_save(session
->user
);
3821 session_add_to_gc_queue(session
);
3824 user
= hashmap_get(m
->user_units
, unit
);
3826 if (streq_ptr(path
, user
->service_job
)) {
3827 user
->service_job
= mfree(user
->service_job
);
3829 LIST_FOREACH(sessions_by_user
, session
, user
->sessions
)
3830 (void) session_jobs_reply(session
, id
, unit
, NULL
/* don't propagate user service failures to the client */);
3835 user_add_to_gc_queue(user
);
3841 int match_unit_removed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
3842 const char *path
, *unit
;
3843 Manager
*m
= userdata
;
3851 r
= sd_bus_message_read(message
, "so", &unit
, &path
);
3853 bus_log_parse_error(r
);
3857 session
= hashmap_get(m
->session_units
, unit
);
3859 session_add_to_gc_queue(session
);
3861 user
= hashmap_get(m
->user_units
, unit
);
3863 user_add_to_gc_queue(user
);
3868 int match_properties_changed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
3869 _cleanup_free_
char *unit
= NULL
;
3870 Manager
*m
= userdata
;
3879 path
= sd_bus_message_get_path(message
);
3883 r
= unit_name_from_dbus_path(path
, &unit
);
3884 if (r
== -EINVAL
) /* not a unit */
3891 session
= hashmap_get(m
->session_units
, unit
);
3893 session_add_to_gc_queue(session
);
3895 user
= hashmap_get(m
->user_units
, unit
);
3897 user_add_to_gc_queue(user
);
3902 int match_reloading(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
3903 Manager
*m
= userdata
;
3911 r
= sd_bus_message_read(message
, "b", &b
);
3913 bus_log_parse_error(r
);
3920 /* systemd finished reloading, let's recheck all our sessions */
3921 log_debug("System manager has been reloaded, rechecking sessions...");
3923 HASHMAP_FOREACH(session
, m
->sessions
, i
)
3924 session_add_to_gc_queue(session
);
3929 int manager_send_changed(Manager
*manager
, const char *property
, ...) {
3934 l
= strv_from_stdarg_alloca(property
);
3936 return sd_bus_emit_properties_changed_strv(
3938 "/org/freedesktop/login1",
3939 "org.freedesktop.login1.Manager",
3943 static int strdup_job(sd_bus_message
*reply
, char **job
) {
3948 r
= sd_bus_message_read(reply
, "o", &j
);
3960 int manager_start_scope(
3965 const char *description
,
3968 const char *requires_mounts_for
,
3969 sd_bus_message
*more_properties
,
3970 sd_bus_error
*error
,
3973 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
, *reply
= NULL
;
3982 r
= bus_message_new_method_call(manager
->bus
, &m
, bus_systemd_mgr
, "StartTransientUnit");
3986 r
= sd_bus_message_append(m
, "ss", strempty(scope
), "fail");
3990 r
= sd_bus_message_open_container(m
, 'a', "(sv)");
3994 if (!isempty(slice
)) {
3995 r
= sd_bus_message_append(m
, "(sv)", "Slice", "s", slice
);
4000 if (!isempty(description
)) {
4001 r
= sd_bus_message_append(m
, "(sv)", "Description", "s", description
);
4006 STRV_FOREACH(i
, wants
) {
4007 r
= sd_bus_message_append(m
, "(sv)", "Wants", "as", 1, *i
);
4012 STRV_FOREACH(i
, after
) {
4013 r
= sd_bus_message_append(m
, "(sv)", "After", "as", 1, *i
);
4018 if (!empty_or_root(requires_mounts_for
)) {
4019 r
= sd_bus_message_append(m
, "(sv)", "RequiresMountsFor", "as", 1, requires_mounts_for
);
4024 /* Make sure that the session shells are terminated with SIGHUP since bash and friends tend to ignore
4026 r
= sd_bus_message_append(m
, "(sv)", "SendSIGHUP", "b", true);
4030 r
= sd_bus_message_append(m
, "(sv)", "PIDs", "au", 1, pid
);
4034 /* disable TasksMax= for the session scope, rely on the slice setting for it */
4035 r
= sd_bus_message_append(m
, "(sv)", "TasksMax", "t", (uint64_t)-1);
4037 return bus_log_create_error(r
);
4039 if (more_properties
) {
4040 /* If TasksMax also appears here, it will overwrite the default value set above */
4041 r
= sd_bus_message_copy(m
, more_properties
, true);
4046 r
= sd_bus_message_close_container(m
);
4050 r
= sd_bus_message_append(m
, "a(sa(sv))", 0);
4054 r
= sd_bus_call(manager
->bus
, m
, 0, error
, &reply
);
4058 return strdup_job(reply
, job
);
4061 int manager_start_unit(Manager
*manager
, const char *unit
, sd_bus_error
*error
, char **job
) {
4062 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
4069 r
= bus_call_method(
4075 "ss", unit
, "replace");
4079 return strdup_job(reply
, job
);
4082 int manager_stop_unit(Manager
*manager
, const char *unit
, sd_bus_error
*error
, char **job
) {
4083 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
4090 r
= bus_call_method(
4096 "ss", unit
, "fail");
4098 if (sd_bus_error_has_name(error
, BUS_ERROR_NO_SUCH_UNIT
) ||
4099 sd_bus_error_has_name(error
, BUS_ERROR_LOAD_FAILED
)) {
4102 sd_bus_error_free(error
);
4109 return strdup_job(reply
, job
);
4112 int manager_abandon_scope(Manager
*manager
, const char *scope
, sd_bus_error
*ret_error
) {
4113 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
4114 _cleanup_free_
char *path
= NULL
;
4120 path
= unit_dbus_path_from_name(scope
);
4124 r
= sd_bus_call_method(
4126 "org.freedesktop.systemd1",
4128 "org.freedesktop.systemd1.Scope",
4134 if (sd_bus_error_has_name(&error
, BUS_ERROR_NO_SUCH_UNIT
) ||
4135 sd_bus_error_has_name(&error
, BUS_ERROR_LOAD_FAILED
) ||
4136 sd_bus_error_has_name(&error
, BUS_ERROR_SCOPE_NOT_RUNNING
))
4139 sd_bus_error_move(ret_error
, &error
);
4146 int manager_kill_unit(Manager
*manager
, const char *unit
, KillWho who
, int signo
, sd_bus_error
*error
) {
4150 return bus_call_method(
4156 "ssi", unit
, who
== KILL_LEADER
? "main" : "all", signo
);
4159 int manager_unit_is_active(Manager
*manager
, const char *unit
, sd_bus_error
*ret_error
) {
4160 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
4161 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
4162 _cleanup_free_
char *path
= NULL
;
4169 path
= unit_dbus_path_from_name(unit
);
4173 r
= sd_bus_get_property(
4175 "org.freedesktop.systemd1",
4177 "org.freedesktop.systemd1.Unit",
4183 /* systemd might have dropped off momentarily, let's
4184 * not make this an error */
4185 if (sd_bus_error_has_name(&error
, SD_BUS_ERROR_NO_REPLY
) ||
4186 sd_bus_error_has_name(&error
, SD_BUS_ERROR_DISCONNECTED
))
4189 /* If the unit is already unloaded then it's not
4191 if (sd_bus_error_has_name(&error
, BUS_ERROR_NO_SUCH_UNIT
) ||
4192 sd_bus_error_has_name(&error
, BUS_ERROR_LOAD_FAILED
))
4195 sd_bus_error_move(ret_error
, &error
);
4199 r
= sd_bus_message_read(reply
, "s", &state
);
4203 return !STR_IN_SET(state
, "inactive", "failed");
4206 int manager_job_is_active(Manager
*manager
, const char *path
, sd_bus_error
*ret_error
) {
4207 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
4208 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
4214 r
= sd_bus_get_property(
4216 "org.freedesktop.systemd1",
4218 "org.freedesktop.systemd1.Job",
4224 if (sd_bus_error_has_name(&error
, SD_BUS_ERROR_NO_REPLY
) ||
4225 sd_bus_error_has_name(&error
, SD_BUS_ERROR_DISCONNECTED
))
4228 if (sd_bus_error_has_name(&error
, SD_BUS_ERROR_UNKNOWN_OBJECT
))
4231 sd_bus_error_move(ret_error
, &error
);
4235 /* We don't actually care about the state really. The fact
4236 * that we could read the job state is enough for us */