Mirrors/DroidDeck
1
0 Fork 0
mirror of https://github.com/Droid-Deck/DroidDeck.git synced 2026-11-11 11:01:07 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
4ff4be23710f720cea7cd00a2fc836ebc4a7736d
DroidDeck/tools/tests/test_fakeinput_ring.py
T

354 lines
14 KiB
Python
Raw Blame History

import os
from pathlib import Path
import shutil
import struct
import subprocess
import sys
import tempfile
import unittest
SOURCE = Path(__file__).resolve().parents[2] / "app/src/main/cpp/fakeinput_steam.cpp"
RING_MAGIC = 0x46494252
DESCRIPTION_MAGIC = 0x46495544
HEADER = 64
EVENT = 24
CAPACITY = 4096
DESCRIPTION = 1824
READER = r"""
#include <fcntl.h>
#include <linux/input.h>
#include <stdio.h>
#include <sys/uio.h>
#include <unistd.h>
static int vector_count;
static ssize_t controller_read(int fd, void *buffer, size_t size)
{
if (!vector_count)
return read(fd, buffer, size);
struct iovec vectors[3] = {
{buffer, sizeof(struct input_event)},
{(char *)buffer + sizeof(struct input_event), 0},
{(char *)buffer + sizeof(struct input_event), size - sizeof(struct input_event)},
};
if (vector_count == 1) {
vectors[0].iov_len = size;
return readv(fd, vectors, 1);
}
return readv(fd, vectors, 3);
}
int main(int argc, char **argv)
{
vector_count = argc > 1 ? (argv[1][0] == '1' ? 1 : 3) : 0;
struct input_event events[64];
int fd = open("/dev/input/event16", O_RDONLY | O_NONBLOCK);
if (fd < 0) {
perror("open");
return 1;
}
while (controller_read(fd, events, sizeof(events)) > 0)
;
puts("ready");
fflush(stdout);
char go;
if (read(0, &go, 1) != 1)
return 1;
ssize_t got = controller_read(fd, events, sizeof(events));
for (ssize_t i = 0; i < got / (ssize_t)sizeof(events[0]); i++)
printf("%ld.%06ld %u %u %d\n", (long)events[i].time.tv_sec, (long)events[i].time.tv_usec, events[i].type,
events[i].code, events[i].value);
return got > 0 ? 0 : 1;
}
"""
PROBE = r"""
#include <errno.h>
#include <fcntl.h>
#include <linux/input.h>
#include <linux/joystick.h>
#include <stdio.h>
#include <sys/ioctl.h>
int main(void)
{
char name[128] = "";
struct input_id id = {0};
int fd = open("/dev/input/event16", O_RDONLY | O_NONBLOCK);
if (fd < 0)
return 1;
int joydev = ioctl(fd, JSIOCGNAME(sizeof(name)), name);
printf("JSIOCGNAME %d %s\n", joydev, joydev < 0 && errno == EINVAL ? "EINVAL" : name);
if (ioctl(fd, EVIOCGID, &id) < 0 || ioctl(fd, EVIOCGNAME(sizeof(name)), name) < 0)
return 1;
printf("%04x:%04x %s\n", id.vendor, id.product, name);
return 0;
}
"""
READV_CHECKS = r"""
#include <errno.h>
#include <fcntl.h>
#include <linux/input.h>
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/uio.h>
#include <unistd.h>
int main(void)
{
struct input_event events[64];
int fd = open("/dev/input/event16", O_RDONLY | O_NONBLOCK);
if (fd < 0)
return 1;
while (read(fd, events, sizeof(events)) > 0)
;
struct iovec vector = {events, sizeof(events)};
if (readv(fd, &vector, 1) != -1 || errno != EAGAIN)
return 2;
if (readv(fd, NULL, 0) != 0)
return 3;
vector.iov_len = 0;
if (readv(fd, &vector, 1) != 0)
return 4;
vector.iov_len = sizeof(struct input_event) - 1;
if (readv(fd, &vector, 1) != -1 || errno != EINVAL)
return 5;
ssize_t (*invoke)(int, const struct iovec *, int) = readv;
if (invoke(fd, NULL, -1) != -1 || errno != EINVAL)
return 6;
if (invoke(fd, NULL, 1025) != -1 || errno != EINVAL)
return 7;
if (invoke(fd, NULL, 1) != -1 || errno != EFAULT)
return 8;
long page = sysconf(_SC_PAGESIZE);
void *area = mmap(NULL, 2 * page, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (area == MAP_FAILED)
return 10;
struct iovec *boundary = (struct iovec *)((char *)area + page - sizeof(struct iovec));
*boundary = vector;
if (mprotect((char *)area + page, page, PROT_NONE))
return 11;
if (invoke(fd, boundary, 2) != -1 || errno != EFAULT)
return 12;
if (invoke(fd, boundary + 1, 1) != -1 || errno != EFAULT)
return 13;
if (munmap(area, 2 * page))
return 14;
if (invoke(fd, boundary, 1) != -1 || errno != EFAULT)
return 15;
int pipefd[2];
char text[5] = {0};
struct iovec parts[2] = {{text, 1}, {text + 1, 3}};
if (pipe(pipefd) || write(pipefd[1], "test", 4) != 4 ||
readv(pipefd[0], parts, 2) != 4 || strcmp(text, "test"))
return 9;
puts("ok");
return 0;
}
"""
READV_DESTINATION_CHECKS = r"""
#include <errno.h>
#include <fcntl.h>
#include <linux/input.h>
#include <stdio.h>
#include <sys/mman.h>
#include <sys/uio.h>
#include <unistd.h>
int main(int argc, char **argv)
{
struct input_event events[64];
int fd = open("/dev/input/event16", O_RDONLY | O_NONBLOCK);
if (fd < 0)
return 1;
if (argc > 1)
while (read(fd, events, sizeof(events)) > 0)
;
puts("ready");
fflush(stdout);
char go;
if (read(0, &go, 1) != 1)
return 2;
long page = sysconf(_SC_PAGESIZE);
char *area = mmap(NULL, 2 * page, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (area == MAP_FAILED || mprotect(area + page, page, PROT_NONE))
return 3;
struct iovec vector = {area + page, sizeof(struct input_event)};
if (readv(fd, &vector, 1) != -1 || errno != EFAULT)
return 4;
if (read(fd, vector.iov_base, vector.iov_len) != -1 || errno != EFAULT)
return 5;
if (mprotect(area, page, PROT_READ))
return 6;
vector.iov_base = area;
if (readv(fd, &vector, 1) != -1 || errno != EFAULT)
return 7;
if (mprotect(area, page, PROT_READ | PROT_WRITE) || munmap(area + page, page))
return 8;
vector.iov_base = area + page;
if (readv(fd, &vector, 1) != -1 || errno != EFAULT)
return 9;
vector.iov_base = area + page - 1;
if (readv(fd, &vector, 1) != -1 || errno != EFAULT)
return 15;
vector.iov_base = area + page - sizeof(struct input_event);
vector.iov_len = 2 * sizeof(struct input_event);
if (readv(fd, &vector, 1) != sizeof(struct input_event))
return 10;
struct input_event *first = vector.iov_base;
if (first->type != EV_KEY || first->code != BTN_A)
return 11;
struct iovec parts[2] = {{events, sizeof(struct input_event)}, {NULL, sizeof(struct input_event)}};
if (readv(fd, parts, 2) != sizeof(struct input_event))
return 12;
if (events[0].type != (argc > 1 ? EV_ABS : EV_KEY) || events[0].code != (argc > 1 ? ABS_Y : BTN_B))
return 13;
vector.iov_base = events;
vector.iov_len = sizeof(events);
ssize_t got = readv(fd, &vector, 1);
if (got != (argc > 1 ? 1 : 18) * sizeof(struct input_event) ||
events[0].type != (argc > 1 ? EV_SYN : EV_KEY) || events[0].code != (argc > 1 ? SYN_REPORT : BTN_X))
return 14;
munmap(area, page);
puts("ok");
return 0;
}
"""
OVERLAY_READ = r"""
#include <sys/uio.h>
#include <unistd.h>
ssize_t read(int fd, void *buffer, size_t size)
{
struct iovec vector = {buffer, size};
return readv(fd, &vector, 1);
}
"""
def can_build(bits):
with tempfile.TemporaryDirectory() as tmp:
probe = Path(tmp) / "probe.cpp"
probe.write_text("#include <string>\nint main() { return std::string().size(); }\n")
return subprocess.run(["g++", bits, "-static-libstdc++", "-o", str(Path(tmp) / "probe"), str(probe)],
capture_output=True).returncode == 0
@unittest.skipUnless(sys.platform == "linux" and os.uname().machine == "x86_64" and shutil.which("g++")
and shutil.which("gcc"), "needs gcc and g++ on an x86-64 Linux host")
class FakeinputRingTest(unittest.TestCase):
def setUp(self):
self.tmp = Path(tempfile.mkdtemp())
self.addCleanup(shutil.rmtree, self.tmp, True)
def ring(self, virtual=True):
hooks = self.tmp / "hooks"
hooks.mkdir()
(hooks / ("event16" if virtual else "event0")).touch()
ring = bytearray(HEADER + CAPACITY * EVENT + (DESCRIPTION if virtual else 0))
struct.pack_into("<IIIIQQQ", ring, 0, RING_MAGIC, 2, EVENT, CAPACITY, 5, 0, 0)
if virtual:
struct.pack_into("<IiHHHHI80s", ring, HEADER + CAPACITY * EVENT, DESCRIPTION_MAGIC, os.getpid(),
3, 0x28de, 0x11ff, 1, 16, b"Microsoft X-Box 360 pad 0")
path = hooks / ".uinput-event16" if virtual else self.tmp / "ring0"
path.write_bytes(bytes(ring))
return hooks, path
def build(self, bits, program, name):
if not can_build(bits):
self.skipTest("no %s C++ toolchain" % bits)
library = self.tmp / ("libfakeinput%s.so" % bits)
subprocess.run(["g++", bits, "-shared", "-fPIC", "-O2", "-Wno-attributes", "-pthread", "-std=c++17",
"-static-libstdc++", "-static-libgcc", "-Wl,--exclude-libs,ALL", "-o", str(library),
str(SOURCE), "-ldl"], check=True, capture_output=True)
binary = self.tmp / (name + bits)
(self.tmp / (name + ".c")).write_text(program)
subprocess.run(["gcc", bits, "-o", str(binary), str(self.tmp / (name + ".c"))], check=True)
return library, binary
def read_through(self, bits, vectors=None, overlay=False, virtual=True, program=READER):
if not virtual:
program = program.replace("event16", "event0")
library, reader = self.build(bits, program, "reader")
hooks, path = self.ring(virtual=virtual)
env = dict(os.environ, LD_PRELOAD=str(library), FAKE_EVDEV_DIR=str(hooks))
if not virtual:
env["FAKE_EVDEV_MEMFD_PATHS"] = "0=" + str(path)
if overlay:
source = self.tmp / "overlay.c"
source.write_text(OVERLAY_READ)
overlay_library = self.tmp / "overlay.so"
subprocess.run(["gcc", bits, "-shared", "-fPIC", "-o", str(overlay_library), str(source)], check=True)
env["LD_PRELOAD"] = str(overlay_library) + ":" + str(library)
command = [str(reader)] + ([str(vectors)] if vectors else [])
process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, env=env, text=True)
self.addCleanup(process.kill)
self.assertEqual(process.stdout.readline(), "ready\n")
with open(path, "r+b") as ring:
for i, (kind, code, value) in enumerate(((1, 304, 1), (3, 1, -32768), (0, 0, 0))):
ring.seek(HEADER + (5 + i) * EVENT)
ring.write(struct.pack("<qqHHi", 1700000000 + i, 250000, kind, code, value))
ring.seek(16)
ring.write(struct.pack("<Q", 8))
output, _ = process.communicate("g", timeout=10)
self.assertEqual(process.returncode, 0)
return output
def test_a_32_bit_guest_reads_the_64_bit_ring(self):
self.assertEqual(self.read_through("-m32"),
"1700000000.250000 1 304 1\n1700000001.250000 3 1 -32768\n1700000002.250000 0 0 0\n")
def test_a_64_bit_guest_reads_the_same_ring(self):
self.assertEqual(self.read_through("-m64"),
"1700000000.250000 1 304 1\n1700000001.250000 3 1 -32768\n1700000002.250000 0 0 0\n")
def test_readv_reads_events_instead_of_the_backing_file(self):
self.assertEqual(self.read_through("-m64", vectors=1),
"1700000000.250000 1 304 1\n1700000001.250000 3 1 -32768\n1700000002.250000 0 0 0\n")
def test_readv_reads_the_original_controller_ring(self):
self.assertEqual(self.read_through("-m64", vectors=1, virtual=False),
"1700000000.250000 1 304 1\n1700000001.250000 3 1 -32768\n1700000002.250000 0 0 0\n")
def test_an_overlay_read_fallback_to_readv_reads_events_without_recursion(self):
self.assertEqual(self.read_through("-m64", overlay=True),
"1700000000.250000 1 304 1\n1700000001.250000 3 1 -32768\n1700000002.250000 0 0 0\n")
def test_readv_reads_event_aligned_vectors_and_skips_empty_ones(self):
self.assertEqual(self.read_through("-m64", vectors=3),
"1700000000.250000 1 304 1\n1700000001.250000 3 1 -32768\n1700000002.250000 0 0 0\n")
def test_a_32_bit_guest_reads_the_same_events_with_readv(self):
self.assertEqual(self.read_through("-m32", vectors=1),
"1700000000.250000 1 304 1\n1700000001.250000 3 1 -32768\n1700000002.250000 0 0 0\n")
def test_readv_preserves_nonblocking_errors_and_other_descriptors(self):
library, probe = self.build("-m64", READV_CHECKS, "readv-checks")
hooks, _ = self.ring()
run = subprocess.run([str(probe)], capture_output=True, text=True, timeout=10,
env=dict(os.environ, LD_PRELOAD=str(library), FAKE_EVDEV_DIR=str(hooks)))
self.assertEqual(run.returncode, 0, run.stderr)
self.assertEqual(run.stdout, "ok\n")
def test_readv_keyframes_handle_destination_faults_and_partial_progress(self):
self.assertEqual(self.read_through("-m64", program=READV_DESTINATION_CHECKS), "ok\n")
def test_readv_ring_events_handle_destination_faults_and_partial_progress(self):
self.assertEqual(self.read_through("-m64", vectors=1, program=READV_DESTINATION_CHECKS), "ok\n")
def test_a_32_bit_guest_handles_readv_destination_faults(self):
self.assertEqual(self.read_through("-m32", program=READV_DESTINATION_CHECKS), "ok\n")
def test_an_event_node_rejects_joydev_requests_so_sdl_reads_its_id(self):
library, probe = self.build("-m64", PROBE, "probe")
hooks, _ = self.ring()
run = subprocess.run([str(probe)], capture_output=True, text=True, timeout=10,
env=dict(os.environ, LD_PRELOAD=str(library), FAKE_EVDEV_DIR=str(hooks)))
self.assertEqual(run.returncode, 0, run.stderr)
self.assertEqual(run.stdout, "JSIOCGNAME -1 EINVAL\n28de:11ff Microsoft X-Box 360 pad 0\n")
if __name__ == "__main__":
unittest.main()
Reference in new issue View Git Blame Copy Permalink