hashmap_remove(s->manager->sessions, s->id);
- s->vt_source = sd_event_source_unref(s->vt_source);
-
free(s->state_file);
free(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;
+ }
+
+ fprintf(f, "REMOTE_USER=%s\n", escaped);
+ }
- if (s->remote_user)
- fprintf(f, "REMOTE_USER=%s\n", s->remote_user);
+ if (s->service) {
+ _cleanup_free_ char *escaped;
- if (s->service)
- fprintf(f, "SERVICE=%s\n", s->service);
+ 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->desktop)
- fprintf(f, "DESKTOP=%s\n", s->desktop);
+ fprintf(f, "DESKTOP=%s\n", escaped);
+ }
if (s->seat && seat_has_vts(s->seat))
fprintf(f, "VTNR=%u\n", s->vtnr);
trigger the EOF. */
fd = session_create_fifo(s);
- if (fd >= 0)
- close_nointr_nofail(fd);
+ safe_close(fd);
}
if (realtime) {
if (!s->scope) {
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_free_ char *description = NULL;
- 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();
- r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "systemd-logind.service", &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_message(&error, r), error.name);
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);
s->started = true;
+ user_elect_display(s->user);
+
/* Save data */
session_save(s);
user_save(s->user);
/* Send signals */
session_send_signal(s, true);
- user_send_changed(s->user, "Sessions", NULL);
+ user_send_changed(s->user, "Sessions", "Display", NULL);
if (s->seat) {
if (s->seat->active == s)
seat_send_changed(s->seat, "Sessions", "ActiveSession", 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;
- if (manager_shall_kill(s->manager, s->user->name)) {
+ 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 0;
}
-int session_stop(Session *s) {
+int session_stop(Session *s, bool force) {
int r;
assert(s);
session_remove_fifo(s);
/* Kill cgroup */
- r = session_stop_scope(s);
+ r = session_stop_scope(s, force);
s->stopping = true;
+ user_elect_display(s->user);
+
session_save(s);
user_save(s->user);
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);
}
user_save(s->user);
- user_send_changed(s->user, "Sessions", NULL);
+ user_send_changed(s->user, "Sessions", "Display", NULL);
return r;
}
assert(es);
assert(s);
- session_stop(s);
+ session_stop(s, false);
return 0;
}
return;
if (!s->timer_event_source)
- sd_event_add_monotonic(s->manager->event, now(CLOCK_MONOTONIC) + RELEASE_USEC, 0, release_timeout_callback, s, &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) {
/* 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;
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);
SessionState session_get_state(Session *s) {
assert(s);
+ /* 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 (session_is_active(s))
static int session_open_vt(Session *s) {
char path[sizeof("/dev/tty") + DECIMAL_STR_MAX(s->vtnr)];
- if (!s->vtnr)
- return -1;
+ if (s->vtnr < 1)
+ return -ENODEV;
if (s->vtfd >= 0)
return s->vtfd;
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 -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_mute_vt(Session *s) {
+int session_prepare_vt(Session *s) {
int vt, r;
struct vt_mode mode = { 0 };
- sigset_t mask;
+
+ if (s->vtnr < 1)
+ return 0;
vt = session_open_vt(s);
if (vt < 0)
- return;
+ return vt;
- r = ioctl(vt, KDSKBMODE, K_OFF);
- if (r < 0)
+ r = fchown(vt, s->user->uid, -1);
+ if (r < 0) {
+ r = -errno;
+ log_error("Cannot change owner of /dev/tty%u: %m", s->vtnr);
goto error;
+ }
- r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
- if (r < 0)
+ r = ioctl(vt, KDSKBMODE, K_OFF);
+ if (r < 0) {
+ r = -errno;
+ log_error("Cannot set K_OFF on /dev/tty%u: %m", s->vtnr);
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)
+ r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
+ if (r < 0) {
+ r = -errno;
+ log_error("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 = SIGUSR1;
- mode.acqsig = SIGUSR1;
+ mode.relsig = SIGRTMIN;
+ mode.acqsig = SIGRTMIN + 1;
r = ioctl(vt, VT_SETMODE, &mode);
- if (r < 0)
+ if (r < 0) {
+ r = -errno;
+ log_error("Cannot set VT_PROCESS on /dev/tty%u: %m", s->vtnr);
goto error;
+ }
- return;
+ return 0;
error:
- log_error("cannot mute VT %u for session %s (%d/%d)", s->vtnr, s->id, r, errno);
session_restore_vt(s);
+ return r;
}
void session_restore_vt(Session *s) {
- _cleanup_free_ char *utf8;
+ _cleanup_free_ char *utf8 = NULL;
int vt, kb = K_XLATE;
struct vt_mode mode = { 0 };
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);
- close_nointr_nofail(vt);
- s->vtfd = -1;
+ fchown(vt, 0, -1);
+
+ s->vtfd = safe_close(s->vtfd);
}
bool session_is_controller(Session *s, const char *sender) {
return r;
}
- 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
* 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);
+ r = session_prepare_vt(s);
+ if (r < 0)
+ return r;
+
+ session_swap_controller(s, t);
return 0;
}
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_WAYLAND] = "wayland",
- [SESSION_UNSPECIFIED] = "unspecified",
+ [SESSION_MIR] = "mir",
+ [SESSION_WEB] = "web",
};
DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
~ianmdlvl / elogind.git / blobdiff