NetOpsBox.psm1

# NetOpsBox.psm1 — 网络运维工具箱主模块
# 版本: 1.0 (Phase 1 骨架)
# 运行环境: Windows PowerShell 5.1
# 编码: UTF-8 with BOM

# ============================================================
# [1] 模块级初始化
# ============================================================

# -- 环境探测 --
$_EnvInfo = @{
    OSVersion    = [Environment]::OSVersion
    Is64BitOS    = [Environment]::Is64BitOperatingSystem
    Is64BitPS    = [Environment]::Is64BitProcess
    PSVersion    = $PSVersionTable.PSVersion.ToString()
    ComputerName = $env:COMPUTERNAME
}

# -- OUI 厂商映射表（约 80 条）--
$_OuiTable = @{
    # Cisco
    "00000C" = "Cisco"
    "00107B" = "Cisco"
    "0010F6" = "Cisco"
    "0011BB" = "Cisco"
    "0011BC" = "Cisco"
    "00121A" = "Cisco"
    "00127F" = "Cisco"
    "0013C4" = "Cisco"
    "0016C8" = "Cisco"
    "0019E8" = "Cisco"
    "001A2F" = "Cisco"
    "001AA1" = "Cisco"
    "002255" = "Cisco"
    "0023EB" = "Cisco"
    "0024F7" = "Cisco"
    "005080" = "Cisco"
    "00E016" = "Cisco"
    # Huawei
    "00000E" = "Huawei"
    "001882" = "Huawei"
    "00259C" = "Huawei"
    "0025A0" = "Huawei"
    "0026B8" = "Huawei"
    "085700" = "Huawei"
    "1057CA" = "Huawei"
    "2021A5" = "Huawei"
    # HPE / Aruba
    "0001E6" = "HPE/Aruba"
    "0004E2" = "HPE/Aruba"
    "0017A4" = "HPE/Aruba"
    "001871" = "HPE/Aruba"
    "001C2E" = "HPE/Aruba"
    "0021F7" = "HPE/Aruba"
    "009C02" = "HPE/Aruba"
    "04BD88" = "Aruba"
    "20A6CD" = "Aruba"
    # Juniper
    "0005A0" = "Juniper"
    "00075A" = "Juniper"
    "0010DB" = "Juniper"
    "0019E4" = "Juniper"
    "00237D" = "Juniper"
    # Dell
    "00016C" = "Dell"
    "0007E9" = "Dell"
    "001018" = "Dell"
    "001422" = "Dell"
    "0015C5" = "Dell"
    "0023AE" = "Dell"
    "F0D5BF" = "Dell"
    # Intel
    "00001A" = "Intel"
    "0002B3" = "Intel"
    "0013E8" = "Intel"
    "00166F" = "Intel"
    "001B21" = "Intel"
    "0024D6" = "Intel"
    "A4C3F0" = "Intel"
    # Realtek
    "000085" = "Realtek"
    "00095B" = "Realtek"
    "001A6B" = "Realtek"
    "00238B" = "Realtek"
    "D85DEF" = "Realtek"
    "E8D8D1" = "Realtek"
    # Broadcom
    "000017" = "Broadcom"
    "0001EA" = "Broadcom"
    "0015F2" = "Broadcom"
    "00146C" = "Broadcom"
    "001BFC" = "Broadcom"
    "DCA6BD" = "Broadcom"
    # Apple
    "000393" = "Apple"
    "000A27" = "Apple"
    "0010FA" = "Apple"
    "001124" = "Apple"
    "001451" = "Apple"
    "0016CB" = "Apple"
    "001E52" = "Apple"
    "002312" = "Apple"
    "002436" = "Apple"
    "00254B" = "Apple"
    # Samsung
    "0000F0" = "Samsung"
    "00016B" = "Samsung"
    "0013D3" = "Samsung"
    "0017D5" = "Samsung"
    "0024E9" = "Samsung"
    "18AF61" = "Samsung"
    # Xiaomi
    "000A9F" = "Xiaomi"
    "1038B9" = "Xiaomi"
    "28E02C" = "Xiaomi"
    "34A84F" = "Xiaomi"
    "640980" = "Xiaomi"
    "8C6D50" = "Xiaomi"
    # TP-Link
    "000569" = "TP-Link"
    "000625" = "TP-Link"
    "001625" = "TP-Link"
    "002719" = "TP-Link"
    "10683F" = "TP-Link"
    "B0487A" = "TP-Link"
    # Netgear
    "000FB5" = "Netgear"
    "0017C2" = "Netgear"
    "001B2F" = "Netgear"
    "0023A7" = "Netgear"
    "08BD43" = "Netgear"
    # D-Link
    "00055D" = "D-Link"
    "000D88" = "D-Link"
    "001195" = "D-Link"
    "001346" = "D-Link"
    "001CF0" = "D-Link"
    "0022B0" = "D-Link"
    # ASUS
    "000C6E" = "ASUS"
    "001E8C" = "ASUS"
    "002354" = "ASUS"
    "08606E" = "ASUS"
    # Lenovo
    "000103" = "Lenovo"
    "0013C6" = "Lenovo"
    "0017A8" = "Lenovo"
    "00215C" = "Lenovo"
    "0024B2" = "Lenovo"
    # Microsoft
    "0003FF" = "Microsoft"
    "00125A" = "Microsoft"
    "0017FA" = "Microsoft"
    "0022B7" = "Microsoft"
    "0050F2" = "Microsoft"
    # Google
    "001A11" = "Google"
    "002590" = "Google"
    "3C5AB4" = "Google"
    "54A51C" = "Google"
    # Ubiquiti
    "0004F2" = "Ubiquiti"
    "00236A" = "Ubiquiti"
    "04A2E2" = "Ubiquiti"
    "788A20" = "Ubiquiti"
    # Fortinet
    "00090F" = "Fortinet"
    "001CDF" = "Fortinet"
    "00219B" = "Fortinet"
    "08A95A" = "Fortinet"
    # Palo Alto
    "0018CA" = "Palo Alto"
    "0022B9" = "Palo Alto"
    "008FA1" = "Palo Alto"
    # Synology
    "001132" = "Synology"
    "001DAA" = "Synology"
    # H3C
    "000FE2" = "H3C"
    "0023B8" = "H3C"
    "3822D6" = "H3C"
    # ZTE
    "001E73" = "ZTE"
    "0022DE" = "ZTE"
    "0024D2" = "ZTE"
    # VMware
    "000C29" = "VMware"
    "005056" = "VMware"
    # Other common
    "000039" = "Oracle"
    "0007CB" = "NVIDIA"
    "0008C7" = "IBM"
    "00095C" = "Foxconn"
    "000E1E" = "Ruckus"
    "000D65" = "WatchGuard"
    "00116E" = "Check Point"
    "00132D" = "F5 Networks"
    "0015C7" = "Citrix"
    "00178B" = "Extreme"
    "001D45" = "Motorola"
    "0021A3" = "SonicWall"
}

# -- 知名端口映射表 --
$_WellKnownPorts = @{
    21   = "FTP"
    22   = "SSH"
    23   = "Telnet"
    25   = "SMTP"
    53   = "DNS"
    80   = "HTTP"
    443  = "HTTPS"
    1433 = "MSSQL"
    3306 = "MySQL"
    3389 = "RDP"
    5432 = "PostgreSQL"
    6379 = "Redis"
    8080 = "HTTP-Alt"
    8443 = "HTTPS-Alt"
    27017= "MongoDB"
}

# -- 双语关键字 --
$_BilingualKeywords = @{
    RequestTimeout        = @("请求超时", "Request timed out")
    DestinationUnreachable= @("无法访问目标主机", "Destination host unreachable", "Destination net unreachable")
    TtlExpired            = @("TTL 传输中过期", "TTL expired in transit")
    ReplyFrom             = @("来自", "Reply from")
    PingStatistics        = @("Ping 统计信息", "Ping statistics")
    PacketsSent           = @("已发送", "Sent")
    PacketsReceived       = @("已接收", "Received")
    PacketsLost           = @("丢失", "Lost")
    ApproximateRoundTrip  = @("往返行程的估计时间", "Approximate round trip")
    Minimum               = @("最短", "Minimum")
    Maximum               = @("最长", "Maximum")
    Average               = @("平均", "Average")
    DupReply              = @("(DUP!)", "重复应答")
    TraceComplete         = @("跟踪完成", "Trace complete")
    UnableToResolve       = @("无法解析目标系统名称", "Unable to resolve target system name")
}

# -- 规模保护阈值 --
$_ScaleThresholds = @{
    LanScanAutoMax      = 254
    LanScanConfirmMax   = 4094
    BatchPingConfirmMin = 100
    DefaultParallelMax  = 64
}

# -- 常用命令速查表 --
$_QuickReference = @(
    @{ Category = "网络配置"; Command = "ipconfig /all"; Description = "查看完整网络配置" }
    @{ Category = "网络配置"; Command = "ipconfig /release"; Description = "释放 DHCP 地址" }
    @{ Category = "网络配置"; Command = "ipconfig /renew"; Description = "续租 DHCP 地址" }
    @{ Category = "网络配置"; Command = "ipconfig /flushdns"; Description = "清空本地 DNS 缓存" }
    @{ Category = "连通性"; Command = "ping -t <目标>"; Description = "持续 Ping" }
    @{ Category = "连通性"; Command = "pathping <目标>"; Description = "路径质量分析" }
    @{ Category = "端口/进程"; Command = "netstat -ano"; Description = "查看所有连接及监听端口对应 PID" }
    @{ Category = "端口/进程"; Command = "taskkill /PID <PID> /F"; Description = "强制结束指定进程" }
    @{ Category = "路由/ARP"; Command = "route add <目标> mask <掩码> <网关>"; Description = "添加静态路由" }
    @{ Category = "路由/ARP"; Command = "route delete <目标>"; Description = "删除路由条目" }
    @{ Category = "路由/ARP"; Command = "arp -d <IP>"; Description = "删除指定 ARP 缓存条目" }
    @{ Category = "DNS"; Command = "nslookup <域名> <DNS服务器>"; Description = "指定服务器查询域名" }
    @{ Category = "无线网络"; Command = "netsh wlan show profiles"; Description = "列出已保存的 Wi-Fi 配置文件" }
    @{ Category = "无线网络"; Command = 'netsh wlan show profile name="<SSID>" key=clear'; Description = "查看已保存 Wi-Fi 的明文密码" }
    @{ Category = "防火墙"; Command = "netsh advfirewall show allprofiles"; Description = "查看防火墙各 Profile 状态" }
    @{ Category = "共享/权限"; Command = 'net use \\<IP>\<共享名> /user:<用户名> <密码>'; Description = "建立 SMB 共享连接" }
)

# -- 未知行收集器（双语解析兜底用）--
$_UnknownLines = New-Object System.Collections.ArrayList

# ============================================================
# [2] 通用工具函数
# ============================================================

# -- 带颜色输出 --
function _Write-Color {
    param(
        [Parameter(Mandatory=$true)]
        [string]$Text,
        [ConsoleColor]$Color = [ConsoleColor]::White
    )
    Write-Host $Text -ForegroundColor $Color
}

# -- 统一错误格式 --
function _Write-ErrorMsg {
    param(
        [string]$Reason,
        [string]$Suggestion = ""
    )
    $msg = "[错误] $Reason"
    if ($Suggestion) {
        $msg += "。建议：$Suggestion"
    }
    Write-Host $msg -ForegroundColor Red
}

# -- 对齐表格渲染 --
function _Format-Table {
    param(
        [Parameter(Mandatory=$true)]
        [object[]]$Data,
        [string[]]$Columns = $null,
        [hashtable]$Colors = @{}
    )
    if (-not $Data -or $Data.Count -eq 0) { return }

    # 确定要显示的列
    if (-not $Columns) {
        $Columns = $Data[0].PSObject.Properties.Name
    }

    # 计算每列最大宽度
    $colWidths = @{}
    foreach ($col in $Columns) {
        $maxLen = $col.Length
        foreach ($row in $Data) {
            $val = if ($row -is [hashtable]) { "$($row[$col])" } else { "$($row.$col)" }
            if ($val.Length -gt $maxLen) { $maxLen = $val.Length }
        }
        # 限制最大列宽为终端宽度的一部分
        $termWidth = $Host.UI.RawUI.WindowSize.Width
        $maxColWidth = [Math]::Min($maxLen, [Math]::Max(10, ($termWidth - ($Columns.Count * 3)) / $Columns.Count))
        $colWidths[$col] = [int]$maxColWidth
    }

    # 渲染表头分隔线
    $separator = ""
    foreach ($col in $Columns) {
        $separator += "-" * $colWidths[$col] + "  "
    }
    Write-Host $separator.TrimEnd() -ForegroundColor DarkGray

    # 渲染表头
    $header = ""
    foreach ($col in $Columns) {
        $header += $col.PadRight($colWidths[$col]) + "  "
    }
    Write-Host $header.TrimEnd() -ForegroundColor DarkGray

    # 渲染分隔线
    Write-Host $separator.TrimEnd() -ForegroundColor DarkGray

    # 渲染数据行
    foreach ($row in $Data) {
        $line = ""
        $color = [ConsoleColor]::White
        foreach ($col in $Columns) {
            $val = if ($row -is [hashtable]) { "$($row[$col])" } else { "$($row.$col)" }
            if ($val.Length -gt $colWidths[$col]) {
                # 列宽截断：优先截断中间
                $half = [int](($colWidths[$col] - 3) / 2)
                $val = $val.Substring(0, $half) + "..." + $val.Substring($val.Length - $half, $half)
            }
            $line += $val.PadRight($colWidths[$col]) + "  "
        }
        # 根据规则取颜色
        if ($Colors.Count -gt 0 -and $row -is [hashtable]) {
            foreach ($key in $Colors.Keys) {
                if ($row[$key] -match $Colors[$key]) {
                    $color = [ConsoleColor]::Green; break
                }
            }
        }
        Write-Host $line.TrimEnd() -ForegroundColor $color
    }
    Write-Host $separator.TrimEnd() -ForegroundColor DarkGray
}

