Files
DroidDeck/tools/linuxfs/preload/inputudev.c
T

1203 lines
40 KiB
C

/*
* Ported from WinNative (maxjivi05, feature/wayland-gamescope, 2026-09-18/19), GPL-3.0.
*/
#define _GNU_SOURCE
#include <dlfcn.h>
#include <errno.h>
#include <limits.h>
#include <linux/input.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <unistd.h>
#define RING_MAX 4
#define UINPUT_BASE 16
#define PAD_MAX 64
#define EVENT_MINOR_BASE 64
#define PAD_UEVENT_FORMAT \
"PRODUCT=6/28de/11ff/110\n" \
"NAME=\"Generic HID Gamepad %d\"\n" \
"PHYS=\"usb-fakeinput/input%d\"\n"
#define PAD_PHYSICAL_UEVENT_FORMAT \
"PRODUCT=3/45e/28e/110\n" \
"NAME=\"Xbox 360 Controller (%d)\"\n" \
"PHYS=\"usb-fakeinput/input%d\"\n"
#define PARENT_NAME "droiddeck-input"
#define PARENT_SYSPATH_FORMAT "/sys/devices/droiddeck%d/" PARENT_NAME "%d"
#define EVENT_SYSPATH_FORMAT PARENT_SYSPATH_FORMAT "/event%d"
struct pad {
char syspath[80];
char devnode[32];
char sysname[24];
char uevent[256];
dev_t devnum;
int node;
int parent;
int live;
};
static struct pad pads[PAD_MAX];
static struct pad parents[PAD_MAX];
static int pad_count;
static pthread_mutex_t virtual_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t enumerate_lock = PTHREAD_MUTEX_INITIALIZER;
/* The event device's parent has to answer as a separate device so that its syspath differs from
* the child's: consumers compare parent syspaths to tell gamepads apart. */
static void make_parent(int node, const struct pad *pad, struct pad *parent) {
snprintf(parent->syspath, sizeof(parent->syspath), PARENT_SYSPATH_FORMAT, node, node);
snprintf(parent->sysname, sizeof(parent->sysname), PARENT_NAME "%d", node);
parent->devnode[0] = '\0';
memcpy(parent->uevent, pad->uevent, sizeof(parent->uevent));
parent->devnum = makedev(0, 0);
parent->node = node;
parent->parent = 1;
parent->live = pad->live;
}
static void sync_parent(int node) {
make_parent(node, &pads[node], &parents[node]);
}
static void discover_pads(void) {
const char *spec = getenv("FAKE_EVDEV_MEMFD_PATHS");
const char *entry;
if (spec == NULL) return;
for (entry = spec; *entry != '\0';) {
char *end;
long slot = strtol(entry, &end, 10);
if (end != entry && *end == '=' && slot >= 0 && slot < RING_MAX) {
struct pad *pad = &pads[slot];
if (pad->devnode[0] == '\0') {
snprintf(pad->sysname, sizeof(pad->sysname), "event%ld", slot);
snprintf(pad->syspath, sizeof(pad->syspath), EVENT_SYSPATH_FORMAT, (int)slot, (int)slot,
(int)slot);
snprintf(pad->devnode, sizeof(pad->devnode), "/dev/input/event%ld", slot);
snprintf(pad->uevent, sizeof(pad->uevent), PAD_UEVENT_FORMAT, (int)slot, (int)slot);
pad->devnum = makedev(13, EVENT_MINOR_BASE + (unsigned int)slot);
pad->node = (int)slot;
pad->live = 1;
if (slot >= pad_count) pad_count = (int)slot + 1;
sync_parent((int)slot);
}
}
entry = strchr(entry, ';');
if (entry == NULL) break;
entry++;
}
}
static void ensure_pads(void) {
static pthread_once_t once = PTHREAD_ONCE_INIT;
pthread_once(&once, discover_pads);
}
static int uinput_enabled(void) {
const char *enabled = getenv("FAKE_EVDEV_UINPUT");
return enabled != NULL && atoi(enabled) != 0;
}
static int read_virtual_uevent(int node, char *buf, size_t size) {
const char *dir = getenv("FAKE_EVDEV_DIR");
char path[PATH_MAX];
FILE *file;
size_t length;
if (dir == NULL) return 0;
snprintf(path, sizeof(path), "%s/.uinput-event%d.uevent", dir, node);
if ((file = fopen(path, "re")) == NULL) return 0;
length = fread(buf, 1, size - 1, file);
fclose(file);
buf[length] = '\0';
return length > 0;
}
static int any_virtual_pad(void) {
char uevent[256];
int node;
for (node = UINPUT_BASE; node < PAD_MAX; node++)
if (read_virtual_uevent(node, uevent, sizeof(uevent))) return 1;
return 0;
}
static void refresh_locked(int node) {
struct pad *pad = &pads[node];
if (node >= UINPUT_BASE) {
char uevent[sizeof(pad->uevent)];
if (read_virtual_uevent(node, uevent, sizeof(uevent))) {
snprintf(pad->sysname, sizeof(pad->sysname), "event%d", node);
snprintf(pad->syspath, sizeof(pad->syspath), EVENT_SYSPATH_FORMAT, node, node, node);
memcpy(pad->uevent, uevent, sizeof(uevent));
pad->devnum = makedev(13, EVENT_MINOR_BASE + (unsigned int)node);
snprintf(pad->devnode, sizeof(pad->devnode), "/dev/input/event%d", node);
pad->node = node;
pad->live = 1;
if (node >= pad_count) pad_count = node + 1;
} else {
pad->devnode[0] = '\0';
pad->live = 0;
}
} else if (pad->sysname[0] != '\0') {
char path[PATH_MAX];
const char *dir = getenv("FAKE_EVDEV_DIR");
if (dir == NULL || snprintf(path, sizeof(path), "%s/event%d", dir, node) >= (int)sizeof(path) ||
access(path, F_OK) != 0) {
pad->devnode[0] = '\0';
pad->live = 0;
} else {
snprintf(pad->devnode, sizeof(pad->devnode), "/dev/input/event%d", node);
pad->live = 1;
if (uinput_enabled())
snprintf(pad->uevent, sizeof(pad->uevent),
any_virtual_pad() ? PAD_PHYSICAL_UEVENT_FORMAT : PAD_UEVENT_FORMAT, node, node);
}
}
sync_parent(node);
}
static int snapshot_pad(int node, int parent, struct pad *out) {
int found;
if (node < 0 || node >= PAD_MAX) return 0;
ensure_pads();
pthread_mutex_lock(&virtual_lock);
refresh_locked(node);
found = parent ? parents[node].live : pads[node].devnode[0] != '\0';
if (found) *out = parent ? parents[node] : pads[node];
pthread_mutex_unlock(&virtual_lock);
return found;
}
static int parse_number(const char **cursor) {
int value = 0;
if (**cursor < '0' || **cursor > '9') return -1;
while (**cursor >= '0' && **cursor <= '9') {
if (value < PAD_MAX) value = value * 10 + (*(*cursor) - '0');
(*cursor)++;
}
return value;
}
static int match_numbered(const char **cursor, const char *literal, int node) {
char expected[32];
int length = snprintf(expected, sizeof(expected), "%s%d", literal, node);
if (strncmp(*cursor, expected, (size_t)length) != 0) return 0;
*cursor += length;
return 1;
}
/* Returns the pad node behind one of our syspaths, -1 for anything else. */
static int node_from_syspath(const char *syspath, int *child) {
static const char virtual_prefix[] = "/sys/devices/virtual/input/droiddeck";
static const char child_prefix[] = "/sys/devices/droiddeck";
const char *cursor;
int node;
if (syspath == NULL) return -1;
if (strncmp(syspath, virtual_prefix, sizeof(virtual_prefix) - 1) == 0) {
cursor = syspath + sizeof(virtual_prefix) - 1;
*child = 0;
} else if (strncmp(syspath, child_prefix, sizeof(child_prefix) - 1) == 0) {
cursor = syspath + sizeof(child_prefix) - 1;
*child = 1;
} else {
return -1;
}
node = parse_number(&cursor);
if (node < 0 || node >= PAD_MAX) return -1;
if (!*child) {
if (*cursor == '\0') return node;
return match_numbered(&cursor, "/event", node) && *cursor == '\0' ? node : -1;
}
if (!match_numbered(&cursor, "/" PARENT_NAME, node)) return -1;
if (*cursor == '\0') return node;
if (!match_numbered(&cursor, "/event", node) || *cursor != '\0') return -1;
*child = 0;
return node;
}
static int syspath_pad(const char *syspath, struct pad *out) {
int child = 0;
int node = node_from_syspath(syspath, &child);
return node >= 0 && snapshot_pad(node, child, out);
}
static int sysname_pad(const char *sysname, struct pad *out) {
static const char parent_name[] = PARENT_NAME;
const char *cursor;
int parent;
int node;
if (strncmp(sysname, "event", 5) == 0) {
cursor = sysname + 5;
parent = 0;
} else if (strncmp(sysname, parent_name, sizeof(parent_name) - 1) == 0) {
cursor = sysname + sizeof(parent_name) - 1;
parent = 1;
} else {
return 0;
}
node = parse_number(&cursor);
return node >= 0 && *cursor == '\0' && snapshot_pad(node, parent, out);
}
/* Each construction hands out its own handle bound to the context that built it, so one consumer
* releasing its libudev context can never leave another consumer's device with a dangling one. */
#define HANDLE_MAX 256
static const char *const property_keys[] = {"DEVNAME", "DEVPATH", "ID_INPUT", "ID_INPUT_JOYSTICK"};
#define PROPERTY_COUNT (sizeof(property_keys) / sizeof(property_keys[0]))
struct handle {
struct pad info;
void *udev;
struct handle *parent;
int refs;
char properties[PROPERTY_COUNT];
};
static struct handle handles[HANDLE_MAX];
static pthread_mutex_t handle_lock = PTHREAD_MUTEX_INITIALIZER;
static struct handle *live_handle(void *device) {
uintptr_t offset = (uintptr_t)device - (uintptr_t)handles;
struct handle *handle;
if (offset >= sizeof(handles) || offset % sizeof(handles[0]) != 0) return NULL;
handle = &handles[offset / sizeof(handles[0])];
return handle->refs > 0 ? handle : NULL;
}
static struct handle *claim_slot(const struct pad *info, void *udev) {
int i;
for (i = 0; i < HANDLE_MAX; i++) {
if (handles[i].refs == 0) {
handles[i].refs = 1;
handles[i].info = *info;
handles[i].udev = udev;
handles[i].parent = NULL;
return &handles[i];
}
}
return NULL;
}
static void *claim_handle(const struct pad *info, void *udev) {
struct handle *handle;
pthread_mutex_lock(&handle_lock);
handle = claim_slot(info, udev);
pthread_mutex_unlock(&handle_lock);
return handle;
}
static int retain_handle(void *device) {
struct handle *handle;
pthread_mutex_lock(&handle_lock);
handle = live_handle(device);
if (handle != NULL) handle->refs++;
pthread_mutex_unlock(&handle_lock);
return handle != NULL;
}
static int release_handle(void *device) {
struct handle *handle;
int found;
pthread_mutex_lock(&handle_lock);
handle = live_handle(device);
found = handle != NULL;
while (handle != NULL && --handle->refs == 0) {
struct handle *parent = handle->parent;
handle->parent = NULL;
handle = parent;
}
pthread_mutex_unlock(&handle_lock);
return found;
}
static struct handle *device_handle(void *device) {
struct handle *handle;
if (device == NULL) return NULL;
pthread_mutex_lock(&handle_lock);
handle = live_handle(device);
pthread_mutex_unlock(&handle_lock);
return handle;
}
static struct pad *device_pad(void *device) {
struct handle *handle = device_handle(device);
return handle != NULL ? &handle->info : NULL;
}
/* The parent belongs to the child that handed it out and goes away with it, as in libudev. */
static void *parent_device(void *device, struct pad *pad) {
struct handle *handle;
struct handle *parent = NULL;
struct pad info;
if (pad->parent) return NULL;
make_parent(pad->node, pad, &info);
pthread_mutex_lock(&handle_lock);
handle = live_handle(device);
if (handle != NULL) {
if (handle->parent == NULL) handle->parent = claim_slot(&info, handle->udev);
parent = handle->parent;
}
pthread_mutex_unlock(&handle_lock);
return parent;
}
static const char *pad_property(const struct pad *pad, const char *key) {
if (key == NULL) return NULL;
if (strcmp(key, "ID_INPUT") == 0 || strcmp(key, "ID_INPUT_JOYSTICK") == 0) return "1";
if (strcmp(key, "DEVNAME") == 0) return !pad->parent && pad->devnode[0] != '\0' ? pad->devnode : NULL;
if (strcmp(key, "DEVPATH") == 0) return pad->syspath + 4;
return NULL;
}
static struct handle *property_handle(void *entry, size_t *index) {
uintptr_t offset = (uintptr_t)entry - (uintptr_t)handles;
size_t within;
if (offset >= sizeof(handles)) return NULL;
within = offset % sizeof(handles[0]);
if (within < offsetof(struct handle, properties) ||
within >= offsetof(struct handle, properties) + PROPERTY_COUNT)
return NULL;
*index = within - offsetof(struct handle, properties);
return &handles[offset / sizeof(handles[0])];
}
static void *next_property(struct handle *handle, size_t from) {
size_t i;
for (i = from; i < PROPERTY_COUNT; i++)
if (pad_property(&handle->info, property_keys[i]) != NULL) return &handle->properties[i];
return NULL;
}
static int syslink_pad(const char *path, struct pad *out) {
static const char prefix[] = "/sys/class/input/";
if (path == NULL || strncmp(path, prefix, sizeof(prefix) - 1) != 0) return 0;
return sysname_pad(path + sizeof(prefix) - 1, out);
}
static void *real_dlsym(void);
/* libudev is often opened with RTLD_LOCAL, which keeps it out of the global scope that RTLD_NEXT
* searches, so the handle the program opened is the only way back to the real implementation. */
static _Atomic(void *) udev_handle;
__attribute__((visibility("hidden"))) void bl_inputudev_note_dlopen(const char *path, void *handle) {
if (handle != NULL && path != NULL && strstr(path, "libudev") != NULL)
atomic_store_explicit(&udev_handle, handle, memory_order_release);
}
static void *next_symbol(const char *name) {
void *(*forward)(void *, const char *) = real_dlsym();
void *symbol;
if (forward == NULL) return NULL;
if (strncmp(name, "udev_", 5) == 0) {
symbol = atomic_load_explicit(&udev_handle, memory_order_acquire);
if (symbol != NULL && (symbol = forward(symbol, name)) != NULL) return symbol;
}
return forward(RTLD_NEXT, name);
}
char *dd_cached_realpath(const char *path, char *resolved, char *(*real)(const char *, char *))
__attribute__((visibility("hidden")));
static int caller_is_winebus(void *caller) {
Dl_info info;
if (dladdr(caller, &info) == 0 || info.dli_fname == NULL) return 0;
return strstr(info.dli_fname, "winebus.so") != NULL;
}
__attribute__((visibility("hidden"))) int dd_winebus_rumble_ioctl(int (*real)(int, unsigned long, void *), int fd,
unsigned long request, void *arg, void *caller,
int *rc) {
struct ff_effect *effect = arg;
__u16 length;
if (request != EVIOCSFF || effect == NULL || effect->type != FF_RUMBLE || !caller_is_winebus(caller)) return 0;
length = effect->replay.length;
effect->replay.length = 0;
*rc = real(fd, request, arg);
effect->replay.length = length;
return 1;
}
char *realpath(const char *path, char *resolved) {
static char *(*real_realpath)(const char *, char *);
struct pad pad;
if (syslink_pad(path, &pad)) {
if (resolved == NULL) return strdup(pad.syspath);
memcpy(resolved, pad.syspath, strlen(pad.syspath) + 1);
return resolved;
}
if (real_realpath == NULL) real_realpath = next_symbol("realpath");
if (real_realpath == NULL) return NULL;
return dd_cached_realpath(path, resolved, real_realpath);
}
void *udev_device_new_from_syspath(void *udev, const char *syspath) {
static void *(*real_new)(void *, const char *);
struct pad pad;
if (syspath_pad(syspath, &pad)) return claim_handle(&pad, udev);
if (real_new == NULL) real_new = next_symbol("udev_device_new_from_syspath");
if (real_new == NULL) return NULL;
return real_new(udev, syspath);
}
void *udev_device_ref(void *device) {
static void *(*real_ref)(void *);
if (retain_handle(device)) return device;
if (real_ref == NULL) real_ref = next_symbol("udev_device_ref");
if (real_ref == NULL) return NULL;
return real_ref(device);
}
void *udev_device_unref(void *device) {
static void *(*real_unref)(void *);
if (release_handle(device)) return NULL;
if (real_unref == NULL) real_unref = next_symbol("udev_device_unref");
if (real_unref == NULL) return NULL;
return real_unref(device);
}
const char *udev_device_get_devnode(void *device) {
static const char *(*real_get)(void *);
struct pad *pad = device_pad(device);
if (pad != NULL) return pad->parent || pad->devnode[0] == '\0' ? NULL : pad->devnode;
if (real_get == NULL) real_get = next_symbol("udev_device_get_devnode");
if (real_get == NULL) return NULL;
return real_get(device);
}
const char *udev_device_get_syspath(void *device) {
static const char *(*real_get)(void *);
struct pad *pad = device_pad(device);
if (pad != NULL) return pad->syspath;
if (real_get == NULL) real_get = next_symbol("udev_device_get_syspath");
if (real_get == NULL) return NULL;
return real_get(device);
}
const char *udev_device_get_devpath(void *device) {
static const char *(*real_get)(void *);
struct pad *pad = device_pad(device);
if (pad != NULL) return pad->syspath + 4;
if (real_get == NULL) real_get = next_symbol("udev_device_get_devpath");
if (real_get == NULL) return NULL;
return real_get(device);
}
const char *udev_device_get_sysname(void *device) {
static const char *(*real_get)(void *);
struct pad *pad = device_pad(device);
if (pad != NULL) return pad->sysname;
if (real_get == NULL) real_get = next_symbol("udev_device_get_sysname");
if (real_get == NULL) return NULL;
return real_get(device);
}
const char *udev_device_get_sysnum(void *device) {
static const char *(*real_get)(void *);
struct pad *pad = device_pad(device);
if (pad != NULL) return pad->sysname + strcspn(pad->sysname, "0123456789");
if (real_get == NULL) real_get = next_symbol("udev_device_get_sysnum");
if (real_get == NULL) return NULL;
return real_get(device);
}
const char *udev_device_get_subsystem(void *device) {
static const char *(*real_get)(void *);
struct pad *pad = device_pad(device);
if (pad != NULL) return "input";
if (real_get == NULL) real_get = next_symbol("udev_device_get_subsystem");
if (real_get == NULL) return NULL;
return real_get(device);
}
const char *udev_device_get_devtype(void *device) {
static const char *(*real_get)(void *);
struct pad *pad = device_pad(device);
if (pad != NULL) return NULL;
if (real_get == NULL) real_get = next_symbol("udev_device_get_devtype");
if (real_get == NULL) return NULL;
return real_get(device);
}
const char *udev_device_get_action(void *device) {
static const char *(*real_get)(void *);
struct pad *pad = device_pad(device);
if (pad != NULL) return NULL;
if (real_get == NULL) real_get = next_symbol("udev_device_get_action");
if (real_get == NULL) return NULL;
return real_get(device);
}
dev_t udev_device_get_devnum(void *device) {
static dev_t (*real_get)(void *);
struct pad *pad = device_pad(device);
if (pad != NULL) return pad->devnum;
if (real_get == NULL) real_get = next_symbol("udev_device_get_devnum");
if (real_get == NULL) return makedev(0, 0);
return real_get(device);
}
void *udev_device_get_udev(void *device) {
static void *(*real_get)(void *);
struct handle *handle = device_handle(device);
if (handle != NULL) return handle->udev;
if (real_get == NULL) real_get = next_symbol("udev_device_get_udev");
return real_get != NULL ? real_get(device) : NULL;
}
int udev_device_get_is_initialized(void *device) {
static int (*real_get)(void *);
if (device_pad(device) != NULL) return 1;
if (real_get == NULL) real_get = next_symbol("udev_device_get_is_initialized");
return real_get != NULL ? real_get(device) : 0;
}
void *udev_device_get_parent_with_subsystem_devtype(void *device, const char *subsystem,
const char *devtype) {
static void *(*real_get)(void *, const char *, const char *);
struct pad *pad = device_pad(device);
if (pad != NULL) {
if (subsystem != NULL && strcmp(subsystem, "input") == 0 && devtype == NULL)
return parent_device(device, pad);
return NULL;
}
if (real_get == NULL) real_get = next_symbol("udev_device_get_parent_with_subsystem_devtype");
if (real_get == NULL) return NULL;
return real_get(device, subsystem, devtype);
}
const char *udev_device_get_sysattr_value(void *device, const char *attr) {
static const char *(*real_get)(void *, const char *);
struct pad *pad = device_pad(device);
if (pad != NULL) return attr != NULL && strcmp(attr, "uevent") == 0 ? pad->uevent : NULL;
if (real_get == NULL) real_get = next_symbol("udev_device_get_sysattr_value");
if (real_get == NULL) return NULL;
return real_get(device, attr);
}
const char *udev_device_get_property_value(void *device, const char *key) {
static const char *(*real_get)(void *, const char *);
struct pad *pad = device_pad(device);
if (pad != NULL) return pad_property(pad, key);
if (real_get == NULL) real_get = next_symbol("udev_device_get_property_value");
if (real_get == NULL) return NULL;
return real_get(device, key);
}
void *udev_device_get_parent(void *device) {
static void *(*real_get)(void *);
struct pad *pad = device_pad(device);
if (pad != NULL) return parent_device(device, pad);
if (real_get == NULL) real_get = next_symbol("udev_device_get_parent");
return real_get != NULL ? real_get(device) : NULL;
}
int udev_device_has_tag(void *device, const char *tag) {
static int (*real_has)(void *, const char *);
if (device_pad(device) != NULL) return 0;
if (real_has == NULL) real_has = next_symbol("udev_device_has_tag");
return real_has != NULL ? real_has(device, tag) : 0;
}
void *udev_device_get_properties_list_entry(void *device) {
static void *(*real_get)(void *);
struct handle *handle = device_handle(device);
if (handle != NULL) return next_property(handle, 0);
if (real_get == NULL) real_get = next_symbol("udev_device_get_properties_list_entry");
return real_get != NULL ? real_get(device) : NULL;
}
void *udev_device_get_tags_list_entry(void *device) {
static void *(*real_get)(void *);
if (device_pad(device) != NULL) return NULL;
if (real_get == NULL) real_get = next_symbol("udev_device_get_tags_list_entry");
return real_get != NULL ? real_get(device) : NULL;
}
void *udev_device_get_sysattr_list_entry(void *device) {
static void *(*real_get)(void *);
if (device_pad(device) != NULL) return NULL;
if (real_get == NULL) real_get = next_symbol("udev_device_get_sysattr_list_entry");
return real_get != NULL ? real_get(device) : NULL;
}
void *udev_device_new_from_devnum(void *udev, char type, dev_t devnum) {
static void *(*real_new)(void *, char, dev_t);
struct pad pad;
int node;
for (node = 0; node < PAD_MAX; node++)
if (snapshot_pad(node, 0, &pad) && pad.devnum == devnum) return claim_handle(&pad, udev);
if (real_new == NULL) real_new = next_symbol("udev_device_new_from_devnum");
return real_new != NULL ? real_new(udev, type, devnum) : NULL;
}
void *udev_device_new_from_subsystem_sysname(void *udev, const char *subsystem, const char *sysname) {
static void *(*real_new)(void *, const char *, const char *);
struct pad pad;
if (subsystem != NULL && sysname != NULL && strcmp(subsystem, "input") == 0 && sysname_pad(sysname, &pad))
return claim_handle(&pad, udev);
if (real_new == NULL) real_new = next_symbol("udev_device_new_from_subsystem_sysname");
return real_new != NULL ? real_new(udev, subsystem, sysname) : NULL;
}
#define ENTRY_MAX (PAD_MAX * 2)
struct enumerate {
struct enumerate *next;
void *real;
void *real_head;
int matched;
int filtered;
int parent_node;
int real_parent;
int real_listed;
int scanned;
int refs;
char names[ENTRY_MAX][sizeof(pads[0].syspath)];
};
static struct enumerate *enumerates;
static struct enumerate *entry_state(void *entry, int *slot) {
struct enumerate *state;
pthread_mutex_lock(&enumerate_lock);
for (state = enumerates; state != NULL; state = state->next) {
uintptr_t offset = (uintptr_t)entry - (uintptr_t)state->names;
if (offset < sizeof(state->names) && offset % sizeof(state->names[0]) == 0) {
*slot = (int)(offset / sizeof(state->names[0]));
break;
}
}
pthread_mutex_unlock(&enumerate_lock);
return state;
}
static struct enumerate *enumerate_state(void *enumerate) {
struct enumerate *state;
pthread_mutex_lock(&enumerate_lock);
for (state = enumerates; state != NULL && state->real != enumerate; state = state->next) {
}
pthread_mutex_unlock(&enumerate_lock);
return state;
}
void *udev_enumerate_new(void *udev) {
static void *(*real_new)(void *);
void *enumerate;
struct enumerate *state;
if (real_new == NULL) real_new = next_symbol("udev_enumerate_new");
if (real_new == NULL) return NULL;
enumerate = real_new(udev);
if (enumerate == NULL) return NULL;
state = calloc(1, sizeof(*state));
if (state == NULL) return enumerate;
state->real = enumerate;
state->parent_node = -1;
state->refs = 1;
pthread_mutex_lock(&enumerate_lock);
state->next = enumerates;
enumerates = state;
pthread_mutex_unlock(&enumerate_lock);
return enumerate;
}
void *udev_enumerate_ref(void *enumerate) {
static void *(*real_ref)(void *);
struct enumerate *state = enumerate_state(enumerate);
if (state != NULL) {
pthread_mutex_lock(&enumerate_lock);
state->refs++;
pthread_mutex_unlock(&enumerate_lock);
}
if (real_ref == NULL) real_ref = next_symbol("udev_enumerate_ref");
return real_ref != NULL ? real_ref(enumerate) : enumerate;
}
void *udev_enumerate_unref(void *enumerate) {
static void *(*real_unref)(void *);
struct enumerate *state = enumerate_state(enumerate);
if (state != NULL) {
pthread_mutex_lock(&enumerate_lock);
if (--state->refs <= 0) {
struct enumerate **link;
for (link = &enumerates; *link != NULL && *link != state; link = &(*link)->next) {
}
if (*link != NULL) *link = state->next;
} else {
state = NULL;
}
pthread_mutex_unlock(&enumerate_lock);
free(state);
}
if (real_unref == NULL) real_unref = next_symbol("udev_enumerate_unref");
return real_unref != NULL ? real_unref(enumerate) : NULL;
}
int udev_enumerate_add_match_subsystem(void *enumerate, const char *subsystem) {
static int (*real_add)(void *, const char *);
struct enumerate *state = enumerate_state(enumerate);
int rc;
if (real_add == NULL) real_add = next_symbol("udev_enumerate_add_match_subsystem");
rc = real_add != NULL ? real_add(enumerate, subsystem) : 0;
if (rc == 0 && state != NULL && subsystem != NULL) {
pthread_mutex_lock(&enumerate_lock);
state->filtered = 1;
state->matched = state->matched || strcmp(subsystem, "input") == 0;
pthread_mutex_unlock(&enumerate_lock);
}
return rc;
}
int udev_enumerate_add_match_parent(void *enumerate, void *parent) {
static int (*real_add)(void *, void *);
struct enumerate *state = enumerate_state(enumerate);
struct pad *pad = device_pad(parent);
int rc;
if (pad != NULL) {
if (state == NULL) return -EINVAL;
pthread_mutex_lock(&enumerate_lock);
state->parent_node = pad->node;
state->real_parent = 0;
pthread_mutex_unlock(&enumerate_lock);
return 0;
}
if (real_add == NULL) real_add = next_symbol("udev_enumerate_add_match_parent");
rc = real_add != NULL ? real_add(enumerate, parent) : -ENOSYS;
if (rc == 0 && state != NULL) {
pthread_mutex_lock(&enumerate_lock);
state->parent_node = -1;
state->real_parent = 1;
pthread_mutex_unlock(&enumerate_lock);
}
return rc;
}
static void *real_get_list_entry(void *enumerate) {
static void *(*real_get)(void *);
if (real_get == NULL) real_get = next_symbol("udev_enumerate_get_list_entry");
return real_get != NULL ? real_get(enumerate) : NULL;
}
int udev_enumerate_scan_devices(void *enumerate) {
static int (*real_scan)(void *);
struct enumerate *state = enumerate_state(enumerate);
char names[ENTRY_MAX][sizeof(pads[0].syspath)];
int include;
int parent_node;
int added = 0;
int node;
int rc;
if (real_scan == NULL) real_scan = next_symbol("udev_enumerate_scan_devices");
rc = real_scan != NULL ? real_scan(enumerate) : -1;
if (state == NULL) return rc;
pthread_mutex_lock(&enumerate_lock);
parent_node = state->parent_node;
include = !state->real_parent && (state->filtered ? state->matched : parent_node >= 0);
pthread_mutex_unlock(&enumerate_lock);
for (node = 0; node < PAD_MAX; node++) {
struct pad pad;
names[2 * node][0] = '\0';
names[2 * node + 1][0] = '\0';
if (!include || (parent_node >= 0 && parent_node != node)) continue;
if (parent_node >= 0 && snapshot_pad(node, 1, &pad)) {
memcpy(names[2 * node], pad.syspath, sizeof(names[0]));
added++;
}
if (snapshot_pad(node, 0, &pad)) {
memcpy(names[2 * node + 1], pad.syspath, sizeof(names[0]));
added++;
}
}
pthread_mutex_lock(&enumerate_lock);
memcpy(state->names, names, sizeof(names));
state->scanned = 1;
state->real_listed = rc == 0 && parent_node < 0;
state->real_head = NULL;
pthread_mutex_unlock(&enumerate_lock);
/* Both browsers abandon the enumeration when the scan reports an error, and the real scan always
fails here because Android hides /sys/class from readdir. */
if (added > 0 && rc < 0) rc = 0;
return rc;
}
static void *next_pad_entry(struct enumerate *state, int from) {
void *entry;
int slot;
pthread_mutex_lock(&enumerate_lock);
for (slot = from; slot < ENTRY_MAX && state->names[slot][0] == '\0'; slot++) {
}
entry = slot < ENTRY_MAX ? (void *)state->names[slot] : state->real_head;
pthread_mutex_unlock(&enumerate_lock);
return entry;
}
void *udev_enumerate_get_list_entry(void *enumerate) {
struct enumerate *state = enumerate_state(enumerate);
void *head = NULL;
int own;
int real_listed;
if (state == NULL) return real_get_list_entry(enumerate);
pthread_mutex_lock(&enumerate_lock);
own = state->scanned && (state->matched || state->parent_node >= 0);
real_listed = state->real_listed;
pthread_mutex_unlock(&enumerate_lock);
if (!own) return real_get_list_entry(enumerate);
if (real_listed) head = real_get_list_entry(enumerate);
pthread_mutex_lock(&enumerate_lock);
state->real_head = head;
pthread_mutex_unlock(&enumerate_lock);
return next_pad_entry(state, 0);
}
void *udev_list_entry_get_next(void *entry) {
static void *(*real_get)(void *);
struct enumerate *state;
struct handle *handle;
size_t index;
int slot;
if ((state = entry_state(entry, &slot)) != NULL) return next_pad_entry(state, slot + 1);
if ((handle = property_handle(entry, &index)) != NULL) return next_property(handle, index + 1);
if (real_get == NULL) real_get = next_symbol("udev_list_entry_get_next");
return real_get != NULL ? real_get(entry) : NULL;
}
void *udev_list_entry_get_by_name(void *entry, const char *name) {
static void *(*real_get)(void *, const char *);
struct enumerate *state;
struct handle *handle;
size_t index;
int slot;
if ((state = entry_state(entry, &slot)) != NULL) {
if (name == NULL) return NULL;
pthread_mutex_lock(&enumerate_lock);
for (slot = 0; slot < ENTRY_MAX && (state->names[slot][0] == '\0' || strcmp(state->names[slot], name) != 0);
slot++) {
}
entry = slot < ENTRY_MAX ? (void *)state->names[slot] : state->real_head;
pthread_mutex_unlock(&enumerate_lock);
if (entry == NULL || slot < ENTRY_MAX) return entry;
} else if ((handle = property_handle(entry, &index)) != NULL) {
for (index = 0; index < PROPERTY_COUNT; index++)
if (name != NULL && strcmp(property_keys[index], name) == 0 && pad_property(&handle->info, name) != NULL)
return &handle->properties[index];
return NULL;
}
if (real_get == NULL) real_get = next_symbol("udev_list_entry_get_by_name");
return real_get != NULL ? real_get(entry, name) : NULL;
}
const char *udev_list_entry_get_name(void *entry) {
static const char *(*real_get)(void *);
size_t index;
int slot;
if (entry_state(entry, &slot) != NULL) return entry;
if (property_handle(entry, &index) != NULL) return property_keys[index];
if (real_get == NULL) real_get = next_symbol("udev_list_entry_get_name");
return real_get != NULL ? real_get(entry) : NULL;
}
const char *udev_list_entry_get_value(void *entry) {
static const char *(*real_get)(void *);
struct handle *handle;
size_t index;
int slot;
if (entry_state(entry, &slot) != NULL) return "";
if ((handle = property_handle(entry, &index)) != NULL) return pad_property(&handle->info, property_keys[index]);
if (real_get == NULL) real_get = next_symbol("udev_list_entry_get_value");
return real_get != NULL ? real_get(entry) : NULL;
}
struct udev_symbol {
const char *name;
void *address;
};
static const struct udev_symbol udev_symbols[] = {
{"udev_device_new_from_syspath", (void *)udev_device_new_from_syspath},
{"udev_device_new_from_devnum", (void *)udev_device_new_from_devnum},
{"udev_device_new_from_subsystem_sysname", (void *)udev_device_new_from_subsystem_sysname},
{"udev_device_ref", (void *)udev_device_ref},
{"udev_device_unref", (void *)udev_device_unref},
{"udev_device_get_devnode", (void *)udev_device_get_devnode},
{"udev_device_get_syspath", (void *)udev_device_get_syspath},
{"udev_device_get_devpath", (void *)udev_device_get_devpath},
{"udev_device_get_sysname", (void *)udev_device_get_sysname},
{"udev_device_get_sysnum", (void *)udev_device_get_sysnum},
{"udev_device_get_subsystem", (void *)udev_device_get_subsystem},
{"udev_device_get_devtype", (void *)udev_device_get_devtype},
{"udev_device_get_action", (void *)udev_device_get_action},
{"udev_device_get_devnum", (void *)udev_device_get_devnum},
{"udev_device_get_sysattr_value", (void *)udev_device_get_sysattr_value},
{"udev_device_get_property_value", (void *)udev_device_get_property_value},
{"udev_device_get_parent_with_subsystem_devtype",
(void *)udev_device_get_parent_with_subsystem_devtype},
{"udev_device_get_parent", (void *)udev_device_get_parent},
{"udev_device_get_udev", (void *)udev_device_get_udev},
{"udev_device_get_is_initialized", (void *)udev_device_get_is_initialized},
{"udev_device_has_tag", (void *)udev_device_has_tag},
{"udev_device_get_properties_list_entry", (void *)udev_device_get_properties_list_entry},
{"udev_device_get_tags_list_entry", (void *)udev_device_get_tags_list_entry},
{"udev_device_get_sysattr_list_entry", (void *)udev_device_get_sysattr_list_entry},
{"udev_enumerate_new", (void *)udev_enumerate_new},
{"udev_enumerate_ref", (void *)udev_enumerate_ref},
{"udev_enumerate_unref", (void *)udev_enumerate_unref},
{"udev_enumerate_add_match_subsystem", (void *)udev_enumerate_add_match_subsystem},
{"udev_enumerate_add_match_parent", (void *)udev_enumerate_add_match_parent},
{"udev_enumerate_scan_devices", (void *)udev_enumerate_scan_devices},
{"udev_enumerate_get_list_entry", (void *)udev_enumerate_get_list_entry},
{"udev_list_entry_get_next", (void *)udev_list_entry_get_next},
{"udev_list_entry_get_by_name", (void *)udev_list_entry_get_by_name},
{"udev_list_entry_get_name", (void *)udev_list_entry_get_name},
{"udev_list_entry_get_value", (void *)udev_list_entry_get_value},
};
static void *own_udev_symbol(const char *name) {
size_t i;
for (i = 0; i < sizeof(udev_symbols) / sizeof(udev_symbols[0]); i++)
if (strcmp(udev_symbols[i].name, name) == 0) return udev_symbols[i].address;
return NULL;
}
static void *dlvsym_any(const char *name) {
static const char *versions[] = {"GLIBC_2.17", "GLIBC_2.2.5", "GLIBC_2.0", "GLIBC_2.34"};
size_t i;
void *resolved = NULL;
for (i = 0; i < sizeof(versions) / sizeof(versions[0]) && resolved == NULL; i++)
resolved = dlvsym(RTLD_NEXT, name, versions[i]);
return resolved;
}
/* A versioned lookup only ever finds libc, so the next dlsym in line is asked for by plain name to
* keep another preload's dlsym in the chain. */
static void *real_dlsym(void) {
static void *resolved;
if (resolved == NULL) {
void *(*libc)(void *, const char *) = dlvsym_any("dlsym");
void *next = libc != NULL ? libc(RTLD_NEXT, "dlsym") : NULL;
resolved = next != NULL ? next : (void *)libc;
}
return resolved;
}
static int steam_runtime_path(const char *path) {
static const char *const runtimes[] = {"steamrtarm64", "steamrt64"};
const char *name = strrchr(path, '/');
size_t i;
if (name == NULL || strcmp(name + 1, "steam") != 0) return 0;
for (i = 0; i < sizeof(runtimes) / sizeof(runtimes[0]); i++) {
size_t length = strlen(runtimes[i]);
if ((size_t)(name - path) > length && name[-(ptrdiff_t)length - 1] == '/' &&
memcmp(name - length, runtimes[i], length) == 0)
return 1;
}
return 0;
}
/* The Steam client reads the pads straight from /dev/input and hands whatever the udev enumeration
* gives it back to the real libudev, which cannot read these synthetic devices. */
static int steam_client_process(void) {
static _Atomic int cached = -1;
char path[PATH_MAX];
ssize_t length;
int result = atomic_load_explicit(&cached, memory_order_acquire);
if (result >= 0) return result;
result = 0;
length = readlink("/proc/self/exe", path, sizeof(path) - 1);
if (length > 0) {
path[length] = '\0';
result = steam_runtime_path(path);
}
atomic_store_explicit(&cached, result, memory_order_release);
return result;
}
static void *missing_dlsym(void *handle, const char *name) {
(void)handle;
(void)name;
return NULL;
}
static void *own_dlsym(void *handle, const char *name) {
(void)handle;
return own_udev_symbol(name);
}
/* Returns what dlsym jumps to. Anything outside the udev_ names has to reach the real dlsym without
* a single interposable call on the way, because other preloads resolve their own symbols from
* inside one-time initialisers that those calls would re-enter. */
__attribute__((visibility("hidden"), used)) void *inputudev_dlsym_target(void *handle, const char *name) {
void *forward = real_dlsym();
(void)handle;
if (name != NULL && strncmp(name, "udev_", 5) == 0 && own_udev_symbol(name) != NULL &&
!steam_client_process())
return (void *)own_dlsym;
return forward != NULL ? forward : (void *)missing_dlsym;
}
/* Browsers resolve libudev through dlopen and dlsym, which skips symbol interposition, so the
* devices have to be handed out from here as well. The real dlsym is entered with a jump so that it
* still sees the original caller, which is what RTLD_NEXT and RTLD_DEFAULT lookups are relative to. */
#if defined(__aarch64__)
__asm__(".text\n"
".globl dlsym\n"
".type dlsym, %function\n"
"dlsym:\n"
".cfi_startproc\n"
"hint #34\n"
"stp x29, x30, [sp, #-32]!\n"
".cfi_adjust_cfa_offset 32\n"
".cfi_offset x29, -32\n"
".cfi_offset x30, -24\n"
"mov x29, sp\n"
"stp x0, x1, [sp, #16]\n"
"bl inputudev_dlsym_target\n"
"mov x16, x0\n"
"ldp x0, x1, [sp, #16]\n"
"ldp x29, x30, [sp], #32\n"
".cfi_adjust_cfa_offset -32\n"
".cfi_restore x29\n"
".cfi_restore x30\n"
"br x16\n"
".cfi_endproc\n"
".size dlsym, .-dlsym\n");
#elif defined(__x86_64__)
__asm__(".text\n"
".globl dlsym\n"
".type dlsym, @function\n"
"dlsym:\n"
".cfi_startproc\n"
"pushq %rdi\n"
".cfi_adjust_cfa_offset 8\n"
"pushq %rsi\n"
".cfi_adjust_cfa_offset 8\n"
"subq $8, %rsp\n"
".cfi_adjust_cfa_offset 8\n"
"call inputudev_dlsym_target\n"
"addq $8, %rsp\n"
".cfi_adjust_cfa_offset -8\n"
"popq %rsi\n"
".cfi_adjust_cfa_offset -8\n"
"popq %rdi\n"
".cfi_adjust_cfa_offset -8\n"
"jmp *%rax\n"
".cfi_endproc\n"
".size dlsym, .-dlsym\n");
#elif defined(__i386__)
__asm__(".text\n"
".globl dlsym\n"
".type dlsym, @function\n"
"dlsym:\n"
".cfi_startproc\n"
"subl $12, %esp\n"
".cfi_adjust_cfa_offset 12\n"
"movl 20(%esp), %eax\n"
"movl %eax, 4(%esp)\n"
"movl 16(%esp), %eax\n"
"movl %eax, (%esp)\n"
"call inputudev_dlsym_target\n"
"addl $12, %esp\n"
".cfi_adjust_cfa_offset -12\n"
"jmp *%eax\n"
".cfi_endproc\n"
".size dlsym, .-dlsym\n");
#else
void *dlsym(void *handle, const char *name) {
void *(*target)(void *, const char *) = inputudev_dlsym_target(handle, name);
return target(handle, name);
}
#endif