From 86983092afd06c724d8616a438a36dd33e9e46d8 Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sat, 31 Oct 2026 23:36:24 -0400 Subject: [PATCH] fix: Flathub installs work again outside a session (#1923) --- .../overlay/usr/local/bin/droiddeck-flatpak | 144 +++++++++++++ tools/tests/test_flatpak_system_bus.py | 199 ++++++++++++++++++ 2 files changed, 343 insertions(+) create mode 100644 tools/tests/test_flatpak_system_bus.py diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-flatpak b/tools/linuxfs/overlay/usr/local/bin/droiddeck-flatpak index 15f028fd4..eea38e457 100644 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-flatpak +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-flatpak @@ -1,7 +1,15 @@ #!/usr/bin/python3 import json import os +import re +import shutil +import signal +import socket +import subprocess import sys +import tempfile +import time +import urllib.parse os.environ.setdefault("FLATPAK_BWRAP", "/usr/local/bin/droiddeck-bwrap") @@ -11,6 +19,22 @@ gi.require_version("Flatpak", "1.0") from gi.repository import Flatpak, Gio, GLib REMOTE = "flathub" +SYSTEM_BUS = "/run/dbus/system_bus_socket" +BUS_COMMANDS = ("install", "install-bundle", "uninstall", "update", "prune") +BUS_CONFIG = """ + + system + unix:path=%s + EXTERNAL + + + + + + + +""" def prepare_rootfs(): @@ -33,6 +57,116 @@ def prepare_rootfs(): emit(e="warning", message="could not prepare %s: %s" % (target, err)) +def bus_reachable(path): + if isinstance(path, tuple): + try: + socket.create_connection(path, timeout=1).close() + return True + except (OSError, ValueError): + return False + sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + try: + sock.connect(path) + return True + except OSError: + return False + finally: + sock.close() + + +def system_bus_paths(): + address = os.environ.get("DBUS_SYSTEM_BUS_ADDRESS", "") + if not address: + return [SYSTEM_BUS] + paths = [] + for entry in filter(None, address.split(";")): + found = None + kind, _, params = entry.partition(":") + values = dict(part.partition("=")[::2] for part in params.split(",")) + if kind == "unix": + if values.get("path"): + found = urllib.parse.unquote_to_bytes(values["path"]) + elif values.get("abstract"): + found = b"\0" + urllib.parse.unquote_to_bytes(values["abstract"]) + elif kind == "tcp": + port = urllib.parse.unquote(values.get("port", "")) + digits = port.lstrip("0") + if not re.fullmatch(r"[0-9]+", port, re.ASCII) or not 0 < len(digits) <= 5 or int(digits) > 65535: + continue + found = (urllib.parse.unquote(values.get("host", "localhost")), int(digits)) + if found is None: + return None + paths.append(found) + return paths + + +def system_bus_reachable(): + paths = system_bus_paths() + return paths is None or any(bus_reachable(path) for path in paths) + + +def stop_system_bus(bus): + if not bus: + return + proc, work, conf, path = bus + if proc.poll() is None: + proc.terminate() + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + proc.wait() + remove_bus_files(work, conf, path) + + +def remove_bus_files(work, conf, path): + for name in (path, conf): + try: + os.unlink(name) + except OSError: + pass + try: + os.rmdir(work) + except OSError: + pass + + +def private_system_bus(): + if system_bus_reachable(): + return None + daemon = shutil.which("dbus-daemon") + if not daemon: + emit(e="warning", message="no system bus and no dbus-daemon to start one") + return None + try: + work = tempfile.mkdtemp(prefix="droiddeck-flatpak-bus-") + except OSError as err: + emit(e="warning", message="could not start a private system bus: %s" % err) + return None + conf = os.path.join(work, "bus.conf") + path = os.path.join(work, "bus") + try: + with open(conf, "w") as f: + f.write(BUS_CONFIG % path) + proc = subprocess.Popen([daemon, "--config-file=" + conf, "--nofork", "--nopidfile"], + stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + except OSError as err: + remove_bus_files(work, conf, path) + emit(e="warning", message="could not start a private system bus: %s" % err) + return None + bus = (proc, work, conf, path) + for _ in range(50): + if bus_reachable(path) or proc.poll() is not None: + break + time.sleep(0.1) + if not bus_reachable(path): + stop_system_bus(bus) + emit(e="warning", message="the private system bus did not start") + return None + os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = "unix:path=" + path + return bus + + def emit(**kw): sys.stdout.write(json.dumps(kw) + "\n") sys.stdout.flush() @@ -257,6 +391,16 @@ def main(): cmd, args = sys.argv[1], sys.argv[2:] if cmd in ("install", "install-bundle", "update"): prepare_rootfs() + bus = private_system_bus() if cmd in BUS_COMMANDS else None + if bus: + signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit(128 + signum)) + try: + return command(cmd, args) + finally: + stop_system_bus(bus) + + +def command(cmd, args): if cmd == "install" and args: return install(args[0]) if cmd == "install-bundle" and args: diff --git a/tools/tests/test_flatpak_system_bus.py b/tools/tests/test_flatpak_system_bus.py new file mode 100644 index 000000000..ebddaa3a6 --- /dev/null +++ b/tools/tests/test_flatpak_system_bus.py @@ -0,0 +1,199 @@ +import importlib.machinery +import importlib.util +import os +from pathlib import Path +import socket +import sys +import tempfile +import types +import unittest +from unittest import mock + +SCRIPT = Path(__file__).resolve().parents[1] / "linuxfs/overlay/usr/local/bin/droiddeck-flatpak" + + +def load(): + repository = types.ModuleType("gi.repository") + repository.Flatpak = types.SimpleNamespace() + repository.Gio = types.SimpleNamespace() + repository.GLib = types.SimpleNamespace(Error=RuntimeError) + gi = types.ModuleType("gi") + gi.require_version = lambda *args: None + gi.repository = repository + saved = {name: sys.modules.get(name) for name in ("gi", "gi.repository")} + sys.modules["gi"] = gi + sys.modules["gi.repository"] = repository + try: + loader = importlib.machinery.SourceFileLoader("droiddeck_flatpak_bus", str(SCRIPT)) + module = importlib.util.module_from_spec(importlib.util.spec_from_loader(loader.name, loader)) + loader.exec_module(module) + finally: + for name, value in saved.items(): + if value is None: + sys.modules.pop(name, None) + else: + sys.modules[name] = value + return module + + +class FakeDaemon: + started = [] + + def __init__(self, argv, **kwargs): + conf = next(a for a in argv if a.startswith("--config-file=")).split("=", 1)[1] + text = open(conf).read() + self.path = text.split("unix:path=", 1)[1].split("", 1)[0] + self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + self.server.bind(self.path) + self.server.listen(4) + self.running = True + FakeDaemon.started.append(self) + + def poll(self): + return None if self.running else 0 + + def terminate(self): + self.running = False + self.server.close() + + def wait(self, timeout=None): + return 0 + + def kill(self): + self.terminate() + + +class FlatpakSystemBusTest(unittest.TestCase): + def setUp(self): + self.module = load() + self.tmp = tempfile.mkdtemp() + self.env = mock.patch.dict(os.environ, {"DBUS_SYSTEM_BUS_ADDRESS": "unix:path=" + os.path.join(self.tmp, "missing")}) + self.env.start() + FakeDaemon.started = [] + + def tearDown(self): + self.env.stop() + os.rmdir(self.tmp) + + def test_a_reachable_system_bus_is_used_as_it_is(self): + path = os.path.join(self.tmp, "system") + server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + server.bind(path) + server.listen(1) + try: + os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = "unix:path=" + path + with mock.patch.object(self.module.subprocess, "Popen", FakeDaemon): + self.assertIsNone(self.module.private_system_bus()) + self.assertEqual([], FakeDaemon.started) + finally: + server.close() + os.unlink(path) + + def test_without_a_system_bus_a_private_one_runs_for_the_command_and_is_removed_after(self): + with mock.patch.object(self.module.shutil, "which", return_value="/usr/bin/dbus-daemon"), \ + mock.patch.object(self.module.subprocess, "Popen", FakeDaemon): + bus = self.module.private_system_bus() + self.assertIsNotNone(bus) + _, work, conf, path = bus + self.assertEqual("unix:path=" + path, os.environ["DBUS_SYSTEM_BUS_ADDRESS"]) + self.assertTrue(self.module.bus_reachable(path)) + self.module.stop_system_bus(bus) + self.assertFalse(os.path.exists(work)) + + def test_any_reachable_address_in_a_list_counts_as_the_system_bus(self): + path = os.path.join(self.tmp, "system") + server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + server.bind(path) + server.listen(1) + try: + os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = "unix:path=%s;unix:guid=1,path=%s" % (os.path.join(self.tmp, "missing"), path) + with mock.patch.object(self.module.subprocess, "Popen", FakeDaemon): + self.assertIsNone(self.module.private_system_bus()) + self.assertEqual([], FakeDaemon.started) + finally: + server.close() + os.unlink(path) + + def test_escaped_and_abstract_addresses_are_probed_as_dbus_reads_them(self): + path = os.path.join(self.tmp, "sys-bus") + server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + server.bind(path) + server.listen(1) + abstract = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + abstract.bind(b"\0droiddeck-flatpak-test-%d\xff" % os.getpid()) + abstract.listen(1) + try: + os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = "unix:path=" + path.replace("-", "%2D") + self.assertTrue(self.module.system_bus_reachable()) + os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = "unix:path=%s;unix:abstract=droiddeck-flatpak-test-%d%%FF" % (os.path.join(self.tmp, "missing"), os.getpid()) + self.assertTrue(self.module.system_bus_reachable()) + os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = "unix:abstract=droiddeck-flatpak-missing-%d" % os.getpid() + self.assertFalse(self.module.system_bus_reachable()) + listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + listener.bind(("127.0.0.1", 0)) + listener.listen(8) + port = listener.getsockname()[1] + os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = "unix:abstract=droiddeck-flatpak-missing-%d;tcp:host=127.0.0.1,port=%d" % (os.getpid(), port) + self.assertTrue(self.module.system_bus_reachable()) + os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = "tcp:host=127.0.0.1,port=" + "".join("%%%02X" % ord(c) for c in str(port)) + self.assertTrue(self.module.system_bus_reachable()) + os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = "tcp:host=127.0.0.1,port=000%d" % port + self.assertTrue(self.module.system_bus_reachable()) + listener.close() + self.assertFalse(self.module.system_bus_reachable()) + for bad in ("%C2%B2", "65536", "0", "000", "x", "9" * 5000): + os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = "tcp:host=127.0.0.1,port=" + bad + self.assertEqual([], self.module.system_bus_paths()) + self.assertFalse(self.module.system_bus_reachable()) + os.environ["DBUS_SYSTEM_BUS_ADDRESS"] = "launchd:env=DBUS_LAUNCHD_SESSION_BUS_SOCKET" + self.assertTrue(self.module.system_bus_reachable()) + finally: + abstract.close() + server.close() + os.unlink(path) + + def test_a_daemon_that_cannot_launch_leaves_no_files_and_warns(self): + made = [] + real = tempfile.mkdtemp + + def mkdtemp(**kwargs): + made.append(real(**kwargs)) + return made[-1] + + with mock.patch.object(self.module.shutil, "which", return_value="/usr/bin/dbus-daemon"), \ + mock.patch.object(self.module.tempfile, "mkdtemp", mkdtemp), \ + mock.patch.object(self.module.subprocess, "Popen", side_effect=OSError("exec failed")), \ + mock.patch.object(self.module, "emit") as emit: + self.assertIsNone(self.module.private_system_bus()) + emit.assert_called_once() + self.assertFalse(os.path.exists(made[0])) + + def test_without_dbus_daemon_the_command_still_runs_and_warns(self): + with mock.patch.object(self.module.shutil, "which", return_value=None), \ + mock.patch.object(self.module, "emit") as emit: + self.assertIsNone(self.module.private_system_bus()) + emit.assert_called_once() + + def test_every_command_that_changes_apps_gets_a_system_bus(self): + calls = [] + self.module.private_system_bus = lambda: calls.append("start") or "bus" + self.module.stop_system_bus = lambda bus: calls.append("stop:%s" % bus) + self.module.prepare_rootfs = lambda: None + self.module.install = lambda app_id: calls.append("install") or 0 + self.module.updates = lambda: calls.append("updates") or 0 + with mock.patch.object(sys, "argv", ["droiddeck-flatpak", "install", "org.example.App"]), \ + mock.patch.object(self.module.signal, "signal") as handler: + self.assertEqual(0, self.module.main()) + self.assertEqual(["start", "install", "stop:bus"], calls) + self.assertEqual(self.module.signal.SIGTERM, handler.call_args[0][0]) + with self.assertRaises(SystemExit): + handler.call_args[0][1](self.module.signal.SIGTERM, None) + calls.clear() + with mock.patch.object(sys, "argv", ["droiddeck-flatpak", "updates"]): + self.assertEqual(0, self.module.main()) + self.assertNotIn("start", calls) + self.assertIn("updates", calls) + + +if __name__ == "__main__": + unittest.main()