# -- 参数解析器 --
function _Parse-Args {
    param(
        [string]$RawInput,
        [hashtable]$ParamDefs
    )
    # 返回一个 PSObject，包含各参数的默认值和用户填写的值
    $result = @{}
    foreach ($key in $ParamDefs.Keys) {
        $def = $ParamDefs[$key]
        $result[$key] = $def.Default
    }

    if ([string]::IsNullOrWhiteSpace($RawInput)) {
        return [PSCustomObject]$result
    }

    # 将输入分割为 token
    # 支持位置参数和命名参数
    $tokens = @()
    $current = ""
    $inQuote = $false
    foreach ($ch in $RawInput.ToCharArray()) {
        if ($ch -eq '"') {
            $inQuote = -not $inQuote
        } elseif ($ch -eq ' ' -and -not $inQuote) {
            if ($current) { $tokens += $current; $current = "" }
        } else {
            $current += $ch
        }
    }
    if ($current) { $tokens += $current }

    # 收集位置参数的定义
    $positionalDefs = @()
    foreach ($p in $ParamDefs.GetEnumerator()) {
        if ($p.Value.Position -ge 0) {
            $positionalDefs += @{ Index = $p.Value.Position; Name = $p.Key }
        }
    }
    $positionalDefs = @($positionalDefs | Sort-Object Index)

    # 解析 token
    $posIndex = 0
    $i = 0
    while ($i -lt $tokens.Count) {
        $t = $tokens[$i]
        $matched = $false

        # 检查粘连写法: -c50 形式
        if ($t -match '^-([a-zA-Z])(\d+)$') {
            $shortName = $Matches[1]
            $value = $Matches[2]
            foreach ($p in $ParamDefs.GetEnumerator()) {
                if ($p.Value.Short -eq $shortName) {
                    $result[$p.Key] = $value
                    $matched = $true
                    break
                }
            }
            if ($matched) { $i++; continue }
        }

        # 检查命名参数
        if ($t -match '^-([a-zA-Z]+)$' -or $t -match '^-([a-zA-Z])$') {
            $paramName = $Matches[1]
            $found = $false
            foreach ($p in $ParamDefs.GetEnumerator()) {
                if ($p.Value.Long -eq $paramName -or $p.Value.Short -eq $paramName) {
                    if ($i + 1 -lt $tokens.Count) {
                        $next = $tokens[$i + 1]
                        if ($next -notmatch '^-') {
                            $result[$p.Key] = $next
                            $i += 2
                            $found = $true
                            break
                        }
                    }
                    # 布尔开关参数（无值视为 $true）
                    $result[$p.Key] = $true
                    $i++
                    $found = $true
                    break
                }
            }
            if ($found) { continue }
        }

        # 按位置参数处理
        if ($posIndex -lt $positionalDefs.Count) {
            $pName = $positionalDefs[$posIndex].Name
            $result[$pName] = $t
            $posIndex++
        }
        $i++
    }

    return [PSCustomObject]$result
}

# -- 等待 Enter 键 --
function _Wait-EnterKey {
    Write-Host ""
    Write-Host "--- 按 Enter 键返回主菜单 ---" -ForegroundColor DarkGray
    Read-Host | Out-Null
}

# -- 降级封装 --
function _Invoke-WithFallback {
    param(
        [Parameter(Mandatory=$true)]
        [string]$FeatureName,
        [Parameter(Mandatory=$true)]
        [ScriptBlock]$Primary,
        [Parameter(Mandatory=$true)]
        [ScriptBlock]$Fallback,
        [Parameter(Mandatory=$true)]
        [ScriptBlock]$OutputFormatter
    )
    try {
        $result = & $Primary
        if ($null -ne $result) {
            return (& $OutputFormatter $result)
        }
    } catch { }

    try {
        Write-Host "($FeatureName 兼容模式)" -ForegroundColor DarkGray
        $result = & $Fallback
        if ($null -ne $result) {
            return (& $OutputFormatter $result)
        }
    } catch { }

    _Write-ErrorMsg "$FeatureName 获取失败，两种方式均不可用 "
    return @()
}

# -- 获取默认网关 --
function _Get-DefaultGateway {
    # Primary: Get-NetRoute
    try {
        $route = Get-NetRoute -DestinationPrefix '0.0.0.0/0' -ErrorAction Stop |
            Sort-Object RouteMetric |
            Select-Object -First 1
        if ($route) { return $route.NextHop }
    } catch { }

    # Fallback: route print
    try {
        $output = & cmd.exe /c "route print 2>&1"
        foreach ($line in $output) {
            if ($line -match '^\s*0\.0\.0\.0\s+0\.0\.0\.0\s+(\S+)') {
                return $Matches[1]
            }
        }
    } catch { }

    return $null
}

# -- 获取活跃子网 --
function _Get-ActiveSubnet {
    $adapters = @()
    # Primary: Get-NetIPAddress + Get-NetAdapter
    try {
        $netAdapters = Get-NetAdapter -ErrorAction Stop | Where-Object { $_.Status -eq 'Up' }
        foreach ($adapter in $netAdapters) {
            $ipInfo = Get-NetIPAddress -AddressFamily IPv4 -InterfaceIndex $adapter.InterfaceIndex -ErrorAction SilentlyContinue |
                Where-Object { $_.PrefixOrigin -ne 'WellKnown' } |
                Select-Object -First 1
            if (-not $ipInfo) { continue }
            $route = Get-NetRoute -DestinationPrefix '0.0.0.0/0' -InterfaceIndex $adapter.InterfaceIndex -ErrorAction SilentlyContinue |
                Sort-Object RouteMetric | Select-Object -First 1
            $adapters += [PSCustomObject]@{
                InterfaceName   = $adapter.Name
                InterfaceIndex  = $adapter.InterfaceIndex
                IP              = $ipInfo.IPAddress
                SubnetMask      = $ipInfo.PrefixLength
                Gateway         = if ($route) { $route.NextHop } else { "" }
                Metric          = if ($route) { $route.RouteMetric } else { 9999 }
            }
        }
        if ($adapters.Count -gt 0) {
            $adapters = $adapters | Sort-Object Metric
            return $adapters[0]
        }
    } catch { }

    # Fallback: ipconfig + WMI
    try {
        $output = & cmd.exe /c "ipconfig 2>&1"
        $currentAdapter = $null
        foreach ($line in $output) {
            if ($line -match '^\S' -and $line -notmatch '^\s') {
                $currentAdapter = $line -replace ':.*$', ''
            }
            if ($currentAdapter -and $line -match 'IPv4.*:\s*(\S+)') {
                $ip = $Matches[1]
                $maskLine = $output | Where-Object { $_ -match 'Subnet Mask.*:\s*(\S+)' } | Select-Object -First 1
                $gwLine = $output | Where-Object { $_ -match 'Default Gateway.*:\s*(\S+)' } | Select-Object -First 1
                $mask = if ($maskLine -and $maskLine -match ':\s*(\S+)') { $Matches[1] } else { "" }
                $gw = if ($gwLine -and $gwLine -match ':\s*(\S+)') { $Matches[1] } else { "" }
                if ($ip -and $ip -ne '') {
                    return [PSCustomObject]@{
                        InterfaceName  = $currentAdapter
                        InterfaceIndex = 0
                        IP             = $ip
                        SubnetMask     = $mask
                        Gateway        = if ($gw -and $gw -ne '') { $gw } else { "" }
                        Metric         = 0
                    }
                }
            }
        }
    } catch { }

    return $null
}

# -- 获取网卡信息 --
function _Get-AdapterInfo {
    return _Invoke-WithFallback -FeatureName "网卡配置" `
        -Primary {
            $adapters = Get-NetAdapter -ErrorAction Stop
            $result = @()
            foreach ($adapter in $adapters) {
                $ipInfo = Get-NetIPAddress -AddressFamily IPv4 -InterfaceIndex $adapter.InterfaceIndex -ErrorAction SilentlyContinue |
                    Where-Object { $_.PrefixOrigin -ne 'WellKnown' } | Select-Object -First 1
                $dnsServers = (Get-DnsClientServerAddress -AddressFamily IPv4 -InterfaceIndex $adapter.InterfaceIndex -ErrorAction SilentlyContinue).ServerAddresses -join ', '
                $result += [PSCustomObject]@{
                    Name       = $adapter.Name
                    Status     = $adapter.Status
                    MacAddress = $adapter.MacAddress
                    IPv4       = if ($ipInfo) { "$($ipInfo.IPAddress)/$($ipInfo.PrefixLength)" } else { "-" }
                    SubnetMask = if ($ipInfo) { $ipInfo.PrefixLength } else { "-" }
                    Gateway    = if ($ipInfo) { (_Get-DefaultGateway) } else { "-" }
                    DnsServers = if ($dnsServers) { $dnsServers } else { "-" }
                    Speed      = if ($adapter.LinkSpeed) { "$([Math]::Round($adapter.LinkSpeed / 1e6)) Mbps" } else { "-" }
                }
            }
            return $result
        } `
        -Fallback {
            $adapters = Get-WmiObject Win32_NetworkAdapter -Filter "NetEnabled=True" -ErrorAction Stop
            $configs = Get-WmiObject Win32_NetworkAdapterConfiguration -Filter "IPEnabled=True" -ErrorAction Stop
            $result = @()
            foreach ($adapter in $adapters) {
                $config = $configs | Where-Object { $_.Index -eq $adapter.Index } | Select-Object -First 1
                $result += [PSCustomObject]@{
                    Name       = $adapter.Name
                    Status     = if ($adapter.NetEnabled) { "Up" } else { "Disconnected" }
                    MacAddress = $adapter.MACAddress
                    IPv4       = if ($config -and $config.IPAddress) { $config.IPAddress[0] } else { "-" }
                    SubnetMask = if ($config -and $config.IPSubnet) { $config.IPSubnet[0] } else { "-" }
                    Gateway    = if ($config -and $config.DefaultIPGateway) { $config.DefaultIPGateway[0] } else { "-" }
                    DnsServers = if ($config -and $config.DNSServerSearchOrder) { $config.DNSServerSearchOrder -join ', ' } else { "-" }
                    Speed      = if ($adapter.Speed) { "$([Math]::Round($adapter.Speed / 1e6)) Mbps" } else { "-" }
                }
            }
            return $result
        } `
        -OutputFormatter { param($InputObject) return $InputObject }
}

# -- 获取 ARP 表 --
function _Get-ArpTable {
    return _Invoke-WithFallback -FeatureName "ARP 缓存" `
        -Primary {
            $entries = Get-NetNeighbor -AddressFamily IPv4 -ErrorAction Stop
            $result = @()
            foreach ($e in $entries) {
                if ($e.State -notin @('Reachable','Permanent','Stale','Delay','Probe')) { continue }
                $type = if ($e.State -eq 'Permanent') { "静态" } else { "动态" }
                $result += [PSCustomObject]@{
                    InterfaceIP      = $e.ifIndex
                    InternetAddress  = $e.IPAddress
                    PhysicalAddress  = $e.LinkLayerAddress
                    Type             = $type
                }
            }
            return $result
        } `
        -Fallback {
            $output = & cmd.exe /c "arp -a 2>&1"
            $result = @()
            $currentInterface = ""
            foreach ($line in $output) {
                if ($line -match '^接口:\s*(\S+)') {
                    $currentInterface = $Matches[1]
                    continue
                }
                if ($line -match '^\s*(\d+\.\d+\.\d+\.\d+)\s+([0-9a-fA-F-]{17})\s+(\S+)') {
                    $type = if ($Matches[3] -eq "static") { "静态" } else { "动态" }
                    $result += [PSCustomObject]@{
                        InterfaceIP      = $currentInterface
                        InternetAddress  = $Matches[1]
                        PhysicalAddress  = $Matches[2]
                        Type             = $type
                    }
                }
            }
            return $result
        } `
        -OutputFormatter { param($InputObject) return $InputObject }
}

# -- 获取路由表 --
function _Get-RouteTable {
    return _Invoke-WithFallback -FeatureName "路由表" `
        -Primary {
            $routes = Get-NetRoute -AddressFamily IPv4 -ErrorAction Stop
            $result = @()
            foreach ($r in $routes) {
                $result += [PSCustomObject]@{
                    Destination = $r.DestinationPrefix
                    NextHop     = $r.NextHop
                    Interface   = $r.InterfaceAlias
                    Metric      = $r.RouteMetric
                }
            }
            return $result
        } `
        -Fallback {
            $output = & cmd.exe /c "route print 2>&1"
            $result = @()
            $inIPv4 = $false
            foreach ($line in $output) {
                if ($line -match '^IPv4 路由表' -or $line -match '^IPv4 Route Table') {
                    $inIPv4 = $true; continue
                }
                if ($inIPv4 -and ($line -match '^IPv6' -or $line -match '^永久路由')) {
                    $inIPv4 = $false; continue
                }
                if ($inIPv4 -and $line -match '^\s*(\d+\.\d+\.\d+\.\d+)\s+(\d+\.\d+\.\d+\.\d+)\s+(\S+)\s+(\S+)\s+(\d+)') {
                    $result += [PSCustomObject]@{
                        Destination = $Matches[1]
                        NextHop     = $Matches[3]
                        Interface   = $Matches[4]
                        Metric      = [int]$Matches[5]
                    }
                }
            }
            return $result
        } `
        -OutputFormatter { param($InputObject) return $InputObject }
}

# -- 获取监听端口 --
function _Get-ListeningPorts {
    return _Invoke-WithFallback -FeatureName "监听端口" `
        -Primary {
            $connections = Get-NetTCPConnection -State Listen -ErrorAction Stop
            $result = @()
            foreach ($c in $connections) {
                $procName = "未知"
                try {
                    $proc = Get-Process -Id $c.OwningProcess -ErrorAction Stop
                    $procName = $proc.ProcessName
                } catch { }
                $result += [PSCustomObject]@{
                    LocalAddress = if ($c.LocalAddress -eq '0.0.0.0') { "0.0.0.0 (所有网卡)" }
                                   elseif ($c.LocalAddress -eq '::') { "[::] (IPv6)" }
                                   else { $c.LocalAddress }
                    Port         = $c.LocalPort
                    Protocol     = "TCP"
                    PID          = $c.OwningProcess
                    ProcessName  = $procName
                }
            }
            return $result
        } `
        -Fallback {
            $output = & cmd.exe /c "netstat -ano 2>&1"
            $result = @()
            foreach ($line in $output) {
                # 匹配 LISTENING 行: TCP  0.0.0.0:80  0.0.0.0:0  LISTENING  1234
                if ($line -match '^\s*TCP\s+(\S+):(\d+)\s+\S+\s+LISTENING\s+(\d+)') {
                    $addr = $Matches[1]
                    $port = [int]$Matches[2]
                    $pid = [int]$Matches[3]
                    $procName = "未知"
                    try { $procName = (Get-Process -Id $pid -ErrorAction Stop).ProcessName } catch { }
                    $displayAddr = if ($addr -eq '0.0.0.0') { "0.0.0.0 (所有网卡)" }
                                   elseif ($addr -match '^\[') { "$addr (IPv6)" }
                                   else { $addr }
                    $result += [PSCustomObject]@{
                        LocalAddress = $displayAddr
                        Port         = $port
                        Protocol     = "TCP"
                        PID          = $pid
                        ProcessName  = $procName
                    }
                }
            }
            return $result
        } `
        -OutputFormatter { param($InputObject) return $InputObject }
}

# -- OUI 厂商查询 --
function _Resolve-OUI {
    param([string]$MacAddress)
    if ([string]::IsNullOrWhiteSpace($MacAddress)) { return $null }
    # 归一化：去分隔符，转大写，取前 6 字符
    $clean = $MacAddress -replace '[:-]', '' -replace '\.', '' -replace '\s', ''
    if ($clean.Length -lt 6) { return $null }
    $oui = $clean.Substring(0, 6).ToUpper()
    if ($_OuiTable.ContainsKey($oui)) {
        return $_OuiTable[$oui]
    }
    return $null
}

# -- 端口服务名查询 --
function _Resolve-PortName {
    param([int]$Port)
    if ($_WellKnownPorts.ContainsKey($Port)) {
        return $_WellKnownPorts[$Port]
    }
    return $null
}

# -- 显示子菜单 --
function _Show-SubMenu {
    param(
        [string]$Title,
        [hashtable[]]$Options  # @{ Key="1"; Label="..." }
    )
    Write-Host ""
    Write-Host "=== $Title ===" -ForegroundColor DarkGray
    Write-Host ""
    foreach ($opt in $Options) {
        Write-Host "  [$($opt.Key)] $($opt.Label)"
    }
    Write-Host "  [B] 返回主菜单"
    Write-Host ""
}

