telnetlib3 4.0.4__tar.gz → 5.0.0__tar.gz

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: telnetlib3
-Version: 4.0.4
+Version: 5.0.0
 Summary:  Python Telnet server and client CLI and Protocol library
 Project-URL: Homepage, https://github.com/jquast/telnetlib3
 Project-URL: Documentation, https://telnetlib3.readthedocs.io

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/docs/history.rst

@@ -1,5 +1,41 @@
 History
 =======
+
+5.0.0
+  * changed: :meth:`~telnetlib3.stream_writer.TelnetWriter.handle_zmp` now receives ``command,
+    *args`` instead of one ``parts`` list; ``zmp_data`` moved to ``writer.ctx`` and is now a dict
+    keyed by command (was a list of messages).  New
+    :meth:`~telnetlib3.stream_writer.TelnetWriter.send_zmp`.
+  * changed: MUD protocol subnegotiation data (``mssp_data``, ``atcp_data``, ``aardwolf_data``,
+    ``mxp_data``, ``comport_data``) moved from :class:`~telnetlib3.stream_writer.TelnetWriter` to
+    :class:`~telnetlib3._session_context.TelnetSessionContext` (``writer.ctx.mssp_data``, etc.).
+    Deprecated writer properties delegate to ``ctx``; ``writer.zmp_data`` is removed without
+    deprecation.
+  * changed: client-side MUD protocol declines (GMCP, MSDP, MSSP, MSP, MXP, ZMP, AARDWOLF, ATCP)
+    remain the default; the decline log messages now name the enable mechanism (``always_will`` /
+    ``always_do`` / ``passive_do``) used by downstream clients such as telix to accept them.  Note
+    that MXP's negotiation direction is server-sends-``DO`` (the LPMud family convention, e.g.
+    Discworld), so a client accepting MXP replies ``WILL`` to ``IAC DO MXP``.
+    :meth:`~telnetlib3.stream_writer.TelnetWriter.remove_will_callback` for per-option callbacks
+    invoked after :meth:`~telnetlib3.stream_writer.TelnetWriter.handle_will` negotiation.  Replaces
+    the previous
+    closure-wrapping pattern in :class:`~telnetlib3.client.TelnetClient` for GMCP, ZMP, and CHARSET
+    will-detection.
+  * enhancement: ``telnetlib3-fingerprint`` now accepts all MUD protocol offers (ATCP, AARDWOLF,
+    MSP, MXP, MSDP, MSSP) to collect subnegotiation data.
+  * enhancement: sub-negotiation payloads are bounded to 1,000KB.
+  * enhancement: ``--loglevel=trace`` receive dumps show the decompressed telnet stream (MCCP2,
+    MCCP3) instead of raw compressed bytes.
+  * bugfix: ``IAC SB IAC SE`` (sub-negotiation with no option byte) should not raise ``IndexError``
+  * new: :meth:`~telnetlib3.stream_writer.TelnetWriter.add_will_callback` and
+
+
+4.0.6
+  * bugfix: default GMCP modules requested are now in lowercase instead of titlecase
+
+4.0.5
+  * enhancement: ``telnetlib3-client`` client shell now drains stdout.
+
 4.0.4
   * bugfix: servers using ``robot_check=True`` with ``encoding=False`` raised ``TypeError: buf
     expected bytes, got <class 'str'>``. ``telnetlib3-server`` now also accepts ``--encoding=False``

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/docs/rfcs.rst

@@ -77,6 +77,9 @@ Dungeon) servers and clients.
 * `GMCP`_ (Generic MUD Communication Protocol, option 201). JSON-based
   bidirectional messaging for game data such as room info, character vitals,
   and client metadata.
+* `ZMP`_ (Zenith Mud Protocol, option 93). Bidirectional messaging of
+  NUL-delimited string lists (a command plus arguments), carrying data such
+  as room info and character vitals.
 * `MSDP`_ (MUD Server Data Protocol, option 69). Structured key-value protocol
   for game variables with support for nested tables and arrays.
 * `MSSP`_ (MUD Server Status Protocol, option 70). Server metadata protocol
@@ -93,13 +96,14 @@ Dungeon) servers and clients.
 .. _MSSP: https://tintin.mudhalla.net/protocols/mssp/
 .. _MCCP2: https://tintin.mudhalla.net/protocols/mccp/
 .. _MCCP3: https://tintin.mudhalla.net/protocols/mccp/
