{"diffoscope-json-version": 1, "source1": "/srv/reproducible-results/rbuild-debian/r-b-build.fWH4IW2f/b1/cockpit_311-1_armhf.changes", "source2": "/srv/reproducible-results/rbuild-debian/r-b-build.fWH4IW2f/b2/cockpit_311-1_armhf.changes", "unified_diff": null, "details": [{"source1": "Files", "source2": "Files", "unified_diff": "@@ -1,10 +1,10 @@\n \n cf6e11841c7839c56944514d11f89c98 138212 debug optional cockpit-bridge-dbgsym_311-1_armhf.deb\n- 797438ab16c5264312e22f9cc4085d32 352276 admin optional cockpit-bridge_311-1_armhf.deb\n+ 9373abbf727d0fc1b6749d2aa23aa88b 352160 admin optional cockpit-bridge_311-1_armhf.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 f8f0abe7a7679703c2b319034bcb3343 231244 debug optional cockpit-pcp-dbgsym_311-1_armhf.deb\n bdd727962c92577ef1a24abf8491bc8c 70672 admin optional cockpit-pcp_311-1_armhf.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_armhf.deb", "source2": "cockpit-bridge_311-1_armhf.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 3880 2024-02-15 08:39:16.000000 control.tar.xz\n--rw-r--r-- 0 0 0 348204 2024-02-15 08:39:16.000000 data.tar.xz\n+-rw-r--r-- 0 0 0 348088 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) 85660 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) 85552 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,15 +64,15 @@\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/protocol.py': br'''# This file is part of Cockpit.\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@@ -81,491 +81,1306 @@\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 .\n \n+\"\"\"Bi-directional asyncio.Transport implementations based on file descriptors.\"\"\"\n+\n import asyncio\n-import json\n+import collections\n+import ctypes\n+import errno\n+import fcntl\n import logging\n-import uuid\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 .jsonutil import JsonError, JsonObject, JsonValue, create_object, get_int, get_str, typechecked\n \n logger = logging.getLogger(__name__)\n+IOV_MAX = 1024 # man 2 writev\n \n \n-class CockpitProblem(Exception):\n- \"\"\"A type of exception that carries a problem code and a message.\n+class _Transport(asyncio.Transport):\n+ BLOCK_SIZE: ClassVar[int] = 1024 * 1024\n \n- Depending on the scope, this is used to handle shutting down:\n+ # A transport always has a loop and a protocol\n+ _loop: asyncio.AbstractEventLoop\n+ _protocol: asyncio.Protocol\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+ _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- 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+ 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- 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+ 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-class CockpitProtocolError(CockpitProblem):\n- def __init__(self, message: str, problem: str = 'protocol-error'):\n- super().__init__(problem, message=message)\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-class CockpitProtocol(asyncio.Protocol):\n- \"\"\"A naive implementation of the Cockpit frame protocol\n+ os.set_blocking(in_fd, False)\n+ if out_fd != in_fd:\n+ os.set_blocking(out_fd, False)\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+ self._protocol.connection_made(self)\n+ self.resume_reading()\n \n- def do_ready(self) -> None:\n- pass\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- def do_closed(self, exc: 'Exception | None') -> None:\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 transport_control_received(self, command: str, message: JsonObject) -> None:\n- raise NotImplementedError\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 channel_control_received(self, channel: str, command: str, message: JsonObject) -> None:\n+ def can_write_eof(self) -> bool:\n raise NotImplementedError\n \n- def channel_data_received(self, channel: str, data: bytes) -> None:\n- raise NotImplementedError\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 frame_received(self, frame: bytes) -> None:\n- header, _, data = frame.partition(b'\\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- 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+ def get_write_buffer_limits(self) -> 'tuple[int, int]':\n+ return (0, 0)\n \n- else:\n- self.control_received(data)\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- 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_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- 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+ logger.debug(' successfully wrote %d bytes from the queue', n_bytes)\n \n- except (json.JSONDecodeError, JsonError) as exc:\n- raise CockpitProtocolError(f'control message: {exc!s}') from exc\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- def consume_one_frame(self, data: bytes) -> int:\n- \"\"\"Consumes a single frame from view.\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- 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+ 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- 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_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- length = int(data[:newline])\n- except ValueError as exc:\n- raise CockpitProtocolError(\"frame size is not an integer\") from exc\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- start = newline + 1\n- end = start + length\n+ return asyncio.SafeChildWatcher()\n \n- if end > len(data):\n- # We need to read more\n- return len(data) - end\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- # We can consume a full frame\n- self.frame_received(data[start:end])\n- return end\n+ if watcher is None:\n+ watcher = SubprocessTransport._create_watcher()\n+ watcher.attach_loop(loop)\n+ setattr(loop, quark, watcher)\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+ return watcher\n \n- if self._closed:\n- logger.debug(' but the protocol already was closed, so closing transport')\n- transport.close()\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 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+ 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- def close(self, exc: 'Exception | None' = None) -> None:\n- if self._closed:\n- return\n- self._closed = True\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- if self.transport:\n- self.transport.close()\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- self.do_closed(exc)\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- 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+ 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- 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+ 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- 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+ 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 eof_received(self) -> bool:\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-# 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+class Spooler:\n+ \"\"\"Consumes data from an fd, storing it in a buffer.\n \n- def do_init(self, message: JsonObject) -> None:\n- pass\n+ This makes a copy of the fd, so you don't have to worry about holding it\n+ open.\n+ \"\"\"\n \n- def do_kill(self, host: 'str | None', group: 'str | None', message: JsonObject) -> None:\n- raise NotImplementedError\n+ _loop: asyncio.AbstractEventLoop\n+ _fd: int\n+ _contents: 'list[bytes]'\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+ 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- def do_ready(self) -> None:\n- self.do_send_init()\n+ self._fd = os.dup(fd)\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+ 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- 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+ 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- def do_authorize(self, message: JsonObject) -> None:\n- cookie = get_str(message, 'cookie')\n- response = get_str(message, 'response')\n+ if data != b'':\n+ self._contents.append(data)\n+ else:\n+ self.close()\n \n- if self.authorizations is None or cookie not in self.authorizations:\n- logger.warning('no matching authorize request')\n- return\n+ def _is_ready(self) -> bool:\n+ if self._fd == -1:\n+ return False\n+ return select.select([self._fd], [], [], 0) != ([], [], [])\n \n- self.authorizations[cookie].set_result(response)\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/superuser.py': br'''# This file is part of Cockpit.\n+ 'cockpit/polkit.py': r'''# This file is part of Cockpit.\n #\n-# Copyright (C) 2022 Red Hat, Inc.\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 .\n \n-import array\n import asyncio\n-import contextlib\n-import getpass\n+import locale\n import logging\n import os\n-import socket\n-from tempfile import TemporaryDirectory\n-from typing import List, Optional, Sequence, Tuple\n+import pwd\n+from typing import Dict, List, Sequence, Tuple\n \n-from cockpit._vendor import ferny\n-from cockpit._vendor.bei.bootloader import make_bootloader\n+from cockpit._vendor.ferny import AskpassHandler\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+# that path is valid on at least Debian, Fedora/RHEL, and Arch\n+HELPER_PATH = '/usr/lib/polkit-1/polkit-agent-helper-1'\n+\n+AGENT_DBUS_PATH = '/PolkitAgent'\n \n logger = logging.getLogger(__name__)\n \n+Identity = Tuple[str, Dict[str, Variant]]\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+# https://www.freedesktop.org/software/polkit/docs/latest/eggdbus-interface-org.freedesktop.PolicyKit1.AuthenticationAgent.html\n+\n+# Note that we don't implement the CancelAuthentication() API. pkexec gets called in a way that has no opportunity to\n+# cancel an ongoing authentication from the pkexec side. On the UI side cancellation is implemented via the standard\n+# asyncio process mechanism. If we ever need CancelAuthentication(), we could keep a cookie \u2192 get_current_task()\n+# mapping, but that method is not available for Python 3.6 yet.\n+\n+class org_freedesktop_PolicyKit1_AuthenticationAgent(bus.Object):\n+ def __init__(self, responder: AskpassHandler):\n+ super().__init__()\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+ # confusingly named: this actually does the whole authentication dialog, see docs\n+ @bus.Interface.Method('', ['s', 's', 's', 'a{ss}', 's', 'a(sa{sv})'])\n+ async def begin_authentication(self, action_id: str, message: str, icon_name: str,\n+ details: Dict[str, str], cookie: str, identities: Sequence[Identity]) -> None:\n+ logger.debug('BeginAuthentication: action %s, message \"%s\", icon %s, details %s, cookie %s, identities %r',\n+ action_id, message, icon_name, details, cookie, identities)\n+ # only support authentication as ourselves, as we don't yet have the\n+ # protocol plumbing and UI to select an admin user\n+ my_uid = os.geteuid()\n+ for (auth_type, subject) in identities:\n+ if auth_type == 'unix-user' and 'uid' in subject and subject['uid'].value == my_uid:\n+ logger.debug('Authentication subject %s matches our uid %d', subject, my_uid)\n+ break\n+ else:\n+ logger.warning('Not supporting authentication as any of %s', identities)\n+ return\n \n- responders: 'list[ferny.InteractionHandler]' = [self.responder]\n+ user_name = pwd.getpwuid(my_uid).pw_name\n+ process = await asyncio.create_subprocess_exec(HELPER_PATH, user_name, cookie,\n+ stdin=asyncio.subprocess.PIPE,\n+ stdout=asyncio.subprocess.PIPE)\n+ try:\n+ await self._communicate(process)\n+ except asyncio.CancelledError:\n+ logger.debug('Cancelled authentication')\n+ process.terminate()\n+ finally:\n+ res = await process.wait()\n+ logger.debug('helper exited with code %i', res)\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+ async def _communicate(self, process: asyncio.subprocess.Process) -> None:\n+ assert process.stdin\n+ assert process.stdout\n \n- agent = ferny.InteractionAgent(responders)\n+ messages: List[str] = []\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+ async for line in process.stdout:\n+ logger.debug('Read line from helper: %s', line)\n+ command, _, value = line.strip().decode().partition(' ')\n+\n+ # usually: PAM_PROMPT_ECHO_OFF Password: \\n\n+ if command.startswith('PAM_PROMPT'):\n+ # Don't pass this to the UI if it's \"Password\" (the usual case),\n+ # so that superuser.py uses the translated default\n+ if value.startswith('Password'):\n+ value = ''\n+\n+ # flush out accumulated info/error messages\n+ passwd = await self.responder.do_askpass('\\n'.join(messages), value, '')\n+ messages.clear()\n+ if passwd is None:\n+ logger.debug('got PAM_PROMPT %s, but do_askpass returned None', value)\n+ raise asyncio.CancelledError('no password given')\n+ logger.debug('got PAM_PROMPT %s, do_askpass returned a password', value)\n+ process.stdin.write(passwd.encode())\n+ process.stdin.write(b'\\n')\n+ del passwd # don't keep this around longer than necessary\n+ await process.stdin.drain()\n+ logger.debug('got PAM_PROMPT, wrote password to helper')\n+ elif command in ('PAM_TEXT_INFO', 'PAM_ERROR'):\n+ messages.append(value)\n+ elif command == 'SUCCESS':\n+ logger.debug('Authentication succeeded')\n+ break\n+ elif command == 'FAILURE':\n+ logger.warning('Authentication failed')\n+ break\n else:\n- env = self.env\n+ logger.warning('Unknown line from helper, aborting: %s', line)\n+ process.terminate()\n+ break\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+class PolkitAgent:\n+ \"\"\"Register polkit agent when required\n \n- try:\n- await agent.communicate()\n- except ferny.InteractionError as exc:\n- raise PeerError('authentication-failed', message=str(exc)) from exc\n+ Use this as a context manager to ensure that the agent gets unregistered again.\n+ \"\"\"\n+ def __init__(self, responder: AskpassHandler):\n+ self.responder = responder\n+ self.agent_slot = None\n \n+ async def __aenter__(self):\n+ try:\n+ self.system_bus = bus.Bus.default_system()\n+ except OSError as e:\n+ logger.warning('cannot connect to system bus, not registering polkit agent: %s', e)\n+ return self\n \n-class CockpitResponder(ferny.AskpassHandler):\n- commands = ('ferny.askpass', 'cockpit.send-stderr')\n+ try:\n+ # may refine that with a D-Bus call to logind\n+ self.subject = ('unix-session', {'session-id': Variant(os.environ['XDG_SESSION_ID'], 's')})\n+ except KeyError:\n+ logger.debug('XDG_SESSION_ID not set, not registering polkit agent')\n+ return self\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+ agent_object = org_freedesktop_PolicyKit1_AuthenticationAgent(self.responder)\n+ self.agent_slot = self.system_bus.add_object(AGENT_DBUS_PATH, agent_object)\n \n+ # register agent\n+ locale_name = locale.setlocale(locale.LC_MESSAGES, None)\n+ await self.system_bus.call_method_async(\n+ 'org.freedesktop.PolicyKit1',\n+ '/org/freedesktop/PolicyKit1/Authority',\n+ 'org.freedesktop.PolicyKit1.Authority',\n+ 'RegisterAuthenticationAgent',\n+ '(sa{sv})ss',\n+ self.subject, locale_name, AGENT_DBUS_PATH)\n+ logger.debug('Registered agent for %r and locale %s', self.subject, locale_name)\n+ return self\n \n-class AuthorizeResponder(CockpitResponder):\n- def __init__(self, router: Router):\n- self.router = router\n+ async def __aexit__(self, _exc_type, _exc_value, _traceback):\n+ if self.agent_slot:\n+ await self.system_bus.call_method_async(\n+ 'org.freedesktop.PolicyKit1',\n+ '/org/freedesktop/PolicyKit1/Authority',\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/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 .\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+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-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+from .data import read_cockpit_data_file\n+from .peer import Peer, PeerError\n \n- # D-Bus signals\n- prompt = bus.Interface.Signal('s', 's', 's', 'b', 's') # message, prompt, default, echo, error\n+logger = logging.getLogger(__name__)\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+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- 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+ 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- # superuser requested, but not active? That's an error.\n- raise RoutingError('access-denied')\n+ raise PeerError('internal-error', message=f'Unexpected ferny interaction command {command}')\n+''',\n+ 'cockpit/_version.py': br'''__version__ = '311'\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 .\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+from enum import Enum\n+from typing import Callable, Dict, List, Mapping, Optional, Sequence, Type, TypeVar, Union\n \n- def __init__(self, router: Router, *, privileged: bool = False):\n- super().__init__(router)\n+JsonLiteral = Union[str, float, bool, None]\n \n- self.pending_prompt = None\n- self.peer = None\n- self.startup = None\n+# immutable\n+JsonValue = Union['JsonObject', Sequence['JsonValue'], JsonLiteral]\n+JsonObject = Mapping[str, JsonValue]\n \n- if privileged or os.getuid() == 0:\n- self.current = 'root'\n+# mutable\n+JsonDocument = Union['JsonDict', 'JsonList', JsonLiteral]\n+JsonDict = Dict[str, JsonDocument]\n+JsonList = List[JsonDocument]\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+DT = TypeVar('DT')\n+T = TypeVar('T')\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+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- raise bus.BusError('cockpit.Superuser.Error', f'Unknown superuser bridge type \"{name}\"')\n+ result.pop(key, None)\n \n- self.current = 'init'\n- self.peer = SuperuserPeer(self.router, config, responder)\n- self.peer.add_done_callback(self.peer_done)\n+ return result\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+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- 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+ 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/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 .\n \n- logger.debug(\" bridges are now %s\", self.bridges)\n+import contextlib\n+import socket\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+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/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+# (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 .\n+\n+import asyncio\n+import collections\n+import logging\n+from typing import Dict, List, Optional\n+\n+from .jsonutil import JsonObject, JsonValue\n+from .protocol import CockpitProblem, CockpitProtocolError, CockpitProtocolServer\n+\n+logger = logging.getLogger(__name__)\n+\n+\n+class ExecutionQueue:\n+ \"\"\"Temporarily delay calls to a given set of class methods.\n+\n+ Functions by replacing the named function at the instance __dict__\n+ level, effectively providing an override for exactly one instance\n+ of `method`'s object.\n+ Queues the invocations. Run them later with .run(), which also reverses\n+ the redirection by deleting the named methods from the instance.\n+ \"\"\"\n+ def __init__(self, methods):\n+ self.queue = collections.deque()\n+ self.methods = methods\n+\n+ for method in self.methods:\n+ self._wrap(method)\n+\n+ def _wrap(self, method):\n+ # NB: this function is stored in the instance dict and therefore\n+ # doesn't function as a descriptor, isn't a method, doesn't get bound,\n+ # and therefore doesn't receive a self parameter\n+ setattr(method.__self__, method.__func__.__name__, lambda *args: self.queue.append((method, args)))\n+\n+ def run(self):\n+ logger.debug('ExecutionQueue: Running %d queued method calls', len(self.queue))\n+ for method, args in self.queue:\n+ method(*args)\n+\n+ for method in self.methods:\n+ delattr(method.__self__, method.__func__.__name__)\n+\n+\n+class Endpoint:\n+ router: 'Router'\n+ __endpoint_frozen_queue: Optional[ExecutionQueue] = None\n+\n+ def __init__(self, router: 'Router'):\n+ router.add_endpoint(self)\n+ self.router = router\n+\n+ def freeze_endpoint(self):\n+ assert self.__endpoint_frozen_queue is None\n+ logger.debug('Freezing endpoint %s', self)\n+ self.__endpoint_frozen_queue = ExecutionQueue({self.do_channel_control, self.do_channel_data, self.do_kill})\n+\n+ def thaw_endpoint(self):\n+ assert self.__endpoint_frozen_queue is not None\n+ logger.debug('Thawing endpoint %s', self)\n+ self.__endpoint_frozen_queue.run()\n+ self.__endpoint_frozen_queue = None\n+\n+ # interface for receiving messages\n+ def do_close(self):\n+ raise NotImplementedError\n+\n+ def do_channel_control(self, channel: str, command: str, message: JsonObject) -> None:\n+ raise NotImplementedError\n+\n+ def do_channel_data(self, channel: str, data: bytes) -> None:\n+ raise NotImplementedError\n+\n+ def do_kill(self, host: 'str | None', group: 'str | None', message: JsonObject) -> None:\n+ raise NotImplementedError\n+\n+ # interface for sending messages\n+ def send_channel_data(self, channel: str, data: bytes) -> None:\n+ self.router.write_channel_data(channel, data)\n+\n+ def send_channel_control(\n+ self, channel: str, command: str, _msg: 'JsonObject | None', **kwargs: JsonValue\n+ ) -> None:\n+ self.router.write_control(_msg, channel=channel, command=command, **kwargs)\n+ if command == 'close':\n+ self.router.endpoints[self].remove(channel)\n+ self.router.drop_channel(channel)\n+\n+ def shutdown_endpoint(self, _msg: 'JsonObject | None' = None, **kwargs: JsonValue) -> None:\n+ self.router.shutdown_endpoint(self, _msg, **kwargs)\n+\n+\n+class RoutingError(CockpitProblem):\n+ pass\n+\n+\n+class RoutingRule:\n+ router: 'Router'\n+\n+ def __init__(self, router: 'Router'):\n+ self.router = router\n+\n+ def apply_rule(self, options: JsonObject) -> Optional[Endpoint]:\n+ \"\"\"Check if a routing rule applies to a given 'open' message.\n+\n+ This should inspect the options dictionary and do one of the following three things:\n+\n+ - return an Endpoint to handle this channel\n+ - raise a RoutingError to indicate that the open should be rejected\n+ - return None to let the next rule run\n+ \"\"\"\n+ raise NotImplementedError\n \n def shutdown(self):\n- self.cancel_prompt()\n+ raise NotImplementedError\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+class Router(CockpitProtocolServer):\n+ routing_rules: List[RoutingRule]\n+ open_channels: Dict[str, Endpoint]\n+ endpoints: 'dict[Endpoint, set[str]]'\n+ no_endpoints: asyncio.Event # set if endpoints dict is empty\n+ _eof: bool = False\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+ def __init__(self, routing_rules: List[RoutingRule]):\n+ for rule in routing_rules:\n+ rule.router = self\n+ self.routing_rules = routing_rules\n+ self.open_channels = {}\n+ self.endpoints = {}\n+ self.no_endpoints = asyncio.Event()\n+ self.no_endpoints.set() # at first there are no endpoints\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+ def check_rules(self, options: JsonObject) -> Endpoint:\n+ for rule in self.routing_rules:\n+ logger.debug(' applying rule %s', rule)\n+ endpoint = rule.apply_rule(options)\n+ if endpoint is not None:\n+ logger.debug(' resulting endpoint is %s', endpoint)\n+ return endpoint\n+ else:\n+ logger.debug(' No rules matched')\n+ raise RoutingError('not-supported')\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+ def drop_channel(self, channel: str) -> None:\n+ try:\n+ self.open_channels.pop(channel)\n+ logger.debug('router dropped channel %s', channel)\n+ except KeyError:\n+ logger.error('trying to drop non-existent channel %s from %s', channel, self.open_channels)\n \n- @bus.Interface.Method()\n- def stop(self) -> None:\n- self.shutdown()\n+ def add_endpoint(self, endpoint: Endpoint) -> None:\n+ self.endpoints[endpoint] = set()\n+ self.no_endpoints.clear()\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+ def shutdown_endpoint(self, endpoint: Endpoint, _msg: 'JsonObject | None' = None, **kwargs: JsonValue) -> None:\n+ channels = self.endpoints.pop(endpoint)\n+ logger.debug('shutdown_endpoint(%s, %s) will close %s', endpoint, kwargs, channels)\n+ for channel in channels:\n+ self.write_control(_msg, command='close', channel=channel, **kwargs)\n+ self.drop_channel(channel)\n+\n+ if not self.endpoints:\n+ self.no_endpoints.set()\n+\n+ # were we waiting to exit?\n+ if self._eof:\n+ logger.debug(' endpoints remaining: %r', self.endpoints)\n+ if not self.endpoints and self.transport:\n+ logger.debug(' close transport')\n+ self.transport.close()\n+\n+ def do_kill(self, host: 'str | None', group: 'str | None', message: JsonObject) -> None:\n+ endpoints = set(self.endpoints)\n+ logger.debug('do_kill(%s, %s). Considering %d endpoints.', host, group, len(endpoints))\n+ for endpoint in endpoints:\n+ endpoint.do_kill(host, group, message)\n+\n+ def channel_control_received(self, channel: str, command: str, message: JsonObject) -> None:\n+ # If this is an open message then we need to apply the routing rules to\n+ # figure out the correct endpoint to connect. If it's not an open\n+ # message, then we expect the endpoint to already exist.\n+ if command == 'open':\n+ if channel in self.open_channels:\n+ raise CockpitProtocolError('channel is already open')\n+\n+ try:\n+ logger.debug('Trying to find endpoint for new channel %s payload=%s', channel, message.get('payload'))\n+ endpoint = self.check_rules(message)\n+ except RoutingError as exc:\n+ self.write_control(exc.attrs, command='close', channel=channel)\n+ return\n+\n+ self.open_channels[channel] = endpoint\n+ self.endpoints[endpoint].add(channel)\n else:\n- logger.debug('got Answer, but no prompt pending')\n+ try:\n+ endpoint = self.open_channels[channel]\n+ except KeyError:\n+ # sending to a non-existent channel can happen due to races and is not an error\n+ return\n+\n+ # At this point, we have the endpoint. Route the message.\n+ endpoint.do_channel_control(channel, command, message)\n+\n+ def channel_data_received(self, channel: str, data: bytes) -> None:\n+ try:\n+ endpoint = self.open_channels[channel]\n+ except KeyError:\n+ return\n+\n+ endpoint.do_channel_data(channel, data)\n+\n+ def eof_received(self) -> bool:\n+ logger.debug('eof_received(%r)', self)\n+\n+ endpoints = set(self.endpoints)\n+ for endpoint in endpoints:\n+ endpoint.do_close()\n+\n+ self._eof = True\n+ logger.debug(' endpoints remaining: %r', self.endpoints)\n+ return bool(self.endpoints)\n+\n+ _communication_done: Optional[asyncio.Future] = None\n+\n+ def do_closed(self, exc: Optional[Exception]) -> None:\n+ # If we didn't send EOF yet, do it now.\n+ if not self._eof:\n+ self.eof_received()\n+\n+ if self._communication_done is not None:\n+ if exc is None:\n+ self._communication_done.set_result(None)\n+ else:\n+ self._communication_done.set_exception(exc)\n+\n+ async def communicate(self) -> None:\n+ \"\"\"Wait until communication is complete on the router and all endpoints are done.\"\"\"\n+ assert self._communication_done is None\n+ self._communication_done = asyncio.get_running_loop().create_future()\n+ try:\n+ await self._communication_done\n+ except (BrokenPipeError, ConnectionResetError):\n+ pass # these are normal occurrences when closed from the other side\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/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@@ -1339,16 +2154,14 @@\n CPUTemperatureSampler,\n DiskSampler,\n MemorySampler,\n MountSampler,\n NetworkSampler,\n ]\n ''',\n- 'cockpit/_version.py': br'''__version__ = '311'\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@@ -1657,2100 +2470,14 @@\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/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 .\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/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-# (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 .\n-\n-import asyncio\n-import locale\n-import logging\n-import os\n-import pwd\n-from typing import Dict, List, Sequence, Tuple\n-\n-from cockpit._vendor.ferny import AskpassHandler\n-from cockpit._vendor.systemd_ctypes import Variant, bus\n-\n-# that path is valid on at least Debian, Fedora/RHEL, and Arch\n-HELPER_PATH = '/usr/lib/polkit-1/polkit-agent-helper-1'\n-\n-AGENT_DBUS_PATH = '/PolkitAgent'\n-\n-logger = logging.getLogger(__name__)\n-\n-Identity = Tuple[str, Dict[str, Variant]]\n-\n-\n-# https://www.freedesktop.org/software/polkit/docs/latest/eggdbus-interface-org.freedesktop.PolicyKit1.AuthenticationAgent.html\n-\n-# Note that we don't implement the CancelAuthentication() API. pkexec gets called in a way that has no opportunity to\n-# cancel an ongoing authentication from the pkexec side. On the UI side cancellation is implemented via the standard\n-# asyncio process mechanism. If we ever need CancelAuthentication(), we could keep a cookie \u2192 get_current_task()\n-# mapping, but that method is not available for Python 3.6 yet.\n-\n-class org_freedesktop_PolicyKit1_AuthenticationAgent(bus.Object):\n- def __init__(self, responder: AskpassHandler):\n- super().__init__()\n- self.responder = responder\n-\n- # confusingly named: this actually does the whole authentication dialog, see docs\n- @bus.Interface.Method('', ['s', 's', 's', 'a{ss}', 's', 'a(sa{sv})'])\n- async def begin_authentication(self, action_id: str, message: str, icon_name: str,\n- details: Dict[str, str], cookie: str, identities: Sequence[Identity]) -> None:\n- logger.debug('BeginAuthentication: action %s, message \"%s\", icon %s, details %s, cookie %s, identities %r',\n- action_id, message, icon_name, details, cookie, identities)\n- # only support authentication as ourselves, as we don't yet have the\n- # protocol plumbing and UI to select an admin user\n- my_uid = os.geteuid()\n- for (auth_type, subject) in identities:\n- if auth_type == 'unix-user' and 'uid' in subject and subject['uid'].value == my_uid:\n- logger.debug('Authentication subject %s matches our uid %d', subject, my_uid)\n- break\n- else:\n- logger.warning('Not supporting authentication as any of %s', identities)\n- return\n-\n- user_name = pwd.getpwuid(my_uid).pw_name\n- process = await asyncio.create_subprocess_exec(HELPER_PATH, user_name, cookie,\n- stdin=asyncio.subprocess.PIPE,\n- stdout=asyncio.subprocess.PIPE)\n- try:\n- await self._communicate(process)\n- except asyncio.CancelledError:\n- logger.debug('Cancelled authentication')\n- process.terminate()\n- finally:\n- res = await process.wait()\n- logger.debug('helper exited with code %i', res)\n-\n- async def _communicate(self, process: asyncio.subprocess.Process) -> None:\n- assert process.stdin\n- assert process.stdout\n-\n- messages: List[str] = []\n-\n- async for line in process.stdout:\n- logger.debug('Read line from helper: %s', line)\n- command, _, value = line.strip().decode().partition(' ')\n-\n- # usually: PAM_PROMPT_ECHO_OFF Password: \\n\n- if command.startswith('PAM_PROMPT'):\n- # Don't pass this to the UI if it's \"Password\" (the usual case),\n- # so that superuser.py uses the translated default\n- if value.startswith('Password'):\n- value = ''\n-\n- # flush out accumulated info/error messages\n- passwd = await self.responder.do_askpass('\\n'.join(messages), value, '')\n- messages.clear()\n- if passwd is None:\n- logger.debug('got PAM_PROMPT %s, but do_askpass returned None', value)\n- raise asyncio.CancelledError('no password given')\n- logger.debug('got PAM_PROMPT %s, do_askpass returned a password', value)\n- process.stdin.write(passwd.encode())\n- process.stdin.write(b'\\n')\n- del passwd # don't keep this around longer than necessary\n- await process.stdin.drain()\n- logger.debug('got PAM_PROMPT, wrote password to helper')\n- elif command in ('PAM_TEXT_INFO', 'PAM_ERROR'):\n- messages.append(value)\n- elif command == 'SUCCESS':\n- logger.debug('Authentication succeeded')\n- break\n- elif command == 'FAILURE':\n- logger.warning('Authentication failed')\n- break\n- else:\n- logger.warning('Unknown line from helper, aborting: %s', line)\n- process.terminate()\n- break\n-\n-\n-class PolkitAgent:\n- \"\"\"Register polkit agent when required\n-\n- Use this as a context manager to ensure that the agent gets unregistered again.\n- \"\"\"\n- def __init__(self, responder: AskpassHandler):\n- self.responder = responder\n- self.agent_slot = None\n-\n- async def __aenter__(self):\n- try:\n- self.system_bus = bus.Bus.default_system()\n- except OSError as e:\n- logger.warning('cannot connect to system bus, not registering polkit agent: %s', e)\n- return self\n-\n- try:\n- # may refine that with a D-Bus call to logind\n- self.subject = ('unix-session', {'session-id': Variant(os.environ['XDG_SESSION_ID'], 's')})\n- except KeyError:\n- logger.debug('XDG_SESSION_ID not set, not registering polkit agent')\n- return self\n-\n- agent_object = org_freedesktop_PolicyKit1_AuthenticationAgent(self.responder)\n- self.agent_slot = self.system_bus.add_object(AGENT_DBUS_PATH, agent_object)\n-\n- # register agent\n- locale_name = locale.setlocale(locale.LC_MESSAGES, None)\n- await self.system_bus.call_method_async(\n- 'org.freedesktop.PolicyKit1',\n- '/org/freedesktop/PolicyKit1/Authority',\n- 'org.freedesktop.PolicyKit1.Authority',\n- 'RegisterAuthenticationAgent',\n- '(sa{sv})ss',\n- self.subject, locale_name, AGENT_DBUS_PATH)\n- logger.debug('Registered agent for %r and locale %s', self.subject, locale_name)\n- return self\n-\n- async def __aexit__(self, _exc_type, _exc_value, _traceback):\n- if self.agent_slot:\n- await self.system_bus.call_method_async(\n- 'org.freedesktop.PolicyKit1',\n- '/org/freedesktop/PolicyKit1/Authority',\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/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 .\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/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 .\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/__init__.py': br'''from ._version import __version__ # noqa: F401\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 .\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/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-# (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 .\n-\n-import asyncio\n-import collections\n-import logging\n-from typing import Dict, List, Optional\n-\n-from .jsonutil import JsonObject, JsonValue\n-from .protocol import CockpitProblem, CockpitProtocolError, CockpitProtocolServer\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class ExecutionQueue:\n- \"\"\"Temporarily delay calls to a given set of class methods.\n-\n- Functions by replacing the named function at the instance __dict__\n- level, effectively providing an override for exactly one instance\n- of `method`'s object.\n- Queues the invocations. Run them later with .run(), which also reverses\n- the redirection by deleting the named methods from the instance.\n- \"\"\"\n- def __init__(self, methods):\n- self.queue = collections.deque()\n- self.methods = methods\n-\n- for method in self.methods:\n- self._wrap(method)\n-\n- def _wrap(self, method):\n- # NB: this function is stored in the instance dict and therefore\n- # doesn't function as a descriptor, isn't a method, doesn't get bound,\n- # and therefore doesn't receive a self parameter\n- setattr(method.__self__, method.__func__.__name__, lambda *args: self.queue.append((method, args)))\n-\n- def run(self):\n- logger.debug('ExecutionQueue: Running %d queued method calls', len(self.queue))\n- for method, args in self.queue:\n- method(*args)\n-\n- for method in self.methods:\n- delattr(method.__self__, method.__func__.__name__)\n-\n-\n-class Endpoint:\n- router: 'Router'\n- __endpoint_frozen_queue: Optional[ExecutionQueue] = None\n-\n- def __init__(self, router: 'Router'):\n- router.add_endpoint(self)\n- self.router = router\n-\n- def freeze_endpoint(self):\n- assert self.__endpoint_frozen_queue is None\n- logger.debug('Freezing endpoint %s', self)\n- self.__endpoint_frozen_queue = ExecutionQueue({self.do_channel_control, self.do_channel_data, self.do_kill})\n-\n- def thaw_endpoint(self):\n- assert self.__endpoint_frozen_queue is not None\n- logger.debug('Thawing endpoint %s', self)\n- self.__endpoint_frozen_queue.run()\n- self.__endpoint_frozen_queue = None\n-\n- # interface for receiving messages\n- def do_close(self):\n- raise NotImplementedError\n-\n- def do_channel_control(self, channel: str, command: str, message: JsonObject) -> None:\n- raise NotImplementedError\n-\n- def do_channel_data(self, channel: str, data: bytes) -> None:\n- raise NotImplementedError\n-\n- def do_kill(self, host: 'str | None', group: 'str | None', message: JsonObject) -> None:\n- raise NotImplementedError\n-\n- # interface for sending messages\n- def send_channel_data(self, channel: str, data: bytes) -> None:\n- self.router.write_channel_data(channel, data)\n-\n- def send_channel_control(\n- self, channel: str, command: str, _msg: 'JsonObject | None', **kwargs: JsonValue\n- ) -> None:\n- self.router.write_control(_msg, channel=channel, command=command, **kwargs)\n- if command == 'close':\n- self.router.endpoints[self].remove(channel)\n- self.router.drop_channel(channel)\n-\n- def shutdown_endpoint(self, _msg: 'JsonObject | None' = None, **kwargs: JsonValue) -> None:\n- self.router.shutdown_endpoint(self, _msg, **kwargs)\n-\n-\n-class RoutingError(CockpitProblem):\n- pass\n-\n-\n-class RoutingRule:\n- router: 'Router'\n-\n- def __init__(self, router: 'Router'):\n- self.router = router\n-\n- def apply_rule(self, options: JsonObject) -> Optional[Endpoint]:\n- \"\"\"Check if a routing rule applies to a given 'open' message.\n-\n- This should inspect the options dictionary and do one of the following three things:\n-\n- - return an Endpoint to handle this channel\n- - raise a RoutingError to indicate that the open should be rejected\n- - return None to let the next rule run\n- \"\"\"\n- raise NotImplementedError\n-\n- def shutdown(self):\n- raise NotImplementedError\n-\n-\n-class Router(CockpitProtocolServer):\n- routing_rules: List[RoutingRule]\n- open_channels: Dict[str, Endpoint]\n- endpoints: 'dict[Endpoint, set[str]]'\n- no_endpoints: asyncio.Event # set if endpoints dict is empty\n- _eof: bool = False\n-\n- def __init__(self, routing_rules: List[RoutingRule]):\n- for rule in routing_rules:\n- rule.router = self\n- self.routing_rules = routing_rules\n- self.open_channels = {}\n- self.endpoints = {}\n- self.no_endpoints = asyncio.Event()\n- self.no_endpoints.set() # at first there are no endpoints\n-\n- def check_rules(self, options: JsonObject) -> Endpoint:\n- for rule in self.routing_rules:\n- logger.debug(' applying rule %s', rule)\n- endpoint = rule.apply_rule(options)\n- if endpoint is not None:\n- logger.debug(' resulting endpoint is %s', endpoint)\n- return endpoint\n- else:\n- logger.debug(' No rules matched')\n- raise RoutingError('not-supported')\n-\n- def drop_channel(self, channel: str) -> None:\n- try:\n- self.open_channels.pop(channel)\n- logger.debug('router dropped channel %s', channel)\n- except KeyError:\n- logger.error('trying to drop non-existent channel %s from %s', channel, self.open_channels)\n-\n- def add_endpoint(self, endpoint: Endpoint) -> None:\n- self.endpoints[endpoint] = set()\n- self.no_endpoints.clear()\n-\n- def shutdown_endpoint(self, endpoint: Endpoint, _msg: 'JsonObject | None' = None, **kwargs: JsonValue) -> None:\n- channels = self.endpoints.pop(endpoint)\n- logger.debug('shutdown_endpoint(%s, %s) will close %s', endpoint, kwargs, channels)\n- for channel in channels:\n- self.write_control(_msg, command='close', channel=channel, **kwargs)\n- self.drop_channel(channel)\n-\n- if not self.endpoints:\n- self.no_endpoints.set()\n-\n- # were we waiting to exit?\n- if self._eof:\n- logger.debug(' endpoints remaining: %r', self.endpoints)\n- if not self.endpoints and self.transport:\n- logger.debug(' close transport')\n- self.transport.close()\n-\n- def do_kill(self, host: 'str | None', group: 'str | None', message: JsonObject) -> None:\n- endpoints = set(self.endpoints)\n- logger.debug('do_kill(%s, %s). Considering %d endpoints.', host, group, len(endpoints))\n- for endpoint in endpoints:\n- endpoint.do_kill(host, group, message)\n-\n- def channel_control_received(self, channel: str, command: str, message: JsonObject) -> None:\n- # If this is an open message then we need to apply the routing rules to\n- # figure out the correct endpoint to connect. If it's not an open\n- # message, then we expect the endpoint to already exist.\n- if command == 'open':\n- if channel in self.open_channels:\n- raise CockpitProtocolError('channel is already open')\n-\n- try:\n- logger.debug('Trying to find endpoint for new channel %s payload=%s', channel, message.get('payload'))\n- endpoint = self.check_rules(message)\n- except RoutingError as exc:\n- self.write_control(exc.attrs, command='close', channel=channel)\n- return\n-\n- self.open_channels[channel] = endpoint\n- self.endpoints[endpoint].add(channel)\n- else:\n- try:\n- endpoint = self.open_channels[channel]\n- except KeyError:\n- # sending to a non-existent channel can happen due to races and is not an error\n- return\n-\n- # At this point, we have the endpoint. Route the message.\n- endpoint.do_channel_control(channel, command, message)\n-\n- def channel_data_received(self, channel: str, data: bytes) -> None:\n- try:\n- endpoint = self.open_channels[channel]\n- except KeyError:\n- return\n-\n- endpoint.do_channel_data(channel, data)\n-\n- def eof_received(self) -> bool:\n- logger.debug('eof_received(%r)', self)\n-\n- endpoints = set(self.endpoints)\n- for endpoint in endpoints:\n- endpoint.do_close()\n-\n- self._eof = True\n- logger.debug(' endpoints remaining: %r', self.endpoints)\n- return bool(self.endpoints)\n-\n- _communication_done: Optional[asyncio.Future] = None\n-\n- def do_closed(self, exc: Optional[Exception]) -> None:\n- # If we didn't send EOF yet, do it now.\n- if not self._eof:\n- self.eof_received()\n-\n- if self._communication_done is not None:\n- if exc is None:\n- self._communication_done.set_result(None)\n- else:\n- self._communication_done.set_exception(exc)\n-\n- async def communicate(self) -> None:\n- \"\"\"Wait until communication is complete on the router and all endpoints are done.\"\"\"\n- assert self._communication_done is None\n- self._communication_done = asyncio.get_running_loop().create_future()\n- try:\n- await self._communication_done\n- except (BrokenPipeError, ConnectionResetError):\n- pass # these are normal occurrences when closed from the other side\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/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 .\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/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 .\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/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 .\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/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@@ -4074,15 +2801,15 @@\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/remote.py': r'''# This file is part of Cockpit.\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@@ -4091,231 +2818,155 @@\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 .\n \n-import getpass\n+import asyncio\n+import glob\n+import grp\n+import json\n import logging\n-import re\n-import socket\n-from typing import Dict, List, Optional, Tuple\n+import os\n+import pwd\n+from pathlib import Path\n+from typing import Dict, Optional\n \n-from cockpit._vendor import ferny\n+from cockpit._vendor.systemd_ctypes import Variant, bus, inotify, pathwatch\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+from . import config\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+class cockpit_LoginMessages(bus.Object):\n+ messages: Optional[str] = None\n \n- if self.password is not None:\n- options.update(NumberOfPasswordPrompts='1')\n- else:\n- options.update(PasswordAuthentication=\"no\", KbdInteractiveAuthentication=\"no\")\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- 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+ 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- 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+ @bus.Interface.Method(out_types=['s'])\n+ def get(self):\n+ return self.messages or '{}'\n \n- args = self.session.wrap_subprocess_args(['cockpit-bridge'])\n- await self.spawn(args, [])\n+ @bus.Interface.Method(out_types=[])\n+ def dismiss(self):\n+ self.messages = None\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+class cockpit_Machines(bus.Object):\n+ path: Path\n+ watch: pathwatch.PathWatch\n+ pending_notify: Optional[asyncio.Handle]\n \n- def do_superuser_init_done(self) -> None:\n- self.password = None\n+ # D-Bus implementation\n+ machines = bus.Interface.Property('a{sa{sv}}')\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+ @machines.getter\n+ def get_machines(self) -> Dict[str, Dict[str, Variant]]:\n+ results: Dict[str, Dict[str, Variant]] = {}\n \n- self.session = ferny.Session()\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- 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+ return results\n \n- self.start_in_background(init_host=host, superuser=superuser)\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-class HostRoutingRule(RoutingRule):\n- remotes: Dict[Tuple[str, Optional[str], Optional[str]], Peer]\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 __init__(self, router):\n- super().__init__(router)\n- self.remotes = {}\n+ def notify(self):\n+ def _notify_now():\n+ self.properties_changed('cockpit.Machines', {}, ['Machines'])\n+ self.pending_notify = None\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+ # 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- host = get_str(options, 'host', self.router.init_host)\n- if host == self.router.init_host:\n- return None\n+ # inotify events\n+ def do_inotify_event(self, mask: inotify.Event, cookie: int, name: Optional[str]) -> None:\n+ self.notify()\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+ def do_identity_changed(self, fd: Optional[int], errno: Optional[int]) -> None:\n+ self.notify()\n \n- if get_str(options, 'session', None) == 'private':\n- nonce = get_str(options, 'channel')\n- else:\n- nonce = None\n+ def __init__(self):\n+ self.path = config.lookup_config('machines.d')\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+ # ignore the first callback\n+ self.pending_notify = ...\n+ self.watch = pathwatch.PathWatch(str(self.path), self)\n+ self.pending_notify = None\n \n- key = host, user, nonce\n \n- logger.debug('Request for channel %s is remote.', options)\n- logger.debug('key=%s', key)\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- 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+ 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- 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+EXPORTS = [\n+ ('/LoginMessages', cockpit_LoginMessages),\n+ ('/machines', cockpit_Machines),\n+ ('/user', cockpit_User),\n+]\n+''',\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@@ -4889,1981 +3540,2843 @@\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/_vendor/__init__.py': br'''''',\n- 'cockpit/_vendor/bei/beiboot.py': br\"\"\"# beiboot - Remote bootloader for Python\n+ 'cockpit/channel.py': br'''# This file is part of Cockpit.\n #\n-# Copyright (C) 2022 Allison Karlitskaya \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 .\n+# along with this program. If not, see .\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+import json\n+import logging\n+from typing import BinaryIO, ClassVar, Dict, Generator, List, Optional, Sequence, Set, Tuple, Type\n \n-from .bootloader import make_bootloader\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-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+class ChannelRoutingRule(RoutingRule):\n+ table: Dict[str, List[Type['Channel']]]\n \n- if sh:\n- command = (' '.join(shlex.quote(arg) for arg in command),)\n+ def __init__(self, router: Router, channel_types: List[Type['Channel']]):\n+ super().__init__(router)\n+ self.table = {}\n \n- return command\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 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+ 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-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+ # 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 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+ 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-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+ 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- threading.Thread(target=_thread, daemon=True).start()\n+ def shutdown(self):\n+ pass # we don't hold any state\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+class ChannelError(CockpitProblem):\n+ pass\n \n- splice_in_thread(0, proc.stdin)\n- sys.exit(proc.wait())\n \n+class Channel(Endpoint):\n+ # Values borrowed from C implementation\n+ BLOCK_SIZE = 16 * 1024\n+ SEND_WINDOW = 2 * 1024 * 1024\n \n-def send_xz_and_splice(command: Sequence[str], script: bytes) -> None:\n- import ferny\n+ # Flow control book-keeping\n+ _send_pings: bool = False\n+ _out_sequence: int = 0\n+ _out_window: int = SEND_WINDOW\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+ # Task management\n+ _tasks: Set[asyncio.Task]\n+ _close_args: Optional[JsonObject] = None\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+ # Must be filled in by the channel implementation\n+ payload: ClassVar[str]\n+ restrictions: ClassVar[Sequence[Tuple[str, object]]] = ()\n \n- asyncio.run(agent.communicate())\n- splice_in_thread(0, proc.stdin)\n- sys.exit(proc.wait())\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 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+ 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- args = parser.parse_args()\n- tty = not args.script and os.isatty(0)\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- 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+ 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 args.script:\n- with open(args.script, 'rb') as file:\n- script = file.read()\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- send_and_splice(command, script)\n+ # At least this one really ought to be implemented...\n+ def do_open(self, options: JsonObject) -> None:\n+ raise NotImplementedError\n \n- elif args.xz:\n- with open(args.xz, 'rb') as file:\n- script = file.read()\n+ # ... but many subclasses may reasonably want to ignore some of these.\n+ def do_ready(self) -> None:\n+ pass\n \n- send_xz_and_splice(command, script)\n+ def do_done(self) -> None:\n+ pass\n \n- else:\n- # If we're streaming from stdin then this is a lot easier...\n- os.execlp(command[0], *command)\n+ def do_close(self) -> None:\n+ self.close()\n \n- # Otherwise, \"full strength\"\n+ def do_options(self, message: JsonObject) -> None:\n+ raise ChannelError('not-supported', message='This channel does not implement \"options\"')\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 \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 .\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-import textwrap\n-from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple\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-GADGETS = {\n- \"_frame\": r\"\"\"\n- import sys\n- import traceback\n+ # Catch errors and turn them into close messages\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+ 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-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+ # 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-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+ # tasks and close management\n+ def is_closing(self) -> bool:\n+ return self._close_args is not None\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 _close_now(self) -> None:\n+ self.shutdown_endpoint(self._close_args)\n \n- # Yield functions mentioned in steps from the caller\n- for name, args in steps:\n- yield '', name + repr(tuple(args))\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-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 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- 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+ def close(self, close_args: 'JsonObject | None' = None) -> None:\n+ \"\"\"Requests the channel to be closed.\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/tmpfs.py': br'''import os\n-import subprocess\n-import sys\n-import tempfile\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 main(*command: str) -> None:\n- with tempfile.TemporaryDirectory() as tmpdir:\n- os.chdir(tmpdir)\n+ def send_data(self, data: bytes) -> bool:\n+ \"\"\"Send data and handle book-keeping for flow control.\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+ 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- os.chdir('tmpfs')\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- result = subprocess.run(command, check=False)\n- sys.exit(result.returncode)\n-''',\n- 'cockpit/_vendor/bei/beipack.py': br'''# beipack - Remote bootloader for Python\n-#\n-# Copyright (C) 2022 Allison Karlitskaya \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 .\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-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+ return self._out_sequence < self._out_window\n \n-from .data import read_data_file\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 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+ 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 ascii_bytes_repr(data: bytes) -> str:\n- return 'b' + escape_string(data.decode('ascii'))\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 utf8_bytes_repr(data: bytes) -> str:\n- return escape_string(data.decode('utf-8')) + \".encode('utf-8')\"\n+ def send_pong(self, message: JsonObject) -> None:\n+ self.send_channel_control(self.channel, 'pong', message)\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+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-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+ 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- try:\n- return ascii_bytes_repr(data)\n- except UnicodeDecodeError:\n- # it's not ascii\n- pass\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- # utf-8\n- try:\n- return utf8_bytes_repr(data)\n- except UnicodeDecodeError:\n- # it's not utf-8\n- pass\n+ # read-side EOF handling\n+ _close_on_eof: bool = False\n+ _eof: bool = False\n \n- return base64_bytes_repr(data, imports)\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-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+ 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 pack(contents: Dict[str, bytes],\n- entrypoint: Optional[str] = None,\n- args: str = '') -> str:\n- \"\"\"Creates a beipack with the given `contents`.\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- 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+ self.connection_made(transport)\n+ self.ready()\n \n- from package.module import func as main\n- main()\n+ def connection_made(self, transport: asyncio.BaseTransport) -> None:\n+ assert isinstance(transport, asyncio.Transport)\n+ self._transport = transport\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+ def _get_close_args(self) -> JsonObject:\n+ return {}\n \n- loader = read_data_file('beipack_loader.py')\n- lines = [line for line in loader.splitlines() if line]\n- lines.append('')\n+ def connection_lost(self, exc: Optional[Exception]) -> None:\n+ self.close(self._get_close_args())\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+ def do_data(self, data: bytes) -> None:\n+ assert self._transport is not None\n+ self._transport.write(data)\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+ 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- return ''.join(f'{line}\\n' for line in lines)\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 collect_contents(filenames: List[str],\n- relative_to: Optional[str] = None) -> Dict[str, bytes]:\n- contents: Dict[str, bytes] = {}\n+ def do_resume_send(self) -> None:\n+ assert self._transport is not None\n+ self._transport.resume_reading()\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+ def close_on_eof(self) -> None:\n+ \"\"\"Mark the channel to be closed on EOF.\n \n- return contents\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-def collect_module(name: str, *, recursive: bool) -> Dict[str, bytes]:\n- import importlib.resources\n- from importlib.resources.abc import Traversable\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 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+ def eof_received(self) -> bool:\n+ self._eof = True\n+ self.done()\n+ return not self._close_on_eof\n \n- return dict(walk(name.replace('.', '/'), importlib.resources.files(name)))\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 collect_zip(filename: str) -> Dict[str, bytes]:\n- contents = {}\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- 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+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-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+ 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-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+ On the sending side, write() will block if the channel backs up.\n+ \"\"\"\n \n- contents = collect_contents(args.files, relative_to=args.topdir)\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- for file in args.zip:\n- contents.update(collect_zip(file))\n+ # Send-side flow control\n+ write_waiter = None\n \n- for name in args.module:\n- contents.update(collect_module(name, recursive=True))\n+ async def run(self, options):\n+ raise NotImplementedError\n \n- for path in args.build:\n- contents.update(collect_pep517(path))\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- result = pack(contents, args.main, args.main_args).encode('utf-8')\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- if args.python:\n- result = b'#!' + args.python.encode('ascii') + b'\\n' + result\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- if args.xz:\n- result = lzma.compress(result, preset=lzma.PRESET_EXTREME)\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- 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+ 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-if __name__ == '__main__':\n- main()\n-''',\n- 'cockpit/_vendor/bei/spawn.py': br'''\"\"\"Helper to create a beipack to spawn a command with files in a tmpdir\"\"\"\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-import argparse\n-import os\n-import sys\n+ def do_done(self):\n+ self.receive_queue.put_nowait(b'')\n \n-from . import pack, tmpfs\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 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+ 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- contents = {\n- '_beitmpfs.py': tmpfs.__spec__.loader.get_data(tmpfs.__spec__.origin)\n- }\n+ self.receive_queue.put_nowait(data)\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+class GeneratorChannel(Channel):\n+ \"\"\"A trivial Channel subclass for sending data from a generator with flow control.\n \n- script = pack.pack(contents, '_beitmpfs:main', '*' + repr(args.command))\n- sys.stdout.write(script)\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-if __name__ == '__main__':\n- main()\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/_vendor/bei/data/__init__.py': br'''import sys\n+ 'cockpit/__init__.py': br'''from ._version import __version__ # noqa: F401\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 .\n \n-if sys.version_info >= (3, 9):\n- import importlib.abc\n- import importlib.resources\n+import asyncio\n+import json\n+import logging\n+import uuid\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/bei/data/beipack_loader.py': br'''# beipack https://github.com/allisonkarlitskaya/beipack\n+from .jsonutil import JsonError, JsonObject, JsonValue, create_object, get_int, get_str, typechecked\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+logger = logging.getLogger(__name__)\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+class CockpitProblem(Exception):\n+ \"\"\"A type of exception that carries a problem code and a message.\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+ Depending on the scope, this is used to handle shutting down:\n \n- def is_resource(self, resource: str) -> bool:\n- return f'{self._dir}{resource}' in self._contents\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- def open_resource(self, resource: str) -> BinaryIO:\n- return io.BytesIO(self._contents[f'{self._dir}{resource}'])\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 resource_path(self, resource: str) -> str:\n- raise FileNotFoundError\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- 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+class CockpitProtocolError(CockpitProblem):\n+ def __init__(self, message: str, problem: str = 'protocol-error'):\n+ super().__init__(problem, message=message)\n \n- return iter(result)\n \n- contents: Dict[str, bytes]\n- modules: Dict[str, str]\n+class CockpitProtocol(asyncio.Protocol):\n+ \"\"\"A naive implementation of the Cockpit frame protocol\n \n- def __init__(self, contents: Dict[str, bytes]) -> None:\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- contents[__file__] = __self_source__ # type: ignore[name-defined]\n- except NameError:\n- pass\n+ message = typechecked(json.loads(data), dict)\n+ command = get_str(message, 'command')\n+ channel = get_str(message, 'channel', None)\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+ 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 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+ except (json.JSONDecodeError, JsonError) as exc:\n+ raise CockpitProtocolError(f'control message: {exc!s}') from exc\n \n- def get_resource_reader(self, fullname: str) -> ResourceReader:\n- return BeipackLoader.ResourceReader(self.contents, fullname.replace('.', '/'))\n+ def consume_one_frame(self, data: bytes) -> int:\n+ \"\"\"Consumes a single frame from view.\n \n- def get_data(self, path: str) -> bytes:\n- return self.contents[path]\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- def get_filename(self, fullname: str) -> str:\n- return self.modules[fullname]\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- 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+ 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/_vendor/systemd_ctypes/librarywrapper.py': br'''# systemd_ctypes\n+ 'cockpit/superuser.py': br'''# This file is part of Cockpit.\n #\n-# Copyright (C) 2022 Allison Karlitskaya \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 .\n+# along with this program. If not, see .\n \n-import ctypes\n-import inspect\n+import array\n+import asyncio\n+import contextlib\n+import getpass\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+import socket\n+from tempfile import TemporaryDirectory\n+from typing import List, Optional, Sequence, Tuple\n \n-from . import typing\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-# First in 3.10, and conditional import gives type errors\n-NoneType = type(None)\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-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+class SuperuserPeer(ConfiguredPeer):\n+ responder: ferny.AskpassHandler\n \n-if typing.TYPE_CHECKING:\n- class Reference(Generic[CType], ctypes._Pointer[CType]):\n- pass\n+ def __init__(self, router: Router, config: BridgeConfig, responder: ferny.AskpassHandler):\n+ super().__init__(router, config)\n+ self.responder = responder\n \n- def byref(x: CType) -> Reference[CType]:\n- raise NotImplementedError\n-else:\n- class Reference(Generic[CType]):\n- pass\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- byref = ctypes.byref\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-UserData = Optional[ctypes.c_void_p]\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-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+ 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-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+ try:\n+ await agent.communicate()\n+ except ferny.InteractionError as exc:\n+ raise PeerError('authentication-failed', message=str(exc)) from exc\n \n- @classmethod\n- def from_param(cls, value: str) -> 'utf8':\n- return cls(value.encode())\n \n+class CockpitResponder(ferny.AskpassHandler):\n+ commands = ('ferny.askpass', 'cockpit.send-stderr')\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+ 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- @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+class AuthorizeResponder(CockpitResponder):\n+ def __init__(self, router: Router):\n+ self.router = router\n \n-class boolint(ctypes.c_int):\n- def errcheck(self, func: Callable[..., object], _args: Tuple[object, ...]) -> bool:\n- return bool(self.value)\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-WeakReference = NewType(\"WeakReference\", int)\n-Errno = typing.Annotated[NoReturn, \"errno\"]\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-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+ # 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-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+ 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- if isinstance(annotation, typing.ForwardRef):\n- annotation = annotation.__forward_arg__\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- if isinstance(annotation, str):\n- annotation = global_vars[annotation]\n+ def __init__(self, router: Router, *, privileged: bool = False):\n+ super().__init__(router)\n \n- origin = typing.get_origin(annotation)\n- args = typing.get_args(annotation)\n+ self.pending_prompt = None\n+ self.peer = None\n+ self.startup = None\n \n- if origin is Reference:\n- return ctypes.POINTER(map_type(args[0], global_vars))\n+ if privileged or os.getuid() == 0:\n+ self.current = 'root'\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+ def peer_done(self):\n+ self.current = 'none'\n+ self.peer = None\n \n- elif origin is typing.Annotated:\n- return args[1]\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- else:\n- assert origin is None, origin\n- return annotation\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-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+ self.current = 'init'\n+ self.peer = SuperuserPeer(self.router, config, responder)\n+ self.peer.add_done_callback(self.peer_done)\n \n- cls._wrap(cdll, cls._ref)\n- cls._wrap(cdll, cls._unref)\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- @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.current = self.peer.config.name\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 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(' create wrapper %s.%s%s', cls.__name__, name, signature)\n- logger.debug(' args %s res %s', func.argtypes, func.restype)\n+ logger.debug(\" bridges are now %s\", self.bridges)\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+ # 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 _unref(self: 'ReferenceType') -> None:\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 _ref(self: 'ReferenceType') -> None:\n- ...\n+ def shutdown(self):\n+ self.cancel_prompt()\n \n- T = TypeVar(\"T\", bound='ReferenceType')\n+ if self.peer is not None:\n+ self.peer.close()\n \n- @classmethod\n- def ref(cls: Type[T], origin: WeakReference) -> T:\n- self = cls(origin)\n- self._ref()\n- return self\n+ # close() should have disconnected the peer immediately\n+ assert self.peer is None\n \n- def __del__(self) -> None:\n- if self.value is not None:\n- self._unref()\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/_vendor/systemd_ctypes/event.py': br'''# systemd_ctypes\n+ 'cockpit/config.py': br'''# This file is part of Cockpit.\n #\n-# Copyright (C) 2022 Allison Karlitskaya \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 .\n+# along with this program. If not, see .\n \n-import asyncio\n-import selectors\n-import sys\n-from typing import Callable, ClassVar, Coroutine, List, Optional, Tuple\n+import configparser\n+import logging\n+import os\n+from pathlib import Path\n \n-from . import inotify, libsystemd\n-from .librarywrapper import Reference, UserData, byref\n+from cockpit._vendor.systemd_ctypes import bus\n \n+logger = logging.getLogger(__name__)\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+XDG_CONFIG_HOME = Path(os.getenv('XDG_CONFIG_HOME') or os.path.expanduser('~/.config'))\n+DOT_CONFIG_COCKPIT = XDG_CONFIG_HOME / 'cockpit'\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+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- InotifyHandler = Callable[[inotify.Event, int, Optional[bytes]], None]\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- 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+class Config(bus.Object, interface='cockpit.Config'):\n+ def __init__(self):\n+ self.reload()\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+ @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-# 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+ 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/remote.py': r'''# This file is part of Cockpit.\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+# 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 .\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+import getpass\n+import logging\n+import re\n+import socket\n+from typing import Dict, List, Optional, Tuple\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+from cockpit._vendor import ferny\n \n- # We can be sure we're not dispatching callbacks anymore\n- libsystemd.Trampoline.deferred = None\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- # 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+logger = logging.getLogger(__name__)\n \n \n-class EventLoopPolicy(asyncio.DefaultEventLoopPolicy):\n- def new_event_loop(self) -> asyncio.AbstractEventLoop:\n- return asyncio.SelectorEventLoop(Selector())\n+class PasswordResponder(ferny.AskpassHandler):\n+ PASSPHRASE_RE = re.compile(r\"Enter passphrase for key '(.*)': \")\n \n+ password: Optional[str]\n \n-def run_async(main: Coroutine[None, None, None], debug: Optional[bool] = None) -> None:\n- asyncio.set_event_loop_policy(EventLoopPolicy())\n+ hostkeys_seen: List[Tuple[str, str, str, str, str]]\n+ error_message: Optional[str]\n+ password_attempts: int\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+ def __init__(self, password: Optional[str]):\n+ self.password = password\n \n- assert not hasattr(asyncio, 'get_running_loop')\n- asyncio.get_running_loop = lambda: loop\n+ self.hostkeys_seen = []\n+ self.error_message = None\n+ self.password_attempts = 0\n \n- assert not hasattr(asyncio, 'create_task')\n- asyncio.create_task = loop.create_task\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- assert not hasattr(asyncio, 'run')\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- 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+ 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- asyncio.run = run # type: ignore[assignment]\n+ assert self.password is not None\n+ assert self.password_attempts == 0\n+ self.password_attempts += 1\n+ return self.password\n \n- asyncio._systemd_ctypes_polyfills = True # type: ignore[attr-defined]\n \n- asyncio.run(main, debug=debug)\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- if polyfill:\n- del asyncio.create_task, asyncio.get_running_loop, asyncio.run\n-''',\n- 'cockpit/_vendor/systemd_ctypes/bustypes.py': br'''# systemd_ctypes\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/_vendor/__init__.py': br'''''',\n+ 'cockpit/_vendor/ferny/session.py': r'''# ferny - asyncio SSH client library, using ssh(1)\n #\n-# Copyright (C) 2023 Allison Karlitskaya \n+# Copyright (C) 2022 Allison Karlitskaya \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 .\n \n-\n-# This file is responsible for creating functions to (de)serialize Python\n-# objects into and out of BusMessage objects.\n-#\n-# Each Type corresponds to a (possibly complex) D-Bus type. It has a .reader\n-# and a .writer property. The readers take a message and deserialize a single\n-# value from it, returning the value:\n-#\n-# def reader(message: BusMessage) -> object:\n-#\n-# The writers take a message and a value, and append the value to the message.\n-#\n-# def writer(message: BusMessage, value: object) -> None:\n-#\n-# The necessary information for the specific type of object to be handled is\n-# part of the function. No additional information needs to be provided.\n-\n-import binascii\n+import asyncio\n import ctypes\n import functools\n-import inspect\n-import json\n-import re\n-from enum import Enum\n-from typing import Any, Callable, ClassVar, Dict, Iterable, List, Optional, Sequence, Tuple, TypeVar, Union\n-\n-from . import libsystemd, typing\n-from .typing import Annotated, TypeGuard\n-\n-_object_path_re = re.compile(r'/|(/[A-Za-z0-9_]+)+')\n-\n-\n-def is_object_path(candidate: str) -> TypeGuard['BusType.objectpath']:\n- return _object_path_re.fullmatch(candidate) is not None\n-\n-\n-def is_signature(candidate: str) -> TypeGuard['BusType.signature']:\n- offset = 0\n+import logging\n+import os\n+import shlex\n+import signal\n+import subprocess\n+import tempfile\n+from typing import Mapping, Sequence\n \n- def maybe_pop(acceptable: str) -> Optional[str]:\n- nonlocal offset\n- char = candidate[offset]\n- if char in acceptable:\n- offset += 1\n- return char\n- else:\n- return None\n+from . import ssh_errors\n+from .interaction_agent import InteractionAgent, InteractionError, InteractionHandler, write_askpass_to_tmpdir\n \n- def pop(acceptable: str) -> str:\n- char = maybe_pop(acceptable)\n- assert char is not None\n- return char\n+prctl = ctypes.cdll.LoadLibrary('libc.so.6').prctl\n+logger = logging.getLogger(__name__)\n+PR_SET_PDEATHSIG = 1\n \n- def find_next() -> None:\n- first = pop('ybnqiuxtsogdva(') # valid first characters\n- if first == 'a':\n- if maybe_pop('{'): # dict\n- pop('ybnqiuxtsogd') # key\n- find_next() # value\n- pop('}')\n- else: # array\n- find_next() # item\n- elif first == '(': # structure\n- find_next() # at least one item\n- while not maybe_pop(')'):\n- find_next() # and possibly more\n \n+@functools.lru_cache()\n+def has_feature(feature: str, teststr: str = 'x') -> bool:\n try:\n- while offset < len(candidate):\n- find_next()\n+ subprocess.check_output(['ssh', f'-o{feature} {teststr}', '-G', 'nonexisting'], stderr=subprocess.DEVNULL)\n return True\n- except (AssertionError, IndexError):\n+ except subprocess.CalledProcessError:\n return False\n \n \n-def yield_base_helpers() -> Iterable[Tuple[str, object]]:\n- for method in ['enter_container', 'exit_container', 'open_container', 'close_container',\n- 'append_basic', 'read_basic', 'append_array', 'read_array']:\n- yield method, libsystemd.libsystemd[f'sd_bus_message_{method}']\n+class SubprocessContext:\n+ def wrap_subprocess_args(self, args: Sequence[str]) -> Sequence[str]:\n+ \"\"\"Return the args required to launch a process in the given context.\n \n- for name in ['size_t', 'char_p']:\n- instance = getattr(ctypes, f'c_{name}')()\n- yield f'{name}', instance\n- yield f'{name}_ref', ctypes.byref(instance)\n- yield f'{name}_setter', instance.__class__.value.__set__\n+ For example, this might return a vector with\n+ [\"sudo\"]\n+ or\n+ [\"flatpak-spawn\", \"--host\"]\n+ prepended.\n \n- for char in 'aervy':\n- yield char, ctypes.c_char(ord(char))\n+ It is also possible that more substantial changes may be performed.\n \n- # https://docs.python.org/3/c-api/unicode.html#c.PyUnicode_FromString\n- to_bytes = ctypes.pythonapi.PyBytes_FromStringAndSize\n- to_bytes.restype = ctypes.py_object\n- yield 'to_bytes', to_bytes\n+ This function is not permitted to modify its argument, although it may\n+ (optionally) return it unmodified, if no changes are required.\n+ \"\"\"\n+ return args\n \n+ def wrap_subprocess_env(self, env: Mapping[str, str]) -> Mapping[str, str]:\n+ \"\"\"Return the envp required to launch a process in the given context.\n \n-_base_helpers = dict(yield_base_helpers())\n+ For example, this might set the \"SUDO_ASKPASS\" environment variable, if\n+ needed.\n \n-T = TypeVar('T')\n+ As with wrap_subprocess_args(), this function is not permitted to\n+ modify its argument, although it may (optionally) return it unmodified\n+ if no changes are required.\n+ \"\"\"\n+ return env\n \n \n-def call_with_kwargs(func: Callable[..., T], kwargs: Dict[str, Any]) -> T:\n- parameters = set(inspect.signature(func).parameters)\n- return func(**{key: value for key, value in kwargs.items() if key in parameters})\n+class Session(SubprocessContext, InteractionHandler):\n+ # Set after .connect() called, even if failed\n+ _controldir: 'tempfile.TemporaryDirectory | None' = None\n+ _controlsock: 'str | None' = None\n \n+ # Set if connected, else None\n+ _process: 'asyncio.subprocess.Process | None' = None\n \n-class Type:\n- _cache: ClassVar[Dict[Tuple[type, Tuple[object, ...]], 'Type']] = {}\n+ async def connect(self,\n+ destination: str,\n+ handle_host_key: bool = False,\n+ configfile: 'str | None' = None,\n+ identity_file: 'str | None' = None,\n+ login_name: 'str | None' = None,\n+ options: 'Mapping[str, str] | None' = None,\n+ pkcs11: 'str | None' = None,\n+ port: 'int | None' = None,\n+ interaction_responder: 'InteractionHandler | None' = None) -> None:\n+ rundir = os.path.join(os.environ.get('XDG_RUNTIME_DIR', '/run'), 'ferny')\n+ os.makedirs(rundir, exist_ok=True)\n+ self._controldir = tempfile.TemporaryDirectory(dir=rundir)\n+ self._controlsock = f'{self._controldir.name}/socket'\n \n- __slots__ = 'typestring', 'bytes_typestring', 'writer', 'reader'\n- typestring: str\n- bytes_typestring: bytes\n- reader: Callable[[libsystemd.sd_bus_message], object]\n- writer: Callable[[libsystemd.sd_bus_message, object], None]\n+ # In general, we can't guarantee an accessible and executable version\n+ # of this file, but since it's small and we're making a temporary\n+ # directory anyway, let's just copy it into place and use it from\n+ # there.\n+ askpass_path = write_askpass_to_tmpdir(self._controldir.name)\n \n- def __new__(cls, *args: Any) -> 'Type':\n- instance = Type._cache.get((cls, args))\n- if instance is None:\n- instance = object.__new__(cls)\n- Type._cache[(cls, args)] = instance\n- return instance\n+ env = dict(os.environ)\n+ env['SSH_ASKPASS'] = askpass_path\n+ env['SSH_ASKPASS_REQUIRE'] = 'force'\n+ # old SSH doesn't understand SSH_ASKPASS_REQUIRE and guesses based on DISPLAY instead\n+ env['DISPLAY'] = '-'\n \n- def __init__(self, typestring: str, **kwargs: Any):\n- self.typestring = typestring\n- self.bytes_typestring = typestring.encode('ascii')\n+ args = [\n+ '-M',\n+ '-N',\n+ '-S', self._controlsock,\n+ '-o', 'PermitLocalCommand=yes',\n+ '-o', f'LocalCommand={askpass_path}',\n+ ]\n \n- kwargs = dict(_base_helpers, **kwargs)\n- self.writer = call_with_kwargs(self.get_writer, kwargs)\n- self.reader = call_with_kwargs(self.get_reader, kwargs)\n+ if configfile is not None:\n+ args.append(f'-F{configfile}')\n \n- def __repr__(self) -> str:\n- return f\"{self.__class__.__name__}('{self.typestring}')\"\n+ if identity_file is not None:\n+ args.append(f'-i{identity_file}')\n \n- def get_writer(self, **kwargs: object) -> Callable[[object, object], None]:\n- raise NotImplementedError\n+ if options is not None:\n+ for key in options: # Note: Mapping may not have .items()\n+ args.append(f'-o{key} {options[key]}')\n \n- def get_reader(self, **kwargs: object) -> Callable[[object], object]:\n- raise NotImplementedError\n+ if pkcs11 is not None:\n+ args.append(f'-I{pkcs11}')\n \n+ if port is not None:\n+ args.append(f'-p{port}')\n \n-class BasicType(Type):\n- __slots__ = ()\n+ if login_name is not None:\n+ args.append(f'-l{login_name}')\n \n- def __init__(self, typestring: str, ctype, get_wrapper=None, **kwargs):\n- variable = ctype() # NB: not thread-safe\n- super().__init__(typestring, ctype=ctype, type_constant=ctypes.c_char(ord(typestring)),\n- getter=get_wrapper or ctype.value.__get__, setter=ctype.value.__set__,\n- variable=variable, reference=ctypes.byref(variable), **kwargs)\n+ if handle_host_key and has_feature('KnownHostsCommand'):\n+ args.extend([\n+ '-o', f'KnownHostsCommand={askpass_path} %I %H %t %K %f',\n+ '-o', 'StrictHostKeyChecking=yes',\n+ ])\n \n- def get_reader(self, read_basic, type_constant, variable, reference, getter):\n- def basic_reader(message: libsystemd.sd_bus_message) -> object:\n- if read_basic(message, type_constant, reference) <= 0:\n- raise StopIteration\n- return getter(variable)\n- return basic_reader\n+ agent = InteractionAgent([interaction_responder] if interaction_responder is not None else [])\n \n+ # SSH_ASKPASS_REQUIRE is not generally available, so use setsid\n+ process = await asyncio.create_subprocess_exec(\n+ *('/usr/bin/ssh', *args, destination), env=env,\n+ start_new_session=True, stdin=asyncio.subprocess.DEVNULL,\n+ stdout=asyncio.subprocess.DEVNULL, stderr=agent, # type: ignore\n+ preexec_fn=lambda: prctl(PR_SET_PDEATHSIG, signal.SIGKILL))\n \n-class FixedType(BasicType):\n- __slots__ = ()\n+ # This is tricky: we need to clean up the subprocess, but only in case\n+ # if failure. Otherwise, we keep it around.\n+ try:\n+ await agent.communicate()\n+ assert os.path.exists(self._controlsock)\n+ self._process = process\n+ except InteractionError as exc:\n+ await process.wait()\n+ raise ssh_errors.get_exception_for_ssh_stderr(str(exc)) from None\n+ except BaseException:\n+ # If we get here because the InteractionHandler raised an\n+ # exception then SSH might still be running, and may even attempt\n+ # further interactions (ie: 2nd attempt for password). We already\n+ # have our exception and don't need any more info. Kill it.\n+ try:\n+ process.kill()\n+ except ProcessLookupError:\n+ pass # already exited? good.\n+ await process.wait()\n+ raise\n \n- def get_writer(self, append_basic, type_constant, variable, reference, setter, getter):\n- def fixed_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n- setter(variable, value)\n- if getter(variable) != value:\n- raise TypeError(f\"Cannot represent value {value} with type '{self.typestring}'\")\n- append_basic(message, type_constant, reference)\n- return fixed_writer\n+ def is_connected(self) -> bool:\n+ return self._process is not None\n \n+ async def wait(self) -> None:\n+ assert self._process is not None\n+ await self._process.wait()\n \n-class StringLikeType(BasicType):\n- __slots__ = ()\n+ def exit(self) -> None:\n+ assert self._process is not None\n+ self._process.terminate()\n \n- @staticmethod\n- def get_guarded_conversion(typestring: str, guard: Callable[[str], bool]) -> Callable[[object], bytes]:\n- def convert(candidate: object) -> bytes:\n- if not isinstance(candidate, str):\n- raise TypeError(f\"'{typestring}' encodes 'str', not '{candidate.__class__.__name__}'\")\n- if not guard(candidate):\n- raise ValueError(f\"Invalid value provided for type '{typestring}'\")\n- return str.encode(candidate)\n- return convert\n+ async def disconnect(self) -> None:\n+ self.exit()\n+ await self.wait()\n \n- def __init__(self, typestring: str, guard: Optional[Callable[[str], bool]] = None):\n- # https://docs.python.org/3/c-api/unicode.html#c.PyUnicode_FromString\n- to_unicode = ctypes.pythonapi.PyUnicode_FromString\n- to_unicode.restype = ctypes.py_object\n+ # Launching of processes\n+ def wrap_subprocess_args(self, args: Sequence[str]) -> Sequence[str]:\n+ assert self._controlsock is not None\n+ # 1. We specify the hostname as the empty string: it will be ignored\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/askpass.py': br'''from .interaction_client import main\n \n- if guard is not None:\n- convert = StringLikeType.get_guarded_conversion(typestring, guard)\n- else:\n- convert = str.encode # type: ignore[assignment] # can throw TypeError on call\n+if __name__ == '__main__':\n+ main()\n+''',\n+ 'cockpit/_vendor/ferny/py.typed': br'''''',\n+ 'cockpit/_vendor/ferny/ssh_askpass.py': br'''import logging\n+import re\n+from typing import ClassVar, Match, Sequence\n \n- super().__init__(typestring, ctypes.c_char_p, to_unicode, convert=convert)\n+from .interaction_agent import AskpassHandler\n \n- def get_writer(self, append_basic, type_constant, convert):\n- def string_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n- append_basic(message, type_constant, convert(value))\n- return string_writer\n+logger = logging.getLogger(__name__)\n \n \n-class BytestringType(Type):\n- __slots__ = ()\n+class AskpassPrompt:\n+ \"\"\"An askpass prompt resulting from a call to ferny-askpass.\n \n- def get_writer(self, append_array, y, size_t_setter, size_t):\n- def bytes_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n- if not isinstance(value, bytes):\n- if isinstance(value, str):\n- try:\n- value = binascii.a2b_base64(value.encode('ascii')) # or decode base64\n- except binascii.Error as exc:\n- raise ValueError(\"'ay' cannot encode invalid base64 string\") from exc\n- elif isinstance(value, (memoryview, bytearray)):\n- value = bytes(value)\n- else:\n- raise TypeError(\"'ay' can only encode bytes-like or base64 string objects, \"\n- f\"not '{value.__class__.__name__}'.\")\n- size_t_setter(size_t, len(value))\n- append_array(message, y, value, size_t)\n- return bytes_writer\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 get_reader(self, read_array, y, to_bytes, char_p, char_p_ref, size_t, size_t_ref):\n- def bytes_reader(message):\n- if read_array(message, y, char_p_ref, size_t_ref) <= 0:\n- raise StopIteration\n- return to_bytes(char_p, size_t)\n- return bytes_reader\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 ContainerType(Type):\n- _typestring_template: ClassVar[str]\n- __slots__ = 'item_types'\n- item_types: Sequence[Type]\n+ def close(self) -> None:\n+ pass\n \n- def __init__(self, *item_types: Type, **kwargs: Any):\n- assert len(item_types) > 0\n- item_typestrings = ''.join(item.typestring for item in item_types)\n- self.item_types = item_types\n- super().__init__(self._typestring_template.replace('_', item_typestrings),\n- type_contents=ctypes.c_char_p(item_typestrings.encode('ascii')),\n- **kwargs)\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-class ArrayType(ContainerType):\n- _typestring_template = 'a_'\n- __slots__ = ()\n \n- def __init__(self, item_type: Type):\n- super().__init__(item_type,\n- item_writer=item_type.writer,\n- item_reader=item_type.reader,\n- list_append=list.append)\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- def get_reader(self, enter_container, exit_container, list_append, item_reader):\n- def array_reader(message: libsystemd.sd_bus_message) -> object:\n- if enter_container(message, 0, None) <= 0:\n- raise StopIteration\n- result: List[object] = []\n- try:\n- while True:\n- list_append(result, item_reader(message))\n- except StopIteration:\n- return result\n- finally:\n- exit_container(message)\n- return array_reader\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 get_writer(self, a, type_contents, open_container, close_container, item_writer):\n- def array_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n- open_container(message, a, type_contents)\n- for item in value: # type: ignore[attr-defined] # can throw TypeError\n- item_writer(message, item)\n- close_container(message)\n- return array_writer\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+ 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-class StructType(ContainerType):\n- _typestring_template = '(_)'\n- __slots__ = ()\n \n- def get_reader(self, enter_container, exit_container):\n- item_readers = tuple(item_type.reader for item_type in self.item_types)\n+# Specific prompts\n+HELPERS = {\n+ \"%{algorithm}\": r\"(?P\\b[-\\w]+\\b)\",\n+ \"%{filename}\": r\"(?P.+)\",\n+ \"%{fingerprint}\": r\"(?PSHA256:[0-9A-Za-z+/]{43})\",\n+ \"%{hostname}\": r\"(?P[^ @']+)\",\n+ \"%{pkcs11_id}\": r\"(?P.+)\",\n+ \"%{username}\": r\"(?P[^ @']+)\",\n+}\n \n- def array_reader(message: libsystemd.sd_bus_message) -> object:\n- if enter_container(message, 0, None) <= 0:\n- raise StopIteration\n- result = tuple(item_reader(message) for item_reader in item_readers)\n- exit_container(message)\n- return result\n- return array_reader\n \n- def get_writer(self, r, type_contents, open_container, close_container):\n- item_writers = tuple(item_type.writer for item_type in self.item_types)\n+class SshPasswordPrompt(SSHAskpassPrompt):\n+ _pattern = r\"%{username}@%{hostname}'s password: \"\n+ username: 'str | None' = None\n+ hostname: 'str | None' = None\n \n- def struct_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n- n_items = len(value) # type: ignore[arg-type] # can throw TypeError\n- if n_items != len(item_writers):\n- raise TypeError(f\"Wrong numbers of items ({n_items}) for structure type '{self.typestring}'\")\n- open_container(message, r, type_contents)\n- for item_writer, item in zip(item_writers, value): # type: ignore[call-overload] # can throw TypeError\n- item_writer(message, item)\n- close_container(message)\n- return struct_writer\n+ async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n+ return await responder.do_password_prompt(self)\n \n \n-class DictionaryType(ContainerType):\n- _typestring_template = 'a{_}'\n- __slots__ = ()\n+class SshPassphrasePrompt(SSHAskpassPrompt):\n+ _pattern = r\"Enter passphrase for key '%{filename}': \"\n+ filename: str\n \n- def __init__(self, key_type: Type, value_type: Type):\n- assert isinstance(key_type, BasicType)\n- item_type = '{' + key_type.typestring + value_type.typestring + '}'\n- super().__init__(key_type, value_type,\n- key_reader=key_type.reader, key_writer=key_type.writer,\n- value_reader=value_type.reader, value_writer=value_type.writer,\n- item_type=ctypes.c_char_p(item_type.encode('ascii')))\n+ async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n+ return await responder.do_passphrase_prompt(self)\n \n- def get_reader(self, enter_container, exit_container, key_reader, value_reader):\n- def dict_reader(message: libsystemd.sd_bus_message) -> object:\n- if enter_container(message, 0, None) <= 0: # array\n- raise StopIteration\n- result = {}\n- while enter_container(message, 0, None) > 0: # entry\n- key = key_reader(message)\n- value = value_reader(message)\n- result[key] = value\n- exit_container(message)\n- exit_container(message)\n- return result\n- return dict_reader\n \n- def get_writer(self, a, item_type, e, type_contents, open_container, close_container, key_writer, value_writer):\n- def dict_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n- open_container(message, a, item_type) # array\n- for key, val in value.items(): # type: ignore[attr-defined] # can raise AttributeError\n- open_container(message, e, type_contents) # entry\n- key_writer(message, key) # key\n- value_writer(message, val) # value\n- close_container(message) # end entry\n- close_container(message) # end array\n- return dict_writer\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-class VariantType(Type):\n- __slots__ = ()\n \n- def get_reader(self, enter_container, exit_container):\n- def variant_reader(message: libsystemd.sd_bus_message) -> object:\n- if enter_container(message, 0, None) <= 0:\n- raise StopIteration\n- typestring = message.get_signature(False)\n- type_, = from_signature(typestring)\n- value = type_.reader(message)\n- exit_container(message)\n- return Variant(value, type_)\n- return variant_reader\n+class SshFIDOUserPresencePrompt(SSHAskpassPrompt):\n+ _pattern = r\"Confirm user presence for key %{algorithm} %{fingerprint}\"\n+ answers = ()\n+ algorithm: str\n+ fingerprint: str\n \n- def get_writer(self, open_container, close_container, v):\n- def variant_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n- if isinstance(value, Variant):\n- type_ = value.type\n- contents = value.value\n- else:\n- try:\n- type_, = from_signature(value['t']) # type: ignore[index] # can throw TypeError\n- contents = value['v'] # type: ignore[index] # can throw TypeError\n- except KeyError as exc:\n- raise TypeError(\"'v' can encode Variant objects, or mappings with 't' and 'v' keys\") from exc\n+ async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n+ return await responder.do_fido_user_presence_prompt(self)\n \n- open_container(message, v, type_.bytes_typestring)\n- type_.writer(message, contents)\n- close_container(message)\n- return variant_writer\n \n+class SshPKCS11PINPrompt(SSHAskpassPrompt):\n+ _pattern = r\"Enter PIN for '%{pkcs11_id}': \"\n+ pkcs11_id: str\n \n-class Variant:\n- __slots__ = 'type', 'value'\n- type: Type\n- value: object\n+ async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n+ return await responder.do_pkcs11_pin_prompt(self)\n \n- def __init__(self, value: object, hint: object = None):\n- if isinstance(hint, Type):\n- self.type = hint\n- elif isinstance(hint, str):\n- self.type, = from_signature(hint)\n- else:\n- self.type = from_annotation(hint or value.__class__)\n- self.value = value\n \n- def __repr__(self) -> str:\n- return f\"systemd_ctypes.Variant({self.value}, '{self.type.typestring}')\"\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- def __eq__(self, other: object) -> bool:\n- if isinstance(other, Variant):\n- return self.type == other.type and self.value == other.value\n- elif isinstance(other, dict):\n- return (self.type,) == from_signature(other['t']) and self.value == other['v']\n- else:\n- return False\n+ async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n+ return await responder.do_host_key_prompt(self)\n \n- def __hash__(self) -> int:\n- return hash(self.type) ^ hash(self.value)\n \n+def with_helpers(pattern: str) -> str:\n+ for name, helper in HELPERS.items():\n+ pattern = pattern.replace(name, helper)\n \n-class BusType(Enum):\n- boolean = Annotated[bool, FixedType('b', ctypes.c_int, ctypes.c_int.__bool__)]\n- byte = Annotated[int, FixedType('y', ctypes.c_uint8)]\n- int16 = Annotated[int, FixedType('n', ctypes.c_int16)]\n- uint16 = Annotated[int, FixedType('q', ctypes.c_uint16)]\n- int32 = Annotated[int, FixedType('i', ctypes.c_int32)]\n- uint32 = Annotated[int, FixedType('u', ctypes.c_uint32)]\n- int64 = Annotated[int, FixedType('x', ctypes.c_int64)]\n- uint64 = Annotated[int, FixedType('t', ctypes.c_uint64)]\n- double = Annotated[float, FixedType('d', ctypes.c_double)]\n- string = Annotated[str, StringLikeType('s')]\n- objectpath = Annotated[str, StringLikeType('o', is_object_path)]\n- signature = Annotated[str, StringLikeType('g', is_signature)]\n- bytestring = Annotated[bytes, BytestringType('ay')]\n- variant = Annotated[dict, VariantType('v')]\n+ assert '%{' not in pattern\n+ return pattern\n \n \n-# mypy gets confused by enums, so just use Any\n-_base_equivalence_map: Dict[type, Any] = {\n- bool: BusType.boolean,\n- bytes: BusType.bytestring,\n- int: BusType.int32,\n- str: BusType.string,\n- Variant: BusType.variant,\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-_factory_map: Dict[object, Callable[..., Type]] = {\n- dict: DictionaryType, Dict: DictionaryType,\n- list: ArrayType, List: ArrayType,\n- tuple: StructType, Tuple: StructType,\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 cls(last_line, extras, stderr, match)\n \n-@functools.lru_cache()\n-def from_annotation(annotation: Union[str, type, BusType]) -> Type:\n- # Simple Python types\n- if isinstance(annotation, str):\n- types = from_signature(annotation)\n- if len(types) != 1:\n- raise TypeError(f\"Signature '{annotation}' invalid as a type string \"\n- f\"because it describes {len(types)} types, not one.\")\n- return types[0]\n+ return AskpassPrompt(last_line, extras, stderr)\n \n- if isinstance(annotation, type):\n- annotation = _base_equivalence_map.get(annotation, annotation)\n \n- # Our own BusType types\n- if isinstance(annotation, BusType):\n- bus_type = typing.get_args(annotation.value)[1]\n- assert isinstance(bus_type, Type)\n- return bus_type\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- # Container types\n- try:\n- factory = _factory_map[typing.get_origin(annotation)]\n- args = [from_annotation(arg) for arg in typing.get_args(annotation)]\n- return factory(*args)\n- except (AssertionError, AttributeError, KeyError, TypeError):\n- raise TypeError(f\"Cannot interpret {annotation} as a dbus type\") from None\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-_base_typestring_map: Dict[str, Type] = {\n- bustype.typestring: bustype for bustype in (from_annotation(entry) for entry in BusType)\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-@functools.lru_cache()\n-def from_signature(signature: str) -> Tuple[Type, ...]:\n- stack = list(reversed(signature))\n+ async def do_pkcs11_pin_prompt(self, prompt: SshPKCS11PINPrompt) -> 'str | None':\n+ return await self.do_prompt(prompt)\n \n- def get_one() -> Type:\n- first = stack.pop()\n- if first == 'a':\n- if stack[-1] == 'y':\n- first += stack.pop()\n- elif stack[-1] == '{':\n- stack.pop()\n- return DictionaryType(*get_several('}'))\n- else:\n- return ArrayType(get_one())\n- elif first == '(':\n- return StructType(*get_several(')'))\n+ async def do_passphrase_prompt(self, prompt: SshPassphrasePrompt) -> 'str | None':\n+ return await self.do_prompt(prompt)\n \n- return _base_typestring_map[first]\n+ async def do_password_prompt(self, prompt: SshPasswordPrompt) -> 'str | None':\n+ return await self.do_prompt(prompt)\n+''',\n+ 'cockpit/_vendor/ferny/interaction_client.py': br'''#!/usr/bin/python3\n \n- def get_several(end: str) -> Iterable[Type]:\n- yield get_one()\n- while stack[-1] != end:\n- yield get_one()\n- stack.pop()\n+import array\n+import io\n+import os\n+import socket\n+import sys\n+from typing import Sequence\n \n- def get_all() -> Iterable[Type]:\n- while stack:\n- yield get_one()\n \n- try:\n- return tuple(get_all())\n- except (AssertionError, IndexError, KeyError) as exc:\n- raise TypeError(f\"Invalid type signature '{signature}'\") from exc\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-class MessageType:\n- item_types: Sequence[Type]\n- typestrings: List[str]\n- signature: str\n+ cmd_write.write(repr((command, args)))\n \n- def __init__(self, item_types: Sequence[Union[str, type, BusType]]):\n- self.item_types = [from_annotation(item_type) for item_type in item_types]\n- self.typestrings = [item_type.typestring for item_type in self.item_types]\n- self.signature = ''.join(self.typestrings)\n \n- def write(self, message: libsystemd.sd_bus_message, *items: object) -> None:\n- assert len(items) == len(self.item_types)\n- for item_type, item in zip(self.item_types, items):\n- item_type.writer(message, item)\n+def askpass(stderr_fd: int, stdout_fd: int, args: 'list[str]', env: 'dict[str, str]') -> int:\n+ ours, theirs = socket.socketpair()\n \n- def read(self, message: libsystemd.sd_bus_message) -> Optional[Tuple[object, ...]]:\n- if not message.has_signature(self.signature):\n- return None\n- return tuple(item_type.reader(message) for item_type in self.item_types)\n+ with theirs:\n+ command(stderr_fd, 'ferny.askpass', args, env, fds=(theirs.fileno(), stdout_fd))\n \n- def __len__(self) -> int:\n- return len(self.item_types)\n+ with ours:\n+ return int(ours.recv(16) or b'1')\n \n \n-class JSONEncoder(json.JSONEncoder):\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+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/systemd_ctypes/introspection.py': br'''# systemd_ctypes\n+ 'cockpit/_vendor/ferny/transport.py': br'''# ferny - asyncio SSH client library, using ssh(1)\n #\n-# Copyright (C) 2022 Allison Karlitskaya \n+# Copyright (C) 2023 Allison Karlitskaya \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 .\n \n-import xml.etree.ElementTree as ET\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-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+logger = logging.getLogger(__name__)\n \n+P = TypeVar('P', bound=asyncio.Protocol)\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+class SubprocessError(Exception):\n+ returncode: int\n+ stderr: str\n \n-def parse_signal(signal):\n- return {\"in\": [tag.attrib['type'] for tag in signal.findall(\"arg\")]}\n+ def __init__(self, returncode: int, stderr: str) -> None:\n+ super().__init__(returncode, stderr)\n+ self.returncode = returncode\n+ self.stderr = stderr\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+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-def parse_xml(xml):\n- et = ET.fromstring(xml)\n- return {tag.attrib['name']: parse_interface(tag) for tag in et.findall('interface')}\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-# 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+ 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 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+ 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-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+ 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-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+ 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-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+ 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-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/__init__.py': br'''# systemd_ctypes\n-#\n-# Copyright (C) 2022 Allison Karlitskaya \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 .\n+ self._agent = InteractionAgent(interaction_handlers, loop, self._interaction_completed)\n+ kwargs.setdefault('stderr', self._agent.fileno())\n \n-\"\"\"systemd_ctypes\"\"\"\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-__version__ = \"0\"\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-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+ # 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+\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 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+\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+\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+\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+\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_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+\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+\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+\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 get_returncode(self) -> 'int | None':\n+ return self._returncode\n+\n+ def kill(self) -> None:\n+ assert self._subprocess_transport is not None\n+ self._subprocess_transport.kill()\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+\n+ def terminate(self) -> None:\n+ assert self._subprocess_transport is not None\n+ self._subprocess_transport.terminate()\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+ temporary_askpass,\n+ write_askpass_to_tmpdir,\n+)\n+from .session import Session\n+from .ssh_askpass import (\n+ AskpassPrompt,\n+ SshAskpassResponder,\n+ SshFIDOPINPrompt,\n+ SshFIDOUserPresencePrompt,\n+ SshHostKeyPrompt,\n+ SshPassphrasePrompt,\n+ SshPasswordPrompt,\n+ SshPKCS11PINPrompt,\n+)\n+from .ssh_errors import (\n+ SshAuthenticationError,\n+ SshChangedHostKeyError,\n+ SshError,\n+ SshHostKeyError,\n+ SshUnknownHostKeyError,\n+)\n+from .transport import FernyTransport, SubprocessError\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+ 'AskpassHandler',\n+ 'AskpassPrompt',\n+ 'AuthenticationError',\n+ 'BEIBOOT_GADGETS',\n+ 'COMMAND_TEMPLATE',\n+ 'ChangedHostKeyError',\n+ 'FernyTransport',\n+ 'HostKeyError',\n+ 'InteractionAgent',\n+ 'InteractionError',\n+ 'InteractionHandler',\n+ 'Session',\n+ 'SshAskpassResponder',\n+ 'SshAuthenticationError',\n+ 'SshChangedHostKeyError',\n+ 'SshError',\n+ 'SshFIDOPINPrompt',\n+ 'SshFIDOUserPresencePrompt',\n+ 'SshHostKeyError',\n+ 'SshHostKeyPrompt',\n+ 'SshPKCS11PINPrompt',\n+ 'SshPassphrasePrompt',\n+ 'SshPasswordPrompt',\n+ 'SshUnknownHostKeyError',\n+ 'SubprocessError',\n+ 'temporary_askpass',\n+ 'write_askpass_to_tmpdir',\n ]\n+\n+__version__ = '0'\n ''',\n- 'cockpit/_vendor/systemd_ctypes/py.typed': br'''''',\n- 'cockpit/_vendor/systemd_ctypes/pathwatch.py': br'''# systemd_ctypes\n+ 'cockpit/_vendor/ferny/interaction_agent.py': r'''# ferny - asyncio SSH client library, using ssh(1)\n #\n-# Copyright (C) 2022 Allison Karlitskaya \n+# Copyright (C) 2023 Allison Karlitskaya \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 .\n \n-import errno\n+import array\n+import ast\n+import asyncio\n+import contextlib\n import logging\n import os\n-import stat\n-from typing import Any, List, Optional\n+import re\n+import socket\n+import tempfile\n+from typing import Any, Callable, ClassVar, Generator, Sequence\n \n-from .event import Event\n-from .inotify import Event as IN\n+from . import interaction_client\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+COMMAND_RE = re.compile(b'\\0ferny\\0([^\\n]*)\\0\\0\\n')\n+COMMAND_TEMPLATE = '\\0ferny\\0{(command, args)!r}\\0\\0\\n'\n \n+BEIBOOT_GADGETS = {\n+ \"command\": fr\"\"\"\n+ import sys\n+ def command(command, *args):\n+ sys.stderr.write(f{COMMAND_TEMPLATE!r})\n+ sys.stderr.flush()\n+ \"\"\",\n+ \"end\": r\"\"\"\n+ def end():\n+ command('ferny.end')\n+ \"\"\",\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+class InteractionError(Exception):\n+ pass\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+try:\n+ recv_fds = socket.recv_fds\n+except AttributeError:\n+ # Python < 3.9\n \n- def close(self) -> None:\n- if self._needs_close:\n- self._needs_close = False\n- os.close(self)\n+ def recv_fds(\n+ sock: socket.socket, bufsize: int, maxfds: int, flags: int = 0\n+ ) -> 'tuple[bytes, list[int], int, None]':\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- 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+def get_running_loop() -> asyncio.AbstractEventLoop:\n+ try:\n+ return asyncio.get_running_loop()\n+ except AttributeError:\n+ # Python 3.6\n+ return asyncio.get_event_loop()\n \n- if not self or not value: # when only one == -1\n- return False\n \n- return os.path.sameopenfile(self, value)\n+class InteractionHandler:\n+ commands: ClassVar[Sequence[str]]\n \n- def __del__(self) -> None:\n- if self._needs_close:\n- self.close()\n+ async def run_command(self, command: str, args: 'tuple[object, ...]', fds: 'list[int]', stderr: str) -> None:\n+ raise NotImplementedError\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 AskpassHandler(InteractionHandler):\n+ commands: ClassVar[Sequence[str]] = ('ferny.askpass',)\n \n- @classmethod\n- def open(cls, *args: Any, **kwargs: Any) -> 'Handle':\n- return cls(os.open(*args, **kwargs))\n+ async def do_askpass(self, messages: str, prompt: str, hint: str) -> 'str | None':\n+ \"\"\"Prompt the user for an authentication or confirmation interaction.\n \n- def steal(self) -> 'Handle':\n- self._needs_close = False\n- return self.__class__(int(self))\n+ 'messages' is data that was sent to stderr before the interaction was requested.\n+ 'prompt' is the interaction prompt.\n \n+ The expected response type depends on hint:\n \n-class WatchInvalidator:\n- _name: bytes\n- _source: Optional[Event.Source]\n- _watch: Optional['PathWatch']\n+ - \"confirm\": ask for permission, returning \"yes\" if accepted\n+ - example: authorizing agent operation\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+ - \"none\": show a request without need for a response\n+ - example: please touch your authentication token\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+ - otherwise: return a password or other form of text token\n+ - examples: enter password, unlock private key\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+ In any case, the function should properly handle cancellation. For the\n+ \"none\" case, this will be the normal way to dismiss the dialog.\n+ \"\"\"\n+ return None\n+\n+ async def do_hostkey(self, reason: str, host: str, algorithm: str, key: str, fingerprint: str) -> bool:\n+ \"\"\"Prompt the user for a decision regarding acceptance of a host key.\n+\n+ The \"reason\" will be either \"HOSTNAME\" or \"ADDRESS\" (if `CheckHostIP` is enabled).\n+\n+ The host, algorithm, and key parameters are the values in the form that\n+ they would appear one a single line in the known hosts file. The\n+ fingerprint is the key fingerprint in the format that ssh would\n+ normally present it to the user.\n+\n+ In case the host key should be accepted, this function needs to return\n+ True. Returning False means that ssh implements its default logic. To\n+ interrupt the connection, raise an exception.\n+ \"\"\"\n+ return False\n+\n+ async def do_custom_command(\n+ self, command: str, args: 'tuple[object, ...]', fds: 'list[int]', stderr: str\n+ ) -> None:\n+ \"\"\"Handle a custom command.\n+\n+ The command name, its arguments, the passed fds, and the stderr leading\n+ up to the command invocation are all provided.\n+\n+ See doc/interaction-protocol.md\n+ \"\"\"\n+\n+ async def _askpass_command(self, args: 'tuple[object, ...]', fds: 'list[int]', stderr: str) -> None:\n+ logger.debug('_askpass_command(%s, %s, %s)', args, fds, stderr)\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+ argv, env = args\n+ assert isinstance(argv, list)\n+ assert all(isinstance(arg, str) for arg in argv)\n+ assert isinstance(env, dict)\n+ assert all(isinstance(key, str) and isinstance(val, str) for key, val in env.items())\n+ assert len(fds) == 2\n+ except (ValueError, TypeError, AssertionError) as exc:\n+ logger.error('Invalid arguments to askpass interaction: %s, %s: %s', args, fds, exc)\n+ return\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+ with open(fds.pop(0), 'w') as status, open(fds.pop(0), 'w') as stdout:\n+ try:\n+ loop = get_running_loop()\n+ try:\n+ task = asyncio.current_task()\n+ except AttributeError:\n+ task = asyncio.Task.current_task() # type:ignore[attr-defined] # (Python 3.6)\n+ assert task is not None\n+ loop.add_reader(status, task.cancel)\n \n+ if len(argv) == 2:\n+ # normal askpass\n+ prompt = argv[1]\n+ hint = env.get('SSH_ASKPASS_PROMPT', '')\n+ logger.debug('do_askpass(%r, %r, %r)', stderr, prompt, hint)\n+ answer = await self.do_askpass(stderr, prompt, hint)\n+ logger.debug('do_askpass answer %r', answer)\n+ if answer is not None:\n+ print(answer, file=stdout)\n+ print(0, file=status)\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+ elif len(argv) == 6:\n+ # KnownHostsCommand\n+ argv0, reason, host, algorithm, key, fingerprint = argv\n+ if reason in ['ADDRESS', 'HOSTNAME']:\n+ logger.debug('do_hostkey(%r, %r, %r, %r, %r)', reason, host, algorithm, key, fingerprint)\n+ if await self.do_hostkey(reason, host, algorithm, key, fingerprint):\n+ print(host, algorithm, key, file=stdout)\n+ else:\n+ logger.debug('ignoring KnownHostsCommand reason %r', reason)\n \n- def __init__(self, path: str):\n- super().__init__()\n- self.add_path(path)\n+ print(0, file=status)\n \n+ else:\n+ logger.error('Incorrect number of command-line arguments to ferny-askpass: %s', argv)\n+ finally:\n+ loop.remove_reader(status)\n \n-class Listener:\n- def do_inotify_event(self, mask: IN, cookie: int, name: Optional[bytes]) -> None:\n- raise NotImplementedError\n+ async def run_command(self, command: str, args: 'tuple[object, ...]', fds: 'list[int]', stderr: str) -> None:\n+ logger.debug('run_command(%s, %s, %s, %s)', command, args, fds, stderr)\n+ if command == 'ferny.askpass':\n+ await self._askpass_command(args, fds, stderr)\n+ else:\n+ await self.do_custom_command(command, args, fds, stderr)\n \n- def do_identity_changed(self, fd: Optional[Handle], errno: Optional[int]) -> None:\n- raise NotImplementedError\n \n+class InteractionAgent:\n+ _handlers: 'dict[str, InteractionHandler]'\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+ _loop: asyncio.AbstractEventLoop\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+ _tasks: 'set[asyncio.Task]'\n \n- self._invalidators = []\n- self._errno = None\n- self._source = None\n- self._tag = None\n- self._fd = Handle()\n+ _buffer: bytearray\n+ _ours: socket.socket\n+ _theirs: socket.socket\n \n- self.invalidate()\n+ _completion_future: 'asyncio.Future[str]'\n+ _pending_result: 'None | str | Exception' = None\n+ _end: bool = False\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+ def _consider_completion(self) -> None:\n+ logger.debug('_consider_completion(%r)', self)\n \n- def invalidate(self) -> None:\n- for invalidator in self._invalidators:\n- invalidator.close()\n- self._invalidators = []\n+ if self._pending_result is None or self._tasks:\n+ logger.debug(' but not ready yet')\n \n- try:\n- fd = self.walk()\n- except OSError as error:\n- logger.debug('walk ended in error %d', error.errno)\n+ elif self._completion_future.done():\n+ logger.debug(' but already complete')\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+ elif isinstance(self._pending_result, str):\n+ logger.debug(' submitting stderr (%r) to completion_future', self._pending_result)\n+ self._completion_future.set_result(self._pending_result)\n \n- logger.debug('Notifying of new error state %d', self._errno)\n- self._listener.do_identity_changed(None, self._errno)\n+ else:\n+ logger.debug(' submitting exception (%r) to completion_future')\n+ self._completion_future.set_exception(self._pending_result)\n+\n+ def _result(self, result: 'str | Exception') -> None:\n+ logger.debug('_result(%r, %r)', self, result)\n+\n+ if self._pending_result is None:\n+ self._pending_result = result\n+\n+ if self._ours.fileno() != -1:\n+ logger.debug(' remove_reader(%r)', self._ours)\n+ self._loop.remove_reader(self._ours.fileno())\n+\n+ for task in self._tasks:\n+ logger.debug(' cancel(%r)', task)\n+ task.cancel()\n \n+ logger.debug(' closing sockets')\n+ self._theirs.close() # idempotent\n+ self._ours.close()\n+\n+ self._consider_completion()\n+\n+ def _invoke_command(self, stderr: bytes, command_blob: bytes, fds: 'list[int]') -> None:\n+ logger.debug('_invoke_command(%r, %r, %r)', stderr, command_blob, fds)\n+ try:\n+ command, args = ast.literal_eval(command_blob.decode())\n+ if not isinstance(command, str) or not isinstance(args, tuple):\n+ raise TypeError('Invalid argument types')\n+ except (UnicodeDecodeError, SyntaxError, ValueError, TypeError) as exc:\n+ logger.error('Received invalid ferny command: %s: %s', command_blob, exc)\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+ if command == 'ferny.end':\n+ self._end = True\n+ self._result(self._buffer.decode(errors='replace'))\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+ try:\n+ handler = self._handlers[command]\n+ except KeyError:\n+ logger.error('Received unhandled ferny command: %s', command)\n+ return\n+\n+ # The task is responsible for the list of fds and removing itself\n+ # from the set.\n+ task_fds = list(fds)\n+ task = self._loop.create_task(handler.run_command(command, args, task_fds, stderr.decode()))\n+\n+ def bottom_half(completed_task: asyncio.Task) -> None:\n+ assert completed_task is task\n+ while task_fds:\n+ os.close(task_fds.pop())\n+ self._tasks.remove(task)\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+ task.result()\n+ logger.debug('%r completed cleanly', handler)\n+ except asyncio.CancelledError:\n+ # this is not an error \u2014 it just means ferny-askpass exited via signal\n+ logger.debug('%r was cancelled', handler)\n+ except Exception as exc:\n+ logger.debug('%r raised %r', handler, exc)\n+ self._result(exc)\n \n- def walk(self) -> Handle:\n- remaining_symlink_lookups = 40\n- remaining_components = PathStack(self._path)\n- dirfd = Handle()\n+ self._consider_completion()\n \n+ task.add_done_callback(bottom_half)\n+ self._tasks.add(task)\n+ fds[:] = []\n+\n+ def _got_data(self, data: bytes, fds: 'list[int]') -> None:\n+ logger.debug('_got_data(%r, %r)', data, fds)\n+\n+ if data == b'':\n+ self._result(self._buffer.decode(errors='replace'))\n+ return\n+\n+ self._buffer.extend(data)\n+\n+ # Read zero or more \"remote\" messages\n+ chunks = COMMAND_RE.split(self._buffer)\n+ self._buffer = bytearray(chunks.pop())\n+ while len(chunks) > 1:\n+ self._invoke_command(chunks[0], chunks[1], [])\n+ chunks = chunks[2:]\n+\n+ # Maybe read one \"local\" message\n+ if fds:\n+ assert self._buffer.endswith(b'\\0'), self._buffer\n+ stderr = self._buffer[:-1]\n+ self._buffer = bytearray(b'')\n+ with open(fds.pop(0), 'rb') as command_channel:\n+ command = command_channel.read()\n+ self._invoke_command(stderr, command, fds)\n+\n+ def _read_ready(self) -> None:\n try:\n- logger.debug('Starting path walk')\n+ data, fds, _flags, _addr = recv_fds(self._ours, 4096, 10, flags=socket.MSG_DONTWAIT)\n+ except BlockingIOError:\n+ return\n+ except OSError as exc:\n+ self._result(exc)\n+ else:\n+ self._got_data(data, fds)\n+ finally:\n+ while fds:\n+ os.close(fds.pop())\n \n- while remaining_components:\n- logger.debug('r=%s dfd=%s', remaining_components, dirfd)\n+ def __init__(\n+ self,\n+ handlers: Sequence[InteractionHandler],\n+ loop: 'asyncio.AbstractEventLoop | None' = None,\n+ done_callback: 'Callable[[asyncio.Future[str]], None] | None' = None,\n+ ) -> None:\n+ self._loop = loop or get_running_loop()\n+ self._completion_future = self._loop.create_future()\n+ self._tasks = set()\n+ self._handlers = {}\n \n- name = remaining_components.pop()\n+ for handler in handlers:\n+ for command in handler.commands:\n+ self._handlers[command] = handler\n \n- if dirfd and name != '/':\n- self._invalidators.append(WatchInvalidator(self, self._event, dirfd, name))\n+ if done_callback is not None:\n+ self._completion_future.add_done_callback(done_callback)\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+ self._theirs, self._ours = socket.socketpair(socket.AF_UNIX, socket.SOCK_STREAM)\n+ self._buffer = bytearray()\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+ def fileno(self) -> int:\n+ return self._theirs.fileno()\n \n- else:\n- dirfd.close()\n- dirfd = fd.steal()\n+ def start(self) -> None:\n+ logger.debug('start(%r)', self)\n+ if self._ours.fileno() != -1:\n+ logger.debug(' add_reader(%r)', self._ours)\n+ self._loop.add_reader(self._ours.fileno(), self._read_ready)\n+ else:\n+ logger.debug(' ...but agent is already finished.')\n \n- return dirfd.steal()\n+ logger.debug(' close(%r)', self._theirs)\n+ self._theirs.close()\n \n+ def force_completion(self) -> None:\n+ logger.debug('force_completion(%r)', self)\n+\n+ # read any residual data on stderr, but don't process commands, and\n+ # don't block\n+ try:\n+ if self._ours.fileno() != -1:\n+ logger.debug(' draining pending stderr data (non-blocking)')\n+ with contextlib.suppress(BlockingIOError):\n+ while True:\n+ data = self._ours.recv(4096, socket.MSG_DONTWAIT)\n+ logger.debug(' got %d bytes', len(data))\n+ if not data:\n+ break\n+ self._buffer.extend(data)\n+ except OSError as exc:\n+ self._result(exc)\n+ else:\n+ self._result(self._buffer.decode(errors='replace'))\n+\n+ async def communicate(self) -> None:\n+ logger.debug('_communicate(%r)', self)\n+ try:\n+ self.start()\n+ # We assume that we are the only ones to write to\n+ # self._completion_future. If we directly await it, though, it can\n+ # also have a asyncio.CancelledError posted to it from outside.\n+ # Shield it to prevent that from happening.\n+ stderr = await asyncio.shield(self._completion_future)\n+ logger.debug('_communicate(%r) stderr result is %r', self, stderr)\n finally:\n- dirfd.close()\n+ logger.debug('_communicate finished. Ensuring completion.')\n+ self.force_completion()\n+ if not self._end:\n+ logger.debug('_communicate never saw ferny.end. raising InteractionError.')\n+ raise InteractionError(stderr.strip())\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+def write_askpass_to_tmpdir(tmpdir: str) -> str:\n+ askpass_path = os.path.join(tmpdir, 'ferny-askpass')\n+ fd = os.open(askpass_path, os.O_CREAT | os.O_WRONLY | os.O_CLOEXEC | os.O_EXCL | os.O_NOFOLLOW, 0o777)\n+ try:\n+ os.write(fd, __loader__.get_data(interaction_client.__file__)) # type: ignore\n+ finally:\n+ os.close(fd)\n+ return askpass_path\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/ssh_errors.py': br'''# ferny - asyncio SSH client library, using ssh(1)\n+#\n+# Copyright (C) 2023 Allison Karlitskaya \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 .\n+\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 SshError(Exception):\n+ PATTERN: ClassVar[Pattern]\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+ self.stderr = stderr\n+\n+\n+class SshAuthenticationError(SshError):\n+ PATTERN = re.compile(r'^([^:]+): Permission denied \\(([^()]+)\\)\\.$', re.M)\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+\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+\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+\n+class SshChangedHostKeyError(SshHostKeyError):\n+ PATTERN = re.compile(r'warning.*remote host identification has changed', re.I)\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+\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+\n+gaierror_map = dict(make_gaierror_map())\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+\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+ if match is not None:\n+ return ssh_cls(match, stderr)\n+\n+ before, colon, after = stderr.rpartition(':')\n+ if colon and after:\n+ potential_strerror = after.strip()\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+\n+ # No match? Generic.\n+ return SshError(None, stderr)\n ''',\n- 'cockpit/_vendor/systemd_ctypes/libsystemd.py': r'''# systemd_ctypes\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/beipack.py': br'''# beipack - Remote bootloader for Python\n #\n # Copyright (C) 2022 Allison Karlitskaya \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@@ -6872,333 +6385,356 @@\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 .\n \n-import ctypes\n+import argparse\n+import binascii\n+import lzma\n import os\n import sys\n-from typing import ClassVar, List, Optional, Tuple, Union\n+import tempfile\n+import zipfile\n+from typing import Dict, Iterable, List, Optional, Set, Tuple\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+from .data import read_data_file\n \n \n-class Trampoline(ReferenceType):\n- deferred: 'ClassVar[list[Callback] | None]' = None\n- trampoline: Callback\n- userdata: UserData = None\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- 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+def ascii_bytes_repr(data: bytes) -> str:\n+ return 'b' + escape_string(data.decode('ascii'))\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+def utf8_bytes_repr(data: bytes) -> str:\n+ return escape_string(data.decode('utf-8')) + \".encode('utf-8')\"\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+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- def __del__(self) -> None:\n- if self._b_needsfree_:\n- libsystemd.sd_bus_error_free(byref(self))\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-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+ 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-class sd_event_source(Trampoline):\n- ...\n+ return base64_bytes_repr(data, imports)\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+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- def dispatch(self: 'sd_event') -> Union[None, Errno]:\n- ...\n \n- def get_fd(self: 'sd_event') -> Union[int, Errno]:\n- raise NotImplementedError\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 get_state(self: 'sd_event') -> Union[int, Errno]:\n- raise NotImplementedError\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- def loop(self: 'sd_event') -> Union[None, Errno]:\n- ...\n+ from package.module import func as main\n+ main()\n \n- def prepare(self: 'sd_event') -> Union[None, Errno]:\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- def wait(\n- self: 'sd_event', timeout: Annotated[int, ctypes.c_uint64]\n- ) -> Union[None, Errno]:\n- ...\n+ loader = read_data_file('beipack_loader.py')\n+ lines = [line for line in loader.splitlines() if line]\n+ lines.append('')\n \n- @staticmethod\n- def _default(ret: Reference['sd_event']) -> Union[None, Errno]:\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-class sd_bus_slot(Trampoline):\n- ...\n+ return ''.join(f'{line}\\n' for line in lines)\n \n \n-class sd_bus_message(ReferenceType):\n- def rewind(self: 'sd_bus_message', complete: bool) -> Union[None, Errno]:\n- ...\n+def collect_contents(filenames: List[str],\n+ relative_to: Optional[str] = None) -> Dict[str, bytes]:\n+ contents: Dict[str, bytes] = {}\n \n- def _get_error(self: 'sd_bus_message') -> Reference[sd_bus_error]:\n- raise NotImplementedError\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- def has_signature(self: 'sd_bus_message', signature: str) -> Union[bool, Errno]:\n- raise NotImplementedError\n+ return contents\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+def collect_module(name: str, *, recursive: bool) -> Dict[str, bytes]:\n+ import importlib.resources\n+ from importlib.resources.abc import Traversable\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+ 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- def _new_method_return(\n- self: 'sd_bus_message', m: Reference['sd_bus_message']\n- ) -> Union[None, Errno]:\n- ...\n+ return dict(walk(name.replace('.', '/'), importlib.resources.files(name)))\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+def collect_zip(filename: str) -> Dict[str, bytes]:\n+ contents = {}\n \n- def get_destination(self: 'sd_bus_message') -> str:\n- raise NotImplementedError\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- def get_interface(self: 'sd_bus_message') -> str:\n- raise NotImplementedError\n+ return contents\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+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- 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+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-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+ for file in args.zip:\n+ contents.update(collect_zip(file))\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+ for name in args.module:\n+ contents.update(collect_module(name, recursive=True))\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+ for path in args.build:\n+ contents.update(collect_pep517(path))\n \n- def attach_event(\n- self: 'sd_bus', event: Optional[sd_event], priority: int\n- ) -> Union[None, Errno]:\n- ...\n+ result = pack(contents, args.main, args.main_args).encode('utf-8')\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+ if args.python:\n+ result = b'#!' + args.python.encode('ascii') + b'\\n' + result\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+ 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+ 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+\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 \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 .\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- def flush(self: 'sd_bus') -> Union[None, Errno]:\n- ...\n \n- def get_fd(self: 'sd_bus') -> Union[int, Errno]:\n- raise NotImplementedError\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- 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+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- def release_name(self: 'sd_bus', name: str) -> Union[None, Errno]:\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- def request_name(\n- self: 'sd_bus', name: str, flags: Annotated[int, ctypes.c_uint64]\n- ) -> Union[None, Errno]:\n- ...\n+ # Yield functions mentioned in steps from the caller\n+ for name, args in steps:\n+ yield '', name + repr(tuple(args))\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+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- def set_fd(self: 'sd_bus', input_fd: int, output_fd: int) -> Union[None, Errno]:\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- def set_server(self: 'sd_bus', b: bool, bus_d: sd_id128) -> Union[None, Errno]:\n- ...\n+ return \"\".join(f\"{line}\\n\" for line in [*imports, *lines]) + \"\\n\"\n+''',\n+ 'cockpit/_vendor/bei/spawn.py': br'''\"\"\"Helper to create a beipack to spawn a command with files in a tmpdir\"\"\"\n \n- def start(self: 'sd_bus') -> Union[None, Errno]:\n- ...\n+import argparse\n+import os\n+import sys\n \n- def wait(\n- self: 'sd_bus', timeout_usec: Annotated[int, ctypes.c_uint64]\n- ) -> Union[None, Errno]:\n- ...\n+from . import pack, tmpfs\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+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- @staticmethod\n- def _default_user(ret: Reference['sd_bus']) -> Union[None, Errno]:\n- ...\n+ contents = {\n+ '_beitmpfs.py': tmpfs.__spec__.loader.get_data(tmpfs.__spec__.origin)\n+ }\n \n- @staticmethod\n- def _new(ret: Reference['sd_bus']) -> Union[None, Errno]:\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-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+ script = pack.pack(contents, '_beitmpfs:main', '*' + repr(args.command))\n+ sys.stdout.write(script)\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/inotify.py': br'''# systemd_ctypes\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 \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@@ -7207,130 +6743,258 @@\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 .\n \n-import ctypes\n-from enum import IntFlag, auto\n-from typing import Optional\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-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+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- class event_with_name(ctypes.Structure):\n- _fields_ = (*inotify_event._fields_, ('name', ctypes.c_char * self.len))\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- name = ctypes.cast(ctypes.addressof(self), ctypes.POINTER(event_with_name)).contents.name\n- assert isinstance(name, bytes)\n- return name\n+ if sh:\n+ command = (' '.join(shlex.quote(arg) for arg in command),)\n \n+ return command\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+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- 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+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- 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+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-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+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/__init__.py': br'''''',\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- # 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+ 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/bei/data/beipack_loader.py': br'''# beipack https://github.com/allisonkarlitskaya/beipack\n \n- class Annotated(metaclass=AnnotatedMeta):\n- pass\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- 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+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- try:\n- from typing import ForwardRef\n- except ImportError:\n- from typing import _ForwardRef as ForwardRef\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- try:\n- from typing import TypeGuard\n- except ImportError:\n- T = typing.TypeVar('T')\n+ def is_resource(self, resource: str) -> bool:\n+ return f'{self._dir}{resource}' in self._contents\n \n- class TypeGuard(typing.Generic[T]):\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-__all__ = (\n- 'Annotated',\n- 'ForwardRef',\n- 'TypeGuard',\n- 'get_args',\n- 'get_origin',\n- 'TYPE_CHECKING',\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/systemd_ctypes/bus.py': br'''# systemd_ctypes\n #\n # Copyright (C) 2022 Allison Karlitskaya \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@@ -8186,1144 +7850,1076 @@\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/ferny/askpass.py': br'''from .interaction_client import main\n-\n-if __name__ == '__main__':\n- main()\n-''',\n- 'cockpit/_vendor/ferny/transport.py': br'''# ferny - asyncio SSH client library, using ssh(1)\n+ 'cockpit/_vendor/systemd_ctypes/introspection.py': br'''# systemd_ctypes\n #\n-# Copyright (C) 2023 Allison Karlitskaya \n+# Copyright (C) 2022 Allison Karlitskaya \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 .\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-\n-\n-class SubprocessError(Exception):\n- returncode: int\n- stderr: str\n-\n- def __init__(self, returncode: int, stderr: str) -> None:\n- super().__init__(returncode, stderr)\n- self.returncode = returncode\n- self.stderr = stderr\n+import xml.etree.ElementTree as ET\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+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- # 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+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- @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+def parse_signal(signal):\n+ return {\"in\": [tag.attrib['type'] for tag in signal.findall(\"arg\")]}\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+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- 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+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- 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+# 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- :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+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- 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+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- # 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+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- # 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+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- self._exec_task.add_done_callback(exec_completed)\n \n- return self, protocol\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/pathwatch.py': br'''# systemd_ctypes\n+#\n+# Copyright (C) 2022 Allison Karlitskaya \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 .\n \n- def __init__(self, protocol: asyncio.Protocol) -> None:\n- self._protocol = protocol\n+import errno\n+import logging\n+import os\n+import stat\n+from typing import Any, List, Optional\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+from .event import Event\n+from .inotify import Event as IN\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+logger = logging.getLogger(__name__)\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+# 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- # 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+class Handle(int):\n+ \"\"\"An integer subclass that makes it easier to work with file descriptors\"\"\"\n \n- self._consider_disconnect()\n+ def __new__(cls, fd: int = -1) -> 'Handle':\n+ return super(Handle, cls).__new__(cls, fd)\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+ # 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- stdin_transport = transport.get_pipe_transport(0)\n- assert isinstance(stdin_transport, asyncio.WriteTransport)\n- self._stdin_transport = stdin_transport\n+ def __bool__(self) -> bool:\n+ return self != -1\n \n- stdout_transport = transport.get_pipe_transport(1)\n- assert isinstance(stdout_transport, asyncio.ReadTransport)\n- self._stdout_transport = stdout_transport\n+ def close(self) -> None:\n+ if self._needs_close:\n+ self._needs_close = False\n+ os.close(self)\n \n- stderr_transport = transport.get_pipe_transport(2)\n- assert stderr_transport is None\n+ def __eq__(self, value: object) -> bool:\n+ if int.__eq__(self, value): # also handles both == -1\n+ return True\n \n- logger.debug('calling connection_made(%r, %r)', self, self._protocol)\n- self._protocol.connection_made(self)\n+ if not isinstance(value, int): # other object is not an int\n+ return False\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+ if not self or not value: # when only one == -1\n+ return False\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+ return os.path.sameopenfile(self, value)\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+ def __del__(self) -> None:\n+ if self._needs_close:\n+ self.close()\n \n- # We treat this as a clean close\n- if isinstance(exc, BrokenPipeError):\n- exc = None\n+ def __enter__(self) -> 'Handle':\n+ return self\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+ def __exit__(self, _type: type, _value: object, _traceback: object) -> None:\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+ @classmethod\n+ def open(cls, *args: Any, **kwargs: Any) -> 'Handle':\n+ return cls(os.open(*args, **kwargs))\n \n- def pause_writing(self) -> None:\n- logger.debug('pause_writing(%r)', self)\n- self._protocol.pause_writing()\n+ def steal(self) -> 'Handle':\n+ self._needs_close = False\n+ return self.__class__(int(self))\n \n- def resume_writing(self) -> None:\n- logger.debug('resume_writing(%r)', self)\n- self._protocol.resume_writing()\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+class WatchInvalidator:\n+ _name: bytes\n+ _source: Optional[Event.Source]\n+ _watch: Optional['PathWatch']\n \n- def is_closing(self) -> bool:\n- assert self._subprocess_transport is not None\n- return self._subprocess_transport.is_closing()\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 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+ def __init__(self, watch: 'PathWatch', event: Event, dirfd: int, name: str):\n+ self._watch = watch\n+ self._name = name.encode('utf-8')\n \n- def set_protocol(self, protocol: asyncio.BaseProtocol) -> None:\n- assert isinstance(protocol, asyncio.Protocol)\n- self._protocol = protocol\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 get_protocol(self) -> asyncio.Protocol:\n- return self._protocol\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- 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 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 resume_reading(self) -> None:\n- assert self._stdout_transport is not None\n- self._stdout_transport.resume_reading()\n+ def __init__(self, path: str):\n+ super().__init__()\n+ self.add_path(path)\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 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+class Listener:\n+ def do_inotify_event(self, mask: IN, cookie: int, name: Optional[bytes]) -> None:\n+ raise NotImplementedError\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+ def do_identity_changed(self, fd: Optional[Handle], errno: Optional[int]) -> None:\n+ raise NotImplementedError\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 \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+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 write(self, data: bytes) -> None:\n- assert self._stdin_transport is not None\n- return self._stdin_transport.write(data)\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- 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+ self._invalidators = []\n+ self._errno = None\n+ self._source = None\n+ self._tag = None\n+ self._fd = Handle()\n \n- def write_eof(self) -> None:\n- assert self._stdin_transport is not None\n- return self._stdin_transport.write_eof()\n+ self.invalidate()\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+ 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 get_returncode(self) -> 'int | None':\n- return self._returncode\n+ def invalidate(self) -> None:\n+ for invalidator in self._invalidators:\n+ invalidator.close()\n+ self._invalidators = []\n \n- def kill(self) -> None:\n- assert self._subprocess_transport is not None\n- self._subprocess_transport.kill()\n+ try:\n+ fd = self.walk()\n+ except OSError as error:\n+ logger.debug('walk ended in error %d', error.errno)\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+ 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- def terminate(self) -> None:\n- assert self._subprocess_transport is not None\n- self._subprocess_transport.terminate()\n-''',\n- 'cockpit/_vendor/ferny/interaction_client.py': br'''#!/usr/bin/python3\n+ logger.debug('Notifying of new error state %d', self._errno)\n+ self._listener.do_identity_changed(None, self._errno)\n \n-import array\n-import io\n-import os\n-import socket\n-import sys\n-from typing import Sequence\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-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+ 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- 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+ 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- cmd_write.write(repr((command, args)))\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-def askpass(stderr_fd: int, stdout_fd: int, args: 'list[str]', env: 'dict[str, str]') -> int:\n- ours, theirs = socket.socketpair()\n+ while remaining_components:\n+ logger.debug('r=%s dfd=%s', remaining_components, dirfd)\n \n- with theirs:\n- command(stderr_fd, 'ferny.askpass', args, env, fds=(theirs.fileno(), stdout_fd))\n+ name = remaining_components.pop()\n \n- with ours:\n- return int(ours.recv(16) or b'1')\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-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+ 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-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- temporary_askpass,\n- write_askpass_to_tmpdir,\n-)\n-from .session import Session\n-from .ssh_askpass import (\n- AskpassPrompt,\n- SshAskpassResponder,\n- SshFIDOPINPrompt,\n- SshFIDOUserPresencePrompt,\n- SshHostKeyPrompt,\n- SshPassphrasePrompt,\n- SshPasswordPrompt,\n- SshPKCS11PINPrompt,\n-)\n-from .ssh_errors import (\n- SshAuthenticationError,\n- SshChangedHostKeyError,\n- SshError,\n- SshHostKeyError,\n- SshUnknownHostKeyError,\n-)\n-from .transport import FernyTransport, SubprocessError\n+ return dirfd.steal()\n \n-__all__ = [\n- 'AskpassHandler',\n- 'AskpassPrompt',\n- 'AuthenticationError',\n- 'BEIBOOT_GADGETS',\n- 'COMMAND_TEMPLATE',\n- 'ChangedHostKeyError',\n- 'FernyTransport',\n- 'HostKeyError',\n- 'InteractionAgent',\n- 'InteractionError',\n- 'InteractionHandler',\n- 'Session',\n- 'SshAskpassResponder',\n- 'SshAuthenticationError',\n- 'SshChangedHostKeyError',\n- 'SshError',\n- 'SshFIDOPINPrompt',\n- 'SshFIDOUserPresencePrompt',\n- 'SshHostKeyError',\n- 'SshHostKeyPrompt',\n- 'SshPKCS11PINPrompt',\n- 'SshPassphrasePrompt',\n- 'SshPasswordPrompt',\n- 'SshUnknownHostKeyError',\n- 'SubprocessError',\n- 'temporary_askpass',\n- 'write_askpass_to_tmpdir',\n-]\n+ finally:\n+ dirfd.close()\n \n-__version__ = '0'\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/ferny/py.typed': br'''''',\n- 'cockpit/_vendor/ferny/interaction_agent.py': r'''# ferny - asyncio SSH client library, using ssh(1)\n+ 'cockpit/_vendor/systemd_ctypes/py.typed': br'''''',\n+ 'cockpit/_vendor/systemd_ctypes/libsystemd.py': r'''# systemd_ctypes\n #\n-# Copyright (C) 2023 Allison Karlitskaya \n+# Copyright (C) 2022 Allison Karlitskaya \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 .\n \n-import array\n-import ast\n-import asyncio\n-import contextlib\n-import logging\n+import ctypes\n import os\n-import re\n-import socket\n-import tempfile\n-from typing import Any, Callable, ClassVar, Generator, Sequence\n+import sys\n+from typing import ClassVar, List, Optional, Tuple, Union\n \n-from . import interaction_client\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-logger = logging.getLogger(__name__)\n \n+class Trampoline(ReferenceType):\n+ deferred: 'ClassVar[list[Callback] | None]' = None\n+ trampoline: Callback\n+ userdata: UserData = None\n \n-COMMAND_RE = re.compile(b'\\0ferny\\0([^\\n]*)\\0\\0\\n')\n-COMMAND_TEMPLATE = '\\0ferny\\0{(command, args)!r}\\0\\0\\n'\n+ def cancel(self) -> None:\n+ self._unref()\n+ self.value = None\n \n-BEIBOOT_GADGETS = {\n- \"command\": fr\"\"\"\n- import sys\n- def command(command, *args):\n- sys.stderr.write(f{COMMAND_TEMPLATE!r})\n- sys.stderr.flush()\n- \"\"\",\n- \"end\": r\"\"\"\n- def end():\n- command('ferny.end')\n- \"\"\",\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 InteractionError(Exception):\n- pass\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-try:\n- recv_fds = socket.recv_fds\n-except AttributeError:\n- # Python < 3.9\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 recv_fds(\n- sock: socket.socket, bufsize: int, maxfds: int, flags: int = 0\n- ) -> 'tuple[bytes, list[int], int, None]':\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+ def __del__(self) -> None:\n+ if self._b_needsfree_:\n+ libsystemd.sd_bus_error_free(byref(self))\n \n \n-def get_running_loop() -> asyncio.AbstractEventLoop:\n- try:\n- return asyncio.get_running_loop()\n- except AttributeError:\n- # Python 3.6\n- return asyncio.get_event_loop()\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 InteractionHandler:\n- commands: ClassVar[Sequence[str]]\n+class sd_event_source(Trampoline):\n+ ...\n \n- async def run_command(self, command: str, args: 'tuple[object, ...]', fds: 'list[int]', stderr: str) -> None:\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-class AskpassHandler(InteractionHandler):\n- commands: ClassVar[Sequence[str]] = ('ferny.askpass',)\n+ def loop(self: 'sd_event') -> Union[None, Errno]:\n+ ...\n \n- async def do_askpass(self, messages: str, prompt: str, hint: str) -> 'str | None':\n- \"\"\"Prompt the user for an authentication or confirmation interaction.\n+ def prepare(self: 'sd_event') -> Union[None, Errno]:\n+ ...\n \n- 'messages' is data that was sent to stderr before the interaction was requested.\n- 'prompt' is the interaction prompt.\n+ def wait(\n+ self: 'sd_event', timeout: Annotated[int, ctypes.c_uint64]\n+ ) -> Union[None, Errno]:\n+ ...\n \n- The expected response type depends on hint:\n+ @staticmethod\n+ def _default(ret: Reference['sd_event']) -> Union[None, Errno]:\n+ ...\n \n- - \"confirm\": ask for permission, returning \"yes\" if accepted\n- - example: authorizing agent operation\n \n- - \"none\": show a request without need for a response\n- - example: please touch your authentication token\n+class sd_bus_slot(Trampoline):\n+ ...\n \n- - otherwise: return a password or other form of text token\n- - examples: enter password, unlock private key\n \n- In any case, the function should properly handle cancellation. For the\n- \"none\" case, this will be the normal way to dismiss the dialog.\n- \"\"\"\n- return None\n+class sd_bus_message(ReferenceType):\n+ def rewind(self: 'sd_bus_message', complete: bool) -> Union[None, Errno]:\n+ ...\n \n- async def do_hostkey(self, reason: str, host: str, algorithm: str, key: str, fingerprint: str) -> bool:\n- \"\"\"Prompt the user for a decision regarding acceptance of a host key.\n+ def _get_error(self: 'sd_bus_message') -> Reference[sd_bus_error]:\n+ raise NotImplementedError\n \n- The \"reason\" will be either \"HOSTNAME\" or \"ADDRESS\" (if `CheckHostIP` is enabled).\n+ def has_signature(self: 'sd_bus_message', signature: str) -> Union[bool, Errno]:\n+ raise NotImplementedError\n \n- The host, algorithm, and key parameters are the values in the form that\n- they would appear one a single line in the known hosts file. The\n- fingerprint is the key fingerprint in the format that ssh would\n- normally present it to the user.\n+ def is_method_error(self: 'sd_bus_message', name: str) -> Union[bool, Errno]:\n+ raise NotImplementedError\n \n- In case the host key should be accepted, this function needs to return\n- True. Returning False means that ssh implements its default logic. To\n- interrupt the connection, raise an exception.\n- \"\"\"\n- return False\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- async def do_custom_command(\n- self, command: str, args: 'tuple[object, ...]', fds: 'list[int]', stderr: str\n- ) -> None:\n- \"\"\"Handle a custom command.\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- The command name, its arguments, the passed fds, and the stderr leading\n- up to the command invocation are all provided.\n+ def _new_method_return(\n+ self: 'sd_bus_message', m: Reference['sd_bus_message']\n+ ) -> Union[None, Errno]:\n+ ...\n \n- See doc/interaction-protocol.md\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- async def _askpass_command(self, args: 'tuple[object, ...]', fds: 'list[int]', stderr: str) -> None:\n- logger.debug('_askpass_command(%s, %s, %s)', args, fds, stderr)\n- try:\n- argv, env = args\n- assert isinstance(argv, list)\n- assert all(isinstance(arg, str) for arg in argv)\n- assert isinstance(env, dict)\n- assert all(isinstance(key, str) and isinstance(val, str) for key, val in env.items())\n- assert len(fds) == 2\n- except (ValueError, TypeError, AssertionError) as exc:\n- logger.error('Invalid arguments to askpass interaction: %s, %s: %s', args, fds, exc)\n- return\n+ def _get_bus(self: 'sd_bus_message') -> WeakReference:\n+ raise NotImplementedError\n \n- with open(fds.pop(0), 'w') as status, open(fds.pop(0), 'w') as stdout:\n- try:\n- loop = get_running_loop()\n- try:\n- task = asyncio.current_task()\n- except AttributeError:\n- task = asyncio.Task.current_task() # type:ignore[attr-defined] # (Python 3.6)\n- assert task is not None\n- loop.add_reader(status, task.cancel)\n+ def get_destination(self: 'sd_bus_message') -> str:\n+ raise NotImplementedError\n \n- if len(argv) == 2:\n- # normal askpass\n- prompt = argv[1]\n- hint = env.get('SSH_ASKPASS_PROMPT', '')\n- logger.debug('do_askpass(%r, %r, %r)', stderr, prompt, hint)\n- answer = await self.do_askpass(stderr, prompt, hint)\n- logger.debug('do_askpass answer %r', answer)\n- if answer is not None:\n- print(answer, file=stdout)\n- print(0, file=status)\n+ def get_interface(self: 'sd_bus_message') -> str:\n+ raise NotImplementedError\n \n- elif len(argv) == 6:\n- # KnownHostsCommand\n- argv0, reason, host, algorithm, key, fingerprint = argv\n- if reason in ['ADDRESS', 'HOSTNAME']:\n- logger.debug('do_hostkey(%r, %r, %r, %r, %r)', reason, host, algorithm, key, fingerprint)\n- if await self.do_hostkey(reason, host, algorithm, key, fingerprint):\n- print(host, algorithm, key, file=stdout)\n- else:\n- logger.debug('ignoring KnownHostsCommand reason %r', reason)\n+ def get_member(self: 'sd_bus_message') -> str:\n+ raise NotImplementedError\n \n- print(0, file=status)\n+ def get_path(self: 'sd_bus_message') -> str:\n+ raise NotImplementedError\n \n- else:\n- logger.error('Incorrect number of command-line arguments to ferny-askpass: %s', argv)\n- finally:\n- loop.remove_reader(status)\n+ def get_sender(self: 'sd_bus_message') -> Optional[str]:\n+ raise NotImplementedError\n \n- async def run_command(self, command: str, args: 'tuple[object, ...]', fds: 'list[int]', stderr: str) -> None:\n- logger.debug('run_command(%s, %s, %s, %s)', command, args, fds, stderr)\n- if command == 'ferny.askpass':\n- await self._askpass_command(args, fds, stderr)\n- else:\n- await self.do_custom_command(command, args, fds, stderr)\n+ def get_signature(self: 'sd_bus_message', complete: bool) -> str:\n+ raise NotImplementedError\n \n \n-class InteractionAgent:\n- _handlers: 'dict[str, InteractionHandler]'\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- _loop: asyncio.AbstractEventLoop\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- _tasks: 'set[asyncio.Task]'\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- _buffer: bytearray\n- _ours: socket.socket\n- _theirs: socket.socket\n+ def attach_event(\n+ self: 'sd_bus', event: Optional[sd_event], priority: int\n+ ) -> Union[None, Errno]:\n+ ...\n \n- _completion_future: 'asyncio.Future[str]'\n- _pending_result: 'None | str | Exception' = None\n- _end: bool = False\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 _consider_completion(self) -> None:\n- logger.debug('_consider_completion(%r)', self)\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- if self._pending_result is None or self._tasks:\n- logger.debug(' but not ready yet')\n+ def flush(self: 'sd_bus') -> Union[None, Errno]:\n+ ...\n \n- elif self._completion_future.done():\n- logger.debug(' but already complete')\n+ def get_fd(self: 'sd_bus') -> Union[int, Errno]:\n+ raise NotImplementedError\n \n- elif isinstance(self._pending_result, str):\n- logger.debug(' submitting stderr (%r) to completion_future', self._pending_result)\n- self._completion_future.set_result(self._pending_result)\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- else:\n- logger.debug(' submitting exception (%r) to completion_future')\n- self._completion_future.set_exception(self._pending_result)\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 _result(self, result: 'str | Exception') -> None:\n- logger.debug('_result(%r, %r)', self, result)\n+ def release_name(self: 'sd_bus', name: str) -> Union[None, Errno]:\n+ ...\n \n- if self._pending_result is None:\n- self._pending_result = result\n+ def request_name(\n+ self: 'sd_bus', name: str, flags: Annotated[int, ctypes.c_uint64]\n+ ) -> Union[None, Errno]:\n+ ...\n \n- if self._ours.fileno() != -1:\n- logger.debug(' remove_reader(%r)', self._ours)\n- self._loop.remove_reader(self._ours.fileno())\n+ def set_address(self: 'sd_bus', address: str) -> Union[None, Errno]:\n+ ...\n \n- for task in self._tasks:\n- logger.debug(' cancel(%r)', task)\n- task.cancel()\n+ def set_bus_client(self: 'sd_bus', b: bool) -> Union[None, Errno]:\n+ ...\n \n- logger.debug(' closing sockets')\n- self._theirs.close() # idempotent\n- self._ours.close()\n+ def set_fd(self: 'sd_bus', input_fd: int, output_fd: int) -> Union[None, Errno]:\n+ ...\n \n- self._consider_completion()\n+ def set_server(self: 'sd_bus', b: bool, bus_d: sd_id128) -> Union[None, Errno]:\n+ ...\n \n- def _invoke_command(self, stderr: bytes, command_blob: bytes, fds: 'list[int]') -> None:\n- logger.debug('_invoke_command(%r, %r, %r)', stderr, command_blob, fds)\n- try:\n- command, args = ast.literal_eval(command_blob.decode())\n- if not isinstance(command, str) or not isinstance(args, tuple):\n- raise TypeError('Invalid argument types')\n- except (UnicodeDecodeError, SyntaxError, ValueError, TypeError) as exc:\n- logger.error('Received invalid ferny command: %s: %s', command_blob, exc)\n- return\n+ def start(self: 'sd_bus') -> Union[None, Errno]:\n+ ...\n \n- if command == 'ferny.end':\n- self._end = True\n- self._result(self._buffer.decode(errors='replace'))\n- return\n+ def wait(\n+ self: 'sd_bus', timeout_usec: Annotated[int, ctypes.c_uint64]\n+ ) -> Union[None, Errno]:\n+ ...\n \n- try:\n- handler = self._handlers[command]\n- except KeyError:\n- logger.error('Received unhandled ferny command: %s', command)\n- return\n+ def send(\n+ self: 'sd_bus', message: sd_bus_message, cookie: Optional[Reference[ctypes.c_uint64]]\n+ ) -> Union[None, Errno]:\n+ ...\n \n- # The task is responsible for the list of fds and removing itself\n- # from the set.\n- task_fds = list(fds)\n- task = self._loop.create_task(handler.run_command(command, args, task_fds, stderr.decode()))\n+ @staticmethod\n+ def _default_system(ret: Reference['sd_bus']) -> Union[None, Errno]:\n+ ...\n \n- def bottom_half(completed_task: asyncio.Task) -> None:\n- assert completed_task is task\n- while task_fds:\n- os.close(task_fds.pop())\n- self._tasks.remove(task)\n+ @staticmethod\n+ def _default_user(ret: Reference['sd_bus']) -> Union[None, Errno]:\n+ ...\n \n- try:\n- task.result()\n- logger.debug('%r completed cleanly', handler)\n- except asyncio.CancelledError:\n- # this is not an error \u2014 it just means ferny-askpass exited via signal\n- logger.debug('%r was cancelled', handler)\n- except Exception as exc:\n- logger.debug('%r raised %r', handler, exc)\n- self._result(exc)\n+ @staticmethod\n+ def _new(ret: Reference['sd_bus']) -> Union[None, Errno]:\n+ ...\n \n- self._consider_completion()\n \n- task.add_done_callback(bottom_half)\n- self._tasks.add(task)\n- fds[:] = []\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- def _got_data(self, data: bytes, fds: 'list[int]') -> None:\n- logger.debug('_got_data(%r, %r)', data, fds)\n \n- if data == b'':\n- self._result(self._buffer.decode(errors='replace'))\n- return\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/inotify.py': br'''# systemd_ctypes\n+#\n+# Copyright (C) 2022 Allison Karlitskaya \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 .\n \n- self._buffer.extend(data)\n+import ctypes\n+from enum import IntFlag, auto\n+from typing import Optional\n \n- # Read zero or more \"remote\" messages\n- chunks = COMMAND_RE.split(self._buffer)\n- self._buffer = bytearray(chunks.pop())\n- while len(chunks) > 1:\n- self._invoke_command(chunks[0], chunks[1], [])\n- chunks = chunks[2:]\n \n- # Maybe read one \"local\" message\n- if fds:\n- assert self._buffer.endswith(b'\\0'), self._buffer\n- stderr = self._buffer[:-1]\n- self._buffer = bytearray(b'')\n- with open(fds.pop(0), 'rb') as command_channel:\n- command = command_channel.read()\n- self._invoke_command(stderr, command, fds)\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- def _read_ready(self) -> None:\n- try:\n- data, fds, _flags, _addr = recv_fds(self._ours, 4096, 10, flags=socket.MSG_DONTWAIT)\n- except BlockingIOError:\n- return\n- except OSError as exc:\n- self._result(exc)\n- else:\n- self._got_data(data, fds)\n- finally:\n- while fds:\n- os.close(fds.pop())\n+ @property\n+ def name(self) -> Optional[bytes]:\n+ if self.len == 0:\n+ return None\n \n- def __init__(\n- self,\n- handlers: Sequence[InteractionHandler],\n- loop: 'asyncio.AbstractEventLoop | None' = None,\n- done_callback: 'Callable[[asyncio.Future[str]], None] | None' = None,\n- ) -> None:\n- self._loop = loop or get_running_loop()\n- self._completion_future = self._loop.create_future()\n- self._tasks = set()\n- self._handlers = {}\n+ class event_with_name(ctypes.Structure):\n+ _fields_ = (*inotify_event._fields_, ('name', ctypes.c_char * self.len))\n \n- for handler in handlers:\n- for command in handler.commands:\n- self._handlers[command] = handler\n+ name = ctypes.cast(ctypes.addressof(self), ctypes.POINTER(event_with_name)).contents.name\n+ assert isinstance(name, bytes)\n+ return name\n \n- if done_callback is not None:\n- self._completion_future.add_done_callback(done_callback)\n \n- self._theirs, self._ours = socket.socketpair(socket.AF_UNIX, socket.SOCK_STREAM)\n- self._buffer = bytearray()\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- def fileno(self) -> int:\n- return self._theirs.fileno()\n+ UNMOUNT = 1 << 13\n+ Q_OVERFLOW = auto()\n+ IGNORED = auto()\n \n- def start(self) -> None:\n- logger.debug('start(%r)', self)\n- if self._ours.fileno() != -1:\n- logger.debug(' add_reader(%r)', self._ours)\n- self._loop.add_reader(self._ours.fileno(), self._read_ready)\n- else:\n- logger.debug(' ...but agent is already finished.')\n+ ONLYDIR = 1 << 24\n+ DONT_FOLLOW = auto()\n+ EXCL_UNLINK = auto()\n \n- logger.debug(' close(%r)', self._theirs)\n- self._theirs.close()\n+ MASK_CREATE = 1 << 28\n+ MASK_ADD = auto()\n+ ISDIR = auto()\n+ ONESHOT = auto()\n \n- def force_completion(self) -> None:\n- logger.debug('force_completion(%r)', self)\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/librarywrapper.py': br'''# systemd_ctypes\n+#\n+# Copyright (C) 2022 Allison Karlitskaya \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 .\n \n- # read any residual data on stderr, but don't process commands, and\n- # don't block\n- try:\n- if self._ours.fileno() != -1:\n- logger.debug(' draining pending stderr data (non-blocking)')\n- with contextlib.suppress(BlockingIOError):\n- while True:\n- data = self._ours.recv(4096, socket.MSG_DONTWAIT)\n- logger.debug(' got %d bytes', len(data))\n- if not data:\n- break\n- self._buffer.extend(data)\n- except OSError as exc:\n- self._result(exc)\n- else:\n- self._result(self._buffer.decode(errors='replace'))\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- async def communicate(self) -> None:\n- logger.debug('_communicate(%r)', self)\n- try:\n- self.start()\n- # We assume that we are the only ones to write to\n- # self._completion_future. If we directly await it, though, it can\n- # also have a asyncio.CancelledError posted to it from outside.\n- # Shield it to prevent that from happening.\n- stderr = await asyncio.shield(self._completion_future)\n- logger.debug('_communicate(%r) stderr result is %r', self, stderr)\n- finally:\n- logger.debug('_communicate finished. Ensuring completion.')\n- self.force_completion()\n- if not self._end:\n- logger.debug('_communicate never saw ferny.end. raising InteractionError.')\n- raise InteractionError(stderr.strip())\n+from . import typing\n \n+# First in 3.10, and conditional import gives type errors\n+NoneType = type(None)\n \n-def write_askpass_to_tmpdir(tmpdir: str) -> str:\n- askpass_path = os.path.join(tmpdir, 'ferny-askpass')\n- fd = os.open(askpass_path, os.O_CREAT | os.O_WRONLY | os.O_CLOEXEC | os.O_EXCL | os.O_NOFOLLOW, 0o777)\n- try:\n- os.write(fd, __loader__.get_data(interaction_client.__file__)) # type: ignore\n- finally:\n- os.close(fd)\n- return askpass_path\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-@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/ssh_askpass.py': br'''import logging\n-import re\n-from typing import ClassVar, Match, Sequence\n \n-from .interaction_agent import AskpassHandler\n+if typing.TYPE_CHECKING:\n+ class Reference(Generic[CType], ctypes._Pointer[CType]):\n+ pass\n \n-logger = logging.getLogger(__name__)\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-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+UserData = Optional[ctypes.c_void_p]\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+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- def close(self) -> None:\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+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- async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n- return await responder.do_prompt(self)\n+ @classmethod\n+ def from_param(cls, value: str) -> 'utf8':\n+ return cls(value.encode())\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+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- # 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+ @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- 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- 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+class boolint(ctypes.c_int):\n+ def errcheck(self, func: Callable[..., object], _args: Tuple[object, ...]) -> bool:\n+ return bool(self.value)\n \n \n-# Specific prompts\n-HELPERS = {\n- \"%{algorithm}\": r\"(?P\\b[-\\w]+\\b)\",\n- \"%{filename}\": r\"(?P.+)\",\n- \"%{fingerprint}\": r\"(?PSHA256:[0-9A-Za-z+/]{43})\",\n- \"%{hostname}\": r\"(?P[^ @']+)\",\n- \"%{pkcs11_id}\": r\"(?P.+)\",\n- \"%{username}\": r\"(?P[^ @']+)\",\n-}\n+WeakReference = NewType(\"WeakReference\", int)\n+Errno = typing.Annotated[NoReturn, \"errno\"]\n \n \n-class SshPasswordPrompt(SSHAskpassPrompt):\n- _pattern = r\"%{username}@%{hostname}'s password: \"\n- username: 'str | None' = None\n- hostname: 'str | None' = None\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- async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n- return await responder.do_password_prompt(self)\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-class SshPassphrasePrompt(SSHAskpassPrompt):\n- _pattern = r\"Enter passphrase for key '%{filename}': \"\n- filename: str\n+ if isinstance(annotation, typing.ForwardRef):\n+ annotation = annotation.__forward_arg__\n \n- async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n- return await responder.do_passphrase_prompt(self)\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-class SshFIDOPINPrompt(SSHAskpassPrompt):\n- _pattern = r\"Enter PIN for %{algorithm} key %{filename}: \"\n- algorithm: str\n- filename: str\n+ if origin is Reference:\n+ return ctypes.POINTER(map_type(args[0], global_vars))\n \n- async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n- return await responder.do_fido_pin_prompt(self)\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-class SshFIDOUserPresencePrompt(SSHAskpassPrompt):\n- _pattern = r\"Confirm user presence for key %{algorithm} %{fingerprint}\"\n- answers = ()\n- algorithm: str\n- fingerprint: str\n+ else:\n+ assert origin is None, origin\n+ return annotation\n \n- async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n- return await responder.do_fido_user_presence_prompt(self)\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-class SshPKCS11PINPrompt(SSHAskpassPrompt):\n- _pattern = r\"Enter PIN for '%{pkcs11_id}': \"\n- pkcs11_id: str\n+ cls._wrap(cdll, cls._ref)\n+ cls._wrap(cdll, cls._unref)\n \n- async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n- return await responder.do_pkcs11_pin_prompt(self)\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-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+ logger.debug(' create wrapper %s.%s%s', cls.__name__, name, signature)\n+ logger.debug(' args %s res %s', func.argtypes, func.restype)\n \n- async def dispatch(self, responder: 'SshAskpassResponder') -> 'str | None':\n- return await responder.do_host_key_prompt(self)\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 with_helpers(pattern: str) -> str:\n- for name, helper in HELPERS.items():\n- pattern = pattern.replace(name, helper)\n+ def _ref(self: 'ReferenceType') -> None:\n+ ...\n \n- assert '%{' not in pattern\n- return pattern\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 categorize_ssh_prompt(string: str, stderr: str) -> AskpassPrompt:\n- classes = [\n- SshFIDOPINPrompt,\n- SshFIDOUserPresencePrompt,\n- SshHostKeyPrompt,\n- SshPKCS11PINPrompt,\n- SshPassphrasePrompt,\n- SshPasswordPrompt,\n- ]\n+ def __del__(self) -> None:\n+ if self.value is not None:\n+ self._unref()\n+''',\n+ 'cockpit/_vendor/systemd_ctypes/typing.py': br'''import typing\n+from typing import TYPE_CHECKING\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+# 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- 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 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 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+ class Annotated(metaclass=AnnotatedMeta):\n+ pass\n \n- async def do_prompt(self, prompt: AskpassPrompt) -> 'str | None':\n- # Default fallback for unrecognised message types: unimplemented\n- return None\n+ def get_args(annotation: typing.Any) -> typing.Tuple[typing.Any]:\n+ return getattr(annotation, '__args__', ())\n \n- async def do_fido_pin_prompt(self, prompt: SshFIDOPINPrompt) -> 'str | None':\n- return await self.do_prompt(prompt)\n+ def get_origin(annotation: typing.Any) -> typing.Any:\n+ return getattr(annotation, '__origin__', None)\n \n- async def do_fido_user_presence_prompt(self, prompt: SshFIDOUserPresencePrompt) -> 'str | None':\n- return await self.do_prompt(prompt)\n+ try:\n+ from typing import ForwardRef\n+ except ImportError:\n+ from typing import _ForwardRef as ForwardRef\n \n- async def do_host_key_prompt(self, prompt: SshHostKeyPrompt) -> 'str | None':\n- return await self.do_prompt(prompt)\n+ try:\n+ from typing import TypeGuard\n+ except ImportError:\n+ T = typing.TypeVar('T')\n \n- async def do_pkcs11_pin_prompt(self, prompt: SshPKCS11PINPrompt) -> 'str | None':\n- return await self.do_prompt(prompt)\n+ class TypeGuard(typing.Generic[T]):\n+ pass\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+__all__ = (\n+ 'Annotated',\n+ 'ForwardRef',\n+ 'TypeGuard',\n+ 'get_args',\n+ 'get_origin',\n+ 'TYPE_CHECKING',\n+)\n ''',\n- 'cockpit/_vendor/ferny/session.py': r'''# ferny - asyncio SSH client library, using ssh(1)\n+ 'cockpit/_vendor/systemd_ctypes/__init__.py': br'''# systemd_ctypes\n #\n # Copyright (C) 2022 Allison Karlitskaya \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@@ -9332,197 +8928,177 @@\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 .\n \n-import asyncio\n-import ctypes\n-import functools\n-import logging\n-import os\n-import shlex\n-import signal\n-import subprocess\n-import tempfile\n-from typing import Mapping, Sequence\n-\n-from . import ssh_errors\n-from .interaction_agent import InteractionAgent, InteractionError, InteractionHandler, write_askpass_to_tmpdir\n-\n-prctl = ctypes.cdll.LoadLibrary('libc.so.6').prctl\n-logger = logging.getLogger(__name__)\n-PR_SET_PDEATHSIG = 1\n+\"\"\"systemd_ctypes\"\"\"\n \n+__version__ = \"0\"\n \n-@functools.lru_cache()\n-def has_feature(feature: str, teststr: str = 'x') -> bool:\n- try:\n- subprocess.check_output(['ssh', f'-o{feature} {teststr}', '-G', 'nonexisting'], stderr=subprocess.DEVNULL)\n- return True\n- except subprocess.CalledProcessError:\n- return False\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+__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/event.py': br'''# systemd_ctypes\n+#\n+# Copyright (C) 2022 Allison Karlitskaya \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 .\n \n-class SubprocessContext:\n- def wrap_subprocess_args(self, args: Sequence[str]) -> Sequence[str]:\n- \"\"\"Return the args required to launch a process in the given context.\n+import asyncio\n+import selectors\n+import sys\n+from typing import Callable, ClassVar, Coroutine, List, Optional, Tuple\n \n- For example, this might return a vector with\n- [\"sudo\"]\n- or\n- [\"flatpak-spawn\", \"--host\"]\n- prepended.\n+from . import inotify, libsystemd\n+from .librarywrapper import Reference, UserData, byref\n \n- It is also possible that more substantial changes may be performed.\n \n- This function is not permitted to modify its argument, although it may\n- (optionally) return it unmodified, if no changes are required.\n- \"\"\"\n- return args\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- def wrap_subprocess_env(self, env: Mapping[str, str]) -> Mapping[str, str]:\n- \"\"\"Return the envp required to launch a process in the given context.\n+ _default_instance: ClassVar[Optional['Event']] = None\n \n- For example, this might set the \"SUDO_ASKPASS\" environment variable, if\n- needed.\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- As with wrap_subprocess_args(), this function is not permitted to\n- modify its argument, although it may (optionally) return it unmodified\n- if no changes are required.\n- \"\"\"\n- return env\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-class Session(SubprocessContext, InteractionHandler):\n- # Set after .connect() called, even if failed\n- _controldir: 'tempfile.TemporaryDirectory | None' = None\n- _controlsock: 'str | None' = None\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- # Set if connected, else None\n- _process: 'asyncio.subprocess.Process | None' = None\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- async def connect(self,\n- destination: str,\n- handle_host_key: bool = False,\n- configfile: 'str | None' = None,\n- identity_file: 'str | None' = None,\n- login_name: 'str | None' = None,\n- options: 'Mapping[str, str] | None' = None,\n- pkcs11: 'str | None' = None,\n- port: 'int | None' = None,\n- interaction_responder: 'InteractionHandler | None' = None) -> None:\n- rundir = os.path.join(os.environ.get('XDG_RUNTIME_DIR', '/run'), 'ferny')\n- os.makedirs(rundir, exist_ok=True)\n- self._controldir = tempfile.TemporaryDirectory(dir=rundir)\n- self._controlsock = f'{self._controldir.name}/socket'\n \n- # In general, we can't guarantee an accessible and executable version\n- # of this file, but since it's small and we're making a temporary\n- # directory anyway, let's just copy it into place and use it from\n- # there.\n- askpass_path = write_askpass_to_tmpdir(self._controldir.name)\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- env = dict(os.environ)\n- env['SSH_ASKPASS'] = askpass_path\n- env['SSH_ASKPASS_REQUIRE'] = 'force'\n- # old SSH doesn't understand SSH_ASKPASS_REQUIRE and guesses based on DISPLAY instead\n- env['DISPLAY'] = '-'\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- args = [\n- '-M',\n- '-N',\n- '-S', self._controlsock,\n- '-o', 'PermitLocalCommand=yes',\n- '-o', f'LocalCommand={askpass_path}',\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- if configfile is not None:\n- args.append(f'-F{configfile}')\n+ # We can be sure we're not dispatching callbacks anymore\n+ libsystemd.Trampoline.deferred = None\n \n- if identity_file is not None:\n- args.append(f'-i{identity_file}')\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- if options is not None:\n- for key in options: # Note: Mapping may not have .items()\n- args.append(f'-o{key} {options[key]}')\n \n- if pkcs11 is not None:\n- args.append(f'-I{pkcs11}')\n+class EventLoopPolicy(asyncio.DefaultEventLoopPolicy):\n+ def new_event_loop(self) -> asyncio.AbstractEventLoop:\n+ return asyncio.SelectorEventLoop(Selector())\n \n- if port is not None:\n- args.append(f'-p{port}')\n \n- if login_name is not None:\n- args.append(f'-l{login_name}')\n+def run_async(main: Coroutine[None, None, None], debug: Optional[bool] = None) -> None:\n+ asyncio.set_event_loop_policy(EventLoopPolicy())\n \n- if handle_host_key and has_feature('KnownHostsCommand'):\n- args.extend([\n- '-o', f'KnownHostsCommand={askpass_path} %I %H %t %K %f',\n- '-o', 'StrictHostKeyChecking=yes',\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- agent = InteractionAgent([interaction_responder] if interaction_responder is not None else [])\n+ assert not hasattr(asyncio, 'get_running_loop')\n+ asyncio.get_running_loop = lambda: loop\n \n- # SSH_ASKPASS_REQUIRE is not generally available, so use setsid\n- process = await asyncio.create_subprocess_exec(\n- *('/usr/bin/ssh', *args, destination), env=env,\n- start_new_session=True, stdin=asyncio.subprocess.DEVNULL,\n- stdout=asyncio.subprocess.DEVNULL, stderr=agent, # type: ignore\n- preexec_fn=lambda: prctl(PR_SET_PDEATHSIG, signal.SIGKILL))\n+ assert not hasattr(asyncio, 'create_task')\n+ asyncio.create_task = loop.create_task\n \n- # This is tricky: we need to clean up the subprocess, but only in case\n- # if failure. Otherwise, we keep it around.\n- try:\n- await agent.communicate()\n- assert os.path.exists(self._controlsock)\n- self._process = process\n- except InteractionError as exc:\n- await process.wait()\n- raise ssh_errors.get_exception_for_ssh_stderr(str(exc)) from None\n- except BaseException:\n- # If we get here because the InteractionHandler raised an\n- # exception then SSH might still be running, and may even attempt\n- # further interactions (ie: 2nd attempt for password). We already\n- # have our exception and don't need any more info. Kill it.\n- try:\n- process.kill()\n- except ProcessLookupError:\n- pass # already exited? good.\n- await process.wait()\n- raise\n+ assert not hasattr(asyncio, 'run')\n \n- def is_connected(self) -> bool:\n- return self._process is not None\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- async def wait(self) -> None:\n- assert self._process is not None\n- await self._process.wait()\n+ asyncio.run = run # type: ignore[assignment]\n \n- def exit(self) -> None:\n- assert self._process is not None\n- self._process.terminate()\n+ asyncio._systemd_ctypes_polyfills = True # type: ignore[attr-defined]\n \n- async def disconnect(self) -> None:\n- self.exit()\n- await self.wait()\n+ asyncio.run(main, debug=debug)\n \n- # Launching of processes\n- def wrap_subprocess_args(self, args: Sequence[str]) -> Sequence[str]:\n- assert self._controlsock is not None\n- # 1. We specify the hostname as the empty string: it will be ignored\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/ssh_errors.py': br'''# ferny - asyncio SSH client library, using ssh(1)\n+ if polyfill:\n+ del asyncio.create_task, asyncio.get_running_loop, asyncio.run\n+''',\n+ 'cockpit/_vendor/systemd_ctypes/bustypes.py': br'''# systemd_ctypes\n #\n # Copyright (C) 2023 Allison Karlitskaya \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@@ -9531,124 +9107,548 @@\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 .\n \n+\n+# This file is responsible for creating functions to (de)serialize Python\n+# objects into and out of BusMessage objects.\n+#\n+# Each Type corresponds to a (possibly complex) D-Bus type. It has a .reader\n+# and a .writer property. The readers take a message and deserialize a single\n+# value from it, returning the value:\n+#\n+# def reader(message: BusMessage) -> object:\n+#\n+# The writers take a message and a value, and append the value to the message.\n+#\n+# def writer(message: BusMessage, value: object) -> None:\n+#\n+# The necessary information for the specific type of object to be handled is\n+# part of the function. No additional information needs to be provided.\n+\n+import binascii\n import ctypes\n-import errno\n-import os\n+import functools\n+import inspect\n+import json\n import re\n-import socket\n-from typing import ClassVar, Iterable, Match, Pattern\n+from enum import Enum\n+from typing import Any, Callable, ClassVar, Dict, Iterable, List, Optional, Sequence, Tuple, TypeVar, Union\n \n+from . import libsystemd, typing\n+from .typing import Annotated, TypeGuard\n \n-class SshError(Exception):\n- PATTERN: ClassVar[Pattern]\n+_object_path_re = re.compile(r'/|(/[A-Za-z0-9_]+)+')\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- self.stderr = stderr\n \n+def is_object_path(candidate: str) -> TypeGuard['BusType.objectpath']:\n+ return _object_path_re.fullmatch(candidate) is not None\n \n-class SshAuthenticationError(SshError):\n- PATTERN = re.compile(r'^([^:]+): Permission denied \\(([^()]+)\\)\\.$', re.M)\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+def is_signature(candidate: str) -> TypeGuard['BusType.signature']:\n+ offset = 0\n+\n+ def maybe_pop(acceptable: str) -> Optional[str]:\n+ nonlocal offset\n+ char = candidate[offset]\n+ if char in acceptable:\n+ offset += 1\n+ return char\n+ else:\n+ return None\n \n+ def pop(acceptable: str) -> str:\n+ char = maybe_pop(acceptable)\n+ assert char is not None\n+ return char\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+ def find_next() -> None:\n+ first = pop('ybnqiuxtsogdva(') # valid first characters\n+ if first == 'a':\n+ if maybe_pop('{'): # dict\n+ pop('ybnqiuxtsogd') # key\n+ find_next() # value\n+ pop('}')\n+ else: # array\n+ find_next() # item\n+ elif first == '(': # structure\n+ find_next() # at least one item\n+ while not maybe_pop(')'):\n+ find_next() # and possibly more\n \n+ try:\n+ while offset < len(candidate):\n+ find_next()\n+ return True\n+ except (AssertionError, IndexError):\n+ return False\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 \n+def yield_base_helpers() -> Iterable[Tuple[str, object]]:\n+ for method in ['enter_container', 'exit_container', 'open_container', 'close_container',\n+ 'append_basic', 'read_basic', 'append_array', 'read_array']:\n+ yield method, libsystemd.libsystemd[f'sd_bus_message_{method}']\n \n-class SshChangedHostKeyError(SshHostKeyError):\n- PATTERN = re.compile(r'warning.*remote host identification has changed', re.I)\n+ for name in ['size_t', 'char_p']:\n+ instance = getattr(ctypes, f'c_{name}')()\n+ yield f'{name}', instance\n+ yield f'{name}_ref', ctypes.byref(instance)\n+ yield f'{name}_setter', instance.__class__.value.__set__\n \n+ for char in 'aervy':\n+ yield char, ctypes.c_char(ord(char))\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+ # https://docs.python.org/3/c-api/unicode.html#c.PyUnicode_FromString\n+ to_bytes = ctypes.pythonapi.PyBytes_FromStringAndSize\n+ to_bytes.restype = ctypes.py_object\n+ yield 'to_bytes', to_bytes\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+_base_helpers = dict(yield_base_helpers())\n \n-gaierror_map = dict(make_gaierror_map())\n+T = TypeVar('T')\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+def call_with_kwargs(func: Callable[..., T], kwargs: Dict[str, Any]) -> T:\n+ parameters = set(inspect.signature(func).parameters)\n+ return func(**{key: value for key, value in kwargs.items() if key in parameters})\n \n \n-def get_exception_for_ssh_stderr(stderr: str) -> Exception:\n- stderr = stderr.replace('\\r\\n', '\\n') # fix line separators\n+class Type:\n+ _cache: ClassVar[Dict[Tuple[type, Tuple[object, ...]], 'Type']] = {}\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- if match is not None:\n- return ssh_cls(match, stderr)\n+ __slots__ = 'typestring', 'bytes_typestring', 'writer', 'reader'\n+ typestring: str\n+ bytes_typestring: bytes\n+ reader: Callable[[libsystemd.sd_bus_message], object]\n+ writer: Callable[[libsystemd.sd_bus_message, object], None]\n \n- before, colon, after = stderr.rpartition(':')\n- if colon and after:\n- potential_strerror = after.strip()\n+ def __new__(cls, *args: Any) -> 'Type':\n+ instance = Type._cache.get((cls, args))\n+ if instance is None:\n+ instance = object.__new__(cls)\n+ Type._cache[(cls, args)] = instance\n+ return instance\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+ def __init__(self, typestring: str, **kwargs: Any):\n+ self.typestring = typestring\n+ self.bytes_typestring = typestring.encode('ascii')\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+ kwargs = dict(_base_helpers, **kwargs)\n+ self.writer = call_with_kwargs(self.get_writer, kwargs)\n+ self.reader = call_with_kwargs(self.get_reader, kwargs)\n \n- # No match? Generic.\n- return SshError(None, stderr)\n+ def __repr__(self) -> str:\n+ return f\"{self.__class__.__name__}('{self.typestring}')\"\n+\n+ def get_writer(self, **kwargs: object) -> Callable[[object, object], None]:\n+ raise NotImplementedError\n+\n+ def get_reader(self, **kwargs: object) -> Callable[[object], object]:\n+ raise NotImplementedError\n+\n+\n+class BasicType(Type):\n+ __slots__ = ()\n+\n+ def __init__(self, typestring: str, ctype, get_wrapper=None, **kwargs):\n+ variable = ctype() # NB: not thread-safe\n+ super().__init__(typestring, ctype=ctype, type_constant=ctypes.c_char(ord(typestring)),\n+ getter=get_wrapper or ctype.value.__get__, setter=ctype.value.__set__,\n+ variable=variable, reference=ctypes.byref(variable), **kwargs)\n+\n+ def get_reader(self, read_basic, type_constant, variable, reference, getter):\n+ def basic_reader(message: libsystemd.sd_bus_message) -> object:\n+ if read_basic(message, type_constant, reference) <= 0:\n+ raise StopIteration\n+ return getter(variable)\n+ return basic_reader\n+\n+\n+class FixedType(BasicType):\n+ __slots__ = ()\n+\n+ def get_writer(self, append_basic, type_constant, variable, reference, setter, getter):\n+ def fixed_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n+ setter(variable, value)\n+ if getter(variable) != value:\n+ raise TypeError(f\"Cannot represent value {value} with type '{self.typestring}'\")\n+ append_basic(message, type_constant, reference)\n+ return fixed_writer\n+\n+\n+class StringLikeType(BasicType):\n+ __slots__ = ()\n+\n+ @staticmethod\n+ def get_guarded_conversion(typestring: str, guard: Callable[[str], bool]) -> Callable[[object], bytes]:\n+ def convert(candidate: object) -> bytes:\n+ if not isinstance(candidate, str):\n+ raise TypeError(f\"'{typestring}' encodes 'str', not '{candidate.__class__.__name__}'\")\n+ if not guard(candidate):\n+ raise ValueError(f\"Invalid value provided for type '{typestring}'\")\n+ return str.encode(candidate)\n+ return convert\n+\n+ def __init__(self, typestring: str, guard: Optional[Callable[[str], bool]] = None):\n+ # https://docs.python.org/3/c-api/unicode.html#c.PyUnicode_FromString\n+ to_unicode = ctypes.pythonapi.PyUnicode_FromString\n+ to_unicode.restype = ctypes.py_object\n+\n+ if guard is not None:\n+ convert = StringLikeType.get_guarded_conversion(typestring, guard)\n+ else:\n+ convert = str.encode # type: ignore[assignment] # can throw TypeError on call\n+\n+ super().__init__(typestring, ctypes.c_char_p, to_unicode, convert=convert)\n+\n+ def get_writer(self, append_basic, type_constant, convert):\n+ def string_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n+ append_basic(message, type_constant, convert(value))\n+ return string_writer\n+\n+\n+class BytestringType(Type):\n+ __slots__ = ()\n+\n+ def get_writer(self, append_array, y, size_t_setter, size_t):\n+ def bytes_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n+ if not isinstance(value, bytes):\n+ if isinstance(value, str):\n+ try:\n+ value = binascii.a2b_base64(value.encode('ascii')) # or decode base64\n+ except binascii.Error as exc:\n+ raise ValueError(\"'ay' cannot encode invalid base64 string\") from exc\n+ elif isinstance(value, (memoryview, bytearray)):\n+ value = bytes(value)\n+ else:\n+ raise TypeError(\"'ay' can only encode bytes-like or base64 string objects, \"\n+ f\"not '{value.__class__.__name__}'.\")\n+ size_t_setter(size_t, len(value))\n+ append_array(message, y, value, size_t)\n+ return bytes_writer\n+\n+ def get_reader(self, read_array, y, to_bytes, char_p, char_p_ref, size_t, size_t_ref):\n+ def bytes_reader(message):\n+ if read_array(message, y, char_p_ref, size_t_ref) <= 0:\n+ raise StopIteration\n+ return to_bytes(char_p, size_t)\n+ return bytes_reader\n+\n+\n+class ContainerType(Type):\n+ _typestring_template: ClassVar[str]\n+ __slots__ = 'item_types'\n+ item_types: Sequence[Type]\n+\n+ def __init__(self, *item_types: Type, **kwargs: Any):\n+ assert len(item_types) > 0\n+ item_typestrings = ''.join(item.typestring for item in item_types)\n+ self.item_types = item_types\n+ super().__init__(self._typestring_template.replace('_', item_typestrings),\n+ type_contents=ctypes.c_char_p(item_typestrings.encode('ascii')),\n+ **kwargs)\n+\n+\n+class ArrayType(ContainerType):\n+ _typestring_template = 'a_'\n+ __slots__ = ()\n+\n+ def __init__(self, item_type: Type):\n+ super().__init__(item_type,\n+ item_writer=item_type.writer,\n+ item_reader=item_type.reader,\n+ list_append=list.append)\n+\n+ def get_reader(self, enter_container, exit_container, list_append, item_reader):\n+ def array_reader(message: libsystemd.sd_bus_message) -> object:\n+ if enter_container(message, 0, None) <= 0:\n+ raise StopIteration\n+ result: List[object] = []\n+ try:\n+ while True:\n+ list_append(result, item_reader(message))\n+ except StopIteration:\n+ return result\n+ finally:\n+ exit_container(message)\n+ return array_reader\n+\n+ def get_writer(self, a, type_contents, open_container, close_container, item_writer):\n+ def array_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n+ open_container(message, a, type_contents)\n+ for item in value: # type: ignore[attr-defined] # can throw TypeError\n+ item_writer(message, item)\n+ close_container(message)\n+ return array_writer\n+\n+\n+class StructType(ContainerType):\n+ _typestring_template = '(_)'\n+ __slots__ = ()\n+\n+ def get_reader(self, enter_container, exit_container):\n+ item_readers = tuple(item_type.reader for item_type in self.item_types)\n+\n+ def array_reader(message: libsystemd.sd_bus_message) -> object:\n+ if enter_container(message, 0, None) <= 0:\n+ raise StopIteration\n+ result = tuple(item_reader(message) for item_reader in item_readers)\n+ exit_container(message)\n+ return result\n+ return array_reader\n+\n+ def get_writer(self, r, type_contents, open_container, close_container):\n+ item_writers = tuple(item_type.writer for item_type in self.item_types)\n+\n+ def struct_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n+ n_items = len(value) # type: ignore[arg-type] # can throw TypeError\n+ if n_items != len(item_writers):\n+ raise TypeError(f\"Wrong numbers of items ({n_items}) for structure type '{self.typestring}'\")\n+ open_container(message, r, type_contents)\n+ for item_writer, item in zip(item_writers, value): # type: ignore[call-overload] # can throw TypeError\n+ item_writer(message, item)\n+ close_container(message)\n+ return struct_writer\n+\n+\n+class DictionaryType(ContainerType):\n+ _typestring_template = 'a{_}'\n+ __slots__ = ()\n+\n+ def __init__(self, key_type: Type, value_type: Type):\n+ assert isinstance(key_type, BasicType)\n+ item_type = '{' + key_type.typestring + value_type.typestring + '}'\n+ super().__init__(key_type, value_type,\n+ key_reader=key_type.reader, key_writer=key_type.writer,\n+ value_reader=value_type.reader, value_writer=value_type.writer,\n+ item_type=ctypes.c_char_p(item_type.encode('ascii')))\n+\n+ def get_reader(self, enter_container, exit_container, key_reader, value_reader):\n+ def dict_reader(message: libsystemd.sd_bus_message) -> object:\n+ if enter_container(message, 0, None) <= 0: # array\n+ raise StopIteration\n+ result = {}\n+ while enter_container(message, 0, None) > 0: # entry\n+ key = key_reader(message)\n+ value = value_reader(message)\n+ result[key] = value\n+ exit_container(message)\n+ exit_container(message)\n+ return result\n+ return dict_reader\n+\n+ def get_writer(self, a, item_type, e, type_contents, open_container, close_container, key_writer, value_writer):\n+ def dict_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n+ open_container(message, a, item_type) # array\n+ for key, val in value.items(): # type: ignore[attr-defined] # can raise AttributeError\n+ open_container(message, e, type_contents) # entry\n+ key_writer(message, key) # key\n+ value_writer(message, val) # value\n+ close_container(message) # end entry\n+ close_container(message) # end array\n+ return dict_writer\n+\n+\n+class VariantType(Type):\n+ __slots__ = ()\n+\n+ def get_reader(self, enter_container, exit_container):\n+ def variant_reader(message: libsystemd.sd_bus_message) -> object:\n+ if enter_container(message, 0, None) <= 0:\n+ raise StopIteration\n+ typestring = message.get_signature(False)\n+ type_, = from_signature(typestring)\n+ value = type_.reader(message)\n+ exit_container(message)\n+ return Variant(value, type_)\n+ return variant_reader\n+\n+ def get_writer(self, open_container, close_container, v):\n+ def variant_writer(message: libsystemd.sd_bus_message, value: object) -> None:\n+ if isinstance(value, Variant):\n+ type_ = value.type\n+ contents = value.value\n+ else:\n+ try:\n+ type_, = from_signature(value['t']) # type: ignore[index] # can throw TypeError\n+ contents = value['v'] # type: ignore[index] # can throw TypeError\n+ except KeyError as exc:\n+ raise TypeError(\"'v' can encode Variant objects, or mappings with 't' and 'v' keys\") from exc\n+\n+ open_container(message, v, type_.bytes_typestring)\n+ type_.writer(message, contents)\n+ close_container(message)\n+ return variant_writer\n+\n+\n+class Variant:\n+ __slots__ = 'type', 'value'\n+ type: Type\n+ value: object\n+\n+ def __init__(self, value: object, hint: object = None):\n+ if isinstance(hint, Type):\n+ self.type = hint\n+ elif isinstance(hint, str):\n+ self.type, = from_signature(hint)\n+ else:\n+ self.type = from_annotation(hint or value.__class__)\n+ self.value = value\n+\n+ def __repr__(self) -> str:\n+ return f\"systemd_ctypes.Variant({self.value}, '{self.type.typestring}')\"\n+\n+ def __eq__(self, other: object) -> bool:\n+ if isinstance(other, Variant):\n+ return self.type == other.type and self.value == other.value\n+ elif isinstance(other, dict):\n+ return (self.type,) == from_signature(other['t']) and self.value == other['v']\n+ else:\n+ return False\n+\n+ def __hash__(self) -> int:\n+ return hash(self.type) ^ hash(self.value)\n+\n+\n+class BusType(Enum):\n+ boolean = Annotated[bool, FixedType('b', ctypes.c_int, ctypes.c_int.__bool__)]\n+ byte = Annotated[int, FixedType('y', ctypes.c_uint8)]\n+ int16 = Annotated[int, FixedType('n', ctypes.c_int16)]\n+ uint16 = Annotated[int, FixedType('q', ctypes.c_uint16)]\n+ int32 = Annotated[int, FixedType('i', ctypes.c_int32)]\n+ uint32 = Annotated[int, FixedType('u', ctypes.c_uint32)]\n+ int64 = Annotated[int, FixedType('x', ctypes.c_int64)]\n+ uint64 = Annotated[int, FixedType('t', ctypes.c_uint64)]\n+ double = Annotated[float, FixedType('d', ctypes.c_double)]\n+ string = Annotated[str, StringLikeType('s')]\n+ objectpath = Annotated[str, StringLikeType('o', is_object_path)]\n+ signature = Annotated[str, StringLikeType('g', is_signature)]\n+ bytestring = Annotated[bytes, BytestringType('ay')]\n+ variant = Annotated[dict, VariantType('v')]\n+\n+\n+# mypy gets confused by enums, so just use Any\n+_base_equivalence_map: Dict[type, Any] = {\n+ bool: BusType.boolean,\n+ bytes: BusType.bytestring,\n+ int: BusType.int32,\n+ str: BusType.string,\n+ Variant: BusType.variant,\n+}\n+\n+_factory_map: Dict[object, Callable[..., Type]] = {\n+ dict: DictionaryType, Dict: DictionaryType,\n+ list: ArrayType, List: ArrayType,\n+ tuple: StructType, Tuple: StructType,\n+}\n+\n+\n+@functools.lru_cache()\n+def from_annotation(annotation: Union[str, type, BusType]) -> Type:\n+ # Simple Python types\n+ if isinstance(annotation, str):\n+ types = from_signature(annotation)\n+ if len(types) != 1:\n+ raise TypeError(f\"Signature '{annotation}' invalid as a type string \"\n+ f\"because it describes {len(types)} types, not one.\")\n+ return types[0]\n+\n+ if isinstance(annotation, type):\n+ annotation = _base_equivalence_map.get(annotation, annotation)\n+\n+ # Our own BusType types\n+ if isinstance(annotation, BusType):\n+ bus_type = typing.get_args(annotation.value)[1]\n+ assert isinstance(bus_type, Type)\n+ return bus_type\n+\n+ # Container types\n+ try:\n+ factory = _factory_map[typing.get_origin(annotation)]\n+ args = [from_annotation(arg) for arg in typing.get_args(annotation)]\n+ return factory(*args)\n+ except (AssertionError, AttributeError, KeyError, TypeError):\n+ raise TypeError(f\"Cannot interpret {annotation} as a dbus type\") from None\n+\n+\n+_base_typestring_map: Dict[str, Type] = {\n+ bustype.typestring: bustype for bustype in (from_annotation(entry) for entry in BusType)\n+}\n+\n+\n+@functools.lru_cache()\n+def from_signature(signature: str) -> Tuple[Type, ...]:\n+ stack = list(reversed(signature))\n+\n+ def get_one() -> Type:\n+ first = stack.pop()\n+ if first == 'a':\n+ if stack[-1] == 'y':\n+ first += stack.pop()\n+ elif stack[-1] == '{':\n+ stack.pop()\n+ return DictionaryType(*get_several('}'))\n+ else:\n+ return ArrayType(get_one())\n+ elif first == '(':\n+ return StructType(*get_several(')'))\n+\n+ return _base_typestring_map[first]\n+\n+ def get_several(end: str) -> Iterable[Type]:\n+ yield get_one()\n+ while stack[-1] != end:\n+ yield get_one()\n+ stack.pop()\n+\n+ def get_all() -> Iterable[Type]:\n+ while stack:\n+ yield get_one()\n+\n+ try:\n+ return tuple(get_all())\n+ except (AssertionError, IndexError, KeyError) as exc:\n+ raise TypeError(f\"Invalid type signature '{signature}'\") from exc\n+\n+\n+class MessageType:\n+ item_types: Sequence[Type]\n+ typestrings: List[str]\n+ signature: str\n+\n+ def __init__(self, item_types: Sequence[Union[str, type, BusType]]):\n+ self.item_types = [from_annotation(item_type) for item_type in item_types]\n+ self.typestrings = [item_type.typestring for item_type in self.item_types]\n+ self.signature = ''.join(self.typestrings)\n+\n+ def write(self, message: libsystemd.sd_bus_message, *items: object) -> None:\n+ assert len(items) == len(self.item_types)\n+ for item_type, item in zip(self.item_types, items):\n+ item_type.writer(message, item)\n+\n+ def read(self, message: libsystemd.sd_bus_message) -> Optional[Tuple[object, ...]]:\n+ if not message.has_signature(self.signature):\n+ return None\n+ return tuple(item_type.reader(message) for item_type in self.item_types)\n+\n+ def __len__(self) -> int:\n+ return len(self.item_types)\n+\n+\n+class JSONEncoder(json.JSONEncoder):\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/data/fail.html': br'''\n \n \n @@message@@\n \n \n@@ -9706,14 +9706,480 @@\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+ '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 .\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/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 .\n+\n+import asyncio\n+import http.client\n+import logging\n+import socket\n+import ssl\n+\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+\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+\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+ 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+\n+ else:\n+ return http.client.HTTPConnection(opt_address, port=opt_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+\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+ 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+\n+ if 'connection' in options:\n+ raise ChannelError('protocol-error', message='connection sharing is not implemented on this bridge')\n+\n+ loop = asyncio.get_running_loop()\n+ connection = self.create_client(options)\n+\n+ self.ready()\n+\n+ body = b''\n+ while True:\n+ data = await self.read()\n+ if data == b'':\n+ break\n+ body += data\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+ # 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+ 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+ 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+''',\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+# 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 .\n+\n+import asyncio\n+import json\n+import logging\n+import sys\n+import time\n+from collections import defaultdict\n+from typing import Dict, List, NamedTuple, Optional, Set, Tuple, Union\n+\n+from ..channel import AsyncChannel, ChannelError\n+from ..jsonutil import JsonList\n+from ..samples import SAMPLERS, SampleDescription, Sampler, Samples\n+\n+logger = logging.getLogger(__name__)\n+\n+\n+class MetricInfo(NamedTuple):\n+ derive: Optional[str]\n+ desc: SampleDescription\n+\n+\n+class InternalMetricsChannel(AsyncChannel):\n+ payload = 'metrics1'\n+ restrictions = [('source', 'internal')]\n+\n+ metrics: List[MetricInfo]\n+ samplers: Set\n+ samplers_cache: Optional[Dict[str, Tuple[Sampler, SampleDescription]]] = None\n+\n+ interval: int = 1000\n+ need_meta: bool = True\n+ last_timestamp: float = 0\n+ next_timestamp: float = 0\n+\n+ @classmethod\n+ def ensure_samplers(cls):\n+ if cls.samplers_cache is None:\n+ cls.samplers_cache = {desc.name: (sampler, desc) for sampler in SAMPLERS for desc in sampler.descriptions}\n+\n+ def parse_options(self, options):\n+ logger.debug('metrics internal open: %s, channel: %s', options, self.channel)\n+\n+ interval = options.get('interval', self.interval)\n+ if not isinstance(interval, int) or interval <= 0 or interval > sys.maxsize:\n+ raise ChannelError('protocol-error', message=f'invalid \"interval\" value: {interval}')\n+\n+ self.interval = interval\n+\n+ metrics = options.get('metrics')\n+ if not isinstance(metrics, list) or len(metrics) == 0:\n+ logger.error('invalid \"metrics\" value: %s', metrics)\n+ raise ChannelError('protocol-error', message='invalid \"metrics\" option was specified (not an array)')\n+\n+ sampler_classes = set()\n+ for metric in metrics:\n+ # validate it's an object\n+ name = metric.get('name')\n+ units = metric.get('units')\n+ derive = metric.get('derive')\n+\n+ try:\n+ sampler, desc = self.samplers_cache[name]\n+ except KeyError as exc:\n+ logger.error('unsupported metric: %s', name)\n+ raise ChannelError('not-supported', message=f'unsupported metric: {name}') from exc\n+\n+ if units and units != desc.units:\n+ raise ChannelError('not-supported', message=f'{name} has units {desc.units}, not {units}')\n+\n+ sampler_classes.add(sampler)\n+ self.metrics.append(MetricInfo(derive=derive, desc=desc))\n+\n+ self.samplers = {cls() for cls in sampler_classes}\n+\n+ def send_meta(self, samples: Samples, timestamp: float):\n+ metrics: JsonList = []\n+ for metricinfo in self.metrics:\n+ if metricinfo.desc.instanced:\n+ metrics.append({\n+ 'name': metricinfo.desc.name,\n+ 'units': metricinfo.desc.units,\n+ 'instances': list(samples[metricinfo.desc.name].keys()),\n+ 'semantics': metricinfo.desc.semantics\n+ })\n+ else:\n+ metrics.append({\n+ 'name': metricinfo.desc.name,\n+ 'derive': metricinfo.derive, # type: ignore[dict-item]\n+ 'units': metricinfo.desc.units,\n+ 'semantics': metricinfo.desc.semantics\n+ })\n+\n+ self.send_json(source='internal', interval=self.interval, timestamp=timestamp * 1000, metrics=metrics)\n+ self.need_meta = False\n+\n+ def sample(self):\n+ samples = defaultdict(dict)\n+ for sampler in self.samplers:\n+ sampler.sample(samples)\n+ return samples\n+\n+ def calculate_sample_rate(self, value: float, old_value: Optional[float]) -> Union[float, bool]:\n+ if old_value is not None and self.last_timestamp:\n+ return (value - old_value) / (self.next_timestamp - self.last_timestamp)\n+ else:\n+ return False\n+\n+ def send_updates(self, samples: Samples, last_samples: Samples):\n+ data: List[Union[float, List[Optional[Union[float, bool]]]]] = []\n+ timestamp = time.time()\n+ self.next_timestamp = timestamp\n+\n+ for metricinfo in self.metrics:\n+ value = samples[metricinfo.desc.name]\n+\n+ if metricinfo.desc.instanced:\n+ old_value = last_samples[metricinfo.desc.name]\n+ assert isinstance(value, dict)\n+ assert isinstance(old_value, dict)\n+\n+ # If we have less or more keys the data changed, send a meta message.\n+ if value.keys() != old_value.keys():\n+ self.need_meta = True\n+\n+ if metricinfo.derive == 'rate':\n+ instances: List[Optional[Union[float, bool]]] = []\n+ for key, val in value.items():\n+ instances.append(self.calculate_sample_rate(val, old_value.get(key)))\n+\n+ data.append(instances)\n+ else:\n+ data.append(list(value.values()))\n+ else:\n+ old_value = last_samples.get(metricinfo.desc.name)\n+ assert not isinstance(value, dict)\n+ assert not isinstance(old_value, dict)\n+\n+ if metricinfo.derive == 'rate':\n+ data.append(self.calculate_sample_rate(value, old_value))\n+ else:\n+ data.append(value)\n+\n+ if self.need_meta:\n+ self.send_meta(samples, timestamp)\n+\n+ self.last_timestamp = self.next_timestamp\n+ self.send_data(json.dumps([data]).encode())\n+\n+ async def run(self, options):\n+ self.metrics = []\n+ self.samplers = set()\n+\n+ InternalMetricsChannel.ensure_samplers()\n+\n+ self.parse_options(options)\n+ self.ready()\n+\n+ last_samples = defaultdict(dict)\n+ while True:\n+ samples = self.sample()\n+ self.send_updates(samples, last_samples)\n+ last_samples = samples\n+\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/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@@ -10256,15 +10722,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/stream.py': br'''# This file is part of Cockpit.\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@@ -10273,117 +10739,98 @@\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 .\n \n-import asyncio\n import logging\n-import os\n-import subprocess\n-from typing import Dict\n+from typing import Optional\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+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 SocketStreamChannel(ProtocolChannel):\n- payload = 'stream'\n+class PackagesChannel(AsyncChannel):\n+ payload = 'http-stream1'\n+ restrictions = [(\"internal\", \"packages\")]\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+ # 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- # 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+ if get_str(options, 'method') != 'GET':\n+ raise ValueError(f'Unsupported HTTP method {options[\"method\"]}')\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+ self.ready()\n+ if await self.read() != b'':\n+ raise ValueError('Received unexpected data')\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+ path = get_str(options, 'path')\n+ headers = get_dict(options, 'headers')\n+ document = packages.load_path(path, headers)\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+ # 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-class SubprocessStreamChannel(ProtocolChannel, SubprocessProtocol):\n- payload = 'stream'\n- restrictions = (('spawn', None),)\n+ if document.content_security_policy is not None:\n+ policy = document.content_security_policy\n \n- def process_exited(self) -> None:\n- self.close_on_eof()\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 _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+ 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 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+ out_headers['Content-Security-Policy'] = policy\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+ except ValueError as exc:\n+ self.http_error(400, str(exc))\n \n- if err == 'out':\n- stderr = subprocess.STDOUT\n- elif err == 'ignore':\n- stderr = subprocess.DEVNULL\n- else:\n- stderr = subprocess.PIPE\n+ except KeyError:\n+ self.http_error(404, 'Not found')\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+ except OSError as exc:\n+ self.http_error(500, f'Internal error: {exc!s}')\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+ 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@@ -10986,457 +11433,10 @@\n InternalMetricsChannel,\n NullChannel,\n PackagesChannel,\n SubprocessStreamChannel,\n SocketStreamChannel,\n ]\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 .\n-\n-import asyncio\n-import http.client\n-import logging\n-import socket\n-import ssl\n-\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-\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-\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- 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-\n- else:\n- return http.client.HTTPConnection(opt_address, port=opt_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-\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- 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-\n- if 'connection' in options:\n- raise ChannelError('protocol-error', message='connection sharing is not implemented on this bridge')\n-\n- loop = asyncio.get_running_loop()\n- connection = self.create_client(options)\n-\n- self.ready()\n-\n- body = b''\n- while True:\n- data = await self.read()\n- if data == b'':\n- break\n- body += data\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- # 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- 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- 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-''',\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-# 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 .\n-\n-import asyncio\n-import json\n-import logging\n-import sys\n-import time\n-from collections import defaultdict\n-from typing import Dict, List, NamedTuple, Optional, Set, Tuple, Union\n-\n-from ..channel import AsyncChannel, ChannelError\n-from ..jsonutil import JsonList\n-from ..samples import SAMPLERS, SampleDescription, Sampler, Samples\n-\n-logger = logging.getLogger(__name__)\n-\n-\n-class MetricInfo(NamedTuple):\n- derive: Optional[str]\n- desc: SampleDescription\n-\n-\n-class InternalMetricsChannel(AsyncChannel):\n- payload = 'metrics1'\n- restrictions = [('source', 'internal')]\n-\n- metrics: List[MetricInfo]\n- samplers: Set\n- samplers_cache: Optional[Dict[str, Tuple[Sampler, SampleDescription]]] = None\n-\n- interval: int = 1000\n- need_meta: bool = True\n- last_timestamp: float = 0\n- next_timestamp: float = 0\n-\n- @classmethod\n- def ensure_samplers(cls):\n- if cls.samplers_cache is None:\n- cls.samplers_cache = {desc.name: (sampler, desc) for sampler in SAMPLERS for desc in sampler.descriptions}\n-\n- def parse_options(self, options):\n- logger.debug('metrics internal open: %s, channel: %s', options, self.channel)\n-\n- interval = options.get('interval', self.interval)\n- if not isinstance(interval, int) or interval <= 0 or interval > sys.maxsize:\n- raise ChannelError('protocol-error', message=f'invalid \"interval\" value: {interval}')\n-\n- self.interval = interval\n-\n- metrics = options.get('metrics')\n- if not isinstance(metrics, list) or len(metrics) == 0:\n- logger.error('invalid \"metrics\" value: %s', metrics)\n- raise ChannelError('protocol-error', message='invalid \"metrics\" option was specified (not an array)')\n-\n- sampler_classes = set()\n- for metric in metrics:\n- # validate it's an object\n- name = metric.get('name')\n- units = metric.get('units')\n- derive = metric.get('derive')\n-\n- try:\n- sampler, desc = self.samplers_cache[name]\n- except KeyError as exc:\n- logger.error('unsupported metric: %s', name)\n- raise ChannelError('not-supported', message=f'unsupported metric: {name}') from exc\n-\n- if units and units != desc.units:\n- raise ChannelError('not-supported', message=f'{name} has units {desc.units}, not {units}')\n-\n- sampler_classes.add(sampler)\n- self.metrics.append(MetricInfo(derive=derive, desc=desc))\n-\n- self.samplers = {cls() for cls in sampler_classes}\n-\n- def send_meta(self, samples: Samples, timestamp: float):\n- metrics: JsonList = []\n- for metricinfo in self.metrics:\n- if metricinfo.desc.instanced:\n- metrics.append({\n- 'name': metricinfo.desc.name,\n- 'units': metricinfo.desc.units,\n- 'instances': list(samples[metricinfo.desc.name].keys()),\n- 'semantics': metricinfo.desc.semantics\n- })\n- else:\n- metrics.append({\n- 'name': metricinfo.desc.name,\n- 'derive': metricinfo.derive, # type: ignore[dict-item]\n- 'units': metricinfo.desc.units,\n- 'semantics': metricinfo.desc.semantics\n- })\n-\n- self.send_json(source='internal', interval=self.interval, timestamp=timestamp * 1000, metrics=metrics)\n- self.need_meta = False\n-\n- def sample(self):\n- samples = defaultdict(dict)\n- for sampler in self.samplers:\n- sampler.sample(samples)\n- return samples\n-\n- def calculate_sample_rate(self, value: float, old_value: Optional[float]) -> Union[float, bool]:\n- if old_value is not None and self.last_timestamp:\n- return (value - old_value) / (self.next_timestamp - self.last_timestamp)\n- else:\n- return False\n-\n- def send_updates(self, samples: Samples, last_samples: Samples):\n- data: List[Union[float, List[Optional[Union[float, bool]]]]] = []\n- timestamp = time.time()\n- self.next_timestamp = timestamp\n-\n- for metricinfo in self.metrics:\n- value = samples[metricinfo.desc.name]\n-\n- if metricinfo.desc.instanced:\n- old_value = last_samples[metricinfo.desc.name]\n- assert isinstance(value, dict)\n- assert isinstance(old_value, dict)\n-\n- # If we have less or more keys the data changed, send a meta message.\n- if value.keys() != old_value.keys():\n- self.need_meta = True\n-\n- if metricinfo.derive == 'rate':\n- instances: List[Optional[Union[float, bool]]] = []\n- for key, val in value.items():\n- instances.append(self.calculate_sample_rate(val, old_value.get(key)))\n-\n- data.append(instances)\n- else:\n- data.append(list(value.values()))\n- else:\n- old_value = last_samples.get(metricinfo.desc.name)\n- assert not isinstance(value, dict)\n- assert not isinstance(old_value, dict)\n-\n- if metricinfo.derive == 'rate':\n- data.append(self.calculate_sample_rate(value, old_value))\n- else:\n- data.append(value)\n-\n- if self.need_meta:\n- self.send_meta(samples, timestamp)\n-\n- self.last_timestamp = self.next_timestamp\n- self.send_data(json.dumps([data]).encode())\n-\n- async def run(self, options):\n- self.metrics = []\n- self.samplers = set()\n-\n- InternalMetricsChannel.ensure_samplers()\n-\n- self.parse_options(options)\n- self.ready()\n-\n- last_samples = defaultdict(dict)\n- while True:\n- samples = self.sample()\n- self.send_updates(samples, last_samples)\n- last_samples = samples\n-\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 .\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 }))\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=db21ac8b9c9e699bfa4281ff97f13b94f631bc3cf1567ffa8a44246eeb81f9f7', \"", " \"'hashes': {'sha256': \"", " \"'db21ac8b9c9e699bfa4281ff97f13b94f631bc3cf1567ffa8a44246eeb81f9f7'}}\"}"], "unified_diff": "@@ -1,9 +1,9 @@\n {\n \"archive_info\": {\n- \"hash\": \"sha256=1eeb38288684c94a41a89da1b7c490a6132460d2eb97fead27254de495f9f177\",\n+ \"hash\": \"sha256=db21ac8b9c9e699bfa4281ff97f13b94f631bc3cf1567ffa8a44246eeb81f9f7\",\n \"hashes\": {\n- \"sha256\": \"1eeb38288684c94a41a89da1b7c490a6132460d2eb97fead27254de495f9f177\"\n+ \"sha256\": \"db21ac8b9c9e699bfa4281ff97f13b94f631bc3cf1567ffa8a44246eeb81f9f7\"\n }\n },\n \"url\": \"file:///build/reproducible-path/cockpit-311/tmp/wheel/cockpit-311-py3-none-any.whl\"\n }\n"}]}]}]}]}]}