# -- 规模保护 --
function _Confirm-LargeScale {
    param(
        [int]$Count,
        [int]$AutoMax,
        [int]$ConfirmMax,
        [string]$Description
    )
    if ($Count -le $AutoMax) {
        return "Proceed"
    }
    if ($ConfirmMax -gt 0 -and $Count -gt $ConfirmMax) {
        Write-Host "目标数量 ($Count) 超过上限 ($ConfirmMax)。$Description 过多，建议缩小范围后重试。" -ForegroundColor Red
        return "Reject"
    }
    Write-Host "检测到 $Description 数量为 $Count，预计耗时较长。是否继续？(Y/N)" -ForegroundColor Yellow
    $answer = Read-Host
    if ($answer -eq 'Y' -or $answer -eq 'y') {
        return "Proceed"
    }
    return "Reject"
}

# -- IP 地址与 uint32 互转（网络字节序，位运算安全） --
function _IpToUInt32 {
    param([string]$IpStr)
    $bytes = ([System.Net.IPAddress]$IpStr).GetAddressBytes()
    return ([uint32]$bytes[0] -shl 24) -bor ([uint32]$bytes[1] -shl 16) -bor ([uint32]$bytes[2] -shl 8) -bor [uint32]$bytes[3]
}
function _UInt32ToIp {
    param([uint32]$Val)
    return "$(($Val -shr 24) -band 0xFF).$(($Val -shr 16) -band 0xFF).$(($Val -shr 8) -band 0xFF).$($Val -band 0xFF)"
}

# -- 并行任务调度器（PS5.1 RunspacePool） --
function _Invoke-Parallel {
    param(
        [ScriptBlock]$ScriptBlock,
        [object[]]$InputObjects,
        [int]$Throttle = 20,
        [ScriptBlock]$OnComplete = $null
    )
    if ($InputObjects.Count -eq 0) { return @() }
    if ($InputObjects.Count -eq 1) {
        $r = & $ScriptBlock $InputObjects[0]
        if ($OnComplete) { & $OnComplete $r }
        return @($r)
    }

    $throttle = [Math]::Min($Throttle, $InputObjects.Count)
    $pool = [RunspaceFactory]::CreateRunspacePool(1, $throttle)
    $pool.Open()
    $tasks = New-Object System.Collections.ArrayList

    foreach ($obj in $InputObjects) {
        $ps = [PowerShell]::Create()
        $ps.RunspacePool = $pool
        [void]$ps.AddScript($ScriptBlock.ToString())
        [void]$ps.AddArgument($obj)
        $async = $ps.BeginInvoke()
        [void]$tasks.Add(@{ PS=$ps; Async=$async; Obj=$obj })
    }

    $results = New-Object System.Collections.ArrayList
    foreach ($task in $tasks) {
        try {
            $dataColl = $task.PS.EndInvoke($task.Async)
            if ($dataColl -and $dataColl.Count -gt 0) {
                $data = $dataColl[0]
                if ($null -ne $data) {
                    [void]$results.Add($data)
                    if ($OnComplete) { & $OnComplete $data }
                }
            }
        } catch {
            if ($OnComplete) { & $OnComplete @{ Error = $_.Exception.Message; Obj = $task.Obj } }
        }
        $task.PS.Dispose()
    }

    $pool.Close()
    $pool.Dispose()
    return $results.ToArray()
}

# -- 通用 E 键退出检测 --
function _Check-ExitKey {
    if ([Console]::KeyAvailable) {
        $key = [Console]::ReadKey($true)
        if ($key.Key -eq 'E') {
            Write-Host ""
            _Write-Color "[已取消] 用户按 E 键退出" Yellow
            return $true
        }
    }
    return $false
}

# -- 双语关键字匹配 --
function _Match-Bilingual {
    param(
        [Parameter(Mandatory=$true)]
        [string]$Line,
        [Parameter(Mandatory=$true)]
        [string]$Category
    )
    $keywords = $_BilingualKeywords[$Category]
    if (-not $keywords) {
        return $false
    }
    foreach ($kw in $keywords) {
        if ($Line -match [regex]::Escape($kw)) {
            return $true
        }
    }
    # 记录未知行，供调用方后续处理
    [void]$_UnknownLines.Add($Line)
    return $false
}

# -- Ping 输出解析器 --
function _Parse-PingOutput {
    param(
        [Parameter(Mandatory=$true)]
        [string[]]$Output
    )
    $replies = New-Object System.Collections.ArrayList
    $stats = @{}
    $dupDetected = $false
    $dupData = @()

    # 已见过的序号（用于检测 DUP!）
    $seenSeq = @{}

    foreach ($line in $Output) {
        if ([string]::IsNullOrWhiteSpace($line)) { continue }

        # 检测 DUP!
        if ($line -match '\(DUP!\)' -or $line -match '重复应答') {
            $dupDetected = $true
        }

        # 解析应答行: "来自 192.168.1.1: 字节=32 时间=1ms TTL=64" 或
        #            "Reply from 192.168.1.1: bytes=32 time=1ms TTL=64"
        if ($line -match '(?:来自|Reply from)\s+([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)[:\s]') {
            $ip = $Matches[1]
            $ttl = if ($line -match '(?:TTL|ttl)[= ]*([0-9]+)') { [int]$Matches[1] } else { 0 }
            $bytes = if ($line -match '(?:字节|bytes)[= ]*([0-9]+)') { [int]$Matches[1] } else { 0 }
            $time = if ($line -match '(?:时间|time)[=< ]*([0-9]+)\s*ms') { [int]$Matches[1] } else { 0 }

            $isDup = $line -match '\(DUP!\)' -or $line -match '重复应答'

            $entry = [PSCustomObject]@{
                IP      = $ip
                TTL     = $ttl
                Bytes   = $bytes
                TimeMs  = $time
                Status  = if ($isDup) { "DUP" } else { "Reply" }
            }
            [void]$replies.Add($entry)
            continue
        }

        # 检测超时行
        if (_Match-Bilingual -Line $line -Category "RequestTimeout") {
            [void]$replies.Add([PSCustomObject]@{ IP="*"; TTL=0; Bytes=0; TimeMs=0; Status="Timeout" })
            continue
        }

        # 检测不可达行
        if (_Match-Bilingual -Line $line -Category "DestinationUnreachable") {
            [void]$replies.Add([PSCustomObject]@{ IP="*"; TTL=0; Bytes=0; TimeMs=0; Status="Unreachable" })
            continue
        }

        # 解析统计信息
        # 报文统计行（英文/中文均为一行）
        if (_Match-Bilingual -Line $line -Category "PacketsSent") {
            # English: "Packets: Sent = 3, Received = 3, Lost = 0"
            # Chinese: "数据包: 已发送 = 3，已接收 = 3，丢失 = 0"
            if ($line -match 'Sent\s*=\s*(\d+)') { $stats['Sent'] = [int]$Matches[1] }
            elseif ($line -match '已发送\s*=\s*(\d+)') { $stats['Sent'] = [int]$Matches[1] }
            if ($line -match 'Received\s*=\s*(\d+)') { $stats['Received'] = [int]$Matches[1] }
            elseif ($line -match '已接收\s*=\s*(\d+)') { $stats['Received'] = [int]$Matches[1] }
            if ($line -match 'Lost\s*=\s*(\d+)') { $stats['Lost'] = [int]$Matches[1] }
            elseif ($line -match '丢失\s*=\s*(\d+)') { $stats['Lost'] = [int]$Matches[1] }
        }

        # 延迟统计行
        if (_Match-Bilingual -Line $line -Category "Minimum") {
            if ($line -match 'Minimum\s*=\s*(\d+)\s*ms') { $stats['MinMs'] = [int]$Matches[1] }
            elseif ($line -match '最短\s*=\s*(\d+)\s*ms') { $stats['MinMs'] = [int]$Matches[1] }
            if ($line -match 'Maximum\s*=\s*(\d+)\s*ms') { $stats['MaxMs'] = [int]$Matches[1] }
            elseif ($line -match '最长\s*=\s*(\d+)\s*ms') { $stats['MaxMs'] = [int]$Matches[1] }
            if ($line -match 'Average\s*=\s*(\d+)\s*ms') { $stats['AvgMs'] = [int]$Matches[1] }
            elseif ($line -match '平均\s*=\s*(\d+)\s*ms') { $stats['AvgMs'] = [int]$Matches[1] }
        }
    }

    # 补全默认统计
    if (-not $stats.ContainsKey('Sent')) { $stats['Sent'] = $replies.Count }
    if (-not $stats.ContainsKey('Received')) { $stats['Received'] = 0 }
    if (-not $stats.ContainsKey('Lost')) { $stats['Lost'] = $stats['Sent'] - $stats['Received'] }

    return [PSCustomObject]@{
        Replies    = $replies.ToArray()
        Statistics = [PSCustomObject]$stats
        HasDUP     = $dupDetected
    }
}

# -- 单行 Ping 解析（实时用） --
function _Parse-PingLine {
    param([string]$Line)
    if ([string]::IsNullOrWhiteSpace($Line)) { return $null }

    # DUP! 标记
    $isDup = $Line -match '\(DUP!\)' -or $Line -match '重复应答'

    # 应答行
    if ($Line -match '(?:来自|Reply from)\s+([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)[:\s]') {
        $ip = $Matches[1]
        $ttl = if ($Line -match '(?:TTL|ttl)[= ]*([0-9]+)') { [int]$Matches[1] } else { 0 }
        $bytes = if ($Line -match '(?:字节|bytes)[= ]*([0-9]+)') { [int]$Matches[1] } else { 0 }
        $time = if ($Line -match '(?:时间|time)[=< ]*([0-9]+)\s*ms') { [int]$Matches[1] } else { 0 }
        return [PSCustomObject]@{ IP=$ip; TTL=$ttl; Bytes=$bytes; TimeMs=$time; Status=('DUP','Reply')[$isDup -eq $false] }
    }

    # 超时
    if (_Match-Bilingual -Line $Line -Category "RequestTimeout") {
        return [PSCustomObject]@{ IP="*"; TTL=0; Bytes=0; TimeMs=0; Status="Timeout" }
    }

    # 不可达
    if (_Match-Bilingual -Line $Line -Category "DestinationUnreachable") {
        return [PSCustomObject]@{ IP="*"; TTL=0; Bytes=0; TimeMs=0; Status="Unreachable" }
    }

    return $null
}

# -- Ping 核心引擎（支持流式回调） --
function _Invoke-PingCore {
    param(
        [Parameter(Mandatory=$true)]
        [string]$Target,
        [int]$Count = 10,
        [int]$Timeout = 4000,
        [int]$Size = 32,
        [int]$TTL = 128,
        [ScriptBlock]$OnReply = $null
    )
    $pingArgs = "-n $Count -w $Timeout -l $Size -i $TTL $Target"

    try {
        $psi = New-Object System.Diagnostics.ProcessStartInfo
        $psi.FileName = "cmd.exe"
        $psi.Arguments = "/c ping.exe $pingArgs 2>&1"
        $psi.UseShellExecute = $false
        $psi.RedirectStandardOutput = $true
        $psi.RedirectStandardError = $true
        $psi.CreateNoWindow = $true

        $process = [System.Diagnostics.Process]::Start($psi)
        $allLines = New-Object System.Collections.ArrayList
        $replies = New-Object System.Collections.ArrayList
        $hasDup = $false
        $seq = 0

        # 逐行读取，实时回调
        while (-not $process.StandardOutput.EndOfStream) {
            $line = $process.StandardOutput.ReadLine()
            if ($line) {
                [void]$allLines.Add($line)
                $reply = _Parse-PingLine -Line $line
                if ($reply) {
                    $seq++
                    if ($reply.Status -eq "DUP") { $hasDup = $true }
                    [void]$replies.Add($reply)
                    if ($OnReply) {
                        & $OnReply -Reply $reply -Seq $seq
                    }
                }
            }
        }
        $process.WaitForExit(5000)

        # 解析统计行
        $stats = @{}
        foreach ($line in $allLines) {
            if (_Match-Bilingual -Line $line -Category "PacketsSent") {
                if ($line -match 'Sent\s*=\s*(\d+)') { $stats['Sent'] = [int]$Matches[1] }
                elseif ($line -match '已发送\s*=\s*(\d+)') { $stats['Sent'] = [int]$Matches[1] }
                if ($line -match 'Received\s*=\s*(\d+)') { $stats['Received'] = [int]$Matches[1] }
                elseif ($line -match '已接收\s*=\s*(\d+)') { $stats['Received'] = [int]$Matches[1] }
                if ($line -match 'Lost\s*=\s*(\d+)') { $stats['Lost'] = [int]$Matches[1] }
                elseif ($line -match '丢失\s*=\s*(\d+)') { $stats['Lost'] = [int]$Matches[1] }
            }
            if (_Match-Bilingual -Line $line -Category "Minimum") {
                if ($line -match 'Minimum\s*=\s*(\d+)\s*ms') { $stats['MinMs'] = [int]$Matches[1] }
                elseif ($line -match '最短\s*=\s*(\d+)\s*ms') { $stats['MinMs'] = [int]$Matches[1] }
                if ($line -match 'Maximum\s*=\s*(\d+)\s*ms') { $stats['MaxMs'] = [int]$Matches[1] }
                elseif ($line -match '最长\s*=\s*(\d+)\s*ms') { $stats['MaxMs'] = [int]$Matches[1] }
                if ($line -match 'Average\s*=\s*(\d+)\s*ms') { $stats['AvgMs'] = [int]$Matches[1] }
                elseif ($line -match '平均\s*=\s*(\d+)\s*ms') { $stats['AvgMs'] = [int]$Matches[1] }
            }
        }
        if (-not $stats.ContainsKey('Sent')) { $stats['Sent'] = $Count }
        if (-not $stats.ContainsKey('Received')) { $stats['Received'] = 0 }
        if (-not $stats.ContainsKey('Lost')) { $stats['Lost'] = $stats['Sent'] - $stats['Received'] }

        return [PSCustomObject]@{ Replies=$replies.ToArray(); Statistics=[PSCustomObject]$stats; HasDUP=$hasDup; Error=$null }
    }
    catch {
        return [PSCustomObject]@{ Replies=@(); Statistics=[PSCustomObject]@{ Sent=$Count; Received=0; Lost=$Count; MinMs=0; MaxMs=0; AvgMs=0 }; HasDUP=$false; Error="[错误] Ping 执行异常: $($_.Exception.Message)" }
    }
}

# ============================================================
# [3] 功能函数（18个，占位实现）
# ============================================================

