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()