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 "formats-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 int manager_get_session_from_creds(Manager
*m
, sd_bus_message
*message
, const char *name
, sd_bus_error
*error
, Session
**ret
) {
54 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
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
);
72 session
= hashmap_get(m
->sessions
, name
);
74 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SESSION
, "No session '%s' known", name
);
80 int manager_get_user_from_creds(Manager
*m
, sd_bus_message
*message
, uid_t uid
, sd_bus_error
*error
, User
**ret
) {
88 if (uid
== UID_INVALID
) {
89 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
91 /* Note that we get the owner UID of the session, not the actual client UID here! */
92 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_OWNER_UID
|SD_BUS_CREDS_AUGMENT
, &creds
);
96 r
= sd_bus_creds_get_owner_uid(creds
, &uid
);
101 user
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
103 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_USER
, "No user "UID_FMT
" known or logged in", uid
);
109 int manager_get_seat_from_creds(Manager
*m
, sd_bus_message
*message
, const char *name
, sd_bus_error
*error
, Seat
**ret
) {
120 r
= manager_get_session_from_creds(m
, message
, NULL
, error
, &session
);
124 seat
= session
->seat
;
126 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
, "Session has no seat.");
128 seat
= hashmap_get(m
->seats
, name
);
130 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
, "No seat '%s' known", name
);
137 static int property_get_idle_hint(
140 const char *interface
,
141 const char *property
,
142 sd_bus_message
*reply
,
144 sd_bus_error
*error
) {
146 Manager
*m
= userdata
;
152 return sd_bus_message_append(reply
, "b", manager_get_idle_hint(m
, NULL
) > 0);
155 static int property_get_idle_since_hint(
158 const char *interface
,
159 const char *property
,
160 sd_bus_message
*reply
,
162 sd_bus_error
*error
) {
164 Manager
*m
= userdata
;
165 dual_timestamp t
= DUAL_TIMESTAMP_NULL
;
171 manager_get_idle_hint(m
, &t
);
173 return sd_bus_message_append(reply
, "t", streq(property
, "IdleSinceHint") ? t
.realtime
: t
.monotonic
);
176 static int property_get_inhibited(
179 const char *interface
,
180 const char *property
,
181 sd_bus_message
*reply
,
183 sd_bus_error
*error
) {
185 Manager
*m
= userdata
;
192 w
= manager_inhibit_what(m
, streq(property
, "BlockInhibited") ? INHIBIT_BLOCK
: INHIBIT_DELAY
);
194 return sd_bus_message_append(reply
, "s", inhibit_what_to_string(w
));
197 static int property_get_preparing(
200 const char *interface
,
201 const char *property
,
202 sd_bus_message
*reply
,
204 sd_bus_error
*error
) {
206 Manager
*m
= userdata
;
213 if (streq(property
, "PreparingForShutdown"))
214 b
= !!(m
->action_what
& INHIBIT_SHUTDOWN
);
216 b
= !!(m
->action_what
& INHIBIT_SLEEP
);
218 return sd_bus_message_append(reply
, "b", b
);
221 static int property_get_scheduled_shutdown(
224 const char *interface
,
225 const char *property
,
226 sd_bus_message
*reply
,
228 sd_bus_error
*error
) {
230 Manager
*m
= userdata
;
237 r
= sd_bus_message_open_container(reply
, 'r', "st");
241 r
= sd_bus_message_append(reply
, "st", m
->scheduled_shutdown_type
, m
->scheduled_shutdown_timeout
);
245 return sd_bus_message_close_container(reply
);
248 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_handle_action
, handle_action
, HandleAction
);
250 static int property_get_docked(
253 const char *interface
,
254 const char *property
,
255 sd_bus_message
*reply
,
257 sd_bus_error
*error
) {
259 Manager
*m
= userdata
;
265 return sd_bus_message_append(reply
, "b", manager_is_docked_or_external_displays(m
));
268 static int method_get_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
269 _cleanup_free_
char *p
= NULL
;
270 Manager
*m
= userdata
;
278 r
= sd_bus_message_read(message
, "s", &name
);
282 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
286 p
= session_bus_path(session
);
290 return sd_bus_reply_method_return(message
, "o", p
);
293 static int method_get_session_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
294 _cleanup_free_
char *p
= NULL
;
295 Session
*session
= NULL
;
296 Manager
*m
= userdata
;
303 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
305 r
= sd_bus_message_read(message
, "u", &pid
);
312 r
= manager_get_session_from_creds(m
, message
, NULL
, error
, &session
);
316 r
= manager_get_session_by_pid(m
, pid
, &session
);
321 return sd_bus_error_setf(error
, BUS_ERROR_NO_SESSION_FOR_PID
, "PID "PID_FMT
" does not belong to any known session", pid
);
324 p
= session_bus_path(session
);
328 return sd_bus_reply_method_return(message
, "o", p
);
331 static int method_get_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
332 _cleanup_free_
char *p
= NULL
;
333 Manager
*m
= userdata
;
341 r
= sd_bus_message_read(message
, "u", &uid
);
345 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
349 p
= user_bus_path(user
);
353 return sd_bus_reply_method_return(message
, "o", p
);
356 static int method_get_user_by_pid(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
357 _cleanup_free_
char *p
= NULL
;
358 Manager
*m
= userdata
;
366 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
368 r
= sd_bus_message_read(message
, "u", &pid
);
375 r
= manager_get_user_from_creds(m
, message
, UID_INVALID
, error
, &user
);
379 r
= manager_get_user_by_pid(m
, pid
, &user
);
383 return sd_bus_error_setf(error
, BUS_ERROR_NO_USER_FOR_PID
, "PID "PID_FMT
" does not belong to any known or logged in user", pid
);
386 p
= user_bus_path(user
);
390 return sd_bus_reply_method_return(message
, "o", p
);
393 static int method_get_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
394 _cleanup_free_
char *p
= NULL
;
395 Manager
*m
= userdata
;
403 r
= sd_bus_message_read(message
, "s", &name
);
407 r
= manager_get_seat_from_creds(m
, message
, name
, error
, &seat
);
411 p
= seat_bus_path(seat
);
415 return sd_bus_reply_method_return(message
, "o", p
);
418 static int method_list_sessions(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
419 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
420 Manager
*m
= userdata
;
428 r
= sd_bus_message_new_method_return(message
, &reply
);
432 r
= sd_bus_message_open_container(reply
, 'a', "(susso)");
436 HASHMAP_FOREACH(session
, m
->sessions
, i
) {
437 _cleanup_free_
char *p
= NULL
;
439 p
= session_bus_path(session
);
443 r
= sd_bus_message_append(reply
, "(susso)",
445 (uint32_t) session
->user
->uid
,
447 session
->seat
? session
->seat
->id
: "",
453 r
= sd_bus_message_close_container(reply
);
457 return sd_bus_send(NULL
, reply
, NULL
);
460 static int method_list_users(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
461 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
462 Manager
*m
= userdata
;
470 r
= sd_bus_message_new_method_return(message
, &reply
);
474 r
= sd_bus_message_open_container(reply
, 'a', "(uso)");
478 HASHMAP_FOREACH(user
, m
->users
, i
) {
479 _cleanup_free_
char *p
= NULL
;
481 p
= user_bus_path(user
);
485 r
= sd_bus_message_append(reply
, "(uso)",
486 (uint32_t) user
->uid
,
493 r
= sd_bus_message_close_container(reply
);
497 return sd_bus_send(NULL
, reply
, NULL
);
500 static int method_list_seats(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', "(so)");
518 HASHMAP_FOREACH(seat
, m
->seats
, i
) {
519 _cleanup_free_
char *p
= NULL
;
521 p
= seat_bus_path(seat
);
525 r
= sd_bus_message_append(reply
, "(so)", seat
->id
, p
);
530 r
= sd_bus_message_close_container(reply
);
534 return sd_bus_send(NULL
, reply
, NULL
);
537 static int method_list_inhibitors(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
538 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
539 Manager
*m
= userdata
;
540 Inhibitor
*inhibitor
;
547 r
= sd_bus_message_new_method_return(message
, &reply
);
551 r
= sd_bus_message_open_container(reply
, 'a', "(ssssuu)");
555 HASHMAP_FOREACH(inhibitor
, m
->inhibitors
, i
) {
557 r
= sd_bus_message_append(reply
, "(ssssuu)",
558 strempty(inhibit_what_to_string(inhibitor
->what
)),
559 strempty(inhibitor
->who
),
560 strempty(inhibitor
->why
),
561 strempty(inhibit_mode_to_string(inhibitor
->mode
)),
562 (uint32_t) inhibitor
->uid
,
563 (uint32_t) inhibitor
->pid
);
568 r
= sd_bus_message_close_container(reply
);
572 return sd_bus_send(NULL
, reply
, NULL
);
575 static int method_create_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
576 const char *service
, *type
, *class, *cseat
, *tty
, *display
, *remote_user
, *remote_host
, *desktop
;
577 uint32_t audit_id
= 0;
578 _cleanup_free_
char *id
= NULL
;
579 Session
*session
= NULL
;
580 Manager
*m
= userdata
;
594 assert_cc(sizeof(pid_t
) == sizeof(uint32_t));
595 assert_cc(sizeof(uid_t
) == sizeof(uint32_t));
597 r
= sd_bus_message_read(message
, "uusssssussbss", &uid
, &leader
, &service
, &type
, &class, &desktop
, &cseat
, &vtnr
, &tty
, &display
, &remote
, &remote_user
, &remote_host
);
601 if (!uid_is_valid(uid
))
602 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid UID");
603 if (leader
< 0 || leader
== 1)
604 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid leader PID");
607 t
= _SESSION_TYPE_INVALID
;
609 t
= session_type_from_string(type
);
611 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid session type %s", type
);
615 c
= _SESSION_CLASS_INVALID
;
617 c
= session_class_from_string(class);
619 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid session class %s", class);
622 if (isempty(desktop
))
625 if (!string_is_safe(desktop
))
626 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid desktop string %s", desktop
);
632 seat
= hashmap_get(m
->seats
, cseat
);
634 return sd_bus_error_setf(error
, BUS_ERROR_NO_SUCH_SEAT
, "No seat '%s' known", cseat
);
637 if (tty_is_vc(tty
)) {
642 else if (seat
!= m
->seat0
)
643 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
);
645 v
= vtnr_from_tty(tty
);
647 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Cannot determine VT number from virtual console TTY %s", tty
);
651 else if (vtnr
!= (uint32_t) v
)
652 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Specified TTY and VT number do not match");
654 } else if (tty_is_console(tty
)) {
658 else if (seat
!= m
->seat0
)
659 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Console TTY specified but seat is not seat0");
662 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Console TTY specified but VT number is not 0");
666 if (seat_has_vts(seat
)) {
667 if (!vtnr
|| vtnr
> 63)
668 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "VT number out of range");
671 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Seat has no VTs but VT number not 0");
675 r
= sd_bus_message_enter_container(message
, 'a', "(sv)");
679 if (t
== _SESSION_TYPE_INVALID
) {
680 if (!isempty(display
))
682 else if (!isempty(tty
))
685 t
= SESSION_UNSPECIFIED
;
688 if (c
== _SESSION_CLASS_INVALID
) {
689 if (t
== SESSION_UNSPECIFIED
)
690 c
= SESSION_BACKGROUND
;
696 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
698 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_PID
, &creds
);
702 r
= sd_bus_creds_get_pid(creds
, (pid_t
*) &leader
);
707 r
= manager_get_session_by_pid(m
, leader
, NULL
);
709 return sd_bus_error_setf(error
, BUS_ERROR_SESSION_BUSY
, "Already running in a session");
712 * Old gdm and lightdm start the user-session on the same VT as
713 * the greeter session. But they destroy the greeter session
714 * after the user-session and want the user-session to take
715 * over the VT. We need to support this for
716 * backwards-compatibility, so make sure we allow new sessions
717 * on a VT that a greeter is running on. Furthermore, to allow
718 * re-logins, we have to allow a greeter to take over a used VT for
719 * the exact same reasons.
721 if (c
!= SESSION_GREETER
&&
723 vtnr
< m
->seat0
->position_count
&&
724 m
->seat0
->positions
[vtnr
] &&
725 m
->seat0
->positions
[vtnr
]->class != SESSION_GREETER
)
726 return sd_bus_error_setf(error
, BUS_ERROR_SESSION_BUSY
, "Already occupied by a session");
728 audit_session_from_pid(leader
, &audit_id
);
730 /* Keep our session IDs and the audit session IDs in sync */
732 if (asprintf(&id
, "%"PRIu32
, audit_id
) < 0)
735 /* Wut? There's already a session by this name and we
736 * didn't find it above? Weird, then let's not trust
737 * the audit data and let's better register a new
739 if (hashmap_get(m
->sessions
, id
)) {
740 log_warning("Existing logind session ID %s used by new audit session, ignoring", id
);
751 if (asprintf(&id
, "c%lu", ++m
->session_counter
) < 0)
754 } while (hashmap_get(m
->sessions
, id
));
757 r
= manager_add_user_by_uid(m
, uid
, &user
);
761 r
= manager_add_session(m
, id
, &session
);
765 session_set_user(session
, user
);
767 session
->leader
= leader
;
768 session
->audit_id
= audit_id
;
771 session
->remote
= remote
;
772 session
->vtnr
= vtnr
;
775 session
->tty
= strdup(tty
);
782 if (!isempty(display
)) {
783 session
->display
= strdup(display
);
784 if (!session
->display
) {
790 if (!isempty(remote_user
)) {
791 session
->remote_user
= strdup(remote_user
);
792 if (!session
->remote_user
) {
798 if (!isempty(remote_host
)) {
799 session
->remote_host
= strdup(remote_host
);
800 if (!session
->remote_host
) {
806 if (!isempty(service
)) {
807 session
->service
= strdup(service
);
808 if (!session
->service
) {
814 if (!isempty(desktop
)) {
815 session
->desktop
= strdup(desktop
);
816 if (!session
->desktop
) {
823 r
= seat_attach_session(seat
, session
);
828 r
= session_start(session
);
832 session
->create_message
= sd_bus_message_ref(message
);
834 /* Now, let's wait until the slice unit and stuff got
835 * created. We send the reply back from
836 * session_send_create_reply(). */
842 session_add_to_gc_queue(session
);
845 user_add_to_gc_queue(user
);
850 static int method_release_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
851 Manager
*m
= userdata
;
859 r
= sd_bus_message_read(message
, "s", &name
);
863 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
867 r
= session_release(session
);
871 return sd_bus_reply_method_return(message
, NULL
);
874 static int method_activate_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
875 Manager
*m
= userdata
;
883 r
= sd_bus_message_read(message
, "s", &name
);
887 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
891 return bus_session_method_activate(message
, session
, error
);
894 static int method_activate_session_on_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
895 const char *session_name
, *seat_name
;
896 Manager
*m
= userdata
;
904 /* Same as ActivateSession() but refuses to work if
905 * the seat doesn't match */
907 r
= sd_bus_message_read(message
, "ss", &session_name
, &seat_name
);
911 r
= manager_get_session_from_creds(m
, message
, session_name
, error
, &session
);
915 r
= manager_get_seat_from_creds(m
, message
, seat_name
, error
, &seat
);
919 if (session
->seat
!= seat
)
920 return sd_bus_error_setf(error
, BUS_ERROR_SESSION_NOT_ON_SEAT
, "Session %s not on seat %s", session_name
, seat_name
);
922 r
= session_activate(session
);
926 return sd_bus_reply_method_return(message
, NULL
);
929 static int method_lock_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
930 Manager
*m
= userdata
;
938 r
= sd_bus_message_read(message
, "s", &name
);
942 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
946 return bus_session_method_lock(message
, session
, error
);
949 static int method_lock_sessions(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
950 Manager
*m
= userdata
;
956 r
= bus_verify_polkit_async(
959 "org.freedesktop.login1.lock-sessions",
968 return 1; /* Will call us back */
970 r
= session_send_lock_all(m
, streq(sd_bus_message_get_member(message
), "LockSessions"));
974 return sd_bus_reply_method_return(message
, NULL
);
977 static int method_kill_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
979 Manager
*m
= userdata
;
986 r
= sd_bus_message_read(message
, "s", &name
);
990 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
994 return bus_session_method_kill(message
, session
, error
);
997 static int method_kill_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
998 Manager
*m
= userdata
;
1006 r
= sd_bus_message_read(message
, "u", &uid
);
1010 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
1014 return bus_user_method_kill(message
, user
, error
);
1017 static int method_terminate_session(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1018 Manager
*m
= userdata
;
1026 r
= sd_bus_message_read(message
, "s", &name
);
1030 r
= manager_get_session_from_creds(m
, message
, name
, error
, &session
);
1034 return bus_session_method_terminate(message
, session
, error
);
1037 static int method_terminate_user(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1038 Manager
*m
= userdata
;
1046 r
= sd_bus_message_read(message
, "u", &uid
);
1050 r
= manager_get_user_from_creds(m
, message
, uid
, error
, &user
);
1054 return bus_user_method_terminate(message
, user
, error
);
1057 static int method_terminate_seat(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1058 Manager
*m
= userdata
;
1066 r
= sd_bus_message_read(message
, "s", &name
);
1070 r
= manager_get_seat_from_creds(m
, message
, name
, error
, &seat
);
1074 return bus_seat_method_terminate(message
, seat
, error
);
1077 static int method_set_user_linger(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1078 _cleanup_free_
char *cc
= NULL
;
1079 Manager
*m
= userdata
;
1080 int r
, b
, interactive
;
1089 r
= sd_bus_message_read(message
, "ubb", &uid
, &b
, &interactive
);
1093 if (uid
== UID_INVALID
) {
1094 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
1096 /* Note that we get the owner UID of the session, not the actual client UID here! */
1097 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_OWNER_UID
|SD_BUS_CREDS_AUGMENT
, &creds
);
1101 r
= sd_bus_creds_get_owner_uid(creds
, &uid
);
1107 } else if (!uid_is_valid(uid
))
1113 return errno
> 0 ? -errno
: -ENOENT
;
1115 r
= bus_verify_polkit_async(
1118 self
? "org.freedesktop.login1.set-self-linger" : "org.freedesktop.login1.set-user-linger",
1122 &m
->polkit_registry
,
1127 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1129 mkdir_p_label("/var/lib/systemd", 0755);
1131 r
= mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0);
1135 cc
= cescape(pw
->pw_name
);
1139 path
= strjoina("/var/lib/systemd/linger/", cc
);
1147 if (manager_add_user_by_uid(m
, uid
, &u
) >= 0)
1154 if (r
< 0 && errno
!= ENOENT
)
1157 u
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
1159 user_add_to_gc_queue(u
);
1162 return sd_bus_reply_method_return(message
, NULL
);
1165 static int trigger_device(Manager
*m
, struct udev_device
*d
) {
1166 _cleanup_udev_enumerate_unref_
struct udev_enumerate
*e
= NULL
;
1167 struct udev_list_entry
*first
, *item
;
1172 e
= udev_enumerate_new(m
->udev
);
1177 r
= udev_enumerate_add_match_parent(e
, d
);
1182 r
= udev_enumerate_scan_devices(e
);
1186 first
= udev_enumerate_get_list_entry(e
);
1187 udev_list_entry_foreach(item
, first
) {
1188 _cleanup_free_
char *t
= NULL
;
1191 p
= udev_list_entry_get_name(item
);
1193 t
= strappend(p
, "/uevent");
1197 write_string_file(t
, "change", WRITE_STRING_FILE_CREATE
);
1203 static int attach_device(Manager
*m
, const char *seat
, const char *sysfs
) {
1204 _cleanup_udev_device_unref_
struct udev_device
*d
= NULL
;
1205 _cleanup_free_
char *rule
= NULL
, *file
= NULL
;
1206 const char *id_for_seat
;
1213 d
= udev_device_new_from_syspath(m
->udev
, sysfs
);
1217 if (!udev_device_has_tag(d
, "seat"))
1220 id_for_seat
= udev_device_get_property_value(d
, "ID_FOR_SEAT");
1224 if (asprintf(&file
, "/etc/udev/rules.d/72-seat-%s.rules", id_for_seat
) < 0)
1227 if (asprintf(&rule
, "TAG==\"seat\", ENV{ID_FOR_SEAT}==\"%s\", ENV{ID_SEAT}=\"%s\"", id_for_seat
, seat
) < 0)
1230 mkdir_p_label("/etc/udev/rules.d", 0755);
1231 r
= write_string_file_atomic_label(file
, rule
);
1235 return trigger_device(m
, d
);
1238 static int flush_devices(Manager
*m
) {
1239 _cleanup_closedir_
DIR *d
;
1243 d
= opendir("/etc/udev/rules.d");
1245 if (errno
!= ENOENT
)
1246 log_warning_errno(errno
, "Failed to open /etc/udev/rules.d: %m");
1250 while ((de
= readdir(d
))) {
1252 if (!dirent_is_file(de
))
1255 if (!startswith(de
->d_name
, "72-seat-"))
1258 if (!endswith(de
->d_name
, ".rules"))
1261 if (unlinkat(dirfd(d
), de
->d_name
, 0) < 0)
1262 log_warning_errno(errno
, "Failed to unlink %s: %m", de
->d_name
);
1266 return trigger_device(m
, NULL
);
1269 static int method_attach_device(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1270 const char *sysfs
, *seat
;
1271 Manager
*m
= userdata
;
1277 r
= sd_bus_message_read(message
, "ssb", &seat
, &sysfs
, &interactive
);
1281 if (!path_startswith(sysfs
, "/sys"))
1282 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Path %s is not in /sys", sysfs
);
1284 if (!seat_name_is_valid(seat
))
1285 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Seat %s is not valid", seat
);
1287 r
= bus_verify_polkit_async(
1290 "org.freedesktop.login1.attach-device",
1294 &m
->polkit_registry
,
1299 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1301 r
= attach_device(m
, seat
, sysfs
);
1305 return sd_bus_reply_method_return(message
, NULL
);
1308 static int method_flush_devices(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1309 Manager
*m
= userdata
;
1315 r
= sd_bus_message_read(message
, "b", &interactive
);
1319 r
= bus_verify_polkit_async(
1322 "org.freedesktop.login1.flush-devices",
1326 &m
->polkit_registry
,
1331 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1333 r
= flush_devices(m
);
1337 return sd_bus_reply_method_return(message
, NULL
);
1340 static int have_multiple_sessions(
1349 /* Check for other users' sessions. Greeter sessions do not
1350 * count, and non-login sessions do not count either. */
1351 HASHMAP_FOREACH(session
, m
->sessions
, i
)
1352 if (session
->class == SESSION_USER
&&
1353 session
->user
->uid
!= uid
)
1359 static int bus_manager_log_shutdown(
1362 const char *unit_name
) {
1369 if (w
!= INHIBIT_SHUTDOWN
)
1372 if (streq(unit_name
, SPECIAL_POWEROFF_TARGET
)) {
1373 p
= "MESSAGE=System is powering down";
1374 q
= "SHUTDOWN=power-off";
1375 } else if (streq(unit_name
, SPECIAL_HALT_TARGET
)) {
1376 p
= "MESSAGE=System is halting";
1377 q
= "SHUTDOWN=halt";
1378 } else if (streq(unit_name
, SPECIAL_REBOOT_TARGET
)) {
1379 p
= "MESSAGE=System is rebooting";
1380 q
= "SHUTDOWN=reboot";
1381 } else if (streq(unit_name
, SPECIAL_KEXEC_TARGET
)) {
1382 p
= "MESSAGE=System is rebooting with kexec";
1383 q
= "SHUTDOWN=kexec";
1385 p
= "MESSAGE=System is shutting down";
1389 if (isempty(m
->wall_message
))
1390 p
= strjoina(p
, ".");
1392 p
= strjoina(p
, " (", m
->wall_message
, ").");
1394 return log_struct(LOG_NOTICE
,
1395 LOG_MESSAGE_ID(SD_MESSAGE_SHUTDOWN
),
1401 static int lid_switch_ignore_handler(sd_event_source
*e
, uint64_t usec
, void *userdata
) {
1402 Manager
*m
= userdata
;
1407 m
->lid_switch_ignore_event_source
= sd_event_source_unref(m
->lid_switch_ignore_event_source
);
1411 int manager_set_lid_switch_ignore(Manager
*m
, usec_t until
) {
1416 if (until
<= now(CLOCK_MONOTONIC
))
1419 /* We want to ignore the lid switch for a while after each
1420 * suspend, and after boot-up. Hence let's install a timer for
1421 * this. As long as the event source exists we ignore the lid
1424 if (m
->lid_switch_ignore_event_source
) {
1427 r
= sd_event_source_get_time(m
->lid_switch_ignore_event_source
, &u
);
1434 r
= sd_event_source_set_time(m
->lid_switch_ignore_event_source
, until
);
1436 r
= sd_event_add_time(
1438 &m
->lid_switch_ignore_event_source
,
1441 lid_switch_ignore_handler
, m
);
1446 static void reset_scheduled_shutdown(Manager
*m
) {
1447 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
1448 m
->wall_message_timeout_source
= sd_event_source_unref(m
->wall_message_timeout_source
);
1449 m
->nologin_timeout_source
= sd_event_source_unref(m
->nologin_timeout_source
);
1450 m
->scheduled_shutdown_type
= mfree(m
->scheduled_shutdown_type
);
1451 m
->scheduled_shutdown_timeout
= 0;
1452 m
->shutdown_dry_run
= false;
1454 if (m
->unlink_nologin
) {
1455 (void) unlink("/run/nologin");
1456 m
->unlink_nologin
= false;
1460 static int execute_shutdown_or_sleep(
1463 const char *unit_name
,
1464 sd_bus_error
*error
) {
1466 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
1473 assert(w
< _INHIBIT_WHAT_MAX
);
1476 bus_manager_log_shutdown(m
, w
, unit_name
);
1478 if (m
->shutdown_dry_run
) {
1479 log_info("Running in dry run, suppressing action.");
1480 reset_scheduled_shutdown(m
);
1482 r
= sd_bus_call_method(
1484 "org.freedesktop.systemd1",
1485 "/org/freedesktop/systemd1",
1486 "org.freedesktop.systemd1.Manager",
1490 "ss", unit_name
, "replace-irreversibly");
1494 r
= sd_bus_message_read(reply
, "o", &p
);
1503 m
->action_unit
= unit_name
;
1504 free(m
->action_job
);
1508 /* Make sure the lid switch is ignored for a while */
1509 manager_set_lid_switch_ignore(m
, now(CLOCK_MONOTONIC
) + m
->holdoff_timeout_usec
);
1514 int manager_dispatch_delayed(Manager
*manager
, bool timeout
) {
1516 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1517 Inhibitor
*offending
= NULL
;
1522 if (manager
->action_what
== 0 || manager
->action_job
)
1525 if (manager_is_inhibited(manager
, manager
->action_what
, INHIBIT_DELAY
, NULL
, false, false, 0, &offending
)) {
1526 _cleanup_free_
char *comm
= NULL
, *u
= NULL
;
1531 (void) get_process_comm(offending
->pid
, &comm
);
1532 u
= uid_to_name(offending
->uid
);
1534 log_notice("Delay lock is active (UID "UID_FMT
"/%s, PID "PID_FMT
"/%s) but inhibitor timeout is reached.",
1535 offending
->uid
, strna(u
),
1536 offending
->pid
, strna(comm
));
1539 /* Actually do the operation */
1540 r
= execute_shutdown_or_sleep(manager
, manager
->action_what
, manager
->action_unit
, &error
);
1542 log_warning("Failed to send delayed message: %s", bus_error_message(&error
, r
));
1544 manager
->action_unit
= NULL
;
1545 manager
->action_what
= 0;
1552 static int manager_inhibit_timeout_handler(
1557 Manager
*manager
= userdata
;
1561 assert(manager
->inhibit_timeout_source
== s
);
1563 r
= manager_dispatch_delayed(manager
, true);
1564 return (r
< 0) ? r
: 0;
1567 static int delay_shutdown_or_sleep(
1570 const char *unit_name
) {
1577 assert(w
< _INHIBIT_WHAT_MAX
);
1580 timeout_val
= now(CLOCK_MONOTONIC
) + m
->inhibit_delay_max
;
1582 if (m
->inhibit_timeout_source
) {
1583 r
= sd_event_source_set_time(m
->inhibit_timeout_source
, timeout_val
);
1585 return log_error_errno(r
, "sd_event_source_set_time() failed: %m");
1587 r
= sd_event_source_set_enabled(m
->inhibit_timeout_source
, SD_EVENT_ONESHOT
);
1589 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
1591 r
= sd_event_add_time(m
->event
, &m
->inhibit_timeout_source
, CLOCK_MONOTONIC
,
1592 timeout_val
, 0, manager_inhibit_timeout_handler
, m
);
1597 m
->action_unit
= unit_name
;
1603 static int send_prepare_for(Manager
*m
, InhibitWhat w
, bool _active
) {
1605 static const char * const signal_name
[_INHIBIT_WHAT_MAX
] = {
1606 [INHIBIT_SHUTDOWN
] = "PrepareForShutdown",
1607 [INHIBIT_SLEEP
] = "PrepareForSleep"
1610 int active
= _active
;
1614 assert(w
< _INHIBIT_WHAT_MAX
);
1615 assert(signal_name
[w
]);
1617 return sd_bus_emit_signal(m
->bus
,
1618 "/org/freedesktop/login1",
1619 "org.freedesktop.login1.Manager",
1625 int bus_manager_shutdown_or_sleep_now_or_later(
1627 const char *unit_name
,
1629 sd_bus_error
*error
) {
1637 assert(w
<= _INHIBIT_WHAT_MAX
);
1638 assert(!m
->action_job
);
1640 /* Tell everybody to prepare for shutdown/sleep */
1641 send_prepare_for(m
, w
, true);
1644 m
->inhibit_delay_max
> 0 &&
1645 manager_is_inhibited(m
, w
, INHIBIT_DELAY
, NULL
, false, false, 0, NULL
);
1648 /* Shutdown is delayed, keep in mind what we
1649 * want to do, and start a timeout */
1650 r
= delay_shutdown_or_sleep(m
, w
, unit_name
);
1652 /* Shutdown is not delayed, execute it
1654 r
= execute_shutdown_or_sleep(m
, w
, unit_name
, error
);
1659 static int verify_shutdown_creds(
1661 sd_bus_message
*message
,
1665 const char *action_multiple_sessions
,
1666 const char *action_ignore_inhibit
,
1667 sd_bus_error
*error
) {
1669 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
1670 bool multiple_sessions
, blocked
;
1677 assert(w
<= _INHIBIT_WHAT_MAX
);
1679 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
, &creds
);
1683 r
= sd_bus_creds_get_euid(creds
, &uid
);
1687 r
= have_multiple_sessions(m
, uid
);
1691 multiple_sessions
= r
> 0;
1692 blocked
= manager_is_inhibited(m
, w
, INHIBIT_BLOCK
, NULL
, false, true, uid
, NULL
);
1694 if (multiple_sessions
&& action_multiple_sessions
) {
1695 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action_multiple_sessions
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1699 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1702 if (blocked
&& action_ignore_inhibit
) {
1703 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action_ignore_inhibit
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1707 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1710 if (!multiple_sessions
&& !blocked
&& action
) {
1711 r
= bus_verify_polkit_async(message
, CAP_SYS_BOOT
, action
, NULL
, interactive
, UID_INVALID
, &m
->polkit_registry
, error
);
1715 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1721 static int method_do_shutdown_or_sleep(
1723 sd_bus_message
*message
,
1724 const char *unit_name
,
1727 const char *action_multiple_sessions
,
1728 const char *action_ignore_inhibit
,
1729 const char *sleep_verb
,
1730 sd_bus_error
*error
) {
1738 assert(w
<= _INHIBIT_WHAT_MAX
);
1740 r
= sd_bus_message_read(message
, "b", &interactive
);
1744 /* Don't allow multiple jobs being executed at the same time */
1746 return sd_bus_error_setf(error
, BUS_ERROR_OPERATION_IN_PROGRESS
, "There's already a shutdown or sleep operation in progress");
1749 r
= can_sleep(sleep_verb
);
1754 return sd_bus_error_setf(error
, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED
, "Sleep verb not supported");
1757 r
= verify_shutdown_creds(m
, message
, w
, interactive
, action
, action_multiple_sessions
,
1758 action_ignore_inhibit
, error
);
1762 r
= bus_manager_shutdown_or_sleep_now_or_later(m
, unit_name
, w
, error
);
1766 return sd_bus_reply_method_return(message
, NULL
);
1769 static int method_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1770 Manager
*m
= userdata
;
1772 return method_do_shutdown_or_sleep(
1774 SPECIAL_POWEROFF_TARGET
,
1776 "org.freedesktop.login1.power-off",
1777 "org.freedesktop.login1.power-off-multiple-sessions",
1778 "org.freedesktop.login1.power-off-ignore-inhibit",
1783 static int method_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1784 Manager
*m
= userdata
;
1786 return method_do_shutdown_or_sleep(
1788 SPECIAL_REBOOT_TARGET
,
1790 "org.freedesktop.login1.reboot",
1791 "org.freedesktop.login1.reboot-multiple-sessions",
1792 "org.freedesktop.login1.reboot-ignore-inhibit",
1797 static int method_suspend(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1798 Manager
*m
= userdata
;
1800 return method_do_shutdown_or_sleep(
1802 SPECIAL_SUSPEND_TARGET
,
1804 "org.freedesktop.login1.suspend",
1805 "org.freedesktop.login1.suspend-multiple-sessions",
1806 "org.freedesktop.login1.suspend-ignore-inhibit",
1811 static int nologin_timeout_handler(
1816 Manager
*m
= userdata
;
1819 log_info("Creating /run/nologin, blocking further logins...");
1821 r
= write_string_file_atomic_label("/run/nologin", "System is going down.");
1823 log_error_errno(r
, "Failed to create /run/nologin: %m");
1825 m
->unlink_nologin
= true;
1830 static int update_schedule_file(Manager
*m
) {
1831 _cleanup_free_
char *temp_path
= NULL
;
1832 _cleanup_fclose_
FILE *f
= NULL
;
1837 r
= mkdir_safe_label("/run/systemd/shutdown", 0755, 0, 0);
1839 return log_error_errno(r
, "Failed to create shutdown subdirectory: %m");
1841 r
= fopen_temporary("/run/systemd/shutdown/scheduled", &f
, &temp_path
);
1843 return log_error_errno(r
, "Failed to save information about scheduled shutdowns: %m");
1845 (void) fchmod(fileno(f
), 0644);
1851 m
->scheduled_shutdown_timeout
,
1852 m
->enable_wall_messages
,
1853 m
->scheduled_shutdown_type
);
1855 if (!isempty(m
->wall_message
)) {
1856 _cleanup_free_
char *t
;
1858 t
= cescape(m
->wall_message
);
1864 fprintf(f
, "WALL_MESSAGE=%s\n", t
);
1867 r
= fflush_and_check(f
);
1871 if (rename(temp_path
, "/run/systemd/shutdown/scheduled") < 0) {
1879 (void) unlink(temp_path
);
1880 (void) unlink("/run/systemd/shutdown/scheduled");
1882 return log_error_errno(r
, "Failed to write information about scheduled shutdowns: %m");
1885 static int manager_scheduled_shutdown_handler(
1890 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
1891 Manager
*m
= userdata
;
1897 if (isempty(m
->scheduled_shutdown_type
))
1900 if (streq(m
->scheduled_shutdown_type
, "halt"))
1901 target
= SPECIAL_HALT_TARGET
;
1902 else if (streq(m
->scheduled_shutdown_type
, "poweroff"))
1903 target
= SPECIAL_POWEROFF_TARGET
;
1905 target
= SPECIAL_REBOOT_TARGET
;
1907 r
= execute_shutdown_or_sleep(m
, 0, target
, &error
);
1909 return log_error_errno(r
, "Unable to execute transition to %s: %m", target
);
1914 static int method_schedule_shutdown(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
1915 Manager
*m
= userdata
;
1916 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
1917 const char *action_multiple_sessions
= NULL
;
1918 const char *action_ignore_inhibit
= NULL
;
1919 const char *action
= NULL
;
1927 r
= sd_bus_message_read(message
, "st", &type
, &elapse
);
1931 if (startswith(type
, "dry-")) {
1933 m
->shutdown_dry_run
= true;
1936 if (streq(type
, "reboot")) {
1937 action
= "org.freedesktop.login1.reboot";
1938 action_multiple_sessions
= "org.freedesktop.login1.reboot-multiple-sessions";
1939 action_ignore_inhibit
= "org.freedesktop.login1.reboot-ignore-inhibit";
1940 } else if (streq(type
, "halt")) {
1941 action
= "org.freedesktop.login1.halt";
1942 action_multiple_sessions
= "org.freedesktop.login1.halt-multiple-sessions";
1943 action_ignore_inhibit
= "org.freedesktop.login1.halt-ignore-inhibit";
1944 } else if (streq(type
, "poweroff")) {
1945 action
= "org.freedesktop.login1.power-off";
1946 action_multiple_sessions
= "org.freedesktop.login1.power-off-multiple-sessions";
1947 action_ignore_inhibit
= "org.freedesktop.login1.power-off-ignore-inhibit";
1949 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Unsupported shutdown type");
1951 r
= verify_shutdown_creds(m
, message
, INHIBIT_SHUTDOWN
, false,
1952 action
, action_multiple_sessions
, action_ignore_inhibit
, error
);
1956 if (m
->scheduled_shutdown_timeout_source
) {
1957 r
= sd_event_source_set_time(m
->scheduled_shutdown_timeout_source
, elapse
);
1959 return log_error_errno(r
, "sd_event_source_set_time() failed: %m");
1961 r
= sd_event_source_set_enabled(m
->scheduled_shutdown_timeout_source
, SD_EVENT_ONESHOT
);
1963 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
1965 r
= sd_event_add_time(m
->event
, &m
->scheduled_shutdown_timeout_source
,
1966 CLOCK_REALTIME
, elapse
, 0, manager_scheduled_shutdown_handler
, m
);
1968 return log_error_errno(r
, "sd_event_add_time() failed: %m");
1971 r
= free_and_strdup(&m
->scheduled_shutdown_type
, type
);
1973 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
1977 if (m
->nologin_timeout_source
) {
1978 r
= sd_event_source_set_time(m
->nologin_timeout_source
, elapse
);
1980 return log_error_errno(r
, "sd_event_source_set_time() failed: %m");
1982 r
= sd_event_source_set_enabled(m
->nologin_timeout_source
, SD_EVENT_ONESHOT
);
1984 return log_error_errno(r
, "sd_event_source_set_enabled() failed: %m");
1986 r
= sd_event_add_time(m
->event
, &m
->nologin_timeout_source
,
1987 CLOCK_REALTIME
, elapse
- 5 * USEC_PER_MINUTE
, 0, nologin_timeout_handler
, m
);
1989 return log_error_errno(r
, "sd_event_add_time() failed: %m");
1992 m
->scheduled_shutdown_timeout
= elapse
;
1994 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_AUGMENT
|SD_BUS_CREDS_TTY
|SD_BUS_CREDS_UID
, &creds
);
1996 const char *tty
= NULL
;
1998 (void) sd_bus_creds_get_uid(creds
, &m
->scheduled_shutdown_uid
);
1999 (void) sd_bus_creds_get_tty(creds
, &tty
);
2001 r
= free_and_strdup(&m
->scheduled_shutdown_tty
, tty
);
2003 m
->scheduled_shutdown_timeout_source
= sd_event_source_unref(m
->scheduled_shutdown_timeout_source
);
2008 r
= manager_setup_wall_message_timer(m
);
2012 if (!isempty(type
)) {
2013 r
= update_schedule_file(m
);
2017 (void) unlink("/run/systemd/shutdown/scheduled");
2019 return sd_bus_reply_method_return(message
, NULL
);
2022 static int method_cancel_scheduled_shutdown(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2023 Manager
*m
= userdata
;
2029 cancelled
= m
->scheduled_shutdown_type
!= NULL
;
2030 reset_scheduled_shutdown(m
);
2033 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2034 const char *tty
= NULL
;
2038 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_AUGMENT
|SD_BUS_CREDS_TTY
|SD_BUS_CREDS_UID
, &creds
);
2040 (void) sd_bus_creds_get_uid(creds
, &uid
);
2041 (void) sd_bus_creds_get_tty(creds
, &tty
);
2044 utmp_wall("The system shutdown has been cancelled",
2045 uid_to_name(uid
), tty
, logind_wall_tty_filter
, m
);
2048 return sd_bus_reply_method_return(message
, "b", cancelled
);
2051 static int method_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2052 Manager
*m
= userdata
;
2054 return method_do_shutdown_or_sleep(
2056 SPECIAL_HIBERNATE_TARGET
,
2058 "org.freedesktop.login1.hibernate",
2059 "org.freedesktop.login1.hibernate-multiple-sessions",
2060 "org.freedesktop.login1.hibernate-ignore-inhibit",
2065 static int method_hybrid_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2066 Manager
*m
= userdata
;
2068 return method_do_shutdown_or_sleep(
2070 SPECIAL_HYBRID_SLEEP_TARGET
,
2072 "org.freedesktop.login1.hibernate",
2073 "org.freedesktop.login1.hibernate-multiple-sessions",
2074 "org.freedesktop.login1.hibernate-ignore-inhibit",
2079 static int method_can_shutdown_or_sleep(
2081 sd_bus_message
*message
,
2084 const char *action_multiple_sessions
,
2085 const char *action_ignore_inhibit
,
2086 const char *sleep_verb
,
2087 sd_bus_error
*error
) {
2089 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2090 bool multiple_sessions
, challenge
, blocked
;
2091 const char *result
= NULL
;
2098 assert(w
<= _INHIBIT_WHAT_MAX
);
2100 assert(action_multiple_sessions
);
2101 assert(action_ignore_inhibit
);
2104 r
= can_sleep(sleep_verb
);
2108 return sd_bus_reply_method_return(message
, "s", "na");
2111 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
, &creds
);
2115 r
= sd_bus_creds_get_euid(creds
, &uid
);
2119 r
= have_multiple_sessions(m
, uid
);
2123 multiple_sessions
= r
> 0;
2124 blocked
= manager_is_inhibited(m
, w
, INHIBIT_BLOCK
, NULL
, false, true, uid
, NULL
);
2126 if (multiple_sessions
) {
2127 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action_multiple_sessions
, NULL
, UID_INVALID
, &challenge
, error
);
2134 result
= "challenge";
2140 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action_ignore_inhibit
, NULL
, UID_INVALID
, &challenge
, error
);
2144 if (r
> 0 && !result
)
2146 else if (challenge
&& (!result
|| streq(result
, "yes")))
2147 result
= "challenge";
2152 if (!multiple_sessions
&& !blocked
) {
2153 /* If neither inhibit nor multiple sessions
2154 * apply then just check the normal policy */
2156 r
= bus_test_polkit(message
, CAP_SYS_BOOT
, action
, NULL
, UID_INVALID
, &challenge
, error
);
2163 result
= "challenge";
2168 return sd_bus_reply_method_return(message
, "s", result
);
2171 static int method_can_poweroff(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2172 Manager
*m
= userdata
;
2174 return method_can_shutdown_or_sleep(
2177 "org.freedesktop.login1.power-off",
2178 "org.freedesktop.login1.power-off-multiple-sessions",
2179 "org.freedesktop.login1.power-off-ignore-inhibit",
2184 static int method_can_reboot(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2185 Manager
*m
= userdata
;
2187 return method_can_shutdown_or_sleep(
2190 "org.freedesktop.login1.reboot",
2191 "org.freedesktop.login1.reboot-multiple-sessions",
2192 "org.freedesktop.login1.reboot-ignore-inhibit",
2197 static int method_can_suspend(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2198 Manager
*m
= userdata
;
2200 return method_can_shutdown_or_sleep(
2203 "org.freedesktop.login1.suspend",
2204 "org.freedesktop.login1.suspend-multiple-sessions",
2205 "org.freedesktop.login1.suspend-ignore-inhibit",
2210 static int method_can_hibernate(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2211 Manager
*m
= userdata
;
2213 return method_can_shutdown_or_sleep(
2216 "org.freedesktop.login1.hibernate",
2217 "org.freedesktop.login1.hibernate-multiple-sessions",
2218 "org.freedesktop.login1.hibernate-ignore-inhibit",
2223 static int method_can_hybrid_sleep(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2224 Manager
*m
= userdata
;
2226 return method_can_shutdown_or_sleep(
2229 "org.freedesktop.login1.hibernate",
2230 "org.freedesktop.login1.hibernate-multiple-sessions",
2231 "org.freedesktop.login1.hibernate-ignore-inhibit",
2236 static int property_get_reboot_to_firmware_setup(
2239 const char *interface
,
2240 const char *property
,
2241 sd_bus_message
*reply
,
2243 sd_bus_error
*error
) {
2250 r
= efi_get_reboot_to_firmware();
2251 if (r
< 0 && r
!= -EOPNOTSUPP
)
2254 return sd_bus_message_append(reply
, "b", r
> 0);
2257 static int method_set_reboot_to_firmware_setup(
2258 sd_bus_message
*message
,
2260 sd_bus_error
*error
) {
2263 Manager
*m
= userdata
;
2268 r
= sd_bus_message_read(message
, "b", &b
);
2272 r
= bus_verify_polkit_async(message
,
2274 "org.freedesktop.login1.set-reboot-to-firmware-setup",
2278 &m
->polkit_registry
,
2283 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2285 r
= efi_set_reboot_to_firmware(b
);
2289 return sd_bus_reply_method_return(message
, NULL
);
2292 static int method_can_reboot_to_firmware_setup(
2293 sd_bus_message
*message
,
2295 sd_bus_error
*error
) {
2300 Manager
*m
= userdata
;
2305 r
= efi_reboot_to_firmware_supported();
2306 if (r
== -EOPNOTSUPP
)
2307 return sd_bus_reply_method_return(message
, "s", "na");
2311 r
= bus_test_polkit(message
,
2313 "org.freedesktop.login1.set-reboot-to-firmware-setup",
2324 result
= "challenge";
2328 return sd_bus_reply_method_return(message
, "s", result
);
2331 static int method_set_wall_message(
2332 sd_bus_message
*message
,
2334 sd_bus_error
*error
) {
2337 Manager
*m
= userdata
;
2339 int enable_wall_messages
;
2344 r
= sd_bus_message_read(message
, "sb", &wall_message
, &enable_wall_messages
);
2348 r
= bus_verify_polkit_async(message
,
2350 "org.freedesktop.login1.set-wall-message",
2354 &m
->polkit_registry
,
2359 return 1; /* Will call us back */
2361 if (isempty(wall_message
))
2362 m
->wall_message
= mfree(m
->wall_message
);
2364 r
= free_and_strdup(&m
->wall_message
, wall_message
);
2369 m
->enable_wall_messages
= enable_wall_messages
;
2371 return sd_bus_reply_method_return(message
, NULL
);
2374 static int method_inhibit(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2375 _cleanup_(sd_bus_creds_unrefp
) sd_bus_creds
*creds
= NULL
;
2376 const char *who
, *why
, *what
, *mode
;
2377 _cleanup_free_
char *id
= NULL
;
2378 _cleanup_close_
int fifo_fd
= -1;
2379 Manager
*m
= userdata
;
2380 Inhibitor
*i
= NULL
;
2390 r
= sd_bus_message_read(message
, "ssss", &what
, &who
, &why
, &mode
);
2394 w
= inhibit_what_from_string(what
);
2396 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid what specification %s", what
);
2398 mm
= inhibit_mode_from_string(mode
);
2400 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Invalid mode specification %s", mode
);
2402 /* Delay is only supported for shutdown/sleep */
2403 if (mm
== INHIBIT_DELAY
&& (w
& ~(INHIBIT_SHUTDOWN
|INHIBIT_SLEEP
)))
2404 return sd_bus_error_setf(error
, SD_BUS_ERROR_INVALID_ARGS
, "Delay inhibitors only supported for shutdown and sleep");
2406 /* Don't allow taking delay locks while we are already
2407 * executing the operation. We shouldn't create the impression
2408 * that the lock was successful if the machine is about to go
2409 * down/suspend any moment. */
2410 if (m
->action_what
& w
)
2411 return sd_bus_error_setf(error
, BUS_ERROR_OPERATION_IN_PROGRESS
, "The operation inhibition has been requested for is already running");
2413 r
= bus_verify_polkit_async(
2416 w
== INHIBIT_SHUTDOWN
? (mm
== INHIBIT_BLOCK
? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
2417 w
== INHIBIT_SLEEP
? (mm
== INHIBIT_BLOCK
? "org.freedesktop.login1.inhibit-block-sleep" : "org.freedesktop.login1.inhibit-delay-sleep") :
2418 w
== INHIBIT_IDLE
? "org.freedesktop.login1.inhibit-block-idle" :
2419 w
== INHIBIT_HANDLE_POWER_KEY
? "org.freedesktop.login1.inhibit-handle-power-key" :
2420 w
== INHIBIT_HANDLE_SUSPEND_KEY
? "org.freedesktop.login1.inhibit-handle-suspend-key" :
2421 w
== INHIBIT_HANDLE_HIBERNATE_KEY
? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
2422 "org.freedesktop.login1.inhibit-handle-lid-switch",
2426 &m
->polkit_registry
,
2431 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2433 r
= sd_bus_query_sender_creds(message
, SD_BUS_CREDS_EUID
|SD_BUS_CREDS_PID
, &creds
);
2437 r
= sd_bus_creds_get_euid(creds
, &uid
);
2441 r
= sd_bus_creds_get_pid(creds
, &pid
);
2448 if (asprintf(&id
, "%lu", ++m
->inhibit_counter
) < 0)
2451 } while (hashmap_get(m
->inhibitors
, id
));
2453 r
= manager_add_inhibitor(m
, id
, &i
);
2461 i
->why
= strdup(why
);
2462 i
->who
= strdup(who
);
2464 if (!i
->why
|| !i
->who
) {
2469 fifo_fd
= inhibitor_create_fifo(i
);
2477 return sd_bus_reply_method_return(message
, "h", fifo_fd
);
2486 const sd_bus_vtable manager_vtable
[] = {
2487 SD_BUS_VTABLE_START(0),
2489 SD_BUS_WRITABLE_PROPERTY("EnableWallMessages", "b", NULL
, NULL
, offsetof(Manager
, enable_wall_messages
), 0),
2490 SD_BUS_WRITABLE_PROPERTY("WallMessage", "s", NULL
, NULL
, offsetof(Manager
, wall_message
), 0),
2492 SD_BUS_PROPERTY("NAutoVTs", "u", NULL
, offsetof(Manager
, n_autovts
), SD_BUS_VTABLE_PROPERTY_CONST
),
2493 SD_BUS_PROPERTY("KillOnlyUsers", "as", NULL
, offsetof(Manager
, kill_only_users
), SD_BUS_VTABLE_PROPERTY_CONST
),
2494 SD_BUS_PROPERTY("KillExcludeUsers", "as", NULL
, offsetof(Manager
, kill_exclude_users
), SD_BUS_VTABLE_PROPERTY_CONST
),
2495 SD_BUS_PROPERTY("KillUserProcesses", "b", NULL
, offsetof(Manager
, kill_user_processes
), SD_BUS_VTABLE_PROPERTY_CONST
),
2496 SD_BUS_PROPERTY("RebootToFirmwareSetup", "b", property_get_reboot_to_firmware_setup
, 0, SD_BUS_VTABLE_PROPERTY_CONST
),
2497 SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2498 SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2499 SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2500 SD_BUS_PROPERTY("BlockInhibited", "s", property_get_inhibited
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2501 SD_BUS_PROPERTY("DelayInhibited", "s", property_get_inhibited
, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE
),
2502 SD_BUS_PROPERTY("InhibitDelayMaxUSec", "t", NULL
, offsetof(Manager
, inhibit_delay_max
), SD_BUS_VTABLE_PROPERTY_CONST
),
2503 SD_BUS_PROPERTY("HandlePowerKey", "s", property_get_handle_action
, offsetof(Manager
, handle_power_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
2504 SD_BUS_PROPERTY("HandleSuspendKey", "s", property_get_handle_action
, offsetof(Manager
, handle_suspend_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
2505 SD_BUS_PROPERTY("HandleHibernateKey", "s", property_get_handle_action
, offsetof(Manager
, handle_hibernate_key
), SD_BUS_VTABLE_PROPERTY_CONST
),
2506 SD_BUS_PROPERTY("HandleLidSwitch", "s", property_get_handle_action
, offsetof(Manager
, handle_lid_switch
), SD_BUS_VTABLE_PROPERTY_CONST
),
2507 SD_BUS_PROPERTY("HandleLidSwitchDocked", "s", property_get_handle_action
, offsetof(Manager
, handle_lid_switch_docked
), SD_BUS_VTABLE_PROPERTY_CONST
),
2508 SD_BUS_PROPERTY("HoldoffTimeoutUSec", "t", NULL
, offsetof(Manager
, holdoff_timeout_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2509 SD_BUS_PROPERTY("IdleAction", "s", property_get_handle_action
, offsetof(Manager
, idle_action
), SD_BUS_VTABLE_PROPERTY_CONST
),
2510 SD_BUS_PROPERTY("IdleActionUSec", "t", NULL
, offsetof(Manager
, idle_action_usec
), SD_BUS_VTABLE_PROPERTY_CONST
),
2511 SD_BUS_PROPERTY("PreparingForShutdown", "b", property_get_preparing
, 0, 0),
2512 SD_BUS_PROPERTY("PreparingForSleep", "b", property_get_preparing
, 0, 0),
2513 SD_BUS_PROPERTY("ScheduledShutdown", "(st)", property_get_scheduled_shutdown
, 0, 0),
2514 SD_BUS_PROPERTY("Docked", "b", property_get_docked
, 0, 0),
2516 SD_BUS_METHOD("GetSession", "s", "o", method_get_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2517 SD_BUS_METHOD("GetSessionByPID", "u", "o", method_get_session_by_pid
, SD_BUS_VTABLE_UNPRIVILEGED
),
2518 SD_BUS_METHOD("GetUser", "u", "o", method_get_user
, SD_BUS_VTABLE_UNPRIVILEGED
),
2519 SD_BUS_METHOD("GetUserByPID", "u", "o", method_get_user_by_pid
, SD_BUS_VTABLE_UNPRIVILEGED
),
2520 SD_BUS_METHOD("GetSeat", "s", "o", method_get_seat
, SD_BUS_VTABLE_UNPRIVILEGED
),
2521 SD_BUS_METHOD("ListSessions", NULL
, "a(susso)", method_list_sessions
, SD_BUS_VTABLE_UNPRIVILEGED
),
2522 SD_BUS_METHOD("ListUsers", NULL
, "a(uso)", method_list_users
, SD_BUS_VTABLE_UNPRIVILEGED
),
2523 SD_BUS_METHOD("ListSeats", NULL
, "a(so)", method_list_seats
, SD_BUS_VTABLE_UNPRIVILEGED
),
2524 SD_BUS_METHOD("ListInhibitors", NULL
, "a(ssssuu)", method_list_inhibitors
, SD_BUS_VTABLE_UNPRIVILEGED
),
2525 SD_BUS_METHOD("CreateSession", "uusssssussbssa(sv)", "soshusub", method_create_session
, 0),
2526 SD_BUS_METHOD("ReleaseSession", "s", NULL
, method_release_session
, 0),
2527 SD_BUS_METHOD("ActivateSession", "s", NULL
, method_activate_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2528 SD_BUS_METHOD("ActivateSessionOnSeat", "ss", NULL
, method_activate_session_on_seat
, SD_BUS_VTABLE_UNPRIVILEGED
),
2529 SD_BUS_METHOD("LockSession", "s", NULL
, method_lock_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2530 SD_BUS_METHOD("UnlockSession", "s", NULL
, method_lock_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2531 SD_BUS_METHOD("LockSessions", NULL
, NULL
, method_lock_sessions
, SD_BUS_VTABLE_UNPRIVILEGED
),
2532 SD_BUS_METHOD("UnlockSessions", NULL
, NULL
, method_lock_sessions
, SD_BUS_VTABLE_UNPRIVILEGED
),
2533 SD_BUS_METHOD("KillSession", "ssi", NULL
, method_kill_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2534 SD_BUS_METHOD("KillUser", "ui", NULL
, method_kill_user
, SD_BUS_VTABLE_UNPRIVILEGED
),
2535 SD_BUS_METHOD("TerminateSession", "s", NULL
, method_terminate_session
, SD_BUS_VTABLE_UNPRIVILEGED
),
2536 SD_BUS_METHOD("TerminateUser", "u", NULL
, method_terminate_user
, SD_BUS_VTABLE_UNPRIVILEGED
),
2537 SD_BUS_METHOD("TerminateSeat", "s", NULL
, method_terminate_seat
, SD_BUS_VTABLE_UNPRIVILEGED
),
2538 SD_BUS_METHOD("SetUserLinger", "ubb", NULL
, method_set_user_linger
, SD_BUS_VTABLE_UNPRIVILEGED
),
2539 SD_BUS_METHOD("AttachDevice", "ssb", NULL
, method_attach_device
, SD_BUS_VTABLE_UNPRIVILEGED
),
2540 SD_BUS_METHOD("FlushDevices", "b", NULL
, method_flush_devices
, SD_BUS_VTABLE_UNPRIVILEGED
),
2541 SD_BUS_METHOD("PowerOff", "b", NULL
, method_poweroff
, SD_BUS_VTABLE_UNPRIVILEGED
),
2542 SD_BUS_METHOD("Reboot", "b", NULL
, method_reboot
, SD_BUS_VTABLE_UNPRIVILEGED
),
2543 SD_BUS_METHOD("Suspend", "b", NULL
, method_suspend
, SD_BUS_VTABLE_UNPRIVILEGED
),
2544 SD_BUS_METHOD("Hibernate", "b", NULL
, method_hibernate
, SD_BUS_VTABLE_UNPRIVILEGED
),
2545 SD_BUS_METHOD("HybridSleep", "b", NULL
, method_hybrid_sleep
, SD_BUS_VTABLE_UNPRIVILEGED
),
2546 SD_BUS_METHOD("CanPowerOff", NULL
, "s", method_can_poweroff
, SD_BUS_VTABLE_UNPRIVILEGED
),
2547 SD_BUS_METHOD("CanReboot", NULL
, "s", method_can_reboot
, SD_BUS_VTABLE_UNPRIVILEGED
),
2548 SD_BUS_METHOD("CanSuspend", NULL
, "s", method_can_suspend
, SD_BUS_VTABLE_UNPRIVILEGED
),
2549 SD_BUS_METHOD("CanHibernate", NULL
, "s", method_can_hibernate
, SD_BUS_VTABLE_UNPRIVILEGED
),
2550 SD_BUS_METHOD("CanHybridSleep", NULL
, "s", method_can_hybrid_sleep
, SD_BUS_VTABLE_UNPRIVILEGED
),
2551 SD_BUS_METHOD("ScheduleShutdown", "st", NULL
, method_schedule_shutdown
, SD_BUS_VTABLE_UNPRIVILEGED
),
2552 SD_BUS_METHOD("CancelScheduledShutdown", NULL
, "b", method_cancel_scheduled_shutdown
, SD_BUS_VTABLE_UNPRIVILEGED
),
2553 SD_BUS_METHOD("Inhibit", "ssss", "h", method_inhibit
, SD_BUS_VTABLE_UNPRIVILEGED
),
2554 SD_BUS_METHOD("CanRebootToFirmwareSetup", NULL
, "s", method_can_reboot_to_firmware_setup
, SD_BUS_VTABLE_UNPRIVILEGED
),
2555 SD_BUS_METHOD("SetRebootToFirmwareSetup", "b", NULL
, method_set_reboot_to_firmware_setup
, SD_BUS_VTABLE_UNPRIVILEGED
),
2556 SD_BUS_METHOD("SetWallMessage", "sb", NULL
, method_set_wall_message
, SD_BUS_VTABLE_UNPRIVILEGED
),
2558 SD_BUS_SIGNAL("SessionNew", "so", 0),
2559 SD_BUS_SIGNAL("SessionRemoved", "so", 0),
2560 SD_BUS_SIGNAL("UserNew", "uo", 0),
2561 SD_BUS_SIGNAL("UserRemoved", "uo", 0),
2562 SD_BUS_SIGNAL("SeatNew", "so", 0),
2563 SD_BUS_SIGNAL("SeatRemoved", "so", 0),
2564 SD_BUS_SIGNAL("PrepareForShutdown", "b", 0),
2565 SD_BUS_SIGNAL("PrepareForSleep", "b", 0),
2570 static int session_jobs_reply(Session
*s
, const char *unit
, const char *result
) {
2579 if (streq(result
, "done"))
2580 r
= session_send_create_reply(s
, NULL
);
2582 _cleanup_(sd_bus_error_free
) sd_bus_error e
= SD_BUS_ERROR_NULL
;
2584 sd_bus_error_setf(&e
, BUS_ERROR_JOB_FAILED
, "Start job for unit %s failed with '%s'", unit
, result
);
2585 r
= session_send_create_reply(s
, &e
);
2591 int match_job_removed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2592 const char *path
, *result
, *unit
;
2593 Manager
*m
= userdata
;
2602 r
= sd_bus_message_read(message
, "uoss", &id
, &path
, &unit
, &result
);
2604 bus_log_parse_error(r
);
2608 if (m
->action_job
&& streq(m
->action_job
, path
)) {
2609 log_info("Operation '%s' finished.", inhibit_what_to_string(m
->action_what
));
2611 /* Tell people that they now may take a lock again */
2612 send_prepare_for(m
, m
->action_what
, false);
2614 m
->action_job
= mfree(m
->action_job
);
2615 m
->action_unit
= NULL
;
2620 session
= hashmap_get(m
->session_units
, unit
);
2621 if (session
&& streq_ptr(path
, session
->scope_job
)) {
2622 session
->scope_job
= mfree(session
->scope_job
);
2623 session_jobs_reply(session
, unit
, result
);
2625 session_save(session
);
2626 user_save(session
->user
);
2627 session_add_to_gc_queue(session
);
2630 user
= hashmap_get(m
->user_units
, unit
);
2632 (streq_ptr(path
, user
->service_job
) ||
2633 streq_ptr(path
, user
->slice_job
))) {
2635 if (streq_ptr(path
, user
->service_job
))
2636 user
->service_job
= mfree(user
->service_job
);
2638 if (streq_ptr(path
, user
->slice_job
))
2639 user
->slice_job
= mfree(user
->slice_job
);
2641 LIST_FOREACH(sessions_by_user
, session
, user
->sessions
)
2642 session_jobs_reply(session
, unit
, result
);
2645 user_add_to_gc_queue(user
);
2651 int match_unit_removed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2652 const char *path
, *unit
;
2653 Manager
*m
= userdata
;
2661 r
= sd_bus_message_read(message
, "so", &unit
, &path
);
2663 bus_log_parse_error(r
);
2667 session
= hashmap_get(m
->session_units
, unit
);
2669 session_add_to_gc_queue(session
);
2671 user
= hashmap_get(m
->user_units
, unit
);
2673 user_add_to_gc_queue(user
);
2678 int match_properties_changed(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2679 _cleanup_free_
char *unit
= NULL
;
2680 Manager
*m
= userdata
;
2689 path
= sd_bus_message_get_path(message
);
2693 r
= unit_name_from_dbus_path(path
, &unit
);
2694 if (r
== -EINVAL
) /* not a unit */
2701 session
= hashmap_get(m
->session_units
, unit
);
2703 session_add_to_gc_queue(session
);
2705 user
= hashmap_get(m
->user_units
, unit
);
2707 user_add_to_gc_queue(user
);
2712 int match_reloading(sd_bus_message
*message
, void *userdata
, sd_bus_error
*error
) {
2713 Manager
*m
= userdata
;
2721 r
= sd_bus_message_read(message
, "b", &b
);
2723 bus_log_parse_error(r
);
2730 /* systemd finished reloading, let's recheck all our sessions */
2731 log_debug("System manager has been reloaded, rechecking sessions...");
2733 HASHMAP_FOREACH(session
, m
->sessions
, i
)
2734 session_add_to_gc_queue(session
);
2739 int manager_send_changed(Manager
*manager
, const char *property
, ...) {
2744 l
= strv_from_stdarg_alloca(property
);
2746 return sd_bus_emit_properties_changed_strv(
2748 "/org/freedesktop/login1",
2749 "org.freedesktop.login1.Manager",
2753 static int strdup_job(sd_bus_message
*reply
, char **job
) {
2758 r
= sd_bus_message_read(reply
, "o", &j
);
2770 int manager_start_slice(
2773 const char *description
,
2777 sd_bus_error
*error
,
2780 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
, *reply
= NULL
;
2787 r
= sd_bus_message_new_method_call(
2790 "org.freedesktop.systemd1",
2791 "/org/freedesktop/systemd1",
2792 "org.freedesktop.systemd1.Manager",
2793 "StartTransientUnit");
2797 r
= sd_bus_message_append(m
, "ss", strempty(slice
), "fail");
2801 r
= sd_bus_message_open_container(m
, 'a', "(sv)");
2805 if (!isempty(description
)) {
2806 r
= sd_bus_message_append(m
, "(sv)", "Description", "s", description
);
2811 if (!isempty(after
)) {
2812 r
= sd_bus_message_append(m
, "(sv)", "After", "as", 1, after
);
2817 if (!isempty(after2
)) {
2818 r
= sd_bus_message_append(m
, "(sv)", "After", "as", 1, after2
);
2823 r
= sd_bus_message_append(m
, "(sv)", "TasksMax", "t", tasks_max
);
2827 r
= sd_bus_message_close_container(m
);
2831 r
= sd_bus_message_append(m
, "a(sa(sv))", 0);
2835 r
= sd_bus_call(manager
->bus
, m
, 0, error
, &reply
);
2839 return strdup_job(reply
, job
);
2842 int manager_start_scope(
2847 const char *description
,
2851 sd_bus_error
*error
,
2854 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*m
= NULL
, *reply
= NULL
;
2862 r
= sd_bus_message_new_method_call(
2865 "org.freedesktop.systemd1",
2866 "/org/freedesktop/systemd1",
2867 "org.freedesktop.systemd1.Manager",
2868 "StartTransientUnit");
2872 r
= sd_bus_message_append(m
, "ss", strempty(scope
), "fail");
2876 r
= sd_bus_message_open_container(m
, 'a', "(sv)");
2880 if (!isempty(slice
)) {
2881 r
= sd_bus_message_append(m
, "(sv)", "Slice", "s", slice
);
2886 if (!isempty(description
)) {
2887 r
= sd_bus_message_append(m
, "(sv)", "Description", "s", description
);
2892 if (!isempty(after
)) {
2893 r
= sd_bus_message_append(m
, "(sv)", "After", "as", 1, after
);
2898 if (!isempty(after2
)) {
2899 r
= sd_bus_message_append(m
, "(sv)", "After", "as", 1, after2
);
2904 /* cgroup empty notification is not available in containers
2905 * currently. To make this less problematic, let's shorten the
2906 * stop timeout for sessions, so that we don't wait
2909 /* Make sure that the session shells are terminated with
2910 * SIGHUP since bash and friends tend to ignore SIGTERM */
2911 r
= sd_bus_message_append(m
, "(sv)", "SendSIGHUP", "b", true);
2915 r
= sd_bus_message_append(m
, "(sv)", "PIDs", "au", 1, pid
);
2919 r
= sd_bus_message_append(m
, "(sv)", "TasksMax", "t", tasks_max
);
2923 r
= sd_bus_message_close_container(m
);
2927 r
= sd_bus_message_append(m
, "a(sa(sv))", 0);
2931 r
= sd_bus_call(manager
->bus
, m
, 0, error
, &reply
);
2935 return strdup_job(reply
, job
);
2938 int manager_start_unit(Manager
*manager
, const char *unit
, sd_bus_error
*error
, char **job
) {
2939 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2946 r
= sd_bus_call_method(
2948 "org.freedesktop.systemd1",
2949 "/org/freedesktop/systemd1",
2950 "org.freedesktop.systemd1.Manager",
2954 "ss", unit
, "replace");
2958 return strdup_job(reply
, job
);
2961 int manager_stop_unit(Manager
*manager
, const char *unit
, sd_bus_error
*error
, char **job
) {
2962 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
2969 r
= sd_bus_call_method(
2971 "org.freedesktop.systemd1",
2972 "/org/freedesktop/systemd1",
2973 "org.freedesktop.systemd1.Manager",
2977 "ss", unit
, "fail");
2979 if (sd_bus_error_has_name(error
, BUS_ERROR_NO_SUCH_UNIT
) ||
2980 sd_bus_error_has_name(error
, BUS_ERROR_LOAD_FAILED
)) {
2983 sd_bus_error_free(error
);
2990 return strdup_job(reply
, job
);
2993 int manager_abandon_scope(Manager
*manager
, const char *scope
, sd_bus_error
*error
) {
2994 _cleanup_free_
char *path
= NULL
;
3000 path
= unit_dbus_path_from_name(scope
);
3004 r
= sd_bus_call_method(
3006 "org.freedesktop.systemd1",
3008 "org.freedesktop.systemd1.Scope",
3014 if (sd_bus_error_has_name(error
, BUS_ERROR_NO_SUCH_UNIT
) ||
3015 sd_bus_error_has_name(error
, BUS_ERROR_LOAD_FAILED
) ||
3016 sd_bus_error_has_name(error
, BUS_ERROR_SCOPE_NOT_RUNNING
)) {
3017 sd_bus_error_free(error
);
3027 int manager_kill_unit(Manager
*manager
, const char *unit
, KillWho who
, int signo
, sd_bus_error
*error
) {
3031 return sd_bus_call_method(
3033 "org.freedesktop.systemd1",
3034 "/org/freedesktop/systemd1",
3035 "org.freedesktop.systemd1.Manager",
3039 "ssi", unit
, who
== KILL_LEADER
? "main" : "all", signo
);
3042 int manager_unit_is_active(Manager
*manager
, const char *unit
) {
3043 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
3044 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
3045 _cleanup_free_
char *path
= NULL
;
3052 path
= unit_dbus_path_from_name(unit
);
3056 r
= sd_bus_get_property(
3058 "org.freedesktop.systemd1",
3060 "org.freedesktop.systemd1.Unit",
3066 /* systemd might have droppped off momentarily, let's
3067 * not make this an error */
3068 if (sd_bus_error_has_name(&error
, SD_BUS_ERROR_NO_REPLY
) ||
3069 sd_bus_error_has_name(&error
, SD_BUS_ERROR_DISCONNECTED
))
3072 /* If the unit is already unloaded then it's not
3074 if (sd_bus_error_has_name(&error
, BUS_ERROR_NO_SUCH_UNIT
) ||
3075 sd_bus_error_has_name(&error
, BUS_ERROR_LOAD_FAILED
))
3081 r
= sd_bus_message_read(reply
, "s", &state
);
3085 return !streq(state
, "inactive") && !streq(state
, "failed");
3088 int manager_job_is_active(Manager
*manager
, const char *path
) {
3089 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
3090 _cleanup_(sd_bus_message_unrefp
) sd_bus_message
*reply
= NULL
;
3096 r
= sd_bus_get_property(
3098 "org.freedesktop.systemd1",
3100 "org.freedesktop.systemd1.Job",
3106 if (sd_bus_error_has_name(&error
, SD_BUS_ERROR_NO_REPLY
) ||
3107 sd_bus_error_has_name(&error
, SD_BUS_ERROR_DISCONNECTED
))
3110 if (sd_bus_error_has_name(&error
, SD_BUS_ERROR_UNKNOWN_OBJECT
))
3116 /* We don't actually care about the state really. The fact
3117 * that we could read the job state is enough for us */