function Invoke-PingTest {
    $gw = _Get-DefaultGateway
    $gwLabel = if ($gw) { "默认网关 ($gw)" } else { "默认网关 (不可用)" }
    $options = @(
        @{ Key = "1"; Label = "互联网出口 -> www.baidu.com（默认 10 个报文）" }
        @{ Key = "2"; Label = $gwLabel + "（默认 10 个报文）" }
        @{ Key = "3"; Label = "自定义 -> 指定目标和参数" }
        @{ Key = "4"; Label = "持续探测互联网出口（按 E 退出）" }
        @{ Key = "5"; Label = "持续探测默认网关（按 E 退出）" }
        @{ Key = "6"; Label = "持续探测自定义地址（按 E 退出）" }
    )
    _Show-SubMenu -Title "Ping 连通性测试" -Options $options
    $choice = Read-Host "请输入选项"
    if ($choice -eq 'B' -or $choice -eq 'b') { return }

    $target = ""; $count = 10; $timeout = 4000; $size = 32; $ttl = 128
    $continuous = $false

    switch ($choice) {
        "1" { $target = "www.baidu.com" }
        "2" {
            if (-not $gw) { _Write-ErrorMsg "无法获取默认网关" "使用自定义模式"; return }
            $target = $gw
        }
        "3" {
            $raw = Read-Host "请输入目标及参数（如 192.168.1.1 -c 5 -w 2000）"
            if ([string]::IsNullOrWhiteSpace($raw)) { _Write-ErrorMsg "未输入目标" "输入 IP 或域名"; return }
            $defs = @{
                Target  = @{ Long="Target";  Short="";  Position=0;  Default="" }
                Count   = @{ Long="Count";   Short="c"; Position=-1; Default="10" }
                Timeout = @{ Long="Timeout"; Short="w"; Position=-1; Default="4000" }
                Size    = @{ Long="Size";    Short="l"; Position=-1; Default="32" }
                TTL     = @{ Long="TTL";     Short="i"; Position=-1; Default="128" }
            }
            $parsed = _Parse-Args -RawInput $raw -ParamDefs $defs
            if (-not $parsed.Target) { _Write-ErrorMsg "未指定目标地址"; return }
            $target = $parsed.Target; $count = [int]$parsed.Count; $timeout = [int]$parsed.Timeout
            $size = [int]$parsed.Size; $ttl = [int]$parsed.TTL
        }
        "4" { $target = "www.baidu.com"; $continuous = $true; $timeout = 2000 }
        "5" {
            if (-not $gw) { _Write-ErrorMsg "无法获取默认网关"; return }
            $target = $gw; $continuous = $true; $timeout = 2000
        }
        "6" {
            $raw = Read-Host "请输入目标地址及参数（如 192.168.1.1 -w 1000，按 E 键可退出持续探测）"
            if ([string]::IsNullOrWhiteSpace($raw)) { _Write-ErrorMsg "未输入目标"; return }
            $defs = @{
                Target  = @{ Long="Target";  Short="";  Position=0; Default="" }
                Timeout = @{ Long="Timeout"; Short="w"; Position=-1; Default="2000" }
                Size    = @{ Long="Size";    Short="l"; Position=-1; Default="32" }
                TTL     = @{ Long="TTL";     Short="i"; Position=-1; Default="128" }
            }
            $parsed = _Parse-Args -RawInput $raw -ParamDefs $defs
            if (-not $parsed.Target) { _Write-ErrorMsg "未指定目标地址"; return }
            $target = $parsed.Target; $timeout = [int]$parsed.Timeout
            $size = [int]$parsed.Size; $ttl = [int]$parsed.TTL; $continuous = $true
        }
        default { _Write-ErrorMsg "无效选项" "输入 1-6 或 B"; return }
    }

    # 持续探测
    if ($continuous) {
        Write-Host ""
        Write-Host "持续 Ping $target (Timeout=$timeout ms, Size=$size, TTL=$ttl) — 按 E 键退出" -ForegroundColor DarkGray
        Write-Host ""
        $pinger = New-Object System.Net.NetworkInformation.Ping
        $po = New-Object System.Net.NetworkInformation.PingOptions; $po.Ttl = $ttl; $po.DontFragment = $false
        $buf = New-Object byte[] $size; for ($j = 0; $j -lt $size; $j++) { $buf[$j] = 0x61 }
        $seq = 0; $sent = 0; $recv = 0
        try {
            while ($true) {
                # 检查 E 键退出
                if ([Console]::KeyAvailable) {
                    $key = [Console]::ReadKey($true)
                    if ($key.Key -eq 'E') { break }
                }
                $seq++; try {
                    $reply = $pinger.Send($target, $timeout, $buf, $po); $sent++
                    $s = "{0:D3}" -f $seq
                    if ($reply.Status -eq 'Success') {
                        $recv++
                        _Write-Color "[$s] 来自 $($reply.Address): 字节=$($reply.Buffer.Length) 时间=$($reply.RoundtripTime)ms TTL=$($reply.Options.Ttl)" Green
                    } elseif ($reply.Status -eq 'TimedOut') {
                        _Write-Color "[$s] 请求超时。" Yellow
                    } elseif ($reply.Status -match 'Unreachable') {
                        _Write-Color "[$s] 目标不可达。" Red
                    } else {
                        _Write-Color "[$s] $($reply.Status)" Yellow
                    }
                } catch { $sent++; _Write-Color "[$s] 请求超时。" Yellow }
                # 短暂间隔，同时在此期间也检查 E 键
                for ($w = 0; $w -lt 5; $w++) {
                    if ([Console]::KeyAvailable) {
                        $key = [Console]::ReadKey($true)
                        if ($key.Key -eq 'E') { break }
                    }
                    Start-Sleep -Milliseconds 200
                }
                if ($key -and $key.Key -eq 'E') { break }
            }
        } finally { $pinger.Dispose() }
        Write-Host ""
        Write-Host "--- 持续探测结束 ---" -ForegroundColor DarkGray
        $lossCount = $sent - $recv
        $lossRate = if ($sent -gt 0) { [Math]::Round($lossCount / $sent * 100, 1) } else { 100 }
        Write-Host "发送: $sent | 接收: $recv | 丢失: $lossCount ($lossRate%)"
        _Wait-EnterKey
        return
    }

    # 固定次数探测
    Write-Host ""
    Write-Host "Ping $target (Count=$count, Timeout=$timeout ms, Size=$size, TTL=$ttl) — 按 E 可提前退出" -ForegroundColor DarkGray
    Write-Host ""

    $pinger = New-Object System.Net.NetworkInformation.Ping
    $po = New-Object System.Net.NetworkInformation.PingOptions; $po.Ttl = $ttl; $po.DontFragment = $false
    $buf = New-Object byte[] $size; for ($j = 0; $j -lt $size; $j++) { $buf[$j] = 0x61 }
    $sent = 0; $recv = 0; $minMs = [int]::MaxValue; $maxMs = 0; $totalMs = 0; $cancelled = $false

    try {
        for ($seq = 1; $seq -le $count; $seq++) {
            if (_Check-ExitKey) { $cancelled = $true; break }
            try {
                $reply = $pinger.Send($target, $timeout, $buf, $po); $sent++
                $s = "{0:D2}" -f $seq
                if ($reply.Status -eq 'Success') {
                    $recv++; $rt = [int]$reply.RoundtripTime
                    if ($rt -lt $minMs) { $minMs = $rt }
                    if ($rt -gt $maxMs) { $maxMs = $rt }
                    $totalMs += $rt
                    _Write-Color "[$s] 来自 $($reply.Address): 字节=$($reply.Buffer.Length) 时间=$($reply.RoundtripTime)ms TTL=$($reply.Options.Ttl)" Green
                } elseif ($reply.Status -eq 'TimedOut') {
                    _Write-Color "[$s] 请求超时。" Yellow
                } elseif ($reply.Status -match 'Unreachable') {
                    _Write-Color "[$s] 目标不可达。" Red
                } else {
                    _Write-Color "[$s] $($reply.Status)" Yellow
                }
            } catch { $sent++; _Write-Color "[$s] 请求超时。" Yellow }
            if ($seq -lt $count) {
                for ($w = 0; $w -lt 2; $w++) {
                    if (_Check-ExitKey) { $cancelled = $true; break }
                    Start-Sleep -Milliseconds 100
                }
                if ($cancelled) { break }
            }
        }
    } finally { $pinger.Dispose() }

    Write-Host ""
    Write-Host "--- Ping 统计 ---" -ForegroundColor DarkGray
    $lossCount = $sent - $recv
    $lossRate = if ($sent -gt 0) { [Math]::Round($lossCount / $sent * 100, 1) } else { 100 }
    Write-Host "发送: $sent | 接收: $recv | 丢失: $lossCount ($lossRate%)"
    if ($recv -gt 0) {
        $avgMs = [Math]::Round($totalMs / $recv, 0)
        Write-Host "最短: $minMs ms | 最长: $maxMs ms | 平均: $avgMs ms"
    }
    _Wait-EnterKey
}

function Invoke-TcpPortTest {
    $options = @(
        @{ Key = "1"; Label = "常用服务探测 -> 输入目标 IP，批量检测常见端口" }
        @{ Key = "2"; Label = "自定义 -> 输入目标 IP 和端口" }
    )
    _Show-SubMenu -Title "TCP 端口探测" -Options $options
    $choice = Read-Host "请输入选项"
    if ($choice -eq 'B' -or $choice -eq 'b') { return }

    $ports = @()
    $target = ""
    $timeout = 3000

    switch ($choice) {
        "1" {
            $target = Read-Host "请输入目标 IP"
            if ([string]::IsNullOrWhiteSpace($target)) { _Write-ErrorMsg "未输入目标 IP"; return }
            $ports = @(21,22,23,25,53,80,443,3389,8080,8443)
        }
        "2" {
            $raw = Read-Host "请输入目标及端口（如 192.168.1.1 80 -w 2000）"
            $defs = @{
                Target  = @{ Long="Target"; Short=""; Position=0; Default="" }
                Port    = @{ Long="Port"; Short=""; Position=1; Default="" }
                Timeout = @{ Long="Timeout"; Short="w"; Position=-1; Default="3000" }
            }
            $parsed = _Parse-Args -RawInput $raw -ParamDefs $defs
            if (-not $parsed.Target -or -not $parsed.Port) { _Write-ErrorMsg "未指定目标或端口"; return }
            $target = $parsed.Target
            $ports = @([int]$parsed.Port)
            $timeout = [int]$parsed.Timeout
        }
        default { _Write-ErrorMsg "无效选项"; return }
    }

    Write-Host ""
    Write-Host "并行探测 $target 的 $($ports.Count) 个端口 (超时: $timeout ms)" -ForegroundColor DarkGray
    Write-Host ""

    # 并行端口探测任务（ASCII 文本避免编码歧义）
    $portBlock = [ScriptBlock]::Create(@"
param(`$port)
`$sw = [System.Diagnostics.Stopwatch]::StartNew()
`$st = 'closed'
try {
    `$tcp = New-Object System.Net.Sockets.TcpClient
    `$ar = `$tcp.BeginConnect('$target', `$port, `$null, `$null)
    if (`$ar.AsyncWaitHandle.WaitOne($timeout)) { `$tcp.EndConnect(`$ar); `$st = 'open' }
    `$tcp.Close()
} catch { }
`$sw.Stop()
return @{ Port=`$port; Status=`$st; TimeMs=`$sw.ElapsedMilliseconds }
"@)

    $portResults = _Invoke-Parallel -ScriptBlock $portBlock -InputObjects $ports -Throttle 64 -OnComplete {
        param($data)
        if (-not $data -or $data.Error) { return }
        $svc = _Resolve-PortName $data.Port
        $svcName = if ($svc) { $svc } else { "-" }
        $color = if ($data.Status -eq 'open') { "Green" } else { "Red" }
        $label = if ($data.Status -eq 'open') { "开放" } else { "关闭" }
        _Write-Color "  $($data.Port)/$svcName : $label ($($data.TimeMs)ms)" $color
    }

    Write-Host ""
    $results = @()
    foreach ($r in $portResults) {
        if ($r -and -not $r.Error) {
            $svc = _Resolve-PortName $r.Port
            $label = if ($r.Status -eq 'open') { "开放" } else { "关闭" }
            $results += [PSCustomObject]@{ Port=$r.Port; Service=if($svc){$svc}else{"-"}; Status=$label; TimeMs=$r.TimeMs }
        }
    }
    if ($results.Count -gt 0) {
        _Format-Table -Data $results -Columns @("Port","Service","Status","TimeMs")
    }
    _Wait-EnterKey
}

function Invoke-Tracert {
    $gw = _Get-DefaultGateway
    $gwLabel = if ($gw) { "默认网关 ($gw)" } else { "默认网关 (不可用)" }
    $options = @(
        @{ Key = "1"; Label = "互联网出口 -> www.baidu.com" }
        @{ Key = "2"; Label = $gwLabel }
        @{ Key = "3"; Label = "自定义" }
    )
    _Show-SubMenu -Title "路由追踪" -Options $options
    $choice = Read-Host "请输入选项"
    if ($choice -eq 'B' -or $choice -eq 'b') { return }

    $target = ""; $maxHops = 30; $timeout = 4000
    switch ($choice) {
        "1" { $target = "www.baidu.com" }
        "2" { if (-not $gw) { _Write-ErrorMsg "无法获取默认网关"; return }; $target = $gw }
        "3" {
            $raw = Read-Host "请输入目标及参数（如 10.0.0.1 -h 15 -w 3000）"
            $defs = @{
                Target  = @{ Long="Target"; Short=""; Position=0; Default="" }
                Hops    = @{ Long="h"; Short="h"; Position=-1; Default="30" }
                Timeout = @{ Long="w"; Short="w"; Position=-1; Default="4000" }
            }
            $parsed = _Parse-Args -RawInput $raw -ParamDefs $defs
            if (-not $parsed.Target) { _Write-ErrorMsg "未指定目标地址"; return }
            $target = $parsed.Target
            $maxHops = [int]$parsed.Hops
            $timeout = [int]$parsed.Timeout
        }
        default { _Write-ErrorMsg "无效选项"; return }
    }

    Write-Host ""
    Write-Host "Tracert $target (max hops=$maxHops, timeout=$timeout ms)" -ForegroundColor DarkGray
    Write-Host ""

    # 使用 Ping 类逐跳 TTL 递增实现真正的实时路由追踪
    Write-Host "通过最多 $maxHops 个跃点跟踪到 $target 的路由 — 按 E 可提前退出:" -ForegroundColor DarkGray
    Write-Host ""

    $pinger = New-Object System.Net.NetworkInformation.Ping
    $buf = New-Object byte[] 32
    for ($j = 0; $j -lt 32; $j++) { $buf[$j] = 0x61 }

    $reachedTarget = $false; $cancelled = $false
    for ($hop = 1; $hop -le $maxHops; $hop++) {
        if (_Check-ExitKey) { $cancelled = $true; break }
        $hopStr = "{0:D2}" -f $hop
        $times = @()
        $hopIp = "*"

        for ($probe = 1; $probe -le 3; $probe++) {
            if (_Check-ExitKey) { $cancelled = $true; break }
            try {
                $pingOpt = New-Object System.Net.NetworkInformation.PingOptions($hop, $false)
                $reply = $pinger.Send($target, $timeout, $buf, $pingOpt)
                if ($reply.Status -eq 'Success') {
                    $hopIp = $reply.Address.ToString()
                    $times += [int]$reply.RoundtripTime
                    $reachedTarget = $true
                } elseif ($reply.Status -eq 'TtlExpired') {
                    $hopIp = $reply.Address.ToString()
                    $times += [int]$reply.RoundtripTime
                }
            } catch { }
            Start-Sleep -Milliseconds 50
        }
        if ($cancelled) { break }

        if ($times.Count -eq 0) {
            _Write-Color "[$hopStr] * * *" Yellow
        } else {
            $avg = [Math]::Round(($times | Measure-Object -Average).Average, 1)
            _Write-Color "[$hopStr] $hopIp ($($times -join '/')ms, avg=${avg}ms)" White
        }

        if ($reachedTarget) { break }
    }

    $pinger.Dispose()
    Write-Host ""
    if ($cancelled) {
        _Write-Color "跟踪已取消。" Yellow
    } elseif ($reachedTarget) {
        _Write-Color "跟踪完成。" Green
    } else {
        _Write-Color "目标不可达（达到最大跃点数 $maxHops）" Red
    }
    _Wait-EnterKey
}

