More work on tentacles.

internal/platform/xorg/commands_local.c

@@ -0,0 +1,164 @@
+// Copyright (c) 2026 Storm Dragon
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "commands_native.h"
+#include <X11/extensions/XInput2.h>
+#include <X11/Xatom.h>
+#include <X11/XKBlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+// Xorg marks XTEST devices with a non-deletable, read-only property. Device
+// names and the core send_event flag are not provenance. Unknown/non-device
+// sources stay ineligible; no timing match against XRecord is involved.
+static int local_source(CommandDevice *device, int source) {
+    if (source <= 0 || source == device->localKeyboard) return 0;
+    int count = 0, allowed = 0;
+    cthulhu_x11_begin_read(device->display);
+    XIDeviceInfo *info = XIQueryDevice(device->display, source, &count);
+    if (info && count == 1 && info->use == XISlaveKeyboard && info->enabled &&
+        info->attachment == device->localKeyboard) {
+        Atom type = None;
+        int format = 0;
+        unsigned long items = 0, remaining = 0;
+        unsigned char *data = NULL;
+        Atom xtest = XInternAtom(device->display, "XTEST Device", True);
+        int result = xtest == None ? BadAtom : XIGetProperty(device->display,
+            source, xtest, 0, 1, False, AnyPropertyType, &type, &format,
+            &items, &remaining, &data);
+        // The atom must exist on the server, but not on this source device.
+        int synthetic = result != Success || type != None;
+        if (data) XFree(data);
+        data = NULL;
+        Atom node = XInternAtom(device->display, "Device Node", True);
+        if (!synthetic && node != None && XIGetProperty(device->display, source,
+            node, 0, 64, False, XA_STRING, &type, &format, &items,
+            &remaining, &data) == Success && type == XA_STRING && format == 8 &&
+            items > 16 && items < 256 && remaining == 0 && data &&
+            memcmp(data, "/dev/input/event", 16) == 0) {
+            int valid = 1;
+            for (unsigned long i = 16; i < items; i++)
+                if (data[i] < '0' || data[i] > '9') valid = 0;
+            char path[256];
+            memcpy(path, data, items);
+            path[items] = 0;
+            struct stat status;
+            if (valid && stat(path, &status) == 0 && S_ISCHR(status.st_mode))
+                allowed = 1;
+        }
+        if (data) XFree(data);
+    }
+    if (info) XIFreeDeviceInfo(info);
+    if (cthulhu_x11_end_read(device->display)) allowed = 0;
+    return allowed;
+}
+
+static int acquire_local_keyboard_unchecked(CommandDevice *device) {
+    int eventBase, errorBase, major = 2, minor = 0, pointer = 0;
+    if (device->active || !XQueryExtension(device->display, "XInputExtension",
+        &device->xiOpcode, &eventBase, &errorBase) ||
+        XIQueryVersion(device->display, &major, &minor) != Success || major < 2 ||
+        !XIGetClientPointer(device->display, None, &pointer)) return -1;
+    int count = 0, keyboard = 0;
+    XIDeviceInfo *info = XIQueryDevice(device->display, pointer, &count);
+    if (info && count == 1 && info->use == XIMasterPointer && info->enabled)
+        keyboard = info->attachment;
+    if (info) XIFreeDeviceInfo(info);
+    if (!keyboard) return -1;
+    // A key held before the dialog cannot submit it on repeat or provide an
+    // inherited modifier. The caller may retry after releasing that chord.
+    char held[32];
+    XQueryKeymap(device->display, held);
+    for (int i = 0; i < 32; i++) if (held[i]) return -1;
+    unsigned char bits[XIMaskLen(XI_LASTEVENT)] = {0};
+    XISetMask(bits, XI_KeyPress);
+    XISetMask(bits, XI_KeyRelease);
+    XIEventMask mask = {keyboard, sizeof(bits), bits};
+    int result = XIGrabDevice(device->display, keyboard, device->root, CurrentTime,
+        None, GrabModeAsync, GrabModeAsync, False, &mask);
+    if (result != GrabSuccess) return result ? result : -1;
+    unsigned char changes[XIMaskLen(XI_LASTEVENT)] = {0};
+    XISetMask(changes, XI_HierarchyChanged);
+    XIEventMask hierarchy = {XIAllDevices, sizeof(changes), changes};
+    XISelectEvents(device->display, device->root, &hierarchy, 1);
+    device->localKeyboard = keyboard;
+    memset(device->localHeld, 0, sizeof(device->localHeld));
+    // Initialize the ordinary text/compose renderer after acquiring XI2. Its
+    // core-grab branch is skipped because the device already owns capture.
+    device->active = 1;
+    acquire_internal_keyboard(device);
+    XFlush(device->display);
+    return 0;
+}
+
+int acquire_local_keyboard(CommandDevice *device) {
+    // The selected master can disappear between query and grab. Like source
+    // validation, acquisition must turn BadDevice into denial, not reader exit.
+    cthulhu_x11_begin_read(device->display);
+    int result = acquire_local_keyboard_unchecked(device);
+    int error = cthulhu_x11_end_read(device->display);
+    if (error) {
+        release_local_keyboard(device);
+        device->active = 0;
+        reset_internal_compose(device);
+        return -1;
+    }
+    return result;
+}
+
+// Convert the very same device event to the existing text renderer. Core and
+// SendEvent traffic is discarded in this mode, as are XTEST and unknown sources.
+int next_local_key(CommandDevice *device, XEvent *event) {
+    if (event->type != GenericEvent || event->xcookie.extension != device->xiOpcode ||
+        !XGetEventData(device->display, &event->xcookie)) return 0;
+    int accepted = 0;
+    XKeyEvent key = {0};
+    // Device removal/disable/reattachment invalidates this capture, including
+    // keys whose release can no longer arrive. Reopen against a fresh hierarchy.
+    if (!event->xcookie.send_event && event->xcookie.evtype == XI_HierarchyChanged) accepted = -1;
+    if (event->xcookie.evtype == XI_KeyPress || event->xcookie.evtype == XI_KeyRelease) {
+        XIDeviceEvent *input = event->xcookie.data;
+        if (!event->xcookie.send_event && !input->send_event &&
+            input->deviceid == device->localKeyboard && input->detail >= 8 &&
+            input->detail <= 255 && !(input->flags & XIKeyRepeat) &&
+            local_source(device, input->sourceid)) {
+            int code = input->detail;
+            // Duplicate downs and releases without a down in this capture
+            // lifetime cannot navigate or activate a local form.
+            if ((input->evtype == XI_KeyPress) != !!device->localHeld[code]) {
+                key.type = input->evtype == XI_KeyPress ? KeyPress : KeyRelease;
+                key.display = device->display;
+                key.window = input->event;
+                key.root = input->root;
+                key.time = input->time;
+                key.keycode = code;
+                key.same_screen = True;
+                // Ignore modifiers held by an injected source. Build state
+                // solely from keys admitted during this local capture.
+                for (int i = 8; i < 256; i++) if (device->localHeld[i])
+                    key.state |= XkbKeysymToModifiers(device->display,
+                        XkbKeycodeToKeysym(device->display, i, 0, 0));
+                device->localHeld[code] = key.type == KeyPress;
+                accepted = 1;
+            }
+        }
+    }
+    XFreeEventData(device->display, &event->xcookie);
+    if (accepted > 0) { memset(event, 0, sizeof(*event)); event->xkey = key; }
+    return accepted;
+}
+
+void release_local_keyboard(CommandDevice *device) {
+    if (device->localKeyboard) {
+        cthulhu_x11_begin_read(device->display);
+        XIUngrabDevice(device->display, device->localKeyboard, CurrentTime);
+        unsigned char bits[XIMaskLen(XI_LASTEVENT)] = {0};
+        XIEventMask mask = {XIAllDevices, sizeof(bits), bits};
+        XISelectEvents(device->display, device->root, &mask, 1);
+        // A removed master has already lost its grab. Still clear our local
+        // ownership and root event selection when XIUngrab reports BadDevice.
+        cthulhu_x11_end_read(device->display);
+        device->localKeyboard = 0;
+        memset(device->localHeld, 0, sizeof(device->localHeld));
+    }
+}