chiark / gitweb /
keymap: Asus -- do not overwrite explicitely kernel driver defined keys
[elogind.git] / src / login / logind-session.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 <sys/epoll.h>
26 #include <fcntl.h>
27
28 #include <systemd/sd-id128.h>
29 #include <systemd/sd-messages.h>
30
31 #include "strv.h"
32 #include "util.h"
33 #include "mkdir.h"
34 #include "path-util.h"
35 #include "cgroup-util.h"
36 #include "fileio.h"
37 #include "dbus-common.h"
38 #include "logind-session.h"
39
40 Session* session_new(Manager *m, const char *id) {
41         Session *s;
42
43         assert(m);
44         assert(id);
45
46         s = new0(Session, 1);
47         if (!s)
48                 return NULL;
49
50         s->state_file = strappend("/run/systemd/sessions/", id);
51         if (!s->state_file) {
52                 free(s);
53                 return NULL;
54         }
55
56         s->id = path_get_file_name(s->state_file);
57
58         if (hashmap_put(m->sessions, s->id, s) < 0) {
59                 free(s->state_file);
60                 free(s);
61                 return NULL;
62         }
63
64         s->manager = m;
65         s->fifo_fd = -1;
66
67         return s;
68 }
69
70 void session_free(Session *s) {
71         assert(s);
72
73         if (s->in_gc_queue)
74                 LIST_REMOVE(Session, gc_queue, s->manager->session_gc_queue, s);
75
76         if (s->user) {
77                 LIST_REMOVE(Session, sessions_by_user, s->user->sessions, s);
78
79                 if (s->user->display == s)
80                         s->user->display = NULL;
81         }
82
83         if (s->seat) {
84                 if (s->seat->active == s)
85                         s->seat->active = NULL;
86
87                 LIST_REMOVE(Session, sessions_by_seat, s->seat->sessions, s);
88         }
89
90         if (s->scope) {
91                 hashmap_remove(s->manager->session_units, s->scope);
92                 free(s->scope);
93         }
94
95         free(s->scope_job);
96
97         if (s->create_message)
98                 dbus_message_unref(s->create_message);
99
100         free(s->tty);
101         free(s->display);
102         free(s->remote_host);
103         free(s->remote_user);
104         free(s->service);
105
106         hashmap_remove(s->manager->sessions, s->id);
107         session_remove_fifo(s);
108
109         free(s->state_file);
110         free(s);
111 }
112
113 void session_set_user(Session *s, User *u) {
114         assert(s);
115         assert(!s->user);
116
117         s->user = u;
118         LIST_PREPEND(Session, sessions_by_user, u->sessions, s);
119 }
120
121 int session_save(Session *s) {
122         _cleanup_fclose_ FILE *f = NULL;
123         _cleanup_free_ char *temp_path = NULL;
124         int r = 0;
125
126         assert(s);
127
128         if (!s->user)
129                 return -ESTALE;
130
131         if (!s->started)
132                 return 0;
133
134         r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0);
135         if (r < 0)
136                 goto finish;
137
138         r = fopen_temporary(s->state_file, &f, &temp_path);
139         if (r < 0)
140                 goto finish;
141
142         assert(s->user);
143
144         fchmod(fileno(f), 0644);
145
146         fprintf(f,
147                 "# This is private data. Do not parse.\n"
148                 "UID=%lu\n"
149                 "USER=%s\n"
150                 "ACTIVE=%i\n"
151                 "STATE=%s\n"
152                 "REMOTE=%i\n",
153                 (unsigned long) s->user->uid,
154                 s->user->name,
155                 session_is_active(s),
156                 session_state_to_string(session_get_state(s)),
157                 s->remote);
158
159         if (s->type >= 0)
160                 fprintf(f, "TYPE=%s\n", session_type_to_string(s->type));
161
162         if (s->class >= 0)
163                 fprintf(f, "CLASS=%s\n", session_class_to_string(s->class));
164
165         if (s->scope)
166                 fprintf(f, "SCOPE=%s\n", s->scope);
167
168         if (s->scope_job)
169                 fprintf(f, "SCOPE_JOB=%s\n", s->scope_job);
170
171         if (s->fifo_path)
172                 fprintf(f, "FIFO=%s\n", s->fifo_path);
173
174         if (s->seat)
175                 fprintf(f, "SEAT=%s\n", s->seat->id);
176
177         if (s->tty)
178                 fprintf(f, "TTY=%s\n", s->tty);
179
180         if (s->display)
181                 fprintf(f, "DISPLAY=%s\n", s->display);
182
183         if (s->remote_host)
184                 fprintf(f, "REMOTE_HOST=%s\n", s->remote_host);
185
186         if (s->remote_user)
187                 fprintf(f, "REMOTE_USER=%s\n", s->remote_user);
188
189         if (s->service)
190                 fprintf(f, "SERVICE=%s\n", s->service);
191
192         if (s->seat && seat_can_multi_session(s->seat))
193                 fprintf(f, "VTNR=%i\n", s->vtnr);
194
195         if (s->leader > 0)
196                 fprintf(f, "LEADER=%lu\n", (unsigned long) s->leader);
197
198         if (s->audit_id > 0)
199                 fprintf(f, "AUDIT=%"PRIu32"\n", s->audit_id);
200
201         if (dual_timestamp_is_set(&s->timestamp))
202                 fprintf(f,
203                         "REALTIME=%llu\n"
204                         "MONOTONIC=%llu\n",
205                         (unsigned long long) s->timestamp.realtime,
206                         (unsigned long long) s->timestamp.monotonic);
207
208         fflush(f);
209
210         if (ferror(f) || rename(temp_path, s->state_file) < 0) {
211                 r = -errno;
212                 unlink(s->state_file);
213                 unlink(temp_path);
214         }
215
216 finish:
217         if (r < 0)
218                 log_error("Failed to save session data for %s: %s", s->id, strerror(-r));
219
220         return r;
221 }
222
223 int session_load(Session *s) {
224         _cleanup_free_ char *remote = NULL,
225                 *seat = NULL,
226                 *vtnr = NULL,
227                 *leader = NULL,
228                 *audit_id = NULL,
229                 *type = NULL,
230                 *class = NULL,
231                 *uid = NULL,
232                 *realtime = NULL,
233                 *monotonic = NULL;
234
235         int k, r;
236
237         assert(s);
238
239         r = parse_env_file(s->state_file, NEWLINE,
240                            "REMOTE",         &remote,
241                            "SCOPE",          &s->scope,
242                            "SCOPE_JOB",      &s->scope_job,
243                            "FIFO",           &s->fifo_path,
244                            "SEAT",           &seat,
245                            "TTY",            &s->tty,
246                            "DISPLAY",        &s->display,
247                            "REMOTE_HOST",    &s->remote_host,
248                            "REMOTE_USER",    &s->remote_user,
249                            "SERVICE",        &s->service,
250                            "VTNR",           &vtnr,
251                            "LEADER",         &leader,
252                            "TYPE",           &type,
253                            "CLASS",          &class,
254                            "UID",            &uid,
255                            "REALTIME",       &realtime,
256                            "MONOTONIC",      &monotonic,
257                            NULL);
258
259         if (r < 0) {
260                 log_error("Failed to read %s: %s", s->state_file, strerror(-r));
261                 return r;
262         }
263
264         if (!s->user) {
265                 uid_t u;
266                 User *user;
267
268                 if (!uid) {
269                         log_error("UID not specified for session %s", s->id);
270                         return -ENOENT;
271                 }
272
273                 r = parse_uid(uid, &u);
274                 if (r < 0)  {
275                         log_error("Failed to parse UID value %s for session %s.", uid, s->id);
276                         return r;
277                 }
278
279                 user = hashmap_get(s->manager->users, ULONG_TO_PTR((unsigned long) u));
280                 if (!user) {
281                         log_error("User of session %s not known.", s->id);
282                         return -ENOENT;
283                 }
284
285                 session_set_user(s, user);
286         }
287
288         if (remote) {
289                 k = parse_boolean(remote);
290                 if (k >= 0)
291                         s->remote = k;
292         }
293
294         if (seat && !s->seat) {
295                 Seat *o;
296
297                 o = hashmap_get(s->manager->seats, seat);
298                 if (o)
299                         seat_attach_session(o, s);
300         }
301
302         if (vtnr && s->seat && seat_can_multi_session(s->seat)) {
303                 int v;
304
305                 k = safe_atoi(vtnr, &v);
306                 if (k >= 0 && v >= 1)
307                         s->vtnr = v;
308         }
309
310         if (leader) {
311                 k = parse_pid(leader, &s->leader);
312                 if (k >= 0)
313                         audit_session_from_pid(s->leader, &s->audit_id);
314         }
315
316         if (type) {
317                 SessionType t;
318
319                 t = session_type_from_string(type);
320                 if (t >= 0)
321                         s->type = t;
322         }
323
324         if (class) {
325                 SessionClass c;
326
327                 c = session_class_from_string(class);
328                 if (c >= 0)
329                         s->class = c;
330         }
331
332         if (s->fifo_path) {
333                 int fd;
334
335                 /* If we open an unopened pipe for reading we will not
336                    get an EOF. to trigger an EOF we hence open it for
337                    reading, but close it right-away which then will
338                    trigger the EOF. */
339
340                 fd = session_create_fifo(s);
341                 if (fd >= 0)
342                         close_nointr_nofail(fd);
343         }
344
345         if (realtime) {
346                 unsigned long long l;
347                 if (sscanf(realtime, "%llu", &l) > 0)
348                         s->timestamp.realtime = l;
349         }
350
351         if (monotonic) {
352                 unsigned long long l;
353                 if (sscanf(monotonic, "%llu", &l) > 0)
354                         s->timestamp.monotonic = l;
355         }
356
357         return r;
358 }
359
360 int session_activate(Session *s) {
361         int r;
362
363         assert(s);
364         assert(s->user);
365
366         if (s->vtnr < 0)
367                 return -ENOTSUP;
368
369         if (!s->seat)
370                 return -ENOTSUP;
371
372         if (s->seat->active == s)
373                 return 0;
374
375         assert(seat_is_vtconsole(s->seat));
376
377         r = chvt(s->vtnr);
378         if (r < 0)
379                 return r;
380
381         return seat_set_active(s->seat, s);
382 }
383
384 static int session_link_x11_socket(Session *s) {
385         char *t, *f, *c;
386         size_t k;
387
388         assert(s);
389         assert(s->user);
390         assert(s->user->runtime_path);
391
392         if (s->user->display)
393                 return 0;
394
395         if (!s->display || !display_is_local(s->display))
396                 return 0;
397
398         k = strspn(s->display+1, "0123456789");
399         f = new(char, sizeof("/tmp/.X11-unix/X") + k);
400         if (!f)
401                 return log_oom();
402
403         c = stpcpy(f, "/tmp/.X11-unix/X");
404         memcpy(c, s->display+1, k);
405         c[k] = 0;
406
407         if (access(f, F_OK) < 0) {
408                 log_warning("Session %s has display %s with non-existing socket %s.", s->id, s->display, f);
409                 free(f);
410                 return -ENOENT;
411         }
412
413         /* Note that this cannot be in a subdir to avoid
414          * vulnerabilities since we are privileged but the runtime
415          * path is owned by the user */
416
417         t = strappend(s->user->runtime_path, "/X11-display");
418         if (!t) {
419                 free(f);
420                 return log_oom();
421         }
422
423         if (link(f, t) < 0) {
424                 if (errno == EEXIST) {
425                         unlink(t);
426
427                         if (link(f, t) >= 0)
428                                 goto done;
429                 }
430
431                 if (symlink(f, t) < 0) {
432
433                         if (errno == EEXIST) {
434                                 unlink(t);
435
436                                 if (symlink(f, t) >= 0)
437                                         goto done;
438                         }
439
440                         log_error("Failed to link %s to %s: %m", f, t);
441                         free(f);
442                         free(t);
443                         return -errno;
444                 }
445         }
446
447 done:
448         log_info("Linked %s to %s.", f, t);
449         free(f);
450         free(t);
451
452         s->user->display = s;
453
454         return 0;
455 }
456
457 static int session_start_scope(Session *s) {
458         _cleanup_free_ char *description = NULL;
459         DBusError error;
460         char *job;
461         int r;
462
463         assert(s);
464         assert(s->user);
465         assert(s->user->slice);
466
467         dbus_error_init(&error);
468
469         if (!s->scope) {
470                 s->scope = strjoin("session.", s->id, ".scope", NULL);
471                 if (!s->scope)
472                         return log_oom();
473
474                 r = hashmap_put(s->manager->session_units, s->scope, s);
475                 if (r < 0)
476                         log_warning("Failed to create mapping between unit and session");
477         }
478
479         description = strjoin("Session ", s->id, " of user ", s->user->name, NULL);
480
481         r = manager_start_scope(s->manager, s->scope, s->leader, s->user->slice, description, &error, &job);
482         if (r < 0) {
483                 log_error("Failed to start session scope: %s %s", bus_error(&error, r), error.name);
484                 dbus_error_free(&error);
485         } else {
486                 free(s->scope_job);
487                 s->scope_job = job;
488         }
489
490         return 0;
491 }
492
493 int session_start(Session *s) {
494         int r;
495
496         assert(s);
497
498         if (!s->user)
499                 return -ESTALE;
500
501         if (s->started)
502                 return 0;
503
504         r = user_start(s->user);
505         if (r < 0)
506                 return r;
507
508         /* Create cgroup */
509         r = session_start_scope(s);
510         if (r < 0)
511                 return r;
512
513         log_struct(s->type == SESSION_TTY || s->type == SESSION_X11 ? LOG_INFO : LOG_DEBUG,
514                    MESSAGE_ID(SD_MESSAGE_SESSION_START),
515                    "SESSION_ID=%s", s->id,
516                    "USER_ID=%s", s->user->name,
517                    "LEADER=%lu", (unsigned long) s->leader,
518                    "MESSAGE=New session %s of user %s.", s->id, s->user->name,
519                    NULL);
520
521         /* Create X11 symlink */
522         session_link_x11_socket(s);
523
524         if (!dual_timestamp_is_set(&s->timestamp))
525                 dual_timestamp_get(&s->timestamp);
526
527         if (s->seat)
528                 seat_read_active_vt(s->seat);
529
530         s->started = true;
531
532         /* Save session data */
533         session_save(s);
534         user_save(s->user);
535
536         session_send_signal(s, true);
537
538         if (s->seat) {
539                 seat_save(s->seat);
540
541                 if (s->seat->active == s)
542                         seat_send_changed(s->seat, "Sessions\0ActiveSession\0");
543                 else
544                         seat_send_changed(s->seat, "Sessions\0");
545         }
546
547         user_send_changed(s->user, "Sessions\0");
548
549         return 0;
550 }
551
552 /* static bool session_shall_kill(Session *s) { */
553 /*         assert(s); */
554
555 /*         if (!s->kill_processes) */
556 /*                 return false; */
557
558 /*         if (strv_contains(s->manager->kill_exclude_users, s->user->name)) */
559 /*                 return false; */
560
561 /*         if (strv_isempty(s->manager->kill_only_users)) */
562 /*                 return true; */
563
564 /*         return strv_contains(s->manager->kill_only_users, s->user->name); */
565 /* } */
566
567 static int session_stop_scope(Session *s) {
568         DBusError error;
569         char *job;
570         int r;
571
572         assert(s);
573
574         dbus_error_init(&error);
575
576         if (!s->scope)
577                 return 0;
578
579         r = manager_stop_unit(s->manager, s->scope, &error, &job);
580         if (r < 0) {
581                 log_error("Failed to stop session scope: %s", bus_error(&error, r));
582                 dbus_error_free(&error);
583                 return r;
584         }
585
586         free(s->scope_job);
587         s->scope_job = job;
588
589         return 0;
590 }
591
592 static int session_unlink_x11_socket(Session *s) {
593         char *t;
594         int r;
595
596         assert(s);
597         assert(s->user);
598
599         if (s->user->display != s)
600                 return 0;
601
602         s->user->display = NULL;
603
604         t = strappend(s->user->runtime_path, "/X11-display");
605         if (!t)
606                 return log_oom();
607
608         r = unlink(t);
609         free(t);
610
611         return r < 0 ? -errno : 0;
612 }
613
614 int session_stop(Session *s) {
615         int r = 0, k;
616
617         assert(s);
618
619         if (!s->user)
620                 return -ESTALE;
621
622         if (s->started)
623                 log_struct(s->type == SESSION_TTY || s->type == SESSION_X11 ? LOG_INFO : LOG_DEBUG,
624                            MESSAGE_ID(SD_MESSAGE_SESSION_STOP),
625                            "SESSION_ID=%s", s->id,
626                            "USER_ID=%s", s->user->name,
627                            "LEADER=%lu", (unsigned long) s->leader,
628                            "MESSAGE=Removed session %s.", s->id,
629                            NULL);
630
631         /* Kill cgroup */
632         k = session_stop_scope(s);
633         if (k < 0)
634                 r = k;
635
636         /* Remove X11 symlink */
637         session_unlink_x11_socket(s);
638
639         unlink(s->state_file);
640         session_add_to_gc_queue(s);
641         user_add_to_gc_queue(s->user);
642
643         if (s->started)
644                 session_send_signal(s, false);
645
646         s->started = false;
647
648         if (s->seat) {
649                 if (s->seat->active == s)
650                         seat_set_active(s->seat, NULL);
651
652                 seat_send_changed(s->seat, "Sessions\0");
653                 seat_save(s->seat);
654         }
655
656         user_send_changed(s->user, "Sessions\0");
657         user_save(s->user);
658
659         return r;
660 }
661
662 bool session_is_active(Session *s) {
663         assert(s);
664
665         if (!s->seat)
666                 return true;
667
668         return s->seat->active == s;
669 }
670
671 static int get_tty_atime(const char *tty, usec_t *atime) {
672         _cleanup_free_ char *p = NULL;
673         struct stat st;
674
675         assert(tty);
676         assert(atime);
677
678         if (!path_is_absolute(tty)) {
679                 p = strappend("/dev/", tty);
680                 if (!p)
681                         return -ENOMEM;
682
683                 tty = p;
684         } else if (!path_startswith(tty, "/dev/"))
685                 return -ENOENT;
686
687         if (lstat(tty, &st) < 0)
688                 return -errno;
689
690         *atime = timespec_load(&st.st_atim);
691         return 0;
692 }
693
694 static int get_process_ctty_atime(pid_t pid, usec_t *atime) {
695         _cleanup_free_ char *p = NULL;
696         int r;
697
698         assert(pid > 0);
699         assert(atime);
700
701         r = get_ctty(pid, NULL, &p);
702         if (r < 0)
703                 return r;
704
705         return get_tty_atime(p, atime);
706 }
707
708 int session_get_idle_hint(Session *s, dual_timestamp *t) {
709         usec_t atime = 0, n;
710         int r;
711
712         assert(s);
713
714         /* Explicit idle hint is set */
715         if (s->idle_hint) {
716                 if (t)
717                         *t = s->idle_hint_timestamp;
718
719                 return s->idle_hint;
720         }
721
722         /* Graphical sessions should really implement a real
723          * idle hint logic */
724         if (s->display)
725                 goto dont_know;
726
727         /* For sessions with an explicitly configured tty, let's check
728          * its atime */
729         if (s->tty) {
730                 r = get_tty_atime(s->tty, &atime);
731                 if (r >= 0)
732                         goto found_atime;
733         }
734
735         /* For sessions with a leader but no explicitly configured
736          * tty, let's check the controlling tty of the leader */
737         if (s->leader > 0) {
738                 r = get_process_ctty_atime(s->leader, &atime);
739                 if (r >= 0)
740                         goto found_atime;
741         }
742
743 dont_know:
744         if (t)
745                 *t = s->idle_hint_timestamp;
746
747         return 0;
748
749 found_atime:
750         if (t)
751                 dual_timestamp_from_realtime(t, atime);
752
753         n = now(CLOCK_REALTIME);
754
755         if (s->manager->idle_action_usec <= 0)
756                 return 0;
757
758         return atime + s->manager->idle_action_usec <= n;
759 }
760
761 void session_set_idle_hint(Session *s, bool b) {
762         assert(s);
763
764         if (s->idle_hint == b)
765                 return;
766
767         s->idle_hint = b;
768         dual_timestamp_get(&s->idle_hint_timestamp);
769
770         session_send_changed(s,
771                              "IdleHint\0"
772                              "IdleSinceHint\0"
773                              "IdleSinceHintMonotonic\0");
774
775         if (s->seat)
776                 seat_send_changed(s->seat,
777                                   "IdleHint\0"
778                                   "IdleSinceHint\0"
779                                   "IdleSinceHintMonotonic\0");
780
781         user_send_changed(s->user,
782                           "IdleHint\0"
783                           "IdleSinceHint\0"
784                           "IdleSinceHintMonotonic\0");
785
786         manager_send_changed(s->manager,
787                              "IdleHint\0"
788                              "IdleSinceHint\0"
789                              "IdleSinceHintMonotonic\0");
790 }
791
792 int session_create_fifo(Session *s) {
793         int r;
794
795         assert(s);
796
797         /* Create FIFO */
798         if (!s->fifo_path) {
799                 r = mkdir_safe_label("/run/systemd/sessions", 0755, 0, 0);
800                 if (r < 0)
801                         return r;
802
803                 if (asprintf(&s->fifo_path, "/run/systemd/sessions/%s.ref", s->id) < 0)
804                         return -ENOMEM;
805
806                 if (mkfifo(s->fifo_path, 0600) < 0 && errno != EEXIST)
807                         return -errno;
808         }
809
810         /* Open reading side */
811         if (s->fifo_fd < 0) {
812                 struct epoll_event ev = {};
813
814                 s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
815                 if (s->fifo_fd < 0)
816                         return -errno;
817
818                 r = hashmap_put(s->manager->session_fds, INT_TO_PTR(s->fifo_fd + 1), s);
819                 if (r < 0)
820                         return r;
821
822                 ev.events = 0;
823                 ev.data.u32 = FD_OTHER_BASE + s->fifo_fd;
824
825                 if (epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_ADD, s->fifo_fd, &ev) < 0)
826                         return -errno;
827         }
828
829         /* Open writing side */
830         r = open(s->fifo_path, O_WRONLY|O_CLOEXEC|O_NDELAY);
831         if (r < 0)
832                 return -errno;
833
834         return r;
835 }
836
837 void session_remove_fifo(Session *s) {
838         assert(s);
839
840         if (s->fifo_fd >= 0) {
841                 assert_se(hashmap_remove(s->manager->session_fds, INT_TO_PTR(s->fifo_fd + 1)) == s);
842                 assert_se(epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_DEL, s->fifo_fd, NULL) == 0);
843                 close_nointr_nofail(s->fifo_fd);
844                 s->fifo_fd = -1;
845
846                 session_save(s);
847                 user_save(s->user);
848         }
849
850         if (s->fifo_path) {
851                 unlink(s->fifo_path);
852                 free(s->fifo_path);
853                 s->fifo_path = NULL;
854         }
855 }
856
857 int session_check_gc(Session *s, bool drop_not_started) {
858         int r;
859
860         assert(s);
861
862         if (drop_not_started && !s->started)
863                 return 0;
864
865         if (!s->user)
866                 return 0;
867
868         if (s->fifo_fd >= 0) {
869
870                 r = pipe_eof(s->fifo_fd);
871                 if (r < 0)
872                         return r;
873
874                 if (r == 0)
875                         return 1;
876         }
877
878         if (s->scope_job)
879                 return 1;
880
881         if (s->scope)
882                 return manager_unit_is_active(s->manager, s->scope) != 0;
883
884         return 0;
885 }
886
887 void session_add_to_gc_queue(Session *s) {
888         assert(s);
889
890         if (s->in_gc_queue)
891                 return;
892
893         LIST_PREPEND(Session, gc_queue, s->manager->session_gc_queue, s);
894         s->in_gc_queue = true;
895 }
896
897 SessionState session_get_state(Session *s) {
898         assert(s);
899
900         if (s->scope_job)
901                 return s->started ? SESSION_OPENING : SESSION_CLOSING;
902
903         if (s->fifo_fd < 0)
904                 return SESSION_CLOSING;
905
906         if (session_is_active(s))
907                 return SESSION_ACTIVE;
908
909         return SESSION_ONLINE;
910 }
911
912 int session_kill(Session *s, KillWho who, int signo) {
913         assert(s);
914
915         if (!s->scope)
916                 return -ESRCH;
917
918         return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
919 }
920
921 static const char* const session_state_table[_SESSION_STATE_MAX] = {
922         [SESSION_OPENING] = "opening",
923         [SESSION_ONLINE] = "online",
924         [SESSION_ACTIVE] = "active",
925         [SESSION_CLOSING] = "closing"
926 };
927
928 DEFINE_STRING_TABLE_LOOKUP(session_state, SessionState);
929
930 static const char* const session_type_table[_SESSION_TYPE_MAX] = {
931         [SESSION_TTY] = "tty",
932         [SESSION_X11] = "x11",
933         [SESSION_UNSPECIFIED] = "unspecified"
934 };
935
936 DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
937
938 static const char* const session_class_table[_SESSION_CLASS_MAX] = {
939         [SESSION_USER] = "user",
940         [SESSION_GREETER] = "greeter",
941         [SESSION_LOCK_SCREEN] = "lock-screen",
942         [SESSION_BACKGROUND] = "background"
943 };
944
945 DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
946
947 static const char* const kill_who_table[_KILL_WHO_MAX] = {
948         [KILL_LEADER] = "leader",
949         [KILL_ALL] = "all"
950 };
951
952 DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);