function Invoke-BatchPing {
    Write-Host ""
    Write-Host "=== 批量 Ping 健康检查 ===" -ForegroundColor DarkGray
    Write-Host ""
    Write-Host "目标列表支持:" -ForegroundColor DarkGray
    Write-Host "  1) 逗号分隔: 192.168.1.1,192.168.1.2,www.baidu.com"
    Write-Host "  2) CIDR 网段: 192.168.1.0/24"
    $raw = Read-Host "请输入目标列表 [-Count <N>] [-Timeout <ms>] [-Parallel <N>]"
    if ($raw -eq 'B' -or $raw -eq 'b') { return }
    if ([string]::IsNullOrWhiteSpace($raw)) { _Write-ErrorMsg "未输入目标"; return }

    $defs = @{
        TargetList = @{ Long="TargetList"; Short=""; Position=0; Default="" }
        Count      = @{ Long="Count"; Short="c"; Position=-1; Default="2" }
        Timeout    = @{ Long="Timeout"; Short="w"; Position=-1; Default="1000" }
        Parallel   = @{ Long="Parallel"; Short="p"; Position=-1; Default="64" }
    }
    $parsed = _Parse-Args -RawInput $raw -ParamDefs $defs
    $count = [int]$parsed.Count
    $timeout = [int]$parsed.Timeout
    $parallel = [int]$parsed.Parallel
    $rawTargets = $parsed.TargetList

    # Expand targets
    $targets = @()
    if ($rawTargets -match ',' -or $rawTargets -notmatch '/') {
        $targets = $rawTargets -split ',' | ForEach-Object { $_.Trim() } | Where-Object { $_ }
    } elseif ($rawTargets -match '^(\d+\.\d+\.\d+\.\d+)\s*/\s*(\d+)$') {
        $netIp = _IpToUInt32 $Matches[1]
        $prefix = [int]$Matches[2]
        if ($prefix -eq 0) { $mask = 0 } else { $mask = ([uint32]::MaxValue -shl (32 - $prefix)) -band [uint32]::MaxValue }
        $netStart = ($netIp -band $mask) + 1
        $netEnd = ($netIp -bor ((-bnot $mask) -band [uint32]::MaxValue)) - 1
        if ($netEnd -lt $netStart) { _Write-ErrorMsg "网段太小，无可扫描主机"; return }
        $total = $netEnd - $netStart + 1
        if ($total -gt 254) {
            $result = _Confirm-LargeScale -Count ([int]$total) -AutoMax 254 -ConfirmMax 0 -Description "待 Ping 的主机"
            if ($result -ne "Proceed") { return }
        }
        for ($i = $netStart; $i -le $netEnd; $i++) { $targets += _UInt32ToIp $i }
    } else {
        $targets = @($rawTargets)
    }

    if ($targets.Count -eq 0) { _Write-ErrorMsg "未能解析出有效目标"; return }
    if ($targets.Count -gt 100) {
        $result = _Confirm-LargeScale -Count $targets.Count -AutoMax 0 -ConfirmMax 0 -Description "待 Ping 的主机"
        if ($result -ne "Proceed") { return }
    }

    Write-Host ""
    Write-Host "Ping $($targets.Count) 个目标 (Count=$count, Timeout=$timeout) — 按 E 可提前退出" -ForegroundColor DarkGray
    Write-Host ""

    $results = [System.Collections.ArrayList]::new()
    $swGlobal = [System.Diagnostics.Stopwatch]::StartNew()
    $sync = [hashtable]::Synchronized(@{ Online = 0; Offline = 0; Done = 0; Results = $results; Cancelled = $false })

    # 并行探测任务
    $pingBlock = [ScriptBlock]::Create(@"
param(`$t)
`$c = $count; `$to = $timeout
`$pinger = New-Object System.Net.NetworkInformation.Ping
`$po = New-Object System.Net.NetworkInformation.PingOptions; `$po.Ttl = 128; `$po.DontFragment = `$false
`$buf = New-Object byte[] 32; for (`$j = 0; `$j -lt 32; `$j++) { `$buf[`$j] = 0x61 }
`$sent = 0; `$recv = 0; `$totalMs = 0
for (`$p = 1; `$p -le `$c; `$p++) {
    try { `$reply = `$pinger.Send(`$t, `$to, `$buf, `$po); `$sent++; if (`$reply.Status -eq 'Success') { `$recv++; `$totalMs += [int]`$reply.RoundtripTime } } catch { `$sent++ }
}
`$pinger.Dispose()
`$lossRate = if (`$sent -gt 0) { [Math]::Round((`$sent - `$recv) / `$sent * 100, 1) } else { 100 }
return @{ Target = `$t; Sent = `$sent; Recv = `$recv; TotalMs = `$totalMs; LossRate = `$lossRate; IsUp = (`$recv -gt 0) }
"@)

    # 结果回调——仅在线设备实时显示，离线设备静默计数
    $onDone = {
        param($data)
        if ($data.Error) { return }
        $sync.Done++
        $idxStr = "{0:D2}" -f $sync.Done
        $isUp = $data.IsUp
        $avgStr = if ($data.Recv -gt 0) { "$([Math]::Round($data.TotalMs / $data.Recv, 0))ms" } else { "-" }
        [void]$sync.Results.Add([PSCustomObject]@{ No=$idxStr; Target=$data.Target; Reachable=('否','是')[$isUp]; LossRate="$($data.LossRate)%"; AvgMs=$avgStr })
        if ($isUp) {
            $sync.Online++
            _Write-Color "[$idxStr] $($data.Target) : 在线 延迟 $avgStr" Green
        } else {
            $sync.Offline++
        }
    }

    Write-Host "并行 Ping $($targets.Count) 个目标 (线程数: $(if($parallel -gt 0){$parallel}else{64}), Count=$count, Timeout=$timeout) — 结果将实时显示" -ForegroundColor DarkGray
    Write-Host ""

    $null = _Invoke-Parallel -ScriptBlock $pingBlock -InputObjects $targets -Throttle $(if($parallel -gt 0){$parallel}else{64}) -OnComplete $onDone

    $swGlobal.Stop()
    Write-Host ""
    Write-Host "总数: $($sync.Done) | 在线: $($sync.Online) | 离线: $($sync.Offline) | 耗时: $($swGlobal.ElapsedMilliseconds)ms" -ForegroundColor DarkGray
    _Wait-EnterKey
}

function Invoke-DnsResolve {
    $options = @(
        @{ Key = "1"; Label = "正向解析 -> 域名 -> IP（默认 www.baidu.com）" }
        @{ Key = "2"; Label = "反向解析 -> IP -> 域名" }
        @{ Key = "3"; Label = "指定 DNS 服务器解析" }
    )
    _Show-SubMenu -Title "DNS 解析" -Options $options
    $choice = Read-Host "请输入选项"
    if ($choice -eq 'B' -or $choice -eq 'b') { return }

    $sw = [System.Diagnostics.Stopwatch]::StartNew()
    switch ($choice) {
        "1" {
            $raw = Read-Host "请输入域名（直接回车使用 www.baidu.com）"
            $domain = if ([string]::IsNullOrWhiteSpace($raw)) { "www.baidu.com" } else { $raw }
            try {
                $entry = [System.Net.Dns]::GetHostEntry($domain)
                $sw.Stop()
                _Write-Color "正向解析成功" Green
                Write-Host "域名: $domain"
                Write-Host "IP 地址: $($entry.AddressList -join ', ')"
                Write-Host "耗时: $($sw.ElapsedMilliseconds)ms"
            } catch {
                $sw.Stop()
                _Write-ErrorMsg "域名解析失败（域名不存在或 DNS 服务器无响应）" "检查域名拼写，或尝试 [3] 指定其他 DNS 服务器"
            }
        }
        "2" {
            $raw = Read-Host "请输入 IP 地址"
            try {
                $entry = [System.Net.Dns]::GetHostEntry($raw)
                $sw.Stop()
                _Write-Color "反向解析成功" Green
                Write-Host "IP: $raw"
                Write-Host "主机名: $($entry.HostName)"
                if ($entry.Aliases.Count -gt 0) { Write-Host "别名: $($entry.Aliases -join ', ')" }
                Write-Host "耗时: $($sw.ElapsedMilliseconds)ms"
            } catch {
                $sw.Stop()
                _Write-ErrorMsg "反向解析失败（该 IP 未配置 PTR 记录）" "大多数公网 IP 没有反向解析记录。可尝试 [1] 正向解析查询域名对应 IP，或 [3] 指定 DNS 服务器"
            }
        }
        "3" {
            $raw = Read-Host "请输入域名及 DNS 服务器（如 www.baidu.com -Server 8.8.8.8）"
            $defs = @{
                Target = @{ Long="Target"; Short=""; Position=0; Default="" }
                Server = @{ Long="Server"; Short=""; Position=-1; Default="" }
            }
            $parsed = _Parse-Args -RawInput $raw -ParamDefs $defs
            if (-not $parsed.Target -or -not $parsed.Server) { _Write-ErrorMsg "未指定目标或 DNS 服务器"; return }
            $output = & cmd.exe /c "nslookup $($parsed.Target) $($parsed.Server) 2>&1"
            $sw.Stop()
            Write-Host "DNS 服务器: $($parsed.Server)"
            foreach ($line in $output) {
                if ([string]::IsNullOrWhiteSpace($line)) { continue }
                $c = if ($line -match 'Non-existent domain|找不到') { "Red" } else { "White" }
                _Write-Color $line $c
            }
            Write-Host "耗时: $($sw.ElapsedMilliseconds)ms" -ForegroundColor DarkGray
        }
        default { _Write-ErrorMsg "无效选项" }
    }
    _Wait-EnterKey
}

function Invoke-HttpProbe {
    $gw = _Get-DefaultGateway
    $gwLabel = if ($gw) { "默认网关 -> http://$gw" } else { "默认网关 (不可用)" }
    $options = @(
        @{ Key = "1"; Label = "互联网出口 -> https://www.baidu.com" }
        @{ Key = "2"; Label = $gwLabel }
        @{ Key = "3"; Label = "自定义" }
    )
    _Show-SubMenu -Title "HTTP 服务探测" -Options $options
    $choice = Read-Host "请输入选项"
    if ($choice -eq 'B' -or $choice -eq 'b') { return }

    $url = ""; $timeout = 5000
    switch ($choice) {
        "1" { $url = "https://www.baidu.com" }
        "2" {
            if (-not $gw) { _Write-ErrorMsg "无法获取默认网关"; return }
            $url = "http://$gw"
        }
        "3" {
            $raw = Read-Host "请输入 URL 及参数（如 http://192.168.1.1 -w 3000）"
            $defs = @{
                Target  = @{ Long="Target"; Short=""; Position=0; Default="" }
                Timeout = @{ Long="w"; Short="w"; Position=-1; Default="5000" }
            }
            $parsed = _Parse-Args -RawInput $raw -ParamDefs $defs
            if (-not $parsed.Target) { _Write-ErrorMsg "未指定 URL"; return }
            $url = $parsed.Target
            if ($url -notmatch '^https?://') { $url = "http://$url" }
            $timeout = [int]$parsed.Timeout
        }
        default { _Write-ErrorMsg "无效选项"; return }
    }

    Write-Host ""
    Write-Host "探测: $url" -ForegroundColor DarkGray
    $sw = [System.Diagnostics.Stopwatch]::StartNew()
    try {
        [System.Net.ServicePointManager]::ServerCertificateValidationCallback = { $true }
        $req = [System.Net.HttpWebRequest]::Create($url)
        $req.Timeout = $timeout
        $req.AllowAutoRedirect = $true
        $resp = $req.GetResponse()
        $sw.Stop()
        $statusCode = [int]$resp.StatusCode
        $color = if ($statusCode -lt 300) { "Green" } elseif ($statusCode -lt 400) { "Yellow" } else { "Red" }
        _Write-Color "HTTP $statusCode $($resp.StatusDescription)" $color
        Write-Host "响应时间: $($sw.ElapsedMilliseconds)ms"
        Write-Host "Content-Type: $($resp.ContentType)"
        $server = $resp.Headers['Server']; if ($server) { Write-Host "Server: $server" }
        $resp.Close()
    } catch {
        $sw.Stop()
        if ($_.Exception -is [System.Net.WebException] -and $_.Exception.Response) {
            $resp = $_.Exception.Response
            $statusCode = [int]$resp.StatusCode
            $color = if ($statusCode -lt 300) { "Green" } elseif ($statusCode -lt 400) { "Yellow" } else { "Red" }
            _Write-Color "HTTP $statusCode $($resp.StatusDescription)" $color
            Write-Host "响应时间: $($sw.ElapsedMilliseconds)ms"
            $resp.Close()
        } else {
            _Write-ErrorMsg "HTTP 请求失败: $($_.Exception.Message)" "检查 URL 和网络连接"
        }
    }
    _Wait-EnterKey
}

function Invoke-ListeningPorts {
    $entries = _Get-ListeningPorts
    if (-not $entries -or $entries.Count -eq 0) {
        Write-Host "未发现监听端口" -ForegroundColor Yellow
        _Wait-EnterKey; return
    }
    Write-Host ""
    foreach ($e in $entries) {
        $svc = _Resolve-PortName $e.Port
        $color = if ($svc) { "Cyan" } elseif ($e.ProcessName -eq "未知") { "Yellow" } else { "White" }
        $svcStr = if ($svc) { " ($svc)" } else { "" }
        _Write-Color "  $($e.LocalAddress):$($e.Port) -> $($e.ProcessName) (PID=$($e.PID))$svcStr" $color
    }
    Write-Host "监听端口总数: $($entries.Count)" -ForegroundColor DarkGray
    _Wait-EnterKey
}

function Invoke-MacVendor {
    Write-Host ""
    Write-Host "=== MAC 厂商查询 ===" -ForegroundColor DarkGray
    Write-Host ""
    $raw = Read-Host "请输入 MAC 地址（B 返回）"
    if ($raw -eq 'B' -or $raw -eq 'b') { return }
    if ([string]::IsNullOrWhiteSpace($raw)) { _Write-ErrorMsg "未输入 MAC 地址"; _Wait-EnterKey; return }

    # Normalize and validate
    $clean = $raw -replace '[:-]', '' -replace '\.', '' -replace '\s', '' -replace '-', ''
    if ($clean.Length -ne 12 -or $clean -notmatch '^[0-9a-fA-F]{12}$') {
        _Write-ErrorMsg "MAC 地址格式不正确" "支持: AA:BB:CC:DD:EE:FF | AA-BB-CC-DD-EE-FF | AABB.CCDD.EEFF | AABBCCDDEEFF"
        _Wait-EnterKey; return
    }
    $oui = $clean.Substring(0, 6).ToUpper()
    $vendor = _Resolve-OUI -MacAddress $raw
    Write-Host ""
    if ($vendor) {
        _Write-Color "厂商: $vendor (OUI 前缀: $oui)" Green
    } else {
        _Write-Color "未识别厂商（该 OUI 前缀 $oui 不在内置库中）" Yellow
    }
    _Wait-EnterKey
}

function Invoke-DhcpScan {
    Write-Host ""
    Write-Host "=== DHCP 服务器扫描 ===" -ForegroundColor DarkGray

    # 检测当前是否以管理员运行
    $isAdmin = $false
    try {
        $identity = [Security.Principal.WindowsIdentity]::GetCurrent()
        $principal = New-Object Security.Principal.WindowsPrincipal($identity)
        $isAdmin = $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
    } catch { }

    $leaseServers = @{}
    $discoverServers = @{}

    # -- 解析 ipconfig /all（零权限） --
    try {
        Write-Host "正在查询本机 DHCP 配置..." -ForegroundColor DarkGray
        $ipconfigOut = & cmd.exe /c "ipconfig /all 2>&1"
        $currentAdapter = ""
        $leaseObtained = ""; $leaseExpires = ""; $currentDhcp = ""
        foreach ($line in $ipconfigOut) {
            if ($line -match '^\S' -and $line -notmatch '^\s' -and $line -match 'adapter|适配器') {
                # 遇到新网卡段，保存上一个
                if ($currentDhcp -and $currentDhcp -ne '255.255.255.255') {
                    if (-not $leaseServers.ContainsKey($currentDhcp)) {
                        $leaseServers[$currentDhcp] = @{ Adapter = $currentAdapter }
                    }
                    $leaseServers[$currentDhcp]['Obtained'] = $leaseObtained
                    $leaseServers[$currentDhcp]['Expires'] = $leaseExpires
                }
                $currentAdapter = ($line -replace ':\s*$', '').Trim()
                $currentDhcp = ""; $leaseObtained = ""; $leaseExpires = ""
            }
            if ($line -match 'DHCP Server.*:\s*(\d+\.\d+\.\d+\.\d+)' -or $line -match 'DHCP 服务器.*:\s*(\d+\.\d+\.\d+\.\d+)') {
                $currentDhcp = $Matches[1]
            }
            if ($line -match 'Lease Obtained.*:\s*(.+)' -or $line -match '获得租约的时间.*:\s*(.+)') {
                $leaseObtained = $Matches[1].Trim()
            }
            if ($line -match 'Lease Expires.*:\s*(.+)' -or $line -match '租约过期的时间.*:\s*(.+)') {
                $leaseExpires = $Matches[1].Trim()
            }
        }
        # 最后一个网卡段
        if ($currentDhcp -and $currentDhcp -ne '255.255.255.255') {
            if (-not $leaseServers.ContainsKey($currentDhcp)) {
                $leaseServers[$currentDhcp] = @{ Adapter = $currentAdapter }
            }
            $leaseServers[$currentDhcp]['Obtained'] = $leaseObtained
            $leaseServers[$currentDhcp]['Expires'] = $leaseExpires
        }
    } catch { }

    # -- 广播探测（需要管理员权限才能绑端口 68） --
    if ($isAdmin) {
        try {
            Write-Host "正在广播探测 DHCP 服务器..." -ForegroundColor DarkGray
            $udp = New-Object System.Net.Sockets.UdpClient
            $udp.Client.Bind((New-Object System.Net.IPEndPoint([System.Net.IPAddress]::Any, 68)))
            $udp.EnableBroadcast = $true

            $rng = New-Object System.Security.Cryptography.RNGCryptoServiceProvider
            $xid = New-Object byte[] 4; $rng.GetBytes($xid)
            $macBytes = @(0,0,0,0,0,0)
            try {
                $nic = [System.Net.NetworkInformation.NetworkInterface]::GetAllNetworkInterfaces() |
                    Where-Object { $_.OperationalStatus -eq 'Up' -and $_.NetworkInterfaceType -ne 'Loopback' } |
                    Select-Object -First 1
                if ($nic) { $macBytes = $nic.GetPhysicalAddress().GetAddressBytes() }
            } catch { }

            $msg = New-Object byte[] (272)
            $msg[0] = 1; $msg[1] = 1; $msg[2] = 6; $msg[3] = 0
            [Array]::Copy($xid, 0, $msg, 4, 4)
            $msg[10] = 0x80
            for ($j = 0; $j -lt [Math]::Min($macBytes.Length, 16); $j++) { $msg[28 + $j] = $macBytes[$j] }
            $msg[236] = 99; $msg[237] = 130; $msg[238] = 83; $msg[239] = 99
            $optPos = 240
            $msg[$optPos++] = 53; $msg[$optPos++] = 1; $msg[$optPos++] = 1
            $msg[$optPos++] = 55; $msg[$optPos++] = 4
            $msg[$optPos++] = 1; $msg[$optPos++] = 3; $msg[$optPos++] = 6; $msg[$optPos++] = 15
            $msg[$optPos++] = 255

            $remoteEp = New-Object System.Net.IPEndPoint([System.Net.IPAddress]::Broadcast, 67)
            [void]$udp.Send($msg, $optPos, $remoteEp)

            $timeout = 4000
            $startTime = Get-Date
            while (((Get-Date) - $startTime).TotalMilliseconds -lt $timeout) {
                if (_Check-ExitKey) { break }
                if ($udp.Available -gt 0) {
                    $recvEp = New-Object System.Net.IPEndPoint([System.Net.IPAddress]::Any, 0)
                    $data = $udp.Receive([ref]$recvEp)
                    if ($data.Length -ge 240) {
                        $serverIp = $recvEp.Address.ToString()
                        if (-not $discoverServers.ContainsKey($serverIp)) {
                            $info = @{ Yiaddr = "$($data[16]).$($data[17]).$($data[18]).$($data[19])" }
                            $pos = 240
                            while ($pos -lt $data.Length - 2) {
                                $ot = $data[$pos]
                                if ($ot -eq 255) { break }
                                if ($ot -eq 0) { $pos++; continue }
                                if ($pos + 1 -ge $data.Length) { break }
                                $ol = $data[$pos + 1]
                                if ($pos + 2 + $ol -gt $data.Length) { break }
                                if ($ot -eq 1 -and $ol -eq 4) {
                                    $info['SubnetMask'] = "$($data[$pos+2]).$($data[$pos+3]).$($data[$pos+4]).$($data[$pos+5])"
                                } elseif ($ot -eq 3 -and $ol -ge 4) {
                                    $info['Router'] = "$($data[$pos+2]).$($data[$pos+3]).$($data[$pos+4]).$($data[$pos+5])"
                                } elseif ($ot -eq 6) {
                                    $d = @(); for ($k=0; $k -lt $ol; $k+=4) { $d += "$($data[$pos+2+$k]).$($data[$pos+3+$k]).$($data[$pos+4+$k]).$($data[$pos+5+$k])" }
                                    $info['DnsServers'] = $d -join ', '
                                } elseif ($ot -eq 51 -and $ol -eq 4) {
                                    $info['LeaseTime'] = "$(([uint32]$data[$pos+2] -shl 24) -bor ([uint32]$data[$pos+3] -shl 16) -bor ([uint32]$data[$pos+4] -shl 8) -bor [uint32]$data[$pos+5]) 秒"
                                } elseif ($ot -eq 54 -and $ol -eq 4) {
                                    $info['ServerId'] = "$($data[$pos+2]).$($data[$pos+3]).$($data[$pos+4]).$($data[$pos+5])"
                                }
                                $pos += 2 + $ol
                            }
                            $discoverServers[$serverIp] = $info
                        }
                    }
                }
                Start-Sleep -Milliseconds 100
            }
            $udp.Close()
        } catch { }
    }

    # -- 展示结果 --
    if ($leaseServers.Count -eq 0 -and $discoverServers.Count -eq 0) {
        Write-Host "未发现 DHCP 服务器" -ForegroundColor Yellow
        _Wait-EnterKey; return
    }

    Write-Host ""
    # 本机租约
    if ($leaseServers.Count -gt 0) {
        _Write-Color "--- 本机租约 ($($leaseServers.Count) 台) ---" DarkGray
        foreach ($kv in $leaseServers.GetEnumerator()) {
            Write-Host ""
            _Write-Color "  $($kv.Key) (当前正在使用)" Green
            $v = $kv.Value
            if ($v['Adapter']) { Write-Host "    网卡: $($v.Adapter)" }
            if ($v['Obtained']) { Write-Host "    租约获取: $($v.Obtained)" }
            if ($v['Expires']) { Write-Host "    租约到期: $($v.Expires)" }
        }
    }

    # 广播探测
    if ($isAdmin) {
        if ($discoverServers.Count -gt 0) {
            Write-Host ""
            _Write-Color "--- 广播探测 ($($discoverServers.Count) 台) ---" DarkGray
            foreach ($kv in $discoverServers.GetEnumerator()) {
                $s = $kv.Value; $ip = $kv.Key
                Write-Host ""
                $isInLease = $leaseServers.ContainsKey($ip)
                $label = if ($isInLease) { "$ip (已在租约中)" } else { "$ip (新发现)" }
                $color = if ($isInLease) { "White" } else { "Yellow" }
                _Write-Color "  $label" $color
                if ($s['Yiaddr'] -and $s['Yiaddr'] -ne '0.0.0.0') { Write-Host "    提供 IP: $($s.Yiaddr)" }
                if ($s['SubnetMask']) { Write-Host "    子网掩码: $($s.SubnetMask)" }
                if ($s['Router']) { Write-Host "    路由器: $($s.Router)" }
                if ($s['DnsServers']) { Write-Host "    DNS: $($s.DnsServers)" }
                if ($s['LeaseTime']) { Write-Host "    租约时间: $($s.LeaseTime)" }
                if ($s['ServerId']) { Write-Host "    Server ID: $($s.ServerId)" }
            }
        } else {
            Write-Host ""
            _Write-Color "--- 广播探测 (0 台) ---" DarkGray
            Write-Host "  未收到响应"
        }
        Write-Host ""
        if ($discoverServers.Count -gt 1) {
            _Write-Color "广播探测到 $($discoverServers.Count) 台 DHCP 服务器，可能存在私接路由！" Yellow
        } elseif ($discoverServers.Count -eq 1) {
            Write-Host "广播探测到 1 台 DHCP 服务器，网络环境正常"
        } else {
            Write-Host "广播探测未收到响应"
        }
    } else {
        Write-Host ""
        _Write-Color "--- 广播探测 ---" DarkGray
        Write-Host "  广播探测需要管理员权限（需绑定 DHCP 客户端端口 68）。"
        Write-Host "  请以管理员身份运行本工具后重试此功能，以发现私接 DHCP 服务器。"
        Write-Host ""
    }
    _Wait-EnterKey
}

function Invoke-LoopDetect {
    Write-Host ""
    Write-Host "=== 二层环路检测 ===" -ForegroundColor DarkGray
    Write-Host ""
    $gw = _Get-DefaultGateway
    if (-not $gw) { _Write-ErrorMsg "无法获取默认网关"; _Wait-EnterKey; return }

    $raw = Read-Host "请输入目标 IP 及参数（默认: $gw -c 20 -w 1000，按 Enter 使用默认，B 返回）"
    if ($raw -eq 'B' -or $raw -eq 'b') { return }
    if ([string]::IsNullOrWhiteSpace($raw)) { $raw = "$gw -c 20 -w 1000" }

    $defs = @{
        Target  = @{ Long="Target"; Short=""; Position=0; Default=$gw }
        Count   = @{ Long="c"; Short="c"; Position=-1; Default="20" }
        Timeout = @{ Long="w"; Short="w"; Position=-1; Default="1000" }
    }
    $parsed = _Parse-Args -RawInput $raw -ParamDefs $defs
    $target = if ($parsed.Target) { $parsed.Target } else { $gw }
    $count = [int]$parsed.Count
    $timeout = [int]$parsed.Timeout

    Write-Host "快速 Ping $target (Count=$count, Timeout=$timeout ms)..." -ForegroundColor DarkGray
    $pingResult = _Invoke-PingCore -Target $target -Count $count -Timeout $timeout

    $dupCount = 0; $arpDriftCount = 0
    if ($pingResult.HasDUP) {
        $dupReplies = $pingResult.Replies | Where-Object { $_.Status -eq "DUP" }
        $dupCount = $dupReplies.Count
        if ($dupCount -gt 0) {
            Write-Host ""
            _Write-Color "检测到 DUP!（重复应答）: $dupCount 次" Red
        }
    }

    $arp = _Get-ArpTable
    if ($arp -and $arp.Count -gt 0) {
        # 过滤：排除组播/广播/空 MAC（这些是正常网络行为，非环路）
        $validArp = $arp | Where-Object {
            $mac = $_.PhysicalAddress
            $mac -and $mac -ne '' -and
            $mac -notmatch '^01-00-5E' -and          # IPv4 组播 MAC
            $mac -ne 'FF-FF-FF-FF-FF-FF' -and        # 广播 MAC
            $mac -notmatch '^33-33' -and              # IPv6 组播 MAC
            $mac -notmatch '^01-80-C2'                # STP/LLDP 保留 MAC
        }
        $macGroups = $validArp | Group-Object PhysicalAddress | Where-Object { $_.Count -ge 2 }
        foreach ($g in $macGroups) {
            # 去重 IP 后再显示
            $ips = ($g.Group | Select-Object -ExpandProperty InternetAddress | Sort-Object -Unique) -join ', '
            Write-Host ""
            _Write-Color "MAC 漂移: $($g.Name) 对应 $($g.Group.Count) 个 IP: $ips" Red
            $arpDriftCount++
        }
    }

    Write-Host ""
    if ($dupCount -eq 0 -and $arpDriftCount -eq 0) {
        _Write-Color "未检测到环路迹象" Green
    } else {
        _Write-Color "疑似存在二层环路，请检查网络" Red
    }
    _Wait-EnterKey
}

function Invoke-LanScan {
    Write-Host ""
    Write-Host "=== 局域网设备扫描 ===" -ForegroundColor DarkGray
    Write-Host ""
    $subnet = _Get-ActiveSubnet
    if (-not $subnet -or -not $subnet.IP) {
        _Write-ErrorMsg "未找到活跃网卡"
        _Wait-EnterKey; return
    }

    # Calculate subnet range
    $ipBin = _IpToUInt32 $subnet.IP
    if ($subnet.SubnetMask -match '^\d+$') {
        $prefix = [int]$subnet.SubnetMask
    } elseif ($subnet.SubnetMask -match '^\d+\.\d+\.\d+\.\d+$') {
        $maskParts = $subnet.SubnetMask -split '\.'
        $mBin = 0; foreach ($p in $maskParts) { $mBin = ($mBin -shl 8) -bor [uint32]$p }
        $binStr = [Convert]::ToString($mBin, 2).PadLeft(32, '0')
        $prefix = $binStr.IndexOf('0'); if ($prefix -lt 0) { $prefix = 32 }
    } else {
        $prefix = 24 # default /24
    }
    if ($prefix -eq 0) { $mask = 0 } else { $mask = ([uint32]::MaxValue -shl (32 - $prefix)) -band [uint32]::MaxValue }
    $netStart = ($ipBin -band $mask) + 1
    $netEnd = ($ipBin -bor ((-bnot $mask) -band [uint32]::MaxValue)) - 1
    $total = $netEnd - $netStart + 1

    if ($total -le 0) {
        _Write-ErrorMsg "网段太小 ($($subnet.IP)/$prefix)，无可扫描主机"
        _Wait-EnterKey; return
    }

    $result = _Confirm-LargeScale -Count ([int]$total) -AutoMax 254 -ConfirmMax 4094 -Description "待扫描的 IP 地址"
    if ($result -ne "Proceed") { _Wait-EnterKey; return }

    Write-Host "并行扫描 $($subnet.IP)/$prefix ($total 个主机)..." -ForegroundColor DarkGray
    $sw = [System.Diagnostics.Stopwatch]::StartNew()

    # 构建 IP 列表
    $ipList = @()
    for ($i = $netStart; $i -le $netEnd; $i++) { $ipList += _UInt32ToIp $i }

    # 并行 Ping 扫描任务
    $scanBlock = [ScriptBlock]::Create(@'
param($ip)
$pinger = New-Object System.Net.NetworkInformation.Ping
$po = New-Object System.Net.NetworkInformation.PingOptions; $po.Ttl = 128; $po.DontFragment = $false
$buf = New-Object byte[] 32; for ($j = 0; $j -lt 32; $j++) { $buf[$j] = 0x61 }
try { $r = $pinger.Send($ip, 500, $buf, $po); $pinger.Dispose(); if ($r.Status -eq 'Success') { return $ip } } catch { }
$pinger.Dispose(); return $null
'@)

    $onlineIps = New-Object System.Collections.ArrayList
    $sync2 = [hashtable]::Synchronized(@{ Scanned = 0; Online = $onlineIps })
    $onScanDone = {
        param($data)
        $sync2.Scanned++
        if ($data -and -not $data.Error) { [void]$sync2.Online.Add($data) }
        if ($sync2.Scanned % 50 -eq 0 -or $sync2.Scanned -eq $ipList.Count) {
            Write-Host "`r  扫描进度: $($sync2.Scanned)/$($ipList.Count) 在线: $($sync2.Online.Count)" -NoNewline
        }
    }

    $null = _Invoke-Parallel -ScriptBlock $scanBlock -InputObjects $ipList -Throttle 64 -OnComplete $onScanDone
    Write-Host ""

    if ($onlineIps.Count -eq 0) {
        Write-Host "未发现在线设备" -ForegroundColor Yellow
        _Wait-EnterKey; return
    }

    Write-Host "在线设备: $($onlineIps.Count)，正在查询主机名和厂商..." -ForegroundColor DarkGray

    # Phase 2: Read ARP table
    $arpEntries = _Get-ArpTable
    $arpMap = @{}
    foreach ($e in $arpEntries) {
        $arpMap[$e.InternetAddress] = $e.PhysicalAddress
    }

    # Phase 3: Resolve each device and display immediately
    $devices = @()
    $devIdx = 0
    foreach ($ip in $onlineIps) {
        $devIdx++
        $mac = if ($arpMap.ContainsKey($ip)) { $arpMap[$ip] } else { "-" }
        # Hostname resolution
        $hostname = "-"
        try {
            $dns = [System.Net.Dns]::GetHostEntry($ip)
            if ($dns.HostName -and $dns.HostName -ne $ip) { $hostname = $dns.HostName }
        } catch { }
        # NetBIOS
        if ($hostname -eq "-") {
            try {
                $nb = & cmd.exe /c "nbtstat -A $ip 2>&1"
                foreach ($l in $nb) {
                    if ($l -match '^\s*(\S+)\s+<00>\s+UNIQUE') { $hostname = $Matches[1]; break }
                }
            } catch { }
        }
        # OUI
        $vendor = if ($mac -ne "-") { _Resolve-OUI $mac } else { $null }
        $vendorStr = if ($vendor) { $vendor } else { "未知" }
        $d = [PSCustomObject]@{ IP=$ip; MAC=$mac; Hostname=$hostname; Vendor=$vendorStr }
        $devices += $d
        # 实时显示
        $color = if ($hostname -ne "-") { "Green" } elseif ($vendorStr -eq "未知") { "Yellow" } else { "White" }
        $devStr = "{0:D2}" -f $devIdx
        _Write-Color "[$devStr] $ip | $mac | $hostname | $vendorStr" $color
    }

    $sw.Stop()
    Write-Host ""
    Write-Host "在线设备: $($devices.Count) | 有主机名: $(($devices | Where-Object { $_.Hostname -ne '-' }).Count) | 耗时: $($sw.ElapsedMilliseconds)ms" -ForegroundColor DarkGray
    _Wait-EnterKey
}

