adbproxy 0.1.0__py3-none-any.whl

adbproxy/device/session.py

@@ -0,0 +1,304 @@
+"""Device transport session decision layer (Track 2b).
+
+``AdbdSession.receive`` / ``on_session_event`` produce TransportAction lists.
+No socket I/O, no thread join, no ``_try_flush`` algorithm.
+Connection executes actions and owns flush/backpressure.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from adbproxy.device.banner import build_cnxn_banner
+from adbproxy.protocols.transport import (
+    A_AUTH,
+    A_CLSE,
+    A_CNXN,
+    A_OKAY,
+    A_OPEN,
+    A_STLS,
+    A_VERSION,
+    A_WRTE,
+    LOCAL_MAXDATA,
+)
+
+
+# ---- TransportAction (plan §4.2.3 A) ----
+
+
+@dataclass(frozen=True)
+class Ignore:
+    reason: str = ""
+
+
+@dataclass(frozen=True)
+class RejectOpen:
+    peer_local: int
+
+
+@dataclass(frozen=True)
+class AcceptOpen:
+    peer_local: int
+    service: str
+
+
+@dataclass(frozen=True)
+class AttachObserver:
+    entry: Any  # StreamEntry
+    service: str
+
+
+@dataclass(frozen=True)
+class OpenBackend:
+    entry: Any
+    generation: int
+
+
+@dataclass(frozen=True)
+class SendPacket:
+    cmd: int
+    arg0: int
+    arg1: int
+    payload: bytes = b""
+    log_status: str | None = None
+
+
+@dataclass(frozen=True)
+class ForwardToBackend:
+    entry: Any
+    payload: bytes
+    also_okay: bool = True
+
+
+@dataclass(frozen=True)
+class QueueFromBackend:
+    entry: Any
+    data: bytes
+
+
+@dataclass(frozen=True)
+class SetCanSend:
+    entry: Any
+    value: bool = True
+    flush: bool = True
+
+
+@dataclass(frozen=True)
+class CloseStream:
+    entry: Any
+    send_clse: bool = True
+    close_arg0: int | None = None
+    close_arg1: int | None = None
+
+
+@dataclass(frozen=True)
+class MarkTransportTerminal:
+    reason: str
+
+
+@dataclass(frozen=True)
+class ResetStreamsForCnxn:
+    """Close all existing streams without sending CLSE (CNXN reset)."""
+
+    pass
+
+
+@dataclass(frozen=True)
+class NegotiateCodec:
+    version: int
+    peer_maxdata: int
+
+
+@dataclass(frozen=True)
+class LogEvent:
+    message: str
+
+
+# Session events from workers (plan §4.2.3 B)
+
+
+@dataclass(frozen=True)
+class BackendReady:
+    entry: Any
+    generation: int
+
+
+@dataclass(frozen=True)
+class BackendFailed:
+    entry: Any
+    generation: int
+
+
+class AdbdSession:
+    """Pure-ish decision engine for one front transport connection.
+
+    Holds CNXN flag, banner config, and stream_table reference. Mutates stream
+    table state under caller-held conventions; never performs socket I/O.
+    """
+
+    def __init__(
+        self,
+        stream_table,
+        *,
+        banner_features: str,
+        banner_type: str,
+        banner_product,
+        banner_model,
+        banner_device,
+        peer_maxdata: int,
+    ):
+        self.stream_table = stream_table
+        self.banner_features = banner_features
+        self.banner_type = banner_type
+        self.banner_product = banner_product
+        self.banner_model = banner_model
+        self.banner_device = banner_device
+        self.peer_maxdata = peer_maxdata
+        self._cnxn_done = False
+
+    @property
+    def cnxn_done(self) -> bool:
+        return self._cnxn_done
+
+    def receive(self, packet) -> list:
+        """Map one transport packet to a list of TransportAction."""
+        cmd, arg0, arg1, payload = packet
+        if cmd == A_CNXN:
+            return self._on_cnxn(arg0, arg1, payload)
+        if cmd == A_OPEN:
+            return self._on_open(arg0, arg1, payload)
+        if cmd == A_OKAY:
+            return self._on_okay(arg0, arg1, payload)
+        if cmd == A_WRTE:
+            return self._on_wrte(arg0, arg1, payload)
+        if cmd == A_CLSE:
+            return self._on_clse(arg0, arg1, payload)
+        if cmd == A_STLS:
+            return [MarkTransportTerminal("STLS/TLS 首版不支持")]
+        if cmd == A_AUTH:
+            return [MarkTransportTerminal("AUTH 配对模拟首版不支持")]
+        return [LogEvent(f"[!] 未知传输命令 0x{cmd:08x}")]
+
+    def on_session_event(self, event) -> list:
+        """Handle BackendReady / BackendFailed from worker threads."""
+        if isinstance(event, BackendReady):
+            return self._on_backend_ready(event.entry, event.generation)
+        if isinstance(event, BackendFailed):
+            return self._on_backend_failed(event.entry, event.generation)
+        return [Ignore(reason=f"unknown event {type(event)!r}")]
+
+    def _on_cnxn(self, arg0, arg1, payload) -> list:
+        actions: list = [ResetStreamsForCnxn()]
+        self._cnxn_done = False
+        self.peer_maxdata = arg1 or self.peer_maxdata
+        parts = payload.split(b"::", 1)
+        banner = parts[1].decode("utf-8", errors="replace") if len(parts) > 1 else ""
+        actions.append(LogEvent("========"))
+        actions.append(
+            LogEvent(f"📥 [CNXN]: version=0x{arg0:08x} maxdata={self.peer_maxdata}")
+        )
+        if banner:
+            actions.append(LogEvent(f"   banner: {banner}"))
+        actions.append(NegotiateCodec(arg0, self.peer_maxdata))
+        our_banner = build_cnxn_banner(
+            banner_type=self.banner_type,
+            features=self.banner_features,
+            product=self.banner_product,
+            model=self.banner_model,
+            device=self.banner_device,
+        )
+        actions.append(
+            SendPacket(
+                A_CNXN,
+                A_VERSION,
+                LOCAL_MAXDATA,
+                our_banner.encode("utf-8"),
+            )
+        )
+        self._cnxn_done = True
+        return actions
+
+    def _on_open(self, arg0, arg1, payload) -> list:
+        if not self._cnxn_done:
+            return [
+                LogEvent("[!] OPEN 在 CNXN 握手前到达，忽略该包"),
+                Ignore(reason="open_before_cnxn"),
+            ]
+        if arg0 == 0:
+            return [
+                LogEvent("[!] OPEN local ID 为 0，忽略该包"),
+                Ignore(reason="open_zero_local"),
+            ]
+        advertised_features = set((self.banner_features or "").split(","))
+        if arg1 != 0 and "delayed_ack" not in advertised_features:
+            return [
+                LogEvent(
+                    f"[!] OPEN send-buffer={arg1} 但未广告 delayed_ack，关闭该流"
+                ),
+                RejectOpen(peer_local=arg0),
+            ]
+        peer_local = arg0
+        service = payload.rstrip(b"\x00").decode("utf-8", errors="ignore")
+        entry = self.stream_table.allocate(peer_local, service)
+        entry.state = "opening"
+        entry.generation = entry.local_id
+        return [
+            AcceptOpen(peer_local=peer_local, service=service),
+            AttachObserver(entry=entry, service=service),
+            OpenBackend(entry=entry, generation=entry.generation),
+        ]
+
+    def _on_okay(self, arg0, arg1, payload) -> list:
+        entry = self.stream_table.find_by_pair(arg1, arg0)
+        if entry is None:
+            return [Ignore(reason="okay_unknown_pair")]
+        return [SetCanSend(entry=entry, value=True, flush=True)]
+
+    def _on_wrte(self, arg0, arg1, payload) -> list:
+        entry = self.stream_table.find_by_pair(arg1, arg0)
+        if entry is None:
+            return [Ignore(reason="wrte_unknown_pair")]
+        return [ForwardToBackend(entry=entry, payload=payload, also_okay=True)]
+
+    def _on_clse(self, arg0, arg1, payload) -> list:
+        entry = self.stream_table.find_by_pair(arg1, arg0)
+        if entry is None and arg0 == 0 and arg1:
+            candidate = self.stream_table.find_by_remote(arg1)
+            if candidate is not None and candidate.state == "opening":
+                entry = candidate
+        if entry is None:
+            return [Ignore(reason="clse_unknown")]
+        return [CloseStream(entry=entry)]
+
+    def _on_backend_ready(self, entry, generation) -> list:
+        current = self.stream_table.get(entry.local_id)
+        with entry.lock:
+            if (
+                current is not entry
+                or entry.generation != generation
+                or entry.closed
+                or entry.state != "opening"
+            ):
+                return [Ignore(reason="backend_ready_stale")]
+            entry.state = "ready"
+            entry.can_send = True
+        # OKAY first; connection flushes after send (SetCanSend flush=True)
+        return [
+            SendPacket(A_OKAY, entry.local_id, entry.remote_id),
+            SetCanSend(entry=entry, value=True, flush=True),
+        ]
+
+    def _on_backend_failed(self, entry, generation) -> list:
+        current = self.stream_table.get(entry.local_id)
+        with entry.lock:
+            if current is not entry or entry.generation != generation:
+                return [Ignore(reason="backend_failed_stale")]
+        return [
+            CloseStream(
+                entry=entry,
+                send_clse=True,
+                close_arg0=0,
+                close_arg1=entry.remote_id,
+            )
+        ]

adbproxy/device/stream_table.py

@@ -0,0 +1,125 @@
+"""Device transport stream registry (Track 2a).
+
+Dual-lock semantics (must preserve):
+- ``lock`` (registry): streams dict, next local id allocation, find/pop
+- ``entry.lock`` / ``entry.flow_cv``: per-stream queue, can_send, closed, flush wait
+
+No TransportAction; no flush algorithm.
+"""
+
+from __future__ import annotations
+
+import threading
+from collections import deque
+
+
+class StreamEntry:
+    """per-stream 状态：本端/对端 id、service、后端、v1 停等流控标志、幂等 closed、
+    per-stream StreamBuffer（隔离 shell/sync/install 解析，防多 stream 串流）。"""
+
+    __slots__ = (
+        "local_id",
+        "remote_id",
+        "service",
+        "back",
+        "can_send",
+        "back_eof",
+        "closed",
+        "send_queue",
+        "queued_bytes",
+        "lock",
+        "flow_cv",
+        "sb",
+        "state",
+        "generation",
+    )
+
+    def __init__(self, local_id, remote_id, service):
+        self.local_id = local_id
+        self.remote_id = remote_id
+        self.service = service
+        self.back = None
+        self.can_send = False
+        self.back_eof = False
+        self.closed = False
+        self.send_queue = deque()
+        self.queued_bytes = 0
+        self.lock = threading.Lock()
+        self.flow_cv = threading.Condition(self.lock)
+        self.sb = None
+        self.state = "ready"
+        self.generation = 0
+
+
+# Backward-compatible alias for tests that import ``_StreamEntry``.
+_StreamEntry = StreamEntry
+
+
+class StreamTable:
+    """Registry of open streams for one TransportConnection.
+
+    Owns the registry lock and stream map. Entry-level locks remain on StreamEntry.
+    """
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._streams: dict = {}
+        self._next_local_id = 1
+
+    @property
+    def lock(self):
+        """Registry lock (same role as TransportConnection._streams_lock)."""
+        return self._lock
+
+    @property
+    def streams(self) -> dict:
+        return self._streams
+
+    def allocate(self, remote_id, service) -> StreamEntry:
+        """Allocate local id, create StreamEntry, insert into map. Holds registry lock."""
+        with self._lock:
+            local_id = self._next_local_id
+            self._next_local_id += 1
+            entry = StreamEntry(local_id, remote_id, service)
+            self._streams[local_id] = entry
+            return entry
+
+    def get(self, local_id):
+        with self._lock:
+            return self._streams.get(local_id)
+
+    def find_by_local(self, local_id):
+        return self.get(local_id)
+
+    def find_by_remote(self, remote_id):
+        with self._lock:
+            for e in self._streams.values():
+                if e.remote_id == remote_id:
+                    return e
+        return None
+
+    def find_by_pair(self, local_id, remote_id):
+        if not local_id or not remote_id:
+            return None
+        with self._lock:
+            entry = self._streams.get(local_id)
+            if entry is not None and entry.remote_id == remote_id:
+                return entry
+        return None
+
+    def remove_if_same(self, entry: StreamEntry) -> bool:
+        """Pop entry from registry if map still points at this object."""
+        with self._lock:
+            if self._streams.get(entry.local_id) is entry:
+                self._streams.pop(entry.local_id, None)
+                return True
+        return False
+
+    def snapshot(self) -> list:
+        """List current entries (for CNXN reset / finish)."""
+        with self._lock:
+            return list(self._streams.values())
+
+    def clear_map_locked(self):
+        """Caller already holds registry lock; clear map without releasing."""
+        self._streams.clear()

adbproxy/observers/__init__.py

@@ -0,0 +1 @@
+"""只读的 shell、sync 和 install 流观察器。"""

adbproxy/observers/events.py

@@ -0,0 +1,19 @@
+"""Shallow observer events for StreamBuffer routing.
+
+O-track (phase2): only ClientBytes/ServerBytes. Activate* and deep
+session-internal event SMs are follow-ups — do not expand here.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ClientBytes:
+    data: bytes
+
+
+@dataclass(frozen=True)
+class ServerBytes:
+    data: bytes

