X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flogin%2Flogind-session.c;h=fdeacb150acb42a84f203cb052fc412a613c6a50;hp=8a021f32a14afa9fdcb45bf1fd93074e073470b9;hb=558c6490b1df7f82a63d0a747fda7412c4d28b0c;hpb=71fda00f320379f5cbee8e118848de98caaa229d diff --git a/src/login/logind-session.c b/src/login/logind-session.c index 8a021f32a..fdeacb150 100644 --- a/src/login/logind-session.c +++ b/src/login/logind-session.c @@ -20,26 +20,34 @@ ***/ #include +#include +#include +#include +#include #include +#include #include -#include -#include - -#include -#include +#include "sd-id128.h" +#include "sd-messages.h" #include "strv.h" #include "util.h" #include "mkdir.h" #include "path-util.h" #include "fileio.h" -#include "dbus-common.h" +#include "audit.h" +#include "bus-util.h" +#include "bus-error.h" #include "logind-session.h" -static unsigned devt_hash_func(const void *p) { +#define RELEASE_USEC (20*USEC_PER_SEC) + +static void session_remove_fifo(Session *s); + +static unsigned long devt_hash_func(const void *p, const uint8_t hash_key[HASH_KEY_SIZE]) { uint64_t u = *(const dev_t*)p; - return uint64_hash_func(&u); + return uint64_hash_func(&u, hash_key); } static int devt_compare_func(const void *_a, const void *_b) { @@ -75,7 +83,7 @@ Session* session_new(Manager *m, const char *id) { return NULL; } - s->id = path_get_file_name(s->state_file); + s->id = basename(s->state_file); if (hashmap_put(m->sessions, s->id, s) < 0) { hashmap_free(s->devices); @@ -86,6 +94,7 @@ Session* session_new(Manager *m, const char *id) { s->manager = m; s->fifo_fd = -1; + s->vtfd = -1; return s; } @@ -98,6 +107,10 @@ void session_free(Session *s) { if (s->in_gc_queue) LIST_REMOVE(gc_queue, s->manager->session_gc_queue, s); + s->timer_event_source = sd_event_source_unref(s->timer_event_source); + + session_remove_fifo(s); + session_drop_controller(s); while ((sd = hashmap_first(s->devices))) @@ -118,6 +131,7 @@ void session_free(Session *s) { if (s->seat->pending_switch == s) s->seat->pending_switch = NULL; + seat_evict_position(s->seat, s); LIST_REMOVE(sessions_by_seat, s->seat->sessions, s); } @@ -128,17 +142,18 @@ void session_free(Session *s) { free(s->scope_job); - if (s->create_message) - dbus_message_unref(s->create_message); + sd_bus_message_unref(s->create_message); free(s->tty); free(s->display); free(s->remote_host); free(s->remote_user); free(s->service); + free(s->desktop); hashmap_remove(s->manager->sessions, s->id); - session_remove_fifo(s); + + s->vt_source = sd_event_source_unref(s->vt_source); free(s->state_file); free(s); @@ -153,8 +168,8 @@ void session_set_user(Session *s, User *u) { } int session_save(Session *s) { - _cleanup_fclose_ FILE *f = NULL; _cleanup_free_ char *temp_path = NULL; + _cleanup_fclose_ FILE *f = NULL; int r = 0; assert(s); @@ -179,12 +194,12 @@ int session_save(Session *s) { fprintf(f, "# This is private data. Do not parse.\n" - "UID=%lu\n" + "UID="UID_FMT"\n" "USER=%s\n" "ACTIVE=%i\n" "STATE=%s\n" "REMOTE=%i\n", - (unsigned long) s->user->uid, + s->user->uid, s->user->name, session_is_active(s), session_state_to_string(session_get_state(s)), @@ -198,7 +213,6 @@ int session_save(Session *s) { if (s->scope) fprintf(f, "SCOPE=%s\n", s->scope); - if (s->scope_job) fprintf(f, "SCOPE_JOB=%s\n", s->scope_job); @@ -214,30 +228,76 @@ int session_save(Session *s) { if (s->display) fprintf(f, "DISPLAY=%s\n", s->display); - if (s->remote_host) - fprintf(f, "REMOTE_HOST=%s\n", s->remote_host); + if (s->remote_host) { + _cleanup_free_ char *escaped; + + escaped = cescape(s->remote_host); + if (!escaped) { + r = -ENOMEM; + goto finish; + } + + fprintf(f, "REMOTE_HOST=%s\n", escaped); + } + + if (s->remote_user) { + _cleanup_free_ char *escaped; + + escaped = cescape(s->remote_user); + if (!escaped) { + r = -ENOMEM; + goto finish; + } + + fprintf(f, "REMOTE_USER=%s\n", escaped); + } + + if (s->service) { + _cleanup_free_ char *escaped; + + escaped = cescape(s->service); + if (!escaped) { + r = -ENOMEM; + goto finish; + } + + fprintf(f, "SERVICE=%s\n", escaped); + } - if (s->remote_user) - fprintf(f, "REMOTE_USER=%s\n", s->remote_user); + if (s->desktop) { + _cleanup_free_ char *escaped; - if (s->service) - fprintf(f, "SERVICE=%s\n", s->service); + + escaped = cescape(s->desktop); + if (!escaped) { + r = -ENOMEM; + goto finish; + } + + fprintf(f, "DESKTOP=%s\n", escaped); + } if (s->seat && seat_has_vts(s->seat)) - fprintf(f, "VTNR=%i\n", s->vtnr); + fprintf(f, "VTNR=%u\n", s->vtnr); + + if (!s->vtnr) + fprintf(f, "POS=%u\n", s->pos); if (s->leader > 0) - fprintf(f, "LEADER=%lu\n", (unsigned long) s->leader); + fprintf(f, "LEADER="PID_FMT"\n", s->leader); if (s->audit_id > 0) fprintf(f, "AUDIT=%"PRIu32"\n", s->audit_id); if (dual_timestamp_is_set(&s->timestamp)) fprintf(f, - "REALTIME=%llu\n" - "MONOTONIC=%llu\n", - (unsigned long long) s->timestamp.realtime, - (unsigned long long) s->timestamp.monotonic); + "REALTIME="USEC_FMT"\n" + "MONOTONIC="USEC_FMT"\n", + s->timestamp.realtime, + s->timestamp.monotonic); + + if (s->controller) + fprintf(f, "CONTROLLER=%s\n", s->controller); fflush(f); @@ -249,7 +309,7 @@ int session_save(Session *s) { finish: if (r < 0) - log_error("Failed to save session data for %s: %s", s->id, strerror(-r)); + log_error("Failed to save session data %s: %s", s->state_file, strerror(-r)); return r; } @@ -258,12 +318,14 @@ int session_load(Session *s) { _cleanup_free_ char *remote = NULL, *seat = NULL, *vtnr = NULL, + *pos = NULL, *leader = NULL, *type = NULL, *class = NULL, *uid = NULL, *realtime = NULL, - *monotonic = NULL; + *monotonic = NULL, + *controller = NULL; int k, r; @@ -280,13 +342,16 @@ int session_load(Session *s) { "REMOTE_HOST", &s->remote_host, "REMOTE_USER", &s->remote_user, "SERVICE", &s->service, + "DESKTOP", &s->desktop, "VTNR", &vtnr, + "POS", &pos, "LEADER", &leader, "TYPE", &type, "CLASS", &class, "UID", &uid, "REALTIME", &realtime, "MONOTONIC", &monotonic, + "CONTROLLER", &controller, NULL); if (r < 0) { @@ -324,20 +389,27 @@ 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; + if (!s->seat || !seat_has_vts(s->seat)) + s->vtnr = 0; - k = safe_atoi(vtnr, &v); - if (k >= 0 && v >= 1) - s->vtnr = v; + if (pos && s->seat) { + unsigned int npos; + + safe_atou(pos, &npos); + seat_claim_position(s->seat, s, npos); } if (leader) { @@ -371,8 +443,7 @@ int session_load(Session *s) { trigger the EOF. */ fd = session_create_fifo(s); - if (fd >= 0) - close_nointr_nofail(fd); + safe_close(fd); } if (realtime) { @@ -387,6 +458,13 @@ int session_load(Session *s) { s->timestamp.monotonic = l; } + 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; } @@ -404,7 +482,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); @@ -427,86 +505,17 @@ int session_activate(Session *s) { return 0; } -static int session_link_x11_socket(Session *s) { - _cleanup_free_ char *t = NULL, *f = NULL; - char *c; - size_t k; - - assert(s); - assert(s->user); - assert(s->user->runtime_path); - - if (s->user->display) - return 0; - - if (!s->display || !display_is_local(s->display)) - return 0; - - k = strspn(s->display+1, "0123456789"); - f = new(char, sizeof("/tmp/.X11-unix/X") + k); - if (!f) - return log_oom(); - - c = stpcpy(f, "/tmp/.X11-unix/X"); - memcpy(c, s->display+1, k); - c[k] = 0; - - if (access(f, F_OK) < 0) { - log_warning("Session %s has display %s with non-existing socket %s.", s->id, s->display, f); - return -ENOENT; - } - - /* Note that this cannot be in a subdir to avoid - * vulnerabilities since we are privileged but the runtime - * path is owned by the user */ - - t = strappend(s->user->runtime_path, "/X11-display"); - if (!t) - return log_oom(); - - if (link(f, t) < 0) { - if (errno == EEXIST) { - unlink(t); - - if (link(f, t) >= 0) - goto done; - } - - if (symlink(f, t) < 0) { - - if (errno == EEXIST) { - unlink(t); - - if (symlink(f, t) >= 0) - goto done; - } - - log_error("Failed to link %s to %s: %m", f, t); - return -errno; - } - } - -done: - log_info("Linked %s to %s.", f, t); - s->user->display = s; - - return 0; -} - static int session_start_scope(Session *s) { - DBusError error; int r; assert(s); assert(s->user); assert(s->user->slice); - dbus_error_init(&error); - if (!s->scope) { + _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL; _cleanup_free_ char *description = NULL; - const char *kill_mode; - char *scope, *job; + char *scope, *job = NULL; description = strjoin("Session ", s->id, " of user ", s->user->name, NULL); if (!description) @@ -516,14 +525,10 @@ static int session_start_scope(Session *s) { if (!scope) return log_oom(); - kill_mode = manager_shall_kill(s->manager, s->user->name) ? "control-group" : "none"; - - r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "systemd-user-sessions.service", kill_mode, &error, &job); + r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "systemd-logind.service", "systemd-user-sessions.service", &error, &job); if (r < 0) { log_error("Failed to start session scope %s: %s %s", - scope, bus_error(&error, r), error.name); - dbus_error_free(&error); - + scope, bus_error_message(&error, r), error.name); free(scope); return r; } else { @@ -560,17 +565,14 @@ int session_start(Session *s) { if (r < 0) return r; - log_struct(s->type == SESSION_TTY || s->type == SESSION_X11 ? LOG_INFO : LOG_DEBUG, + log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO, MESSAGE_ID(SD_MESSAGE_SESSION_START), "SESSION_ID=%s", s->id, "USER_ID=%s", s->user->name, - "LEADER=%lu", (unsigned long) s->leader, + "LEADER="PID_FMT, s->leader, "MESSAGE=New session %s of user %s.", s->id, s->user->name, NULL); - /* Create X11 symlink */ - session_link_x11_socket(s); - if (!dual_timestamp_is_set(&s->timestamp)) dual_timestamp_get(&s->timestamp); @@ -579,83 +581,79 @@ int session_start(Session *s) { s->started = true; - /* Save session data */ + user_elect_display(s->user); + + /* Save data */ session_save(s); user_save(s->user); + if (s->seat) + seat_save(s->seat); + /* Send signals */ session_send_signal(s, true); - + user_send_changed(s->user, "Sessions", "Display", NULL); if (s->seat) { - seat_save(s->seat); - if (s->seat->active == s) - seat_send_changed(s->seat, "Sessions\0ActiveSession\0"); + seat_send_changed(s->seat, "Sessions", "ActiveSession", NULL); else - seat_send_changed(s->seat, "Sessions\0"); + seat_send_changed(s->seat, "Sessions", NULL); } - user_send_changed(s->user, "Sessions\0"); - return 0; } -static int session_stop_scope(Session *s) { - DBusError error; - char *job; +static int session_stop_scope(Session *s, bool force) { + _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL; + char *job = NULL; int r; assert(s); - dbus_error_init(&error); - if (!s->scope) return 0; - r = manager_stop_unit(s->manager, s->scope, &error, &job); - if (r < 0) { - log_error("Failed to stop session scope: %s", bus_error(&error, r)); - dbus_error_free(&error); - return r; - } + if (force || manager_shall_kill(s->manager, s->user->name)) { + r = manager_stop_unit(s->manager, s->scope, &error, &job); + if (r < 0) { + log_error("Failed to stop session scope: %s", bus_error_message(&error, r)); + return r; + } - free(s->scope_job); - s->scope_job = job; + free(s->scope_job); + s->scope_job = job; + } else { + r = manager_abandon_scope(s->manager, s->scope, &error); + if (r < 0) { + log_error("Failed to abandon session scope: %s", bus_error_message(&error, r)); + return r; + } + } return 0; } -static int session_unlink_x11_socket(Session *s) { - _cleanup_free_ char *t = NULL; +int session_stop(Session *s, bool force) { int r; assert(s); - assert(s->user); - - if (s->user->display != s) - return 0; - - s->user->display = NULL; - t = strappend(s->user->runtime_path, "/X11-display"); - if (!t) - return log_oom(); + if (!s->user) + return -ESTALE; - r = unlink(t); - return r < 0 ? -errno : 0; -} + s->timer_event_source = sd_event_source_unref(s->timer_event_source); -int session_stop(Session *s) { - int r; + /* We are going down, don't care about FIFOs anymore */ + session_remove_fifo(s); - assert(s); + /* Kill cgroup */ + r = session_stop_scope(s, force); - if (!s->user) - return -ESTALE; + s->stopping = true; - /* Kill cgroup */ - r = session_stop_scope(s); + user_elect_display(s->user); session_save(s); + user_save(s->user); return r; } @@ -670,21 +668,20 @@ int session_finalize(Session *s) { return -ESTALE; if (s->started) - log_struct(s->type == SESSION_TTY || s->type == SESSION_X11 ? LOG_INFO : LOG_DEBUG, + log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO, MESSAGE_ID(SD_MESSAGE_SESSION_STOP), "SESSION_ID=%s", s->id, "USER_ID=%s", s->user->name, - "LEADER=%lu", (unsigned long) s->leader, + "LEADER="PID_FMT, s->leader, "MESSAGE=Removed session %s.", s->id, NULL); + s->timer_event_source = sd_event_source_unref(s->timer_event_source); + /* Kill session devices */ while ((sd = hashmap_first(s->devices))) session_device_free(sd); - /* Remove X11 symlink */ - session_unlink_x11_socket(s); - unlink(s->state_file); session_add_to_gc_queue(s); user_add_to_gc_queue(s->user); @@ -698,16 +695,40 @@ int session_finalize(Session *s) { if (s->seat->active == s) seat_set_active(s->seat, NULL); - seat_send_changed(s->seat, "Sessions\0"); seat_save(s->seat); + seat_send_changed(s->seat, "Sessions", NULL); } - user_send_changed(s->user, "Sessions\0"); user_save(s->user); + user_send_changed(s->user, "Sessions", "Display", NULL); return r; } +static int release_timeout_callback(sd_event_source *es, uint64_t usec, void *userdata) { + Session *s = userdata; + + assert(es); + assert(s); + + session_stop(s, false); + return 0; +} + +void session_release(Session *s) { + assert(s); + + if (!s->started || s->stopping) + return; + + if (!s->timer_event_source) + sd_event_add_time(s->manager->event, + &s->timer_event_source, + CLOCK_MONOTONIC, + now(CLOCK_MONOTONIC) + RELEASE_USEC, 0, + release_timeout_callback, s); +} + bool session_is_active(Session *s) { assert(s); @@ -816,26 +837,27 @@ void session_set_idle_hint(Session *s, bool b) { s->idle_hint = b; dual_timestamp_get(&s->idle_hint_timestamp); - session_send_changed(s, - "IdleHint\0" - "IdleSinceHint\0" - "IdleSinceHintMonotonic\0"); + session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL); if (s->seat) - seat_send_changed(s->seat, - "IdleHint\0" - "IdleSinceHint\0" - "IdleSinceHintMonotonic\0"); - - user_send_changed(s->user, - "IdleHint\0" - "IdleSinceHint\0" - "IdleSinceHintMonotonic\0"); - - manager_send_changed(s->manager, - "IdleHint\0" - "IdleSinceHint\0" - "IdleSinceHintMonotonic\0"); + seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL); + + user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL); + manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL); +} + +static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) { + Session *s = userdata; + + assert(s); + assert(s->fifo_fd == fd); + + /* EOF on the FIFO means the session died abnormally. */ + + session_remove_fifo(s); + session_stop(s, false); + + return 1; } int session_create_fifo(Session *s) { @@ -858,21 +880,20 @@ int session_create_fifo(Session *s) { /* Open reading side */ if (s->fifo_fd < 0) { - struct epoll_event ev = {}; - s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY); if (s->fifo_fd < 0) return -errno; - r = hashmap_put(s->manager->session_fds, INT_TO_PTR(s->fifo_fd + 1), s); + } + + if (!s->fifo_event_source) { + r = sd_event_add_io(s->manager->event, &s->fifo_event_source, s->fifo_fd, 0, session_dispatch_fifo, s); if (r < 0) return r; - ev.events = 0; - ev.data.u32 = FD_OTHER_BASE + s->fifo_fd; - - if (epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_ADD, s->fifo_fd, &ev) < 0) - return -errno; + r = sd_event_source_set_priority(s->fifo_event_source, SD_EVENT_PRIORITY_IDLE); + if (r < 0) + return r; } /* Open writing side */ @@ -883,18 +904,11 @@ int session_create_fifo(Session *s) { return r; } -void session_remove_fifo(Session *s) { +static void session_remove_fifo(Session *s) { assert(s); - if (s->fifo_fd >= 0) { - assert_se(hashmap_remove(s->manager->session_fds, INT_TO_PTR(s->fifo_fd + 1)) == s); - assert_se(epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_DEL, s->fifo_fd, NULL) == 0); - close_nointr_nofail(s->fifo_fd); - s->fifo_fd = -1; - - session_save(s); - user_save(s->user); - } + s->fifo_event_source = sd_event_source_unref(s->fifo_event_source); + s->fifo_fd = safe_close(s->fifo_fd); if (s->fifo_path) { unlink(s->fifo_path); @@ -903,33 +917,27 @@ void session_remove_fifo(Session *s) { } } -int session_check_gc(Session *s, bool drop_not_started) { - int r; - +bool session_check_gc(Session *s, bool drop_not_started) { assert(s); if (drop_not_started && !s->started) - return 0; + return false; if (!s->user) - return 0; + return false; if (s->fifo_fd >= 0) { - r = pipe_eof(s->fifo_fd); - if (r < 0) - return r; - - if (r == 0) - return 1; + if (pipe_eof(s->fifo_fd) <= 0) + return true; } - if (s->scope_job) - return 1; + if (s->scope_job && manager_job_is_active(s->manager, s->scope_job)) + return true; - if (s->scope) - return manager_unit_is_active(s->manager, s->scope) != 0; + if (s->scope && manager_unit_is_active(s->manager, s->scope)) + return true; - return 0; + return false; } void session_add_to_gc_queue(Session *s) { @@ -945,15 +953,13 @@ void session_add_to_gc_queue(Session *s) { SessionState session_get_state(Session *s) { assert(s); - if (s->closing) + /* always check closing first */ + if (s->stopping || s->timer_event_source) return SESSION_CLOSING; - if (s->scope_job) + if (s->scope_job || s->fifo_fd < 0) return SESSION_OPENING; - if (s->fifo_fd < 0) - return SESSION_CLOSING; - if (session_is_active(s)) return SESSION_ACTIVE; @@ -969,13 +975,134 @@ int session_kill(Session *s, KillWho who, int signo) { return manager_kill_unit(s->manager, s->scope, who, signo, NULL); } -bool session_is_controller(Session *s, const char *sender) -{ +static int session_open_vt(Session *s) { + char path[sizeof("/dev/tty") + DECIMAL_STR_MAX(s->vtnr)]; + + 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 -errno; + } + + 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_prepare_vt(Session *s) { + int vt, r; + struct vt_mode mode = { 0 }; + sigset_t mask; + + vt = session_open_vt(s); + if (vt < 0) + return; + + r = fchown(vt, s->user->uid, -1); + if (r < 0) + goto error; + + 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, &s->vt_source, SIGUSR1, session_vt_fn, s); + 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 = NULL; + int vt, kb = K_XLATE; + struct vt_mode mode = { 0 }; + + vt = session_open_vt(s); + if (vt < 0) + return; + + s->vt_source = sd_event_source_unref(s->vt_source); + + 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); + + fchown(vt, 0, -1); + + s->vtfd = safe_close(s->vtfd); +} + +bool session_is_controller(Session *s, const char *sender) { assert(s); return streq_ptr(s->controller, sender); } +static void session_swap_controller(Session *s, char *name) { + SessionDevice *sd; + + if (s->controller) { + manager_drop_busname(s->manager, s->controller); + free(s->controller); + s->controller = NULL; + + /* Drop all devices as they're now unused. Do that after the + * controller is released to avoid sending out useles + * dbus signals. */ + while ((sd = hashmap_first(s->devices))) + session_device_free(sd); + + if (!name) + session_restore_vt(s); + } + + s->controller = name; + session_save(s); +} + int session_set_controller(Session *s, const char *sender, bool force) { char *t; int r; @@ -998,28 +1125,28 @@ int session_set_controller(Session *s, const char *sender, bool force) { return r; } - session_drop_controller(s); + 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_prepare_vt(s); - s->controller = t; return 0; } void session_drop_controller(Session *s) { - SessionDevice *sd; - assert(s); if (!s->controller) return; - manager_drop_busname(s->manager, s->controller); - free(s->controller); - s->controller = NULL; - - /* Drop all devices as they're now unused. Do that after the controller - * is released to avoid sending out useles dbus signals. */ - while ((sd = hashmap_first(s->devices))) - session_device_free(sd); + session_swap_controller(s, NULL); } static const char* const session_state_table[_SESSION_STATE_MAX] = { @@ -1032,9 +1159,11 @@ static const char* const session_state_table[_SESSION_STATE_MAX] = { DEFINE_STRING_TABLE_LOOKUP(session_state, SessionState); static const char* const session_type_table[_SESSION_TYPE_MAX] = { + [SESSION_UNSPECIFIED] = "unspecified", [SESSION_TTY] = "tty", [SESSION_X11] = "x11", - [SESSION_UNSPECIFIED] = "unspecified" + [SESSION_WAYLAND] = "wayland", + [SESSION_MIR] = "mir", }; DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);