function Invoke-IpConflict {
    Write-Host ""
    Write-Host "=== IP 冲突检测 ===" -ForegroundColor DarkGray
    Write-Host ""
    $raw = Read-Host "请输入待检测 IP [-w <超时ms>]（B 返回）"
    if ($raw -eq 'B' -or $raw -eq 'b') { return }
    if ([string]::IsNullOrWhiteSpace($raw)) { _Write-ErrorMsg "未输入 IP 地址"; _Wait-EnterKey; return }

    $defs = @{
        Target  = @{ Long="Target"; Short=""; Position=0; Default="" }
        Timeout = @{ Long="w"; Short="w"; Position=-1; Default="1500" }
    }
    $parsed = _Parse-Args -RawInput $raw -ParamDefs $defs
    if (-not $parsed.Target) { _Write-ErrorMsg "未指定 IP 地址"; _Wait-EnterKey; return }
    $target = $parsed.Target

    # 检查目标 IP 是否在本地子网内（ARP 只对本地子网有效）
    $subnet = _Get-ActiveSubnet
    $onLocalSubnet = $false
    if ($subnet -and $subnet.IP) {
        $localIpBin = _IpToUInt32 $subnet.IP
        $prefix = if ($subnet.SubnetMask -match '^\d+$') { [int]$subnet.SubnetMask } else { 24 }
        $mask = if ($prefix -eq 0) { 0 } else { ([uint32]::MaxValue -shl (32 - $prefix)) -band [uint32]::MaxValue }
        $targetBin = _IpToUInt32 $target
        $onLocalSubnet = ($localIpBin -band $mask) -eq ($targetBin -band $mask)
    }
    if (-not $onLocalSubnet) {
        Write-Host ""
        _Write-Color "该 IP ($target) 不在本地子网内，ARP 检测仅适用于同一网段。" Yellow
        Write-Host "  Ping 成功不代表 IP 冲突——可能是路由器转发的。"
        Write-Host "  建议：检测本地子网内的 IP（如本机所在 /24 网段）。"
        _Wait-EnterKey; return
    }

    # ADR-006: No arp -d, use before/after diff
    $arpBefore = _Get-ArpTable
    $macBefore = ($arpBefore | Where-Object { $_.InternetAddress -eq $target } | Select-Object -First 1).PhysicalAddress

    Write-Host "正在检测 $target..." -ForegroundColor DarkGray
    try {
        $pinger = New-Object System.Net.NetworkInformation.Ping
        $po = New-Object System.Net.NetworkInformation.PingOptions; $po.Ttl = 128; $po.DontFragment = $false
        $buf = New-Object byte[] 32; for ($j = 0; $j -lt 32; $j++) { $buf[$j] = 0x61 }
        for ($p = 1; $p -le 2; $p++) { try { $pinger.Send($target, 1500, $buf, $po) | Out-Null } catch { } }
        $pinger.Dispose()
    } catch { }
    Start-Sleep -Milliseconds 500

    $arpAfter = _Get-ArpTable
    $macsAfter = @($arpAfter | Where-Object { $_.InternetAddress -eq $target })

    Write-Host ""
    if ($macsAfter.Count -eq 0) {
        _Write-Color "该 IP $target 当前空闲，未发现占用" Green
    } elseif ($macsAfter.Count -eq 1) {
        $mac = $macsAfter[0].PhysicalAddress
        _Write-Color "该 IP $target 已被占用" Yellow
        Write-Host "  占用主机 MAC: $mac"
        # Try DNS reverse lookup
        try { $h = [System.Net.Dns]::GetHostEntry($target); Write-Host "  主机名: $($h.HostName)" } catch { }
    } else {
        _Write-Color "检测到 IP 地址冲突！多个设备响应同一 IP:" Red
        foreach ($m in $macsAfter) {
            Write-Host "  MAC: $($m.PhysicalAddress)"
        }
    }
    _Wait-EnterKey
}

