procproxy 0.1.0__py3-none-any.whl

proxycore/dns/udp.py

@@ -0,0 +1,606 @@
+"""UDP 策略与会话。
+
+原则：默认保守、可配置、失败即失败（不静默直连）。
+
+* `udp_policy.default` + `udp_policy.by_port` 决定每条 UDP 数据报的去向；
+* `block` 是推荐默认（QUIC 被丢包后浏览器会回落 HTTP/2 over TCP → 走代理）；
+* `direct` 会泄漏真实 IP，文档必须明确告知；
+* 每个 `(pid, src_port)` 一条 SOCKS5 UDP 关联（共用会串包）；60s 无包回收；
+* 分片 UDP：直接放行并记 WARN（注入分片极易出错）。
+"""
+
+from __future__ import annotations
+
+import contextlib
+import queue
+import socket
+import threading
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+from ..log import EventLogger, get_logger
+from ..types import Action, Endpoint, UdpAssociation
+from ..upstream.base import UpstreamDown
+from ..upstream.socks5 import build_udp_datagram, parse_udp_datagram
+
+LOG = EventLogger(get_logger("proxycore.dns.udp"))
+
+DEFAULT_IDLE_TIMEOUT_S = 60.0
+MAX_UDP_DATAGRAM = 65535
+
+# 后台建关联的 worker 数。一次 `UDP ASSOCIATE` 是一次完整 TCP 握手 + 认证，
+# 单 worker 会让所有待建关联串行排在一次慢握手后面；worker 太多则是白占栈。
+ASSOCIATE_WORKERS = 4
+# 待建关联队列上限。满了就丢弃数据报（记 WARN），绝不阻塞决策线程。
+ASSOCIATE_QUEUE_MAX = 1024
+
+# Windows 特有：尚未绑定的连接less socket 上调用 `recvfrom`，Winsock 返回
+# WSAEINVAL(10022) 而不是 WSAEWOULDBLOCK(10035)，语义却同样是"现在没有数据"。
+# 第一次 `send()` 会隐式绑定，此后就恢复成正常的 10035。
+# 必须单独识别：漏掉它会让"还没发过包就先收包"的调用路径直接抛异常。
+_WSAEINVAL = 10022
+
+
+def _errno_of(exc: OSError) -> int | None:
+    """Windows 上 `OSError.errno` 就是 winsock 错误码，优先用 `winerror`。"""
+    winerror = getattr(exc, "winerror", None)
+    if isinstance(winerror, int):
+        return winerror
+    return exc.errno
+
+
+class UdpRelayTransport:
+    """到 SOCKS5 中继的一条 UDP 通道（每 `(pid, src_port)` 一条）。
+
+    为什么每条会话各用一个 socket：中继按源地址:源端口回包，
+    多条会话共用一个 socket 时回包无法区分归属（串包）。
+    """
+
+    def __init__(self, family: int = socket.AF_INET) -> None:
+        self._sock = socket.socket(family, socket.SOCK_DGRAM)
+        self._sock.settimeout(0.0)
+
+    def send(self, payload: bytes, addr: tuple[str, int]) -> int:
+        return self._sock.sendto(payload, addr)
+
+    def recv(self, *, timeout: float = 0.0, size: int = MAX_UDP_DATAGRAM) -> bytes | None:
+        """取一个回包；没有就返回 None（"没数据"不是错误，不抛异常）。
+
+        `timeout=0` ⇒ 非阻塞轮询（调用方自己掌握节奏）；`timeout>0` ⇒ 最长等这么久。
+        """
+        self._sock.settimeout(timeout if timeout > 0 else 0.0)
+        try:
+            data, _peer = self._sock.recvfrom(size)
+        except (TimeoutError, BlockingIOError):
+            return None
+        except OSError as exc:
+            if _errno_of(exc) == _WSAEINVAL:
+                return None  # 见文件头的 _WSAEINVAL 说明：还没绑定过而已
+            raise  # 真错误（WSAENOTSOCK、WSAENETDOWN…）不能被吞掉
+        return data
+
+    def close(self) -> None:
+        with contextlib.suppress(OSError):
+            self._sock.close()
+
+
+class UdpTransport(Protocol):
+    """到 SOCKS5 中继的 UDP 通道（真实实现或测试替身）。"""
+
+    def send(self, payload: bytes, addr: tuple[str, int]) -> int: ...
+
+    def recv(self, *, timeout: float = 0.0, size: int = MAX_UDP_DATAGRAM) -> bytes | None: ...
+
+    def close(self) -> None: ...
+
+
+@dataclass(slots=True)
+class UdpSession:
+    """一条 NAT 式 UDP 会话（键是 `(pid, src_port)`）。"""
+
+    key: tuple[int, int]
+    assoc: UdpAssociation | None = None
+    transport: UdpTransport | None = None  # 到中继的 UDP 通道（UdpRelayTransport 或测试替身）
+    upstream: str = ""
+    dst: Endpoint | None = None
+    last_seen: float = 0.0
+    packets_up: int = 0
+    packets_down: int = 0
+    bytes_up: int = 0
+    bytes_down: int = 0
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "pid": self.key[0],
+            "src_port": self.key[1],
+            "upstream": self.upstream,
+            "dst": str(self.dst) if self.dst else "",
+            "packets_up": self.packets_up,
+            "packets_down": self.packets_down,
+            "bytes_up": self.bytes_up,
+            "bytes_down": self.bytes_down,
+        }
+
+
+class UdpPolicyResolver:
+    """`udp_policy` → `Action`。"""
+
+    def __init__(self, policy: Any = None) -> None:
+        self.default = str(getattr(policy, "default", "direct") or "direct")
+        self.by_port: dict[int, str] = dict(getattr(policy, "by_port", {}) or {})
+
+    def action_for(self, port: int) -> Action:
+        raw = self.by_port.get(int(port), self.default)
+        return {
+            "direct": Action.DIRECT,
+            "proxy": Action.PROXY,
+            "block": Action.BLOCK,
+        }.get(str(raw), Action.BLOCK)  # 未知策略按失败处理，绝不默认直连
+
+    def describe(self) -> dict[str, Any]:
+        return {"default": self.default, "by_port": {str(k): v for k, v in self.by_port.items()}}
+
+    def leaks_ip(self) -> bool:
+        """`direct` 会让支持 QUIC 的应用绕过代理（文档必须写明）。"""
+        return self.default == "direct" or any(v == "direct" for v in self.by_port.values())
+
+
+class UdpSessionTable:
+    """`(pid, src_port) → UdpSession` 的 NAT 表。"""
+
+    def __init__(self, *, idle_timeout_s: float = DEFAULT_IDLE_TIMEOUT_S, clock: Any = time.time) -> None:
+        self.idle_timeout_s = float(idle_timeout_s)
+        self._clock = clock
+        self._lock = threading.RLock()
+        self._sessions: dict[tuple[int, int], UdpSession] = {}
+        self._counters = {
+            "opened": 0,
+            "reaped": 0,
+            "dropped": 0,
+            "fragmented": 0,
+            "no_upstream": 0,
+            "no_payload": 0,
+            "send_failed": 0,
+            # 两段式建关联期间丢弃的数据报。它不等于故障：这是决策线程
+            # 绝不阻塞的代价（QUIC 会重传、DNS 会重试）。
+            "associating": 0,
+        }
+
+    # ------------------------------------------------------------ 会话 -----
+    def open(
+        self,
+        pid: int,
+        src_port: int,
+        *,
+        upstream: str = "",
+        dst: Endpoint | None = None,
+        assoc: UdpAssociation | None = None,
+        transport: UdpTransport | None = None,
+    ) -> UdpSession:
+        key = (int(pid), int(src_port))
+        with self._lock:
+            session = UdpSession(
+                key=key,
+                assoc=assoc,
+                transport=transport,
+                upstream=upstream,
+                dst=dst,
+                last_seen=self._clock(),
+            )
+            self._sessions[key] = session
+            self._counters["opened"] += 1
+            return session
+
+    @staticmethod
+    def _release(session: UdpSession) -> None:
+        """释放一条会话占用的全部资源：控制连接 + 中继 UDP 通道。
+
+        漏掉 transport 的后果不是"泄漏一个 socket"这么轻，关联列表已经把它
+        移除，客户端就再也拿不到回包，而 socket 一直开着、内核缓冲区继续堆积，
+        直到进程退出。
+        """
+        if session.assoc is not None:
+            session.assoc.close()
+        if session.transport is not None:
+            with contextlib.suppress(Exception):  # 关闭失败无补救
+                session.transport.close()
+            session.transport = None
+
+    def get(self, pid: int, src_port: int) -> UdpSession | None:
+        with self._lock:
+            return self._sessions.get((int(pid), int(src_port)))
+
+    def touch(self, pid: int, src_port: int) -> UdpSession | None:
+        with self._lock:
+            session = self._sessions.get((int(pid), int(src_port)))
+            if session is not None:
+                session.last_seen = self._clock()
+            return session
+
+    def close(self, pid: int, src_port: int) -> None:
+        with self._lock:
+            session = self._sessions.pop((int(pid), int(src_port)), None)
+        if session is not None:
+            self._release(session)
+
+    def close_all(self) -> int:
+        """释放全部会话（`Runtime.stop()` 用），返回释放条数。
+
+        与 `reap()`/`prune_pids()` 的区别只是"无条件"：退出时不能让任何 socket
+        或控制连接留到进程结束，否则 `stop()` 之后就再没人能关它们了。
+        """
+        with self._lock:
+            victims = list(self._sessions.values())
+            self._sessions.clear()
+        for session in victims:
+            self._release(session)
+        return len(victims)
+
+    def reap(self, *, now: float | None = None) -> int:
+        stamp = now if now is not None else self._clock()
+        removed = 0
+        with self._lock:
+            victims = [
+                key
+                for key, session in self._sessions.items()
+                if stamp - session.last_seen > self.idle_timeout_s
+            ]
+            for key in victims:
+                session = self._sessions.pop(key, None)
+                if session is not None:
+                    self._release(session)
+                removed += 1
+            self._counters["reaped"] += removed
+        return removed
+
+    def prune_pids(self, alive: set[int]) -> int:
+        """进程退出立即回收。"""
+        removed = 0
+        with self._lock:
+            for key in [k for k in self._sessions if k[0] not in alive]:
+                session = self._sessions.pop(key, None)
+                if session is not None:
+                    self._release(session)
+                removed += 1
+        return removed
+
+    def count(self) -> int:
+        with self._lock:
+            return len(self._sessions)
+
+    def pids(self) -> set[int]:
+        """当前表里出现过的 PID（维护线程据此筛出已退出的进程）。"""
+        with self._lock:
+            return {key[0] for key in self._sessions}
+
+    def snapshot(self) -> list[dict[str, Any]]:
+        with self._lock:
+            return [s.to_dict() for s in self._sessions.values()]
+
+    def stats(self) -> dict[str, int]:
+        with self._lock:
+            out = dict(self._counters)
+            out["active"] = len(self._sessions)
+            return out
+
+    def note_dropped(self, reason: str) -> None:
+        """记录一次丢弃（关联失败 → 记 `E_UPSTREAM_DOWN`，不直连）。
+
+        `dropped` 是总数，`no_upstream`/`fragmented`/`no_payload`/`send_failed`/
+        `associating` 是分类计数，排查时必须能一眼分辨"上游不支持"和"根本没拿到载荷"。
+        """
+        key = {
+            "no-upstream": "no_upstream",
+            "fragmented": "fragmented",
+            "no-payload": "no_payload",
+            "send-failed": "send_failed",
+            "associating": "associating",
+        }.get(reason)
+        with self._lock:
+            if key is not None:
+                self._counters[key] += 1
+            self._counters["dropped"] += 1
+
+
+class UdpForwarder:
+    """把 UDP 数据报按策略交给上游（SOCKS5 UDP ASSOCIATE）。
+
+    关联失败 → 丢弃该数据报并记 `E_UPSTREAM_DOWN`（不直连）。
+
+    ## 两段式建关联（为什么 `handle()` 绝不阻塞）
+
+    建一条 SOCKS5 UDP 关联要跟上游做一次完整 TCP 握手 + 认证，是阻塞调用。
+    而 `handle()` 跑在后端的事件线程上（那条线程还要处理其它决策），
+    超时后驱动按默认放行（PERMIT），真实 IP 就泄漏了。所以决策线程上
+    绝不允许出现网络等待：
+
+    ```
+    首个数据报        → 立刻返回 BLOCK（丢弃）+ 把关联丢给后台 worker
+    关联就绪          → PROXY
+    就绪前的每个数据报 → 继续丢弃（计数 associating）
+    ```
+
+    代价是每个 `(pid, src_port)` 丢开头若干个包。这是可接受的：QUIC 会重传、
+    DNS 会重试，而"决策线程被一次慢握手拖住"会导致全机 TCP 决策一起变慢。
+    """
+
+    def __init__(
+        self,
+        *,
+        policy: UdpPolicyResolver,
+        sessions: UdpSessionTable,
+        dialer_factory: Callable[[str], UdpAssociation | None] | None = None,
+        transport_factory: Callable[[int], UdpTransport] | None = None,
+        associate_workers: int = ASSOCIATE_WORKERS,
+    ) -> None:
+        self.policy = policy
+        self.sessions = sessions
+        self._dialer_factory = dialer_factory
+        # `None` ⇒ 用真实的 `UdpRelayTransport`；测试注入替身以免真的发包。
+        self._transport_factory: Callable[[int], UdpTransport] = transport_factory or UdpRelayTransport
+
+        # 后台建关联：固定数量 worker + 去重队列。
+        # 不去重的话，一个视频流的每个丢包都会排一次队；不用线程池而用固定
+        # worker 是因为关联数受"不同 (pid,src_port) 数"限制，且一次握手最长
+        # `UDP_ASSOCIATE_TIMEOUT_S`，worker 太多只是白占栈。
+        self._associate_workers = max(1, int(associate_workers))
+        self._queue: queue.Queue[tuple[int, int, str] | None] | None = None
+        self._workers: list[threading.Thread] = []
+        self._inflight: set[tuple[int, int]] = set()
+        self._assoc_lock = threading.Lock()
+        self._closed = False
+
+    # -------------------------------------------------------- 后台建关联 -----
+    def _start_workers_locked(self) -> None:
+        """惰性启动 worker（没用 UDP 的进程不该平白多出几条线程）。调用方须持锁。"""
+        if self._queue is not None:
+            return
+        q: queue.Queue[tuple[int, int, str] | None] = queue.Queue(maxsize=ASSOCIATE_QUEUE_MAX)
+        self._queue = q
+        for i in range(self._associate_workers):
+            thread = threading.Thread(
+                target=self._associate_worker, args=(q,), name=f"ppx-udp-assoc-{i}", daemon=True
+            )
+            thread.start()
+            self._workers.append(thread)
+
+    def _associate_worker(self, q: queue.Queue[tuple[int, int, str] | None]) -> None:
+        """worker 主循环。
+
+        `q` 必须由参数传入、不能在循环里读 `self._queue`，`close()` 会把
+        `self._queue` 置 `None`，而此刻 worker 可能正拿着一个包在收尾，读属性
+        就会 `AttributeError`（线程里抛异常只打日志，但 `task_done()` 漏掉会让
+        `close()` 的 `join()` 逻辑失去意义）。
+        """
+        while True:
+            item = q.get()
+            if item is None:  # 毒丸：close() 放的
+                q.task_done()
+                return
+            pid, src_port, alias = item
+            try:
+                self.ensure_association(pid, src_port, alias)
+            except Exception as exc:  # noqa: BLE001 - worker 线程不能死
+                # `ensure_association` 自己已经把失败路径都记了账，这里只兜底
+                LOG.error("udp_associate_worker_failed", pid=pid, src_port=src_port, error=str(exc))
+            finally:
+                with self._assoc_lock:
+                    self._inflight.discard((pid, src_port))
+                q.task_done()
+
+    def request_association(self, pid: int, src_port: int, upstream_alias: str) -> bool:
+        """非阻塞地排队建关联。
+
+        返回 `True` = 这次真的排上了；`False` = 已经就绪、已经在建、或已关闭
+        （三种情况调用方都不需要做任何事）。
+        """
+        key = (int(pid), int(src_port))
+        session = self.sessions.get(pid, src_port)
+        if session is not None and session.assoc is not None and session.transport is not None:
+            return False  # 已就绪
+        with self._assoc_lock:
+            if self._closed or key in self._inflight:
+                return False
+            self._start_workers_locked()
+            assert self._queue is not None
+            self._inflight.add(key)
+            try:
+                self._queue.put_nowait((key[0], key[1], upstream_alias))
+            except queue.Full:
+                # 队列满意味着"待建关联数"已远超正常值：宁可丢弃也不阻塞决策线程。
+                self._inflight.discard(key)
+                LOG.warn("udp_associate_queue_full", pid=pid, src_port=src_port)
+                return False
+        return True
+
+    def close(self, *, timeout: float = 1.0) -> None:
+        """停掉后台 worker（幂等）。已建好的会话由 `UdpSessionTable` 负责释放。"""
+        with self._assoc_lock:
+            if self._closed:
+                return
+            self._closed = True
+            q, self._queue = self._queue, None
+        if q is not None:
+            for _ in self._workers:
+                with contextlib.suppress(queue.Full):
+                    q.put_nowait(None)  # 毒丸
+            for thread in self._workers:
+                thread.join(timeout=timeout)
+        self._workers.clear()
+
+    def decide_action(self, dst_port: int) -> Action:
+        return self.policy.action_for(dst_port)
+
+    @staticmethod
+    def _relay_family(assoc: UdpAssociation) -> int:
+        relay = getattr(assoc, "relay", None)
+        return socket.AF_INET6 if getattr(relay, "is_v6", False) else socket.AF_INET
+
+    def ensure_association(self, pid: int, src_port: int, upstream_alias: str) -> UdpSession | None:
+        """建立（或复用）`(pid, src_port)` 的 UDP 关联及其数据通道。
+
+        只有"控制连接 + 数据通道"两者俱全才算可用会话：缺了 transport 的会话
+        发不出包也收不到包，必须当作不存在，否则 `handle()` 会以为成功而静默丢包。
+        """
+        session = self.sessions.get(pid, src_port)
+        if session is not None and session.assoc is not None and session.transport is not None:
+            return session
+
+        if self._dialer_factory is None:
+            self.sessions.note_dropped("no-upstream")
+            LOG.error(
+                "udp_associate_unavailable",
+                pid=pid,
+                src_port=src_port,
+                code="E_UPSTREAM_DOWN",
+                hint="没有可用的 UDP 关联（上游需支持 SOCKS5 UDP ASSOCIATE，且配置 udp=true）",
+            )
+            return None
+
+        assoc: UdpAssociation | None
+        try:
+            if session is not None and session.assoc is not None:
+                assoc = session.assoc  # 控制连接还在（比如只有通道建失败过），补通道即可
+            else:
+                assoc = self._dialer_factory(upstream_alias)
+        except Exception as exc:  # noqa: BLE001 - 关联失败只丢弃该数据报
+            self.sessions.note_dropped("no-upstream")
+            LOG.error("udp_associate_failed", upstream=upstream_alias, code="E_UPSTREAM_DOWN", error=str(exc))
+            return None
+        if assoc is None:
+            # 工厂用 None 表示"上游不可用"（别名不存在 / 不支持 UDP）。
+            # 必须在这里挡掉：放它过去会建出一个 `assoc=None` 的空壳会话，
+            # 之后每次 `handle()` 都失败，而计数里一次 `no_upstream` 都没有。
+            self.sessions.note_dropped("no-upstream")
+            LOG.error(
+                "udp_associate_unavailable",
+                upstream=upstream_alias,
+                code="E_UPSTREAM_DOWN",
+                hint="上游不存在或未启用 UDP（upstream.udp=true）",
+            )
+            return None
+
+        try:
+            transport = self._transport_factory(self._relay_family(assoc))
+        except Exception as exc:  # noqa: BLE001 - 建不出通道等价于没有关联
+            # 关联本身是"死物"：没有通道它永远用不上，不关掉就是泄漏一条控制连接。
+            with contextlib.suppress(Exception):
+                assoc.close()
+            self.sessions.note_dropped("no-upstream")
+            LOG.error(
+                "udp_transport_failed",
+                upstream=upstream_alias,
+                code="E_UPSTREAM_DOWN",
+                error=str(exc),
+            )
+            return None
+
+        if session is not None:
+            session.assoc = assoc
+            session.transport = transport
+            if not session.upstream:
+                session.upstream = upstream_alias
+            return session
+        return self.sessions.open(pid, src_port, upstream=upstream_alias, assoc=assoc, transport=transport)
+
+    def handle(
+        self, pid: int, src_port: int, dst: Endpoint, payload: bytes, *, upstream_alias: str = ""
+    ) -> Action:
+        """把数据报封装成 SOCKS5 UDP 报文发给中继，返回实际采取的动作。
+
+        调用方只应依据返回值决定是否放行原始报文：返回 `PROXY` 时原始数据报
+        必须被丢弃（否则同一个包会直连出去一次，等于白白泄漏真实 IP），
+        返回 `BLOCK` 时同样丢弃（失败即失败，绝不静默直连）。
+
+        本函数绝不阻塞：关联没就绪时不建，只排队并丢弃当前数据报
+        （两段式，理由见类 docstring）。
+        """
+        action = self.decide_action(dst.port)
+        if action is not Action.PROXY:
+            if action is Action.DIRECT:
+                LOG.debug("udp_direct", pid=pid, dst=str(dst), port=dst.port, leak=True)
+            else:
+                LOG.debug("udp_blocked", pid=pid, dst=str(dst), port=dst.port)
+            return action
+
+        existing = self.sessions.get(pid, src_port)
+        alias = upstream_alias or (existing.upstream if existing is not None else "")
+        session = existing
+        if session is None or session.assoc is None or session.transport is None:
+            # 关联还没建好（或正在建）→ 丢掉这一个包，把建关联交给后台 worker。
+            # 注意这里不是失败：`associating` 与 `no_upstream` 必须能分开看，
+            # 否则"首个包被丢"会被误读成"上游不可用"。
+            self.sessions.note_dropped("associating")
+            if self.request_association(pid, src_port, alias):
+                LOG.info("udp_associating", pid=pid, src_port=src_port, dst=str(dst), upstream=alias)
+            return Action.BLOCK
+
+        relay = session.assoc.relay
+        try:
+            session.transport.send(build_udp_datagram(dst, payload), (relay.addr, relay.port))
+        except OSError as exc:
+            # UDP 的 sendto 错误是逐包的（路由不可达等），socket 本身通常还好，
+            # 所以只丢这一个包、保留关联，重建关联的代价远高于丢一个包。
+            self.sessions.note_dropped("send-failed")
+            LOG.error("udp_send_failed", pid=pid, dst=str(dst), relay=str(relay), code="E_CONNECT", error=str(exc))
+            return Action.BLOCK
+
+        session.dst = dst
+        session.packets_up += 1
+        # 记裸载荷字节数，与 bytes_down 口径一致；不含 SOCKS5 UDP 头的开销，
+        # 否则统计值取决于目标地址是 v4/v6/域名，和用户看到的流量对不上。
+        session.bytes_up += len(payload)
+        self.sessions.touch(pid, src_port)
+        return Action.PROXY
+
+    def poll_response(
+        self, pid: int, src_port: int, *, timeout: float = 0.0
+    ) -> tuple[Endpoint, bytes] | None:
+        """取一条来自中继的回包；没有就返回 `None`（超时不算错误）。
+
+        返回的 `Endpoint` 是回包的原始来源，可能与本会话记录的上行 `dst` 不同
+        （同一会话可能向多个目标发包），调用方应以它为准决定把裸载荷回注给谁。
+        """
+        session = self.sessions.get(pid, src_port)
+        if session is None or session.transport is None:
+            return None
+        try:
+            packet = session.transport.recv(timeout=timeout)
+        except OSError as exc:
+            LOG.warn("udp_recv_failed", pid=pid, src_port=src_port, error=str(exc))
+            return None
+        if not packet:
+            return None
+        try:
+            src, payload = parse_udp_datagram(packet)
+        except UpstreamDown as exc:
+            # 解析失败→ 丢弃并计数
+            self.sessions.note_dropped("fragmented")
+            LOG.warn("udp_response_dropped", pid=pid, src_port=src_port, reason=str(exc))
+            return None
+        self.note_response(pid, src_port, payload)
+        return src, payload
+
+    def note_response(self, pid: int, src_port: int, payload: bytes) -> None:
+        session = self.sessions.touch(pid, src_port)
+        if session is not None:
+            session.packets_down += 1
+            session.bytes_down += len(payload)
+
+    def note_fragmented(self, pid: int, dst: Endpoint) -> None:
+        """分片 UDP：直接放行并记 WARN。"""
+        self.sessions.note_dropped("fragmented")
+        LOG.warn("udp_fragmented_passthrough", pid=pid, dst=str(dst))
+
+
+__all__ = [
+    "DEFAULT_IDLE_TIMEOUT_S",
+    "MAX_UDP_DATAGRAM",
+    "UdpForwarder",
+    "UdpPolicyResolver",
+    "UdpRelayTransport",
+    "UdpSession",
+    "UdpSessionTable",
+]