logind: require VTs on seat0 and forbid elsewhere

[elogind.git] / src / login / logind-session.c

diff --git a/src/login/logind-session.c b/src/login/logind-session.c
index 0e1c40b4eb8ab87418dfcfbe4a282f15431d84a9..a72b13ee0363c3826836706c36c4f4dd64439c00 100644 (file)
--- a/src/login/logind-session.c
+++ b/src/login/logind-session.c
@@ -20,9 +20,13 @@
 ***/
 
 #include <errno.h>
+#include <fcntl.h>
+#include <linux/vt.h>
+#include <linux/kd.h>
+#include <signal.h>
 #include <string.h>
+#include <sys/ioctl.h>
 #include <unistd.h>
-#include <fcntl.h>
 
 #include "sd-id128.h"
 #include "sd-messages.h"
@@ -86,6 +90,7 @@ Session* session_new(Manager *m, const char *id) {
 
         s->manager = m;
         s->fifo_fd = -1;
+        s->vtfd = -1;
 
         return s;
 }
@@ -224,7 +229,7 @@ int session_save(Session *s) {
                 fprintf(f, "SERVICE=%s\n", s->service);
 
         if (s->seat && seat_has_vts(s->seat))
-                fprintf(f, "VTNR=%i\n", s->vtnr);
+                fprintf(f, "VTNR=%u\n", s->vtnr);
 
         if (s->leader > 0)
                 fprintf(f, "LEADER=%lu\n", (unsigned long) s->leader);
@@ -329,21 +334,21 @@ int session_load(Session *s) {
                         s->remote = k;
         }
 
+        if (vtnr)
+                safe_atou(vtnr, &s->vtnr);
+
         if (seat && !s->seat) {
                 Seat *o;
 
                 o = hashmap_get(s->manager->seats, seat);
                 if (o)
-                        seat_attach_session(o, s);
+                        r = seat_attach_session(o, s);
+                if (!o || r < 0)
+                        log_error("Cannot attach session %s to seat %s", s->id, seat);
         }
 
-        if (vtnr && s->seat && seat_has_vts(s->seat)) {
-                int v;
-
-                k = safe_atoi(vtnr, &v);
-                if (k >= 0 && v >= 1)
-                        s->vtnr = v;
-        }
+        if (!s->seat || !seat_has_vts(s->seat))
+                s->vtnr = 0;
 
         if (leader) {
                 k = parse_pid(leader, &s->leader);
@@ -395,6 +400,8 @@ int session_load(Session *s) {
         if (controller) {
                 if (bus_name_has_owner(s->manager->bus, controller, NULL) > 0)
                         session_set_controller(s, controller, false);
+                else
+                        session_restore_vt(s);
         }
 
         return r;
@@ -414,7 +421,7 @@ int session_activate(Session *s) {
 
         /* on seats with VTs, we let VTs manage session-switching */
         if (seat_has_vts(s->seat)) {
-                if (s->vtnr <= 0)
+                if (!s->vtnr)
                         return -ENOTSUP;
 
                 return chvt(s->vtnr);
@@ -971,6 +978,101 @@ int session_kill(Session *s, KillWho who, int signo) {
         return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
 }
 
+static int session_open_vt(Session *s) {
+        char path[128];
+
+        if (!s->vtnr)
+                return -1;
+
+        if (s->vtfd >= 0)
+                return s->vtfd;
+
+        sprintf(path, "/dev/tty%u", s->vtnr);
+        s->vtfd = open(path, O_RDWR | O_CLOEXEC | O_NONBLOCK | O_NOCTTY);
+        if (s->vtfd < 0) {
+                log_error("cannot open VT %s of session %s: %m", path, s->id);
+                return -1;
+        }
+
+        return s->vtfd;
+}
+
+static int session_vt_fn(sd_event_source *source, const struct signalfd_siginfo *si, void *data) {
+        Session *s = data;
+
+        if (s->vtfd >= 0)
+                ioctl(s->vtfd, VT_RELDISP, 1);
+
+        return 0;
+}
+
+void session_mute_vt(Session *s) {
+        int vt, r;
+        struct vt_mode mode = { 0 };
+        sigset_t mask;
+
+        vt = session_open_vt(s);
+        if (vt < 0)
+                return;
+
+        r = ioctl(vt, KDSKBMODE, K_OFF);
+        if (r < 0)
+                goto error;
+
+        r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
+        if (r < 0)
+                goto error;
+
+        sigemptyset(&mask);
+        sigaddset(&mask, SIGUSR1);
+        sigprocmask(SIG_BLOCK, &mask, NULL);
+
+        r = sd_event_add_signal(s->manager->event, SIGUSR1, session_vt_fn, s, &s->vt_source);
+        if (r < 0)
+                goto error;
+
+        /* Oh, thanks to the VT layer, VT_AUTO does not work with KD_GRAPHICS.
+         * So we need a dummy handler here which just acknowledges *all* VT
+         * switch requests. */
+        mode.mode = VT_PROCESS;
+        mode.relsig = SIGUSR1;
+        mode.acqsig = SIGUSR1;
+        r = ioctl(vt, VT_SETMODE, &mode);
+        if (r < 0)
+                goto error;
+
+        return;
+
+error:
+        log_error("cannot mute VT %u for session %s (%d/%d)", s->vtnr, s->id, r, errno);
+        session_restore_vt(s);
+}
+
+void session_restore_vt(Session *s) {
+        _cleanup_free_ char *utf8;
+        int vt, kb = K_XLATE;
+        struct vt_mode mode = { 0 };
+
+        vt = session_open_vt(s);
+        if (vt < 0)
+                return;
+
+        sd_event_source_unref(s->vt_source);
+        s->vt_source = NULL;
+
+        ioctl(vt, KDSETMODE, KD_TEXT);
+
+        if (read_one_line_file("/sys/module/vt/parameters/default_utf8", &utf8) >= 0 && *utf8 == '1')
+                kb = K_UNICODE;
+        ioctl(vt, KDSKBMODE, kb);
+
+        mode.mode = VT_AUTO;
+        ioctl(vt, VT_SETMODE, &mode);
+
+        close_nointr_nofail(vt);
+        s->vtfd = -1;
+}
+
 bool session_is_controller(Session *s, const char *sender) {
         assert(s);
 
@@ -990,6 +1092,9 @@ static void session_swap_controller(Session *s, char *name) {
                  * dbus signals. */
                 while ((sd = hashmap_first(s->devices)))
                         session_device_free(sd);
+
+                if (!name)
+                        session_restore_vt(s);
         }
 
         s->controller = name;
@@ -1020,6 +1125,16 @@ int session_set_controller(Session *s, const char *sender, bool force) {
 
         session_swap_controller(s, t);
 
+        /* When setting a session controller, we forcibly mute the VT and set
+         * it into graphics-mode. Applications can override that by changing
+         * VT state after calling TakeControl(). However, this serves as a good
+         * default and well-behaving controllers can now ignore VTs entirely.
+         * Note that we reset the VT on ReleaseControl() and if the controller
+         * exits.
+         * If logind crashes/restarts, we restore the controller during restart
+         * or reset the VT in case it crashed/exited, too. */
+        session_mute_vt(s);
+
         return 0;
 }