function Invoke-AdapterInfo {
    $adapters = _Get-AdapterInfo
    if (-not $adapters -or $adapters.Count -eq 0) {
        _Write-ErrorMsg "无法获取网卡信息"
        _Wait-EnterKey; return
    }
    Write-Host ""
    foreach ($a in $adapters) {
        $color = if ($a.Status -eq "Up") { "Green" } else { "Red" }
        Write-Host "------------------------------------------------------------" -ForegroundColor DarkGray
        _Write-Color "  $($a.Name)" $color
        Write-Host "    连接状态 : $($a.Status)"
        Write-Host "    MAC 地址 : $($a.MacAddress)"
        Write-Host "    IPv4 地址 : $($a.IPv4)"
        Write-Host "    子网掩码 : $($a.SubnetMask)"
        Write-Host "    默认网关 : $($a.Gateway)"
        Write-Host "    DNS 服务器: $($a.DnsServers)"
        Write-Host "    连接速率 : $($a.Speed)"
    }
    Write-Host "------------------------------------------------------------" -ForegroundColor DarkGray
    Write-Host "共 $($adapters.Count) 块网卡" -ForegroundColor DarkGray
    _Wait-EnterKey
}

function Invoke-ArpTable {
    $entries = _Get-ArpTable
    if (-not $entries -or $entries.Count -eq 0) {
        Write-Host "ARP 缓存表为空" -ForegroundColor Yellow
        _Wait-EnterKey; return
    }
    Write-Host ""
    foreach ($e in $entries) {
        $color = if ($e.Type -eq "静态") { "Cyan" } else { "White" }
        _Write-Color "  $($e.InternetAddress) -> $($e.PhysicalAddress) [$($e.Type)]" $color
    }
    Write-Host "ARP 条目总数: $($entries.Count)" -ForegroundColor DarkGray
    _Wait-EnterKey
}

function Invoke-RouteTable {
    $entries = _Get-RouteTable
    if (-not $entries -or $entries.Count -eq 0) {
        Write-Host "路由表为空" -ForegroundColor Yellow
        _Wait-EnterKey; return
    }
    Write-Host ""
    foreach ($e in $entries) {
        $isDefault = $e.Destination -eq "0.0.0.0" -or $e.Destination -eq "0.0.0.0/0"
        $isLoopback = $e.Destination -match '^127\.'
        if ($isDefault) {
            _Write-Color "  $($e.Destination) -> $($e.NextHop) (接口: $($e.Interface) 跃点: $($e.Metric)) [默认路由]" Yellow
        } elseif ($isLoopback) {
            _Write-Color "  $($e.Destination) -> $($e.NextHop) [$($e.Interface)]" DarkGray
        } else {
            Write-Host "  $($e.Destination) -> $($e.NextHop) (接口: $($e.Interface) 跃点: $($e.Metric))"
        }
    }
    Write-Host "路由条目总数: $($entries.Count)" -ForegroundColor DarkGray
    _Wait-EnterKey
}

function Invoke-SubnetCalc {
    Write-Host ""
    Write-Host "=== 子网计算器 ===" -ForegroundColor DarkGray
    Write-Host ""
    $raw = Read-Host "请输入（CIDR 如 192.168.1.0/24 或 IP+掩码 如 192.168.1.0 255.255.255.0，B 返回）"
    if ($raw -eq 'B' -or $raw -eq 'b') { return }
    if ([string]::IsNullOrWhiteSpace($raw)) { _Write-ErrorMsg "未输入任何内容"; _Wait-EnterKey; return }

    # 解析输入
    $ip = $null; $prefix = -1
    if ($raw -match '^(\d+\.\d+\.\d+\.\d+)\s*/\s*(\d+)$') {
        $ip = $Matches[1]; $prefix = [int]$Matches[2]
        # 从前缀长度计算子网掩码
        if ($prefix -eq 0) { $maskBin = 0 } else { $maskBin = ([uint32]::MaxValue -shl (32 - $prefix)) -band [uint32]::MaxValue }
        $maskStr = "$(($maskBin -shr 24) -band 0xFF).$(($maskBin -shr 16) -band 0xFF).$(($maskBin -shr 8) -band 0xFF).$($maskBin -band 0xFF)"
    } elseif ($raw -match '^(\d+\.\d+\.\d+\.\d+)\s+(\d+\.\d+\.\d+\.\d+)$') {
        $ip = $Matches[1]
        $maskStr = $Matches[2]
        $maskParts = $maskStr -split '\.'
        $valid = $true
        foreach ($p in $maskParts) { if ([int]$p -lt 0 -or [int]$p -gt 255) { $valid = $false } }
        if (-not $valid) { _Write-ErrorMsg "子网掩码格式不合法" "示例：255.255.255.0"; _Wait-EnterKey; return }
        $maskBin = 0
        foreach ($p in $maskParts) { $maskBin = ($maskBin -shl 8) -bor [uint32]$p }
        # 检查掩码连续性
        $binStr = [Convert]::ToString($maskBin, 2).PadLeft(32, '0')
        if ($binStr -match '^1*0*$') {
            $prefix = $binStr.IndexOf('0')
            if ($prefix -lt 0) { $prefix = 32 }
        } else {
            _Write-ErrorMsg "子网掩码不连续（必须为连续的 1 后跟连续的 0）" "示例：255.255.255.0 是合法的，255.0.255.0 不合法"
            _Wait-EnterKey; return
        }
    } else {
        _Write-ErrorMsg "输入格式无法识别" "示例：192.168.1.0/24 或 192.168.1.0 255.255.255.0"
        _Wait-EnterKey; return
    }

    if ($prefix -lt 0 -or $prefix -gt 32) {
        _Write-ErrorMsg "前缀长度超出范围（0-32）"
        _Wait-EnterKey; return
    }

    # 验证 IP 格式
    $ipParts = $ip -split '\.'
    $ipValid = $true
    foreach ($p in $ipParts) { if ([int]$p -lt 0 -or [int]$p -gt 255) { $ipValid = $false } }
    if (-not $ipValid) { _Write-ErrorMsg "IP 地址格式不合法"; _Wait-EnterKey; return }

    # 位运算
    $ipBin = _IpToUInt32 $ip
    if ($prefix -eq 0) { $maskBin = 0 } else { $maskBin = ([uint32]::MaxValue -shl (32 - $prefix)) -band [uint32]::MaxValue }
    $netBin = $ipBin -band $maskBin
    $broadBin = $netBin -bor ((-bnot $maskBin) -band [uint32]::MaxValue)

    $netAddr = _UInt32ToIp $netBin
    $broadAddr = _UInt32ToIp $broadBin
    $maskAddr = _UInt32ToIp $maskBin
    $firstHost = if ($prefix -ge 31) { $netBin } else { $netBin + 1 }
    $lastHost  = if ($prefix -ge 31) { $broadBin } else { $broadBin - 1 }

    $totalHosts = if ($prefix -eq 32) { 1 } elseif ($prefix -eq 31) { 2 } else { [Math]::Pow(2, 32 - $prefix) - 2 }

    Write-Host ""
    _Write-Color "网络地址:     $netAddr" Green
    _Write-Color "广播地址:     $broadAddr" Green
    _Write-Color "子网掩码:     $maskStr" Green
    _Write-Color "前缀长度:     /$prefix" Green
    _Write-Color "可用主机范围: $(_UInt32ToIp $firstHost) ~ $(_UInt32ToIp $lastHost)" Green
    if ($prefix -eq 32) {
        _Write-Color "可用主机数:   1（/32 仅包含单个主机地址）" Yellow
    } elseif ($prefix -eq 31) {
        _Write-Color "可用主机数:   2（点对点链路 /31）" Green
    } else {
        _Write-Color "可用主机数:   $totalHosts" Green
    }
    Write-Host "所属网段:     输入的 IP $ip 在网段 $netAddr/$prefix 内" -ForegroundColor DarkGray
    _Wait-EnterKey
}

