Files
DroidDeck/tools/tests/test_descriptor_preload.py
T
Kurt Himebauch eabcfc7b74 chore: consistent code branding (#2800)
* chore: consistent code branding

* fix: carry legacy overrides, queues and live sync rows across the rename

* fix: keep queued legacy overrides on a failed rename and separate merged queue entries
2026-11-17 23:31:26 -05:00

246 lines
10 KiB
Python

import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import unittest
PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload"
FAKE = r"""
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
static int answer(int fd) {
char link[32], path[4096];
snprintf(link, sizeof(link), "/proc/self/fd/%d", fd);
long n = syscall(SYS_readlinkat, AT_FDCWD, link, path, sizeof(path) - 1);
path[n > 0 ? n : 0] = '\0';
if (strstr(path, "/card/")) return ENOTSUP;
if (strstr(path, "/denied/")) return EACCES;
return ENODATA;
}
ssize_t fgetxattr(int fd, const char *name, void *value, size_t size) {
(void)name; (void)value; (void)size;
errno = answer(fd);
return -1;
}
int fsetxattr(int fd, const char *name, const void *value, size_t size, int flags) {
(void)name; (void)value; (void)size; (void)flags;
int error = answer(fd);
if (error == ENODATA) return 0;
errno = error;
return -1;
}
int fremovexattr(int fd, const char *name) {
(void)name;
errno = answer(fd);
return -1;
}
"""
PROGRAM = r"""
#define _GNU_SOURCE
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/xattr.h>
#include <unistd.h>
static const char *error(void) {
return errno == ENOTSUP ? "unsupported" : errno == ENODATA ? "none" : errno == ERANGE ? "range" :
errno == EACCES ? "denied" : "other";
}
int main(int argc, char **argv) {
for (int i = 1; i < argc; i++) {
const char *op = argv[i];
if (!strcmp(op, "unlink") || !strcmp(op, "rmdir")) {
const char *path = argv[++i];
printf("%s\n", (op[0] == 'u' ? unlink(path) : rmdir(path)) == 0 ? "ok" : "failed");
continue;
}
if (!strcmp(op, "remove-path")) {
printf("%s\n", remove(argv[++i]) == 0 ? "ok" : "failed");
continue;
}
if (!strcmp(op, "rename")) {
const char *from = argv[++i], *to = argv[++i];
printf("%s\n", rename(from, to) == 0 ? "ok" : "failed");
continue;
}
int fd = open(argv[++i], O_RDONLY);
char value[64];
if (!strcmp(op, "set")) {
const char *text = argv[++i];
errno = 1234;
int result = fsetxattr(fd, "user.wine.sd", text, strlen(text), 0);
printf("%s\n", result == 0 ? errno == 1234 ? "ok" : "errno" : error());
} else if (!strcmp(op, "get")) {
ssize_t n = fgetxattr(fd, "user.wine.sd", value, sizeof(value));
if (n < 0) printf("%s\n", error());
else printf("=%.*s\n", (int)n, value);
} else if (!strcmp(op, "size")) {
ssize_t n = fgetxattr(fd, "user.wine.sd", NULL, 0);
if (n < 0) printf("%s\n", error());
else printf("%d\n", (int)n);
} else if (!strcmp(op, "short")) {
ssize_t n = fgetxattr(fd, "user.wine.sd", value, 2);
printf("%s\n", n < 0 ? error() : "read");
} else if (!strcmp(op, "remove")) {
errno = 1234;
int result = fremovexattr(fd, "user.wine.sd");
printf("%s\n", result == 0 ? errno == 1234 ? "ok" : "errno" : error());
} else if (!strcmp(op, "other")) {
ssize_t n = fgetxattr(fd, "user.other", value, sizeof(value));
printf("%s\n", n < 0 ? error() : "read");
}
close(fd);
}
return 0;
}
"""
@unittest.skipUnless(shutil.which("cc"), "needs a C compiler")
class DescriptorPreloadTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.build_dir = tempfile.TemporaryDirectory()
build = Path(cls.build_dir.name)
(build / "fake.c").write_text(FAKE)
(build / "program.c").write_text(PROGRAM)
cls.preload = build / "libddsession.so"
cls.fake = build / "fake.so"
subprocess.run(["cc", "-shared", "-fPIC", "-O2", "-Wall", "-pthread", "-o", str(cls.preload),
*map(str, sorted(PRELOAD.glob("*.c"))), "-ldl"], check=True)
subprocess.run(["cc", "-shared", "-fPIC", "-O2", "-o", str(cls.fake), str(build / "fake.c")], check=True)
cls.wineserver = build / "wineserver"
subprocess.run(["cc", "-O2", "-o", str(cls.wineserver), str(build / "program.c")], check=True)
cls.other = build / "wine64-preloader"
shutil.copy(cls.wineserver, cls.other)
@classmethod
def tearDownClass(cls):
cls.build_dir.cleanup()
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.dir = Path(os.path.realpath(self.temp.name))
self.prefix = self.dir / "prefix"
self.prefix.mkdir()
self.store = self.prefix / ".droiddeck-descriptors"
for kind in ("card", "disk", "denied"):
(self.dir / kind / "game").mkdir(parents=True)
(self.dir / kind / "game" / "file").write_text("x")
def tearDown(self):
self.temp.cleanup()
def path(self, *parts):
return str(self.dir.joinpath(*parts))
def run_as(self, program, *args, prefix=True):
env = dict(os.environ, LD_PRELOAD="%s:%s" % (self.preload, self.fake))
env.pop("WINEPREFIX", None)
if prefix:
env["WINEPREFIX"] = str(self.prefix)
result = subprocess.run([str(program), *args], env=env, capture_output=True, text=True, check=True)
return result.stdout.split()
def server(self, *args, **kwargs):
return self.run_as(self.wineserver, *args, **kwargs)
def test_a_descriptor_is_kept_where_the_volume_cannot_store_it(self):
file, folder = self.path("card", "game", "file"), self.path("card", "game")
self.assertEqual(["none", "ok", "ok"], self.server("get", file, "set", file, "one", "set", folder, "two"))
self.assertEqual(["=one", "3", "=two"], self.server("get", file, "size", file, "get", folder))
def test_a_descriptor_is_replaced_and_removed(self):
file = self.path("card", "game", "file")
self.assertEqual(["ok", "ok", "=longer"], self.server("set", file, "one", "set", file, "longer", "get", file))
self.assertEqual(["range", "ok", "none", "none"], self.server("short", file, "remove", file, "get", file, "remove", file))
def test_a_volume_that_stores_descriptors_is_left_alone(self):
file = self.path("disk", "game", "file")
self.assertEqual(["ok", "none", "none"], self.server("set", file, "one", "get", file, "remove", file))
self.assertFalse(self.store.exists())
def test_other_failures_keep_their_error(self):
file = self.path("denied", "game", "file")
self.assertEqual(["denied", "denied", "denied"], self.server("set", file, "one", "get", file, "remove", file))
self.assertFalse(self.store.exists())
def test_other_programs_and_other_attributes_are_unchanged(self):
file = self.path("card", "game", "file")
self.assertEqual(["unsupported", "unsupported", "unsupported"],
self.run_as(self.other, "set", file, "one", "get", file, "remove", file))
self.assertEqual(["ok", "unsupported"], self.server("set", file, "one", "other", file))
self.assertEqual(["unsupported"], self.run_as(self.other, "get", file))
def test_nothing_is_kept_without_a_prefix(self):
file = self.path("card", "game", "file")
self.assertEqual(["unsupported", "unsupported", "unsupported"],
self.server("set", file, "one", "get", file, "remove", file, prefix=False))
def test_a_deleted_file_loses_its_descriptor(self):
file, folder = self.path("card", "game", "file"), self.path("card", "game")
self.assertEqual(["ok", "ok", "ok"], self.server("set", file, "one", "set", folder, "two", "unlink", file))
Path(file).write_text("x")
self.assertEqual(["none", "ok", "ok"], self.server("get", file, "unlink", file, "rmdir", folder))
Path(folder).mkdir()
self.assertEqual(["none"], self.server("get", folder))
def test_a_removed_file_or_folder_loses_its_descriptor(self):
file, folder = self.path("card", "game", "file"), self.path("card", "game")
self.assertEqual(["ok", "ok", "ok", "ok"],
self.server("set", file, "one", "set", folder, "two", "remove-path", file, "remove-path", folder))
Path(folder).mkdir()
Path(file).write_text("x")
self.assertEqual(["none", "none"], self.server("get", folder, "get", file))
def test_a_file_deleted_through_a_link_loses_its_descriptor(self):
file = self.path("card", "game", "file")
os.symlink(self.path("card"), self.path("drive"))
self.assertEqual(["ok", "ok"], self.server("set", file, "one", "unlink", self.path("drive", "game", "file")))
Path(file).write_text("x")
self.assertEqual(["none"], self.server("get", file))
def test_a_descriptor_follows_a_rename(self):
file, moved = self.path("card", "game", "file"), self.path("card", "game", "moved")
self.assertEqual(["ok", "ok", "=one"], self.server("set", file, "one", "rename", file, moved, "get", moved))
Path(file).write_text("x")
self.assertEqual(["none", "ok", "none"], self.server("get", file, "rename", file, moved, "get", moved))
def test_descriptors_follow_a_renamed_folder(self):
file, folder, moved = self.path("card", "game", "file"), self.path("card", "game"), self.path("card", "moved")
self.assertEqual(["ok", "ok", "ok"], self.server("set", file, "one", "set", folder, "two", "rename", folder, moved))
self.assertEqual(["=two", "=one"], self.server("get", moved, "get", self.path("card", "moved", "file")))
Path(folder).mkdir()
(Path(folder) / "file").write_text("x")
self.assertEqual(["none", "none"], self.server("get", folder, "get", file))
def test_deletes_outside_the_store_cost_nothing_before_it_exists(self):
file = self.path("disk", "game", "file")
self.assertEqual(["ok"], self.server("unlink", file))
self.assertFalse(self.store.exists())
def test_a_name_too_long_to_keep_reports_no_support(self):
long_file = self.path("card", "game", "n" * 254)
Path(long_file).write_text("x")
self.assertEqual(["unsupported", "unsupported"], self.server("set", long_file, "one", "get", long_file))
if __name__ == "__main__":
unittest.main()