adbproxy/observers/install.py

@@ -0,0 +1,126 @@
+import os
+import threading
+
+from adbproxy.config import MAX_SYNC_FILE
+from adbproxy.runtime.capture import open_unique_capture
+
+
+class InstallStreamCapture:
+    """adb install 流式 raw 字节捕获：apk 内容只落盘，绝不进控制台/日志。
+
+    命中 abb_exec:package install(-write)? -S <size> 后激活，
+    按 -S size 计数捕获 client→server 的 raw apk 流；server→client 只回 Success/Failure
+    短文本，不在此落盘（交碎片流走可读路径）。单文件上限复用 MAX_SYNC_FILE。
+    """
+
+    def __init__(self, logger, files_dir, capture_enabled=True):
+        self.logger = logger
+        self.files_dir = files_dir
+        self.capture_enabled = capture_enabled
+        self.lock = threading.Lock()
+        self.remaining = 0  # 待捕获字节数（按 -S size 递减）
+        self.total_size = 0
+        self.remote_label = None  # service 串或其中的 name，用于事件与文件命名
+        self.accumulated = 0  # 已落盘字节数
+        self.file_fp = None  # 落盘文件句柄（"wb" 覆写，时间戳防重名）
+        self.capture_path = None
+        self.capture_overflow = False  # 超 MAX_SYNC_FILE 后停止写盘
+
+    @property
+    def active(self):
+        return self.remaining > 0
+
+    def activate(self, total_size, remote_label):
+        """由 Connection 在 client 首帧命中 install 流式服务时调用。开 capture 文件并置计数。"""
+        with self.lock:
+            self.total_size = total_size
+            self.remaining = total_size
+            self.accumulated = 0
+            self.capture_overflow = False
+            self.remote_label = remote_label
+            self._open_capture()
+
+    def on_client(self, data):
+        """捕获 client→server raw apk 字节。返回 take（本次消耗字节数），
+        data[take:] 由调用方交回可读路径。apk 字节绝不进 StreamBuffer.c_buf。"""
+        if not data or self.remaining <= 0:
+            return 0
+        with self.lock:
+            if self.remaining <= 0:
+                return 0
+            take = min(self.remaining, len(data))
+            chunk = bytes(data[:take])
+            self._write_capture(chunk)
+            self.accumulated += len(chunk)
+            self.remaining -= take
+            if self.remaining <= 0:
+                cap = (
+                    self.capture_path
+                    if (self.capture_enabled and self.capture_path)
+                    else None
+                )
+                if cap:
+                    # 路径=创建路径（无 rename），唯一 captured
+                    self.logger.event(
+                        f"[install captured]: {cap} size={self.total_size}"
+                    )
+                else:
+                    # --no-capture：无 captured，但仍打 size 摘要不崩
+                    self.logger.event(f"[install done]: size={self.total_size}")
+                self._close_capture()
+            return take
+
+    def on_server(self, data):
+        """install 上下文 server 只回 Success/Failure 短文本，不在此落盘。
+        返回 False 让 StreamBuffer 走可读路径（不拦 server）。"""
+        return False
+
+    def _open_capture(self):
+        # 统一命名：install-apk-conn{N}-{size}B-{time_ns}-{seq}.apk
+        # activate 时 -S size 已知，一次命名无 rename；唯一性由 capture token 保证
+        if not self.capture_enabled:
+            self.capture_path = None
+            self.file_fp = None
+            return
+        try:
+            prefix = f"install-apk-conn{self.logger.conn_id}-{self.total_size}B"
+            self.capture_path, self.file_fp = open_unique_capture(
+                self.files_dir, prefix, ".apk"
+            )
+        except IOError as e:
+            self.logger.event(f"[!] install capture open failed: {e}")
+            self.capture_path = None
+            self.file_fp = None
+            self.capture_overflow = True
+
+    def _write_capture(self, payload):
+        """流式写盘：每段 payload 直接 write 到已 open file_fp。IOError 内化不冒泡。"""
+        if not self.file_fp or self.capture_overflow:
+            return
+        if self.accumulated + len(payload) > MAX_SYNC_FILE:
+            self.logger.event(
+                f"[!] install file > {MAX_SYNC_FILE} bytes, stop capturing"
+            )
+            self._close_capture()
+            self.capture_overflow = True
+            return
+        try:
+            self.file_fp.write(payload)
+        except IOError as e:
+            self.logger.event(f"[!] install capture write failed: {e}")
+            self._close_capture()
+            self.capture_overflow = True
+
+    def _close_capture(self):
+        if self.file_fp:
+            try:
+                self.file_fp.close()
+            except Exception:
+                pass
+            self.file_fp = None
+
+    def close(self):
+        """连接关闭时兜底关闭未收完的文件（保留部分落盘便于排查）。"""
+        with self.lock:
+            self._close_capture()
+            self.remaining = 0