adbproxy 0.1.0__py3-none-any.whl

adbproxy/protocols/smart_socket/handshake.py

@@ -0,0 +1,75 @@
+"""Backend smart-socket handshake sequencer helpers (pure framing, no I/O).
+
+Blocking handshake stays in AdbClientBackend.start(): send frame → recv exact
+status → optional FAIL body. This module only builds frames and interprets
+status/hex4 words — never a multi-shape incremental conversation loop.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from adbproxy.protocols.smart_socket.wire import (
+    FAIL,
+    OKAY,
+    decode_hex4,
+    format_service_frame,
+    parse_status,
+)
+
+
+@dataclass(frozen=True)
+class HandshakeStatus:
+    """Result of interpreting a 4-byte smart-socket status word."""
+
+    word: str  # "OKAY" | "FAIL" | other decoded
+    ok: bool
+    fail: bool
+    valid: bool  # True when word is exactly OKAY or FAIL
+
+
+class SmartSocketHandshake:
+    """Client-side handshake helpers for adb server smart-socket.
+
+    One logical use per stream: tport frame → status → service frame → status.
+    """
+
+    @staticmethod
+    def build_transport_frame(serial: str) -> bytes:
+        """Encode ``host:transport:<serial>`` smart-socket frame."""
+        return format_service_frame(f"host:transport:{serial}")
+
+    @staticmethod
+    def build_service_frame(service: bytes | str) -> bytes:
+        """Encode service smart-socket frame; raises ValueError if body > 0xffff."""
+        return format_service_frame(service)
+
+    @staticmethod
+    def interpret_status(data: bytes | bytearray | memoryview) -> HandshakeStatus:
+        """Interpret exactly 4 bytes as OKAY/FAIL (or invalid)."""
+        raw = bytes(data)
+        if len(raw) != 4:
+            return HandshakeStatus(word="", ok=False, fail=False, valid=False)
+        try:
+            word = parse_status(raw)
+        except ValueError:
+            word = raw.decode("ascii", errors="ignore")
+            return HandshakeStatus(word=word, ok=False, fail=False, valid=False)
+        return HandshakeStatus(
+            word=word,
+            ok=word == "OKAY",
+            fail=word == "FAIL",
+            valid=True,
+        )
+
+    @staticmethod
+    def decode_fail_length(hex4: bytes | bytearray | memoryview) -> int | None:
+        """Decode FAIL protocol-string length prefix; None if invalid hex4."""
+        try:
+            return decode_hex4(hex4)
+        except ValueError:
+            return None
+
+    # re-export status constants for backend clarity
+    OKAY = OKAY
+    FAIL = FAIL

adbproxy/protocols/smart_socket/wire.py

@@ -0,0 +1,82 @@
+"""Pure smart-socket wire primitives: OKAY/FAIL, hex4, protocol-string frames.
+
+No I/O, no policy, no connection state. Shared by server conversation and
+backend handshake (encode/decode only).
+"""
+
+from __future__ import annotations
+
+OKAY = b"OKAY"
+FAIL = b"FAIL"
+_STATUS_VALUES = {OKAY, FAIL}
+
+
+def encode_hex4(length: int) -> bytes:
+    """Encode a non-negative integer as 4 ASCII hex digits (big-endian nibble text)."""
+    if length < 0 or length > 0xFFFF:
+        raise ValueError(f"hex4 length out of range: {length}")
+    return f"{length:04x}".encode("ascii")
+
+
+def decode_hex4(data: bytes | bytearray | memoryview) -> int:
+    """Decode exactly 4 ASCII hex digits to int. Raises ValueError on bad input."""
+    raw = bytes(data)
+    if len(raw) != 4:
+        raise ValueError(f"hex4 requires exactly 4 bytes, got {len(raw)}")
+    try:
+        return int(raw.decode("ascii"), 16)
+    except (UnicodeDecodeError, ValueError) as exc:
+        raise ValueError(f"invalid hex4: {raw!r}") from exc
+
+
+def try_parse_hex4_length_prefix(
+    buf: bytes | bytearray | memoryview,
+) -> tuple[int, bytes] | None:
+    """If buf starts with a complete hex4 length prefix, return (length, rest).
+
+    Returns None when fewer than 4 bytes are available. Raises ValueError when
+    the 4-byte prefix is not valid ASCII hex.
+    """
+    raw = bytes(buf)
+    if len(raw) < 4:
+        return None
+    length = decode_hex4(raw[:4])
+    return length, raw[4:]
+
+
+def encode_protocol_string(body: bytes | str) -> bytes:
+    """Encode a length-prefixed protocol string: <hex4><body>."""
+    raw = body.encode("utf-8") if isinstance(body, str) else bytes(body)
+    if len(raw) > 0xFFFF:
+        raise ValueError(f"protocol-string body too large: {len(raw)}")
+    return encode_hex4(len(raw)) + raw
+
+
+def format_service_frame(service: bytes | str) -> bytes:
+    """Encode smart-socket ``<hex4><body>``; body must be ≤ 0xffff bytes."""
+    body = service.encode("utf-8") if isinstance(service, str) else bytes(service)
+    if len(body) > 0xFFFF:
+        raise ValueError(f"smart-socket service body too large: {len(body)}")
+    return encode_hex4(len(body)) + body
+
+
+def parse_status(data: bytes | bytearray | memoryview) -> str:
+    """Parse a 4-byte status word into 'OKAY' or 'FAIL'. Raises ValueError otherwise."""
+    raw = bytes(data)
+    if len(raw) != 4:
+        raise ValueError(f"status requires exactly 4 bytes, got {len(raw)}")
+    if raw not in _STATUS_VALUES:
+        raise ValueError(f"invalid status word: {raw!r}")
+    return raw.decode("ascii")
+
+
+def try_parse_status(buf: bytes | bytearray | memoryview) -> tuple[str, bytes] | None:
+    """If buf has ≥4 bytes, parse the leading status word and return (status, rest).
+
+    Returns None when fewer than 4 bytes are available. Raises ValueError on an
+    invalid 4-byte status word.
+    """
+    raw = bytes(buf)
+    if len(raw) < 4:
+        return None
+    return parse_status(raw[:4]), raw[4:]

adbproxy/protocols/transport/__init__.py

@@ -0,0 +1,52 @@
+"""Transport protocol package (constants / errors / codec).
+
+Public surface remains ``from adbproxy.protocols.transport import ...``.
+"""
+
+from adbproxy.protocols.transport.codec import TransportCodec
+from adbproxy.protocols.transport.constants import (
+    A_AUTH,
+    A_CLSE,
+    A_CNXN,
+    A_OKAY,
+    A_OPEN,
+    A_STLS,
+    A_VERSION,
+    A_VERSION_MIN,
+    A_VERSION_SKIP_CHECKSUM,
+    A_WRTE,
+    DEFAULT_ADB_SERVER_PORT,
+    DEFAULT_BANNER_FEATURES,
+    DEFAULT_LISTEN_PORT,
+    HEADER_FMT,
+    HEADER_SIZE,
+    LOCAL_MAXDATA,
+    MAX_PAYLOAD,
+    MAX_PAYLOAD_V1,
+    MAX_SEND_QUEUE,
+)
+from adbproxy.protocols.transport.errors import TransportProtocolError
+
+__all__ = [
+    "A_AUTH",
+    "A_CLSE",
+    "A_CNXN",
+    "A_OKAY",
+    "A_OPEN",
+    "A_STLS",
+    "A_VERSION",
+    "A_VERSION_MIN",
+    "A_VERSION_SKIP_CHECKSUM",
+    "A_WRTE",
+    "DEFAULT_ADB_SERVER_PORT",
+    "DEFAULT_BANNER_FEATURES",
+    "DEFAULT_LISTEN_PORT",
+    "HEADER_FMT",
+    "HEADER_SIZE",
+    "LOCAL_MAXDATA",
+    "MAX_PAYLOAD",
+    "MAX_PAYLOAD_V1",
+    "MAX_SEND_QUEUE",
+    "TransportCodec",
+    "TransportProtocolError",
+]

adbproxy/protocols/transport/codec.py

@@ -0,0 +1,90 @@
+"""Transport 24B header encode/decode + streaming framing."""
+
+from __future__ import annotations
+
+import struct
+
+from adbproxy.protocols.transport.constants import (
+    A_VERSION,
+    A_VERSION_MIN,
+    A_VERSION_SKIP_CHECKSUM,
+    HEADER_FMT,
+    HEADER_SIZE,
+    LOCAL_MAXDATA,
+    MAX_PAYLOAD,
+    MAX_PAYLOAD_V1,
+)
+from adbproxy.protocols.transport.errors import TransportProtocolError
+
+
+class TransportCodec:
+    """传输协议 24B 头编解码 + 流式分帧。自包含，可单独搬迁。
+    头格式（little-endian 6×uint32）：command, arg0, arg1, data_length, data_check, magic。
+    magic = command ^ 0xFFFFFFFF；data_check = sum(payload) & 0xFFFFFFFF（adb.cpp:113-119）。"""
+
+    def __init__(self):
+        self.buf = bytearray()
+        self.max_payload = MAX_PAYLOAD_V1  # 握手前 4KB，CNXN 后按双端 maxdata 协商裁剪
+        self.protocol_version = A_VERSION_MIN
+
+    def negotiate(self, peer_version, peer_maxdata):
+        """按 AOSP update_version 协商协议版本和 payload 上限。"""
+        self.protocol_version = min(peer_version, A_VERSION)
+        self.set_max_payload(peer_maxdata)
+
+    def encode(self, command, arg0, arg1, payload=b""):
+        """按已协商版本决定是否省略 outgoing checksum。"""
+        checksum_enabled = self.protocol_version < A_VERSION_SKIP_CHECKSUM
+        return self.pack(
+            command,
+            arg0,
+            arg1,
+            payload,
+            checksum_enabled=checksum_enabled,
+        )
+
+    def set_max_payload(self, peer_maxdata):
+        """CNXN 握手后协商 max_payload = min(双端 maxdata, 1MB)。"""
+        self.max_payload = min(peer_maxdata, LOCAL_MAXDATA, MAX_PAYLOAD)
+
+    @staticmethod
+    def pack(command, arg0, arg1, payload=b"", *, checksum_enabled=True):
+        """组 24B 头 + payload。checksum = sum(payload)&0xFFFFFFFF（无 payload 为 0）。"""
+        data_len = len(payload)
+        checksum = (
+            (sum(payload) & 0xFFFFFFFF) if payload and checksum_enabled else 0
+        )
+        magic = command ^ 0xFFFFFFFF
+        header = struct.pack(HEADER_FMT, command, arg0, arg1, data_len, checksum, magic)
+        return header + payload
+
+    @staticmethod
+    def unpack_header(buf):
+        """解 24B 头 -> (cmd,arg0,arg1,dlen,chk,magic)。"""
+        return struct.unpack(HEADER_FMT, bytes(buf[:HEADER_SIZE]))
+
+    def feed(self, chunk):
+        """流式累积字节 -> 产出完整 apacket 列表。apacket = (cmd,arg0,arg1,payload:bytes)。
+        半包头/半 payload 留 buf 续接。magic 不匹配/长度越界：抛出终止性协议错误。"""
+        packets = []
+        self.buf.extend(chunk)
+        while True:
+            if len(self.buf) < HEADER_SIZE:
+                break
+            cmd, arg0, arg1, dlen, chk, magic = struct.unpack(
+                HEADER_FMT, bytes(self.buf[:HEADER_SIZE])
+            )
+            if magic != (cmd ^ 0xFFFFFFFF):
+                raise TransportProtocolError(
+                    f"invalid transport magic: command=0x{cmd:08x} magic=0x{magic:08x}"
+                )
+            if dlen > self.max_payload:
+                raise TransportProtocolError(
+                    f"transport payload {dlen} exceeds max {self.max_payload}"
+                )
+            if len(self.buf) < HEADER_SIZE + dlen:
+                break  # 半包，等 payload 收齐
+            payload = bytes(self.buf[HEADER_SIZE : HEADER_SIZE + dlen])
+            del self.buf[: HEADER_SIZE + dlen]
+            packets.append((cmd, arg0, arg1, payload))
+        return packets

adbproxy/protocols/transport/constants.py

@@ -0,0 +1,21 @@
+"""Transport protocol constants (AOSP-aligned command words and limits)."""
+
+A_CNXN = 0x4E584E43
+A_AUTH = 0x48545541
+A_OPEN = 0x4E45504F
+A_OKAY = 0x59414B4F
+A_CLSE = 0x45534C43
+A_WRTE = 0x45545257
+A_STLS = 0x534C5453
+A_VERSION_MIN = 0x01000000
+A_VERSION_SKIP_CHECKSUM = 0x01000001
+A_VERSION = 0x01000001
+MAX_PAYLOAD_V1 = 4 * 1024  # adb.h:33，握手前未知对端 maxdata
+MAX_PAYLOAD = 1024 * 1024  # adb.h:34
+LOCAL_MAXDATA = 0x40000  # 256KB，本端 maxdata（adb.cpp send_connect arg1）
+HEADER_FMT = "<6I"  # 24B 头 little-endian 6×uint32
+HEADER_SIZE = 24  # struct.calcsize(HEADER_FMT)
+MAX_SEND_QUEUE = 4 * LOCAL_MAXDATA  # 发送队列背压上限，超限关流 CLSE
+DEFAULT_LISTEN_PORT = 5566
+DEFAULT_ADB_SERVER_PORT = 5037
+DEFAULT_BANNER_FEATURES = "shell_v2,sendrecv_v2"  # 显式不含 delayed_ack

adbproxy/protocols/transport/errors.py

@@ -0,0 +1,5 @@
+"""Transport protocol errors."""
+
+
+class TransportProtocolError(ValueError):
+    """传输头不可恢复时终止当前 transport。"""

adbproxy/runtime/__init__.py

@@ -0,0 +1 @@
+"""socket、日志、抓取和进程运行时工具。"""

adbproxy/runtime/adb_process.py

@@ -0,0 +1,195 @@
+import socket
+import subprocess
+import time
+
+
+def probe_adb_server(port):
+    """仅探测端口是否可连接；探活结果本身不代表进程所有权。"""
+    sock = None
+    try:
+        sock = socket.create_connection(("127.0.0.1", port), timeout=0.5)
+        return True
+    except OSError:
+        return False
+    finally:
+        if sock is not None:
+            try:
+                sock.close()
+            except Exception:
+                pass
+
+
+class AdbServerLease:
+    """记录本进程对 adb server 执行过的动作，并只撤销有证据的所有权。"""
+
+    def __init__(
+        self,
+        managed_port,
+        restore_port=None,
+        *,
+        runner=None,
+        probe=None,
+        sleeper=None,
+        probe_attempts=50,
+        probe_interval=0.1,
+        cleanup_attempts=3,
+        log=None,
+    ):
+        self.managed_port = managed_port
+        self.restore_port = restore_port
+        self.runner = runner or subprocess.run
+        self.probe = probe or probe_adb_server
+        self.sleeper = sleeper or time.sleep
+        self.probe_attempts = probe_attempts
+        self.probe_interval = probe_interval
+        self.cleanup_attempts = cleanup_attempts
+        self.log = log or (lambda _message: None)
+        self.initial_state = None
+        self.stopped_by_us = False
+        self.started_by_us = False
+        self.restore_required = False
+        self.preflight_absent = False
+        self.start_command_succeeded = False
+        self.post_start_ready = False
+        self._cleaned = False
+
+    def _command(self, action, port):
+        if port == 5037:
+            return ["adb", f"{action}-server"]
+        return ["adb", "-P", str(port), f"{action}-server"]
+
+    def _run(self, command, timeout):
+        try:
+            result = self.runner(
+                command,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=timeout,
+            )
+        except subprocess.TimeoutExpired:
+            self.log(f"[!] adb 调用超时: {' '.join(command)}")
+            return False
+        except FileNotFoundError:
+            self.log(f"[!] adb 未找到: {' '.join(command)}")
+            return False
+        if result.returncode != 0:
+            self.log(
+                f"[!] adb 命令失败 returncode={result.returncode}: {' '.join(command)}"
+            )
+            return False
+        return True
+
+    def _wait_for(self, port, expected):
+        for attempt in range(self.probe_attempts):
+            if bool(self.probe(port)) is expected:
+                return True
+            if attempt + 1 < self.probe_attempts:
+                self.sleeper(self.probe_interval)
+        return False
+
+    def acquire_owned(self):
+        """为单端口启动场景获取 lease；预先存在的实例绝不接管。"""
+        initially_running = bool(self.probe(self.managed_port))
+        self.initial_state = "running" if initially_running else "absent"
+        if initially_running:
+            self.log(
+                f"[!] adb server :{self.managed_port} 已存在，拒绝推断或接管所有权"
+            )
+            return False
+        self.preflight_absent = True
+        return self.start_owned()
+
+    def prepare_takeover(self):
+        """代理接管前先确认后端端口为空，再按证据停止需恢复的默认实例。"""
+        if self.restore_port is None:
+            raise ValueError("restore_port is required for takeover")
+        managed_running = bool(self.probe(self.managed_port))
+        restore_running = bool(self.probe(self.restore_port)) if not managed_running else None
+        self.initial_state = {
+            "managed": "running" if managed_running else "absent",
+            "restore": (
+                "unknown"
+                if restore_running is None
+                else ("running" if restore_running else "absent")
+            ),
+        }
+        if managed_running:
+            self.log(
+                f"[!] adb server :{self.managed_port} 已存在，停止默认实例前终止接管"
+            )
+            return False
+        self.preflight_absent = True
+        if not restore_running:
+            return True
+        if not self._run(self._command("kill", self.restore_port), timeout=5):
+            return False
+        if not self._wait_for(self.restore_port, False):
+            self.log(f"[!] adb server :{self.restore_port} 停止后仍可连接")
+            return False
+        self.stopped_by_us = True
+        self.restore_required = True
+        return True
+
+    def start_owned(self):
+        """仅在 preflight 已证明端口为空时启动并提交所有权。"""
+        if not self.preflight_absent:
+            self.log("[!] 缺少 preflight absent 证据，拒绝启动 adb server")
+            return False
+        if not self._run(self._command("start", self.managed_port), timeout=10):
+            return False
+        self.start_command_succeeded = True
+        if not self._wait_for(self.managed_port, True):
+            self.log(f"[!] adb server :{self.managed_port} 启动后探活失败，回滚")
+            self._rollback_started_command()
+            return False
+        self.post_start_ready = True
+        self.started_by_us = True
+        return True
+
+    def _rollback_started_command(self):
+        if not (self.preflight_absent and self.start_command_succeeded):
+            return True
+        if not self._cleanup_action("kill", self.managed_port, 5, False):
+            self.log(
+                f"[!] adb server :{self.managed_port} 回滚未完成；保留启动证据供 cleanup 重试"
+            )
+            return False
+        self.start_command_succeeded = False
+        self.started_by_us = False
+        self.post_start_ready = False
+        return True
+
+    def _cleanup_action(self, action, port, timeout, expected_running):
+        """有界重试清理动作；命令和端口状态都成功后才提交 ledger。"""
+        command = self._command(action, port)
+        for attempt in range(self.cleanup_attempts):
+            if self._run(command, timeout=timeout):
+                if self._wait_for(port, expected_running):
+                    return True
+                self.log(
+                    f"[!] adb server :{port} 执行 {action} 后状态未达到预期"
+                )
+            if attempt + 1 < self.cleanup_attempts:
+                self.sleeper(self.probe_interval)
+        return False
+
+    def cleanup(self):
+        """幂等撤销 action ledger；失败时保留证据，允许后续再次清理。"""
+        if self._cleaned:
+            return True
+        complete = True
+        if self.started_by_us or self.start_command_succeeded:
+            if self._cleanup_action("kill", self.managed_port, 5, False):
+                self.started_by_us = False
+                self.start_command_succeeded = False
+                self.post_start_ready = False
+            else:
+                complete = False
+        if self.restore_required and self.restore_port is not None:
+            if self._cleanup_action("start", self.restore_port, 10, True):
+                self.restore_required = False
+                self.stopped_by_us = False
+            else:
+                complete = False
+        self._cleaned = complete
+        return complete

adbproxy/runtime/capture.py

@@ -0,0 +1,41 @@
+import os
+import threading
+import time
+
+
+_CAPTURE_NAME_LOCK = threading.Lock()
+_CAPTURE_NAME_COUNTER = 0
+
+
+def _next_capture_token():
+    """生成进程内单调且含纳秒时间的抓包名 token（无 pid）。
+
+    形态：``{time_ns}-{seq}``。seq 为进程内成功打开 capture 的单调序号。
+    """
+    global _CAPTURE_NAME_COUNTER
+    with _CAPTURE_NAME_LOCK:
+        _CAPTURE_NAME_COUNTER += 1
+        counter = _CAPTURE_NAME_COUNTER
+    return f"{time.time_ns()}-{counter}"
+
+
+def open_unique_capture(directory, prefix, suffix):
+    """以排他创建方式打开抓包文件，避免并发同名覆盖。
+
+    最终名：``{prefix}-{time_ns}-{seq}{suffix}``。
+    """
+    os.makedirs(directory, exist_ok=True)
+    while True:
+        name = f"{prefix}-{_next_capture_token()}{suffix}"
+        path = os.path.join(directory, name)
+        try:
+            return path, open(path, "xb")
+        except FileExistsError:
+            continue
+
+
+def reserve_unique_capture_path(directory, prefix, suffix):
+    """为后续原子 rename 排他预留唯一目标路径。"""
+    path, fp = open_unique_capture(directory, prefix, suffix)
+    fp.close()
+    return path

adbproxy/runtime/logging.py

@@ -0,0 +1,113 @@
+import threading
+
+
+class FileLogger:
+    """进程级共享文件写入器，持锁串行；日志失败时自动降级为静默。"""
+
+    def __init__(self, path):
+        self.lock = threading.Lock()
+        try:
+            self.file = open(path, "a", encoding="utf-8")
+        except Exception:
+            self.file = None
+
+    def write(self, line):
+        if self.file is None:
+            return
+        try:
+            with self.lock:
+                self.file.write(line + "\n")
+                self.file.flush()
+        except Exception:
+            pass
+
+    def close(self):
+        try:
+            if self.file is not None:
+                self.file.close()
+        except Exception:
+            pass
+
+
+class DebugHexLogger:
+    """P0: 原始 hex 落盘器（per-proxy 单文件）。每 recv 一块写一行 hex + 一个递增 line_no。
+    sendall 原样转发在前，本类仅旁路落盘，写盘异常内化不阻断转发。自包含，可单独搬迁。
+
+    行格式（一个 line_no = 一块 recv）：
+      # L{line_no} Conn#{conn_id} dir={c|s} len={n}\n{hexdump}\n
+    hexdump 内部按 16 字节折行可读（带 ASCII 侧栏），共用块首 line_no。"""
+
+    def __init__(self, path):
+        self.lock = threading.Lock()
+        self.line_no = 0
+        try:
+            self.file = open(path, "a", encoding="utf-8")
+        except Exception:
+            self.file = None
+
+    def write_hex(self, conn_id, direction, data):
+        """落盘一块 hex，返回块首 line_no。direction: "c"(client→server)/"s"(server→client)。
+        异常降级：只返回当前 line_no 不抛（调用方仅用于打提示，失败已在内化）。"""
+        try:
+            if self.file is None:
+                return self.line_no
+            with self.lock:
+                self.line_no += 1
+                ln = self.line_no
+                d = direction if direction in ("c", "s") else "?"
+                self.file.write(f"# L{ln} Conn#{conn_id} dir={d} len={len(data)}\n")
+                self.file.write(self._hexdump(data))
+                self.file.write("\n")
+                self.file.flush()
+            return ln
+        except Exception:
+            return self.line_no  # 写盘失败降级，不阻断转发
+
+    @staticmethod
+    def _hexdump(data):
+        """按 16 字节折行 hex + ASCII 侧栏（可读）。空数据返回空串。"""
+        if not data:
+            return ""
+        lines = []
+        n = len(data)
+        for off in range(0, n, 16):
+            chunk = data[off : off + 16]
+            hexs = " ".join(f"{b:02x}" for b in chunk)
+            ascii_ = "".join(chr(b) if 0x20 <= b < 0x7F else "." for b in chunk)
+            lines.append(f"{off:04x}  {hexs:<47}  |{ascii_}|")
+        return "\n".join(lines) + "\n"
+
+    def close(self):
+        try:
+            if self.file is not None:
+                self.file.close()
+        except Exception:
+            pass
+
+
+class Logger:
+    """per-conn 日志门面：正常时 tee 到控制台和文件，任一输出失败均静默降级。"""
+
+    def __init__(self, conn_id, file_logger):
+        self.conn_id = conn_id
+        self.fl = file_logger
+
+    def _fmt(self, msg):
+        return f"[Conn #{self.conn_id}] {msg}"
+
+    def _write(self, msg):
+        line = self._fmt(msg)
+        try:
+            print(line)
+        except Exception:
+            pass
+        try:
+            self.fl.write(line)
+        except Exception:
+            pass
+
+    def event(self, msg):
+        self._write(msg)
+
+    def debug(self, msg):
+        self._write(msg)