2 This file is part of systemd.
4 Copyright 2011 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include "sd-messages.h"
27 #include "alloc-util.h"
28 #include "audit-util.h"
29 #include "bus-common-errors.h"
30 #include "bus-error.h"
32 #include "dirent-util.h"
36 #include "fileio-label.h"
37 #include "format-util.h"
41 #include "path-util.h"
42 #include "process-util.h"
43 #include "selinux-util.h"
44 #include "sleep-config.h"
47 #include "terminal-util.h"
48 #include "udev-util.h"
49 #include "unit-name.h"
50 #include "user-util.h"
51 #include "utmp-wtmp.h"
53 static int get_sender_session(Manager
*m
, sd_bus_message
*message
, sd_bus_error
*error
, Session
**ret
) {
55 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
60 /* Get client login session. This is not what you are looking for these days,
61 * as apps may instead belong to a user service unit. This includes terminal
62 * emulators and hence command-line apps. */
63 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_SESSION
|SD_BUS_CREDS_AUGMENT
, &creds
);
67 r
= sd_bus_creds_get_session(creds
, &name
);
73 session
= hashmap_get(m
->sessions
, name
);
81 return sd_bus_error_setf(error
, BUS_ERROR_NO_SESSION_FOR_PID
,
82 "Caller does not belong to any known session");
85 int manager_get_session_from_creds(Manager
*m
, sd_bus_message
*message
, const char *name
, sd_bus_error
*error
, Session
**ret
) {
93 return get_sender_session(m
, message
, error
, ret
);
95 session
= hashmap_get(m
->sessions
, name
);
97 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SESSION
, "No session '%s' known", name
);
103 static int get_sender_user(Manager
*m
, sd_bus_message
*message
, sd_bus_error
*error
, User
**ret
) {
105 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
110 /* Note that we get the owner UID of the session, not the actual client UID here! */
111 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_OWNER_UID
|SD_BUS_CREDS_AUGMENT
, &creds
);
115 r
= sd_bus_creds_get_owner_uid(creds
, &uid
);
121 user
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
129 return sd_bus_error_setf(error
, BUS_ERROR_NO_USER_FOR_PID
, "Caller does not belong to any logged in user or lingering user");
132 int manager_get_user_from_creds(Manager
*m
, sd_bus_message
*message
, uid_t uid
, sd_bus_error
*error
, User
**ret
) {
139 if (!uid_is_valid(uid
))
140 return get_sender_user(m
, message
, error
, ret
);
142 user
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
144 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_USER
, "User ID "UID_FMT
" is not logged in or lingering", uid
);
150 int manager_get_seat_from_creds(Manager
*m
, sd_bus_message
*message
, const char *name
, sd_bus_error
*error
, Seat
**ret
) {
161 r
= manager_get_session_from_creds(m
, message
, NULL
, error
, &session
);
165 seat
= session
->seat
;
167 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
, "Session has no seat.");
169 seat
= hashmap_get(m
->seats
, name
);
171 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
, "No seat '%s' known", name
);
178 static int property_get_idle_hint(
181 const char *interface
,
182 const char *property
,
183 sd_bus_message
*reply
,
185 sd_bus_error
*error
) {
187 Manager
*m
= userdata
;
193 return sd_bus_message_append(reply
, "b", manager_get_idle_hint(m
, NULL
) > 0);
196 static int property_get_idle_since_hint(
199 const char *interface
,
200 const char *property
,
201 sd_bus_message
*reply
,
203 sd_bus_error
*error
) {
205 Manager
*m
= userdata
;
206 dual_timestamp t
= DUAL_TIMESTAMP_NULL
;
212 manager_get_idle_hint(m
, &t
);
214 return sd_bus_message_append(reply
, "t", streq(property
, "IdleSinceHint") ? t
.realtime
: t
.monotonic
);
217 static int property_get_inhibited(
220 const char *interface
,
221 const char *property
,
222 sd_bus_message
*reply
,
224 sd_bus_error
*error
) {
226 Manager
*m
= userdata
;
233 w
= manager_inhibit_what(m
, streq(property
, "BlockInhibited") ? INHIBIT_BLOCK
: INHIBIT_DELAY
);
235 return sd_bus_message_append(reply
, "s", inhibit_what_to_string(w
));
238 static int property_get_preparing(
241 const char *interface
,
242 const char *property
,
243 sd_bus_message
*reply
,
245 sd_bus_error
*error
) {
247 Manager
*m
= userdata
;
254 if (streq(property
, "PreparingForShutdown"))
255 b
= !!(m
->action_what
& INHIBIT_SHUTDOWN
);
257 b
= !!(m
->action_what
& INHIBIT_SLEEP
);
259 return sd_bus_message_append(reply
, "b", b
);
262 static int property_get_scheduled_shutdown(
265 const char *interface
,
266 const char *property
,
267 sd_bus_message
*reply
,
269 sd_bus_error
*error
) {
271 Manager
*m
= userdata
;
278 r
= sd_bus_message_open_container(reply
, 'r', "st");
282 r
= sd_bus_message_append(reply
, "st", m
->scheduled_shutdown_type
, m
->scheduled_shutdown_timeout
);
286 return sd_bus_message_close_container(reply
);
289 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_handle_action
, handle_action
, HandleAction
);
291 static int property_get_docked(
294 const char *interface
,
295 const char *property
,
296 sd_bus_message
*reply
,
298 sd_bus_error
*error
) {
300 Manager
*m
= userdata
;
306 return sd_bus_message_append(reply
, "b", manager_is_docked_or_external_displays(m
));
309 static int property_get_current_sessions(
312 const char *interface
,
313 const char *property
,
314 sd_bus_message
*reply
,
316 sd_bus_error
*error
) {
318 Manager
*m
= userdata
;
324 return sd_bus_message_append(reply
, "t", (uint64_t) hashmap_size(m
->sessions
));
327 static int property_get_current_inhibitors(
330 const char *interface
,
331 const char *property
,
332 sd_bus_message
*reply
,
334 sd_bus_error
*error
) {
336 Manager
*m
= userdata
;
342 return sd_bus_message_append(reply
, "t", (uint64_t) hashmap_size(m
->inhibitors
));
345 static int method_get_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
346 _cleanup_free_
char *p
= NULL
;
347 Manager
*m
= userdata
;
355 r
= sd_bus_message_read(message
, "s", &name
);
359 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
363 p
= session_bus_path(session
);
367 return sd_bus_reply_method_return(message
, "o", p
);
370 /* Get login session of a process. This is not what you are looking for these days,
371 * as apps may instead belong to a user service unit. This includes terminal
372 * emulators and hence command-line apps. */
373 static int method_get_session_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
374 _cleanup_free_
char *p
= NULL
;
375 Session
*session
= NULL
;
376 Manager
*m
= userdata
;
383 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
385 r
= sd_bus_message_read(message
, "u", &pid
);
392 r
= manager_get_session_from_creds(m
, message
, NULL
, error
, &session
);
396 r
= manager_get_session_by_pid(m
, pid
, &session
);
401 return sd_bus_error_setf(error
, BUS_ERROR_NO_SESSION_FOR_PID
, "PID "PID_FMT
" does not belong to any known session", pid
);
404 p
= session_bus_path(session
);
408 return sd_bus_reply_method_return(message
, "o", p
);
411 static int method_get_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
412 _cleanup_free_
char *p
= NULL
;
413 Manager
*m
= userdata
;
421 r
= sd_bus_message_read(message
, "u", &uid
);
425 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
429 p
= user_bus_path(user
);
433 return sd_bus_reply_method_return(message
, "o", p
);
436 static int method_get_user_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
437 _cleanup_free_
char *p
= NULL
;
438 Manager
*m
= userdata
;
446 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
448 r
= sd_bus_message_read(message
, "u", &pid
);
455 r
= manager_get_user_from_creds(m
, message
, UID_INVALID
, error
, &user
);
459 r
= manager_get_user_by_pid(m
, pid
, &user
);
463 return sd_bus_error_setf(error
, BUS_ERROR_NO_USER_FOR_PID
,
464 "PID "PID_FMT
" does not belong to any logged in user or lingering user",
468 p
= user_bus_path(user
);
472 return sd_bus_reply_method_return(message
, "o", p
);
475 static int method_get_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
476 _cleanup_free_
char *p
= NULL
;
477 Manager
*m
= userdata
;
485 r
= sd_bus_message_read(message
, "s", &name
);
489 r
= manager_get_seat_from_creds(m
, message
, name
, error
, &seat
);
493 p
= seat_bus_path(seat
);
497 return sd_bus_reply_method_return(message
, "o", p
);
500 static int method_list_sessions(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
501 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
502 Manager
*m
= userdata
;
510 r
= sd_bus_message_new_method_return(message
, &reply
);
514 r
= sd_bus_message_open_container(reply
, 'a', "(susso)");
518 HASHMAP_FOREACH(session
, m
->sessions
, i
) {
519 _cleanup_free_
char *p
= NULL
;
521 p
= session_bus_path(session
);
525 r
= sd_bus_message_append(reply
, "(susso)",
527 (uint32_t) session
->user
->uid
,
529 session
->seat
? session
->seat
->id
: "",
535 r
= sd_bus_message_close_container(reply
);
539 return sd_bus_send(NULL
, reply
, NULL
);
542 static int method_list_users(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
543 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
544 Manager
*m
= userdata
;
552 r
= sd_bus_message_new_method_return(message
, &reply
);
556 r
= sd_bus_message_open_container(reply
, 'a', "(uso)");
560 HASHMAP_FOREACH(user
, m
->users
, i
) {
561 _cleanup_free_
char *p
= NULL
;
563 p
= user_bus_path(user
);
567 r
= sd_bus_message_append(reply
, "(uso)",
568 (uint32_t) user
->uid
,
575 r
= sd_bus_message_close_container(reply
);
579 return sd_bus_send(NULL
, reply
, NULL
);
582 static int method_list_seats(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
583 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
584 Manager
*m
= userdata
;
592 r
= sd_bus_message_new_method_return(message
, &reply
);
596 r
= sd_bus_message_open_container(reply
, 'a', "(so)");
600 HASHMAP_FOREACH(seat
, m
->seats
, i
) {
601 _cleanup_free_
char *p
= NULL
;
603 p
= seat_bus_path(seat
);
607 r
= sd_bus_message_append(reply
, "(so)", seat
->id
, p
);
612 r
= sd_bus_message_close_container(reply
);
616 return sd_bus_send(NULL
, reply
, NULL
);
619 static int method_list_inhibitors(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
620 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
621 Manager
*m
= userdata
;
622 Inhibitor
*inhibitor
;
629 r
= sd_bus_message_new_method_return(message
, &reply
);
633 r
= sd_bus_message_open_container(reply
, 'a', "(ssssuu)");
637 HASHMAP_FOREACH(inhibitor
, m
->inhibitors
, i
) {
639 r
= sd_bus_message_append(reply
, "(ssssuu)",
640 strempty(inhibit_what_to_string(inhibitor
->what
)),
641 strempty(inhibitor
->who
),
642 strempty(inhibitor
->why
),
643 strempty(inhibit_mode_to_string(inhibitor
->mode
)),
644 (uint32_t) inhibitor
->uid
,
645 (uint32_t) inhibitor
->pid
);
650 r
= sd_bus_message_close_container(reply
);
654 return sd_bus_send(NULL
, reply
, NULL
);
657 static int method_create_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
658 const char *service
, *type
, *class, *cseat
, *tty
, *display
, *remote_user
, *remote_host
, *desktop
;
659 uint32_t audit_id
= 0;
660 _cleanup_free_
char *id
= NULL
;
661 Session
*session
= NULL
;
662 Manager
*m
= userdata
;
676 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
677 assert_cc(sizeof(uid_t
) == sizeof(uint32_t));
679 r
= sd_bus_message_read(message
, "uusssssussbss", &uid
, &leader
, &service
, &type
, &class, &desktop
, &cseat
, &vtnr
, &tty
, &display
, &remote
, &remote_user
, &remote_host
);
683 if (!uid_is_valid(uid
))
684 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid UID");
685 if (leader
< 0 || leader
== 1)
686 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid leader PID");
689 t
= _SESSION_TYPE_INVALID
;
691 t
= session_type_from_string(type
);
693 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid session type %s", type
);
697 c
= _SESSION_CLASS_INVALID
;
699 c
= session_class_from_string(class);
701 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid session class %s", class);
704 if (isempty(desktop
))
707 if (!string_is_safe(desktop
))
708 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid desktop string %s", desktop
);
714 seat
= hashmap_get(m
->seats
, cseat
);
716 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
, "No seat '%s' known", cseat
);
719 if (tty_is_vc(tty
)) {
724 else if (seat
!= m
->seat0
)
725 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "TTY %s is virtual console but seat %s is not seat0", tty
, seat
->id
);
727 v
= vtnr_from_tty(tty
);
729 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Cannot determine VT number from virtual console TTY %s", tty
);
733 else if (vtnr
!= (uint32_t) v
)
734 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Specified TTY and VT number do not match");
736 } else if (tty_is_console(tty
)) {
740 else if (seat
!= m
->seat0
)
741 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Console TTY specified but seat is not seat0");
744 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Console TTY specified but VT number is not 0");
748 if (seat_has_vts(seat
)) {
749 if (!vtnr
|| vtnr
> 63)
750 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "VT number out of range");
753 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Seat has no VTs but VT number not 0");
757 r
= sd_bus_message_enter_container(message
, 'a', "(sv)");
761 if (t
== _SESSION_TYPE_INVALID
) {
762 if (!isempty(display
))
764 else if (!isempty(tty
))
767 t
= SESSION_UNSPECIFIED
;
770 if (c
== _SESSION_CLASS_INVALID
) {
771 if (t
== SESSION_UNSPECIFIED
)
772 c
= SESSION_BACKGROUND
;
778 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
780 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
784 r
= sd_bus_creds_get_pid(creds
, (pid_t
*) &leader
);
789 r
= manager_get_session_by_pid(m
, leader
, NULL
);
791 return sd_bus_error_setf(error
, BUS_ERROR_SESSION_BUSY
, "Already running in a session");
794 * Old gdm and lightdm start the user-session on the same VT as
795 * the greeter session. But they destroy the greeter session
796 * after the user-session and want the user-session to take
797 * over the VT. We need to support this for
798 * backwards-compatibility, so make sure we allow new sessions
799 * on a VT that a greeter is running on. Furthermore, to allow
800 * re-logins, we have to allow a greeter to take over a used VT for
801 * the exact same reasons.
803 if (c
!= SESSION_GREETER
&&
805 vtnr
< m
->seat0
->position_count
&&
806 m
->seat0
->positions
[vtnr
] &&
807 m
->seat0
->positions
[vtnr
]->class != SESSION_GREETER
)
808 return sd_bus_error_setf(error
, BUS_ERROR_SESSION_BUSY
, "Already occupied by a session");
810 if (hashmap_size(m
->sessions
) >= m
->sessions_max
)
811 return sd_bus_error_setf(error
, SD_BUS_ERROR_LIMITS_EXCEEDED
, "Maximum number of sessions (%" PRIu64
") reached, refusing further sessions.", m
->sessions_max
);
813 (void) audit_session_from_pid(leader
, &audit_id
);
814 if (audit_session_is_valid(audit_id
)) {
815 /* Keep our session IDs and the audit session IDs in sync */
817 if (asprintf(&id
, "%"PRIu32
, audit_id
) < 0)
820 /* Wut? There's already a session by this name and we
821 * didn't find it above? Weird, then let's not trust
822 * the audit data and let's better register a new
824 if (hashmap_get(m
->sessions
, id
)) {
825 log_warning("Existing logind session ID %s used by new audit session, ignoring", id
);
826 audit_id
= AUDIT_SESSION_INVALID
;
836 if (asprintf(&id
, "c%lu", ++m
->session_counter
) < 0)
839 } while (hashmap_get(m
->sessions
, id
));
842 r
= manager_add_user_by_uid(m
, uid
, &user
);
846 r
= manager_add_session(m
, id
, &session
);
850 session_set_user(session
, user
);
852 session
->leader
= leader
;
853 session
->audit_id
= audit_id
;
856 session
->remote
= remote
;
857 session
->vtnr
= vtnr
;
860 session
->tty
= strdup(tty
);
867 if (!isempty(display
)) {
868 session
->display
= strdup(display
);
869 if (!session
->display
) {
875 if (!isempty(remote_user
)) {
876 session
->remote_user
= strdup(remote_user
);
877 if (!session
->remote_user
) {
883 if (!isempty(remote_host
)) {
884 session
->remote_host
= strdup(remote_host
);
885 if (!session
->remote_host
) {
891 if (!isempty(service
)) {
892 session
->service
= strdup(service
);
893 if (!session
->service
) {
899 if (!isempty(desktop
)) {
900 session
->desktop
= strdup(desktop
);
901 if (!session
->desktop
) {
908 r
= seat_attach_session(seat
, session
);
913 r
= session_start(session
);
917 session
->create_message
= sd_bus_message_ref(message
);
919 /* Now, let's wait until the slice unit and stuff got
920 * created. We send the reply back from
921 * session_send_create_reply(). */
927 session_add_to_gc_queue(session
);
930 user_add_to_gc_queue(user
);
935 static int method_release_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
936 Manager
*m
= userdata
;
944 r
= sd_bus_message_read(message
, "s", &name
);
948 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
952 r
= session_release(session
);
956 return sd_bus_reply_method_return(message
, NULL
);
959 static int method_activate_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
960 Manager
*m
= userdata
;
968 r
= sd_bus_message_read(message
, "s", &name
);
972 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
976 return bus_session_method_activate(message
, session
, error
);
979 static int method_activate_session_on_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
980 const char *session_name
, *seat_name
;
981 Manager
*m
= userdata
;
989 /* Same as ActivateSession() but refuses to work if
990 * the seat doesn't match */
992 r
= sd_bus_message_read(message
, "ss", &session_name
, &seat_name
);
996 r
= manager_get_session_from_creds(m
, message
, session_name
, error
, &session
);
1000 r
= manager_get_seat_from_creds(m
, message
, seat_name
, error
, &seat
);
1004 if (session
->seat
!= seat
)
1005 return sd_bus_error_setf(error
, BUS_ERROR_SESSION_NOT_ON_SEAT
, "Session %s not on seat %s", session_name
, seat_name
);
1007 r
= session_activate(session
);
1011 return sd_bus_reply_method_return(message
, NULL
);
1014 static int method_lock_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1015 Manager
*m
= userdata
;
1023 r
= sd_bus_message_read(message
, "s", &name
);
1027 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1031 return bus_session_method_lock(message
, session
, error
);
1034 static int method_lock_sessions(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1035 Manager
*m
= userdata
;
1041 r
= bus_verify_polkit_async(
1044 "org.freedesktop.login1.lock-sessions",
1048 &m
->polkit_registry
,
1053 return 1; /* Will call us back */
1055 r
= session_send_lock_all(m
, streq(sd_bus_message_get_member(message
), "LockSessions"));
1059 return sd_bus_reply_method_return(message
, NULL
);
1062 static int method_kill_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1064 Manager
*m
= userdata
;
1071 r
= sd_bus_message_read(message
, "s", &name
);
1075 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1079 return bus_session_method_kill(message
, session
, error
);
1082 static int method_kill_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1083 Manager
*m
= userdata
;
1091 r
= sd_bus_message_read(message
, "u", &uid
);
1095 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
1099 return bus_user_method_kill(message
, user
, error
);
1102 static int method_terminate_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1103 Manager
*m
= userdata
;
1111 r
= sd_bus_message_read(message
, "s", &name
);
1115 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1119 return bus_session_method_terminate(message
, session
, error
);
1122 static int method_terminate_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1123 Manager
*m
= userdata
;
1131 r
= sd_bus_message_read(message
, "u", &uid
);
1135 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
1139 return bus_user_method_terminate(message
, user
, error
);
1142 static int method_terminate_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1143 Manager
*m
= userdata
;
1151 r
= sd_bus_message_read(message
, "s", &name
);
1155 r
= manager_get_seat_from_creds(m
, message
, name
, error
, &seat
);
1159 return bus_seat_method_terminate(message
, seat
, error
);
1162 static int method_set_user_linger(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1163 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
1164 _cleanup_free_
char *cc
= NULL
;
1165 Manager
*m
= userdata
;
1166 int r
, b
, interactive
;
1169 uint32_t uid
, auth_uid
;
1174 r
= sd_bus_message_read(message
, "ubb", &uid
, &b
, &interactive
);
1178 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
|
1179 SD_BUS_CREDS_OWNER_UID
|SD_BUS_CREDS_AUGMENT
, &creds
);
1183 if (!uid_is_valid(uid
)) {
1184 /* Note that we get the owner UID of the session or user unit,
1185 * not the actual client UID here! */
1186 r
= sd_bus_creds_get_owner_uid(creds
, &uid
);
1191 /* owner_uid is racy, so for authorization we must use euid */
1192 r
= sd_bus_creds_get_euid(creds
, &auth_uid
);
1199 return errno
> 0 ? -errno
: -ENOENT
;
1201 r
= bus_verify_polkit_async(
1204 uid
== auth_uid
? "org.freedesktop.login1.set-self-linger" :
1205 "org.freedesktop.login1.set-user-linger",
1209 &m
->polkit_registry
,
1214 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1216 mkdir_p_label("/var/lib/systemd", 0755);
1218 r
= mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0, false);
1222 cc
= cescape(pw
->pw_name
);
1226 path
= strjoina("/var/lib/systemd/linger/", cc
);
1234 if (manager_add_user_by_uid(m
, uid
, &u
) >= 0)
1241 if (r
< 0 && errno
!= ENOENT
)
1244 u
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
1246 user_add_to_gc_queue(u
);
1249 return sd_bus_reply_method_return(message
, NULL
);
1252 static int trigger_device(Manager
*m
, struct udev_device
*d
) {
1253 _cleanup_udev_enumerate_unref_
struct udev_enumerate
*e
= NULL
;
1254 struct udev_list_entry
*first
, *item
;
1259 e
= udev_enumerate_new(m
->udev
);
1264 r
= udev_enumerate_add_match_parent(e
, d
);
1269 r
= udev_enumerate_scan_devices(e
);
1273 first
= udev_enumerate_get_list_entry(e
);
1274 udev_list_entry_foreach(item
, first
) {
1275 _cleanup_free_
char *t
= NULL
;
1278 p
= udev_list_entry_get_name(item
);
1280 t
= strappend(p
, "/uevent");
1284 write_string_file(t
, "change", WRITE_STRING_FILE_CREATE
);
1290 static int attach_device(Manager
*m
, const char *seat
, const char *sysfs
) {
1291 _cleanup_udev_device_unref_
struct udev_device
*d
= NULL
;
1292 _cleanup_free_
char *rule
= NULL
, *file
= NULL
;
1293 const char *id_for_seat
;
1300 d
= udev_device_new_from_syspath(m
->udev
, sysfs
);
1304 if (!udev_device_has_tag(d
, "seat"))
1307 id_for_seat
= udev_device_get_property_value(d
, "ID_FOR_SEAT");
1311 if (asprintf(&file
, "/etc/udev/rules.d/72-seat-%s.rules", id_for_seat
) < 0)
1314 if (asprintf(&rule
, "TAG==\"seat\", ENV{ID_FOR_SEAT}==\"%s\", ENV{ID_SEAT}=\"%s\"", id_for_seat
, seat
) < 0)
1317 mkdir_p_label("/etc/udev/rules.d", 0755);
1318 r
= write_string_file_atomic_label(file
, rule
);
1322 return trigger_device(m
, d
);
1325 static int flush_devices(Manager
*m
) {
1326 _cleanup_closedir_
DIR *d
;
1330 d
= opendir("/etc/udev/rules.d");
1332 if (errno
!= ENOENT
)
1333 log_warning_errno(errno
, "Failed to open /etc/udev/rules.d: %m");
1337 FOREACH_DIRENT_ALL(de
, d
, break) {
1338 if (!dirent_is_file(de
))
1341 if (!startswith(de
->d_name
, "72-seat-"))
1344 if (!endswith(de
->d_name
, ".rules"))
1347 if (unlinkat(dirfd(d
), de
->d_name
, 0) < 0)
1348 log_warning_errno(errno
, "Failed to unlink %s: %m", de
->d_name
);
1352 return trigger_device(m
, NULL
);
1355 static int method_attach_device(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1356 const char *sysfs
, *seat
;
1357 Manager
*m
= userdata
;
1363 r
= sd_bus_message_read(message
, "ssb", &seat
, &sysfs
, &interactive
);
1367 if (!path_startswith(sysfs
, "/sys"))
1368 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Path %s is not in /sys", sysfs
);
1370 if (!seat_name_is_valid(seat
))
1371 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Seat %s is not valid", seat
);
1373 r
= bus_verify_polkit_async(
1376 "org.freedesktop.login1.attach-device",
1380 &m
->polkit_registry
,
1385 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1387 r
= attach_device(m
, seat
, sysfs
);
1391 return sd_bus_reply_method_return(message
, NULL
);
1394 static int method_flush_devices(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1395 Manager
*m
= userdata
;
1401 r
= sd_bus_message_read(message
, "b", &interactive
);
1405 r
= bus_verify_polkit_async(
1408 "org.freedesktop.login1.flush-devices",
1412 &m
->polkit_registry
,
1417 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1419 r
= flush_devices(m
);
1423 return sd_bus_reply_method_return(message
, NULL
);
1426 static int have_multiple_sessions(
1435 /* Check for other users' sessions. Greeter sessions do not
1436 * count, and non-login sessions do not count either. */
1437 HASHMAP_FOREACH(session
, m
->sessions
, i
)
1438 if (session
->class == SESSION_USER
&&
1439 session
->user
->uid
!= uid
)
1445 static int bus_manager_log_shutdown(
1447 const char *unit_name
) {
1454 if (streq(unit_name
, SPECIAL_POWEROFF_TARGET
)) {
1455 p
= "MESSAGE=System is powering down";
1456 q
= "SHUTDOWN=power-off";
1457 } else if (streq(unit_name
, SPECIAL_REBOOT_TARGET
)) {
1458 p
= "MESSAGE=System is rebooting";
1459 q
= "SHUTDOWN=reboot";
1460 } else if (streq(unit_name
, SPECIAL_HALT_TARGET
)) {
1461 p
= "MESSAGE=System is halting";
1462 q
= "SHUTDOWN=halt";
1463 } else if (streq(unit_name
, SPECIAL_KEXEC_TARGET
)) {
1464 p
= "MESSAGE=System is rebooting with kexec";
1465 q
= "SHUTDOWN=kexec";
1467 p
= "MESSAGE=System is shutting down";
1471 if (isempty(m
->wall_message
))
1472 p
= strjoina(p
, ".");
1474 p
= strjoina(p
, " (", m
->wall_message
, ").");
1476 return log_struct(LOG_NOTICE
,
1477 "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_STR
,
1483 static int lid_switch_ignore_handler(sd_event_source
*e
, uint64_t usec
, void *userdata
) {
1484 Manager
*m
= userdata
;
1489 m
->lid_switch_ignore_event_source
= sd_event_source_unref(m
->lid_switch_ignore_event_source
);
1493 int manager_set_lid_switch_ignore(Manager
*m
, usec_t until
) {
1498 if (until
<= now(CLOCK_MONOTONIC
))
1501 /* We want to ignore the lid switch for a while after each
1502 * suspend, and after boot-up. Hence let's install a timer for
1503 * this. As long as the event source exists we ignore the lid
1506 if (m
->lid_switch_ignore_event_source
) {
1509 r
= sd_event_source_get_time(m
->lid_switch_ignore_event_source
, &u
);
1516 r
= sd_event_source_set_time(m
->lid_switch_ignore_event_source
, until
);
1518 r
= sd_event_add_time(
1520 &m
->lid_switch_ignore_event_source
,
1523 lid_switch_ignore_handler
, m
);
1528 static int send_prepare_for(Manager
*m
, InhibitWhat w
, bool _active
) {
1530 static const char * const signal_name
[_INHIBIT_WHAT_MAX
] = {
1531 [INHIBIT_SHUTDOWN
] = "PrepareForShutdown",
1532 [INHIBIT_SLEEP
] = "PrepareForSleep"
1535 int active
= _active
;
1539 assert(w
< _INHIBIT_WHAT_MAX
);
1540 assert(signal_name
[w
]);
1542 return sd_bus_emit_signal(m
->bus
,
1543 "/org/freedesktop/login1",
1544 "org.freedesktop.login1.Manager",
1550 static int execute_shutdown_or_sleep(
1553 const char *unit_name
,
1554 sd_bus_error
*error
) {
1556 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1563 assert(w
< _INHIBIT_WHAT_MAX
);
1566 if (w
== INHIBIT_SHUTDOWN
)
1567 bus_manager_log_shutdown(m
, unit_name
);
1569 r
= sd_bus_call_method(
1571 "org.freedesktop.systemd1",
1572 "/org/freedesktop/systemd1",
1573 "org.freedesktop.systemd1.Manager",
1577 "ss", unit_name
, "replace-irreversibly");
1581 r
= sd_bus_message_read(reply
, "o", &p
);
1591 m
->action_unit
= unit_name
;
1592 free(m
->action_job
);
1596 /* Make sure the lid switch is ignored for a while */
1597 manager_set_lid_switch_ignore(m
, now(CLOCK_MONOTONIC
) + m
->holdoff_timeout_usec
);
1602 /* Tell people that they now may take a lock again */
1603 send_prepare_for(m
, m
->action_what
, false);
1608 int manager_dispatch_delayed(Manager
*manager
, bool timeout
) {
1610 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1611 Inhibitor
*offending
= NULL
;
1616 if (manager
->action_what
== 0 || manager
->action_job
)
1619 if (manager_is_inhibited(manager
, manager
->action_what
, INHIBIT_DELAY
, NULL
, false, false, 0, &offending
)) {
1620 _cleanup_free_
char *comm
= NULL
, *u
= NULL
;
1625 (void) get_process_comm(offending
->pid
, &comm
);
1626 u
= uid_to_name(offending
->uid
);
1628 log_notice("Delay lock is active (UID "UID_FMT
"/%s, PID "PID_FMT
"/%s) but inhibitor timeout is reached.",
1629 offending
->uid
, strna(u
),
1630 offending
->pid
, strna(comm
));
1633 /* Actually do the operation */
1634 r
= execute_shutdown_or_sleep(manager
, manager
->action_what
, manager
->action_unit
, &error
);
1636 log_warning("Error during inhibitor-delayed operation (already returned success to client): %s",
1637 bus_error_message(&error
, r
));
1639 manager
->action_unit
= NULL
;
1640 manager
->action_what
= 0;
1647 static int manager_inhibit_timeout_handler(
1652 Manager
*manager
= userdata
;
1656 assert(manager
->inhibit_timeout_source
== s
);
1658 r
= manager_dispatch_delayed(manager
, true);
1659 return (r
< 0) ? r
: 0;
1662 static int delay_shutdown_or_sleep(
1665 const char *unit_name
) {
1672 assert(w
< _INHIBIT_WHAT_MAX
);
1675 timeout_val
= now(CLOCK_MONOTONIC
) + m
->inhibit_delay_max
;
1677 if (m
->inhibit_timeout_source
) {
1678 r
= sd_event_source_set_time(m
->inhibit_timeout_source
, timeout_val
);
1680 return log_error_errno(r
, "sd_event_source_set_time() failed: %m");
1682 r
= sd_event_source_set_enabled(m
->inhibit_timeout_source
, SD_EVENT_ONESHOT
);
1684 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
1686 r
= sd_event_add_time(m
->event
, &m
->inhibit_timeout_source
, CLOCK_MONOTONIC
,
1687 timeout_val
, 0, manager_inhibit_timeout_handler
, m
);
1692 m
->action_unit
= unit_name
;
1698 int bus_manager_shutdown_or_sleep_now_or_later(
1700 const char *unit_name
,
1702 sd_bus_error
*error
) {
1710 assert(w
<= _INHIBIT_WHAT_MAX
);
1711 assert(!m
->action_job
);
1713 /* Tell everybody to prepare for shutdown/sleep */
1714 send_prepare_for(m
, w
, true);
1717 m
->inhibit_delay_max
> 0 &&
1718 manager_is_inhibited(m
, w
, INHIBIT_DELAY
, NULL
, false, false, 0, NULL
);
1721 /* Shutdown is delayed, keep in mind what we
1722 * want to do, and start a timeout */
1723 r
= delay_shutdown_or_sleep(m
, w
, unit_name
);
1725 /* Shutdown is not delayed, execute it
1727 r
= execute_shutdown_or_sleep(m
, w
, unit_name
, error
);
1732 static int verify_shutdown_creds(
1734 sd_bus_message
*message
,
1738 const char *action_multiple_sessions
,
1739 const char *action_ignore_inhibit
,
1740 sd_bus_error
*error
) {
1742 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
1743 bool multiple_sessions
, blocked
;
1750 assert(w
<= _INHIBIT_WHAT_MAX
);
1752 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
, &creds
);
1756 r
= sd_bus_creds_get_euid(creds
, &uid
);
1760 r
= have_multiple_sessions(m
, uid
);
1764 multiple_sessions
= r
> 0;
1765 blocked
= manager_is_inhibited(m
, w
, INHIBIT_BLOCK
, NULL
, false, true, uid
, NULL
);
1767 if (multiple_sessions
&& action_multiple_sessions
) {
1768 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action_multiple_sessions
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1772 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1775 if (blocked
&& action_ignore_inhibit
) {
1776 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action_ignore_inhibit
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1780 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1783 if (!multiple_sessions
&& !blocked
&& action
) {
1784 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1788 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1794 static int method_do_shutdown_or_sleep(
1796 sd_bus_message
*message
,
1797 const char *unit_name
,
1800 const char *action_multiple_sessions
,
1801 const char *action_ignore_inhibit
,
1802 const char *sleep_verb
,
1803 sd_bus_error
*error
) {
1811 assert(w
<= _INHIBIT_WHAT_MAX
);
1813 r
= sd_bus_message_read(message
, "b", &interactive
);
1817 /* Don't allow multiple jobs being executed at the same time */
1819 return sd_bus_error_setf(error
, BUS_ERROR_OPERATION_IN_PROGRESS
, "There's already a shutdown or sleep operation in progress");
1822 r
= can_sleep(sleep_verb
);
1827 return sd_bus_error_setf(error
, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED
, "Sleep verb not supported");
1830 r
= verify_shutdown_creds(m
, message
, w
, interactive
, action
, action_multiple_sessions
,
1831 action_ignore_inhibit
, error
);
1835 r
= bus_manager_shutdown_or_sleep_now_or_later(m
, unit_name
, w
, error
);
1839 return sd_bus_reply_method_return(message
, NULL
);
1842 static int method_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1843 Manager
*m
= userdata
;
1845 return method_do_shutdown_or_sleep(
1847 SPECIAL_POWEROFF_TARGET
,
1849 "org.freedesktop.login1.power-off",
1850 "org.freedesktop.login1.power-off-multiple-sessions",
1851 "org.freedesktop.login1.power-off-ignore-inhibit",
1856 static int method_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1857 Manager
*m
= userdata
;
1859 return method_do_shutdown_or_sleep(
1861 SPECIAL_REBOOT_TARGET
,
1863 "org.freedesktop.login1.reboot",
1864 "org.freedesktop.login1.reboot-multiple-sessions",
1865 "org.freedesktop.login1.reboot-ignore-inhibit",
1870 static int method_halt(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1871 Manager
*m
= userdata
;
1873 return method_do_shutdown_or_sleep(
1875 SPECIAL_HALT_TARGET
,
1877 "org.freedesktop.login1.halt",
1878 "org.freedesktop.login1.halt-multiple-sessions",
1879 "org.freedesktop.login1.halt-ignore-inhibit",
1884 static int method_suspend(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1885 Manager
*m
= userdata
;
1887 return method_do_shutdown_or_sleep(
1889 SPECIAL_SUSPEND_TARGET
,
1891 "org.freedesktop.login1.suspend",
1892 "org.freedesktop.login1.suspend-multiple-sessions",
1893 "org.freedesktop.login1.suspend-ignore-inhibit",
1898 static int method_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1899 Manager
*m
= userdata
;
1901 return method_do_shutdown_or_sleep(
1903 SPECIAL_HIBERNATE_TARGET
,
1905 "org.freedesktop.login1.hibernate",
1906 "org.freedesktop.login1.hibernate-multiple-sessions",
1907 "org.freedesktop.login1.hibernate-ignore-inhibit",
1912 static int method_hybrid_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1913 Manager
*m
= userdata
;
1915 return method_do_shutdown_or_sleep(
1917 SPECIAL_HYBRID_SLEEP_TARGET
,
1919 "org.freedesktop.login1.hibernate",
1920 "org.freedesktop.login1.hibernate-multiple-sessions",
1921 "org.freedesktop.login1.hibernate-ignore-inhibit",
1926 static int nologin_timeout_handler(
1931 Manager
*m
= userdata
;
1934 log_info("Creating /run/nologin, blocking further logins...");
1936 r
= write_string_file_atomic_label("/run/nologin", "System is going down.");
1938 log_error_errno(r
, "Failed to create /run/nologin: %m");
1940 m
->unlink_nologin
= true;
1945 static int update_schedule_file(Manager
*m
) {
1946 _cleanup_free_
char *temp_path
= NULL
;
1947 _cleanup_fclose_
FILE *f
= NULL
;
1952 r
= mkdir_safe_label("/run/systemd/shutdown", 0755, 0, 0, false);
1954 return log_error_errno(r
, "Failed to create shutdown subdirectory: %m");
1956 r
= fopen_temporary("/run/systemd/shutdown/scheduled", &f
, &temp_path
);
1958 return log_error_errno(r
, "Failed to save information about scheduled shutdowns: %m");
1960 (void) fchmod(fileno(f
), 0644);
1966 m
->scheduled_shutdown_timeout
,
1967 m
->enable_wall_messages
,
1968 m
->scheduled_shutdown_type
);
1970 if (!isempty(m
->wall_message
)) {
1971 _cleanup_free_
char *t
;
1973 t
= cescape(m
->wall_message
);
1979 fprintf(f
, "WALL_MESSAGE=%s\n", t
);
1982 r
= fflush_and_check(f
);
1986 if (rename(temp_path
, "/run/systemd/shutdown/scheduled") < 0) {
1994 (void) unlink(temp_path
);
1995 (void) unlink("/run/systemd/shutdown/scheduled");
1997 return log_error_errno(r
, "Failed to write information about scheduled shutdowns: %m");
2000 static void reset_scheduled_shutdown(Manager
*m
) {
2003 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
2004 m
->wall_message_timeout_source
= sd_event_source_unref(m
->wall_message_timeout_source
);
2005 m
->nologin_timeout_source
= sd_event_source_unref(m
->nologin_timeout_source
);
2007 m
->scheduled_shutdown_type
= mfree(m
->scheduled_shutdown_type
);
2008 m
->scheduled_shutdown_timeout
= 0;
2009 m
->shutdown_dry_run
= false;
2011 if (m
->unlink_nologin
) {
2012 (void) unlink("/run/nologin");
2013 m
->unlink_nologin
= false;
2016 (void) unlink("/run/systemd/shutdown/scheduled");
2019 static int manager_scheduled_shutdown_handler(
2024 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
2025 Manager
*m
= userdata
;
2031 if (isempty(m
->scheduled_shutdown_type
))
2034 if (streq(m
->scheduled_shutdown_type
, "poweroff"))
2035 target
= SPECIAL_POWEROFF_TARGET
;
2036 else if (streq(m
->scheduled_shutdown_type
, "reboot"))
2037 target
= SPECIAL_REBOOT_TARGET
;
2038 else if (streq(m
->scheduled_shutdown_type
, "halt"))
2039 target
= SPECIAL_HALT_TARGET
;
2041 assert_not_reached("unexpected shutdown type");
2043 /* Don't allow multiple jobs being executed at the same time */
2044 if (m
->action_what
) {
2046 log_error("Scheduled shutdown to %s failed: shutdown or sleep operation already in progress", target
);
2050 if (m
->shutdown_dry_run
) {
2051 /* We do not process delay inhibitors here. Otherwise, we
2052 * would have to be considered "in progress" (like the check
2053 * above) for some seconds after our admin has seen the final
2056 bus_manager_log_shutdown(m
, target
);
2057 log_info("Running in dry run, suppressing action.");
2058 reset_scheduled_shutdown(m
);
2063 r
= bus_manager_shutdown_or_sleep_now_or_later(m
, target
, INHIBIT_SHUTDOWN
, &error
);
2065 log_error_errno(r
, "Scheduled shutdown to %s failed: %m", target
);
2072 reset_scheduled_shutdown(m
);
2076 static int method_schedule_shutdown(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2077 Manager
*m
= userdata
;
2078 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2079 const char *action_multiple_sessions
= NULL
;
2080 const char *action_ignore_inhibit
= NULL
;
2081 const char *action
= NULL
;
2085 bool dry_run
= false;
2090 r
= sd_bus_message_read(message
, "st", &type
, &elapse
);
2094 if (startswith(type
, "dry-")) {
2099 if (streq(type
, "poweroff")) {
2100 action
= "org.freedesktop.login1.power-off";
2101 action_multiple_sessions
= "org.freedesktop.login1.power-off-multiple-sessions";
2102 action_ignore_inhibit
= "org.freedesktop.login1.power-off-ignore-inhibit";
2103 } else if (streq(type
, "reboot")) {
2104 action
= "org.freedesktop.login1.reboot";
2105 action_multiple_sessions
= "org.freedesktop.login1.reboot-multiple-sessions";
2106 action_ignore_inhibit
= "org.freedesktop.login1.reboot-ignore-inhibit";
2107 } else if (streq(type
, "halt")) {
2108 action
= "org.freedesktop.login1.halt";
2109 action_multiple_sessions
= "org.freedesktop.login1.halt-multiple-sessions";
2110 action_ignore_inhibit
= "org.freedesktop.login1.halt-ignore-inhibit";
2112 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Unsupported shutdown type");
2114 r
= verify_shutdown_creds(m
, message
, INHIBIT_SHUTDOWN
, false,
2115 action
, action_multiple_sessions
, action_ignore_inhibit
, error
);
2119 if (m
->scheduled_shutdown_timeout_source
) {
2120 r
= sd_event_source_set_time(m
->scheduled_shutdown_timeout_source
, elapse
);
2122 return log_error_errno(r
, "sd_event_source_set_time() failed: %m");
2124 r
= sd_event_source_set_enabled(m
->scheduled_shutdown_timeout_source
, SD_EVENT_ONESHOT
);
2126 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
2128 r
= sd_event_add_time(m
->event
, &m
->scheduled_shutdown_timeout_source
,
2129 CLOCK_REALTIME
, elapse
, 0, manager_scheduled_shutdown_handler
, m
);
2131 return log_error_errno(r
, "sd_event_add_time() failed: %m");
2134 r
= free_and_strdup(&m
->scheduled_shutdown_type
, type
);
2136 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
2140 m
->shutdown_dry_run
= dry_run
;
2142 if (m
->nologin_timeout_source
) {
2143 r
= sd_event_source_set_time(m
->nologin_timeout_source
, elapse
);
2145 return log_error_errno(r
, "sd_event_source_set_time() failed: %m");
2147 r
= sd_event_source_set_enabled(m
->nologin_timeout_source
, SD_EVENT_ONESHOT
);
2149 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
2151 r
= sd_event_add_time(m
->event
, &m
->nologin_timeout_source
,
2152 CLOCK_REALTIME
, elapse
- 5 * USEC_PER_MINUTE
, 0, nologin_timeout_handler
, m
);
2154 return log_error_errno(r
, "sd_event_add_time() failed: %m");
2157 m
->scheduled_shutdown_timeout
= elapse
;
2159 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_AUGMENT
|SD_BUS_CREDS_TTY
|SD_BUS_CREDS_UID
, &creds
);
2161 const char *tty
= NULL
;
2163 (void) sd_bus_creds_get_uid(creds
, &m
->scheduled_shutdown_uid
);
2164 (void) sd_bus_creds_get_tty(creds
, &tty
);
2166 r
= free_and_strdup(&m
->scheduled_shutdown_tty
, tty
);
2168 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
2173 r
= manager_setup_wall_message_timer(m
);
2177 r
= update_schedule_file(m
);
2181 return sd_bus_reply_method_return(message
, NULL
);
2184 static int method_cancel_scheduled_shutdown(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2185 Manager
*m
= userdata
;
2191 cancelled
= m
->scheduled_shutdown_type
!= NULL
;
2192 reset_scheduled_shutdown(m
);
2195 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2196 const char *tty
= NULL
;
2200 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_AUGMENT
|SD_BUS_CREDS_TTY
|SD_BUS_CREDS_UID
, &creds
);
2202 (void) sd_bus_creds_get_uid(creds
, &uid
);
2203 (void) sd_bus_creds_get_tty(creds
, &tty
);
2206 utmp_wall("The system shutdown has been cancelled",
2207 uid_to_name(uid
), tty
, logind_wall_tty_filter
, m
);
2210 return sd_bus_reply_method_return(message
, "b", cancelled
);
2213 static int method_can_shutdown_or_sleep(
2215 sd_bus_message
*message
,
2218 const char *action_multiple_sessions
,
2219 const char *action_ignore_inhibit
,
2220 const char *sleep_verb
,
2221 sd_bus_error
*error
) {
2223 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2224 bool multiple_sessions
, challenge
, blocked
;
2225 const char *result
= NULL
;
2232 assert(w
<= _INHIBIT_WHAT_MAX
);
2234 assert(action_multiple_sessions
);
2235 assert(action_ignore_inhibit
);
2238 r
= can_sleep(sleep_verb
);
2242 return sd_bus_reply_method_return(message
, "s", "na");
2245 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
, &creds
);
2249 r
= sd_bus_creds_get_euid(creds
, &uid
);
2253 r
= have_multiple_sessions(m
, uid
);
2257 multiple_sessions
= r
> 0;
2258 blocked
= manager_is_inhibited(m
, w
, INHIBIT_BLOCK
, NULL
, false, true, uid
, NULL
);
2260 if (multiple_sessions
) {
2261 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action_multiple_sessions
, NULL
, UID_INVALID
, &challenge
, error
);
2268 result
= "challenge";
2274 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action_ignore_inhibit
, NULL
, UID_INVALID
, &challenge
, error
);
2278 if (r
> 0 && !result
)
2280 else if (challenge
&& (!result
|| streq(result
, "yes")))
2281 result
= "challenge";
2286 if (!multiple_sessions
&& !blocked
) {
2287 /* If neither inhibit nor multiple sessions
2288 * apply then just check the normal policy */
2290 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action
, NULL
, UID_INVALID
, &challenge
, error
);
2297 result
= "challenge";
2302 return sd_bus_reply_method_return(message
, "s", result
);
2305 static int method_can_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2306 Manager
*m
= userdata
;
2308 return method_can_shutdown_or_sleep(
2311 "org.freedesktop.login1.power-off",
2312 "org.freedesktop.login1.power-off-multiple-sessions",
2313 "org.freedesktop.login1.power-off-ignore-inhibit",
2318 static int method_can_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2319 Manager
*m
= userdata
;
2321 return method_can_shutdown_or_sleep(
2324 "org.freedesktop.login1.reboot",
2325 "org.freedesktop.login1.reboot-multiple-sessions",
2326 "org.freedesktop.login1.reboot-ignore-inhibit",
2331 static int method_can_halt(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2332 Manager
*m
= userdata
;
2334 return method_can_shutdown_or_sleep(
2337 "org.freedesktop.login1.halt",
2338 "org.freedesktop.login1.halt-multiple-sessions",
2339 "org.freedesktop.login1.halt-ignore-inhibit",
2344 static int method_can_suspend(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2345 Manager
*m
= userdata
;
2347 return method_can_shutdown_or_sleep(
2350 "org.freedesktop.login1.suspend",
2351 "org.freedesktop.login1.suspend-multiple-sessions",
2352 "org.freedesktop.login1.suspend-ignore-inhibit",
2357 static int method_can_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2358 Manager
*m
= userdata
;
2360 return method_can_shutdown_or_sleep(
2363 "org.freedesktop.login1.hibernate",
2364 "org.freedesktop.login1.hibernate-multiple-sessions",
2365 "org.freedesktop.login1.hibernate-ignore-inhibit",
2370 static int method_can_hybrid_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2371 Manager
*m
= userdata
;
2373 return method_can_shutdown_or_sleep(
2376 "org.freedesktop.login1.hibernate",
2377 "org.freedesktop.login1.hibernate-multiple-sessions",
2378 "org.freedesktop.login1.hibernate-ignore-inhibit",
2383 static int property_get_reboot_to_firmware_setup(
2386 const char *interface
,
2387 const char *property
,
2388 sd_bus_message
*reply
,
2390 sd_bus_error
*error
) {
2397 r
= efi_get_reboot_to_firmware();
2398 if (r
< 0 && r
!= -EOPNOTSUPP
)
2401 return sd_bus_message_append(reply
, "b", r
> 0);
2404 static int method_set_reboot_to_firmware_setup(
2405 sd_bus_message
*message
,
2407 sd_bus_error
*error
) {
2410 Manager
*m
= userdata
;
2415 r
= sd_bus_message_read(message
, "b", &b
);
2419 r
= bus_verify_polkit_async(message
,
2421 "org.freedesktop.login1.set-reboot-to-firmware-setup",
2425 &m
->polkit_registry
,
2430 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2432 r
= efi_set_reboot_to_firmware(b
);
2436 return sd_bus_reply_method_return(message
, NULL
);
2439 static int method_can_reboot_to_firmware_setup(
2440 sd_bus_message
*message
,
2442 sd_bus_error
*error
) {
2447 Manager
*m
= userdata
;
2452 r
= efi_reboot_to_firmware_supported();
2453 if (r
== -EOPNOTSUPP
)
2454 return sd_bus_reply_method_return(message
, "s", "na");
2458 r
= bus_test_polkit(message
,
2460 "org.freedesktop.login1.set-reboot-to-firmware-setup",
2471 result
= "challenge";
2475 return sd_bus_reply_method_return(message
, "s", result
);
2478 static int method_set_wall_message(
2479 sd_bus_message
*message
,
2481 sd_bus_error
*error
) {
2484 Manager
*m
= userdata
;
2486 int enable_wall_messages
;
2491 r
= sd_bus_message_read(message
, "sb", &wall_message
, &enable_wall_messages
);
2495 r
= bus_verify_polkit_async(message
,
2497 "org.freedesktop.login1.set-wall-message",
2501 &m
->polkit_registry
,
2506 return 1; /* Will call us back */
2508 r
= free_and_strdup(&m
->wall_message
, empty_to_null(wall_message
));
2512 m
->enable_wall_messages
= enable_wall_messages
;
2514 return sd_bus_reply_method_return(message
, NULL
);
2517 static int method_inhibit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2518 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2519 const char *who
, *why
, *what
, *mode
;
2520 _cleanup_free_
char *id
= NULL
;
2521 _cleanup_close_
int fifo_fd
= -1;
2522 Manager
*m
= userdata
;
2523 Inhibitor
*i
= NULL
;
2533 r
= sd_bus_message_read(message
, "ssss", &what
, &who
, &why
, &mode
);
2537 w
= inhibit_what_from_string(what
);
2539 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid what specification %s", what
);
2541 mm
= inhibit_mode_from_string(mode
);
2543 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid mode specification %s", mode
);
2545 /* Delay is only supported for shutdown/sleep */
2546 if (mm
== INHIBIT_DELAY
&& (w
& ~(INHIBIT_SHUTDOWN
|INHIBIT_SLEEP
)))
2547 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Delay inhibitors only supported for shutdown and sleep");
2549 /* Don't allow taking delay locks while we are already
2550 * executing the operation. We shouldn't create the impression
2551 * that the lock was successful if the machine is about to go
2552 * down/suspend any moment. */
2553 if (m
->action_what
& w
)
2554 return sd_bus_error_setf(error
, BUS_ERROR_OPERATION_IN_PROGRESS
, "The operation inhibition has been requested for is already running");
2556 r
= bus_verify_polkit_async(
2559 w
== INHIBIT_SHUTDOWN
? (mm
== INHIBIT_BLOCK
? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
2560 w
== INHIBIT_SLEEP
? (mm
== INHIBIT_BLOCK
? "org.freedesktop.login1.inhibit-block-sleep" : "org.freedesktop.login1.inhibit-delay-sleep") :
2561 w
== INHIBIT_IDLE
? "org.freedesktop.login1.inhibit-block-idle" :
2562 w
== INHIBIT_HANDLE_POWER_KEY
? "org.freedesktop.login1.inhibit-handle-power-key" :
2563 w
== INHIBIT_HANDLE_SUSPEND_KEY
? "org.freedesktop.login1.inhibit-handle-suspend-key" :
2564 w
== INHIBIT_HANDLE_HIBERNATE_KEY
? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
2565 "org.freedesktop.login1.inhibit-handle-lid-switch",
2569 &m
->polkit_registry
,
2574 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2576 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
|SD_BUS_CREDS_PID
, &creds
);
2580 r
= sd_bus_creds_get_euid(creds
, &uid
);
2584 r
= sd_bus_creds_get_pid(creds
, &pid
);
2588 if (hashmap_size(m
->inhibitors
) >= m
->inhibitors_max
)
2589 return sd_bus_error_setf(error
, SD_BUS_ERROR_LIMITS_EXCEEDED
, "Maximum number of inhibitors (%" PRIu64
") reached, refusing further inhibitors.", m
->inhibitors_max
);
2594 if (asprintf(&id
, "%lu", ++m
->inhibit_counter
) < 0)
2597 } while (hashmap_get(m
->inhibitors
, id
));
2599 r
= manager_add_inhibitor(m
, id
, &i
);
2607 i
->why
= strdup(why
);
2608 i
->who
= strdup(who
);
2610 if (!i
->why
|| !i
->who
) {
2615 fifo_fd
= inhibitor_create_fifo(i
);
2623 return sd_bus_reply_method_return(message
, "h", fifo_fd
);
2632 const sd_bus_vtable manager_vtable
[] = {
2633 SD_BUS_VTABLE_START(0),
2635 SD_BUS_WRITABLE_PROPERTY("EnableWallMessages", "b", NULL
, NULL
, offsetof(Manager
, enable_wall_messages
), 0),
2636 SD_BUS_WRITABLE_PROPERTY("WallMessage", "s", NULL
, NULL
, offsetof(Manager
, wall_message
), 0),
2638 SD_BUS_PROPERTY("NAutoVTs", "u", NULL
, offsetof(Manager
, n_autovts
), SD_BUS_VTABLE_PROPERTY_CONST
),
2639 SD_BUS_PROPERTY("KillOnlyUsers", "as", NULL
, offsetof(Manager
, kill_only_users
), SD_BUS_VTABLE_PROPERTY_CONST
),
2640 SD_BUS_PROPERTY("KillExcludeUsers", "as", NULL
, offsetof(Manager
, kill_exclude_users
), SD_BUS_VTABLE_PROPERTY_CONST
),
2641 SD_BUS_PROPERTY("KillUserProcesses", "b", NULL
, offsetof(Manager
, kill_user_processes
), SD_BUS_VTABLE_PROPERTY_CONST
),
2642 SD_BUS_PROPERTY("RebootToFirmwareSetup", "b", property_get_reboot_to_firmware_setup
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2643 SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2644 SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2645 SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2646 SD_BUS_PROPERTY("BlockInhibited", "s", property_get_inhibited
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2647 SD_BUS_PROPERTY("DelayInhibited", "s", property_get_inhibited
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2648 SD_BUS_PROPERTY("InhibitDelayMaxUSec", "t", NULL
, offsetof(Manager
, inhibit_delay_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
2649 SD_BUS_PROPERTY("HandlePowerKey", "s", property_get_handle_action
, offsetof(Manager
, handle_power_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
2650 SD_BUS_PROPERTY("HandleSuspendKey", "s", property_get_handle_action
, offsetof(Manager
, handle_suspend_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
2651 SD_BUS_PROPERTY("HandleHibernateKey", "s", property_get_handle_action
, offsetof(Manager
, handle_hibernate_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
2652 SD_BUS_PROPERTY("HandleLidSwitch", "s", property_get_handle_action
, offsetof(Manager
, handle_lid_switch
), SD_BUS_VTABLE_PROPERTY_CONST
),
2653 SD_BUS_PROPERTY("HandleLidSwitchDocked", "s", property_get_handle_action
, offsetof(Manager
, handle_lid_switch_docked
), SD_BUS_VTABLE_PROPERTY_CONST
),
2654 SD_BUS_PROPERTY("HoldoffTimeoutUSec", "t", NULL
, offsetof(Manager
, holdoff_timeout_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2655 SD_BUS_PROPERTY("IdleAction", "s", property_get_handle_action
, offsetof(Manager
, idle_action
), SD_BUS_VTABLE_PROPERTY_CONST
),
2656 SD_BUS_PROPERTY("IdleActionUSec", "t", NULL
, offsetof(Manager
, idle_action_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2657 SD_BUS_PROPERTY("PreparingForShutdown", "b", property_get_preparing
, 0, 0),
2658 SD_BUS_PROPERTY("PreparingForSleep", "b", property_get_preparing
, 0, 0),
2659 SD_BUS_PROPERTY("ScheduledShutdown", "(st)", property_get_scheduled_shutdown
, 0, 0),
2660 SD_BUS_PROPERTY("Docked", "b", property_get_docked
, 0, 0),
2661 SD_BUS_PROPERTY("RemoveIPC", "b", bus_property_get_bool
, offsetof(Manager
, remove_ipc
), SD_BUS_VTABLE_PROPERTY_CONST
),
2662 SD_BUS_PROPERTY("RuntimeDirectorySize", "t", bus_property_get_size
, offsetof(Manager
, runtime_dir_size
), SD_BUS_VTABLE_PROPERTY_CONST
),
2663 SD_BUS_PROPERTY("InhibitorsMax", "t", NULL
, offsetof(Manager
, inhibitors_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
2664 SD_BUS_PROPERTY("NCurrentInhibitors", "t", property_get_current_inhibitors
, 0, 0),
2665 SD_BUS_PROPERTY("SessionsMax", "t", NULL
, offsetof(Manager
, sessions_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
2666 SD_BUS_PROPERTY("NCurrentSessions", "t", property_get_current_sessions
, 0, 0),
2667 SD_BUS_PROPERTY("UserTasksMax", "t", NULL
, offsetof(Manager
, user_tasks_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
2669 SD_BUS_METHOD("GetSession", "s", "o", method_get_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2670 SD_BUS_METHOD("GetSessionByPID", "u", "o", method_get_session_by_pid
, SD_BUS_VTABLE_UNPRIVILEGED
),
2671 SD_BUS_METHOD("GetUser", "u", "o", method_get_user
, SD_BUS_VTABLE_UNPRIVILEGED
),
2672 SD_BUS_METHOD("GetUserByPID", "u", "o", method_get_user_by_pid
, SD_BUS_VTABLE_UNPRIVILEGED
),
2673 SD_BUS_METHOD("GetSeat", "s", "o", method_get_seat
, SD_BUS_VTABLE_UNPRIVILEGED
),
2674 SD_BUS_METHOD("ListSessions", NULL
, "a(susso)", method_list_sessions
, SD_BUS_VTABLE_UNPRIVILEGED
),
2675 SD_BUS_METHOD("ListUsers", NULL
, "a(uso)", method_list_users
, SD_BUS_VTABLE_UNPRIVILEGED
),
2676 SD_BUS_METHOD("ListSeats", NULL
, "a(so)", method_list_seats
, SD_BUS_VTABLE_UNPRIVILEGED
),
2677 SD_BUS_METHOD("ListInhibitors", NULL
, "a(ssssuu)", method_list_inhibitors
, SD_BUS_VTABLE_UNPRIVILEGED
),
2678 SD_BUS_METHOD("CreateSession", "uusssssussbssa(sv)", "soshusub", method_create_session
, 0),
2679 SD_BUS_METHOD("ReleaseSession", "s", NULL
, method_release_session
, 0),
2680 SD_BUS_METHOD("ActivateSession", "s", NULL
, method_activate_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2681 SD_BUS_METHOD("ActivateSessionOnSeat", "ss", NULL
, method_activate_session_on_seat
, SD_BUS_VTABLE_UNPRIVILEGED
),
2682 SD_BUS_METHOD("LockSession", "s", NULL
, method_lock_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2683 SD_BUS_METHOD("UnlockSession", "s", NULL
, method_lock_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2684 SD_BUS_METHOD("LockSessions", NULL
, NULL
, method_lock_sessions
, SD_BUS_VTABLE_UNPRIVILEGED
),
2685 SD_BUS_METHOD("UnlockSessions", NULL
, NULL
, method_lock_sessions
, SD_BUS_VTABLE_UNPRIVILEGED
),
2686 SD_BUS_METHOD("KillSession", "ssi", NULL
, method_kill_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2687 SD_BUS_METHOD("KillUser", "ui", NULL
, method_kill_user
, SD_BUS_VTABLE_UNPRIVILEGED
),
2688 SD_BUS_METHOD("TerminateSession", "s", NULL
, method_terminate_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2689 SD_BUS_METHOD("TerminateUser", "u", NULL
, method_terminate_user
, SD_BUS_VTABLE_UNPRIVILEGED
),
2690 SD_BUS_METHOD("TerminateSeat", "s", NULL
, method_terminate_seat
, SD_BUS_VTABLE_UNPRIVILEGED
),
2691 SD_BUS_METHOD("SetUserLinger", "ubb", NULL
, method_set_user_linger
, SD_BUS_VTABLE_UNPRIVILEGED
),
2692 SD_BUS_METHOD("AttachDevice", "ssb", NULL
, method_attach_device
, SD_BUS_VTABLE_UNPRIVILEGED
),
2693 SD_BUS_METHOD("FlushDevices", "b", NULL
, method_flush_devices
, SD_BUS_VTABLE_UNPRIVILEGED
),
2694 SD_BUS_METHOD("PowerOff", "b", NULL
, method_poweroff
, SD_BUS_VTABLE_UNPRIVILEGED
),
2695 SD_BUS_METHOD("Reboot", "b", NULL
, method_reboot
, SD_BUS_VTABLE_UNPRIVILEGED
),
2696 SD_BUS_METHOD("Halt", "b", NULL
, method_halt
, SD_BUS_VTABLE_UNPRIVILEGED
),
2697 SD_BUS_METHOD("Suspend", "b", NULL
, method_suspend
, SD_BUS_VTABLE_UNPRIVILEGED
),
2698 SD_BUS_METHOD("Hibernate", "b", NULL
, method_hibernate
, SD_BUS_VTABLE_UNPRIVILEGED
),
2699 SD_BUS_METHOD("HybridSleep", "b", NULL
, method_hybrid_sleep
, SD_BUS_VTABLE_UNPRIVILEGED
),
2700 SD_BUS_METHOD("CanPowerOff", NULL
, "s", method_can_poweroff
, SD_BUS_VTABLE_UNPRIVILEGED
),
2701 SD_BUS_METHOD("CanReboot", NULL
, "s", method_can_reboot
, SD_BUS_VTABLE_UNPRIVILEGED
),
2702 SD_BUS_METHOD("CanHalt", NULL
, "s", method_can_halt
, SD_BUS_VTABLE_UNPRIVILEGED
),
2703 SD_BUS_METHOD("CanSuspend", NULL
, "s", method_can_suspend
, SD_BUS_VTABLE_UNPRIVILEGED
),
2704 SD_BUS_METHOD("CanHibernate", NULL
, "s", method_can_hibernate
, SD_BUS_VTABLE_UNPRIVILEGED
),
2705 SD_BUS_METHOD("CanHybridSleep", NULL
, "s", method_can_hybrid_sleep
, SD_BUS_VTABLE_UNPRIVILEGED
),
2706 SD_BUS_METHOD("ScheduleShutdown", "st", NULL
, method_schedule_shutdown
, SD_BUS_VTABLE_UNPRIVILEGED
),
2707 SD_BUS_METHOD("CancelScheduledShutdown", NULL
, "b", method_cancel_scheduled_shutdown
, SD_BUS_VTABLE_UNPRIVILEGED
),
2708 SD_BUS_METHOD("Inhibit", "ssss", "h", method_inhibit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2709 SD_BUS_METHOD("CanRebootToFirmwareSetup", NULL
, "s", method_can_reboot_to_firmware_setup
, SD_BUS_VTABLE_UNPRIVILEGED
),
2710 SD_BUS_METHOD("SetRebootToFirmwareSetup", "b", NULL
, method_set_reboot_to_firmware_setup
, SD_BUS_VTABLE_UNPRIVILEGED
),
2711 SD_BUS_METHOD("SetWallMessage", "sb", NULL
, method_set_wall_message
, SD_BUS_VTABLE_UNPRIVILEGED
),
2713 SD_BUS_SIGNAL("SessionNew", "so", 0),
2714 SD_BUS_SIGNAL("SessionRemoved", "so", 0),
2715 SD_BUS_SIGNAL("UserNew", "uo", 0),
2716 SD_BUS_SIGNAL("UserRemoved", "uo", 0),
2717 SD_BUS_SIGNAL("SeatNew", "so", 0),
2718 SD_BUS_SIGNAL("SeatRemoved", "so", 0),
2719 SD_BUS_SIGNAL("PrepareForShutdown", "b", 0),
2720 SD_BUS_SIGNAL("PrepareForSleep", "b", 0),
2725 static int session_jobs_reply(Session
*s
, const char *unit
, const char *result
) {
2734 if (streq(result
, "done"))
2735 r
= session_send_create_reply(s
, NULL
);
2737 _cleanup_(sd_bus_error_free
) sd_bus_error e
= SD_BUS_ERROR_NULL
;
2739 sd_bus_error_setf(&e
, BUS_ERROR_JOB_FAILED
, "Start job for unit %s failed with '%s'", unit
, result
);
2740 r
= session_send_create_reply(s
, &e
);
2746 int match_job_removed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2747 const char *path
, *result
, *unit
;
2748 Manager
*m
= userdata
;
2757 r
= sd_bus_message_read(message
, "uoss", &id
, &path
, &unit
, &result
);
2759 bus_log_parse_error(r
);
2763 if (m
->action_job
&& streq(m
->action_job
, path
)) {
2764 log_info("Operation '%s' finished.", inhibit_what_to_string(m
->action_what
));
2766 /* Tell people that they now may take a lock again */
2767 send_prepare_for(m
, m
->action_what
, false);
2769 m
->action_job
= mfree(m
->action_job
);
2770 m
->action_unit
= NULL
;
2775 session
= hashmap_get(m
->session_units
, unit
);
2776 if (session
&& streq_ptr(path
, session
->scope_job
)) {
2777 session
->scope_job
= mfree(session
->scope_job
);
2778 session_jobs_reply(session
, unit
, result
);
2780 session_save(session
);
2781 user_save(session
->user
);
2782 session_add_to_gc_queue(session
);
2785 user
= hashmap_get(m
->user_units
, unit
);
2787 (streq_ptr(path
, user
->service_job
) ||
2788 streq_ptr(path
, user
->slice_job
))) {
2790 if (streq_ptr(path
, user
->service_job
))
2791 user
->service_job
= mfree(user
->service_job
);
2793 if (streq_ptr(path
, user
->slice_job
))
2794 user
->slice_job
= mfree(user
->slice_job
);
2796 LIST_FOREACH(sessions_by_user
, session
, user
->sessions
)
2797 session_jobs_reply(session
, unit
, result
);
2800 user_add_to_gc_queue(user
);
2806 int match_unit_removed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2807 const char *path
, *unit
;
2808 Manager
*m
= userdata
;
2816 r
= sd_bus_message_read(message
, "so", &unit
, &path
);
2818 bus_log_parse_error(r
);
2822 session
= hashmap_get(m
->session_units
, unit
);
2824 session_add_to_gc_queue(session
);
2826 user
= hashmap_get(m
->user_units
, unit
);
2828 user_add_to_gc_queue(user
);
2833 int match_properties_changed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2834 _cleanup_free_
char *unit
= NULL
;
2835 Manager
*m
= userdata
;
2844 path
= sd_bus_message_get_path(message
);
2848 r
= unit_name_from_dbus_path(path
, &unit
);
2849 if (r
== -EINVAL
) /* not a unit */
2856 session
= hashmap_get(m
->session_units
, unit
);
2858 session_add_to_gc_queue(session
);
2860 user
= hashmap_get(m
->user_units
, unit
);
2862 user_add_to_gc_queue(user
);
2867 int match_reloading(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2868 Manager
*m
= userdata
;
2876 r
= sd_bus_message_read(message
, "b", &b
);
2878 bus_log_parse_error(r
);
2885 /* systemd finished reloading, let's recheck all our sessions */
2886 log_debug("System manager has been reloaded, rechecking sessions...");
2888 HASHMAP_FOREACH(session
, m
->sessions
, i
)
2889 session_add_to_gc_queue(session
);
2894 int manager_send_changed(Manager
*manager
, const char *property
, ...) {
2899 l
= strv_from_stdarg_alloca(property
);
2901 return sd_bus_emit_properties_changed_strv(
2903 "/org/freedesktop/login1",
2904 "org.freedesktop.login1.Manager",
2908 static int strdup_job(sd_bus_message
*reply
, char **job
) {
2913 r
= sd_bus_message_read(reply
, "o", &j
);
2925 int manager_start_slice(
2928 const char *description
,
2932 sd_bus_error
*error
,
2935 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
, *reply
= NULL
;
2942 r
= sd_bus_message_new_method_call(
2945 "org.freedesktop.systemd1",
2946 "/org/freedesktop/systemd1",
2947 "org.freedesktop.systemd1.Manager",
2948 "StartTransientUnit");
2952 r
= sd_bus_message_append(m
, "ss", strempty(slice
), "fail");
2956 r
= sd_bus_message_open_container(m
, 'a', "(sv)");
2960 if (!isempty(description
)) {
2961 r
= sd_bus_message_append(m
, "(sv)", "Description", "s", description
);
2966 if (!isempty(after
)) {
2967 r
= sd_bus_message_append(m
, "(sv)", "After", "as", 1, after
);
2972 if (!isempty(after2
)) {
2973 r
= sd_bus_message_append(m
, "(sv)", "After", "as", 1, after2
);
2978 r
= sd_bus_message_append(m
, "(sv)", "TasksMax", "t", tasks_max
);
2982 r
= sd_bus_message_close_container(m
);
2986 r
= sd_bus_message_append(m
, "a(sa(sv))", 0);
2990 r
= sd_bus_call(manager
->bus
, m
, 0, error
, &reply
);
2994 return strdup_job(reply
, job
);
2997 int manager_start_scope(
3002 const char *description
,
3006 sd_bus_error
*error
,
3009 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
, *reply
= NULL
;
3017 r
= sd_bus_message_new_method_call(
3020 "org.freedesktop.systemd1",
3021 "/org/freedesktop/systemd1",
3022 "org.freedesktop.systemd1.Manager",
3023 "StartTransientUnit");
3027 r
= sd_bus_message_append(m
, "ss", strempty(scope
), "fail");
3031 r
= sd_bus_message_open_container(m
, 'a', "(sv)");
3035 if (!isempty(slice
)) {
3036 r
= sd_bus_message_append(m
, "(sv)", "Slice", "s", slice
);
3041 if (!isempty(description
)) {
3042 r
= sd_bus_message_append(m
, "(sv)", "Description", "s", description
);
3047 if (!isempty(after
)) {
3048 r
= sd_bus_message_append(m
, "(sv)", "After", "as", 1, after
);
3053 if (!isempty(after2
)) {
3054 r
= sd_bus_message_append(m
, "(sv)", "After", "as", 1, after2
);
3059 /* cgroup empty notification is not available in containers
3060 * currently. To make this less problematic, let's shorten the
3061 * stop timeout for sessions, so that we don't wait
3064 /* Make sure that the session shells are terminated with
3065 * SIGHUP since bash and friends tend to ignore SIGTERM */
3066 r
= sd_bus_message_append(m
, "(sv)", "SendSIGHUP", "b", true);
3070 r
= sd_bus_message_append(m
, "(sv)", "PIDs", "au", 1, pid
);
3074 r
= sd_bus_message_append(m
, "(sv)", "TasksMax", "t", tasks_max
);
3078 r
= sd_bus_message_close_container(m
);
3082 r
= sd_bus_message_append(m
, "a(sa(sv))", 0);
3086 r
= sd_bus_call(manager
->bus
, m
, 0, error
, &reply
);
3090 return strdup_job(reply
, job
);
3093 int manager_start_unit(Manager
*manager
, const char *unit
, sd_bus_error
*error
, char **job
) {
3094 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
3101 r
= sd_bus_call_method(
3103 "org.freedesktop.systemd1",
3104 "/org/freedesktop/systemd1",
3105 "org.freedesktop.systemd1.Manager",
3109 "ss", unit
, "replace");
3113 return strdup_job(reply
, job
);
3116 int manager_stop_unit(Manager
*manager
, const char *unit
, sd_bus_error
*error
, char **job
) {
3117 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
3124 r
= sd_bus_call_method(
3126 "org.freedesktop.systemd1",
3127 "/org/freedesktop/systemd1",
3128 "org.freedesktop.systemd1.Manager",
3132 "ss", unit
, "fail");
3134 if (sd_bus_error_has_name(error
, BUS_ERROR_NO_SUCH_UNIT
) ||
3135 sd_bus_error_has_name(error
, BUS_ERROR_LOAD_FAILED
)) {
3138 sd_bus_error_free(error
);
3145 return strdup_job(reply
, job
);
3148 int manager_abandon_scope(Manager
*manager
, const char *scope
, sd_bus_error
*error
) {
3149 _cleanup_free_
char *path
= NULL
;
3155 path
= unit_dbus_path_from_name(scope
);
3159 r
= sd_bus_call_method(
3161 "org.freedesktop.systemd1",
3163 "org.freedesktop.systemd1.Scope",
3169 if (sd_bus_error_has_name(error
, BUS_ERROR_NO_SUCH_UNIT
) ||
3170 sd_bus_error_has_name(error
, BUS_ERROR_LOAD_FAILED
) ||
3171 sd_bus_error_has_name(error
, BUS_ERROR_SCOPE_NOT_RUNNING
)) {
3172 sd_bus_error_free(error
);
3182 int manager_kill_unit(Manager
*manager
, const char *unit
, KillWho who
, int signo
, sd_bus_error
*error
) {
3186 return sd_bus_call_method(
3188 "org.freedesktop.systemd1",
3189 "/org/freedesktop/systemd1",
3190 "org.freedesktop.systemd1.Manager",
3194 "ssi", unit
, who
== KILL_LEADER
? "main" : "all", signo
);
3197 int manager_unit_is_active(Manager
*manager
, const char *unit
) {
3198 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
3199 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
3200 _cleanup_free_
char *path
= NULL
;
3207 path
= unit_dbus_path_from_name(unit
);
3211 r
= sd_bus_get_property(
3213 "org.freedesktop.systemd1",
3215 "org.freedesktop.systemd1.Unit",
3221 /* systemd might have droppped off momentarily, let's
3222 * not make this an error */
3223 if (sd_bus_error_has_name(&error
, SD_BUS_ERROR_NO_REPLY
) ||
3224 sd_bus_error_has_name(&error
, SD_BUS_ERROR_DISCONNECTED
))
3227 /* If the unit is already unloaded then it's not
3229 if (sd_bus_error_has_name(&error
, BUS_ERROR_NO_SUCH_UNIT
) ||
3230 sd_bus_error_has_name(&error
, BUS_ERROR_LOAD_FAILED
))
3236 r
= sd_bus_message_read(reply
, "s", &state
);
3240 return !streq(state
, "inactive") && !streq(state
, "failed");
3243 int manager_job_is_active(Manager
*manager
, const char *path
) {
3244 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
3245 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
3251 r
= sd_bus_get_property(
3253 "org.freedesktop.systemd1",
3255 "org.freedesktop.systemd1.Job",
3261 if (sd_bus_error_has_name(&error
, SD_BUS_ERROR_NO_REPLY
) ||
3262 sd_bus_error_has_name(&error
, SD_BUS_ERROR_DISCONNECTED
))
3265 if (sd_bus_error_has_name(&error
, SD_BUS_ERROR_UNKNOWN_OBJECT
))
3271 /* We don't actually care about the state really. The fact
3272 * that we could read the job state is enough for us */