{"diffoscope-json-version": 1, "source1": "/srv/reproducible-results/rbuild-debian/r-b-build.6ILpfJsB/b1/cockpit_311-1_amd64.changes", "source2": "/srv/reproducible-results/rbuild-debian/r-b-build.6ILpfJsB/b2/cockpit_311-1_amd64.changes", "unified_diff": null, "details": [{"source1": "Files", "source2": "Files", "unified_diff": "@@ -1,10 +1,10 @@\n \n  eb39dff5eefa816b4e7a39342463c119 139816 debug optional cockpit-bridge-dbgsym_311-1_amd64.deb\n- 1ca873f860e5729a903db399530a38d0 358052 admin optional cockpit-bridge_311-1_amd64.deb\n+ 58be68cbeebfe3b2801686970963a37e 358300 admin optional cockpit-bridge_311-1_amd64.deb\n  d6420f2f7547b4e22925ba79ff18803d 131364 doc optional cockpit-doc_311-1_all.deb\n  88b04dc126f5b100988e2bdf9812be7b 833092 admin optional cockpit-networkmanager_311-1_all.deb\n  270d4784b46c2aff32acab6a65b331f8 939100 admin optional cockpit-packagekit_311-1_all.deb\n  2404cac22f6d13ee8bc98b8a653fe7db 234052 debug optional cockpit-pcp-dbgsym_311-1_amd64.deb\n  89b873b9ffeee3532d069d884640ec67 78852 admin optional cockpit-pcp_311-1_amd64.deb\n  e3b2783c793e9b15a89ff5b04c527610 557948 admin optional cockpit-sosreport_311-1_all.deb\n  cdf3488303d663c6fd12c06a5f2b8016 872112 admin optional cockpit-storaged_311-1_all.deb\n"}, {"source1": "cockpit-bridge_311-1_amd64.deb", "source2": "cockpit-bridge_311-1_amd64.deb", "unified_diff": null, "details": [{"source1": "file list", "source2": "file list", "unified_diff": "@@ -1,3 +1,3 @@\n -rw-r--r--   0        0        0        4 2024-02-15 08:39:16.000000 debian-binary\n -rw-r--r--   0        0        0     3888 2024-02-15 08:39:16.000000 control.tar.xz\n--rw-r--r--   0        0        0   353972 2024-02-15 08:39:16.000000 data.tar.xz\n+-rw-r--r--   0        0        0   354220 2024-02-15 08:39:16.000000 data.tar.xz\n"}, {"source1": "control.tar.xz", "source2": "control.tar.xz", "unified_diff": null, "details": [{"source1": "control.tar", "source2": "control.tar", "unified_diff": null, "details": [{"source1": "./md5sums", "source2": "./md5sums", "unified_diff": null, "details": [{"source1": "./md5sums", "source2": "./md5sums", "comments": ["Files differ"], "unified_diff": null}]}]}]}, {"source1": "data.tar.xz", "source2": "data.tar.xz", "unified_diff": null, "details": [{"source1": "data.tar", "source2": "data.tar", "unified_diff": null, "details": [{"source1": "file list", "source2": "file list", "unified_diff": "@@ -60,15 +60,15 @@\n -rw-r--r--   0 root         (0) root         (0)     6861 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/channels/metrics.py\n -rw-r--r--   0 root         (0) root         (0)     4053 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/channels/packages.py\n -rw-r--r--   0 root         (0) root         (0)     4827 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/channels/stream.py\n -rw-r--r--   0 root         (0) root         (0)     1171 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/channels/trivial.py\n -rw-r--r--   0 root         (0) root         (0)     3188 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/config.py\n drwxr-xr-x   0 root         (0) root         (0)        0 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/data/\n -rw-r--r--   0 root         (0) root         (0)      574 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/data/__init__.py\n--rw-r--r--   0 root         (0) root         (0)    86152 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/data/cockpit-bridge.beipack.xz\n+-rw-r--r--   0 root         (0) root         (0)    86428 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/data/cockpit-bridge.beipack.xz\n -rw-r--r--   0 root         (0) root         (0)     3212 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/data/fail.html\n -rw-r--r--   0 root         (0) root         (0)     5517 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/internal_endpoints.py\n -rw-r--r--   0 root         (0) root         (0)     6742 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/jsonutil.py\n -rw-r--r--   0 root         (0) root         (0)    21539 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/packages.py\n -rw-r--r--   0 root         (0) root         (0)    12729 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/peer.py\n -rw-r--r--   0 root         (0) root         (0)     7580 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/polkit.py\n -rw-r--r--   0 root         (0) root         (0)     2031 2024-02-15 08:39:16.000000 ./usr/lib/python3/dist-packages/cockpit/polyfills.py\n"}, {"source1": "./usr/lib/python3/dist-packages/cockpit/data/cockpit-bridge.beipack.xz", "source2": "./usr/lib/python3/dist-packages/cockpit/data/cockpit-bridge.beipack.xz", "unified_diff": null, "details": [{"source1": "cockpit-bridge.beipack", "source2": "cockpit-bridge.beipack", "comments": ["Ordering differences only"], "unified_diff": "@@ -64,197 +64,1122 @@\n       ) -> Optional[importlib.machinery.ModuleSpec]:\n         if fullname not in self.modules:\n             return None\n         return importlib.util.spec_from_loader(fullname, self)\n \n import sys\n sys.meta_path.insert(0, BeipackLoader({\n-  'cockpit/_version.py': br'''__version__ = '311'\n-''',\n-  'cockpit/jsonutil.py': r'''# This file is part of Cockpit.\n+  'cockpit/peer.py': r'''# This file is part of Cockpit.\n #\n-# Copyright (C) 2023 Red Hat, Inc.\n+# Copyright (C) 2022 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n # (at your option) any later version.\n #\n # This program is distributed in the hope that it will be useful,\n # but WITHOUT ANY WARRANTY; without even the implied warranty of\n # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n # GNU General Public License for more details.\n #\n # You should have received a copy of the GNU General Public License\n # along with this program.  If not, see <https://www.gnu.org/licenses/>.\n \n-from enum import Enum\n-from typing import Callable, Dict, List, Mapping, Optional, Sequence, Type, TypeVar, Union\n+import asyncio\n+import logging\n+import os\n+from typing import Callable, List, Optional, Sequence\n \n-JsonLiteral = Union[str, float, bool, None]\n+from .jsonutil import JsonObject, JsonValue\n+from .packages import BridgeConfig\n+from .protocol import CockpitProblem, CockpitProtocol, CockpitProtocolError\n+from .router import Endpoint, Router, RoutingRule\n+from .transports import SubprocessProtocol, SubprocessTransport\n \n-# immutable\n-JsonValue = Union['JsonObject', Sequence['JsonValue'], JsonLiteral]\n-JsonObject = Mapping[str, JsonValue]\n+logger = logging.getLogger(__name__)\n \n-# mutable\n-JsonDocument = Union['JsonDict', 'JsonList', JsonLiteral]\n-JsonDict = Dict[str, JsonDocument]\n-JsonList = List[JsonDocument]\n \n+class PeerError(CockpitProblem):\n+    pass\n \n-DT = TypeVar('DT')\n-T = TypeVar('T')\n \n+class PeerExited(Exception):\n+    def __init__(self, exit_code: int):\n+        self.exit_code = exit_code\n \n-class JsonError(Exception):\n-    value: object\n \n-    def __init__(self, value: object, msg: str):\n-        super().__init__(msg)\n-        self.value = value\n+class Peer(CockpitProtocol, SubprocessProtocol, Endpoint):\n+    done_callbacks: List[Callable[[], None]]\n+    init_future: Optional[asyncio.Future]\n \n+    def __init__(self, router: Router):\n+        super().__init__(router)\n \n-def typechecked(value: JsonValue, expected_type: Type[T]) -> T:\n-    \"\"\"Ensure a JSON value has the expected type, returning it if so.\"\"\"\n-    if not isinstance(value, expected_type):\n-        raise JsonError(value, f'must have type {expected_type.__name__}')\n-    return value\n+        # All Peers start out frozen \u2014 we only unfreeze after we see the first 'init' message\n+        self.freeze_endpoint()\n \n+        self.init_future = asyncio.get_running_loop().create_future()\n+        self.done_callbacks = []\n \n-# We can't use None as a sentinel because it's often the actual default value\n-# EllipsisType is difficult because it's not available before 3.10.\n-# See https://peps.python.org/pep-0484/#support-for-singleton-types-in-unions\n-class _Empty(Enum):\n-    TOKEN = 0\n+    # Initialization\n+    async def do_connect_transport(self) -> None:\n+        raise NotImplementedError\n \n+    async def spawn(self, argv: Sequence[str], env: Sequence[str], **kwargs) -> asyncio.Transport:\n+        # Not actually async...\n+        loop = asyncio.get_running_loop()\n+        user_env = dict(e.split('=', 1) for e in env)\n+        return SubprocessTransport(loop, self, argv, env=dict(os.environ, **user_env), **kwargs)\n \n-_empty = _Empty.TOKEN\n+    async def start(self, init_host: Optional[str] = None, **kwargs: JsonValue) -> JsonObject:\n+        \"\"\"Request that the Peer is started and connected to the router.\n \n+        Creates the transport, connects it to the protocol, and participates in\n+        exchanging of init messages.  If anything goes wrong, the connection\n+        will be closed and an exception will be raised.\n \n-def _get(obj: JsonObject, cast: Callable[[JsonValue], T], key: str, default: Union[DT, _Empty]) -> Union[T, DT]:\n-    try:\n-        return cast(obj[key])\n-    except KeyError:\n-        if default is not _empty:\n-            return default\n-        raise JsonError(obj, f\"attribute '{key}' required\") from None\n-    except JsonError as exc:\n-        target = f\"attribute '{key}'\" + (' elements:' if exc.value is not obj[key] else ':')\n-        raise JsonError(obj, f\"{target} {exc!s}\") from exc\n+        The Peer starts out in a frozen state (ie: attempts to send messages to\n+        it will initially be queued). If init_host is not None then an init\n+        message is sent with the given 'host' field, plus any extra kwargs, and\n+        the queue is thawed. Otherwise, the caller is responsible for sending\n+        the init message and thawing the peer.\n \n+        In any case, the return value is the init message from the peer.\n+        \"\"\"\n+        assert self.init_future is not None\n \n-def get_bool(obj: JsonObject, key: str, default: Union[DT, _Empty] = _empty) -> Union[DT, bool]:\n-    return _get(obj, lambda v: typechecked(v, bool), key, default)\n+        def _connect_task_done(task: asyncio.Task) -> None:\n+            assert task is connect_task\n+            try:\n+                task.result()\n+            except asyncio.CancelledError:  # we did that (below)\n+                pass                        # we want to ignore it\n+            except Exception as exc:\n+                self.close(exc)\n \n+        connect_task = asyncio.create_task(self.do_connect_transport())\n+        connect_task.add_done_callback(_connect_task_done)\n \n-def get_int(obj: JsonObject, key: str, default: Union[DT, _Empty] = _empty) -> Union[DT, int]:\n-    return _get(obj, lambda v: typechecked(v, int), key, default)\n+        try:\n+            # Wait for something to happen:\n+            #   - exception from our connection function\n+            #   - receiving \"init\" from the other side\n+            #   - receiving EOF from the other side\n+            #   - .close() was called\n+            #   - other transport exception\n+            init_message = await self.init_future\n \n+        except (PeerExited, BrokenPipeError):\n+            # These are fairly generic errors. PeerExited means that we observed the process exiting.\n+            # BrokenPipeError means that we got EPIPE when attempting to write() to it. In both cases,\n+            # the process is gone, but it's not clear why. If the connection process is still running,\n+            # perhaps we'd get a better error message from it.\n+            await connect_task\n+            # Otherwise, re-raise\n+            raise\n \n-def get_str(obj: JsonObject, key: str, default: Union[DT, _Empty] = _empty) -> Union[DT, str]:\n-    return _get(obj, lambda v: typechecked(v, str), key, default)\n+        finally:\n+            self.init_future = None\n \n+            # In any case (failure or success) make sure this is done.\n+            if not connect_task.done():\n+                connect_task.cancel()\n \n-def get_str_or_none(obj: JsonObject, key: str, default: Optional[str]) -> Optional[str]:\n-    return _get(obj, lambda v: None if v is None else typechecked(v, str), key, default)\n+        if init_host is not None:\n+            logger.debug('  sending init message back, host %s', init_host)\n+            # Send \"init\" back\n+            self.write_control(None, command='init', version=1, host=init_host, **kwargs)\n \n+            # Thaw the queued messages\n+            self.thaw_endpoint()\n \n-def get_dict(obj: JsonObject, key: str, default: Union[DT, _Empty] = _empty) -> Union[DT, JsonObject]:\n-    return _get(obj, lambda v: typechecked(v, dict), key, default)\n+        return init_message\n \n+    # Background initialization\n+    def start_in_background(self, init_host: Optional[str] = None, **kwargs: JsonValue) -> None:\n+        def _start_task_done(task: asyncio.Task) -> None:\n+            assert task is start_task\n \n-def get_object(\n-    obj: JsonObject,\n-    key: str,\n-    constructor: Callable[[JsonObject], T],\n-    default: Union[DT, _Empty] = _empty\n-) -> Union[DT, T]:\n-    return _get(obj, lambda v: constructor(typechecked(v, dict)), key, default)\n+            try:\n+                task.result()\n+            except (OSError, PeerExited, CockpitProblem, asyncio.CancelledError):\n+                pass  # Those are expected.  Others will throw.\n \n+        start_task = asyncio.create_task(self.start(init_host, **kwargs))\n+        start_task.add_done_callback(_start_task_done)\n \n-def get_strv(obj: JsonObject, key: str, default: Union[DT, _Empty] = _empty) -> Union[DT, Sequence[str]]:\n-    def as_strv(value: JsonValue) -> Sequence[str]:\n-        return tuple(typechecked(item, str) for item in typechecked(value, list))\n-    return _get(obj, as_strv, key, default)\n+    # Shutdown\n+    def add_done_callback(self, callback: Callable[[], None]) -> None:\n+        self.done_callbacks.append(callback)\n \n+    # Handling of interesting events\n+    def do_superuser_init_done(self) -> None:\n+        pass\n \n-def get_objv(obj: JsonObject, key: str, constructor: Callable[[JsonObject], T]) -> Union[DT, Sequence[T]]:\n-    def as_objv(value: JsonValue) -> Sequence[T]:\n-        return tuple(constructor(typechecked(item, dict)) for item in typechecked(value, list))\n-    return _get(obj, as_objv, key, ())\n+    def do_authorize(self, message: JsonObject) -> None:\n+        pass\n \n+    def transport_control_received(self, command: str, message: JsonObject) -> None:\n+        if command == 'init' and self.init_future is not None:\n+            logger.debug('Got init message with active init_future.  Setting result.')\n+            self.init_future.set_result(message)\n+        elif command == 'authorize':\n+            self.do_authorize(message)\n+        elif command == 'superuser-init-done':\n+            self.do_superuser_init_done()\n+        else:\n+            raise CockpitProtocolError(f'Received unexpected control message {command}')\n \n-def create_object(message: 'JsonObject | None', kwargs: JsonObject) -> JsonObject:\n-    \"\"\"Constructs a JSON object based on message and kwargs.\n+    def eof_received(self) -> bool:\n+        # We always expect to be the ones to close the connection, so if we get\n+        # an EOF, then we consider it to be an error.  This allows us to\n+        # distinguish close caused by unexpected EOF (but no errno from a\n+        # syscall failure) vs. close caused by calling .close() on our side.\n+        # The process is still running at this point, so keep it and handle\n+        # the error in process_exited().\n+        logger.debug('Peer %s received unexpected EOF', self.__class__.__name__)\n+        return True\n \n-    If only message is given, it is returned, unmodified.  If message is None,\n-    it is equivalent to an empty dictionary.  A copy is always made.\n+    def do_closed(self, exc: Optional[Exception]) -> None:\n+        logger.debug('Peer %s connection lost %s %s', self.__class__.__name__, type(exc), exc)\n \n-    If kwargs are present, then any underscore ('_') present in a key name is\n-    rewritten to a dash ('-').  This is intended to bridge between the required\n-    Python syntax when providing kwargs and idiomatic JSON (which uses '-' for\n-    attributes).  These values override values in message.\n+        if exc is None:\n+            self.shutdown_endpoint(problem='terminated')\n+        elif isinstance(exc, PeerExited):\n+            # a common case is that the called peer does not exist\n+            if exc.exit_code == 127:\n+                self.shutdown_endpoint(problem='no-cockpit')\n+            else:\n+                self.shutdown_endpoint(problem='terminated', message=f'Peer exited with status {exc.exit_code}')\n+        elif isinstance(exc, CockpitProblem):\n+            self.shutdown_endpoint(exc.attrs)\n+        else:\n+            self.shutdown_endpoint(problem='internal-error',\n+                                   message=f\"[{exc.__class__.__name__}] {exc!s}\")\n \n-    The idea is that `message` should be used for passing data along, and\n-    kwargs used for data originating at a given call site, possibly including\n-    modifications to an original message.\n+        # If .start() is running, we need to make sure it stops running,\n+        # raising the correct exception.\n+        if self.init_future is not None and not self.init_future.done():\n+            if exc is not None:\n+                self.init_future.set_exception(exc)\n+            else:\n+                self.init_future.cancel()\n+\n+        for callback in self.done_callbacks:\n+            callback()\n+\n+    def process_exited(self) -> None:\n+        assert isinstance(self.transport, SubprocessTransport)\n+        logger.debug('Peer %s exited, status %d', self.__class__.__name__, self.transport.get_returncode())\n+        returncode = self.transport.get_returncode()\n+        assert isinstance(returncode, int)\n+        self.close(PeerExited(returncode))\n+\n+    # Forwarding data: from the peer to the router\n+    def channel_control_received(self, channel: str, command: str, message: JsonObject) -> None:\n+        if self.init_future is not None:\n+            raise CockpitProtocolError('Received unexpected channel control message before init')\n+        self.send_channel_control(channel, command, message)\n+\n+    def channel_data_received(self, channel: str, data: bytes) -> None:\n+        if self.init_future is not None:\n+            raise CockpitProtocolError('Received unexpected channel data before init')\n+        self.send_channel_data(channel, data)\n+\n+    # Forwarding data: from the router to the peer\n+    def do_channel_control(self, channel: str, command: str, message: JsonObject) -> None:\n+        assert self.init_future is None\n+        self.write_control(message)\n+\n+    def do_channel_data(self, channel: str, data: bytes) -> None:\n+        assert self.init_future is None\n+        self.write_channel_data(channel, data)\n+\n+    def do_kill(self, host: 'str | None', group: 'str | None', message: JsonObject) -> None:\n+        assert self.init_future is None\n+        self.write_control(message)\n+\n+    def do_close(self) -> None:\n+        self.close()\n+\n+\n+class ConfiguredPeer(Peer):\n+    config: BridgeConfig\n+    args: Sequence[str]\n+    env: Sequence[str]\n+\n+    def __init__(self, router: Router, config: BridgeConfig):\n+        self.config = config\n+        self.args = config.spawn\n+        self.env = config.environ\n+        super().__init__(router)\n+\n+    async def do_connect_transport(self) -> None:\n+        await self.spawn(self.args, self.env)\n+\n+\n+class PeerRoutingRule(RoutingRule):\n+    config: BridgeConfig\n+    match: JsonObject\n+    peer: Optional[Peer]\n+\n+    def __init__(self, router: Router, config: BridgeConfig):\n+        super().__init__(router)\n+        self.config = config\n+        self.match = config.match\n+        self.peer = None\n+\n+    def apply_rule(self, options: JsonObject) -> Optional[Peer]:\n+        # Check that we match\n+\n+        for key, value in self.match.items():\n+            if key not in options:\n+                logger.debug('        rejecting because key %s is missing', key)\n+                return None\n+            if value is not None and options[key] != value:\n+                logger.debug('        rejecting because key %s has wrong value %s (vs %s)', key, options[key], value)\n+                return None\n+\n+        # Start the peer if it's not running already\n+        if self.peer is None:\n+            self.peer = ConfiguredPeer(self.router, self.config)\n+            self.peer.add_done_callback(self.peer_closed)\n+            assert self.router.init_host\n+            self.peer.start_in_background(init_host=self.router.init_host)\n+\n+        return self.peer\n+\n+    def peer_closed(self):\n+        self.peer = None\n+\n+    def shutdown(self):\n+        if self.peer is not None:\n+            self.peer.close()\n+\n+\n+class PeersRoutingRule(RoutingRule):\n+    rules: List[PeerRoutingRule] = []\n+\n+    def apply_rule(self, options: JsonObject) -> Optional[Endpoint]:\n+        logger.debug('    considering %d rules', len(self.rules))\n+        for rule in self.rules:\n+            logger.debug('      considering %s', rule.config.name)\n+            endpoint = rule.apply_rule(options)\n+            if endpoint is not None:\n+                logger.debug('        selected')\n+                return endpoint\n+        logger.debug('      no peer rules matched')\n+        return None\n+\n+    def set_configs(self, bridge_configs: Sequence[BridgeConfig]) -> None:\n+        old_rules = self.rules\n+        self.rules = []\n+\n+        for config in bridge_configs:\n+            # Those are handled elsewhere...\n+            if config.privileged or 'host' in config.match:\n+                continue\n+\n+            # Try to reuse an existing rule, if one exists...\n+            for rule in list(old_rules):\n+                if rule.config == config:\n+                    old_rules.remove(rule)\n+                    break\n+            else:\n+                # ... otherwise, create a new one.\n+                rule = PeerRoutingRule(self.router, config)\n+\n+            self.rules.append(rule)\n+\n+        # close down the old rules that didn't get reclaimed\n+        for rule in old_rules:\n+            rule.shutdown()\n+\n+    def shutdown(self):\n+        for rule in self.rules:\n+            rule.shutdown()\n+'''.encode('utf-8'),\n+  'cockpit/protocol.py': br'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2022 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n+\n+import asyncio\n+import json\n+import logging\n+import uuid\n+\n+from .jsonutil import JsonError, JsonObject, JsonValue, create_object, get_int, get_str, typechecked\n+\n+logger = logging.getLogger(__name__)\n+\n+\n+class CockpitProblem(Exception):\n+    \"\"\"A type of exception that carries a problem code and a message.\n+\n+    Depending on the scope, this is used to handle shutting down:\n+\n+      - an individual channel (sends problem code in the close message)\n+      - peer connections (sends problem code in close message for each open channel)\n+      - the main stdio interaction with the bridge\n+\n+    It is usually thrown in response to some violation of expected protocol\n+    when parsing messages, connecting to a peer, or opening a channel.\n     \"\"\"\n-    result = dict(message or {})\n+    attrs: JsonObject\n \n-    for key, value in kwargs.items():\n-        # rewrite '_' (necessary in Python syntax kwargs list) to '-' (idiomatic JSON)\n-        json_key = key.replace('_', '-')\n-        result[json_key] = value\n+    def __init__(self, problem: str, _msg: 'JsonObject | None' = None, **kwargs: JsonValue) -> None:\n+        kwargs['problem'] = problem\n+        self.attrs = create_object(_msg, kwargs)\n+        super().__init__(get_str(self.attrs, 'message', problem))\n \n-    return result\n+\n+class CockpitProtocolError(CockpitProblem):\n+    def __init__(self, message: str, problem: str = 'protocol-error'):\n+        super().__init__(problem, message=message)\n \n \n-def json_merge_patch(current: JsonObject, patch: JsonObject) -> JsonObject:\n-    \"\"\"Perform a JSON merge patch (RFC 7396) using 'current' and 'patch'.\n-    Neither of the original dictionaries is modified \u2014 the result is returned.\n+class CockpitProtocol(asyncio.Protocol):\n+    \"\"\"A naive implementation of the Cockpit frame protocol\n+\n+    We need to use this because Python's SelectorEventLoop doesn't supported\n+    buffered protocols.\n     \"\"\"\n-    # Always take a copy ('result') \u2014 we never modify the input ('current')\n-    result = dict(current)\n-    for key, patch_value in patch.items():\n-        if isinstance(patch_value, Mapping):\n-            current_value = current.get(key, None)\n-            if not isinstance(current_value, Mapping):\n-                current_value = {}\n-            result[key] = json_merge_patch(current_value, patch_value)\n-        elif patch_value is not None:\n-            result[key] = patch_value\n+    transport: 'asyncio.Transport | None' = None\n+    buffer = b''\n+    _closed: bool = False\n+    _communication_done: 'asyncio.Future[None] | None' = None\n+\n+    def do_ready(self) -> None:\n+        pass\n+\n+    def do_closed(self, exc: 'Exception | None') -> None:\n+        pass\n+\n+    def transport_control_received(self, command: str, message: JsonObject) -> None:\n+        raise NotImplementedError\n+\n+    def channel_control_received(self, channel: str, command: str, message: JsonObject) -> None:\n+        raise NotImplementedError\n+\n+    def channel_data_received(self, channel: str, data: bytes) -> None:\n+        raise NotImplementedError\n+\n+    def frame_received(self, frame: bytes) -> None:\n+        header, _, data = frame.partition(b'\\n')\n+\n+        if header != b'':\n+            channel = header.decode('ascii')\n+            logger.debug('data received: %d bytes of data for channel %s', len(data), channel)\n+            self.channel_data_received(channel, data)\n+\n         else:\n-            result.pop(key, None)\n+            self.control_received(data)\n \n-    return result\n+    def control_received(self, data: bytes) -> None:\n+        try:\n+            message = typechecked(json.loads(data), dict)\n+            command = get_str(message, 'command')\n+            channel = get_str(message, 'channel', None)\n \n+            if channel is not None:\n+                logger.debug('channel control received %s', message)\n+                self.channel_control_received(channel, command, message)\n+            else:\n+                logger.debug('transport control received %s', message)\n+                self.transport_control_received(command, message)\n \n-def json_merge_and_filter_patch(current: JsonDict, patch: JsonDict) -> None:\n-    \"\"\"Perform a JSON merge patch (RFC 7396) modifying 'current' with 'patch'.\n-    Also modifies 'patch' to remove redundant operations.\n+        except (json.JSONDecodeError, JsonError) as exc:\n+            raise CockpitProtocolError(f'control message: {exc!s}') from exc\n+\n+    def consume_one_frame(self, data: bytes) -> int:\n+        \"\"\"Consumes a single frame from view.\n+\n+        Returns positive if a number of bytes were consumed, or negative if no\n+        work can be done because of a given number of bytes missing.\n+        \"\"\"\n+\n+        try:\n+            newline = data.index(b'\\n')\n+        except ValueError as exc:\n+            if len(data) < 10:\n+                # Let's try reading more\n+                return len(data) - 10\n+            raise CockpitProtocolError(\"size line is too long\") from exc\n+\n+        try:\n+            length = int(data[:newline])\n+        except ValueError as exc:\n+            raise CockpitProtocolError(\"frame size is not an integer\") from exc\n+\n+        start = newline + 1\n+        end = start + length\n+\n+        if end > len(data):\n+            # We need to read more\n+            return len(data) - end\n+\n+        # We can consume a full frame\n+        self.frame_received(data[start:end])\n+        return end\n+\n+    def connection_made(self, transport: asyncio.BaseTransport) -> None:\n+        logger.debug('connection_made(%s)', transport)\n+        assert isinstance(transport, asyncio.Transport)\n+        self.transport = transport\n+        self.do_ready()\n+\n+        if self._closed:\n+            logger.debug('  but the protocol already was closed, so closing transport')\n+            transport.close()\n+\n+    def connection_lost(self, exc: 'Exception | None') -> None:\n+        logger.debug('connection_lost')\n+        assert self.transport is not None\n+        self.transport = None\n+        self.close(exc)\n+\n+    def close(self, exc: 'Exception | None' = None) -> None:\n+        if self._closed:\n+            return\n+        self._closed = True\n+\n+        if self.transport:\n+            self.transport.close()\n+\n+        self.do_closed(exc)\n+\n+    def write_channel_data(self, channel: str, payload: bytes) -> None:\n+        \"\"\"Send a given payload (bytes) on channel (string)\"\"\"\n+        # Channel is certainly ascii (as enforced by .encode() below)\n+        frame_length = len(channel + '\\n') + len(payload)\n+        header = f'{frame_length}\\n{channel}\\n'.encode('ascii')\n+        if self.transport is not None:\n+            logger.debug('writing to transport %s', self.transport)\n+            self.transport.write(header + payload)\n+        else:\n+            logger.debug('cannot write to closed transport')\n+\n+    def write_control(self, _msg: 'JsonObject | None' = None, **kwargs: JsonValue) -> None:\n+        \"\"\"Write a control message.  See jsonutil.create_object() for details.\"\"\"\n+        logger.debug('sending control message %r %r', _msg, kwargs)\n+        pretty = json.dumps(create_object(_msg, kwargs), indent=2) + '\\n'\n+        self.write_channel_data('', pretty.encode())\n+\n+    def data_received(self, data: bytes) -> None:\n+        try:\n+            self.buffer += data\n+            while self.buffer:\n+                result = self.consume_one_frame(self.buffer)\n+                if result <= 0:\n+                    return\n+                self.buffer = self.buffer[result:]\n+        except CockpitProtocolError as exc:\n+            self.close(exc)\n+\n+    def eof_received(self) -> bool:\n+        return False\n+\n+\n+# Helpful functionality for \"server\"-side protocol implementations\n+class CockpitProtocolServer(CockpitProtocol):\n+    init_host: 'str | None' = None\n+    authorizations: 'dict[str, asyncio.Future[str]] | None' = None\n+\n+    def do_send_init(self) -> None:\n+        raise NotImplementedError\n+\n+    def do_init(self, message: JsonObject) -> None:\n+        pass\n+\n+    def do_kill(self, host: 'str | None', group: 'str | None', message: JsonObject) -> None:\n+        raise NotImplementedError\n+\n+    def transport_control_received(self, command: str, message: JsonObject) -> None:\n+        if command == 'init':\n+            if get_int(message, 'version') != 1:\n+                raise CockpitProtocolError('incorrect version number')\n+            self.init_host = get_str(message, 'host')\n+            self.do_init(message)\n+        elif command == 'kill':\n+            self.do_kill(get_str(message, 'host', None), get_str(message, 'group', None), message)\n+        elif command == 'authorize':\n+            self.do_authorize(message)\n+        else:\n+            raise CockpitProtocolError(f'unexpected control message {command} received')\n+\n+    def do_ready(self) -> None:\n+        self.do_send_init()\n+\n+    # authorize request/response API\n+    async def request_authorization(\n+        self, challenge: str, timeout: 'int | None' = None, **kwargs: JsonValue\n+    ) -> str:\n+        if self.authorizations is None:\n+            self.authorizations = {}\n+        cookie = str(uuid.uuid4())\n+        future = asyncio.get_running_loop().create_future()\n+        try:\n+            self.authorizations[cookie] = future\n+            self.write_control(None, command='authorize', challenge=challenge, cookie=cookie, **kwargs)\n+            return await asyncio.wait_for(future, timeout)\n+        finally:\n+            self.authorizations.pop(cookie)\n+\n+    def do_authorize(self, message: JsonObject) -> None:\n+        cookie = get_str(message, 'cookie')\n+        response = get_str(message, 'response')\n+\n+        if self.authorizations is None or cookie not in self.authorizations:\n+            logger.warning('no matching authorize request')\n+            return\n+\n+        self.authorizations[cookie].set_result(response)\n+''',\n+  'cockpit/channel.py': br'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2022 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n+\n+import asyncio\n+import json\n+import logging\n+from typing import BinaryIO, ClassVar, Dict, Generator, List, Optional, Sequence, Set, Tuple, Type\n+\n+from .jsonutil import JsonError, JsonObject, JsonValue, create_object, get_bool, get_str\n+from .protocol import CockpitProblem\n+from .router import Endpoint, Router, RoutingRule\n+\n+logger = logging.getLogger(__name__)\n+\n+\n+class ChannelRoutingRule(RoutingRule):\n+    table: Dict[str, List[Type['Channel']]]\n+\n+    def __init__(self, router: Router, channel_types: List[Type['Channel']]):\n+        super().__init__(router)\n+        self.table = {}\n+\n+        # Sort the channels into buckets by payload type\n+        for cls in channel_types:\n+            entry = self.table.setdefault(cls.payload, [])\n+            entry.append(cls)\n+\n+        # Within each bucket, sort the channels so those with more\n+        # restrictions are considered first.\n+        for entry in self.table.values():\n+            entry.sort(key=lambda cls: len(cls.restrictions), reverse=True)\n+\n+    def check_restrictions(self, restrictions: Sequence[Tuple[str, object]], options: JsonObject) -> bool:\n+        for key, expected_value in restrictions:\n+            our_value = options.get(key)\n+\n+            # If the match rule specifies that a value must be present and\n+            # we don't have it, then fail.\n+            if our_value is None:\n+                return False\n+\n+            # If the match rule specified a specific expected value, and\n+            # our value doesn't match it, then fail.\n+            if expected_value is not None and our_value != expected_value:\n+                return False\n+\n+        # Everything checked out\n+        return True\n+\n+    def apply_rule(self, options: JsonObject) -> Optional['Channel']:\n+        assert self.router is not None\n+\n+        payload = options.get('payload')\n+        if not isinstance(payload, str):\n+            return None\n+\n+        for cls in self.table.get(payload, []):\n+            if self.check_restrictions(cls.restrictions, options):\n+                return cls(self.router)\n+        else:\n+            return None\n+\n+    def shutdown(self):\n+        pass  # we don't hold any state\n+\n+\n+class ChannelError(CockpitProblem):\n+    pass\n+\n+\n+class Channel(Endpoint):\n+    # Values borrowed from C implementation\n+    BLOCK_SIZE = 16 * 1024\n+    SEND_WINDOW = 2 * 1024 * 1024\n+\n+    # Flow control book-keeping\n+    _send_pings: bool = False\n+    _out_sequence: int = 0\n+    _out_window: int = SEND_WINDOW\n+\n+    # Task management\n+    _tasks: Set[asyncio.Task]\n+    _close_args: Optional[JsonObject] = None\n+\n+    # Must be filled in by the channel implementation\n+    payload: ClassVar[str]\n+    restrictions: ClassVar[Sequence[Tuple[str, object]]] = ()\n+\n+    # These get filled in from .do_open()\n+    channel = ''\n+    group = ''\n+\n+    # input\n+    def do_control(self, command, message):\n+        # Break the various different kinds of control messages out into the\n+        # things that our subclass may be interested in handling.  We drop the\n+        # 'message' field for handlers that don't need it.\n+        if command == 'open':\n+            self._tasks = set()\n+            self.channel = message['channel']\n+            if get_bool(message, 'flow-control', default=False):\n+                self._send_pings = True\n+            self.group = get_str(message, 'group', 'default')\n+            self.freeze_endpoint()\n+            self.do_open(message)\n+        elif command == 'ready':\n+            self.do_ready()\n+        elif command == 'done':\n+            self.do_done()\n+        elif command == 'close':\n+            self.do_close()\n+        elif command == 'ping':\n+            self.do_ping(message)\n+        elif command == 'pong':\n+            self.do_pong(message)\n+        elif command == 'options':\n+            self.do_options(message)\n+\n+    def do_channel_control(self, channel: str, command: str, message: JsonObject) -> None:\n+        # Already closing?  Ignore.\n+        if self._close_args is not None:\n+            return\n+\n+        # Catch errors and turn them into close messages\n+        try:\n+            try:\n+                self.do_control(command, message)\n+            except JsonError as exc:\n+                raise ChannelError('protocol-error', message=str(exc)) from exc\n+        except ChannelError as exc:\n+            self.close(exc.attrs)\n+\n+    def do_kill(self, host: 'str | None', group: 'str | None', _message: JsonObject) -> None:\n+        # Already closing?  Ignore.\n+        if self._close_args is not None:\n+            return\n+\n+        if host is not None:\n+            return\n+        if group is not None and self.group != group:\n+            return\n+        self.do_close()\n+\n+    # At least this one really ought to be implemented...\n+    def do_open(self, options: JsonObject) -> None:\n+        raise NotImplementedError\n+\n+    # ... but many subclasses may reasonably want to ignore some of these.\n+    def do_ready(self) -> None:\n+        pass\n+\n+    def do_done(self) -> None:\n+        pass\n+\n+    def do_close(self) -> None:\n+        self.close()\n+\n+    def do_options(self, message: JsonObject) -> None:\n+        raise ChannelError('not-supported', message='This channel does not implement \"options\"')\n+\n+    # 'reasonable' default, overridden in other channels for receive-side flow control\n+    def do_ping(self, message: JsonObject) -> None:\n+        self.send_pong(message)\n+\n+    def do_channel_data(self, channel: str, data: bytes) -> None:\n+        # Already closing?  Ignore.\n+        if self._close_args is not None:\n+            return\n+\n+        # Catch errors and turn them into close messages\n+        try:\n+            self.do_data(data)\n+        except ChannelError as exc:\n+            self.close(exc.attrs)\n+\n+    def do_data(self, _data: bytes) -> None:\n+        # By default, channels can't receive data.\n+        self.close()\n+\n+    # output\n+    def ready(self, **kwargs: JsonValue) -> None:\n+        self.thaw_endpoint()\n+        self.send_control(command='ready', **kwargs)\n+\n+    def done(self) -> None:\n+        self.send_control(command='done')\n+\n+    # tasks and close management\n+    def is_closing(self) -> bool:\n+        return self._close_args is not None\n+\n+    def _close_now(self) -> None:\n+        self.shutdown_endpoint(self._close_args)\n+\n+    def _task_done(self, task):\n+        # Strictly speaking, we should read the result and check for exceptions but:\n+        #   - exceptions bubbling out of the task are programming errors\n+        #   - the only thing we'd do with it anyway, is to show it\n+        #   - Python already does that with its \"Task exception was never retrieved\" messages\n+        self._tasks.remove(task)\n+        if self._close_args is not None and not self._tasks:\n+            self._close_now()\n+\n+    def create_task(self, coroutine, name=None):\n+        \"\"\"Create a task associated with the channel.\n+\n+        All tasks must exit before the channel can close.  You may not create\n+        new tasks after calling .close().\n+        \"\"\"\n+        assert self._close_args is None\n+        task = asyncio.create_task(coroutine)\n+        self._tasks.add(task)\n+        task.add_done_callback(self._task_done)\n+        return task\n+\n+    def close(self, close_args: 'JsonObject | None' = None) -> None:\n+        \"\"\"Requests the channel to be closed.\n+\n+        After you call this method, you won't get anymore `.do_*()` calls.\n+\n+        This will wait for any running tasks to complete before sending the\n+        close message.\n+        \"\"\"\n+        if self._close_args is not None:\n+            # close already requested\n+            return\n+        self._close_args = close_args or {}\n+        if not self._tasks:\n+            self._close_now()\n+\n+    def send_data(self, data: bytes) -> bool:\n+        \"\"\"Send data and handle book-keeping for flow control.\n+\n+        The flow control is \"advisory\".  The data is sent immediately, even if\n+        it's larger than the window.  In general you should try to send packets\n+        which are approximately Channel.BLOCK_SIZE in size.\n+\n+        Returns True if there is still room in the window, or False if you\n+        should stop writing for now.  In that case, `.do_resume_send()` will be\n+        called later when there is more room.\n+        \"\"\"\n+        self.send_channel_data(self.channel, data)\n+\n+        if self._send_pings:\n+            out_sequence = self._out_sequence + len(data)\n+            if self._out_sequence // Channel.BLOCK_SIZE != out_sequence // Channel.BLOCK_SIZE:\n+                self.send_control(command='ping', sequence=out_sequence)\n+            self._out_sequence = out_sequence\n+\n+        return self._out_sequence < self._out_window\n+\n+    def do_pong(self, message):\n+        if not self._send_pings:  # huh?\n+            logger.warning(\"Got wild pong on channel %s\", self.channel)\n+            return\n+\n+        self._out_window = message['sequence'] + Channel.SEND_WINDOW\n+        if self._out_sequence < self._out_window:\n+            self.do_resume_send()\n+\n+    def do_resume_send(self) -> None:\n+        \"\"\"Called to indicate that the channel may start sending again.\"\"\"\n+        # change to `raise NotImplementedError` after everyone implements it\n+\n+    json_encoder: ClassVar[json.JSONEncoder] = json.JSONEncoder(indent=2)\n+\n+    def send_json(self, _msg: 'JsonObject | None' = None, **kwargs: JsonValue) -> bool:\n+        pretty = self.json_encoder.encode(create_object(_msg, kwargs)) + '\\n'\n+        return self.send_data(pretty.encode())\n+\n+    def send_control(self, command: str, **kwargs: JsonValue) -> None:\n+        self.send_channel_control(self.channel, command, None, **kwargs)\n+\n+    def send_pong(self, message: JsonObject) -> None:\n+        self.send_channel_control(self.channel, 'pong', message)\n+\n+\n+class ProtocolChannel(Channel, asyncio.Protocol):\n+    \"\"\"A channel subclass that implements the asyncio Protocol interface.\n+\n+    In effect, data sent to this channel will be written to the connected\n+    transport, and vice-versa.  Flow control is supported.\n+\n+    The default implementation of the .do_open() method calls the\n+    .create_transport() abstract method.  This method should return a transport\n+    which will be used for communication on the channel.\n+\n+    Otherwise, if the subclass implements .do_open() itself, it is responsible\n+    for setting up the connection and ensuring that .connection_made() is called.\n     \"\"\"\n-    for key, patch_value in tuple(patch.items()):\n-        current_value = current.get(key, None)\n+    _transport: Optional[asyncio.Transport]\n+    _loop: Optional[asyncio.AbstractEventLoop]\n+    _send_pongs: bool = True\n+    _last_ping: Optional[JsonObject] = None\n+    _create_transport_task = None\n \n-        if isinstance(patch_value, dict):\n-            if not isinstance(current_value, dict):\n-                current[key] = current_value = {}\n-                json_merge_and_filter_patch(current_value, patch_value)\n-            else:\n-                json_merge_and_filter_patch(current_value, patch_value)\n-                if not patch_value:\n-                    del patch[key]\n-        elif current_value == patch_value:\n-            del patch[key]\n-        elif patch_value is not None:\n-            current[key] = patch_value\n+    # read-side EOF handling\n+    _close_on_eof: bool = False\n+    _eof: bool = False\n+\n+    async def create_transport(self, loop: asyncio.AbstractEventLoop, options: JsonObject) -> asyncio.Transport:\n+        \"\"\"Creates the transport for this channel, according to options.\n+\n+        The event loop for the transport is passed to the function.  The\n+        protocol for the transport is the channel object, itself (self).\n+\n+        This needs to be implemented by the subclass.\n+        \"\"\"\n+        raise NotImplementedError\n+\n+    def do_open(self, options: JsonObject) -> None:\n+        loop = asyncio.get_running_loop()\n+        self._create_transport_task = asyncio.create_task(self.create_transport(loop, options))\n+        self._create_transport_task.add_done_callback(self.create_transport_done)\n+\n+    def create_transport_done(self, task: 'asyncio.Task[asyncio.Transport]') -> None:\n+        assert task is self._create_transport_task\n+        self._create_transport_task = None\n+        try:\n+            transport = task.result()\n+        except ChannelError as exc:\n+            self.close(exc.attrs)\n+            return\n+\n+        self.connection_made(transport)\n+        self.ready()\n+\n+    def connection_made(self, transport: asyncio.BaseTransport) -> None:\n+        assert isinstance(transport, asyncio.Transport)\n+        self._transport = transport\n+\n+    def _get_close_args(self) -> JsonObject:\n+        return {}\n+\n+    def connection_lost(self, exc: Optional[Exception]) -> None:\n+        self.close(self._get_close_args())\n+\n+    def do_data(self, data: bytes) -> None:\n+        assert self._transport is not None\n+        self._transport.write(data)\n+\n+    def do_done(self) -> None:\n+        assert self._transport is not None\n+        if self._transport.can_write_eof():\n+            self._transport.write_eof()\n+\n+    def do_close(self) -> None:\n+        if self._transport is not None:\n+            self._transport.close()\n+\n+    def data_received(self, data: bytes) -> None:\n+        assert self._transport is not None\n+        if not self.send_data(data):\n+            self._transport.pause_reading()\n+\n+    def do_resume_send(self) -> None:\n+        assert self._transport is not None\n+        self._transport.resume_reading()\n+\n+    def close_on_eof(self) -> None:\n+        \"\"\"Mark the channel to be closed on EOF.\n+\n+        Normally, ProtocolChannel tries to keep the channel half-open after\n+        receiving EOF from the transport.  This instructs that the channel\n+        should be closed on EOF.\n+\n+        If EOF was already received, then calling this function will close the\n+        channel immediately.\n+\n+        If you don't call this function, you are responsible for closing the\n+        channel yourself.\n+        \"\"\"\n+        self._close_on_eof = True\n+        if self._eof:\n+            assert self._transport is not None\n+            self._transport.close()\n+\n+    def eof_received(self) -> bool:\n+        self._eof = True\n+        self.done()\n+        return not self._close_on_eof\n+\n+    # Channel receive-side flow control\n+    def do_ping(self, message):\n+        if self._send_pongs:\n+            self.send_pong(message)\n         else:\n-            del current[key]\n-'''.encode('utf-8'),\n+            # we'll have to pong later\n+            self._last_ping = message\n+\n+    def pause_writing(self) -> None:\n+        # We can't actually stop writing, but we can stop replying to pings\n+        self._send_pongs = False\n+\n+    def resume_writing(self) -> None:\n+        self._send_pongs = True\n+        if self._last_ping is not None:\n+            self.send_pong(self._last_ping)\n+            self._last_ping = None\n+\n+\n+class AsyncChannel(Channel):\n+    \"\"\"A subclass for async/await-style implementation of channels, with flow control\n+\n+    This subclass provides asynchronous `read()` and `write()` calls for\n+    subclasses, with familiar semantics.  `write()` doesn't buffer, so the\n+    `done()` method on the base channel class can be used in a way similar to\n+    `shutdown()`.  A high-level `sendfile()` method is available to send the\n+    entire contents of a binary-mode file-like object.\n+\n+    The subclass must provide an async `run()` function, which will be spawned\n+    as a task.\n+\n+    On the receiving side, the channel will respond to flow control pings to\n+    indicate that it has received the data, but only after it has been consumed\n+    by `read()`.\n+\n+    On the sending side, write() will block if the channel backs up.\n+    \"\"\"\n+\n+    # Receive-side flow control: intermix pings and data in the queue and reply\n+    # to pings as we dequeue them.  This is a buffer: since we need to handle\n+    # do_data() without blocking, we have no choice.\n+    receive_queue = None\n+\n+    # Send-side flow control\n+    write_waiter = None\n+\n+    async def run(self, options):\n+        raise NotImplementedError\n+\n+    async def run_wrapper(self, options):\n+        try:\n+            await self.run(options)\n+            self.close()\n+        except ChannelError as exc:\n+            self.close(exc.attrs)\n+\n+    async def read(self):\n+        while True:\n+            item = await self.receive_queue.get()\n+            if isinstance(item, bytes):\n+                return item\n+            self.send_pong(item)\n+\n+    async def write(self, data):\n+        if not self.send_data(data):\n+            self.write_waiter = asyncio.get_running_loop().create_future()\n+            await self.write_waiter\n+\n+    async def sendfile(self, stream: BinaryIO) -> None:\n+        loop = asyncio.get_running_loop()\n+        with stream:\n+            while True:\n+                data = await loop.run_in_executor(None, stream.read, Channel.BLOCK_SIZE)\n+                if data == b'':\n+                    break\n+                await self.write(data)\n+\n+            self.done()\n+\n+    def do_resume_send(self) -> None:\n+        if self.write_waiter is not None:\n+            self.write_waiter.set_result(None)\n+            self.write_waiter = None\n+\n+    def do_open(self, options):\n+        self.receive_queue = asyncio.Queue()\n+        self.create_task(self.run_wrapper(options), name=f'{self.__class__.__name__}.run_wrapper({options})')\n+\n+    def do_done(self):\n+        self.receive_queue.put_nowait(b'')\n+\n+    def do_close(self):\n+        # we might have already sent EOF for done, but two EOFs won't hurt anyone\n+        self.receive_queue.put_nowait(b'')\n+\n+    def do_ping(self, message):\n+        self.receive_queue.put_nowait(message)\n+\n+    def do_data(self, data):\n+        if not isinstance(data, bytes):\n+            # this will persist past this callback, so make sure we take our\n+            # own copy, in case this was a memoryview into a bytearray.\n+            data = bytes(data)\n+\n+        self.receive_queue.put_nowait(data)\n+\n+\n+class GeneratorChannel(Channel):\n+    \"\"\"A trivial Channel subclass for sending data from a generator with flow control.\n+\n+    Calls the .do_yield_data() generator with the options from the open message\n+    and sends the data which it yields.  If the generator returns a value it\n+    will be used for the close message.\n+    \"\"\"\n+    DataGenerator = Generator[bytes, None, Optional[JsonObject]]\n+    __generator: DataGenerator\n+\n+    def do_yield_data(self, options: JsonObject) -> 'DataGenerator':\n+        raise NotImplementedError\n+\n+    def do_open(self, options: JsonObject) -> None:\n+        self.__generator = self.do_yield_data(options)\n+        self.do_resume_send()\n+\n+    def do_resume_send(self) -> None:\n+        try:\n+            while self.send_data(next(self.__generator)):\n+                pass\n+        except StopIteration as stop:\n+            self.done()\n+            self.close(stop.value)\n+''',\n   'cockpit/samples.py': br'''# This file is part of Cockpit.\n #\n # Copyright (C) 2022 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n@@ -686,14 +1611,1363 @@\n     CPUTemperatureSampler,\n     DiskSampler,\n     MemorySampler,\n     MountSampler,\n     NetworkSampler,\n ]\n ''',\n+  'cockpit/superuser.py': br'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2022 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n+\n+import array\n+import asyncio\n+import contextlib\n+import getpass\n+import logging\n+import os\n+import socket\n+from tempfile import TemporaryDirectory\n+from typing import List, Optional, Sequence, Tuple\n+\n+from cockpit._vendor import ferny\n+from cockpit._vendor.bei.bootloader import make_bootloader\n+from cockpit._vendor.systemd_ctypes import Variant, bus\n+\n+from .beipack import BridgeBeibootHelper\n+from .jsonutil import JsonObject, get_str\n+from .packages import BridgeConfig\n+from .peer import ConfiguredPeer, Peer, PeerError\n+from .polkit import PolkitAgent\n+from .router import Router, RoutingError, RoutingRule\n+\n+logger = logging.getLogger(__name__)\n+\n+\n+class SuperuserPeer(ConfiguredPeer):\n+    responder: ferny.AskpassHandler\n+\n+    def __init__(self, router: Router, config: BridgeConfig, responder: ferny.AskpassHandler):\n+        super().__init__(router, config)\n+        self.responder = responder\n+\n+    async def do_connect_transport(self) -> None:\n+        async with contextlib.AsyncExitStack() as context:\n+            if 'pkexec' in self.args:\n+                logger.debug('connecting polkit superuser peer transport %r', self.args)\n+                await context.enter_async_context(PolkitAgent(self.responder))\n+            else:\n+                logger.debug('connecting non-polkit superuser peer transport %r', self.args)\n+\n+            responders: 'list[ferny.InteractionHandler]' = [self.responder]\n+\n+            if '# cockpit-bridge' in self.args:\n+                logger.debug('going to beiboot superuser bridge %r', self.args)\n+                helper = BridgeBeibootHelper(self, ['--privileged'])\n+                responders.append(helper)\n+                stage1 = make_bootloader(helper.steps, gadgets=ferny.BEIBOOT_GADGETS).encode()\n+            else:\n+                stage1 = None\n+\n+            agent = ferny.InteractionAgent(responders)\n+\n+            if 'SUDO_ASKPASS=ferny-askpass' in self.env:\n+                tmpdir = context.enter_context(TemporaryDirectory())\n+                ferny_askpass = ferny.write_askpass_to_tmpdir(tmpdir)\n+                env: Sequence[str] = [f'SUDO_ASKPASS={ferny_askpass}']\n+            else:\n+                env = self.env\n+\n+            transport = await self.spawn(self.args, env, stderr=agent, start_new_session=True)\n+\n+            if stage1 is not None:\n+                transport.write(stage1)\n+\n+            try:\n+                await agent.communicate()\n+            except ferny.InteractionError as exc:\n+                raise PeerError('authentication-failed', message=str(exc)) from exc\n+\n+\n+class CockpitResponder(ferny.AskpassHandler):\n+    commands = ('ferny.askpass', 'cockpit.send-stderr')\n+\n+    async def do_custom_command(self, command: str, args: Tuple, fds: List[int], stderr: str) -> None:\n+        if command == 'cockpit.send-stderr':\n+            with socket.socket(fileno=fds[0]) as sock:\n+                fds.pop(0)\n+                # socket.send_fds(sock, [b'\\0'], [2])  # New in Python 3.9\n+                sock.sendmsg([b'\\0'], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, array.array(\"i\", [2]))])\n+\n+\n+class AuthorizeResponder(CockpitResponder):\n+    def __init__(self, router: Router):\n+        self.router = router\n+\n+    async def do_askpass(self, messages: str, prompt: str, hint: str) -> str:\n+        hexuser = ''.join(f'{c:02x}' for c in getpass.getuser().encode('ascii'))\n+        return await self.router.request_authorization(f'plain1:{hexuser}')\n+\n+\n+class SuperuserRoutingRule(RoutingRule, CockpitResponder, bus.Object, interface='cockpit.Superuser'):\n+    superuser_configs: Sequence[BridgeConfig] = ()\n+    pending_prompt: Optional[asyncio.Future]\n+    peer: Optional[SuperuserPeer]\n+\n+    # D-Bus signals\n+    prompt = bus.Interface.Signal('s', 's', 's', 'b', 's')  # message, prompt, default, echo, error\n+\n+    # D-Bus properties\n+    bridges = bus.Interface.Property('as', value=[])\n+    current = bus.Interface.Property('s', value='none')\n+    methods = bus.Interface.Property('a{sv}', value={})\n+\n+    # RoutingRule\n+    def apply_rule(self, options: JsonObject) -> Optional[Peer]:\n+        superuser = options.get('superuser')\n+\n+        if not superuser or self.current == 'root':\n+            # superuser not requested, or already superuser?  Next rule.\n+            return None\n+        elif self.peer or superuser == 'try':\n+            # superuser requested and active?  Return it.\n+            # 'try' requested?  Either return the peer, or None.\n+            return self.peer\n+        else:\n+            # superuser requested, but not active?  That's an error.\n+            raise RoutingError('access-denied')\n+\n+    # ferny.AskpassHandler\n+    async def do_askpass(self, messages: str, prompt: str, hint: str) -> Optional[str]:\n+        assert self.pending_prompt is None\n+        echo = hint == \"confirm\"\n+        self.pending_prompt = asyncio.get_running_loop().create_future()\n+        try:\n+            logger.debug('prompting for %s', prompt)\n+            # with sudo, all stderr messages are treated as warning/errors by the UI\n+            # (such as the lecture or \"wrong password\"), so pass them in the \"error\" field\n+            self.prompt('', prompt, '', echo, messages)\n+            return await self.pending_prompt\n+        finally:\n+            self.pending_prompt = None\n+\n+    def __init__(self, router: Router, *, privileged: bool = False):\n+        super().__init__(router)\n+\n+        self.pending_prompt = None\n+        self.peer = None\n+        self.startup = None\n+\n+        if privileged or os.getuid() == 0:\n+            self.current = 'root'\n+\n+    def peer_done(self):\n+        self.current = 'none'\n+        self.peer = None\n+\n+    async def go(self, name: str, responder: ferny.AskpassHandler) -> None:\n+        if self.current != 'none':\n+            raise bus.BusError('cockpit.Superuser.Error', 'Superuser bridge already running')\n+\n+        assert self.peer is None\n+        assert self.startup is None\n+\n+        for config in self.superuser_configs:\n+            if name in (config.name, 'any'):\n+                break\n+        else:\n+            raise bus.BusError('cockpit.Superuser.Error', f'Unknown superuser bridge type \"{name}\"')\n+\n+        self.current = 'init'\n+        self.peer = SuperuserPeer(self.router, config, responder)\n+        self.peer.add_done_callback(self.peer_done)\n+\n+        try:\n+            await self.peer.start(init_host=self.router.init_host)\n+        except asyncio.CancelledError:\n+            raise bus.BusError('cockpit.Superuser.Error.Cancelled', 'Operation aborted') from None\n+        except (OSError, PeerError) as exc:\n+            raise bus.BusError('cockpit.Superuser.Error', str(exc)) from exc\n+\n+        self.current = self.peer.config.name\n+\n+    def set_configs(self, configs: Sequence[BridgeConfig]):\n+        logger.debug(\"set_configs() with %d items\", len(configs))\n+        configs = [config for config in configs if config.privileged]\n+        self.superuser_configs = tuple(configs)\n+        self.bridges = [config.name for config in self.superuser_configs]\n+        self.methods = {c.label: Variant({'label': Variant(c.label)}, 'a{sv}') for c in configs if c.label}\n+\n+        logger.debug(\"  bridges are now %s\", self.bridges)\n+\n+        # If the currently active bridge config is not in the new set of configs, stop it\n+        if self.peer is not None:\n+            if self.peer.config not in self.superuser_configs:\n+                logger.debug(\"  stopping superuser bridge '%s': it disappeared from configs\", self.peer.config.name)\n+                self.stop()\n+\n+    def cancel_prompt(self):\n+        if self.pending_prompt is not None:\n+            self.pending_prompt.cancel()\n+            self.pending_prompt = None\n+\n+    def shutdown(self):\n+        self.cancel_prompt()\n+\n+        if self.peer is not None:\n+            self.peer.close()\n+\n+        # close() should have disconnected the peer immediately\n+        assert self.peer is None\n+\n+    # Connect-on-startup functionality\n+    def init(self, params: JsonObject) -> None:\n+        name = get_str(params, 'id', 'any')\n+        responder = AuthorizeResponder(self.router)\n+        self._init_task = asyncio.create_task(self.go(name, responder))\n+        self._init_task.add_done_callback(self._init_done)\n+\n+    def _init_done(self, task: 'asyncio.Task[None]') -> None:\n+        logger.debug('superuser init done! %s', task.exception())\n+        self.router.write_control(command='superuser-init-done')\n+        del self._init_task\n+\n+    # D-Bus methods\n+    @bus.Interface.Method(in_types=['s'])\n+    async def start(self, name: str) -> None:\n+        await self.go(name, self)\n+\n+    @bus.Interface.Method()\n+    def stop(self) -> None:\n+        self.shutdown()\n+\n+    @bus.Interface.Method(in_types=['s'])\n+    def answer(self, reply: str) -> None:\n+        if self.pending_prompt is not None:\n+            logger.debug('responding to pending prompt')\n+            self.pending_prompt.set_result(reply)\n+        else:\n+            logger.debug('got Answer, but no prompt pending')\n+''',\n+  'cockpit/transports.py': br'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2022 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n+\n+\"\"\"Bi-directional asyncio.Transport implementations based on file descriptors.\"\"\"\n+\n+import asyncio\n+import collections\n+import ctypes\n+import errno\n+import fcntl\n+import logging\n+import os\n+import select\n+import signal\n+import struct\n+import subprocess\n+import termios\n+from typing import Any, ClassVar, Sequence\n+\n+from .jsonutil import JsonObject, get_int\n+\n+libc6 = ctypes.cdll.LoadLibrary('libc.so.6')\n+\n+\n+def prctl(*args: int) -> None:\n+    if libc6.prctl(*args) != 0:\n+        raise OSError('prctl() failed')\n+\n+\n+SET_PDEATHSIG = 1\n+\n+\n+logger = logging.getLogger(__name__)\n+IOV_MAX = 1024  # man 2 writev\n+\n+\n+class _Transport(asyncio.Transport):\n+    BLOCK_SIZE: ClassVar[int] = 1024 * 1024\n+\n+    # A transport always has a loop and a protocol\n+    _loop: asyncio.AbstractEventLoop\n+    _protocol: asyncio.Protocol\n+\n+    _queue: 'collections.deque[bytes] | None'\n+    _in_fd: int\n+    _out_fd: int\n+    _closing: bool\n+    _is_reading: bool\n+    _eof: bool\n+    _eio_is_eof: bool = False\n+\n+    def __init__(self,\n+                 loop: asyncio.AbstractEventLoop,\n+                 protocol: asyncio.Protocol,\n+                 in_fd: int = -1, out_fd: int = -1,\n+                 extra: 'dict[str, object] | None' = None):\n+        super().__init__(extra)\n+\n+        self._loop = loop\n+        self._protocol = protocol\n+\n+        logger.debug('Created transport %s for protocol %s, fds %d %d', self, protocol, in_fd, out_fd)\n+\n+        self._queue = None\n+        self._is_reading = False\n+        self._eof = False\n+        self._closing = False\n+\n+        self._in_fd = in_fd\n+        self._out_fd = out_fd\n+\n+        os.set_blocking(in_fd, False)\n+        if out_fd != in_fd:\n+            os.set_blocking(out_fd, False)\n+\n+        self._protocol.connection_made(self)\n+        self.resume_reading()\n+\n+    def _read_ready(self) -> None:\n+        logger.debug('Read ready on %s %s %d', self, self._protocol, self._in_fd)\n+        try:\n+            data = os.read(self._in_fd, _Transport.BLOCK_SIZE)\n+        except BlockingIOError:  # pragma: no cover\n+            return\n+        except OSError as exc:\n+            if self._eio_is_eof and exc.errno == errno.EIO:\n+                # PTY devices return EIO to mean \"EOF\"\n+                data = b''\n+            else:\n+                # Other errors: terminate the connection\n+                self.abort(exc)\n+                return\n+\n+        if data != b'':\n+            logger.debug('  read %d bytes', len(data))\n+            self._protocol.data_received(data)\n+        else:\n+            logger.debug('  got EOF')\n+            self._close_reader()\n+            keep_open = self._protocol.eof_received()\n+            if not keep_open:\n+                self.close()\n+\n+    def is_reading(self) -> bool:\n+        return self._is_reading\n+\n+    def _close_reader(self) -> None:\n+        self.pause_reading()\n+        self._in_fd = -1\n+\n+    def pause_reading(self) -> None:\n+        if self._is_reading:\n+            self._loop.remove_reader(self._in_fd)\n+            self._is_reading = False\n+\n+    def resume_reading(self) -> None:\n+        # It's possible that the Protocol could decide to attempt to unpause\n+        # reading after _close_reader() got called.  Check that the fd is != -1\n+        # before actually resuming.\n+        if not self._is_reading and self._in_fd != -1:\n+            self._loop.add_reader(self._in_fd, self._read_ready)\n+            self._is_reading = True\n+\n+    def _close(self) -> None:\n+        pass\n+\n+    def abort(self, exc: 'Exception | None' = None) -> None:\n+        self._closing = True\n+        self._close_reader()\n+        self._remove_write_queue()\n+        self._protocol.connection_lost(exc)\n+        self._close()\n+\n+    def can_write_eof(self) -> bool:\n+        raise NotImplementedError\n+\n+    def write_eof(self) -> None:\n+        assert not self._eof\n+        self._eof = True\n+        if self._queue is None:\n+            logger.debug('%s got EOF.  closing backend.', self)\n+            self._write_eof_now()\n+        else:\n+            logger.debug('%s got EOF.  bytes in queue, deferring close', self)\n+\n+    def get_write_buffer_size(self) -> int:\n+        if self._queue is None:\n+            return 0\n+        return sum(len(block) for block in self._queue)\n+\n+    def get_write_buffer_limits(self) -> 'tuple[int, int]':\n+        return (0, 0)\n+\n+    def set_write_buffer_limits(self, high: 'int | None' = None, low: 'int | None' = None) -> None:\n+        assert high is None or high == 0\n+        assert low is None or low == 0\n+\n+    def _write_eof_now(self) -> None:\n+        raise NotImplementedError\n+\n+    def _write_ready(self) -> None:\n+        logger.debug('%s _write_ready', self)\n+        assert self._queue is not None\n+\n+        try:\n+            n_bytes = os.writev(self._out_fd, self._queue)\n+        except BlockingIOError:  # pragma: no cover\n+            n_bytes = 0\n+        except OSError as exc:\n+            self.abort(exc)\n+            return\n+\n+        logger.debug('  successfully wrote %d bytes from the queue', n_bytes)\n+\n+        while n_bytes:\n+            block = self._queue.popleft()\n+            if len(block) > n_bytes:\n+                # This block wasn't completely written.\n+                logger.debug('  incomplete block.  Stop.')\n+                self._queue.appendleft(block[n_bytes:])\n+                break\n+            n_bytes -= len(block)\n+            logger.debug('  removed complete block.  %d remains.', n_bytes)\n+\n+        if not self._queue:\n+            logger.debug('%s queue drained.')\n+            self._remove_write_queue()\n+            if self._eof:\n+                logger.debug('%s queue drained.  closing backend now.')\n+                self._write_eof_now()\n+            if self._closing:\n+                self.abort()\n+\n+    def _remove_write_queue(self) -> None:\n+        if self._queue is not None:\n+            self._protocol.resume_writing()\n+            self._loop.remove_writer(self._out_fd)\n+            self._queue = None\n+\n+    def _create_write_queue(self, data: bytes) -> None:\n+        logger.debug('%s creating write queue for fd %s', self, self._out_fd)\n+        assert self._queue is None\n+        self._loop.add_writer(self._out_fd, self._write_ready)\n+        self._queue = collections.deque((data,))\n+        self._protocol.pause_writing()\n+\n+    def write(self, data: bytes) -> None:\n+        # this is a race condition with subprocesses: if we get and process the the \"exited\"\n+        # event before seeing BrokenPipeError, we'll try to write to a closed pipe.\n+        # Do what the standard library does and ignore, instead of assert\n+        if self._closing:\n+            logger.debug('ignoring write() to closing transport fd %i', self._out_fd)\n+            return\n+\n+        assert not self._eof\n+\n+        if self._queue is not None:\n+            self._queue.append(data)\n+\n+            # writev() will complain if the queue is too long.  Consolidate it.\n+            if len(self._queue) > IOV_MAX:\n+                all_data = b''.join(self._queue)\n+                self._queue.clear()\n+                self._queue.append(all_data)\n+\n+            return\n+\n+        try:\n+            n_bytes = os.write(self._out_fd, data)\n+        except BlockingIOError:\n+            n_bytes = 0\n+        except OSError as exc:\n+            self.abort(exc)\n+            return\n+\n+        if n_bytes != len(data):\n+            self._create_write_queue(data[n_bytes:])\n+\n+    def close(self) -> None:\n+        if self._closing:\n+            return\n+\n+        self._closing = True\n+        self._close_reader()\n+\n+        if self._queue is not None:\n+            # abort() will be called from _write_ready() when it's done\n+            return\n+\n+        self.abort()\n+\n+    def get_protocol(self) -> asyncio.BaseProtocol:\n+        return self._protocol\n+\n+    def is_closing(self) -> bool:\n+        return self._closing\n+\n+    def set_protocol(self, protocol: asyncio.BaseProtocol) -> None:\n+        raise NotImplementedError\n+\n+    def __del__(self) -> None:\n+        self._close()\n+\n+\n+class SubprocessProtocol(asyncio.Protocol):\n+    \"\"\"An extension to asyncio.Protocol for use with SubprocessTransport.\"\"\"\n+    def process_exited(self) -> None:\n+        \"\"\"Called when subprocess has exited.\"\"\"\n+        raise NotImplementedError\n+\n+\n+class WindowSize:\n+    def __init__(self, value: JsonObject):\n+        self.rows = get_int(value, 'rows')\n+        self.cols = get_int(value, 'cols')\n+\n+\n+class SubprocessTransport(_Transport, asyncio.SubprocessTransport):\n+    \"\"\"A bi-directional transport speaking with stdin/out of a subprocess.\n+\n+    Note: this is not really a normal SubprocessTransport.  Although it\n+    implements the entire API of asyncio.SubprocessTransport, it is not\n+    designed to be used with asyncio.SubprocessProtocol objects.  Instead, it\n+    pair with normal Protocol objects which also implement the\n+    SubprocessProtocol defined in this module (which only has a\n+    process_exited() method).  Whatever the protocol writes is sent to stdin,\n+    and whatever comes from stdout is given to the Protocol via the\n+    .data_received() function.\n+\n+    If stderr is configured as a pipe, the transport will separately collect\n+    data from it, making it available via the .get_stderr() method.\n+    \"\"\"\n+\n+    _returncode: 'int | None' = None\n+\n+    _pty_fd: 'int | None' = None\n+    _process: 'subprocess.Popen[bytes] | None' = None\n+    _stderr: 'Spooler | None'\n+\n+    @staticmethod\n+    def _create_watcher() -> asyncio.AbstractChildWatcher:\n+        try:\n+            os.close(os.pidfd_open(os.getpid(), 0))  # check for kernel support\n+            return asyncio.PidfdChildWatcher()\n+        except (AttributeError, OSError):\n+            pass\n+\n+        return asyncio.SafeChildWatcher()\n+\n+    @staticmethod\n+    def _get_watcher(loop: asyncio.AbstractEventLoop) -> asyncio.AbstractChildWatcher:\n+        quark = '_cockpit_transports_child_watcher'\n+        watcher = getattr(loop, quark, None)\n+\n+        if watcher is None:\n+            watcher = SubprocessTransport._create_watcher()\n+            watcher.attach_loop(loop)\n+            setattr(loop, quark, watcher)\n+\n+        return watcher\n+\n+    def get_stderr(self, *, reset: bool = False) -> str:\n+        if self._stderr is not None:\n+            return self._stderr.get(reset=reset).decode(errors='replace')\n+        else:\n+            return ''\n+\n+    def _exited(self, pid: int, code: int) -> None:\n+        # NB: per AbstractChildWatcher API, this handler should be thread-safe,\n+        # but we only ever use non-threaded child watcher implementations, so\n+        # we can assume we'll always be called in the main thread.\n+\n+        # NB: the subprocess is going to want to waitpid() itself as well, but\n+        # will get ECHILD since we already reaped it.  Fortunately, since\n+        # Python 3.2 this is supported, and process gets a return status of\n+        # zero.  For that reason, we need to store our own copy of the return\n+        # status.  See https://github.com/python/cpython/issues/59960\n+        assert isinstance(self._protocol, SubprocessProtocol)\n+        assert self._process is not None\n+        assert self._process.pid == pid\n+        self._returncode = code\n+        logger.debug('Process exited with status %d', self._returncode)\n+        if not self._closing:\n+            self._protocol.process_exited()\n+\n+    def __init__(self,\n+                 loop: asyncio.AbstractEventLoop,\n+                 protocol: SubprocessProtocol,\n+                 args: Sequence[str],\n+                 *,\n+                 pty: bool = False,\n+                 window: 'WindowSize | None' = None,\n+                 **kwargs: Any):\n+\n+        # go down as a team -- we don't want any leaked processes when the bridge terminates\n+        def preexec_fn() -> None:\n+            prctl(SET_PDEATHSIG, signal.SIGTERM)\n+            if pty:\n+                fcntl.ioctl(0, termios.TIOCSCTTY, 0)\n+\n+        if pty:\n+            self._pty_fd, session_fd = os.openpty()\n+\n+            if window is not None:\n+                self.set_window_size(window)\n+\n+            kwargs['stderr'] = session_fd\n+            self._process = subprocess.Popen(args,\n+                                             stdin=session_fd, stdout=session_fd,\n+                                             preexec_fn=preexec_fn, start_new_session=True, **kwargs)\n+            os.close(session_fd)\n+\n+            in_fd, out_fd = self._pty_fd, self._pty_fd\n+            self._eio_is_eof = True\n+\n+        else:\n+            self._process = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE,\n+                                             preexec_fn=preexec_fn, **kwargs)\n+            assert self._process.stdin\n+            assert self._process.stdout\n+            in_fd = self._process.stdout.fileno()\n+            out_fd = self._process.stdin.fileno()\n+\n+        if self._process.stderr is not None:\n+            self._stderr = Spooler(loop, self._process.stderr.fileno())\n+        else:\n+            self._stderr = None\n+\n+        super().__init__(loop, protocol, in_fd, out_fd)\n+\n+        self._get_watcher(loop).add_child_handler(self._process.pid, self._exited)\n+\n+    def set_window_size(self, size: WindowSize) -> None:\n+        assert self._pty_fd is not None\n+        fcntl.ioctl(self._pty_fd, termios.TIOCSWINSZ, struct.pack('2H4x', size.rows, size.cols))\n+\n+    def can_write_eof(self) -> bool:\n+        assert self._process is not None\n+        return self._process.stdin is not None\n+\n+    def _write_eof_now(self) -> None:\n+        assert self._process is not None\n+        assert self._process.stdin is not None\n+        self._process.stdin.close()\n+        self._out_fd = -1\n+\n+    def get_pid(self) -> int:\n+        assert self._process is not None\n+        return self._process.pid\n+\n+    def get_returncode(self) -> 'int | None':\n+        return self._returncode\n+\n+    def get_pipe_transport(self, fd: int) -> asyncio.Transport:\n+        raise NotImplementedError\n+\n+    def send_signal(self, sig: signal.Signals) -> None:  # type: ignore[override] # mypy/issues/13885\n+        assert self._process is not None\n+        # We try to avoid using subprocess.send_signal().  It contains a call\n+        # to waitpid() internally to avoid signalling the wrong process (if a\n+        # PID gets reused), but:\n+        #\n+        #  - we already detect the process exiting via our PidfdChildWatcher\n+        #\n+        #  - the check is actually harmful since collecting the process via\n+        #    waitpid() prevents the PidfdChildWatcher from doing the same,\n+        #    resulting in an error.\n+        #\n+        # It's on us now to check it, but that's easy:\n+        if self._returncode is not None:\n+            logger.debug(\"won't attempt %s to process %i.  It exited already.\", sig, self._process.pid)\n+            return\n+\n+        try:\n+            os.kill(self._process.pid, sig)\n+            logger.debug('sent %s to process %i', sig, self._process.pid)\n+        except ProcessLookupError:\n+            # already gone? fine\n+            logger.debug(\"can't send %s to process %i.  It's exited just now.\", sig, self._process.pid)\n+\n+    def terminate(self) -> None:\n+        self.send_signal(signal.SIGTERM)\n+\n+    def kill(self) -> None:\n+        self.send_signal(signal.SIGKILL)\n+\n+    def _close(self) -> None:\n+        if self._pty_fd is not None:\n+            os.close(self._pty_fd)\n+            self._pty_fd = None\n+\n+        if self._process is not None:\n+            if self._process.stdin is not None:\n+                self._process.stdin.close()\n+                self._process.stdin = None\n+            try:\n+                self.terminate()  # best effort...\n+            except PermissionError:\n+                logger.debug(\"can't kill %i due to EPERM\", self._process.pid)\n+\n+\n+class StdioTransport(_Transport):\n+    \"\"\"A bi-directional transport that corresponds to stdin/out.\n+\n+    Can talk to just about anything:\n+        - files\n+        - pipes\n+        - character devices (including terminals)\n+        - sockets\n+    \"\"\"\n+\n+    def __init__(self, loop: asyncio.AbstractEventLoop, protocol: asyncio.Protocol, stdin: int = 0, stdout: int = 1):\n+        super().__init__(loop, protocol, stdin, stdout)\n+\n+    def can_write_eof(self) -> bool:\n+        return False\n+\n+    def _write_eof_now(self) -> None:\n+        raise RuntimeError(\"Can't write EOF to stdout\")\n+\n+\n+class Spooler:\n+    \"\"\"Consumes data from an fd, storing it in a buffer.\n+\n+    This makes a copy of the fd, so you don't have to worry about holding it\n+    open.\n+    \"\"\"\n+\n+    _loop: asyncio.AbstractEventLoop\n+    _fd: int\n+    _contents: 'list[bytes]'\n+\n+    def __init__(self, loop: asyncio.AbstractEventLoop, fd: int):\n+        self._loop = loop\n+        self._fd = -1  # in case dup() raises an exception\n+        self._contents = []\n+\n+        self._fd = os.dup(fd)\n+\n+        os.set_blocking(self._fd, False)\n+        loop.add_reader(self._fd, self._read_ready)\n+\n+    def _read_ready(self) -> None:\n+        try:\n+            data = os.read(self._fd, 8192)\n+        except BlockingIOError:  # pragma: no cover\n+            return\n+        except OSError:\n+            # all other errors -> EOF\n+            data = b''\n+\n+        if data != b'':\n+            self._contents.append(data)\n+        else:\n+            self.close()\n+\n+    def _is_ready(self) -> bool:\n+        if self._fd == -1:\n+            return False\n+        return select.select([self._fd], [], [], 0) != ([], [], [])\n+\n+    def get(self, *, reset: bool = False) -> bytes:\n+        while self._is_ready():\n+            self._read_ready()\n+\n+        result = b''.join(self._contents)\n+        if reset:\n+            self._contents = []\n+        return result\n+\n+    def close(self) -> None:\n+        if self._fd != -1:\n+            self._loop.remove_reader(self._fd)\n+            os.close(self._fd)\n+            self._fd = -1\n+\n+    def __del__(self) -> None:\n+        self.close()\n+''',\n+  'cockpit/remote.py': r'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2022 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n+\n+import getpass\n+import logging\n+import re\n+import socket\n+from typing import Dict, List, Optional, Tuple\n+\n+from cockpit._vendor import ferny\n+\n+from .jsonutil import JsonObject, JsonValue, get_str, get_str_or_none\n+from .peer import Peer, PeerError\n+from .router import Router, RoutingRule\n+\n+logger = logging.getLogger(__name__)\n+\n+\n+class PasswordResponder(ferny.AskpassHandler):\n+    PASSPHRASE_RE = re.compile(r\"Enter passphrase for key '(.*)': \")\n+\n+    password: Optional[str]\n+\n+    hostkeys_seen: List[Tuple[str, str, str, str, str]]\n+    error_message: Optional[str]\n+    password_attempts: int\n+\n+    def __init__(self, password: Optional[str]):\n+        self.password = password\n+\n+        self.hostkeys_seen = []\n+        self.error_message = None\n+        self.password_attempts = 0\n+\n+    async def do_hostkey(self, reason: str, host: str, algorithm: str, key: str, fingerprint: str) -> bool:\n+        self.hostkeys_seen.append((reason, host, algorithm, key, fingerprint))\n+        return False\n+\n+    async def do_askpass(self, messages: str, prompt: str, hint: str) -> Optional[str]:\n+        logger.debug('Got askpass(%s): %s', hint, prompt)\n+\n+        match = PasswordResponder.PASSPHRASE_RE.fullmatch(prompt)\n+        if match is not None:\n+            # We never unlock private keys \u2014 we rather need to throw a\n+            # specially-formatted error message which will cause the frontend\n+            # to load the named key into the agent for us and try again.\n+            path = match.group(1)\n+            logger.debug(\"This is a passphrase request for %s, but we don't do those.  Abort.\", path)\n+            self.error_message = f'locked identity: {path}'\n+            return None\n+\n+        assert self.password is not None\n+        assert self.password_attempts == 0\n+        self.password_attempts += 1\n+        return self.password\n+\n+\n+class SshPeer(Peer):\n+    session: Optional[ferny.Session] = None\n+    host: str\n+    user: Optional[str]\n+    password: Optional[str]\n+    private: bool\n+\n+    async def do_connect_transport(self) -> None:\n+        assert self.session is not None\n+        logger.debug('Starting ssh session user=%s, host=%s, private=%s', self.user, self.host, self.private)\n+\n+        basename, colon, portstr = self.host.rpartition(':')\n+        if colon and portstr.isdigit():\n+            host = basename\n+            port = int(portstr)\n+        else:\n+            host = self.host\n+            port = None\n+\n+        responder = PasswordResponder(self.password)\n+        options = {\"StrictHostKeyChecking\": 'yes'}\n+\n+        if self.password is not None:\n+            options.update(NumberOfPasswordPrompts='1')\n+        else:\n+            options.update(PasswordAuthentication=\"no\", KbdInteractiveAuthentication=\"no\")\n+\n+        try:\n+            await self.session.connect(host, login_name=self.user, port=port,\n+                                       handle_host_key=self.private, options=options,\n+                                       interaction_responder=responder)\n+        except (OSError, socket.gaierror) as exc:\n+            logger.debug('connecting to host %s failed: %s', host, exc)\n+            raise PeerError('no-host', error='no-host', message=str(exc)) from exc\n+\n+        except ferny.SshHostKeyError as exc:\n+            if responder.hostkeys_seen:\n+                # If we saw a hostkey then we can issue a detailed error message\n+                # containing the key that would need to be accepted.  That will\n+                # cause the front-end to present a dialog.\n+                _reason, host, algorithm, key, fingerprint = responder.hostkeys_seen[0]\n+                error_args = {'host-key': f'{host} {algorithm} {key}', 'host-fingerprint': fingerprint}\n+            else:\n+                error_args = {}\n+\n+            if isinstance(exc, ferny.SshChangedHostKeyError):\n+                error = 'invalid-hostkey'\n+            elif self.private:\n+                error = 'unknown-hostkey'\n+            else:\n+                # non-private session case.  throw a generic error.\n+                error = 'unknown-host'\n+\n+            logger.debug('SshPeer got a %s %s; private %s, seen hostkeys %r; raising %s with extra args %r',\n+                         type(exc), exc, self.private, responder.hostkeys_seen, error, error_args)\n+            raise PeerError(error, error_args, error=error, auth_method_results={}) from exc\n+\n+        except ferny.SshAuthenticationError as exc:\n+            logger.debug('authentication to host %s failed: %s', host, exc)\n+\n+            results = {method: 'not-provided' for method in exc.methods}\n+            if 'password' in results and self.password is not None:\n+                if responder.password_attempts == 0:\n+                    results['password'] = 'not-tried'\n+                else:\n+                    results['password'] = 'denied'\n+\n+            raise PeerError('authentication-failed',\n+                            error=responder.error_message or 'authentication-failed',\n+                            auth_method_results=results) from exc\n+\n+        except ferny.SshError as exc:\n+            logger.debug('unknown failure connecting to host %s: %s', host, exc)\n+            raise PeerError('internal-error', message=str(exc)) from exc\n+\n+        args = self.session.wrap_subprocess_args(['cockpit-bridge'])\n+        await self.spawn(args, [])\n+\n+    def do_kill(self, host: 'str | None', group: 'str | None', message: JsonObject) -> None:\n+        if host == self.host:\n+            self.close()\n+        elif host is None:\n+            super().do_kill(host, group, message)\n+\n+    def do_authorize(self, message: JsonObject) -> None:\n+        if get_str(message, 'challenge').startswith('plain1:'):\n+            cookie = get_str(message, 'cookie')\n+            self.write_control(command='authorize', cookie=cookie, response=self.password or '')\n+            self.password = None  # once is enough...\n+\n+    def do_superuser_init_done(self) -> None:\n+        self.password = None\n+\n+    def __init__(self, router: Router, host: str, user: Optional[str], options: JsonObject, *, private: bool) -> None:\n+        super().__init__(router)\n+        self.host = host\n+        self.user = user\n+        self.password = get_str(options, 'password', None)\n+        self.private = private\n+\n+        self.session = ferny.Session()\n+\n+        superuser: JsonValue\n+        init_superuser = get_str_or_none(options, 'init-superuser', None)\n+        if init_superuser in (None, 'none'):\n+            superuser = False\n+        else:\n+            superuser = {'id': init_superuser}\n+\n+        self.start_in_background(init_host=host, superuser=superuser)\n+\n+\n+class HostRoutingRule(RoutingRule):\n+    remotes: Dict[Tuple[str, Optional[str], Optional[str]], Peer]\n+\n+    def __init__(self, router):\n+        super().__init__(router)\n+        self.remotes = {}\n+\n+    def apply_rule(self, options: JsonObject) -> Optional[Peer]:\n+        assert self.router is not None\n+        assert self.router.init_host is not None\n+\n+        host = get_str(options, 'host', self.router.init_host)\n+        if host == self.router.init_host:\n+            return None\n+\n+        user = get_str(options, 'user', None)\n+        # HACK: the front-end relies on this for tracking connections without an explicit user name;\n+        # the user will then be determined by SSH (`User` in the config or the current user)\n+        # See cockpit_router_normalize_host_params() in src/bridge/cockpitrouter.c\n+        if user == getpass.getuser():\n+            user = None\n+        if not user:\n+            user_from_host, _, _ = host.rpartition('@')\n+            user = user_from_host or None  # avoid ''\n+\n+        if get_str(options, 'session', None) == 'private':\n+            nonce = get_str(options, 'channel')\n+        else:\n+            nonce = None\n+\n+        assert isinstance(host, str)\n+        assert user is None or isinstance(user, str)\n+        assert nonce is None or isinstance(nonce, str)\n+\n+        key = host, user, nonce\n+\n+        logger.debug('Request for channel %s is remote.', options)\n+        logger.debug('key=%s', key)\n+\n+        if key not in self.remotes:\n+            logger.debug('%s is not among the existing remotes %s.  Opening a new connection.', key, self.remotes)\n+            peer = SshPeer(self.router, host, user, options, private=nonce is not None)\n+            peer.add_done_callback(lambda: self.remotes.__delitem__(key))\n+            self.remotes[key] = peer\n+\n+        return self.remotes[key]\n+\n+    def shutdown(self):\n+        for peer in set(self.remotes.values()):\n+            peer.close()\n+'''.encode('utf-8'),\n+  'cockpit/bridge.py': r'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2022 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n+\n+import argparse\n+import asyncio\n+import contextlib\n+import json\n+import logging\n+import os\n+import pwd\n+import shlex\n+import socket\n+import stat\n+import subprocess\n+from typing import Iterable, List, Optional, Sequence, Tuple, Type\n+\n+from cockpit._vendor.ferny import interaction_client\n+from cockpit._vendor.systemd_ctypes import bus, run_async\n+\n+from . import polyfills\n+from ._version import __version__\n+from .channel import ChannelRoutingRule\n+from .channels import CHANNEL_TYPES\n+from .config import Config, Environment\n+from .internal_endpoints import EXPORTS\n+from .jsonutil import JsonError, JsonObject, get_dict\n+from .packages import BridgeConfig, Packages, PackagesListener\n+from .peer import PeersRoutingRule\n+from .remote import HostRoutingRule\n+from .router import Router\n+from .superuser import SuperuserRoutingRule\n+from .transports import StdioTransport\n+\n+logger = logging.getLogger(__name__)\n+\n+\n+class InternalBus:\n+    exportees: List[bus.Slot]\n+\n+    def __init__(self, exports: Iterable[Tuple[str, Type[bus.BaseObject]]]):\n+        client_socket, server_socket = socket.socketpair()\n+        self.client = bus.Bus.new(fd=client_socket.detach())\n+        self.server = bus.Bus.new(fd=server_socket.detach(), server=True)\n+        self.exportees = [self.server.add_object(path, cls()) for path, cls in exports]\n+\n+    def export(self, path: str, obj: bus.BaseObject) -> None:\n+        self.exportees.append(self.server.add_object(path, obj))\n+\n+\n+class Bridge(Router, PackagesListener):\n+    internal_bus: InternalBus\n+    packages: Optional[Packages]\n+    bridge_configs: Sequence[BridgeConfig]\n+    args: argparse.Namespace\n+\n+    def __init__(self, args: argparse.Namespace):\n+        self.internal_bus = InternalBus(EXPORTS)\n+        self.bridge_configs = []\n+        self.args = args\n+\n+        self.superuser_rule = SuperuserRoutingRule(self, privileged=args.privileged)\n+        self.internal_bus.export('/superuser', self.superuser_rule)\n+\n+        self.internal_bus.export('/config', Config())\n+        self.internal_bus.export('/environment', Environment())\n+\n+        self.peers_rule = PeersRoutingRule(self)\n+\n+        if args.beipack:\n+            # Some special stuff for beipack\n+            self.superuser_rule.set_configs((\n+                BridgeConfig({\n+                    \"privileged\": True,\n+                    \"spawn\": [\"sudo\", \"-k\", \"-A\", \"python3\", \"-ic\", \"# cockpit-bridge\", \"--privileged\"],\n+                    \"environ\": [\"SUDO_ASKPASS=ferny-askpass\"],\n+                }),\n+            ))\n+            self.packages = None\n+        elif args.privileged:\n+            self.packages = None\n+        else:\n+            self.packages = Packages(self)\n+            self.internal_bus.export('/packages', self.packages)\n+            self.packages_loaded()\n+\n+        super().__init__([\n+            HostRoutingRule(self),\n+            self.superuser_rule,\n+            ChannelRoutingRule(self, CHANNEL_TYPES),\n+            self.peers_rule,\n+        ])\n+\n+    @staticmethod\n+    def get_os_release():\n+        try:\n+            file = open('/etc/os-release', encoding='utf-8')\n+        except FileNotFoundError:\n+            try:\n+                file = open('/usr/lib/os-release', encoding='utf-8')\n+            except FileNotFoundError:\n+                logger.warning(\"Neither /etc/os-release nor /usr/lib/os-release exists\")\n+                return {}\n+\n+        os_release = {}\n+        for line in file.readlines():\n+            line = line.strip()\n+            if not line or line.startswith('#'):\n+                continue\n+            try:\n+                k, v = line.split('=')\n+                (v_parsed, ) = shlex.split(v)  # expect exactly one token\n+            except ValueError:\n+                logger.warning('Ignoring invalid line in os-release: %r', line)\n+                continue\n+            os_release[k] = v_parsed\n+        return os_release\n+\n+    def do_init(self, message: JsonObject) -> None:\n+        # we're only interested in the case where this is a dict, but\n+        # 'superuser' may well be `False` and that's not an error\n+        with contextlib.suppress(JsonError):\n+            superuser = get_dict(message, 'superuser')\n+            self.superuser_rule.init(superuser)\n+\n+    def do_send_init(self) -> None:\n+        init_args = {\n+            'capabilities': {'explicit-superuser': True},\n+            'command': 'init',\n+            'os-release': self.get_os_release(),\n+            'version': 1,\n+        }\n+\n+        if self.packages is not None:\n+            init_args['packages'] = {p: None for p in self.packages.packages}\n+\n+        self.write_control(init_args)\n+\n+    # PackagesListener interface\n+    def packages_loaded(self) -> None:\n+        assert self.packages\n+        bridge_configs = self.packages.get_bridge_configs()\n+        if self.bridge_configs != bridge_configs:\n+            self.superuser_rule.set_configs(bridge_configs)\n+            self.peers_rule.set_configs(bridge_configs)\n+            self.bridge_configs = bridge_configs\n+\n+\n+async def run(args) -> None:\n+    logger.debug(\"Hi. How are you today?\")\n+\n+    # Unit tests require this\n+    me = pwd.getpwuid(os.getuid())\n+    os.environ['HOME'] = me.pw_dir\n+    os.environ['SHELL'] = me.pw_shell\n+    os.environ['USER'] = me.pw_name\n+\n+    logger.debug('Starting the router.')\n+    router = Bridge(args)\n+    StdioTransport(asyncio.get_running_loop(), router)\n+\n+    logger.debug('Startup done.  Looping until connection closes.')\n+\n+    try:\n+        await router.communicate()\n+    except (BrokenPipeError, ConnectionResetError):\n+        # not unexpected if the peer doesn't hang up cleanly\n+        pass\n+\n+\n+def try_to_receive_stderr():\n+    try:\n+        ours, theirs = socket.socketpair()\n+        with ours:\n+            with theirs:\n+                interaction_client.command(2, 'cockpit.send-stderr', fds=[theirs.fileno()])\n+            _msg, fds, _flags, _addr = socket.recv_fds(ours, 1, 1)\n+    except OSError:\n+        return\n+\n+    try:\n+        stderr_fd, = fds\n+        # We're about to abruptly drop our end of the stderr socketpair that we\n+        # share with the ferny agent.  ferny would normally treat that as an\n+        # unexpected error. Instruct it to do a clean exit, instead.\n+        interaction_client.command(2, 'ferny.end')\n+        os.dup2(stderr_fd, 2)\n+    finally:\n+        for fd in fds:\n+            os.close(fd)\n+\n+\n+def setup_journald() -> bool:\n+    # If stderr is a socket, prefer systemd-journal logging.  This covers the\n+    # case we're already connected to the journal but also the case where we're\n+    # talking to the ferny agent, while leaving logging to file or terminal\n+    # unaffected.\n+    if not stat.S_ISSOCK(os.fstat(2).st_mode):\n+        # not a socket?  Don't redirect.\n+        return False\n+\n+    try:\n+        import systemd.journal  # type: ignore[import]\n+    except ImportError:\n+        # No python3-systemd?  Don't redirect.\n+        return False\n+\n+    logging.root.addHandler(systemd.journal.JournalHandler())\n+    return True\n+\n+\n+def setup_logging(*, debug: bool) -> None:\n+    \"\"\"Setup our logger with optional filtering of modules if COCKPIT_DEBUG env is set\"\"\"\n+\n+    modules = os.getenv('COCKPIT_DEBUG', '')\n+\n+    # Either setup logging via journal or via formatted messages to stderr\n+    if not setup_journald():\n+        logging.basicConfig(format='%(name)s-%(levelname)s: %(message)s')\n+\n+    if debug or modules == 'all':\n+        logging.getLogger().setLevel(level=logging.DEBUG)\n+    elif modules:\n+        for module in modules.split(','):\n+            module = module.strip()\n+            if not module:\n+                continue\n+\n+            logging.getLogger(module).setLevel(logging.DEBUG)\n+\n+\n+def start_ssh_agent() -> None:\n+    # Launch the agent so that it goes down with us on EOF; PDEATHSIG would be more robust,\n+    # but it gets cleared on setgid ssh-agent, which some distros still do\n+    try:\n+        proc = subprocess.Popen(['ssh-agent', 'sh', '-ec', 'echo SSH_AUTH_SOCK=$SSH_AUTH_SOCK; read a'],\n+                                stdin=subprocess.PIPE, stdout=subprocess.PIPE, universal_newlines=True)\n+        assert proc.stdout is not None\n+\n+        # Wait for the agent to write at least one line and look for the\n+        # listener socket.  If we fail to find it, kill the agent \u2014 something\n+        # went wrong.\n+        for token in shlex.shlex(proc.stdout.readline(), punctuation_chars=True):\n+            if token.startswith('SSH_AUTH_SOCK='):\n+                os.environ['SSH_AUTH_SOCK'] = token.replace('SSH_AUTH_SOCK=', '', 1)\n+                break\n+        else:\n+            proc.terminate()\n+            proc.wait()\n+\n+    except FileNotFoundError:\n+        logger.debug(\"Couldn't start ssh-agent (FileNotFoundError)\")\n+\n+    except OSError as exc:\n+        logger.warning(\"Could not start ssh-agent: %s\", exc)\n+\n+\n+def main(*, beipack: bool = False) -> None:\n+    polyfills.install()\n+\n+    parser = argparse.ArgumentParser(description='cockpit-bridge is run automatically inside of a Cockpit session.')\n+    parser.add_argument('--privileged', action='store_true', help='Privileged copy of the bridge')\n+    parser.add_argument('--packages', action='store_true', help='Show Cockpit package information')\n+    parser.add_argument('--bridges', action='store_true', help='Show Cockpit bridges information')\n+    parser.add_argument('--debug', action='store_true', help='Enable debug output (very verbose)')\n+    parser.add_argument('--version', action='store_true', help='Show Cockpit version information')\n+    args = parser.parse_args()\n+\n+    # This is determined by who calls us\n+    args.beipack = beipack\n+\n+    # If we were run with --privileged then our stderr is currently being\n+    # consumed by the main bridge looking for startup-related error messages.\n+    # Let's switch back to the original stderr stream, which has a side-effect\n+    # of indicating that our startup is more or less complete.  Any errors\n+    # after this point will land in the journal.\n+    if args.privileged:\n+        try_to_receive_stderr()\n+\n+    setup_logging(debug=args.debug)\n+\n+    # Special modes\n+    if args.packages:\n+        Packages().show()\n+        return\n+    elif args.version:\n+        print(f'Version: {__version__}\\nProtocol: 1')\n+        return\n+    elif args.bridges:\n+        print(json.dumps([config.__dict__ for config in Packages().get_bridge_configs()], indent=2))\n+        return\n+\n+    # The privileged bridge doesn't need ssh-agent, but the main one does\n+    if 'SSH_AUTH_SOCK' not in os.environ and not args.privileged:\n+        start_ssh_agent()\n+\n+    # asyncio.run() shim for Python 3.6 support\n+    run_async(run(args), debug=args.debug)\n+\n+\n+if __name__ == '__main__':\n+    main()\n+'''.encode('utf-8'),\n   'cockpit/polkit.py': r'''# This file is part of Cockpit.\n #\n # Copyright (C) 2023 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n@@ -858,14 +3132,241 @@\n                 'org.freedesktop.PolicyKit1.Authority',\n                 'UnregisterAuthenticationAgent',\n                 '(sa{sv})s',\n                 self.subject, AGENT_DBUS_PATH)\n             self.agent_slot.cancel()\n             logger.debug('Unregistered agent for %r', self.subject)\n '''.encode('utf-8'),\n+  'cockpit/__init__.py': br'''from ._version import __version__  # noqa: F401\n+''',\n+  'cockpit/config.py': br'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2023 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n+\n+import configparser\n+import logging\n+import os\n+from pathlib import Path\n+\n+from cockpit._vendor.systemd_ctypes import bus\n+\n+logger = logging.getLogger(__name__)\n+\n+XDG_CONFIG_HOME = Path(os.getenv('XDG_CONFIG_HOME') or os.path.expanduser('~/.config'))\n+DOT_CONFIG_COCKPIT = XDG_CONFIG_HOME / 'cockpit'\n+\n+\n+def lookup_config(filename: str) -> Path:\n+    config_dirs = os.environ.get('XDG_CONFIG_DIRS', '/etc').split(':')\n+    fallback = None\n+    for config_dir in config_dirs:\n+        config_path = Path(config_dir, 'cockpit', filename)\n+        if not fallback:\n+            fallback = config_path\n+        if config_path.exists():\n+            logger.debug('lookup_config(%s): found %s', filename, config_path)\n+            return config_path\n+\n+    # default to the first entry in XDG_CONFIG_DIRS; that's not according to the spec,\n+    # but what Cockpit has done for years\n+    logger.debug('lookup_config(%s): defaulting to %s', filename, fallback)\n+    assert fallback  # mypy; config_dirs always has at least one string\n+    return fallback\n+\n+\n+class Config(bus.Object, interface='cockpit.Config'):\n+    def __init__(self):\n+        self.reload()\n+\n+    @bus.Interface.Method(out_types='s', in_types='ss')\n+    def get_string(self, section, key):\n+        try:\n+            return self.config[section][key]\n+        except KeyError as exc:\n+            raise bus.BusError('cockpit.Config.KeyError', f'key {key} in section {section} does not exist') from exc\n+\n+    @bus.Interface.Method(out_types='u', in_types='ssuuu')\n+    def get_u_int(self, section, key, default, maximum, minimum):\n+        try:\n+            value = self.config[section][key]\n+        except KeyError:\n+            return default\n+\n+        try:\n+            int_val = int(value)\n+        except ValueError:\n+            logger.warning('cockpit.conf: [%s] %s is not an integer', section, key)\n+            return default\n+\n+        return min(max(int_val, minimum), maximum)\n+\n+    @bus.Interface.Method()\n+    def reload(self):\n+        self.config = configparser.ConfigParser(interpolation=None)\n+        cockpit_conf = lookup_config('cockpit.conf')\n+        logger.debug(\"cockpit.Config: loading %s\", cockpit_conf)\n+        # this may not exist, but it's ok to not have a config file and thus leave self.config empty\n+        self.config.read(cockpit_conf)\n+\n+\n+class Environment(bus.Object, interface='cockpit.Environment'):\n+    variables = bus.Interface.Property('a{ss}')\n+\n+    @variables.getter\n+    def get_variables(self):\n+        return os.environ.copy()\n+''',\n+  'cockpit/polyfills.py': br'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2023 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n+\n+import contextlib\n+import socket\n+\n+\n+def install():\n+    \"\"\"Add shims for older Python versions\"\"\"\n+\n+    # introduced in 3.9\n+    if not hasattr(socket, 'recv_fds'):\n+        import array\n+\n+        import _socket\n+\n+        def recv_fds(sock, bufsize, maxfds, flags=0):\n+            fds = array.array(\"i\")\n+            msg, ancdata, flags, addr = sock.recvmsg(bufsize, _socket.CMSG_LEN(maxfds * fds.itemsize))\n+            for cmsg_level, cmsg_type, cmsg_data in ancdata:\n+                if (cmsg_level == _socket.SOL_SOCKET and cmsg_type == _socket.SCM_RIGHTS):\n+                    fds.frombytes(cmsg_data[:len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])\n+            return msg, list(fds), flags, addr\n+\n+        socket.recv_fds = recv_fds\n+\n+    # introduced in 3.7\n+    if not hasattr(contextlib, 'AsyncExitStack'):\n+        class AsyncExitStack:\n+            async def __aenter__(self):\n+                self.cms = []\n+                return self\n+\n+            async def enter_async_context(self, cm):\n+                result = await cm.__aenter__()\n+                self.cms.append(cm)\n+                return result\n+\n+            async def __aexit__(self, exc_type, exc_value, traceback):\n+                for cm in self.cms:\n+                    cm.__aexit__(exc_type, exc_value, traceback)\n+\n+        contextlib.AsyncExitStack = AsyncExitStack\n+''',\n+  'cockpit/beipack.py': br'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2023 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n+\n+import logging\n+import lzma\n+from typing import List, Sequence, Tuple\n+\n+from cockpit._vendor import ferny\n+from cockpit._vendor.bei import beipack\n+\n+from .data import read_cockpit_data_file\n+from .peer import Peer, PeerError\n+\n+logger = logging.getLogger(__name__)\n+\n+\n+def get_bridge_beipack_xz() -> Tuple[str, bytes]:\n+    try:\n+        bridge_beipack_xz = read_cockpit_data_file('cockpit-bridge.beipack.xz')\n+        logger.debug('Got pre-built cockpit-bridge.beipack.xz')\n+    except FileNotFoundError:\n+        logger.debug('Pre-built cockpit-bridge.beipack.xz; building our own.')\n+        # beipack ourselves\n+        cockpit_contents = beipack.collect_module('cockpit', recursive=True)\n+        bridge_beipack = beipack.pack(cockpit_contents, entrypoint='cockpit.bridge:main', args='beipack=True')\n+        bridge_beipack_xz = lzma.compress(bridge_beipack.encode())\n+        logger.debug('  ... done!')\n+\n+    return 'cockpit/data/cockpit-bridge.beipack.xz', bridge_beipack_xz\n+\n+\n+class BridgeBeibootHelper(ferny.InteractionHandler):\n+    # ferny.InteractionHandler ClassVar\n+    commands = ['beiboot.provide', 'beiboot.exc']\n+\n+    peer: Peer\n+    payload: bytes\n+    steps: Sequence[Tuple[str, Sequence[object]]]\n+\n+    def __init__(self, peer: Peer, args: Sequence[str] = ()) -> None:\n+        filename, payload = get_bridge_beipack_xz()\n+\n+        self.peer = peer\n+        self.payload = payload\n+        self.steps = (('boot_xz', (filename, len(payload), tuple(args))),)\n+\n+    async def run_command(self, command: str, args: Tuple, fds: List[int], stderr: str) -> None:\n+        logger.debug('Got ferny request %s %s %s %s', command, args, fds, stderr)\n+        if command == 'beiboot.provide':\n+            try:\n+                size, = args\n+                assert size == len(self.payload)\n+            except (AssertionError, ValueError) as exc:\n+                raise PeerError('internal-error', message=f'ferny interaction error {exc!s}') from exc\n+\n+            assert self.peer.transport is not None\n+            logger.debug('Writing %d bytes of payload', len(self.payload))\n+            self.peer.transport.write(self.payload)\n+        elif command == 'beiboot.exc':\n+            raise PeerError('internal-error', message=f'Remote exception: {args[0]}')\n+        else:\n+            raise PeerError('internal-error', message=f'Unexpected ferny interaction command {command}')\n+''',\n   'cockpit/router.py': br'''# This file is part of Cockpit.\n #\n # Copyright (C) 2022 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n@@ -1125,14 +3626,355 @@\n         finally:\n             self._communication_done = None\n \n             # In an orderly exit, this is already done, but in case it wasn't\n             # orderly, we need to make sure the endpoints shut down anyway...\n             await self.no_endpoints.wait()\n ''',\n+  'cockpit/jsonutil.py': r'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2023 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n+\n+from enum import Enum\n+from typing import Callable, Dict, List, Mapping, Optional, Sequence, Type, TypeVar, Union\n+\n+JsonLiteral = Union[str, float, bool, None]\n+\n+# immutable\n+JsonValue = Union['JsonObject', Sequence['JsonValue'], JsonLiteral]\n+JsonObject = Mapping[str, JsonValue]\n+\n+# mutable\n+JsonDocument = Union['JsonDict', 'JsonList', JsonLiteral]\n+JsonDict = Dict[str, JsonDocument]\n+JsonList = List[JsonDocument]\n+\n+\n+DT = TypeVar('DT')\n+T = TypeVar('T')\n+\n+\n+class JsonError(Exception):\n+    value: object\n+\n+    def __init__(self, value: object, msg: str):\n+        super().__init__(msg)\n+        self.value = value\n+\n+\n+def typechecked(value: JsonValue, expected_type: Type[T]) -> T:\n+    \"\"\"Ensure a JSON value has the expected type, returning it if so.\"\"\"\n+    if not isinstance(value, expected_type):\n+        raise JsonError(value, f'must have type {expected_type.__name__}')\n+    return value\n+\n+\n+# We can't use None as a sentinel because it's often the actual default value\n+# EllipsisType is difficult because it's not available before 3.10.\n+# See https://peps.python.org/pep-0484/#support-for-singleton-types-in-unions\n+class _Empty(Enum):\n+    TOKEN = 0\n+\n+\n+_empty = _Empty.TOKEN\n+\n+\n+def _get(obj: JsonObject, cast: Callable[[JsonValue], T], key: str, default: Union[DT, _Empty]) -> Union[T, DT]:\n+    try:\n+        return cast(obj[key])\n+    except KeyError:\n+        if default is not _empty:\n+            return default\n+        raise JsonError(obj, f\"attribute '{key}' required\") from None\n+    except JsonError as exc:\n+        target = f\"attribute '{key}'\" + (' elements:' if exc.value is not obj[key] else ':')\n+        raise JsonError(obj, f\"{target} {exc!s}\") from exc\n+\n+\n+def get_bool(obj: JsonObject, key: str, default: Union[DT, _Empty] = _empty) -> Union[DT, bool]:\n+    return _get(obj, lambda v: typechecked(v, bool), key, default)\n+\n+\n+def get_int(obj: JsonObject, key: str, default: Union[DT, _Empty] = _empty) -> Union[DT, int]:\n+    return _get(obj, lambda v: typechecked(v, int), key, default)\n+\n+\n+def get_str(obj: JsonObject, key: str, default: Union[DT, _Empty] = _empty) -> Union[DT, str]:\n+    return _get(obj, lambda v: typechecked(v, str), key, default)\n+\n+\n+def get_str_or_none(obj: JsonObject, key: str, default: Optional[str]) -> Optional[str]:\n+    return _get(obj, lambda v: None if v is None else typechecked(v, str), key, default)\n+\n+\n+def get_dict(obj: JsonObject, key: str, default: Union[DT, _Empty] = _empty) -> Union[DT, JsonObject]:\n+    return _get(obj, lambda v: typechecked(v, dict), key, default)\n+\n+\n+def get_object(\n+    obj: JsonObject,\n+    key: str,\n+    constructor: Callable[[JsonObject], T],\n+    default: Union[DT, _Empty] = _empty\n+) -> Union[DT, T]:\n+    return _get(obj, lambda v: constructor(typechecked(v, dict)), key, default)\n+\n+\n+def get_strv(obj: JsonObject, key: str, default: Union[DT, _Empty] = _empty) -> Union[DT, Sequence[str]]:\n+    def as_strv(value: JsonValue) -> Sequence[str]:\n+        return tuple(typechecked(item, str) for item in typechecked(value, list))\n+    return _get(obj, as_strv, key, default)\n+\n+\n+def get_objv(obj: JsonObject, key: str, constructor: Callable[[JsonObject], T]) -> Union[DT, Sequence[T]]:\n+    def as_objv(value: JsonValue) -> Sequence[T]:\n+        return tuple(constructor(typechecked(item, dict)) for item in typechecked(value, list))\n+    return _get(obj, as_objv, key, ())\n+\n+\n+def create_object(message: 'JsonObject | None', kwargs: JsonObject) -> JsonObject:\n+    \"\"\"Constructs a JSON object based on message and kwargs.\n+\n+    If only message is given, it is returned, unmodified.  If message is None,\n+    it is equivalent to an empty dictionary.  A copy is always made.\n+\n+    If kwargs are present, then any underscore ('_') present in a key name is\n+    rewritten to a dash ('-').  This is intended to bridge between the required\n+    Python syntax when providing kwargs and idiomatic JSON (which uses '-' for\n+    attributes).  These values override values in message.\n+\n+    The idea is that `message` should be used for passing data along, and\n+    kwargs used for data originating at a given call site, possibly including\n+    modifications to an original message.\n+    \"\"\"\n+    result = dict(message or {})\n+\n+    for key, value in kwargs.items():\n+        # rewrite '_' (necessary in Python syntax kwargs list) to '-' (idiomatic JSON)\n+        json_key = key.replace('_', '-')\n+        result[json_key] = value\n+\n+    return result\n+\n+\n+def json_merge_patch(current: JsonObject, patch: JsonObject) -> JsonObject:\n+    \"\"\"Perform a JSON merge patch (RFC 7396) using 'current' and 'patch'.\n+    Neither of the original dictionaries is modified \u2014 the result is returned.\n+    \"\"\"\n+    # Always take a copy ('result') \u2014 we never modify the input ('current')\n+    result = dict(current)\n+    for key, patch_value in patch.items():\n+        if isinstance(patch_value, Mapping):\n+            current_value = current.get(key, None)\n+            if not isinstance(current_value, Mapping):\n+                current_value = {}\n+            result[key] = json_merge_patch(current_value, patch_value)\n+        elif patch_value is not None:\n+            result[key] = patch_value\n+        else:\n+            result.pop(key, None)\n+\n+    return result\n+\n+\n+def json_merge_and_filter_patch(current: JsonDict, patch: JsonDict) -> None:\n+    \"\"\"Perform a JSON merge patch (RFC 7396) modifying 'current' with 'patch'.\n+    Also modifies 'patch' to remove redundant operations.\n+    \"\"\"\n+    for key, patch_value in tuple(patch.items()):\n+        current_value = current.get(key, None)\n+\n+        if isinstance(patch_value, dict):\n+            if not isinstance(current_value, dict):\n+                current[key] = current_value = {}\n+                json_merge_and_filter_patch(current_value, patch_value)\n+            else:\n+                json_merge_and_filter_patch(current_value, patch_value)\n+                if not patch_value:\n+                    del patch[key]\n+        elif current_value == patch_value:\n+            del patch[key]\n+        elif patch_value is not None:\n+            current[key] = patch_value\n+        else:\n+            del current[key]\n+'''.encode('utf-8'),\n+  'cockpit/internal_endpoints.py': br'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2022 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n+\n+import asyncio\n+import glob\n+import grp\n+import json\n+import logging\n+import os\n+import pwd\n+from pathlib import Path\n+from typing import Dict, Optional\n+\n+from cockpit._vendor.systemd_ctypes import Variant, bus, inotify, pathwatch\n+\n+from . import config\n+\n+logger = logging.getLogger(__name__)\n+\n+\n+class cockpit_LoginMessages(bus.Object):\n+    messages: Optional[str] = None\n+\n+    def __init__(self):\n+        fdstr = os.environ.pop('COCKPIT_LOGIN_MESSAGES_MEMFD', None)\n+        if fdstr is None:\n+            logger.debug(\"COCKPIT_LOGIN_MESSAGES_MEMFD wasn't set.  No login messages today.\")\n+            return\n+\n+        logger.debug(\"Trying to read login messages from fd %s\", fdstr)\n+        try:\n+            with open(int(fdstr), 'r') as login_messages:\n+                login_messages.seek(0)\n+                self.messages = login_messages.read()\n+        except (ValueError, OSError, UnicodeDecodeError) as exc:\n+            # ValueError - the envvar wasn't an int\n+            # OSError - the fd wasn't open, or other read failure\n+            # UnicodeDecodeError - didn't contain utf-8\n+            # For all of these, we simply failed to get the message.\n+            logger.debug(\"Reading login messages failed: %s\", exc)\n+        else:\n+            logger.debug(\"Successfully read login messages: %s\", self.messages)\n+\n+    @bus.Interface.Method(out_types=['s'])\n+    def get(self):\n+        return self.messages or '{}'\n+\n+    @bus.Interface.Method(out_types=[])\n+    def dismiss(self):\n+        self.messages = None\n+\n+\n+class cockpit_Machines(bus.Object):\n+    path: Path\n+    watch: pathwatch.PathWatch\n+    pending_notify: Optional[asyncio.Handle]\n+\n+    # D-Bus implementation\n+    machines = bus.Interface.Property('a{sa{sv}}')\n+\n+    @machines.getter\n+    def get_machines(self) -> Dict[str, Dict[str, Variant]]:\n+        results: Dict[str, Dict[str, Variant]] = {}\n+\n+        for filename in glob.glob(f'{self.path}/*.json'):\n+            with open(filename) as fp:\n+                try:\n+                    contents = json.load(fp)\n+                except json.JSONDecodeError:\n+                    logger.warning('Invalid JSON in file %s.  Ignoring.', filename)\n+                    continue\n+                # merge\n+                for hostname, attrs in contents.items():\n+                    results[hostname] = {key: Variant(value) for key, value in attrs.items()}\n+\n+        return results\n+\n+    @bus.Interface.Method(in_types=['s', 's', 'a{sv}'])\n+    def update(self, filename: str, hostname: str, attrs: Dict[str, Variant]) -> None:\n+        try:\n+            with self.path.joinpath(filename).open() as fp:\n+                contents = json.load(fp)\n+        except json.JSONDecodeError as exc:\n+            # Refuse to replace corrupted file\n+            raise bus.BusError('cockpit.Machines.Error', f'File {filename} is in invalid format: {exc}.') from exc\n+        except FileNotFoundError:\n+            # But an empty file is an expected case\n+            contents = {}\n+\n+        contents.setdefault(hostname, {}).update({key: value.value for key, value in attrs.items()})\n+\n+        self.path.mkdir(parents=True, exist_ok=True)\n+        with open(self.path.joinpath(filename), 'w') as fp:\n+            json.dump(contents, fp, indent=2)\n+\n+    def notify(self):\n+        def _notify_now():\n+            self.properties_changed('cockpit.Machines', {}, ['Machines'])\n+            self.pending_notify = None\n+\n+        # avoid a flurry of update notifications\n+        if self.pending_notify is None:\n+            self.pending_notify = asyncio.get_running_loop().call_later(1.0, _notify_now)\n+\n+    # inotify events\n+    def do_inotify_event(self, mask: inotify.Event, cookie: int, name: Optional[str]) -> None:\n+        self.notify()\n+\n+    def do_identity_changed(self, fd: Optional[int], errno: Optional[int]) -> None:\n+        self.notify()\n+\n+    def __init__(self):\n+        self.path = config.lookup_config('machines.d')\n+\n+        # ignore the first callback\n+        self.pending_notify = ...\n+        self.watch = pathwatch.PathWatch(str(self.path), self)\n+        self.pending_notify = None\n+\n+\n+class cockpit_User(bus.Object):\n+    name = bus.Interface.Property('s', value='')\n+    full = bus.Interface.Property('s', value='')\n+    id = bus.Interface.Property('i', value=0)\n+    home = bus.Interface.Property('s', value='')\n+    shell = bus.Interface.Property('s', value='')\n+    groups = bus.Interface.Property('as', value=[])\n+\n+    def __init__(self):\n+        user = pwd.getpwuid(os.getuid())\n+        self.name = user.pw_name\n+        self.full = user.pw_gecos\n+        self.id = user.pw_uid\n+        self.home = user.pw_dir\n+        self.shell = user.pw_shell\n+        self.groups = [gr.gr_name for gr in grp.getgrall() if user.pw_name in gr.gr_mem]\n+\n+\n+EXPORTS = [\n+    ('/LoginMessages', cockpit_LoginMessages),\n+    ('/machines', cockpit_Machines),\n+    ('/user', cockpit_User),\n+]\n+''',\n+  'cockpit/_version.py': br'''__version__ = '311'\n+''',\n   'cockpit/beiboot.py': br'''# This file is part of Cockpit.\n #\n # Copyright (C) 2022 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n@@ -1466,963 +4308,14 @@\n \n     asyncio.run(run(args), debug=args.debug)\n \n \n if __name__ == '__main__':\n     main()\n ''',\n-  'cockpit/config.py': br'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2023 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import configparser\n-import logging\n-import os\n-from pathlib import Path\n-\n-from cockpit._vendor.systemd_ctypes import bus\n-\n-logger = logging.getLogger(__name__)\n-\n-XDG_CONFIG_HOME = Path(os.getenv('XDG_CONFIG_HOME') or os.path.expanduser('~/.config'))\n-DOT_CONFIG_COCKPIT = XDG_CONFIG_HOME / 'cockpit'\n-\n-\n-def lookup_config(filename: str) -> Path:\n-    config_dirs = os.environ.get('XDG_CONFIG_DIRS', '/etc').split(':')\n-    fallback = None\n-    for config_dir in config_dirs:\n-        config_path = Path(config_dir, 'cockpit', filename)\n-        if not fallback:\n-            fallback = config_path\n-        if config_path.exists():\n-            logger.debug('lookup_config(%s): found %s', filename, config_path)\n-            return config_path\n-\n-    # default to the first entry in XDG_CONFIG_DIRS; that's not according to the spec,\n-    # but what Cockpit has done for years\n-    logger.debug('lookup_config(%s): defaulting to %s', filename, fallback)\n-    assert fallback  # mypy; config_dirs always has at least one string\n-    return fallback\n-\n-\n-class Config(bus.Object, interface='cockpit.Config'):\n-    def __init__(self):\n-        self.reload()\n-\n-    @bus.Interface.Method(out_types='s', in_types='ss')\n-    def get_string(self, section, key):\n-        try:\n-            return self.config[section][key]\n-        except KeyError as exc:\n-            raise bus.BusError('cockpit.Config.KeyError', f'key {key} in section {section} does not exist') from exc\n-\n-    @bus.Interface.Method(out_types='u', in_types='ssuuu')\n-    def get_u_int(self, section, key, default, maximum, minimum):\n-        try:\n-            value = self.config[section][key]\n-        except KeyError:\n-            return default\n-\n-        try:\n-            int_val = int(value)\n-        except ValueError:\n-            logger.warning('cockpit.conf: [%s] %s is not an integer', section, key)\n-            return default\n-\n-        return min(max(int_val, minimum), maximum)\n-\n-    @bus.Interface.Method()\n-    def reload(self):\n-        self.config = configparser.ConfigParser(interpolation=None)\n-        cockpit_conf = lookup_config('cockpit.conf')\n-        logger.debug(\"cockpit.Config: loading %s\", cockpit_conf)\n-        # this may not exist, but it's ok to not have a config file and thus leave self.config empty\n-        self.config.read(cockpit_conf)\n-\n-\n-class Environment(bus.Object, interface='cockpit.Environment'):\n-    variables = bus.Interface.Property('a{ss}')\n-\n-    @variables.getter\n-    def get_variables(self):\n-        return os.environ.copy()\n-''',\n-  'cockpit/channel.py': br'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2022 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import asyncio\n-import json\n-import logging\n-from typing import BinaryIO, ClassVar, Dict, Generator, List, Optional, Sequence, Set, Tuple, Type\n-\n-from .jsonutil import JsonError, JsonObject, JsonValue, create_object, get_bool, get_str\n-from .protocol import CockpitProblem\n-from .router import Endpoint, Router, RoutingRule\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class ChannelRoutingRule(RoutingRule):\n-    table: Dict[str, List[Type['Channel']]]\n-\n-    def __init__(self, router: Router, channel_types: List[Type['Channel']]):\n-        super().__init__(router)\n-        self.table = {}\n-\n-        # Sort the channels into buckets by payload type\n-        for cls in channel_types:\n-            entry = self.table.setdefault(cls.payload, [])\n-            entry.append(cls)\n-\n-        # Within each bucket, sort the channels so those with more\n-        # restrictions are considered first.\n-        for entry in self.table.values():\n-            entry.sort(key=lambda cls: len(cls.restrictions), reverse=True)\n-\n-    def check_restrictions(self, restrictions: Sequence[Tuple[str, object]], options: JsonObject) -> bool:\n-        for key, expected_value in restrictions:\n-            our_value = options.get(key)\n-\n-            # If the match rule specifies that a value must be present and\n-            # we don't have it, then fail.\n-            if our_value is None:\n-                return False\n-\n-            # If the match rule specified a specific expected value, and\n-            # our value doesn't match it, then fail.\n-            if expected_value is not None and our_value != expected_value:\n-                return False\n-\n-        # Everything checked out\n-        return True\n-\n-    def apply_rule(self, options: JsonObject) -> Optional['Channel']:\n-        assert self.router is not None\n-\n-        payload = options.get('payload')\n-        if not isinstance(payload, str):\n-            return None\n-\n-        for cls in self.table.get(payload, []):\n-            if self.check_restrictions(cls.restrictions, options):\n-                return cls(self.router)\n-        else:\n-            return None\n-\n-    def shutdown(self):\n-        pass  # we don't hold any state\n-\n-\n-class ChannelError(CockpitProblem):\n-    pass\n-\n-\n-class Channel(Endpoint):\n-    # Values borrowed from C implementation\n-    BLOCK_SIZE = 16 * 1024\n-    SEND_WINDOW = 2 * 1024 * 1024\n-\n-    # Flow control book-keeping\n-    _send_pings: bool = False\n-    _out_sequence: int = 0\n-    _out_window: int = SEND_WINDOW\n-\n-    # Task management\n-    _tasks: Set[asyncio.Task]\n-    _close_args: Optional[JsonObject] = None\n-\n-    # Must be filled in by the channel implementation\n-    payload: ClassVar[str]\n-    restrictions: ClassVar[Sequence[Tuple[str, object]]] = ()\n-\n-    # These get filled in from .do_open()\n-    channel = ''\n-    group = ''\n-\n-    # input\n-    def do_control(self, command, message):\n-        # Break the various different kinds of control messages out into the\n-        # things that our subclass may be interested in handling.  We drop the\n-        # 'message' field for handlers that don't need it.\n-        if command == 'open':\n-            self._tasks = set()\n-            self.channel = message['channel']\n-            if get_bool(message, 'flow-control', default=False):\n-                self._send_pings = True\n-            self.group = get_str(message, 'group', 'default')\n-            self.freeze_endpoint()\n-            self.do_open(message)\n-        elif command == 'ready':\n-            self.do_ready()\n-        elif command == 'done':\n-            self.do_done()\n-        elif command == 'close':\n-            self.do_close()\n-        elif command == 'ping':\n-            self.do_ping(message)\n-        elif command == 'pong':\n-            self.do_pong(message)\n-        elif command == 'options':\n-            self.do_options(message)\n-\n-    def do_channel_control(self, channel: str, command: str, message: JsonObject) -> None:\n-        # Already closing?  Ignore.\n-        if self._close_args is not None:\n-            return\n-\n-        # Catch errors and turn them into close messages\n-        try:\n-            try:\n-                self.do_control(command, message)\n-            except JsonError as exc:\n-                raise ChannelError('protocol-error', message=str(exc)) from exc\n-        except ChannelError as exc:\n-            self.close(exc.attrs)\n-\n-    def do_kill(self, host: 'str | None', group: 'str | None', _message: JsonObject) -> None:\n-        # Already closing?  Ignore.\n-        if self._close_args is not None:\n-            return\n-\n-        if host is not None:\n-            return\n-        if group is not None and self.group != group:\n-            return\n-        self.do_close()\n-\n-    # At least this one really ought to be implemented...\n-    def do_open(self, options: JsonObject) -> None:\n-        raise NotImplementedError\n-\n-    # ... but many subclasses may reasonably want to ignore some of these.\n-    def do_ready(self) -> None:\n-        pass\n-\n-    def do_done(self) -> None:\n-        pass\n-\n-    def do_close(self) -> None:\n-        self.close()\n-\n-    def do_options(self, message: JsonObject) -> None:\n-        raise ChannelError('not-supported', message='This channel does not implement \"options\"')\n-\n-    # 'reasonable' default, overridden in other channels for receive-side flow control\n-    def do_ping(self, message: JsonObject) -> None:\n-        self.send_pong(message)\n-\n-    def do_channel_data(self, channel: str, data: bytes) -> None:\n-        # Already closing?  Ignore.\n-        if self._close_args is not None:\n-            return\n-\n-        # Catch errors and turn them into close messages\n-        try:\n-            self.do_data(data)\n-        except ChannelError as exc:\n-            self.close(exc.attrs)\n-\n-    def do_data(self, _data: bytes) -> None:\n-        # By default, channels can't receive data.\n-        self.close()\n-\n-    # output\n-    def ready(self, **kwargs: JsonValue) -> None:\n-        self.thaw_endpoint()\n-        self.send_control(command='ready', **kwargs)\n-\n-    def done(self) -> None:\n-        self.send_control(command='done')\n-\n-    # tasks and close management\n-    def is_closing(self) -> bool:\n-        return self._close_args is not None\n-\n-    def _close_now(self) -> None:\n-        self.shutdown_endpoint(self._close_args)\n-\n-    def _task_done(self, task):\n-        # Strictly speaking, we should read the result and check for exceptions but:\n-        #   - exceptions bubbling out of the task are programming errors\n-        #   - the only thing we'd do with it anyway, is to show it\n-        #   - Python already does that with its \"Task exception was never retrieved\" messages\n-        self._tasks.remove(task)\n-        if self._close_args is not None and not self._tasks:\n-            self._close_now()\n-\n-    def create_task(self, coroutine, name=None):\n-        \"\"\"Create a task associated with the channel.\n-\n-        All tasks must exit before the channel can close.  You may not create\n-        new tasks after calling .close().\n-        \"\"\"\n-        assert self._close_args is None\n-        task = asyncio.create_task(coroutine)\n-        self._tasks.add(task)\n-        task.add_done_callback(self._task_done)\n-        return task\n-\n-    def close(self, close_args: 'JsonObject | None' = None) -> None:\n-        \"\"\"Requests the channel to be closed.\n-\n-        After you call this method, you won't get anymore `.do_*()` calls.\n-\n-        This will wait for any running tasks to complete before sending the\n-        close message.\n-        \"\"\"\n-        if self._close_args is not None:\n-            # close already requested\n-            return\n-        self._close_args = close_args or {}\n-        if not self._tasks:\n-            self._close_now()\n-\n-    def send_data(self, data: bytes) -> bool:\n-        \"\"\"Send data and handle book-keeping for flow control.\n-\n-        The flow control is \"advisory\".  The data is sent immediately, even if\n-        it's larger than the window.  In general you should try to send packets\n-        which are approximately Channel.BLOCK_SIZE in size.\n-\n-        Returns True if there is still room in the window, or False if you\n-        should stop writing for now.  In that case, `.do_resume_send()` will be\n-        called later when there is more room.\n-        \"\"\"\n-        self.send_channel_data(self.channel, data)\n-\n-        if self._send_pings:\n-            out_sequence = self._out_sequence + len(data)\n-            if self._out_sequence // Channel.BLOCK_SIZE != out_sequence // Channel.BLOCK_SIZE:\n-                self.send_control(command='ping', sequence=out_sequence)\n-            self._out_sequence = out_sequence\n-\n-        return self._out_sequence < self._out_window\n-\n-    def do_pong(self, message):\n-        if not self._send_pings:  # huh?\n-            logger.warning(\"Got wild pong on channel %s\", self.channel)\n-            return\n-\n-        self._out_window = message['sequence'] + Channel.SEND_WINDOW\n-        if self._out_sequence < self._out_window:\n-            self.do_resume_send()\n-\n-    def do_resume_send(self) -> None:\n-        \"\"\"Called to indicate that the channel may start sending again.\"\"\"\n-        # change to `raise NotImplementedError` after everyone implements it\n-\n-    json_encoder: ClassVar[json.JSONEncoder] = json.JSONEncoder(indent=2)\n-\n-    def send_json(self, _msg: 'JsonObject | None' = None, **kwargs: JsonValue) -> bool:\n-        pretty = self.json_encoder.encode(create_object(_msg, kwargs)) + '\\n'\n-        return self.send_data(pretty.encode())\n-\n-    def send_control(self, command: str, **kwargs: JsonValue) -> None:\n-        self.send_channel_control(self.channel, command, None, **kwargs)\n-\n-    def send_pong(self, message: JsonObject) -> None:\n-        self.send_channel_control(self.channel, 'pong', message)\n-\n-\n-class ProtocolChannel(Channel, asyncio.Protocol):\n-    \"\"\"A channel subclass that implements the asyncio Protocol interface.\n-\n-    In effect, data sent to this channel will be written to the connected\n-    transport, and vice-versa.  Flow control is supported.\n-\n-    The default implementation of the .do_open() method calls the\n-    .create_transport() abstract method.  This method should return a transport\n-    which will be used for communication on the channel.\n-\n-    Otherwise, if the subclass implements .do_open() itself, it is responsible\n-    for setting up the connection and ensuring that .connection_made() is called.\n-    \"\"\"\n-    _transport: Optional[asyncio.Transport]\n-    _loop: Optional[asyncio.AbstractEventLoop]\n-    _send_pongs: bool = True\n-    _last_ping: Optional[JsonObject] = None\n-    _create_transport_task = None\n-\n-    # read-side EOF handling\n-    _close_on_eof: bool = False\n-    _eof: bool = False\n-\n-    async def create_transport(self, loop: asyncio.AbstractEventLoop, options: JsonObject) -> asyncio.Transport:\n-        \"\"\"Creates the transport for this channel, according to options.\n-\n-        The event loop for the transport is passed to the function.  The\n-        protocol for the transport is the channel object, itself (self).\n-\n-        This needs to be implemented by the subclass.\n-        \"\"\"\n-        raise NotImplementedError\n-\n-    def do_open(self, options: JsonObject) -> None:\n-        loop = asyncio.get_running_loop()\n-        self._create_transport_task = asyncio.create_task(self.create_transport(loop, options))\n-        self._create_transport_task.add_done_callback(self.create_transport_done)\n-\n-    def create_transport_done(self, task: 'asyncio.Task[asyncio.Transport]') -> None:\n-        assert task is self._create_transport_task\n-        self._create_transport_task = None\n-        try:\n-            transport = task.result()\n-        except ChannelError as exc:\n-            self.close(exc.attrs)\n-            return\n-\n-        self.connection_made(transport)\n-        self.ready()\n-\n-    def connection_made(self, transport: asyncio.BaseTransport) -> None:\n-        assert isinstance(transport, asyncio.Transport)\n-        self._transport = transport\n-\n-    def _get_close_args(self) -> JsonObject:\n-        return {}\n-\n-    def connection_lost(self, exc: Optional[Exception]) -> None:\n-        self.close(self._get_close_args())\n-\n-    def do_data(self, data: bytes) -> None:\n-        assert self._transport is not None\n-        self._transport.write(data)\n-\n-    def do_done(self) -> None:\n-        assert self._transport is not None\n-        if self._transport.can_write_eof():\n-            self._transport.write_eof()\n-\n-    def do_close(self) -> None:\n-        if self._transport is not None:\n-            self._transport.close()\n-\n-    def data_received(self, data: bytes) -> None:\n-        assert self._transport is not None\n-        if not self.send_data(data):\n-            self._transport.pause_reading()\n-\n-    def do_resume_send(self) -> None:\n-        assert self._transport is not None\n-        self._transport.resume_reading()\n-\n-    def close_on_eof(self) -> None:\n-        \"\"\"Mark the channel to be closed on EOF.\n-\n-        Normally, ProtocolChannel tries to keep the channel half-open after\n-        receiving EOF from the transport.  This instructs that the channel\n-        should be closed on EOF.\n-\n-        If EOF was already received, then calling this function will close the\n-        channel immediately.\n-\n-        If you don't call this function, you are responsible for closing the\n-        channel yourself.\n-        \"\"\"\n-        self._close_on_eof = True\n-        if self._eof:\n-            assert self._transport is not None\n-            self._transport.close()\n-\n-    def eof_received(self) -> bool:\n-        self._eof = True\n-        self.done()\n-        return not self._close_on_eof\n-\n-    # Channel receive-side flow control\n-    def do_ping(self, message):\n-        if self._send_pongs:\n-            self.send_pong(message)\n-        else:\n-            # we'll have to pong later\n-            self._last_ping = message\n-\n-    def pause_writing(self) -> None:\n-        # We can't actually stop writing, but we can stop replying to pings\n-        self._send_pongs = False\n-\n-    def resume_writing(self) -> None:\n-        self._send_pongs = True\n-        if self._last_ping is not None:\n-            self.send_pong(self._last_ping)\n-            self._last_ping = None\n-\n-\n-class AsyncChannel(Channel):\n-    \"\"\"A subclass for async/await-style implementation of channels, with flow control\n-\n-    This subclass provides asynchronous `read()` and `write()` calls for\n-    subclasses, with familiar semantics.  `write()` doesn't buffer, so the\n-    `done()` method on the base channel class can be used in a way similar to\n-    `shutdown()`.  A high-level `sendfile()` method is available to send the\n-    entire contents of a binary-mode file-like object.\n-\n-    The subclass must provide an async `run()` function, which will be spawned\n-    as a task.\n-\n-    On the receiving side, the channel will respond to flow control pings to\n-    indicate that it has received the data, but only after it has been consumed\n-    by `read()`.\n-\n-    On the sending side, write() will block if the channel backs up.\n-    \"\"\"\n-\n-    # Receive-side flow control: intermix pings and data in the queue and reply\n-    # to pings as we dequeue them.  This is a buffer: since we need to handle\n-    # do_data() without blocking, we have no choice.\n-    receive_queue = None\n-\n-    # Send-side flow control\n-    write_waiter = None\n-\n-    async def run(self, options):\n-        raise NotImplementedError\n-\n-    async def run_wrapper(self, options):\n-        try:\n-            await self.run(options)\n-            self.close()\n-        except ChannelError as exc:\n-            self.close(exc.attrs)\n-\n-    async def read(self):\n-        while True:\n-            item = await self.receive_queue.get()\n-            if isinstance(item, bytes):\n-                return item\n-            self.send_pong(item)\n-\n-    async def write(self, data):\n-        if not self.send_data(data):\n-            self.write_waiter = asyncio.get_running_loop().create_future()\n-            await self.write_waiter\n-\n-    async def sendfile(self, stream: BinaryIO) -> None:\n-        loop = asyncio.get_running_loop()\n-        with stream:\n-            while True:\n-                data = await loop.run_in_executor(None, stream.read, Channel.BLOCK_SIZE)\n-                if data == b'':\n-                    break\n-                await self.write(data)\n-\n-            self.done()\n-\n-    def do_resume_send(self) -> None:\n-        if self.write_waiter is not None:\n-            self.write_waiter.set_result(None)\n-            self.write_waiter = None\n-\n-    def do_open(self, options):\n-        self.receive_queue = asyncio.Queue()\n-        self.create_task(self.run_wrapper(options), name=f'{self.__class__.__name__}.run_wrapper({options})')\n-\n-    def do_done(self):\n-        self.receive_queue.put_nowait(b'')\n-\n-    def do_close(self):\n-        # we might have already sent EOF for done, but two EOFs won't hurt anyone\n-        self.receive_queue.put_nowait(b'')\n-\n-    def do_ping(self, message):\n-        self.receive_queue.put_nowait(message)\n-\n-    def do_data(self, data):\n-        if not isinstance(data, bytes):\n-            # this will persist past this callback, so make sure we take our\n-            # own copy, in case this was a memoryview into a bytearray.\n-            data = bytes(data)\n-\n-        self.receive_queue.put_nowait(data)\n-\n-\n-class GeneratorChannel(Channel):\n-    \"\"\"A trivial Channel subclass for sending data from a generator with flow control.\n-\n-    Calls the .do_yield_data() generator with the options from the open message\n-    and sends the data which it yields.  If the generator returns a value it\n-    will be used for the close message.\n-    \"\"\"\n-    DataGenerator = Generator[bytes, None, Optional[JsonObject]]\n-    __generator: DataGenerator\n-\n-    def do_yield_data(self, options: JsonObject) -> 'DataGenerator':\n-        raise NotImplementedError\n-\n-    def do_open(self, options: JsonObject) -> None:\n-        self.__generator = self.do_yield_data(options)\n-        self.do_resume_send()\n-\n-    def do_resume_send(self) -> None:\n-        try:\n-            while self.send_data(next(self.__generator)):\n-                pass\n-        except StopIteration as stop:\n-            self.done()\n-            self.close(stop.value)\n-''',\n-  'cockpit/peer.py': r'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2022 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import asyncio\n-import logging\n-import os\n-from typing import Callable, List, Optional, Sequence\n-\n-from .jsonutil import JsonObject, JsonValue\n-from .packages import BridgeConfig\n-from .protocol import CockpitProblem, CockpitProtocol, CockpitProtocolError\n-from .router import Endpoint, Router, RoutingRule\n-from .transports import SubprocessProtocol, SubprocessTransport\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class PeerError(CockpitProblem):\n-    pass\n-\n-\n-class PeerExited(Exception):\n-    def __init__(self, exit_code: int):\n-        self.exit_code = exit_code\n-\n-\n-class Peer(CockpitProtocol, SubprocessProtocol, Endpoint):\n-    done_callbacks: List[Callable[[], None]]\n-    init_future: Optional[asyncio.Future]\n-\n-    def __init__(self, router: Router):\n-        super().__init__(router)\n-\n-        # All Peers start out frozen \u2014 we only unfreeze after we see the first 'init' message\n-        self.freeze_endpoint()\n-\n-        self.init_future = asyncio.get_running_loop().create_future()\n-        self.done_callbacks = []\n-\n-    # Initialization\n-    async def do_connect_transport(self) -> None:\n-        raise NotImplementedError\n-\n-    async def spawn(self, argv: Sequence[str], env: Sequence[str], **kwargs) -> asyncio.Transport:\n-        # Not actually async...\n-        loop = asyncio.get_running_loop()\n-        user_env = dict(e.split('=', 1) for e in env)\n-        return SubprocessTransport(loop, self, argv, env=dict(os.environ, **user_env), **kwargs)\n-\n-    async def start(self, init_host: Optional[str] = None, **kwargs: JsonValue) -> JsonObject:\n-        \"\"\"Request that the Peer is started and connected to the router.\n-\n-        Creates the transport, connects it to the protocol, and participates in\n-        exchanging of init messages.  If anything goes wrong, the connection\n-        will be closed and an exception will be raised.\n-\n-        The Peer starts out in a frozen state (ie: attempts to send messages to\n-        it will initially be queued). If init_host is not None then an init\n-        message is sent with the given 'host' field, plus any extra kwargs, and\n-        the queue is thawed. Otherwise, the caller is responsible for sending\n-        the init message and thawing the peer.\n-\n-        In any case, the return value is the init message from the peer.\n-        \"\"\"\n-        assert self.init_future is not None\n-\n-        def _connect_task_done(task: asyncio.Task) -> None:\n-            assert task is connect_task\n-            try:\n-                task.result()\n-            except asyncio.CancelledError:  # we did that (below)\n-                pass                        # we want to ignore it\n-            except Exception as exc:\n-                self.close(exc)\n-\n-        connect_task = asyncio.create_task(self.do_connect_transport())\n-        connect_task.add_done_callback(_connect_task_done)\n-\n-        try:\n-            # Wait for something to happen:\n-            #   - exception from our connection function\n-            #   - receiving \"init\" from the other side\n-            #   - receiving EOF from the other side\n-            #   - .close() was called\n-            #   - other transport exception\n-            init_message = await self.init_future\n-\n-        except (PeerExited, BrokenPipeError):\n-            # These are fairly generic errors. PeerExited means that we observed the process exiting.\n-            # BrokenPipeError means that we got EPIPE when attempting to write() to it. In both cases,\n-            # the process is gone, but it's not clear why. If the connection process is still running,\n-            # perhaps we'd get a better error message from it.\n-            await connect_task\n-            # Otherwise, re-raise\n-            raise\n-\n-        finally:\n-            self.init_future = None\n-\n-            # In any case (failure or success) make sure this is done.\n-            if not connect_task.done():\n-                connect_task.cancel()\n-\n-        if init_host is not None:\n-            logger.debug('  sending init message back, host %s', init_host)\n-            # Send \"init\" back\n-            self.write_control(None, command='init', version=1, host=init_host, **kwargs)\n-\n-            # Thaw the queued messages\n-            self.thaw_endpoint()\n-\n-        return init_message\n-\n-    # Background initialization\n-    def start_in_background(self, init_host: Optional[str] = None, **kwargs: JsonValue) -> None:\n-        def _start_task_done(task: asyncio.Task) -> None:\n-            assert task is start_task\n-\n-            try:\n-                task.result()\n-            except (OSError, PeerExited, CockpitProblem, asyncio.CancelledError):\n-                pass  # Those are expected.  Others will throw.\n-\n-        start_task = asyncio.create_task(self.start(init_host, **kwargs))\n-        start_task.add_done_callback(_start_task_done)\n-\n-    # Shutdown\n-    def add_done_callback(self, callback: Callable[[], None]) -> None:\n-        self.done_callbacks.append(callback)\n-\n-    # Handling of interesting events\n-    def do_superuser_init_done(self) -> None:\n-        pass\n-\n-    def do_authorize(self, message: JsonObject) -> None:\n-        pass\n-\n-    def transport_control_received(self, command: str, message: JsonObject) -> None:\n-        if command == 'init' and self.init_future is not None:\n-            logger.debug('Got init message with active init_future.  Setting result.')\n-            self.init_future.set_result(message)\n-        elif command == 'authorize':\n-            self.do_authorize(message)\n-        elif command == 'superuser-init-done':\n-            self.do_superuser_init_done()\n-        else:\n-            raise CockpitProtocolError(f'Received unexpected control message {command}')\n-\n-    def eof_received(self) -> bool:\n-        # We always expect to be the ones to close the connection, so if we get\n-        # an EOF, then we consider it to be an error.  This allows us to\n-        # distinguish close caused by unexpected EOF (but no errno from a\n-        # syscall failure) vs. close caused by calling .close() on our side.\n-        # The process is still running at this point, so keep it and handle\n-        # the error in process_exited().\n-        logger.debug('Peer %s received unexpected EOF', self.__class__.__name__)\n-        return True\n-\n-    def do_closed(self, exc: Optional[Exception]) -> None:\n-        logger.debug('Peer %s connection lost %s %s', self.__class__.__name__, type(exc), exc)\n-\n-        if exc is None:\n-            self.shutdown_endpoint(problem='terminated')\n-        elif isinstance(exc, PeerExited):\n-            # a common case is that the called peer does not exist\n-            if exc.exit_code == 127:\n-                self.shutdown_endpoint(problem='no-cockpit')\n-            else:\n-                self.shutdown_endpoint(problem='terminated', message=f'Peer exited with status {exc.exit_code}')\n-        elif isinstance(exc, CockpitProblem):\n-            self.shutdown_endpoint(exc.attrs)\n-        else:\n-            self.shutdown_endpoint(problem='internal-error',\n-                                   message=f\"[{exc.__class__.__name__}] {exc!s}\")\n-\n-        # If .start() is running, we need to make sure it stops running,\n-        # raising the correct exception.\n-        if self.init_future is not None and not self.init_future.done():\n-            if exc is not None:\n-                self.init_future.set_exception(exc)\n-            else:\n-                self.init_future.cancel()\n-\n-        for callback in self.done_callbacks:\n-            callback()\n-\n-    def process_exited(self) -> None:\n-        assert isinstance(self.transport, SubprocessTransport)\n-        logger.debug('Peer %s exited, status %d', self.__class__.__name__, self.transport.get_returncode())\n-        returncode = self.transport.get_returncode()\n-        assert isinstance(returncode, int)\n-        self.close(PeerExited(returncode))\n-\n-    # Forwarding data: from the peer to the router\n-    def channel_control_received(self, channel: str, command: str, message: JsonObject) -> None:\n-        if self.init_future is not None:\n-            raise CockpitProtocolError('Received unexpected channel control message before init')\n-        self.send_channel_control(channel, command, message)\n-\n-    def channel_data_received(self, channel: str, data: bytes) -> None:\n-        if self.init_future is not None:\n-            raise CockpitProtocolError('Received unexpected channel data before init')\n-        self.send_channel_data(channel, data)\n-\n-    # Forwarding data: from the router to the peer\n-    def do_channel_control(self, channel: str, command: str, message: JsonObject) -> None:\n-        assert self.init_future is None\n-        self.write_control(message)\n-\n-    def do_channel_data(self, channel: str, data: bytes) -> None:\n-        assert self.init_future is None\n-        self.write_channel_data(channel, data)\n-\n-    def do_kill(self, host: 'str | None', group: 'str | None', message: JsonObject) -> None:\n-        assert self.init_future is None\n-        self.write_control(message)\n-\n-    def do_close(self) -> None:\n-        self.close()\n-\n-\n-class ConfiguredPeer(Peer):\n-    config: BridgeConfig\n-    args: Sequence[str]\n-    env: Sequence[str]\n-\n-    def __init__(self, router: Router, config: BridgeConfig):\n-        self.config = config\n-        self.args = config.spawn\n-        self.env = config.environ\n-        super().__init__(router)\n-\n-    async def do_connect_transport(self) -> None:\n-        await self.spawn(self.args, self.env)\n-\n-\n-class PeerRoutingRule(RoutingRule):\n-    config: BridgeConfig\n-    match: JsonObject\n-    peer: Optional[Peer]\n-\n-    def __init__(self, router: Router, config: BridgeConfig):\n-        super().__init__(router)\n-        self.config = config\n-        self.match = config.match\n-        self.peer = None\n-\n-    def apply_rule(self, options: JsonObject) -> Optional[Peer]:\n-        # Check that we match\n-\n-        for key, value in self.match.items():\n-            if key not in options:\n-                logger.debug('        rejecting because key %s is missing', key)\n-                return None\n-            if value is not None and options[key] != value:\n-                logger.debug('        rejecting because key %s has wrong value %s (vs %s)', key, options[key], value)\n-                return None\n-\n-        # Start the peer if it's not running already\n-        if self.peer is None:\n-            self.peer = ConfiguredPeer(self.router, self.config)\n-            self.peer.add_done_callback(self.peer_closed)\n-            assert self.router.init_host\n-            self.peer.start_in_background(init_host=self.router.init_host)\n-\n-        return self.peer\n-\n-    def peer_closed(self):\n-        self.peer = None\n-\n-    def shutdown(self):\n-        if self.peer is not None:\n-            self.peer.close()\n-\n-\n-class PeersRoutingRule(RoutingRule):\n-    rules: List[PeerRoutingRule] = []\n-\n-    def apply_rule(self, options: JsonObject) -> Optional[Endpoint]:\n-        logger.debug('    considering %d rules', len(self.rules))\n-        for rule in self.rules:\n-            logger.debug('      considering %s', rule.config.name)\n-            endpoint = rule.apply_rule(options)\n-            if endpoint is not None:\n-                logger.debug('        selected')\n-                return endpoint\n-        logger.debug('      no peer rules matched')\n-        return None\n-\n-    def set_configs(self, bridge_configs: Sequence[BridgeConfig]) -> None:\n-        old_rules = self.rules\n-        self.rules = []\n-\n-        for config in bridge_configs:\n-            # Those are handled elsewhere...\n-            if config.privileged or 'host' in config.match:\n-                continue\n-\n-            # Try to reuse an existing rule, if one exists...\n-            for rule in list(old_rules):\n-                if rule.config == config:\n-                    old_rules.remove(rule)\n-                    break\n-            else:\n-                # ... otherwise, create a new one.\n-                rule = PeerRoutingRule(self.router, config)\n-\n-            self.rules.append(rule)\n-\n-        # close down the old rules that didn't get reclaimed\n-        for rule in old_rules:\n-            rule.shutdown()\n-\n-    def shutdown(self):\n-        for rule in self.rules:\n-            rule.shutdown()\n-'''.encode('utf-8'),\n   'cockpit/packages.py': br'''# This file is part of Cockpit.\n #\n # Copyright (C) 2022 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n@@ -2996,1220 +4889,15 @@\n         elif filename == 'manifests.js':\n             return self.load_manifests_js(headers)\n         elif filename == 'manifests.json':\n             return self.load_manifests_json()\n         else:\n             raise KeyError\n ''',\n-  'cockpit/internal_endpoints.py': br'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2022 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import asyncio\n-import glob\n-import grp\n-import json\n-import logging\n-import os\n-import pwd\n-from pathlib import Path\n-from typing import Dict, Optional\n-\n-from cockpit._vendor.systemd_ctypes import Variant, bus, inotify, pathwatch\n-\n-from . import config\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class cockpit_LoginMessages(bus.Object):\n-    messages: Optional[str] = None\n-\n-    def __init__(self):\n-        fdstr = os.environ.pop('COCKPIT_LOGIN_MESSAGES_MEMFD', None)\n-        if fdstr is None:\n-            logger.debug(\"COCKPIT_LOGIN_MESSAGES_MEMFD wasn't set.  No login messages today.\")\n-            return\n-\n-        logger.debug(\"Trying to read login messages from fd %s\", fdstr)\n-        try:\n-            with open(int(fdstr), 'r') as login_messages:\n-                login_messages.seek(0)\n-                self.messages = login_messages.read()\n-        except (ValueError, OSError, UnicodeDecodeError) as exc:\n-            # ValueError - the envvar wasn't an int\n-            # OSError - the fd wasn't open, or other read failure\n-            # UnicodeDecodeError - didn't contain utf-8\n-            # For all of these, we simply failed to get the message.\n-            logger.debug(\"Reading login messages failed: %s\", exc)\n-        else:\n-            logger.debug(\"Successfully read login messages: %s\", self.messages)\n-\n-    @bus.Interface.Method(out_types=['s'])\n-    def get(self):\n-        return self.messages or '{}'\n-\n-    @bus.Interface.Method(out_types=[])\n-    def dismiss(self):\n-        self.messages = None\n-\n-\n-class cockpit_Machines(bus.Object):\n-    path: Path\n-    watch: pathwatch.PathWatch\n-    pending_notify: Optional[asyncio.Handle]\n-\n-    # D-Bus implementation\n-    machines = bus.Interface.Property('a{sa{sv}}')\n-\n-    @machines.getter\n-    def get_machines(self) -> Dict[str, Dict[str, Variant]]:\n-        results: Dict[str, Dict[str, Variant]] = {}\n-\n-        for filename in glob.glob(f'{self.path}/*.json'):\n-            with open(filename) as fp:\n-                try:\n-                    contents = json.load(fp)\n-                except json.JSONDecodeError:\n-                    logger.warning('Invalid JSON in file %s.  Ignoring.', filename)\n-                    continue\n-                # merge\n-                for hostname, attrs in contents.items():\n-                    results[hostname] = {key: Variant(value) for key, value in attrs.items()}\n-\n-        return results\n-\n-    @bus.Interface.Method(in_types=['s', 's', 'a{sv}'])\n-    def update(self, filename: str, hostname: str, attrs: Dict[str, Variant]) -> None:\n-        try:\n-            with self.path.joinpath(filename).open() as fp:\n-                contents = json.load(fp)\n-        except json.JSONDecodeError as exc:\n-            # Refuse to replace corrupted file\n-            raise bus.BusError('cockpit.Machines.Error', f'File {filename} is in invalid format: {exc}.') from exc\n-        except FileNotFoundError:\n-            # But an empty file is an expected case\n-            contents = {}\n-\n-        contents.setdefault(hostname, {}).update({key: value.value for key, value in attrs.items()})\n-\n-        self.path.mkdir(parents=True, exist_ok=True)\n-        with open(self.path.joinpath(filename), 'w') as fp:\n-            json.dump(contents, fp, indent=2)\n-\n-    def notify(self):\n-        def _notify_now():\n-            self.properties_changed('cockpit.Machines', {}, ['Machines'])\n-            self.pending_notify = None\n-\n-        # avoid a flurry of update notifications\n-        if self.pending_notify is None:\n-            self.pending_notify = asyncio.get_running_loop().call_later(1.0, _notify_now)\n-\n-    # inotify events\n-    def do_inotify_event(self, mask: inotify.Event, cookie: int, name: Optional[str]) -> None:\n-        self.notify()\n-\n-    def do_identity_changed(self, fd: Optional[int], errno: Optional[int]) -> None:\n-        self.notify()\n-\n-    def __init__(self):\n-        self.path = config.lookup_config('machines.d')\n-\n-        # ignore the first callback\n-        self.pending_notify = ...\n-        self.watch = pathwatch.PathWatch(str(self.path), self)\n-        self.pending_notify = None\n-\n-\n-class cockpit_User(bus.Object):\n-    name = bus.Interface.Property('s', value='')\n-    full = bus.Interface.Property('s', value='')\n-    id = bus.Interface.Property('i', value=0)\n-    home = bus.Interface.Property('s', value='')\n-    shell = bus.Interface.Property('s', value='')\n-    groups = bus.Interface.Property('as', value=[])\n-\n-    def __init__(self):\n-        user = pwd.getpwuid(os.getuid())\n-        self.name = user.pw_name\n-        self.full = user.pw_gecos\n-        self.id = user.pw_uid\n-        self.home = user.pw_dir\n-        self.shell = user.pw_shell\n-        self.groups = [gr.gr_name for gr in grp.getgrall() if user.pw_name in gr.gr_mem]\n-\n-\n-EXPORTS = [\n-    ('/LoginMessages', cockpit_LoginMessages),\n-    ('/machines', cockpit_Machines),\n-    ('/user', cockpit_User),\n-]\n-''',\n-  'cockpit/__init__.py': br'''from ._version import __version__  # noqa: F401\n-''',\n-  'cockpit/bridge.py': r'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2022 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import argparse\n-import asyncio\n-import contextlib\n-import json\n-import logging\n-import os\n-import pwd\n-import shlex\n-import socket\n-import stat\n-import subprocess\n-from typing import Iterable, List, Optional, Sequence, Tuple, Type\n-\n-from cockpit._vendor.ferny import interaction_client\n-from cockpit._vendor.systemd_ctypes import bus, run_async\n-\n-from . import polyfills\n-from ._version import __version__\n-from .channel import ChannelRoutingRule\n-from .channels import CHANNEL_TYPES\n-from .config import Config, Environment\n-from .internal_endpoints import EXPORTS\n-from .jsonutil import JsonError, JsonObject, get_dict\n-from .packages import BridgeConfig, Packages, PackagesListener\n-from .peer import PeersRoutingRule\n-from .remote import HostRoutingRule\n-from .router import Router\n-from .superuser import SuperuserRoutingRule\n-from .transports import StdioTransport\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class InternalBus:\n-    exportees: List[bus.Slot]\n-\n-    def __init__(self, exports: Iterable[Tuple[str, Type[bus.BaseObject]]]):\n-        client_socket, server_socket = socket.socketpair()\n-        self.client = bus.Bus.new(fd=client_socket.detach())\n-        self.server = bus.Bus.new(fd=server_socket.detach(), server=True)\n-        self.exportees = [self.server.add_object(path, cls()) for path, cls in exports]\n-\n-    def export(self, path: str, obj: bus.BaseObject) -> None:\n-        self.exportees.append(self.server.add_object(path, obj))\n-\n-\n-class Bridge(Router, PackagesListener):\n-    internal_bus: InternalBus\n-    packages: Optional[Packages]\n-    bridge_configs: Sequence[BridgeConfig]\n-    args: argparse.Namespace\n-\n-    def __init__(self, args: argparse.Namespace):\n-        self.internal_bus = InternalBus(EXPORTS)\n-        self.bridge_configs = []\n-        self.args = args\n-\n-        self.superuser_rule = SuperuserRoutingRule(self, privileged=args.privileged)\n-        self.internal_bus.export('/superuser', self.superuser_rule)\n-\n-        self.internal_bus.export('/config', Config())\n-        self.internal_bus.export('/environment', Environment())\n-\n-        self.peers_rule = PeersRoutingRule(self)\n-\n-        if args.beipack:\n-            # Some special stuff for beipack\n-            self.superuser_rule.set_configs((\n-                BridgeConfig({\n-                    \"privileged\": True,\n-                    \"spawn\": [\"sudo\", \"-k\", \"-A\", \"python3\", \"-ic\", \"# cockpit-bridge\", \"--privileged\"],\n-                    \"environ\": [\"SUDO_ASKPASS=ferny-askpass\"],\n-                }),\n-            ))\n-            self.packages = None\n-        elif args.privileged:\n-            self.packages = None\n-        else:\n-            self.packages = Packages(self)\n-            self.internal_bus.export('/packages', self.packages)\n-            self.packages_loaded()\n-\n-        super().__init__([\n-            HostRoutingRule(self),\n-            self.superuser_rule,\n-            ChannelRoutingRule(self, CHANNEL_TYPES),\n-            self.peers_rule,\n-        ])\n-\n-    @staticmethod\n-    def get_os_release():\n-        try:\n-            file = open('/etc/os-release', encoding='utf-8')\n-        except FileNotFoundError:\n-            try:\n-                file = open('/usr/lib/os-release', encoding='utf-8')\n-            except FileNotFoundError:\n-                logger.warning(\"Neither /etc/os-release nor /usr/lib/os-release exists\")\n-                return {}\n-\n-        os_release = {}\n-        for line in file.readlines():\n-            line = line.strip()\n-            if not line or line.startswith('#'):\n-                continue\n-            try:\n-                k, v = line.split('=')\n-                (v_parsed, ) = shlex.split(v)  # expect exactly one token\n-            except ValueError:\n-                logger.warning('Ignoring invalid line in os-release: %r', line)\n-                continue\n-            os_release[k] = v_parsed\n-        return os_release\n-\n-    def do_init(self, message: JsonObject) -> None:\n-        # we're only interested in the case where this is a dict, but\n-        # 'superuser' may well be `False` and that's not an error\n-        with contextlib.suppress(JsonError):\n-            superuser = get_dict(message, 'superuser')\n-            self.superuser_rule.init(superuser)\n-\n-    def do_send_init(self) -> None:\n-        init_args = {\n-            'capabilities': {'explicit-superuser': True},\n-            'command': 'init',\n-            'os-release': self.get_os_release(),\n-            'version': 1,\n-        }\n-\n-        if self.packages is not None:\n-            init_args['packages'] = {p: None for p in self.packages.packages}\n-\n-        self.write_control(init_args)\n-\n-    # PackagesListener interface\n-    def packages_loaded(self) -> None:\n-        assert self.packages\n-        bridge_configs = self.packages.get_bridge_configs()\n-        if self.bridge_configs != bridge_configs:\n-            self.superuser_rule.set_configs(bridge_configs)\n-            self.peers_rule.set_configs(bridge_configs)\n-            self.bridge_configs = bridge_configs\n-\n-\n-async def run(args) -> None:\n-    logger.debug(\"Hi. How are you today?\")\n-\n-    # Unit tests require this\n-    me = pwd.getpwuid(os.getuid())\n-    os.environ['HOME'] = me.pw_dir\n-    os.environ['SHELL'] = me.pw_shell\n-    os.environ['USER'] = me.pw_name\n-\n-    logger.debug('Starting the router.')\n-    router = Bridge(args)\n-    StdioTransport(asyncio.get_running_loop(), router)\n-\n-    logger.debug('Startup done.  Looping until connection closes.')\n-\n-    try:\n-        await router.communicate()\n-    except (BrokenPipeError, ConnectionResetError):\n-        # not unexpected if the peer doesn't hang up cleanly\n-        pass\n-\n-\n-def try_to_receive_stderr():\n-    try:\n-        ours, theirs = socket.socketpair()\n-        with ours:\n-            with theirs:\n-                interaction_client.command(2, 'cockpit.send-stderr', fds=[theirs.fileno()])\n-            _msg, fds, _flags, _addr = socket.recv_fds(ours, 1, 1)\n-    except OSError:\n-        return\n-\n-    try:\n-        stderr_fd, = fds\n-        # We're about to abruptly drop our end of the stderr socketpair that we\n-        # share with the ferny agent.  ferny would normally treat that as an\n-        # unexpected error. Instruct it to do a clean exit, instead.\n-        interaction_client.command(2, 'ferny.end')\n-        os.dup2(stderr_fd, 2)\n-    finally:\n-        for fd in fds:\n-            os.close(fd)\n-\n-\n-def setup_journald() -> bool:\n-    # If stderr is a socket, prefer systemd-journal logging.  This covers the\n-    # case we're already connected to the journal but also the case where we're\n-    # talking to the ferny agent, while leaving logging to file or terminal\n-    # unaffected.\n-    if not stat.S_ISSOCK(os.fstat(2).st_mode):\n-        # not a socket?  Don't redirect.\n-        return False\n-\n-    try:\n-        import systemd.journal  # type: ignore[import]\n-    except ImportError:\n-        # No python3-systemd?  Don't redirect.\n-        return False\n-\n-    logging.root.addHandler(systemd.journal.JournalHandler())\n-    return True\n-\n-\n-def setup_logging(*, debug: bool) -> None:\n-    \"\"\"Setup our logger with optional filtering of modules if COCKPIT_DEBUG env is set\"\"\"\n-\n-    modules = os.getenv('COCKPIT_DEBUG', '')\n-\n-    # Either setup logging via journal or via formatted messages to stderr\n-    if not setup_journald():\n-        logging.basicConfig(format='%(name)s-%(levelname)s: %(message)s')\n-\n-    if debug or modules == 'all':\n-        logging.getLogger().setLevel(level=logging.DEBUG)\n-    elif modules:\n-        for module in modules.split(','):\n-            module = module.strip()\n-            if not module:\n-                continue\n-\n-            logging.getLogger(module).setLevel(logging.DEBUG)\n-\n-\n-def start_ssh_agent() -> None:\n-    # Launch the agent so that it goes down with us on EOF; PDEATHSIG would be more robust,\n-    # but it gets cleared on setgid ssh-agent, which some distros still do\n-    try:\n-        proc = subprocess.Popen(['ssh-agent', 'sh', '-ec', 'echo SSH_AUTH_SOCK=$SSH_AUTH_SOCK; read a'],\n-                                stdin=subprocess.PIPE, stdout=subprocess.PIPE, universal_newlines=True)\n-        assert proc.stdout is not None\n-\n-        # Wait for the agent to write at least one line and look for the\n-        # listener socket.  If we fail to find it, kill the agent \u2014 something\n-        # went wrong.\n-        for token in shlex.shlex(proc.stdout.readline(), punctuation_chars=True):\n-            if token.startswith('SSH_AUTH_SOCK='):\n-                os.environ['SSH_AUTH_SOCK'] = token.replace('SSH_AUTH_SOCK=', '', 1)\n-                break\n-        else:\n-            proc.terminate()\n-            proc.wait()\n-\n-    except FileNotFoundError:\n-        logger.debug(\"Couldn't start ssh-agent (FileNotFoundError)\")\n-\n-    except OSError as exc:\n-        logger.warning(\"Could not start ssh-agent: %s\", exc)\n-\n-\n-def main(*, beipack: bool = False) -> None:\n-    polyfills.install()\n-\n-    parser = argparse.ArgumentParser(description='cockpit-bridge is run automatically inside of a Cockpit session.')\n-    parser.add_argument('--privileged', action='store_true', help='Privileged copy of the bridge')\n-    parser.add_argument('--packages', action='store_true', help='Show Cockpit package information')\n-    parser.add_argument('--bridges', action='store_true', help='Show Cockpit bridges information')\n-    parser.add_argument('--debug', action='store_true', help='Enable debug output (very verbose)')\n-    parser.add_argument('--version', action='store_true', help='Show Cockpit version information')\n-    args = parser.parse_args()\n-\n-    # This is determined by who calls us\n-    args.beipack = beipack\n-\n-    # If we were run with --privileged then our stderr is currently being\n-    # consumed by the main bridge looking for startup-related error messages.\n-    # Let's switch back to the original stderr stream, which has a side-effect\n-    # of indicating that our startup is more or less complete.  Any errors\n-    # after this point will land in the journal.\n-    if args.privileged:\n-        try_to_receive_stderr()\n-\n-    setup_logging(debug=args.debug)\n-\n-    # Special modes\n-    if args.packages:\n-        Packages().show()\n-        return\n-    elif args.version:\n-        print(f'Version: {__version__}\\nProtocol: 1')\n-        return\n-    elif args.bridges:\n-        print(json.dumps([config.__dict__ for config in Packages().get_bridge_configs()], indent=2))\n-        return\n-\n-    # The privileged bridge doesn't need ssh-agent, but the main one does\n-    if 'SSH_AUTH_SOCK' not in os.environ and not args.privileged:\n-        start_ssh_agent()\n-\n-    # asyncio.run() shim for Python 3.6 support\n-    run_async(run(args), debug=args.debug)\n-\n-\n-if __name__ == '__main__':\n-    main()\n-'''.encode('utf-8'),\n-  'cockpit/superuser.py': br'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2022 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import array\n-import asyncio\n-import contextlib\n-import getpass\n-import logging\n-import os\n-import socket\n-from tempfile import TemporaryDirectory\n-from typing import List, Optional, Sequence, Tuple\n-\n-from cockpit._vendor import ferny\n-from cockpit._vendor.bei.bootloader import make_bootloader\n-from cockpit._vendor.systemd_ctypes import Variant, bus\n-\n-from .beipack import BridgeBeibootHelper\n-from .jsonutil import JsonObject, get_str\n-from .packages import BridgeConfig\n-from .peer import ConfiguredPeer, Peer, PeerError\n-from .polkit import PolkitAgent\n-from .router import Router, RoutingError, RoutingRule\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class SuperuserPeer(ConfiguredPeer):\n-    responder: ferny.AskpassHandler\n-\n-    def __init__(self, router: Router, config: BridgeConfig, responder: ferny.AskpassHandler):\n-        super().__init__(router, config)\n-        self.responder = responder\n-\n-    async def do_connect_transport(self) -> None:\n-        async with contextlib.AsyncExitStack() as context:\n-            if 'pkexec' in self.args:\n-                logger.debug('connecting polkit superuser peer transport %r', self.args)\n-                await context.enter_async_context(PolkitAgent(self.responder))\n-            else:\n-                logger.debug('connecting non-polkit superuser peer transport %r', self.args)\n-\n-            responders: 'list[ferny.InteractionHandler]' = [self.responder]\n-\n-            if '# cockpit-bridge' in self.args:\n-                logger.debug('going to beiboot superuser bridge %r', self.args)\n-                helper = BridgeBeibootHelper(self, ['--privileged'])\n-                responders.append(helper)\n-                stage1 = make_bootloader(helper.steps, gadgets=ferny.BEIBOOT_GADGETS).encode()\n-            else:\n-                stage1 = None\n-\n-            agent = ferny.InteractionAgent(responders)\n-\n-            if 'SUDO_ASKPASS=ferny-askpass' in self.env:\n-                tmpdir = context.enter_context(TemporaryDirectory())\n-                ferny_askpass = ferny.write_askpass_to_tmpdir(tmpdir)\n-                env: Sequence[str] = [f'SUDO_ASKPASS={ferny_askpass}']\n-            else:\n-                env = self.env\n-\n-            transport = await self.spawn(self.args, env, stderr=agent, start_new_session=True)\n-\n-            if stage1 is not None:\n-                transport.write(stage1)\n-\n-            try:\n-                await agent.communicate()\n-            except ferny.InteractionError as exc:\n-                raise PeerError('authentication-failed', message=str(exc)) from exc\n-\n-\n-class CockpitResponder(ferny.AskpassHandler):\n-    commands = ('ferny.askpass', 'cockpit.send-stderr')\n-\n-    async def do_custom_command(self, command: str, args: Tuple, fds: List[int], stderr: str) -> None:\n-        if command == 'cockpit.send-stderr':\n-            with socket.socket(fileno=fds[0]) as sock:\n-                fds.pop(0)\n-                # socket.send_fds(sock, [b'\\0'], [2])  # New in Python 3.9\n-                sock.sendmsg([b'\\0'], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, array.array(\"i\", [2]))])\n-\n-\n-class AuthorizeResponder(CockpitResponder):\n-    def __init__(self, router: Router):\n-        self.router = router\n-\n-    async def do_askpass(self, messages: str, prompt: str, hint: str) -> str:\n-        hexuser = ''.join(f'{c:02x}' for c in getpass.getuser().encode('ascii'))\n-        return await self.router.request_authorization(f'plain1:{hexuser}')\n-\n-\n-class SuperuserRoutingRule(RoutingRule, CockpitResponder, bus.Object, interface='cockpit.Superuser'):\n-    superuser_configs: Sequence[BridgeConfig] = ()\n-    pending_prompt: Optional[asyncio.Future]\n-    peer: Optional[SuperuserPeer]\n-\n-    # D-Bus signals\n-    prompt = bus.Interface.Signal('s', 's', 's', 'b', 's')  # message, prompt, default, echo, error\n-\n-    # D-Bus properties\n-    bridges = bus.Interface.Property('as', value=[])\n-    current = bus.Interface.Property('s', value='none')\n-    methods = bus.Interface.Property('a{sv}', value={})\n-\n-    # RoutingRule\n-    def apply_rule(self, options: JsonObject) -> Optional[Peer]:\n-        superuser = options.get('superuser')\n-\n-        if not superuser or self.current == 'root':\n-            # superuser not requested, or already superuser?  Next rule.\n-            return None\n-        elif self.peer or superuser == 'try':\n-            # superuser requested and active?  Return it.\n-            # 'try' requested?  Either return the peer, or None.\n-            return self.peer\n-        else:\n-            # superuser requested, but not active?  That's an error.\n-            raise RoutingError('access-denied')\n-\n-    # ferny.AskpassHandler\n-    async def do_askpass(self, messages: str, prompt: str, hint: str) -> Optional[str]:\n-        assert self.pending_prompt is None\n-        echo = hint == \"confirm\"\n-        self.pending_prompt = asyncio.get_running_loop().create_future()\n-        try:\n-            logger.debug('prompting for %s', prompt)\n-            # with sudo, all stderr messages are treated as warning/errors by the UI\n-            # (such as the lecture or \"wrong password\"), so pass them in the \"error\" field\n-            self.prompt('', prompt, '', echo, messages)\n-            return await self.pending_prompt\n-        finally:\n-            self.pending_prompt = None\n-\n-    def __init__(self, router: Router, *, privileged: bool = False):\n-        super().__init__(router)\n-\n-        self.pending_prompt = None\n-        self.peer = None\n-        self.startup = None\n-\n-        if privileged or os.getuid() == 0:\n-            self.current = 'root'\n-\n-    def peer_done(self):\n-        self.current = 'none'\n-        self.peer = None\n-\n-    async def go(self, name: str, responder: ferny.AskpassHandler) -> None:\n-        if self.current != 'none':\n-            raise bus.BusError('cockpit.Superuser.Error', 'Superuser bridge already running')\n-\n-        assert self.peer is None\n-        assert self.startup is None\n-\n-        for config in self.superuser_configs:\n-            if name in (config.name, 'any'):\n-                break\n-        else:\n-            raise bus.BusError('cockpit.Superuser.Error', f'Unknown superuser bridge type \"{name}\"')\n-\n-        self.current = 'init'\n-        self.peer = SuperuserPeer(self.router, config, responder)\n-        self.peer.add_done_callback(self.peer_done)\n-\n-        try:\n-            await self.peer.start(init_host=self.router.init_host)\n-        except asyncio.CancelledError:\n-            raise bus.BusError('cockpit.Superuser.Error.Cancelled', 'Operation aborted') from None\n-        except (OSError, PeerError) as exc:\n-            raise bus.BusError('cockpit.Superuser.Error', str(exc)) from exc\n-\n-        self.current = self.peer.config.name\n-\n-    def set_configs(self, configs: Sequence[BridgeConfig]):\n-        logger.debug(\"set_configs() with %d items\", len(configs))\n-        configs = [config for config in configs if config.privileged]\n-        self.superuser_configs = tuple(configs)\n-        self.bridges = [config.name for config in self.superuser_configs]\n-        self.methods = {c.label: Variant({'label': Variant(c.label)}, 'a{sv}') for c in configs if c.label}\n-\n-        logger.debug(\"  bridges are now %s\", self.bridges)\n-\n-        # If the currently active bridge config is not in the new set of configs, stop it\n-        if self.peer is not None:\n-            if self.peer.config not in self.superuser_configs:\n-                logger.debug(\"  stopping superuser bridge '%s': it disappeared from configs\", self.peer.config.name)\n-                self.stop()\n-\n-    def cancel_prompt(self):\n-        if self.pending_prompt is not None:\n-            self.pending_prompt.cancel()\n-            self.pending_prompt = None\n-\n-    def shutdown(self):\n-        self.cancel_prompt()\n-\n-        if self.peer is not None:\n-            self.peer.close()\n-\n-        # close() should have disconnected the peer immediately\n-        assert self.peer is None\n-\n-    # Connect-on-startup functionality\n-    def init(self, params: JsonObject) -> None:\n-        name = get_str(params, 'id', 'any')\n-        responder = AuthorizeResponder(self.router)\n-        self._init_task = asyncio.create_task(self.go(name, responder))\n-        self._init_task.add_done_callback(self._init_done)\n-\n-    def _init_done(self, task: 'asyncio.Task[None]') -> None:\n-        logger.debug('superuser init done! %s', task.exception())\n-        self.router.write_control(command='superuser-init-done')\n-        del self._init_task\n-\n-    # D-Bus methods\n-    @bus.Interface.Method(in_types=['s'])\n-    async def start(self, name: str) -> None:\n-        await self.go(name, self)\n-\n-    @bus.Interface.Method()\n-    def stop(self) -> None:\n-        self.shutdown()\n-\n-    @bus.Interface.Method(in_types=['s'])\n-    def answer(self, reply: str) -> None:\n-        if self.pending_prompt is not None:\n-            logger.debug('responding to pending prompt')\n-            self.pending_prompt.set_result(reply)\n-        else:\n-            logger.debug('got Answer, but no prompt pending')\n-''',\n-  'cockpit/protocol.py': br'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2022 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import asyncio\n-import json\n-import logging\n-import uuid\n-\n-from .jsonutil import JsonError, JsonObject, JsonValue, create_object, get_int, get_str, typechecked\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class CockpitProblem(Exception):\n-    \"\"\"A type of exception that carries a problem code and a message.\n-\n-    Depending on the scope, this is used to handle shutting down:\n-\n-      - an individual channel (sends problem code in the close message)\n-      - peer connections (sends problem code in close message for each open channel)\n-      - the main stdio interaction with the bridge\n-\n-    It is usually thrown in response to some violation of expected protocol\n-    when parsing messages, connecting to a peer, or opening a channel.\n-    \"\"\"\n-    attrs: JsonObject\n-\n-    def __init__(self, problem: str, _msg: 'JsonObject | None' = None, **kwargs: JsonValue) -> None:\n-        kwargs['problem'] = problem\n-        self.attrs = create_object(_msg, kwargs)\n-        super().__init__(get_str(self.attrs, 'message', problem))\n-\n-\n-class CockpitProtocolError(CockpitProblem):\n-    def __init__(self, message: str, problem: str = 'protocol-error'):\n-        super().__init__(problem, message=message)\n-\n-\n-class CockpitProtocol(asyncio.Protocol):\n-    \"\"\"A naive implementation of the Cockpit frame protocol\n-\n-    We need to use this because Python's SelectorEventLoop doesn't supported\n-    buffered protocols.\n-    \"\"\"\n-    transport: 'asyncio.Transport | None' = None\n-    buffer = b''\n-    _closed: bool = False\n-    _communication_done: 'asyncio.Future[None] | None' = None\n-\n-    def do_ready(self) -> None:\n-        pass\n-\n-    def do_closed(self, exc: 'Exception | None') -> None:\n-        pass\n-\n-    def transport_control_received(self, command: str, message: JsonObject) -> None:\n-        raise NotImplementedError\n-\n-    def channel_control_received(self, channel: str, command: str, message: JsonObject) -> None:\n-        raise NotImplementedError\n-\n-    def channel_data_received(self, channel: str, data: bytes) -> None:\n-        raise NotImplementedError\n-\n-    def frame_received(self, frame: bytes) -> None:\n-        header, _, data = frame.partition(b'\\n')\n-\n-        if header != b'':\n-            channel = header.decode('ascii')\n-            logger.debug('data received: %d bytes of data for channel %s', len(data), channel)\n-            self.channel_data_received(channel, data)\n-\n-        else:\n-            self.control_received(data)\n-\n-    def control_received(self, data: bytes) -> None:\n-        try:\n-            message = typechecked(json.loads(data), dict)\n-            command = get_str(message, 'command')\n-            channel = get_str(message, 'channel', None)\n-\n-            if channel is not None:\n-                logger.debug('channel control received %s', message)\n-                self.channel_control_received(channel, command, message)\n-            else:\n-                logger.debug('transport control received %s', message)\n-                self.transport_control_received(command, message)\n-\n-        except (json.JSONDecodeError, JsonError) as exc:\n-            raise CockpitProtocolError(f'control message: {exc!s}') from exc\n-\n-    def consume_one_frame(self, data: bytes) -> int:\n-        \"\"\"Consumes a single frame from view.\n-\n-        Returns positive if a number of bytes were consumed, or negative if no\n-        work can be done because of a given number of bytes missing.\n-        \"\"\"\n-\n-        try:\n-            newline = data.index(b'\\n')\n-        except ValueError as exc:\n-            if len(data) < 10:\n-                # Let's try reading more\n-                return len(data) - 10\n-            raise CockpitProtocolError(\"size line is too long\") from exc\n-\n-        try:\n-            length = int(data[:newline])\n-        except ValueError as exc:\n-            raise CockpitProtocolError(\"frame size is not an integer\") from exc\n-\n-        start = newline + 1\n-        end = start + length\n-\n-        if end > len(data):\n-            # We need to read more\n-            return len(data) - end\n-\n-        # We can consume a full frame\n-        self.frame_received(data[start:end])\n-        return end\n-\n-    def connection_made(self, transport: asyncio.BaseTransport) -> None:\n-        logger.debug('connection_made(%s)', transport)\n-        assert isinstance(transport, asyncio.Transport)\n-        self.transport = transport\n-        self.do_ready()\n-\n-        if self._closed:\n-            logger.debug('  but the protocol already was closed, so closing transport')\n-            transport.close()\n-\n-    def connection_lost(self, exc: 'Exception | None') -> None:\n-        logger.debug('connection_lost')\n-        assert self.transport is not None\n-        self.transport = None\n-        self.close(exc)\n-\n-    def close(self, exc: 'Exception | None' = None) -> None:\n-        if self._closed:\n-            return\n-        self._closed = True\n-\n-        if self.transport:\n-            self.transport.close()\n-\n-        self.do_closed(exc)\n-\n-    def write_channel_data(self, channel: str, payload: bytes) -> None:\n-        \"\"\"Send a given payload (bytes) on channel (string)\"\"\"\n-        # Channel is certainly ascii (as enforced by .encode() below)\n-        frame_length = len(channel + '\\n') + len(payload)\n-        header = f'{frame_length}\\n{channel}\\n'.encode('ascii')\n-        if self.transport is not None:\n-            logger.debug('writing to transport %s', self.transport)\n-            self.transport.write(header + payload)\n-        else:\n-            logger.debug('cannot write to closed transport')\n-\n-    def write_control(self, _msg: 'JsonObject | None' = None, **kwargs: JsonValue) -> None:\n-        \"\"\"Write a control message.  See jsonutil.create_object() for details.\"\"\"\n-        logger.debug('sending control message %r %r', _msg, kwargs)\n-        pretty = json.dumps(create_object(_msg, kwargs), indent=2) + '\\n'\n-        self.write_channel_data('', pretty.encode())\n-\n-    def data_received(self, data: bytes) -> None:\n-        try:\n-            self.buffer += data\n-            while self.buffer:\n-                result = self.consume_one_frame(self.buffer)\n-                if result <= 0:\n-                    return\n-                self.buffer = self.buffer[result:]\n-        except CockpitProtocolError as exc:\n-            self.close(exc)\n-\n-    def eof_received(self) -> bool:\n-        return False\n-\n-\n-# Helpful functionality for \"server\"-side protocol implementations\n-class CockpitProtocolServer(CockpitProtocol):\n-    init_host: 'str | None' = None\n-    authorizations: 'dict[str, asyncio.Future[str]] | None' = None\n-\n-    def do_send_init(self) -> None:\n-        raise NotImplementedError\n-\n-    def do_init(self, message: JsonObject) -> None:\n-        pass\n-\n-    def do_kill(self, host: 'str | None', group: 'str | None', message: JsonObject) -> None:\n-        raise NotImplementedError\n-\n-    def transport_control_received(self, command: str, message: JsonObject) -> None:\n-        if command == 'init':\n-            if get_int(message, 'version') != 1:\n-                raise CockpitProtocolError('incorrect version number')\n-            self.init_host = get_str(message, 'host')\n-            self.do_init(message)\n-        elif command == 'kill':\n-            self.do_kill(get_str(message, 'host', None), get_str(message, 'group', None), message)\n-        elif command == 'authorize':\n-            self.do_authorize(message)\n-        else:\n-            raise CockpitProtocolError(f'unexpected control message {command} received')\n-\n-    def do_ready(self) -> None:\n-        self.do_send_init()\n-\n-    # authorize request/response API\n-    async def request_authorization(\n-        self, challenge: str, timeout: 'int | None' = None, **kwargs: JsonValue\n-    ) -> str:\n-        if self.authorizations is None:\n-            self.authorizations = {}\n-        cookie = str(uuid.uuid4())\n-        future = asyncio.get_running_loop().create_future()\n-        try:\n-            self.authorizations[cookie] = future\n-            self.write_control(None, command='authorize', challenge=challenge, cookie=cookie, **kwargs)\n-            return await asyncio.wait_for(future, timeout)\n-        finally:\n-            self.authorizations.pop(cookie)\n-\n-    def do_authorize(self, message: JsonObject) -> None:\n-        cookie = get_str(message, 'cookie')\n-        response = get_str(message, 'response')\n-\n-        if self.authorizations is None or cookie not in self.authorizations:\n-            logger.warning('no matching authorize request')\n-            return\n-\n-        self.authorizations[cookie].set_result(response)\n-''',\n-  'cockpit/remote.py': r'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2022 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import getpass\n-import logging\n-import re\n-import socket\n-from typing import Dict, List, Optional, Tuple\n-\n-from cockpit._vendor import ferny\n-\n-from .jsonutil import JsonObject, JsonValue, get_str, get_str_or_none\n-from .peer import Peer, PeerError\n-from .router import Router, RoutingRule\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class PasswordResponder(ferny.AskpassHandler):\n-    PASSPHRASE_RE = re.compile(r\"Enter passphrase for key '(.*)': \")\n-\n-    password: Optional[str]\n-\n-    hostkeys_seen: List[Tuple[str, str, str, str, str]]\n-    error_message: Optional[str]\n-    password_attempts: int\n-\n-    def __init__(self, password: Optional[str]):\n-        self.password = password\n-\n-        self.hostkeys_seen = []\n-        self.error_message = None\n-        self.password_attempts = 0\n-\n-    async def do_hostkey(self, reason: str, host: str, algorithm: str, key: str, fingerprint: str) -> bool:\n-        self.hostkeys_seen.append((reason, host, algorithm, key, fingerprint))\n-        return False\n-\n-    async def do_askpass(self, messages: str, prompt: str, hint: str) -> Optional[str]:\n-        logger.debug('Got askpass(%s): %s', hint, prompt)\n-\n-        match = PasswordResponder.PASSPHRASE_RE.fullmatch(prompt)\n-        if match is not None:\n-            # We never unlock private keys \u2014 we rather need to throw a\n-            # specially-formatted error message which will cause the frontend\n-            # to load the named key into the agent for us and try again.\n-            path = match.group(1)\n-            logger.debug(\"This is a passphrase request for %s, but we don't do those.  Abort.\", path)\n-            self.error_message = f'locked identity: {path}'\n-            return None\n-\n-        assert self.password is not None\n-        assert self.password_attempts == 0\n-        self.password_attempts += 1\n-        return self.password\n-\n-\n-class SshPeer(Peer):\n-    session: Optional[ferny.Session] = None\n-    host: str\n-    user: Optional[str]\n-    password: Optional[str]\n-    private: bool\n-\n-    async def do_connect_transport(self) -> None:\n-        assert self.session is not None\n-        logger.debug('Starting ssh session user=%s, host=%s, private=%s', self.user, self.host, self.private)\n-\n-        basename, colon, portstr = self.host.rpartition(':')\n-        if colon and portstr.isdigit():\n-            host = basename\n-            port = int(portstr)\n-        else:\n-            host = self.host\n-            port = None\n-\n-        responder = PasswordResponder(self.password)\n-        options = {\"StrictHostKeyChecking\": 'yes'}\n-\n-        if self.password is not None:\n-            options.update(NumberOfPasswordPrompts='1')\n-        else:\n-            options.update(PasswordAuthentication=\"no\", KbdInteractiveAuthentication=\"no\")\n-\n-        try:\n-            await self.session.connect(host, login_name=self.user, port=port,\n-                                       handle_host_key=self.private, options=options,\n-                                       interaction_responder=responder)\n-        except (OSError, socket.gaierror) as exc:\n-            logger.debug('connecting to host %s failed: %s', host, exc)\n-            raise PeerError('no-host', error='no-host', message=str(exc)) from exc\n-\n-        except ferny.SshHostKeyError as exc:\n-            if responder.hostkeys_seen:\n-                # If we saw a hostkey then we can issue a detailed error message\n-                # containing the key that would need to be accepted.  That will\n-                # cause the front-end to present a dialog.\n-                _reason, host, algorithm, key, fingerprint = responder.hostkeys_seen[0]\n-                error_args = {'host-key': f'{host} {algorithm} {key}', 'host-fingerprint': fingerprint}\n-            else:\n-                error_args = {}\n-\n-            if isinstance(exc, ferny.SshChangedHostKeyError):\n-                error = 'invalid-hostkey'\n-            elif self.private:\n-                error = 'unknown-hostkey'\n-            else:\n-                # non-private session case.  throw a generic error.\n-                error = 'unknown-host'\n-\n-            logger.debug('SshPeer got a %s %s; private %s, seen hostkeys %r; raising %s with extra args %r',\n-                         type(exc), exc, self.private, responder.hostkeys_seen, error, error_args)\n-            raise PeerError(error, error_args, error=error, auth_method_results={}) from exc\n-\n-        except ferny.SshAuthenticationError as exc:\n-            logger.debug('authentication to host %s failed: %s', host, exc)\n-\n-            results = {method: 'not-provided' for method in exc.methods}\n-            if 'password' in results and self.password is not None:\n-                if responder.password_attempts == 0:\n-                    results['password'] = 'not-tried'\n-                else:\n-                    results['password'] = 'denied'\n-\n-            raise PeerError('authentication-failed',\n-                            error=responder.error_message or 'authentication-failed',\n-                            auth_method_results=results) from exc\n-\n-        except ferny.SshError as exc:\n-            logger.debug('unknown failure connecting to host %s: %s', host, exc)\n-            raise PeerError('internal-error', message=str(exc)) from exc\n-\n-        args = self.session.wrap_subprocess_args(['cockpit-bridge'])\n-        await self.spawn(args, [])\n-\n-    def do_kill(self, host: 'str | None', group: 'str | None', message: JsonObject) -> None:\n-        if host == self.host:\n-            self.close()\n-        elif host is None:\n-            super().do_kill(host, group, message)\n-\n-    def do_authorize(self, message: JsonObject) -> None:\n-        if get_str(message, 'challenge').startswith('plain1:'):\n-            cookie = get_str(message, 'cookie')\n-            self.write_control(command='authorize', cookie=cookie, response=self.password or '')\n-            self.password = None  # once is enough...\n-\n-    def do_superuser_init_done(self) -> None:\n-        self.password = None\n-\n-    def __init__(self, router: Router, host: str, user: Optional[str], options: JsonObject, *, private: bool) -> None:\n-        super().__init__(router)\n-        self.host = host\n-        self.user = user\n-        self.password = get_str(options, 'password', None)\n-        self.private = private\n-\n-        self.session = ferny.Session()\n-\n-        superuser: JsonValue\n-        init_superuser = get_str_or_none(options, 'init-superuser', None)\n-        if init_superuser in (None, 'none'):\n-            superuser = False\n-        else:\n-            superuser = {'id': init_superuser}\n-\n-        self.start_in_background(init_host=host, superuser=superuser)\n-\n-\n-class HostRoutingRule(RoutingRule):\n-    remotes: Dict[Tuple[str, Optional[str], Optional[str]], Peer]\n-\n-    def __init__(self, router):\n-        super().__init__(router)\n-        self.remotes = {}\n-\n-    def apply_rule(self, options: JsonObject) -> Optional[Peer]:\n-        assert self.router is not None\n-        assert self.router.init_host is not None\n-\n-        host = get_str(options, 'host', self.router.init_host)\n-        if host == self.router.init_host:\n-            return None\n-\n-        user = get_str(options, 'user', None)\n-        # HACK: the front-end relies on this for tracking connections without an explicit user name;\n-        # the user will then be determined by SSH (`User` in the config or the current user)\n-        # See cockpit_router_normalize_host_params() in src/bridge/cockpitrouter.c\n-        if user == getpass.getuser():\n-            user = None\n-        if not user:\n-            user_from_host, _, _ = host.rpartition('@')\n-            user = user_from_host or None  # avoid ''\n-\n-        if get_str(options, 'session', None) == 'private':\n-            nonce = get_str(options, 'channel')\n-        else:\n-            nonce = None\n-\n-        assert isinstance(host, str)\n-        assert user is None or isinstance(user, str)\n-        assert nonce is None or isinstance(nonce, str)\n-\n-        key = host, user, nonce\n-\n-        logger.debug('Request for channel %s is remote.', options)\n-        logger.debug('key=%s', key)\n-\n-        if key not in self.remotes:\n-            logger.debug('%s is not among the existing remotes %s.  Opening a new connection.', key, self.remotes)\n-            peer = SshPeer(self.router, host, user, options, private=nonce is not None)\n-            peer.add_done_callback(lambda: self.remotes.__delitem__(key))\n-            self.remotes[key] = peer\n-\n-        return self.remotes[key]\n-\n-    def shutdown(self):\n-        for peer in set(self.remotes.values()):\n-            peer.close()\n-'''.encode('utf-8'),\n-  'cockpit/transports.py': br'''# This file is part of Cockpit.\n+  'cockpit/channels/trivial.py': br'''# This file is part of Cockpit.\n #\n # Copyright (C) 2022 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n # (at your option) any later version.\n@@ -4218,684 +4906,43 @@\n # but WITHOUT ANY WARRANTY; without even the implied warranty of\n # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n # GNU General Public License for more details.\n #\n # You should have received a copy of the GNU General Public License\n # along with this program.  If not, see <https://www.gnu.org/licenses/>.\n \n-\"\"\"Bi-directional asyncio.Transport implementations based on file descriptors.\"\"\"\n-\n-import asyncio\n-import collections\n-import ctypes\n-import errno\n-import fcntl\n import logging\n-import os\n-import select\n-import signal\n-import struct\n-import subprocess\n-import termios\n-from typing import Any, ClassVar, Sequence\n-\n-from .jsonutil import JsonObject, get_int\n-\n-libc6 = ctypes.cdll.LoadLibrary('libc.so.6')\n-\n-\n-def prctl(*args: int) -> None:\n-    if libc6.prctl(*args) != 0:\n-        raise OSError('prctl() failed')\n-\n-\n-SET_PDEATHSIG = 1\n \n+from ..channel import Channel\n \n logger = logging.getLogger(__name__)\n-IOV_MAX = 1024  # man 2 writev\n-\n-\n-class _Transport(asyncio.Transport):\n-    BLOCK_SIZE: ClassVar[int] = 1024 * 1024\n-\n-    # A transport always has a loop and a protocol\n-    _loop: asyncio.AbstractEventLoop\n-    _protocol: asyncio.Protocol\n-\n-    _queue: 'collections.deque[bytes] | None'\n-    _in_fd: int\n-    _out_fd: int\n-    _closing: bool\n-    _is_reading: bool\n-    _eof: bool\n-    _eio_is_eof: bool = False\n-\n-    def __init__(self,\n-                 loop: asyncio.AbstractEventLoop,\n-                 protocol: asyncio.Protocol,\n-                 in_fd: int = -1, out_fd: int = -1,\n-                 extra: 'dict[str, object] | None' = None):\n-        super().__init__(extra)\n-\n-        self._loop = loop\n-        self._protocol = protocol\n-\n-        logger.debug('Created transport %s for protocol %s, fds %d %d', self, protocol, in_fd, out_fd)\n-\n-        self._queue = None\n-        self._is_reading = False\n-        self._eof = False\n-        self._closing = False\n-\n-        self._in_fd = in_fd\n-        self._out_fd = out_fd\n-\n-        os.set_blocking(in_fd, False)\n-        if out_fd != in_fd:\n-            os.set_blocking(out_fd, False)\n-\n-        self._protocol.connection_made(self)\n-        self.resume_reading()\n-\n-    def _read_ready(self) -> None:\n-        logger.debug('Read ready on %s %s %d', self, self._protocol, self._in_fd)\n-        try:\n-            data = os.read(self._in_fd, _Transport.BLOCK_SIZE)\n-        except BlockingIOError:  # pragma: no cover\n-            return\n-        except OSError as exc:\n-            if self._eio_is_eof and exc.errno == errno.EIO:\n-                # PTY devices return EIO to mean \"EOF\"\n-                data = b''\n-            else:\n-                # Other errors: terminate the connection\n-                self.abort(exc)\n-                return\n-\n-        if data != b'':\n-            logger.debug('  read %d bytes', len(data))\n-            self._protocol.data_received(data)\n-        else:\n-            logger.debug('  got EOF')\n-            self._close_reader()\n-            keep_open = self._protocol.eof_received()\n-            if not keep_open:\n-                self.close()\n-\n-    def is_reading(self) -> bool:\n-        return self._is_reading\n-\n-    def _close_reader(self) -> None:\n-        self.pause_reading()\n-        self._in_fd = -1\n-\n-    def pause_reading(self) -> None:\n-        if self._is_reading:\n-            self._loop.remove_reader(self._in_fd)\n-            self._is_reading = False\n-\n-    def resume_reading(self) -> None:\n-        # It's possible that the Protocol could decide to attempt to unpause\n-        # reading after _close_reader() got called.  Check that the fd is != -1\n-        # before actually resuming.\n-        if not self._is_reading and self._in_fd != -1:\n-            self._loop.add_reader(self._in_fd, self._read_ready)\n-            self._is_reading = True\n-\n-    def _close(self) -> None:\n-        pass\n-\n-    def abort(self, exc: 'Exception | None' = None) -> None:\n-        self._closing = True\n-        self._close_reader()\n-        self._remove_write_queue()\n-        self._protocol.connection_lost(exc)\n-        self._close()\n-\n-    def can_write_eof(self) -> bool:\n-        raise NotImplementedError\n-\n-    def write_eof(self) -> None:\n-        assert not self._eof\n-        self._eof = True\n-        if self._queue is None:\n-            logger.debug('%s got EOF.  closing backend.', self)\n-            self._write_eof_now()\n-        else:\n-            logger.debug('%s got EOF.  bytes in queue, deferring close', self)\n-\n-    def get_write_buffer_size(self) -> int:\n-        if self._queue is None:\n-            return 0\n-        return sum(len(block) for block in self._queue)\n-\n-    def get_write_buffer_limits(self) -> 'tuple[int, int]':\n-        return (0, 0)\n-\n-    def set_write_buffer_limits(self, high: 'int | None' = None, low: 'int | None' = None) -> None:\n-        assert high is None or high == 0\n-        assert low is None or low == 0\n-\n-    def _write_eof_now(self) -> None:\n-        raise NotImplementedError\n-\n-    def _write_ready(self) -> None:\n-        logger.debug('%s _write_ready', self)\n-        assert self._queue is not None\n-\n-        try:\n-            n_bytes = os.writev(self._out_fd, self._queue)\n-        except BlockingIOError:  # pragma: no cover\n-            n_bytes = 0\n-        except OSError as exc:\n-            self.abort(exc)\n-            return\n-\n-        logger.debug('  successfully wrote %d bytes from the queue', n_bytes)\n-\n-        while n_bytes:\n-            block = self._queue.popleft()\n-            if len(block) > n_bytes:\n-                # This block wasn't completely written.\n-                logger.debug('  incomplete block.  Stop.')\n-                self._queue.appendleft(block[n_bytes:])\n-                break\n-            n_bytes -= len(block)\n-            logger.debug('  removed complete block.  %d remains.', n_bytes)\n-\n-        if not self._queue:\n-            logger.debug('%s queue drained.')\n-            self._remove_write_queue()\n-            if self._eof:\n-                logger.debug('%s queue drained.  closing backend now.')\n-                self._write_eof_now()\n-            if self._closing:\n-                self.abort()\n-\n-    def _remove_write_queue(self) -> None:\n-        if self._queue is not None:\n-            self._protocol.resume_writing()\n-            self._loop.remove_writer(self._out_fd)\n-            self._queue = None\n-\n-    def _create_write_queue(self, data: bytes) -> None:\n-        logger.debug('%s creating write queue for fd %s', self, self._out_fd)\n-        assert self._queue is None\n-        self._loop.add_writer(self._out_fd, self._write_ready)\n-        self._queue = collections.deque((data,))\n-        self._protocol.pause_writing()\n-\n-    def write(self, data: bytes) -> None:\n-        # this is a race condition with subprocesses: if we get and process the the \"exited\"\n-        # event before seeing BrokenPipeError, we'll try to write to a closed pipe.\n-        # Do what the standard library does and ignore, instead of assert\n-        if self._closing:\n-            logger.debug('ignoring write() to closing transport fd %i', self._out_fd)\n-            return\n-\n-        assert not self._eof\n-\n-        if self._queue is not None:\n-            self._queue.append(data)\n-\n-            # writev() will complain if the queue is too long.  Consolidate it.\n-            if len(self._queue) > IOV_MAX:\n-                all_data = b''.join(self._queue)\n-                self._queue.clear()\n-                self._queue.append(all_data)\n-\n-            return\n-\n-        try:\n-            n_bytes = os.write(self._out_fd, data)\n-        except BlockingIOError:\n-            n_bytes = 0\n-        except OSError as exc:\n-            self.abort(exc)\n-            return\n-\n-        if n_bytes != len(data):\n-            self._create_write_queue(data[n_bytes:])\n-\n-    def close(self) -> None:\n-        if self._closing:\n-            return\n-\n-        self._closing = True\n-        self._close_reader()\n-\n-        if self._queue is not None:\n-            # abort() will be called from _write_ready() when it's done\n-            return\n-\n-        self.abort()\n-\n-    def get_protocol(self) -> asyncio.BaseProtocol:\n-        return self._protocol\n-\n-    def is_closing(self) -> bool:\n-        return self._closing\n-\n-    def set_protocol(self, protocol: asyncio.BaseProtocol) -> None:\n-        raise NotImplementedError\n-\n-    def __del__(self) -> None:\n-        self._close()\n-\n-\n-class SubprocessProtocol(asyncio.Protocol):\n-    \"\"\"An extension to asyncio.Protocol for use with SubprocessTransport.\"\"\"\n-    def process_exited(self) -> None:\n-        \"\"\"Called when subprocess has exited.\"\"\"\n-        raise NotImplementedError\n-\n-\n-class WindowSize:\n-    def __init__(self, value: JsonObject):\n-        self.rows = get_int(value, 'rows')\n-        self.cols = get_int(value, 'cols')\n-\n-\n-class SubprocessTransport(_Transport, asyncio.SubprocessTransport):\n-    \"\"\"A bi-directional transport speaking with stdin/out of a subprocess.\n-\n-    Note: this is not really a normal SubprocessTransport.  Although it\n-    implements the entire API of asyncio.SubprocessTransport, it is not\n-    designed to be used with asyncio.SubprocessProtocol objects.  Instead, it\n-    pair with normal Protocol objects which also implement the\n-    SubprocessProtocol defined in this module (which only has a\n-    process_exited() method).  Whatever the protocol writes is sent to stdin,\n-    and whatever comes from stdout is given to the Protocol via the\n-    .data_received() function.\n-\n-    If stderr is configured as a pipe, the transport will separately collect\n-    data from it, making it available via the .get_stderr() method.\n-    \"\"\"\n-\n-    _returncode: 'int | None' = None\n-\n-    _pty_fd: 'int | None' = None\n-    _process: 'subprocess.Popen[bytes] | None' = None\n-    _stderr: 'Spooler | None'\n-\n-    @staticmethod\n-    def _create_watcher() -> asyncio.AbstractChildWatcher:\n-        try:\n-            os.close(os.pidfd_open(os.getpid(), 0))  # check for kernel support\n-            return asyncio.PidfdChildWatcher()\n-        except (AttributeError, OSError):\n-            pass\n-\n-        return asyncio.SafeChildWatcher()\n-\n-    @staticmethod\n-    def _get_watcher(loop: asyncio.AbstractEventLoop) -> asyncio.AbstractChildWatcher:\n-        quark = '_cockpit_transports_child_watcher'\n-        watcher = getattr(loop, quark, None)\n-\n-        if watcher is None:\n-            watcher = SubprocessTransport._create_watcher()\n-            watcher.attach_loop(loop)\n-            setattr(loop, quark, watcher)\n-\n-        return watcher\n-\n-    def get_stderr(self, *, reset: bool = False) -> str:\n-        if self._stderr is not None:\n-            return self._stderr.get(reset=reset).decode(errors='replace')\n-        else:\n-            return ''\n-\n-    def _exited(self, pid: int, code: int) -> None:\n-        # NB: per AbstractChildWatcher API, this handler should be thread-safe,\n-        # but we only ever use non-threaded child watcher implementations, so\n-        # we can assume we'll always be called in the main thread.\n-\n-        # NB: the subprocess is going to want to waitpid() itself as well, but\n-        # will get ECHILD since we already reaped it.  Fortunately, since\n-        # Python 3.2 this is supported, and process gets a return status of\n-        # zero.  For that reason, we need to store our own copy of the return\n-        # status.  See https://github.com/python/cpython/issues/59960\n-        assert isinstance(self._protocol, SubprocessProtocol)\n-        assert self._process is not None\n-        assert self._process.pid == pid\n-        self._returncode = code\n-        logger.debug('Process exited with status %d', self._returncode)\n-        if not self._closing:\n-            self._protocol.process_exited()\n-\n-    def __init__(self,\n-                 loop: asyncio.AbstractEventLoop,\n-                 protocol: SubprocessProtocol,\n-                 args: Sequence[str],\n-                 *,\n-                 pty: bool = False,\n-                 window: 'WindowSize | None' = None,\n-                 **kwargs: Any):\n-\n-        # go down as a team -- we don't want any leaked processes when the bridge terminates\n-        def preexec_fn() -> None:\n-            prctl(SET_PDEATHSIG, signal.SIGTERM)\n-            if pty:\n-                fcntl.ioctl(0, termios.TIOCSCTTY, 0)\n-\n-        if pty:\n-            self._pty_fd, session_fd = os.openpty()\n-\n-            if window is not None:\n-                self.set_window_size(window)\n-\n-            kwargs['stderr'] = session_fd\n-            self._process = subprocess.Popen(args,\n-                                             stdin=session_fd, stdout=session_fd,\n-                                             preexec_fn=preexec_fn, start_new_session=True, **kwargs)\n-            os.close(session_fd)\n-\n-            in_fd, out_fd = self._pty_fd, self._pty_fd\n-            self._eio_is_eof = True\n-\n-        else:\n-            self._process = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE,\n-                                             preexec_fn=preexec_fn, **kwargs)\n-            assert self._process.stdin\n-            assert self._process.stdout\n-            in_fd = self._process.stdout.fileno()\n-            out_fd = self._process.stdin.fileno()\n-\n-        if self._process.stderr is not None:\n-            self._stderr = Spooler(loop, self._process.stderr.fileno())\n-        else:\n-            self._stderr = None\n-\n-        super().__init__(loop, protocol, in_fd, out_fd)\n-\n-        self._get_watcher(loop).add_child_handler(self._process.pid, self._exited)\n-\n-    def set_window_size(self, size: WindowSize) -> None:\n-        assert self._pty_fd is not None\n-        fcntl.ioctl(self._pty_fd, termios.TIOCSWINSZ, struct.pack('2H4x', size.rows, size.cols))\n \n-    def can_write_eof(self) -> bool:\n-        assert self._process is not None\n-        return self._process.stdin is not None\n \n-    def _write_eof_now(self) -> None:\n-        assert self._process is not None\n-        assert self._process.stdin is not None\n-        self._process.stdin.close()\n-        self._out_fd = -1\n-\n-    def get_pid(self) -> int:\n-        assert self._process is not None\n-        return self._process.pid\n-\n-    def get_returncode(self) -> 'int | None':\n-        return self._returncode\n-\n-    def get_pipe_transport(self, fd: int) -> asyncio.Transport:\n-        raise NotImplementedError\n-\n-    def send_signal(self, sig: signal.Signals) -> None:  # type: ignore[override] # mypy/issues/13885\n-        assert self._process is not None\n-        # We try to avoid using subprocess.send_signal().  It contains a call\n-        # to waitpid() internally to avoid signalling the wrong process (if a\n-        # PID gets reused), but:\n-        #\n-        #  - we already detect the process exiting via our PidfdChildWatcher\n-        #\n-        #  - the check is actually harmful since collecting the process via\n-        #    waitpid() prevents the PidfdChildWatcher from doing the same,\n-        #    resulting in an error.\n-        #\n-        # It's on us now to check it, but that's easy:\n-        if self._returncode is not None:\n-            logger.debug(\"won't attempt %s to process %i.  It exited already.\", sig, self._process.pid)\n-            return\n-\n-        try:\n-            os.kill(self._process.pid, sig)\n-            logger.debug('sent %s to process %i', sig, self._process.pid)\n-        except ProcessLookupError:\n-            # already gone? fine\n-            logger.debug(\"can't send %s to process %i.  It's exited just now.\", sig, self._process.pid)\n-\n-    def terminate(self) -> None:\n-        self.send_signal(signal.SIGTERM)\n-\n-    def kill(self) -> None:\n-        self.send_signal(signal.SIGKILL)\n-\n-    def _close(self) -> None:\n-        if self._pty_fd is not None:\n-            os.close(self._pty_fd)\n-            self._pty_fd = None\n-\n-        if self._process is not None:\n-            if self._process.stdin is not None:\n-                self._process.stdin.close()\n-                self._process.stdin = None\n-            try:\n-                self.terminate()  # best effort...\n-            except PermissionError:\n-                logger.debug(\"can't kill %i due to EPERM\", self._process.pid)\n-\n-\n-class StdioTransport(_Transport):\n-    \"\"\"A bi-directional transport that corresponds to stdin/out.\n-\n-    Can talk to just about anything:\n-        - files\n-        - pipes\n-        - character devices (including terminals)\n-        - sockets\n-    \"\"\"\n-\n-    def __init__(self, loop: asyncio.AbstractEventLoop, protocol: asyncio.Protocol, stdin: int = 0, stdout: int = 1):\n-        super().__init__(loop, protocol, stdin, stdout)\n-\n-    def can_write_eof(self) -> bool:\n-        return False\n-\n-    def _write_eof_now(self) -> None:\n-        raise RuntimeError(\"Can't write EOF to stdout\")\n-\n-\n-class Spooler:\n-    \"\"\"Consumes data from an fd, storing it in a buffer.\n-\n-    This makes a copy of the fd, so you don't have to worry about holding it\n-    open.\n-    \"\"\"\n-\n-    _loop: asyncio.AbstractEventLoop\n-    _fd: int\n-    _contents: 'list[bytes]'\n-\n-    def __init__(self, loop: asyncio.AbstractEventLoop, fd: int):\n-        self._loop = loop\n-        self._fd = -1  # in case dup() raises an exception\n-        self._contents = []\n-\n-        self._fd = os.dup(fd)\n-\n-        os.set_blocking(self._fd, False)\n-        loop.add_reader(self._fd, self._read_ready)\n-\n-    def _read_ready(self) -> None:\n-        try:\n-            data = os.read(self._fd, 8192)\n-        except BlockingIOError:  # pragma: no cover\n-            return\n-        except OSError:\n-            # all other errors -> EOF\n-            data = b''\n-\n-        if data != b'':\n-            self._contents.append(data)\n-        else:\n-            self.close()\n-\n-    def _is_ready(self) -> bool:\n-        if self._fd == -1:\n-            return False\n-        return select.select([self._fd], [], [], 0) != ([], [], [])\n-\n-    def get(self, *, reset: bool = False) -> bytes:\n-        while self._is_ready():\n-            self._read_ready()\n+class EchoChannel(Channel):\n+    payload = 'echo'\n \n-        result = b''.join(self._contents)\n-        if reset:\n-            self._contents = []\n-        return result\n+    def do_open(self, options):\n+        self.ready()\n \n-    def close(self) -> None:\n-        if self._fd != -1:\n-            self._loop.remove_reader(self._fd)\n-            os.close(self._fd)\n-            self._fd = -1\n+    def do_data(self, data):\n+        self.send_data(data)\n \n-    def __del__(self) -> None:\n+    def do_done(self):\n+        self.done()\n         self.close()\n-''',\n-  'cockpit/beipack.py': br'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2023 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import logging\n-import lzma\n-from typing import List, Sequence, Tuple\n-\n-from cockpit._vendor import ferny\n-from cockpit._vendor.bei import beipack\n-\n-from .data import read_cockpit_data_file\n-from .peer import Peer, PeerError\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-def get_bridge_beipack_xz() -> Tuple[str, bytes]:\n-    try:\n-        bridge_beipack_xz = read_cockpit_data_file('cockpit-bridge.beipack.xz')\n-        logger.debug('Got pre-built cockpit-bridge.beipack.xz')\n-    except FileNotFoundError:\n-        logger.debug('Pre-built cockpit-bridge.beipack.xz; building our own.')\n-        # beipack ourselves\n-        cockpit_contents = beipack.collect_module('cockpit', recursive=True)\n-        bridge_beipack = beipack.pack(cockpit_contents, entrypoint='cockpit.bridge:main', args='beipack=True')\n-        bridge_beipack_xz = lzma.compress(bridge_beipack.encode())\n-        logger.debug('  ... done!')\n-\n-    return 'cockpit/data/cockpit-bridge.beipack.xz', bridge_beipack_xz\n-\n-\n-class BridgeBeibootHelper(ferny.InteractionHandler):\n-    # ferny.InteractionHandler ClassVar\n-    commands = ['beiboot.provide', 'beiboot.exc']\n-\n-    peer: Peer\n-    payload: bytes\n-    steps: Sequence[Tuple[str, Sequence[object]]]\n \n-    def __init__(self, peer: Peer, args: Sequence[str] = ()) -> None:\n-        filename, payload = get_bridge_beipack_xz()\n-\n-        self.peer = peer\n-        self.payload = payload\n-        self.steps = (('boot_xz', (filename, len(payload), tuple(args))),)\n-\n-    async def run_command(self, command: str, args: Tuple, fds: List[int], stderr: str) -> None:\n-        logger.debug('Got ferny request %s %s %s %s', command, args, fds, stderr)\n-        if command == 'beiboot.provide':\n-            try:\n-                size, = args\n-                assert size == len(self.payload)\n-            except (AssertionError, ValueError) as exc:\n-                raise PeerError('internal-error', message=f'ferny interaction error {exc!s}') from exc\n-\n-            assert self.peer.transport is not None\n-            logger.debug('Writing %d bytes of payload', len(self.payload))\n-            self.peer.transport.write(self.payload)\n-        elif command == 'beiboot.exc':\n-            raise PeerError('internal-error', message=f'Remote exception: {args[0]}')\n-        else:\n-            raise PeerError('internal-error', message=f'Unexpected ferny interaction command {command}')\n-''',\n-  'cockpit/polyfills.py': br'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2023 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import contextlib\n-import socket\n-\n-\n-def install():\n-    \"\"\"Add shims for older Python versions\"\"\"\n-\n-    # introduced in 3.9\n-    if not hasattr(socket, 'recv_fds'):\n-        import array\n-\n-        import _socket\n-\n-        def recv_fds(sock, bufsize, maxfds, flags=0):\n-            fds = array.array(\"i\")\n-            msg, ancdata, flags, addr = sock.recvmsg(bufsize, _socket.CMSG_LEN(maxfds * fds.itemsize))\n-            for cmsg_level, cmsg_type, cmsg_data in ancdata:\n-                if (cmsg_level == _socket.SOL_SOCKET and cmsg_type == _socket.SCM_RIGHTS):\n-                    fds.frombytes(cmsg_data[:len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])\n-            return msg, list(fds), flags, addr\n-\n-        socket.recv_fds = recv_fds\n \n-    # introduced in 3.7\n-    if not hasattr(contextlib, 'AsyncExitStack'):\n-        class AsyncExitStack:\n-            async def __aenter__(self):\n-                self.cms = []\n-                return self\n-\n-            async def enter_async_context(self, cm):\n-                result = await cm.__aenter__()\n-                self.cms.append(cm)\n-                return result\n+class NullChannel(Channel):\n+    payload = 'null'\n \n-            async def __aexit__(self, exc_type, exc_value, traceback):\n-                for cm in self.cms:\n-                    cm.__aexit__(exc_type, exc_value, traceback)\n+    def do_open(self, options):\n+        self.ready()\n \n-        contextlib.AsyncExitStack = AsyncExitStack\n+    def do_close(self):\n+        self.close()\n ''',\n   'cockpit/channels/metrics.py': br'''# This file is part of Cockpit.\n #\n # Copyright (C) 2022 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n@@ -5075,163 +5122,14 @@\n             try:\n                 await asyncio.wait_for(self.read(), self.interval / 1000)\n                 return\n             except asyncio.TimeoutError:\n                 # Continue the while loop, we use wait_for as an interval timer.\n                 continue\n ''',\n-  'cockpit/channels/packages.py': br'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2022 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import logging\n-from typing import Optional\n-\n-from ..channel import AsyncChannel\n-from ..data import read_cockpit_data_file\n-from ..jsonutil import JsonObject, get_dict, get_str\n-from ..packages import Packages\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class PackagesChannel(AsyncChannel):\n-    payload = 'http-stream1'\n-    restrictions = [(\"internal\", \"packages\")]\n-\n-    # used to carry data forward from open to done\n-    options: Optional[JsonObject] = None\n-\n-    def http_error(self, status: int, message: str) -> None:\n-        template = read_cockpit_data_file('fail.html')\n-        self.send_json(status=status, reason='ERROR', headers={'Content-Type': 'text/html; charset=utf-8'})\n-        self.send_data(template.replace(b'@@message@@', message.encode('utf-8')))\n-        self.done()\n-        self.close()\n-\n-    async def run(self, options: JsonObject) -> None:\n-        packages: Packages = self.router.packages  # type: ignore[attr-defined]  # yes, this is evil\n-\n-        try:\n-            if get_str(options, 'method') != 'GET':\n-                raise ValueError(f'Unsupported HTTP method {options[\"method\"]}')\n-\n-            self.ready()\n-            if await self.read() != b'':\n-                raise ValueError('Received unexpected data')\n-\n-            path = get_str(options, 'path')\n-            headers = get_dict(options, 'headers')\n-            document = packages.load_path(path, headers)\n-\n-            # Note: we can't cache documents right now.  See\n-            # https://github.com/cockpit-project/cockpit/issues/19071\n-            # for future plans.\n-            out_headers = {\n-                'Cache-Control': 'no-cache, no-store',\n-                'Content-Type': document.content_type,\n-            }\n-\n-            if document.content_encoding is not None:\n-                out_headers['Content-Encoding'] = document.content_encoding\n-\n-            if document.content_security_policy is not None:\n-                policy = document.content_security_policy\n-\n-                # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/connect-src\n-                #\n-                #    Note: connect-src 'self' does not resolve to websocket\n-                #    schemes in all browsers, more info in this issue.\n-                #\n-                # https://github.com/w3c/webappsec-csp/issues/7\n-                if \"connect-src 'self';\" in policy:\n-                    protocol = headers.get('X-Forwarded-Proto')\n-                    host = headers.get('X-Forwarded-Host')\n-                    if not isinstance(protocol, str) or not isinstance(host, str):\n-                        raise ValueError('Invalid host or protocol header')\n-\n-                    websocket_scheme = \"wss\" if protocol == \"https\" else \"ws\"\n-                    websocket_origin = f\"{websocket_scheme}://{host}\"\n-                    policy = policy.replace(\"connect-src 'self';\", f\"connect-src {websocket_origin} 'self';\")\n-\n-                out_headers['Content-Security-Policy'] = policy\n-\n-        except ValueError as exc:\n-            self.http_error(400, str(exc))\n-\n-        except KeyError:\n-            self.http_error(404, 'Not found')\n-\n-        except OSError as exc:\n-            self.http_error(500, f'Internal error: {exc!s}')\n-\n-        else:\n-            self.send_json(status=200, reason='OK', headers=out_headers)\n-            await self.sendfile(document.data)\n-''',\n-  'cockpit/channels/trivial.py': br'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2022 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import logging\n-\n-from ..channel import Channel\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class EchoChannel(Channel):\n-    payload = 'echo'\n-\n-    def do_open(self, options):\n-        self.ready()\n-\n-    def do_data(self, data):\n-        self.send_data(data)\n-\n-    def do_done(self):\n-        self.done()\n-        self.close()\n-\n-\n-class NullChannel(Channel):\n-    payload = 'null'\n-\n-    def do_open(self, options):\n-        self.ready()\n-\n-    def do_close(self):\n-        self.close()\n-''',\n   'cockpit/channels/__init__.py': br'''# This file is part of Cockpit.\n #\n # Copyright (C) 2022 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n@@ -5265,656 +5163,14 @@\n     InternalMetricsChannel,\n     NullChannel,\n     PackagesChannel,\n     SubprocessStreamChannel,\n     SocketStreamChannel,\n ]\n ''',\n-  'cockpit/channels/stream.py': br'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2022 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-import asyncio\n-import logging\n-import os\n-import subprocess\n-from typing import Dict\n-\n-from ..channel import ChannelError, ProtocolChannel\n-from ..jsonutil import JsonDict, JsonObject, get_bool, get_int, get_object, get_str, get_strv\n-from ..transports import SubprocessProtocol, SubprocessTransport, WindowSize\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class SocketStreamChannel(ProtocolChannel):\n-    payload = 'stream'\n-\n-    async def create_transport(self, loop: asyncio.AbstractEventLoop, options: JsonObject) -> asyncio.Transport:\n-        if 'unix' in options and 'port' in options:\n-            raise ChannelError('protocol-error', message='cannot specify both \"port\" and \"unix\" options')\n-\n-        try:\n-            # Unix\n-            if 'unix' in options:\n-                path = get_str(options, 'unix')\n-                label = f'Unix socket {path}'\n-                transport, _ = await loop.create_unix_connection(lambda: self, path)\n-\n-            # TCP\n-            elif 'port' in options:\n-                port = get_int(options, 'port')\n-                host = get_str(options, 'address', 'localhost')\n-                label = f'TCP socket {host}:{port}'\n-\n-                transport, _ = await loop.create_connection(lambda: self, host, port)\n-            else:\n-                raise ChannelError('protocol-error',\n-                                   message='no \"port\" or \"unix\" or other address option for channel')\n-\n-            logger.debug('SocketStreamChannel: connected to %s', label)\n-        except OSError as error:\n-            logger.info('SocketStreamChannel: connecting to %s failed: %s', label, error)\n-            if isinstance(error, ConnectionRefusedError):\n-                problem = 'not-found'\n-            else:\n-                problem = 'terminated'\n-            raise ChannelError(problem, message=str(error)) from error\n-        self.close_on_eof()\n-        assert isinstance(transport, asyncio.Transport)\n-        return transport\n-\n-\n-class SubprocessStreamChannel(ProtocolChannel, SubprocessProtocol):\n-    payload = 'stream'\n-    restrictions = (('spawn', None),)\n-\n-    def process_exited(self) -> None:\n-        self.close_on_eof()\n-\n-    def _get_close_args(self) -> JsonObject:\n-        assert isinstance(self._transport, SubprocessTransport)\n-        args: JsonDict = {'exit-status': self._transport.get_returncode()}\n-        stderr = self._transport.get_stderr()\n-        if stderr is not None:\n-            args['message'] = stderr\n-        return args\n-\n-    def do_options(self, options):\n-        window = get_object(options, 'window', WindowSize, None)\n-        if window is not None:\n-            self._transport.set_window_size(window)\n-\n-    async def create_transport(self, loop: asyncio.AbstractEventLoop, options: JsonObject) -> SubprocessTransport:\n-        args = get_strv(options, 'spawn')\n-        err = get_str(options, 'err', 'msg')\n-        cwd = get_str(options, 'directory', '.')\n-        pty = get_bool(options, 'pty', default=False)\n-        window = get_object(options, 'window', WindowSize, None)\n-        environ = get_strv(options, 'environ', [])\n-\n-        if err == 'out':\n-            stderr = subprocess.STDOUT\n-        elif err == 'ignore':\n-            stderr = subprocess.DEVNULL\n-        else:\n-            stderr = subprocess.PIPE\n-\n-        env: Dict[str, str] = dict(os.environ)\n-        try:\n-            env.update(dict(e.split('=', 1) for e in environ))\n-        except ValueError:\n-            raise ChannelError('protocol-error', message='invalid \"environ\" option for stream channel') from None\n-\n-        try:\n-            transport = SubprocessTransport(loop, self, args, pty=pty, window=window, env=env, cwd=cwd, stderr=stderr)\n-            logger.debug('Spawned process args=%s pid=%i', args, transport.get_pid())\n-            return transport\n-        except FileNotFoundError as error:\n-            raise ChannelError('not-found') from error\n-        except PermissionError as error:\n-            raise ChannelError('access-denied') from error\n-        except OSError as error:\n-            logger.info(\"Failed to spawn %s: %s\", args, str(error))\n-            raise ChannelError('internal-error') from error\n-''',\n-  'cockpit/channels/dbus.py': r'''# This file is part of Cockpit.\n-#\n-# Copyright (C) 2022 Red Hat, Inc.\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n-\n-# Missing stuff compared to the C bridge that we should probably add:\n-#\n-# - removing matches\n-# - removing watches\n-# - emitting of signals\n-# - publishing of objects\n-# - failing more gracefully in some cases (during open, etc)\n-#\n-# Stuff we might or might not do:\n-#\n-# - using non-default service names\n-#\n-# Stuff we should probably not do:\n-#\n-# - emulation of ObjectManager via recursive introspection\n-# - automatic detection of ObjectManager below the given path_namespace\n-# - recursive scraping of properties for new object paths\n-#   (for path_namespace watches that don't hit an ObjectManager)\n-\n-import asyncio\n-import errno\n-import json\n-import logging\n-import traceback\n-import xml.etree.ElementTree as ET\n-\n-from cockpit._vendor import systemd_ctypes\n-from cockpit._vendor.systemd_ctypes import Bus, BusError, introspection\n-\n-from ..channel import Channel, ChannelError\n-\n-logger = logging.getLogger(__name__)\n-\n-# The dbusjson3 payload\n-#\n-# This channel payload type translates JSON encoded messages on a\n-# Cockpit channel to D-Bus messages, in a mostly straightforward way.\n-# See doc/protocol.md for a description of the basics.\n-#\n-# However, dbusjson3 offers some advanced features as well that are\n-# meant to support the \"magic\" DBusProxy objects implemented by\n-# cockpit.js.  Those proxy objects \"magically\" expose all the methods\n-# and properties of a D-Bus interface without requiring any explicit\n-# binding code to be generated for a JavaScript client.  A dbusjson3\n-# channel does this by doing automatic introspection and property\n-# retrieval without much direction from the JavaScript client.\n-#\n-# The details of what exactly is done is not specified very strictly,\n-# and the Python bridge will likely differ from the C bridge\n-# significantly. This will be informed by what existing code actually\n-# needs, and we might end up with a more concrete description of what\n-# a client can actually expect.\n-#\n-# Here is an example of a more complex scenario:\n-#\n-# - The client adds a \"watch\" for a path namespace.  There is a\n-#   ObjectManager at the given path and the bridge emits \"meta\" and\n-#   \"notify\" messages to describe all interfaces and objects reported\n-#   by that ObjectManager.\n-#\n-# - The client makes a method call that causes a new object with a new\n-#   interface to appear at the ObjectManager.  The bridge will send a\n-#   \"meta\" and \"notify\" message to describe this new object.\n-#\n-# - Since the InterfacesAdded signal was emitted before the method\n-#   reply, the bridge must send the \"meta\" and \"notify\" messages\n-#   before the method reply message.\n-#\n-# - However, in order to construct the \"meta\" message, the bridge must\n-#   perform a Introspect call, and consequently must delay sending the\n-#   method reply until that call has finished.\n-#\n-# The Python bridge implements this delaying of messages with\n-# coroutines and a fair mutex. Every message coming from D-Bus will\n-# wait on the mutex for its turn to send its message on the Cockpit\n-# channel, and will keep that mutex locked until it is done with\n-# sending.  Since the mutex is fair, everyone will nicely wait in line\n-# without messages getting re-ordered.\n-#\n-# The scenario above will play out like this:\n-#\n-# - While adding the initial \"watch\", the lock is held until the\n-#   \"meta\" and \"notify\" messages have been sent.\n-#\n-# - Later, when the InterfacesAdded signal comes in that has been\n-#   triggered by the method call, the mutex will be locked while the\n-#   necessary introspection is going on.\n-#\n-# - The method reply will likely come while the mutex is locked, and\n-#   the task for sending that reply on the Cockpit channel will enter\n-#   the wait queue of the mutex.\n-#\n-# - Once the introspection is done and the new \"meta\" and \"notify\"\n-#   messages have been sent, the mutex is unlocked, the method reply\n-#   task acquires it, and sends its message.\n-\n-\n-class InterfaceCache:\n-    def __init__(self):\n-        self.cache = {}\n-        self.old = set()  # Interfaces already returned by get_interface_if_new\n-\n-    def inject(self, interfaces):\n-        self.cache.update(interfaces)\n-\n-    async def introspect_path(self, bus, destination, object_path):\n-        xml, = await bus.call_method_async(destination, object_path,\n-                                           'org.freedesktop.DBus.Introspectable',\n-                                           'Introspect')\n-\n-        et = ET.fromstring(xml)\n-\n-        interfaces = {tag.attrib['name']: introspection.parse_interface(tag) for tag in et.findall('interface')}\n-\n-        # Add all interfaces we found: we might use them later\n-        self.inject(interfaces)\n-\n-        return interfaces\n-\n-    async def get_interface(self, interface_name, bus=None, destination=None, object_path=None):\n-        try:\n-            return self.cache[interface_name]\n-        except KeyError:\n-            pass\n-\n-        if bus and object_path:\n-            try:\n-                await self.introspect_path(bus, destination, object_path)\n-            except BusError:\n-                pass\n-\n-        return self.cache.get(interface_name)\n-\n-    async def get_interface_if_new(self, interface_name, bus, destination, object_path):\n-        if interface_name in self.old:\n-            return None\n-        self.old.add(interface_name)\n-        return await self.get_interface(interface_name, bus, destination, object_path)\n-\n-    async def get_signature(self, interface_name, method, bus=None, destination=None, object_path=None):\n-        interface = await self.get_interface(interface_name, bus, destination, object_path)\n-        if interface is None:\n-            raise KeyError(f'Interface {interface_name} is not found')\n-\n-        return ''.join(interface['methods'][method]['in'])\n-\n-\n-def notify_update(notify, path, interface_name, props):\n-    notify.setdefault(path, {})[interface_name] = {k: v.value for k, v in props.items()}\n-\n-\n-class DBusChannel(Channel):\n-    json_encoder = systemd_ctypes.JSONEncoder(indent=2)\n-    payload = 'dbus-json3'\n-\n-    matches = None\n-    name = None\n-    bus = None\n-    owner = None\n-\n-    async def setup_name_owner_tracking(self):\n-        def send_owner(owner):\n-            # We must be careful not to send duplicate owner\n-            # notifications. cockpit.js relies on that.\n-            if self.owner != owner:\n-                self.owner = owner\n-                self.send_json(owner=owner)\n-\n-        def handler(message):\n-            name, old, new = message.get_body()\n-            send_owner(owner=new if new != \"\" else None)\n-        self.add_signal_handler(handler,\n-                                sender='org.freedesktop.DBus',\n-                                path='/org/freedesktop/DBus',\n-                                interface='org.freedesktop.DBus',\n-                                member='NameOwnerChanged',\n-                                arg0=self.name)\n-        try:\n-            unique_name, = await self.bus.call_method_async(\"org.freedesktop.DBus\",\n-                                                            \"/org/freedesktop/DBus\",\n-                                                            \"org.freedesktop.DBus\",\n-                                                            \"GetNameOwner\", \"s\", self.name)\n-        except BusError as error:\n-            if error.name == \"org.freedesktop.DBus.Error.NameHasNoOwner\":\n-                # Try to start it.  If it starts successfully, we will\n-                # get a NameOwnerChanged signal (which will set\n-                # self.owner) before StartServiceByName returns.\n-                try:\n-                    await self.bus.call_method_async(\"org.freedesktop.DBus\",\n-                                                     \"/org/freedesktop/DBus\",\n-                                                     \"org.freedesktop.DBus\",\n-                                                     \"StartServiceByName\", \"su\", self.name, 0)\n-                except BusError as start_error:\n-                    logger.debug(\"Failed to start service '%s': %s\", self.name, start_error.message)\n-                    self.send_json(owner=None)\n-            else:\n-                logger.debug(\"Failed to get owner of service '%s': %s\", self.name, error.message)\n-        else:\n-            send_owner(unique_name)\n-\n-    def do_open(self, options):\n-        self.cache = InterfaceCache()\n-        self.name = options.get('name')\n-        self.matches = []\n-\n-        bus = options.get('bus')\n-        address = options.get('address')\n-\n-        try:\n-            if address is not None:\n-                if bus is not None and bus != 'none':\n-                    raise ChannelError('protocol-error', message='only one of \"bus\" and \"address\" can be specified')\n-                logger.debug('get bus with address %s for %s', address, self.name)\n-                self.bus = Bus.new(address=address, bus_client=self.name is not None)\n-            elif bus == 'internal':\n-                logger.debug('get internal bus for %s', self.name)\n-                self.bus = self.router.internal_bus.client\n-            else:\n-                if bus == 'session':\n-                    logger.debug('get session bus for %s', self.name)\n-                    self.bus = Bus.default_user()\n-                elif bus == 'system' or bus is None:\n-                    logger.debug('get system bus for %s', self.name)\n-                    self.bus = Bus.default_system()\n-                else:\n-                    raise ChannelError('protocol-error', message=f'invalid bus \"{bus}\"')\n-        except OSError as exc:\n-            raise ChannelError('protocol-error', message=f'failed to connect to {bus} bus: {exc}') from exc\n-\n-        try:\n-            self.bus.attach_event(None, 0)\n-        except OSError as err:\n-            if err.errno != errno.EBUSY:\n-                raise\n-\n-        # This needs to be a fair mutex so that outgoing messages don't\n-        # get re-ordered.  asyncio.Lock is fair.\n-        self.watch_processing_lock = asyncio.Lock()\n-\n-        if self.name is not None:\n-            async def get_ready():\n-                async with self.watch_processing_lock:\n-                    await self.setup_name_owner_tracking()\n-                    if self.owner:\n-                        self.ready(unique_name=self.owner)\n-                    else:\n-                        self.close({'problem': 'not-found'})\n-            self.create_task(get_ready())\n-        else:\n-            self.ready()\n-\n-    def add_signal_handler(self, handler, **kwargs):\n-        r = dict(**kwargs)\n-        r['type'] = 'signal'\n-        if 'sender' not in r and self.name is not None:\n-            r['sender'] = self.name\n-        # HACK - https://github.com/bus1/dbus-broker/issues/309\n-        # path_namespace='/' in a rule does not work.\n-        if r.get('path_namespace') == \"/\":\n-            del r['path_namespace']\n-\n-        def filter_owner(message):\n-            if self.owner is not None and self.owner == message.get_sender():\n-                handler(message)\n-\n-        if self.name is not None and 'sender' in r and r['sender'] == self.name:\n-            func = filter_owner\n-        else:\n-            func = handler\n-        r_string = ','.join(f\"{key}='{value}'\" for key, value in r.items())\n-        if not self.is_closing():\n-            # this gets an EINTR very often especially on RHEL 8\n-            while True:\n-                try:\n-                    match = self.bus.add_match(r_string, func)\n-                    break\n-                except InterruptedError:\n-                    pass\n-\n-            self.matches.append(match)\n-\n-    def add_async_signal_handler(self, handler, **kwargs):\n-        def sync_handler(message):\n-            self.create_task(handler(message))\n-        self.add_signal_handler(sync_handler, **kwargs)\n-\n-    async def do_call(self, message):\n-        path, iface, method, args = message['call']\n-        cookie = message.get('id')\n-        flags = message.get('flags')\n-\n-        timeout = message.get('timeout')\n-        if timeout is not None:\n-            # sd_bus timeout is \u00b5s, cockpit API timeout is ms\n-            timeout *= 1000\n-        else:\n-            # sd_bus has no \"indefinite\" timeout, so use MAX_UINT64\n-            timeout = 2 ** 64 - 1\n-\n-        # We have to figure out the signature of the call.  Either we got told it:\n-        signature = message.get('type')\n-\n-        # ... or there aren't any arguments\n-        if signature is None and len(args) == 0:\n-            signature = ''\n-\n-        # ... or we need to introspect\n-        if signature is None:\n-            try:\n-                logger.debug('Doing introspection request for %s %s', iface, method)\n-                signature = await self.cache.get_signature(iface, method, self.bus, self.name, path)\n-            except BusError as error:\n-                self.send_json(error=[error.name, [f'Introspection: {error.message}']], id=cookie)\n-                return\n-            except KeyError:\n-                self.send_json(\n-                    error=[\n-                        \"org.freedesktop.DBus.Error.UnknownMethod\",\n-                        [f\"Introspection data for method {iface} {method} not available\"]],\n-                    id=cookie)\n-                return\n-            except Exception as exc:\n-                self.send_json(error=['python.error', [f'Introspection: {exc!s}']], id=cookie)\n-                return\n-\n-        try:\n-            method_call = self.bus.message_new_method_call(self.name, path, iface, method, signature, *args)\n-            reply = await self.bus.call_async(method_call, timeout=timeout)\n-            # If the method call has kicked off any signals related to\n-            # watch processing, wait for that to be done.\n-            async with self.watch_processing_lock:\n-                # TODO: stop hard-coding the endian flag here.\n-                self.send_json(\n-                    reply=[reply.get_body()], id=cookie,\n-                    flags=\"<\" if flags is not None else None,\n-                    type=reply.get_signature(True))  # noqa: FBT003\n-        except BusError as error:\n-            # actually, should send the fields from the message body\n-            self.send_json(error=[error.name, [error.message]], id=cookie)\n-        except Exception:\n-            logger.exception(\"do_call(%s): generic exception\", message)\n-            self.send_json(error=['python.error', [traceback.format_exc()]], id=cookie)\n-\n-    async def do_add_match(self, message):\n-        add_match = message['add-match']\n-        logger.debug('adding match %s', add_match)\n-\n-        async def match_hit(message):\n-            logger.debug('got match')\n-            async with self.watch_processing_lock:\n-                self.send_json(signal=[\n-                    message.get_path(),\n-                    message.get_interface(),\n-                    message.get_member(),\n-                    list(message.get_body())\n-                ])\n-\n-        self.add_async_signal_handler(match_hit, **add_match)\n-\n-    async def setup_objectmanager_watch(self, path, interface_name, meta, notify):\n-        # Watch the objects managed by the ObjectManager at \"path\".\n-        # Properties are not watched, that is done by setup_path_watch\n-        # below via recursive_props == True.\n-\n-        async def handler(message):\n-            member = message.get_member()\n-            if member == \"InterfacesAdded\":\n-                (path, interface_props) = message.get_body()\n-                logger.debug('interfaces added %s %s', path, interface_props)\n-                meta = {}\n-                notify = {}\n-                async with self.watch_processing_lock:\n-                    for name, props in interface_props.items():\n-                        if interface_name is None or name == interface_name:\n-                            mm = await self.cache.get_interface_if_new(name, self.bus, self.name, path)\n-                            if mm:\n-                                meta.update({name: mm})\n-                            notify_update(notify, path, name, props)\n-                    self.send_json(meta=meta)\n-                    self.send_json(notify=notify)\n-            elif member == \"InterfacesRemoved\":\n-                (path, interfaces) = message.get_body()\n-                logger.debug('interfaces removed %s %s', path, interfaces)\n-                async with self.watch_processing_lock:\n-                    notify = {path: {name: None for name in interfaces}}\n-                    self.send_json(notify=notify)\n-\n-        self.add_async_signal_handler(handler,\n-                                      path=path,\n-                                      interface=\"org.freedesktop.DBus.ObjectManager\")\n-        objects, = await self.bus.call_method_async(self.name, path,\n-                                                    'org.freedesktop.DBus.ObjectManager',\n-                                                    'GetManagedObjects')\n-        for p, ifaces in objects.items():\n-            for iface, props in ifaces.items():\n-                if interface_name is None or iface == interface_name:\n-                    mm = await self.cache.get_interface_if_new(iface, self.bus, self.name, p)\n-                    if mm:\n-                        meta.update({iface: mm})\n-                    notify_update(notify, p, iface, props)\n-\n-    async def setup_path_watch(self, path, interface_name, recursive_props, meta, notify):\n-        # Watch a single object at \"path\", but maybe also watch for\n-        # property changes for all objects below \"path\".\n-\n-        async def handler(message):\n-            async with self.watch_processing_lock:\n-                path = message.get_path()\n-                name, props, invalids = message.get_body()\n-                logger.debug('NOTIFY: %s %s %s %s', path, name, props, invalids)\n-                for inv in invalids:\n-                    try:\n-                        reply, = await self.bus.call_method_async(self.name, path,\n-                                                                  'org.freedesktop.DBus.Properties', 'Get',\n-                                                                  'ss', name, inv)\n-                    except BusError as exc:\n-                        logger.debug('failed to fetch property %s.%s on %s %s: %s',\n-                                     name, inv, self.name, path, str(exc))\n-                        continue\n-                    props[inv] = reply\n-                notify = {}\n-                notify_update(notify, path, name, props)\n-                self.send_json(notify=notify)\n-\n-        this_meta = await self.cache.introspect_path(self.bus, self.name, path)\n-        if interface_name is not None:\n-            interface = this_meta.get(interface_name)\n-            this_meta = {interface_name: interface}\n-        meta.update(this_meta)\n-        if recursive_props:\n-            self.add_async_signal_handler(handler,\n-                                          interface=\"org.freedesktop.DBus.Properties\",\n-                                          path_namespace=path)\n-        else:\n-            self.add_async_signal_handler(handler,\n-                                          interface=\"org.freedesktop.DBus.Properties\",\n-                                          path=path)\n-\n-        for name in meta:\n-            if name.startswith(\"org.freedesktop.DBus.\"):\n-                continue\n-            try:\n-                props, = await self.bus.call_method_async(self.name, path,\n-                                                          'org.freedesktop.DBus.Properties',\n-                                                          'GetAll', 's', name)\n-                notify_update(notify, path, name, props)\n-            except BusError:\n-                pass\n-\n-    async def do_watch(self, message):\n-        watch = message['watch']\n-        path = watch.get('path')\n-        path_namespace = watch.get('path_namespace')\n-        interface_name = watch.get('interface')\n-        cookie = message.get('id')\n-\n-        path = path or path_namespace\n-        recursive = path == path_namespace\n-\n-        if path is None or cookie is None:\n-            logger.debug('ignored incomplete watch request %s', message)\n-            self.send_json(error=['x.y.z', ['Not Implemented']], id=cookie)\n-            self.send_json(reply=[], id=cookie)\n-            return\n-\n-        try:\n-            async with self.watch_processing_lock:\n-                meta = {}\n-                notify = {}\n-                await self.setup_path_watch(path, interface_name, recursive, meta, notify)\n-                if recursive:\n-                    await self.setup_objectmanager_watch(path, interface_name, meta, notify)\n-                self.send_json(meta=meta)\n-                self.send_json(notify=notify)\n-                self.send_json(reply=[], id=message['id'])\n-        except BusError as error:\n-            logger.debug(\"do_watch(%s) caught D-Bus error: %s\", message, error.message)\n-            self.send_json(error=[error.name, [error.message]], id=cookie)\n-\n-    async def do_meta(self, message):\n-        self.cache.inject(message['meta'])\n-\n-    def do_data(self, data):\n-        message = json.loads(data)\n-        logger.debug('receive dbus request %s %s', self.name, message)\n-\n-        if 'call' in message:\n-            self.create_task(self.do_call(message))\n-        elif 'add-match' in message:\n-            self.create_task(self.do_add_match(message))\n-        elif 'watch' in message:\n-            self.create_task(self.do_watch(message))\n-        elif 'meta' in message:\n-            self.create_task(self.do_meta(message))\n-        else:\n-            logger.debug('ignored dbus request %s', message)\n-            return\n-\n-    def do_close(self):\n-        for slot in self.matches:\n-            slot.cancel()\n-        self.matches = []\n-        self.close()\n-'''.encode('utf-8'),\n   'cockpit/channels/filesystem.py': r'''# This file is part of Cockpit.\n #\n # Copyright (C) 2022 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n@@ -6457,15 +5713,15 @@\n \n         else:\n             # PathWatch will call do_identity_changed(), which does the same as\n             # above: calls either report_initial_state() or report_error(),\n             # depending on if it was provided with an fd or an error code.\n             self.path_watch = PathWatch(self.path, self)\n '''.encode('utf-8'),\n-  'cockpit/channels/http.py': br'''# This file is part of Cockpit.\n+  'cockpit/channels/stream.py': br'''# This file is part of Cockpit.\n #\n # Copyright (C) 2022 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n # (at your option) any later version.\n@@ -6475,1396 +5731,900 @@\n # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n # GNU General Public License for more details.\n #\n # You should have received a copy of the GNU General Public License\n # along with this program.  If not, see <https://www.gnu.org/licenses/>.\n \n import asyncio\n-import http.client\n import logging\n-import socket\n-import ssl\n+import os\n+import subprocess\n+from typing import Dict\n \n-from ..channel import AsyncChannel, ChannelError\n-from ..jsonutil import JsonObject, get_dict, get_int, get_object, get_str, typechecked\n+from ..channel import ChannelError, ProtocolChannel\n+from ..jsonutil import JsonDict, JsonObject, get_bool, get_int, get_object, get_str, get_strv\n+from ..transports import SubprocessProtocol, SubprocessTransport, WindowSize\n \n logger = logging.getLogger(__name__)\n \n \n-class HttpChannel(AsyncChannel):\n-    payload = 'http-stream2'\n-\n-    @staticmethod\n-    def get_headers(response: http.client.HTTPResponse, binary: 'str | None') -> JsonObject:\n-        # Never send these headers\n-        remove = {'Connection', 'Transfer-Encoding'}\n-\n-        if binary != 'raw':\n-            # Only send these headers for raw binary streams\n-            remove.update({'Content-Length', 'Range'})\n-\n-        return {key: value for key, value in response.getheaders() if key not in remove}\n-\n-    @staticmethod\n-    def create_client(options: JsonObject) -> http.client.HTTPConnection:\n-        opt_address = get_str(options, 'address', 'localhost')\n-        opt_tls = get_dict(options, 'tls', None)\n-        opt_unix = get_str(options, 'unix', None)\n-        opt_port = get_int(options, 'port', None)\n+class SocketStreamChannel(ProtocolChannel):\n+    payload = 'stream'\n \n-        if opt_tls is not None and opt_unix is not None:\n-            raise ChannelError('protocol-error', message='TLS on Unix socket is not supported')\n-        if opt_port is None and opt_unix is None:\n-            raise ChannelError('protocol-error', message='no \"port\" or \"unix\" option for channel')\n-        if opt_port is not None and opt_unix is not None:\n+    async def create_transport(self, loop: asyncio.AbstractEventLoop, options: JsonObject) -> asyncio.Transport:\n+        if 'unix' in options and 'port' in options:\n             raise ChannelError('protocol-error', message='cannot specify both \"port\" and \"unix\" options')\n \n-        if opt_tls is not None:\n-            authority = get_dict(opt_tls, 'authority', None)\n-            if authority is not None:\n-                data = get_str(authority, 'data', None)\n-                if data is not None:\n-                    context = ssl.create_default_context(cadata=data)\n-                else:\n-                    context = ssl.create_default_context(cafile=get_str(authority, 'file'))\n-            else:\n-                context = ssl.create_default_context()\n-\n-            if 'validate' in opt_tls and not opt_tls['validate']:\n-                context.check_hostname = False\n-                context.verify_mode = ssl.VerifyMode.CERT_NONE\n-\n-            # See https://github.com/python/typeshed/issues/11057\n-            return http.client.HTTPSConnection(opt_address, port=opt_port, context=context)  # type: ignore[arg-type]\n+        try:\n+            # Unix\n+            if 'unix' in options:\n+                path = get_str(options, 'unix')\n+                label = f'Unix socket {path}'\n+                transport, _ = await loop.create_unix_connection(lambda: self, path)\n \n-        else:\n-            return http.client.HTTPConnection(opt_address, port=opt_port)\n+            # TCP\n+            elif 'port' in options:\n+                port = get_int(options, 'port')\n+                host = get_str(options, 'address', 'localhost')\n+                label = f'TCP socket {host}:{port}'\n \n-    @staticmethod\n-    def connect(connection: http.client.HTTPConnection, opt_unix: 'str | None') -> None:\n-        # Blocks.  Runs in a thread.\n-        if opt_unix:\n-            # create the connection's socket so that it won't call .connect() internally (which only supports TCP)\n-            connection.sock = socket.socket(socket.AF_UNIX)\n-            connection.sock.connect(opt_unix)\n-        else:\n-            # explicitly call connect(), so that we can do proper error handling\n-            connection.connect()\n+                transport, _ = await loop.create_connection(lambda: self, host, port)\n+            else:\n+                raise ChannelError('protocol-error',\n+                                   message='no \"port\" or \"unix\" or other address option for channel')\n \n-    @staticmethod\n-    def request(\n-        connection: http.client.HTTPConnection, method: str, path: str, headers: 'dict[str, str]', body: bytes\n-    ) -> http.client.HTTPResponse:\n-        # Blocks.  Runs in a thread.\n-        connection.request(method, path, headers=headers or {}, body=body)\n-        return connection.getresponse()\n+            logger.debug('SocketStreamChannel: connected to %s', label)\n+        except OSError as error:\n+            logger.info('SocketStreamChannel: connecting to %s failed: %s', label, error)\n+            if isinstance(error, ConnectionRefusedError):\n+                problem = 'not-found'\n+            else:\n+                problem = 'terminated'\n+            raise ChannelError(problem, message=str(error)) from error\n+        self.close_on_eof()\n+        assert isinstance(transport, asyncio.Transport)\n+        return transport\n \n-    async def run(self, options: JsonObject) -> None:\n-        logger.debug('open %s', options)\n \n-        binary = get_str(options, 'binary', None)\n-        method = get_str(options, 'method')\n-        path = get_str(options, 'path')\n-        headers = get_object(options, 'headers', lambda d: {k: typechecked(v, str) for k, v in d.items()}, None)\n+class SubprocessStreamChannel(ProtocolChannel, SubprocessProtocol):\n+    payload = 'stream'\n+    restrictions = (('spawn', None),)\n \n-        if 'connection' in options:\n-            raise ChannelError('protocol-error', message='connection sharing is not implemented on this bridge')\n+    def process_exited(self) -> None:\n+        self.close_on_eof()\n \n-        loop = asyncio.get_running_loop()\n-        connection = self.create_client(options)\n+    def _get_close_args(self) -> JsonObject:\n+        assert isinstance(self._transport, SubprocessTransport)\n+        args: JsonDict = {'exit-status': self._transport.get_returncode()}\n+        stderr = self._transport.get_stderr()\n+        if stderr is not None:\n+            args['message'] = stderr\n+        return args\n \n-        self.ready()\n+    def do_options(self, options):\n+        window = get_object(options, 'window', WindowSize, None)\n+        if window is not None:\n+            self._transport.set_window_size(window)\n \n-        body = b''\n-        while True:\n-            data = await self.read()\n-            if data == b'':\n-                break\n-            body += data\n+    async def create_transport(self, loop: asyncio.AbstractEventLoop, options: JsonObject) -> SubprocessTransport:\n+        args = get_strv(options, 'spawn')\n+        err = get_str(options, 'err', 'msg')\n+        cwd = get_str(options, 'directory', '.')\n+        pty = get_bool(options, 'pty', default=False)\n+        window = get_object(options, 'window', WindowSize, None)\n+        environ = get_strv(options, 'environ', [])\n \n-        # Connect in a thread and handle errors\n-        try:\n-            await loop.run_in_executor(None, self.connect, connection, get_str(options, 'unix', None))\n-        except ssl.SSLCertVerificationError as exc:\n-            raise ChannelError('unknown-hostkey', message=str(exc)) from exc\n-        except (OSError, IOError) as exc:\n-            raise ChannelError('not-found', message=str(exc)) from exc\n+        if err == 'out':\n+            stderr = subprocess.STDOUT\n+        elif err == 'ignore':\n+            stderr = subprocess.DEVNULL\n+        else:\n+            stderr = subprocess.PIPE\n \n-        # Submit request in a thread and handle errors\n+        env: Dict[str, str] = dict(os.environ)\n         try:\n-            response = await loop.run_in_executor(None, self.request, connection, method, path, headers or {}, body)\n-        except (http.client.HTTPException, OSError) as exc:\n-            raise ChannelError('terminated', message=str(exc)) from exc\n-\n-        self.send_control(command='response',\n-                          status=response.status,\n-                          reason=response.reason,\n-                          headers=self.get_headers(response, binary))\n+            env.update(dict(e.split('=', 1) for e in environ))\n+        except ValueError:\n+            raise ChannelError('protocol-error', message='invalid \"environ\" option for stream channel') from None\n \n-        # Receive the body and finish up\n         try:\n-            while True:\n-                block = await loop.run_in_executor(None, response.read1, self.BLOCK_SIZE)\n-                if not block:\n-                    break\n-                await self.write(block)\n-\n-            logger.debug('reading response done')\n-            # this returns immediately and does not read anything more, but updates the http.client's\n-            # internal state machine to \"response done\"\n-            block = response.read()\n-            assert block == b''\n-\n-            await loop.run_in_executor(None, connection.close)\n-        except (http.client.HTTPException, OSError) as exc:\n-            raise ChannelError('terminated', message=str(exc)) from exc\n-\n-        self.done()\n+            transport = SubprocessTransport(loop, self, args, pty=pty, window=window, env=env, cwd=cwd, stderr=stderr)\n+            logger.debug('Spawned process args=%s pid=%i', args, transport.get_pid())\n+            return transport\n+        except FileNotFoundError as error:\n+            raise ChannelError('not-found') from error\n+        except PermissionError as error:\n+            raise ChannelError('access-denied') from error\n+        except OSError as error:\n+            logger.info(\"Failed to spawn %s: %s\", args, str(error))\n+            raise ChannelError('internal-error') from error\n ''',\n-  'cockpit/_vendor/__init__.py': br'''''',\n-  'cockpit/_vendor/systemd_ctypes/introspection.py': br'''# systemd_ctypes\n+  'cockpit/channels/dbus.py': r'''# This file is part of Cockpit.\n #\n-# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+# Copyright (C) 2022 Red Hat, Inc.\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n # (at your option) any later version.\n #\n # This program is distributed in the hope that it will be useful,\n # but WITHOUT ANY WARRANTY; without even the implied warranty of\n # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n # GNU General Public License for more details.\n #\n # You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n-\n-import xml.etree.ElementTree as ET\n-\n-\n-def parse_method(method):\n-    return {\n-        \"in\": [tag.attrib['type'] for tag in method.findall(\"arg\") if tag.get('direction', 'in') == 'in'],\n-        \"out\": [tag.attrib['type'] for tag in method.findall(\"arg[@direction='out']\")]\n-    }\n-\n-\n-def parse_property(prop):\n-    return {\n-        \"flags\": 'w' if prop.attrib.get('access') == 'write' else 'r',\n-        \"type\": prop.attrib['type']\n-    }\n-\n-\n-def parse_signal(signal):\n-    return {\"in\": [tag.attrib['type'] for tag in signal.findall(\"arg\")]}\n-\n-\n-def parse_interface(interface):\n-    return {\n-        \"methods\": {tag.attrib['name']: parse_method(tag) for tag in interface.findall('method')},\n-        \"properties\": {tag.attrib['name']: parse_property(tag) for tag in interface.findall('property')},\n-        \"signals\": {tag.attrib['name']: parse_signal(tag) for tag in interface.findall('signal')}\n-    }\n-\n-\n-def parse_xml(xml):\n-    et = ET.fromstring(xml)\n-    return {tag.attrib['name']: parse_interface(tag) for tag in et.findall('interface')}\n-\n-\n-# Pretend like this is a little bit functional\n-def element(tag, children=(), **kwargs):\n-    tag = ET.Element(tag, kwargs)\n-    tag.extend(children)\n-    return tag\n-\n-\n-def method_to_xml(name, method_info):\n-    return element('method', name=name,\n-                   children=[\n-                       element('arg', type=arg_type, direction=direction)\n-                       for direction in ['in', 'out']\n-                       for arg_type in method_info[direction]\n-                   ])\n-\n-\n-def property_to_xml(name, property_info):\n-    return element('property', name=name,\n-                   access='write' if property_info['flags'] == 'w' else 'read',\n-                   type=property_info['type'])\n-\n-\n-def signal_to_xml(name, signal_info):\n-    return element('signal', name=name,\n-                   children=[\n-                       element('arg', type=arg_type) for arg_type in signal_info['in']\n-                   ])\n-\n-\n-def interface_to_xml(name, interface_info):\n-    return element('interface', name=name,\n-                   children=[\n-                       *(method_to_xml(name, info) for name, info in interface_info['methods'].items()),\n-                       *(property_to_xml(name, info) for name, info in interface_info['properties'].items()),\n-                       *(signal_to_xml(name, info) for name, info in interface_info['signals'].items()),\n-                   ])\n-\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n \n-def to_xml(interfaces):\n-    node = element('node', children=(interface_to_xml(name, members) for name, members in interfaces.items()))\n-    return ET.tostring(node, encoding='unicode')\n-''',\n-  'cockpit/_vendor/systemd_ctypes/event.py': br'''# systemd_ctypes\n+# Missing stuff compared to the C bridge that we should probably add:\n #\n-# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+# - removing matches\n+# - removing watches\n+# - emitting of signals\n+# - publishing of objects\n+# - failing more gracefully in some cases (during open, etc)\n #\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n+# Stuff we might or might not do:\n #\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n+# - using non-default service names\n #\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n+# Stuff we should probably not do:\n+#\n+# - emulation of ObjectManager via recursive introspection\n+# - automatic detection of ObjectManager below the given path_namespace\n+# - recursive scraping of properties for new object paths\n+#   (for path_namespace watches that don't hit an ObjectManager)\n \n import asyncio\n-import selectors\n-import sys\n-from typing import Callable, ClassVar, Coroutine, List, Optional, Tuple\n-\n-from . import inotify, libsystemd\n-from .librarywrapper import Reference, UserData, byref\n-\n-\n-class Event(libsystemd.sd_event):\n-    class Source(libsystemd.sd_event_source):\n-        def cancel(self) -> None:\n-            self._unref()\n-            self.value = None\n-\n-    _default_instance: ClassVar[Optional['Event']] = None\n-\n-    @staticmethod\n-    def default() -> 'Event':\n-        if Event._default_instance is None:\n-            Event._default_instance = Event()\n-            Event._default(byref(Event._default_instance))\n-        return Event._default_instance\n-\n-    InotifyHandler = Callable[[inotify.Event, int, Optional[bytes]], None]\n-\n-    class InotifySource(Source):\n-        def __init__(self, handler: 'Event.InotifyHandler') -> None:\n-            def callback(source: libsystemd.sd_event_source,\n-                         _event: Reference[inotify.inotify_event],\n-                         userdata: UserData) -> int:\n-                event = _event.contents\n-                handler(inotify.Event(event.mask), event.cookie, event.name)\n-                return 0\n-            self.trampoline = libsystemd.sd_event_inotify_handler_t(callback)\n+import errno\n+import json\n+import logging\n+import traceback\n+import xml.etree.ElementTree as ET\n \n-    def add_inotify(self, path: str, mask: inotify.Event, handler: InotifyHandler) -> InotifySource:\n-        source = Event.InotifySource(handler)\n-        self._add_inotify(byref(source), path, mask, source.trampoline, source.userdata)\n-        return source\n+from cockpit._vendor import systemd_ctypes\n+from cockpit._vendor.systemd_ctypes import Bus, BusError, introspection\n \n-    def add_inotify_fd(self, fd: int, mask: inotify.Event, handler: InotifyHandler) -> InotifySource:\n-        # HACK: sd_event_add_inotify_fd() got added in 250, which is too new.  Fake it.\n-        return self.add_inotify(f'/proc/self/fd/{fd}', mask, handler)\n+from ..channel import Channel, ChannelError\n \n+logger = logging.getLogger(__name__)\n \n-# This is all a bit more awkward than it should have to be: systemd's event\n-# loop chaining model is designed for glib's prepare/check/dispatch paradigm;\n-# failing to call prepare() can lead to deadlocks, for example.\n+# The dbusjson3 payload\n #\n-# Hack a selector subclass which calls prepare() before sleeping and this for us.\n-class Selector(selectors.DefaultSelector):\n-    def __init__(self, event: Optional[Event] = None) -> None:\n-        super().__init__()\n-        self.sd_event = event or Event.default()\n-        self.key = self.register(self.sd_event.get_fd(), selectors.EVENT_READ)\n-\n-    def select(\n-            self, timeout: Optional[float] = None\n-    ) -> List[Tuple[selectors.SelectorKey, int]]:\n-        # It's common to drop the last reference to a Source or Slot object on\n-        # a dispatch of that same source/slot from the main loop.  If we happen\n-        # to garbage collect before returning, the trampoline could be\n-        # destroyed before we're done using it.  Provide a mechanism to defer\n-        # the destruction of trampolines for as long as we might be\n-        # dispatching.  This gets cleared again at the bottom, before return.\n-        libsystemd.Trampoline.deferred = []\n-\n-        while self.sd_event.prepare():\n-            self.sd_event.dispatch()\n-        ready = super().select(timeout)\n-        # workaround https://github.com/systemd/systemd/issues/23826\n-        # keep calling wait() until there's nothing left\n-        while self.sd_event.wait(0):\n-            self.sd_event.dispatch()\n-            while self.sd_event.prepare():\n-                self.sd_event.dispatch()\n-\n-        # We can be sure we're not dispatching callbacks anymore\n-        libsystemd.Trampoline.deferred = None\n-\n-        # This could return zero events with infinite timeout, but nobody seems to mind.\n-        return [(key, events) for (key, events) in ready if key != self.key]\n-\n-\n-class EventLoopPolicy(asyncio.DefaultEventLoopPolicy):\n-    def new_event_loop(self) -> asyncio.AbstractEventLoop:\n-        return asyncio.SelectorEventLoop(Selector())\n-\n-\n-def run_async(main: Coroutine[None, None, None], debug: Optional[bool] = None) -> None:\n-    asyncio.set_event_loop_policy(EventLoopPolicy())\n-\n-    polyfill = sys.version_info < (3, 7, 0) and not hasattr(asyncio, 'run')\n-    if polyfill:\n-        # Polyfills for Python 3.6:\n-        loop = asyncio.get_event_loop()\n-\n-        assert not hasattr(asyncio, 'get_running_loop')\n-        asyncio.get_running_loop = lambda: loop\n-\n-        assert not hasattr(asyncio, 'create_task')\n-        asyncio.create_task = loop.create_task\n-\n-        assert not hasattr(asyncio, 'run')\n-\n-        def run(\n-                main: Coroutine[None, None, None], debug: Optional[bool] = None\n-        ) -> None:\n-            if debug is not None:\n-                loop.set_debug(debug)\n-            loop.run_until_complete(main)\n-\n-        asyncio.run = run  # type: ignore[assignment]\n-\n-        asyncio._systemd_ctypes_polyfills = True  # type: ignore[attr-defined]\n-\n-    asyncio.run(main, debug=debug)\n-\n-    if polyfill:\n-        del asyncio.create_task, asyncio.get_running_loop, asyncio.run\n-''',\n-  'cockpit/_vendor/systemd_ctypes/pathwatch.py': br'''# systemd_ctypes\n+# This channel payload type translates JSON encoded messages on a\n+# Cockpit channel to D-Bus messages, in a mostly straightforward way.\n+# See doc/protocol.md for a description of the basics.\n #\n-# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+# However, dbusjson3 offers some advanced features as well that are\n+# meant to support the \"magic\" DBusProxy objects implemented by\n+# cockpit.js.  Those proxy objects \"magically\" expose all the methods\n+# and properties of a D-Bus interface without requiring any explicit\n+# binding code to be generated for a JavaScript client.  A dbusjson3\n+# channel does this by doing automatic introspection and property\n+# retrieval without much direction from the JavaScript client.\n #\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n+# The details of what exactly is done is not specified very strictly,\n+# and the Python bridge will likely differ from the C bridge\n+# significantly. This will be informed by what existing code actually\n+# needs, and we might end up with a more concrete description of what\n+# a client can actually expect.\n #\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n+# Here is an example of a more complex scenario:\n #\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n-\n-import errno\n-import logging\n-import os\n-import stat\n-from typing import Any, List, Optional\n-\n-from .event import Event\n-from .inotify import Event as IN\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-# inotify hard facts:\n+# - The client adds a \"watch\" for a path namespace.  There is a\n+#   ObjectManager at the given path and the bridge emits \"meta\" and\n+#   \"notify\" messages to describe all interfaces and objects reported\n+#   by that ObjectManager.\n #\n-# DELETE_SELF doesn't get called until all references to an inode are gone\n-#   - including open fds\n-#   - including on directories\n+# - The client makes a method call that causes a new object with a new\n+#   interface to appear at the ObjectManager.  The bridge will send a\n+#   \"meta\" and \"notify\" message to describe this new object.\n #\n-# ATTRIB gets called when unlinking files (because the link count changes) but\n-# not on directories.  When unlinking an open directory, no events at all\n-# happen on the directory.  ATTRIB also collects child events, which means we\n-# get a lot of unwanted noise.\n+# - Since the InterfacesAdded signal was emitted before the method\n+#   reply, the bridge must send the \"meta\" and \"notify\" messages\n+#   before the method reply message.\n #\n-# There's nothing like UNLINK_SELF, unfortunately.\n+# - However, in order to construct the \"meta\" message, the bridge must\n+#   perform a Introspect call, and consequently must delay sending the\n+#   method reply until that call has finished.\n #\n-# Even if it was possible to take this approach, it might not work: after\n-# you've opened the fd, it might get deleted before you can establish the watch\n-# on it.\n+# The Python bridge implements this delaying of messages with\n+# coroutines and a fair mutex. Every message coming from D-Bus will\n+# wait on the mutex for its turn to send its message on the Cockpit\n+# channel, and will keep that mutex locked until it is done with\n+# sending.  Since the mutex is fair, everyone will nicely wait in line\n+# without messages getting re-ordered.\n #\n-# Additionally, systemd makes it impossible to register those events on\n-# symlinks (because it removes IN_DONT_FOLLOW in order to watch via\n-# /proc/self/fd).\n+# The scenario above will play out like this:\n #\n-# For all of these reasons, unfortunately, the best way seems to be to watch\n-# for CREATE|DELETE|MOVE events on each intermediate directory.\n+# - While adding the initial \"watch\", the lock is held until the\n+#   \"meta\" and \"notify\" messages have been sent.\n #\n-# Unfortunately there is no way to filter to only the name we're interested in,\n-# so we're gonna get a lot of unnecessary wakeups.\n+# - Later, when the InterfacesAdded signal comes in that has been\n+#   triggered by the method call, the mutex will be locked while the\n+#   necessary introspection is going on.\n #\n-# Also: due to the above-mentioned race about watching after opening the fd,\n-# let's just always watch for both create and delete events *before* trying to\n-# open the fd.  We could try to reduce the mask after the fact, but meh...\n+# - The method reply will likely come while the mutex is locked, and\n+#   the task for sending that reply on the Cockpit channel will enter\n+#   the wait queue of the mutex.\n #\n-# We use a WatchInvalidator utility class to fill the role of \"Tell me when an\n-# event happened on this (directory) fd which impacted the name file\".  We\n-# build a series of these when setting up a watch in order to find out if any\n-# part of the path leading to the monitored file changed.\n-\n-\n-class Handle(int):\n-    \"\"\"An integer subclass that makes it easier to work with file descriptors\"\"\"\n-\n-    def __new__(cls, fd: int = -1) -> 'Handle':\n-        return super(Handle, cls).__new__(cls, fd)\n-\n-    # separate __init__() to set _needs_close mostly to keep pylint quiet\n-    def __init__(self, fd: int = -1):\n-        super().__init__()\n-        self._needs_close = fd != -1\n-\n-    def __bool__(self) -> bool:\n-        return self != -1\n-\n-    def close(self) -> None:\n-        if self._needs_close:\n-            self._needs_close = False\n-            os.close(self)\n-\n-    def __eq__(self, value: object) -> bool:\n-        if int.__eq__(self, value):  # also handles both == -1\n-            return True\n-\n-        if not isinstance(value, int):  # other object is not an int\n-            return False\n-\n-        if not self or not value:  # when only one == -1\n-            return False\n-\n-        return os.path.sameopenfile(self, value)\n-\n-    def __del__(self) -> None:\n-        if self._needs_close:\n-            self.close()\n+# - Once the introspection is done and the new \"meta\" and \"notify\"\n+#   messages have been sent, the mutex is unlocked, the method reply\n+#   task acquires it, and sends its message.\n \n-    def __enter__(self) -> 'Handle':\n-        return self\n \n-    def __exit__(self, _type: type, _value: object, _traceback: object) -> None:\n-        self.close()\n+class InterfaceCache:\n+    def __init__(self):\n+        self.cache = {}\n+        self.old = set()  # Interfaces already returned by get_interface_if_new\n \n-    @classmethod\n-    def open(cls, *args: Any, **kwargs: Any) -> 'Handle':\n-        return cls(os.open(*args, **kwargs))\n+    def inject(self, interfaces):\n+        self.cache.update(interfaces)\n \n-    def steal(self) -> 'Handle':\n-        self._needs_close = False\n-        return self.__class__(int(self))\n+    async def introspect_path(self, bus, destination, object_path):\n+        xml, = await bus.call_method_async(destination, object_path,\n+                                           'org.freedesktop.DBus.Introspectable',\n+                                           'Introspect')\n \n+        et = ET.fromstring(xml)\n \n-class WatchInvalidator:\n-    _name: bytes\n-    _source: Optional[Event.Source]\n-    _watch: Optional['PathWatch']\n+        interfaces = {tag.attrib['name']: introspection.parse_interface(tag) for tag in et.findall('interface')}\n \n-    def event(self, mask: IN, _cookie: int, name: Optional[bytes]) -> None:\n-        logger.debug('invalidator event %s %s', mask, name)\n-        if self._watch is not None:\n-            # If this node itself disappeared, that's definitely an\n-            # invalidation.  Otherwise, the name needs to match.\n-            if IN.IGNORED in mask or self._name == name:\n-                logger.debug('Invalidating!')\n-                self._watch.invalidate()\n+        # Add all interfaces we found: we might use them later\n+        self.inject(interfaces)\n \n-    def __init__(self, watch: 'PathWatch', event: Event, dirfd: int, name: str):\n-        self._watch = watch\n-        self._name = name.encode('utf-8')\n+        return interfaces\n \n-        # establishing invalidation watches is best-effort and can fail for a\n-        # number of reasons, including search (+x) but not read (+r) permission\n-        # on a particular path component, or exceeding limits on watches\n+    async def get_interface(self, interface_name, bus=None, destination=None, object_path=None):\n         try:\n-            mask = IN.CREATE | IN.DELETE | IN.MOVE | IN.DELETE_SELF | IN.IGNORED\n-            self._source = event.add_inotify_fd(dirfd, mask, self.event)\n-        except OSError:\n-            self._source = None\n-\n-    def close(self) -> None:\n-        # This is a little bit tricky: systemd doesn't have a specific close\n-        # API outside of unref, so let's make it as explicit as possible.\n-        self._watch = None\n-        self._source = None\n-\n-\n-class PathStack(List[str]):\n-    def add_path(self, pathname: str) -> None:\n-        # TO DO: consider doing something reasonable with trailing slashes\n-        # this is a stack, popped from the end: push components in reverse\n-        self.extend(item for item in reversed(pathname.split('/')) if item)\n-        if pathname.startswith('/'):\n-            self.append('/')\n+            return self.cache[interface_name]\n+        except KeyError:\n+            pass\n \n-    def __init__(self, path: str):\n-        super().__init__()\n-        self.add_path(path)\n+        if bus and object_path:\n+            try:\n+                await self.introspect_path(bus, destination, object_path)\n+            except BusError:\n+                pass\n \n+        return self.cache.get(interface_name)\n \n-class Listener:\n-    def do_inotify_event(self, mask: IN, cookie: int, name: Optional[bytes]) -> None:\n-        raise NotImplementedError\n+    async def get_interface_if_new(self, interface_name, bus, destination, object_path):\n+        if interface_name in self.old:\n+            return None\n+        self.old.add(interface_name)\n+        return await self.get_interface(interface_name, bus, destination, object_path)\n \n-    def do_identity_changed(self, fd: Optional[Handle], errno: Optional[int]) -> None:\n-        raise NotImplementedError\n+    async def get_signature(self, interface_name, method, bus=None, destination=None, object_path=None):\n+        interface = await self.get_interface(interface_name, bus, destination, object_path)\n+        if interface is None:\n+            raise KeyError(f'Interface {interface_name} is not found')\n \n+        return ''.join(interface['methods'][method]['in'])\n \n-class PathWatch:\n-    _event: Event\n-    _listener: Listener\n-    _path: str\n-    _invalidators: List[WatchInvalidator]\n-    _errno: Optional[int]\n-    _source: Optional[Event.Source]\n-    _tag: Optional[None]\n-    _fd: Handle\n \n-    def __init__(self, path: str, listener: Listener, event: Optional[Event] = None):\n-        self._event = event or Event.default()\n-        self._path = path\n-        self._listener = listener\n+def notify_update(notify, path, interface_name, props):\n+    notify.setdefault(path, {})[interface_name] = {k: v.value for k, v in props.items()}\n \n-        self._invalidators = []\n-        self._errno = None\n-        self._source = None\n-        self._tag = None\n-        self._fd = Handle()\n \n-        self.invalidate()\n+class DBusChannel(Channel):\n+    json_encoder = systemd_ctypes.JSONEncoder(indent=2)\n+    payload = 'dbus-json3'\n \n-    def got_event(self, mask: IN, cookie: int, name: Optional[bytes]) -> None:\n-        logger.debug('target event %s: %s %s %s', self._path, mask, cookie, name)\n-        self._listener.do_inotify_event(mask, cookie, name)\n+    matches = None\n+    name = None\n+    bus = None\n+    owner = None\n \n-    def invalidate(self) -> None:\n-        for invalidator in self._invalidators:\n-            invalidator.close()\n-        self._invalidators = []\n+    async def setup_name_owner_tracking(self):\n+        def send_owner(owner):\n+            # We must be careful not to send duplicate owner\n+            # notifications. cockpit.js relies on that.\n+            if self.owner != owner:\n+                self.owner = owner\n+                self.send_json(owner=owner)\n \n+        def handler(message):\n+            name, old, new = message.get_body()\n+            send_owner(owner=new if new != \"\" else None)\n+        self.add_signal_handler(handler,\n+                                sender='org.freedesktop.DBus',\n+                                path='/org/freedesktop/DBus',\n+                                interface='org.freedesktop.DBus',\n+                                member='NameOwnerChanged',\n+                                arg0=self.name)\n         try:\n-            fd = self.walk()\n-        except OSError as error:\n-            logger.debug('walk ended in error %d', error.errno)\n-\n-            if self._source or self._fd or self._errno != error.errno:\n-                logger.debug('Ending existing watches.')\n-                self._source = None\n-                self._fd.close()\n-                self._fd = Handle()\n-                self._errno = error.errno\n-\n-                logger.debug('Notifying of new error state %d', self._errno)\n-                self._listener.do_identity_changed(None, self._errno)\n-\n-            return\n-\n-        with fd:\n-            logger.debug('walk successful.  Got fd %d', fd)\n-            if fd == self._fd:\n-                logger.debug('fd seems to refer to same file.  Doing nothing.')\n-                return\n-\n-            logger.debug('This file is new for us.  Removing old watch.')\n-            self._source = None\n-            self._fd.close()\n-            self._fd = fd.steal()\n+            unique_name, = await self.bus.call_method_async(\"org.freedesktop.DBus\",\n+                                                            \"/org/freedesktop/DBus\",\n+                                                            \"org.freedesktop.DBus\",\n+                                                            \"GetNameOwner\", \"s\", self.name)\n+        except BusError as error:\n+            if error.name == \"org.freedesktop.DBus.Error.NameHasNoOwner\":\n+                # Try to start it.  If it starts successfully, we will\n+                # get a NameOwnerChanged signal (which will set\n+                # self.owner) before StartServiceByName returns.\n+                try:\n+                    await self.bus.call_method_async(\"org.freedesktop.DBus\",\n+                                                     \"/org/freedesktop/DBus\",\n+                                                     \"org.freedesktop.DBus\",\n+                                                     \"StartServiceByName\", \"su\", self.name, 0)\n+                except BusError as start_error:\n+                    logger.debug(\"Failed to start service '%s': %s\", self.name, start_error.message)\n+                    self.send_json(owner=None)\n+            else:\n+                logger.debug(\"Failed to get owner of service '%s': %s\", self.name, error.message)\n+        else:\n+            send_owner(unique_name)\n \n-            try:\n-                logger.debug('Establishing a new watch.')\n-                self._source = self._event.add_inotify_fd(self._fd, IN.CHANGED, self.got_event)\n-                logger.debug('Watching successfully.  Notifying of new identity.')\n-                self._listener.do_identity_changed(self._fd, None)\n-            except OSError as error:\n-                logger.debug('Watching failed (%d).  Notifying of new identity.', error.errno)\n-                self._listener.do_identity_changed(self._fd, error.errno)\n+    def do_open(self, options):\n+        self.cache = InterfaceCache()\n+        self.name = options.get('name')\n+        self.matches = []\n \n-    def walk(self) -> Handle:\n-        remaining_symlink_lookups = 40\n-        remaining_components = PathStack(self._path)\n-        dirfd = Handle()\n+        bus = options.get('bus')\n+        address = options.get('address')\n \n         try:\n-            logger.debug('Starting path walk')\n-\n-            while remaining_components:\n-                logger.debug('r=%s dfd=%s', remaining_components, dirfd)\n-\n-                name = remaining_components.pop()\n-\n-                if dirfd and name != '/':\n-                    self._invalidators.append(WatchInvalidator(self, self._event, dirfd, name))\n+            if address is not None:\n+                if bus is not None and bus != 'none':\n+                    raise ChannelError('protocol-error', message='only one of \"bus\" and \"address\" can be specified')\n+                logger.debug('get bus with address %s for %s', address, self.name)\n+                self.bus = Bus.new(address=address, bus_client=self.name is not None)\n+            elif bus == 'internal':\n+                logger.debug('get internal bus for %s', self.name)\n+                self.bus = self.router.internal_bus.client\n+            else:\n+                if bus == 'session':\n+                    logger.debug('get session bus for %s', self.name)\n+                    self.bus = Bus.default_user()\n+                elif bus == 'system' or bus is None:\n+                    logger.debug('get system bus for %s', self.name)\n+                    self.bus = Bus.default_system()\n+                else:\n+                    raise ChannelError('protocol-error', message=f'invalid bus \"{bus}\"')\n+        except OSError as exc:\n+            raise ChannelError('protocol-error', message=f'failed to connect to {bus} bus: {exc}') from exc\n \n-                with Handle.open(name, os.O_PATH | os.O_NOFOLLOW | os.O_CLOEXEC, dir_fd=dirfd) as fd:\n-                    mode = os.fstat(fd).st_mode\n+        try:\n+            self.bus.attach_event(None, 0)\n+        except OSError as err:\n+            if err.errno != errno.EBUSY:\n+                raise\n \n-                    if stat.S_ISLNK(mode):\n-                        if remaining_symlink_lookups == 0:\n-                            raise OSError(errno.ELOOP, os.strerror(errno.ELOOP))\n-                        remaining_symlink_lookups -= 1\n-                        linkpath = os.readlink('', dir_fd=fd)\n-                        logger.debug('%s is a symlink.  adding %s to components', name, linkpath)\n-                        remaining_components.add_path(linkpath)\n+        # This needs to be a fair mutex so that outgoing messages don't\n+        # get re-ordered.  asyncio.Lock is fair.\n+        self.watch_processing_lock = asyncio.Lock()\n \n+        if self.name is not None:\n+            async def get_ready():\n+                async with self.watch_processing_lock:\n+                    await self.setup_name_owner_tracking()\n+                    if self.owner:\n+                        self.ready(unique_name=self.owner)\n                     else:\n-                        dirfd.close()\n-                        dirfd = fd.steal()\n-\n-            return dirfd.steal()\n-\n-        finally:\n-            dirfd.close()\n-\n-    def close(self) -> None:\n-        for invalidator in self._invalidators:\n-            invalidator.close()\n-        self._invalidators = []\n-        self._source = None\n-        self._fd.close()\n-''',\n-  'cockpit/_vendor/systemd_ctypes/inotify.py': br'''# systemd_ctypes\n-#\n-# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n-\n-import ctypes\n-from enum import IntFlag, auto\n-from typing import Optional\n-\n-\n-class inotify_event(ctypes.Structure):\n-    _fields_ = (\n-        ('wd', ctypes.c_int32),\n-        ('mask', ctypes.c_uint32),\n-        ('cookie', ctypes.c_uint32),\n-        ('len', ctypes.c_uint32),\n-    )\n-\n-    @property\n-    def name(self) -> Optional[bytes]:\n-        if self.len == 0:\n-            return None\n-\n-        class event_with_name(ctypes.Structure):\n-            _fields_ = (*inotify_event._fields_, ('name', ctypes.c_char * self.len))\n-\n-        name = ctypes.cast(ctypes.addressof(self), ctypes.POINTER(event_with_name)).contents.name\n-        assert isinstance(name, bytes)\n-        return name\n-\n-\n-class Event(IntFlag):\n-    ACCESS = auto()\n-    MODIFY = auto()\n-    ATTRIB = auto()\n-    CLOSE_WRITE = auto()\n-    CLOSE_NOWRITE = auto()\n-    OPEN = auto()\n-    MOVED_FROM = auto()\n-    MOVED_TO = auto()\n-    CREATE = auto()\n-    DELETE = auto()\n-    DELETE_SELF = auto()\n-    MOVE_SELF = auto()\n-\n-    UNMOUNT = 1 << 13\n-    Q_OVERFLOW = auto()\n-    IGNORED = auto()\n-\n-    ONLYDIR = 1 << 24\n-    DONT_FOLLOW = auto()\n-    EXCL_UNLINK = auto()\n-\n-    MASK_CREATE = 1 << 28\n-    MASK_ADD = auto()\n-    ISDIR = auto()\n-    ONESHOT = auto()\n-\n-    CLOSE = CLOSE_WRITE | CLOSE_NOWRITE\n-    MOVE = MOVED_FROM | MOVED_TO\n-    CHANGED = (MODIFY | ATTRIB | CLOSE_WRITE | MOVE |\n-               CREATE | DELETE | DELETE_SELF | MOVE_SELF)\n-''',\n-  'cockpit/_vendor/systemd_ctypes/typing.py': br'''import typing\n-from typing import TYPE_CHECKING\n-\n-# The goal here is to continue to work on Python 3.6 while pretending to have\n-# access to some modern typing features.  The shims provided here are only\n-# enough for what we need for systemd_ctypes to work at runtime.\n-\n-\n-if TYPE_CHECKING:\n-    # See https://github.com/python/mypy/issues/1153 for why we do this separately\n-    from typing import Annotated, ForwardRef, TypeGuard, get_args, get_origin\n-\n-else:\n-    # typing.get_args() and .get_origin() appeared in Python 3.8 but Annotated\n-    # arrived in 3.9.  Unfortunately, it's difficult to implement a mocked up\n-    # version of Annotated which works with the real typing.get_args() and\n-    # .get_origin() in Python 3.8, so we use our own versions there as well.\n-    try:\n-        from typing import Annotated, get_args, get_origin\n-    except ImportError:\n-        class AnnotatedMeta(type):\n-            def __getitem__(cls, params):\n-                class AnnotatedType:\n-                    __origin__ = Annotated\n-                    __args__ = params\n-                return AnnotatedType\n-\n-        class Annotated(metaclass=AnnotatedMeta):\n-            pass\n-\n-        def get_args(annotation: typing.Any) -> typing.Tuple[typing.Any]:\n-            return getattr(annotation, '__args__', ())\n-\n-        def get_origin(annotation: typing.Any) -> typing.Any:\n-            return getattr(annotation, '__origin__', None)\n-\n-    try:\n-        from typing import ForwardRef\n-    except ImportError:\n-        from typing import _ForwardRef as ForwardRef\n-\n-    try:\n-        from typing import TypeGuard\n-    except ImportError:\n-        T = typing.TypeVar('T')\n-\n-        class TypeGuard(typing.Generic[T]):\n-            pass\n-\n-\n-__all__ = (\n-    'Annotated',\n-    'ForwardRef',\n-    'TypeGuard',\n-    'get_args',\n-    'get_origin',\n-    'TYPE_CHECKING',\n-)\n-''',\n-  'cockpit/_vendor/systemd_ctypes/librarywrapper.py': br'''# systemd_ctypes\n-#\n-# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n-\n-import ctypes\n-import inspect\n-import logging\n-import os\n-import sys\n-import types\n-from typing import (\n-    Any,\n-    Callable,\n-    Dict,\n-    Generic,\n-    NewType,\n-    NoReturn,\n-    Optional,\n-    Tuple,\n-    Type,\n-    TypeVar,\n-    Union,\n-)\n-\n-from . import typing\n-\n-# First in 3.10, and conditional import gives type errors\n-NoneType = type(None)\n-\n-logger = logging.getLogger(__name__)\n-\n-if typing.TYPE_CHECKING:\n-    CType = TypeVar(\"CType\", bound=ctypes._CData)\n-    Callback = ctypes._FuncPointer\n-else:\n-    CType = TypeVar(\"CType\")\n-    Callback = ctypes.c_void_p\n-\n-\n-if typing.TYPE_CHECKING:\n-    class Reference(Generic[CType], ctypes._Pointer[CType]):\n-        pass\n-\n-    def byref(x: CType) -> Reference[CType]:\n-        raise NotImplementedError\n-else:\n-    class Reference(Generic[CType]):\n-        pass\n-\n-    byref = ctypes.byref\n-\n-\n-UserData = Optional[ctypes.c_void_p]\n-\n-\n-class negative_errno(ctypes.c_int):\n-    def errcheck(self, func: Callable[..., object], _args: Tuple[object, ...]) -> int:\n-        result = self.value\n-        if result < 0:\n-            raise OSError(-result, f\"{func.__name__}: {os.strerror(-result)}\")\n-        return result\n-\n-\n-class utf8(ctypes.c_char_p):\n-    def errcheck(self, func: Callable[..., object], _args: Tuple[object, ...]) -> str:\n-        assert self.value is not None\n-        return self.value.decode()\n-\n-    @classmethod\n-    def from_param(cls, value: str) -> 'utf8':\n-        return cls(value.encode())\n-\n-\n-class utf8_or_null(ctypes.c_char_p):\n-    def errcheck(self,\n-                 func: Callable[..., object],\n-                 _args: Tuple[object, ...]) -> Optional[str]:\n-        return self.value.decode() if self.value is not None else None\n-\n-    @classmethod\n-    def from_param(cls, value: Optional[str]) -> 'utf8_or_null':\n-        return cls(value.encode() if value is not None else None)\n-\n-\n-class boolint(ctypes.c_int):\n-    def errcheck(self, func: Callable[..., object], _args: Tuple[object, ...]) -> bool:\n-        return bool(self.value)\n-\n-\n-WeakReference = NewType(\"WeakReference\", int)\n-Errno = typing.Annotated[NoReturn, \"errno\"]\n-\n-\n-type_map = {\n-    Union[None, Errno]: negative_errno,  # technically returns int\n-    Union[bool, Errno]: negative_errno,  # technically returns int\n-    Union[int, Errno]: negative_errno,\n-    bool: boolint,\n-    Optional[str]: utf8_or_null,\n-    str: utf8,\n-    int: ctypes.c_int,\n-    WeakReference: ctypes.c_void_p\n-}\n-\n-\n-def map_type(annotation: Any, global_vars: Dict[str, object]) -> Any:\n-    try:\n-        return type_map[annotation]\n-    except KeyError:\n-        pass  # ... and try more cases below\n-\n-    if isinstance(annotation, typing.ForwardRef):\n-        annotation = annotation.__forward_arg__\n-\n-    if isinstance(annotation, str):\n-        annotation = global_vars[annotation]\n-\n-    origin = typing.get_origin(annotation)\n-    args = typing.get_args(annotation)\n-\n-    if origin is Reference:\n-        return ctypes.POINTER(map_type(args[0], global_vars))\n-\n-    elif origin is Union and NoneType in args:\n-        # the C pointer types are already nullable\n-        other_arg, = set(args) - {NoneType}\n-        return map_type(other_arg, global_vars)\n-\n-    elif origin is typing.Annotated:\n-        return args[1]\n-\n-    else:\n-        assert origin is None, origin\n-        return annotation\n-\n-\n-class ReferenceType(ctypes.c_void_p):\n-    @classmethod\n-    def _install_cfuncs(cls, cdll: ctypes.CDLL) -> None:\n-        logger.debug('Installing stubs for %s:', cls)\n-        stubs = tuple(cls.__dict__.items())\n-        for name, stub in stubs:\n-            if name.startswith(\"__\"):\n-                continue\n-            cls._wrap(cdll, stub)\n-\n-        cls._wrap(cdll, cls._ref)\n-        cls._wrap(cdll, cls._unref)\n-\n-    @classmethod\n-    def _wrap(cls, cdll: ctypes.CDLL, stub: object) -> None:\n-        stub_type = type(stub)\n-        if isinstance(stub, staticmethod):\n-            # In older Python versions, staticmethod() isn't considered\n-            # callable, doesn't have a name, and can't be introspected with\n-            # inspect.signature(). Unwrap it.\n-            stub = stub.__func__\n-        assert isinstance(stub, types.FunctionType)\n-        name = stub.__name__\n-        signature = inspect.signature(stub)\n-        stub_globals = sys.modules.get(cls.__module__).__dict__\n+                        self.close({'problem': 'not-found'})\n+            self.create_task(get_ready())\n+        else:\n+            self.ready()\n \n-        func = cdll[f'{cls.__name__}_{name.lstrip(\"_\")}']\n-        func.argtypes = tuple(\n-            map_type(parameter.annotation, stub_globals)\n-            for parameter in signature.parameters.values()\n-        )\n-        func.restype = map_type(signature.return_annotation, stub_globals)\n-        errcheck = getattr(func.restype, 'errcheck', None)\n-        if errcheck is not None:\n-            func.errcheck = errcheck\n+    def add_signal_handler(self, handler, **kwargs):\n+        r = dict(**kwargs)\n+        r['type'] = 'signal'\n+        if 'sender' not in r and self.name is not None:\n+            r['sender'] = self.name\n+        # HACK - https://github.com/bus1/dbus-broker/issues/309\n+        # path_namespace='/' in a rule does not work.\n+        if r.get('path_namespace') == \"/\":\n+            del r['path_namespace']\n \n-        logger.debug('  create wrapper %s.%s%s', cls.__name__, name, signature)\n-        logger.debug('    args %s res %s', func.argtypes, func.restype)\n+        def filter_owner(message):\n+            if self.owner is not None and self.owner == message.get_sender():\n+                handler(message)\n \n-        # ctypes function pointer objects don't implement the usual function\n-        # descriptor logic, which means they won't bind as methods.  For static\n-        # methods, that's good, but for instance methods, we add a wrapper as\n-        # the easiest and most performant way to get the binding behaviour.\n-        if stub_type is not staticmethod:\n-            setattr(cls, name, lambda *args: func(*args))\n+        if self.name is not None and 'sender' in r and r['sender'] == self.name:\n+            func = filter_owner\n         else:\n-            setattr(cls, name, func)\n-\n-    def _unref(self: 'ReferenceType') -> None:\n-        ...\n-\n-    def _ref(self: 'ReferenceType') -> None:\n-        ...\n+            func = handler\n+        r_string = ','.join(f\"{key}='{value}'\" for key, value in r.items())\n+        if not self.is_closing():\n+            # this gets an EINTR very often especially on RHEL 8\n+            while True:\n+                try:\n+                    match = self.bus.add_match(r_string, func)\n+                    break\n+                except InterruptedError:\n+                    pass\n \n-    T = TypeVar(\"T\", bound='ReferenceType')\n+            self.matches.append(match)\n \n-    @classmethod\n-    def ref(cls: Type[T], origin: WeakReference) -> T:\n-        self = cls(origin)\n-        self._ref()\n-        return self\n+    def add_async_signal_handler(self, handler, **kwargs):\n+        def sync_handler(message):\n+            self.create_task(handler(message))\n+        self.add_signal_handler(sync_handler, **kwargs)\n \n-    def __del__(self) -> None:\n-        if self.value is not None:\n-            self._unref()\n-''',\n-  'cockpit/_vendor/systemd_ctypes/__init__.py': br'''# systemd_ctypes\n-#\n-# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n+    async def do_call(self, message):\n+        path, iface, method, args = message['call']\n+        cookie = message.get('id')\n+        flags = message.get('flags')\n \n-\"\"\"systemd_ctypes\"\"\"\n+        timeout = message.get('timeout')\n+        if timeout is not None:\n+            # sd_bus timeout is \u00b5s, cockpit API timeout is ms\n+            timeout *= 1000\n+        else:\n+            # sd_bus has no \"indefinite\" timeout, so use MAX_UINT64\n+            timeout = 2 ** 64 - 1\n \n-__version__ = \"0\"\n+        # We have to figure out the signature of the call.  Either we got told it:\n+        signature = message.get('type')\n \n-from .bus import Bus, BusError, BusMessage\n-from .bustypes import BusType, JSONEncoder, Variant\n-from .event import Event, EventLoopPolicy, run_async\n-from .pathwatch import Handle, PathWatch\n+        # ... or there aren't any arguments\n+        if signature is None and len(args) == 0:\n+            signature = ''\n \n-__all__ = [\n-    \"Bus\",\n-    \"BusError\",\n-    \"BusMessage\",\n-    \"BusType\",\n-    \"Event\",\n-    \"EventLoopPolicy\",\n-    \"Handle\",\n-    \"JSONEncoder\",\n-    \"PathWatch\",\n-    \"Variant\",\n-    \"run_async\",\n-]\n-''',\n-  'cockpit/_vendor/systemd_ctypes/py.typed': br'''''',\n-  'cockpit/_vendor/systemd_ctypes/libsystemd.py': r'''# systemd_ctypes\n-#\n-# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n+        # ... or we need to introspect\n+        if signature is None:\n+            try:\n+                logger.debug('Doing introspection request for %s %s', iface, method)\n+                signature = await self.cache.get_signature(iface, method, self.bus, self.name, path)\n+            except BusError as error:\n+                self.send_json(error=[error.name, [f'Introspection: {error.message}']], id=cookie)\n+                return\n+            except KeyError:\n+                self.send_json(\n+                    error=[\n+                        \"org.freedesktop.DBus.Error.UnknownMethod\",\n+                        [f\"Introspection data for method {iface} {method} not available\"]],\n+                    id=cookie)\n+                return\n+            except Exception as exc:\n+                self.send_json(error=['python.error', [f'Introspection: {exc!s}']], id=cookie)\n+                return\n \n-import ctypes\n-import os\n-import sys\n-from typing import ClassVar, List, Optional, Tuple, Union\n+        try:\n+            method_call = self.bus.message_new_method_call(self.name, path, iface, method, signature, *args)\n+            reply = await self.bus.call_async(method_call, timeout=timeout)\n+            # If the method call has kicked off any signals related to\n+            # watch processing, wait for that to be done.\n+            async with self.watch_processing_lock:\n+                # TODO: stop hard-coding the endian flag here.\n+                self.send_json(\n+                    reply=[reply.get_body()], id=cookie,\n+                    flags=\"<\" if flags is not None else None,\n+                    type=reply.get_signature(True))  # noqa: FBT003\n+        except BusError as error:\n+            # actually, should send the fields from the message body\n+            self.send_json(error=[error.name, [error.message]], id=cookie)\n+        except Exception:\n+            logger.exception(\"do_call(%s): generic exception\", message)\n+            self.send_json(error=['python.error', [traceback.format_exc()]], id=cookie)\n \n-from .inotify import inotify_event\n-from .librarywrapper import (\n-    Callback,\n-    Errno,\n-    Reference,\n-    ReferenceType,\n-    UserData,\n-    WeakReference,\n-    byref,\n-)\n-from .typing import Annotated\n+    async def do_add_match(self, message):\n+        add_match = message['add-match']\n+        logger.debug('adding match %s', add_match)\n \n+        async def match_hit(message):\n+            logger.debug('got match')\n+            async with self.watch_processing_lock:\n+                self.send_json(signal=[\n+                    message.get_path(),\n+                    message.get_interface(),\n+                    message.get_member(),\n+                    list(message.get_body())\n+                ])\n \n-class Trampoline(ReferenceType):\n-    deferred: 'ClassVar[list[Callback] | None]' = None\n-    trampoline: Callback\n-    userdata: UserData = None\n+        self.add_async_signal_handler(match_hit, **add_match)\n \n-    def cancel(self) -> None:\n-        self._unref()\n-        self.value = None\n+    async def setup_objectmanager_watch(self, path, interface_name, meta, notify):\n+        # Watch the objects managed by the ObjectManager at \"path\".\n+        # Properties are not watched, that is done by setup_path_watch\n+        # below via recursive_props == True.\n \n-    def __del__(self) -> None:\n-        # This might be the currently-dispatching callback \u2014 make sure we don't\n-        # destroy the trampoline before we return.  We drop the deferred list\n-        # from the event loop when we're sure we're not doing any dispatches.\n-        if Trampoline.deferred is not None:\n-            Trampoline.deferred.append(self.trampoline)\n-        if self.value is not None:\n-            self._unref()\n+        async def handler(message):\n+            member = message.get_member()\n+            if member == \"InterfacesAdded\":\n+                (path, interface_props) = message.get_body()\n+                logger.debug('interfaces added %s %s', path, interface_props)\n+                meta = {}\n+                notify = {}\n+                async with self.watch_processing_lock:\n+                    for name, props in interface_props.items():\n+                        if interface_name is None or name == interface_name:\n+                            mm = await self.cache.get_interface_if_new(name, self.bus, self.name, path)\n+                            if mm:\n+                                meta.update({name: mm})\n+                            notify_update(notify, path, name, props)\n+                    self.send_json(meta=meta)\n+                    self.send_json(notify=notify)\n+            elif member == \"InterfacesRemoved\":\n+                (path, interfaces) = message.get_body()\n+                logger.debug('interfaces removed %s %s', path, interfaces)\n+                async with self.watch_processing_lock:\n+                    notify = {path: {name: None for name in interfaces}}\n+                    self.send_json(notify=notify)\n \n+        self.add_async_signal_handler(handler,\n+                                      path=path,\n+                                      interface=\"org.freedesktop.DBus.ObjectManager\")\n+        objects, = await self.bus.call_method_async(self.name, path,\n+                                                    'org.freedesktop.DBus.ObjectManager',\n+                                                    'GetManagedObjects')\n+        for p, ifaces in objects.items():\n+            for iface, props in ifaces.items():\n+                if interface_name is None or iface == interface_name:\n+                    mm = await self.cache.get_interface_if_new(iface, self.bus, self.name, p)\n+                    if mm:\n+                        meta.update({iface: mm})\n+                    notify_update(notify, p, iface, props)\n \n-class sd_bus_error(ctypes.Structure):\n-    # This is ABI, so we are safe to assume it doesn't change.\n-    # Unfortunately, we lack anything like sd_bus_error_new().\n-    _fields_ = (\n-        (\"name\", ctypes.c_char_p),\n-        (\"message\", ctypes.c_char_p),\n-        (\"_need_free\", ctypes.c_int),\n-    )\n+    async def setup_path_watch(self, path, interface_name, recursive_props, meta, notify):\n+        # Watch a single object at \"path\", but maybe also watch for\n+        # property changes for all objects below \"path\".\n \n-    def get(self) -> Tuple[str, str]:\n-        return self.name.decode(), self.message.decode()\n+        async def handler(message):\n+            async with self.watch_processing_lock:\n+                path = message.get_path()\n+                name, props, invalids = message.get_body()\n+                logger.debug('NOTIFY: %s %s %s %s', path, name, props, invalids)\n+                for inv in invalids:\n+                    try:\n+                        reply, = await self.bus.call_method_async(self.name, path,\n+                                                                  'org.freedesktop.DBus.Properties', 'Get',\n+                                                                  'ss', name, inv)\n+                    except BusError as exc:\n+                        logger.debug('failed to fetch property %s.%s on %s %s: %s',\n+                                     name, inv, self.name, path, str(exc))\n+                        continue\n+                    props[inv] = reply\n+                notify = {}\n+                notify_update(notify, path, name, props)\n+                self.send_json(notify=notify)\n \n-    def set(self, name: str, message: str) -> None:\n-        result = libsystemd.sd_bus_error_set(byref(self), name, message)\n-        if result < 0:\n-            raise OSError(-result, f\"sd_bus_error_set: {os.strerror(-result)}\")\n+        this_meta = await self.cache.introspect_path(self.bus, self.name, path)\n+        if interface_name is not None:\n+            interface = this_meta.get(interface_name)\n+            this_meta = {interface_name: interface}\n+        meta.update(this_meta)\n+        if recursive_props:\n+            self.add_async_signal_handler(handler,\n+                                          interface=\"org.freedesktop.DBus.Properties\",\n+                                          path_namespace=path)\n+        else:\n+            self.add_async_signal_handler(handler,\n+                                          interface=\"org.freedesktop.DBus.Properties\",\n+                                          path=path)\n \n-    def __del__(self) -> None:\n-        if self._b_needsfree_:\n-            libsystemd.sd_bus_error_free(byref(self))\n+        for name in meta:\n+            if name.startswith(\"org.freedesktop.DBus.\"):\n+                continue\n+            try:\n+                props, = await self.bus.call_method_async(self.name, path,\n+                                                          'org.freedesktop.DBus.Properties',\n+                                                          'GetAll', 's', name)\n+                notify_update(notify, path, name, props)\n+            except BusError:\n+                pass\n \n+    async def do_watch(self, message):\n+        watch = message['watch']\n+        path = watch.get('path')\n+        path_namespace = watch.get('path_namespace')\n+        interface_name = watch.get('interface')\n+        cookie = message.get('id')\n \n-class sd_id128(ctypes.Structure):\n-    # HACK: Pass-by-value of array-containing-structs is broken on Python\n-    # 3.6. See https://bugs.python.org/issue22273\n-    _fields_: List[Tuple[str, type]] = (\n-        [(\"bytes\", ctypes.c_uint8 * 16)]\n-        if sys.version_info >= (3, 7, 0)\n-        else [(\"one\", ctypes.c_uint64), (\"two\", ctypes.c_uint64)]\n-    )\n+        path = path or path_namespace\n+        recursive = path == path_namespace\n \n+        if path is None or cookie is None:\n+            logger.debug('ignored incomplete watch request %s', message)\n+            self.send_json(error=['x.y.z', ['Not Implemented']], id=cookie)\n+            self.send_json(reply=[], id=cookie)\n+            return\n \n-class sd_event_source(Trampoline):\n-    ...\n+        try:\n+            async with self.watch_processing_lock:\n+                meta = {}\n+                notify = {}\n+                await self.setup_path_watch(path, interface_name, recursive, meta, notify)\n+                if recursive:\n+                    await self.setup_objectmanager_watch(path, interface_name, meta, notify)\n+                self.send_json(meta=meta)\n+                self.send_json(notify=notify)\n+                self.send_json(reply=[], id=message['id'])\n+        except BusError as error:\n+            logger.debug(\"do_watch(%s) caught D-Bus error: %s\", message, error.message)\n+            self.send_json(error=[error.name, [error.message]], id=cookie)\n \n+    async def do_meta(self, message):\n+        self.cache.inject(message['meta'])\n \n-class sd_event(ReferenceType):\n-    def _add_inotify(\n-        self: 'sd_event',\n-        source: Reference[sd_event_source],\n-        path: str,\n-        event: int,\n-        callback: Callback,\n-        user_data: UserData,\n-    ) -> Union[None, Errno]:\n-        ...\n+    def do_data(self, data):\n+        message = json.loads(data)\n+        logger.debug('receive dbus request %s %s', self.name, message)\n \n-    def dispatch(self: 'sd_event') -> Union[None, Errno]:\n-        ...\n+        if 'call' in message:\n+            self.create_task(self.do_call(message))\n+        elif 'add-match' in message:\n+            self.create_task(self.do_add_match(message))\n+        elif 'watch' in message:\n+            self.create_task(self.do_watch(message))\n+        elif 'meta' in message:\n+            self.create_task(self.do_meta(message))\n+        else:\n+            logger.debug('ignored dbus request %s', message)\n+            return\n \n-    def get_fd(self: 'sd_event') -> Union[int, Errno]:\n-        raise NotImplementedError\n+    def do_close(self):\n+        for slot in self.matches:\n+            slot.cancel()\n+        self.matches = []\n+        self.close()\n+'''.encode('utf-8'),\n+  'cockpit/channels/packages.py': br'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2022 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n \n-    def get_state(self: 'sd_event') -> Union[int, Errno]:\n-        raise NotImplementedError\n+import logging\n+from typing import Optional\n \n-    def loop(self: 'sd_event') -> Union[None, Errno]:\n-        ...\n+from ..channel import AsyncChannel\n+from ..data import read_cockpit_data_file\n+from ..jsonutil import JsonObject, get_dict, get_str\n+from ..packages import Packages\n \n-    def prepare(self: 'sd_event') -> Union[None, Errno]:\n-        ...\n+logger = logging.getLogger(__name__)\n \n-    def wait(\n-        self: 'sd_event', timeout: Annotated[int, ctypes.c_uint64]\n-    ) -> Union[None, Errno]:\n-        ...\n \n-    @staticmethod\n-    def _default(ret: Reference['sd_event']) -> Union[None, Errno]:\n-        ...\n+class PackagesChannel(AsyncChannel):\n+    payload = 'http-stream1'\n+    restrictions = [(\"internal\", \"packages\")]\n \n+    # used to carry data forward from open to done\n+    options: Optional[JsonObject] = None\n \n-class sd_bus_slot(Trampoline):\n-    ...\n+    def http_error(self, status: int, message: str) -> None:\n+        template = read_cockpit_data_file('fail.html')\n+        self.send_json(status=status, reason='ERROR', headers={'Content-Type': 'text/html; charset=utf-8'})\n+        self.send_data(template.replace(b'@@message@@', message.encode('utf-8')))\n+        self.done()\n+        self.close()\n \n+    async def run(self, options: JsonObject) -> None:\n+        packages: Packages = self.router.packages  # type: ignore[attr-defined]  # yes, this is evil\n \n-class sd_bus_message(ReferenceType):\n-    def rewind(self: 'sd_bus_message', complete: bool) -> Union[None, Errno]:\n-        ...\n+        try:\n+            if get_str(options, 'method') != 'GET':\n+                raise ValueError(f'Unsupported HTTP method {options[\"method\"]}')\n \n-    def _get_error(self: 'sd_bus_message') -> Reference[sd_bus_error]:\n-        raise NotImplementedError\n+            self.ready()\n+            if await self.read() != b'':\n+                raise ValueError('Received unexpected data')\n \n-    def has_signature(self: 'sd_bus_message', signature: str) -> Union[bool, Errno]:\n-        raise NotImplementedError\n+            path = get_str(options, 'path')\n+            headers = get_dict(options, 'headers')\n+            document = packages.load_path(path, headers)\n \n-    def is_method_error(self: 'sd_bus_message', name: str) -> Union[bool, Errno]:\n-        raise NotImplementedError\n+            # Note: we can't cache documents right now.  See\n+            # https://github.com/cockpit-project/cockpit/issues/19071\n+            # for future plans.\n+            out_headers = {\n+                'Cache-Control': 'no-cache, no-store',\n+                'Content-Type': document.content_type,\n+            }\n \n-    def _new_method_errnof(\n-            self: 'sd_bus_message',\n-            message: Reference['sd_bus_message'],\n-            error: int,\n-            format_str: str,\n-            first_arg: str\n-    ) -> Union[None, Errno]:\n-        ...\n+            if document.content_encoding is not None:\n+                out_headers['Content-Encoding'] = document.content_encoding\n \n-    def _new_method_errorf(\n-        self: 'sd_bus_message',\n-        m: Reference['sd_bus_message'],\n-        name: str,\n-        format_str: str,\n-        first_arg: str\n-    ) -> Union[None, Errno]:\n-        ...\n+            if document.content_security_policy is not None:\n+                policy = document.content_security_policy\n \n-    def _new_method_return(\n-        self: 'sd_bus_message', m: Reference['sd_bus_message']\n-    ) -> Union[None, Errno]:\n-        ...\n+                # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/connect-src\n+                #\n+                #    Note: connect-src 'self' does not resolve to websocket\n+                #    schemes in all browsers, more info in this issue.\n+                #\n+                # https://github.com/w3c/webappsec-csp/issues/7\n+                if \"connect-src 'self';\" in policy:\n+                    protocol = headers.get('X-Forwarded-Proto')\n+                    host = headers.get('X-Forwarded-Host')\n+                    if not isinstance(protocol, str) or not isinstance(host, str):\n+                        raise ValueError('Invalid host or protocol header')\n \n-    def seal(\n-        self: 'sd_bus_message',\n-        cookie: Annotated[int, ctypes.c_uint64],\n-        timeout: Annotated[int, ctypes.c_uint64],\n-    ) -> Union[None, Errno]:\n-        ...\n+                    websocket_scheme = \"wss\" if protocol == \"https\" else \"ws\"\n+                    websocket_origin = f\"{websocket_scheme}://{host}\"\n+                    policy = policy.replace(\"connect-src 'self';\", f\"connect-src {websocket_origin} 'self';\")\n \n-    def _get_bus(self: 'sd_bus_message') -> WeakReference:\n-        raise NotImplementedError\n+                out_headers['Content-Security-Policy'] = policy\n \n-    def get_destination(self: 'sd_bus_message') -> str:\n-        raise NotImplementedError\n+        except ValueError as exc:\n+            self.http_error(400, str(exc))\n \n-    def get_interface(self: 'sd_bus_message') -> str:\n-        raise NotImplementedError\n+        except KeyError:\n+            self.http_error(404, 'Not found')\n \n-    def get_member(self: 'sd_bus_message') -> str:\n-        raise NotImplementedError\n+        except OSError as exc:\n+            self.http_error(500, f'Internal error: {exc!s}')\n \n-    def get_path(self: 'sd_bus_message') -> str:\n-        raise NotImplementedError\n+        else:\n+            self.send_json(status=200, reason='OK', headers=out_headers)\n+            await self.sendfile(document.data)\n+''',\n+  'cockpit/channels/http.py': br'''# This file is part of Cockpit.\n+#\n+# Copyright (C) 2022 Red Hat, Inc.\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <https://www.gnu.org/licenses/>.\n \n-    def get_sender(self: 'sd_bus_message') -> Optional[str]:\n-        raise NotImplementedError\n+import asyncio\n+import http.client\n+import logging\n+import socket\n+import ssl\n \n-    def get_signature(self: 'sd_bus_message', complete: bool) -> str:\n-        raise NotImplementedError\n+from ..channel import AsyncChannel, ChannelError\n+from ..jsonutil import JsonObject, get_dict, get_int, get_object, get_str, typechecked\n \n+logger = logging.getLogger(__name__)\n \n-class sd_bus(ReferenceType):\n-    def _add_match(\n-        self: 'sd_bus',\n-        slot: Reference[sd_bus_slot],\n-        match: str,\n-        handler: Callback,\n-        user_data: UserData,\n-    ) -> Union[None, Errno]:\n-        ...\n \n-    def _add_match_async(\n-        self: 'sd_bus',\n-        slot: Reference[sd_bus_slot],\n-        match: str,\n-        callback: Callback,\n-        install_callback: Callback,\n-        user_data: UserData,\n-    ) -> Union[None, Errno]:\n-        ...\n+class HttpChannel(AsyncChannel):\n+    payload = 'http-stream2'\n \n-    def _add_object(\n-        self: 'sd_bus',\n-        slot: Reference[sd_bus_slot],\n-        path: str,\n-        callback: Callback,\n-        user_data: UserData,\n-    ) -> Union[None, Errno]:\n-        ...\n+    @staticmethod\n+    def get_headers(response: http.client.HTTPResponse, binary: 'str | None') -> JsonObject:\n+        # Never send these headers\n+        remove = {'Connection', 'Transfer-Encoding'}\n \n-    def attach_event(\n-        self: 'sd_bus', event: Optional[sd_event], priority: int\n-    ) -> Union[None, Errno]:\n-        ...\n+        if binary != 'raw':\n+            # Only send these headers for raw binary streams\n+            remove.update({'Content-Length', 'Range'})\n \n-    def _call(\n-        self: 'sd_bus',\n-        message: sd_bus_message,\n-        timeout: Annotated[int, ctypes.c_uint64],\n-        ret_error: Reference[sd_bus_error],\n-        reply: Reference[sd_bus_message],\n-    ) -> Union[None, Errno]:\n-        ...\n+        return {key: value for key, value in response.getheaders() if key not in remove}\n \n-    def _call_async(\n-        self: 'sd_bus',\n-        slot: Reference[sd_bus_slot],\n-        message: sd_bus_message,\n-        callback: Callback,\n-        user_data: UserData,\n-        timeout_usec: Annotated[int, ctypes.c_uint64],\n-    ) -> Union[None, Errno]:\n-        ...\n+    @staticmethod\n+    def create_client(options: JsonObject) -> http.client.HTTPConnection:\n+        opt_address = get_str(options, 'address', 'localhost')\n+        opt_tls = get_dict(options, 'tls', None)\n+        opt_unix = get_str(options, 'unix', None)\n+        opt_port = get_int(options, 'port', None)\n \n-    def flush(self: 'sd_bus') -> Union[None, Errno]:\n-        ...\n+        if opt_tls is not None and opt_unix is not None:\n+            raise ChannelError('protocol-error', message='TLS on Unix socket is not supported')\n+        if opt_port is None and opt_unix is None:\n+            raise ChannelError('protocol-error', message='no \"port\" or \"unix\" option for channel')\n+        if opt_port is not None and opt_unix is not None:\n+            raise ChannelError('protocol-error', message='cannot specify both \"port\" and \"unix\" options')\n \n-    def get_fd(self: 'sd_bus') -> Union[int, Errno]:\n-        raise NotImplementedError\n+        if opt_tls is not None:\n+            authority = get_dict(opt_tls, 'authority', None)\n+            if authority is not None:\n+                data = get_str(authority, 'data', None)\n+                if data is not None:\n+                    context = ssl.create_default_context(cadata=data)\n+                else:\n+                    context = ssl.create_default_context(cafile=get_str(authority, 'file'))\n+            else:\n+                context = ssl.create_default_context()\n \n-    def _message_new_method_call(\n-        self: 'sd_bus',\n-        message: Reference[sd_bus_message],\n-        destination: Optional[str],\n-        path: str,\n-        interface: str,\n-        member: str,\n-    ) -> Union[None, Errno]:\n-        ...\n+            if 'validate' in opt_tls and not opt_tls['validate']:\n+                context.check_hostname = False\n+                context.verify_mode = ssl.VerifyMode.CERT_NONE\n \n-    def _message_new_signal(\n-        self: 'sd_bus',\n-        message: Reference[sd_bus_message],\n-        path: str,\n-        interface: str,\n-        member: str,\n-    ) -> Union[None, Errno]:\n-        ...\n+            # See https://github.com/python/typeshed/issues/11057\n+            return http.client.HTTPSConnection(opt_address, port=opt_port, context=context)  # type: ignore[arg-type]\n \n-    def release_name(self: 'sd_bus', name: str) -> Union[None, Errno]:\n-        ...\n+        else:\n+            return http.client.HTTPConnection(opt_address, port=opt_port)\n \n-    def request_name(\n-        self: 'sd_bus', name: str, flags: Annotated[int, ctypes.c_uint64]\n-    ) -> Union[None, Errno]:\n-        ...\n+    @staticmethod\n+    def connect(connection: http.client.HTTPConnection, opt_unix: 'str | None') -> None:\n+        # Blocks.  Runs in a thread.\n+        if opt_unix:\n+            # create the connection's socket so that it won't call .connect() internally (which only supports TCP)\n+            connection.sock = socket.socket(socket.AF_UNIX)\n+            connection.sock.connect(opt_unix)\n+        else:\n+            # explicitly call connect(), so that we can do proper error handling\n+            connection.connect()\n \n-    def set_address(self: 'sd_bus', address: str) -> Union[None, Errno]:\n-        ...\n+    @staticmethod\n+    def request(\n+        connection: http.client.HTTPConnection, method: str, path: str, headers: 'dict[str, str]', body: bytes\n+    ) -> http.client.HTTPResponse:\n+        # Blocks.  Runs in a thread.\n+        connection.request(method, path, headers=headers or {}, body=body)\n+        return connection.getresponse()\n \n-    def set_bus_client(self: 'sd_bus', b: bool) -> Union[None, Errno]:\n-        ...\n+    async def run(self, options: JsonObject) -> None:\n+        logger.debug('open %s', options)\n \n-    def set_fd(self: 'sd_bus', input_fd: int, output_fd: int) -> Union[None, Errno]:\n-        ...\n+        binary = get_str(options, 'binary', None)\n+        method = get_str(options, 'method')\n+        path = get_str(options, 'path')\n+        headers = get_object(options, 'headers', lambda d: {k: typechecked(v, str) for k, v in d.items()}, None)\n \n-    def set_server(self: 'sd_bus', b: bool, bus_d: sd_id128) -> Union[None, Errno]:\n-        ...\n+        if 'connection' in options:\n+            raise ChannelError('protocol-error', message='connection sharing is not implemented on this bridge')\n \n-    def start(self: 'sd_bus') -> Union[None, Errno]:\n-        ...\n+        loop = asyncio.get_running_loop()\n+        connection = self.create_client(options)\n \n-    def wait(\n-        self: 'sd_bus', timeout_usec: Annotated[int, ctypes.c_uint64]\n-    ) -> Union[None, Errno]:\n-        ...\n+        self.ready()\n \n-    def send(\n-        self: 'sd_bus', message: sd_bus_message, cookie: Optional[Reference[ctypes.c_uint64]]\n-    ) -> Union[None, Errno]:\n-        ...\n+        body = b''\n+        while True:\n+            data = await self.read()\n+            if data == b'':\n+                break\n+            body += data\n \n-    @staticmethod\n-    def _default_system(ret: Reference['sd_bus']) -> Union[None, Errno]:\n-        ...\n+        # Connect in a thread and handle errors\n+        try:\n+            await loop.run_in_executor(None, self.connect, connection, get_str(options, 'unix', None))\n+        except ssl.SSLCertVerificationError as exc:\n+            raise ChannelError('unknown-hostkey', message=str(exc)) from exc\n+        except (OSError, IOError) as exc:\n+            raise ChannelError('not-found', message=str(exc)) from exc\n \n-    @staticmethod\n-    def _default_user(ret: Reference['sd_bus']) -> Union[None, Errno]:\n-        ...\n+        # Submit request in a thread and handle errors\n+        try:\n+            response = await loop.run_in_executor(None, self.request, connection, method, path, headers or {}, body)\n+        except (http.client.HTTPException, OSError) as exc:\n+            raise ChannelError('terminated', message=str(exc)) from exc\n \n-    @staticmethod\n-    def _new(ret: Reference['sd_bus']) -> Union[None, Errno]:\n-        ...\n+        self.send_control(command='response',\n+                          status=response.status,\n+                          reason=response.reason,\n+                          headers=self.get_headers(response, binary))\n \n+        # Receive the body and finish up\n+        try:\n+            while True:\n+                block = await loop.run_in_executor(None, response.read1, self.BLOCK_SIZE)\n+                if not block:\n+                    break\n+                await self.write(block)\n \n-sd_bus_message_handler_t = ctypes.CFUNCTYPE(\n-    ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(sd_bus_error))\n-sd_event_inotify_handler_t = ctypes.CFUNCTYPE(\n-    ctypes.c_int, ctypes.c_void_p, ctypes.POINTER(inotify_event), ctypes.c_void_p)\n+            logger.debug('reading response done')\n+            # this returns immediately and does not read anything more, but updates the http.client's\n+            # internal state machine to \"response done\"\n+            block = response.read()\n+            assert block == b''\n \n+            await loop.run_in_executor(None, connection.close)\n+        except (http.client.HTTPException, OSError) as exc:\n+            raise ChannelError('terminated', message=str(exc)) from exc\n \n-libsystemd = ctypes.CDLL(\"libsystemd.so.0\")\n-for cls in {\n-    sd_bus,\n-    sd_bus_message,\n-    sd_bus_slot,\n-    sd_event,\n-    sd_event_source,\n-}:\n-    cls._install_cfuncs(libsystemd)\n-'''.encode('utf-8'),\n+        self.done()\n+''',\n+  'cockpit/_vendor/__init__.py': br'''''',\n   'cockpit/_vendor/systemd_ctypes/bus.py': br'''# systemd_ctypes\n #\n # Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n@@ -8719,14 +7479,651 @@\n         try:\n             method = self._find_member(interface, 'methods', name)\n             assert isinstance(method, Interface.Method)\n             return method._invoke(self, message)\n         except Object.Method.Unhandled:\n             return False\n ''',\n+  'cockpit/_vendor/systemd_ctypes/librarywrapper.py': br'''# systemd_ctypes\n+#\n+# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n+\n+import ctypes\n+import inspect\n+import logging\n+import os\n+import sys\n+import types\n+from typing import (\n+    Any,\n+    Callable,\n+    Dict,\n+    Generic,\n+    NewType,\n+    NoReturn,\n+    Optional,\n+    Tuple,\n+    Type,\n+    TypeVar,\n+    Union,\n+)\n+\n+from . import typing\n+\n+# First in 3.10, and conditional import gives type errors\n+NoneType = type(None)\n+\n+logger = logging.getLogger(__name__)\n+\n+if typing.TYPE_CHECKING:\n+    CType = TypeVar(\"CType\", bound=ctypes._CData)\n+    Callback = ctypes._FuncPointer\n+else:\n+    CType = TypeVar(\"CType\")\n+    Callback = ctypes.c_void_p\n+\n+\n+if typing.TYPE_CHECKING:\n+    class Reference(Generic[CType], ctypes._Pointer[CType]):\n+        pass\n+\n+    def byref(x: CType) -> Reference[CType]:\n+        raise NotImplementedError\n+else:\n+    class Reference(Generic[CType]):\n+        pass\n+\n+    byref = ctypes.byref\n+\n+\n+UserData = Optional[ctypes.c_void_p]\n+\n+\n+class negative_errno(ctypes.c_int):\n+    def errcheck(self, func: Callable[..., object], _args: Tuple[object, ...]) -> int:\n+        result = self.value\n+        if result < 0:\n+            raise OSError(-result, f\"{func.__name__}: {os.strerror(-result)}\")\n+        return result\n+\n+\n+class utf8(ctypes.c_char_p):\n+    def errcheck(self, func: Callable[..., object], _args: Tuple[object, ...]) -> str:\n+        assert self.value is not None\n+        return self.value.decode()\n+\n+    @classmethod\n+    def from_param(cls, value: str) -> 'utf8':\n+        return cls(value.encode())\n+\n+\n+class utf8_or_null(ctypes.c_char_p):\n+    def errcheck(self,\n+                 func: Callable[..., object],\n+                 _args: Tuple[object, ...]) -> Optional[str]:\n+        return self.value.decode() if self.value is not None else None\n+\n+    @classmethod\n+    def from_param(cls, value: Optional[str]) -> 'utf8_or_null':\n+        return cls(value.encode() if value is not None else None)\n+\n+\n+class boolint(ctypes.c_int):\n+    def errcheck(self, func: Callable[..., object], _args: Tuple[object, ...]) -> bool:\n+        return bool(self.value)\n+\n+\n+WeakReference = NewType(\"WeakReference\", int)\n+Errno = typing.Annotated[NoReturn, \"errno\"]\n+\n+\n+type_map = {\n+    Union[None, Errno]: negative_errno,  # technically returns int\n+    Union[bool, Errno]: negative_errno,  # technically returns int\n+    Union[int, Errno]: negative_errno,\n+    bool: boolint,\n+    Optional[str]: utf8_or_null,\n+    str: utf8,\n+    int: ctypes.c_int,\n+    WeakReference: ctypes.c_void_p\n+}\n+\n+\n+def map_type(annotation: Any, global_vars: Dict[str, object]) -> Any:\n+    try:\n+        return type_map[annotation]\n+    except KeyError:\n+        pass  # ... and try more cases below\n+\n+    if isinstance(annotation, typing.ForwardRef):\n+        annotation = annotation.__forward_arg__\n+\n+    if isinstance(annotation, str):\n+        annotation = global_vars[annotation]\n+\n+    origin = typing.get_origin(annotation)\n+    args = typing.get_args(annotation)\n+\n+    if origin is Reference:\n+        return ctypes.POINTER(map_type(args[0], global_vars))\n+\n+    elif origin is Union and NoneType in args:\n+        # the C pointer types are already nullable\n+        other_arg, = set(args) - {NoneType}\n+        return map_type(other_arg, global_vars)\n+\n+    elif origin is typing.Annotated:\n+        return args[1]\n+\n+    else:\n+        assert origin is None, origin\n+        return annotation\n+\n+\n+class ReferenceType(ctypes.c_void_p):\n+    @classmethod\n+    def _install_cfuncs(cls, cdll: ctypes.CDLL) -> None:\n+        logger.debug('Installing stubs for %s:', cls)\n+        stubs = tuple(cls.__dict__.items())\n+        for name, stub in stubs:\n+            if name.startswith(\"__\"):\n+                continue\n+            cls._wrap(cdll, stub)\n+\n+        cls._wrap(cdll, cls._ref)\n+        cls._wrap(cdll, cls._unref)\n+\n+    @classmethod\n+    def _wrap(cls, cdll: ctypes.CDLL, stub: object) -> None:\n+        stub_type = type(stub)\n+        if isinstance(stub, staticmethod):\n+            # In older Python versions, staticmethod() isn't considered\n+            # callable, doesn't have a name, and can't be introspected with\n+            # inspect.signature(). Unwrap it.\n+            stub = stub.__func__\n+        assert isinstance(stub, types.FunctionType)\n+        name = stub.__name__\n+        signature = inspect.signature(stub)\n+        stub_globals = sys.modules.get(cls.__module__).__dict__\n+\n+        func = cdll[f'{cls.__name__}_{name.lstrip(\"_\")}']\n+        func.argtypes = tuple(\n+            map_type(parameter.annotation, stub_globals)\n+            for parameter in signature.parameters.values()\n+        )\n+        func.restype = map_type(signature.return_annotation, stub_globals)\n+        errcheck = getattr(func.restype, 'errcheck', None)\n+        if errcheck is not None:\n+            func.errcheck = errcheck\n+\n+        logger.debug('  create wrapper %s.%s%s', cls.__name__, name, signature)\n+        logger.debug('    args %s res %s', func.argtypes, func.restype)\n+\n+        # ctypes function pointer objects don't implement the usual function\n+        # descriptor logic, which means they won't bind as methods.  For static\n+        # methods, that's good, but for instance methods, we add a wrapper as\n+        # the easiest and most performant way to get the binding behaviour.\n+        if stub_type is not staticmethod:\n+            setattr(cls, name, lambda *args: func(*args))\n+        else:\n+            setattr(cls, name, func)\n+\n+    def _unref(self: 'ReferenceType') -> None:\n+        ...\n+\n+    def _ref(self: 'ReferenceType') -> None:\n+        ...\n+\n+    T = TypeVar(\"T\", bound='ReferenceType')\n+\n+    @classmethod\n+    def ref(cls: Type[T], origin: WeakReference) -> T:\n+        self = cls(origin)\n+        self._ref()\n+        return self\n+\n+    def __del__(self) -> None:\n+        if self.value is not None:\n+            self._unref()\n+''',\n+  'cockpit/_vendor/systemd_ctypes/event.py': br'''# systemd_ctypes\n+#\n+# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n+\n+import asyncio\n+import selectors\n+import sys\n+from typing import Callable, ClassVar, Coroutine, List, Optional, Tuple\n+\n+from . import inotify, libsystemd\n+from .librarywrapper import Reference, UserData, byref\n+\n+\n+class Event(libsystemd.sd_event):\n+    class Source(libsystemd.sd_event_source):\n+        def cancel(self) -> None:\n+            self._unref()\n+            self.value = None\n+\n+    _default_instance: ClassVar[Optional['Event']] = None\n+\n+    @staticmethod\n+    def default() -> 'Event':\n+        if Event._default_instance is None:\n+            Event._default_instance = Event()\n+            Event._default(byref(Event._default_instance))\n+        return Event._default_instance\n+\n+    InotifyHandler = Callable[[inotify.Event, int, Optional[bytes]], None]\n+\n+    class InotifySource(Source):\n+        def __init__(self, handler: 'Event.InotifyHandler') -> None:\n+            def callback(source: libsystemd.sd_event_source,\n+                         _event: Reference[inotify.inotify_event],\n+                         userdata: UserData) -> int:\n+                event = _event.contents\n+                handler(inotify.Event(event.mask), event.cookie, event.name)\n+                return 0\n+            self.trampoline = libsystemd.sd_event_inotify_handler_t(callback)\n+\n+    def add_inotify(self, path: str, mask: inotify.Event, handler: InotifyHandler) -> InotifySource:\n+        source = Event.InotifySource(handler)\n+        self._add_inotify(byref(source), path, mask, source.trampoline, source.userdata)\n+        return source\n+\n+    def add_inotify_fd(self, fd: int, mask: inotify.Event, handler: InotifyHandler) -> InotifySource:\n+        # HACK: sd_event_add_inotify_fd() got added in 250, which is too new.  Fake it.\n+        return self.add_inotify(f'/proc/self/fd/{fd}', mask, handler)\n+\n+\n+# This is all a bit more awkward than it should have to be: systemd's event\n+# loop chaining model is designed for glib's prepare/check/dispatch paradigm;\n+# failing to call prepare() can lead to deadlocks, for example.\n+#\n+# Hack a selector subclass which calls prepare() before sleeping and this for us.\n+class Selector(selectors.DefaultSelector):\n+    def __init__(self, event: Optional[Event] = None) -> None:\n+        super().__init__()\n+        self.sd_event = event or Event.default()\n+        self.key = self.register(self.sd_event.get_fd(), selectors.EVENT_READ)\n+\n+    def select(\n+            self, timeout: Optional[float] = None\n+    ) -> List[Tuple[selectors.SelectorKey, int]]:\n+        # It's common to drop the last reference to a Source or Slot object on\n+        # a dispatch of that same source/slot from the main loop.  If we happen\n+        # to garbage collect before returning, the trampoline could be\n+        # destroyed before we're done using it.  Provide a mechanism to defer\n+        # the destruction of trampolines for as long as we might be\n+        # dispatching.  This gets cleared again at the bottom, before return.\n+        libsystemd.Trampoline.deferred = []\n+\n+        while self.sd_event.prepare():\n+            self.sd_event.dispatch()\n+        ready = super().select(timeout)\n+        # workaround https://github.com/systemd/systemd/issues/23826\n+        # keep calling wait() until there's nothing left\n+        while self.sd_event.wait(0):\n+            self.sd_event.dispatch()\n+            while self.sd_event.prepare():\n+                self.sd_event.dispatch()\n+\n+        # We can be sure we're not dispatching callbacks anymore\n+        libsystemd.Trampoline.deferred = None\n+\n+        # This could return zero events with infinite timeout, but nobody seems to mind.\n+        return [(key, events) for (key, events) in ready if key != self.key]\n+\n+\n+class EventLoopPolicy(asyncio.DefaultEventLoopPolicy):\n+    def new_event_loop(self) -> asyncio.AbstractEventLoop:\n+        return asyncio.SelectorEventLoop(Selector())\n+\n+\n+def run_async(main: Coroutine[None, None, None], debug: Optional[bool] = None) -> None:\n+    asyncio.set_event_loop_policy(EventLoopPolicy())\n+\n+    polyfill = sys.version_info < (3, 7, 0) and not hasattr(asyncio, 'run')\n+    if polyfill:\n+        # Polyfills for Python 3.6:\n+        loop = asyncio.get_event_loop()\n+\n+        assert not hasattr(asyncio, 'get_running_loop')\n+        asyncio.get_running_loop = lambda: loop\n+\n+        assert not hasattr(asyncio, 'create_task')\n+        asyncio.create_task = loop.create_task\n+\n+        assert not hasattr(asyncio, 'run')\n+\n+        def run(\n+                main: Coroutine[None, None, None], debug: Optional[bool] = None\n+        ) -> None:\n+            if debug is not None:\n+                loop.set_debug(debug)\n+            loop.run_until_complete(main)\n+\n+        asyncio.run = run  # type: ignore[assignment]\n+\n+        asyncio._systemd_ctypes_polyfills = True  # type: ignore[attr-defined]\n+\n+    asyncio.run(main, debug=debug)\n+\n+    if polyfill:\n+        del asyncio.create_task, asyncio.get_running_loop, asyncio.run\n+''',\n+  'cockpit/_vendor/systemd_ctypes/pathwatch.py': br'''# systemd_ctypes\n+#\n+# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n+\n+import errno\n+import logging\n+import os\n+import stat\n+from typing import Any, List, Optional\n+\n+from .event import Event\n+from .inotify import Event as IN\n+\n+logger = logging.getLogger(__name__)\n+\n+\n+# inotify hard facts:\n+#\n+# DELETE_SELF doesn't get called until all references to an inode are gone\n+#   - including open fds\n+#   - including on directories\n+#\n+# ATTRIB gets called when unlinking files (because the link count changes) but\n+# not on directories.  When unlinking an open directory, no events at all\n+# happen on the directory.  ATTRIB also collects child events, which means we\n+# get a lot of unwanted noise.\n+#\n+# There's nothing like UNLINK_SELF, unfortunately.\n+#\n+# Even if it was possible to take this approach, it might not work: after\n+# you've opened the fd, it might get deleted before you can establish the watch\n+# on it.\n+#\n+# Additionally, systemd makes it impossible to register those events on\n+# symlinks (because it removes IN_DONT_FOLLOW in order to watch via\n+# /proc/self/fd).\n+#\n+# For all of these reasons, unfortunately, the best way seems to be to watch\n+# for CREATE|DELETE|MOVE events on each intermediate directory.\n+#\n+# Unfortunately there is no way to filter to only the name we're interested in,\n+# so we're gonna get a lot of unnecessary wakeups.\n+#\n+# Also: due to the above-mentioned race about watching after opening the fd,\n+# let's just always watch for both create and delete events *before* trying to\n+# open the fd.  We could try to reduce the mask after the fact, but meh...\n+#\n+# We use a WatchInvalidator utility class to fill the role of \"Tell me when an\n+# event happened on this (directory) fd which impacted the name file\".  We\n+# build a series of these when setting up a watch in order to find out if any\n+# part of the path leading to the monitored file changed.\n+\n+\n+class Handle(int):\n+    \"\"\"An integer subclass that makes it easier to work with file descriptors\"\"\"\n+\n+    def __new__(cls, fd: int = -1) -> 'Handle':\n+        return super(Handle, cls).__new__(cls, fd)\n+\n+    # separate __init__() to set _needs_close mostly to keep pylint quiet\n+    def __init__(self, fd: int = -1):\n+        super().__init__()\n+        self._needs_close = fd != -1\n+\n+    def __bool__(self) -> bool:\n+        return self != -1\n+\n+    def close(self) -> None:\n+        if self._needs_close:\n+            self._needs_close = False\n+            os.close(self)\n+\n+    def __eq__(self, value: object) -> bool:\n+        if int.__eq__(self, value):  # also handles both == -1\n+            return True\n+\n+        if not isinstance(value, int):  # other object is not an int\n+            return False\n+\n+        if not self or not value:  # when only one == -1\n+            return False\n+\n+        return os.path.sameopenfile(self, value)\n+\n+    def __del__(self) -> None:\n+        if self._needs_close:\n+            self.close()\n+\n+    def __enter__(self) -> 'Handle':\n+        return self\n+\n+    def __exit__(self, _type: type, _value: object, _traceback: object) -> None:\n+        self.close()\n+\n+    @classmethod\n+    def open(cls, *args: Any, **kwargs: Any) -> 'Handle':\n+        return cls(os.open(*args, **kwargs))\n+\n+    def steal(self) -> 'Handle':\n+        self._needs_close = False\n+        return self.__class__(int(self))\n+\n+\n+class WatchInvalidator:\n+    _name: bytes\n+    _source: Optional[Event.Source]\n+    _watch: Optional['PathWatch']\n+\n+    def event(self, mask: IN, _cookie: int, name: Optional[bytes]) -> None:\n+        logger.debug('invalidator event %s %s', mask, name)\n+        if self._watch is not None:\n+            # If this node itself disappeared, that's definitely an\n+            # invalidation.  Otherwise, the name needs to match.\n+            if IN.IGNORED in mask or self._name == name:\n+                logger.debug('Invalidating!')\n+                self._watch.invalidate()\n+\n+    def __init__(self, watch: 'PathWatch', event: Event, dirfd: int, name: str):\n+        self._watch = watch\n+        self._name = name.encode('utf-8')\n+\n+        # establishing invalidation watches is best-effort and can fail for a\n+        # number of reasons, including search (+x) but not read (+r) permission\n+        # on a particular path component, or exceeding limits on watches\n+        try:\n+            mask = IN.CREATE | IN.DELETE | IN.MOVE | IN.DELETE_SELF | IN.IGNORED\n+            self._source = event.add_inotify_fd(dirfd, mask, self.event)\n+        except OSError:\n+            self._source = None\n+\n+    def close(self) -> None:\n+        # This is a little bit tricky: systemd doesn't have a specific close\n+        # API outside of unref, so let's make it as explicit as possible.\n+        self._watch = None\n+        self._source = None\n+\n+\n+class PathStack(List[str]):\n+    def add_path(self, pathname: str) -> None:\n+        # TO DO: consider doing something reasonable with trailing slashes\n+        # this is a stack, popped from the end: push components in reverse\n+        self.extend(item for item in reversed(pathname.split('/')) if item)\n+        if pathname.startswith('/'):\n+            self.append('/')\n+\n+    def __init__(self, path: str):\n+        super().__init__()\n+        self.add_path(path)\n+\n+\n+class Listener:\n+    def do_inotify_event(self, mask: IN, cookie: int, name: Optional[bytes]) -> None:\n+        raise NotImplementedError\n+\n+    def do_identity_changed(self, fd: Optional[Handle], errno: Optional[int]) -> None:\n+        raise NotImplementedError\n+\n+\n+class PathWatch:\n+    _event: Event\n+    _listener: Listener\n+    _path: str\n+    _invalidators: List[WatchInvalidator]\n+    _errno: Optional[int]\n+    _source: Optional[Event.Source]\n+    _tag: Optional[None]\n+    _fd: Handle\n+\n+    def __init__(self, path: str, listener: Listener, event: Optional[Event] = None):\n+        self._event = event or Event.default()\n+        self._path = path\n+        self._listener = listener\n+\n+        self._invalidators = []\n+        self._errno = None\n+        self._source = None\n+        self._tag = None\n+        self._fd = Handle()\n+\n+        self.invalidate()\n+\n+    def got_event(self, mask: IN, cookie: int, name: Optional[bytes]) -> None:\n+        logger.debug('target event %s: %s %s %s', self._path, mask, cookie, name)\n+        self._listener.do_inotify_event(mask, cookie, name)\n+\n+    def invalidate(self) -> None:\n+        for invalidator in self._invalidators:\n+            invalidator.close()\n+        self._invalidators = []\n+\n+        try:\n+            fd = self.walk()\n+        except OSError as error:\n+            logger.debug('walk ended in error %d', error.errno)\n+\n+            if self._source or self._fd or self._errno != error.errno:\n+                logger.debug('Ending existing watches.')\n+                self._source = None\n+                self._fd.close()\n+                self._fd = Handle()\n+                self._errno = error.errno\n+\n+                logger.debug('Notifying of new error state %d', self._errno)\n+                self._listener.do_identity_changed(None, self._errno)\n+\n+            return\n+\n+        with fd:\n+            logger.debug('walk successful.  Got fd %d', fd)\n+            if fd == self._fd:\n+                logger.debug('fd seems to refer to same file.  Doing nothing.')\n+                return\n+\n+            logger.debug('This file is new for us.  Removing old watch.')\n+            self._source = None\n+            self._fd.close()\n+            self._fd = fd.steal()\n+\n+            try:\n+                logger.debug('Establishing a new watch.')\n+                self._source = self._event.add_inotify_fd(self._fd, IN.CHANGED, self.got_event)\n+                logger.debug('Watching successfully.  Notifying of new identity.')\n+                self._listener.do_identity_changed(self._fd, None)\n+            except OSError as error:\n+                logger.debug('Watching failed (%d).  Notifying of new identity.', error.errno)\n+                self._listener.do_identity_changed(self._fd, error.errno)\n+\n+    def walk(self) -> Handle:\n+        remaining_symlink_lookups = 40\n+        remaining_components = PathStack(self._path)\n+        dirfd = Handle()\n+\n+        try:\n+            logger.debug('Starting path walk')\n+\n+            while remaining_components:\n+                logger.debug('r=%s dfd=%s', remaining_components, dirfd)\n+\n+                name = remaining_components.pop()\n+\n+                if dirfd and name != '/':\n+                    self._invalidators.append(WatchInvalidator(self, self._event, dirfd, name))\n+\n+                with Handle.open(name, os.O_PATH | os.O_NOFOLLOW | os.O_CLOEXEC, dir_fd=dirfd) as fd:\n+                    mode = os.fstat(fd).st_mode\n+\n+                    if stat.S_ISLNK(mode):\n+                        if remaining_symlink_lookups == 0:\n+                            raise OSError(errno.ELOOP, os.strerror(errno.ELOOP))\n+                        remaining_symlink_lookups -= 1\n+                        linkpath = os.readlink('', dir_fd=fd)\n+                        logger.debug('%s is a symlink.  adding %s to components', name, linkpath)\n+                        remaining_components.add_path(linkpath)\n+\n+                    else:\n+                        dirfd.close()\n+                        dirfd = fd.steal()\n+\n+            return dirfd.steal()\n+\n+        finally:\n+            dirfd.close()\n+\n+    def close(self) -> None:\n+        for invalidator in self._invalidators:\n+            invalidator.close()\n+        self._invalidators = []\n+        self._source = None\n+        self._fd.close()\n+''',\n   'cockpit/_vendor/systemd_ctypes/bustypes.py': br'''# systemd_ctypes\n #\n # Copyright (C) 2023 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n@@ -9271,213 +8668,1300 @@\n     def default(self, obj: object) -> object:\n         if isinstance(obj, Variant):\n             return {\"t\": obj.type.typestring, \"v\": obj.value}\n         elif isinstance(obj, bytes):\n             return binascii.b2a_base64(obj, newline=False).decode('ascii')\n         return super().default(obj)\n ''',\n-  'cockpit/_vendor/ferny/ssh_askpass.py': br'''import logging\n-import re\n-from typing import ClassVar, Match, Sequence\n+  'cockpit/_vendor/systemd_ctypes/__init__.py': br'''# systemd_ctypes\n+#\n+# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n \n-from .interaction_agent import AskpassHandler\n+\"\"\"systemd_ctypes\"\"\"\n \n-logger = logging.getLogger(__name__)\n+__version__ = \"0\"\n \n+from .bus import Bus, BusError, BusMessage\n+from .bustypes import BusType, JSONEncoder, Variant\n+from .event import Event, EventLoopPolicy, run_async\n+from .pathwatch import Handle, PathWatch\n \n-class AskpassPrompt:\n-    \"\"\"An askpass prompt resulting from a call to ferny-askpass.\n+__all__ = [\n+    \"Bus\",\n+    \"BusError\",\n+    \"BusMessage\",\n+    \"BusType\",\n+    \"Event\",\n+    \"EventLoopPolicy\",\n+    \"Handle\",\n+    \"JSONEncoder\",\n+    \"PathWatch\",\n+    \"Variant\",\n+    \"run_async\",\n+]\n+''',\n+  'cockpit/_vendor/systemd_ctypes/py.typed': br'''''',\n+  'cockpit/_vendor/systemd_ctypes/introspection.py': br'''# systemd_ctypes\n+#\n+# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n \n-      stderr: the contents of stderr from before ferny-askpass was called.\n-              Likely related to previous failed operations.\n-      messages: all but the last line of the prompt as handed to ferny-askpass.\n-                Usually contains context about the question.\n-      prompt: the last line handed to ferny-askpass.  The prompt itself.\n-    \"\"\"\n-    stderr: str\n-    messages: str\n-    prompt: str\n+import xml.etree.ElementTree as ET\n \n-    def __init__(self, prompt: str, messages: str, stderr: str) -> None:\n-        self.stderr = stderr\n-        self.messages = messages\n-        self.prompt = prompt\n \n-    def reply(self, response: str) -> None:\n+def parse_method(method):\n+    return {\n+        \"in\": [tag.attrib['type'] for tag in method.findall(\"arg\") if tag.get('direction', 'in') == 'in'],\n+        \"out\": [tag.attrib['type'] for tag in method.findall(\"arg[@direction='out']\")]\n+    }\n+\n+\n+def parse_property(prop):\n+    return {\n+        \"flags\": 'w' if prop.attrib.get('access') == 'write' else 'r',\n+        \"type\": prop.attrib['type']\n+    }\n+\n+\n+def parse_signal(signal):\n+    return {\"in\": [tag.attrib['type'] for tag in signal.findall(\"arg\")]}\n+\n+\n+def parse_interface(interface):\n+    return {\n+        \"methods\": {tag.attrib['name']: parse_method(tag) for tag in interface.findall('method')},\n+        \"properties\": {tag.attrib['name']: parse_property(tag) for tag in interface.findall('property')},\n+        \"signals\": {tag.attrib['name']: parse_signal(tag) for tag in interface.findall('signal')}\n+    }\n+\n+\n+def parse_xml(xml):\n+    et = ET.fromstring(xml)\n+    return {tag.attrib['name']: parse_interface(tag) for tag in et.findall('interface')}\n+\n+\n+# Pretend like this is a little bit functional\n+def element(tag, children=(), **kwargs):\n+    tag = ET.Element(tag, kwargs)\n+    tag.extend(children)\n+    return tag\n+\n+\n+def method_to_xml(name, method_info):\n+    return element('method', name=name,\n+                   children=[\n+                       element('arg', type=arg_type, direction=direction)\n+                       for direction in ['in', 'out']\n+                       for arg_type in method_info[direction]\n+                   ])\n+\n+\n+def property_to_xml(name, property_info):\n+    return element('property', name=name,\n+                   access='write' if property_info['flags'] == 'w' else 'read',\n+                   type=property_info['type'])\n+\n+\n+def signal_to_xml(name, signal_info):\n+    return element('signal', name=name,\n+                   children=[\n+                       element('arg', type=arg_type) for arg_type in signal_info['in']\n+                   ])\n+\n+\n+def interface_to_xml(name, interface_info):\n+    return element('interface', name=name,\n+                   children=[\n+                       *(method_to_xml(name, info) for name, info in interface_info['methods'].items()),\n+                       *(property_to_xml(name, info) for name, info in interface_info['properties'].items()),\n+                       *(signal_to_xml(name, info) for name, info in interface_info['signals'].items()),\n+                   ])\n+\n+\n+def to_xml(interfaces):\n+    node = element('node', children=(interface_to_xml(name, members) for name, members in interfaces.items()))\n+    return ET.tostring(node, encoding='unicode')\n+''',\n+  'cockpit/_vendor/systemd_ctypes/libsystemd.py': r'''# systemd_ctypes\n+#\n+# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n+\n+import ctypes\n+import os\n+import sys\n+from typing import ClassVar, List, Optional, Tuple, Union\n+\n+from .inotify import inotify_event\n+from .librarywrapper import (\n+    Callback,\n+    Errno,\n+    Reference,\n+    ReferenceType,\n+    UserData,\n+    WeakReference,\n+    byref,\n+)\n+from .typing import Annotated\n+\n+\n+class Trampoline(ReferenceType):\n+    deferred: 'ClassVar[list[Callback] | None]' = None\n+    trampoline: Callback\n+    userdata: UserData = None\n+\n+    def cancel(self) -> None:\n+        self._unref()\n+        self.value = None\n+\n+    def __del__(self) -> None:\n+        # This might be the currently-dispatching callback \u2014 make sure we don't\n+        # destroy the trampoline before we return.  We drop the deferred list\n+        # from the event loop when we're sure we're not doing any dispatches.\n+        if Trampoline.deferred is not None:\n+            Trampoline.deferred.append(self.trampoline)\n+        if self.value is not None:\n+            self._unref()\n+\n+\n+class sd_bus_error(ctypes.Structure):\n+    # This is ABI, so we are safe to assume it doesn't change.\n+    # Unfortunately, we lack anything like sd_bus_error_new().\n+    _fields_ = (\n+        (\"name\", ctypes.c_char_p),\n+        (\"message\", ctypes.c_char_p),\n+        (\"_need_free\", ctypes.c_int),\n+    )\n+\n+    def get(self) -> Tuple[str, str]:\n+        return self.name.decode(), self.message.decode()\n+\n+    def set(self, name: str, message: str) -> None:\n+        result = libsystemd.sd_bus_error_set(byref(self), name, message)\n+        if result < 0:\n+            raise OSError(-result, f\"sd_bus_error_set: {os.strerror(-result)}\")\n+\n+    def __del__(self) -> None:\n+        if self._b_needsfree_:\n+            libsystemd.sd_bus_error_free(byref(self))\n+\n+\n+class sd_id128(ctypes.Structure):\n+    # HACK: Pass-by-value of array-containing-structs is broken on Python\n+    # 3.6. See https://bugs.python.org/issue22273\n+    _fields_: List[Tuple[str, type]] = (\n+        [(\"bytes\", ctypes.c_uint8 * 16)]\n+        if sys.version_info >= (3, 7, 0)\n+        else [(\"one\", ctypes.c_uint64), (\"two\", ctypes.c_uint64)]\n+    )\n+\n+\n+class sd_event_source(Trampoline):\n+    ...\n+\n+\n+class sd_event(ReferenceType):\n+    def _add_inotify(\n+        self: 'sd_event',\n+        source: Reference[sd_event_source],\n+        path: str,\n+        event: int,\n+        callback: Callback,\n+        user_data: UserData,\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def dispatch(self: 'sd_event') -> Union[None, Errno]:\n+        ...\n+\n+    def get_fd(self: 'sd_event') -> Union[int, Errno]:\n+        raise NotImplementedError\n+\n+    def get_state(self: 'sd_event') -> Union[int, Errno]:\n+        raise NotImplementedError\n+\n+    def loop(self: 'sd_event') -> Union[None, Errno]:\n+        ...\n+\n+    def prepare(self: 'sd_event') -> Union[None, Errno]:\n+        ...\n+\n+    def wait(\n+        self: 'sd_event', timeout: Annotated[int, ctypes.c_uint64]\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    @staticmethod\n+    def _default(ret: Reference['sd_event']) -> Union[None, Errno]:\n+        ...\n+\n+\n+class sd_bus_slot(Trampoline):\n+    ...\n+\n+\n+class sd_bus_message(ReferenceType):\n+    def rewind(self: 'sd_bus_message', complete: bool) -> Union[None, Errno]:\n+        ...\n+\n+    def _get_error(self: 'sd_bus_message') -> Reference[sd_bus_error]:\n+        raise NotImplementedError\n+\n+    def has_signature(self: 'sd_bus_message', signature: str) -> Union[bool, Errno]:\n+        raise NotImplementedError\n+\n+    def is_method_error(self: 'sd_bus_message', name: str) -> Union[bool, Errno]:\n+        raise NotImplementedError\n+\n+    def _new_method_errnof(\n+            self: 'sd_bus_message',\n+            message: Reference['sd_bus_message'],\n+            error: int,\n+            format_str: str,\n+            first_arg: str\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def _new_method_errorf(\n+        self: 'sd_bus_message',\n+        m: Reference['sd_bus_message'],\n+        name: str,\n+        format_str: str,\n+        first_arg: str\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def _new_method_return(\n+        self: 'sd_bus_message', m: Reference['sd_bus_message']\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def seal(\n+        self: 'sd_bus_message',\n+        cookie: Annotated[int, ctypes.c_uint64],\n+        timeout: Annotated[int, ctypes.c_uint64],\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def _get_bus(self: 'sd_bus_message') -> WeakReference:\n+        raise NotImplementedError\n+\n+    def get_destination(self: 'sd_bus_message') -> str:\n+        raise NotImplementedError\n+\n+    def get_interface(self: 'sd_bus_message') -> str:\n+        raise NotImplementedError\n+\n+    def get_member(self: 'sd_bus_message') -> str:\n+        raise NotImplementedError\n+\n+    def get_path(self: 'sd_bus_message') -> str:\n+        raise NotImplementedError\n+\n+    def get_sender(self: 'sd_bus_message') -> Optional[str]:\n+        raise NotImplementedError\n+\n+    def get_signature(self: 'sd_bus_message', complete: bool) -> str:\n+        raise NotImplementedError\n+\n+\n+class sd_bus(ReferenceType):\n+    def _add_match(\n+        self: 'sd_bus',\n+        slot: Reference[sd_bus_slot],\n+        match: str,\n+        handler: Callback,\n+        user_data: UserData,\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def _add_match_async(\n+        self: 'sd_bus',\n+        slot: Reference[sd_bus_slot],\n+        match: str,\n+        callback: Callback,\n+        install_callback: Callback,\n+        user_data: UserData,\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def _add_object(\n+        self: 'sd_bus',\n+        slot: Reference[sd_bus_slot],\n+        path: str,\n+        callback: Callback,\n+        user_data: UserData,\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def attach_event(\n+        self: 'sd_bus', event: Optional[sd_event], priority: int\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def _call(\n+        self: 'sd_bus',\n+        message: sd_bus_message,\n+        timeout: Annotated[int, ctypes.c_uint64],\n+        ret_error: Reference[sd_bus_error],\n+        reply: Reference[sd_bus_message],\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def _call_async(\n+        self: 'sd_bus',\n+        slot: Reference[sd_bus_slot],\n+        message: sd_bus_message,\n+        callback: Callback,\n+        user_data: UserData,\n+        timeout_usec: Annotated[int, ctypes.c_uint64],\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def flush(self: 'sd_bus') -> Union[None, Errno]:\n+        ...\n+\n+    def get_fd(self: 'sd_bus') -> Union[int, Errno]:\n+        raise NotImplementedError\n+\n+    def _message_new_method_call(\n+        self: 'sd_bus',\n+        message: Reference[sd_bus_message],\n+        destination: Optional[str],\n+        path: str,\n+        interface: str,\n+        member: str,\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def _message_new_signal(\n+        self: 'sd_bus',\n+        message: Reference[sd_bus_message],\n+        path: str,\n+        interface: str,\n+        member: str,\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def release_name(self: 'sd_bus', name: str) -> Union[None, Errno]:\n+        ...\n+\n+    def request_name(\n+        self: 'sd_bus', name: str, flags: Annotated[int, ctypes.c_uint64]\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def set_address(self: 'sd_bus', address: str) -> Union[None, Errno]:\n+        ...\n+\n+    def set_bus_client(self: 'sd_bus', b: bool) -> Union[None, Errno]:\n+        ...\n+\n+    def set_fd(self: 'sd_bus', input_fd: int, output_fd: int) -> Union[None, Errno]:\n+        ...\n+\n+    def set_server(self: 'sd_bus', b: bool, bus_d: sd_id128) -> Union[None, Errno]:\n+        ...\n+\n+    def start(self: 'sd_bus') -> Union[None, Errno]:\n+        ...\n+\n+    def wait(\n+        self: 'sd_bus', timeout_usec: Annotated[int, ctypes.c_uint64]\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    def send(\n+        self: 'sd_bus', message: sd_bus_message, cookie: Optional[Reference[ctypes.c_uint64]]\n+    ) -> Union[None, Errno]:\n+        ...\n+\n+    @staticmethod\n+    def _default_system(ret: Reference['sd_bus']) -> Union[None, Errno]:\n+        ...\n+\n+    @staticmethod\n+    def _default_user(ret: Reference['sd_bus']) -> Union[None, Errno]:\n+        ...\n+\n+    @staticmethod\n+    def _new(ret: Reference['sd_bus']) -> Union[None, Errno]:\n+        ...\n+\n+\n+sd_bus_message_handler_t = ctypes.CFUNCTYPE(\n+    ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(sd_bus_error))\n+sd_event_inotify_handler_t = ctypes.CFUNCTYPE(\n+    ctypes.c_int, ctypes.c_void_p, ctypes.POINTER(inotify_event), ctypes.c_void_p)\n+\n+\n+libsystemd = ctypes.CDLL(\"libsystemd.so.0\")\n+for cls in {\n+    sd_bus,\n+    sd_bus_message,\n+    sd_bus_slot,\n+    sd_event,\n+    sd_event_source,\n+}:\n+    cls._install_cfuncs(libsystemd)\n+'''.encode('utf-8'),\n+  'cockpit/_vendor/systemd_ctypes/typing.py': br'''import typing\n+from typing import TYPE_CHECKING\n+\n+# The goal here is to continue to work on Python 3.6 while pretending to have\n+# access to some modern typing features.  The shims provided here are only\n+# enough for what we need for systemd_ctypes to work at runtime.\n+\n+\n+if TYPE_CHECKING:\n+    # See https://github.com/python/mypy/issues/1153 for why we do this separately\n+    from typing import Annotated, ForwardRef, TypeGuard, get_args, get_origin\n+\n+else:\n+    # typing.get_args() and .get_origin() appeared in Python 3.8 but Annotated\n+    # arrived in 3.9.  Unfortunately, it's difficult to implement a mocked up\n+    # version of Annotated which works with the real typing.get_args() and\n+    # .get_origin() in Python 3.8, so we use our own versions there as well.\n+    try:\n+        from typing import Annotated, get_args, get_origin\n+    except ImportError:\n+        class AnnotatedMeta(type):\n+            def __getitem__(cls, params):\n+                class AnnotatedType:\n+                    __origin__ = Annotated\n+                    __args__ = params\n+                return AnnotatedType\n+\n+        class Annotated(metaclass=AnnotatedMeta):\n+            pass\n+\n+        def get_args(annotation: typing.Any) -> typing.Tuple[typing.Any]:\n+            return getattr(annotation, '__args__', ())\n+\n+        def get_origin(annotation: typing.Any) -> typing.Any:\n+            return getattr(annotation, '__origin__', None)\n+\n+    try:\n+        from typing import ForwardRef\n+    except ImportError:\n+        from typing import _ForwardRef as ForwardRef\n+\n+    try:\n+        from typing import TypeGuard\n+    except ImportError:\n+        T = typing.TypeVar('T')\n+\n+        class TypeGuard(typing.Generic[T]):\n+            pass\n+\n+\n+__all__ = (\n+    'Annotated',\n+    'ForwardRef',\n+    'TypeGuard',\n+    'get_args',\n+    'get_origin',\n+    'TYPE_CHECKING',\n+)\n+''',\n+  'cockpit/_vendor/systemd_ctypes/inotify.py': br'''# systemd_ctypes\n+#\n+# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n+\n+import ctypes\n+from enum import IntFlag, auto\n+from typing import Optional\n+\n+\n+class inotify_event(ctypes.Structure):\n+    _fields_ = (\n+        ('wd', ctypes.c_int32),\n+        ('mask', ctypes.c_uint32),\n+        ('cookie', ctypes.c_uint32),\n+        ('len', ctypes.c_uint32),\n+    )\n+\n+    @property\n+    def name(self) -> Optional[bytes]:\n+        if self.len == 0:\n+            return None\n+\n+        class event_with_name(ctypes.Structure):\n+            _fields_ = (*inotify_event._fields_, ('name', ctypes.c_char * self.len))\n+\n+        name = ctypes.cast(ctypes.addressof(self), ctypes.POINTER(event_with_name)).contents.name\n+        assert isinstance(name, bytes)\n+        return name\n+\n+\n+class Event(IntFlag):\n+    ACCESS = auto()\n+    MODIFY = auto()\n+    ATTRIB = auto()\n+    CLOSE_WRITE = auto()\n+    CLOSE_NOWRITE = auto()\n+    OPEN = auto()\n+    MOVED_FROM = auto()\n+    MOVED_TO = auto()\n+    CREATE = auto()\n+    DELETE = auto()\n+    DELETE_SELF = auto()\n+    MOVE_SELF = auto()\n+\n+    UNMOUNT = 1 << 13\n+    Q_OVERFLOW = auto()\n+    IGNORED = auto()\n+\n+    ONLYDIR = 1 << 24\n+    DONT_FOLLOW = auto()\n+    EXCL_UNLINK = auto()\n+\n+    MASK_CREATE = 1 << 28\n+    MASK_ADD = auto()\n+    ISDIR = auto()\n+    ONESHOT = auto()\n+\n+    CLOSE = CLOSE_WRITE | CLOSE_NOWRITE\n+    MOVE = MOVED_FROM | MOVED_TO\n+    CHANGED = (MODIFY | ATTRIB | CLOSE_WRITE | MOVE |\n+               CREATE | DELETE | DELETE_SELF | MOVE_SELF)\n+''',\n+  'cockpit/_vendor/bei/tmpfs.py': br'''import os\n+import subprocess\n+import sys\n+import tempfile\n+\n+\n+def main(*command: str) -> None:\n+    with tempfile.TemporaryDirectory() as tmpdir:\n+        os.chdir(tmpdir)\n+\n+        for key, value in __loader__.get_contents().items():\n+            if key.startswith('tmpfs/'):\n+                subdir = os.path.dirname(key)\n+                os.makedirs(subdir, exist_ok=True)\n+                with open(key, 'wb') as fp:\n+                    fp.write(value)\n+\n+        os.chdir('tmpfs')\n+\n+        result = subprocess.run(command, check=False)\n+        sys.exit(result.returncode)\n+''',\n+  'cockpit/_vendor/bei/bootloader.py': br'''# beiboot - Remote bootloader for Python\n+#\n+# Copyright (C) 2023 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n+\n+import textwrap\n+from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple\n+\n+GADGETS = {\n+    \"_frame\": r\"\"\"\n+        import sys\n+        import traceback\n+        try:\n+            ...\n+        except SystemExit:\n+            raise\n+        except BaseException:\n+            command('beiboot.exc', traceback.format_exc())\n+            sys.exit(37)\n+    \"\"\",\n+    \"try_exec\": r\"\"\"\n+        import contextlib\n+        import os\n+        def try_exec(argv):\n+            with contextlib.suppress(OSError):\n+                os.execvp(argv[0], argv)\n+    \"\"\",\n+    \"boot_xz\": r\"\"\"\n+        import lzma\n+        import sys\n+        def boot_xz(filename, size, args=[], send_end=False):\n+            command('beiboot.provide', size)\n+            src_xz = sys.stdin.buffer.read(size)\n+            src = lzma.decompress(src_xz)\n+            sys.argv = [filename, *args]\n+            if send_end:\n+                end()\n+            exec(src, {\n+                '__name__': '__main__',\n+                '__self_source__': src_xz,\n+                '__file__': filename})\n+            sys.exit()\n+    \"\"\",\n+}\n+\n+\n+def split_code(code: str, imports: Set[str]) -> Iterable[Tuple[str, str]]:\n+    for line in textwrap.dedent(code).splitlines():\n+        text = line.lstrip(\" \")\n+        if text.startswith(\"import \"):\n+            imports.add(text)\n+        elif text:\n+            spaces = len(line) - len(text)\n+            assert (spaces % 4) == 0\n+            yield \"\\t\" * (spaces // 4), text\n+\n+\n+def yield_body(user_gadgets: Dict[str, str],\n+               steps: Sequence[Tuple[str, Sequence[object]]],\n+               imports: Set[str]) -> Iterable[Tuple[str, str]]:\n+    # Allow the caller to override our gadgets, but keep the original\n+    # variable for use in the next step.\n+    gadgets = dict(GADGETS, **user_gadgets)\n+\n+    # First emit the gadgets.  Emit all gadgets provided by the caller,\n+    # plus any referred to by the caller's list of steps.\n+    provided_gadgets = set(user_gadgets)\n+    step_gadgets = {name for name, _args in steps}\n+    for name in provided_gadgets | step_gadgets:\n+        yield from split_code(gadgets[name], imports)\n+\n+    # Yield functions mentioned in steps from the caller\n+    for name, args in steps:\n+        yield '', name + repr(tuple(args))\n+\n+\n+def make_bootloader(steps: Sequence[Tuple[str, Sequence[object]]],\n+                    gadgets: Optional[Dict[str, str]] = None) -> str:\n+    imports: Set[str] = set()\n+    lines: List[str] = []\n+\n+    for frame_spaces, frame_text in split_code(GADGETS[\"_frame\"], imports):\n+        if frame_text == \"...\":\n+            for spaces, text in yield_body(gadgets or {}, steps, imports):\n+                lines.append(frame_spaces + spaces + text)\n+        else:\n+            lines.append(frame_spaces + frame_text)\n+\n+    return \"\".join(f\"{line}\\n\" for line in [*imports, *lines]) + \"\\n\"\n+''',\n+  'cockpit/_vendor/bei/__init__.py': br'''''',\n+  'cockpit/_vendor/bei/spawn.py': br'''\"\"\"Helper to create a beipack to spawn a command with files in a tmpdir\"\"\"\n+\n+import argparse\n+import os\n+import sys\n+\n+from . import pack, tmpfs\n+\n+\n+def main() -> None:\n+    parser = argparse.ArgumentParser()\n+    parser.add_argument('--file', '-f', action='append')\n+    parser.add_argument('command', nargs='+', help='The command to execute')\n+    args = parser.parse_args()\n+\n+    contents = {\n+        '_beitmpfs.py': tmpfs.__spec__.loader.get_data(tmpfs.__spec__.origin)\n+    }\n+\n+    if args.file is not None:\n+        files = args.file\n+    else:\n+        file = args.command[-1]\n+        files = [file]\n+        args.command[-1] = './' + os.path.basename(file)\n+\n+    for filename in files:\n+        with open(filename, 'rb') as file:\n+            basename = os.path.basename(filename)\n+            contents[f'tmpfs/{basename}'] = file.read()\n+\n+    script = pack.pack(contents, '_beitmpfs:main', '*' + repr(args.command))\n+    sys.stdout.write(script)\n+\n+\n+if __name__ == '__main__':\n+    main()\n+''',\n+  'cockpit/_vendor/bei/beipack.py': br'''# beipack - Remote bootloader for Python\n+#\n+# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n+\n+import argparse\n+import binascii\n+import lzma\n+import os\n+import sys\n+import tempfile\n+import zipfile\n+from typing import Dict, Iterable, List, Optional, Set, Tuple\n+\n+from .data import read_data_file\n+\n+\n+def escape_string(data: str) -> str:\n+    # Avoid mentioning ' ' ' literally, to make our own packing a bit prettier\n+    triplequote = \"'\" * 3\n+    if triplequote not in data:\n+        return \"r\" + triplequote + data + triplequote\n+    if '\"\"\"' not in data:\n+        return 'r\"\"\"' + data + '\"\"\"'\n+    return repr(data)\n+\n+\n+def ascii_bytes_repr(data: bytes) -> str:\n+    return 'b' + escape_string(data.decode('ascii'))\n+\n+\n+def utf8_bytes_repr(data: bytes) -> str:\n+    return escape_string(data.decode('utf-8')) + \".encode('utf-8')\"\n+\n+\n+def base64_bytes_repr(data: bytes, imports: Set[str]) -> str:\n+    # base85 is smaller, but base64 is in C, and ~20x faster.\n+    # when compressing with `xz -e` the size difference is marginal.\n+    imports.add('from binascii import a2b_base64')\n+    encoded = binascii.b2a_base64(data).decode('ascii').strip()\n+    return f'a2b_base64(\"{encoded}\")'\n+\n+\n+def bytes_repr(data: bytes, imports: Set[str]) -> str:\n+    # Strategy:\n+    #   if the file is ascii, encode it directly as bytes\n+    #   otherwise, if it's UTF-8, use a unicode string and encode\n+    #   otherwise, base64\n+\n+    try:\n+        return ascii_bytes_repr(data)\n+    except UnicodeDecodeError:\n+        # it's not ascii\n         pass\n \n-    def close(self) -> None:\n+    # utf-8\n+    try:\n+        return utf8_bytes_repr(data)\n+    except UnicodeDecodeError:\n+        # it's not utf-8\n         pass\n \n-    async def handle_via(self, responder: 'SshAskpassResponder') -> None:\n-        try:\n-            response = await self.dispatch(responder)\n-            if response is not None:\n-                self.reply(response)\n-        finally:\n-            self.close()\n+    return base64_bytes_repr(data, imports)\n \n-    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n-        return await responder.do_prompt(self)\n \n+def dict_repr(contents: Dict[str, bytes], imports: Set[str]) -> str:\n+    return ('{\\n' +\n+            ''.join(f'  {repr(k)}: {bytes_repr(v, imports)},\\n'\n+                    for k, v in contents.items()) +\n+            '}')\n \n-class SSHAskpassPrompt(AskpassPrompt):\n-    # The valid answers to prompts of this type.  If this is None then any\n-    # answer is permitted.  If it's a sequence then only answers from the\n-    # sequence are permitted.  If it's an empty sequence, then no answer is\n-    # permitted (ie: the askpass callback should never return).\n-    answers: 'ClassVar[Sequence[str] | None]' = None\n \n-    # Patterns to capture.  `_pattern` *must* match.\n-    _pattern: ClassVar[str]\n-    # `_extra_patterns` can fill in extra class attributes if they match.\n-    _extra_patterns: ClassVar[Sequence[str]] = ()\n+def pack(contents: Dict[str, bytes],\n+         entrypoint: Optional[str] = None,\n+         args: str = '') -> str:\n+    \"\"\"Creates a beipack with the given `contents`.\n \n-    def __init__(self, prompt: str, messages: str, stderr: str, match: Match) -> None:\n-        super().__init__(prompt, messages, stderr)\n-        self.__dict__.update(match.groupdict())\n+    If `entrypoint` is given, it should be an entry point which is run as the\n+    \"main\" function.  It is given in the `package.module:func format` such that\n+    the following code is emitted:\n \n-        for pattern in self._extra_patterns:\n-            extra_match = re.search(with_helpers(pattern), messages, re.M)\n-            if extra_match is not None:\n-                self.__dict__.update(extra_match.groupdict())\n+        from package.module import func as main\n+        main()\n \n+    Additionally, if `args` is given, it is written verbatim between the parens\n+    of the call to main (ie: it should already be in Python syntax).\n+    \"\"\"\n \n-# Specific prompts\n-HELPERS = {\n-    \"%{algorithm}\": r\"(?P<algorithm>\\b[-\\w]+\\b)\",\n-    \"%{filename}\": r\"(?P<filename>.+)\",\n-    \"%{fingerprint}\": r\"(?P<fingerprint>SHA256:[0-9A-Za-z+/]{43})\",\n-    \"%{hostname}\": r\"(?P<hostname>[^ @']+)\",\n-    \"%{pkcs11_id}\": r\"(?P<pkcs11_id>.+)\",\n-    \"%{username}\": r\"(?P<username>[^ @']+)\",\n-}\n+    loader = read_data_file('beipack_loader.py')\n+    lines = [line for line in loader.splitlines() if line]\n+    lines.append('')\n \n+    imports = {'import sys'}\n+    contents_txt = dict_repr(contents, imports)\n+    lines.extend(imports)\n+    lines.append(f'sys.meta_path.insert(0, BeipackLoader({contents_txt}))')\n \n-class SshPasswordPrompt(SSHAskpassPrompt):\n-    _pattern = r\"%{username}@%{hostname}'s password: \"\n-    username: 'str | None' = None\n-    hostname: 'str | None' = None\n+    if entrypoint:\n+        package, main = entrypoint.split(':')\n+        lines.append(f'from {package} import {main} as main')\n+        lines.append(f'main({args})')\n \n-    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n-        return await responder.do_password_prompt(self)\n+    return ''.join(f'{line}\\n' for line in lines)\n \n \n-class SshPassphrasePrompt(SSHAskpassPrompt):\n-    _pattern = r\"Enter passphrase for key '%{filename}': \"\n-    filename: str\n+def collect_contents(filenames: List[str],\n+                     relative_to: Optional[str] = None) -> Dict[str, bytes]:\n+    contents: Dict[str, bytes] = {}\n \n-    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n-        return await responder.do_passphrase_prompt(self)\n+    for filename in filenames:\n+        with open(filename, 'rb') as file:\n+            contents[os.path.relpath(filename, start=relative_to)] = file.read()\n \n+    return contents\n \n-class SshFIDOPINPrompt(SSHAskpassPrompt):\n-    _pattern = r\"Enter PIN for %{algorithm} key %{filename}: \"\n-    algorithm: str\n-    filename: str\n \n-    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str  | None':\n-        return await responder.do_fido_pin_prompt(self)\n+def collect_module(name: str, *, recursive: bool) -> Dict[str, bytes]:\n+    import importlib.resources\n+    from importlib.resources.abc import Traversable\n \n+    def walk(path: str, entry: Traversable) -> Iterable[Tuple[str, bytes]]:\n+        for item in entry.iterdir():\n+            itemname = f'{path}/{item.name}'\n+            if item.is_file():\n+                yield itemname, item.read_bytes()\n+            elif recursive and item.name != '__pycache__':\n+                yield from walk(itemname, item)\n \n-class SshFIDOUserPresencePrompt(SSHAskpassPrompt):\n-    _pattern = r\"Confirm user presence for key %{algorithm} %{fingerprint}\"\n-    answers = ()\n-    algorithm: str\n-    fingerprint: str\n+    return dict(walk(name.replace('.', '/'), importlib.resources.files(name)))\n \n-    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n-        return await responder.do_fido_user_presence_prompt(self)\n \n+def collect_zip(filename: str) -> Dict[str, bytes]:\n+    contents = {}\n \n-class SshPKCS11PINPrompt(SSHAskpassPrompt):\n-    _pattern = r\"Enter PIN for '%{pkcs11_id}': \"\n-    pkcs11_id: str\n+    with zipfile.ZipFile(filename) as file:\n+        for entry in file.filelist:\n+            if '.dist-info/' in entry.filename:\n+                continue\n+            contents[entry.filename] = file.read(entry)\n \n-    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n-        return await responder.do_pkcs11_pin_prompt(self)\n+    return contents\n \n \n-class SshHostKeyPrompt(SSHAskpassPrompt):\n-    _pattern = r\"Are you sure you want to continue connecting \\(yes/no(/\\[fingerprint\\])?\\)\\? \"\n-    _extra_patterns = [\n-        r\"%{fingerprint}[.]$\",\n-        r\"^%{algorithm} key fingerprint is\",\n-        r\"^The fingerprint for the %{algorithm} key sent by the remote host is$\"\n-    ]\n-    answers = ('yes', 'no')\n-    algorithm: str\n-    fingerprint: str\n+def collect_pep517(path: str) -> Dict[str, bytes]:\n+    with tempfile.TemporaryDirectory() as tmpdir:\n+        import build\n+        builder = build.ProjectBuilder(path)\n+        wheel = builder.build('wheel', tmpdir)\n+        return collect_zip(wheel)\n \n-    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n-        return await responder.do_host_key_prompt(self)\n \n+def main() -> None:\n+    parser = argparse.ArgumentParser()\n+    parser.add_argument('--python', '-p',\n+                        help=\"add a #!python3 interpreter line using the given path\")\n+    parser.add_argument('--xz', '-J', action='store_true',\n+                        help=\"compress the output with `xz`\")\n+    parser.add_argument('--topdir',\n+                        help=\"toplevel directory (paths are stored relative to this)\")\n+    parser.add_argument('--output', '-o',\n+                        help=\"write output to a file (default: stdout)\")\n+    parser.add_argument('--main', '-m', metavar='MODULE:FUNC',\n+                        help=\"use FUNC from MODULE as the main function\")\n+    parser.add_argument('--main-args', metavar='ARGS',\n+                        help=\"arguments to main() in Python syntax\", default='')\n+    parser.add_argument('--module', action='append', default=[],\n+                        help=\"collect installed modules (recursively)\")\n+    parser.add_argument('--zip', '-z', action='append', default=[],\n+                        help=\"include files from a zipfile (or wheel)\")\n+    parser.add_argument('--build', metavar='DIR', action='append', default=[],\n+                        help=\"PEP-517 from a given source directory\")\n+    parser.add_argument('files', nargs='*',\n+                        help=\"files to include in the beipack\")\n+    args = parser.parse_args()\n+\n+    contents = collect_contents(args.files, relative_to=args.topdir)\n \n-def with_helpers(pattern: str) -> str:\n-    for name, helper in HELPERS.items():\n-        pattern = pattern.replace(name, helper)\n+    for file in args.zip:\n+        contents.update(collect_zip(file))\n \n-    assert '%{' not in pattern\n-    return pattern\n+    for name in args.module:\n+        contents.update(collect_module(name, recursive=True))\n \n+    for path in args.build:\n+        contents.update(collect_pep517(path))\n \n-def categorize_ssh_prompt(string: str, stderr: str) -> AskpassPrompt:\n-    classes = [\n-        SshFIDOPINPrompt,\n-        SshFIDOUserPresencePrompt,\n-        SshHostKeyPrompt,\n-        SshPKCS11PINPrompt,\n-        SshPassphrasePrompt,\n-        SshPasswordPrompt,\n-    ]\n+    result = pack(contents, args.main, args.main_args).encode('utf-8')\n \n-    # The last line is the line after the last newline character, excluding the\n-    # optional final newline character.  eg: \"x\\ny\\nLAST\\n\" or \"x\\ny\\nLAST\"\n-    second_last_newline = string.rfind('\\n', 0, -1)\n-    if second_last_newline >= 0:\n-        last_line = string[second_last_newline + 1:]\n-        extras = string[:second_last_newline + 1]\n+    if args.python:\n+        result = b'#!' + args.python.encode('ascii') + b'\\n' + result\n+\n+    if args.xz:\n+        result = lzma.compress(result, preset=lzma.PRESET_EXTREME)\n+\n+    if args.output:\n+        with open(args.output, 'wb') as file:\n+            file.write(result)\n     else:\n-        last_line = string\n-        extras = ''\n+        if args.xz and os.isatty(1):\n+            sys.exit('refusing to write compressed output to a terminal')\n+        sys.stdout.buffer.write(result)\n \n-    for cls in classes:\n-        pattern = with_helpers(cls._pattern)\n-        match = re.fullmatch(pattern, last_line)\n-        if match is not None:\n-            return cls(last_line, extras, stderr, match)\n \n-    return AskpassPrompt(last_line, extras, stderr)\n+if __name__ == '__main__':\n+    main()\n+''',\n+  'cockpit/_vendor/bei/beiboot.py': br\"\"\"# beiboot - Remote bootloader for Python\n+#\n+# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+#\n+# This program is free software: you can redistribute it and/or modify\n+# it under the terms of the GNU General Public License as published by\n+# the Free Software Foundation, either version 3 of the License, or\n+# (at your option) any later version.\n+#\n+# This program is distributed in the hope that it will be useful,\n+# but WITHOUT ANY WARRANTY; without even the implied warranty of\n+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n+# GNU General Public License for more details.\n+#\n+# You should have received a copy of the GNU General Public License\n+# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n \n+import argparse\n+import asyncio\n+import os\n+import shlex\n+import subprocess\n+import sys\n+import threading\n+from typing import IO, List, Sequence, Tuple\n \n-class SshAskpassResponder(AskpassHandler):\n-    async def do_askpass(self, stderr: str, prompt: str, hint: str) -> 'str | None':\n-        return await categorize_ssh_prompt(prompt, stderr).dispatch(self)\n+from .bootloader import make_bootloader\n \n-    async def do_prompt(self, prompt: AskpassPrompt) -> 'str | None':\n-        # Default fallback for unrecognised message types: unimplemented\n-        return None\n \n-    async def do_fido_pin_prompt(self, prompt: SshFIDOPINPrompt) -> 'str | None':\n-        return await self.do_prompt(prompt)\n+def get_python_command(local: bool = False,\n+                       tty: bool = False,\n+                       sh: bool = False) -> Sequence[str]:\n+    interpreter = sys.executable if local else 'python3'\n+    command: Sequence[str]\n \n-    async def do_fido_user_presence_prompt(self, prompt: SshFIDOUserPresencePrompt) -> 'str | None':\n-        return await self.do_prompt(prompt)\n+    if tty:\n+        command = (interpreter, '-iq')\n+    else:\n+        command = (\n+            interpreter, '-ic',\n+            # https://github.com/python/cpython/issues/93139\n+            '''\" - beiboot - \"; import sys; sys.ps1 = ''; sys.ps2 = '';'''\n+        )\n \n-    async def do_host_key_prompt(self, prompt: SshHostKeyPrompt) -> 'str | None':\n-        return await self.do_prompt(prompt)\n+    if sh:\n+        command = (' '.join(shlex.quote(arg) for arg in command),)\n \n-    async def do_pkcs11_pin_prompt(self, prompt: SshPKCS11PINPrompt) -> 'str | None':\n-        return await self.do_prompt(prompt)\n+    return command\n \n-    async def do_passphrase_prompt(self, prompt: SshPassphrasePrompt) -> 'str | None':\n-        return await self.do_prompt(prompt)\n \n-    async def do_password_prompt(self, prompt: SshPasswordPrompt) -> 'str | None':\n-        return await self.do_prompt(prompt)\n+def get_ssh_command(*args: str, tty: bool = False) -> Sequence[str]:\n+    return ('ssh',\n+            *(['-t'] if tty else ()),\n+            *args,\n+            *get_python_command(tty=tty, sh=True))\n+\n+\n+def get_container_command(*args: str, tty: bool = False) -> Sequence[str]:\n+    return ('podman', 'exec', '--interactive',\n+            *(['--tty'] if tty else ()),\n+            *args,\n+            *get_python_command(tty=tty))\n+\n+\n+def get_command(*args: str, tty: bool = False, sh: bool = False) -> Sequence[str]:\n+    return (*args, *get_python_command(local=True, tty=tty, sh=sh))\n+\n+\n+def splice_in_thread(src: int, dst: IO[bytes]) -> None:\n+    def _thread() -> None:\n+        # os.splice() only in Python 3.10\n+        with dst:\n+            block_size = 1 << 20\n+            while True:\n+                data = os.read(src, block_size)\n+                if not data:\n+                    break\n+                dst.write(data)\n+                dst.flush()\n+\n+    threading.Thread(target=_thread, daemon=True).start()\n+\n+\n+def send_and_splice(command: Sequence[str], script: bytes) -> None:\n+    with subprocess.Popen(command, stdin=subprocess.PIPE) as proc:\n+        assert proc.stdin is not None\n+        proc.stdin.write(script)\n+\n+        splice_in_thread(0, proc.stdin)\n+        sys.exit(proc.wait())\n+\n+\n+def send_xz_and_splice(command: Sequence[str], script: bytes) -> None:\n+    import ferny\n+\n+    class Responder(ferny.InteractionResponder):\n+        async def do_custom_command(self,\n+                                    command: str,\n+                                    args: Tuple,\n+                                    fds: List[int],\n+                                    stderr: str) -> None:\n+            assert proc.stdin is not None\n+            if command == 'beiboot.provide':\n+                proc.stdin.write(script)\n+                proc.stdin.flush()\n+\n+    agent = ferny.InteractionAgent(Responder())\n+    with subprocess.Popen(command, stdin=subprocess.PIPE, stderr=agent) as proc:\n+        assert proc.stdin is not None\n+        proc.stdin.write(make_bootloader([\n+            ('boot_xz', ('script.py.xz', len(script), [], True)),\n+        ], gadgets=ferny.BEIBOOT_GADGETS).encode())\n+        proc.stdin.flush()\n+\n+        asyncio.run(agent.communicate())\n+        splice_in_thread(0, proc.stdin)\n+        sys.exit(proc.wait())\n+\n+\n+def main() -> None:\n+    parser = argparse.ArgumentParser()\n+    parser.add_argument('--sh', action='store_true',\n+                        help='Pass Python interpreter command as shell-script')\n+    parser.add_argument('--xz', help=\"the xz to run remotely\")\n+    parser.add_argument('--script',\n+                        help=\"the script to run remotely (must be repl-friendly)\")\n+    parser.add_argument('command', nargs='*')\n+\n+    args = parser.parse_args()\n+    tty = not args.script and os.isatty(0)\n+\n+    if args.command == []:\n+        command = get_python_command(tty=tty)\n+    elif args.command[0] == 'ssh':\n+        command = get_ssh_command(*args.command[1:], tty=tty)\n+    elif args.command[0] == 'container':\n+        command = get_container_command(*args.command[1:], tty=tty)\n+    else:\n+        command = get_command(*args.command, tty=tty, sh=args.sh)\n+\n+    if args.script:\n+        with open(args.script, 'rb') as file:\n+            script = file.read()\n+\n+        send_and_splice(command, script)\n+\n+    elif args.xz:\n+        with open(args.xz, 'rb') as file:\n+            script = file.read()\n+\n+        send_xz_and_splice(command, script)\n+\n+    else:\n+        # If we're streaming from stdin then this is a lot easier...\n+        os.execlp(command[0], *command)\n+\n+    # Otherwise, \"full strength\"\n+\n+if __name__ == '__main__':\n+    main()\n+\"\"\",\n+  'cockpit/_vendor/bei/data/beipack_loader.py': br'''# beipack https://github.com/allisonkarlitskaya/beipack\n+\n+import importlib.abc\n+import importlib.util\n+import io\n+import sys\n+from types import ModuleType\n+from typing import BinaryIO, Dict, Iterator, Optional, Sequence\n+\n+\n+class BeipackLoader(importlib.abc.SourceLoader, importlib.abc.MetaPathFinder):\n+    if sys.version_info >= (3, 11):\n+        from importlib.resources.abc import ResourceReader as AbstractResourceReader\n+    else:\n+        AbstractResourceReader = object\n+\n+    class ResourceReader(AbstractResourceReader):\n+        def __init__(self, contents: Dict[str, bytes], filename: str) -> None:\n+            self._contents = contents\n+            self._dir = f'{filename}/'\n+\n+        def is_resource(self, resource: str) -> bool:\n+            return f'{self._dir}{resource}' in self._contents\n+\n+        def open_resource(self, resource: str) -> BinaryIO:\n+            return io.BytesIO(self._contents[f'{self._dir}{resource}'])\n+\n+        def resource_path(self, resource: str) -> str:\n+            raise FileNotFoundError\n+\n+        def contents(self) -> Iterator[str]:\n+            dir_length = len(self._dir)\n+            result = set()\n+\n+            for filename in self._contents:\n+                if filename.startswith(self._dir):\n+                    try:\n+                        next_slash = filename.index('/', dir_length)\n+                    except ValueError:\n+                        next_slash = None\n+                    result.add(filename[dir_length:next_slash])\n+\n+            return iter(result)\n+\n+    contents: Dict[str, bytes]\n+    modules: Dict[str, str]\n+\n+    def __init__(self, contents: Dict[str, bytes]) -> None:\n+        try:\n+            contents[__file__] = __self_source__  # type: ignore[name-defined]\n+        except NameError:\n+            pass\n+\n+        self.contents = contents\n+        self.modules = {\n+            self.get_fullname(filename): filename\n+            for filename in contents\n+            if filename.endswith(\".py\")\n+        }\n+\n+    def get_fullname(self, filename: str) -> str:\n+        assert filename.endswith(\".py\")\n+        filename = filename[:-3]\n+        if filename.endswith(\"/__init__\"):\n+            filename = filename[:-9]\n+        return filename.replace(\"/\", \".\")\n+\n+    def get_resource_reader(self, fullname: str) -> ResourceReader:\n+        return BeipackLoader.ResourceReader(self.contents, fullname.replace('.', '/'))\n+\n+    def get_data(self, path: str) -> bytes:\n+        return self.contents[path]\n+\n+    def get_filename(self, fullname: str) -> str:\n+        return self.modules[fullname]\n+\n+    def find_spec(\n+        self,\n+        fullname: str,\n+        path: Optional[Sequence[str]],\n+        target: Optional[ModuleType] = None\n+      ) -> Optional[importlib.machinery.ModuleSpec]:\n+        if fullname not in self.modules:\n+            return None\n+        return importlib.util.spec_from_loader(fullname, self)\n+''',\n+  'cockpit/_vendor/bei/data/__init__.py': br'''import sys\n+\n+if sys.version_info >= (3, 9):\n+    import importlib.abc\n+    import importlib.resources\n+\n+    def read_data_file(filename: str) -> str:\n+        return (importlib.resources.files(__name__) / filename).read_text()\n+else:\n+    def read_data_file(filename: str) -> str:\n+        loader = __loader__  # type: ignore[name-defined]\n+        data = loader.get_data(__file__.replace('__init__.py', filename))\n+        return data.decode('utf-8')\n+''',\n+  'cockpit/_vendor/ferny/interaction_client.py': br'''#!/usr/bin/python3\n+\n+import array\n+import io\n+import os\n+import socket\n+import sys\n+from typing import Sequence\n+\n+\n+def command(stderr_fd: int, command: str, *args: object, fds: Sequence[int] = ()) -> None:\n+    cmd_read, cmd_write = [io.open(*end) for end in zip(os.pipe(), 'rw')]\n+\n+    with cmd_write:\n+        with cmd_read:\n+            with socket.fromfd(stderr_fd, socket.AF_UNIX, socket.SOCK_STREAM) as sock:\n+                fd_array = array.array('i', (cmd_read.fileno(), *fds))\n+                sock.sendmsg([b'\\0'], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fd_array)])\n+\n+        cmd_write.write(repr((command, args)))\n+\n+\n+def askpass(stderr_fd: int, stdout_fd: int, args: 'list[str]', env: 'dict[str, str]') -> int:\n+    ours, theirs = socket.socketpair()\n+\n+    with theirs:\n+        command(stderr_fd, 'ferny.askpass', args, env, fds=(theirs.fileno(), stdout_fd))\n+\n+    with ours:\n+        return int(ours.recv(16) or b'1')\n+\n+\n+def main() -> None:\n+    if len(sys.argv) == 1:\n+        command(2, 'ferny.end', [])\n+    else:\n+        sys.exit(askpass(2, 1, sys.argv, dict(os.environ)))\n+\n+\n+if __name__ == '__main__':\n+    main()\n ''',\n   'cockpit/_vendor/ferny/session.py': r'''# ferny - asyncio SSH client library, using ssh(1)\n #\n # Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n@@ -9670,15 +10154,15 @@\n         #    when ssh is trying to use the control socket, but in case the\n         #    socket has stopped working, ssh will try to fall back to directly\n         #    connecting, in which case an empty hostname will prevent that.\n         # 2. We need to quote the arguments \u2014 ssh will paste them together\n         #    using only spaces, executing the result using the user's shell.\n         return ('ssh', '-S', self._controlsock, '', *map(shlex.quote, args))\n '''.encode('utf-8'),\n-  'cockpit/_vendor/ferny/transport.py': br'''# ferny - asyncio SSH client library, using ssh(1)\n+  'cockpit/_vendor/ferny/ssh_errors.py': br'''# ferny - asyncio SSH client library, using ssh(1)\n #\n # Copyright (C) 2023 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n # (at your option) any later version.\n@@ -9687,441 +10171,130 @@\n # but WITHOUT ANY WARRANTY; without even the implied warranty of\n # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n # GNU General Public License for more details.\n #\n # You should have received a copy of the GNU General Public License\n # along with this program.  If not, see <http://www.gnu.org/licenses/>.\n \n-import asyncio\n-import contextlib\n-import logging\n-import typing\n-from typing import Any, Callable, Iterable, Sequence, TypeVar\n-\n-from .interaction_agent import InteractionAgent, InteractionHandler, get_running_loop\n-from .ssh_errors import get_exception_for_ssh_stderr\n-\n-logger = logging.getLogger(__name__)\n-\n-P = TypeVar('P', bound=asyncio.Protocol)\n+import ctypes\n+import errno\n+import os\n+import re\n+import socket\n+from typing import ClassVar, Iterable, Match, Pattern\n \n \n-class SubprocessError(Exception):\n-    returncode: int\n-    stderr: str\n+class SshError(Exception):\n+    PATTERN: ClassVar[Pattern]\n \n-    def __init__(self, returncode: int, stderr: str) -> None:\n-        super().__init__(returncode, stderr)\n-        self.returncode = returncode\n+    def __init__(self, match: 'Match | None', stderr: str) -> None:\n+        super().__init__(match.group(0) if match is not None else stderr)\n         self.stderr = stderr\n \n \n-class FernyTransport(asyncio.Transport, asyncio.SubprocessProtocol):\n-    _agent: InteractionAgent\n-    _exec_task: 'asyncio.Task[tuple[asyncio.SubprocessTransport, FernyTransport]]'\n-    _is_ssh: bool\n-    _protocol: asyncio.Protocol\n-    _protocol_disconnected: bool = False\n-\n-    # These get initialized in connection_made() and once set, never get unset.\n-    _subprocess_transport: 'asyncio.SubprocessTransport | None' = None\n-    _stdin_transport: 'asyncio.WriteTransport | None' = None\n-    _stdout_transport: 'asyncio.ReadTransport | None' = None\n-\n-    # We record events that might build towards a connection termination here\n-    # and consider them from _consider_disconnect() in order to try to get the\n-    # best possible Exception for the protocol, rather than just taking the\n-    # first one (which is likely to be somewhat random).\n-    _exception: 'Exception | None' = None\n-    _stderr_output: 'str | None' = None\n-    _returncode: 'int | None' = None\n-    _transport_disconnected: bool = False\n-    _closed: bool = False\n-\n-    @classmethod\n-    def spawn(\n-        cls: 'type[typing.Self]',\n-        protocol_factory: Callable[[], P],\n-        args: Sequence[str],\n-        loop: 'asyncio.AbstractEventLoop | None' = None,\n-        interaction_handlers: Sequence[InteractionHandler] = (),\n-        is_ssh: bool = True,\n-        **kwargs: Any\n-    ) -> 'tuple[typing.Self, P]':\n-        \"\"\"Connects a FernyTransport to a protocol, using the given command.\n-\n-        This spawns an external command and connects the stdin and stdout of\n-        the command to the protocol returned by the factory.\n-\n-        An instance of ferny.InteractionAgent is created and attached to the\n-        stderr of the spawned process, using the provided handlers.  It is the\n-        responsibility of the caller to ensure that:\n-          - a `ferny-askpass` client program is installed somewhere; and\n-          - any relevant command-line arguments or environment variables are\n-            passed correctly to the program to be spawned\n-\n-        This function returns immediately and never raises exceptions, assuming\n-        all preconditions are met.\n-\n-        If spawning the process fails then connection_lost() will be\n-        called with the relevant OSError, even before connection_made() is\n-        called.  This is somewhat non-standard behaviour, but is the easiest\n-        way to report these errors without making this function async.\n-\n-        Once the process is successfully executed, connection_made() will be\n-        called and the transport can be used as normal.  connection_lost() will\n-        be called if the process exits or another error occurs.\n-\n-        The return value of this function is the transport, but it exists in a\n-        semi-initialized state.  You can call .close() on it, but nothing else.\n-        Once .connection_made() is called, you can call all the other\n-        functions.\n-\n-        After you call this function, `.connection_lost()` will be called on\n-        your Protocol, exactly once, no matter what.  Until that happens, you\n-        are responsible for holding a reference to the returned transport.\n-\n-        :param args: the full argv of the command to spawn\n-        :param loop: the event loop to use.  If none is provided, we use the\n-            one which is (read: must be) currently running.\n-        :param interaction_handlers: the handlers passed to the\n-            InteractionAgent\n-        :param is_ssh: whether we should attempt to interpret stderr as ssh\n-            error messages\n-        :param kwargs: anything else is passed through to `subprocess_exec()`\n-        :returns: the usual `(Transport, Protocol)` pair\n-        \"\"\"\n-        logger.debug('spawn(%r, %r, %r)', cls, protocol_factory, args)\n-\n-        protocol = protocol_factory()\n-        self = cls(protocol)\n-        self._is_ssh = is_ssh\n-\n-        if loop is None:\n-            loop = get_running_loop()\n-\n-        self._agent = InteractionAgent(interaction_handlers, loop, self._interaction_completed)\n-        kwargs.setdefault('stderr', self._agent.fileno())\n-\n-        # As of Python 3.12 this isn't really asynchronous (since it uses the\n-        # subprocess module, which blocks while waiting for the exec() to\n-        # complete in the child), but we have to deal with the complication of\n-        # the async interface anyway.  Since we, ourselves, want to export a\n-        # non-async interface, that means that we need a task here and a\n-        # bottom-half handler below.\n-        self._exec_task = loop.create_task(loop.subprocess_exec(lambda: self, *args, **kwargs))\n-\n-        def exec_completed(task: asyncio.Task) -> None:\n-            logger.debug('exec_completed(%r, %r)', self, task)\n-            assert task is self._exec_task\n-            try:\n-                transport, me = task.result()\n-                assert me is self\n-                logger.debug('  success.')\n-            except asyncio.CancelledError:\n-                return  # in that case, do nothing\n-            except OSError as exc:\n-                logger.debug('  OSError %r', exc)\n-                self.close(exc)\n-                return\n-\n-            # Our own .connection_made() handler should have gotten called by\n-            # now.  Make sure everything got filled in properly.\n-            assert self._subprocess_transport is transport\n-            assert self._stdin_transport is not None\n-            assert self._stdout_transport is not None\n-\n-            # Ask the InteractionAgent to start processing stderr.\n-            self._agent.start()\n-\n-        self._exec_task.add_done_callback(exec_completed)\n-\n-        return self, protocol\n-\n-    def __init__(self, protocol: asyncio.Protocol) -> None:\n-        self._protocol = protocol\n-\n-    def _consider_disconnect(self) -> None:\n-        logger.debug('_consider_disconnect(%r)', self)\n-        # We cannot disconnect as long as any of these three things are happening\n-        if not self._exec_task.done():\n-            logger.debug('  exec_task still running %r', self._exec_task)\n-            return\n-\n-        if self._subprocess_transport is not None and not self._transport_disconnected:\n-            logger.debug('  transport still connected %r', self._subprocess_transport)\n-            return\n-\n-        if self._stderr_output is None:\n-            logger.debug('  agent still running')\n-            return\n-\n-        # All conditions for disconnection are satisfied.\n-        if self._protocol_disconnected:\n-            logger.debug('  already disconnected')\n-            return\n-        self._protocol_disconnected = True\n-\n-        # Now we just need to determine what we report to the protocol...\n-        if self._exception is not None:\n-            # If we got an exception reported, that's our reason for closing.\n-            logger.debug('  disconnect with exception %r', self._exception)\n-            self._protocol.connection_lost(self._exception)\n-        elif self._returncode == 0 or self._closed:\n-            # If we called close() or have a zero return status, that's a clean\n-            # exit, regardless of noise that might have landed in stderr.\n-            logger.debug('  clean disconnect')\n-            self._protocol.connection_lost(None)\n-        elif self._is_ssh and self._returncode == 255:\n-            # This is an error code due to an SSH failure.  Try to interpret it.\n-            logger.debug('  disconnect with ssh error %r', self._stderr_output)\n-            self._protocol.connection_lost(get_exception_for_ssh_stderr(self._stderr_output))\n-        else:\n-            # Otherwise, report the stderr text and return code.\n-            logger.debug('  disconnect with exit code %r, stderr %r', self._returncode, self._stderr_output)\n-            # We surely have _returncode set here, since otherwise:\n-            #  - exec_task failed with an exception (which we handle above); or\n-            #  - we're still connected...\n-            assert self._returncode is not None\n-            self._protocol.connection_lost(SubprocessError(self._returncode, self._stderr_output))\n-\n-    def _interaction_completed(self, future: 'asyncio.Future[str]') -> None:\n-        logger.debug('_interaction_completed(%r, %r)', self, future)\n-        try:\n-            self._stderr_output = future.result()\n-            logger.debug('  stderr: %r', self._stderr_output)\n-        except Exception as exc:\n-            logger.debug('  exception: %r', exc)\n-            self._stderr_output = ''  # we need to set this in order to complete\n-            self.close(exc)\n-\n-        self._consider_disconnect()\n-\n-    # BaseProtocol implementation\n-    def connection_made(self, transport: asyncio.BaseTransport) -> None:\n-        logger.debug('connection_made(%r, %r)', self, transport)\n-        assert isinstance(transport, asyncio.SubprocessTransport)\n-        self._subprocess_transport = transport\n-\n-        stdin_transport = transport.get_pipe_transport(0)\n-        assert isinstance(stdin_transport, asyncio.WriteTransport)\n-        self._stdin_transport = stdin_transport\n-\n-        stdout_transport = transport.get_pipe_transport(1)\n-        assert isinstance(stdout_transport, asyncio.ReadTransport)\n-        self._stdout_transport = stdout_transport\n-\n-        stderr_transport = transport.get_pipe_transport(2)\n-        assert stderr_transport is None\n-\n-        logger.debug('calling connection_made(%r, %r)', self, self._protocol)\n-        self._protocol.connection_made(self)\n-\n-    def connection_lost(self, exc: 'Exception | None') -> None:\n-        logger.debug('connection_lost(%r, %r)', self, exc)\n-        if self._exception is None:\n-            self._exception = exc\n-        self._transport_disconnected = True\n-        self._consider_disconnect()\n-\n-    # SubprocessProtocol implementation\n-    def pipe_data_received(self, fd: int, data: bytes) -> None:\n-        logger.debug('pipe_data_received(%r, %r, %r)', self, fd, len(data))\n-        assert fd == 1  # stderr is handled separately\n-        self._protocol.data_received(data)\n-\n-    def pipe_connection_lost(self, fd: int, exc: 'Exception | None') -> None:\n-        logger.debug('pipe_connection_lost(%r, %r, %r)', self, fd, exc)\n-        assert fd in (0, 1)  # stderr is handled separately\n-\n-        # We treat this as a clean close\n-        if isinstance(exc, BrokenPipeError):\n-            exc = None\n-\n-        # Record serious errors to propagate them to the protocol\n-        # If this is a clean exit on stdout, report an EOF\n-        if exc is not None:\n-            self.close(exc)\n-        elif fd == 1 and not self._closed:\n-            if not self._protocol.eof_received():\n-                self.close()\n-\n-    def process_exited(self) -> None:\n-        logger.debug('process_exited(%r)', self)\n-        assert self._subprocess_transport is not None\n-        self._returncode = self._subprocess_transport.get_returncode()\n-        logger.debug('  ._returncode = %r', self._returncode)\n-        self._agent.force_completion()\n-\n-    def pause_writing(self) -> None:\n-        logger.debug('pause_writing(%r)', self)\n-        self._protocol.pause_writing()\n-\n-    def resume_writing(self) -> None:\n-        logger.debug('resume_writing(%r)', self)\n-        self._protocol.resume_writing()\n+class SshAuthenticationError(SshError):\n+    PATTERN = re.compile(r'^([^:]+): Permission denied \\(([^()]+)\\)\\.$', re.M)\n \n-    # Transport implementation.  Most of this is straight delegation.\n-    def close(self, exc: 'Exception | None' = None) -> None:\n-        logger.debug('close(%r, %r)', self, exc)\n-        self._closed = True\n-        if self._exception is None:\n-            logger.debug('  setting exception %r', exc)\n-            self._exception = exc\n-        if not self._exec_task.done():\n-            logger.debug('  cancelling _exec_task')\n-            self._exec_task.cancel()\n-        if self._subprocess_transport is not None:\n-            logger.debug('  closing _subprocess_transport')\n-            # https://github.com/python/cpython/issues/112800\n-            with contextlib.suppress(PermissionError):\n-                self._subprocess_transport.close()\n-        self._agent.force_completion()\n+    def __init__(self, match: Match, stderr: str) -> None:\n+        super().__init__(match, stderr)\n+        self.destination = match.group(1)\n+        self.methods = match.group(2).split(',')\n+        self.message = match.group(0)\n \n-    def is_closing(self) -> bool:\n-        assert self._subprocess_transport is not None\n-        return self._subprocess_transport.is_closing()\n \n-    def get_extra_info(self, name: str, default: object = None) -> object:\n-        assert self._subprocess_transport is not None\n-        return self._subprocess_transport.get_extra_info(name, default)\n+# generic host key error for OSes without KnownHostsCommand support\n+class SshHostKeyError(SshError):\n+    PATTERN = re.compile(r'^Host key verification failed.$', re.M)\n \n-    def set_protocol(self, protocol: asyncio.BaseProtocol) -> None:\n-        assert isinstance(protocol, asyncio.Protocol)\n-        self._protocol = protocol\n \n-    def get_protocol(self) -> asyncio.Protocol:\n-        return self._protocol\n+# specific errors for OSes with KnownHostsCommand\n+class SshUnknownHostKeyError(SshHostKeyError):\n+    PATTERN = re.compile(r'^No .* host key is known.*Host key verification failed.$', re.S | re.M)\n \n-    def is_reading(self) -> bool:\n-        assert self._stdout_transport is not None\n-        try:\n-            return self._stdout_transport.is_reading()\n-        except NotImplementedError:\n-            # This is (incorrectly) unimplemented before Python 3.11\n-            return not self._stdout_transport._paused  # type:ignore[attr-defined]\n-        except AttributeError:\n-            # ...and in Python 3.6 it's even worse\n-            try:\n-                selector = self._stdout_transport._loop._selector  # type:ignore[attr-defined]\n-                selector.get_key(self._stdout_transport._fileno)  # type:ignore[attr-defined]\n-                return True\n-            except KeyError:\n-                return False\n \n-    def pause_reading(self) -> None:\n-        assert self._stdout_transport is not None\n-        self._stdout_transport.pause_reading()\n+class SshChangedHostKeyError(SshHostKeyError):\n+    PATTERN = re.compile(r'warning.*remote host identification has changed', re.I)\n \n-    def resume_reading(self) -> None:\n-        assert self._stdout_transport is not None\n-        self._stdout_transport.resume_reading()\n \n-    def abort(self) -> None:\n-        assert self._stdin_transport is not None\n-        assert self._subprocess_transport is not None\n-        self._stdin_transport.abort()\n-        self._subprocess_transport.kill()\n+# Functionality for mapping getaddrinfo()-family error messages to their\n+# equivalent Python exceptions.\n+def make_gaierror_map() -> 'Iterable[tuple[str, int]]':\n+    libc = ctypes.CDLL(None)\n+    libc.gai_strerror.restype = ctypes.c_char_p\n \n-    def can_write_eof(self) -> bool:\n-        assert self._stdin_transport is not None\n-        return self._stdin_transport.can_write_eof()  # will always be True\n+    for key in dir(socket):\n+        if key.startswith('EAI_'):\n+            errnum = getattr(socket, key)\n+            yield libc.gai_strerror(errnum).decode('utf-8'), errnum\n \n-    def get_write_buffer_size(self) -> int:\n-        assert self._stdin_transport is not None\n-        return self._stdin_transport.get_write_buffer_size()\n \n-    def get_write_buffer_limits(self) -> 'tuple[int, int]':\n-        assert self._stdin_transport is not None\n-        return self._stdin_transport.get_write_buffer_limits()\n+gaierror_map = dict(make_gaierror_map())\n \n-    def set_write_buffer_limits(self, high: 'int | None' = None, low: 'int | None' = None) -> None:\n-        assert self._stdin_transport is not None\n-        return self._stdin_transport.set_write_buffer_limits(high, low)\n \n-    def write(self, data: bytes) -> None:\n-        assert self._stdin_transport is not None\n-        return self._stdin_transport.write(data)\n+# Functionality for passing strerror() error messages to their equivalent\n+# Python exceptions.\n+# There doesn't seem to be an official API for turning an errno into the\n+# correct subtype of OSError, and the list that cpython uses is hidden fairly\n+# deeply inside of the implementation.  This is basically copied from the\n+# ADD_ERRNO() lines in _PyExc_InitState in cpython/Objects/exceptions.c\n+oserror_subclass_map = dict((errnum, cls) for cls, errnum in [\n+    (BlockingIOError, errno.EAGAIN),\n+    (BlockingIOError, errno.EALREADY),\n+    (BlockingIOError, errno.EINPROGRESS),\n+    (BlockingIOError, errno.EWOULDBLOCK),\n+    (BrokenPipeError, errno.EPIPE),\n+    (BrokenPipeError, errno.ESHUTDOWN),\n+    (ChildProcessError, errno.ECHILD),\n+    (ConnectionAbortedError, errno.ECONNABORTED),\n+    (ConnectionRefusedError, errno.ECONNREFUSED),\n+    (ConnectionResetError, errno.ECONNRESET),\n+    (FileExistsError, errno.EEXIST),\n+    (FileNotFoundError, errno.ENOENT),\n+    (IsADirectoryError, errno.EISDIR),\n+    (NotADirectoryError, errno.ENOTDIR),\n+    (InterruptedError, errno.EINTR),\n+    (PermissionError, errno.EACCES),\n+    (PermissionError, errno.EPERM),\n+    (ProcessLookupError, errno.ESRCH),\n+    (TimeoutError, errno.ETIMEDOUT),\n+])\n \n-    def writelines(self, list_of_data: Iterable[bytes]) -> None:\n-        assert self._stdin_transport is not None\n-        return self._stdin_transport.writelines(list_of_data)\n \n-    def write_eof(self) -> None:\n-        assert self._stdin_transport is not None\n-        return self._stdin_transport.write_eof()\n+def get_exception_for_ssh_stderr(stderr: str) -> Exception:\n+    stderr = stderr.replace('\\r\\n', '\\n')  # fix line separators\n \n-    # We don't really implement SubprocessTransport, but provide these as\n-    # \"extras\" to our user.\n-    def get_pid(self) -> int:\n-        assert self._subprocess_transport is not None\n-        return self._subprocess_transport.get_pid()\n+    # check for the specific error messages first, then for generic SshHostKeyError\n+    for ssh_cls in [SshAuthenticationError, SshChangedHostKeyError, SshUnknownHostKeyError, SshHostKeyError]:\n+        match = ssh_cls.PATTERN.search(stderr)\n+        if match is not None:\n+            return ssh_cls(match, stderr)\n \n-    def get_returncode(self) -> 'int | None':\n-        return self._returncode\n+    before, colon, after = stderr.rpartition(':')\n+    if colon and after:\n+        potential_strerror = after.strip()\n \n-    def kill(self) -> None:\n-        assert self._subprocess_transport is not None\n-        self._subprocess_transport.kill()\n+        # DNS lookup errors\n+        if potential_strerror in gaierror_map:\n+            errnum = gaierror_map[potential_strerror]\n+            return socket.gaierror(errnum, stderr)\n \n-    def send_signal(self, number: int) -> None:\n-        assert self._subprocess_transport is not None\n-        self._subprocess_transport.send_signal(number)\n+        # Network connect errors\n+        for errnum in errno.errorcode:\n+            if os.strerror(errnum) == potential_strerror:\n+                os_cls = oserror_subclass_map.get(errnum, OSError)\n+                return os_cls(errnum, stderr)\n \n-    def terminate(self) -> None:\n-        assert self._subprocess_transport is not None\n-        self._subprocess_transport.terminate()\n+    # No match?  Generic.\n+    return SshError(None, stderr)\n ''',\n   'cockpit/_vendor/ferny/askpass.py': br'''from .interaction_client import main\n \n if __name__ == '__main__':\n     main()\n ''',\n-  'cockpit/_vendor/ferny/interaction_client.py': br'''#!/usr/bin/python3\n-\n-import array\n-import io\n-import os\n-import socket\n-import sys\n-from typing import Sequence\n-\n-\n-def command(stderr_fd: int, command: str, *args: object, fds: Sequence[int] = ()) -> None:\n-    cmd_read, cmd_write = [io.open(*end) for end in zip(os.pipe(), 'rw')]\n-\n-    with cmd_write:\n-        with cmd_read:\n-            with socket.fromfd(stderr_fd, socket.AF_UNIX, socket.SOCK_STREAM) as sock:\n-                fd_array = array.array('i', (cmd_read.fileno(), *fds))\n-                sock.sendmsg([b'\\0'], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fd_array)])\n-\n-        cmd_write.write(repr((command, args)))\n-\n-\n-def askpass(stderr_fd: int, stdout_fd: int, args: 'list[str]', env: 'dict[str, str]') -> int:\n-    ours, theirs = socket.socketpair()\n-\n-    with theirs:\n-        command(stderr_fd, 'ferny.askpass', args, env, fds=(theirs.fileno(), stdout_fd))\n-\n-    with ours:\n-        return int(ours.recv(16) or b'1')\n-\n-\n-def main() -> None:\n-    if len(sys.argv) == 1:\n-        command(2, 'ferny.end', [])\n-    else:\n-        sys.exit(askpass(2, 1, sys.argv, dict(os.environ)))\n-\n-\n-if __name__ == '__main__':\n-    main()\n-''',\n   'cockpit/_vendor/ferny/__init__.py': br'''from .interaction_agent import (\n     BEIBOOT_GADGETS,\n     COMMAND_TEMPLATE,\n     AskpassHandler,\n     InteractionAgent,\n     InteractionError,\n     InteractionHandler,\n@@ -10176,141 +10349,214 @@\n     'SubprocessError',\n     'temporary_askpass',\n     'write_askpass_to_tmpdir',\n ]\n \n __version__ = '0'\n ''',\n-  'cockpit/_vendor/ferny/ssh_errors.py': br'''# ferny - asyncio SSH client library, using ssh(1)\n-#\n-# Copyright (C) 2023 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n-\n-import ctypes\n-import errno\n-import os\n+  'cockpit/_vendor/ferny/py.typed': br'''''',\n+  'cockpit/_vendor/ferny/ssh_askpass.py': br'''import logging\n import re\n-import socket\n-from typing import ClassVar, Iterable, Match, Pattern\n+from typing import ClassVar, Match, Sequence\n \n+from .interaction_agent import AskpassHandler\n \n-class SshError(Exception):\n-    PATTERN: ClassVar[Pattern]\n+logger = logging.getLogger(__name__)\n \n-    def __init__(self, match: 'Match | None', stderr: str) -> None:\n-        super().__init__(match.group(0) if match is not None else stderr)\n+\n+class AskpassPrompt:\n+    \"\"\"An askpass prompt resulting from a call to ferny-askpass.\n+\n+      stderr: the contents of stderr from before ferny-askpass was called.\n+              Likely related to previous failed operations.\n+      messages: all but the last line of the prompt as handed to ferny-askpass.\n+                Usually contains context about the question.\n+      prompt: the last line handed to ferny-askpass.  The prompt itself.\n+    \"\"\"\n+    stderr: str\n+    messages: str\n+    prompt: str\n+\n+    def __init__(self, prompt: str, messages: str, stderr: str) -> None:\n         self.stderr = stderr\n+        self.messages = messages\n+        self.prompt = prompt\n \n+    def reply(self, response: str) -> None:\n+        pass\n \n-class SshAuthenticationError(SshError):\n-    PATTERN = re.compile(r'^([^:]+): Permission denied \\(([^()]+)\\)\\.$', re.M)\n+    def close(self) -> None:\n+        pass\n \n-    def __init__(self, match: Match, stderr: str) -> None:\n-        super().__init__(match, stderr)\n-        self.destination = match.group(1)\n-        self.methods = match.group(2).split(',')\n-        self.message = match.group(0)\n+    async def handle_via(self, responder: 'SshAskpassResponder') -> None:\n+        try:\n+            response = await self.dispatch(responder)\n+            if response is not None:\n+                self.reply(response)\n+        finally:\n+            self.close()\n \n+    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n+        return await responder.do_prompt(self)\n \n-# generic host key error for OSes without KnownHostsCommand support\n-class SshHostKeyError(SshError):\n-    PATTERN = re.compile(r'^Host key verification failed.$', re.M)\n \n+class SSHAskpassPrompt(AskpassPrompt):\n+    # The valid answers to prompts of this type.  If this is None then any\n+    # answer is permitted.  If it's a sequence then only answers from the\n+    # sequence are permitted.  If it's an empty sequence, then no answer is\n+    # permitted (ie: the askpass callback should never return).\n+    answers: 'ClassVar[Sequence[str] | None]' = None\n \n-# specific errors for OSes with KnownHostsCommand\n-class SshUnknownHostKeyError(SshHostKeyError):\n-    PATTERN = re.compile(r'^No .* host key is known.*Host key verification failed.$', re.S | re.M)\n+    # Patterns to capture.  `_pattern` *must* match.\n+    _pattern: ClassVar[str]\n+    # `_extra_patterns` can fill in extra class attributes if they match.\n+    _extra_patterns: ClassVar[Sequence[str]] = ()\n \n+    def __init__(self, prompt: str, messages: str, stderr: str, match: Match) -> None:\n+        super().__init__(prompt, messages, stderr)\n+        self.__dict__.update(match.groupdict())\n \n-class SshChangedHostKeyError(SshHostKeyError):\n-    PATTERN = re.compile(r'warning.*remote host identification has changed', re.I)\n+        for pattern in self._extra_patterns:\n+            extra_match = re.search(with_helpers(pattern), messages, re.M)\n+            if extra_match is not None:\n+                self.__dict__.update(extra_match.groupdict())\n \n \n-# Functionality for mapping getaddrinfo()-family error messages to their\n-# equivalent Python exceptions.\n-def make_gaierror_map() -> 'Iterable[tuple[str, int]]':\n-    libc = ctypes.CDLL(None)\n-    libc.gai_strerror.restype = ctypes.c_char_p\n+# Specific prompts\n+HELPERS = {\n+    \"%{algorithm}\": r\"(?P<algorithm>\\b[-\\w]+\\b)\",\n+    \"%{filename}\": r\"(?P<filename>.+)\",\n+    \"%{fingerprint}\": r\"(?P<fingerprint>SHA256:[0-9A-Za-z+/]{43})\",\n+    \"%{hostname}\": r\"(?P<hostname>[^ @']+)\",\n+    \"%{pkcs11_id}\": r\"(?P<pkcs11_id>.+)\",\n+    \"%{username}\": r\"(?P<username>[^ @']+)\",\n+}\n \n-    for key in dir(socket):\n-        if key.startswith('EAI_'):\n-            errnum = getattr(socket, key)\n-            yield libc.gai_strerror(errnum).decode('utf-8'), errnum\n \n+class SshPasswordPrompt(SSHAskpassPrompt):\n+    _pattern = r\"%{username}@%{hostname}'s password: \"\n+    username: 'str | None' = None\n+    hostname: 'str | None' = None\n \n-gaierror_map = dict(make_gaierror_map())\n+    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n+        return await responder.do_password_prompt(self)\n \n \n-# Functionality for passing strerror() error messages to their equivalent\n-# Python exceptions.\n-# There doesn't seem to be an official API for turning an errno into the\n-# correct subtype of OSError, and the list that cpython uses is hidden fairly\n-# deeply inside of the implementation.  This is basically copied from the\n-# ADD_ERRNO() lines in _PyExc_InitState in cpython/Objects/exceptions.c\n-oserror_subclass_map = dict((errnum, cls) for cls, errnum in [\n-    (BlockingIOError, errno.EAGAIN),\n-    (BlockingIOError, errno.EALREADY),\n-    (BlockingIOError, errno.EINPROGRESS),\n-    (BlockingIOError, errno.EWOULDBLOCK),\n-    (BrokenPipeError, errno.EPIPE),\n-    (BrokenPipeError, errno.ESHUTDOWN),\n-    (ChildProcessError, errno.ECHILD),\n-    (ConnectionAbortedError, errno.ECONNABORTED),\n-    (ConnectionRefusedError, errno.ECONNREFUSED),\n-    (ConnectionResetError, errno.ECONNRESET),\n-    (FileExistsError, errno.EEXIST),\n-    (FileNotFoundError, errno.ENOENT),\n-    (IsADirectoryError, errno.EISDIR),\n-    (NotADirectoryError, errno.ENOTDIR),\n-    (InterruptedError, errno.EINTR),\n-    (PermissionError, errno.EACCES),\n-    (PermissionError, errno.EPERM),\n-    (ProcessLookupError, errno.ESRCH),\n-    (TimeoutError, errno.ETIMEDOUT),\n-])\n+class SshPassphrasePrompt(SSHAskpassPrompt):\n+    _pattern = r\"Enter passphrase for key '%{filename}': \"\n+    filename: str\n \n+    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n+        return await responder.do_passphrase_prompt(self)\n \n-def get_exception_for_ssh_stderr(stderr: str) -> Exception:\n-    stderr = stderr.replace('\\r\\n', '\\n')  # fix line separators\n \n-    # check for the specific error messages first, then for generic SshHostKeyError\n-    for ssh_cls in [SshAuthenticationError, SshChangedHostKeyError, SshUnknownHostKeyError, SshHostKeyError]:\n-        match = ssh_cls.PATTERN.search(stderr)\n+class SshFIDOPINPrompt(SSHAskpassPrompt):\n+    _pattern = r\"Enter PIN for %{algorithm} key %{filename}: \"\n+    algorithm: str\n+    filename: str\n+\n+    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str  | None':\n+        return await responder.do_fido_pin_prompt(self)\n+\n+\n+class SshFIDOUserPresencePrompt(SSHAskpassPrompt):\n+    _pattern = r\"Confirm user presence for key %{algorithm} %{fingerprint}\"\n+    answers = ()\n+    algorithm: str\n+    fingerprint: str\n+\n+    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n+        return await responder.do_fido_user_presence_prompt(self)\n+\n+\n+class SshPKCS11PINPrompt(SSHAskpassPrompt):\n+    _pattern = r\"Enter PIN for '%{pkcs11_id}': \"\n+    pkcs11_id: str\n+\n+    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n+        return await responder.do_pkcs11_pin_prompt(self)\n+\n+\n+class SshHostKeyPrompt(SSHAskpassPrompt):\n+    _pattern = r\"Are you sure you want to continue connecting \\(yes/no(/\\[fingerprint\\])?\\)\\? \"\n+    _extra_patterns = [\n+        r\"%{fingerprint}[.]$\",\n+        r\"^%{algorithm} key fingerprint is\",\n+        r\"^The fingerprint for the %{algorithm} key sent by the remote host is$\"\n+    ]\n+    answers = ('yes', 'no')\n+    algorithm: str\n+    fingerprint: str\n+\n+    async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n+        return await responder.do_host_key_prompt(self)\n+\n+\n+def with_helpers(pattern: str) -> str:\n+    for name, helper in HELPERS.items():\n+        pattern = pattern.replace(name, helper)\n+\n+    assert '%{' not in pattern\n+    return pattern\n+\n+\n+def categorize_ssh_prompt(string: str, stderr: str) -> AskpassPrompt:\n+    classes = [\n+        SshFIDOPINPrompt,\n+        SshFIDOUserPresencePrompt,\n+        SshHostKeyPrompt,\n+        SshPKCS11PINPrompt,\n+        SshPassphrasePrompt,\n+        SshPasswordPrompt,\n+    ]\n+\n+    # The last line is the line after the last newline character, excluding the\n+    # optional final newline character.  eg: \"x\\ny\\nLAST\\n\" or \"x\\ny\\nLAST\"\n+    second_last_newline = string.rfind('\\n', 0, -1)\n+    if second_last_newline >= 0:\n+        last_line = string[second_last_newline + 1:]\n+        extras = string[:second_last_newline + 1]\n+    else:\n+        last_line = string\n+        extras = ''\n+\n+    for cls in classes:\n+        pattern = with_helpers(cls._pattern)\n+        match = re.fullmatch(pattern, last_line)\n         if match is not None:\n-            return ssh_cls(match, stderr)\n+            return cls(last_line, extras, stderr, match)\n \n-    before, colon, after = stderr.rpartition(':')\n-    if colon and after:\n-        potential_strerror = after.strip()\n+    return AskpassPrompt(last_line, extras, stderr)\n \n-        # DNS lookup errors\n-        if potential_strerror in gaierror_map:\n-            errnum = gaierror_map[potential_strerror]\n-            return socket.gaierror(errnum, stderr)\n \n-        # Network connect errors\n-        for errnum in errno.errorcode:\n-            if os.strerror(errnum) == potential_strerror:\n-                os_cls = oserror_subclass_map.get(errnum, OSError)\n-                return os_cls(errnum, stderr)\n+class SshAskpassResponder(AskpassHandler):\n+    async def do_askpass(self, stderr: str, prompt: str, hint: str) -> 'str | None':\n+        return await categorize_ssh_prompt(prompt, stderr).dispatch(self)\n \n-    # No match?  Generic.\n-    return SshError(None, stderr)\n+    async def do_prompt(self, prompt: AskpassPrompt) -> 'str | None':\n+        # Default fallback for unrecognised message types: unimplemented\n+        return None\n+\n+    async def do_fido_pin_prompt(self, prompt: SshFIDOPINPrompt) -> 'str | None':\n+        return await self.do_prompt(prompt)\n+\n+    async def do_fido_user_presence_prompt(self, prompt: SshFIDOUserPresencePrompt) -> 'str | None':\n+        return await self.do_prompt(prompt)\n+\n+    async def do_host_key_prompt(self, prompt: SshHostKeyPrompt) -> 'str | None':\n+        return await self.do_prompt(prompt)\n+\n+    async def do_pkcs11_pin_prompt(self, prompt: SshPKCS11PINPrompt) -> 'str | None':\n+        return await self.do_prompt(prompt)\n+\n+    async def do_passphrase_prompt(self, prompt: SshPassphrasePrompt) -> 'str | None':\n+        return await self.do_prompt(prompt)\n+\n+    async def do_password_prompt(self, prompt: SshPasswordPrompt) -> 'str | None':\n+        return await self.do_prompt(prompt)\n ''',\n   'cockpit/_vendor/ferny/interaction_agent.py': r'''# ferny - asyncio SSH client library, using ssh(1)\n #\n # Copyright (C) 2023 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n@@ -10726,675 +10972,410 @@\n \n \n @contextlib.contextmanager\n def temporary_askpass(**kwargs: Any) -> Generator[str, None, None]:\n     with tempfile.TemporaryDirectory(**kwargs) as directory:\n         yield write_askpass_to_tmpdir(directory)\n '''.encode('utf-8'),\n-  'cockpit/_vendor/ferny/py.typed': br'''''',\n-  'cockpit/_vendor/bei/beiboot.py': br\"\"\"# beiboot - Remote bootloader for Python\n+  'cockpit/_vendor/ferny/transport.py': br'''# ferny - asyncio SSH client library, using ssh(1)\n #\n-# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n+# Copyright (C) 2023 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n #\n # This program is free software: you can redistribute it and/or modify\n # it under the terms of the GNU General Public License as published by\n # the Free Software Foundation, either version 3 of the License, or\n # (at your option) any later version.\n #\n # This program is distributed in the hope that it will be useful,\n # but WITHOUT ANY WARRANTY; without even the implied warranty of\n # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n # GNU General Public License for more details.\n #\n # You should have received a copy of the GNU General Public License\n # along with this program.  If not, see <http://www.gnu.org/licenses/>.\n \n-import argparse\n import asyncio\n-import os\n-import shlex\n-import subprocess\n-import sys\n-import threading\n-from typing import IO, List, Sequence, Tuple\n-\n-from .bootloader import make_bootloader\n-\n-\n-def get_python_command(local: bool = False,\n-                       tty: bool = False,\n-                       sh: bool = False) -> Sequence[str]:\n-    interpreter = sys.executable if local else 'python3'\n-    command: Sequence[str]\n-\n-    if tty:\n-        command = (interpreter, '-iq')\n-    else:\n-        command = (\n-            interpreter, '-ic',\n-            # https://github.com/python/cpython/issues/93139\n-            '''\" - beiboot - \"; import sys; sys.ps1 = ''; sys.ps2 = '';'''\n-        )\n-\n-    if sh:\n-        command = (' '.join(shlex.quote(arg) for arg in command),)\n-\n-    return command\n-\n-\n-def get_ssh_command(*args: str, tty: bool = False) -> Sequence[str]:\n-    return ('ssh',\n-            *(['-t'] if tty else ()),\n-            *args,\n-            *get_python_command(tty=tty, sh=True))\n-\n-\n-def get_container_command(*args: str, tty: bool = False) -> Sequence[str]:\n-    return ('podman', 'exec', '--interactive',\n-            *(['--tty'] if tty else ()),\n-            *args,\n-            *get_python_command(tty=tty))\n-\n+import contextlib\n+import logging\n+import typing\n+from typing import Any, Callable, Iterable, Sequence, TypeVar\n \n-def get_command(*args: str, tty: bool = False, sh: bool = False) -> Sequence[str]:\n-    return (*args, *get_python_command(local=True, tty=tty, sh=sh))\n+from .interaction_agent import InteractionAgent, InteractionHandler, get_running_loop\n+from .ssh_errors import get_exception_for_ssh_stderr\n \n+logger = logging.getLogger(__name__)\n \n-def splice_in_thread(src: int, dst: IO[bytes]) -> None:\n-    def _thread() -> None:\n-        # os.splice() only in Python 3.10\n-        with dst:\n-            block_size = 1 << 20\n-            while True:\n-                data = os.read(src, block_size)\n-                if not data:\n-                    break\n-                dst.write(data)\n-                dst.flush()\n+P = TypeVar('P', bound=asyncio.Protocol)\n \n-    threading.Thread(target=_thread, daemon=True).start()\n \n+class SubprocessError(Exception):\n+    returncode: int\n+    stderr: str\n \n-def send_and_splice(command: Sequence[str], script: bytes) -> None:\n-    with subprocess.Popen(command, stdin=subprocess.PIPE) as proc:\n-        assert proc.stdin is not None\n-        proc.stdin.write(script)\n+    def __init__(self, returncode: int, stderr: str) -> None:\n+        super().__init__(returncode, stderr)\n+        self.returncode = returncode\n+        self.stderr = stderr\n \n-        splice_in_thread(0, proc.stdin)\n-        sys.exit(proc.wait())\n \n+class FernyTransport(asyncio.Transport, asyncio.SubprocessProtocol):\n+    _agent: InteractionAgent\n+    _exec_task: 'asyncio.Task[tuple[asyncio.SubprocessTransport, FernyTransport]]'\n+    _is_ssh: bool\n+    _protocol: asyncio.Protocol\n+    _protocol_disconnected: bool = False\n \n-def send_xz_and_splice(command: Sequence[str], script: bytes) -> None:\n-    import ferny\n+    # These get initialized in connection_made() and once set, never get unset.\n+    _subprocess_transport: 'asyncio.SubprocessTransport | None' = None\n+    _stdin_transport: 'asyncio.WriteTransport | None' = None\n+    _stdout_transport: 'asyncio.ReadTransport | None' = None\n \n-    class Responder(ferny.InteractionResponder):\n-        async def do_custom_command(self,\n-                                    command: str,\n-                                    args: Tuple,\n-                                    fds: List[int],\n-                                    stderr: str) -> None:\n-            assert proc.stdin is not None\n-            if command == 'beiboot.provide':\n-                proc.stdin.write(script)\n-                proc.stdin.flush()\n+    # We record events that might build towards a connection termination here\n+    # and consider them from _consider_disconnect() in order to try to get the\n+    # best possible Exception for the protocol, rather than just taking the\n+    # first one (which is likely to be somewhat random).\n+    _exception: 'Exception | None' = None\n+    _stderr_output: 'str | None' = None\n+    _returncode: 'int | None' = None\n+    _transport_disconnected: bool = False\n+    _closed: bool = False\n \n-    agent = ferny.InteractionAgent(Responder())\n-    with subprocess.Popen(command, stdin=subprocess.PIPE, stderr=agent) as proc:\n-        assert proc.stdin is not None\n-        proc.stdin.write(make_bootloader([\n-            ('boot_xz', ('script.py.xz', len(script), [], True)),\n-        ], gadgets=ferny.BEIBOOT_GADGETS).encode())\n-        proc.stdin.flush()\n+    @classmethod\n+    def spawn(\n+        cls: 'type[typing.Self]',\n+        protocol_factory: Callable[[], P],\n+        args: Sequence[str],\n+        loop: 'asyncio.AbstractEventLoop | None' = None,\n+        interaction_handlers: Sequence[InteractionHandler] = (),\n+        is_ssh: bool = True,\n+        **kwargs: Any\n+    ) -> 'tuple[typing.Self, P]':\n+        \"\"\"Connects a FernyTransport to a protocol, using the given command.\n \n-        asyncio.run(agent.communicate())\n-        splice_in_thread(0, proc.stdin)\n-        sys.exit(proc.wait())\n+        This spawns an external command and connects the stdin and stdout of\n+        the command to the protocol returned by the factory.\n \n+        An instance of ferny.InteractionAgent is created and attached to the\n+        stderr of the spawned process, using the provided handlers.  It is the\n+        responsibility of the caller to ensure that:\n+          - a `ferny-askpass` client program is installed somewhere; and\n+          - any relevant command-line arguments or environment variables are\n+            passed correctly to the program to be spawned\n \n-def main() -> None:\n-    parser = argparse.ArgumentParser()\n-    parser.add_argument('--sh', action='store_true',\n-                        help='Pass Python interpreter command as shell-script')\n-    parser.add_argument('--xz', help=\"the xz to run remotely\")\n-    parser.add_argument('--script',\n-                        help=\"the script to run remotely (must be repl-friendly)\")\n-    parser.add_argument('command', nargs='*')\n+        This function returns immediately and never raises exceptions, assuming\n+        all preconditions are met.\n \n-    args = parser.parse_args()\n-    tty = not args.script and os.isatty(0)\n+        If spawning the process fails then connection_lost() will be\n+        called with the relevant OSError, even before connection_made() is\n+        called.  This is somewhat non-standard behaviour, but is the easiest\n+        way to report these errors without making this function async.\n \n-    if args.command == []:\n-        command = get_python_command(tty=tty)\n-    elif args.command[0] == 'ssh':\n-        command = get_ssh_command(*args.command[1:], tty=tty)\n-    elif args.command[0] == 'container':\n-        command = get_container_command(*args.command[1:], tty=tty)\n-    else:\n-        command = get_command(*args.command, tty=tty, sh=args.sh)\n+        Once the process is successfully executed, connection_made() will be\n+        called and the transport can be used as normal.  connection_lost() will\n+        be called if the process exits or another error occurs.\n \n-    if args.script:\n-        with open(args.script, 'rb') as file:\n-            script = file.read()\n+        The return value of this function is the transport, but it exists in a\n+        semi-initialized state.  You can call .close() on it, but nothing else.\n+        Once .connection_made() is called, you can call all the other\n+        functions.\n \n-        send_and_splice(command, script)\n+        After you call this function, `.connection_lost()` will be called on\n+        your Protocol, exactly once, no matter what.  Until that happens, you\n+        are responsible for holding a reference to the returned transport.\n \n-    elif args.xz:\n-        with open(args.xz, 'rb') as file:\n-            script = file.read()\n+        :param args: the full argv of the command to spawn\n+        :param loop: the event loop to use.  If none is provided, we use the\n+            one which is (read: must be) currently running.\n+        :param interaction_handlers: the handlers passed to the\n+            InteractionAgent\n+        :param is_ssh: whether we should attempt to interpret stderr as ssh\n+            error messages\n+        :param kwargs: anything else is passed through to `subprocess_exec()`\n+        :returns: the usual `(Transport, Protocol)` pair\n+        \"\"\"\n+        logger.debug('spawn(%r, %r, %r)', cls, protocol_factory, args)\n \n-        send_xz_and_splice(command, script)\n+        protocol = protocol_factory()\n+        self = cls(protocol)\n+        self._is_ssh = is_ssh\n \n-    else:\n-        # If we're streaming from stdin then this is a lot easier...\n-        os.execlp(command[0], *command)\n+        if loop is None:\n+            loop = get_running_loop()\n \n-    # Otherwise, \"full strength\"\n+        self._agent = InteractionAgent(interaction_handlers, loop, self._interaction_completed)\n+        kwargs.setdefault('stderr', self._agent.fileno())\n \n-if __name__ == '__main__':\n-    main()\n-\"\"\",\n-  'cockpit/_vendor/bei/bootloader.py': br'''# beiboot - Remote bootloader for Python\n-#\n-# Copyright (C) 2023 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n+        # As of Python 3.12 this isn't really asynchronous (since it uses the\n+        # subprocess module, which blocks while waiting for the exec() to\n+        # complete in the child), but we have to deal with the complication of\n+        # the async interface anyway.  Since we, ourselves, want to export a\n+        # non-async interface, that means that we need a task here and a\n+        # bottom-half handler below.\n+        self._exec_task = loop.create_task(loop.subprocess_exec(lambda: self, *args, **kwargs))\n \n-import textwrap\n-from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple\n+        def exec_completed(task: asyncio.Task) -> None:\n+            logger.debug('exec_completed(%r, %r)', self, task)\n+            assert task is self._exec_task\n+            try:\n+                transport, me = task.result()\n+                assert me is self\n+                logger.debug('  success.')\n+            except asyncio.CancelledError:\n+                return  # in that case, do nothing\n+            except OSError as exc:\n+                logger.debug('  OSError %r', exc)\n+                self.close(exc)\n+                return\n \n-GADGETS = {\n-    \"_frame\": r\"\"\"\n-        import sys\n-        import traceback\n-        try:\n-            ...\n-        except SystemExit:\n-            raise\n-        except BaseException:\n-            command('beiboot.exc', traceback.format_exc())\n-            sys.exit(37)\n-    \"\"\",\n-    \"try_exec\": r\"\"\"\n-        import contextlib\n-        import os\n-        def try_exec(argv):\n-            with contextlib.suppress(OSError):\n-                os.execvp(argv[0], argv)\n-    \"\"\",\n-    \"boot_xz\": r\"\"\"\n-        import lzma\n-        import sys\n-        def boot_xz(filename, size, args=[], send_end=False):\n-            command('beiboot.provide', size)\n-            src_xz = sys.stdin.buffer.read(size)\n-            src = lzma.decompress(src_xz)\n-            sys.argv = [filename, *args]\n-            if send_end:\n-                end()\n-            exec(src, {\n-                '__name__': '__main__',\n-                '__self_source__': src_xz,\n-                '__file__': filename})\n-            sys.exit()\n-    \"\"\",\n-}\n+            # Our own .connection_made() handler should have gotten called by\n+            # now.  Make sure everything got filled in properly.\n+            assert self._subprocess_transport is transport\n+            assert self._stdin_transport is not None\n+            assert self._stdout_transport is not None\n \n+            # Ask the InteractionAgent to start processing stderr.\n+            self._agent.start()\n \n-def split_code(code: str, imports: Set[str]) -> Iterable[Tuple[str, str]]:\n-    for line in textwrap.dedent(code).splitlines():\n-        text = line.lstrip(\" \")\n-        if text.startswith(\"import \"):\n-            imports.add(text)\n-        elif text:\n-            spaces = len(line) - len(text)\n-            assert (spaces % 4) == 0\n-            yield \"\\t\" * (spaces // 4), text\n+        self._exec_task.add_done_callback(exec_completed)\n \n+        return self, protocol\n \n-def yield_body(user_gadgets: Dict[str, str],\n-               steps: Sequence[Tuple[str, Sequence[object]]],\n-               imports: Set[str]) -> Iterable[Tuple[str, str]]:\n-    # Allow the caller to override our gadgets, but keep the original\n-    # variable for use in the next step.\n-    gadgets = dict(GADGETS, **user_gadgets)\n+    def __init__(self, protocol: asyncio.Protocol) -> None:\n+        self._protocol = protocol\n \n-    # First emit the gadgets.  Emit all gadgets provided by the caller,\n-    # plus any referred to by the caller's list of steps.\n-    provided_gadgets = set(user_gadgets)\n-    step_gadgets = {name for name, _args in steps}\n-    for name in provided_gadgets | step_gadgets:\n-        yield from split_code(gadgets[name], imports)\n+    def _consider_disconnect(self) -> None:\n+        logger.debug('_consider_disconnect(%r)', self)\n+        # We cannot disconnect as long as any of these three things are happening\n+        if not self._exec_task.done():\n+            logger.debug('  exec_task still running %r', self._exec_task)\n+            return\n \n-    # Yield functions mentioned in steps from the caller\n-    for name, args in steps:\n-        yield '', name + repr(tuple(args))\n+        if self._subprocess_transport is not None and not self._transport_disconnected:\n+            logger.debug('  transport still connected %r', self._subprocess_transport)\n+            return\n \n+        if self._stderr_output is None:\n+            logger.debug('  agent still running')\n+            return\n \n-def make_bootloader(steps: Sequence[Tuple[str, Sequence[object]]],\n-                    gadgets: Optional[Dict[str, str]] = None) -> str:\n-    imports: Set[str] = set()\n-    lines: List[str] = []\n+        # All conditions for disconnection are satisfied.\n+        if self._protocol_disconnected:\n+            logger.debug('  already disconnected')\n+            return\n+        self._protocol_disconnected = True\n \n-    for frame_spaces, frame_text in split_code(GADGETS[\"_frame\"], imports):\n-        if frame_text == \"...\":\n-            for spaces, text in yield_body(gadgets or {}, steps, imports):\n-                lines.append(frame_spaces + spaces + text)\n+        # Now we just need to determine what we report to the protocol...\n+        if self._exception is not None:\n+            # If we got an exception reported, that's our reason for closing.\n+            logger.debug('  disconnect with exception %r', self._exception)\n+            self._protocol.connection_lost(self._exception)\n+        elif self._returncode == 0 or self._closed:\n+            # If we called close() or have a zero return status, that's a clean\n+            # exit, regardless of noise that might have landed in stderr.\n+            logger.debug('  clean disconnect')\n+            self._protocol.connection_lost(None)\n+        elif self._is_ssh and self._returncode == 255:\n+            # This is an error code due to an SSH failure.  Try to interpret it.\n+            logger.debug('  disconnect with ssh error %r', self._stderr_output)\n+            self._protocol.connection_lost(get_exception_for_ssh_stderr(self._stderr_output))\n         else:\n-            lines.append(frame_spaces + frame_text)\n-\n-    return \"\".join(f\"{line}\\n\" for line in [*imports, *lines]) + \"\\n\"\n-''',\n-  'cockpit/_vendor/bei/tmpfs.py': br'''import os\n-import subprocess\n-import sys\n-import tempfile\n-\n-\n-def main(*command: str) -> None:\n-    with tempfile.TemporaryDirectory() as tmpdir:\n-        os.chdir(tmpdir)\n-\n-        for key, value in __loader__.get_contents().items():\n-            if key.startswith('tmpfs/'):\n-                subdir = os.path.dirname(key)\n-                os.makedirs(subdir, exist_ok=True)\n-                with open(key, 'wb') as fp:\n-                    fp.write(value)\n-\n-        os.chdir('tmpfs')\n-\n-        result = subprocess.run(command, check=False)\n-        sys.exit(result.returncode)\n-''',\n-  'cockpit/_vendor/bei/__init__.py': br'''''',\n-  'cockpit/_vendor/bei/spawn.py': br'''\"\"\"Helper to create a beipack to spawn a command with files in a tmpdir\"\"\"\n-\n-import argparse\n-import os\n-import sys\n-\n-from . import pack, tmpfs\n-\n-\n-def main() -> None:\n-    parser = argparse.ArgumentParser()\n-    parser.add_argument('--file', '-f', action='append')\n-    parser.add_argument('command', nargs='+', help='The command to execute')\n-    args = parser.parse_args()\n-\n-    contents = {\n-        '_beitmpfs.py': tmpfs.__spec__.loader.get_data(tmpfs.__spec__.origin)\n-    }\n-\n-    if args.file is not None:\n-        files = args.file\n-    else:\n-        file = args.command[-1]\n-        files = [file]\n-        args.command[-1] = './' + os.path.basename(file)\n-\n-    for filename in files:\n-        with open(filename, 'rb') as file:\n-            basename = os.path.basename(filename)\n-            contents[f'tmpfs/{basename}'] = file.read()\n-\n-    script = pack.pack(contents, '_beitmpfs:main', '*' + repr(args.command))\n-    sys.stdout.write(script)\n-\n-\n-if __name__ == '__main__':\n-    main()\n-''',\n-  'cockpit/_vendor/bei/beipack.py': br'''# beipack - Remote bootloader for Python\n-#\n-# Copyright (C) 2022 Allison Karlitskaya <allison.karlitskaya@redhat.com>\n-#\n-# This program is free software: you can redistribute it and/or modify\n-# it under the terms of the GNU General Public License as published by\n-# the Free Software Foundation, either version 3 of the License, or\n-# (at your option) any later version.\n-#\n-# This program is distributed in the hope that it will be useful,\n-# but WITHOUT ANY WARRANTY; without even the implied warranty of\n-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n-# GNU General Public License for more details.\n-#\n-# You should have received a copy of the GNU General Public License\n-# along with this program.  If not, see <http://www.gnu.org/licenses/>.\n-\n-import argparse\n-import binascii\n-import lzma\n-import os\n-import sys\n-import tempfile\n-import zipfile\n-from typing import Dict, Iterable, List, Optional, Set, Tuple\n-\n-from .data import read_data_file\n-\n-\n-def escape_string(data: str) -> str:\n-    # Avoid mentioning ' ' ' literally, to make our own packing a bit prettier\n-    triplequote = \"'\" * 3\n-    if triplequote not in data:\n-        return \"r\" + triplequote + data + triplequote\n-    if '\"\"\"' not in data:\n-        return 'r\"\"\"' + data + '\"\"\"'\n-    return repr(data)\n-\n-\n-def ascii_bytes_repr(data: bytes) -> str:\n-    return 'b' + escape_string(data.decode('ascii'))\n-\n-\n-def utf8_bytes_repr(data: bytes) -> str:\n-    return escape_string(data.decode('utf-8')) + \".encode('utf-8')\"\n-\n-\n-def base64_bytes_repr(data: bytes, imports: Set[str]) -> str:\n-    # base85 is smaller, but base64 is in C, and ~20x faster.\n-    # when compressing with `xz -e` the size difference is marginal.\n-    imports.add('from binascii import a2b_base64')\n-    encoded = binascii.b2a_base64(data).decode('ascii').strip()\n-    return f'a2b_base64(\"{encoded}\")'\n-\n-\n-def bytes_repr(data: bytes, imports: Set[str]) -> str:\n-    # Strategy:\n-    #   if the file is ascii, encode it directly as bytes\n-    #   otherwise, if it's UTF-8, use a unicode string and encode\n-    #   otherwise, base64\n-\n-    try:\n-        return ascii_bytes_repr(data)\n-    except UnicodeDecodeError:\n-        # it's not ascii\n-        pass\n-\n-    # utf-8\n-    try:\n-        return utf8_bytes_repr(data)\n-    except UnicodeDecodeError:\n-        # it's not utf-8\n-        pass\n-\n-    return base64_bytes_repr(data, imports)\n-\n-\n-def dict_repr(contents: Dict[str, bytes], imports: Set[str]) -> str:\n-    return ('{\\n' +\n-            ''.join(f'  {repr(k)}: {bytes_repr(v, imports)},\\n'\n-                    for k, v in contents.items()) +\n-            '}')\n-\n-\n-def pack(contents: Dict[str, bytes],\n-         entrypoint: Optional[str] = None,\n-         args: str = '') -> str:\n-    \"\"\"Creates a beipack with the given `contents`.\n-\n-    If `entrypoint` is given, it should be an entry point which is run as the\n-    \"main\" function.  It is given in the `package.module:func format` such that\n-    the following code is emitted:\n-\n-        from package.module import func as main\n-        main()\n-\n-    Additionally, if `args` is given, it is written verbatim between the parens\n-    of the call to main (ie: it should already be in Python syntax).\n-    \"\"\"\n-\n-    loader = read_data_file('beipack_loader.py')\n-    lines = [line for line in loader.splitlines() if line]\n-    lines.append('')\n-\n-    imports = {'import sys'}\n-    contents_txt = dict_repr(contents, imports)\n-    lines.extend(imports)\n-    lines.append(f'sys.meta_path.insert(0, BeipackLoader({contents_txt}))')\n-\n-    if entrypoint:\n-        package, main = entrypoint.split(':')\n-        lines.append(f'from {package} import {main} as main')\n-        lines.append(f'main({args})')\n-\n-    return ''.join(f'{line}\\n' for line in lines)\n-\n-\n-def collect_contents(filenames: List[str],\n-                     relative_to: Optional[str] = None) -> Dict[str, bytes]:\n-    contents: Dict[str, bytes] = {}\n-\n-    for filename in filenames:\n-        with open(filename, 'rb') as file:\n-            contents[os.path.relpath(filename, start=relative_to)] = file.read()\n-\n-    return contents\n-\n-\n-def collect_module(name: str, *, recursive: bool) -> Dict[str, bytes]:\n-    import importlib.resources\n-    from importlib.resources.abc import Traversable\n-\n-    def walk(path: str, entry: Traversable) -> Iterable[Tuple[str, bytes]]:\n-        for item in entry.iterdir():\n-            itemname = f'{path}/{item.name}'\n-            if item.is_file():\n-                yield itemname, item.read_bytes()\n-            elif recursive and item.name != '__pycache__':\n-                yield from walk(itemname, item)\n-\n-    return dict(walk(name.replace('.', '/'), importlib.resources.files(name)))\n-\n-\n-def collect_zip(filename: str) -> Dict[str, bytes]:\n-    contents = {}\n-\n-    with zipfile.ZipFile(filename) as file:\n-        for entry in file.filelist:\n-            if '.dist-info/' in entry.filename:\n-                continue\n-            contents[entry.filename] = file.read(entry)\n-\n-    return contents\n-\n-\n-def collect_pep517(path: str) -> Dict[str, bytes]:\n-    with tempfile.TemporaryDirectory() as tmpdir:\n-        import build\n-        builder = build.ProjectBuilder(path)\n-        wheel = builder.build('wheel', tmpdir)\n-        return collect_zip(wheel)\n-\n+            # Otherwise, report the stderr text and return code.\n+            logger.debug('  disconnect with exit code %r, stderr %r', self._returncode, self._stderr_output)\n+            # We surely have _returncode set here, since otherwise:\n+            #  - exec_task failed with an exception (which we handle above); or\n+            #  - we're still connected...\n+            assert self._returncode is not None\n+            self._protocol.connection_lost(SubprocessError(self._returncode, self._stderr_output))\n \n-def main() -> None:\n-    parser = argparse.ArgumentParser()\n-    parser.add_argument('--python', '-p',\n-                        help=\"add a #!python3 interpreter line using the given path\")\n-    parser.add_argument('--xz', '-J', action='store_true',\n-                        help=\"compress the output with `xz`\")\n-    parser.add_argument('--topdir',\n-                        help=\"toplevel directory (paths are stored relative to this)\")\n-    parser.add_argument('--output', '-o',\n-                        help=\"write output to a file (default: stdout)\")\n-    parser.add_argument('--main', '-m', metavar='MODULE:FUNC',\n-                        help=\"use FUNC from MODULE as the main function\")\n-    parser.add_argument('--main-args', metavar='ARGS',\n-                        help=\"arguments to main() in Python syntax\", default='')\n-    parser.add_argument('--module', action='append', default=[],\n-                        help=\"collect installed modules (recursively)\")\n-    parser.add_argument('--zip', '-z', action='append', default=[],\n-                        help=\"include files from a zipfile (or wheel)\")\n-    parser.add_argument('--build', metavar='DIR', action='append', default=[],\n-                        help=\"PEP-517 from a given source directory\")\n-    parser.add_argument('files', nargs='*',\n-                        help=\"files to include in the beipack\")\n-    args = parser.parse_args()\n+    def _interaction_completed(self, future: 'asyncio.Future[str]') -> None:\n+        logger.debug('_interaction_completed(%r, %r)', self, future)\n+        try:\n+            self._stderr_output = future.result()\n+            logger.debug('  stderr: %r', self._stderr_output)\n+        except Exception as exc:\n+            logger.debug('  exception: %r', exc)\n+            self._stderr_output = ''  # we need to set this in order to complete\n+            self.close(exc)\n \n-    contents = collect_contents(args.files, relative_to=args.topdir)\n+        self._consider_disconnect()\n \n-    for file in args.zip:\n-        contents.update(collect_zip(file))\n+    # BaseProtocol implementation\n+    def connection_made(self, transport: asyncio.BaseTransport) -> None:\n+        logger.debug('connection_made(%r, %r)', self, transport)\n+        assert isinstance(transport, asyncio.SubprocessTransport)\n+        self._subprocess_transport = transport\n \n-    for name in args.module:\n-        contents.update(collect_module(name, recursive=True))\n+        stdin_transport = transport.get_pipe_transport(0)\n+        assert isinstance(stdin_transport, asyncio.WriteTransport)\n+        self._stdin_transport = stdin_transport\n \n-    for path in args.build:\n-        contents.update(collect_pep517(path))\n+        stdout_transport = transport.get_pipe_transport(1)\n+        assert isinstance(stdout_transport, asyncio.ReadTransport)\n+        self._stdout_transport = stdout_transport\n \n-    result = pack(contents, args.main, args.main_args).encode('utf-8')\n+        stderr_transport = transport.get_pipe_transport(2)\n+        assert stderr_transport is None\n \n-    if args.python:\n-        result = b'#!' + args.python.encode('ascii') + b'\\n' + result\n+        logger.debug('calling connection_made(%r, %r)', self, self._protocol)\n+        self._protocol.connection_made(self)\n \n-    if args.xz:\n-        result = lzma.compress(result, preset=lzma.PRESET_EXTREME)\n+    def connection_lost(self, exc: 'Exception | None') -> None:\n+        logger.debug('connection_lost(%r, %r)', self, exc)\n+        if self._exception is None:\n+            self._exception = exc\n+        self._transport_disconnected = True\n+        self._consider_disconnect()\n \n-    if args.output:\n-        with open(args.output, 'wb') as file:\n-            file.write(result)\n-    else:\n-        if args.xz and os.isatty(1):\n-            sys.exit('refusing to write compressed output to a terminal')\n-        sys.stdout.buffer.write(result)\n+    # SubprocessProtocol implementation\n+    def pipe_data_received(self, fd: int, data: bytes) -> None:\n+        logger.debug('pipe_data_received(%r, %r, %r)', self, fd, len(data))\n+        assert fd == 1  # stderr is handled separately\n+        self._protocol.data_received(data)\n \n+    def pipe_connection_lost(self, fd: int, exc: 'Exception | None') -> None:\n+        logger.debug('pipe_connection_lost(%r, %r, %r)', self, fd, exc)\n+        assert fd in (0, 1)  # stderr is handled separately\n \n-if __name__ == '__main__':\n-    main()\n-''',\n-  'cockpit/_vendor/bei/data/beipack_loader.py': br'''# beipack https://github.com/allisonkarlitskaya/beipack\n+        # We treat this as a clean close\n+        if isinstance(exc, BrokenPipeError):\n+            exc = None\n \n-import importlib.abc\n-import importlib.util\n-import io\n-import sys\n-from types import ModuleType\n-from typing import BinaryIO, Dict, Iterator, Optional, Sequence\n+        # Record serious errors to propagate them to the protocol\n+        # If this is a clean exit on stdout, report an EOF\n+        if exc is not None:\n+            self.close(exc)\n+        elif fd == 1 and not self._closed:\n+            if not self._protocol.eof_received():\n+                self.close()\n \n+    def process_exited(self) -> None:\n+        logger.debug('process_exited(%r)', self)\n+        assert self._subprocess_transport is not None\n+        self._returncode = self._subprocess_transport.get_returncode()\n+        logger.debug('  ._returncode = %r', self._returncode)\n+        self._agent.force_completion()\n \n-class BeipackLoader(importlib.abc.SourceLoader, importlib.abc.MetaPathFinder):\n-    if sys.version_info >= (3, 11):\n-        from importlib.resources.abc import ResourceReader as AbstractResourceReader\n-    else:\n-        AbstractResourceReader = object\n+    def pause_writing(self) -> None:\n+        logger.debug('pause_writing(%r)', self)\n+        self._protocol.pause_writing()\n \n-    class ResourceReader(AbstractResourceReader):\n-        def __init__(self, contents: Dict[str, bytes], filename: str) -> None:\n-            self._contents = contents\n-            self._dir = f'{filename}/'\n+    def resume_writing(self) -> None:\n+        logger.debug('resume_writing(%r)', self)\n+        self._protocol.resume_writing()\n \n-        def is_resource(self, resource: str) -> bool:\n-            return f'{self._dir}{resource}' in self._contents\n+    # Transport implementation.  Most of this is straight delegation.\n+    def close(self, exc: 'Exception | None' = None) -> None:\n+        logger.debug('close(%r, %r)', self, exc)\n+        self._closed = True\n+        if self._exception is None:\n+            logger.debug('  setting exception %r', exc)\n+            self._exception = exc\n+        if not self._exec_task.done():\n+            logger.debug('  cancelling _exec_task')\n+            self._exec_task.cancel()\n+        if self._subprocess_transport is not None:\n+            logger.debug('  closing _subprocess_transport')\n+            # https://github.com/python/cpython/issues/112800\n+            with contextlib.suppress(PermissionError):\n+                self._subprocess_transport.close()\n+        self._agent.force_completion()\n \n-        def open_resource(self, resource: str) -> BinaryIO:\n-            return io.BytesIO(self._contents[f'{self._dir}{resource}'])\n+    def is_closing(self) -> bool:\n+        assert self._subprocess_transport is not None\n+        return self._subprocess_transport.is_closing()\n \n-        def resource_path(self, resource: str) -> str:\n-            raise FileNotFoundError\n+    def get_extra_info(self, name: str, default: object = None) -> object:\n+        assert self._subprocess_transport is not None\n+        return self._subprocess_transport.get_extra_info(name, default)\n \n-        def contents(self) -> Iterator[str]:\n-            dir_length = len(self._dir)\n-            result = set()\n+    def set_protocol(self, protocol: asyncio.BaseProtocol) -> None:\n+        assert isinstance(protocol, asyncio.Protocol)\n+        self._protocol = protocol\n \n-            for filename in self._contents:\n-                if filename.startswith(self._dir):\n-                    try:\n-                        next_slash = filename.index('/', dir_length)\n-                    except ValueError:\n-                        next_slash = None\n-                    result.add(filename[dir_length:next_slash])\n+    def get_protocol(self) -> asyncio.Protocol:\n+        return self._protocol\n \n-            return iter(result)\n+    def is_reading(self) -> bool:\n+        assert self._stdout_transport is not None\n+        try:\n+            return self._stdout_transport.is_reading()\n+        except NotImplementedError:\n+            # This is (incorrectly) unimplemented before Python 3.11\n+            return not self._stdout_transport._paused  # type:ignore[attr-defined]\n+        except AttributeError:\n+            # ...and in Python 3.6 it's even worse\n+            try:\n+                selector = self._stdout_transport._loop._selector  # type:ignore[attr-defined]\n+                selector.get_key(self._stdout_transport._fileno)  # type:ignore[attr-defined]\n+                return True\n+            except KeyError:\n+                return False\n \n-    contents: Dict[str, bytes]\n-    modules: Dict[str, str]\n+    def pause_reading(self) -> None:\n+        assert self._stdout_transport is not None\n+        self._stdout_transport.pause_reading()\n \n-    def __init__(self, contents: Dict[str, bytes]) -> None:\n-        try:\n-            contents[__file__] = __self_source__  # type: ignore[name-defined]\n-        except NameError:\n-            pass\n+    def resume_reading(self) -> None:\n+        assert self._stdout_transport is not None\n+        self._stdout_transport.resume_reading()\n \n-        self.contents = contents\n-        self.modules = {\n-            self.get_fullname(filename): filename\n-            for filename in contents\n-            if filename.endswith(\".py\")\n-        }\n+    def abort(self) -> None:\n+        assert self._stdin_transport is not None\n+        assert self._subprocess_transport is not None\n+        self._stdin_transport.abort()\n+        self._subprocess_transport.kill()\n \n-    def get_fullname(self, filename: str) -> str:\n-        assert filename.endswith(\".py\")\n-        filename = filename[:-3]\n-        if filename.endswith(\"/__init__\"):\n-            filename = filename[:-9]\n-        return filename.replace(\"/\", \".\")\n+    def can_write_eof(self) -> bool:\n+        assert self._stdin_transport is not None\n+        return self._stdin_transport.can_write_eof()  # will always be True\n \n-    def get_resource_reader(self, fullname: str) -> ResourceReader:\n-        return BeipackLoader.ResourceReader(self.contents, fullname.replace('.', '/'))\n+    def get_write_buffer_size(self) -> int:\n+        assert self._stdin_transport is not None\n+        return self._stdin_transport.get_write_buffer_size()\n \n-    def get_data(self, path: str) -> bytes:\n-        return self.contents[path]\n+    def get_write_buffer_limits(self) -> 'tuple[int, int]':\n+        assert self._stdin_transport is not None\n+        return self._stdin_transport.get_write_buffer_limits()\n \n-    def get_filename(self, fullname: str) -> str:\n-        return self.modules[fullname]\n+    def set_write_buffer_limits(self, high: 'int | None' = None, low: 'int | None' = None) -> None:\n+        assert self._stdin_transport is not None\n+        return self._stdin_transport.set_write_buffer_limits(high, low)\n \n-    def find_spec(\n-        self,\n-        fullname: str,\n-        path: Optional[Sequence[str]],\n-        target: Optional[ModuleType] = None\n-      ) -> Optional[importlib.machinery.ModuleSpec]:\n-        if fullname not in self.modules:\n-            return None\n-        return importlib.util.spec_from_loader(fullname, self)\n-''',\n-  'cockpit/_vendor/bei/data/__init__.py': br'''import sys\n+    def write(self, data: bytes) -> None:\n+        assert self._stdin_transport is not None\n+        return self._stdin_transport.write(data)\n \n-if sys.version_info >= (3, 9):\n-    import importlib.abc\n-    import importlib.resources\n+    def writelines(self, list_of_data: Iterable[bytes]) -> None:\n+        assert self._stdin_transport is not None\n+        return self._stdin_transport.writelines(list_of_data)\n \n-    def read_data_file(filename: str) -> str:\n-        return (importlib.resources.files(__name__) / filename).read_text()\n-else:\n-    def read_data_file(filename: str) -> str:\n-        loader = __loader__  # type: ignore[name-defined]\n-        data = loader.get_data(__file__.replace('__init__.py', filename))\n-        return data.decode('utf-8')\n-''',\n-  'cockpit/data/__init__.py': br'''import sys\n+    def write_eof(self) -> None:\n+        assert self._stdin_transport is not None\n+        return self._stdin_transport.write_eof()\n \n-if sys.version_info >= (3, 11):\n-    import importlib.resources\n+    # We don't really implement SubprocessTransport, but provide these as\n+    # \"extras\" to our user.\n+    def get_pid(self) -> int:\n+        assert self._subprocess_transport is not None\n+        return self._subprocess_transport.get_pid()\n \n-    def read_cockpit_data_file(filename: str) -> bytes:\n-        return (importlib.resources.files('cockpit.data') / filename).read_bytes()\n+    def get_returncode(self) -> 'int | None':\n+        return self._returncode\n \n-else:\n-    import importlib.abc\n+    def kill(self) -> None:\n+        assert self._subprocess_transport is not None\n+        self._subprocess_transport.kill()\n \n-    def read_cockpit_data_file(filename: str) -> bytes:\n-        # https://github.com/python/mypy/issues/4182\n-        loader = __loader__  # type: ignore[name-defined]\n-        assert isinstance(loader, importlib.abc.ResourceLoader)\n+    def send_signal(self, number: int) -> None:\n+        assert self._subprocess_transport is not None\n+        self._subprocess_transport.send_signal(number)\n \n-        path = __file__.replace('__init__.py', filename)\n-        return loader.get_data(path)\n+    def terminate(self) -> None:\n+        assert self._subprocess_transport is not None\n+        self._subprocess_transport.terminate()\n ''',\n   'cockpit/data/fail.html': br'''<!DOCTYPE html>\n <html>\n <head>\n     <title>@@message@@</title>\n     <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n     <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n@@ -11433,10 +11414,29 @@\n     <div class=\"blank-slate-pf\">\n         <img src=\"data:image/png;base64,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\">\n         <h1>@@message@@</h1>\n     </div>\n </body>\n </html>\n ''',\n+  'cockpit/data/__init__.py': br'''import sys\n+\n+if sys.version_info >= (3, 11):\n+    import importlib.resources\n+\n+    def read_cockpit_data_file(filename: str) -> bytes:\n+        return (importlib.resources.files('cockpit.data') / filename).read_bytes()\n+\n+else:\n+    import importlib.abc\n+\n+    def read_cockpit_data_file(filename: str) -> bytes:\n+        # https://github.com/python/mypy/issues/4182\n+        loader = __loader__  # type: ignore[name-defined]\n+        assert isinstance(loader, importlib.abc.ResourceLoader)\n+\n+        path = __file__.replace('__init__.py', filename)\n+        return loader.get_data(path)\n+''',\n }))\n from cockpit.bridge import main as main\n main(beipack=True)\n"}]}, {"source1": "./usr/lib/python3/dist-packages/cockpit-311.dist-info/direct_url.json", "source2": "./usr/lib/python3/dist-packages/cockpit-311.dist-info/direct_url.json", "unified_diff": null, "details": [{"source1": "Pretty-printed", "source2": "Pretty-printed", "comments": ["Similarity: 0.90625%", "Differences: {\"'archive_info'\": \"{'hash': \"", "                   \"'sha256=c35b82ebcc20267f3cb333d859e7587ca7783679982ec79d6d226a4252fe3c67', \"", "                   \"'hashes': {'sha256': \"", "                   \"'c35b82ebcc20267f3cb333d859e7587ca7783679982ec79d6d226a4252fe3c67'}}\"}"], "unified_diff": "@@ -1,9 +1,9 @@\n {\n     \"archive_info\": {\n-        \"hash\": \"sha256=6d482ccd7802b9e6c087a16fd3de1aeb271b5d487fd701501af04e539a2122f3\",\n+        \"hash\": \"sha256=c35b82ebcc20267f3cb333d859e7587ca7783679982ec79d6d226a4252fe3c67\",\n         \"hashes\": {\n-            \"sha256\": \"6d482ccd7802b9e6c087a16fd3de1aeb271b5d487fd701501af04e539a2122f3\"\n+            \"sha256\": \"c35b82ebcc20267f3cb333d859e7587ca7783679982ec79d6d226a4252fe3c67\"\n         }\n     },\n     \"url\": \"file:///build/reproducible-path/cockpit-311/tmp/wheel/cockpit-311-py3-none-any.whl\"\n }\n"}]}]}]}]}]}