fix(input): Steam finds a DualShock or DualSense chosen mid-session (#2942)

* fix(input): Steam finds a DualShock or DualSense chosen mid-session

Android lets an app open a uevent netlink socket but not join its multicast
groups, and libudev joins none when no udev daemon runs, so the udev
monitors Steam's SDL opens heard nothing and the pad switch's add and remove
events reached no one. SDL only noticed a new PlayStation pad when the old
one happened to fail a read. A monitor left without a subscription is now
swapped for the session's stand-in under the same descriptor, so it
receives the injected events.

* test(preload): stub the udev monitor bind hook in the CDP guard build
This commit is contained in:
Kurt Himebauch authored and GitHub committed 2026-11-20 12:44:52 -05:00
1 parent d5c83eae15
commit d7f43c26cd
4 files changed
+151 -1

No files matched your search

+4
View File
@@ -111,6 +111,9 @@ typedef int (*accept4_fn)(int, struct sockaddr *, socklen_t *, int);
static unsigned guarded_port(void);
__attribute__((visibility("hidden"))) int dd_udevmon_stand_in(int fd);
__attribute__((visibility("hidden"))) int dd_udevmon_bind(int fd, const struct sockaddr *addr, socklen_t len,
int (*real_bind)(int, const struct sockaddr *, socklen_t),
int *rc);
__attribute__((visibility("hidden"))) int dd_nl_bind(int fd, const struct sockaddr *addr,
socklen_t len, int *rc);
__attribute__((visibility("hidden"))) int dd_nl_connect(int fd, const struct sockaddr *addr,
@@ -121,6 +124,7 @@ int bind(int fd, const struct sockaddr *addr, socklen_t len) {
int nl_rc;
if (!real) real = (bind_fn)dlsym(RTLD_NEXT, "bind");
if (dd_nl_bind(fd, addr, len, &nl_rc)) return nl_rc;
if (dd_udevmon_bind(fd, addr, len, real, &nl_rc)) return nl_rc;
if (dd_udevmon_stand_in(fd)) {
if (addr == NULL || len < sizeof(struct sockaddr_nl) || addr->sa_family != AF_NETLINK) {
errno = EINVAL;
+56
View File
@@ -14,6 +14,7 @@
#include <sys/stat.h>
#include <endian.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
struct stand_in {
@@ -146,6 +147,61 @@ __attribute__((visibility("hidden"))) int dd_udevmon_stand_in(int fd) {
return is_stand_in(fd);
}
static int subscribed(int fd) {
#ifdef UDEVMON_TEST
if (getenv("DD_UDEVMON_REFUSE") != NULL) return 0;
#endif
struct sockaddr_nl nl;
socklen_t len = sizeof(nl);
memset(&nl, 0, sizeof(nl));
return getsockname(fd, (struct sockaddr *)&nl, &len) == 0 && nl.nl_groups != 0;
}
/* Android lets an app open a uevent socket but not join its multicast groups, and libudev joins none
when no udev daemon runs, so a monitor bound there hears nothing. Such a socket is replaced, under
the same descriptor, by a stand-in. */
__attribute__((visibility("hidden"))) int dd_udevmon_bind(int fd, const struct sockaddr *addr, socklen_t len,
int (*real_bind)(int, const struct sockaddr *, socklen_t),
int *rc) {
int protocol = -1;
socklen_t protocol_len = sizeof(protocol);
if (addr == NULL || len < sizeof(struct sockaddr_nl) || addr->sa_family != AF_NETLINK) return 0;
if (is_stand_in(fd) || is_wine_process()) return 0;
if (getsockopt(fd, SOL_SOCKET, SO_PROTOCOL, &protocol, &protocol_len) != 0 || protocol != NETLINK_KOBJECT_UEVENT)
return 0;
*rc = real_bind(fd, addr, len);
int refused = errno;
if (*rc == 0 && subscribed(fd)) return 1;
int status = fcntl(fd, F_GETFL);
int descriptor = fcntl(fd, F_GETFD);
int sv[2];
if (status < 0 || descriptor < 0 || socketpair(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0, sv) != 0) {
errno = refused;
return 1;
}
pthread_mutex_lock(&lock);
size_t slot = sizeof(stand_ins) / sizeof(stand_ins[0]);
for (size_t i = 0; i < sizeof(stand_ins) / sizeof(stand_ins[0]); i++) {
if (stand_ins[i].fd == -1) { slot = i; break; }
}
if (slot == sizeof(stand_ins) / sizeof(stand_ins[0]) ||
dup3(sv[0], fd, (descriptor & FD_CLOEXEC) ? O_CLOEXEC : 0) < 0) {
pthread_mutex_unlock(&lock);
close(sv[0]);
close(sv[1]);
errno = refused;
return 1;
}
close(sv[0]);
if (status & O_NONBLOCK) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
stand_ins[slot].fd = fd;
stand_ins[slot].peer = sv[1];
stand_ins[slot].inode = socket_inode(fd);
pthread_mutex_unlock(&lock);
*rc = 0;
return 1;
}
int getsockname(int fd, struct sockaddr *addr, socklen_t *len) {
static int (*real_getsockname)(int, struct sockaddr *, socklen_t *);
struct sockaddr_nl nl;
+2 -1
View File
@@ -19,7 +19,8 @@ class CdpGuardTest(unittest.TestCase):
subprocess.run(["cc", "-shared", "-fPIC", "-O2", str(SOURCE), str(SOURCE.parent / "binfmt.c"), str(SOURCE.parent / "webhelper.c"),
str(Path(__file__).with_name("netlink_stubs.c")), "-x", "c", "-", "-ldl",
"-o", str(cls.library)],
input=b"int dd_udevmon_stand_in(int fd) { return 0; }", check=True, capture_output=True)
input=b"int dd_udevmon_stand_in(int fd) { return 0; }\n"
b"int dd_udevmon_bind(int fd, const void *addr, unsigned len, void *real, int *rc) { return 0; }", check=True, capture_output=True)
@classmethod
def tearDownClass(cls):
+89
View File
@@ -0,0 +1,89 @@
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
PROGRAM = r"""
#define _GNU_SOURCE
#include <dlfcn.h>
#include <fcntl.h>
#include <linux/netlink.h>
#include <poll.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
int main(int argc, char **argv) {
unsigned groups = argc > 1 ? (unsigned)atoi(argv[1]) : 2;
int fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC | SOCK_NONBLOCK, NETLINK_KOBJECT_UEVENT);
if (fd < 0) { printf("socket failed\n"); return 2; }
struct sockaddr_nl nl = {.nl_family = AF_NETLINK, .nl_groups = groups};
printf("bind %d\n", bind(fd, (struct sockaddr *)&nl, sizeof(nl)));
printf("cloexec %d nonblock %d\n", (fcntl(fd, F_GETFD) & FD_CLOEXEC) != 0, (fcntl(fd, F_GETFL) & O_NONBLOCK) != 0);
int (*inject)(const char *, const char *, const char *, const char *, unsigned, unsigned) =
(int (*)(const char *, const char *, const char *, const char *, unsigned, unsigned))dlsym(RTLD_DEFAULT, "dd_udevmon_inject");
int sent = inject("add", "/devices/droiddeck/usb4/4-1:1.3/0003:054C:09CC.0005/hidraw/hidraw20", "hidraw",
"/dev/hidraw20", 245, 20);
printf("sent %d\n", sent);
struct pollfd p = {.fd = fd, .events = POLLIN};
if (sent > 0 && poll(&p, 1, 1000) == 1) {
char buf[2048];
struct sockaddr_nl from;
struct iovec iov = {.iov_base = buf, .iov_len = sizeof(buf)};
struct msghdr msg = {.msg_name = &from, .msg_namelen = sizeof(from), .msg_iov = &iov, .msg_iovlen = 1};
ssize_t n = recvmsg(fd, &msg, 0);
int found = 0;
for (ssize_t i = 0; n > 0 && i < n; i += (ssize_t)strlen(buf + i) + 1)
if (!strcmp(buf + i, "ACTION=add") || !strcmp(buf + i, "DEVNAME=/dev/hidraw20")) found++;
printf("received %s fields %d\n", n > 0 && !memcmp(buf, "libudev", 8) ? "libudev" : "nothing", found);
}
return 0;
}
"""
@unittest.skipUnless(shutil.which("gcc") and os.uname().machine == "x86_64", "needs gcc on an x86-64 host")
class UdevMonitorPreloadTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.tmp = Path(tempfile.mkdtemp())
cls.library = cls.tmp / "libudevmon.so"
subprocess.run(["gcc", "-shared", "-fPIC", "-O2", "-Wall", "-Wextra", "-Werror", "-DUDEVMON_TEST", "-DBINFMT_TEST",
'-DBINFMT_HANDLER="/bin/false"', "-o", str(cls.library), "-pthread"]
+ [str(PRELOAD / name) for name in ("binfmt.c", "net.c", "udevmon.c", "pathcache.c", "perms.c", "webhelper.c")]
+ [str(Path(__file__).with_name("netlink_stubs.c")), "-ldl"], check=True)
source = cls.tmp / "program.c"
source.write_text(PROGRAM.replace("#include <unistd.h>", "#include <unistd.h>\n#include <stdlib.h>"))
cls.program = cls.tmp / "program"
subprocess.run(["gcc", "-O2", "-o", str(cls.program), str(source), "-ldl"], check=True)
@classmethod
def tearDownClass(cls):
shutil.rmtree(cls.tmp, True)
def run_program(self, *args, refuse=False):
env = dict(os.environ, LD_PRELOAD=str(self.library))
env.pop("DD_UDEVMON_REFUSE", None)
if refuse:
env["DD_UDEVMON_REFUSE"] = "1"
return subprocess.run([str(self.program), *args], env=env, capture_output=True, text=True, check=True).stdout.splitlines()
def test_a_monitor_the_system_will_not_subscribe_hears_the_sessions_events(self):
out = self.run_program(refuse=True)
self.assertEqual(["bind 0", "cloexec 1 nonblock 1", "sent 1", "received libudev fields 2"], out)
def test_a_monitor_the_system_subscribes_stays_on_the_real_socket(self):
self.assertEqual(["bind 0", "cloexec 1 nonblock 1", "sent 0"], self.run_program())
def test_a_monitor_bound_without_groups_hears_the_sessions_events(self):
out = self.run_program("0")
self.assertEqual(["bind 0", "cloexec 1 nonblock 1", "sent 1", "received libudev fields 2"], out)
if __name__ == "__main__":
unittest.main()