diff --git a/.builds/alpine.yml b/.builds/alpine.yml index e048494..7e59203 100644 --- a/.builds/alpine.yml +++ b/.builds/alpine.yml @@ -3,31 +3,26 @@ packages: - meson - linux-headers - clang + - clang-extra-tools - clang-analyzer - scdoc sources: - https://git.sr.ht/~kennylevinsen/seatd tasks: - prepare: | - cd seatd - meson build -Dseatd=enabled -Dbuiltin=enabled -Dlogind=disabled + meson -Dlibseat-seatd=enabled -Dlibseat-builtin=enabled -Dlibseat-logind=disabled -Dexamples=enabled build seatd - build: | - cd seatd ninja -C build + sudo ninja -C build install - unittest: | - cd seatd ninja -C build test - scan-build: | - cd seatd ninja -C build scan-build [ -z "$(ls -A build/meson-logs/scanbuild/ 2>/dev/null)" ] - smoketest: | - cd seatd - timeout -s KILL 30s ./.builds/smoketest-seatd.sh + timeout -s KILL 30s sudo ./build/seatd-launch -l debug -- ./build/simpletest /dev/dri/card0 - smoketest-builtin: | - cd seatd - timeout -s KILL 30s ./.builds/smoketest-builtin.sh + timeout -s KILL 30s sudo LIBSEAT_BACKEND=builtin ./build/simpletest /dev/dri/card0 - check-format: | - cd seatd ninja -C build clang-format - git diff --exit-code + git -C seatd diff --exit-code diff --git a/.builds/archlinux.yml b/.builds/archlinux.yml index 4d8cf63..185d232 100644 --- a/.builds/archlinux.yml +++ b/.builds/archlinux.yml @@ -9,24 +9,22 @@ sources: - https://git.sr.ht/~kennylevinsen/seatd tasks: - prepare: | - cd seatd - meson -Dlogind=enabled -Dseatd=enabled -Dbuiltin=enabled build + meson -Db_sanitize=address -Dlibseat-logind=auto -Dlibseat-seatd=enabled -Dlibseat-builtin=enabled -Dexamples=enabled build seatd - build: | - cd seatd ninja -C build + sudo ninja -C build install - unittest: | - cd seatd ninja -C build test - scan-build: | - cd seatd ninja -C build scan-build [ -z "$(ls -A build/meson-logs/scanbuild/ 2>/dev/null)" ] - smoketest: | - cd seatd - rm -rf build - meson -Db_sanitize=address -Dlogind=enabled -Dseatd=enabled -Dbuiltin=enabled build - ninja -C build - timeout -s KILL 30s ./.builds/smoketest-seatd.sh + timeout -s KILL 30s sudo ./build/seatd-launch -l debug -- ./build/simpletest /dev/input/event0 - smoketest-builtin: | - cd seatd - timeout -s KILL 30s ./.builds/smoketest-builtin.sh + timeout -s KILL 30s sudo LIBSEAT_BACKEND=builtin ./build/simpletest /dev/input/event0 + - smoketest-logind: | + # Turn off systemd-logind and patch our session to be tied to seat0 on VT 6 + sudo systemctl stop systemd-logind + echo -e "ACTIVE=$XDG_SESSION_ID\nACTIVE_UID=$UID\nSESSIONS=$XDG_SESSION_ID\nUIDS=$UID\n" | sudo tee -a /run/systemd/seats/seat0 > /dev/null + echo -e "SEAT=seat0\nVTNR=6\n" | sudo tee -a /run/systemd/sessions/$XDG_SESSION_ID > /dev/null + timeout -s KILL 30s sudo LIBSEAT_BACKEND=logind ./build/simpletest /dev/input/event0 diff --git a/.builds/freebsd.yml b/.builds/freebsd.yml index 048f95c..c8f9618 100644 --- a/.builds/freebsd.yml +++ b/.builds/freebsd.yml @@ -5,17 +5,16 @@ sources: - https://git.sr.ht/~kennylevinsen/seatd tasks: - prepare: | - cd seatd - meson build -Dseatd=enabled -Dbuiltin=enabled -Dlogind=disabled + meson -Dlibseat-seatd=enabled -Dlibseat-builtin=enabled -Dlibseat-logind=disabled build seatd - build: | - cd seatd ninja -C build - unittest: | - cd seatd ninja -C build test - smoketest: | - cd seatd - timeout -s KILL 30s ./.builds/smoketest-seatd.sh + rm -rf build + meson -Db_lundef=false -Db_sanitize=address -Dlibseat-seatd=enabled -Dlibseat-builtin=enabled -Dexamples=enabled -Dlibseat-logind=disabled build seatd + ninja -C build + sudo ninja -C build install + timeout -s KILL 30s sudo ./build/seatd-launch -l debug -- ./build/simpletest /dev/input/event0 - smoketest-builtin: | - cd seatd - timeout -s KILL 30s ./.builds/smoketest-builtin.sh + timeout -s KILL 30s sudo LIBSEAT_BACKEND=builtin ./build/simpletest /dev/input/event0 diff --git a/.builds/netbsd.yml b/.builds/netbsd.yml new file mode 100644 index 0000000..a676138 --- /dev/null +++ b/.builds/netbsd.yml @@ -0,0 +1,24 @@ +image: netbsd/latest +packages: + - meson +sources: + - https://git.sr.ht/~kennylevinsen/seatd +tasks: + - wscons: | + echo 'wscons=YES' | sudo tee -a /etc/rc.conf + sudo /etc/rc.d/wscons start + sudo /etc/rc.d/ttys restart + - prepare: | + meson -Dlibseat-seatd=enabled -Dlibseat-builtin=enabled -Dlibseat-logind=disabled build seatd + - build: | + ninja -C build + - unittest: | + ninja -C build test + - smoketest: | + rm -rf build + meson -Db_lundef=false -Db_sanitize=address -Dlibseat-seatd=enabled -Dlibseat-builtin=enabled -Dexamples=enabled -Dlibseat-logind=disabled build seatd + ninja -C build + sudo ninja -C build install + timeout -s SIGKILL 30s sudo SEATD_LOGLEVEL=debug ./build/seatd-launch ./build/simpletest /dev/wskbd + - smoketest-builtin: | + timeout -s SIGKILL 30s sudo LIBSEAT_BACKEND=builtin ./build/simpletest /dev/wskbd diff --git a/.builds/smoketest-builtin.sh b/.builds/smoketest-builtin.sh deleted file mode 100755 index 8341466..0000000 --- a/.builds/smoketest-builtin.sh +++ /dev/null @@ -1,30 +0,0 @@ -#!/bin/sh - -# Devices that exist on sr.ht -if [ -e "/dev/input/event0" ] -then - file="/dev/input/event0" -elif [ -e "/dev/dri/card0" ] -then - file="/dev/dri/card0" -else - echo "No useful device file found" - exit 1 -fi - -# -# Run simpletest a few times -# -cnt=0 -while [ "$cnt" -lt 5 ] -do - echo "Simpletest run $cnt" - if ! sudo LIBSEAT_BACKEND=builtin LIBSEAT_LOGLEVEL=debug SEATD_SOCK=./seatd.sock ./build/simpletest $file - then - echo "Simpletest failed" - exit $res - fi - cnt=$((cnt+1)) -done - -echo "smoketest-builtin completed" diff --git a/.builds/smoketest-seatd.sh b/.builds/smoketest-seatd.sh deleted file mode 100755 index f6f9732..0000000 --- a/.builds/smoketest-seatd.sh +++ /dev/null @@ -1,58 +0,0 @@ -#!/bin/sh - -# -# Start seatd -# -[ -f seatd.sock ] && sudo rm seatd.sock -sudo SEATD_LOGLEVEL=debug SEATD_SOCK=./seatd.sock ./build/seatd & - -# seatd is started in the background, so wait for it to come alive -cnt=0 -while ! [ -e ./seatd.sock ] && [ "$cnt" -lt 10 ] -do - sleep 0.1 - cnt=$((cnt+1)) -done - -if ! [ -e ./seatd.sock ] -then - echo "seatd socket not found" - exit 1 -fi - -sudo chmod 777 ./seatd.sock - -# Devices that exist on sr.ht -if [ -e "/dev/input/event0" ] -then - file="/dev/input/event0" -elif [ -e "/dev/dri/card0" ] -then - file="/dev/dri/card0" -else - echo "No useful device file found" - exit 1 -fi - -# -# Run simpletest a few times -# -cnt=0 -while [ "$cnt" -lt 5 ] -do - echo "Simpletest run $cnt" - if ! LIBSEAT_LOGLEVEL=debug SEATD_SOCK=./seatd.sock ./build/simpletest $file - then - echo "Simpletest failed" - sudo killall seatd - exit 1 - fi - cnt=$((cnt+1)) -done - -# -# Wait for it to shut down -# -sudo killall seatd 2>/dev/null - -echo "smoketest-seatd completed" diff --git a/.clang-format b/.clang-format index c182735..28723ad 100644 --- a/.clang-format +++ b/.clang-format @@ -2,7 +2,7 @@ IndentWidth: 8 TabWidth: 8 ContinuationIndentWidth: 8 -UseTab: Always +UseTab: ForContinuationAndIndentation ColumnLimit: 100 AlignConsecutiveMacros: true diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..51a7d86 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,8 @@ +root = true + +[*] +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = true +indent_style = tab +indent_size = 8 diff --git a/README.md b/README.md index 114845d..b8a705f 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ A minimal seat management daemon, and a universal seat management library. -Currently supports Linux and FreeBSD. Alpha +Currently supports Linux and FreeBSD, and has experimental NetBSD support. ## What is seat management? @@ -12,7 +12,7 @@ Seat management takes care of mediating access to shared devices (graphics, inpu ### seatd -A seat management deamon, that does everything it needs to do. Nothing more, nothing less. Depends only on libc. +A seat management daemon, that does everything it needs to do. Nothing more, nothing less. Depends only on libc. ### libseat @@ -41,6 +41,6 @@ Why spend time isolating logind and keeping up with upstream when we could inste Instead of giving user shell developers more work, libseat aims to make supporting seatd less work than what they're currently implementing. This is done by taking care of all the seat management needs with multiple backends, providing not only seatd support, but replacing the existing logind and direct seat management implementations. -## I want more +## How to discuss -Go to #kennylevinsen @ chat.freenode.net to discuss, or use [~kennylevinsen/public-inbox@lists.sr.ht](https://lists.sr.ht/~kennylevinsen/public-inbox). +Go to [#kennylevinsen @ irc.libera.chat](ircs://irc.libera.chat/#kennylevinsen) to discuss, or use [~kennylevinsen/seatd-devel@lists.sr.ht](https://lists.sr.ht/~kennylevinsen/seatd-devel). diff --git a/common/connection.c b/common/connection.c index a6739c0..6b2c366 100644 --- a/common/connection.c +++ b/common/connection.c @@ -284,15 +284,14 @@ int connection_get(struct connection *connection, void *dst, size_t count) { return count; } -int connection_get_fd(struct connection *connection) { - int fd; - if (sizeof fd > connection_buffer_size(&connection->fds_in)) { +int connection_get_fd(struct connection *connection, int *fd) { + if (sizeof(int) > connection_buffer_size(&connection->fds_in)) { errno = EAGAIN; return -1; } - connection_buffer_copy(&connection->fds_in, &fd, sizeof fd); - connection_buffer_consume(&connection->fds_in, sizeof fd); - return fd; + connection_buffer_copy(&connection->fds_in, fd, sizeof(int)); + connection_buffer_consume(&connection->fds_in, sizeof(int)); + return 0; } void connection_close_fds(struct connection *connection) { diff --git a/common/drm.c b/common/drm.c index 8be2c62..2fbadd5 100644 --- a/common/drm.c +++ b/common/drm.c @@ -2,19 +2,16 @@ #include #include -#if defined(__linux__) -#include -#endif - #include "drm.h" // From libdrm -#define DRM_IOCTL_BASE 'd' -#define DRM_IO(nr) _IO(DRM_IOCTL_BASE, nr) +#define DRM_IOCTL_BASE 'd' +#define DRM_IO(nr) _IO(DRM_IOCTL_BASE, nr) #define DRM_IOCTL_SET_MASTER DRM_IO(0x1e) #define DRM_IOCTL_DROP_MASTER DRM_IO(0x1f) -#define STRLEN(s) ((sizeof(s) / sizeof(s[0])) - 1) +#define STRLEN(s) ((sizeof(s) / sizeof(s[0])) - 1) +#define STR_HAS_PREFIX(prefix, s) (strncmp(prefix, s, STRLEN(prefix)) == 0) int drm_set_master(int fd) { return ioctl(fd, DRM_IOCTL_SET_MASTER, 0); @@ -24,24 +21,21 @@ int drm_drop_master(int fd) { return ioctl(fd, DRM_IOCTL_DROP_MASTER, 0); } -static int path_is_drm_card(const char *path) { - static const char prefix[] = "/dev/dri/card"; - static const int prefixlen = STRLEN(prefix); - return strncmp(prefix, path, prefixlen) == 0; -} - -static int path_is_drm_render(const char *path) { - static const char prefix[] = "/dev/dri/renderD"; - static const int prefixlen = STRLEN(prefix); - return strncmp(prefix, path, prefixlen) == 0; -} - +#if defined(__linux__) || defined(__NetBSD__) || defined(__OpenBSD__) int path_is_drm(const char *path) { - return path_is_drm_card(path) || path_is_drm_render(path); + if (STR_HAS_PREFIX("/dev/dri/", path)) + return 1; + return 0; } - -#if defined(__linux__) -int dev_is_drm(dev_t device) { - return major(device) == 226; +#elif defined(__FreeBSD__) +int path_is_drm(const char *path) { + if (STR_HAS_PREFIX("/dev/dri/", path)) + return 1; + /* Some drivers have /dev/dri/X symlinked to /dev/drm/X */ + if (STR_HAS_PREFIX("/dev/drm/", path)) + return 1; + return 0; } +#else +#error Unsupported platform #endif diff --git a/common/evdev.c b/common/evdev.c index 4aff9bc..a77bf36 100644 --- a/common/evdev.c +++ b/common/evdev.c @@ -9,14 +9,13 @@ #include #elif defined(__FreeBSD__) #include -#else -#error Unsupported platform #endif #include "evdev.h" #define STRLEN(s) ((sizeof(s) / sizeof(s[0])) - 1) +#if defined(__linux__) || defined(__FreeBSD__) int path_is_evdev(const char *path) { static const char prefix[] = "/dev/input/event"; static const size_t prefixlen = STRLEN(prefix); @@ -26,9 +25,15 @@ int path_is_evdev(const char *path) { int evdev_revoke(int fd) { return ioctl(fd, EVIOCREVOKE, NULL); } - -#if defined(__linux__) -int dev_is_evdev(dev_t device) { - return major(device) == INPUT_MAJOR; +#elif defined(__NetBSD__) || defined(__OpenBSD__) +int path_is_evdev(const char *path) { + (void)path; + return 0; } +int evdev_revoke(int fd) { + (void)fd; + return 0; +} +#else +#error Unsupported platform #endif diff --git a/common/linked_list.c b/common/linked_list.c index cb3e0a8..7383de0 100644 --- a/common/linked_list.c +++ b/common/linked_list.c @@ -32,3 +32,15 @@ bool linked_list_empty(struct linked_list *list) { assert(list->prev != NULL && list->next != NULL); return list->next == list; } + +void linked_list_take(struct linked_list *target, struct linked_list *source) { + if (linked_list_empty(source)) { + return; + } + + source->next->prev = target; + source->prev->next = target->next; + target->next->prev = source->prev; + target->next = source->next; + linked_list_init(source); +} diff --git a/common/list.c b/common/list.c deleted file mode 100644 index 557e0dc..0000000 --- a/common/list.c +++ /dev/null @@ -1,85 +0,0 @@ -#include -#include -#include - -#include "list.h" - -void list_init(struct list *list) { - list->capacity = 10; - list->length = 0; - list->items = malloc(sizeof(void *) * list->capacity); -} - -static void list_resize(struct list *list) { - if (list->length == list->capacity) { - list->capacity *= 2; - list->items = realloc(list->items, sizeof(void *) * list->capacity); - } -} - -void list_free(struct list *list) { - list->capacity = 0; - list->length = 0; - free(list->items); -} - -void list_add(struct list *list, void *item) { - list_resize(list); - list->items[list->length++] = item; -} - -void list_insert(struct list *list, size_t index, void *item) { - list_resize(list); - memmove(&list->items[index + 1], &list->items[index], - sizeof(void *) * (list->length - index)); - list->length++; - list->items[index] = item; -} - -void list_del(struct list *list, size_t index) { - list->length--; - memmove(&list->items[index], &list->items[index + 1], - sizeof(void *) * (list->length - index)); -} - -size_t list_find(struct list *list, const void *item) { - for (size_t i = 0; i < list->length; i++) { - if (list->items[i] == item) { - return i; - } - } - return -1; -} - -void list_concat(struct list *list, const struct list *source) { - if (list->length + source->length > list->capacity) { - while (list->length + source->length > list->capacity) { - list->capacity *= 2; - } - list->items = realloc(list->items, sizeof(void *) * list->capacity); - } - memmove(&list->items[list->length], source->items, sizeof(void *) * (source->length)); - list->length += source->length; -} - -void list_truncate(struct list *list) { - list->length = 0; -} - -void *list_pop_front(struct list *list) { - if (list->length == 0) { - return NULL; - } - void *item = list->items[0]; - list_del(list, 0); - return item; -} - -void *list_pop_back(struct list *list) { - if (list->length == 0) { - return NULL; - } - void *item = list->items[list->length - 1]; - list->length -= 1; - return item; -} diff --git a/common/terminal.c b/common/terminal.c index e397357..5aac2dd 100644 --- a/common/terminal.c +++ b/common/terminal.c @@ -13,14 +13,25 @@ #include #define K_ENABLE K_UNICODE #define K_DISABLE K_OFF -#define FRSIG 0 +#define FRSIG 0 #elif defined(__FreeBSD__) #include #include #include #define K_ENABLE K_XLATE #define K_DISABLE K_RAW -#define FRSIG SIGIO +#define FRSIG SIGIO +#elif defined(__NetBSD__) +#include +#define K_ENABLE K_XLATE +#define K_DISABLE K_RAW +#define FRSIG 0 // unimplemented +#elif defined(__OpenBSD__) +#include +#include +#define K_ENABLE K_XLATE +#define K_DISABLE K_RAW +#define FRSIG SIGIO #else #error Unsupported platform #endif @@ -38,6 +49,38 @@ static int get_tty_path(int tty, char path[static TTYPATHLEN]) { const size_t prefix_len = sizeof(prefix) - 1; strcpy(path, prefix); + // The FreeBSD VT_GETACTIVE is implemented in the kernel as follows: + // + // static int + // vtterm_ioctl(struct terminal *tm, u_long cmd, caddr_t data, + // struct thread *td) + // { + // struct vt_window *vw = tm->tm_softc; + // struct vt_device *vd = vw->vw_device; + // ... + // switch (cmd) { + // ... + // case VT_GETACTIVE: + // *(int *)data = vd->vd_curwindow->vw_number + 1; + // return (0); + // ... + // } + // ... + // } + // + // The side-effect here being that the returned VT number is one + // greater than the internal VT number. The internal number is what is + // used to number the TTY device, while the external number is what we + // use in e.g. VT switching. + // + // We subtract one from the requested TTY number to compensate. If the + // user asked for TTY 0 (which is special on Linux), we just give them + // the first tty. + + if (tty > 0) { + tty--; + } + // The FreeBSD tty name is constructed in the kernel as follows: // // static void @@ -102,31 +145,53 @@ static int get_tty_path(int tty, char path[static TTYPATHLEN]) { } return 0; } +#elif defined(__NetBSD__) +static int get_tty_path(int tty, char path[static TTYPATHLEN]) { + assert(tty >= 0); + if (snprintf(path, TTYPATHLEN, "/dev/ttyE%d", tty) == -1) { + return -1; + } + return 0; +} +#elif defined(__OpenBSD__) +static int get_tty_path(int tty, char path[static TTYPATHLEN]) { + assert(tty >= 0); + if (snprintf(path, TTYPATHLEN, "/dev/ttyC%d", tty) == -1) { + return -1; + } + return 0; +} #else #error Unsupported platform #endif int terminal_open(int vt) { char path[TTYPATHLEN]; + log_debugf("terminal_open vt %d", vt); +#ifdef __OpenBSD__ + if (vt > 0) + vt--; +#endif if (get_tty_path(vt, path) == -1) { - log_errorf("could not generate tty path: %s", strerror(errno)); + log_errorf("Could not generate tty path: %s", strerror(errno)); return -1; } + log_debugf("terminal_open path %s", path); int fd = open(path, O_RDWR | O_NOCTTY); if (fd == -1) { - log_errorf("could not open target tty: %s", strerror(errno)); + log_errorf("Could not open target tty: %s", strerror(errno)); return -1; } return fd; } int terminal_current_vt(int fd) { -#if defined(__linux__) +#if defined(__linux__) || defined(__NetBSD__) || defined(__OpenBSD__) struct vt_stat st; int res = ioctl(fd, VT_GETSTATE, &st); close(fd); if (res == -1) { - log_errorf("could not retrieve VT state: %s", strerror(errno)); + log_errorf("Could not retrieve VT state: %s", strerror(errno)); return -1; } return st.v_active; @@ -135,46 +200,22 @@ int terminal_current_vt(int fd) { int res = ioctl(fd, VT_GETACTIVE, &vt); close(fd); if (res == -1) { - log_errorf("could not retrieve VT state: %s", strerror(errno)); + log_errorf("Could not retrieve VT state: %s", strerror(errno)); return -1; } - // The FreeBSD VT_GETACTIVE is implemented in the kernel as follows: - // - // static int - // vtterm_ioctl(struct terminal *tm, u_long cmd, caddr_t data, - // struct thread *td) - // { - // struct vt_window *vw = tm->tm_softc; - // struct vt_device *vd = vw->vw_device; - // ... - // switch (cmd) { - // ... - // case VT_GETACTIVE: - // *(int *)data = vd->vd_curwindow->vw_number + 1; - // return (0); - // ... - // } - // ... - // } - // - // The side-effect here being that the returned VT number is one - // greater than the internal VT number, which is what is used for e.g. - // numbering the associated VT. To simplify things, we subtract one - // from the returned VT number before returning it. - - if (vt < 1) { - log_errorf("invalid vt: %d", vt); + if (vt == -1) { + log_errorf("Invalid VT: %d", vt); return -1; } - return vt - 1; + return vt; #else #error Unsupported platform #endif } int terminal_set_process_switching(int fd, bool enable) { - log_debug("setting process switching"); + log_debugf("Setting process switching to %d", enable); struct vt_mode mode = { .mode = enable ? VT_PROCESS : VT_AUTO, .waitv = 0, @@ -184,26 +225,37 @@ int terminal_set_process_switching(int fd, bool enable) { }; if (ioctl(fd, VT_SETMODE, &mode) == -1) { - log_errorf("could not set VT mode: %s", strerror(errno)); + log_errorf("Could not set VT mode to %s process switching: %s", + enable ? "enable" : "disable", strerror(errno)); return -1; } return 0; } int terminal_switch_vt(int fd, int vt) { - log_debugf("switching to vt %d", vt); + log_debugf("Switching to VT %d", vt); if (ioctl(fd, VT_ACTIVATE, vt) == -1) { - log_errorf("could not activate VT: %s", strerror(errno)); + log_errorf("Could not activate VT %d: %s", vt, strerror(errno)); return -1; } return 0; } -int terminal_ack_switch(int fd) { - log_debug("acking vt switch"); +int terminal_ack_release(int fd) { + log_debug("Acking VT release"); + if (ioctl(fd, VT_RELDISP, 1) == -1) { + log_errorf("Could not ack VT release: %s", strerror(errno)); + return -1; + } + + return 0; +} + +int terminal_ack_acquire(int fd) { + log_debug("Acking VT acquire"); if (ioctl(fd, VT_RELDISP, VT_ACKACQ) == -1) { - log_errorf("could not ack VT switch: %s", strerror(errno)); + log_errorf("Could not ack VT acquire: %s", strerror(errno)); return -1; } @@ -211,15 +263,25 @@ int terminal_ack_switch(int fd) { } int terminal_set_keyboard(int fd, bool enable) { - log_debugf("setting KD keyboard state to %d", enable); + log_debugf("Setting KD keyboard state to %d", enable); +#ifndef __OpenBSD1__ if (ioctl(fd, KDSKBMODE, enable ? K_ENABLE : K_DISABLE) == -1) { - log_errorf("could not set KD keyboard mode: %s", strerror(errno)); + log_errorf("Could not set KD keyboard mode to %s: %s", + enable ? "enabled" : "disabled", strerror(errno)); return -1; } +#else + int mode = enable ? WSKBD_RAW : WSKBD_TRANSLATED; + if (ioctl(fd, WSKBDIO_SETMODE, &mode) == -1) { + log_errorf("Could not set keyboard mode to %s: %s", + enable ? "translated" : "raw", strerror(errno)); + return -1; + } +#endif #if defined(__FreeBSD__) struct termios tios; if (tcgetattr(fd, &tios) == -1) { - log_errorf("could not set get terminal mode: %s", strerror(errno)); + log_errorf("Could not set get terminal mode: %s", strerror(errno)); return -1; } if (enable) { @@ -228,7 +290,8 @@ int terminal_set_keyboard(int fd, bool enable) { cfmakeraw(&tios); } if (tcsetattr(fd, TCSAFLUSH, &tios) == -1) { - log_errorf("could not set terminal mode: %s", strerror(errno)); + log_errorf("Could not set terminal mode to %s: %s", enable ? "sane" : "raw", + strerror(errno)); return -1; } #endif @@ -236,10 +299,20 @@ int terminal_set_keyboard(int fd, bool enable) { } int terminal_set_graphics(int fd, bool enable) { - log_debugf("setting KD graphics state to %d", enable); + log_debugf("Setting KD graphics state to %d", enable); +#ifndef __OpenBSD1__ if (ioctl(fd, KDSETMODE, enable ? KD_GRAPHICS : KD_TEXT) == -1) { - log_errorf("could not set KD graphics mode: %s", strerror(errno)); + log_errorf("Could not set KD graphics mode to %s: %s", enable ? "graphics" : "text", + strerror(errno)); return -1; } +#else + int mode = enable ? WSDISPLAYIO_MODE_MAPPED : WSDISPLAYIO_MODE_EMUL; + if (ioctl(fd, WSDISPLAYIO_SMODE, &mode) == -1) { + log_errorf("Could not set graphics mode to %s: %s", + enable ? "mapped" : "emul", strerror(errno)); + return -1; + } +#endif return 0; } diff --git a/common/wscons.c b/common/wscons.c new file mode 100644 index 0000000..121074c --- /dev/null +++ b/common/wscons.c @@ -0,0 +1,27 @@ +#include +#include + +#if defined(__NetBSD__) +#include +#include +#endif + +#include "wscons.h" + +#define STRLEN(s) ((sizeof(s) / sizeof(s[0])) - 1) + +#if defined(__NetBSD__) || defined(__OpenBSD__) +int path_is_wscons(const char *path) { + static const char wskbd[] = "/dev/wskbd"; + static const char wsmouse[] = "/dev/wsmouse"; + static const char wsmux[] = "/dev/wsmux"; + return strncmp(path, wskbd, STRLEN(wskbd)) == 0 || + strncmp(path, wsmouse, STRLEN(wsmouse)) == 0 || + strncmp(path, wsmux, STRLEN(wsmouse)) == 0; +} +#else +int path_is_wscons(const char *path) { + (void)path; + return 0; +} +#endif diff --git a/contrib/systemd/seatd.service b/contrib/systemd/seatd.service index 2751217..bbbaf23 100644 --- a/contrib/systemd/seatd.service +++ b/contrib/systemd/seatd.service @@ -1,9 +1,11 @@ [Unit] Description=Seat management daemon +Documentation=man:seatd(1) [Service] Type=simple -ExecStart=seatd -g video +# Specify the group you'd like to grant access to seatd +ExecStart=seatd -g seat Restart=always RestartSec=1 diff --git a/examples/simpletest/main.c b/examples/simpletest/main.c index 0ec1c91..6f94cf5 100644 --- a/examples/simpletest/main.c +++ b/examples/simpletest/main.c @@ -43,7 +43,11 @@ int main(int argc, char *argv[]) { while (active == 0) { fprintf(stderr, "waiting for activation...\n"); - libseat_dispatch(backend, -1); + if (libseat_dispatch(backend, -1) == -1) { + libseat_close_seat(backend); + fprintf(stderr, "libseat_dispatch() failed: %s\n", strerror(errno)); + return -1; + } } fprintf(stderr, "active!\n"); @@ -57,8 +61,8 @@ int main(int argc, char *argv[]) { return 1; } - close(fd); libseat_close_device(backend, device); + close(fd); libseat_close_seat(backend); return 0; } diff --git a/include/backend.h b/include/backend.h index 075f48c..8f6ff39 100644 --- a/include/backend.h +++ b/include/backend.h @@ -16,7 +16,7 @@ struct named_backend { }; struct seat_impl { - struct libseat *(*open_seat)(struct libseat_seat_listener *listener, void *data); + struct libseat *(*open_seat)(const struct libseat_seat_listener *listener, void *data); int (*disable_seat)(struct libseat *seat); int (*close_seat)(struct libseat *seat); const char *(*seat_name)(struct libseat *seat); diff --git a/include/client.h b/include/client.h index e0d9016..8746bea 100644 --- a/include/client.h +++ b/include/client.h @@ -10,6 +10,14 @@ struct server; +enum client_state { + CLIENT_NEW, + CLIENT_ACTIVE, + CLIENT_PENDING_DISABLE, + CLIENT_DISABLED, + CLIENT_CLOSED +}; + struct client { struct linked_list link; // seat::clients struct server *server; @@ -21,18 +29,16 @@ struct client { gid_t gid; struct seat *seat; - int seat_vt; - bool pending_disable; + int session; + enum client_state state; struct linked_list devices; }; struct client *client_create(struct server *server, int client_fd); -void client_kill(struct client *client); void client_destroy(struct client *client); int client_handle_connection(int fd, uint32_t mask, void *data); -int client_get_session(const struct client *client); int client_send_enable_seat(struct client *client); int client_send_disable_seat(struct client *client); diff --git a/include/connection.h b/include/connection.h index 3e15403..d32e766 100644 --- a/include/connection.h +++ b/include/connection.h @@ -28,7 +28,7 @@ int connection_put_fd(struct connection *connection, int fd); size_t connection_pending(struct connection *connection); int connection_get(struct connection *connection, void *dst, size_t count); -int connection_get_fd(struct connection *connection); +int connection_get_fd(struct connection *connection, int *fd); void connection_restore(struct connection *connection, size_t count); void connection_close_fds(struct connection *connection); diff --git a/include/drm.h b/include/drm.h index 8a7fb10..a8a5461 100644 --- a/include/drm.h +++ b/include/drm.h @@ -5,9 +5,4 @@ int drm_set_master(int fd); int drm_drop_master(int fd); int path_is_drm(const char *path); -#if defined(__linux__) -#include -int dev_is_drm(dev_t device); -#endif - #endif diff --git a/include/evdev.h b/include/evdev.h index 6ebd943..5e6cfbf 100644 --- a/include/evdev.h +++ b/include/evdev.h @@ -4,9 +4,4 @@ int evdev_revoke(int fd); int path_is_evdev(const char *path); -#if defined(__linux__) -#include -int dev_is_evdev(dev_t device); -#endif - #endif diff --git a/include/libseat.h b/include/libseat.h index 891cb86..385acd9 100644 --- a/include/libseat.h +++ b/include/libseat.h @@ -1,6 +1,8 @@ #ifndef _LIBSEAT_H #define _LIBSEAT_H +#include + /* * An opaque struct containing an opened seat, created by libseat_open_seat and * destroyed by libseat_close_seat. @@ -45,15 +47,17 @@ struct libseat_seat_listener { * The available backends, if enabled at compile-time, are: seatd, logind and * builtin. * - * To use builtin, the process must have CAP_SYS_ADMIN or be root at the time - * of the call. These privileges can be dropped at any point after the call. + * To use builtin, the process must have permission to open and use the seat's + * devices at the time of the call. In the case of DRM devices, this includes + * permission for drmSetMaster(3). These privileges can be dropped at any + * point after the call. * * The returned pointer must be destroyed with libseat_close_seat. * * Returns a pointer to an opaque libseat struct on success. Returns NULL and * sets errno on error. */ -struct libseat *libseat_open_seat(struct libseat_seat_listener *listener, void *userdata); +struct libseat *libseat_open_seat(const struct libseat_seat_listener *listener, void *userdata); /* * Disables a seat, used in response to a disable_seat event. After disabling @@ -131,7 +135,7 @@ int libseat_get_fd(struct libseat *seat); * milliseconds that might occur. * * Returns a positive number signifying processed internal messages on success. - * Returns 0-if no messages were processed. Returns -1 and sets errno on error. + * Returns 0 if no messages were processed. Returns -1 and sets errno on error. */ int libseat_dispatch(struct libseat *seat, int timeout); diff --git a/include/linked_list.h b/include/linked_list.h index 47cf09b..7a20985 100644 --- a/include/linked_list.h +++ b/include/linked_list.h @@ -12,5 +12,6 @@ void linked_list_init(struct linked_list *list); void linked_list_insert(struct linked_list *list, struct linked_list *elem); void linked_list_remove(struct linked_list *elem); bool linked_list_empty(struct linked_list *list); +void linked_list_take(struct linked_list *target, struct linked_list *source); #endif diff --git a/include/list.h b/include/list.h deleted file mode 100644 index 012f216..0000000 --- a/include/list.h +++ /dev/null @@ -1,23 +0,0 @@ -#ifndef _SEATD_LIST_H -#define _SEATD_LIST_H - -#include - -struct list { - size_t capacity; - size_t length; - void **items; -}; - -void list_init(struct list *); -void list_free(struct list *list); -void list_add(struct list *list, void *item); -void list_insert(struct list *list, size_t index, void *item); -void list_del(struct list *list, size_t index); -void list_concat(struct list *list, const struct list *source); -void list_truncate(struct list *list); -void *list_pop_front(struct list *list); -void *list_pop_back(struct list *list); -size_t list_find(struct list *list, const void *item); - -#endif diff --git a/include/log.h b/include/log.h index 9aee33c..4cf5af3 100644 --- a/include/log.h +++ b/include/log.h @@ -17,31 +17,20 @@ #define __FILENAME__ __FILE__ #endif -#define log_infof(fmt, ...) \ - _logf(LIBSEAT_LOG_LEVEL_INFO, "[%s:%d] %s: " fmt, __FILENAME__, __LINE__, __func__, \ - __VA_ARGS__) +#define log_infof(fmt, ...) \ + _logf(LIBSEAT_LOG_LEVEL_INFO, "[%s:%d] " fmt, __FILENAME__, __LINE__, __VA_ARGS__) -#define log_info(str) \ - _logf(LIBSEAT_LOG_LEVEL_INFO, "[%s:%d] %s: %s", __FILENAME__, __LINE__, __func__, str) +#define log_info(str) _logf(LIBSEAT_LOG_LEVEL_INFO, "[%s:%d] %s", __FILENAME__, __LINE__, str) -#define log_errorf(fmt, ...) \ - _logf(LIBSEAT_LOG_LEVEL_ERROR, "[%s:%d] %s: " fmt, __FILENAME__, __LINE__, __func__, \ - __VA_ARGS__) +#define log_errorf(fmt, ...) \ + _logf(LIBSEAT_LOG_LEVEL_ERROR, "[%s:%d] " fmt, __FILENAME__, __LINE__, __VA_ARGS__) -#define log_error(str) \ - _logf(LIBSEAT_LOG_LEVEL_ERROR, "[%s:%d] %s: %s", __FILENAME__, __LINE__, __func__, str) +#define log_error(str) _logf(LIBSEAT_LOG_LEVEL_ERROR, "[%s:%d] %s", __FILENAME__, __LINE__, str) -#ifdef DEBUG -#define log_debugf(fmt, ...) \ - _logf(LIBSEAT_LOG_LEVEL_DEBUG, "[%s:%d] %s: " fmt, __FILENAME__, __LINE__, __func__, \ - __VA_ARGS__) +#define log_debugf(fmt, ...) \ + _logf(LIBSEAT_LOG_LEVEL_DEBUG, "[%s:%d] " fmt, __FILENAME__, __LINE__, __VA_ARGS__) -#define log_debug(str) \ - _logf(LIBSEAT_LOG_LEVEL_DEBUG, "[%s:%d] %s: %s", __FILENAME__, __LINE__, __func__, str) -#else -#define log_debugf(fmt, ...) -#define log_debug(str) -#endif +#define log_debug(str) _logf(LIBSEAT_LOG_LEVEL_DEBUG, "[%s:%d] %s", __FILENAME__, __LINE__, str) void log_init(void); void _logf(enum libseat_log_level level, const char *fmt, ...) ATTRIB_PRINTF(2, 3); diff --git a/include/poller.h b/include/poller.h index 6b727c4..63733e2 100644 --- a/include/poller.h +++ b/include/poller.h @@ -4,11 +4,7 @@ #include #include -#include "list.h" - -struct poller; -struct event_source_fd; -struct event_source_signal; +#include "linked_list.h" /* * These are the event types available from the poller. @@ -18,6 +14,16 @@ struct event_source_signal; #define EVENT_ERROR 0x8 #define EVENT_HANGUP 0x10 +/** + * The fd poller class. This must be created by poller_add_fd. + */ +struct event_source_fd; + +/* + * The signal poller class. This must be created by poller_add_signal. + */ +struct event_source_signal; + /** * The callback type used by event_source_fd, passed to poller_add_fd. */ @@ -31,21 +37,6 @@ struct event_source_fd_impl { int (*destroy)(struct event_source_fd *event_source); }; -/** - * The fd poller class. This must be created by poller_add_fd. - */ -struct event_source_fd { - const struct event_source_fd_impl *impl; - event_source_fd_func_t func; - - int fd; - uint32_t mask; - void *data; - - struct poller *poller; - bool killed; -}; - /** * Removes the event_source_fd from the poller and frees the structure. */ @@ -68,26 +59,25 @@ struct event_source_signal_impl { int (*destroy)(struct event_source_signal *event_source); }; -/* - * The signal poller class. This must be created by poller_add_signal. - */ -struct event_source_signal { - const struct event_source_signal_impl *impl; - event_source_signal_func_t func; - - int signal; - void *data; - - struct poller *poller; - bool raised; - bool killed; -}; - /** * Removes the event_source_siganl from the poller and frees the structure. */ int event_source_signal_destroy(struct event_source_signal *event_source); +/** + * The poller base class. This must be created by poller_create. + */ +struct poller { + struct linked_list signals; + struct linked_list fds; + + int signal_fds[2]; + struct pollfd *pollfds; + size_t pollfds_len; + size_t fd_event_sources; + bool dirty; +}; + /** * The interface that a poll backend must implement. */ @@ -103,30 +93,11 @@ struct poll_impl { int (*poll)(struct poller *); }; -/** - * The poller base class. This must be created by poller_create. - */ -struct poller { - struct list signals; - struct list new_signals; - struct list fds; - struct list new_fds; - - struct pollfd *pollfds; - size_t pollfds_len; - bool dirty; - bool inpoll; -}; - -/** - * Creates a poller with the best available polling backend. This poller must - * be torn down with poller_destroy when it is no longer needed. - */ /** * Initializes the poller. The poller must be torn down with poller_finish when * it is no longer needed. */ -void poller_init(struct poller *poller); +int poller_init(struct poller *poller); /** * De-initializes the poller. This destroys all remaining event sources and diff --git a/include/protocol.h b/include/protocol.h index 7444b85..25133e5 100644 --- a/include/protocol.h +++ b/include/protocol.h @@ -1,10 +1,10 @@ #ifndef _SEATD_CONSTANTS_H #define _SEATD_CONSTANTS_H -#define MAX_PATH_LEN 256 -#define MAX_SEAT_LEN 64 +#define MAX_PATH_LEN 256 +#define MAX_SEAT_LEN 64 #define MAX_SEAT_DEVICES 128 -#define MAX_SESSION_LEN 64 +#define MAX_SESSION_LEN 64 #define CLIENT_EVENT(opcode) (opcode) #define SERVER_EVENT(opcode) ((opcode) + (1 << 15)) @@ -15,6 +15,7 @@ #define CLIENT_CLOSE_DEVICE CLIENT_EVENT(4) #define CLIENT_DISABLE_SEAT CLIENT_EVENT(5) #define CLIENT_SWITCH_SESSION CLIENT_EVENT(6) +#define CLIENT_PING CLIENT_EVENT(7) #define SERVER_SEAT_OPENED SERVER_EVENT(1) #define SERVER_SEAT_CLOSED SERVER_EVENT(2) @@ -22,7 +23,8 @@ #define SERVER_DEVICE_CLOSED SERVER_EVENT(4) #define SERVER_DISABLE_SEAT SERVER_EVENT(5) #define SERVER_ENABLE_SEAT SERVER_EVENT(6) -#define SERVER_ERROR SERVER_EVENT(0x7FFF) +#define SERVER_PONG SERVER_EVENT(7) +#define SERVER_ERROR SERVER_EVENT(0x7FFF) #include @@ -51,10 +53,7 @@ struct proto_server_seat_opened { struct proto_server_device_opened { int device_id; -}; - -struct proto_server_device_closed { - int device_id; + // One fd in auxillary data }; struct proto_server_error { diff --git a/include/seat.h b/include/seat.h index 60d3b29..ff857e7 100644 --- a/include/seat.h +++ b/include/seat.h @@ -13,6 +13,7 @@ enum seat_device_type { SEAT_DEVICE_TYPE_NORMAL, SEAT_DEVICE_TYPE_EVDEV, SEAT_DEVICE_TYPE_DRM, + SEAT_DEVICE_TYPE_WSCONS, }; struct seat_device { @@ -26,15 +27,15 @@ struct seat_device { }; struct seat { + struct linked_list link; // server::seats char *seat_name; struct linked_list clients; struct client *active_client; struct client *next_client; bool vt_bound; - bool vt_pending_ack; - int next_vt; - int curttyfd; + int cur_vt; + int session_cnt; }; struct seat *seat_create(const char *name, bool vt_bound); @@ -43,7 +44,6 @@ void seat_destroy(struct seat *seat); int seat_add_client(struct seat *seat, struct client *client); int seat_remove_client(struct client *client); int seat_open_client(struct seat *seat, struct client *client); -int seat_close_client(struct client *client); int seat_ack_disable_client(struct client *client); struct seat_device *seat_open_device(struct client *client, const char *path); @@ -51,7 +51,7 @@ int seat_close_device(struct client *client, struct seat_device *seat_device); struct seat_device *seat_find_device(struct client *client, int device_id); int seat_set_next_session(struct client *client, int session); -int seat_activate(struct seat *seat); -int seat_prepare_vt_switch(struct seat *seat); +int seat_vt_activate(struct seat *seat); +int seat_vt_release(struct seat *seat); #endif diff --git a/include/server.h b/include/server.h index a225668..488915c 100644 --- a/include/server.h +++ b/include/server.h @@ -3,7 +3,7 @@ #include -#include "list.h" +#include "linked_list.h" #include "poller.h" struct client; @@ -12,7 +12,8 @@ struct server { bool running; struct poller poller; - struct list seats; + struct linked_list seats; + struct linked_list idle_clients; }; int server_init(struct server *server); diff --git a/include/terminal.h b/include/terminal.h index 1215d8b..fb46ce3 100644 --- a/include/terminal.h +++ b/include/terminal.h @@ -8,7 +8,8 @@ int terminal_open(int vt); int terminal_set_process_switching(int fd, bool enable); int terminal_current_vt(int fd); int terminal_switch_vt(int fd, int vt); -int terminal_ack_switch(int fd); +int terminal_ack_release(int fd); +int terminal_ack_acquire(int fd); int terminal_set_keyboard(int fd, bool enable); int terminal_set_graphics(int fd, bool enable); diff --git a/include/test.h b/include/test.h new file mode 100644 index 0000000..64716cc --- /dev/null +++ b/include/test.h @@ -0,0 +1,23 @@ +#ifndef _TEST_H +#define _TEST_H + +char *__curtestname = ""; + +#define test_run(func) \ + do { \ + char *orig = __curtestname; \ + __curtestname = #func; \ + func(); \ + __curtestname = orig; \ + } while (0) + +#define test_assert(cond) \ + do { \ + if (!(cond)) { \ + fprintf(stderr, "%s:%d: %s: test_assert failed: %s\n", __FILE__, __LINE__, \ + __curtestname, #cond); \ + abort(); \ + } \ + } while (0) + +#endif diff --git a/include/wscons.h b/include/wscons.h new file mode 100644 index 0000000..bf0c10c --- /dev/null +++ b/include/wscons.h @@ -0,0 +1,6 @@ +#ifndef _SEATD_WSCONS_H +#define _SEATD_WSCONS_H + +int path_is_wscons(const char *path); + +#endif diff --git a/libseat/backend/logind.c b/libseat/backend/logind.c index 98d7219..2589e2f 100644 --- a/libseat/backend/logind.c +++ b/libseat/backend/logind.c @@ -13,10 +13,10 @@ #include #include -#if defined(HAVE_ELOGIND) +#if defined(HAVE_LIBELOGIND) #include #include -#elif defined(HAVE_SYSTEMD) +#elif defined(HAVE_LIBSYSTEMD) #include #include #else @@ -28,9 +28,17 @@ #include "libseat.h" #include "log.h" +static int dev_major_is_drm(unsigned int dev_major) { + return dev_major == 226; +} + +static int dev_is_drm(dev_t device) { + return dev_major_is_drm(major(device)); +} + struct backend_logind { struct libseat base; - struct libseat_seat_listener *seat_listener; + const struct libseat_seat_listener *seat_listener; void *seat_listener_data; sd_bus *bus; @@ -39,7 +47,6 @@ struct backend_logind { char *path; char *seat_path; - bool can_graphical; bool active; bool initial_setup; int has_drm; @@ -47,6 +54,7 @@ struct backend_logind { const struct seat_impl logind_impl; static struct backend_logind *backend_logind_from_libseat_backend(struct libseat *base); +static void release_control(struct backend_logind *backend); static void destroy(struct backend_logind *backend) { assert(backend); @@ -62,10 +70,52 @@ static void destroy(struct backend_logind *backend) { static int close_seat(struct libseat *base) { struct backend_logind *backend = backend_logind_from_libseat_backend(base); + release_control(backend); destroy(backend); return 0; } +static int ping_handler(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) { + (void)ret_error; + (void)userdata; + if (sd_bus_message_is_method_error(m, NULL)) { + const sd_bus_error *error = sd_bus_message_get_error(m); + log_errorf("Ping failed: %s: %s", error->name, error->message); + return -1; + } + return 0; +} + +static int send_ping(struct backend_logind *backend) { + int ret = sd_bus_call_method_async(backend->bus, NULL, "org.freedesktop.login1", + "/org/freedesktop/login1", "org.freedesktop.DBus.Peer", + "Ping", ping_handler, backend, ""); + if (ret < 0) { + return ret; + } + return 0; +} + +static void check_pending_events(struct backend_logind *backend) { + uint64_t queued_read, queued_write; + sd_bus_get_n_queued_read(backend->bus, &queued_read); + sd_bus_get_n_queued_write(backend->bus, &queued_write); + + if (queued_read == 0 && queued_write == 0) { + return; + } + + // The sd_bus instance has queued data, so a dispatch is required. + // However, we likely already drained our socket, so there will not be + // anything to read. Instead, send a ping request to logind so that the + // user will be woken up by its response. + int ret = send_ping(backend); + if (ret < 0) { + log_errorf("Could not send ping message: %s", strerror(-ret)); + return; + } +} + static int open_device(struct libseat *base, const char *path, int *fd) { struct backend_logind *session = backend_logind_from_libseat_backend(base); @@ -112,9 +162,11 @@ static int open_device(struct libseat *base, const char *path, int *fd) { } *fd = tmpfd; + out: sd_bus_error_free(&error); sd_bus_message_unref(msg); + check_pending_events(session); return tmpfd; } @@ -130,7 +182,6 @@ static int close_device(struct libseat *base, int device_id) { struct stat st = {0}; if (fstat(fd, &st) < 0) { log_errorf("Could not stat fd %d", fd); - close(fd); return -1; } if (dev_is_drm(st.st_rdev)) { @@ -138,7 +189,6 @@ static int close_device(struct libseat *base, int device_id) { log_debugf("DRM device closed, current total: %d", session->has_drm); assert(session->has_drm >= 0); } - close(fd); sd_bus_message *msg = NULL; sd_bus_error error = SD_BUS_ERROR_NULL; @@ -151,8 +201,8 @@ static int close_device(struct libseat *base, int device_id) { sd_bus_error_free(&error); sd_bus_message_unref(msg); - - return ret >= 0; + check_pending_events(session); + return ret < 0 ? -1 : 0; } static int switch_session(struct libseat *base, int s) { @@ -165,8 +215,7 @@ static int switch_session(struct libseat *base, int s) { sd_bus_message *msg = NULL; sd_bus_error error = SD_BUS_ERROR_NULL; - int ret = sd_bus_call_method(session->bus, "org.freedesktop.login1", - "/org/freedesktop/login1/seat/seat0", + int ret = sd_bus_call_method(session->bus, "org.freedesktop.login1", session->seat_path, "org.freedesktop.login1.Seat", "SwitchTo", &error, &msg, "u", (uint32_t)s); if (ret < 0) { @@ -175,7 +224,8 @@ static int switch_session(struct libseat *base, int s) { sd_bus_error_free(&error); sd_bus_message_unref(msg); - return ret >= 0; + check_pending_events(session); + return ret < 0 ? -1 : 0; } static int disable_seat(struct libseat *base) { @@ -185,7 +235,13 @@ static int disable_seat(struct libseat *base) { static int get_fd(struct libseat *base) { struct backend_logind *backend = backend_logind_from_libseat_backend(base); - return sd_bus_get_fd(backend->bus); + int fd = sd_bus_get_fd(backend->bus); + if (fd >= 0) { + return fd; + } + + errno = -fd; + return -1; } static int poll_connection(struct backend_logind *backend, int timeout) { @@ -209,7 +265,7 @@ static int poll_connection(struct backend_logind *backend, int timeout) { return 0; } -static int dispatch_background(struct libseat *base, int timeout) { +static int dispatch_and_execute(struct libseat *base, int timeout) { struct backend_logind *backend = backend_logind_from_libseat_backend(base); if (backend->initial_setup) { backend->initial_setup = false; @@ -236,15 +292,12 @@ static int dispatch_background(struct libseat *base, int timeout) { total_dispatched += dispatched; } } + check_pending_events(backend); return total_dispatched; } static const char *seat_name(struct libseat *base) { struct backend_logind *backend = backend_logind_from_libseat_backend(base); - - if (backend->seat == NULL) { - return NULL; - } return backend->seat; } @@ -253,10 +306,11 @@ static struct backend_logind *backend_logind_from_libseat_backend(struct libseat return (struct backend_logind *)base; } -static bool session_activate(struct backend_logind *session) { +static int session_activate(struct backend_logind *session) { sd_bus_message *msg = NULL; sd_bus_error error = SD_BUS_ERROR_NULL; + // Note: the Activate call might not make the session active immediately int ret = sd_bus_call_method(session->bus, "org.freedesktop.login1", session->path, "org.freedesktop.login1.Session", "Activate", &error, &msg, ""); if (ret < 0) { @@ -265,10 +319,26 @@ static bool session_activate(struct backend_logind *session) { sd_bus_error_free(&error); sd_bus_message_unref(msg); - return ret >= 0; + return ret; } -static bool take_control(struct backend_logind *session) { +static int session_check_active(struct backend_logind *session) { + sd_bus_error error = SD_BUS_ERROR_NULL; + int active = 0; + int ret = sd_bus_get_property_trivial(session->bus, "org.freedesktop.login1", session->path, + "org.freedesktop.login1.Session", "Active", &error, + 'b', &active); + if (ret < 0) { + log_errorf("Could not check if session is active: %s", error.message); + } else { + session->active = (bool)active; + } + + sd_bus_error_free(&error); + return ret; +} + +static int take_control(struct backend_logind *session) { sd_bus_message *msg = NULL; sd_bus_error error = SD_BUS_ERROR_NULL; @@ -281,7 +351,22 @@ static bool take_control(struct backend_logind *session) { sd_bus_error_free(&error); sd_bus_message_unref(msg); - return ret >= 0; + return ret; +} + +static void release_control(struct backend_logind *session) { + sd_bus_message *msg = NULL; + sd_bus_error error = SD_BUS_ERROR_NULL; + + int ret = sd_bus_call_method(session->bus, "org.freedesktop.login1", session->path, + "org.freedesktop.login1.Session", "ReleaseControl", &error, + &msg, ""); + if (ret < 0) { + log_errorf("Could not release control of session: %s", error.message); + } + + sd_bus_error_free(&error); + sd_bus_message_unref(msg); } static void set_active(struct backend_logind *backend, bool active) { @@ -310,7 +395,7 @@ static int pause_device(sd_bus_message *msg, void *userdata, sd_bus_error *ret_e return 0; } - if (dev_is_drm(makedev(major, minor)) && strcmp(type, "gone") != 0) { + if (dev_major_is_drm(major) && strcmp(type, "gone") != 0) { log_debugf("DRM device paused: %s", type); assert(session->has_drm > 0); set_active(session, false); @@ -342,7 +427,7 @@ static int resume_device(sd_bus_message *msg, void *userdata, sd_bus_error *ret_ return 0; } - if (dev_is_drm(makedev(major, minor))) { + if (dev_major_is_drm(major)) { log_debug("DRM device resumed"); assert(session->has_drm > 0); set_active(session, true); @@ -387,8 +472,7 @@ static int properties_changed(sd_bus_message *msg, void *userdata, sd_bus_error goto error; } - if ((is_session && strcmp(s, "Active") == 0) || - (is_seat && strcmp(s, "CanGraphical"))) { + if (is_session && strcmp(s, "Active") == 0) { int ret; ret = sd_bus_message_enter_container(msg, 'v', "b"); if (ret < 0) { @@ -402,11 +486,7 @@ static int properties_changed(sd_bus_message *msg, void *userdata, sd_bus_error } log_debugf("%s state changed: %d", s, value); - if (is_session) { - set_active(session, value); - } else { - session->can_graphical = value; - } + set_active(session, value); return 0; } else { sd_bus_message_skip(msg, "{sv}"); @@ -430,12 +510,10 @@ static int properties_changed(sd_bus_message *msg, void *userdata, sd_bus_error // PropertiesChanged arg 3: changed properties without values sd_bus_message_enter_container(msg, 'a', "s"); while ((ret = sd_bus_message_read_basic(msg, 's', &s)) > 0) { - if ((is_session && strcmp(s, "Active") == 0) || - (is_seat && strcmp(s, "CanGraphical"))) { + if (is_session && strcmp(s, "Active") == 0) { sd_bus_error error = SD_BUS_ERROR_NULL; - const char *obj = is_session ? "org.freedesktop.login1.Session" - : "org.freedesktop.login1.Seat"; - const char *field = is_session ? "Active" : "CanGraphical"; + const char *obj = "org.freedesktop.login1.Session"; + const char *field = "Active"; bool value; ret = sd_bus_get_property_trivial(session->bus, "org.freedesktop.login1", session->path, obj, field, &error, 'b', @@ -446,11 +524,7 @@ static int properties_changed(sd_bus_message *msg, void *userdata, sd_bus_error } log_debugf("%s state changed: %d", field, value); - if (is_session) { - set_active(session, value); - } else { - session->can_graphical = value; - } + set_active(session, value); return 0; } } @@ -463,7 +537,7 @@ error: return 0; } -static bool add_signal_matches(struct backend_logind *backend) { +static int add_signal_matches(struct backend_logind *backend) { static const char *logind = "org.freedesktop.login1"; static const char *session_interface = "org.freedesktop.login1.Session"; static const char *property_interface = "org.freedesktop.DBus.Properties"; @@ -473,34 +547,34 @@ static bool add_signal_matches(struct backend_logind *backend) { "PauseDevice", pause_device, backend); if (ret < 0) { log_errorf("Could not add D-Bus match: %s", strerror(-ret)); - return false; + return ret; } ret = sd_bus_match_signal(backend->bus, NULL, logind, backend->path, session_interface, "ResumeDevice", resume_device, backend); if (ret < 0) { log_errorf("Could not add D-Bus match: %s", strerror(-ret)); - return false; + return ret; } ret = sd_bus_match_signal(backend->bus, NULL, logind, backend->path, property_interface, "PropertiesChanged", properties_changed, backend); if (ret < 0) { log_errorf("Could not add D-Bus match: %s", strerror(-ret)); - return false; + return ret; } ret = sd_bus_match_signal(backend->bus, NULL, logind, backend->seat_path, property_interface, "PropertiesChanged", properties_changed, backend); if (ret < 0) { log_errorf("Could not add D-Bus match: %s", strerror(-ret)); - return false; + return ret; } - return true; + return 0; } -static bool find_session_path(struct backend_logind *session) { +static int find_session_path(struct backend_logind *session) { int ret; sd_bus_message *msg = NULL; sd_bus_error error = SD_BUS_ERROR_NULL; @@ -525,10 +599,10 @@ out: sd_bus_error_free(&error); sd_bus_message_unref(msg); - return ret >= 0; + return ret; } -static bool find_seat_path(struct backend_logind *session) { +static int find_seat_path(struct backend_logind *session) { int ret; sd_bus_message *msg = NULL; sd_bus_error error = SD_BUS_ERROR_NULL; @@ -553,10 +627,10 @@ out: sd_bus_error_free(&error); sd_bus_message_unref(msg); - return ret >= 0; + return ret; } -static bool get_display_session(char **session_id) { +static int get_display_session(char **session_id) { assert(session_id != NULL); char *xdg_session_id = getenv("XDG_SESSION_ID"); int ret; @@ -589,12 +663,12 @@ static bool get_display_session(char **session_id) { success: assert(*session_id != NULL); - return true; + return 0; error: free(*session_id); *session_id = NULL; - return false; + return ret; } static int set_type(struct backend_logind *backend, const char *type) { @@ -613,17 +687,19 @@ static int set_type(struct backend_logind *backend, const char *type) { return ret; } -static struct libseat *logind_open_seat(struct libseat_seat_listener *listener, void *data) { +static struct libseat *logind_open_seat(const struct libseat_seat_listener *listener, void *data) { struct backend_logind *backend = calloc(1, sizeof(struct backend_logind)); if (backend == NULL) { return NULL; } - if (!get_display_session(&backend->id)) { + int ret; + ret = get_display_session(&backend->id); + if (ret < 0) { goto error; } - int ret = sd_session_get_seat(backend->id, &backend->seat); + ret = sd_session_get_seat(backend->id, &backend->seat); if (ret < 0) { goto error; } @@ -633,32 +709,34 @@ static struct libseat *logind_open_seat(struct libseat_seat_listener *listener, goto error; } - if (!find_session_path(backend)) { + ret = find_session_path(backend); + if (ret < 0) { goto error; } - if (!find_seat_path(backend)) { + ret = find_seat_path(backend); + if (ret < 0) { goto error; } - if (!add_signal_matches(backend)) { + ret = add_signal_matches(backend); + if (ret < 0) { goto error; } - if (!session_activate(backend)) { + ret = session_activate(backend); + if (ret < 0) { goto error; } - if (!take_control(backend)) { + ret = session_check_active(backend); + if (ret < 0) { goto error; } - backend->can_graphical = sd_seat_can_graphical(backend->seat); - while (!backend->can_graphical) { - if (poll_connection(backend, -1) == -1) { - log_errorf("Could not poll connection: %s", strerror(errno)); - goto error; - } + ret = take_control(backend); + if (ret < 0) { + goto error; } const char *env = getenv("XDG_SESSION_TYPE"); @@ -667,17 +745,16 @@ static struct libseat *logind_open_seat(struct libseat_seat_listener *listener, } backend->initial_setup = true; - backend->active = true; backend->seat_listener = listener; backend->seat_listener_data = data; backend->base.impl = &logind_impl; + check_pending_events(backend); return &backend->base; error: - if (backend != NULL) { - destroy(backend); - } + destroy(backend); + errno = -ret; return NULL; } @@ -690,5 +767,5 @@ const struct seat_impl logind_impl = { .close_device = close_device, .switch_session = switch_session, .get_fd = get_fd, - .dispatch = dispatch_background, + .dispatch = dispatch_and_execute, }; diff --git a/libseat/backend/noop.c b/libseat/backend/noop.c new file mode 100644 index 0000000..18f26c3 --- /dev/null +++ b/libseat/backend/noop.c @@ -0,0 +1,136 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "backend.h" +#include "log.h" + +struct backend_noop { + struct libseat base; + const struct libseat_seat_listener *seat_listener; + void *seat_listener_data; + + bool initial_setup; + int sockets[2]; +}; + +extern const struct seat_impl noop_impl; + +static struct backend_noop *backend_noop_from_libseat_backend(struct libseat *base) { + assert(base->impl == &noop_impl); + return (struct backend_noop *)base; +} + +static void destroy(struct backend_noop *backend) { + close(backend->sockets[0]); + close(backend->sockets[1]); + free(backend); +} + +static int close_seat(struct libseat *base) { + struct backend_noop *backend = backend_noop_from_libseat_backend(base); + destroy(backend); + return 0; +} + +static int disable_seat(struct libseat *base) { + (void)base; + return 0; +} + +static const char *seat_name(struct libseat *base) { + (void)base; + return "seat0"; +} + +static int open_device(struct libseat *base, const char *path, int *fd) { + (void)base; + + int tmpfd = open(path, O_RDWR | O_NOCTTY | O_NOFOLLOW | O_CLOEXEC | O_NONBLOCK); + if (tmpfd < 0) { + log_errorf("Failed to open device: %s", strerror(errno)); + return -1; + } + + *fd = tmpfd; + return tmpfd; +} + +static int close_device(struct libseat *base, int device_id) { + (void)base; + (void)device_id; + return 0; +} + +static int switch_session(struct libseat *base, int s) { + (void)base; + (void)s; + log_errorf("No-op backend cannot switch to session %d", s); + return -1; +} + +static int get_fd(struct libseat *base) { + struct backend_noop *backend = backend_noop_from_libseat_backend(base); + return backend->sockets[0]; +} + +static int dispatch_background(struct libseat *base, int timeout) { + struct backend_noop *backend = backend_noop_from_libseat_backend(base); + + if (backend->initial_setup) { + backend->initial_setup = false; + backend->seat_listener->enable_seat(&backend->base, backend->seat_listener_data); + } + + struct pollfd fd = { + .fd = backend->sockets[0], + .events = POLLIN, + }; + if (poll(&fd, 1, timeout) < 0) { + if (errno == EAGAIN || errno == EINTR) { + return 0; + } else { + return -1; + } + } + + return 0; +} + +static struct libseat *noop_open_seat(const struct libseat_seat_listener *listener, void *data) { + struct backend_noop *backend = calloc(1, sizeof(struct backend_noop)); + if (backend == NULL) { + return NULL; + } + + if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, backend->sockets) != 0) { + log_errorf("socketpair() failed: %s", strerror(errno)); + free(backend); + return NULL; + } + + backend->initial_setup = true; + backend->seat_listener = listener; + backend->seat_listener_data = data; + backend->base.impl = &noop_impl; + + return &backend->base; +} + +const struct seat_impl noop_impl = { + .open_seat = noop_open_seat, + .disable_seat = disable_seat, + .close_seat = close_seat, + .seat_name = seat_name, + .open_device = open_device, + .close_device = close_device, + .switch_session = switch_session, + .get_fd = get_fd, + .dispatch = dispatch_background, +}; diff --git a/libseat/backend/seatd.c b/libseat/backend/seatd.c index 413282e..abcd2a5 100644 --- a/libseat/backend/seatd.c +++ b/libseat/backend/seatd.c @@ -33,45 +33,38 @@ struct pending_event { struct backend_seatd { struct libseat base; struct connection connection; - struct libseat_seat_listener *seat_listener; + const struct libseat_seat_listener *seat_listener; void *seat_listener_data; struct linked_list pending_events; + bool awaiting_pong; + bool error; char seat_name[MAX_SEAT_LEN]; }; -static int set_nonblock(int fd) { - int flags; - if ((flags = fcntl(fd, F_GETFD)) == -1 || fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) { - return -1; - } - if ((flags = fcntl(fd, F_GETFL)) == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) { - return -1; - } - return 0; -} - static int seatd_connect(void) { union { struct sockaddr_un unix; struct sockaddr generic; } addr = {{0}}; - int fd = socket(AF_UNIX, SOCK_STREAM, 0); + int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0); if (fd == -1) { + log_errorf("Could not create socket: %s", strerror(errno)); return -1; } - if (set_nonblock(fd) == -1) { - close(fd); - return -1; - } - char *path = getenv("SEATD_SOCK"); + const char *path = getenv("SEATD_SOCK"); if (path == NULL) { - path = "/run/seatd.sock"; + path = SEATD_DEFAULTPATH; } addr.unix.sun_family = AF_UNIX; - strncpy(addr.unix.sun_path, path, sizeof addr.unix.sun_path); + strncpy(addr.unix.sun_path, path, sizeof addr.unix.sun_path - 1); socklen_t size = offsetof(struct sockaddr_un, sun_path) + strlen(addr.unix.sun_path); if (connect(fd, &addr.generic, size) == -1) { + if (errno == ENOENT) { + log_infof("Could not connect to socket %s: %s", path, strerror(errno)); + } else { + log_errorf("Could not connect to socket %s: %s", path, strerror(errno)); + } close(fd); return -1; }; @@ -88,35 +81,87 @@ static struct backend_seatd *backend_seatd_from_libseat_backend(struct libseat * return (struct backend_seatd *)base; } -static void handle_enable_seat(struct backend_seatd *backend) { - log_info("Enabling seat"); - if (backend->seat_listener != NULL && backend->seat_listener->enable_seat != NULL) { - backend->seat_listener->enable_seat(&backend->base, backend->seat_listener_data); +static void cleanup(struct backend_seatd *backend) { + if (backend->connection.fd != -1) { + close(backend->connection.fd); + backend->connection.fd = -1; + } + connection_close_fds(&backend->connection); + while (!linked_list_empty(&backend->pending_events)) { + struct pending_event *ev = (struct pending_event *)backend->pending_events.next; + linked_list_remove(&ev->link); + free(ev); } } -static void handle_disable_seat(struct backend_seatd *backend) { - log_info("Disabling seat"); - if (backend->seat_listener != NULL && backend->seat_listener->disable_seat != NULL) { - backend->seat_listener->disable_seat(&backend->base, backend->seat_listener_data); - } +static void destroy(struct backend_seatd *backend) { + cleanup(backend); + free(backend); } -static size_t read_header(struct connection *connection, uint16_t expected_opcode) { +static void set_error(struct backend_seatd *backend) { + if (backend->error) { + return; + } + + backend->error = true; + cleanup(backend); +} + +static inline int conn_put(struct backend_seatd *backend, const void *data, const size_t data_len) { + if (connection_put(&backend->connection, data, data_len) == -1) { + log_errorf("Could not send request: %s", strerror(errno)); + set_error(backend); + return -1; + } + return 0; +} + +static inline int conn_flush(struct backend_seatd *backend) { + if (connection_flush(&backend->connection) == -1) { + log_errorf("Could not flush connection: %s", strerror(errno)); + set_error(backend); + return -1; + } + return 0; +} + +static inline int conn_get(struct backend_seatd *backend, void *target, const size_t target_len) { + if (connection_get(&backend->connection, target, target_len) == -1) { + log_error("Invalid message: insufficient data received"); + set_error(backend); + errno = EBADMSG; + return -1; + } + return 0; +} + +static inline int conn_get_fd(struct backend_seatd *backend, int *fd) { + if (connection_get_fd(&backend->connection, fd) == -1) { + log_error("Invalid message: insufficient data received"); + set_error(backend); + errno = EBADMSG; + return -1; + } + return 0; +} + +static size_t read_header(struct backend_seatd *backend, uint16_t expected_opcode, + size_t expected_size, bool variable) { struct proto_header header; - if (connection_get(connection, &header, sizeof header) == -1) { - log_error("Received invalid message: header too short"); + if (conn_get(backend, &header, sizeof header) == -1) { + set_error(backend); return SIZE_MAX; } if (header.opcode != expected_opcode) { - connection_restore(connection, sizeof header); struct proto_server_error msg; if (header.opcode != SERVER_ERROR) { - log_errorf("Received invalid message: expected opcode %d, received opcode %d", + log_errorf("Unexpected response: expected opcode %d, received opcode %d", expected_opcode, header.opcode); + set_error(backend); errno = EBADMSG; - } else if (connection_get(connection, &msg, sizeof msg) == -1) { - log_error("Received invalid message"); + } else if (header.size != sizeof msg || conn_get(backend, &msg, sizeof msg) == -1) { + set_error(backend); errno = EBADMSG; } else { errno = msg.error_code; @@ -124,12 +169,20 @@ static size_t read_header(struct connection *connection, uint16_t expected_opcod return SIZE_MAX; } + if ((!variable && header.size != expected_size) || (variable && header.size < expected_size)) { + log_errorf("Invalid message: does not match expected size: variable: %d, header.size: %d, expected size: %zd", + variable, header.size, expected_size); + set_error(backend); + errno = EBADMSG; + return SIZE_MAX; + } return header.size; } static int queue_event(struct backend_seatd *backend, int opcode) { struct pending_event *ev = calloc(1, sizeof(struct pending_event)); if (ev == NULL) { + log_errorf("Allocation failed: %s", strerror(errno)); return -1; } @@ -138,15 +191,11 @@ static int queue_event(struct backend_seatd *backend, int opcode) { return 0; } -static void execute_events(struct backend_seatd *backend) { - struct linked_list list = { - .next = backend->pending_events.next, - .prev = backend->pending_events.prev, - }; - list.next->prev = &list; - list.prev->next = &list; - - linked_list_init(&backend->pending_events); +static int execute_events(struct backend_seatd *backend) { + struct linked_list list; + linked_list_init(&list); + linked_list_take(&list, &backend->pending_events); + int executed = 0; while (!linked_list_empty(&list)) { struct pending_event *ev = (struct pending_event *)list.next; int opcode = ev->opcode; @@ -155,15 +204,22 @@ static void execute_events(struct backend_seatd *backend) { switch (opcode) { case SERVER_DISABLE_SEAT: - handle_disable_seat(backend); + log_info("Disabling seat"); + backend->seat_listener->disable_seat(&backend->base, + backend->seat_listener_data); break; case SERVER_ENABLE_SEAT: - handle_enable_seat(backend); + log_info("Enabling seat"); + backend->seat_listener->enable_seat(&backend->base, + backend->seat_listener_data); break; default: + log_errorf("Invalid opcode: %d", opcode); abort(); } + executed++; } + return executed; } static int dispatch_pending(struct backend_seatd *backend, int *opcode) { @@ -172,9 +228,16 @@ static int dispatch_pending(struct backend_seatd *backend, int *opcode) { while (connection_get(&backend->connection, &header, sizeof header) != -1) { packets++; switch (header.opcode) { + case SERVER_PONG: + // We care about whether or not the answer has been + // read from the connection, so handle it here instead + // of pushing it to the pending event list. + backend->awaiting_pong = false; + break; case SERVER_DISABLE_SEAT: case SERVER_ENABLE_SEAT: if (queue_event(backend, header.opcode) == -1) { + set_error(backend); return -1; } break; @@ -190,6 +253,15 @@ static int dispatch_pending(struct backend_seatd *backend, int *opcode) { return packets; } +static int dispatch_pending_and_execute(struct backend_seatd *backend) { + int dispatched = dispatch_pending(backend, NULL); + if (dispatched == -1) { + return -1; + } + dispatched += execute_events(backend); + return dispatched; +} + static int poll_connection(struct backend_seatd *backend, int timeout) { struct pollfd fd = { .fd = backend->connection.fd, @@ -220,20 +292,23 @@ static int poll_connection(struct backend_seatd *backend, int timeout) { } static int dispatch(struct backend_seatd *backend) { - if (connection_flush(&backend->connection) == -1) { - log_errorf("Could not flush connection: %s", strerror(errno)); + if (conn_flush(backend) == -1) { return -1; } - int opcode = 0, res = 0; - while ((res = dispatch_pending(backend, &opcode)) == 0 && opcode == 0) { + while (true) { + int opcode = 0; + if (dispatch_pending(backend, &opcode) == -1) { + log_errorf("Could not dispatch pending messages: %s", strerror(errno)); + return -1; + } + if (opcode != 0) { + break; + } if (poll_connection(backend, -1) == -1) { log_errorf("Could not poll connection: %s", strerror(errno)); return -1; } } - if (res == -1) { - return -1; - } return 0; } @@ -242,52 +317,52 @@ static int get_fd(struct libseat *base) { return backend->connection.fd; } -static int dispatch_background(struct libseat *base, int timeout) { +static int dispatch_and_execute(struct libseat *base, int timeout) { struct backend_seatd *backend = backend_seatd_from_libseat_backend(base); - int dispatched = dispatch_pending(backend, NULL); - if (dispatched > 0) { - // We don't want to block if we dispatched something, as the - // caller might be waiting for the result. However, we'd also - // like to read anything pending. - timeout = 0; + if (backend->error) { + errno = ENOTCONN; + return -1; } + + int predispatch = dispatch_pending_and_execute(backend); + if (predispatch == -1) { + return -1; + } + + // We don't want to block if we dispatched something, as the + // caller might be waiting for the result. However, we'd also + // like to read anything pending. int read = 0; - if (timeout == 0) { + if (predispatch > 0 || timeout == 0) { read = connection_read(&backend->connection); } else { read = poll_connection(backend, timeout); } - if (read > 0) { - dispatched += dispatch_pending(backend, NULL); + + if (read == 0) { + return predispatch; } else if (read == -1 && errno != EAGAIN) { log_errorf("Could not read from connection: %s", strerror(errno)); return -1; } - execute_events(backend); - return dispatched; + int postdispatch = dispatch_pending_and_execute(backend); + if (postdispatch == -1) { + return -1; + } + + return predispatch + postdispatch; } -static void destroy(struct backend_seatd *backend) { - if (backend->connection.fd != -1) { - close(backend->connection.fd); - backend->connection.fd = -1; - } - connection_close_fds(&backend->connection); - while (!linked_list_empty(&backend->pending_events)) { - struct pending_event *ev = (struct pending_event *)backend->pending_events.next; - linked_list_remove(&ev->link); - free(ev); - } - free(backend); -} - -static struct libseat *_open_seat(struct libseat_seat_listener *listener, void *data, int fd) { +static struct libseat *_open_seat(const struct libseat_seat_listener *listener, void *data, int fd) { + assert(listener != NULL); + assert(listener->enable_seat != NULL && listener->disable_seat != NULL); struct backend_seatd *backend = calloc(1, sizeof(struct backend_seatd)); if (backend == NULL) { - close(fd); - return NULL; + log_errorf("Allocation failed: %s", strerror(errno)); + goto alloc_error; } + backend->seat_listener = listener; backend->seat_listener_data = data; backend->connection.fd = fd; @@ -298,46 +373,36 @@ static struct libseat *_open_seat(struct libseat_seat_listener *listener, void * .opcode = CLIENT_OPEN_SEAT, .size = 0, }; - - if (connection_put(&backend->connection, &header, sizeof header) == -1 || - dispatch(backend) == -1) { - destroy(backend); - return NULL; - } - - size_t size = read_header(&backend->connection, SERVER_SEAT_OPENED); - if (size == SIZE_MAX) { - destroy(backend); - return NULL; + if (conn_put(backend, &header, sizeof header) == -1 || dispatch(backend) == -1) { + goto backend_error; } struct proto_server_seat_opened rmsg; - if (sizeof rmsg > size) { - goto badmsg_error; + size_t size = read_header(backend, SERVER_SEAT_OPENED, sizeof rmsg, true); + if (size == SIZE_MAX || conn_get(backend, &rmsg, sizeof rmsg) == -1) { + goto backend_error; + } + if (rmsg.seat_name_len != size - sizeof rmsg) { + log_errorf("Invalid message: seat_name_len does not match remaining message size (%d != %zd)", + rmsg.seat_name_len, size); + errno = EBADMSG; + goto backend_error; + } + if (conn_get(backend, backend->seat_name, rmsg.seat_name_len) == -1) { + goto backend_error; } - if (connection_get(&backend->connection, &rmsg, sizeof rmsg) == -1) { - goto badmsg_error; - }; - - if (sizeof rmsg + rmsg.seat_name_len > size || - rmsg.seat_name_len >= sizeof backend->seat_name) { - goto badmsg_error; - } - - if (connection_get(&backend->connection, backend->seat_name, rmsg.seat_name_len) == -1) { - goto badmsg_error; - }; - + execute_events(backend); return &backend->base; -badmsg_error: - log_error("Received invalid message"); - errno = EBADMSG; +backend_error: + destroy(backend); +alloc_error: + close(fd); return NULL; } -static struct libseat *open_seat(struct libseat_seat_listener *listener, void *data) { +static struct libseat *open_seat(const struct libseat_seat_listener *listener, void *data) { int fd = seatd_connect(); if (fd == -1) { return NULL; @@ -353,21 +418,22 @@ static int close_seat(struct libseat *base) { .opcode = CLIENT_CLOSE_SEAT, .size = 0, }; - - if (connection_put(&backend->connection, &header, sizeof header) == -1 || - dispatch(backend) == -1) { - destroy(backend); - return -1; + if (conn_put(backend, &header, sizeof header) == -1 || dispatch(backend) == -1) { + goto error; } - size_t size = read_header(&backend->connection, SERVER_SEAT_CLOSED); - if (size == SIZE_MAX) { - destroy(backend); - return -1; + if (read_header(backend, SERVER_SEAT_CLOSED, 0, false) == SIZE_MAX) { + goto error; } + execute_events(backend); destroy(backend); return 0; + +error: + execute_events(backend); + destroy(backend); + return -1; } static const char *seat_name(struct libseat *base) { @@ -375,9 +441,42 @@ static const char *seat_name(struct libseat *base) { return backend->seat_name; } +static int send_ping(struct backend_seatd *backend) { + struct proto_header header = { + .opcode = CLIENT_PING, + .size = 0, + }; + if (conn_put(backend, &header, sizeof header) == -1 || conn_flush(backend) == -1) { + return -1; + } + return 0; +} + +static void check_pending_events(struct backend_seatd *backend) { + if (linked_list_empty(&backend->pending_events)) { + return; + } + if (backend->awaiting_pong) { + return; + } + + // We have events pending execution, so a dispatch is required. + // However, we likely already drained our socket, so there will not be + // anything to read. Instead, send a ping request to seatd, so that the + // user will be woken up by its response. + if (send_ping(backend) == -1) { + log_errorf("Could not send ping request: %s", strerror(errno)); + return; + } + backend->awaiting_pong = true; +} + static int open_device(struct libseat *base, const char *path, int *fd) { struct backend_seatd *backend = backend_seatd_from_libseat_backend(base); - + if (backend->error) { + errno = ENOTCONN; + return -1; + } size_t pathlen = strlen(path) + 1; if (pathlen > MAX_PATH_LEN) { errno = EINVAL; @@ -391,42 +490,32 @@ static int open_device(struct libseat *base, const char *path, int *fd) { .opcode = CLIENT_OPEN_DEVICE, .size = sizeof msg + pathlen, }; - - if (connection_put(&backend->connection, &header, sizeof header) == -1 || - connection_put(&backend->connection, &msg, sizeof msg) == -1 || - connection_put(&backend->connection, path, pathlen) == -1 || dispatch(backend) == -1) { - return -1; - } - - size_t size = read_header(&backend->connection, SERVER_DEVICE_OPENED); - if (size == SIZE_MAX) { - return -1; + if (conn_put(backend, &header, sizeof header) == -1 || + conn_put(backend, &msg, sizeof msg) == -1 || conn_put(backend, path, pathlen) == -1 || + dispatch(backend) == -1) { + goto error; } struct proto_server_device_opened rmsg; - if (sizeof rmsg > size) { - goto badmsg_error; - } - if (connection_get(&backend->connection, &rmsg, sizeof rmsg) == -1) { - goto badmsg_error; + if (read_header(backend, SERVER_DEVICE_OPENED, sizeof rmsg, false) == SIZE_MAX || + conn_get(backend, &rmsg, sizeof rmsg) == -1 || conn_get_fd(backend, fd)) { + goto error; } - int received_fd = connection_get_fd(&backend->connection); - if (received_fd == -1) { - goto badmsg_error; - } - - *fd = received_fd; + check_pending_events(backend); return rmsg.device_id; -badmsg_error: - log_error("Received invalid message"); - errno = EBADMSG; +error: + check_pending_events(backend); return -1; } static int close_device(struct libseat *base, int device_id) { struct backend_seatd *backend = backend_seatd_from_libseat_backend(base); + if (backend->error) { + errno = ENOTCONN; + return -1; + } if (device_id < 0) { errno = EINVAL; return -1; @@ -439,38 +528,29 @@ static int close_device(struct libseat *base, int device_id) { .opcode = CLIENT_CLOSE_DEVICE, .size = sizeof msg, }; - - if (connection_put(&backend->connection, &header, sizeof header) == -1 || - connection_put(&backend->connection, &msg, sizeof msg) == -1 || dispatch(backend) == -1) { - return -1; + if (conn_put(backend, &header, sizeof header) == -1 || + conn_put(backend, &msg, sizeof msg) == -1 || dispatch(backend) == -1) { + goto error; } - size_t size = read_header(&backend->connection, SERVER_DEVICE_CLOSED); - if (size == SIZE_MAX) { - return -1; - } - - struct proto_server_device_closed rmsg; - if (sizeof rmsg > size) { - goto badmsg_error; - } - if (connection_get(&backend->connection, &rmsg, sizeof rmsg) == -1) { - goto badmsg_error; - } - if (rmsg.device_id != device_id) { - goto badmsg_error; + if (read_header(backend, SERVER_DEVICE_CLOSED, 0, false) == SIZE_MAX) { + goto error; } + check_pending_events(backend); return 0; -badmsg_error: - log_error("Received invalid message"); - errno = EBADMSG; +error: + check_pending_events(backend); return -1; } static int switch_session(struct libseat *base, int session) { struct backend_seatd *backend = backend_seatd_from_libseat_backend(base); + if (backend->error) { + errno = ENOTCONN; + return -1; + } if (session < 0) { return -1; } @@ -482,10 +562,8 @@ static int switch_session(struct libseat *base, int session) { .opcode = CLIENT_SWITCH_SESSION, .size = sizeof msg, }; - - if (connection_put(&backend->connection, &header, sizeof header) == -1 || - connection_put(&backend->connection, &msg, sizeof msg) == -1 || - connection_flush(&backend->connection) == -1) { + if (conn_put(backend, &header, sizeof header) == -1 || + conn_put(backend, &msg, sizeof msg) == -1 || conn_flush(backend) == -1) { return -1; } @@ -494,13 +572,15 @@ static int switch_session(struct libseat *base, int session) { static int disable_seat(struct libseat *base) { struct backend_seatd *backend = backend_seatd_from_libseat_backend(base); + if (backend->error) { + errno = ENOTCONN; + return -1; + } struct proto_header header = { .opcode = CLIENT_DISABLE_SEAT, .size = 0, }; - - if (connection_put(&backend->connection, &header, sizeof header) == -1 || - connection_flush(&backend->connection) == -1) { + if (conn_put(backend, &header, sizeof header) == -1 || conn_flush(backend) == -1) { return -1; } @@ -516,33 +596,14 @@ const struct seat_impl seatd_impl = { .close_device = close_device, .switch_session = switch_session, .get_fd = get_fd, - .dispatch = dispatch_background, + .dispatch = dispatch_and_execute, }; #ifdef BUILTIN_ENABLED -#include -static int set_deathsig(int signal); - -#if defined(__linux__) -#include - -static int set_deathsig(int signal) { - return prctl(PR_SET_PDEATHSIG, signal); -} -#elif defined(__FreeBSD__) -#include - -static int set_deathsig(int signal) { - return procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signal); -} -#else -#error Unsupported platform -#endif - -static struct libseat *builtin_open_seat(struct libseat_seat_listener *listener, void *data) { +static struct libseat *builtin_open_seat(const struct libseat_seat_listener *listener, void *data) { int fds[2]; - if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1) { + if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, fds) == -1) { log_errorf("Could not create socket pair: %s", strerror(errno)); return NULL; } @@ -554,6 +615,7 @@ static struct libseat *builtin_open_seat(struct libseat_seat_listener *listener, close(fds[1]); return NULL; } else if (pid == 0) { + close(fds[1]); int fd = fds[0]; int res = 0; struct server server = {0}; @@ -568,20 +630,22 @@ static struct libseat *builtin_open_seat(struct libseat_seat_listener *listener, res = 1; goto server_error; } - set_deathsig(SIGTERM); + log_info("Started embedded seatd"); while (server.running) { if (poller_poll(&server.poller) == -1) { log_errorf("Could not poll server socket: %s", strerror(errno)); res = 1; - goto server_error; + break; } } server_error: server_finish(&server); error: close(fd); + log_info("Stopped embedded seatd"); exit(res); } else { + close(fds[0]); int fd = fds[1]; return _open_seat(listener, data, fd); } @@ -596,6 +660,6 @@ const struct seat_impl builtin_impl = { .close_device = close_device, .switch_session = switch_session, .get_fd = get_fd, - .dispatch = dispatch_background, + .dispatch = dispatch_and_execute, }; #endif diff --git a/libseat/libseat.c b/libseat/libseat.c index d7ab361..8cc9ab2 100644 --- a/libseat/libseat.c +++ b/libseat/libseat.c @@ -13,6 +13,7 @@ extern const struct seat_impl seatd_impl; extern const struct seat_impl logind_impl; extern const struct seat_impl builtin_impl; +extern const struct seat_impl noop_impl; static const struct named_backend impls[] = { #ifdef SEATD_ENABLED @@ -24,6 +25,8 @@ static const struct named_backend impls[] = { #ifdef BUILTIN_ENABLED {"builtin", &builtin_impl}, #endif + {"noop", &noop_impl}, + {NULL, NULL}, }; @@ -31,8 +34,8 @@ static const struct named_backend impls[] = { #error At least one backend must be enabled #endif -struct libseat *libseat_open_seat(struct libseat_seat_listener *listener, void *data) { - if (listener == NULL) { +struct libseat *libseat_open_seat(const struct libseat_seat_listener *listener, void *data) { + if (listener == NULL || listener->enable_seat == NULL || listener->disable_seat == NULL) { errno = EINVAL; return NULL; } @@ -40,22 +43,42 @@ struct libseat *libseat_open_seat(struct libseat_seat_listener *listener, void * log_init(); char *backend_type = getenv("LIBSEAT_BACKEND"); + if (backend_type != NULL) { + const struct named_backend *iter = impls; + while (iter->backend != NULL && strcmp(backend_type, iter->name) != 0) { + iter++; + } + if (iter == NULL || iter->backend == NULL) { + log_errorf("No backend matched name '%s'", backend_type); + errno = EINVAL; + return NULL; + } + struct libseat *backend = iter->backend->open_seat(listener, data); + if (backend == NULL) { + log_errorf("Backend '%s' failed to open seat: %s", iter->name, + strerror(errno)); + return NULL; + } + log_infof("Seat opened with backend '%s'", iter->name); + return backend; + } + struct libseat *backend = NULL; for (const struct named_backend *iter = impls; iter->backend != NULL; iter++) { - if (backend_type != NULL && strcmp(backend_type, iter->name) != 0) { + if (iter->backend == &noop_impl) { continue; } - log_infof("Trying backend '%s'", iter->name); backend = iter->backend->open_seat(listener, data); if (backend != NULL) { log_infof("Seat opened with backend '%s'", iter->name); - break; + return backend; } + log_infof("Backend '%s' failed to open seat, skipping", iter->name); } - if (backend == NULL) { - errno = ENOSYS; - } - return backend; + + log_error("No backend was able to open a seat"); + errno = ENOSYS; + return NULL; } int libseat_disable_seat(struct libseat *seat) { diff --git a/man/seatd-launch.1.scd b/man/seatd-launch.1.scd new file mode 100644 index 0000000..73d302d --- /dev/null +++ b/man/seatd-launch.1.scd @@ -0,0 +1,58 @@ +seatd-launch(1) + +# NAME + +seatd-launch - Start a process with its own seatd instance + +# SYNOPSIS + +*seatd-launch* [options] [--] command + +# OPTIONS + +*-l * + Log-level to pass to seatd. See *seatd*(1) for information about + available log-levels. + +*-h* + Show help message and quit. + +*-v* + Show the version number and quit. + +# DESCRIPTION + +seatd-launch starts a seatd instance with a dedicated socket path, waits for it +to be ready, and starts the specified command with SEATD_SOCK set +appropriately. Once the specified command terminates, the seatd instance is +also terminated. + +seatd requires root privileges to perform its tasks. This can be achieved +through SUID of seatd-launch or by running seatd-launch as root. seatd-launch +will drop privileges from the effective user to the real user before running +the specified command. If the real user is root, this is simply a noop. You +should only run seatd-launch as root if you intend for the specified command to +run as root as well. + +seatd-launch serves a similar purpose to the libseat "builtin" backend, but is +superior to it for two reasons: +. The specified command never runs as root +. The standard seatd executable and libseat backend is used + +# EXIT STATUS + +seatd-launch exits with the status of its child. When the child terminates on +a signal _N_, seatd-launch exits with the status 128 + _N_. + +If seatd-launch fails because of another error, it exits with a non-zero +status. + +# SEE ALSO + +The libseat library, **, *seatd*(1) + +# AUTHORS + +Maintained by Kenny Levinsen , who is assisted by other +open-source contributors. For more information about seatd development, see +https://sr.ht/~kennylevinsen/seatd. diff --git a/man/seatd.1.scd b/man/seatd.1.scd index c18910d..92f8e4b 100644 --- a/man/seatd.1.scd +++ b/man/seatd.1.scd @@ -13,14 +13,20 @@ seatd - A seat management daemon *-h* Show help message and quit. +*-n * + FD to notify readiness on. A single newline will be written and the fd + closed when seatd is ready to serve requests. This is compatible with + s6's notification protocol. + *-u * User to own the seatd socket. *-g * Group to own the seatd socket. -*-s * - Where to create the seatd socket. Defaults to `/run/seatd.sock`. +*-l * + Log-level to use. Must be one of debug, info, error or silent. Defaults + to error. *-v* Show the version number and quit. @@ -33,23 +39,19 @@ such as displays and input devices in a multi-session, multi-seat environment. seatd operates over a UNIX domain socket, with *libseat* providing the client-side of the protocol. +The location of the socket for seatd is set at compile-time. + # ENVIRONMENT -[[ *VARIABLE* -:[ *VALUES* -:< *DESCRIPTION* -| SEATD_SOCK -: File path -: Informs libseat of the socket location, needed if it differs from `/run/seatd.sock` -| SEATD_LOGLEVEL -: silent, error, info, debug -: Sets the seatd log level. Defaults to "error" +*SEATD_VTBOUND* + If set to "0", the seat will not be bound to a VT. # SEE ALSO -The libseat library, ** +The libseat library, **, *seatd-launch*(1) # AUTHORS -Maintained by Kenny Levinsen . For more information about seatd -development, see https://sr.ht/~kennylevinsen/seatd. +Maintained by Kenny Levinsen , who is assisted by other +open-source contributors. For more information about seatd development, see +https://sr.ht/~kennylevinsen/seatd. diff --git a/meson.build b/meson.build index 301b0e3..fcd85de 100644 --- a/meson.build +++ b/meson.build @@ -1,9 +1,9 @@ project( 'seatd', 'c', - version: '0.2.0', + version: '0.8.0', license: 'MIT', - meson_version: '>=0.53.0', + meson_version: '>=0.60.0', default_options: [ 'c_std=c11', 'warning_level=3', @@ -11,7 +11,34 @@ project( ], ) +# Bump whenever ABI-breaking changes occur. +libseat_soversion = 1 + +defaultpath = get_option('defaultpath') +if defaultpath == '' + defaultpath = '/var/run/seatd.sock' + if target_machine.system() == 'linux' + defaultpath = '/run/seatd.sock' + endif +endif + +seatdpath = get_option('prefix') / get_option('bindir') / 'seatd' + +cc = meson.get_compiler('c') + add_project_arguments( + [ + '-D_XOPEN_SOURCE=700', + '-D_BSD_SOURCE', + '-D_NETBSD_SOURCE', + '-DSEATD_VERSION="@0@"'.format(meson.project_version()), + '-DSEATD_DEFAULTPATH="@0@"'.format(defaultpath), + '-DSEATD_INSTALLPATH="@0@"'.format(seatdpath), + ], + language: 'c', +) + +add_project_arguments(cc.get_supported_arguments( [ '-Wundef', '-Wunused', @@ -25,21 +52,28 @@ add_project_arguments( '-Wno-unknown-warning-option', '-Wno-unused-command-line-argument', '-Wvla', + ]), + language: 'c', +) + +add_project_arguments(cc.get_supported_link_arguments( + [ '-Wl,--exclude-libs=ALL', - '-D_XOPEN_SOURCE=700', - '-D__BSD_VISIBLE', - '-DSEATD_VERSION="@0@"'.format(meson.project_version()), - ], + ]), language: 'c', ) if ['debugoptimized', 'release', 'minsize'].contains(get_option('buildtype')) - add_project_arguments('-D_FORTIFY_SOURCE=2', language: 'c') + add_project_arguments('-D_FORTIFY_SOURCE=2', language: 'c') +endif + +if get_option('buildtype').startswith('debug') + add_project_arguments('-DDEBUG', language : 'c') endif # Hacks source_root = meson.current_source_dir().split('/') -build_root = meson.build_root().split('/') +build_root = meson.global_build_root().split('/') relative_dir_parts = [] i = 0 in_prefix = true @@ -60,11 +94,6 @@ foreach p : source_root i += 1 endforeach -if get_option('buildtype').startswith('debug') - add_project_arguments('-DDEBUG', language : 'c') -endif - - add_project_arguments( '-DREL_SRC_DIR="@0@"'.format(join_paths(relative_dir_parts) + '/'), language: 'c', @@ -81,46 +110,59 @@ private_deps = [] server_files = [ 'common/log.c', 'common/linked_list.c', - 'common/list.c', 'common/terminal.c', 'common/connection.c', 'common/evdev.c', 'common/drm.c', + 'common/wscons.c', 'seatd/poller.c', 'seatd/seat.c', 'seatd/client.c', 'seatd/server.c', ] -if get_option('seatd').enabled() +with_seatd = get_option('libseat-seatd') == 'enabled' +with_builtin = get_option('libseat-builtin') == 'enabled' +with_server = get_option('server') == 'enabled' + +if with_seatd or with_builtin private_files += 'libseat/backend/seatd.c' - add_project_arguments('-DSEATD_ENABLED=1', language: 'c') endif -logind_provider = '' -if get_option('logind').enabled() - # Check for libelogind first, as elogind may provide a libsystemd wrapper - # which can cause issues. - logind = dependency('libelogind', required: false) - add_project_arguments('-DLOGIND_ENABLED=1', language: 'c') - if logind.found() - add_project_arguments('-DHAVE_ELOGIND=1', language: 'c') - logind_provider = 'elogind' +libseat_c_args = ['-DLIBSEAT=1'] + +if with_seatd + libseat_c_args += '-DSEATD_ENABLED=1' +endif + +logind = disabler() +if get_option('libseat-logind') != 'disabled' + if get_option('libseat-logind') == 'auto' and get_option('auto_features').disabled() + # Disable logind + elif get_option('libseat-logind') == 'auto' + assert(get_option('auto_features').auto(), '-Dlibseat-logind must be set to systemd or elogind since auto_features != auto') + logind = dependency(['libelogind', 'libsystemd'], required: false) else - logind = dependency('libsystemd') - add_project_arguments('-DHAVE_SYSTEMD=1', language: 'c') - logind_provider = 'systemd' + logind = dependency('lib@0@'.format(get_option('libseat-logind'))) endif - private_files += [ - 'libseat/backend/logind.c', - 'common/drm.c', - ] - private_deps += logind + if logind.found() + libseat_c_args += '-DLOGIND_ENABLED=1' + libseat_c_args += '-DHAVE_@0@=1'.format(logind.name().to_upper()) + private_files += [ + 'libseat/backend/logind.c', + 'common/drm.c', + ] + private_deps += logind + endif endif -if get_option('builtin').enabled() - add_project_arguments('-DBUILTIN_ENABLED=1', language: 'c') +# needed for cross-compilation +# realtime = meson.get_compiler('c').find_library('rt') +# private_deps += realtime + +if with_builtin + libseat_c_args += '-DBUILTIN_ENABLED=1' private_files += server_files endif @@ -129,40 +171,67 @@ private_lib = static_library( private_files, dependencies: private_deps, include_directories: [include_directories('.', 'include')], + c_args: libseat_c_args, ) symbols_file = 'libseat/libseat.syms' symbols_flag = '-Wl,--version-script,@0@/@1@'.format(meson.current_source_dir(), symbols_file) lib = library( 'seat', # This results in the library being called 'libseat' - [ 'libseat/libseat.c' ], + [ 'libseat/libseat.c', 'libseat/backend/noop.c' ], + soversion: '@0@'.format(libseat_soversion), link_with: private_lib, include_directories: [include_directories('.', 'include')], install: true, link_args: symbols_flag, link_depends: symbols_file, + c_args: libseat_c_args, ) install_headers('include/libseat.h') +libseat_vars = { + 'have_seatd': with_seatd.to_string(), + 'have_logind': logind.found().to_string(), + 'have_builtin': with_builtin.to_string(), +} + pkgconfig = import('pkgconfig') pkgconfig.generate(lib, version: meson.project_version(), filebase: 'libseat', name: 'libseat', description: 'Seat management library', + variables: libseat_vars, ) -if get_option('server').enabled() +libseat = declare_dependency( + link_with: lib, + dependencies: private_deps, + include_directories: include_directories('include', is_system: true), + variables: libseat_vars, +) + +meson.override_dependency('libseat', libseat) + +if with_server executable( 'seatd', [ server_files, 'seatd/seatd.c' ], include_directories: [include_directories('.', 'include')], install: true, +# dependencies: [realtime], + ) + executable( + 'seatd-launch', + [ 'seatd-launch/seatd-launch.c' ], + include_directories: [include_directories('.', 'include')], + install: true, +# dependencies: [realtime], ) endif -if get_option('examples').enabled() +if get_option('examples') == 'enabled' executable( 'simpletest', ['examples/simpletest/main.c'], @@ -172,25 +241,29 @@ if get_option('examples').enabled() ) endif -test( - 'linked_list', - executable( - 'linked_list_test', - ['common/linked_list.c', 'tests/linked_list.c'], - include_directories: [include_directories('.', 'include')], - ) -) +tests = { + 'linked_list': ['common/linked_list.c'], + 'connection': ['common/connection.c'], + 'poller': ['common/linked_list.c', 'seatd/poller.c'], +} -scdoc = dependency('scdoc', required: get_option('man-pages'), version: '>= 1.9.7') +foreach name, value : tests + test(name, executable( + '@0@_test'.format(name), + ['tests/@0@.c'.format(name), value], + include_directories: [include_directories('.', 'include')])) +endforeach + +if with_server + scdoc = dependency('scdoc', required: get_option('man-pages'), version: '>= 1.9.7', native: true) +else + scdoc = disabler() +endif if scdoc.found() - sh = find_program('sh') - - man_pages = ['seatd.1.scd'] - mandir = get_option('mandir') - foreach src : man_pages + foreach src : ['seatd.1.scd', 'seatd-launch.1.scd'] topic = src.split('.')[0] section = src.split('.')[1] output = '@0@.@1@'.format(topic, section) @@ -199,9 +272,9 @@ if scdoc.found() output, input: 'man/' + src, output: output, - command: [ - sh, '-c', '@0@ < @INPUT@ > @1@'.format(scdoc.get_pkgconfig_variable('scdoc'), output) - ], + command: scdoc.get_variable(pkgconfig: 'scdoc'), + feed: true, + capture: true, install: true, install_dir: '@0@/man@1@'.format(mandir, section) ) @@ -209,8 +282,9 @@ if scdoc.found() endif summary({ - 'seatd': get_option('seatd').enabled() ? 1 : 0, - 'builtin': get_option('builtin').enabled() ? 1 : 0, - 'systemd': logind_provider == 'systemd' ? 1 : 0, - 'elogind': logind_provider == 'elogind' ? 1 : 0, -}) + 'libseat-seatd': with_seatd, + 'libseat-builtin': with_builtin, + 'libseat-systemd': logind.found() and logind.name() == 'libsystemd', + 'libseat-elogind': logind.found() and logind.name() == 'libelogind', + 'server': with_server, +}, bool_yn: true) diff --git a/meson_options.txt b/meson_options.txt index 6e498c4..0731ac4 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -1,7 +1,7 @@ -option('logind', type: 'feature', value: 'disabled', description: 'logind support') -option('seatd', type: 'feature', value: 'enabled', description: 'seatd support') -option('builtin', type: 'feature', value: 'disabled', description: 'builtin seatd server') -option('server', type: 'feature', value: 'enabled', description: 'seatd server') -option('examples', type: 'feature', value: 'enabled', description: 'libseat example programs') +option('libseat-logind', type: 'combo', choices: ['auto', 'disabled', 'elogind', 'systemd'], value: 'auto', description: 'logind support for libseat') +option('libseat-seatd', type: 'combo', choices: ['enabled', 'disabled'], value: 'enabled', description: 'seatd support for libseat') +option('libseat-builtin', type: 'combo', choices: ['enabled', 'disabled'], value: 'disabled', description: 'built-in seatd server for libseat') +option('server', type: 'combo', choices: ['enabled', 'disabled'], value: 'enabled', description: 'seatd server') +option('examples', type: 'combo', choices: ['enabled', 'disabled'], value: 'disabled', description: 'libseat example programs') option('man-pages', type: 'feature', value: 'auto', description: 'Generate and install man pages') - +option('defaultpath', type: 'string', value: '', description: 'Default location for seatd socket (empty for default)') diff --git a/seatd-launch/seatd-launch.c b/seatd-launch/seatd-launch.c new file mode 100644 index 0000000..65d4f33 --- /dev/null +++ b/seatd-launch/seatd-launch.c @@ -0,0 +1,174 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +int main(int argc, char *argv[]) { + const char *usage = "Usage: seatd-launch [options] [--] command\n" + "\n" + " -l Log-level to pass to seatd\n" + " -h Show this help message\n" + " -v Show the version number\n" + "\n"; + + int c; + char loglevel[16] = "info"; + while ((c = getopt(argc, argv, "vhl:")) != -1) { + switch (c) { + case 'l': + strncpy(loglevel, optarg, sizeof loglevel); + loglevel[sizeof loglevel - 1] = '\0'; + break; + case 'v': + printf("seatd-launch version %s\n", SEATD_VERSION); + return 0; + case 'h': + printf("%s", usage); + return 0; + case '?': + fprintf(stderr, "Try 'seatd-launch -h' for more information.\n"); + return 1; + default: + abort(); + } + } + + if (optind >= argc) { + fprintf(stderr, "A command must be specified\n\n%s", usage); + return 1; + } + char **command = &argv[optind]; + + int readiness_pipe[2]; + if (pipe(readiness_pipe) == -1) { + perror("Could not create pipe"); + goto error; + } + + // Start seatd + pid_t seatd_child = fork(); + if (seatd_child == -1) { + perror("Could not fork seatd process"); + goto error; + } else if (seatd_child == 0) { + close(readiness_pipe[0]); + + char pipebuf[16] = {0}; + snprintf(pipebuf, sizeof pipebuf, "%d", readiness_pipe[1]); + + char *env[1] = {NULL}; + char *command[] = {"seatd", "-n", pipebuf, "-l", loglevel, "-z", NULL}; + execve(SEATD_INSTALLPATH, command, env); + perror("Could not start seatd"); + _exit(1); + } + close(readiness_pipe[1]); + + // Wait for seatd to be ready + char buf[1] = {0}; + while (true) { + pid_t p = waitpid(seatd_child, NULL, WNOHANG); + if (p == seatd_child) { + fprintf(stderr, "seatd exited prematurely\n"); + goto error_seatd; + } else if (p == -1 && (errno != EINTR && errno != ECHILD)) { + perror("Could not wait for seatd process"); + goto error_seatd; + } + + struct pollfd fd = { + .fd = readiness_pipe[0], + .events = POLLIN, + }; + + // We poll with timeout to avoid a racing on a blocking read + if (poll(&fd, 1, 1000) == -1) { + if (errno == EAGAIN || errno == EINTR) { + continue; + } else { + perror("Could not poll notification fd"); + goto error_seatd; + } + } + + if (fd.revents & POLLIN) { + ssize_t n = read(readiness_pipe[0], buf, 1); + if (n == -1 && errno != EINTR) { + perror("Could not read from pipe"); + goto error_seatd; + } else if (n > 0) { + break; + } + } + } + close(readiness_pipe[0]); + + uid_t uid = getuid(); + gid_t gid = getgid(); + + // Restrict access to the socket to just us + if (chown(SEATD_DEFAULTPATH, uid, gid) == -1) { + perror("Could not chown seatd socket"); + goto error_seatd; + } + if (chmod(SEATD_DEFAULTPATH, 0700) == -1) { + perror("Could not chmod socket"); + goto error_seatd; + } + + // Drop privileges + if (setgid(gid) == -1) { + perror("Could not set gid to drop privileges"); + goto error_seatd; + } + if (setuid(uid) == -1) { + perror("Could not set uid to drop privileges"); + goto error_seatd; + } + + pid_t child = fork(); + if (child == -1) { + perror("Could not fork target process"); + goto error_seatd; + } else if (child == 0) { + setenv("SEATD_SOCK", SEATD_DEFAULTPATH, 1); + execvp(command[0], command); + perror("Could not start target"); + _exit(1); + } + + int status = 0; + while (true) { + pid_t p = waitpid(child, &status, 0); + if (p == child) { + break; + } else if (p == -1 && errno != EINTR) { + perror("Could not wait for target process"); + goto error_seatd; + } + } + + if (kill(seatd_child, SIGTERM) != 0) { + perror("Could not kill seatd"); + } + + if (WIFEXITED(status)) { + return WEXITSTATUS(status); + } else if (WIFSIGNALED(status)) { + return 128 + WTERMSIG(status); + } else { + abort(); // unreachable + } + +error_seatd: + kill(seatd_child, SIGTERM); +error: + return 1; +} diff --git a/seatd/client.c b/seatd/client.c index 1adc2d9..481704e 100644 --- a/seatd/client.c +++ b/seatd/client.c @@ -14,6 +14,10 @@ #include #endif +#if defined(__NetBSD__) +#include +#endif + #include "client.h" #include "linked_list.h" #include "log.h" @@ -34,18 +38,56 @@ static int get_peer(int fd, pid_t *pid, uid_t *uid, gid_t *gid) { *uid = cred.uid; *gid = cred.gid; return 0; +#elif defined(__NetBSD__) + struct unpcbid cred; + socklen_t len = sizeof cred; + if (getsockopt(fd, 0, LOCAL_PEEREID, &cred, &len) == -1) { + // assume builtin backend + if (errno == EINVAL) { + *pid = getpid(); + *uid = getuid(); + *gid = getgid(); + return 0; + } + return -1; + } + *pid = cred.unp_pid; + *uid = cred.unp_euid; + *gid = cred.unp_egid; + return 0; +#elif defined(__OpenBSD__) + struct sockpeercred peercred; + socklen_t len = sizeof(peercred); + if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &peercred, &len) == -1) { + // assume builtin backend + if (errno == EINVAL) { + *pid = getpid(); + *uid = getuid(); + *gid = getgid(); + return 0; + } + return -1; + } + *pid = peercred.pid; + *uid = peercred.uid; + *gid = peercred.gid; + return 0; #elif defined(__FreeBSD__) struct xucred cred; socklen_t len = sizeof cred; - if (getsockopt(fd, SOL_SOCKET, LOCAL_PEERCRED, &cred, &len) == -1) { + if (getsockopt(fd, 0, LOCAL_PEERCRED, &cred, &len) == -1) { return -1; } +#if __FreeBSD_version >= 1300030 || (__FreeBSD_version >= 1202506 && __FreeBSD_version < 1300000) + *pid = cred.cr_pid; +#else *pid = -1; +#endif *uid = cred.cr_uid; - *gid = cred.cr_ngroups > 0 ? cred.cr_groups[0] : -1; + *gid = cred.cr_ngroups > 0 ? cred.cr_groups[0] : (gid_t)-1; return 0; #else - return -1; +#error Unsupported platform #endif } @@ -66,37 +108,37 @@ struct client *client_create(struct server *server, int client_fd) { client->uid = uid; client->gid = gid; client->pid = pid; + client->session = -1; client->server = server; client->connection.fd = client_fd; + client->state = CLIENT_NEW; linked_list_init(&client->devices); + linked_list_insert(&server->idle_clients, &client->link); return client; } -void client_kill(struct client *client) { - assert(client); - if (client->connection.fd != -1) { - shutdown(client->connection.fd, SHUT_RDWR); - }; - if (client->seat != NULL) { - seat_remove_client(client); - } -} - void client_destroy(struct client *client) { assert(client); + +#ifdef LIBSEAT + // The built-in backend version of seatd should terminate once its only + // client disconnects. + client->server->running = false; +#endif + client->server = NULL; + if (client->connection.fd != -1) { + close(client->connection.fd); + client->connection.fd = -1; + } + linked_list_remove(&client->link); if (client->seat != NULL) { - // This should also close and remove all devices seat_remove_client(client); } if (client->event_source != NULL) { event_source_fd_destroy(client->event_source); client->event_source = NULL; } - if (client->connection.fd != -1) { - close(client->connection.fd); - client->connection.fd = -1; - } connection_close_fds(&client->connection); assert(linked_list_empty(&client->devices)); free(client); @@ -122,8 +164,8 @@ static int client_send_error(struct client *client, int error_code) { }; if (connection_put(&client->connection, &errheader, sizeof errheader) == -1 || - connection_put(&client->connection, &errmsg, sizeof errmsg)) { - log_error("could not send error to client"); + connection_put(&client->connection, &errmsg, sizeof errmsg) == -1) { + log_errorf("Could not send error to client: %s", strerror(errno)); return -1; } return 0; @@ -138,20 +180,22 @@ static char *client_get_seat_name(struct client *client) { static int handle_open_seat(struct client *client) { char *seat_name = client_get_seat_name(client); if (seat_name == NULL) { - log_error("could not get name of target seat"); + log_error("Could not get name of target seat"); return -1; } struct seat *seat = server_get_seat(client->server, seat_name); if (seat == NULL) { - log_error("unable to find seat by name"); + log_errorf("Could not find seat named %s", seat_name); return -1; } if (seat_add_client(seat, client) == -1) { - log_errorf("unable to add client to target seat: %s", strerror(errno)); + log_errorf("Could not add client to target seat: %s", strerror(errno)); return -1; } + linked_list_remove(&client->link); + linked_list_insert(&seat->clients, &client->link); size_t seat_name_len = strlen(seat_name); @@ -166,7 +210,7 @@ static int handle_open_seat(struct client *client) { if (connection_put(&client->connection, &header, sizeof header) == -1 || connection_put(&client->connection, &rmsg, sizeof rmsg) == -1 || connection_put(&client->connection, seat_name, seat_name_len) == -1) { - log_errorf("unable to write response: %s", strerror(errno)); + log_errorf("Could not write response: %s", strerror(errno)); return -1; } @@ -176,14 +220,16 @@ static int handle_open_seat(struct client *client) { static int handle_close_seat(struct client *client) { if (client->seat == NULL) { - log_error("protocol error: no seat associated with client"); + log_error("Protocol error: no seat associated with client"); return -1; } + linked_list_remove(&client->link); if (seat_remove_client(client) == -1) { - log_error("unable to remove client from seat"); + log_error("Could not remove client from seat"); return -1; } + linked_list_insert(&client->server->idle_clients, &client->link); struct proto_header header = { .opcode = SERVER_SEAT_CLOSED, @@ -191,7 +237,7 @@ static int handle_close_seat(struct client *client) { }; if (connection_put(&client->connection, &header, sizeof header) == -1) { - log_errorf("unable to write response: %s", strerror(errno)); + log_errorf("Could not write response: %s", strerror(errno)); return -1; } @@ -200,25 +246,25 @@ static int handle_close_seat(struct client *client) { static int handle_open_device(struct client *client, char *path) { if (client->seat == NULL) { - log_error("protocol error: no seat associated with client"); + log_error("Protocol error: no seat associated with client"); return -1; } struct seat_device *device = seat_open_device(client, path); if (device == NULL) { - log_errorf("could not open device: %s", strerror(errno)); + log_errorf("Could not open device: %s", strerror(errno)); goto fail; } int dupfd = dup(device->fd); if (dupfd == -1) { - log_errorf("could not dup fd: %s", strerror(errno)); + log_errorf("Could not dup fd: %s", strerror(errno)); seat_close_device(client, device); goto fail; } if (connection_put_fd(&client->connection, dupfd) == -1) { - log_errorf("unable to queue fd for sending: %s", strerror(errno)); + log_errorf("Could not queue fd for sending: %s", strerror(errno)); return -1; } @@ -231,8 +277,8 @@ static int handle_open_device(struct client *client, char *path) { }; if (connection_put(&client->connection, &header, sizeof header) == -1 || - connection_put(&client->connection, &msg, sizeof msg)) { - log_errorf("unable to write response: %s", strerror(errno)); + connection_put(&client->connection, &msg, sizeof msg) == -1) { + log_errorf("Could not write response: %s", strerror(errno)); return -1; } @@ -244,33 +290,29 @@ fail: static int handle_close_device(struct client *client, int device_id) { if (client->seat == NULL) { - log_error("protocol error: no seat associated with client"); + log_error("Protocol error: no seat associated with client"); return -1; } struct seat_device *device = seat_find_device(client, device_id); if (device == NULL) { - log_error("no such device"); + log_error("No such device"); errno = EBADF; goto fail; } if (seat_close_device(client, device) == -1) { - log_errorf("could not close device: %s", strerror(errno)); + log_errorf("Could not close device: %s", strerror(errno)); goto fail; } - struct proto_server_device_closed msg = { - .device_id = device_id, - }; struct proto_header header = { .opcode = SERVER_DEVICE_CLOSED, - .size = sizeof msg, + .size = 0, }; - if (connection_put(&client->connection, &header, sizeof header) == -1 || - connection_put(&client->connection, &msg, sizeof msg)) { - log_errorf("unable to write response: %s", strerror(errno)); + if (connection_put(&client->connection, &header, sizeof header) == -1) { + log_errorf("Could not write response: %s", strerror(errno)); return -1; } @@ -282,10 +324,10 @@ fail: static int handle_switch_session(struct client *client, int session) { if (client->seat == NULL) { - log_error("protocol error: no seat associated with client"); + log_error("Protocol error: no seat associated with client"); return -1; } - + log_debugf("handle_switch_session %d", session); if (seat_set_next_session(client, session) == -1) { goto error; } @@ -298,17 +340,10 @@ error: static int handle_disable_seat(struct client *client) { if (client->seat == NULL) { - log_error("protocol error: no seat associated with client"); + log_error("Protocol error: no seat associated with client"); return -1; } - struct seat *seat = client->seat; - if (seat->active_client != client) { - log_info("client is not currently active"); - errno = EPERM; - goto error; - } - if (seat_ack_disable_client(client) == -1) { goto error; } @@ -319,12 +354,27 @@ error: return client_send_error(client, errno); } +static int handle_ping(struct client *client) { + struct proto_header header = { + .opcode = SERVER_PONG, + .size = 0, + }; + + if (connection_put(&client->connection, &header, sizeof header) == -1) { + log_errorf("Could not write response: %s", strerror(errno)); + return -1; + } + + return 0; +} + static int client_handle_opcode(struct client *client, uint16_t opcode, size_t size) { int res = 0; + log_debugf("client_handle_opcode: %d\n", opcode); switch (opcode) { case CLIENT_OPEN_SEAT: { if (size != 0) { - log_error("protocol error: invalid open_seat message"); + log_error("Protocol error: invalid open_seat message"); return -1; } res = handle_open_seat(client); @@ -332,7 +382,7 @@ static int client_handle_opcode(struct client *client, uint16_t opcode, size_t s } case CLIENT_CLOSE_SEAT: { if (size != 0) { - log_error("protocol error: invalid close_seat message"); + log_error("Protocol error: invalid close_seat message"); return -1; } res = handle_close_seat(client); @@ -343,11 +393,11 @@ static int client_handle_opcode(struct client *client, uint16_t opcode, size_t s struct proto_client_open_device msg; if (sizeof msg > size || connection_get(&client->connection, &msg, sizeof msg) == -1 || sizeof msg + msg.path_len > size || msg.path_len > MAX_PATH_LEN) { - log_error("protocol error: invalid open_device message"); + log_error("Protocol error: invalid open_device message"); return -1; } if (connection_get(&client->connection, path, msg.path_len) == -1) { - log_error("protocol error: invalid open_device message"); + log_error("Protocol error: invalid open_device message"); return -1; } @@ -357,7 +407,7 @@ static int client_handle_opcode(struct client *client, uint16_t opcode, size_t s case CLIENT_CLOSE_DEVICE: { struct proto_client_close_device msg; if (sizeof msg > size || connection_get(&client->connection, &msg, sizeof msg) == -1) { - log_error("protocol error: invalid close_device message"); + log_error("Protocol error: invalid close_device message"); return -1; } @@ -367,7 +417,7 @@ static int client_handle_opcode(struct client *client, uint16_t opcode, size_t s case CLIENT_SWITCH_SESSION: { struct proto_client_switch_session msg; if (sizeof msg > size || connection_get(&client->connection, &msg, sizeof msg) == -1) { - log_error("protocol error: invalid switch_session message"); + log_error("Protocol error: invalid switch_session message"); return -1; } @@ -376,14 +426,22 @@ static int client_handle_opcode(struct client *client, uint16_t opcode, size_t s } case CLIENT_DISABLE_SEAT: { if (size != 0) { - log_error("protocol error: invalid disable_seat message"); + log_error("Protocol error: invalid disable_seat message"); return -1; } res = handle_disable_seat(client); break; } + case CLIENT_PING: { + if (size != 0) { + log_error("Protocol error: invalid ping message"); + return -1; + } + res = handle_ping(client); + break; + } default: - log_errorf("protocol error: unknown opcode: %d", opcode); + log_errorf("Protocol error: unknown opcode: %d", opcode); res = -1; break; } @@ -400,7 +458,7 @@ int client_send_disable_seat(struct client *client) { }; if (connection_put(&client->connection, &header, sizeof header) == -1 || connection_flush(&client->connection) == -1) { - log_error("unable to send event"); + log_errorf("Could not send event: %s", strerror(errno)); return -1; } return 0; @@ -413,7 +471,7 @@ int client_send_enable_seat(struct client *client) { }; if (connection_put(&client->connection, &header, sizeof header) == -1 || connection_flush(&client->connection) == -1) { - log_error("unable to send event"); + log_errorf("Could not send event: %s", strerror(errno)); return -1; } return 0; @@ -424,18 +482,18 @@ int client_handle_connection(int fd, uint32_t mask, void *data) { struct client *client = data; if (mask & EVENT_ERROR) { - log_error("connection error"); + log_error("Connection error"); goto fail; } if (mask & EVENT_HANGUP) { - log_info("client disconnected"); + log_info("Client disconnected"); goto fail; } if (mask & EVENT_WRITABLE) { int len = connection_flush(&client->connection); if (len == -1 && errno != EAGAIN) { - log_error("could not flush client connection"); + log_errorf("Could not flush client connection: %s", strerror(errno)); goto fail; } else if (len >= 0) { event_source_fd_update(client->event_source, EVENT_READABLE); @@ -444,8 +502,18 @@ int client_handle_connection(int fd, uint32_t mask, void *data) { if (mask & EVENT_READABLE) { int len = connection_read(&client->connection); - if (len == 0 || (len == -1 && errno != EAGAIN)) { - log_error("could not read client connection"); + if (len == -1 && errno != EAGAIN) { + log_errorf("Could not read client connection: %s", strerror(errno)); + goto fail; + } + if (len == 0) { +// https://man.netbsd.org/poll.2 +// Sockets produce POLLIN rather than POLLHUP when the remote end is closed. +#if defined(__NetBSD__) + log_info("Client disconnected"); +#else + log_error("Could not read client connection: zero-length read"); +#endif goto fail; } @@ -467,15 +535,3 @@ fail: client_destroy(client); return -1; } - -int client_get_session(const struct client *client) { - if (client->seat == NULL || client->seat->active_client != client) { - return -1; - } - if (client->seat->vt_bound) { - return client->seat_vt; - } - // TODO: Store some session sequence - errno = ENOSYS; - return -1; -} diff --git a/seatd/poller.c b/seatd/poller.c index f786d47..ceadb24 100644 --- a/seatd/poller.c +++ b/seatd/poller.c @@ -1,41 +1,105 @@ #include #include +#include #include #include #include #include #include #include +#include -#include "list.h" +#include "linked_list.h" #include "poller.h" +struct event_source_fd { + struct linked_list link; // poller::fds + const struct event_source_fd_impl *impl; + event_source_fd_func_t func; + + int fd; + uint32_t mask; + void *data; + + struct poller *poller; + bool killed; + ssize_t pollfd_idx; +}; + +struct event_source_signal { + struct linked_list link; // poller::signals + const struct event_source_signal_impl *impl; + event_source_signal_func_t func; + + int signal; + void *data; + + struct poller *poller; + bool raised; + bool killed; +}; + /* Used for signal handling */ struct poller *global_poller = NULL; -void poller_init(struct poller *poller) { +static void signal_handler(int sig) { + if (global_poller == NULL) { + return; + } + for (struct linked_list *elem = global_poller->signals.next; + elem != &global_poller->signals; elem = elem->next) { + struct event_source_signal *bps = (struct event_source_signal *)elem; + if (bps->signal == sig) { + bps->raised = true; + } + } + int saved_errno = errno; + if (write(global_poller->signal_fds[1], "\0", 1) == -1 && errno != EAGAIN) { + // This is unfortunate. + } + errno = saved_errno; +} + +static int set_nonblock(int fd) { + int flags; + if ((flags = fcntl(fd, F_GETFL)) == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) { + return -1; + } + return 0; +} + +int poller_init(struct poller *poller) { assert(global_poller == NULL); - list_init(&poller->fds); - list_init(&poller->new_fds); - list_init(&poller->signals); - list_init(&poller->new_signals); + if (pipe(poller->signal_fds) == -1) { + return -1; + } + if (set_nonblock(poller->signal_fds[0]) == -1) { + return -1; + } + if (set_nonblock(poller->signal_fds[1]) == -1) { + return -1; + } + + linked_list_init(&poller->fds); + linked_list_init(&poller->signals); + poller->pollfds = NULL; + poller->pollfds_len = 0; + poller->dirty = true; + poller->fd_event_sources = 1; global_poller = poller; + + return 0; } int poller_finish(struct poller *poller) { - for (size_t idx = 0; idx < poller->fds.length; idx++) { - struct event_source_fd *bpfd = poller->fds.items[idx]; + while (!linked_list_empty(&poller->fds)) { + struct event_source_fd *bpfd = (struct event_source_fd *)poller->fds.next; + linked_list_remove(&bpfd->link); free(bpfd); } - list_free(&poller->fds); - for (size_t idx = 0; idx < poller->new_fds.length; idx++) { - struct event_source_fd *bpfd = poller->new_fds.items[idx]; - free(bpfd); - } - list_free(&poller->new_fds); - for (size_t idx = 0; idx < poller->signals.length; idx++) { - struct event_source_signal *bps = poller->signals.items[idx]; + while (!linked_list_empty(&poller->signals)) { + struct event_source_signal *bps = (struct event_source_signal *)poller->signals.next; struct sigaction sa; sa.sa_handler = SIG_DFL; @@ -43,22 +107,96 @@ int poller_finish(struct poller *poller) { sa.sa_flags = 0; sigaction(bps->signal, &sa, NULL); + linked_list_remove(&bps->link); free(bps); } - list_free(&poller->signals); - for (size_t idx = 0; idx < poller->new_signals.length; idx++) { - struct event_source_signal *bps = poller->new_signals.items[idx]; - - struct sigaction sa; - sa.sa_handler = SIG_DFL; - sigemptyset(&sa.sa_mask); - sa.sa_flags = 0; - sigaction(bps->signal, &sa, NULL); - - free(bps); - } - list_free(&poller->new_signals); free(poller->pollfds); + global_poller = NULL; + return 0; +} + +struct event_source_fd *poller_add_fd(struct poller *poller, int fd, uint32_t mask, + event_source_fd_func_t func, void *data) { + struct event_source_fd *bpfd = calloc(1, sizeof(struct event_source_fd)); + if (bpfd == NULL) { + return NULL; + } + bpfd->fd = fd; + bpfd->mask = mask; + bpfd->data = data; + bpfd->func = func; + bpfd->poller = poller; + bpfd->pollfd_idx = -1; + poller->fd_event_sources += 1; + poller->dirty = true; + linked_list_insert(&poller->fds, &bpfd->link); + return (struct event_source_fd *)bpfd; +} + +int event_source_fd_destroy(struct event_source_fd *event_source) { + struct event_source_fd *bpfd = (struct event_source_fd *)event_source; + struct poller *poller = bpfd->poller; + poller->fd_event_sources -= 1; + poller->dirty = true; + bpfd->killed = true; + return 0; +} + +int event_source_fd_update(struct event_source_fd *event_source, uint32_t mask) { + struct event_source_fd *bpfd = (struct event_source_fd *)event_source; + struct poller *poller = bpfd->poller; + event_source->mask = mask; + poller->dirty = true; + return 0; +} + +struct event_source_signal *poller_add_signal(struct poller *poller, int signal, + event_source_signal_func_t func, void *data) { + + struct event_source_signal *bps = calloc(1, sizeof(struct event_source_signal)); + if (bps == NULL) { + return NULL; + } + + bps->signal = signal; + bps->data = data; + bps->func = func; + bps->poller = poller; + + struct sigaction sa; + sa.sa_handler = &signal_handler; + sigemptyset(&sa.sa_mask); + sa.sa_flags = 0; + sigaction(signal, &sa, NULL); + + linked_list_insert(&poller->signals, &bps->link); + + return (struct event_source_signal *)bps; +} + +int event_source_signal_destroy(struct event_source_signal *event_source) { + struct event_source_signal *bps = (struct event_source_signal *)event_source; + struct poller *poller = bps->poller; + + int refcnt = 0; + for (struct linked_list *elem = poller->signals.next; elem != &poller->signals; + elem = elem->next) { + struct event_source_signal *b = (struct event_source_signal *)elem; + if (b->signal == bps->signal && !b->killed) { + refcnt++; + } + } + + if (refcnt == 0) { + struct sigaction sa; + sa.sa_handler = SIG_DFL; + sigemptyset(&sa.sa_mask); + sa.sa_flags = 0; + sigaction(bps->signal, &sa, NULL); + } + + poller->dirty = true; + bps->killed = true; return 0; } @@ -90,227 +228,100 @@ static uint32_t poll_mask_to_event_mask(int poll_mask) { return event_mask; } -static int regenerate_pollfds(struct poller *poller) { - if (poller->pollfds_len != poller->fds.length) { - struct pollfd *fds = calloc(poller->fds.length, sizeof(struct pollfd)); +static int regenerate(struct poller *poller) { + if (poller->fd_event_sources > poller->pollfds_len) { + struct pollfd *fds = + realloc(poller->pollfds, poller->fd_event_sources * sizeof(struct pollfd)); if (fds == NULL) { return -1; } - free(poller->pollfds); poller->pollfds = fds; - poller->pollfds_len = poller->fds.length; + poller->pollfds_len = poller->fd_event_sources; } - for (size_t idx = 0; idx < poller->fds.length; idx++) { - struct event_source_fd *bpfd = poller->fds.items[idx]; - poller->pollfds[idx] = (struct pollfd){ - .fd = bpfd->fd, - .events = event_mask_to_poll_mask(bpfd->mask), - }; - } + size_t idx = 0; + poller->pollfds[idx++] = (struct pollfd){ + .fd = poller->signal_fds[0], + .events = POLLIN, + }; - return 0; -} - -struct event_source_fd *poller_add_fd(struct poller *poller, int fd, uint32_t mask, - event_source_fd_func_t func, void *data) { - struct event_source_fd *bpfd = calloc(1, sizeof(struct event_source_fd)); - if (bpfd == NULL) { - return NULL; - } - bpfd->fd = fd; - bpfd->mask = mask; - bpfd->data = data; - bpfd->func = func; - bpfd->poller = poller; - poller->dirty = true; - if (poller->inpoll) { - list_add(&poller->new_fds, bpfd); - } else { - list_add(&poller->fds, bpfd); - regenerate_pollfds(poller); - } - return (struct event_source_fd *)bpfd; -} - -int event_source_fd_destroy(struct event_source_fd *event_source) { - struct event_source_fd *bpfd = (struct event_source_fd *)event_source; - struct poller *poller = bpfd->poller; - int idx = list_find(&poller->fds, event_source); - if (idx == -1) { - return -1; - } - poller->dirty = true; - if (poller->inpoll) { - bpfd->killed = true; - } else { - list_del(&poller->fds, idx); - free(bpfd); - regenerate_pollfds(poller); - } - return 0; -} - -int event_source_fd_update(struct event_source_fd *event_source, uint32_t mask) { - struct event_source_fd *bpfd = (struct event_source_fd *)event_source; - struct poller *poller = bpfd->poller; - event_source->mask = mask; - - poller->dirty = true; - if (!poller->inpoll) { - regenerate_pollfds(poller); - } - return 0; -} - -static void signal_handler(int sig) { - if (global_poller == NULL) { - return; - } - - for (size_t idx = 0; idx < global_poller->signals.length; idx++) { - struct event_source_signal *bps = global_poller->signals.items[idx]; - if (bps->signal == sig) { - bps->raised = true; + for (struct linked_list *elem = poller->fds.next; elem != &poller->fds; elem = elem->next) { + struct event_source_fd *bpfd = (struct event_source_fd *)elem; + if (bpfd->killed) { + elem = elem->prev; + linked_list_remove(&bpfd->link); + free(bpfd); + } else { + bpfd->pollfd_idx = idx++; + assert(bpfd->pollfd_idx < (ssize_t)poller->pollfds_len); + poller->pollfds[bpfd->pollfd_idx] = (struct pollfd){ + .fd = bpfd->fd, + .events = event_mask_to_poll_mask(bpfd->mask), + }; } } -} + assert(idx == poller->fd_event_sources); -struct event_source_signal *poller_add_signal(struct poller *poller, int signal, - event_source_signal_func_t func, void *data) { - - struct event_source_signal *bps = calloc(1, sizeof(struct event_source_signal)); - if (bps == NULL) { - return NULL; - } - - int refcnt = 0; - for (size_t idx = 0; idx < poller->signals.length; idx++) { - struct event_source_signal *bps = poller->signals.items[idx]; - if (bps->signal == signal) { - refcnt++; + for (struct linked_list *elem = poller->signals.next; elem != &poller->signals; + elem = elem->next) { + struct event_source_signal *bps = (struct event_source_signal *)elem; + if (bps->killed) { + elem = elem->prev; + linked_list_remove(&bps->link); + free(bps); } } - bps->signal = signal; - bps->data = data; - bps->func = func; - bps->poller = poller; - - if (refcnt == 0) { - struct sigaction sa; - sa.sa_handler = &signal_handler; - sigemptyset(&sa.sa_mask); - sa.sa_flags = 0; - sigaction(signal, &sa, NULL); - } - - if (poller->inpoll) { - list_add(&poller->new_signals, bps); - } else { - list_add(&poller->signals, bps); - } - - return (struct event_source_signal *)bps; -} - -int event_source_signal_destroy(struct event_source_signal *event_source) { - struct event_source_signal *bps = (struct event_source_signal *)event_source; - struct poller *poller = bps->poller; - - int idx = list_find(&poller->signals, event_source); - if (idx == -1) { - return -1; - } - - int refcnt = 0; - for (size_t idx = 0; idx < poller->signals.length; idx++) { - struct event_source_signal *b = poller->signals.items[idx]; - if (b->signal == bps->signal) { - refcnt++; - } - } - - if (refcnt == 0) { - struct sigaction sa; - sa.sa_handler = SIG_DFL; - sigemptyset(&sa.sa_mask); - sa.sa_flags = 0; - sigaction(bps->signal, &sa, NULL); - } - - if (poller->inpoll) { - bps->killed = true; - } else { - list_del(&poller->signals, idx); - free(bps); - } return 0; } -int poller_poll(struct poller *poller) { - if (poll(poller->pollfds, poller->fds.length, -1) == -1 && errno != EINTR) { - return -1; +static void dispatch(struct poller *poller) { + if ((poller->pollfds[0].revents & POLLIN) != 0) { + char garbage[8]; + while (read(poller->signal_fds[0], &garbage, sizeof garbage) != -1) { + } + + for (struct linked_list *elem = poller->signals.next; elem != &poller->signals; + elem = elem->next) { + struct event_source_signal *bps = (struct event_source_signal *)elem; + if (!bps->raised || bps->killed) { + continue; + } + bps->func(bps->signal, bps->data); + bps->raised = false; + } } - poller->inpoll = true; - - for (size_t idx = 0; idx < poller->fds.length; idx++) { - short revents = poller->pollfds[idx].revents; + for (struct linked_list *elem = poller->fds.next; elem != &poller->fds; elem = elem->next) { + struct event_source_fd *bpfd = (struct event_source_fd *)elem; + if (bpfd->pollfd_idx == -1 || bpfd->killed) { + continue; + } + assert(bpfd->pollfd_idx < (ssize_t)poller->pollfds_len); + short revents = poller->pollfds[bpfd->pollfd_idx].revents; if (revents == 0) { continue; } - struct event_source_fd *bpfd = poller->fds.items[idx]; - bpfd->func(poller->pollfds[idx].fd, poll_mask_to_event_mask(revents), bpfd->data); - } - - for (size_t idx = 0; idx < poller->signals.length; idx++) { - struct event_source_signal *bps = poller->signals.items[idx]; - if (!bps->raised) { - continue; - } - bps->func(bps->signal, bps->data); - bps->raised = false; - } - - poller->inpoll = false; - - for (size_t idx = 0; idx < poller->fds.length; idx++) { - struct event_source_fd *bpfd = poller->fds.items[idx]; - if (!bpfd->killed) { - continue; - } - - list_del(&poller->fds, idx); - free(bpfd); - idx--; - } - - for (size_t idx = 0; idx < poller->signals.length; idx++) { - struct event_source_signal *bps = poller->signals.items[idx]; - if (!bps->killed) { - continue; - } - - list_del(&poller->signals, idx); - free(bps); - idx--; - } - - if (poller->new_fds.length > 0) { - list_concat(&poller->fds, &poller->new_fds); - list_truncate(&poller->new_fds); - } - - if (poller->new_signals.length > 0) { - list_concat(&poller->signals, &poller->new_signals); - list_truncate(&poller->new_signals); + bpfd->func(poller->pollfds[bpfd->pollfd_idx].fd, poll_mask_to_event_mask(revents), + bpfd->data); } +} +int poller_poll(struct poller *poller) { if (poller->dirty) { - regenerate_pollfds(poller); + if (regenerate(poller) == -1) { + return -1; + } poller->dirty = false; } + while (poll(poller->pollfds, poller->fd_event_sources, -1) == -1) { + if (errno != EINTR) { + return -1; + } + } + + dispatch(poller); + return 0; } diff --git a/seatd/seat.c b/seatd/seat.c index 40fbb09..8820992 100644 --- a/seatd/seat.c +++ b/seatd/seat.c @@ -17,6 +17,10 @@ #include "protocol.h" #include "seat.h" #include "terminal.h" +#include "wscons.h" + +static int seat_close_client(struct client *client); +static int vt_close(int vt); struct seat *seat_create(const char *seat_name, bool vt_bound) { struct seat *seat = calloc(1, sizeof(struct seat)); @@ -25,13 +29,17 @@ struct seat *seat_create(const char *seat_name, bool vt_bound) { } linked_list_init(&seat->clients); seat->vt_bound = vt_bound; - seat->curttyfd = -1; seat->seat_name = strdup(seat_name); + seat->cur_vt = 0; if (seat->seat_name == NULL) { free(seat); return NULL; } - log_debugf("created seat '%s' (vt_bound: %d)", seat_name, vt_bound); + if (vt_bound) { + log_infof("Created VT-bound seat %s", seat_name); + } else { + log_infof("Created seat %s", seat_name); + } return seat; } @@ -39,34 +47,129 @@ void seat_destroy(struct seat *seat) { assert(seat); while (!linked_list_empty(&seat->clients)) { struct client *client = (struct client *)seat->clients.next; - // This will cause the client to remove itself from the seat assert(client->seat == seat); - client_kill(client); + client_destroy(client); } - assert(seat->curttyfd == -1); - + linked_list_remove(&seat->link); free(seat->seat_name); free(seat); } +static void seat_update_vt(struct seat *seat) { + int tty0fd = terminal_open(0); + if (tty0fd == -1) { + log_errorf("Could not open tty0 to update VT: %s", strerror(errno)); + return; + } + seat->cur_vt = terminal_current_vt(tty0fd); + close(tty0fd); +} + +static int vt_open(int vt) { + assert(vt != -1); + int ttyfd = terminal_open(vt); + if (ttyfd == -1) { + log_errorf("Could not open terminal for VT %d: %s", vt, strerror(errno)); + return -1; + } + + terminal_set_process_switching(ttyfd, true); + terminal_set_keyboard(ttyfd, false); + terminal_set_graphics(ttyfd, true); + close(ttyfd); + return 0; +} + +static int vt_close(int vt) { + int ttyfd = terminal_open(vt); + if (ttyfd == -1) { + log_errorf("Could not open terminal to clean up VT %d: %s", vt, strerror(errno)); + return -1; + } + terminal_set_process_switching(ttyfd, true); + terminal_set_graphics(ttyfd, false); + terminal_set_keyboard(ttyfd, true); + close(ttyfd); + return 0; +} + +static int vt_switch(struct seat *seat, int vt) { + int ttyfd = terminal_open(seat->cur_vt); + if (ttyfd == -1) { + log_errorf("Could not open terminal to switch to VT %d: %s", vt, strerror(errno)); + return -1; + } + terminal_set_process_switching(ttyfd, true); + terminal_switch_vt(ttyfd, vt); + close(ttyfd); + return 0; +} + +static int vt_ack(struct seat *seat, bool release) { + int tty0fd = terminal_open(seat->cur_vt); + log_debugf("vt_ack VT %d %d\n", seat->cur_vt, release); + if (tty0fd == -1) { + log_errorf("Could not open tty0 to ack VT signal: %s", strerror(errno)); + return -1; + } + if (release) { + terminal_ack_release(tty0fd); + } else { + terminal_ack_acquire(tty0fd); + } + close(tty0fd); + return 0; +} + int seat_add_client(struct seat *seat, struct client *client) { assert(seat); assert(client); if (client->seat != NULL) { - log_error("cannot add client: client is already a member of a seat"); + log_error("Could not add client: client is already a member of a seat"); + errno = EBUSY; return -1; } - if (seat->vt_bound && seat->active_client != NULL) { - log_error("cannot add client: seat is vt_bound and an active client already exists"); + if (seat->vt_bound && seat->active_client != NULL && + seat->active_client->state != CLIENT_PENDING_DISABLE) { + log_error("Could not add client: seat is VT-bound and has an active client"); + errno = EBUSY; return -1; } + if (client->session != -1) { + log_error("Could not add client: client cannot be reused"); + errno = EINVAL; + return -1; + } + + if (seat->vt_bound) { + seat_update_vt(seat); + if (seat->cur_vt == -1) { + log_error("Could not determine VT for client"); + errno = EINVAL; + return -1; + } + if (seat->active_client != NULL) { + for (struct linked_list *elem = seat->clients.next; elem != &seat->clients; + elem = elem->next) { + struct client *client = (struct client *)elem; + if (client->session == seat->cur_vt) { + log_error("Could not add client: seat is VT-bound and already has pending client"); + errno = EBUSY; + return -1; + } + } + } + client->session = seat->cur_vt; + } else { + client->session = seat->session_cnt++; + } + client->seat = seat; + log_infof("Added client %d to %s", client->session, seat->seat_name); - linked_list_insert(&seat->clients, &client->link); - log_debug("added client"); return 0; } @@ -75,10 +178,6 @@ int seat_remove_client(struct client *client) { assert(client->seat); struct seat *seat = client->seat; - - // We must first remove the client to avoid reactivation - linked_list_remove(&client->link); - if (seat->next_client == client) { seat->next_client = NULL; } @@ -88,12 +187,10 @@ int seat_remove_client(struct client *client) { seat_close_device(client, device); } - if (seat->active_client == client) { - seat_close_client(client); - } + seat_close_client(client); client->seat = NULL; - log_debug("removed client"); + log_infof("Removed client %d from %s", client->session, seat->seat_name); return 0; } @@ -120,19 +217,18 @@ struct seat_device *seat_open_device(struct client *client, const char *path) { assert(strlen(path) > 0); struct seat *seat = client->seat; - if (client != seat->active_client) { - errno = EPERM; - return NULL; - } + log_debugf("Opening device %s for client %d on %s", path, client->session, seat->seat_name); - if (client->pending_disable) { + if (client->state != CLIENT_ACTIVE) { + log_error("Could open device: client is not active"); errno = EPERM; return NULL; } + assert(seat->active_client == client); char sanitized_path[PATH_MAX]; if (realpath(path, sanitized_path) == NULL) { - log_errorf("invalid path '%s': %s", path, strerror(errno)); + log_errorf("Could not canonicalize path %s: %s", path, strerror(errno)); return NULL; } @@ -141,61 +237,65 @@ struct seat_device *seat_open_device(struct client *client, const char *path) { type = SEAT_DEVICE_TYPE_EVDEV; } else if (path_is_drm(sanitized_path)) { type = SEAT_DEVICE_TYPE_DRM; + } else if (path_is_wscons(sanitized_path)) { + type = SEAT_DEVICE_TYPE_WSCONS; } else { - log_errorf("invalid path '%s'", sanitized_path); + log_errorf("%s is not a supported device type ", sanitized_path); errno = ENOENT; return NULL; } int device_id = 1; size_t device_count = 0; + struct seat_device *device = NULL; for (struct linked_list *elem = client->devices.next; elem != &client->devices; elem = elem->next) { - struct seat_device *device = (struct seat_device *)elem; + struct seat_device *old_device = (struct seat_device *)elem; - // If the device already exists, increase the ref count and - // return it. - if (strcmp(device->path, path) == 0) { - device->ref_cnt++; - return device; + if (strcmp(old_device->path, sanitized_path) == 0) { + old_device->ref_cnt++; + device = old_device; + goto done; } - // If the device has a higher id, up our device id - if (device->device_id >= device_id) { - device_id = device->device_id + 1; + if (old_device->device_id >= device_id) { + device_id = old_device->device_id + 1; } device_count++; } if (device_count >= MAX_SEAT_DEVICES) { - log_error("max seat devices exceeded"); + log_error("Client exceeded max seat devices"); errno = EMFILE; return NULL; } int fd = open(sanitized_path, O_RDWR | O_NOCTTY | O_NOFOLLOW | O_CLOEXEC | O_NONBLOCK); if (fd == -1) { - log_errorf("could not open file: %s", strerror(errno)); + log_errorf("Could not open file: %s", strerror(errno)); return NULL; } switch (type) { case SEAT_DEVICE_TYPE_DRM: if (drm_set_master(fd) == -1) { - log_debugf("drm_set_master failed: %s", strerror(errno)); + log_errorf("Could not make device fd drm master: %s", strerror(errno)); } break; case SEAT_DEVICE_TYPE_EVDEV: // Nothing to do here break; + case SEAT_DEVICE_TYPE_WSCONS: + // Nothing to do here + break; default: - log_error("invalid seat device type"); + log_error("Invalid seat device type"); abort(); } - struct seat_device *device = calloc(1, sizeof(struct seat_device)); + device = calloc(1, sizeof(struct seat_device)); if (device == NULL) { - log_errorf("could not alloc device for '%s': %s", sanitized_path, strerror(errno)); + log_errorf("Allocation failed: %s", strerror(errno)); close(fd); errno = ENOMEM; return NULL; @@ -203,67 +303,25 @@ struct seat_device *seat_open_device(struct client *client, const char *path) { device->path = strdup(sanitized_path); if (device->path == NULL) { - log_errorf("could not dup path for '%s': %s", sanitized_path, strerror(errno)); + log_errorf("Allocation failed: %s", strerror(errno)); close(fd); free(device); return NULL; } - log_debugf("seat: %p, client: %p, path: '%s', device_id: %d", (void *)seat, (void *)client, - path, device_id); - device->ref_cnt = 1; device->type = type; device->fd = fd; device->device_id = device_id; device->active = true; linked_list_insert(&client->devices, &device->link); + +done: + return device; } -int seat_close_device(struct client *client, struct seat_device *seat_device) { - assert(client); - assert(client->seat); - assert(seat_device && seat_device->fd != -1); - - log_debugf("seat: %p, client: %p, path: '%s', device_id: %d", (void *)client->seat, - (void *)client, seat_device->path, seat_device->device_id); - - seat_device->ref_cnt--; - if (seat_device->ref_cnt > 0) { - // We still have more references to this device, so leave it be. - return 0; - } - - // The ref count hit zero, so destroy the device - linked_list_remove(&seat_device->link); - if (seat_device->active && seat_device->fd != -1) { - switch (seat_device->type) { - case SEAT_DEVICE_TYPE_DRM: - if (drm_drop_master(seat_device->fd) == -1) { - log_debugf("drm_drop_master failed: %s", strerror(errno)); - } - break; - case SEAT_DEVICE_TYPE_EVDEV: - if (evdev_revoke(seat_device->fd) == -1) { - log_debugf("evdev_revoke failed: %s", strerror(errno)); - } - break; - default: - log_error("invalid seat device type"); - abort(); - } - close(seat_device->fd); - seat_device->fd = -1; - } - free(seat_device->path); - free(seat_device); - return 0; -} - -static int seat_deactivate_device(struct client *client, struct seat_device *seat_device) { - assert(client); - assert(client->seat); +static int seat_deactivate_device(struct seat_device *seat_device) { assert(seat_device && seat_device->fd > 0); if (!seat_device->active) { @@ -272,24 +330,50 @@ static int seat_deactivate_device(struct client *client, struct seat_device *sea switch (seat_device->type) { case SEAT_DEVICE_TYPE_DRM: if (drm_drop_master(seat_device->fd) == -1) { - log_debugf("drm_drop_master failed: %s", strerror(errno)); + log_errorf("Could not revoke drm master on device fd: %s", strerror(errno)); return -1; } break; case SEAT_DEVICE_TYPE_EVDEV: if (evdev_revoke(seat_device->fd) == -1) { - log_debugf("evdev_revoke failed: %s", strerror(errno)); + log_errorf("Could not revoke evdev on device fd: %s", strerror(errno)); return -1; } break; + case SEAT_DEVICE_TYPE_WSCONS: + // Nothing to do here + break; default: - log_error("invalid seat device type"); + log_error("Invalid seat device type"); abort(); } seat_device->active = false; return 0; } +int seat_close_device(struct client *client, struct seat_device *seat_device) { + assert(client); + assert(client->seat); + assert(seat_device && seat_device->fd != -1); + + log_debugf("Closing device %s for client %d on %s", seat_device->path, client->session, + client->seat->seat_name); + + seat_device->ref_cnt--; + if (seat_device->ref_cnt > 0) { + return 0; + } + + linked_list_remove(&seat_device->link); + if (seat_device->fd != -1) { + seat_deactivate_device(seat_device); + close(seat_device->fd); + } + free(seat_device->path); + free(seat_device); + return 0; +} + static int seat_activate_device(struct client *client, struct seat_device *seat_device) { assert(client); assert(client->seat); @@ -301,102 +385,145 @@ static int seat_activate_device(struct client *client, struct seat_device *seat_ switch (seat_device->type) { case SEAT_DEVICE_TYPE_DRM: if (drm_set_master(seat_device->fd) == -1) { - log_debugf("drmset_master failed: %s", strerror(errno)); + log_errorf("Could not make device fd drm master: %s", strerror(errno)); } seat_device->active = true; break; case SEAT_DEVICE_TYPE_EVDEV: errno = EINVAL; return -1; + case SEAT_DEVICE_TYPE_WSCONS: + // Nothing to do here + break; default: - log_error("invalid seat device type"); + log_error("Invalid seat device type"); abort(); } return 0; } +static int seat_activate(struct seat *seat) { + assert(seat); + + if (seat->active_client != NULL) { + return 0; + } + + struct client *next_client = NULL; + if (seat->next_client != NULL) { + log_debugf("Activating next queued client on %s", seat->seat_name); + next_client = seat->next_client; + seat->next_client = NULL; + } else if (linked_list_empty(&seat->clients)) { + log_infof("No clients on %s to activate", seat->seat_name); + return -1; + } else if (seat->vt_bound && seat->cur_vt == -1) { + return -1; + } else if (seat->vt_bound) { + for (struct linked_list *elem = seat->clients.next; elem != &seat->clients; + elem = elem->next) { + struct client *client = (struct client *)elem; + if (client->session == seat->cur_vt) { + log_debugf("Activating client belonging to VT %d", seat->cur_vt); + next_client = client; + goto done; + } + } + + log_infof("No clients belonging to VT %d to activate", seat->cur_vt); + return -1; + } else { + log_debugf("Activating first client on %s", seat->seat_name); + next_client = (struct client *)seat->clients.next; + } + +done: + return seat_open_client(seat, next_client); +} + int seat_open_client(struct seat *seat, struct client *client) { assert(seat); assert(client); - if (seat->vt_bound && client->seat_vt == 0) { - int tty0fd = terminal_open(0); - if (tty0fd == -1) { - log_errorf("unable to open tty0: %s", strerror(errno)); - return -1; - } - client->seat_vt = terminal_current_vt(tty0fd); - close(tty0fd); - if (client->seat_vt == -1) { - log_errorf("unable to get current VT for client: %s", strerror(errno)); - client->seat_vt = 0; - return -1; - } + if (client->state != CLIENT_NEW && client->state != CLIENT_DISABLED) { + log_error("Could not enable client: client is not new or disabled"); + errno = EALREADY; + return -1; } if (seat->active_client != NULL) { - log_error("client already active"); + log_error("Could not enable client: seat already has an active client"); errno = EBUSY; return -1; } - assert(seat->curttyfd == -1); - - if (seat->vt_bound) { - int ttyfd = terminal_open(client->seat_vt); - if (ttyfd == -1) { - log_errorf("unable to open tty for vt %d: %s", client->seat_vt, - strerror(errno)); - return -1; - } - terminal_set_process_switching(ttyfd, true); - terminal_set_keyboard(ttyfd, false); - terminal_set_graphics(ttyfd, true); - seat->curttyfd = ttyfd; + if (seat->vt_bound && vt_open(client->session) == -1) { + log_error("Could not open VT for client"); + goto error; } for (struct linked_list *elem = client->devices.next; elem != &client->devices; elem = elem->next) { struct seat_device *device = (struct seat_device *)elem; if (seat_activate_device(client, device) == -1) { - log_errorf("unable to activate '%s': %s", device->path, strerror(errno)); + log_errorf("Could not activate %s: %s", device->path, strerror(errno)); } } + client->state = CLIENT_ACTIVE; seat->active_client = client; if (client_send_enable_seat(client) == -1) { - log_error("could not send enable signal"); - return -1; + log_error("Could not send enable signal to client"); + goto error; } - log_info("client successfully enabled"); + log_infof("Opened client %d on %s", client->session, seat->seat_name); return 0; + +error: + if (seat->vt_bound) { + vt_close(seat->cur_vt); + } + return -1; } -int seat_close_client(struct client *client) { +static int seat_close_client(struct client *client) { assert(client); assert(client->seat); struct seat *seat = client->seat; - if (seat->active_client != client) { - log_error("client not active"); - errno = EBUSY; - return -1; - } - while (!linked_list_empty(&client->devices)) { struct seat_device *device = (struct seat_device *)client->devices.next; if (seat_close_device(client, device) == -1) { - log_errorf("unable to close '%s': %s", device->path, strerror(errno)); + log_errorf("Could not close %s: %s", device->path, strerror(errno)); } } - client->pending_disable = false; - seat->active_client = NULL; - seat_activate(seat); - log_debug("closed client"); + bool was_current = seat->active_client == client; + if (was_current) { + seat->active_client = NULL; + seat_activate(seat); + } + + if (seat->vt_bound) { + if (was_current && seat->active_client == NULL) { + // This client was current, but there were no clients + // waiting to take this VT, so clean it up. + log_debug("Closing active VT"); + vt_close(seat->cur_vt); + } else if (!was_current && client->state != CLIENT_CLOSED) { + // This client was not current, but as the client was + // running, we need to clean up the VT. + log_debug("Closing inactive VT"); + vt_close(client->session); + } + } + + client->state = CLIENT_CLOSED; + log_infof("Closed client %d on %s", client->session, seat->seat_name); + return 0; } @@ -406,11 +533,12 @@ static int seat_disable_client(struct client *client) { struct seat *seat = client->seat; - if (seat->active_client != client) { - log_error("client not active"); + if (client->state != CLIENT_ACTIVE) { + log_error("Could not disable client: client is not active"); errno = EBUSY; return -1; } + assert(seat->active_client == client); // We *deactivate* all remaining fds. These may later be reactivated. // The reason we cannot just close them is that certain device fds, such @@ -419,18 +547,18 @@ static int seat_disable_client(struct client *client) { for (struct linked_list *elem = client->devices.next; elem != &client->devices; elem = elem->next) { struct seat_device *device = (struct seat_device *)elem; - if (seat_deactivate_device(client, device) == -1) { - log_errorf("unable to deactivate '%s': %s", device->path, strerror(errno)); + if (seat_deactivate_device(device) == -1) { + log_errorf("Could not deactivate %s: %s", device->path, strerror(errno)); } } - client->pending_disable = true; + client->state = CLIENT_PENDING_DISABLE; if (client_send_disable_seat(seat->active_client) == -1) { - log_error("could not send disable event"); + log_error("Could not send disable event"); return -1; } - log_debug("disabling client"); + log_infof("Disabling client %d on %s", client->session, seat->seat_name); return 0; } @@ -439,17 +567,25 @@ int seat_ack_disable_client(struct client *client) { assert(client->seat); struct seat *seat = client->seat; - - if (seat->active_client != client || !client->pending_disable) { - log_error("client not active or not pending disable"); + if (client->state != CLIENT_PENDING_DISABLE) { + log_error("Could not ack disable: client is not pending disable"); errno = EBUSY; return -1; } - client->pending_disable = false; + client->state = CLIENT_DISABLED; + log_infof("Disabled client %d on %s", client->session, seat->seat_name); + + if (seat->active_client != client) { + return 0; + } + seat->active_client = NULL; seat_activate(seat); - log_debug("disabled client"); + + // If we're VT-bound, we've either de-activated a client on a foreign + // VT, in which case we need to do nothing, or disabled the current VT, + // in which case seat_activate would just immediately re-enable it. return 0; } @@ -459,186 +595,89 @@ int seat_set_next_session(struct client *client, int session) { struct seat *seat = client->seat; - if (seat->active_client != client || client->pending_disable) { - log_error("client not active or pending disable"); + if (client->state != CLIENT_ACTIVE) { + log_error("Could not set next session: client is not active"); errno = EPERM; return -1; } + assert(seat->active_client == client); - if (session == client_get_session(client)) { - log_info("requested session is already active"); - return 0; - } - - // Check if the session number is valid if (session <= 0) { - log_errorf("invalid session value: %d", session); + log_errorf("Could not set next session: invalid session value %d", session); errno = EINVAL; return -1; } - // Check if a switch is already queued - if (seat->next_vt > 0 || seat->next_client != NULL) { - log_info("switch is already queued"); + if (session == client->session) { + log_info("Could not set next session: requested session is already active"); + return 0; + } + + if (seat->next_client != NULL) { + log_info("Could not set next session: switch is already queued"); + return 0; + } + + if (seat->vt_bound) { + log_infof("Switching from VT %d to VT %d", seat->cur_vt, session); + if (vt_switch(seat, session) == -1) { + log_error("Could not switch VT"); + return -1; + } return 0; } struct client *target = NULL; - for (struct linked_list *elem = seat->clients.next; elem != &seat->clients; elem = elem->next) { struct client *c = (struct client *)elem; - if (client_get_session(c) == session) { + if (c->session == session) { target = c; break; } } - if (target != NULL) { - log_info("queuing switch to different client"); - seat->next_client = target; - seat->next_vt = 0; - } else if (seat->vt_bound) { - log_info("queuing switch to different VT"); - seat->next_vt = session; - seat->next_client = NULL; - } else { - log_error("no valid switch available"); + if (target == NULL) { + log_error("Could not set next session: no such client"); errno = EINVAL; return -1; } + log_infof("Queuing switch to client %d on %s", session, seat->seat_name); + seat->next_client = target; seat_disable_client(seat->active_client); return 0; } -int seat_activate(struct seat *seat) { +int seat_vt_activate(struct seat *seat) { assert(seat); - - // We already have an active client! - if (seat->active_client != NULL) { - return 0; - } - - int vt = -1; - if (seat->vt_bound) { - int ttyfd = terminal_open(0); - if (ttyfd == -1) { - log_errorf("unable to open tty0: %s", strerror(errno)); - return -1; - } - - // If we need to ack a switch, do that - if (seat->vt_pending_ack) { - log_info("acking pending VT switch"); - seat->vt_pending_ack = false; - if (seat->curttyfd != -1) { - terminal_set_process_switching(seat->curttyfd, true); - terminal_set_keyboard(seat->curttyfd, true); - terminal_set_graphics(seat->curttyfd, false); - close(seat->curttyfd); - seat->curttyfd = -1; - } - return 0; - } - - // If we're asked to do a simple VT switch, do that - if (seat->next_vt > 0) { - log_info("executing VT switch"); - if (seat->curttyfd != -1) { - terminal_set_process_switching(seat->curttyfd, true); - terminal_set_keyboard(seat->curttyfd, true); - terminal_set_graphics(seat->curttyfd, false); - close(seat->curttyfd); - seat->curttyfd = -1; - } - terminal_switch_vt(ttyfd, seat->next_vt); - seat->next_vt = 0; - close(ttyfd); - return 0; - } - - // We'll need the VT below - vt = terminal_current_vt(ttyfd); - if (vt == -1) { - log_errorf("unable to get vt: %s", strerror(errno)); - close(ttyfd); - return -1; - } - close(ttyfd); - } - - // Try to pick a client for activation - struct client *next_client = NULL; - if (seat->next_client != NULL) { - // A specific client has been requested, use it - next_client = seat->next_client; - seat->next_client = NULL; - } else if (!linked_list_empty(&seat->clients) && seat->vt_bound) { - // No client is requested, try to find an applicable one - for (struct linked_list *elem = seat->clients.next; elem != &seat->clients; - elem = elem->next) { - struct client *client = (struct client *)elem; - if (client->seat_vt == vt) { - next_client = client; - break; - } - } - } else if (!linked_list_empty(&seat->clients)) { - next_client = (struct client *)seat->clients.next; - } - - if (next_client == NULL) { - // No suitable client found - log_info("no client suitable for activation"); - if (seat->vt_bound && seat->curttyfd != -1) { - terminal_set_process_switching(seat->curttyfd, false); - terminal_set_keyboard(seat->curttyfd, true); - terminal_set_graphics(seat->curttyfd, false); - close(seat->curttyfd); - seat->curttyfd = -1; - } + if (!seat->vt_bound) { + log_debug("VT activation on non VT-bound seat, ignoring"); return -1; } - - log_info("activating next client"); - if (seat->vt_bound && next_client->seat_vt != vt) { - int ttyfd = terminal_open(0); - if (ttyfd == -1) { - log_errorf("unable to open tty0: %s", strerror(errno)); - return -1; - } - terminal_switch_vt(ttyfd, next_client->seat_vt); - close(ttyfd); - } - - return seat_open_client(seat, next_client); -} - -int seat_prepare_vt_switch(struct seat *seat) { - assert(seat); - + seat_update_vt(seat); + log_debug("Activating VT"); + vt_ack(seat, false); if (seat->active_client == NULL) { - log_info("no active client, performing switch immediately"); - int tty0fd = terminal_open(0); - if (tty0fd == -1) { - log_errorf("unable to open tty0: %s", strerror(errno)); - return -1; - } - terminal_ack_switch(tty0fd); - close(tty0fd); - return 0; + seat_activate(seat); } - - if (seat->vt_pending_ack) { - log_info("impatient user, killing session to force pending switch"); - seat_close_client(seat->active_client); - return 0; - } - - log_debug("delaying VT switch acknowledgement"); - - seat->vt_pending_ack = true; - seat_disable_client(seat->active_client); + return 0; +} + +int seat_vt_release(struct seat *seat) { + assert(seat); + if (!seat->vt_bound) { + log_debug("VT release request on non VT-bound seat, ignoring"); + return -1; + } + seat_update_vt(seat); + + log_debug("Releasing VT"); + if (seat->active_client != NULL) { + seat_disable_client(seat->active_client); + } + + vt_ack(seat, true); + seat->cur_vt = -1; return 0; } diff --git a/seatd/seatd.c b/seatd/seatd.c index ce4d2bb..f88e6c9 100644 --- a/seatd/seatd.c +++ b/seatd/seatd.c @@ -17,14 +17,14 @@ #define LISTEN_BACKLOG 16 -static int open_socket(char *path, int uid, int gid) { +static int open_socket(const char *path, int uid, int gid) { union { struct sockaddr_un unix; struct sockaddr generic; } addr = {{0}}; int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0); if (fd == -1) { - log_errorf("could not create socket: %s", strerror(errno)); + log_errorf("Could not create socket: %s", strerror(errno)); return -1; } @@ -32,59 +32,61 @@ static int open_socket(char *path, int uid, int gid) { strncpy(addr.unix.sun_path, path, sizeof addr.unix.sun_path - 1); socklen_t size = offsetof(struct sockaddr_un, sun_path) + strlen(addr.unix.sun_path); if (bind(fd, &addr.generic, size) == -1) { - log_errorf("could not bind socket: %s", strerror(errno)); - close(fd); - return -1; + log_errorf("Could not bind socket: %s", strerror(errno)); + goto error; } if (listen(fd, LISTEN_BACKLOG) == -1) { - log_errorf("could not listen on socket: %s", strerror(errno)); - close(fd); - return -1; + log_errorf("Could not listen on socket: %s", strerror(errno)); + goto error; } - if (uid != 0 || gid != 0) { + if (uid != -1 || gid != -1) { + if (chmod(path, 0770) == -1) { + log_errorf("Could not chmod socket: %s", strerror(errno)); + goto error; + } if (chown(path, uid, gid) == -1) { - log_errorf("could not chown socket to uid %d, gid %d: %s", uid, gid, + log_errorf("Could not chown socket to uid %d, gid %d: %s", uid, gid, strerror(errno)); - } else if (chmod(path, 0770) == -1) { - log_errorf("could not chmod socket: %s", strerror(errno)); + goto error; } } return fd; +error: + close(fd); + return -1; } int main(int argc, char *argv[]) { - char *loglevel = getenv("SEATD_LOGLEVEL"); - enum libseat_log_level level = LIBSEAT_LOG_LEVEL_ERROR; - if (loglevel != NULL) { - if (strcmp(loglevel, "silent") == 0) { - level = LIBSEAT_LOG_LEVEL_SILENT; - } else if (strcmp(loglevel, "info") == 0) { - level = LIBSEAT_LOG_LEVEL_INFO; - } else if (strcmp(loglevel, "debug") == 0) { - level = LIBSEAT_LOG_LEVEL_DEBUG; - } - } - log_init(); - libseat_set_log_level(level); - const char *usage = "Usage: seatd [options]\n" "\n" " -h Show this help message\n" + " -n FD to notify readiness on\n" " -u User to own the seatd socket\n" " -g Group to own the seatd socket\n" - " -s Where to create the seatd socket\n" + " -l Log-level, one of debug, info, error or silent\n" " -v Show the version number\n" "\n"; int c; - int uid = 0, gid = 0; - char *socket_path = getenv("SEATD_SOCK"); - while ((c = getopt(argc, argv, "vhs:g:u:")) != -1) { + int uid = -1, gid = -1; + int readiness = -1; + bool unlink_existing_socket = true; + bool chown_socket = true; + enum libseat_log_level level = LIBSEAT_LOG_LEVEL_INFO; + while ((c = getopt(argc, argv, "vhn:g:u:l:z")) != -1) { switch (c) { - case 's': - socket_path = optarg; + case 'n': + readiness = atoi(optarg); + if (readiness < 0) { + fprintf(stderr, "Invalid readiness fd: %s\n", optarg); + return 1; + } break; case 'u': { + if (!chown_socket) { + fprintf(stderr, "-u/-g and -z are mutually exclusive\n"); + return 1; + } struct passwd *pw = getpwnam(optarg); if (pw == NULL) { fprintf(stderr, "Could not find user by name '%s'.\n", optarg); @@ -95,6 +97,10 @@ int main(int argc, char *argv[]) { break; } case 'g': { + if (!chown_socket) { + fprintf(stderr, "-u/-g and -z are mutually exclusive\n"); + return 1; + } struct group *gr = getgrnam(optarg); if (gr == NULL) { fprintf(stderr, "Could not find group by name '%s'.\n", optarg); @@ -104,6 +110,31 @@ int main(int argc, char *argv[]) { } break; } + case 'l': + if (strcmp(optarg, "debug") == 0) { + level = LIBSEAT_LOG_LEVEL_DEBUG; + } else if (strcmp(optarg, "info") == 0) { + level = LIBSEAT_LOG_LEVEL_INFO; + } else if (strcmp(optarg, "error") == 0) { + level = LIBSEAT_LOG_LEVEL_ERROR; + } else if (strcmp(optarg, "silent") == 0) { + level = LIBSEAT_LOG_LEVEL_SILENT; + } else { + fprintf(stderr, "Invalid loglevel: %s\n", optarg); + return 1; + } + break; + case 'z': + // Running under seatd-launch. We do not unlink files + // to protect against multiple instances, and + // seatd-launch takes care of ownership. + if (uid != -1 || gid != -1) { + fprintf(stderr, "-u/-g and -z are mutually exclusive\n"); + return 1; + } + unlink_existing_socket = false; + chown_socket = false; + break; case 'v': printf("seatd version %s\n", SEATD_VERSION); return 0; @@ -118,45 +149,72 @@ int main(int argc, char *argv[]) { } } - if (socket_path == NULL) { - socket_path = "/run/seatd.sock"; - struct stat st; - if (stat(socket_path, &st) == 0) { - log_info("removing leftover seatd socket"); - unlink(socket_path); + log_init(); + libseat_set_log_level(level); + + struct stat st; + if (lstat(SEATD_DEFAULTPATH, &st) == 0) { + if (!S_ISSOCK(st.st_mode)) { + log_errorf("Non-socket file found at socket path %s, refusing to start", + SEATD_DEFAULTPATH); + return 1; + } else if (!unlink_existing_socket) { + log_errorf("Socket file found at socket path %s, refusing to start", + SEATD_DEFAULTPATH); + return 1; + } else { + // We only do this if the socket path is not user specified + log_infof("Removing leftover socket at %s", SEATD_DEFAULTPATH); + if (unlink(SEATD_DEFAULTPATH) == -1) { + log_errorf("Could not remove leftover socket: %s", strerror(errno)); + return 1; + } } } struct server server = {0}; if (server_init(&server) == -1) { - log_errorf("server_create failed: %s", strerror(errno)); + log_errorf("server_init failed: %s", strerror(errno)); return 1; } - int socket_fd = open_socket(socket_path, uid, gid); + int ret = 1; + int socket_fd = open_socket(SEATD_DEFAULTPATH, uid, gid); if (socket_fd == -1) { - log_errorf("could not create server socket: %s", strerror(errno)); - server_finish(&server); - return 1; + log_error("Could not create server socket"); + goto error_server; } if (poller_add_fd(&server.poller, socket_fd, EVENT_READABLE, server_handle_connection, &server) == NULL) { - log_errorf("could not add socket to poller: %s", strerror(errno)); + log_errorf("Could not add socket to poller: %s", strerror(errno)); close(socket_fd); - server_finish(&server); - return 1; + goto error_socket; } log_info("seatd started"); + if (readiness != -1) { + if (write(readiness, "\n", 1) == -1) { + log_errorf("Could not write readiness signal: %s\n", strerror(errno)); + } + close(readiness); + } + while (server.running) { if (poller_poll(&server.poller) == -1) { - log_errorf("poller failed: %s", strerror(errno)); - return 1; + log_errorf("Poller failed: %s", strerror(errno)); + goto error_socket; } } + ret = 0; + +error_socket: + if (unlink(SEATD_DEFAULTPATH) == -1) { + log_errorf("Could not remove socket: %s", strerror(errno)); + } +error_server: server_finish(&server); - unlink(socket_path); - return 0; + log_info("seatd stopped"); + return ret; } diff --git a/seatd/server.c b/seatd/server.c index 7368ea3..47d6e91 100644 --- a/seatd/server.c +++ b/seatd/server.c @@ -12,7 +12,6 @@ #include #include "client.h" -#include "list.h" #include "log.h" #include "poller.h" #include "seat.h" @@ -24,9 +23,13 @@ static int server_handle_vt_rel(int signal, void *data); static int server_handle_kill(int signal, void *data); int server_init(struct server *server) { - poller_init(&server->poller); + if (poller_init(&server->poller) == -1) { + log_errorf("could not initialize poller: %s", strerror(errno)); + return -1; + } - list_init(&server->seats); + linked_list_init(&server->seats); + linked_list_init(&server->idle_clients); if (poller_add_signal(&server->poller, SIGUSR1, server_handle_vt_rel, server) == NULL || poller_add_signal(&server->poller, SIGUSR2, server_handle_vt_acq, server) == NULL || @@ -45,24 +48,28 @@ int server_init(struct server *server) { return -1; } - list_add(&server->seats, seat); + linked_list_insert(&server->seats, &seat->link); server->running = true; return 0; } void server_finish(struct server *server) { assert(server); - for (size_t idx = 0; idx < server->seats.length; idx++) { - struct seat *seat = server->seats.items[idx]; + while (!linked_list_empty(&server->idle_clients)) { + struct client *client = (struct client *)server->idle_clients.next; + client_destroy(client); + } + while (!linked_list_empty(&server->seats)) { + struct seat *seat = (struct seat *)server->seats.next; seat_destroy(seat); } - list_free(&server->seats); poller_finish(&server->poller); } struct seat *server_get_seat(struct server *server, const char *seat_name) { - for (size_t idx = 0; idx < server->seats.length; idx++) { - struct seat *seat = server->seats.items[idx]; + for (struct linked_list *elem = server->seats.next; elem != &server->seats; + elem = elem->next) { + struct seat *seat = (struct seat *)elem; if (strcmp(seat->seat_name, seat_name) == 0) { return seat; } @@ -78,7 +85,7 @@ static int server_handle_vt_acq(int signal, void *data) { return -1; } - seat_activate(seat); + seat_vt_activate(seat); return 0; } @@ -90,7 +97,7 @@ static int server_handle_vt_rel(int signal, void *data) { return -1; } - seat_prepare_vt_switch(seat); + seat_vt_release(seat); return 0; } @@ -104,11 +111,11 @@ static int server_handle_kill(int signal, void *data) { static int set_nonblock(int fd) { int flags; if ((flags = fcntl(fd, F_GETFD)) == -1 || fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == -1) { - log_errorf("could not set FD_CLOEXEC on socket: %s", strerror(errno)); + log_errorf("Could not set FD_CLOEXEC on socket: %s", strerror(errno)); return -1; } if ((flags = fcntl(fd, F_GETFL)) == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) { - log_errorf("could not set O_NONBLOCK on socket: %s", strerror(errno)); + log_errorf("Could not set O_NONBLOCK on socket: %s", strerror(errno)); return -1; } return 0; @@ -116,20 +123,26 @@ static int set_nonblock(int fd) { int server_add_client(struct server *server, int fd) { if (set_nonblock(fd) != 0) { + log_errorf("Could not prepare new client socket: %s", strerror(errno)); close(fd); - log_errorf("could not prepare new client socket: %s", strerror(errno)); return -1; } struct client *client = client_create(server, fd); + if (client == NULL) { + log_errorf("Could not create client: %s", strerror(errno)); + close(fd); + return -1; + } + client->event_source = poller_add_fd(&server->poller, fd, EVENT_READABLE, client_handle_connection, client); if (client->event_source == NULL) { + log_errorf("Could not add client socket to poller: %s", strerror(errno)); client_destroy(client); - log_errorf("could not add client socket to poller: %s", strerror(errno)); return -1; } - log_infof("new client connected (pid: %d, uid: %d, gid: %d)", client->pid, client->uid, + log_infof("New client connected (pid: %d, uid: %d, gid: %d)", client->pid, client->uid, client->gid); return 0; } @@ -139,14 +152,14 @@ int server_handle_connection(int fd, uint32_t mask, void *data) { if (mask & (EVENT_ERROR | EVENT_HANGUP)) { shutdown(fd, SHUT_RDWR); server->running = false; - log_errorf("server socket recieved an error: %s", strerror(errno)); + log_error("Server socket received an error"); return -1; } if (mask & EVENT_READABLE) { int new_fd = accept(fd, NULL, NULL); if (fd == -1) { - log_errorf("could not accept client connection: %s", strerror(errno)); + log_errorf("Could not accept client connection: %s", strerror(errno)); return 0; } diff --git a/tests/connection.c b/tests/connection.c new file mode 100644 index 0000000..551d799 --- /dev/null +++ b/tests/connection.c @@ -0,0 +1,176 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "connection.h" +#include "test.h" + +static void test_send_one_byte(void) { + int fds[2]; + socketpair(AF_UNIX, SOCK_STREAM, 0, fds); + struct connection c1 = {.fd = fds[0]}; + struct connection c2 = {.fd = fds[1]}; + + char in = 85, out = 0; + + test_assert(connection_put(&c1, &in, sizeof in) == 0); + test_assert(connection_flush(&c1) == sizeof in); + + test_assert(connection_read(&c2) == sizeof out); + test_assert(connection_pending(&c2) == sizeof out); + test_assert(connection_get(&c2, &out, sizeof out) == sizeof out); + test_assert(out == in); + + test_assert(connection_pending(&c2) == 0); + close(fds[0]); + close(fds[1]); +} + +static void test_short_read(void) { + int fds[2]; + socketpair(AF_UNIX, SOCK_STREAM, 0, fds); + struct connection c1 = {.fd = fds[0]}; + struct connection c2 = {.fd = fds[1]}; + + char in = 85, out = 0; + int out_large = 0; + + test_assert(connection_put(&c1, &in, sizeof in) == 0); + test_assert(connection_flush(&c1) > 0); + + test_assert(connection_read(&c2) > 0); + + test_assert(connection_pending(&c2) == sizeof out); + test_assert(connection_get(&c2, &out, sizeof out_large) == -1); + test_assert(errno == EAGAIN); + + test_assert(connection_pending(&c2) == sizeof out); + test_assert(connection_get(&c2, &out, sizeof out) == sizeof out); + + test_assert(out == in); + + test_assert(connection_pending(&c2) == 0); + close(fds[0]); + close(fds[1]); +} + +static void test_long_write(void) { + int fds[2]; + socketpair(AF_UNIX, SOCK_STREAM, 0, fds); + struct connection c1 = {.fd = fds[0]}; + struct connection c2 = {.fd = fds[1]}; + + char in[CONNECTION_BUFFER_SIZE + 1]; + memset(in, 0, sizeof in); + + test_assert(connection_put(&c1, &in, sizeof in) == -1); + test_assert(errno = EAGAIN); + + test_assert(connection_read(&c2) == -1 && errno == EAGAIN); + test_assert(connection_pending(&c2) == 0); + close(fds[0]); + close(fds[1]); +} + +static void test_send_one_int(void) { + int fds[2]; + socketpair(AF_UNIX, SOCK_STREAM, 0, fds); + struct connection c1 = {.fd = fds[0]}; + struct connection c2 = {.fd = fds[1]}; + + int in = 0xDEADBEEF, out = 0; + + test_assert(connection_put(&c1, &in, sizeof in) == 0); + test_assert(connection_flush(&c1) == sizeof in); + + test_assert(connection_read(&c2) == sizeof out); + test_assert(connection_pending(&c2) == sizeof out); + test_assert(connection_get(&c2, &out, sizeof out) == sizeof out); + + test_assert(out == in); + + test_assert(connection_pending(&c2) == 0); + close(fds[0]); + close(fds[1]); +} + +static void test_restore(void) { + int fds[2]; + socketpair(AF_UNIX, SOCK_STREAM, 0, fds); + struct connection c1 = {.fd = fds[0]}; + struct connection c2 = {.fd = fds[1]}; + + int in = 0xDEADBEEF, out = 0; + + test_assert(connection_put(&c1, &in, sizeof in) == 0); + test_assert(connection_flush(&c1) == sizeof in); + + test_assert(connection_read(&c2) == sizeof out); + test_assert(connection_pending(&c2) == sizeof out); + test_assert(connection_get(&c2, &out, sizeof out) == sizeof out); + + test_assert(out == in); + + test_assert(connection_pending(&c2) == 0); + + connection_restore(&c2, sizeof out); + test_assert(connection_pending(&c2) == sizeof out); + test_assert(connection_get(&c2, &out, sizeof out) == sizeof out); + + test_assert(out == in); + + test_assert(connection_pending(&c2) == 0); + close(fds[0]); + close(fds[1]); +} + +static void test_send_variable_sequence(void) { + int fds[2]; + socketpair(AF_UNIX, SOCK_STREAM, 0, fds); + struct connection c1 = {.fd = fds[0]}; + struct connection c2 = {.fd = fds[1]}; + + char in1 = 85, out1 = 0; + int in2 = 0xDEADBEEF, out2 = 0; + uint64_t in3 = 0xCAFEDEADBEEF, out3 = 0; + char in4 = 85, out4 = 0; + + test_assert(connection_put(&c1, &in1, sizeof in1) == 0); + test_assert(connection_put(&c1, &in2, sizeof in2) == 0); + test_assert(connection_put(&c1, &in3, sizeof in3) == 0); + test_assert(connection_put(&c1, &in4, sizeof in4) == 0); + test_assert(connection_flush(&c1) > 0); + + test_assert(connection_read(&c2) > 0); + test_assert(connection_pending(&c2) > 0); + test_assert(connection_get(&c2, &out1, sizeof out1) == sizeof out1); + test_assert(connection_get(&c2, &out2, sizeof out2) == sizeof out2); + test_assert(connection_get(&c2, &out3, sizeof out3) == sizeof out3); + test_assert(connection_get(&c2, &out4, sizeof out4) == sizeof out4); + + test_assert(out1 == in1); + test_assert(out2 == in2); + test_assert(out3 == in3); + test_assert(out4 == in4); + + test_assert(connection_pending(&c2) == 0); + close(fds[0]); + close(fds[1]); +} + +int main(int argc, char *argv[]) { + (void)argc; + (void)argv; + + test_run(test_send_one_byte); + test_run(test_short_read); + test_run(test_long_write); + test_run(test_send_one_int); + test_run(test_restore); + test_run(test_send_variable_sequence); +} diff --git a/tests/linked_list.c b/tests/linked_list.c index a5704a3..6d7a995 100644 --- a/tests/linked_list.c +++ b/tests/linked_list.c @@ -1,9 +1,9 @@ -#include #include #include #include #include "linked_list.h" +#include "test.h" struct list_elem { struct linked_list link; @@ -15,10 +15,10 @@ static void test_linked_list_init(void) { linked_list_init(&list); // Both next and prev should point to self - assert(list.next == &list && list.prev == &list); + test_assert(list.next == &list && list.prev == &list); // The list should be empty - assert(linked_list_empty(&list)); + test_assert(linked_list_empty(&list)); } static void test_linked_list_single_insert(void) { @@ -29,14 +29,14 @@ static void test_linked_list_single_insert(void) { linked_list_insert(&list, &elem1.link); // Both next and prev on list should point to the elem - assert(list.next == &elem1.link && list.prev == &elem1.link); + test_assert(list.next == &elem1.link && list.prev == &elem1.link); // Both next and prev on elem should point to the list - assert(elem1.link.next == &list && elem1.link.prev == &list); + test_assert(elem1.link.next == &list && elem1.link.prev == &list); // The list and element should not be empty - assert(!linked_list_empty(&list)); - assert(!linked_list_empty(&elem1.link)); + test_assert(!linked_list_empty(&list)); + test_assert(!linked_list_empty(&elem1.link)); } static void test_linked_list_single_remove(void) { @@ -48,13 +48,13 @@ static void test_linked_list_single_remove(void) { linked_list_remove(&elem1.link); // Both next and prev on elem be NULL - assert(elem1.link.next == NULL && elem1.link.prev == NULL); + test_assert(elem1.link.next == NULL && elem1.link.prev == NULL); // Both next and prev should point to self - assert(list.next == &list && list.prev == &list); + test_assert(list.next == &list && list.prev == &list); // The list should be empty - assert(linked_list_empty(&list)); + test_assert(linked_list_empty(&list)); } static void test_linked_list_alternate_remove(void) { @@ -66,13 +66,13 @@ static void test_linked_list_alternate_remove(void) { linked_list_remove(&list); // Both next and prev on list be NULL - assert(list.next == NULL && list.prev == NULL); + test_assert(list.next == NULL && list.prev == NULL); // Both next and prev should point to self - assert(elem1.link.next == &elem1.link && elem1.link.prev == &elem1.link); + test_assert(elem1.link.next == &elem1.link && elem1.link.prev == &elem1.link); // The elem should be empty - assert(linked_list_empty(&elem1.link)); + test_assert(linked_list_empty(&elem1.link)); } static void test_linked_list_sequential_remove(void) { @@ -85,35 +85,35 @@ static void test_linked_list_sequential_remove(void) { linked_list_insert(&elem2.link, &elem3.link); // The order should now be list→elem1→elem2→elem3→list - assert(list.next == &elem1.link && list.prev == &elem3.link); - assert(elem1.link.next == &elem2.link && elem1.link.prev == &list); - assert(elem2.link.next == &elem3.link && elem2.link.prev == &elem1.link); - assert(elem3.link.next == &list && elem3.link.prev == &elem2.link); + test_assert(list.next == &elem1.link && list.prev == &elem3.link); + test_assert(elem1.link.next == &elem2.link && elem1.link.prev == &list); + test_assert(elem2.link.next == &elem3.link && elem2.link.prev == &elem1.link); + test_assert(elem3.link.next == &list && elem3.link.prev == &elem2.link); linked_list_remove(list.next); // The order should now be list→elem2→elem3→list - assert(list.next == &elem2.link && list.prev == &elem3.link); - assert(elem2.link.next == &elem3.link && elem2.link.prev == &list); - assert(elem3.link.next == &list && elem3.link.prev == &elem2.link); - assert(elem1.link.next == NULL && elem1.link.prev == NULL); + test_assert(list.next == &elem2.link && list.prev == &elem3.link); + test_assert(elem2.link.next == &elem3.link && elem2.link.prev == &list); + test_assert(elem3.link.next == &list && elem3.link.prev == &elem2.link); + test_assert(elem1.link.next == NULL && elem1.link.prev == NULL); linked_list_remove(list.next); // The order should now be list→elem3→list - assert(list.next == &elem3.link && list.prev == &elem3.link); - assert(elem3.link.next == &list && elem3.link.prev == &list); - assert(elem1.link.next == NULL && elem1.link.prev == NULL); - assert(elem2.link.next == NULL && elem2.link.prev == NULL); + test_assert(list.next == &elem3.link && list.prev == &elem3.link); + test_assert(elem3.link.next == &list && elem3.link.prev == &list); + test_assert(elem1.link.next == NULL && elem1.link.prev == NULL); + test_assert(elem2.link.next == NULL && elem2.link.prev == NULL); linked_list_remove(list.next); // The list should now be empty - assert(elem1.link.next == NULL && elem1.link.prev == NULL); - assert(elem2.link.next == NULL && elem2.link.prev == NULL); - assert(elem3.link.next == NULL && elem3.link.prev == NULL); - assert(list.next == &list && list.prev == &list); - assert(linked_list_empty(&list)); + test_assert(elem1.link.next == NULL && elem1.link.prev == NULL); + test_assert(elem2.link.next == NULL && elem2.link.prev == NULL); + test_assert(elem3.link.next == NULL && elem3.link.prev == NULL); + test_assert(list.next == &list && list.prev == &list); + test_assert(linked_list_empty(&list)); } static void test_linked_list_insert_after(void) { @@ -126,10 +126,10 @@ static void test_linked_list_insert_after(void) { linked_list_insert(&elem1.link, &elem2.link); // The order should now be list→elem1→elem2→elem3→list - assert(list.next == &elem1.link && list.prev == &elem3.link); - assert(elem1.link.next == &elem2.link && elem1.link.prev == &list); - assert(elem2.link.next == &elem3.link && elem2.link.prev == &elem1.link); - assert(elem3.link.next == &list && elem3.link.prev == &elem2.link); + test_assert(list.next == &elem1.link && list.prev == &elem3.link); + test_assert(elem1.link.next == &elem2.link && elem1.link.prev == &list); + test_assert(elem2.link.next == &elem3.link && elem2.link.prev == &elem1.link); + test_assert(elem3.link.next == &list && elem3.link.prev == &elem2.link); } static void test_linked_list_remove_loop(void) { @@ -147,13 +147,13 @@ static void test_linked_list_remove_loop(void) { linked_list_remove(&elem->link); cnt++; } - assert(cnt == 3); + test_assert(cnt == 3); // Link should now be empty, and next and prev on all elements hsould be NULL - assert(linked_list_empty(&list)); - assert(elem1.link.next == NULL && elem1.link.prev == NULL); - assert(elem2.link.next == NULL && elem2.link.prev == NULL); - assert(elem3.link.next == NULL && elem3.link.prev == NULL); + test_assert(linked_list_empty(&list)); + test_assert(elem1.link.next == NULL && elem1.link.prev == NULL); + test_assert(elem2.link.next == NULL && elem2.link.prev == NULL); + test_assert(elem3.link.next == NULL && elem3.link.prev == NULL); } static void test_linked_list_manual_iterate(void) { @@ -170,15 +170,15 @@ static void test_linked_list_manual_iterate(void) { struct list_elem *ptr = NULL; ptr = (struct list_elem *)list.next; - assert(strcmp("elem1", ptr->content) == 0); + test_assert(strcmp("elem1", ptr->content) == 0); ptr = (struct list_elem *)ptr->link.next; - assert(strcmp("elem2", ptr->content) == 0); + test_assert(strcmp("elem2", ptr->content) == 0); ptr = (struct list_elem *)ptr->link.next; - assert(strcmp("elem3", ptr->content) == 0); + test_assert(strcmp("elem3", ptr->content) == 0); - assert(ptr->link.next == &list); + test_assert(ptr->link.next == &list); } static void test_linked_list_loop_iterate(void) { @@ -195,25 +195,97 @@ static void test_linked_list_loop_iterate(void) { size_t cnt = 0; for (struct linked_list *ptr = list.next; ptr != &list; ptr = ptr->next) { struct list_elem *elem = (struct list_elem *)ptr; - assert(strcmp("elem", elem->content) == 0); + test_assert(strcmp("elem", elem->content) == 0); cnt++; } - assert(cnt == 3); + test_assert(cnt == 3); +} + +static void test_linked_list_take_empty(void) { + struct linked_list list1, list2; + linked_list_init(&list1); + linked_list_init(&list2); + + linked_list_take(&list2, &list1); + + test_assert(linked_list_empty(&list1)); + test_assert(linked_list_empty(&list2)); +} + +static void test_linked_list_take_single(void) { + struct linked_list list1, list2; + linked_list_init(&list1); + linked_list_init(&list2); + + struct list_elem elem1 = {{0}, NULL}; + linked_list_insert(&list1, &elem1.link); + + linked_list_take(&list2, &list1); + + test_assert(linked_list_empty(&list1)); + test_assert(list2.next == &elem1.link && list2.prev == &elem1.link); + test_assert(elem1.link.next == &list2 && elem1.link.prev == &list2); +} + +static void test_linked_list_take_many(void) { + struct linked_list list1, list2; + linked_list_init(&list1); + linked_list_init(&list2); + + struct list_elem elem1 = {{0}, NULL}; + struct list_elem elem2 = {{0}, NULL}; + linked_list_insert(&list1, &elem2.link); + linked_list_insert(&list1, &elem1.link); + + linked_list_take(&list2, &list1); + + test_assert(linked_list_empty(&list1)); + test_assert(list2.next == &elem1.link && list2.prev == &elem2.link); + test_assert(elem1.link.next == &elem2.link && elem1.link.prev == &list2); + test_assert(elem2.link.next == &list2 && elem2.link.prev == &elem1.link); +} + +static void test_linked_list_take_concat(void) { + struct linked_list list1, list2; + linked_list_init(&list1); + linked_list_init(&list2); + + struct list_elem elem1 = {{0}, NULL}; + struct list_elem elem2 = {{0}, NULL}; + struct list_elem elem3 = {{0}, NULL}; + struct list_elem elem4 = {{0}, NULL}; + linked_list_insert(&list1, &elem2.link); + linked_list_insert(&list1, &elem1.link); + linked_list_insert(&list2, &elem4.link); + linked_list_insert(&list2, &elem3.link); + + linked_list_take(&list2, &list1); + + test_assert(linked_list_empty(&list1)); + test_assert(list2.next == &elem1.link && list2.prev == &elem4.link); + test_assert(elem1.link.next == &elem2.link && elem1.link.prev == &list2); + test_assert(elem2.link.next == &elem3.link && elem2.link.prev == &elem1.link); + test_assert(elem3.link.next == &elem4.link && elem3.link.prev == &elem2.link); + test_assert(elem4.link.next == &list2 && elem4.link.prev == &elem3.link); } int main(int argc, char *argv[]) { (void)argc; (void)argv; - test_linked_list_init(); - test_linked_list_single_insert(); - test_linked_list_single_remove(); - test_linked_list_alternate_remove(); - test_linked_list_sequential_remove(); - test_linked_list_insert_after(); - test_linked_list_remove_loop(); - test_linked_list_manual_iterate(); - test_linked_list_loop_iterate(); + test_run(test_linked_list_init); + test_run(test_linked_list_single_insert); + test_run(test_linked_list_single_remove); + test_run(test_linked_list_alternate_remove); + test_run(test_linked_list_sequential_remove); + test_run(test_linked_list_insert_after); + test_run(test_linked_list_remove_loop); + test_run(test_linked_list_manual_iterate); + test_run(test_linked_list_loop_iterate); + test_run(test_linked_list_take_empty); + test_run(test_linked_list_take_single); + test_run(test_linked_list_take_many); + test_run(test_linked_list_take_concat); return 0; } diff --git a/tests/poller.c b/tests/poller.c new file mode 100644 index 0000000..dd36c7d --- /dev/null +++ b/tests/poller.c @@ -0,0 +1,195 @@ +#include +#include +#include +#include +#include +#include + +#include "poller.h" +#include "test.h" + +static void test_poller_init(void) { + struct poller poller; + test_assert(poller_init(&poller) == 0); + poller_finish(&poller); +} + +struct test_fd { + int fd; + uint32_t events; +}; + +static int test_fd_event(int fd, uint32_t mask, void *data) { + struct test_fd *d = data; + d->fd = fd; + d->events = mask; + return 0; +} + +static void test_poller_single_fd(void) { + struct poller poller; + test_assert(poller_init(&poller) == 0); + + int fds[2]; + test_assert(pipe(fds) == 0); + + struct test_fd evd; + struct event_source_fd *ev = + poller_add_fd(&poller, fds[0], EVENT_READABLE, test_fd_event, &evd); + test_assert(ev != NULL); + + evd.fd = 0; + evd.events = 0; + test_assert(write(fds[1], "\0", 1) == 1); + test_assert(poller_poll(&poller) == 0); + test_assert(evd.fd == fds[0]); + test_assert(evd.events == EVENT_READABLE); + + evd.fd = 0; + evd.events = 0; + test_assert(write(fds[1], "\0", 1) == 1); + test_assert(poller_poll(&poller) == 0); + test_assert(evd.fd == fds[0]); + test_assert(evd.events == EVENT_READABLE); + + close(fds[0]); + close(fds[1]); + poller_finish(&poller); +} + +static void test_poller_multi_fd(void) { + struct poller poller; + test_assert(poller_init(&poller) == 0); + + char dummy[8]; + int fdsa[2], fdsb[2]; + test_assert(pipe(fdsa) == 0); + test_assert(pipe(fdsb) == 0); + + struct test_fd evd1, evd2; + struct event_source_fd *ev1 = + poller_add_fd(&poller, fdsa[0], EVENT_READABLE, test_fd_event, &evd1); + struct event_source_fd *ev2 = + poller_add_fd(&poller, fdsb[0], EVENT_READABLE, test_fd_event, &evd2); + test_assert(ev1 != NULL); + test_assert(ev2 != NULL); + + evd1.fd = evd2.fd = 0; + evd1.events = evd2.events = 0; + test_assert(write(fdsa[1], "\0", 1) == 1); + test_assert(poller_poll(&poller) == 0); + test_assert(read(fdsa[0], &dummy, sizeof dummy) == 1); + test_assert(evd1.fd == fdsa[0]); + test_assert(evd1.events == EVENT_READABLE); + test_assert(evd2.fd == 0); + test_assert(evd2.events == 0); + + evd1.fd = evd2.fd = 0; + evd1.events = evd2.events = 0; + test_assert(write(fdsb[1], "\0", 1) == 1); + test_assert(poller_poll(&poller) == 0); + test_assert(read(fdsb[0], &dummy, sizeof dummy) == 1); + test_assert(evd1.fd == 0); + test_assert(evd1.events == 0); + test_assert(evd2.fd == fdsb[0]); + test_assert(evd2.events == EVENT_READABLE); + + evd1.fd = evd2.fd = 0; + evd1.events = evd2.events = 0; + test_assert(write(fdsa[1], "\0", 1) == 1); + test_assert(write(fdsb[1], "\0", 1) == 1); + test_assert(poller_poll(&poller) == 0); + test_assert(read(fdsa[0], &dummy, sizeof dummy) == 1); + test_assert(read(fdsb[0], &dummy, sizeof dummy) == 1); + test_assert(evd1.fd == fdsa[0]); + test_assert(evd1.events == EVENT_READABLE); + test_assert(evd2.fd == fdsb[0]); + test_assert(evd2.events == EVENT_READABLE); + + close(fdsa[0]); + close(fdsa[1]); + close(fdsb[0]); + close(fdsb[1]); + poller_finish(&poller); +} + +struct test_signal { + int signal; +}; + +static int test_signal_event(int signal, void *data) { + struct test_signal *d = data; + d->signal = signal; + return 0; +} + +#ifdef __OpenBSD__ +#define SIGRTMIN SIGUSR1 +#endif + +static void test_poller_single_signal(void) { + struct poller poller; + test_assert(poller_init(&poller) == 0); + + struct test_signal evd; + struct event_source_signal *ev = + poller_add_signal(&poller, SIGRTMIN, test_signal_event, &evd); + test_assert(ev != NULL); + + evd.signal = 0; + test_assert(kill(getpid(), SIGRTMIN) == 0); + test_assert(poller_poll(&poller) == 0); + test_assert(evd.signal == SIGRTMIN); + + evd.signal = 0; + test_assert(kill(getpid(), SIGRTMIN) == 0); + test_assert(poller_poll(&poller) == 0); + test_assert(evd.signal == SIGRTMIN); + + poller_finish(&poller); +} + +static void test_poller_multi_signal(void) { + struct poller poller; + test_assert(poller_init(&poller) == 0); + + struct test_signal evd1, evd2; + struct event_source_signal *ev1 = + poller_add_signal(&poller, SIGRTMIN, test_signal_event, &evd1); + struct event_source_signal *ev2 = + poller_add_signal(&poller, SIGRTMIN + 1, test_signal_event, &evd2); + test_assert(ev1 != NULL); + test_assert(ev2 != NULL); + + evd1.signal = evd2.signal = 0; + test_assert(kill(getpid(), SIGRTMIN) == 0); + test_assert(poller_poll(&poller) == 0); + test_assert(evd1.signal == SIGRTMIN); + test_assert(evd2.signal == 0); + + evd1.signal = evd2.signal = 0; + test_assert(kill(getpid(), SIGRTMIN + 1) == 0); + test_assert(poller_poll(&poller) == 0); + test_assert(evd1.signal == 0); + test_assert(evd2.signal == SIGRTMIN + 1); + + evd1.signal = evd2.signal = 0; + test_assert(kill(getpid(), SIGRTMIN) == 0); + test_assert(kill(getpid(), SIGRTMIN + 1) == 0); + test_assert(poller_poll(&poller) == 0); + test_assert(evd1.signal == SIGRTMIN); + test_assert(evd2.signal == SIGRTMIN + 1); + + poller_finish(&poller); +} + +int main(int argc, char *argv[]) { + (void)argc; + (void)argv; + + test_run(test_poller_init); + test_run(test_poller_single_fd); + test_run(test_poller_multi_fd); + test_run(test_poller_single_signal); + test_run(test_poller_multi_signal); +}