+.. _ZMP: https://discworld.starturtle.net/external/protocols/zmp.html
 
 MUDs Not Implemented
 --------------------
 
 Constants are also defined for the following MUD options, though their handlers
-are not implemented: MCCP (85, legacy compression), MXP (91, markup), ZMP
-(93, messaging), MSP (90, sound), and ATCP (200, Achaea-specific).
+are not implemented: MCCP (85, legacy compression), MXP (91, markup), MSP (90,
+sound), and ATCP (200, Achaea-specific).
 
 Additional Resources
 --------------------

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "telnetlib3"
-version = "4.0.4"  # Keep in sync with telnetlib3/accessories.py::get_version !
+version = "5.0.0"  # Keep in sync with telnetlib3/accessories.py::get_version !
 description = " Python Telnet server and client CLI and Protocol library"
 readme = "README.rst"
 license = "ISC"

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/telnetlib3/_session_context.py

@@ -53,3 +53,10 @@ class TelnetSessionContext:
         self.autoreply_wait_fn = autoreply_wait_fn
         self.typescript_file = typescript_file
         self.gmcp_data: dict[str, Any] = gmcp_data if gmcp_data is not None else {}
+        self.zmp_data: dict[str, list[str]] = {}
+        # MUD protocol data moved from TelnetWriter to ctx for consistency
+        self.mssp_data: Optional[dict[str, str | list[str]]] = None
+        self.atcp_data: list[tuple[str, str]] = []
+        self.aardwolf_data: list[dict[str, Any]] = []
+        self.mxp_data: list[bytes] = []
+        self.comport_data: Optional[dict[str, Any]] = None

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/telnetlib3/accessories.py

@@ -42,7 +42,7 @@ PATIENCE_MESSAGES = [
 
 def get_version() -> str:
     """Return the current version of telnetlib3."""
-    return "4.0.4"  # keep in sync with pyproject.toml !
+    return "5.0.0"  # keep in sync with pyproject.toml !
 
 
 def encoding_from_lang(lang: str) -> Optional[str]:

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/telnetlib3/client.py

@@ -12,7 +12,7 @@ import struct
 import asyncio
 import argparse
 import functools
-from typing import Any, Dict, List, Tuple, Union, Callable, Optional, Sequence
+from typing import Any, Dict, List, Tuple, Union, Callable, Optional, Sequence, Collection
 
 # local
 from telnetlib3 import accessories, client_base
@@ -26,14 +26,14 @@ __all__ = ("TelnetClient", "TelnetTerminalClient", "open_connection")
 #: Sub-modules are listed explicitly because not all servers treat
 #: top-level subscriptions as wildcards.
 _DEFAULT_GMCP_MODULES = [
-    "Char 1",
-    "Char.Vitals 1",
-    "Char.Items 1",
-    "Room 1",
-    "Room.Info 1",
-    "Comm 1",
-    "Comm.Channel 1",
-    "Group 1",
+    "char 1",
+    "char.vitals 1",
+    "char.items 1",
+    "room 1",
+    "room.info 1",
+    "comm 1",
+    "comm.channel 1",
+    "group 1",
 ]
 
 
@@ -73,6 +73,8 @@ class TelnetClient(client_base.BaseClient):
         waiter_closed: Optional[asyncio.Future[None]] = None,
         _waiter_connected: Optional[asyncio.Future[None]] = None,
         gmcp_modules: Optional[List[str]] = None,
+        zmp_check_handler: Optional[Callable[[str], bool]] = None,
+        zmp_supported_commands: Optional[Collection[str]] = None,
     ) -> None:
         """Initialize TelnetClient with terminal parameters."""
         self._compression = compression
@@ -89,6 +91,11 @@ class TelnetClient(client_base.BaseClient):
         )
         self._gmcp_modules = gmcp_modules or list(_DEFAULT_GMCP_MODULES)
         self._gmcp_hello_sent = False
