#!/usr/bin/env bash
# @desc: 测本机 NAT 类型并给出四类结论（全锥/受限锥形/端口受限锥形/对称），附可审计原始表与 ZeroTier 打洞判读
# @usage: wcl stun [选项]       直接跑就出结论（本地端口自动随机，约 20~30 秒）
# =============================================================================
#  stun —— NAT 类型检测（RFC 4787 行为分类 + RFC 5780 行为发现）
#
#  用法
#    bash <(curl t.melulu.top/stun)                 直接出结论
#    bash <(curl t.melulu.top/stun) --explain       附每一步原始数据
#    bash <(curl t.melulu.top/stun) -p 56358        固定本地端口（默认随机）
#    bash <(curl t.melulu.top/stun) --json          机器可读
#    wcl stun [同上参数]                            用 wcl 包装器一样可以
#
#  一条命令给全这些内容（都在一个输出里，不需要别的脚本）：
#    ① 四类归一结论：全锥 / 受限锥形 / 端口受限锥形 / 对称 NAT
#    ② 可审计原始表：每个目的地 -> 回包源 -> 被看到的外部地址（回包源不是目的地就标"代答"）
#    ③ 映射维：同一本地端口并发打多个目的地，看外部端口是否随对方变化
#    ④ 过滤维：CHANGE-REQUEST 让服务器换 IP/换端口回包（不支持就明确说"测不了"，不硬编）
#    ⑤ 映射稳定性：同一目的地重复 3 次看端口是否漂移
#    ⑥ 出口公网 IP、本地端口、国内/国际分组、端口分布（判断是 NAT 分配还是代理池）
#    ⑦ 给 ZeroTier 的判读与出路建议
#
#  它是「bash 外壳 + 内嵌 Python3」：外壳负责找解释器、给出可操作的报错；
#  真正的探测在下面的 Python 里（只用标准库，无第三方依赖）。
#  本脚本不写 rc 文件、不安装任何命令；用 source <(curl ...) 调用也不会污染当前 shell。
#  只测 UDP + IPv4。
# =============================================================================
set -u

VERSION="2.0"

# 被 source 时一律用 return（exit 会连带结束调用者的 shell）；直接执行时用 exit。
_SOURCED=0
if [ "${BASH_SOURCE[0]:-}" != "${0:-}" ]; then _SOURCED=1; fi
_finish() {
  if [ "$_SOURCED" = "1" ]; then return "${1:-0}"; fi
  exit "${1:-0}"
}

USAGE="stun $VERSION —— 测本机 NAT 类型（不需要任何服务器）

用法
  bash <(curl t.melulu.top/stun)              直接出结论（约 20~30 秒）
  bash <(curl t.melulu.top/stun) --explain    附每个 Test 的原始数据
  bash <(curl t.melulu.top/stun) --json       输出 JSON（便于比对两台机器）
  wcl stun [同上参数]

输出包含
  ① 四类归一结论  ② 每个目的地/回包源/外部端口的可审计表  ③ 映射维（并发打多目的地）
  ④ 过滤维（换 IP/换端口回包）  ⑤ 映射稳定性（同一目的地重复 3 次）  ⑥ 国内/国际分组与端口分布
  ⑦ 对 ZeroTier 的判读与出路

选项
  -p, --port N         固定本地探测端口（默认随机；绑不上会自动换）
  -t, --timeout SEC    单次探测超时（默认 2.5）
  -e, --explain        展开每个 Test 的原始数据
  -j, --json           机器可读输出
  -h, --help           本帮助

判读
  全锥 / 受限锥形 / 端口受限锥形（映射=端点无关）-> ZeroTier 可打洞
  对称 NAT（映射随目的地变）                      -> 打洞基本不可能
  出口公网 IP 多于 1 个 / 回包源被改写            -> 多 WAN 或路上有代理，单独告警

依赖
  Python 3（任意版本）。没有就按提示装：
    Debian/Ubuntu  sudo apt install -y python3-minimal
    OpenWrt/Wrt     opkg update && opkg install python3-light
    Alpine         apk add python3
    Windows        winget install Python.Python.3.12

退出码
  0 正常   2 判定不出来（服务器都不可用）   130 Ctrl+C"

case " ${1:-} " in
  *" -h "*|*" --help "*|*" help "*) printf '%s\n' "$USAGE"; _finish 0 ;;
esac

