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