***/
#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"
-#include "strv.h"
#include "util.h"
#include "mkdir.h"
#include "path-util.h"
#include "bus-util.h"
#include "bus-error.h"
#include "logind-session.h"
+#include "formats-util.h"
+#include "terminal-util.h"
-static unsigned devt_hash_func(const void *p) {
- uint64_t u = *(const dev_t*)p;
-
- return uint64_hash_func(&u);
-}
+#define RELEASE_USEC (20*USEC_PER_SEC)
-static int devt_compare_func(const void *_a, const void *_b) {
- dev_t a, b;
-
- a = *(const dev_t*) _a;
- b = *(const dev_t*) _b;
-
- return a < b ? -1 : (a > b ? 1 : 0);
-}
+static void session_remove_fifo(Session *s);
Session* session_new(Manager *m, const char *id) {
Session *s;
return NULL;
}
- s->devices = hashmap_new(devt_hash_func, devt_compare_func);
+ s->devices = hashmap_new(&devt_hash_ops);
if (!s->devices) {
free(s->state_file);
free(s);
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);
s->manager = m;
s->fifo_fd = -1;
+ s->vtfd = -1;
return 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);
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);
}
free(s->remote_host);
free(s->remote_user);
free(s->service);
+ free(s->desktop);
hashmap_remove(s->manager->sessions, s->id);
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)),
if (s->scope)
fprintf(f, "SCOPE=%s\n", s->scope);
-
if (s->scope_job)
fprintf(f, "SCOPE_JOB=%s\n", s->scope_job);
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;
+ }
- if (s->remote_user)
- fprintf(f, "REMOTE_USER=%s\n", s->remote_user);
+ 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->desktop) {
+ _cleanup_free_ char *escaped;
+
+
+ escaped = cescape(s->desktop);
+ if (!escaped) {
+ r = -ENOMEM;
+ goto finish;
+ }
- if (s->service)
- fprintf(f, "SERVICE=%s\n", s->service);
+ 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, "POSITION=%u\n", s->position);
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);
finish:
if (r < 0)
- log_error("Failed to save session data for %s: %s", s->id, strerror(-r));
+ log_error_errno(r, "Failed to save session data %s: %m", s->state_file);
return r;
}
_cleanup_free_ char *remote = NULL,
*seat = NULL,
*vtnr = NULL,
+ *state = NULL,
+ *position = NULL,
*leader = NULL,
*type = NULL,
*class = NULL,
*uid = NULL,
*realtime = NULL,
- *monotonic = NULL;
+ *monotonic = NULL,
+ *controller = NULL;
int k, r;
"REMOTE_HOST", &s->remote_host,
"REMOTE_USER", &s->remote_user,
"SERVICE", &s->service,
+ "DESKTOP", &s->desktop,
"VTNR", &vtnr,
+ "STATE", &state,
+ "POSITION", &position,
"LEADER", &leader,
"TYPE", &type,
"CLASS", &class,
"UID", &uid,
"REALTIME", &realtime,
"MONOTONIC", &monotonic,
+ "CONTROLLER", &controller,
NULL);
- if (r < 0) {
- log_error("Failed to read %s: %s", s->state_file, strerror(-r));
- return r;
- }
+ if (r < 0)
+ return log_error_errno(r, "Failed to read %s: %m", s->state_file);
if (!s->user) {
uid_t u;
return r;
}
- user = hashmap_get(s->manager->users, ULONG_TO_PTR((unsigned long) u));
+ user = hashmap_get(s->manager->users, UID_TO_PTR(u));
if (!user) {
log_error("User of session %s not known.", s->id);
return -ENOENT;
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;
+
+ if (position && s->seat) {
+ unsigned int npos;
- k = safe_atoi(vtnr, &v);
- if (k >= 0 && v >= 1)
- s->vtnr = v;
+ safe_atou(position, &npos);
+ seat_claim_position(s->seat, s, npos);
}
if (leader) {
s->class = c;
}
+ if (state && streq(state, "closing"))
+ s->stopping = true;
+
if (s->fifo_path) {
int fd;
/* If we open an unopened pipe for reading we will not
get an EOF. to trigger an EOF we hence open it for
- reading, but close it right-away which then will
- trigger the EOF. */
+ writing, but close it right away which then will
+ trigger the EOF. This will happen immediately if no
+ other process has the FIFO open for writing, i. e.
+ when the session died before logind (re)started. */
fd = session_create_fifo(s);
- if (fd >= 0)
- close_nointr_nofail(fd);
+ safe_close(fd);
}
if (realtime) {
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;
}
assert(s->user);
if (!s->seat)
- return -ENOTSUP;
+ return -EOPNOTSUPP;
if (s->seat->active == s)
return 0;
/* on seats with VTs, we let VTs manage session-switching */
if (seat_has_vts(s->seat)) {
- if (s->vtnr <= 0)
- return -ENOTSUP;
+ if (!s->vtnr)
+ return -EOPNOTSUPP;
return chvt(s->vtnr);
}
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) {
int r;
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)
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, "logind.service", "systemd-user-sessions.service", &error, &job);
if (r < 0) {
log_error("Failed to start session scope %s: %s %s",
scope, bus_error_message(&error, r), error.name);
if (r < 0)
return r;
- log_struct(s->type == SESSION_TTY || s->type == SESSION_X11 ? LOG_INFO : LOG_DEBUG,
- MESSAGE_ID(SD_MESSAGE_SESSION_START),
+ log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
+ LOG_MESSAGE_ID(SD_MESSAGE_SESSION_START),
"SESSION_ID=%s", s->id,
"USER_ID=%s", s->user->name,
- "LEADER=%lu", (unsigned long) s->leader,
- "MESSAGE=New session %s of user %s.", s->id, s->user->name,
+ "LEADER="PID_FMT, s->leader,
+ LOG_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);
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", "ActiveSession", NULL);
else
seat_send_changed(s->seat, "Sessions", NULL);
}
- user_send_changed(s->user, "Sessions", NULL);
-
return 0;
}
-static int session_stop_scope(Session *s) {
+static int session_stop_scope(Session *s, bool force) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
- char *job;
+ char *job = NULL;
int r;
assert(s);
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_message(&error, r));
- 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 -ESTALE;
if (s->started)
- log_struct(s->type == SESSION_TTY || s->type == SESSION_X11 ? LOG_INFO : LOG_DEBUG,
- MESSAGE_ID(SD_MESSAGE_SESSION_STOP),
+ log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO,
+ LOG_MESSAGE_ID(SD_MESSAGE_SESSION_STOP),
"SESSION_ID=%s", s->id,
"USER_ID=%s", s->user->name,
- "LEADER=%lu", (unsigned long) s->leader,
- "MESSAGE=Removed session %s.", s->id,
+ "LEADER="PID_FMT, s->leader,
+ LOG_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);
if (s->seat->active == s)
seat_set_active(s->seat, NULL);
- seat_send_changed(s->seat, "Sessions", NULL);
seat_save(s->seat);
+ seat_send_changed(s->seat, "Sessions", NULL);
}
- user_send_changed(s->user, "Sessions", NULL);
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;
+}
+
+int session_release(Session *s) {
+ assert(s);
+
+ if (!s->started || s->stopping)
+ return 0;
+
+ if (s->timer_event_source)
+ return 0;
+
+ return 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);
/* EOF on the FIFO means the session died abnormally. */
session_remove_fifo(s);
- session_stop(s);
+ session_stop(s, false);
return 1;
}
}
if (!s->fifo_event_source) {
- r = sd_event_add_io(s->manager->event, s->fifo_fd, 0, session_dispatch_fifo, s, &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;
return r;
}
-void session_remove_fifo(Session *s) {
+static void session_remove_fifo(Session *s) {
assert(s);
- if (s->fifo_event_source)
- s->fifo_event_source = sd_event_source_unref(s->fifo_event_source);
-
- if (s->fifo_fd >= 0) {
- close_nointr_nofail(s->fifo_fd);
- s->fifo_fd = -1;
- }
+ 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);
}
bool session_check_gc(Session *s, bool drop_not_started) {
- int r;
-
assert(s);
if (drop_not_started && !s->started)
return false;
if (s->fifo_fd >= 0) {
- r = pipe_eof(s->fifo_fd);
- if (r < 0)
- return true;
-
- if (r == 0)
+ if (pipe_eof(s->fifo_fd) <= 0)
return true;
}
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;
return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
}
+static int session_open_vt(Session *s) {
+ char path[sizeof("/dev/tty") + DECIMAL_STR_MAX(s->vtnr)];
+
+ if (s->vtnr < 1)
+ return -ENODEV;
+
+ 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)
+ return log_error_errno(errno, "cannot open VT %s of session %s: %m", path, s->id);
+
+ return s->vtfd;
+}
+
+int session_prepare_vt(Session *s) {
+ int vt, r;
+ struct vt_mode mode = { 0 };
+
+ if (s->vtnr < 1)
+ return 0;
+
+ vt = session_open_vt(s);
+ if (vt < 0)
+ return vt;
+
+ r = fchown(vt, s->user->uid, -1);
+ if (r < 0) {
+ r = -errno;
+ log_error_errno(errno, "Cannot change owner of /dev/tty%u: %m", s->vtnr);
+ goto error;
+ }
+
+ r = ioctl(vt, KDSKBMODE, K_OFF);
+ if (r < 0) {
+ r = -errno;
+ log_error_errno(errno, "Cannot set K_OFF on /dev/tty%u: %m", s->vtnr);
+ goto error;
+ }
+
+ r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
+ if (r < 0) {
+ r = -errno;
+ log_error_errno(errno, "Cannot set KD_GRAPHICS on /dev/tty%u: %m", s->vtnr);
+ 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 = SIGRTMIN;
+ mode.acqsig = SIGRTMIN + 1;
+ r = ioctl(vt, VT_SETMODE, &mode);
+ if (r < 0) {
+ r = -errno;
+ log_error_errno(errno, "Cannot set VT_PROCESS on /dev/tty%u: %m", s->vtnr);
+ goto error;
+ }
+
+ return 0;
+
+error:
+ session_restore_vt(s);
+ return r;
+}
+
+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;
+
+ (void) ioctl(vt, KDSETMODE, KD_TEXT);
+
+ if (read_one_line_file("/sys/module/vt/parameters/default_utf8", &utf8) >= 0 && *utf8 == '1')
+ kb = K_UNICODE;
+
+ (void) ioctl(vt, KDSKBMODE, kb);
+
+ mode.mode = VT_AUTO;
+ (void) ioctl(vt, VT_SETMODE, &mode);
+
+ fchown(vt, 0, -1);
+
+ s->vtfd = safe_close(s->vtfd);
+}
+
+void session_leave_vt(Session *s) {
+ int r;
+
+ assert(s);
+
+ /* This is called whenever we get a VT-switch signal from the kernel.
+ * We acknowledge all of them unconditionally. Note that session are
+ * free to overwrite those handlers and we only register them for
+ * sessions with controllers. Legacy sessions are not affected.
+ * However, if we switch from a non-legacy to a legacy session, we must
+ * make sure to pause all device before acknowledging the switch. We
+ * process the real switch only after we are notified via sysfs, so the
+ * legacy session might have already started using the devices. If we
+ * don't pause the devices before the switch, we might confuse the
+ * session we switch to. */
+
+ if (s->vtfd < 0)
+ return;
+
+ session_device_pause_all(s);
+ r = ioctl(s->vtfd, VT_RELDISP, 1);
+ if (r < 0)
+ log_debug_errno(errno, "Cannot release VT of session %s: %m", s->id);
+}
+
bool session_is_controller(Session *s, const char *sender) {
assert(s);
return streq_ptr(s->controller, sender);
}
+static void session_release_controller(Session *s, bool notify) {
+ _cleanup_free_ char *name = NULL;
+ SessionDevice *sd;
+
+ if (!s->controller)
+ return;
+
+ name = s->controller;
+
+ /* By resetting the controller before releasing the devices, we won't
+ * send notification signals. This avoids sending useless notifications
+ * if the controller is released on disconnects. */
+ if (!notify)
+ s->controller = NULL;
+
+ while ((sd = hashmap_first(s->devices)))
+ session_device_free(sd);
+
+ s->controller = NULL;
+ manager_drop_busname(s->manager, name);
+}
+
int session_set_controller(Session *s, const char *sender, bool force) {
- char *t;
+ _cleanup_free_ char *name = NULL;
int r;
assert(s);
if (s->controller && !force)
return -EBUSY;
- t = strdup(sender);
- if (!t)
+ name = strdup(sender);
+ if (!name)
return -ENOMEM;
- r = manager_watch_busname(s->manager, sender);
- if (r) {
- free(t);
+ r = manager_watch_busname(s->manager, name);
+ if (r)
+ return r;
+
+ /* 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. */
+ r = session_prepare_vt(s);
+ if (r < 0) {
+ manager_drop_busname(s->manager, name);
return r;
}
- session_drop_controller(s);
+ session_release_controller(s, true);
+ s->controller = name;
+ name = NULL;
+ session_save(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_release_controller(s, false);
+ session_save(s);
+ session_restore_vt(s);
}
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",
+ [SESSION_WEB] = "web",
};
DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
~ianmdlvl / elogind.git / blobdiff