]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/login/logind-dbus.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
logind: introduce an explicit session class for cronjobs and similar
[thirdparty/systemd.git] / src / login / logind-dbus.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2011 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include <pwd.h>
26
27 #include "logind.h"
28 #include "dbus-common.h"
29 #include "strv.h"
30 #include "mkdir.h"
31 #include "path-util.h"
32 #include "polkit.h"
33 #include "special.h"
34 #include "systemd/sd-id128.h"
35 #include "systemd/sd-messages.h"
36 #include "fileio-label.h"
37 #include "label.h"
38
39 #define BUS_MANAGER_INTERFACE \
40 " <interface name=\"org.freedesktop.login1.Manager\">\n" \
41 " <method name=\"GetSession\">\n" \
42 " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
43 " <arg name=\"session\" type=\"o\" direction=\"out\"/>\n" \
44 " </method>\n" \
45 " <method name=\"GetSessionByPID\">\n" \
46 " <arg name=\"pid\" type=\"u\" direction=\"in\"/>\n" \
47 " <arg name=\"session\" type=\"o\" direction=\"out\"/>\n" \
48 " </method>\n" \
49 " <method name=\"GetUser\">\n" \
50 " <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
51 " <arg name=\"user\" type=\"o\" direction=\"out\"/>\n" \
52 " </method>\n" \
53 " <method name=\"GetSeat\">\n" \
54 " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
55 " <arg name=\"seat\" type=\"o\" direction=\"out\"/>\n" \
56 " </method>\n" \
57 " <method name=\"ListSessions\">\n" \
58 " <arg name=\"sessions\" type=\"a(susso)\" direction=\"out\"/>\n" \
59 " </method>\n" \
60 " <method name=\"ListUsers\">\n" \
61 " <arg name=\"users\" type=\"a(uso)\" direction=\"out\"/>\n" \
62 " </method>\n" \
63 " <method name=\"ListSeats\">\n" \
64 " <arg name=\"seats\" type=\"a(so)\" direction=\"out\"/>\n" \
65 " </method>\n" \
66 " <method name=\"CreateSession\">\n" \
67 " <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
68 " <arg name=\"leader\" type=\"u\" direction=\"in\"/>\n" \
69 " <arg name=\"sevice\" type=\"s\" direction=\"in\"/>\n" \
70 " <arg name=\"type\" type=\"s\" direction=\"in\"/>\n" \
71 " <arg name=\"class\" type=\"s\" direction=\"in\"/>\n" \
72 " <arg name=\"seat\" type=\"s\" direction=\"in\"/>\n" \
73 " <arg name=\"vtnr\" type=\"u\" direction=\"in\"/>\n" \
74 " <arg name=\"tty\" type=\"s\" direction=\"in\"/>\n" \
75 " <arg name=\"display\" type=\"s\" direction=\"in\"/>\n" \
76 " <arg name=\"remote\" type=\"b\" direction=\"in\"/>\n" \
77 " <arg name=\"remote_user\" type=\"s\" direction=\"in\"/>\n" \
78 " <arg name=\"remote_host\" type=\"s\" direction=\"in\"/>\n" \
79 " <arg name=\"controllers\" type=\"as\" direction=\"in\"/>\n" \
80 " <arg name=\"reset_controllers\" type=\"as\" direction=\"in\"/>\n" \
81 " <arg name=\"kill_processes\" type=\"b\" direction=\"in\"/>\n" \
82 " <arg name=\"id\" type=\"s\" direction=\"out\"/>\n" \
83 " <arg name=\"path\" type=\"o\" direction=\"out\"/>\n" \
84 " <arg name=\"runtime_path\" type=\"o\" direction=\"out\"/>\n" \
85 " <arg name=\"fd\" type=\"h\" direction=\"out\"/>\n" \
86 " <arg name=\"seat\" type=\"s\" direction=\"out\"/>\n" \
87 " <arg name=\"vtnr\" type=\"u\" direction=\"out\"/>\n" \
88 " <arg name=\"existing\" type=\"b\" direction=\"out\"/>\n" \
89 " </method>\n" \
90 " <method name=\"ReleaseSession\">\n" \
91 " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
92 " </method>\n" \
93 " <method name=\"ActivateSession\">\n" \
94 " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
95 " </method>\n" \
96 " <method name=\"ActivateSessionOnSeat\">\n" \
97 " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
98 " <arg name=\"seat\" type=\"s\" direction=\"in\"/>\n" \
99 " </method>\n" \
100 " <method name=\"LockSession\">\n" \
101 " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
102 " </method>\n" \
103 " <method name=\"UnlockSession\">\n" \
104 " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
105 " </method>\n" \
106 " <method name=\"LockSessions\"/>\n" \
107 " <method name=\"UnlockSessions\"/>\n" \
108 " <method name=\"KillSession\">\n" \
109 " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
110 " <arg name=\"who\" type=\"s\" direction=\"in\"/>\n" \
111 " <arg name=\"signal\" type=\"s\" direction=\"in\"/>\n" \
112 " </method>\n" \
113 " <method name=\"KillUser\">\n" \
114 " <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
115 " <arg name=\"signal\" type=\"s\" direction=\"in\"/>\n" \
116 " </method>\n" \
117 " <method name=\"TerminateSession\">\n" \
118 " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
119 " </method>\n" \
120 " <method name=\"TerminateUser\">\n" \
121 " <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
122 " </method>\n" \
123 " <method name=\"TerminateSeat\">\n" \
124 " <arg name=\"id\" type=\"s\" direction=\"in\"/>\n" \
125 " </method>\n" \
126 " <method name=\"SetUserLinger\">\n" \
127 " <arg name=\"uid\" type=\"u\" direction=\"in\"/>\n" \
128 " <arg name=\"b\" type=\"b\" direction=\"in\"/>\n" \
129 " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
130 " </method>\n" \
131 " <method name=\"AttachDevice\">\n" \
132 " <arg name=\"seat\" type=\"s\" direction=\"in\"/>\n" \
133 " <arg name=\"sysfs\" type=\"s\" direction=\"in\"/>\n" \
134 " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
135 " </method>\n" \
136 " <method name=\"FlushDevices\">\n" \
137 " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
138 " </method>\n" \
139 " <method name=\"PowerOff\">\n" \
140 " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
141 " </method>\n" \
142 " <method name=\"Reboot\">\n" \
143 " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
144 " </method>\n" \
145 " <method name=\"Suspend\">\n" \
146 " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
147 " </method>\n" \
148 " <method name=\"Hibernate\">\n" \
149 " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
150 " </method>\n" \
151 " <method name=\"HybridSleep\">\n" \
152 " <arg name=\"interactive\" type=\"b\" direction=\"in\"/>\n" \
153 " </method>\n" \
154 " <method name=\"CanPowerOff\">\n" \
155 " <arg name=\"result\" type=\"s\" direction=\"out\"/>\n" \
156 " </method>\n" \
157 " <method name=\"CanReboot\">\n" \
158 " <arg name=\"result\" type=\"s\" direction=\"out\"/>\n" \
159 " </method>\n" \
160 " <method name=\"CanSuspend\">\n" \
161 " <arg name=\"result\" type=\"s\" direction=\"out\"/>\n" \
162 " </method>\n" \
163 " <method name=\"CanHibernate\">\n" \
164 " <arg name=\"result\" type=\"s\" direction=\"out\"/>\n" \
165 " </method>\n" \
166 " <method name=\"CanHybridSleep\">\n" \
167 " <arg name=\"result\" type=\"s\" direction=\"out\"/>\n" \
168 " </method>\n" \
169 " <method name=\"Inhibit\">\n" \
170 " <arg name=\"what\" type=\"s\" direction=\"in\"/>\n" \
171 " <arg name=\"who\" type=\"s\" direction=\"in\"/>\n" \
172 " <arg name=\"why\" type=\"s\" direction=\"in\"/>\n" \
173 " <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
174 " <arg name=\"fd\" type=\"h\" direction=\"out\"/>\n" \
175 " </method>\n" \
176 " <method name=\"ListInhibitors\">\n" \
177 " <arg name=\"inhibitors\" type=\"a(ssssuu)\" direction=\"out\"/>\n" \
178 " </method>\n" \
179 " <signal name=\"SessionNew\">\n" \
180 " <arg name=\"id\" type=\"s\"/>\n" \
181 " <arg name=\"path\" type=\"o\"/>\n" \
182 " </signal>\n" \
183 " <signal name=\"SessionRemoved\">\n" \
184 " <arg name=\"id\" type=\"s\"/>\n" \
185 " <arg name=\"path\" type=\"o\"/>\n" \
186 " </signal>\n" \
187 " <signal name=\"UserNew\">\n" \
188 " <arg name=\"uid\" type=\"u\"/>\n" \
189 " <arg name=\"path\" type=\"o\"/>\n" \
190 " </signal>\n" \
191 " <signal name=\"UserRemoved\">\n" \
192 " <arg name=\"uid\" type=\"u\"/>\n" \
193 " <arg name=\"path\" type=\"o\"/>\n" \
194 " </signal>\n" \
195 " <signal name=\"SeatNew\">\n" \
196 " <arg name=\"id\" type=\"s\"/>\n" \
197 " <arg name=\"path\" type=\"o\"/>\n" \
198 " </signal>\n" \
199 " <signal name=\"SeatRemoved\">\n" \
200 " <arg name=\"id\" type=\"s\"/>\n" \
201 " <arg name=\"path\" type=\"o\"/>\n" \
202 " </signal>\n" \
203 " <signal name=\"PrepareForShutdown\">\n" \
204 " <arg name=\"active\" type=\"b\"/>\n" \
205 " </signal>\n" \
206 " <signal name=\"PrepareForSleep\">\n" \
207 " <arg name=\"active\" type=\"b\"/>\n" \
208 " </signal>\n" \
209 " <property name=\"ControlGroupHierarchy\" type=\"s\" access=\"read\"/>\n" \
210 " <property name=\"Controllers\" type=\"as\" access=\"read\"/>\n" \
211 " <property name=\"ResetControllers\" type=\"as\" access=\"read\"/>\n" \
212 " <property name=\"NAutoVTs\" type=\"u\" access=\"read\"/>\n" \
213 " <property name=\"KillOnlyUsers\" type=\"as\" access=\"read\"/>\n" \
214 " <property name=\"KillExcludeUsers\" type=\"as\" access=\"read\"/>\n" \
215 " <property name=\"KillUserProcesses\" type=\"b\" access=\"read\"/>\n" \
216 " <property name=\"IdleHint\" type=\"b\" access=\"read\"/>\n" \
217 " <property name=\"IdleSinceHint\" type=\"t\" access=\"read\"/>\n" \
218 " <property name=\"IdleSinceHintMonotonic\" type=\"t\" access=\"read\"/>\n" \
219 " <property name=\"BlockInhibited\" type=\"s\" access=\"read\"/>\n" \
220 " <property name=\"DelayInhibited\" type=\"s\" access=\"read\"/>\n" \
221 " <property name=\"InhibitDelayMaxUSec\" type=\"t\" access=\"read\"/>\n" \
222 " <property name=\"HandlePowerKey\" type=\"s\" access=\"read\"/>\n" \
223 " <property name=\"HandleSuspendKey\" type=\"s\" access=\"read\"/>\n" \
224 " <property name=\"HandleHibernateKey\" type=\"s\" access=\"read\"/>\n" \
225 " <property name=\"HandleLidSwitch\" type=\"s\" access=\"read\"/>\n" \
226 " <property name=\"IdleAction\" type=\"s\" access=\"read\"/>\n" \
227 " <property name=\"IdleActionUSec\" type=\"t\" access=\"read\"/>\n" \
228 " <property name=\"PreparingForShutdown\" type=\"b\" access=\"read\"/>\n" \
229 " <property name=\"PreparingForSleep\" type=\"b\" access=\"read\"/>\n" \
230 " </interface>\n"
231
232 #define INTROSPECTION_BEGIN \
233 DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
234 "<node>\n" \
235 BUS_MANAGER_INTERFACE \
236 BUS_PROPERTIES_INTERFACE \
237 BUS_PEER_INTERFACE \
238 BUS_INTROSPECTABLE_INTERFACE
239
240 #define INTROSPECTION_END \
241 "</node>\n"
242
243 #define INTERFACES_LIST \
244 BUS_GENERIC_INTERFACES_LIST \
245 "org.freedesktop.login1.Manager\0"
246
247 static int bus_manager_append_idle_hint(DBusMessageIter *i, const char *property, void *data) {
248 Manager *m = data;
249 dbus_bool_t b;
250
251 assert(i);
252 assert(property);
253 assert(m);
254
255 b = manager_get_idle_hint(m, NULL) > 0;
256 if (!dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b))
257 return -ENOMEM;
258
259 return 0;
260 }
261
262 static int bus_manager_append_idle_hint_since(DBusMessageIter *i, const char *property, void *data) {
263 Manager *m = data;
264 dual_timestamp t;
265 uint64_t u;
266
267 assert(i);
268 assert(property);
269 assert(m);
270
271 manager_get_idle_hint(m, &t);
272 u = streq(property, "IdleSinceHint") ? t.realtime : t.monotonic;
273
274 if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
275 return -ENOMEM;
276
277 return 0;
278 }
279
280 static int bus_manager_append_inhibited(DBusMessageIter *i, const char *property, void *data) {
281 Manager *m = data;
282 InhibitWhat w;
283 const char *p;
284
285 w = manager_inhibit_what(m, streq(property, "BlockInhibited") ? INHIBIT_BLOCK : INHIBIT_DELAY);
286 p = inhibit_what_to_string(w);
287
288 if (!dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &p))
289 return -ENOMEM;
290
291 return 0;
292 }
293
294 static int bus_manager_append_preparing(DBusMessageIter *i, const char *property, void *data) {
295 Manager *m = data;
296 dbus_bool_t b;
297
298 assert(i);
299 assert(property);
300
301 if (streq(property, "PreparingForShutdown"))
302 b = !!(m->action_what & INHIBIT_SHUTDOWN);
303 else
304 b = !!(m->action_what & INHIBIT_SLEEP);
305
306 dbus_message_iter_append_basic(i, DBUS_TYPE_BOOLEAN, &b);
307 return 0;
308 }
309
310 static int bus_manager_create_session(Manager *m, DBusMessage *message, DBusMessage **_reply) {
311 const char *type, *class, *cseat, *tty, *display, *remote_user, *remote_host, *service;
312 uint32_t uid, leader, audit_id = 0;
313 dbus_bool_t remote, kill_processes, exists;
314 _cleanup_strv_free_ char **controllers = NULL, **reset_controllers = NULL;
315 _cleanup_free_ char *cgroup = NULL, *id = NULL, *p = NULL;
316 SessionType t;
317 SessionClass c;
318 DBusMessageIter iter;
319 int r;
320 uint32_t vtnr = 0;
321 _cleanup_close_ int fifo_fd = -1;
322 _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
323 Session *session = NULL;
324 User *user = NULL;
325 Seat *seat = NULL;
326 bool b;
327
328 assert(m);
329 assert(message);
330 assert(_reply);
331
332 if (!dbus_message_iter_init(message, &iter) ||
333 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
334 return -EINVAL;
335
336 dbus_message_iter_get_basic(&iter, &uid);
337
338 if (!dbus_message_iter_next(&iter) ||
339 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
340 return -EINVAL;
341
342 dbus_message_iter_get_basic(&iter, &leader);
343
344 if (leader <= 0 ||
345 !dbus_message_iter_next(&iter) ||
346 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
347 return -EINVAL;
348
349 dbus_message_iter_get_basic(&iter, &service);
350
351 if (!dbus_message_iter_next(&iter) ||
352 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
353 return -EINVAL;
354
355 dbus_message_iter_get_basic(&iter, &type);
356 if (isempty(type))
357 t = _SESSION_TYPE_INVALID;
358 else {
359 t = session_type_from_string(type);
360 if (t < 0)
361 return -EINVAL;
362 }
363
364 if (!dbus_message_iter_next(&iter) ||
365 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
366 return -EINVAL;
367
368 dbus_message_iter_get_basic(&iter, &class);
369 if (isempty(class))
370 c = _SESSION_CLASS_INVALID;
371 else {
372 c = session_class_from_string(class);
373 if (c < 0)
374 return -EINVAL;
375 }
376
377 if (!dbus_message_iter_next(&iter) ||
378 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
379 return -EINVAL;
380
381 dbus_message_iter_get_basic(&iter, &cseat);
382
383 if (isempty(cseat))
384 seat = NULL;
385 else {
386 seat = hashmap_get(m->seats, cseat);
387 if (!seat)
388 return -ENOENT;
389 }
390
391 if (!dbus_message_iter_next(&iter) ||
392 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
393 return -EINVAL;
394
395 dbus_message_iter_get_basic(&iter, &vtnr);
396
397 if (!dbus_message_iter_next(&iter) ||
398 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
399 return -EINVAL;
400
401 dbus_message_iter_get_basic(&iter, &tty);
402
403 if (tty_is_vc(tty)) {
404 int v;
405
406 if (!seat)
407 seat = m->vtconsole;
408 else if (seat != m->vtconsole)
409 return -EINVAL;
410
411 v = vtnr_from_tty(tty);
412
413 if (v <= 0)
414 return v < 0 ? v : -EINVAL;
415
416 if (vtnr <= 0)
417 vtnr = (uint32_t) v;
418 else if (vtnr != (uint32_t) v)
419 return -EINVAL;
420 } else if (tty_is_console(tty)) {
421
422 if (!seat)
423 seat = m->vtconsole;
424 else if (seat != m->vtconsole)
425 return -EINVAL;
426
427 if (vtnr != 0)
428 return -EINVAL;
429 }
430
431 if (seat) {
432 if (seat_can_multi_session(seat)) {
433 if (vtnr > 63)
434 return -EINVAL;
435 } else {
436 if (vtnr != 0)
437 return -EINVAL;
438 }
439 }
440
441 if (!dbus_message_iter_next(&iter) ||
442 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
443 return -EINVAL;
444
445 dbus_message_iter_get_basic(&iter, &display);
446
447 if (!dbus_message_iter_next(&iter) ||
448 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
449 return -EINVAL;
450
451 if (t == _SESSION_TYPE_INVALID) {
452 if (!isempty(display))
453 t = SESSION_X11;
454 else if (!isempty(tty))
455 t = SESSION_TTY;
456 else
457 t = SESSION_UNSPECIFIED;
458 }
459
460 if (c == _SESSION_CLASS_INVALID) {
461 if (!isempty(display) || !isempty(tty))
462 c = SESSION_USER;
463 else
464 c = SESSION_BACKGROUND;
465 }
466
467 dbus_message_iter_get_basic(&iter, &remote);
468
469 if (!dbus_message_iter_next(&iter) ||
470 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
471 return -EINVAL;
472
473 dbus_message_iter_get_basic(&iter, &remote_user);
474
475 if (!dbus_message_iter_next(&iter) ||
476 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
477 return -EINVAL;
478
479 dbus_message_iter_get_basic(&iter, &remote_host);
480
481 if (!dbus_message_iter_next(&iter) ||
482 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
483 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRING)
484 return -EINVAL;
485
486 r = bus_parse_strv_iter(&iter, &controllers);
487 if (r < 0)
488 return -EINVAL;
489
490 if (strv_contains(controllers, "systemd") ||
491 !dbus_message_iter_next(&iter) ||
492 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
493 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRING) {
494 r = -EINVAL;
495 goto fail;
496 }
497
498 r = bus_parse_strv_iter(&iter, &reset_controllers);
499 if (r < 0)
500 goto fail;
501
502 if (strv_contains(reset_controllers, "systemd") ||
503 !dbus_message_iter_next(&iter) ||
504 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN) {
505 r = -EINVAL;
506 goto fail;
507 }
508
509 dbus_message_iter_get_basic(&iter, &kill_processes);
510
511 r = cg_pid_get_cgroup(leader, NULL, &cgroup);
512 if (r < 0)
513 goto fail;
514
515 r = manager_get_session_by_cgroup(m, cgroup, &session);
516 if (r < 0)
517 goto fail;
518
519 if (session) {
520 fifo_fd = session_create_fifo(session);
521 if (fifo_fd < 0) {
522 r = fifo_fd;
523 goto fail;
524 }
525
526 /* Session already exists, client is probably
527 * something like "su" which changes uid but
528 * is still the same audit session */
529
530 reply = dbus_message_new_method_return(message);
531 if (!reply) {
532 r = -ENOMEM;
533 goto fail;
534 }
535
536 p = session_bus_path(session);
537 if (!p) {
538 r = -ENOMEM;
539 goto fail;
540 }
541
542 cseat = session->seat ? session->seat->id : "";
543 vtnr = session->vtnr;
544 exists = true;
545
546 b = dbus_message_append_args(
547 reply,
548 DBUS_TYPE_STRING, &session->id,
549 DBUS_TYPE_OBJECT_PATH, &p,
550 DBUS_TYPE_STRING, &session->user->runtime_path,
551 DBUS_TYPE_UNIX_FD, &fifo_fd,
552 DBUS_TYPE_STRING, &cseat,
553 DBUS_TYPE_UINT32, &vtnr,
554 DBUS_TYPE_BOOLEAN, &exists,
555 DBUS_TYPE_INVALID);
556 if (!b) {
557 r = -ENOMEM;
558 goto fail;
559 }
560
561 *_reply = reply;
562 reply = NULL;
563
564 return 0;
565 }
566
567 audit_session_from_pid(leader, &audit_id);
568 if (audit_id > 0) {
569 /* Keep our session IDs and the audit session IDs in sync */
570
571 if (asprintf(&id, "%lu", (unsigned long) audit_id) < 0) {
572 r = -ENOMEM;
573 goto fail;
574 }
575
576 /* Wut? There's already a session by this name and we
577 * didn't find it above? Weird, then let's not trust
578 * the audit data and let's better register a new
579 * ID */
580 if (hashmap_get(m->sessions, id)) {
581 audit_id = 0;
582
583 free(id);
584 id = NULL;
585 }
586 }
587
588 if (!id) {
589 do {
590 free(id);
591 id = NULL;
592
593 if (asprintf(&id, "c%lu", ++m->session_counter) < 0) {
594 r = -ENOMEM;
595 goto fail;
596 }
597
598 } while (hashmap_get(m->sessions, id));
599 }
600
601 r = manager_add_user_by_uid(m, uid, &user);
602 if (r < 0)
603 goto fail;
604
605 r = manager_add_session(m, user, id, &session);
606 if (r < 0)
607 goto fail;
608
609 session->leader = leader;
610 session->audit_id = audit_id;
611 session->type = t;
612 session->class = c;
613 session->remote = remote;
614 session->controllers = controllers;
615 session->reset_controllers = reset_controllers;
616 session->kill_processes = kill_processes;
617 session->vtnr = vtnr;
618
619 controllers = reset_controllers = NULL;
620
621 if (!isempty(tty)) {
622 session->tty = strdup(tty);
623 if (!session->tty) {
624 r = -ENOMEM;
625 goto fail;
626 }
627 }
628
629 if (!isempty(display)) {
630 session->display = strdup(display);
631 if (!session->display) {
632 r = -ENOMEM;
633 goto fail;
634 }
635 }
636
637 if (!isempty(remote_user)) {
638 session->remote_user = strdup(remote_user);
639 if (!session->remote_user) {
640 r = -ENOMEM;
641 goto fail;
642 }
643 }
644
645 if (!isempty(remote_host)) {
646 session->remote_host = strdup(remote_host);
647 if (!session->remote_host) {
648 r = -ENOMEM;
649 goto fail;
650 }
651 }
652
653 if (!isempty(service)) {
654 session->service = strdup(service);
655 if (!session->service) {
656 r = -ENOMEM;
657 goto fail;
658 }
659 }
660
661 fifo_fd = session_create_fifo(session);
662 if (fifo_fd < 0) {
663 r = fifo_fd;
664 goto fail;
665 }
666
667 if (seat) {
668 r = seat_attach_session(seat, session);
669 if (r < 0)
670 goto fail;
671 }
672
673 r = session_start(session);
674 if (r < 0)
675 goto fail;
676
677 reply = dbus_message_new_method_return(message);
678 if (!reply) {
679 r = -ENOMEM;
680 goto fail;
681 }
682
683 p = session_bus_path(session);
684 if (!p) {
685 r = -ENOMEM;
686 goto fail;
687 }
688
689 cseat = seat ? seat->id : "";
690 exists = false;
691 b = dbus_message_append_args(
692 reply,
693 DBUS_TYPE_STRING, &session->id,
694 DBUS_TYPE_OBJECT_PATH, &p,
695 DBUS_TYPE_STRING, &session->user->runtime_path,
696 DBUS_TYPE_UNIX_FD, &fifo_fd,
697 DBUS_TYPE_STRING, &cseat,
698 DBUS_TYPE_UINT32, &vtnr,
699 DBUS_TYPE_BOOLEAN, &exists,
700 DBUS_TYPE_INVALID);
701
702 if (!b) {
703 r = -ENOMEM;
704 goto fail;
705 }
706
707 *_reply = reply;
708 reply = NULL;
709
710 return 0;
711
712 fail:
713 if (session)
714 session_add_to_gc_queue(session);
715
716 if (user)
717 user_add_to_gc_queue(user);
718
719 return r;
720 }
721
722 static int bus_manager_inhibit(
723 Manager *m,
724 DBusConnection *connection,
725 DBusMessage *message,
726 DBusError *error,
727 DBusMessage **_reply) {
728
729 Inhibitor *i = NULL;
730 char *id = NULL;
731 const char *who, *why, *what, *mode;
732 pid_t pid;
733 InhibitWhat w;
734 InhibitMode mm;
735 unsigned long ul;
736 int r, fifo_fd = -1;
737 _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
738
739 assert(m);
740 assert(connection);
741 assert(message);
742 assert(error);
743 assert(_reply);
744
745 if (!dbus_message_get_args(
746 message,
747 error,
748 DBUS_TYPE_STRING, &what,
749 DBUS_TYPE_STRING, &who,
750 DBUS_TYPE_STRING, &why,
751 DBUS_TYPE_STRING, &mode,
752 DBUS_TYPE_INVALID)) {
753 r = -EIO;
754 goto fail;
755 }
756
757 w = inhibit_what_from_string(what);
758 if (w <= 0) {
759 r = -EINVAL;
760 goto fail;
761 }
762
763 mm = inhibit_mode_from_string(mode);
764 if (mm < 0) {
765 r = -EINVAL;
766 goto fail;
767 }
768
769 /* Delay is only supported for shutdown/sleep */
770 if (mm == INHIBIT_DELAY && (w & ~(INHIBIT_SHUTDOWN|INHIBIT_SLEEP))) {
771 r = -EINVAL;
772 goto fail;
773 }
774
775 /* Don't allow taking delay locks while we are already
776 * executing the operation. We shouldn't create the impression
777 * that the lock was successful if the machine is about to go
778 * down/suspend any moment. */
779 if (m->action_what & w) {
780 r = -EALREADY;
781 goto fail;
782 }
783
784 r = verify_polkit(connection, message,
785 w == INHIBIT_SHUTDOWN ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
786 w == INHIBIT_SLEEP ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-sleep" : "org.freedesktop.login1.inhibit-delay-sleep") :
787 w == INHIBIT_IDLE ? "org.freedesktop.login1.inhibit-block-idle" :
788 w == INHIBIT_HANDLE_POWER_KEY ? "org.freedesktop.login1.inhibit-handle-power-key" :
789 w == INHIBIT_HANDLE_SUSPEND_KEY ? "org.freedesktop.login1.inhibit-handle-suspend-key" :
790 w == INHIBIT_HANDLE_HIBERNATE_KEY ? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
791 "org.freedesktop.login1.inhibit-handle-lid-switch",
792 false, NULL, error);
793 if (r < 0)
794 goto fail;
795
796 ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
797 if (ul == (unsigned long) -1) {
798 r = -EIO;
799 goto fail;
800 }
801
802 pid = bus_get_unix_process_id(connection, dbus_message_get_sender(message), error);
803 if (pid <= 0) {
804 r = -EIO;
805 goto fail;
806 }
807
808 do {
809 free(id);
810 id = NULL;
811
812 if (asprintf(&id, "%lu", ++m->inhibit_counter) < 0) {
813 r = -ENOMEM;
814 goto fail;
815 }
816 } while (hashmap_get(m->inhibitors, id));
817
818 r = manager_add_inhibitor(m, id, &i);
819 free(id);
820
821 if (r < 0)
822 goto fail;
823
824 i->what = w;
825 i->mode = mm;
826 i->pid = pid;
827 i->uid = (uid_t) ul;
828 i->why = strdup(why);
829 i->who = strdup(who);
830
831 if (!i->why || !i->who) {
832 r = -ENOMEM;
833 goto fail;
834 }
835
836 fifo_fd = inhibitor_create_fifo(i);
837 if (fifo_fd < 0) {
838 r = fifo_fd;
839 goto fail;
840 }
841
842 reply = dbus_message_new_method_return(message);
843 if (!reply) {
844 r = -ENOMEM;
845 goto fail;
846 }
847
848 if (!dbus_message_append_args(
849 reply,
850 DBUS_TYPE_UNIX_FD, &fifo_fd,
851 DBUS_TYPE_INVALID)) {
852 r = -ENOMEM;
853 goto fail;
854 }
855
856 close_nointr_nofail(fifo_fd);
857 *_reply = reply;
858 reply = NULL;
859
860 inhibitor_start(i);
861
862 return 0;
863
864 fail:
865 if (i)
866 inhibitor_free(i);
867
868 if (fifo_fd >= 0)
869 close_nointr_nofail(fifo_fd);
870
871 return r;
872 }
873
874 static int trigger_device(Manager *m, struct udev_device *d) {
875 struct udev_enumerate *e;
876 struct udev_list_entry *first, *item;
877 int r;
878
879 assert(m);
880
881 e = udev_enumerate_new(m->udev);
882 if (!e) {
883 r = -ENOMEM;
884 goto finish;
885 }
886
887 if (d) {
888 if (udev_enumerate_add_match_parent(e, d) < 0) {
889 r = -EIO;
890 goto finish;
891 }
892 }
893
894 if (udev_enumerate_scan_devices(e) < 0) {
895 r = -EIO;
896 goto finish;
897 }
898
899 first = udev_enumerate_get_list_entry(e);
900 udev_list_entry_foreach(item, first) {
901 char *t;
902 const char *p;
903
904 p = udev_list_entry_get_name(item);
905
906 t = strappend(p, "/uevent");
907 if (!t) {
908 r = -ENOMEM;
909 goto finish;
910 }
911
912 write_string_file(t, "change");
913 free(t);
914 }
915
916 r = 0;
917
918 finish:
919 if (e)
920 udev_enumerate_unref(e);
921
922 return r;
923 }
924
925 static int attach_device(Manager *m, const char *seat, const char *sysfs) {
926 struct udev_device *d;
927 char _cleanup_free_ *rule = NULL, *file = NULL;
928 const char *id_for_seat;
929 int r;
930
931 assert(m);
932 assert(seat);
933 assert(sysfs);
934
935 d = udev_device_new_from_syspath(m->udev, sysfs);
936 if (!d)
937 return -ENODEV;
938
939 if (!udev_device_has_tag(d, "seat")) {
940 r = -ENODEV;
941 goto finish;
942 }
943
944 id_for_seat = udev_device_get_property_value(d, "ID_FOR_SEAT");
945 if (!id_for_seat) {
946 r = -ENODEV;
947 goto finish;
948 }
949
950 if (asprintf(&file, "/etc/udev/rules.d/72-seat-%s.rules", id_for_seat) < 0) {
951 r = -ENOMEM;
952 goto finish;
953 }
954
955 if (asprintf(&rule, "TAG==\"seat\", ENV{ID_FOR_SEAT}==\"%s\", ENV{ID_SEAT}=\"%s\"", id_for_seat, seat) < 0) {
956 r = -ENOMEM;
957 goto finish;
958 }
959
960 mkdir_p_label("/etc/udev/rules.d", 0755);
961 label_init("/etc");
962 r = write_string_file_atomic_label(file, rule);
963 if (r < 0)
964 goto finish;
965
966 r = trigger_device(m, d);
967
968 finish:
969 if (d)
970 udev_device_unref(d);
971
972 return r;
973 }
974
975 static int flush_devices(Manager *m) {
976 DIR _cleanup_closedir_ *d;
977
978 assert(m);
979
980 d = opendir("/etc/udev/rules.d");
981 if (!d) {
982 if (errno != ENOENT)
983 log_warning("Failed to open /etc/udev/rules.d: %m");
984 } else {
985 struct dirent *de;
986
987 while ((de = readdir(d))) {
988
989 if (!dirent_is_file(de))
990 continue;
991
992 if (!startswith(de->d_name, "72-seat-"))
993 continue;
994
995 if (!endswith(de->d_name, ".rules"))
996 continue;
997
998 if (unlinkat(dirfd(d), de->d_name, 0) < 0)
999 log_warning("Failed to unlink %s: %m", de->d_name);
1000 }
1001 }
1002
1003 return trigger_device(m, NULL);
1004 }
1005
1006 static int have_multiple_sessions(
1007 Manager *m,
1008 uid_t uid) {
1009
1010 Session *session;
1011 Iterator i;
1012
1013 assert(m);
1014
1015 /* Check for other users' sessions. Greeter sessions do not
1016 * count, and non-login sessions do not count either. */
1017 HASHMAP_FOREACH(session, m->sessions, i)
1018 if (session->class == SESSION_USER &&
1019 session->user->uid != uid)
1020 return true;
1021
1022 return false;
1023 }
1024
1025 static int bus_manager_log_shutdown(
1026 Manager *m,
1027 InhibitWhat w,
1028 const char *unit_name) {
1029
1030 const char *p, *q;
1031
1032 assert(m);
1033 assert(unit_name);
1034
1035 if (w != INHIBIT_SHUTDOWN)
1036 return 0;
1037
1038 if (streq(unit_name, SPECIAL_POWEROFF_TARGET)) {
1039 p = "MESSAGE=System is powering down.";
1040 q = "SHUTDOWN=power-off";
1041 } else if (streq(unit_name, SPECIAL_HALT_TARGET)) {
1042 p = "MESSAGE=System is halting.";
1043 q = "SHUTDOWN=halt";
1044 } else if (streq(unit_name, SPECIAL_REBOOT_TARGET)) {
1045 p = "MESSAGE=System is rebooting.";
1046 q = "SHUTDOWN=reboot";
1047 } else if (streq(unit_name, SPECIAL_KEXEC_TARGET)) {
1048 p = "MESSAGE=System is rebooting with kexec.";
1049 q = "SHUTDOWN=kexec";
1050 } else {
1051 p = "MESSAGE=System is shutting down.";
1052 q = NULL;
1053 }
1054
1055 return log_struct(LOG_NOTICE, MESSAGE_ID(SD_MESSAGE_SHUTDOWN),
1056 p,
1057 q, NULL);
1058 }
1059
1060 static int execute_shutdown_or_sleep(
1061 Manager *m,
1062 InhibitWhat w,
1063 const char *unit_name,
1064 DBusError *error) {
1065
1066 _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
1067 const char *mode = "replace-irreversibly", *p;
1068 int r;
1069 char *c;
1070
1071 assert(m);
1072 assert(w >= 0);
1073 assert(w < _INHIBIT_WHAT_MAX);
1074 assert(unit_name);
1075
1076 bus_manager_log_shutdown(m, w, unit_name);
1077
1078 r = bus_method_call_with_reply(
1079 m->bus,
1080 "org.freedesktop.systemd1",
1081 "/org/freedesktop/systemd1",
1082 "org.freedesktop.systemd1.Manager",
1083 "StartUnit",
1084 &reply,
1085 error,
1086 DBUS_TYPE_STRING, &unit_name,
1087 DBUS_TYPE_STRING, &mode,
1088 DBUS_TYPE_INVALID);
1089 if (r < 0)
1090 return r;
1091
1092 if (!dbus_message_get_args(
1093 reply,
1094 error,
1095 DBUS_TYPE_OBJECT_PATH, &p,
1096 DBUS_TYPE_INVALID))
1097 return -EINVAL;
1098
1099 c = strdup(p);
1100 if (!c)
1101 return -ENOMEM;
1102
1103 m->action_unit = unit_name;
1104 free(m->action_job);
1105 m->action_job = c;
1106 m->action_what = w;
1107
1108 return 0;
1109 }
1110
1111 static int delay_shutdown_or_sleep(
1112 Manager *m,
1113 InhibitWhat w,
1114 const char *unit_name) {
1115
1116 assert(m);
1117 assert(w >= 0);
1118 assert(w < _INHIBIT_WHAT_MAX);
1119 assert(unit_name);
1120
1121 m->action_timestamp = now(CLOCK_MONOTONIC);
1122 m->action_unit = unit_name;
1123 m->action_what = w;
1124
1125 return 0;
1126 }
1127
1128 static int bus_manager_can_shutdown_or_sleep(
1129 Manager *m,
1130 DBusConnection *connection,
1131 DBusMessage *message,
1132 InhibitWhat w,
1133 const char *action,
1134 const char *action_multiple_sessions,
1135 const char *action_ignore_inhibit,
1136 const char *sleep_type,
1137 const char *sleep_disk_type,
1138 DBusError *error,
1139 DBusMessage **_reply) {
1140
1141 bool multiple_sessions, challenge, blocked, b;
1142 const char *result;
1143 _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
1144 int r;
1145 unsigned long ul;
1146
1147 assert(m);
1148 assert(connection);
1149 assert(message);
1150 assert(w >= 0);
1151 assert(w <= _INHIBIT_WHAT_MAX);
1152 assert(action);
1153 assert(action_multiple_sessions);
1154 assert(action_ignore_inhibit);
1155 assert(error);
1156 assert(_reply);
1157
1158 if (sleep_type) {
1159 r = can_sleep(sleep_type);
1160 if (r < 0)
1161 return r;
1162
1163 if (r == 0) {
1164 result = "na";
1165 goto finish;
1166 }
1167 }
1168
1169 if (sleep_disk_type) {
1170 r = can_sleep_disk(sleep_disk_type);
1171 if (r < 0)
1172 return r;
1173
1174 if (r == 0) {
1175 result = "na";
1176 goto finish;
1177 }
1178 }
1179
1180 ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
1181 if (ul == (unsigned long) -1)
1182 return -EIO;
1183
1184 r = have_multiple_sessions(m, (uid_t) ul);
1185 if (r < 0)
1186 return r;
1187
1188 multiple_sessions = r > 0;
1189 blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, (uid_t) ul);
1190
1191 if (multiple_sessions) {
1192 r = verify_polkit(connection, message, action_multiple_sessions, false, &challenge, error);
1193 if (r < 0)
1194 return r;
1195
1196 if (r > 0)
1197 result = "yes";
1198 else if (challenge)
1199 result = "challenge";
1200 else
1201 result = "no";
1202 }
1203
1204 if (blocked) {
1205 r = verify_polkit(connection, message, action_ignore_inhibit, false, &challenge, error);
1206 if (r < 0)
1207 return r;
1208
1209 if (r > 0 && !result)
1210 result = "yes";
1211 else if (challenge && (!result || streq(result, "yes")))
1212 result = "challenge";
1213 else
1214 result = "no";
1215 }
1216
1217 if (!multiple_sessions && !blocked) {
1218 /* If neither inhibit nor multiple sessions
1219 * apply then just check the normal policy */
1220
1221 r = verify_polkit(connection, message, action, false, &challenge, error);
1222 if (r < 0)
1223 return r;
1224
1225 if (r > 0)
1226 result = "yes";
1227 else if (challenge)
1228 result = "challenge";
1229 else
1230 result = "no";
1231 }
1232
1233 finish:
1234 reply = dbus_message_new_method_return(message);
1235 if (!reply)
1236 return -ENOMEM;
1237
1238 b = dbus_message_append_args(
1239 reply,
1240 DBUS_TYPE_STRING, &result,
1241 DBUS_TYPE_INVALID);
1242 if (!b)
1243 return -ENOMEM;
1244
1245 *_reply = reply;
1246 reply = NULL;
1247 return 0;
1248 }
1249
1250 static int send_prepare_for(Manager *m, InhibitWhat w, bool _active) {
1251 static const char * const signal_name[_INHIBIT_WHAT_MAX] = {
1252 [INHIBIT_SHUTDOWN] = "PrepareForShutdown",
1253 [INHIBIT_SLEEP] = "PrepareForSleep"
1254 };
1255
1256 dbus_bool_t active = _active;
1257 _cleanup_dbus_message_unref_ DBusMessage *message = NULL;
1258
1259 assert(m);
1260 assert(w >= 0);
1261 assert(w < _INHIBIT_WHAT_MAX);
1262 assert(signal_name[w]);
1263
1264 message = dbus_message_new_signal("/org/freedesktop/login1", "org.freedesktop.login1.Manager", signal_name[w]);
1265 if (!message)
1266 return -ENOMEM;
1267
1268 if (!dbus_message_append_args(message, DBUS_TYPE_BOOLEAN, &active, DBUS_TYPE_INVALID) ||
1269 !dbus_connection_send(m->bus, message, NULL))
1270 return -ENOMEM;
1271
1272 return 0;
1273 }
1274
1275 int bus_manager_shutdown_or_sleep_now_or_later(
1276 Manager *m,
1277 const char *unit_name,
1278 InhibitWhat w,
1279 DBusError *error) {
1280
1281 bool delayed;
1282 int r;
1283
1284 assert(m);
1285 assert(unit_name);
1286 assert(w >= 0);
1287 assert(w <= _INHIBIT_WHAT_MAX);
1288 assert(!m->action_job);
1289
1290 /* Tell everybody to prepare for shutdown/sleep */
1291 send_prepare_for(m, w, true);
1292
1293 delayed =
1294 m->inhibit_delay_max > 0 &&
1295 manager_is_inhibited(m, w, INHIBIT_DELAY, NULL, false, false, 0);
1296
1297 if (delayed)
1298 /* Shutdown is delayed, keep in mind what we
1299 * want to do, and start a timeout */
1300 r = delay_shutdown_or_sleep(m, w, unit_name);
1301 else
1302 /* Shutdown is not delayed, execute it
1303 * immediately */
1304 r = execute_shutdown_or_sleep(m, w, unit_name, error);
1305
1306 return r;
1307 }
1308
1309 static int bus_manager_do_shutdown_or_sleep(
1310 Manager *m,
1311 DBusConnection *connection,
1312 DBusMessage *message,
1313 const char *unit_name,
1314 InhibitWhat w,
1315 const char *action,
1316 const char *action_multiple_sessions,
1317 const char *action_ignore_inhibit,
1318 const char *sleep_type,
1319 const char *sleep_disk_type,
1320 DBusError *error,
1321 DBusMessage **_reply) {
1322
1323 dbus_bool_t interactive;
1324 bool multiple_sessions, blocked;
1325 DBusMessage *reply = NULL;
1326 int r;
1327 unsigned long ul;
1328
1329 assert(m);
1330 assert(connection);
1331 assert(message);
1332 assert(unit_name);
1333 assert(w >= 0);
1334 assert(w <= _INHIBIT_WHAT_MAX);
1335 assert(action);
1336 assert(action_multiple_sessions);
1337 assert(action_ignore_inhibit);
1338 assert(error);
1339 assert(_reply);
1340
1341 /* Don't allow multiple jobs being executed at the same time */
1342 if (m->action_what)
1343 return -EALREADY;
1344
1345 if (!dbus_message_get_args(
1346 message,
1347 error,
1348 DBUS_TYPE_BOOLEAN, &interactive,
1349 DBUS_TYPE_INVALID))
1350 return -EINVAL;
1351
1352 if (sleep_type) {
1353 r = can_sleep(sleep_type);
1354 if (r < 0)
1355 return r;
1356
1357 if (r == 0)
1358 return -ENOTSUP;
1359 }
1360
1361 if (sleep_disk_type) {
1362 r = can_sleep_disk(sleep_disk_type);
1363 if (r < 0)
1364 return r;
1365
1366 if (r == 0)
1367 return -ENOTSUP;
1368 }
1369
1370 ul = dbus_bus_get_unix_user(connection, dbus_message_get_sender(message), error);
1371 if (ul == (unsigned long) -1)
1372 return -EIO;
1373
1374 r = have_multiple_sessions(m, (uid_t) ul);
1375 if (r < 0)
1376 return r;
1377
1378 multiple_sessions = r > 0;
1379 blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, (uid_t) ul);
1380
1381 if (multiple_sessions) {
1382 r = verify_polkit(connection, message, action_multiple_sessions, interactive, NULL, error);
1383 if (r < 0)
1384 return r;
1385 }
1386
1387 if (blocked) {
1388 r = verify_polkit(connection, message, action_ignore_inhibit, interactive, NULL, error);
1389 if (r < 0)
1390 return r;
1391 }
1392
1393 if (!multiple_sessions && !blocked) {
1394 r = verify_polkit(connection, message, action, interactive, NULL, error);
1395 if (r < 0)
1396 return r;
1397 }
1398
1399 r = bus_manager_shutdown_or_sleep_now_or_later(m, unit_name, w, error);
1400 if (r < 0)
1401 return r;
1402
1403 reply = dbus_message_new_method_return(message);
1404 if (!reply)
1405 return -ENOMEM;
1406
1407 *_reply = reply;
1408 return 0;
1409 }
1410
1411 static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_manager_append_handle_action, handle_action, HandleAction);
1412
1413 static const BusProperty bus_login_manager_properties[] = {
1414 { "ControlGroupHierarchy", bus_property_append_string, "s", offsetof(Manager, cgroup_path), true },
1415 { "Controllers", bus_property_append_strv, "as", offsetof(Manager, controllers), true },
1416 { "ResetControllers", bus_property_append_strv, "as", offsetof(Manager, reset_controllers), true },
1417 { "NAutoVTs", bus_property_append_unsigned, "u", offsetof(Manager, n_autovts) },
1418 { "KillOnlyUsers", bus_property_append_strv, "as", offsetof(Manager, kill_only_users), true },
1419 { "KillExcludeUsers", bus_property_append_strv, "as", offsetof(Manager, kill_exclude_users), true },
1420 { "KillUserProcesses", bus_property_append_bool, "b", offsetof(Manager, kill_user_processes) },
1421 { "IdleHint", bus_manager_append_idle_hint, "b", 0 },
1422 { "IdleSinceHint", bus_manager_append_idle_hint_since, "t", 0 },
1423 { "IdleSinceHintMonotonic", bus_manager_append_idle_hint_since, "t", 0 },
1424 { "BlockInhibited", bus_manager_append_inhibited, "s", 0 },
1425 { "DelayInhibited", bus_manager_append_inhibited, "s", 0 },
1426 { "InhibitDelayMaxUSec", bus_property_append_usec, "t", offsetof(Manager, inhibit_delay_max) },
1427 { "HandlePowerKey", bus_manager_append_handle_action, "s", offsetof(Manager, handle_power_key) },
1428 { "HandleSuspendKey", bus_manager_append_handle_action, "s", offsetof(Manager, handle_suspend_key) },
1429 { "HandleHibernateKey", bus_manager_append_handle_action, "s", offsetof(Manager, handle_hibernate_key)},
1430 { "HandleLidSwitch", bus_manager_append_handle_action, "s", offsetof(Manager, handle_lid_switch) },
1431 { "IdleAction", bus_manager_append_handle_action, "s", offsetof(Manager, idle_action) },
1432 { "IdleActionUSec", bus_property_append_usec, "t", offsetof(Manager, idle_action_usec) },
1433 { "PreparingForShutdown", bus_manager_append_preparing, "b", 0 },
1434 { "PreparingForSleep", bus_manager_append_preparing, "b", 0 },
1435 { NULL, }
1436 };
1437
1438 static DBusHandlerResult manager_message_handler(
1439 DBusConnection *connection,
1440 DBusMessage *message,
1441 void *userdata) {
1442
1443 Manager *m = userdata;
1444
1445 DBusError error;
1446 _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
1447 int r;
1448
1449 assert(connection);
1450 assert(message);
1451 assert(m);
1452
1453 dbus_error_init(&error);
1454
1455 if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetSession")) {
1456 const char *name;
1457 char *p;
1458 Session *session;
1459 bool b;
1460
1461 if (!dbus_message_get_args(
1462 message,
1463 &error,
1464 DBUS_TYPE_STRING, &name,
1465 DBUS_TYPE_INVALID))
1466 return bus_send_error_reply(connection, message, &error, -EINVAL);
1467
1468 session = hashmap_get(m->sessions, name);
1469 if (!session)
1470 return bus_send_error_reply(connection, message, &error, -ENOENT);
1471
1472 reply = dbus_message_new_method_return(message);
1473 if (!reply)
1474 goto oom;
1475
1476 p = session_bus_path(session);
1477 if (!p)
1478 goto oom;
1479
1480 b = dbus_message_append_args(
1481 reply,
1482 DBUS_TYPE_OBJECT_PATH, &p,
1483 DBUS_TYPE_INVALID);
1484 free(p);
1485
1486 if (!b)
1487 goto oom;
1488
1489 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetSessionByPID")) {
1490 uint32_t pid;
1491 char *p;
1492 Session *session;
1493 bool b;
1494
1495 if (!dbus_message_get_args(
1496 message,
1497 &error,
1498 DBUS_TYPE_UINT32, &pid,
1499 DBUS_TYPE_INVALID))
1500 return bus_send_error_reply(connection, message, &error, -EINVAL);
1501
1502 r = manager_get_session_by_pid(m, pid, &session);
1503 if (r <= 0)
1504 return bus_send_error_reply(connection, message, NULL, r < 0 ? r : -ENOENT);
1505
1506 reply = dbus_message_new_method_return(message);
1507 if (!reply)
1508 goto oom;
1509
1510 p = session_bus_path(session);
1511 if (!p)
1512 goto oom;
1513
1514 b = dbus_message_append_args(
1515 reply,
1516 DBUS_TYPE_OBJECT_PATH, &p,
1517 DBUS_TYPE_INVALID);
1518 free(p);
1519
1520 if (!b)
1521 goto oom;
1522
1523 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetUser")) {
1524 uint32_t uid;
1525 char *p;
1526 User *user;
1527 bool b;
1528
1529 if (!dbus_message_get_args(
1530 message,
1531 &error,
1532 DBUS_TYPE_UINT32, &uid,
1533 DBUS_TYPE_INVALID))
1534 return bus_send_error_reply(connection, message, &error, -EINVAL);
1535
1536 user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
1537 if (!user)
1538 return bus_send_error_reply(connection, message, &error, -ENOENT);
1539
1540 reply = dbus_message_new_method_return(message);
1541 if (!reply)
1542 goto oom;
1543
1544 p = user_bus_path(user);
1545 if (!p)
1546 goto oom;
1547
1548 b = dbus_message_append_args(
1549 reply,
1550 DBUS_TYPE_OBJECT_PATH, &p,
1551 DBUS_TYPE_INVALID);
1552 free(p);
1553
1554 if (!b)
1555 goto oom;
1556
1557 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "GetSeat")) {
1558 const char *name;
1559 char *p;
1560 Seat *seat;
1561 bool b;
1562
1563 if (!dbus_message_get_args(
1564 message,
1565 &error,
1566 DBUS_TYPE_STRING, &name,
1567 DBUS_TYPE_INVALID))
1568 return bus_send_error_reply(connection, message, &error, -EINVAL);
1569
1570 seat = hashmap_get(m->seats, name);
1571 if (!seat)
1572 return bus_send_error_reply(connection, message, &error, -ENOENT);
1573
1574 reply = dbus_message_new_method_return(message);
1575 if (!reply)
1576 goto oom;
1577
1578 p = seat_bus_path(seat);
1579 if (!p)
1580 goto oom;
1581
1582 b = dbus_message_append_args(
1583 reply,
1584 DBUS_TYPE_OBJECT_PATH, &p,
1585 DBUS_TYPE_INVALID);
1586 free(p);
1587
1588 if (!b)
1589 goto oom;
1590
1591 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListSessions")) {
1592 char *p;
1593 Session *session;
1594 Iterator i;
1595 DBusMessageIter iter, sub;
1596 const char *empty = "";
1597
1598 reply = dbus_message_new_method_return(message);
1599 if (!reply)
1600 goto oom;
1601
1602 dbus_message_iter_init_append(reply, &iter);
1603
1604 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(susso)", &sub))
1605 goto oom;
1606
1607 HASHMAP_FOREACH(session, m->sessions, i) {
1608 DBusMessageIter sub2;
1609 uint32_t uid;
1610
1611 if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
1612 goto oom;
1613
1614 uid = session->user->uid;
1615
1616 p = session_bus_path(session);
1617 if (!p)
1618 goto oom;
1619
1620 if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &session->id) ||
1621 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &uid) ||
1622 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &session->user->name) ||
1623 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, session->seat ? (const char**) &session->seat->id : &empty) ||
1624 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) {
1625 free(p);
1626 goto oom;
1627 }
1628
1629 free(p);
1630
1631 if (!dbus_message_iter_close_container(&sub, &sub2))
1632 goto oom;
1633 }
1634
1635 if (!dbus_message_iter_close_container(&iter, &sub))
1636 goto oom;
1637
1638 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListUsers")) {
1639 char *p;
1640 User *user;
1641 Iterator i;
1642 DBusMessageIter iter, sub;
1643
1644 reply = dbus_message_new_method_return(message);
1645 if (!reply)
1646 goto oom;
1647
1648 dbus_message_iter_init_append(reply, &iter);
1649
1650 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(uso)", &sub))
1651 goto oom;
1652
1653 HASHMAP_FOREACH(user, m->users, i) {
1654 DBusMessageIter sub2;
1655 uint32_t uid;
1656
1657 if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
1658 goto oom;
1659
1660 uid = user->uid;
1661
1662 p = user_bus_path(user);
1663 if (!p)
1664 goto oom;
1665
1666 if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &uid) ||
1667 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &user->name) ||
1668 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) {
1669 free(p);
1670 goto oom;
1671 }
1672
1673 free(p);
1674
1675 if (!dbus_message_iter_close_container(&sub, &sub2))
1676 goto oom;
1677 }
1678
1679 if (!dbus_message_iter_close_container(&iter, &sub))
1680 goto oom;
1681
1682 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListSeats")) {
1683 char *p;
1684 Seat *seat;
1685 Iterator i;
1686 DBusMessageIter iter, sub;
1687
1688 reply = dbus_message_new_method_return(message);
1689 if (!reply)
1690 goto oom;
1691
1692 dbus_message_iter_init_append(reply, &iter);
1693
1694 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(so)", &sub))
1695 goto oom;
1696
1697 HASHMAP_FOREACH(seat, m->seats, i) {
1698 DBusMessageIter sub2;
1699
1700 if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
1701 goto oom;
1702
1703 p = seat_bus_path(seat);
1704 if (!p)
1705 goto oom;
1706
1707 if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &seat->id) ||
1708 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_OBJECT_PATH, &p)) {
1709 free(p);
1710 goto oom;
1711 }
1712
1713 free(p);
1714
1715 if (!dbus_message_iter_close_container(&sub, &sub2))
1716 goto oom;
1717 }
1718
1719 if (!dbus_message_iter_close_container(&iter, &sub))
1720 goto oom;
1721
1722 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ListInhibitors")) {
1723 Inhibitor *inhibitor;
1724 Iterator i;
1725 DBusMessageIter iter, sub;
1726
1727 reply = dbus_message_new_method_return(message);
1728 if (!reply)
1729 goto oom;
1730
1731 dbus_message_iter_init_append(reply, &iter);
1732
1733 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(ssssuu)", &sub))
1734 goto oom;
1735
1736 HASHMAP_FOREACH(inhibitor, m->inhibitors, i) {
1737 DBusMessageIter sub2;
1738 dbus_uint32_t uid, pid;
1739 const char *what, *who, *why, *mode;
1740
1741 if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2))
1742 goto oom;
1743
1744 what = strempty(inhibit_what_to_string(inhibitor->what));
1745 who = strempty(inhibitor->who);
1746 why = strempty(inhibitor->why);
1747 mode = strempty(inhibit_mode_to_string(inhibitor->mode));
1748 uid = (dbus_uint32_t) inhibitor->uid;
1749 pid = (dbus_uint32_t) inhibitor->pid;
1750
1751 if (!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &what) ||
1752 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &who) ||
1753 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &why) ||
1754 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &mode) ||
1755 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &uid) ||
1756 !dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT32, &pid))
1757 goto oom;
1758
1759 if (!dbus_message_iter_close_container(&sub, &sub2))
1760 goto oom;
1761 }
1762
1763 if (!dbus_message_iter_close_container(&iter, &sub))
1764 goto oom;
1765
1766 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Inhibit")) {
1767
1768 r = bus_manager_inhibit(m, connection, message, &error, &reply);
1769
1770 if (r < 0)
1771 return bus_send_error_reply(connection, message, &error, r);
1772
1773
1774 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CreateSession")) {
1775
1776 r = bus_manager_create_session(m, message, &reply);
1777
1778 /* Don't delay the work on OOM here, since it might be
1779 * triggered by a low RLIMIT_NOFILE here (since we
1780 * send a dupped fd to the client), and we'd rather
1781 * see this fail quickly then be retried later */
1782
1783 if (r < 0)
1784 return bus_send_error_reply(connection, message, NULL, r);
1785
1786 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ReleaseSession")) {
1787 const char *name;
1788 Session *session;
1789
1790 if (!dbus_message_get_args(
1791 message,
1792 &error,
1793 DBUS_TYPE_STRING, &name,
1794 DBUS_TYPE_INVALID))
1795 return bus_send_error_reply(connection, message, &error, -EINVAL);
1796
1797 session = hashmap_get(m->sessions, name);
1798 if (!session)
1799 return bus_send_error_reply(connection, message, &error, -ENOENT);
1800
1801 /* We use the FIFO to detect stray sessions where the
1802 process invoking PAM dies abnormally. We need to make
1803 sure that that process is not killed if at the clean
1804 end of the session it closes the FIFO. Hence, with
1805 this call explicitly turn off the FIFO logic, so that
1806 the PAM code can finish clean up on its own */
1807 session_remove_fifo(session);
1808
1809 reply = dbus_message_new_method_return(message);
1810 if (!reply)
1811 goto oom;
1812
1813 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ActivateSession")) {
1814 const char *name;
1815 Session *session;
1816
1817 if (!dbus_message_get_args(
1818 message,
1819 &error,
1820 DBUS_TYPE_STRING, &name,
1821 DBUS_TYPE_INVALID))
1822 return bus_send_error_reply(connection, message, &error, -EINVAL);
1823
1824 session = hashmap_get(m->sessions, name);
1825 if (!session)
1826 return bus_send_error_reply(connection, message, &error, -ENOENT);
1827
1828 r = session_activate(session);
1829 if (r < 0)
1830 return bus_send_error_reply(connection, message, NULL, r);
1831
1832 reply = dbus_message_new_method_return(message);
1833 if (!reply)
1834 goto oom;
1835
1836 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "ActivateSessionOnSeat")) {
1837 const char *session_name, *seat_name;
1838 Session *session;
1839 Seat *seat;
1840
1841 /* Same as ActivateSession() but refuses to work if
1842 * the seat doesn't match */
1843
1844 if (!dbus_message_get_args(
1845 message,
1846 &error,
1847 DBUS_TYPE_STRING, &session_name,
1848 DBUS_TYPE_STRING, &seat_name,
1849 DBUS_TYPE_INVALID))
1850 return bus_send_error_reply(connection, message, &error, -EINVAL);
1851
1852 session = hashmap_get(m->sessions, session_name);
1853 if (!session)
1854 return bus_send_error_reply(connection, message, &error, -ENOENT);
1855
1856 seat = hashmap_get(m->seats, seat_name);
1857 if (!seat)
1858 return bus_send_error_reply(connection, message, &error, -ENOENT);
1859
1860 if (session->seat != seat)
1861 return bus_send_error_reply(connection, message, &error, -EINVAL);
1862
1863 r = session_activate(session);
1864 if (r < 0)
1865 return bus_send_error_reply(connection, message, NULL, r);
1866
1867 reply = dbus_message_new_method_return(message);
1868 if (!reply)
1869 goto oom;
1870
1871 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "LockSession") ||
1872 dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "UnlockSession")) {
1873 const char *name;
1874 Session *session;
1875
1876 if (!dbus_message_get_args(
1877 message,
1878 &error,
1879 DBUS_TYPE_STRING, &name,
1880 DBUS_TYPE_INVALID))
1881 return bus_send_error_reply(connection, message, &error, -EINVAL);
1882
1883 session = hashmap_get(m->sessions, name);
1884 if (!session)
1885 return bus_send_error_reply(connection, message, NULL, -ENOENT);
1886
1887 if (session_send_lock(session, streq(dbus_message_get_member(message), "LockSession")) < 0)
1888 goto oom;
1889
1890 reply = dbus_message_new_method_return(message);
1891 if (!reply)
1892 goto oom;
1893
1894 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "LockSessions") ||
1895 dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "UnlockSessions")) {
1896
1897 r = session_send_lock_all(m, streq(dbus_message_get_member(message), "LockSessions"));
1898 if (r < 0)
1899 bus_send_error_reply(connection, message, NULL, r);
1900
1901 reply = dbus_message_new_method_return(message);
1902 if (!reply)
1903 goto oom;
1904
1905 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "KillSession")) {
1906 const char *swho;
1907 int32_t signo;
1908 KillWho who;
1909 const char *name;
1910 Session *session;
1911
1912 if (!dbus_message_get_args(
1913 message,
1914 &error,
1915 DBUS_TYPE_STRING, &name,
1916 DBUS_TYPE_STRING, &swho,
1917 DBUS_TYPE_INT32, &signo,
1918 DBUS_TYPE_INVALID))
1919 return bus_send_error_reply(connection, message, &error, -EINVAL);
1920
1921 if (isempty(swho))
1922 who = KILL_ALL;
1923 else {
1924 who = kill_who_from_string(swho);
1925 if (who < 0)
1926 return bus_send_error_reply(connection, message, &error, -EINVAL);
1927 }
1928
1929 if (signo <= 0 || signo >= _NSIG)
1930 return bus_send_error_reply(connection, message, &error, -EINVAL);
1931
1932 session = hashmap_get(m->sessions, name);
1933 if (!session)
1934 return bus_send_error_reply(connection, message, &error, -ENOENT);
1935
1936 r = session_kill(session, who, signo);
1937 if (r < 0)
1938 return bus_send_error_reply(connection, message, NULL, r);
1939
1940 reply = dbus_message_new_method_return(message);
1941 if (!reply)
1942 goto oom;
1943
1944 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "KillUser")) {
1945 uint32_t uid;
1946 User *user;
1947 int32_t signo;
1948
1949 if (!dbus_message_get_args(
1950 message,
1951 &error,
1952 DBUS_TYPE_UINT32, &uid,
1953 DBUS_TYPE_INT32, &signo,
1954 DBUS_TYPE_INVALID))
1955 return bus_send_error_reply(connection, message, &error, -EINVAL);
1956
1957 if (signo <= 0 || signo >= _NSIG)
1958 return bus_send_error_reply(connection, message, &error, -EINVAL);
1959
1960 user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
1961 if (!user)
1962 return bus_send_error_reply(connection, message, &error, -ENOENT);
1963
1964 r = user_kill(user, signo);
1965 if (r < 0)
1966 return bus_send_error_reply(connection, message, NULL, r);
1967
1968 reply = dbus_message_new_method_return(message);
1969 if (!reply)
1970 goto oom;
1971
1972 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateSession")) {
1973 const char *name;
1974 Session *session;
1975
1976 if (!dbus_message_get_args(
1977 message,
1978 &error,
1979 DBUS_TYPE_STRING, &name,
1980 DBUS_TYPE_INVALID))
1981 return bus_send_error_reply(connection, message, &error, -EINVAL);
1982
1983 session = hashmap_get(m->sessions, name);
1984 if (!session)
1985 return bus_send_error_reply(connection, message, &error, -ENOENT);
1986
1987 r = session_stop(session);
1988 if (r < 0)
1989 return bus_send_error_reply(connection, message, NULL, r);
1990
1991 reply = dbus_message_new_method_return(message);
1992 if (!reply)
1993 goto oom;
1994
1995 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateUser")) {
1996 uint32_t uid;
1997 User *user;
1998
1999 if (!dbus_message_get_args(
2000 message,
2001 &error,
2002 DBUS_TYPE_UINT32, &uid,
2003 DBUS_TYPE_INVALID))
2004 return bus_send_error_reply(connection, message, &error, -EINVAL);
2005
2006 user = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
2007 if (!user)
2008 return bus_send_error_reply(connection, message, &error, -ENOENT);
2009
2010 r = user_stop(user);
2011 if (r < 0)
2012 return bus_send_error_reply(connection, message, NULL, r);
2013
2014 reply = dbus_message_new_method_return(message);
2015 if (!reply)
2016 goto oom;
2017
2018 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "TerminateSeat")) {
2019 const char *name;
2020 Seat *seat;
2021
2022 if (!dbus_message_get_args(
2023 message,
2024 &error,
2025 DBUS_TYPE_STRING, &name,
2026 DBUS_TYPE_INVALID))
2027 return bus_send_error_reply(connection, message, &error, -EINVAL);
2028
2029 seat = hashmap_get(m->seats, name);
2030 if (!seat)
2031 return bus_send_error_reply(connection, message, &error, -ENOENT);
2032
2033 r = seat_stop_sessions(seat);
2034 if (r < 0)
2035 return bus_send_error_reply(connection, message, NULL, r);
2036
2037 reply = dbus_message_new_method_return(message);
2038 if (!reply)
2039 goto oom;
2040
2041 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "SetUserLinger")) {
2042 uint32_t uid;
2043 struct passwd *pw;
2044 dbus_bool_t b, interactive;
2045 char *path;
2046
2047 if (!dbus_message_get_args(
2048 message,
2049 &error,
2050 DBUS_TYPE_UINT32, &uid,
2051 DBUS_TYPE_BOOLEAN, &b,
2052 DBUS_TYPE_BOOLEAN, &interactive,
2053 DBUS_TYPE_INVALID))
2054 return bus_send_error_reply(connection, message, &error, -EINVAL);
2055
2056 errno = 0;
2057 pw = getpwuid(uid);
2058 if (!pw)
2059 return bus_send_error_reply(connection, message, NULL, errno ? -errno : -EINVAL);
2060
2061 r = verify_polkit(connection, message, "org.freedesktop.login1.set-user-linger", interactive, NULL, &error);
2062 if (r < 0)
2063 return bus_send_error_reply(connection, message, &error, r);
2064
2065 mkdir_p_label("/var/lib/systemd", 0755);
2066
2067 r = mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0);
2068 if (r < 0)
2069 return bus_send_error_reply(connection, message, &error, r);
2070
2071 path = strappend("/var/lib/systemd/linger/", pw->pw_name);
2072 if (!path)
2073 goto oom;
2074
2075 if (b) {
2076 User *u;
2077
2078 r = touch(path);
2079 free(path);
2080
2081 if (r < 0)
2082 return bus_send_error_reply(connection, message, &error, r);
2083
2084 if (manager_add_user_by_uid(m, uid, &u) >= 0)
2085 user_start(u);
2086
2087 } else {
2088 User *u;
2089
2090 r = unlink(path);
2091 free(path);
2092
2093 if (r < 0 && errno != ENOENT)
2094 return bus_send_error_reply(connection, message, &error, -errno);
2095
2096 u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
2097 if (u)
2098 user_add_to_gc_queue(u);
2099 }
2100
2101 reply = dbus_message_new_method_return(message);
2102 if (!reply)
2103 goto oom;
2104
2105 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "AttachDevice")) {
2106 const char *sysfs, *seat;
2107 dbus_bool_t interactive;
2108
2109 if (!dbus_message_get_args(
2110 message,
2111 &error,
2112 DBUS_TYPE_STRING, &seat,
2113 DBUS_TYPE_STRING, &sysfs,
2114 DBUS_TYPE_BOOLEAN, &interactive,
2115 DBUS_TYPE_INVALID))
2116 return bus_send_error_reply(connection, message, &error, -EINVAL);
2117
2118 if (!path_startswith(sysfs, "/sys") || !seat_name_is_valid(seat))
2119 return bus_send_error_reply(connection, message, NULL, -EINVAL);
2120
2121 r = verify_polkit(connection, message, "org.freedesktop.login1.attach-device", interactive, NULL, &error);
2122 if (r < 0)
2123 return bus_send_error_reply(connection, message, &error, r);
2124
2125 r = attach_device(m, seat, sysfs);
2126 if (r < 0)
2127 return bus_send_error_reply(connection, message, NULL, -EINVAL);
2128
2129 reply = dbus_message_new_method_return(message);
2130 if (!reply)
2131 goto oom;
2132
2133
2134 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "FlushDevices")) {
2135 dbus_bool_t interactive;
2136
2137 if (!dbus_message_get_args(
2138 message,
2139 &error,
2140 DBUS_TYPE_BOOLEAN, &interactive,
2141 DBUS_TYPE_INVALID))
2142 return bus_send_error_reply(connection, message, &error, -EINVAL);
2143
2144 r = verify_polkit(connection, message, "org.freedesktop.login1.flush-devices", interactive, NULL, &error);
2145 if (r < 0)
2146 return bus_send_error_reply(connection, message, &error, r);
2147
2148 r = flush_devices(m);
2149 if (r < 0)
2150 return bus_send_error_reply(connection, message, NULL, -EINVAL);
2151
2152 reply = dbus_message_new_method_return(message);
2153 if (!reply)
2154 goto oom;
2155
2156 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "PowerOff")) {
2157
2158 r = bus_manager_do_shutdown_or_sleep(
2159 m, connection, message,
2160 SPECIAL_POWEROFF_TARGET,
2161 INHIBIT_SHUTDOWN,
2162 "org.freedesktop.login1.power-off",
2163 "org.freedesktop.login1.power-off-multiple-sessions",
2164 "org.freedesktop.login1.power-off-ignore-inhibit",
2165 NULL, NULL,
2166 &error, &reply);
2167 if (r < 0)
2168 return bus_send_error_reply(connection, message, &error, r);
2169 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Reboot")) {
2170 r = bus_manager_do_shutdown_or_sleep(
2171 m, connection, message,
2172 SPECIAL_REBOOT_TARGET,
2173 INHIBIT_SHUTDOWN,
2174 "org.freedesktop.login1.reboot",
2175 "org.freedesktop.login1.reboot-multiple-sessions",
2176 "org.freedesktop.login1.reboot-ignore-inhibit",
2177 NULL, NULL,
2178 &error, &reply);
2179 if (r < 0)
2180 return bus_send_error_reply(connection, message, &error, r);
2181
2182 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Suspend")) {
2183 r = bus_manager_do_shutdown_or_sleep(
2184 m, connection, message,
2185 SPECIAL_SUSPEND_TARGET,
2186 INHIBIT_SLEEP,
2187 "org.freedesktop.login1.suspend",
2188 "org.freedesktop.login1.suspend-multiple-sessions",
2189 "org.freedesktop.login1.suspend-ignore-inhibit",
2190 "mem", NULL,
2191 &error, &reply);
2192 if (r < 0)
2193 return bus_send_error_reply(connection, message, &error, r);
2194 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "Hibernate")) {
2195 r = bus_manager_do_shutdown_or_sleep(
2196 m, connection, message,
2197 SPECIAL_HIBERNATE_TARGET,
2198 INHIBIT_SLEEP,
2199 "org.freedesktop.login1.hibernate",
2200 "org.freedesktop.login1.hibernate-multiple-sessions",
2201 "org.freedesktop.login1.hibernate-ignore-inhibit",
2202 "disk", NULL,
2203 &error, &reply);
2204 if (r < 0)
2205 return bus_send_error_reply(connection, message, &error, r);
2206
2207 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "HybridSleep")) {
2208 r = bus_manager_do_shutdown_or_sleep(
2209 m, connection, message,
2210 SPECIAL_HYBRID_SLEEP_TARGET,
2211 INHIBIT_SLEEP,
2212 "org.freedesktop.login1.hibernate",
2213 "org.freedesktop.login1.hibernate-multiple-sessions",
2214 "org.freedesktop.login1.hibernate-ignore-inhibit",
2215 "disk", "suspend",
2216 &error, &reply);
2217 if (r < 0)
2218 return bus_send_error_reply(connection, message, &error, r);
2219
2220 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanPowerOff")) {
2221
2222 r = bus_manager_can_shutdown_or_sleep(
2223 m, connection, message,
2224 INHIBIT_SHUTDOWN,
2225 "org.freedesktop.login1.power-off",
2226 "org.freedesktop.login1.power-off-multiple-sessions",
2227 "org.freedesktop.login1.power-off-ignore-inhibit",
2228 NULL, NULL,
2229 &error, &reply);
2230 if (r < 0)
2231 return bus_send_error_reply(connection, message, &error, r);
2232 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanReboot")) {
2233 r = bus_manager_can_shutdown_or_sleep(
2234 m, connection, message,
2235 INHIBIT_SHUTDOWN,
2236 "org.freedesktop.login1.reboot",
2237 "org.freedesktop.login1.reboot-multiple-sessions",
2238 "org.freedesktop.login1.reboot-ignore-inhibit",
2239 NULL, NULL,
2240 &error, &reply);
2241 if (r < 0)
2242 return bus_send_error_reply(connection, message, &error, r);
2243
2244 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanSuspend")) {
2245 r = bus_manager_can_shutdown_or_sleep(
2246 m, connection, message,
2247 INHIBIT_SLEEP,
2248 "org.freedesktop.login1.suspend",
2249 "org.freedesktop.login1.suspend-multiple-sessions",
2250 "org.freedesktop.login1.suspend-ignore-inhibit",
2251 "mem", NULL,
2252 &error, &reply);
2253 if (r < 0)
2254 return bus_send_error_reply(connection, message, &error, r);
2255
2256 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanHibernate")) {
2257 r = bus_manager_can_shutdown_or_sleep(
2258 m, connection, message,
2259 INHIBIT_SLEEP,
2260 "org.freedesktop.login1.hibernate",
2261 "org.freedesktop.login1.hibernate-multiple-sessions",
2262 "org.freedesktop.login1.hibernate-ignore-inhibit",
2263 "disk", NULL,
2264 &error, &reply);
2265 if (r < 0)
2266 return bus_send_error_reply(connection, message, &error, r);
2267
2268 } else if (dbus_message_is_method_call(message, "org.freedesktop.login1.Manager", "CanHybridSleep")) {
2269 r = bus_manager_can_shutdown_or_sleep(
2270 m, connection, message,
2271 INHIBIT_SLEEP,
2272 "org.freedesktop.login1.hibernate",
2273 "org.freedesktop.login1.hibernate-multiple-sessions",
2274 "org.freedesktop.login1.hibernate-ignore-inhibit",
2275 "disk", "suspend",
2276 &error, &reply);
2277 if (r < 0)
2278 return bus_send_error_reply(connection, message, &error, r);
2279
2280 } else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
2281 char *introspection = NULL;
2282 FILE *f;
2283 Iterator i;
2284 Session *session;
2285 Seat *seat;
2286 User *user;
2287 size_t size;
2288 char *p;
2289
2290 if (!(reply = dbus_message_new_method_return(message)))
2291 goto oom;
2292
2293 /* We roll our own introspection code here, instead of
2294 * relying on bus_default_message_handler() because we
2295 * need to generate our introspection string
2296 * dynamically. */
2297
2298 if (!(f = open_memstream(&introspection, &size)))
2299 goto oom;
2300
2301 fputs(INTROSPECTION_BEGIN, f);
2302
2303 HASHMAP_FOREACH(seat, m->seats, i) {
2304 p = bus_path_escape(seat->id);
2305
2306 if (p) {
2307 fprintf(f, "<node name=\"seat/%s\"/>", p);
2308 free(p);
2309 }
2310 }
2311
2312 HASHMAP_FOREACH(user, m->users, i)
2313 fprintf(f, "<node name=\"user/%llu\"/>", (unsigned long long) user->uid);
2314
2315 HASHMAP_FOREACH(session, m->sessions, i) {
2316 p = bus_path_escape(session->id);
2317
2318 if (p) {
2319 fprintf(f, "<node name=\"session/%s\"/>", p);
2320 free(p);
2321 }
2322 }
2323
2324 fputs(INTROSPECTION_END, f);
2325
2326 if (ferror(f)) {
2327 fclose(f);
2328 free(introspection);
2329 goto oom;
2330 }
2331
2332 fclose(f);
2333
2334 if (!introspection)
2335 goto oom;
2336
2337 if (!dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection, DBUS_TYPE_INVALID)) {
2338 free(introspection);
2339 goto oom;
2340 }
2341
2342 free(introspection);
2343 } else {
2344 const BusBoundProperties bps[] = {
2345 { "org.freedesktop.login1.Manager", bus_login_manager_properties, m },
2346 { NULL, }
2347 };
2348 return bus_default_message_handler(connection, message, NULL, INTERFACES_LIST, bps);
2349 }
2350
2351 if (reply) {
2352 if (!bus_maybe_send_reply(connection, message, reply))
2353 goto oom;
2354 }
2355
2356 return DBUS_HANDLER_RESULT_HANDLED;
2357
2358 oom:
2359 dbus_error_free(&error);
2360
2361 return DBUS_HANDLER_RESULT_NEED_MEMORY;
2362 }
2363
2364 const DBusObjectPathVTable bus_manager_vtable = {
2365 .message_function = manager_message_handler
2366 };
2367
2368 DBusHandlerResult bus_message_filter(
2369 DBusConnection *connection,
2370 DBusMessage *message,
2371 void *userdata) {
2372
2373 Manager *m = userdata;
2374 DBusError error;
2375
2376 assert(m);
2377 assert(connection);
2378 assert(message);
2379
2380 dbus_error_init(&error);
2381
2382 if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Agent", "Released")) {
2383 const char *cgroup;
2384
2385 if (!dbus_message_get_args(message, &error,
2386 DBUS_TYPE_STRING, &cgroup,
2387 DBUS_TYPE_INVALID))
2388 log_error("Failed to parse Released message: %s", bus_error_message(&error));
2389 else
2390 manager_cgroup_notify_empty(m, cgroup);
2391
2392 } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
2393 uint32_t id;
2394 const char *path, *result, *unit;
2395
2396 if (!dbus_message_get_args(message, &error,
2397 DBUS_TYPE_UINT32, &id,
2398 DBUS_TYPE_OBJECT_PATH, &path,
2399 DBUS_TYPE_STRING, &unit,
2400 DBUS_TYPE_STRING, &result,
2401 DBUS_TYPE_INVALID))
2402 log_error("Failed to parse JobRemoved message: %s", bus_error_message(&error));
2403
2404 else if (m->action_job && streq(m->action_job, path)) {
2405
2406 log_info("Operation finished.");
2407
2408 /* Tell people that they now may take a lock again */
2409 send_prepare_for(m, m->action_what, false);
2410
2411 free(m->action_job);
2412 m->action_job = NULL;
2413 m->action_unit = NULL;
2414 m->action_what = 0;
2415 }
2416 }
2417
2418 dbus_error_free(&error);
2419
2420 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2421 }
2422
2423 int manager_send_changed(Manager *manager, const char *properties) {
2424 _cleanup_dbus_message_unref_ DBusMessage *m = NULL;
2425
2426 assert(manager);
2427
2428 m = bus_properties_changed_new("/org/freedesktop/login1",
2429 "org.freedesktop.login1.Manager",
2430 properties);
2431 if (!m)
2432 return -ENOMEM;
2433
2434 if (!dbus_connection_send(manager->bus, m, NULL))
2435 return -ENOMEM;
2436
2437 return 0;
2438 }
2439
2440 int manager_dispatch_delayed(Manager *manager) {
2441 DBusError error;
2442 int r;
2443
2444 assert(manager);
2445
2446 if (!manager->action_unit || manager->action_job)
2447 return 0;
2448
2449 /* Continue delay? */
2450 if (manager_is_inhibited(manager, manager->action_what, INHIBIT_DELAY, NULL, false, false, 0)) {
2451
2452 if (manager->action_timestamp + manager->inhibit_delay_max > now(CLOCK_MONOTONIC))
2453 return 0;
2454
2455 log_info("Delay lock is active but inhibitor timeout is reached.");
2456 }
2457
2458 /* Actually do the operation */
2459 dbus_error_init(&error);
2460 r = execute_shutdown_or_sleep(manager, manager->action_what, manager->action_unit, &error);
2461 if (r < 0) {
2462 log_warning("Failed to send delayed message: %s", bus_error_message_or_strerror(&error, -r));
2463 dbus_error_free(&error);
2464
2465 manager->action_unit = NULL;
2466 manager->action_what = 0;
2467 return r;
2468 }
2469
2470 return 1;
2471 }
Unnamed repository; edit this file 'description' to name the repository.