Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <fcntl.h>
4 : : #include <pwd.h>
5 : : #include <sys/ioctl.h>
6 : : #include <sys/types.h>
7 : : #include <linux/vt.h>
8 : : #if ENABLE_UTMP
9 : : #include <utmpx.h>
10 : : #endif
11 : :
12 : : #include "sd-device.h"
13 : :
14 : : #include "alloc-util.h"
15 : : #include "bus-error.h"
16 : : #include "bus-util.h"
17 : : #include "cgroup-util.h"
18 : : #include "conf-parser.h"
19 : : #include "device-util.h"
20 : : #include "errno-util.h"
21 : : #include "fd-util.h"
22 : : #include "limits-util.h"
23 : : #include "logind.h"
24 : : #include "parse-util.h"
25 : : #include "path-util.h"
26 : : #include "process-util.h"
27 : : #include "strv.h"
28 : : #include "terminal-util.h"
29 : : #include "udev-util.h"
30 : : #include "user-util.h"
31 : :
32 : 0 : void manager_reset_config(Manager *m) {
33 [ # # ]: 0 : assert(m);
34 : :
35 : 0 : m->n_autovts = 6;
36 : 0 : m->reserve_vt = 6;
37 : 0 : m->remove_ipc = true;
38 : 0 : m->inhibit_delay_max = 5 * USEC_PER_SEC;
39 : 0 : m->user_stop_delay = 10 * USEC_PER_SEC;
40 : :
41 : 0 : m->handle_power_key = HANDLE_POWEROFF;
42 : 0 : m->handle_suspend_key = HANDLE_SUSPEND;
43 : 0 : m->handle_hibernate_key = HANDLE_HIBERNATE;
44 : 0 : m->handle_lid_switch = HANDLE_SUSPEND;
45 : 0 : m->handle_lid_switch_ep = _HANDLE_ACTION_INVALID;
46 : 0 : m->handle_lid_switch_docked = HANDLE_IGNORE;
47 : 0 : m->power_key_ignore_inhibited = false;
48 : 0 : m->suspend_key_ignore_inhibited = false;
49 : 0 : m->hibernate_key_ignore_inhibited = false;
50 : 0 : m->lid_switch_ignore_inhibited = true;
51 : :
52 : 0 : m->holdoff_timeout_usec = 30 * USEC_PER_SEC;
53 : :
54 : 0 : m->idle_action_usec = 30 * USEC_PER_MINUTE;
55 : 0 : m->idle_action = HANDLE_IGNORE;
56 : :
57 : 0 : m->runtime_dir_size = physical_memory_scale(10U, 100U); /* 10% */
58 : 0 : m->user_tasks_max = system_tasks_max_scale(DEFAULT_USER_TASKS_MAX_PERCENTAGE, 100U); /* 33% */
59 : 0 : m->sessions_max = 8192;
60 : 0 : m->inhibitors_max = 8192;
61 : :
62 : 0 : m->kill_user_processes = KILL_USER_PROCESSES;
63 : :
64 : 0 : m->kill_only_users = strv_free(m->kill_only_users);
65 : 0 : m->kill_exclude_users = strv_free(m->kill_exclude_users);
66 : 0 : }
67 : :
68 : 0 : int manager_parse_config_file(Manager *m) {
69 [ # # ]: 0 : assert(m);
70 : :
71 : 0 : return config_parse_many_nulstr(PKGSYSCONFDIR "/logind.conf",
72 : : CONF_PATHS_NULSTR("systemd/logind.conf.d"),
73 : : "Login\0",
74 : : config_item_perf_lookup, logind_gperf_lookup,
75 : : CONFIG_PARSE_WARN, m);
76 : : }
77 : :
78 : 0 : int manager_add_device(Manager *m, const char *sysfs, bool master, Device **_device) {
79 : : Device *d;
80 : :
81 [ # # ]: 0 : assert(m);
82 [ # # ]: 0 : assert(sysfs);
83 : :
84 : 0 : d = hashmap_get(m->devices, sysfs);
85 [ # # ]: 0 : if (d)
86 : : /* we support adding master-flags, but not removing them */
87 [ # # # # ]: 0 : d->master = d->master || master;
88 : : else {
89 : 0 : d = device_new(m, sysfs, master);
90 [ # # ]: 0 : if (!d)
91 : 0 : return -ENOMEM;
92 : : }
93 : :
94 [ # # ]: 0 : if (_device)
95 : 0 : *_device = d;
96 : :
97 : 0 : return 0;
98 : : }
99 : :
100 : 0 : int manager_add_seat(Manager *m, const char *id, Seat **_seat) {
101 : : Seat *s;
102 : : int r;
103 : :
104 [ # # ]: 0 : assert(m);
105 [ # # ]: 0 : assert(id);
106 : :
107 : 0 : s = hashmap_get(m->seats, id);
108 [ # # ]: 0 : if (!s) {
109 : 0 : r = seat_new(&s, m, id);
110 [ # # ]: 0 : if (r < 0)
111 : 0 : return r;
112 : : }
113 : :
114 [ # # ]: 0 : if (_seat)
115 : 0 : *_seat = s;
116 : :
117 : 0 : return 0;
118 : : }
119 : :
120 : 0 : int manager_add_session(Manager *m, const char *id, Session **_session) {
121 : : Session *s;
122 : : int r;
123 : :
124 [ # # ]: 0 : assert(m);
125 [ # # ]: 0 : assert(id);
126 : :
127 : 0 : s = hashmap_get(m->sessions, id);
128 [ # # ]: 0 : if (!s) {
129 : 0 : r = session_new(&s, m, id);
130 [ # # ]: 0 : if (r < 0)
131 : 0 : return r;
132 : : }
133 : :
134 [ # # ]: 0 : if (_session)
135 : 0 : *_session = s;
136 : :
137 : 0 : return 0;
138 : : }
139 : :
140 : 0 : int manager_add_user(
141 : : Manager *m,
142 : : uid_t uid,
143 : : gid_t gid,
144 : : const char *name,
145 : : const char *home,
146 : : User **_user) {
147 : :
148 : : User *u;
149 : : int r;
150 : :
151 [ # # ]: 0 : assert(m);
152 [ # # ]: 0 : assert(name);
153 : :
154 : 0 : u = hashmap_get(m->users, UID_TO_PTR(uid));
155 [ # # ]: 0 : if (!u) {
156 : 0 : r = user_new(&u, m, uid, gid, name, home);
157 [ # # ]: 0 : if (r < 0)
158 : 0 : return r;
159 : : }
160 : :
161 [ # # ]: 0 : if (_user)
162 : 0 : *_user = u;
163 : :
164 : 0 : return 0;
165 : : }
166 : :
167 : 0 : int manager_add_user_by_name(
168 : : Manager *m,
169 : : const char *name,
170 : : User **_user) {
171 : :
172 : 0 : const char *home = NULL;
173 : : uid_t uid;
174 : : gid_t gid;
175 : : int r;
176 : :
177 [ # # ]: 0 : assert(m);
178 [ # # ]: 0 : assert(name);
179 : :
180 : 0 : r = get_user_creds(&name, &uid, &gid, &home, NULL, 0);
181 [ # # ]: 0 : if (r < 0)
182 : 0 : return r;
183 : :
184 : 0 : return manager_add_user(m, uid, gid, name, home, _user);
185 : : }
186 : :
187 : 0 : int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
188 : : struct passwd *p;
189 : :
190 [ # # ]: 0 : assert(m);
191 : :
192 : 0 : errno = 0;
193 : 0 : p = getpwuid(uid);
194 [ # # ]: 0 : if (!p)
195 : 0 : return errno_or_else(ENOENT);
196 : :
197 : 0 : return manager_add_user(m, uid, p->pw_gid, p->pw_name, p->pw_dir, _user);
198 : : }
199 : :
200 : 0 : int manager_add_inhibitor(Manager *m, const char* id, Inhibitor **ret) {
201 : : Inhibitor *i;
202 : : int r;
203 : :
204 [ # # ]: 0 : assert(m);
205 [ # # ]: 0 : assert(id);
206 : :
207 : 0 : i = hashmap_get(m->inhibitors, id);
208 [ # # ]: 0 : if (!i) {
209 : 0 : r = inhibitor_new(&i, m, id);
210 [ # # ]: 0 : if (r < 0)
211 : 0 : return r;
212 : : }
213 : :
214 [ # # ]: 0 : if (ret)
215 : 0 : *ret = i;
216 : :
217 : 0 : return 0;
218 : : }
219 : :
220 : 0 : int manager_add_button(Manager *m, const char *name, Button **_button) {
221 : : Button *b;
222 : :
223 [ # # ]: 0 : assert(m);
224 [ # # ]: 0 : assert(name);
225 : :
226 : 0 : b = hashmap_get(m->buttons, name);
227 [ # # ]: 0 : if (!b) {
228 : 0 : b = button_new(m, name);
229 [ # # ]: 0 : if (!b)
230 : 0 : return -ENOMEM;
231 : : }
232 : :
233 [ # # ]: 0 : if (_button)
234 : 0 : *_button = b;
235 : :
236 : 0 : return 0;
237 : : }
238 : :
239 : 0 : int manager_process_seat_device(Manager *m, sd_device *d) {
240 : : Device *device;
241 : : int r;
242 : :
243 [ # # ]: 0 : assert(m);
244 : :
245 [ # # ]: 0 : if (device_for_action(d, DEVICE_ACTION_REMOVE)) {
246 : : const char *syspath;
247 : :
248 : 0 : r = sd_device_get_syspath(d, &syspath);
249 [ # # ]: 0 : if (r < 0)
250 : 0 : return 0;
251 : :
252 : 0 : device = hashmap_get(m->devices, syspath);
253 [ # # ]: 0 : if (!device)
254 : 0 : return 0;
255 : :
256 : 0 : seat_add_to_gc_queue(device->seat);
257 : 0 : device_free(device);
258 : :
259 : : } else {
260 : : const char *sn, *syspath;
261 : : bool master;
262 : : Seat *seat;
263 : :
264 [ # # # # ]: 0 : if (sd_device_get_property_value(d, "ID_SEAT", &sn) < 0 || isempty(sn))
265 : 0 : sn = "seat0";
266 : :
267 [ # # ]: 0 : if (!seat_name_is_valid(sn)) {
268 [ # # # # : 0 : log_device_warning(d, "Device with invalid seat name %s found, ignoring.", sn);
# # ]
269 : 0 : return 0;
270 : : }
271 : :
272 : 0 : seat = hashmap_get(m->seats, sn);
273 : 0 : master = sd_device_has_tag(d, "master-of-seat") > 0;
274 : :
275 : : /* Ignore non-master devices for unknown seats */
276 [ # # # # ]: 0 : if (!master && !seat)
277 : 0 : return 0;
278 : :
279 : 0 : r = sd_device_get_syspath(d, &syspath);
280 [ # # ]: 0 : if (r < 0)
281 : 0 : return r;
282 : :
283 : 0 : r = manager_add_device(m, syspath, master, &device);
284 [ # # ]: 0 : if (r < 0)
285 : 0 : return r;
286 : :
287 [ # # ]: 0 : if (!seat) {
288 : 0 : r = manager_add_seat(m, sn, &seat);
289 [ # # ]: 0 : if (r < 0) {
290 [ # # ]: 0 : if (!device->seat)
291 : 0 : device_free(device);
292 : :
293 : 0 : return r;
294 : : }
295 : : }
296 : :
297 : 0 : device_attach(device, seat);
298 : 0 : seat_start(seat);
299 : : }
300 : :
301 : 0 : return 0;
302 : : }
303 : :
304 : 0 : int manager_process_button_device(Manager *m, sd_device *d) {
305 : : const char *sysname;
306 : : Button *b;
307 : : int r;
308 : :
309 [ # # ]: 0 : assert(m);
310 : :
311 : 0 : r = sd_device_get_sysname(d, &sysname);
312 [ # # ]: 0 : if (r < 0)
313 : 0 : return r;
314 : :
315 [ # # ]: 0 : if (device_for_action(d, DEVICE_ACTION_REMOVE)) {
316 : :
317 : 0 : b = hashmap_get(m->buttons, sysname);
318 [ # # ]: 0 : if (!b)
319 : 0 : return 0;
320 : :
321 : 0 : button_free(b);
322 : :
323 : : } else {
324 : : const char *sn;
325 : :
326 : 0 : r = manager_add_button(m, sysname, &b);
327 [ # # ]: 0 : if (r < 0)
328 : 0 : return r;
329 : :
330 [ # # # # ]: 0 : if (sd_device_get_property_value(d, "ID_SEAT", &sn) < 0 || isempty(sn))
331 : 0 : sn = "seat0";
332 : :
333 : 0 : button_set_seat(b, sn);
334 : :
335 : 0 : r = button_open(b);
336 [ # # ]: 0 : if (r < 0) /* event device doesn't have any keys or switches relevant to us? (or any other error
337 : : * opening the device?) let's close the button again. */
338 : 0 : button_free(b);
339 : : }
340 : :
341 : 0 : return 0;
342 : : }
343 : :
344 : 0 : int manager_get_session_by_pid(Manager *m, pid_t pid, Session **ret) {
345 : 0 : _cleanup_free_ char *unit = NULL;
346 : : Session *s;
347 : : int r;
348 : :
349 [ # # ]: 0 : assert(m);
350 : :
351 [ # # ]: 0 : if (!pid_is_valid(pid))
352 : 0 : return -EINVAL;
353 : :
354 : 0 : s = hashmap_get(m->sessions_by_leader, PID_TO_PTR(pid));
355 [ # # ]: 0 : if (!s) {
356 : 0 : r = cg_pid_get_unit(pid, &unit);
357 [ # # ]: 0 : if (r < 0)
358 : 0 : goto not_found;
359 : :
360 : 0 : s = hashmap_get(m->session_units, unit);
361 [ # # ]: 0 : if (!s)
362 : 0 : goto not_found;
363 : : }
364 : :
365 [ # # ]: 0 : if (ret)
366 : 0 : *ret = s;
367 : :
368 : 0 : return 1;
369 : :
370 : 0 : not_found:
371 [ # # ]: 0 : if (ret)
372 : 0 : *ret = NULL;
373 : 0 : return 0;
374 : : }
375 : :
376 : 0 : int manager_get_user_by_pid(Manager *m, pid_t pid, User **ret) {
377 : 0 : _cleanup_free_ char *unit = NULL;
378 : : User *u;
379 : : int r;
380 : :
381 [ # # ]: 0 : assert(m);
382 : :
383 [ # # ]: 0 : if (!pid_is_valid(pid))
384 : 0 : return -EINVAL;
385 : :
386 : 0 : r = cg_pid_get_slice(pid, &unit);
387 [ # # ]: 0 : if (r < 0)
388 : 0 : goto not_found;
389 : :
390 : 0 : u = hashmap_get(m->user_units, unit);
391 [ # # ]: 0 : if (!u)
392 : 0 : goto not_found;
393 : :
394 [ # # ]: 0 : if (ret)
395 : 0 : *ret = u;
396 : :
397 : 0 : return 1;
398 : :
399 : 0 : not_found:
400 [ # # ]: 0 : if (ret)
401 : 0 : *ret = NULL;
402 : :
403 : 0 : return 0;
404 : : }
405 : :
406 : 0 : int manager_get_idle_hint(Manager *m, dual_timestamp *t) {
407 : : Session *s;
408 : : bool idle_hint;
409 : 0 : dual_timestamp ts = DUAL_TIMESTAMP_NULL;
410 : : Iterator i;
411 : :
412 [ # # ]: 0 : assert(m);
413 : :
414 : 0 : idle_hint = !manager_is_inhibited(m, INHIBIT_IDLE, INHIBIT_BLOCK, t, false, false, 0, NULL);
415 : :
416 [ # # ]: 0 : HASHMAP_FOREACH(s, m->sessions, i) {
417 : : dual_timestamp k;
418 : : int ih;
419 : :
420 : 0 : ih = session_get_idle_hint(s, &k);
421 [ # # ]: 0 : if (ih < 0)
422 : 0 : return ih;
423 : :
424 [ # # ]: 0 : if (!ih) {
425 [ # # ]: 0 : if (!idle_hint) {
426 [ # # ]: 0 : if (k.monotonic < ts.monotonic)
427 : 0 : ts = k;
428 : : } else {
429 : 0 : idle_hint = false;
430 : 0 : ts = k;
431 : : }
432 [ # # ]: 0 : } else if (idle_hint) {
433 : :
434 [ # # ]: 0 : if (k.monotonic > ts.monotonic)
435 : 0 : ts = k;
436 : : }
437 : : }
438 : :
439 [ # # ]: 0 : if (t)
440 : 0 : *t = ts;
441 : :
442 : 0 : return idle_hint;
443 : : }
444 : :
445 : 0 : bool manager_shall_kill(Manager *m, const char *user) {
446 [ # # ]: 0 : assert(m);
447 [ # # ]: 0 : assert(user);
448 : :
449 [ # # # # ]: 0 : if (!m->kill_exclude_users && streq(user, "root"))
450 : 0 : return false;
451 : :
452 [ # # ]: 0 : if (strv_contains(m->kill_exclude_users, user))
453 : 0 : return false;
454 : :
455 [ # # ]: 0 : if (!strv_isempty(m->kill_only_users))
456 : 0 : return strv_contains(m->kill_only_users, user);
457 : :
458 : 0 : return m->kill_user_processes;
459 : : }
460 : :
461 : 0 : int config_parse_n_autovts(
462 : : const char *unit,
463 : : const char *filename,
464 : : unsigned line,
465 : : const char *section,
466 : : unsigned section_line,
467 : : const char *lvalue,
468 : : int ltype,
469 : : const char *rvalue,
470 : : void *data,
471 : : void *userdata) {
472 : :
473 : 0 : unsigned *n = data;
474 : : unsigned o;
475 : : int r;
476 : :
477 [ # # ]: 0 : assert(filename);
478 [ # # ]: 0 : assert(lvalue);
479 [ # # ]: 0 : assert(rvalue);
480 [ # # ]: 0 : assert(data);
481 : :
482 : 0 : r = safe_atou(rvalue, &o);
483 [ # # ]: 0 : if (r < 0) {
484 [ # # ]: 0 : log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse number of autovts, ignoring: %s", rvalue);
485 : 0 : return 0;
486 : : }
487 : :
488 [ # # ]: 0 : if (o > 15) {
489 [ # # ]: 0 : log_syntax(unit, LOG_ERR, filename, line, r, "A maximum of 15 autovts are supported, ignoring: %s", rvalue);
490 : 0 : return 0;
491 : : }
492 : :
493 : 0 : *n = o;
494 : 0 : return 0;
495 : : }
496 : :
497 : 0 : static int vt_is_busy(unsigned vtnr) {
498 : : struct vt_stat vt_stat;
499 : 0 : int r = 0;
500 : 0 : _cleanup_close_ int fd;
501 : :
502 [ # # ]: 0 : assert(vtnr >= 1);
503 : :
504 : : /* VT_GETSTATE "cannot return state for more than 16 VTs, since v_state is short" */
505 [ # # ]: 0 : assert(vtnr <= 15);
506 : :
507 : : /* We explicitly open /dev/tty1 here instead of /dev/tty0. If
508 : : * we'd open the latter we'd open the foreground tty which
509 : : * hence would be unconditionally busy. By opening /dev/tty1
510 : : * we avoid this. Since tty1 is special and needs to be an
511 : : * explicitly loaded getty or DM this is safe. */
512 : :
513 : 0 : fd = open_terminal("/dev/tty1", O_RDWR|O_NOCTTY|O_CLOEXEC);
514 [ # # ]: 0 : if (fd < 0)
515 : 0 : return -errno;
516 : :
517 [ # # ]: 0 : if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
518 : 0 : r = -errno;
519 : : else
520 : 0 : r = !!(vt_stat.v_state & (1 << vtnr));
521 : :
522 : 0 : return r;
523 : : }
524 : :
525 : 0 : int manager_spawn_autovt(Manager *m, unsigned vtnr) {
526 : 0 : _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
527 : : char name[sizeof("autovt@tty.service") + DECIMAL_STR_MAX(unsigned)];
528 : : int r;
529 : :
530 [ # # ]: 0 : assert(m);
531 [ # # ]: 0 : assert(vtnr >= 1);
532 : :
533 [ # # ]: 0 : if (vtnr > m->n_autovts &&
534 [ # # ]: 0 : vtnr != m->reserve_vt)
535 : 0 : return 0;
536 : :
537 [ # # ]: 0 : if (vtnr != m->reserve_vt) {
538 : : /* If this is the reserved TTY, we'll start the getty
539 : : * on it in any case, but otherwise only if it is not
540 : : * busy. */
541 : :
542 : 0 : r = vt_is_busy(vtnr);
543 [ # # ]: 0 : if (r < 0)
544 : 0 : return r;
545 [ # # ]: 0 : else if (r > 0)
546 : 0 : return -EBUSY;
547 : : }
548 : :
549 : 0 : snprintf(name, sizeof(name), "autovt@tty%u.service", vtnr);
550 : 0 : r = sd_bus_call_method(
551 : : m->bus,
552 : : "org.freedesktop.systemd1",
553 : : "/org/freedesktop/systemd1",
554 : : "org.freedesktop.systemd1.Manager",
555 : : "StartUnit",
556 : : &error,
557 : : NULL,
558 : : "ss", name, "fail");
559 [ # # ]: 0 : if (r < 0)
560 [ # # ]: 0 : return log_error_errno(r, "Failed to start %s: %s", name, bus_error_message(&error, r));
561 : :
562 : 0 : return 0;
563 : : }
564 : :
565 : 0 : bool manager_is_lid_closed(Manager *m) {
566 : : Iterator i;
567 : : Button *b;
568 : :
569 [ # # ]: 0 : HASHMAP_FOREACH(b, m->buttons, i)
570 [ # # ]: 0 : if (b->lid_closed)
571 : 0 : return true;
572 : :
573 : 0 : return false;
574 : : }
575 : :
576 : 0 : static bool manager_is_docked(Manager *m) {
577 : : Iterator i;
578 : : Button *b;
579 : :
580 [ # # ]: 0 : HASHMAP_FOREACH(b, m->buttons, i)
581 [ # # ]: 0 : if (b->docked)
582 : 0 : return true;
583 : :
584 : 0 : return false;
585 : : }
586 : :
587 : 0 : static int manager_count_external_displays(Manager *m) {
588 : 0 : _cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;
589 : : sd_device *d;
590 : 0 : int r, n = 0;
591 : :
592 : 0 : r = sd_device_enumerator_new(&e);
593 [ # # ]: 0 : if (r < 0)
594 : 0 : return r;
595 : :
596 : 0 : r = sd_device_enumerator_allow_uninitialized(e);
597 [ # # ]: 0 : if (r < 0)
598 : 0 : return r;
599 : :
600 : 0 : r = sd_device_enumerator_add_match_subsystem(e, "drm", true);
601 [ # # ]: 0 : if (r < 0)
602 : 0 : return r;
603 : :
604 [ # # ]: 0 : FOREACH_DEVICE(e, d) {
605 : : const char *status, *enabled, *dash, *nn, *subsys;
606 : : sd_device *p;
607 : :
608 [ # # ]: 0 : if (sd_device_get_parent(d, &p) < 0)
609 : 0 : continue;
610 : :
611 : : /* If the parent shares the same subsystem as the
612 : : * device we are looking at then it is a connector,
613 : : * which is what we are interested in. */
614 [ # # # # ]: 0 : if (sd_device_get_subsystem(p, &subsys) < 0 || !streq(subsys, "drm"))
615 : 0 : continue;
616 : :
617 [ # # ]: 0 : if (sd_device_get_sysname(d, &nn) < 0)
618 : 0 : continue;
619 : :
620 : : /* Ignore internal displays: the type is encoded in the sysfs name, as the second dash separated item
621 : : * (the first is the card name, the last the connector number). We implement a blacklist of external
622 : : * displays here, rather than a whitelist of internal ones, to ensure we don't block suspends too
623 : : * eagerly. */
624 : 0 : dash = strchr(nn, '-');
625 [ # # ]: 0 : if (!dash)
626 : 0 : continue;
627 : :
628 : 0 : dash++;
629 [ # # # # : 0 : if (!STARTSWITH_SET(dash,
# # # # ]
630 : : "VGA-", "DVI-I-", "DVI-D-", "DVI-A-"
631 : : "Composite-", "SVIDEO-", "Component-",
632 : : "DIN-", "DP-", "HDMI-A-", "HDMI-B-", "TV-"))
633 : 0 : continue;
634 : :
635 : : /* Ignore ports that are not enabled */
636 [ # # # # ]: 0 : if (sd_device_get_sysattr_value(d, "enabled", &enabled) < 0 || !streq(enabled, "enabled"))
637 : 0 : continue;
638 : :
639 : : /* We count any connector which is not explicitly
640 : : * "disconnected" as connected. */
641 [ # # # # ]: 0 : if (sd_device_get_sysattr_value(d, "status", &status) < 0 || !streq(status, "disconnected"))
642 : 0 : n++;
643 : : }
644 : :
645 : 0 : return n;
646 : : }
647 : :
648 : 0 : bool manager_is_docked_or_external_displays(Manager *m) {
649 : : int n;
650 : :
651 : : /* If we are docked don't react to lid closing */
652 [ # # ]: 0 : if (manager_is_docked(m)) {
653 [ # # ]: 0 : log_debug("System is docked.");
654 : 0 : return true;
655 : : }
656 : :
657 : : /* If we have more than one display connected,
658 : : * assume that we are docked. */
659 : 0 : n = manager_count_external_displays(m);
660 [ # # ]: 0 : if (n < 0)
661 [ # # ]: 0 : log_warning_errno(n, "Display counting failed: %m");
662 [ # # ]: 0 : else if (n >= 1) {
663 [ # # ]: 0 : log_debug("External (%i) displays connected.", n);
664 : 0 : return true;
665 : : }
666 : :
667 : 0 : return false;
668 : : }
669 : :
670 : 0 : bool manager_is_on_external_power(void) {
671 : : int r;
672 : :
673 : : /* For now we only check for AC power, but 'external power' can apply to anything that isn't an internal
674 : : * battery */
675 : 0 : r = on_ac_power();
676 [ # # ]: 0 : if (r < 0)
677 [ # # ]: 0 : log_warning_errno(r, "Failed to read AC power status: %m");
678 : :
679 : 0 : return r != 0; /* Treat failure as 'on AC' */
680 : : }
681 : :
682 : 0 : bool manager_all_buttons_ignored(Manager *m) {
683 [ # # ]: 0 : assert(m);
684 : :
685 [ # # ]: 0 : if (m->handle_power_key != HANDLE_IGNORE)
686 : 0 : return false;
687 [ # # ]: 0 : if (m->handle_suspend_key != HANDLE_IGNORE)
688 : 0 : return false;
689 [ # # ]: 0 : if (m->handle_hibernate_key != HANDLE_IGNORE)
690 : 0 : return false;
691 [ # # ]: 0 : if (m->handle_lid_switch != HANDLE_IGNORE)
692 : 0 : return false;
693 [ # # # # ]: 0 : if (!IN_SET(m->handle_lid_switch_ep, _HANDLE_ACTION_INVALID, HANDLE_IGNORE))
694 : 0 : return false;
695 [ # # ]: 0 : if (m->handle_lid_switch_docked != HANDLE_IGNORE)
696 : 0 : return false;
697 : :
698 : 0 : return true;
699 : : }
700 : :
701 : 0 : int manager_read_utmp(Manager *m) {
702 : : #if ENABLE_UTMP
703 : : int r;
704 : :
705 [ # # ]: 0 : assert(m);
706 : :
707 [ # # ]: 0 : if (utmpxname(_PATH_UTMPX) < 0)
708 [ # # ]: 0 : return log_error_errno(errno, "Failed to set utmp path to " _PATH_UTMPX ": %m");
709 : :
710 : 0 : setutxent();
711 : :
712 : 0 : for (;;) {
713 [ # # # ]: 0 : _cleanup_free_ char *t = NULL;
714 : : struct utmpx *u;
715 : : const char *c;
716 : : Session *s;
717 : :
718 : 0 : errno = 0;
719 : 0 : u = getutxent();
720 [ # # ]: 0 : if (!u) {
721 [ # # ]: 0 : if (errno != 0)
722 [ # # ]: 0 : log_warning_errno(errno, "Failed to read " _PATH_UTMPX ", ignoring: %m");
723 : 0 : r = 0;
724 : 0 : break;
725 : : }
726 : :
727 [ # # ]: 0 : if (u->ut_type != USER_PROCESS)
728 : 0 : continue;
729 : :
730 [ # # ]: 0 : if (!pid_is_valid(u->ut_pid))
731 : 0 : continue;
732 : :
733 : 0 : t = strndup(u->ut_line, sizeof(u->ut_line));
734 [ # # ]: 0 : if (!t) {
735 : 0 : r = log_oom();
736 : 0 : break;
737 : : }
738 : :
739 : 0 : c = path_startswith(t, "/dev/");
740 [ # # ]: 0 : if (c) {
741 : 0 : r = free_and_strdup(&t, c);
742 [ # # ]: 0 : if (r < 0) {
743 : 0 : log_oom();
744 : 0 : break;
745 : : }
746 : : }
747 : :
748 [ # # ]: 0 : if (isempty(t))
749 : 0 : continue;
750 : :
751 : 0 : s = hashmap_get(m->sessions_by_leader, PID_TO_PTR(u->ut_pid));
752 [ # # ]: 0 : if (!s)
753 : 0 : continue;
754 : :
755 [ # # # # ]: 0 : if (s->tty_validity == TTY_FROM_UTMP && !streq_ptr(s->tty, t)) {
756 : : /* This may happen on multiplexed SSH connection (i.e. 'SSH connection sharing'). In
757 : : * this case PAM and utmp sessions don't match. In such a case let's invalidate the TTY
758 : : * information and never acquire it again. */
759 : :
760 : 0 : s->tty = mfree(s->tty);
761 : 0 : s->tty_validity = TTY_UTMP_INCONSISTENT;
762 [ # # ]: 0 : log_debug("Session '%s' has inconsistent TTY information, dropping TTY information.", s->id);
763 : 0 : continue;
764 : : }
765 : :
766 : : /* Never override what we figured out once */
767 [ # # # # ]: 0 : if (s->tty || s->tty_validity >= 0)
768 : 0 : continue;
769 : :
770 : 0 : s->tty = TAKE_PTR(t);
771 : 0 : s->tty_validity = TTY_FROM_UTMP;
772 [ # # ]: 0 : log_debug("Acquired TTY information '%s' from utmp for session '%s'.", s->tty, s->id);
773 : : }
774 : :
775 : 0 : endutxent();
776 : 0 : return r;
777 : : #else
778 : : return 0;
779 : : #endif
780 : : }
781 : :
782 : : #if ENABLE_UTMP
783 : 0 : static int manager_dispatch_utmp(sd_event_source *s, const struct inotify_event *event, void *userdata) {
784 : 0 : Manager *m = userdata;
785 : :
786 [ # # ]: 0 : assert(m);
787 : :
788 : : /* If there's indication the file itself might have been removed or became otherwise unavailable, then let's
789 : : * reestablish the watch on whatever there's now. */
790 [ # # ]: 0 : if ((event->mask & (IN_ATTRIB|IN_DELETE_SELF|IN_MOVE_SELF|IN_Q_OVERFLOW|IN_UNMOUNT)) != 0)
791 : 0 : manager_connect_utmp(m);
792 : :
793 : 0 : (void) manager_read_utmp(m);
794 : 0 : return 0;
795 : : }
796 : : #endif
797 : :
798 : 0 : void manager_connect_utmp(Manager *m) {
799 : : #if ENABLE_UTMP
800 : 0 : sd_event_source *s = NULL;
801 : : int r;
802 : :
803 [ # # ]: 0 : assert(m);
804 : :
805 : : /* Watch utmp for changes via inotify. We do this to deal with tools such as ssh, which will register the PAM
806 : : * session early, and acquire a TTY only much later for the connection. Thus during PAM the TTY won't be known
807 : : * yet. ssh will register itself with utmp when it finally acquired the TTY. Hence, let's make use of this, and
808 : : * watch utmp for the TTY asynchronously. We use the PAM session's leader PID as key, to find the right entry.
809 : : *
810 : : * Yes, relying on utmp is pretty ugly, but it's good enough for informational purposes, as well as idle
811 : : * detection (which, for tty sessions, relies on the TTY used) */
812 : :
813 : 0 : r = sd_event_add_inotify(m->event, &s, _PATH_UTMPX, IN_MODIFY|IN_MOVE_SELF|IN_DELETE_SELF|IN_ATTRIB, manager_dispatch_utmp, m);
814 [ # # ]: 0 : if (r < 0)
815 [ # # # # ]: 0 : log_full_errno(r == -ENOENT ? LOG_DEBUG: LOG_WARNING, r, "Failed to create inotify watch on " _PATH_UTMPX ", ignoring: %m");
816 : : else {
817 : 0 : r = sd_event_source_set_priority(s, SD_EVENT_PRIORITY_IDLE);
818 [ # # ]: 0 : if (r < 0)
819 [ # # ]: 0 : log_warning_errno(r, "Failed to adjust utmp event source priority, ignoring: %m");
820 : :
821 : 0 : (void) sd_event_source_set_description(s, "utmp");
822 : : }
823 : :
824 : 0 : sd_event_source_unref(m->utmp_event_source);
825 : 0 : m->utmp_event_source = s;
826 : : #endif
827 : 0 : }
828 : :
829 : 0 : void manager_reconnect_utmp(Manager *m) {
830 : : #if ENABLE_UTMP
831 [ # # ]: 0 : assert(m);
832 : :
833 [ # # ]: 0 : if (m->utmp_event_source)
834 : 0 : return;
835 : :
836 : 0 : manager_connect_utmp(m);
837 : : #endif
838 : : }
|