find_py() {
  local c
  for c in python3 python python3.exe python.exe; do
    command -v "$c" >/dev/null 2>&1 || continue
    # 真的能用才算数：必须是 py3，且标准库齐全（Store 的假 shim 会在这里被淘汰）
    if "$c" -c 'import sys,socket,struct,json,argparse,os,time; raise SystemExit(0 if sys.version_info[0]==3 else 1)' >/dev/null 2>&1; then
      printf '%s' "$c"
      return 0
    fi
  done
  return 1
}

PY="$(find_py)" || PY=""
if [ -z "$PY" ]; then
  # 用 printf 内建而不是 cat：PATH 被清空时 cat 也找不到，报错就白报了
  printf '%s\n' \
    '[!] 找不到可用的 Python 3 —— 这个工具需要它来做 UDP 探测。' \
    '' \
    '  装一个再跑（任选其一）：' \
    '    Debian/Ubuntu        sudo apt install -y python3-minimal' \
    '    OpenWrt/ImmortalWrt  opkg update && opkg install python3-light' \
    '    Alpine               apk add python3' \
    '    CentOS/RHEL          sudo dnf install -y python3' \
    '    Windows              winget install Python.Python.3.12' \
    '' \
    '  装完直接重跑本命令即可。' >&2
  _finish 1
fi

# ---------------------------------------------------------------------------
# 内嵌的探测程序（Python 3 标准库）。用 python3 -（程序从 stdin 读），
# 不依赖 $0，因此在 bash <(curl ...) / wcl / 落地成文件 三种方式下都一样。
# ---------------------------------------------------------------------------
"$PY" - "$@" <<'PYEOF'
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""stun —— 本机 NAT 类型检测（RFC 4787 / RFC 5780）

一条命令出四类结论：全锥 / 受限锥形 / 端口受限锥形 / 对称，并附可审计原始数据。
只用 Python 3 标准库；不需要自建任何服务器。

判据顺序（顺序不能反）
  ① 过滤维：CHANGE-REQUEST 让服务器换 IP/换端口回包。必须先测 —— 先给"备用地址"发过包
     就等于在 NAT 上先开了洞，之后测过滤必然误判成"无过滤"。
  ② 映射维：同一本地端口 + 同一 socket 并发打多个目的地。所有目的地外部端口都一样=EIM（锥形）；
     不一样=端点相关（对称），再用 RFC 5780 Test I/II/III 细分 ADM/APDM。
  ③ 四类归一：全锥=EIM+EIF · 受限锥形=EIM+ADF · 端口受限锥形=EIM+APDF · 对称=映射端点相关。

