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