function Invoke-IpCalc {
    _Show-SubMenu -Title "IP 计算器" -Options @(
        @{ Key = "1"; Label = "进制转换 -> IP 点分十进制 <-> 二进制 <-> 十六进制 <-> 32位整数" }
        @{ Key = "2"; Label = "归属判断 -> 判断某 IP 是否属于某网段（CIDR）" }
        @{ Key = "3"; Label = "地址距离 -> 计算两个 IP 之间相差的地址数量" }
    )
    $choice = Read-Host "请输入选项"
    if ($choice -eq 'B' -or $choice -eq 'b') { return }

    switch ($choice) {
        "1" {
            $raw = Read-Host "请输入 IP 地址 / 32位整数 / 十六进制(0x...) / 32位二进制"
            if ($raw -eq 'B' -or $raw -eq 'b') { return }
            $ipUint32 = [uint32]0; $ipBytes = @()
            try {
                if ($raw -match '^0[xX]([0-9a-fA-F]+)') {
                    $ipUint32 = [uint32]('0x' + $Matches[1]) -band [uint32]::MaxValue
                } elseif ($raw -match '^[01]{32}$') {
                    $ipUint32 = [Convert]::ToUInt32($raw, 2)
                } elseif ($raw -match '^-?\d+$' -and $raw.Length -gt 9) {
                    $ipUint32 = [uint32]$raw -band [uint32]::MaxValue
                } elseif ($raw -match '^\d+\.\d+\.\d+\.\d+$') {
                    $ipUint32 = _IpToUInt32 $raw
                } else {
                    _Write-ErrorMsg "无法识别输入格式" "示例：192.168.1.1 | 0xC0A80101 | 3232235777 | 11000000101010000000000100000001"; return
                }
            } catch { _Write-ErrorMsg "输入格式不合法" "检查输入内容"; return }

            $dotted = _UInt32ToIp $ipUint32
            $hex = "0x" + $ipUint32.ToString("X8")
            $binary = [Convert]::ToString($ipUint32, 2).PadLeft(32, '0')
            $binSpaced = $binary.Substring(0,8) + " " + $binary.Substring(8,8) + " " + $binary.Substring(16,8) + " " + $binary.Substring(24,8)

            Write-Host ""
            _Write-Color "点分十进制:   $dotted" Green
            _Write-Color "二进制:       $binSpaced" Green
            _Write-Color "十六进制:     $hex" Green
            _Write-Color "32位整数:     $ipUint32" Green
        }
        "2" {
            $raw = Read-Host "请输入 <待判断IP> <网段CIDR>（如 192.168.1.100 192.168.1.0/24）"
            if ($raw -eq 'B' -or $raw -eq 'b') { return }
            if ($raw -notmatch '^(\d+\.\d+\.\d+\.\d+)\s+(\d+\.\d+\.\d+\.\d+)/(\d+)$') {
                _Write-ErrorMsg "输入格式不正确" "示例：192.168.1.100 192.168.1.0/24"; return
            }
            $testIp = _IpToUInt32 $Matches[1]
            $netIp = _IpToUInt32 $Matches[2]
            $prefix = [int]$Matches[3]
            if ($prefix -eq 0) { $mask = 0 } else { $mask = ([uint32]::MaxValue -shl (32 - $prefix)) -band [uint32]::MaxValue }
            $netStart = $netIp -band $mask
            $netEnd = $netStart -bor ((-bnot $mask) -band [uint32]::MaxValue)

            Write-Host ""
            Write-Host "网段范围: $(_UInt32ToIp $netStart) ~ $(_UInt32ToIp $netEnd)" -ForegroundColor DarkGray
            if ($testIp -ge $netStart -and $testIp -le $netEnd) {
                _Write-Color "IP $($Matches[1]) 属于网段 $($Matches[2])/$prefix" Green
            } else {
                _Write-Color "IP $($Matches[1]) 不属于网段 $($Matches[2])/$prefix" Red
            }
        }
        "3" {
            $raw = Read-Host "请输入 <IP地址1> <IP地址2>（如 192.168.1.1 192.168.1.100）"
            if ($raw -eq 'B' -or $raw -eq 'b') { return }
            if ($raw -notmatch '^(\d+\.\d+\.\d+\.\d+)\s+(\d+\.\d+\.\d+\.\d+)$') {
                _Write-ErrorMsg "输入格式不正确" "示例：192.168.1.1 192.168.1.100"; return
            }
            $ip1 = _IpToUInt32 $Matches[1]
            $ip2 = _IpToUInt32 $Matches[2]
            $diff = if ($ip1 -gt $ip2) { $ip1 - $ip2 } else { $ip2 - $ip1 }
            $direction = if ($ip1 -lt $ip2) { "之前" } elseif ($ip1 -gt $ip2) { "之后" } else { "（相等）" }
            Write-Host ""
            _Write-Color "IP $($Matches[1]) 在 $($Matches[2]) $direction，相差 $diff 个地址" Green
        }
        default { _Write-ErrorMsg "无效选项" "输入 1、2、3 或 B" }
    }
    _Wait-EnterKey
}

function Invoke-QuickRef {
    Write-Host ""
    Write-Host "=== 常用命令速查 ===" -ForegroundColor DarkGray
    Write-Host ""

    $idx = 1
    $currentCategory = ""
    foreach ($item in $_QuickReference) {
        if ($item.Category -ne $currentCategory) {
            if ($currentCategory -ne "") { Write-Host "" }
            _Write-Color "--- $($item.Category) ---" DarkGray
            $currentCategory = $item.Category
        }
        $idxStr = "{0:D2}" -f $idx
        Write-Host "  [$idxStr] " -NoNewline
        _Write-Color $item.Command Cyan
        Write-Host "    $($item.Description)"
        $idx++
    }

    Write-Host ""
    Write-Host "--- 以上命令均为系统原生命令，本工具仅作速查展示，不代为执行 ---" -ForegroundColor DarkGray
    Write-Host ""
    Write-Host "输入命令序号复制到剪贴板，或按 Enter 返回主菜单" -ForegroundColor DarkGray

    while ($true) {
        $choice = Read-Host "请输入序号"
        if ([string]::IsNullOrWhiteSpace($choice)) { break }
        $num = 0
        if (-not [int]::TryParse($choice, [ref]$num)) {
            _Write-Color "无效序号" Yellow; continue
        }
        if ($num -lt 1 -or $num -gt $_QuickReference.Count) {
            _Write-Color "序号超出范围 (1-$($_QuickReference.Count))" Yellow; continue
        }
        $cmd = $_QuickReference[$num - 1].Command
        Set-Clipboard -Value $cmd
        _Write-Color "已复制: $cmd" Green
    }
}

function Invoke-FlushDns {
    Write-Host ""
    Write-Host "=== 清空 DNS 缓存 ===" -ForegroundColor DarkGray
    Write-Host ""
    Write-Host "正在执行 ipconfig /flushdns..." -ForegroundColor DarkGray
    $output = & cmd.exe /c "ipconfig /flushdns 2>&1"
    $success = $false
    foreach ($line in $output) {
        Write-Host $line
        if ($line -match 'successfully|已成功') { $success = $true }
    }
    Write-Host ""
    if ($success) {
        _Write-Color "DNS 缓存已成功清空" Green
    } else {
        _Write-Color "清空完成（如失败请尝试以管理员身份运行）" Yellow
    }
    _Wait-EnterKey
}

function Invoke-RenewDhcp {
    Write-Host ""
    Write-Host "=== 重新获取 DHCP 地址 ===" -ForegroundColor DarkGray
    Write-Host ""
    Write-Host "正在释放当前 IP 地址..." -ForegroundColor DarkGray
    $releaseOut = & cmd.exe /c "ipconfig /release 2>&1"
    foreach ($line in $releaseOut) { Write-Host $line }

    Write-Host ""
    Write-Host "正在重新获取 IP 地址..." -ForegroundColor DarkGray
    $renewOut = & cmd.exe /c "ipconfig /renew 2>&1"
    $success = $false
    foreach ($line in $renewOut) {
        Write-Host $line
        if ($line -match 'IPv4|IP Address|IP 地址|子网掩码|Subnet Mask') { $success = $true }
    }
    Write-Host ""
    if ($success) {
        _Write-Color "DHCP 地址已重新获取" Green
    } else {
        _Write-Color "续租完成（如失败请尝试以管理员身份运行）" Yellow
    }
    _Wait-EnterKey
}

function Invoke-OpenGateway {
    Write-Host ""
    Write-Host "=== 打开网关管理页 ===" -ForegroundColor DarkGray
    Write-Host ""
    $gw = _Get-DefaultGateway
    if (-not $gw) {
        _Write-ErrorMsg "无法获取默认网关" "检查网络连接后重试"
        _Wait-EnterKey; return
    }
    $url = "http://$gw"
    Write-Host "网关地址: $gw" -ForegroundColor Cyan
    Write-Host "正在使用默认浏览器打开 $url ..." -ForegroundColor DarkGray
    try {
        Start-Process $url
        _Write-Color "已启动浏览器，如在弹出窗口中未见页面请手动访问 $url" Green
    } catch {
        _Write-ErrorMsg "无法启动浏览器" "手动在浏览器中访问 $url"
    }
    _Wait-EnterKey
}

# ============================================================
# [4] 菜单系统
# ============================================================

$_MainMenuOptions = @(
    @{ Category = "连通性检测"; Items = @(
        @{ Num = 1;  Label = "Ping 连通性测试";          Func = "Invoke-PingTest" }
        @{ Num = 2;  Label = "TCP 端口探测";              Func = "Invoke-TcpPortTest" }
        @{ Num = 3;  Label = "路由追踪 (Tracert)";       Func = "Invoke-Tracert" }
        @{ Num = 4;  Label = "批量 Ping 健康检查";       Func = "Invoke-BatchPing" }
    )}
    @{ Category = "协议与服务"; Items = @(
        @{ Num = 5;  Label = "DNS 解析";                  Func = "Invoke-DnsResolve" }
        @{ Num = 6;  Label = "HTTP 服务探测";            Func = "Invoke-HttpProbe" }
        @{ Num = 7;  Label = "DHCP 服务器扫描";          Func = "Invoke-DhcpScan" }
    )}
    @{ Category = "局域网诊断"; Items = @(
        @{ Num = 8;  Label = "二层环路检测";              Func = "Invoke-LoopDetect" }
        @{ Num = 9;  Label = "局域网设备扫描";           Func = "Invoke-LanScan" }
        @{ Num = 10; Label = "IP 冲突检测";               Func = "Invoke-IpConflict" }
    )}
    @{ Category = "本机信息"; Items = @(
        @{ Num = 11; Label = "网卡配置信息";              Func = "Invoke-AdapterInfo" }
        @{ Num = 12; Label = "ARP 缓存表";                Func = "Invoke-ArpTable" }
        @{ Num = 13; Label = "路由表";                    Func = "Invoke-RouteTable" }
        @{ Num = 14; Label = "本机监听端口查看";         Func = "Invoke-ListeningPorts" }
    )}
    @{ Category = "实用工具"; Items = @(
        @{ Num = 15; Label = "子网计算器";                Func = "Invoke-SubnetCalc" }
        @{ Num = 16; Label = "IP 计算器";                 Func = "Invoke-IpCalc" }
        @{ Num = 17; Label = "MAC 厂商查询";              Func = "Invoke-MacVendor" }
        @{ Num = 18; Label = "常用命令速查";             Func = "Invoke-QuickRef" }
        @{ Num = 19; Label = "清空 DNS 缓存";             Func = "Invoke-FlushDns" }
        @{ Num = 20; Label = "重新获取 DHCP 地址";       Func = "Invoke-RenewDhcp" }
        @{ Num = 21; Label = "打开网关管理页";             Func = "Invoke-OpenGateway" }
    )}
)

function _Show-MainMenu {
    Clear-Host
    Write-Host "=====================-NetOpsBox-网络运维工具箱-======================" -ForegroundColor DarkGray

    foreach ($section in $_MainMenuOptions) {
        Write-Host "-- $($section.Category) --" -ForegroundColor DarkGray
        foreach ($item in $section.Items) {
            $numStr = "{0:D2}" -f $item.Num
            Write-Host "  [$numStr] $($item.Label)"
        }
    }

    Write-Host "-- 系统 --" -ForegroundColor DarkGray
    Write-Host "  [00] 退出"
    Write-Host "======================================================================" -ForegroundColor DarkGray
    Write-Host ""
}

function _Get-FuncByName {
    param([string]$Name)
    foreach ($section in $_MainMenuOptions) {
        foreach ($item in $section.Items) {
            if ($item.Num -eq [int]$Name) { return $item.Func }
        }
    }
    return $null
}

function _Dispatch-Menu {
    $running = $true
    while ($running) {
        _Show-MainMenu
        $choice = Read-Host "请输入选项"
        Write-Host ""

        if ($choice -eq '0' -or $choice -eq '00') {
            Write-Host "感谢使用 NetOpsBox，再见！" -ForegroundColor Green
            $running = $false
            break
        }

        $funcName = _Get-FuncByName $choice
        if ($funcName) {
            & $funcName
        } else {
            Write-Host "无效选项，请重新输入（输入数字 01-21 选择功能，00 退出）" -ForegroundColor Yellow
            Start-Sleep -Seconds 1
        }
    }
}

# ============================================================
# [5] 入口函数
# ============================================================

function Invoke-NetOpsBox {
    # Verbose 时显示环境信息
    if ($VerbosePreference -eq 'Continue') {
        Write-Host "--- 环境信息 ---" -ForegroundColor DarkGray
        Write-Host "OS 版本: $($_EnvInfo.OSVersion.VersionString)"
        Write-Host "OS 位宽: $(if ($_EnvInfo.Is64BitOS) { '64-bit' } else { '32-bit' })"
        Write-Host "PS 位宽: $(if ($_EnvInfo.Is64BitPS) { '64-bit' } else { '32-bit' })"
        Write-Host "PS 版本: $($_EnvInfo.PSVersion)"
        Write-Host "计算机名: $($_EnvInfo.ComputerName)"
        Write-Host "----------------" -ForegroundColor DarkGray
    }

    # 设置控制台编码为 UTF-8（如果支持）
    try {
        [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
    } catch { }

    _Dispatch-Menu
}