fix: signal a lock screen only once it handles the signal

tests/test_lockers.cpp

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+//
+// A lock screen gets a signal only once it handles it. Before that, the
+// signal would kill it and leave the screen locked for good. The lock
+// screen here is a child of the test that calls itself hyprlock, on a
+// display of its own, so no real one is ever found. The display is set by
+// starting the test again: /proc shows the environment a program started
+// with, not what it set later.
+
+#include "lockers.h"
+
+#include <QtGlobal>
+
+#include <csignal>
+#include <cstdlib>
+#include <cstdio>
+#include <poll.h>
+#include <sys/prctl.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+namespace
+{
+int failures = 0;
+
+void check(bool ok, const char *what)
+{
+    std::printf("%s  %s\n", ok ? "ok  " : "FAIL", what);
+    if (!ok) {
+        ++failures;
+    }
+}
+
+int toParent = -1;
+
+void answer(int)
+{
+    [[maybe_unused]] const ssize_t n = write(toParent, "s", 1);
+}
+
+// A byte from the child, or 0 after a second without one.
+char next(int from)
+{
+    pollfd p{from, POLLIN, 0};
+    char c = 0;
+    if (poll(&p, 1, 1000) == 1 && read(from, &c, 1) == 1) {
+        return c;
+    }
+    return 0;
+}
+
+// A hyprlock that handles SIGUSR2 or not. Says "r" when it is set up, and
+// "s" for every SIGUSR2.
+pid_t fakeHyprlock(bool handles, int *fromChild)
+{
+    int fds[2];
+    if (pipe(fds) != 0) {
+        return -1;
+    }
+    const pid_t pid = fork();
+    if (pid == 0) {
+        close(fds[0]);
+        toParent = fds[1];
+        prctl(PR_SET_NAME, "hyprlock");
+        if (handles) {
+            std::signal(SIGUSR2, answer);
+        }
+        [[maybe_unused]] const ssize_t n = write(toParent, "r", 1);
+        for (;;) {
+            pause();
+        }
+    }
+    close(fds[1]);
+    *fromChild = fds[0];
+    next(fds[0]);
+    return pid;
+}
+
+bool alive(pid_t pid)
+{
+    return waitpid(pid, nullptr, WNOHANG) == 0;
+}
+} // namespace
+
+int main(int, char **argv)
+{
+    const char *display = "fu-test-lockers";
+    if (qgetenv("WAYLAND_DISPLAY") != display) {
+        setenv("WAYLAND_DISPLAY", display, 1);
+        execv("/proc/self/exe", argv);
+        return 2;
+    }
+
+    int from = -1;
+    pid_t pid = fakeHyprlock(false, &from);
+    check(Lockers::find("hyprlock") == QList<pid_t>{pid}, "finds the lock screen on this display");
+    check(Lockers::find("swaylock").isEmpty(), "and only by that name");
+    check(Lockers::signal(SIGUSR2, "hyprlock") == 1, "one not ready yet");
+    usleep(200 * 1000);
+    check(alive(pid), "and it was left alone, alive");
+    kill(pid, SIGKILL);
+    waitpid(pid, nullptr, 0);
+    close(from);
+
+    pid = fakeHyprlock(true, &from);
+    check(Lockers::signal(SIGUSR2, "hyprlock") == 0, "a ready one gets it");
+    check(next(from) == 's', "and handles it");
+    check(alive(pid), "and lives on");
+    kill(pid, SIGKILL);
+    waitpid(pid, nullptr, 0);
+    close(from);
+
+    std::printf("\n%s\n", failures ? "SOME CHECKS FAILED" : "all checks passed");
+    return failures ? 1 : 0;
+}