adbproxy 0.1.0__py3-none-any.whl

adbproxy/device/backend.py

@@ -0,0 +1,242 @@
+import socket
+
+from adbproxy.protocols.smart_socket.handshake import SmartSocketHandshake
+
+
+class AdbClientBackend:
+    """per-stream 5037 后端：经真实 adb server 转发到 USB/网络设备。
+    文本协议：host:transport:<serial>（OKAY 无 body）+ <hex4><service>（OKAY/FAIL+流）。
+    握手由 SmartSocketHandshake 构建帧/解释 status；I/O 仍在本类阻塞 sequencer。
+    """
+
+    def __init__(self, conn, entry, serial, adb_server_port, logger):
+        self.conn = conn
+        self.entry = entry
+        self.serial = serial
+        self.adb_server_port = adb_server_port
+        self.logger = logger
+        self.sock = None
+        self.host_phase = "status"
+        self.stage = "tport"
+        self.host_status_buf = bytearray()
+        self.host_hex_buf = bytearray()
+        self.host_payload_remaining = 0
+        self._fail_msg_buf = bytearray()
+        self._last_host_svc = None
+        self._stopped = False
+        self.handshake = SmartSocketHandshake()
+
+    def start(self):
+        """建 TCP + 发 host:transport + 读 tport OKAY + 发 <hex4><service>。
+
+        关键：host:transport 与 service 两帧必须“发→读 OKAY→发”，不能背靠背连发。
+        adb server smart_socket_enqueue 在同一 enqueue 内合并两帧时，处理完首帧
+        （SwitchedTransport）会 smart_socket_data.clear() 丢弃第二帧（sockets.cpp:867），
+        导致 svc 永不响应、设备流无法回传。真实 adb client 也是先读 tport OKAY 再发
+        service（adb_client.cpp 双握手）。
+        """
+        try:
+            self.sock = socket.create_connection(
+                ("127.0.0.1", self.adb_server_port), timeout=5
+            )
+        except Exception as e:
+            self.logger.event(f"[!] back 连接 adb server 失败: {e}")
+            return False
+        self.logger.event(
+            f"[back] 已连接 adb server :{self.adb_server_port}，target serial={self.serial}"
+        )
+        if not self._send_frame(SmartSocketHandshake.build_transport_frame(self.serial)):
+            return False
+        tport_st = self._recv_exact(4)
+        if tport_st is None:
+            self.logger.event("[!] back 读 tport status EOF/异常，关流 CLSE")
+            return False
+        st = SmartSocketHandshake.interpret_status(tport_st)
+        if st.ok:
+            self.logger.event("📤 [tport Status]: OKAY")
+        elif st.fail:
+            self.logger.event("📤 [tport Status]: FAIL")
+            self._consume_fail_body(prefix="tport")
+            return False
+        else:
+            self.logger.event(f"[!] back tport status 异常: {st.word!r}，关流 CLSE")
+            return False
+        svc = self.entry.service or ""
+        if not self._send_service_frame(svc):
+            return False
+        svc_st = self._recv_exact(4)
+        if svc_st is None:
+            self.logger.event("[!] back 读 service status EOF/超时，关流 CLSE")
+            return False
+        svc_status = SmartSocketHandshake.interpret_status(svc_st)
+        if svc_status.ok:
+            self.logger.event("📤 [Status]: OKAY")
+        elif svc_status.fail:
+            self.logger.event("📤 [Status]: FAIL")
+            self._consume_fail_body(prefix="svc")
+            return False
+        else:
+            self.logger.event(f"[!] back service status 异常: {svc_status.word!r}")
+            return False
+        try:
+            self.sock.settimeout(None)
+        except OSError:
+            return False
+        # service OKAY 已在握手 worker 中精确消费；后续 recv 从第一字节起就是服务流。
+        self.host_phase = "stream"
+        self.stage = "stream"
+        return True
+
+    def _consume_fail_body(self, prefix: str):
+        """Read FAIL protocol-string body after a FAIL status word (blocking)."""
+        hb = self._recv_exact(4)
+        plen = 0
+        if hb:
+            decoded = SmartSocketHandshake.decode_fail_length(hb)
+            plen = decoded if decoded is not None else 0
+        fbody = self._recv_exact(plen) if plen else b""
+        if fbody:
+            label = "tport FAIL body" if prefix == "tport" else "FAIL"
+            self.logger.event(
+                f"📤 [{label}]: {fbody.decode('utf-8', errors='replace')!r}"
+            )
+
+    def _recv_exact(self, n):
+        """精确读 n 字节（循环拼半包）。EOF/异常返回 None。"""
+        buf = bytearray()
+        while len(buf) < n:
+            try:
+                chunk = self.sock.recv(n - len(buf))
+            except OSError:
+                return None
+            if not chunk:
+                return None
+            buf.extend(chunk)
+        return bytes(buf)
+
+    def _send_frame(self, frame: bytes) -> bool:
+        try:
+            self.sock.sendall(frame)
+        except Exception as e:
+            self.logger.event(f"[!] back sendall 失败: {e}")
+            return False
+        return True
+
+    def _send_service_frame(self, svc):
+        try:
+            frame = SmartSocketHandshake.build_service_frame(svc)
+        except (TypeError, UnicodeError, ValueError) as e:
+            self.logger.event(f"[!] back service frame 非法: {e}")
+            return False
+        return self._send_frame(frame)
+
+    def run(self):
+        try:
+            while not self._stopped:
+                try:
+                    data = self.sock.recv(65536)
+                except OSError:
+                    break
+                if not data:
+                    break
+                self._on_back_data(data)
+        finally:
+            self.conn._back_eof(self.entry)
+
+    def stop(self):
+        self._stopped = True
+        try:
+            self.sock.shutdown(socket.SHUT_RDWR)
+        except Exception:
+            pass
+        try:
+            self.sock.close()
+        except Exception:
+            pass
+
+    def _on_back_data(self, data):
+        pos = 0
+        n = len(data)
+        out = bytearray()
+        while pos < n:
+            if self.host_phase == "status":
+                need = 4 - len(self.host_status_buf)
+                take = min(need, n - pos)
+                self.host_status_buf.extend(data[pos : pos + take])
+                pos += take
+                if len(self.host_status_buf) < 4:
+                    break
+                st = bytes(self.host_status_buf).decode("ascii", errors="ignore")
+                self.host_status_buf = bytearray()
+                if st == "OKAY":
+                    if self.stage == "tport":
+                        self.logger.event("📤 [tport Status]: OKAY")
+                        self.stage = "svc"
+                        self.host_phase = "status"
+                    else:
+                        self.logger.event("📤 [Status]: OKAY")
+                        self.stage = "stream"
+                        self.host_phase = "stream"
+                elif st == "FAIL":
+                    self.host_phase = "hex"
+                else:
+                    out.extend(st.encode("ascii", errors="ignore"))
+                    self.host_phase = "stream"
+                    self.stage = "stream"
+            elif self.host_phase == "hex":
+                need = 4 - len(self.host_hex_buf)
+                take = min(need, n - pos)
+                self.host_hex_buf.extend(data[pos : pos + take])
+                pos += take
+                if len(self.host_hex_buf) < 4:
+                    break
+                hx = bytes(self.host_hex_buf).decode("ascii", errors="ignore")
+                self.host_hex_buf = bytearray()
+                plen = SmartSocketHandshake.decode_fail_length(
+                    hx.encode("ascii") if len(hx) == 4 else b""
+                )
+                if plen is None:
+                    # invalid hex — original used int(hx,16) ValueError path
+                    try:
+                        plen = int(hx, 16)
+                    except ValueError:
+                        out.extend(hx.encode("ascii", errors="ignore"))
+                        self.host_phase = "stream"
+                        self.stage = "stream"
+                        continue
+                self.host_payload_remaining = plen
+                if self.host_payload_remaining == 0:
+                    self._on_fail_msg(b"")
+                    self._stopped = True
+                    break
+                else:
+                    self.host_phase = "payload"
+            elif self.host_phase == "payload":
+                take = min(self.host_payload_remaining, n - pos)
+                chunk = data[pos : pos + take]
+                pos += take
+                self.host_payload_remaining -= take
+                self._fail_msg_buf.extend(chunk)
+                if self.host_payload_remaining == 0:
+                    self._on_fail_msg(bytes(self._fail_msg_buf))
+                    self._fail_msg_buf = bytearray()
+                    self._stopped = True
+                    break
+            else:
+                out.extend(data[pos:])
+                pos = n
+        if out and not self._stopped:
+            self.conn._front_wrte_from_back(self.entry, bytes(out))
+
+    def _on_fail_msg(self, msg):
+        """FAIL body 处理：打日志 +（非 shell/sync 激活时）喂 entry.sb.add_server + front CLSE。"""
+        self.logger.event("📤 [Status]: FAIL")
+        msg_text = msg.decode("utf-8", errors="replace")
+        self.logger.event(f"📤 [FAIL body]: {msg_text!r}")
+        sb = self.entry.sb
+        if sb is not None and not (sb.shell.active or sb.sync.active):
+            try:
+                sb.add_server(msg)
+            except Exception:
+                pass
+        self.conn._front_clse(self.entry)

adbproxy/device/banner.py

@@ -0,0 +1,33 @@
+"""Pure CNXN banner helpers (no socket I/O).
+
+App retains adb-server queries for features/product fields; session only
+assembles the reply string via ``build_cnxn_banner``.
+"""
+
+from __future__ import annotations
+
+
+def build_cnxn_banner(
+    *,
+    banner_type: str,
+    features: str,
+    product=None,
+    model=None,
+    device=None,
+) -> str:
+    """Build the local CNXN banner body (type::props;features=...).
+
+    When product/model/device are all present, emit full ro.product.* fields.
+    Otherwise fall back to features-only + ro.product.name=client-mock.
+    """
+    if product is not None and model is not None and device is not None:
+        return (
+            f"{banner_type}::ro.product.name={product}"
+            f";ro.product.model={model}"
+            f";ro.product.device={device}"
+            f";features={features}"
+        )
+    return (
+        f"{banner_type}::features={features}"
+        f";ro.product.name=client-mock"
+    )