对 ZeroTier（以及 WebRTC/游戏联机）真正决定成败的是【映射】：同一本地端口对不同对方给出
同一个外部端口才打得通；每个对方一个端口 = Hard NAT，只能走中继。
"""
import argparse
import json
import random
import select
import socket
import struct
import sys
import time

VERSION = "2.0"
MAGIC = 0x2112A442

# 候选 STUN 服务器（自动只用能应答的；国内优先，保证大陆网络也有足够样本）
SERVERS = [
    ("stun.miwifi.com", 3478, "国内"),
    ("stun.chat.bilibili.com", 3478, "国内"),
    ("stun.douyucdn.cn", 18000, "国内"),
    ("stun.hitv.com", 3478, "国内"),
    ("stun.qq.com", 3478, "国内"),
    ("stun.sipgate.net", 3478, "国际"),
    ("stun.nextcloud.com", 443, "国际"),
    ("stun.radiojar.com", 3478, "国际"),
    ("stun.l.google.com", 19302, "国际"),
    ("stun.cloudflare.com", 3478, "国际"),
]


# --------------------------------------------------------------------------- #
# STUN 编解码
# --------------------------------------------------------------------------- #
def request(change=None):
    tid = random.getrandbits(96).to_bytes(12, "big")
    attr = struct.pack(">HHI", 0x0003, 4, change) if change else b""
    return struct.pack(">HHI12s", 0x0001, len(attr), MAGIC, tid) + attr, tid


def parse(data, tid):
    """返回 (mapped, other)；不是本次事务的响应就返回 (None, None)"""
    if len(data) < 20 or struct.unpack(">H", data[:2])[0] != 0x0101 or data[8:20] != tid:
        return None, None
    mapped = other = None
    pos = 20
    while pos + 4 <= len(data):
        attr, alen = struct.unpack(">HH", data[pos:pos + 4])
        val = data[pos + 4:pos + 4 + alen]
        pos += 4 + alen + ((4 - alen % 4) % 4)
        if len(val) < 8:
            continue
        if attr == 0x0020:                                     # XOR-MAPPED-ADDRESS
            port = struct.unpack(">H", val[2:4])[0] ^ (MAGIC >> 16)
            ip = socket.inet_ntoa(bytes(a ^ b for a, b in zip(val[4:8], MAGIC.to_bytes(4, "big"))))
            mapped = (ip, port)
        elif attr == 0x0001 and mapped is None:                # MAPPED-ADDRESS 兜底
            mapped = (socket.inet_ntoa(val[4:8]), struct.unpack(">H", val[2:4])[0])
        elif attr == 0x802C:                                   # OTHER-ADDRESS（RFC 5780 支持标志）
            other = (socket.inet_ntoa(val[4:8]), struct.unpack(">H", val[2:4])[0])
    return mapped, other


def resolve(host, port):
    try:
        return sorted({ai[4][0] for ai in socket.getaddrinfo(host, port, socket.AF_INET, socket.SOCK_DGRAM)})
    except Exception:
        return []


def local_ip():
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.settimeout(1.0)
        s.connect(("223.5.5.5", 53))
        ip = s.getsockname()[0]
        s.close()
        return ip
    except Exception:
        return "-"


def ask(sock, dst, timeout, change=None):
    """发一个请求（可带 CHANGE-REQUEST），返回 (src, mapped, other)"""
    pkt, tid = request(change)
    try:
        sock.sendto(pkt, dst)
    except Exception:
        return None, None, None
    deadline = time.time() + timeout
    while time.time() < deadline:
        r, _, _ = select.select([sock], [], [], max(0.0, deadline - time.time()))
        if not r:
            break
        try:
            data, src = sock.recvfrom(2048)
        except Exception:
            break
        mapped, other = parse(data, tid)
        if mapped or other:
            return src, mapped, other
    return None, None, None


def probe_all(sock, targets, timeout, rounds=2):
    """同一 socket 并发打所有目的地；没回的再补一轮，尽量凑够样本"""
    got = {}
    for _rnd in range(rounds):
        todo = [t for t in targets if t not in got]
        if not todo:
            break
        pending = {}
        for label, family, dst in todo:
            pkt, tid = request()
            pending[(dst, tid)] = (label, family, dst)
            try:
                sock.sendto(pkt, dst)
            except Exception:
                pass
        deadline = time.time() + timeout
        while time.time() < deadline and pending:
            r, _, _ = select.select([sock], [], [], max(0.0, deadline - time.time()))
            if not r:
                break
            try:
                data, src = sock.recvfrom(2048)
            except Exception:
                break
            for key in list(pending):
                dst, tid = key
                mapped, _o = parse(data, tid)
                if mapped:
                    label, family, _d = pending.pop(key)
                    got[(label, family, dst)] = (mapped, src)
                    break
    return got


# --------------------------------------------------------------------------- #
# 两个维度
# --------------------------------------------------------------------------- #
def rfc5780_mapping(sock, dst, other, timeout):
    """Test I/II/III 细分区 EIM / ADM / APDM（RFC 5780 §4.4）。返回 (类别, 证据行)"""
    ev = []
    sip, sport = dst
    _src, m1, _o = ask(sock, dst, timeout)
    if not m1:
        return None, ev + ["Test I   主服务器 %s:%d 无响应" % (sip, sport)]
    ev.append("Test I   主服务器 %s:%d -> 被看到 %s:%d" % (sip, sport, m1[0], m1[1]))
    if not other:
        return None, ev + ["服务器没给 OTHER-ADDRESS，ADM/APDM 分不开（只判到端点相关）"]
    oip, oport = other
    _s2, m2, _o2 = ask(sock, (oip, sport), timeout)
    _s3, m3, _o3 = ask(sock, (oip, oport), timeout)
    ev.append("Test II  备用 IP + 主端口 %s:%d -> %s"
              % (oip, sport, ("被看到 %s:%d" % m2) if m2 else "无响应"))
    ev.append("Test III 备用 IP + 备用端口 %s:%d -> %s"
              % (oip, oport, ("被看到 %s:%d" % m3) if m3 else "无响应"))
    if m2 and m3:
        if m1 == m2 == m3:
            return "EIM", ev
        if m2 == m3 and m1 != m2:
            return "ADM", ev
        return "APDM", ev
    if m3 and m1 == m3:
        return "EIM", ev
    if m2 and m1 == m2:
        return "ADM", ev
    if m2 or m3:
        return "APDM", ev
    return None, ev + ["Test II/III 都没有回包，细分不了"]


def rfc5780_filter(sock, dst, other, timeout):
    """CHANGE-REQUEST 测过滤维。回包源对不上服务器给的备用地址时判为不可信。"""
    ev = []
    oip, oport = other if other else (None, None)
    src2, _m2, _o = ask(sock, dst, timeout, change=0x0006)      # 换 IP + 换端口
    ok2 = bool(src2) and oip and src2[0] == oip
    ev.append("换 IP+端口 的回包: %s" % (
        "来了，源 %s:%d%s" % (src2[0], src2[1], "" if ok2 else "（不是服务器备用地址）") if src2 else "没有"))
    src3, _m3, _o2 = ask(sock, dst, timeout, change=0x0002)     # 只换端口
    ok3 = bool(src3) and oport and src3[1] == oport
    ev.append("只换端口的回包: %s" % (
        "来了，源 %s:%d%s" % (src3[0], src3[1], "" if ok3 else "（端口不对）") if src3 else "没有"))
    bogus = [s for s, ok in ((src2, ok2), (src3, ok3)) if s and not ok]
    if bogus:
        return "UNKNOWN", ev + ["回包源不是服务器给的备用地址（例 %s:%d）-> 路上有代答/代理，过滤维不可信"
                                % bogus[0]]
    if ok2:
        return "EIF", ev
    if src2:
        return "UNKNOWN", ev + ["服务器不理会 CHANGE-REQUEST（回包源没变）-> 过滤维测不了"]
    if ok3:
        return "ADF", ev
    if other:
        return "APDF", ev + ["服务器给了 OTHER-ADDRESS（支持 RFC 5780），但换地址/换端口的回包都进不来 -> 地址端口相关过滤"]
    return "UNKNOWN", ev + ["无法确认服务器是否支持 CHANGE-REQUEST -> 过滤维测不了"]


def stability(sock, dst, timeout, n=3):
    """同一本地端口 + 同一目的地重复探测，看映射是否稳定"""
    out = []
    for _i in range(n):
        _s, m, _o = ask(sock, dst, timeout)
        out.append(m[1] if m else None)
    return out


# --------------------------------------------------------------------------- #
# 主流程
# --------------------------------------------------------------------------- #
def main():
    ap = argparse.ArgumentParser(add_help=False)
    ap.add_argument("-p", "--port", "--local-port", dest="port", type=int, default=0)
    ap.add_argument("-e", "--explain", "--verbose", dest="explain", action="store_true")
    ap.add_argument("-j", "--json", dest="as_json", action="store_true")
    ap.add_argument("-t", "--timeout", dest="timeout", type=float, default=2.5)
    ap.add_argument("posport", nargs="?", type=int, default=0)
    try:
        args, _unknown = ap.parse_known_args()
    except SystemExit:
        args = ap.parse_args([]) if False else None
    if args is None:
        ap.print_help()
        return 2
    want_port = args.port or args.posport or 0
    timeout = args.timeout

    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    bound = False
    for _try in range(6):
        p = want_port if want_port else random.randint(40000, 60000)
        try:
            sock.bind(("", p))
            bound = True
            break
        except Exception:
            if want_port:
                print("[stun] 本地端口 %d 绑不上（被占用？），改用随机端口" % want_port, file=sys.stderr)
                want_port = 0
    if not bound:
        print("[stun] 绑不上任何本地端口", file=sys.stderr)
        return 2
    local_port = sock.getsockname()[1]

    targets = []
    for host, port, family in SERVERS:
        for ip in resolve(host, port)[:2]:
            targets.append(("%s->%s" % (host, ip), family, (ip, port)))
    if not targets:
        print("[stun] 解析不出任何 STUN 服务器，检查 DNS", file=sys.stderr)
        return 2

    print("stun %s —— NAT 类型检测（RFC 4787 行为分类 + RFC 5780 行为发现）" % VERSION)
    print("本机地址 %s   本地端口 %d%s   候选目的地 %d 个\n"
          % (local_ip(), local_port, "（指定）" if want_port else "（随机）", len(targets)))

    # ---- ① 过滤维先测（顺序反了必然误判成"无过滤"）----
    live, rfc_dst, other = [], None, None
    for label, family, dst in targets:
        _s, m, o = ask(sock, dst, timeout)
        if m:
            live.append((label, family, dst))
            if rfc_dst is None:
                rfc_dst = dst
        if o and other is None:
            other, rfc_dst = o, dst
    if not live:
        print("[stun] 所有候选 STUN 都不应答 —— 检查网络/DNS，或换个端口重试（-p 加别的端口）", file=sys.stderr)
        return 2
    filtering, f_ev = ("UNKNOWN", ["没有服务器返回 OTHER-ADDRESS，过滤维测不了"])
    if rfc_dst and other:
        filtering, f_ev = rfc5780_filter(sock, rfc_dst, other, timeout)

    # ---- ② 映射维：同一 socket 并发打所有能应答的目的地 ----
    got = probe_all(sock, live, timeout)

    print("%-42s %-22s %-22s %s" % ("目的地(我们发的)", "回包源(实际应答者)", "被看到的外部地址", "标记"))
    print("-" * 112)
    ports, by_group, mismatch, srcs = [], {}, [], set()
    egress, answered_dst = None, None
    for label, family, dst in live:
        item = got.get((label, family, dst))
        if not item:
            continue
        (mip, mport), src = item
        srcs.add(src)
        egress = egress or mip
        mark = ""
        if src[0] != dst[0]:
            mark = "⚠ 代答"
            mismatch.append((label, dst[0], src[0]))
        print("%-42s %-22s %-22s %s" % (label, "%s:%d" % src, "%s:%d" % (mip, mport), mark))
        if not mark:
            ports.append(mport)
            by_group.setdefault(family, []).append(mport)
            answered_dst = answered_dst or dst
    n_dead = len(targets) - len(live)
    n_noans = len(live) - sum(len(v) for v in by_group.values())
    print("\n共 %d 个目的地应答（%d 个连不上、%d 个没回包）；同一本地端口 %d 下外部端口: %s"
          % (len(ports), n_dead, n_noans, local_port, sorted(set(ports))))
    for family in ("国内", "国际"):
        ps = by_group.get(family) or []
        if ps:
            print("  %-4s: %s" % (family, sorted(set(ps))))

    # ---- ③ 映射稳定性（同一目的地重复 3 次）----
    stab = []
    ref = rfc_dst or answered_dst
    if ref:
        stab = stability(sock, ref, timeout, 3)
        print("映射稳定性: 同一目的地 %s 重复 3 次 -> %s %s"
              % ("%s:%d" % ref, stab, "稳定" if len(set(x for x in stab if x)) <= 1 else "**会漂移**"))

    # ---- ④ 映射维细分（过滤已测完，可以自由发往备用地址）----
    mapping, m_ev = None, []
    conc = ("EIM" if len(set(ports)) == 1 else "APDM") if len(ports) >= 2 else None
    cls = None
    if ref:
        cls, m_ev = rfc5780_mapping(sock, ref, other, timeout)
    if conc:
        mapping = conc
        if cls == conc:
            mapping = cls
        elif cls and cls != conc:
            m_ev.append("注意: 单服务器细分得到 %s，与并发表(%s)不一致 -> 以并发表为准" % (cls, conc))
    else:
        mapping = cls

    # ---- ⑤ 四类归一 ----
    if mapping == "EIM":
        name = {"EIF": "全锥 NAT (Full Cone)",
                "ADF": "受限锥形 NAT (Restricted Cone)",
                "APDF": "端口受限锥形 NAT (Port Restricted Cone)"}.get(
                    filtering, "锥形族（全锥 / 受限锥形 / 端口受限锥形 之一）")
        basis = ("映射 = 端点无关(EIM)，过滤 = %s" % filtering if filtering in ("EIF", "ADF", "APDF")
                 else "映射 = 端点无关(EIM)，但过滤维测不到 -> 只能锁到锥形族")
    elif mapping in ("ADM", "APDM"):
        name = "对称 NAT (Symmetric)"
        basis = "映射 = 端点相关(%s)：同一本地端口换个对方就换外部端口 —— 四类里只有对称型会这样，与过滤无关" % mapping
    elif mapping == "NO_NAT":
        name, basis = "无 NAT（公网直连）", "出口地址与本机地址相同"
    else:
        name = "无法判定"
        basis = "样本不足（要 ≥2 个目的地返回外部端口）"

    if args.as_json:
        print(json.dumps({
            "version": VERSION, "local_ip": local_ip(), "local_port": local_port,
            "egress_ip": egress, "mapping": mapping, "filtering": filtering,
            "nat_type": name, "basis": basis, "external_ports": sorted(set(ports)),
            "stability": stab, "mismatch": mismatch, "answered": len(ports),
            "explain": {"mapping": m_ev, "filtering": f_ev},
        }, ensure_ascii=False, indent=1))
        sock.close()
        return 0

    print("\n" + "=" * 100)
    print("  结果")
    print("=" * 100)
    print("    本机地址   : %s" % local_ip())
    print("    出口公网 IP: %s" % (egress or "-"))
    print("    ★ NAT 类型 : %s" % name)
    print("    映射行为   : %s" % ({"EIM": "端点无关映射（EIM，锥形）",
                                 "ADM": "地址相关映射（ADM）",
                                 "APDM": "地址端口相关映射（APDM，即对称）"}.get(mapping, "未定")))
    print("    过滤行为   : %s" % ({"EIF": "无过滤（EIF）", "ADF": "地址相关过滤（ADF）",
                                 "APDF": "地址端口相关过滤（APDF，端口受限，最常见）",
                                 "UNKNOWN": "未测定 / 不可信"}.get(filtering, filtering)))
    print("    依据       : %s" % basis)
    if args.explain:
        if m_ev:
            print("\n    映射原始数据:")
            for line in m_ev:
                print("      " + line)
        if f_ev:
            print("    过滤原始数据:")
            for line in f_ev:
                print("      " + line)
    if mismatch:
        print("\n    ! 有 %d 条回包不是从目的地回来的（例: %s 目标 %s 实际来自 %s）"
              % (len(mismatch), mismatch[0][0], mismatch[0][1], mismatch[0][2]))
        print("      -> 这条路上有 UDP 代答/代理，相关结论仅供参考")
        if mapping in ("ADM", "APDM"):
            print("      -> 重点：出现「代答 + 判为对称」时，先怀疑路径上被透明代理（TPROXY）接管了。")
            print("         实测案例（ImmortalWrt + ZeroTier）：路由器开着代理分流时，每个目的地被代理各开一条")
            print("         外出流 -> 测出来就是对称；打开「流量分载 flow offloading」后已建立流走 flowtable")
            print("         快路径、绕过 netfilter，代理接不到包，UDP 回到真实 NAT（端点无关）-> 打洞就通了。")
    if srcs:
        print("    本次回包源 IP: %s" % ", ".join(sorted({s[0] for s in srcs})))
    allp = sorted(set(ports))
    if len(allp) > 1:
        near = [p for p in allp if abs(p - local_port) <= 16]
        print("    端口分布   : %s" % ("都紧邻本地端口 %d -> 本机 NAT 按端口分配（不是代理池）" % local_port
                                   if len(near) == len(allp) else
                                   "离散（与本地端口 %d 无关）-> 也可能是代理/中转在分配" % local_port))

    print("\n" + "=" * 100)
    if mapping in ("ADM", "APDM"):
        print("  对 ZeroTier : 你这一侧是「难打」的一侧（Hard NAT）—— 对方从 root 学到的那个端口只对 root 有效。")
        print("                打洞是两侧配合的：Hard + Hard 打不通；但 Hard + Easy **能通** ——")
        print("                对面若是锥形/有稳定可达地址，你先发过去建起映射，对方回包就能进来，照样 DIRECT。")
        print("                （实测案例：本机对称 + 对端好打 = 直连成功）")
        print("                想让自己这侧也变「好打」（对面换成硬 NAT 时仍能通）：")
        print("                  ① 让一侧真正可达（光猫 DMZ / 改桥接 + 固定映射 UDP 9993）")
        print("                  ② 两端开 IPv6（有公网 v6 就绕开 NAT，ZeroTier 自己走 v6 直连）")
        print("                  ③ 对端多出口/多拨时先收敛成单出口   ④ 都不行就接受中继")
    elif mapping == "EIM":
        print("  对 ZeroTier : 映射是锥形 -> 打洞可行。若仍走中继，问题在对端，或路上挡了入向包。")
    else:
        print("  对 ZeroTier : 判定不出来 —— 换网络/换时间再跑，或加 -p 换本地端口重试。")
    print("=" * 100)
    sock.close()
    return 0


if __name__ == "__main__":
    try:
        sys.exit(main())
    except KeyboardInterrupt:
        sys.exit(130)
PYEOF
rc=$?

_finish "$rc"