+        self._zmp_check_handler = zmp_check_handler  # None means refuse all
+        self._zmp_ident_sent = False
+        self._zmp_supported_commands = (
+            set(zmp_supported_commands) if zmp_supported_commands else set()
+        )
         self._send_environ = set(send_environ or self.DEFAULT_SEND_ENVIRON)
         self._extra.update(
             {
@@ -144,61 +151,74 @@ class TelnetClient(client_base.BaseClient):
         ):
             self.writer.set_ext_offer_callback(opt, offer_func)
 
-        # Override the default handle_will method to detect when both sides support CHARSET
-        # Store the original only on first connection to prevent chain growth on reconnect.
-        if not hasattr(self.writer, "_original_handle_will"):
-            self.writer._original_handle_will = self.writer.handle_will
-        else:
-            self.writer.handle_will = (  # type: ignore[method-assign]
-                self.writer._original_handle_will
-            )
-        original_handle_will = self.writer.handle_will
-        writer = self.writer
+        self.writer.add_will_callback(CHARSET, self.on_will_charset)
 
-        def enhanced_handle_will(opt: bytes) -> None:
-            original_handle_will(opt)
+        self.setup_gmcp()
+        self.setup_zmp()
 
-            # If this was a WILL CHARSET from the server, and we also have WILL CHARSET enabled,
-            # log that both sides support CHARSET. The server should initiate the actual REQUEST.
-            if (
-                opt == CHARSET
-                and writer.remote_option.enabled(CHARSET)
-                and writer.local_option.enabled(CHARSET)
-            ):
-                self.log.debug("Both sides support CHARSET, ready for server to initiate REQUEST")
+    def on_will_charset(self, opt: bytes) -> None:
+        """Log when both sides support CHARSET after WILL negotiation."""
+        from telnetlib3.telopt import CHARSET
 
-        self.writer.handle_will = enhanced_handle_will  # type: ignore[method-assign]
+        if self.writer.remote_option.enabled(CHARSET) and self.writer.local_option.enabled(CHARSET):
+            self.log.debug("Both sides support CHARSET, ready for server to initiate REQUEST")
 
-        self._setup_gmcp()
-
-    def _setup_gmcp(self) -> None:
+    def setup_gmcp(self) -> None:
         """Wire GMCP callback and WILL-detection for Core.Hello handshake."""
         from telnetlib3.telopt import GMCP
 
+        self.writer.passive_do.add(GMCP)
         self.writer.set_ext_callback(GMCP, self.on_gmcp)
+        self.writer.add_will_callback(GMCP, self.on_will_gmcp)
 
-        # Capture current handle_will (already includes CHARSET wrapper).
-        # On reconnect, _original_handle_will was already restored in connection_made,
-        # so this always wraps exactly once.
-        original_handle_will_gmcp = self.writer.handle_will
+    def on_will_gmcp(self, opt: bytes) -> None:
+        """Send Core.Hello after GMCP negotiation."""
+        from telnetlib3.telopt import GMCP
 
-        def _detect_gmcp_will(opt: bytes) -> None:
-            original_handle_will_gmcp(opt)
-            if opt == GMCP and self.writer.remote_option.enabled(GMCP):
-                self._send_gmcp_hello()
+        enabled = self.writer.remote_option.enabled(GMCP)
+        hello_sent = self._gmcp_hello_sent
+        self.log.debug("on_will_gmcp: remote_enabled=%s _gmcp_hello_sent=%s", enabled, hello_sent)
+        if enabled:
+            self.send_gmcp_hello()
 
-        self.writer.handle_will = _detect_gmcp_will  # type: ignore[method-assign]
+    def setup_zmp(self) -> None:
+        """Wire ZMP callback and WILL-detection for zmp.ident handshake."""
+        from telnetlib3.telopt import ZMP
 
-    def _send_gmcp_hello(self) -> None:
+        self.writer.passive_do.add(ZMP)
+        self.writer.set_ext_callback(ZMP, self.on_zmp)
+        self.writer.add_will_callback(ZMP, self.on_will_zmp)
+
+    def on_will_zmp(self, opt: bytes) -> None:
+        """Send zmp.ident after ZMP negotiation."""
+        from telnetlib3.telopt import ZMP
+
+        if self.writer.remote_option.enabled(ZMP):
+            self.send_zmp_ident()
+
+    def send_gmcp_hello(self) -> None:
         """Send ``Core.Hello`` and ``Core.Supports.Set`` after GMCP negotiation."""
         if self._gmcp_hello_sent:
             return
         self._gmcp_hello_sent = True
         from telnetlib3.accessories import get_version
 
+        modules = [m.lower() for m in self._gmcp_modules]
         self.writer.send_gmcp("Core.Hello", {"client": "telnetlib3", "version": get_version()})
-        self.writer.send_gmcp("Core.Supports.Set", self._gmcp_modules)
-        self.log.info("GMCP handshake: Core.Hello + Core.Supports.Set %s", self._gmcp_modules)
+        self.writer.send_gmcp("Core.Supports.Set", modules)
+        self.log.info("GMCP handshake: Core.Hello + Core.Supports.Set %s", modules)
+
+    def send_zmp_ident(self) -> None:
+        """Send ``zmp.ident`` after ZMP negotiation."""
+        if self._zmp_ident_sent:
+            return
+        self._zmp_ident_sent = True
+        from telnetlib3.accessories import get_version
+
+        self.writer.send_zmp("zmp.ident", "telnetlib3", get_version())
+        self.log.info("ZMP handshake: zmp.ident telnetlib3 %s", get_version())
+        for cmd in sorted(self._zmp_supported_commands):
+            self.writer.send_zmp("zmp.support", cmd)
 
     def on_gmcp(self, package: str, data: Any) -> None:
         """Store incoming GMCP data on ``writer.ctx``, merging dict updates."""
@@ -209,6 +229,39 @@ class TelnetClient(client_base.BaseClient):
             gmcp[package] = data
         self.log.debug("GMCP: %s %r", package, data)
 
+    def on_zmp(self, command: str, *args: str) -> None:
+        """
+        Receive and dispatch a ZMP message.
+
+        Auto-responds to ``zmp.check`` and ``zmp.send-support``.
+        Stores latest value for each command in ``writer.ctx.zmp_data``.
+        """
+        self.log.debug("ZMP: %s %r", command, args)
+        self.writer.ctx.zmp_data[command] = list(args)
+        if command == "zmp.check" and args:
+            cmd = args[0]
+            self._respond_zmp_support(cmd)
+        elif command == "zmp.send-support":
+            if args:
+                for cmd in args:
+                    self._respond_zmp_support(cmd)
+            elif not self._zmp_ident_sent:
+                for cmd in sorted(self._zmp_supported_commands):
+                    self._respond_zmp_support(cmd)
+
+    def _respond_zmp_support(self, cmd: str) -> None:
+        """Send ``zmp.support`` or ``zmp.no-support`` for *cmd*."""
+        if self.zmp_check(cmd):
+            self.writer.send_zmp("zmp.support", cmd)
+        else:
+            self.writer.send_zmp("zmp.no-support", cmd)
+
+    def zmp_check(self, cmd: str) -> bool:
+        """Return True if the client supports the given ZMP command."""
+        if self._zmp_check_handler is not None:
+            return self._zmp_check_handler(cmd)
+        return False
+
     def send_ttype(self) -> str:
         """Callback for responding to TTYPE requests."""
         result: str = self._extra["term"]
@@ -688,7 +741,7 @@ async def run_client() -> None:
                 client.writer.always_dont = always_dont
             from .telopt import GMCP as _GMCP
 
-            client.writer.passive_do = {_GMCP}
+            client.writer.passive_do.add(_GMCP)
             client.writer.environ_encoding = environ_encoding
             client.writer._encoding_explicit = encoding_explicit
 

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/telnetlib3/client_base.py

@@ -226,8 +226,6 @@ class BaseClient(TelnetProtocolBase, asyncio.streams.FlowControlMixin, asyncio.P
         Buffer incoming data and schedule async processing to keep the event loop responsive. Apply
         read-side backpressure using transport.pause_reading()/resume_reading().
         """
-        if self.log.isEnabledFor(TRACE):
-            self.log.log(TRACE, "recv %d bytes\n%s", len(data), hexdump(data, prefix="<<  "))
         self._last_received = datetime.datetime.now()
 
         # Detect SyncTERM font switching sequences and auto-switch encoding.
@@ -354,6 +352,19 @@ class BaseClient(TelnetProtocolBase, asyncio.streams.FlowControlMixin, asyncio.P
 
     # private methods
 
+    def _trace_recv(self, data: bytes, decompressed: bool = False) -> None:
+        """
+        Log received bytes at TRACE level.
+
+        :param data: Bytes received from the transport.
+        :param decompressed: True when *data* is the MCCP2-decompressed telnet stream; the raw
+            compressed bytes are not logged.
+        """
+        if not data or not self.log.isEnabledFor(TRACE):
+            return
+        label = " (decompressed)" if decompressed else ""
+        self.log.log(TRACE, "recv %d bytes%s\n%s", len(data), label, hexdump(data, prefix="<<  "))
+
     def _process_chunk(self, data: bytes) -> bool:
         """Process a chunk of received bytes; return True if any IAC/SB cmd observed."""
         self._last_received = datetime.datetime.now()
@@ -380,14 +391,15 @@ class BaseClient(TelnetProtocolBase, asyncio.streams.FlowControlMixin, asyncio.P
             if self._mccp2_decompressor.eof:
                 unused = self._mccp2_decompressor.unused_data
                 self._mccp2_end()
-                cmd = self._process_chunk_inner(data)
+                cmd = self._process_chunk_inner(data, decompressed=True)
                 if unused:
                     cmd = self._process_chunk(unused) or cmd
                 return cmd
+            return self._process_chunk_inner(data, decompressed=True)
 
         return self._process_chunk_inner(data)
 
-    def _process_chunk_inner(self, data: bytes) -> bool:
+    def _process_chunk_inner(self, data: bytes, decompressed: bool = False) -> bool:
         """Inner chunk processing with IAC interpretation and mid-chunk MCCP2 detection."""
         try:
             mode = self.writer.mode
@@ -408,9 +420,17 @@ class BaseClient(TelnetProtocolBase, asyncio.streams.FlowControlMixin, asyncio.P
         if self.writer._compressed_remainder is not None:
             remainder = self.writer._compressed_remainder
             self.writer._compressed_remainder = None
+            if not decompressed:
+                # The chunk activating MCCP2 mixes plain telnet and compressed
+                # bytes; trace only the plain prefix here, the compressed
+                # remainder is traced after decompression by the recursive
+                # _process_chunk() call.
+                self._trace_recv(data[: len(data) - len(remainder)])
             self._mccp2_start()
             if remainder:
                 cmd_received = self._process_chunk(remainder) or cmd_received
+        else:
+            self._trace_recv(data, decompressed=decompressed)
 
         # MCCP3: start compressor when writer signals activation
         if self.writer.mccp3_active and self._mccp3_compressor is None:

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/telnetlib3/client_shell.py

@@ -579,6 +579,8 @@ async def _raw_event_loop(
                 if raw_mode is None and want_repl():
                     state.reactivate_repl = True
             stdout.write(out.encode())
+            if hasattr(stdout, "drain"):
+                await stdout.drain()
             _ts_file = telnet_writer.ctx.typescript_file
             if _ts_file is not None:
                 _ts_file.write(out)

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/telnetlib3/mud.py

@@ -40,6 +40,7 @@ __all__ = (
     "mssp_encode",
     "mssp_decode",
     "MsdpParser",
+    "zmp_encode",
     "zmp_decode",
     "atcp_decode",
     "aardwolf_decode",
@@ -276,6 +277,24 @@ def mssp_decode(buf: bytes, encoding: str = "utf-8") -> dict[str, str | list[str
     return result
 
 
+def zmp_encode(command: str, *args: str) -> bytes:
+    r"""
+    Encode a ZMP message.
+
+    :param command: ZMP command name (e.g., ``"zmp.ident"``).
+    :param args: Zero or more argument strings.
+    :returns: NUL-delimited payload bytes suitable for ZMP subnegotiation.
+
+    Example::
+
+        >>> zmp_encode("zmp.ident", "telnetlib3", "1.0")
+        b'zmp.ident\\x00telnetlib3\\x001.0\\x00'
+    """
+    parts = [command.encode("utf-8")]
+    parts.extend(a.encode("utf-8") for a in args)
+    return b"\x00".join(parts) + b"\x00"
+
+
 def zmp_decode(buf: bytes, encoding: str = "utf-8") -> list[str]:
     """
     Decode ZMP payload to list of NUL-delimited strings.

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/telnetlib3/server_base.py

@@ -188,14 +188,25 @@ class BaseServer(TelnetProtocolBase, asyncio.streams.FlowControlMixin, asyncio.P
                 loop = asyncio.get_event_loop()
                 loop.create_task(coro)
 
+    def _trace_recv(self, data: bytes, decompressed: bool = False) -> None:
+        """
+        Log received bytes at TRACE level.
+
+        :param data: Bytes received from the transport.
+        :param decompressed: True when *data* is the MCCP3-decompressed telnet stream; the raw
+            compressed bytes are not logged.
+        """
+        if not data or not logger.isEnabledFor(TRACE):
+            return
+        label = " (decompressed)" if decompressed else ""
+        logger.log(TRACE, "recv %d bytes%s\n%s", len(data), label, hexdump(data, prefix="<<  "))
+
     def data_received(self, data: bytes) -> None:
         """
         Process bytes received by transport.
 
         Feeds raw bytes through the writer's IAC interpreter, forwarding in-band data to the reader.
         """
-        if logger.isEnabledFor(TRACE):
-            logger.log(TRACE, "recv %d bytes\n%s", len(data), hexdump(data, prefix="<<  "))
         self._last_received = datetime.datetime.now()
         self._rx_bytes += len(data)
 
@@ -207,12 +218,15 @@ class BaseServer(TelnetProtocolBase, asyncio.streams.FlowControlMixin, asyncio.P
                 logger.warning("MCCP3 decompression error, disabling")
                 self._mccp3_end()
                 return
+            self._trace_recv(data, decompressed=True)
             if self._mccp3_decompressor.eof:
                 unused = self._mccp3_decompressor.unused_data
                 self._mccp3_end()
                 if unused:
                     self.data_received(unused)
                     return
+        else:
+            self._trace_recv(data)
 
         if self.writer.slc_simulated:
             slc_vals = {defn.val[0] for defn in self.writer.slctab.values() if defn.val != theNULL}

{telnetlib3-4.0.4 → telnetlib3-5.0.0}/telnetlib3/server_fingerprinting.py

@@ -513,6 +513,13 @@ async def _fingerprint_session(
     start_time = time.time()
     cursor = _VirtualCursor(encoding=writer.environ_encoding)
 
+    # Accept all MUD protocol WILL requests so we can collect
+    # subnegotiation data (ATCP, AARDWOLF, MXP, MSP, etc.).
+    from telnetlib3.telopt import MSP, MXP, ATCP, MSDP, MSSP, AARDWOLF
+
+    for opt in (ATCP, AARDWOLF, MSP, MXP, MSDP, MSSP):
+        writer.passive_do.add(opt)
+
     # 1. Let straggler negotiation settle -- read (and respond to DSR)
     #    instead of sleeping blind so early DSR requests get a CPR reply.
     settle_data = await _read_banner_until_quiet(
@@ -629,8 +636,8 @@ async def _fingerprint_session(
             "dsr_replies": cursor.dsr_replies,
         }
     )
-    if writer.mssp_data is not None:
-        session_data["mssp"] = writer.mssp_data
+    if writer.ctx.mssp_data is not None:
+        session_data["mssp"] = writer.ctx.mssp_data
     session_data.update(_collect_mud_data(writer))
 
     session_entry: dict[str, Any] = {
@@ -966,18 +973,18 @@ def _create_server_protocol_fingerprint(
 
 
 def _collect_mud_data(writer: TelnetWriter) -> dict[str, Any]:
-    """Collect MUD protocol data from *writer* into a dict."""
+    """Collect MUD protocol data from *writer.ctx* into a dict."""
     result: dict[str, Any] = {}
-    if writer.zmp_data:
-        result["zmp"] = writer.zmp_data
-    if writer.atcp_data:
-        result["atcp"] = [{"package": pkg, "value": val} for pkg, val in writer.atcp_data]
-    if writer.aardwolf_data:
-        result["aardwolf"] = writer.aardwolf_data
-    if writer.mxp_data:
-        result["mxp"] = [d.hex() if d else "activated" for d in writer.mxp_data]
-    if writer.comport_data:
-        result["comport"] = writer.comport_data
+    if writer.ctx.zmp_data:
+        result["zmp"] = writer.ctx.zmp_data
+    if writer.ctx.atcp_data:
+        result["atcp"] = [{"package": pkg, "value": val} for pkg, val in writer.ctx.atcp_data]
+    if writer.ctx.aardwolf_data:
+        result["aardwolf"] = writer.ctx.aardwolf_data
+    if writer.ctx.mxp_data:
+        result["mxp"] = [d.hex() if d else "activated" for d in writer.ctx.mxp_data]
+    if writer.ctx.comport_data:
+        result["comport"] = writer.ctx.comport_data
     return result
 
 
@@ -1099,10 +1106,10 @@ def _format_banner(data: bytes, encoding: str = "utf-8") -> str:
 
 async def _await_mssp_data(writer: TelnetWriter, deadline: float) -> None:
     """Wait for MSSP data until *deadline* if server acknowledged MSSP."""
-    if not writer.remote_option.enabled(MSSP) or writer.mssp_data is not None:
+    if not writer.remote_option.enabled(MSSP) or writer.ctx.mssp_data is not None:
         return
     remaining = deadline - time.time()
-    while remaining > 0 and writer.mssp_data is None:
+    while remaining > 0 and writer.ctx.mssp_data is None:
         await asyncio.sleep(min(0.05, remaining))
         remaining = deadline - time.time()