]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/logind-seat.c
logind: make idle hint logic work
[thirdparty/systemd.git] / src / logind-seat.c
CommitLineData
20263082
LP
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 General Public License as published by
10 the Free Software Foundation; either version 2 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 General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
22#include <assert.h>
23#include <errno.h>
24#include <unistd.h>
25#include <fcntl.h>
26#include <sys/ioctl.h>
27#include <linux/vt.h>
5eda94dd 28#include <string.h>
20263082 29
90821c93 30#include "logind-seat.h"
5eda94dd 31#include "logind-acl.h"
20263082
LP
32#include "util.h"
33
34Seat *seat_new(Manager *m, const char *id) {
35 Seat *s;
36
37 assert(m);
38 assert(id);
39
40 s = new0(Seat, 1);
41 if (!s)
42 return NULL;
43
44 s->state_file = strappend("/run/systemd/seat/", id);
45 if (!s->state_file) {
46 free(s);
47 return NULL;
48 }
49
50 s->id = file_name_from_path(s->state_file);
14c3baca 51 s->manager = m;
20263082
LP
52
53 if (hashmap_put(m->seats, s->id, s) < 0) {
14c3baca 54 free(s->state_file);
20263082
LP
55 free(s);
56 return NULL;
57 }
58
20263082
LP
59 return s;
60}
61
62void seat_free(Seat *s) {
63 assert(s);
64
14c3baca
LP
65 if (s->in_gc_queue)
66 LIST_REMOVE(Seat, gc_queue, s->manager->seat_gc_queue, s);
67
20263082
LP
68 while (s->sessions)
69 session_free(s->sessions);
70
71 assert(!s->active);
72
73 while (s->devices)
74 device_free(s->devices);
75
76 hashmap_remove(s->manager->seats, s->id);
77
d2f92cdf 78 free(s->state_file);
20263082
LP
79 free(s);
80}
81
82int seat_save(Seat *s) {
20263082 83 int r;
14c3baca
LP
84 FILE *f;
85 char *temp_path;
20263082
LP
86
87 assert(s);
88
89 r = safe_mkdir("/run/systemd/seat", 0755, 0, 0);
90 if (r < 0)
14c3baca
LP
91 goto finish;
92
93 r = fopen_temporary(s->state_file, &f, &temp_path);
94 if (r < 0)
95 goto finish;
20263082 96
14c3baca 97 fchmod(fileno(f), 0644);
20263082
LP
98
99 fprintf(f,
14c3baca 100 "# This is private data. Do not parse.\n"
20263082 101 "IS_VTCONSOLE=%i\n",
a185c5aa 102 seat_is_vtconsole(s));
20263082
LP
103
104 if (s->active) {
105 assert(s->active->user);
106
107 fprintf(f,
108 "ACTIVE=%s\n"
109 "ACTIVE_UID=%lu\n",
110 s->active->id,
111 (unsigned long) s->active->user->uid);
112 }
113
114 if (s->sessions) {
115 Session *i;
20263082 116
14c3baca 117 fputs("OTHER=", f);
20263082 118 LIST_FOREACH(sessions_by_seat, i, s->sessions) {
14c3baca
LP
119 if (i == s->active)
120 continue;
121
122 fprintf(f,
123 "%s%c",
124 i->id,
125 i->sessions_by_seat_next ? ' ' : '\n');
126 }
20263082 127
14c3baca
LP
128 fputs("OTHER_UIDS=", f);
129 LIST_FOREACH(sessions_by_seat, i, s->sessions) {
20263082
LP
130 if (i == s->active)
131 continue;
132
133 fprintf(f,
14c3baca
LP
134 "%lu%c",
135 (unsigned long) i->user->uid,
136 i->sessions_by_seat_next ? ' ' : '\n');
20263082
LP
137 }
138 }
139
140 fflush(f);
14c3baca
LP
141
142 if (ferror(f) || rename(temp_path, s->state_file) < 0) {
20263082
LP
143 r = -errno;
144 unlink(s->state_file);
14c3baca 145 unlink(temp_path);
20263082
LP
146 }
147
148 fclose(f);
14c3baca
LP
149 free(temp_path);
150
151finish:
152 if (r < 0)
153 log_error("Failed to save seat data for %s: %s", s->id, strerror(-r));
154
20263082
LP
155 return r;
156}
157
158int seat_load(Seat *s) {
159 assert(s);
160
a185c5aa
LP
161 /* There isn't actually anything to read here ... */
162
20263082
LP
163 return 0;
164}
165
166static int vt_allocate(int vtnr) {
167 int fd, r;
168 char *p;
169
170 assert(vtnr >= 1);
171
172 if (asprintf(&p, "/dev/tty%i", vtnr) < 0)
173 return -ENOMEM;
174
175 fd = open_terminal(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
176 free(p);
177
178 r = fd < 0 ? -errno : 0;
179
180 if (fd >= 0)
181 close_nointr_nofail(fd);
182
183 return r;
184}
185
14c3baca 186static int seat_preallocate_vts(Seat *s) {
3f49d45a
LP
187 int r = 0;
188 unsigned i;
20263082
LP
189
190 assert(s);
191 assert(s->manager);
192
193 if (s->manager->n_autovts <= 0)
194 return 0;
195
a185c5aa 196 if (!seat_is_vtconsole(s))
20263082
LP
197 return 0;
198
199 for (i = 1; i < s->manager->n_autovts; i++) {
200 int q;
201
202 q = vt_allocate(i);
14c3baca
LP
203 if (q < 0) {
204 log_error("Failed to preallocate VT %i: %s", i, strerror(-q));
20263082 205 r = q;
14c3baca 206 }
20263082
LP
207 }
208
209 return r;
210}
211
5eda94dd
LP
212int seat_apply_acls(Seat *s, Session *old_active) {
213 int r;
20263082 214
5eda94dd 215 assert(s);
20263082 216
5eda94dd
LP
217 r = devnode_acl_all(s->manager->udev,
218 s->id,
219 false,
220 !!old_active, old_active ? old_active->user->uid : 0,
221 !!s->active, s->active ? s->active->user->uid : 0);
20263082 222
5eda94dd
LP
223 if (r < 0)
224 log_error("Failed to apply ACLs: %s", strerror(-r));
20263082
LP
225
226 return r;
227}
228
9418f147
LP
229int seat_set_active(Seat *s, Session *session) {
230 Session *old_active;
231
232 assert(s);
77527da0 233 assert(!session || session->seat == s);
9418f147
LP
234
235 if (session == s->active)
236 return 0;
237
238 old_active = s->active;
239 s->active = session;
240
241 seat_apply_acls(s, old_active);
242
243 if (session && session->started)
244 session_send_changed(session, "Active\0");
245
246 if (!session || session->started)
247 seat_send_changed(s, "ActiveSession\0");
248
249 return 0;
250}
251
5eda94dd 252int seat_active_vt_changed(Seat *s, int vtnr) {
9418f147
LP
253 Session *i, *new_active = NULL;
254 int r;
20263082
LP
255
256 assert(s);
257 assert(vtnr >= 1);
20263082 258
a185c5aa 259 if (!seat_is_vtconsole(s))
14c3baca
LP
260 return -EINVAL;
261
262 log_debug("VT changed to %i", vtnr);
20263082
LP
263
264 LIST_FOREACH(sessions_by_seat, i, s->sessions)
265 if (i->vtnr == vtnr) {
14c3baca 266 new_active = i;
20263082
LP
267 break;
268 }
269
9418f147 270 r = seat_set_active(s, new_active);
5eda94dd 271 manager_spawn_autovt(s->manager, vtnr);
20263082 272
9418f147 273 return r;
20263082
LP
274}
275
14c3baca
LP
276int seat_read_active_vt(Seat *s) {
277 char t[64];
278 ssize_t k;
279 int r, vtnr;
280
281 assert(s);
282
a185c5aa 283 if (!seat_is_vtconsole(s))
14c3baca
LP
284 return 0;
285
286 lseek(s->manager->console_active_fd, SEEK_SET, 0);
287
288 k = read(s->manager->console_active_fd, t, sizeof(t)-1);
289 if (k <= 0) {
290 log_error("Failed to read current console: %s", k < 0 ? strerror(-errno) : "EOF");
291 return k < 0 ? -errno : -EIO;
292 }
293
294 t[k] = 0;
295 truncate_nl(t);
296
297 if (!startswith(t, "tty")) {
298 log_error("Hm, /sys/class/tty/tty0/active is badly formatted.");
299 return -EIO;
300 }
301
302 r = safe_atoi(t+3, &vtnr);
303 if (r < 0) {
304 log_error("Failed to parse VT number %s", t+3);
305 return r;
306 }
307
308 if (vtnr <= 0) {
309 log_error("VT number invalid: %s", t+3);
310 return -EIO;
311 }
312
313 return seat_active_vt_changed(s, vtnr);
314}
315
316int seat_start(Seat *s) {
317 assert(s);
318
3f49d45a
LP
319 if (s->started)
320 return 0;
321
322 log_info("New seat %s.", s->id);
323
14c3baca
LP
324 /* Initialize VT magic stuff */
325 seat_preallocate_vts(s);
326
327 /* Read current VT */
328 seat_read_active_vt(s);
329
330 /* Save seat data */
331 seat_save(s);
332
3f49d45a
LP
333 s->started = true;
334
da119395
LP
335 seat_send_signal(s, true);
336
14c3baca
LP
337 return 0;
338}
339
20263082 340int seat_stop(Seat *s) {
a185c5aa 341 int r = 0;
20263082
LP
342
343 assert(s);
344
3f49d45a
LP
345 if (!s->started)
346 return 0;
347
348 log_info("Removed seat %s.", s->id);
349
da119395
LP
350 seat_send_signal(s, false);
351
a185c5aa
LP
352 seat_stop_sessions(s);
353
354 unlink(s->state_file);
355 seat_add_to_gc_queue(s);
356
357 s->started = false;
358
359 return r;
360}
361
362int seat_stop_sessions(Seat *s) {
363 Session *session;
364 int r = 0, k;
365
366 assert(s);
367
20263082 368 LIST_FOREACH(sessions_by_seat, session, s->sessions) {
20263082
LP
369 k = session_stop(session);
370 if (k < 0)
371 r = k;
372 }
373
a185c5aa
LP
374 return r;
375}
14c3baca 376
a185c5aa
LP
377int seat_attach_session(Seat *s, Session *session) {
378 assert(s);
379 assert(session);
380 assert(!session->seat);
3f49d45a 381
9418f147
LP
382 if (!seat_is_vtconsole(s) && s->sessions)
383 return -EEXIST;
a185c5aa
LP
384
385 session->seat = s;
386 LIST_PREPEND(Session, sessions_by_seat, s->sessions, session);
387
9418f147
LP
388 seat_send_changed(s, "Sessions\0");
389
390 if (!seat_is_vtconsole(s)) {
391 assert(!s->active);
392 seat_set_active(s, session);
393 }
394
a185c5aa
LP
395 return 0;
396}
397
398bool seat_is_vtconsole(Seat *s) {
399 assert(s);
400
401 return s->manager->vtconsole == s;
402}
403
404int seat_get_idle_hint(Seat *s, dual_timestamp *t) {
405 Session *session;
406 bool idle_hint = true;
407 dual_timestamp ts = { 0, 0 };
408
409 assert(s);
410
411 LIST_FOREACH(sessions_by_seat, session, s->sessions) {
412 dual_timestamp k;
413 int ih;
414
415 ih = session_get_idle_hint(session, &k);
416 if (ih < 0)
417 return ih;
418
419 if (!ih) {
420 if (!idle_hint) {
421 if (k.monotonic < ts.monotonic)
422 ts = k;
423 } else {
424 idle_hint = false;
425 ts = k;
426 }
427 } else if (idle_hint) {
428
429 if (k.monotonic > ts.monotonic)
430 ts = k;
431 }
432 }
433
434 if (t)
435 *t = ts;
436
437 return idle_hint;
20263082 438}
14c3baca
LP
439
440int seat_check_gc(Seat *s) {
441 assert(s);
442
a185c5aa 443 if (seat_is_vtconsole(s))
14c3baca
LP
444 return 1;
445
446 return !!s->devices;
447}
448
449void seat_add_to_gc_queue(Seat *s) {
450 assert(s);
451
452 if (s->in_gc_queue)
453 return;
454
455 LIST_PREPEND(Seat, gc_queue, s->manager->seat_gc_queue, s);
456 s->in_gc_queue = true;
457}
3f49d45a
LP
458
459static bool seat_name_valid_char(char c) {
460 return
461 (c >= 'a' && c <= 'z') ||
462 (c >= 'A' && c <= 'Z') ||
463 (c >= '0' && c <= '9') ||
464 c == '-' ||
465 c == '_';
466}
467
468bool seat_name_is_valid(const char *name) {
469 const char *p;
470
471 assert(name);
472
473 if (!startswith(name, "seat"))
474 return false;
475
476 if (!name[4])
477 return false;
478
479 for (p = name; *p; p++)
480 if (!seat_name_valid_char(*p))
481 return false;
482
483 return true;
484}