基于广播通信模型的服务器端和客户端通信程序

基于广播通信模型的服务器端和客户端通信程序

关键词:Win32 API、Winsock 2、UDP 广播、SO_BROADCAST、SO_REUSEADDR、16 字节应用层报头、UTF-8、客户端多实例、Python 压力测试

目录



一、实验目的

本实验以 Win32 API 与 Winsock 2 为开发基础,设计并实现基于 UDP 广播通信模型的服务器端与客户端图形界面程序。服务器按照设定周期向子网定向广播地址发送携带中文正文的广播报文,客户端在同一子网内监听指定端口,完成报文接收、协议校验、序号统计与界面显示;在此基础上,通过 Python 批量压力测试脚本对服务器发送速率、客户端并发数量、长时间稳定性以及极限负载进行量化测试。

本实验的主要目标如下:

  1. 掌握 Winsock 2 的初始化、UDP 套接字创建、地址绑定、广播发送、数据报接收和资源释放流程。
  2. 理解 SO_BROADCAST、SO_REUSEADDR、子网定向广播地址和 UDP 数据报边界在广播通信中的作用。
  3. 掌握应用层广播报文的报头设计、网络字节序转换、UTF-8 编解码、序号统计和异常报文过滤方法。
  4. 实现服务器端广播发送线程、客户端接收线程以及 Win32 图形界面之间的消息协同,保证网络操作不阻塞窗口消息循环。
  5. 设计基准功能、发送速率、客户端数量、长时间稳定性和极限压力五类测试用例,结合边界内与边界外条件评价程序的运行边界。

二、 实验内容与设计思想

2.1 实验内容

本实验的服务器端与客户端均采用 Win32 图形界面。服务器默认绑定实验网卡地址 192.168.50.1,向子网定向广播地址 192.168.50.255 的 1145 端口发送广播报文,正文默认为“今天是个好日子!”,默认发送周期为 1000 ms。客户端默认监听 192.168.50.2:1145,也可以监听 0.0.0.0:1145 或同一端口上的其他本机地址。服务器每发送一个报文,同一广播域内所有绑定该端口的客户端均可收到该报文。

本实验的数据面是服务器到客户端的单向一对多广播:服务器不建立连接,不维护客户端连接表,也不等待客户端确认;客户端只负责接收、校验和显示。程序的可观测性由应用层报头中的序号、正文长度以及客户端的接收计数、序号缺失计数和非法报文计数共同提供。为了说明本实验的模块组成和代码文件之间的调用关系,表1列出各文件的主要职责。后续代码说明与代码占位均按照这些文件安排。

表1 程序文件及功能

文件 主要功能
common.h 定义广播常量、默认地址与端口、16 字节应用层报头、报文构造与解析、UTF-8/UTF-16 转换、IPv4 文本解析与格式化、Winsock 初始化、日志写入和 Win32 控件辅助函数
server.cpp 创建服务器窗口,读取绑定地址、广播地址、端口、周期和正文,创建 UDP 广播套接字,启动发送线程,维护发送统计并支持自动测试模式
client.cpp 创建客户端窗口,读取监听地址和端口,创建带 SO_REUSEADDR 的 UDP 套接字,启动接收线程,解析广播报文并更新界面与统计
stress_test.py 使用 Python 原始套接字复现同一广播协议,完成真实广播、多端点、边界、五类压力用例和 Markdown/JSON 报告生成
build_msvc.bat 使用 MSVC 编译 server.exe 与 client.exe,统一 UTF-8 源文件解码并链接 Winsock 与 Win32 库
gui_demo.py 自动启动服务器和客户端窗口、点击按钮并抓取界面截图,用于界面联调与实验记录

系统结构由服务器窗口、服务器发送线程、公共广播协议模块、客户端接收线程、客户端窗口和压力测试脚本组成。图1展示各模块之间的调用关系以及广播报文从服务器到多个客户端的传递方向。

图1UDP 广播架构技术框图

图1 系统模块与广播通信关系图

图示说明:展示服务器窗口、发送线程、common.h 公共广播协议、多个客户端接收线程以及压力测试脚本之间的模块关系和 UDP 广播方向。

2.2 通信地址与连接参数

服务器默认绑定 192.168.50.1,广播目标为 192.168.50.255:1145;客户端默认监听 192.168.50.2:1145。服务器绑定源地址而不是 INADDR_ANY,可以保证广播报文从 TCP-Lab 实验网卡发出,避免被 Wi-Fi 或其他虚拟网卡选中。客户端绑定具体地址时只接收该地址上的广播;绑定 0.0.0.0 时接收本机所有接口到达该端口的数据报。

对于 IPv4 的 /24 子网,定向广播地址由网络号与主机位全 1 组成。设服务器地址为 \(A_{srv}\),/24 掩码为 \(M_{24} = 255.255.255.0\),则广播地址可表示为式(1):

\[A_{bcast} = (A_{srv} \land M_{24}) \vee \neg M_{24} \tag{1} \]

当 \(A_{srv} = 192.168.50.1\) 时,\(A_{bcast} = 192.168.50.255\)。该地址是子网定向广播地址,不是 255.255.255.255 的受限广播地址;前者只在指定子网内传播,后者通常不跨越路由器。表2列出程序的默认通信配置。

表2 默认通信配置

项目 配置
网络层协议 IPv4
传输层协议 UDP
服务器绑定地址 192.168.50.1
广播目标地址 192.168.50.255
客户端监听地址 192.168.50.2,也可为 0.0.0.0
默认端口 1145
默认正文 “今天是个好日子!”
正文编码 UTF-8
报头长度 16 字节
最大正文长度 1400 字节
最大数据报长度 1416 字节
默认发送周期 1000 ms
广播套接字选项 SO_BROADCAST
客户端复用选项 SO_REUSEADDR
并发客户端上限 无固定连接上限;实际受操作系统进程、套接字和缓冲区资源限制

2.3 应用层数据帧设计

UDP 本身保留数据报边界,一次 sendto() 对应一次 recvfrom(),因此不需要像 TCP 那样用长度前缀切分字节流。但是,本实验仍需在 UDP 正文之前增加固定报头,用于识别“这是本程序的广播报文”、区分协议版本、统计发送序号、校验正文长度并过滤无关广播。表3说明 16 字节报头的字段布局。

表3 应用层数据帧格式

字段 长度 编码形式 作用
Magic 4 字节 ASCII 字符 B、C、S、T 标识本程序的广播报文
Version 1 字节 无符号整数,当前为 1 协议版本
Type 1 字节 无符号整数,1 表示文本消息 报文类型
Reserved 2 字节 全 0 保留字段,便于后续扩展
Sequence 4 字节 无符号整数,网络字节序 发送序号,从 1 开始递增
PayloadLength 4 字节 无符号整数,网络字节序 后续 UTF-8 正文的字节数
Payload L_p 字节 UTF-8,不含结尾 '\0' 广播正文

设报头长度为 \(H = 16\),正文长度为 \(L_{p}\),则一个应用层数据报的总长度为式(2):

\[L = H + L_{p} = 16 + L_{p},\ \ \ \ 1 \leq L_{p} \leq 1400 \tag{2} \]

正文上限取 1400 字节,使 16+1400=1416 字节的应用层数据报在加入 8 字节 UDP 报头和 20 字节 IP 报头后仍小于以太网 1500 字节 MTU,从而避免 IP 分片。报头字段使用 memcpy 与 htonl()、ntohl() 显式处理,不直接把结构体映射到网络缓冲区,以避免结构体对齐、填充和大小端差异。

2.4 广播消息发送流程

服务器启动广播前,先读取并校验绑定地址、广播地址、端口、正文和发送周期;随后创建 UDP 套接字、设置 SO_BROADCAST、绑定服务器源地址,并把目标地址设置为子网广播地址。发送线程按设定周期构造报文并调用 sendto(),每成功发送一包就更新序号、发送计数和字节计数;当用户点击“停止广播”或达到自动模式设定的包数/时长时,线程退出并释放套接字资源。

设目标发送速率为 \(R_{target}\)(包/秒),则相邻两包的理想时间间隔为式(3):

\[\Delta t = \frac{1}{R_{target}},\ \ \ \ t_{k + 1} = t_{k} + \Delta t \tag{3} \]

图形界面模式使用 --interval 对应的毫秒周期;自动测试模式在 --pps 大于 0 时使用 QueryPerformanceCounter 计算目标时间点,采用“粗粒度 Sleep + 最后忙等”的方式减小定时误差,并对落后超过 2 ms 的时间点进行截断,避免形成突发补发。图2展示广播消息从参数校验到发送结束的流程。

图2UDP 广播发送流程图
图2 广播消息发送流程图

图示说明:展示从广播参数校验、创建 UDP 套接字、启用 SO_BROADCAST、构造报文、调用 sendto() 到停止发送的处理流程。

2.5 服务器端工作流程

服务器窗口提供绑定 IPv4、广播 IPv4、端口、正文和发送周期输入框,以及“启动广播”“停止广播”“立即发送”按钮。点击“启动广播”后,窗口过程读取控件文本并进行地址、端口、正文长度和周期校验;校验通过后调用套接字初始化函数,创建发送线程,并在日志中记录绑定地址、广播地址、端口和报文参数。发送线程通过停止事件和“立即发送”事件与窗口线程协同,窗口线程只负责界面更新,不直接执行阻塞式网络发送。

服务器不维护客户端列表,也不区分客户端数量;每发送一个报文,只是在本机 UDP 套接字上执行一次 sendto()。因此,服务器端的“客户端容量”不是连接表容量,而是发送线程、套接字缓冲区、网卡和操作系统调度等资源共同决定的实际承载能力。图3展示服务器从读取参数到启动、循环发送和停止的流程。

图3服务器广播流程图

图3 服务器端工作流程图

图示说明:展示服务器启动广播、创建工作线程、按周期或 pps 发送、停止判断,以及通过 PostMessage 异步更新窗口日志的过程。

2.6 客户端工作流程

客户端窗口提供监听 IPv4 和端口输入框,以及“开始监听”“停止监听”按钮。点击“开始监听”后,窗口过程校验地址与端口,创建 UDP 套接字,设置 SO_REUSEADDR 以允许同一主机上的多个客户端绑定同一端口,设置接收缓冲区,并绑定监听地址。接收线程使用 select() 等待可读事件,收到数据报后调用 recvfrom(),再交给报文解析函数校验报头、正文长度和序号;合法报文更新接收计数、字节计数和正文显示,非法报文只增加非法计数并丢弃。

客户端不需要连接服务器,也不发送确认报文;它只根据报头中的 Magic、Version、Type 和 PayloadLength 判断报文是否属于本程序。图4展示客户端从参数输入到监听、接收、解析和停止的流程。

图4客户端 UDP 监听流程图
图4 客户端工作流程图

图示说明:展示客户端参数校验、创建 UDP 套接字、启用 SO_REUSEADDR、select() 等待、recvfrom() 接收、协议解析与统计更新的过程。

2.7 广播数据传递流程

广播通信的数据面是服务器到多个客户端的单向传递:服务器只调用一次 sendto(),网卡发出一个以太网广播帧,交换机在同一 VLAN 内把该帧复制到所有端口,所有绑定目标端口的客户端都能收到同一份 UDP 数据报。该过程没有 TCP 的 connect()、accept()、确认报文和重传机制;服务器不知道有多少客户端,也不等待任何客户端回复。图5以横向泳道图展示服务器、网络和多个客户端之间的职责划分。

图5UDP广播数据流示意图

图5 客户端与服务器广播数据传递流程图

图示说明:展示服务器、广播域/交换机和多个客户端的单向广播数据传递,强调无连接、无 ACK 与无重传。

2.7 广播通信模型工作过程分析

广播通信模型的核心是“一个发送端、一个子网广播地址、多个接收端、无连接”。服务器创建 UDP 数据报套接字,设置 SO_BROADCAST,绑定实验网卡源地址,把目标地址设置为子网广播地址 192.168.50.255:1145,再调用 sendto() 发送;网卡把数据封装为以太网广播帧,交换机在同一 VLAN 内把帧复制到所有端口。客户端设置 SO_REUSEADDR,绑定 192.168.50.2:1145,通过 select() 和 recvfrom() 接收,再解析 16 字节报头。图5展示服务器、广播域和多个客户端之间的数据传递关系。

图6服务器广播到多客户端流程图
图6 客户端与服务器广播数据传递流程图

图示说明:展示服务器向广播域发送数据后,客户端 1 至 N 并行接收、解析报文和更新统计的分层泳道关系。

在程序实现中,广播模型分布在四个文件。common.h 定义 16 字节报头、BC_MAX_PAYLOAD=1400、Magic、版本、类型、序号和长度字段,并提供 BuildBroadcastPacket() 与 ParseBroadcastPacket();ParseIPv4Text() 与 FormatIPv4() 负责广播地址的文本解析与格式化。server.cpp 的 OpenServerSocket() 创建 SOCK_DGRAM 套接字、设置 SO_BROADCAST、绑定 192.168.50.1 并把目标地址设为 192.168.50.255:1145;SendOnePacket() 组包后执行 sendto();BroadcastWorker() 按周期或目标 pps 循环发送。服务器不调用 listen()、accept() 或 connect(),不保存客户端列表。

client.cpp 的 OpenClientSocket() 创建 UDP 套接字,设置 SO_REUSEADDR 和 4 MB 接收缓冲区,绑定 192.168.50.2:1145;ReceiveWorker() 用 select() 等待可读事件,recvfrom() 接收数据报;HandleDatagram() 调用 ParseBroadcastPacket() 校验报头,更新接收计数、序号缺失、重复计数和正文显示。SO_REUSEADDR 使同一主机上的多个客户端进程能够绑定同一端口,这是 3、16、128、144 个客户端同时接收的基础。stress_test.py 用 Python 原始套接字复现同一协议,设置 SO_BROADCAST 发送、SO_REUSEADDR 接收,支持多端点、边界和五类压力用例。

广播模型没有 TCP 的 connect()、accept()、三次握手、确认报文、重传和拥塞控制。服务器不知道客户端数量,也不等待客户端回复;客户端不向服务器发送确认。因此,广播是“尽力而为”的不可靠传输:报文可能因接收缓冲区满、网卡丢包、交换机拥塞或主机调度而丢失。程序通过 16 字节报头中的序号统计丢包:若客户端收到序号 \(s_{i - 1}\) 后直接收到 \(s_{i}\),则中间缺失 \(s_{i} - s_{i - 1} - 1\) 个包;累计缺失数由后文式(6)计算。

对于 \(m\) 个客户端,若服务器发送 \(N_{send}\) 个包且无丢包,则第 \(j\) 个客户端的期望接收数为:

\[N_{expect}^{(j)} = N_{send},\ \ \ \ j = 1,\ldots,m \tag{10} \]

本次 128 与 144 客户端测试都满足式(10):所有客户端均收到 10/10 包,说明广播服务器没有“第 129 个客户端被拒绝”的连接表逻辑;实际能承载多少客户端取决于操作系统进程/线程、套接字句柄、接收缓冲区、CPU 和网卡资源。TCP 服务器常见的 MAX_CLIENTS=128 是服务器主动维护的活动连接上限,与本实验的广播模型不是同一类边界。

广播模型的优点是实现简单、无需维护连接表、一次发送可被多个客户端接收;缺点是可靠性低、无确认/重传、广播域受限、交换机泛洪会增加网络负载,且难以精确知道接收端数量。图6展示广播模型从服务器发送到多个客户端接收的完整状态变化。

图7广播通信架构与客户端处理流程
图6 客户端与服务器广播数据传递流程图

图示说明:展示 UDP 广播模型从服务器生成报文、交换机复制广播帧、客户端监听与解析到最终显示的完整工作过程。


三、 实验使用环境

操作系统:Microsoft Windows 7/8/10/11

编程环境:Visual C++ 6.0


四、实验步骤和调试过程(写出详细的代码并插入清晰的效果截图)

4.1 文件准备与编译

4.1.1 配置实验网卡

实验开始前先配置 TCP-Lab 实验网卡,使服务器地址 192.168.50.1 和客户端地址 192.168.50.2 同时存在于同一块 /24 网卡上。配置步骤如下:

  1. 关闭可能占用 1145 端口的程序,断开实验网卡与外部网络的桥接,确认实验环境处于隔离状态。
  2. 以管理员身份打开命令提示符或 PowerShell,进入 TCP-Lab-一键网卡工具\lab-adapter-tools,运行 一键配置并开启实验网卡.cmd。脚本会创建或启用实验网卡,并配置双 IP。
  3. 等待脚本输出“实验网卡已开启,双 IP 配置可用”,不要关闭窗口,直到配置完成。
  4. 打开“网络连接”(ncpa.cpl),确认实验网卡状态为“已启用”,IPv4 地址为 192.168.50.1 和 192.168.50.2,子网掩码为 255.255.255.0;默认网关留空,避免实验流量走外部网络。
  5. 在 PowerShell 中执行 Get-NetAdapter 与 Get-NetIPAddress -AddressFamily IPv4,确认网卡状态为 Up,两个地址均为 Preferred;也可执行 ipconfig /all 核对。运行 python stress_test.py --mode lab-check,脚本会逐端点执行真实广播自检;自检通过后再编译和运行服务器/客户端。若网卡被禁用或显示错误代码 CM_PROB_DISABLED,在设备管理器中启用网卡后重新运行配置脚本;若出现重复 IP,先删除冲突地址再重新配置。
  6. 在 Windows Defender 防火墙中允许实验网卡所在“专用网络”的 UDP 入站,或仅在隔离实验期间临时关闭防火墙;实验结束后恢复防火墙策略。
  7. 实验结束后运行 一键关闭实验网卡.cmd,禁用实验网卡并恢复原有网络配置,避免 192.168.50.1/.2 与校园网地址冲突。图8为实验网卡配置的具体情况。

图片8
图8 实验网卡配置图

图示说明:实验网卡配置截图:展示 TCP-Lab 网卡的启用情况及 192.168.50.1、192.168.50.2 双 IPv4 地址配置。

4.1.2 文件准备与编译

将 common.h、server.cpp、client.cpp、stress_test.py、build_msvc.bat、build_mingw.bat 放在同一项目目录。common.h 以头文件形式被服务器和客户端共同包含;server.cpp 与 client.cpp 分别编译为独立的图形界面程序;stress_test.py 通过命令行调用两个 exe 的自动模式。

本次编译使用 build_msvc.bat --no-pause。脚本进入 MSVC x64 环境后分别编译 server.cpp 与 client.cpp,链接 ws2_32.lib、user32.lib、gdi32.lib 和 shell32.lib。编译结果如图9所示,应显示 Build succeeded 并生成 server.exe 与 client.exe。

图片9
图9 编译结果图

图示说明:程序编译结果截图:展示使用 MSVC 编译脚本生成 server.exe 和 client.exe 的结果。

4.2 common.h 公共模块详解

common.h 是服务器与客户端共享的通信基础模块,包含协议常量、Winsock 初始化、UTF-8/UTF-16 转换、IPv4 文本解析与格式化、广播报文构造与解析、日志写入以及 Win32 控件辅助函数。

4.2.1 常量和协议定义

DEFAULT_PORT 定义默认端口 1145;DEFAULT_BIND_IP_W、DEFAULT_CLIENT_IP_W 和 DEFAULT_BROADCAST_IP_W 分别定义服务器绑定地址、客户端监听地址和子网广播地址;DEFAULT_MESSAGE_W 保存默认中文正文;DEFAULT_INTERVAL_MS 定义默认广播周期 1000 ms。BC_HEADER_SIZE=16、BC_MAX_PAYLOAD=1400、BC_MAX_DATAGRAM=1416 约束应用层报文长度;BC_VERSION=1、BC_TYPE_MESSAGE=1 用于协议校验。与 TCP 服务器不同,本文件不定义 MAX_CLIENTS,因为广播服务器不维护连接表。

4.2.2 InitializeWinsock()

该函数封装 WSAStartup(MAKEWORD(2,2), &data),失败时返回 false;服务器和客户端在创建套接字之前都必须调用。函数原文如下:

点击展开/收起:InitializeWinsock() 初始化 Winsock 代码
/* 初始化 Winsock 2.2。服务器和客户端是两个独立进程,各自初始化、各自清理。 */
inline bool InitializeWinsock()
{
    WSADATA data;
    int result = WSAStartup(MAKEWORD(2, 2), &data);
    return result == 0;
}

4.2.3 Utf8ToWide()

该函数把网络收到的 UTF-8 正文转换为 Windows 宽字符,供控件显示;转换失败时输出空串,避免越界。函数原文如下:

点击展开/收起:Utf8ToWide() UTF-8 转宽字符代码
/*
 * UTF-8 窄字符串 -> Windows 宽字符串。
 * input   :以 '\0' 结尾的 UTF-8 文本,允许为 NULL;
 * output  :接收缓冲区,函数总是先写入空串,保证失败时也是合法字符串;
 * capacity:output 能容纳的 wchar_t 个数(含结束符)。
 * 返回    :无。转换失败时 output 为空串,不会越界。
 */
inline void Utf8ToWide(const char* input, wchar_t* output, int capacity)
{
    if (output == NULL || capacity <= 0)
    {
        return;
    }
    output[0] = L'\0';
    if (input == NULL)
    {
        return;
    }
    MultiByteToWideChar(CP_UTF8, 0, input, -1, output, capacity);
}

4.2.4 WideToUtf8()

该函数把界面输入的中文正文转换为 UTF-8,供网络发送和日志写入;转换失败时输出空串。函数原文如下:

点击展开/收起:WideToUtf8() 宽字符转 UTF-8 代码 ```cpp /* * Windows 宽字符串 -> UTF-8 窄字符串。 * 网络发送、UTF-8 日志文件都使用该函数作为唯一的编码出口。 */ inline void WideToUtf8(const wchar_t* input, char* output, int capacity) { if (output == NULL || capacity <= 0) { return; } output[0] = '\0'; if (input == NULL) { return; } WideCharToMultiByte(CP_UTF8, 0, input, -1, output, capacity, NULL, NULL); } ```

4.2.5 ParseIPv4Text() 与 FormatIPv4()

ParseIPv4Text() 逐字符解析点分十进制地址,严格校验四段、每段 0~255、段间点号和末尾字符;成功后用 htonl() 写入网络序 in_addr。FormatIPv4() 用 ntohl() 还原并格式化。函数原文如下:

点击展开/收起:ParseIPv4Text() 与 FormatIPv4() 代码

/*
 * 手工解析 IPv4 点分十进制文本。
 * 不使用 inet_addr(),原因有三:
 *   1. inet_addr() 在输入非法时返回 INADDR_NONE,与广播地址 255.255.255.255
 *      冲突,容易误判;
 *   2. inet_addr() 在新版编译器中标记为弃用;
 *   3. 手工解析可以给出严格的 0~255 校验,并兼容 Windows XP 等旧系统。
 * 成功时把网络字节序地址写入 address->s_addr,并返回 true。
 */
inline bool ParseIPv4Text(const char* text, in_addr* address)
{
    if (text == NULL || address == NULL)
    {
        return false;
    }

    const char* cursor = text;
    while (*cursor == ' ' || *cursor == '\t')
    {
        ++cursor;
    }

    unsigned int parts[4];
    int partIndex = 0;
    for (partIndex = 0; partIndex < 4; ++partIndex)
    {
        if (*cursor < '0' || *cursor > '9')
        {
            return false;
        }

        unsigned int value = 0;
        int digits = 0;
        while (*cursor >= '0' && *cursor <= '9')
        {
            value = value * 10 + (unsigned int)(*cursor - '0');
            if (value > 255 || ++digits > 3)
            {
                return false;
            }
            ++cursor;
        }
        parts[partIndex] = value;

        if (partIndex < 3)
        {
            if (*cursor != '.')
            {
                return false;
            }
            ++cursor;
        }
    }

    while (*cursor == ' ' || *cursor == '\t')
    {
        ++cursor;
    }
    if (*cursor != '\0')
    {
        return false; /* 例如 192.168.50.1abc 或多余的段 */
    }

    unsigned long hostOrder = (parts[0] << 24) | (parts[1] << 16) |
                              (parts[2] << 8) | parts[3];
    address->s_addr = htonl(hostOrder);
    return true;
}

/* 把网络字节序地址格式化为点分十进制窄字符串。 */
inline void FormatIPv4(const in_addr& address, char* output, int capacity)
{
    if (output == NULL || capacity <= 0)
    {
        return;
    }
    unsigned long hostOrder = ntohl(address.s_addr);
    StringCchPrintfA(output, (size_t)capacity, "%u.%u.%u.%u",
                     (unsigned int)((hostOrder >> 24) & 0xFFUL),
                     (unsigned int)((hostOrder >> 16) & 0xFFUL),
                     (unsigned int)((hostOrder >> 8) & 0xFFUL),
                     (unsigned int)(hostOrder & 0xFFUL));
}

4.2.6 BuildBroadcastPacket()

该函数把序号和 UTF-8 正文封装为 16 字节报头加正文,使用 memcpy 和 htonl() 写入网络字节序,避免结构体对齐问题。函数原文如下:

点击展开/收起:BuildBroadcastPacket() 报文构造代码
/*
 * 组包:把序号和 UTF-8 正文封装为 16 字节报头 + 正文。
 * 返回实际写入的字节数;参数非法时返回 0。
 * 调用者必须保证 buffer 至少有 BC_MAX_DATAGRAM 字节。
 */
inline int BuildBroadcastPacket(unsigned long sequence,
                                const char* payload,
                                int payloadLength,
                                char* buffer,
                                int capacity)
{
    if (payload == NULL || buffer == NULL)
    {
        return 0;
    }
    if (payloadLength <= 0 || payloadLength > BC_MAX_PAYLOAD)
    {
        return 0;
    }

    int totalLength = BC_HEADER_SIZE + payloadLength;
    if (capacity < totalLength)
    {
        return 0;
    }

    buffer[0] = 'B';
    buffer[1] = 'C';
    buffer[2] = 'S';
    buffer[3] = 'T';
    buffer[4] = (char)BC_VERSION;
    buffer[5] = (char)BC_TYPE_MESSAGE;
    buffer[6] = 0;
    buffer[7] = 0;

    /* 32 位字段先转网络字节序,再用 memcpy 写入,避免结构体对齐问题。 */
    unsigned long networkSequence = htonl(sequence);
    unsigned long networkLength = htonl((unsigned long)payloadLength);
    memcpy(buffer + 8, &networkSequence, 4);
    memcpy(buffer + 12, &networkLength, 4);

    memcpy(buffer + BC_HEADER_SIZE, payload, (size_t)payloadLength);
    return totalLength;
}

4.2.7 ParseBroadcastPacket()

该函数对 recvfrom() 收到的数据报做严格校验,失败时返回具体错误码,成功时把 payload 指向缓冲区内部,不复制正文。函数原文如下:

点击展开/收起:ParseBroadcastPacket() 报文解析代码

/*
 * 拆包并做严格校验。
 * data/length:recvfrom 收到的完整数据报;
 * packet     :输出只读视图,payload 指向 data 内部,不分配内存。
 * 返回 BroadcastParseResult 枚举值。
 */
inline int ParseBroadcastPacket(const char* data, int length, BroadcastPacket* packet)
{
    if (packet == NULL)
    {
        return BC_PARSE_TOO_SHORT;
    }
    packet->sequence = 0;
    packet->payload = NULL;
    packet->payloadLength = 0;

    if (data == NULL || length < BC_HEADER_SIZE)
    {
        return BC_PARSE_TOO_SHORT;
    }
    if (data[0] != 'B' || data[1] != 'C' || data[2] != 'S' || data[3] != 'T')
    {
        return BC_PARSE_BAD_MAGIC;
    }
    if ((unsigned char)data[4] != BC_VERSION)
    {
        return BC_PARSE_BAD_VERSION;
    }
    if ((unsigned char)data[5] != BC_TYPE_MESSAGE)
    {
        return BC_PARSE_BAD_TYPE;
    }

    unsigned long networkSequence = 0;
    unsigned long networkLength = 0;
    memcpy(&networkSequence, data + 8, 4);
    memcpy(&networkLength, data + 12, 4);

    unsigned long payloadLength = ntohl(networkLength);
    if (payloadLength == 0 || payloadLength > (unsigned long)BC_MAX_PAYLOAD)
    {
        return BC_PARSE_BAD_LENGTH;
    }
    if (payloadLength != (unsigned long)(length - BC_HEADER_SIZE))
    {
        return BC_PARSE_BAD_LENGTH;
    }

    packet->sequence = ntohl(networkSequence);
    packet->payload = data + BC_HEADER_SIZE;
    packet->payloadLength = (int)payloadLength;
    return BC_PARSE_OK;
}

common.h完整代码如下:

点击展开/收起:common.h 完整代码
#ifndef BROADCAST_COMMON_H
#define BROADCAST_COMMON_H

/*
 * common.h —— 广播通信服务器端 / 客户端公共模块
 * ============================================================================
 * 本文件被 server.cpp 与 client.cpp 同时包含,集中保存两端的公共约定,避免
 * 服务器和客户端对“地址、端口、报文格式、字符编码”的理解不一致。
 *
 * 主要内容分为六部分:
 *   1. 公共常量:默认 IP、默认端口、广播内容、协议版本、数据报长度上限;
 *   2. 字符编码:UTF-8(网络)与 UTF-16(Windows 窗口)之间互转;
 *   3. IPv4 与 Winsock 辅助:地址文本解析、错误码转中文说明、初始化;
 *   4. 广播应用层报文:组包、拆包、校验,保证客户端能识别合法广播;
 *   5. 窗口辅助:创建控件、统一字体、追加日志、读取输入框;
 *   6. 自动测试辅助:命令行参数、UTF-8 日志文件、统计文件写入。
 *
 * 编码约定(对应实验要求“中文和英文混写不能乱码”):
 *   - 源文件保存为 UTF-8(建议带 BOM);
 *   - 所有窗口文字使用宽字符 L"...",编译时由 /utf-8 或 -finput-charset=UTF-8
 *     正确解码,运行期 Win32 控件直接使用 UTF-16,不经过系统 ANSI 代码页;
 *   - 网络上传输的正文统一为 UTF-8,收发边界显式调用 Utf8ToWide/WideToUtf8;
 *   - 自动测试日志文件写 UTF-8 BOM,记事本和 Python 都能正确识别。
 *
 * 编译环境:Windows 7 及以上,Visual C++(MSVC)或 MinGW-w64 均可。
 * 兼容性:代码限制在 C++98 语法范围内,便于课程实验环境使用。
 * ============================================================================
 */

/* 让 Winsock 2 先于 windows.h 引入,避免旧版 winsock.h 与 winsock2.h 冲突。 */
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif

#include <winsock2.h>
#include <windows.h>
#include <shellapi.h>
#include <strsafe.h>

#include <stdlib.h>
#include <string.h>
#include <wchar.h>

/* 使用 MSVC 时自动链接所需系统库;MinGW 由构建脚本中的 -l 参数链接。 */
#ifdef _MSC_VER
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdi32.lib")
#pragma comment(lib, "shell32.lib")
#endif

/* ==========================================================================
 * 一、公共常量
 * ======================================================================== */

/* 默认端口。参考实验报告:服务器与客户端均使用 1145。 */
const unsigned short DEFAULT_PORT = 1145;

/* TCP-Lab 一键网卡工具配置的双 IP:服务器 .1,客户端 .2,子网掩码 /24。 */
const wchar_t DEFAULT_BIND_IP_W[] = L"192.168.50.1";        /* 服务器绑定地址 */
const wchar_t DEFAULT_CLIENT_IP_W[] = L"192.168.50.2";      /* 客户端监听地址 */
const wchar_t DEFAULT_BROADCAST_IP_W[] = L"192.168.50.255"; /* 子网定向广播地址 */

/* 实验要求服务器广播的固定内容;使用宽字符保存,避免执行字符集问题。 */
const wchar_t DEFAULT_MESSAGE_W[] = L"今天是个好日子!";

/* 默认广播周期(毫秒)。1 秒一次既便于观察,也不会刷屏。 */
const unsigned int DEFAULT_INTERVAL_MS = 1000;

/*
 * 应用层广播报文格式(固定 16 字节报头 + UTF-8 正文):
 *
 *   偏移  长度  字段            说明
 *   0     4     Magic           固定为 'B','C','S','T'
 *   4     1     Version         协议版本,当前为 1
 *   5     1     Type            报文类型,1 表示“广播文本消息”
 *   6     2     Reserved        保留字段,当前填 0
 *   8     4     Sequence        发送序号,网络字节序,从 1 开始递增
 *   12    4     PayloadLength   正文 UTF-8 字节数,网络字节序
 *   16    N     Payload         UTF-8 正文,不含字符串结束符
 *
 * 为什么要加报头:UDP 广播本身不保证可靠、不保证顺序,客户端通过 Magic
 * 可以丢弃无关广播,通过 Sequence 可以统计丢包、重复和乱序,从而在压力
 * 测试中给出可量化的结果。报头字段使用 memcpy + htonl/ntohl 处理,避免
 * 结构体对齐和大小端问题。正文上限 1400 字节,加上 16 字节报头和 UDP/IP
 * 报头后仍小于以太网 1500 字节 MTU,可避免 IP 分片。
 */
const int BC_HEADER_SIZE = 16;
const int BC_MAX_PAYLOAD = 1400;
const int BC_MAX_DATAGRAM = BC_HEADER_SIZE + BC_MAX_PAYLOAD;
const unsigned char BC_VERSION = 1;
const unsigned char BC_TYPE_MESSAGE = 1;

/* 拆包结果码,客户端据此区分失败原因并写入日志。 */
enum BroadcastParseResult
{
    BC_PARSE_OK = 0,          /* 校验通过 */
    BC_PARSE_TOO_SHORT,       /* 数据报不足 16 字节 */
    BC_PARSE_BAD_MAGIC,       /* 不是本程序的广播报文 */
    BC_PARSE_BAD_VERSION,     /* 协议版本不匹配 */
    BC_PARSE_BAD_TYPE,        /* 报文类型不支持 */
    BC_PARSE_BAD_LENGTH       /* 正文长度与数据报长度不一致 */
};

/* 拆包后的只读视图;payload 指向 recvfrom 缓冲区内部,不复制正文。 */
struct BroadcastPacket
{
    unsigned long sequence;      /* 发送序号 */
    const char* payload;         /* 指向 UTF-8 正文起始位置 */
    int payloadLength;           /* 正文字节数 */
};

/* ==========================================================================
 * 二、字符编码转换
 * ======================================================================== */

/*
 * UTF-8 窄字符串 -> Windows 宽字符串。
 * input   :以 '\0' 结尾的 UTF-8 文本,允许为 NULL;
 * output  :接收缓冲区,函数总是先写入空串,保证失败时也是合法字符串;
 * capacity:output 能容纳的 wchar_t 个数(含结束符)。
 * 返回    :无。转换失败时 output 为空串,不会越界。
 */
inline void Utf8ToWide(const char* input, wchar_t* output, int capacity)
{
    if (output == NULL || capacity <= 0)
    {
        return;
    }
    output[0] = L'\0';
    if (input == NULL)
    {
        return;
    }
    MultiByteToWideChar(CP_UTF8, 0, input, -1, output, capacity);
}

/*
 * Windows 宽字符串 -> UTF-8 窄字符串。
 * 网络发送、UTF-8 日志文件都使用该函数作为唯一的编码出口。
 */
inline void WideToUtf8(const wchar_t* input, char* output, int capacity)
{
    if (output == NULL || capacity <= 0)
    {
        return;
    }
    output[0] = '\0';
    if (input == NULL)
    {
        return;
    }
    WideCharToMultiByte(CP_UTF8, 0, input, -1, output, capacity, NULL, NULL);
}

/* 复制一份宽字符串到堆上;调用者负责 free。用于跨线程 PostMessage 传参。 */
inline wchar_t* DuplicateWideString(const wchar_t* text)
{
    if (text == NULL)
    {
        return NULL;
    }
    size_t length = wcslen(text) + 1;
    wchar_t* copy = (wchar_t*)malloc(length * sizeof(wchar_t));
    if (copy == NULL)
    {
        return NULL;
    }
    memcpy(copy, text, length * sizeof(wchar_t));
    return copy;
}

/* 去掉宽字符串首尾空白,便于用户输入“ 192.168.50.1 ”时仍能通过校验。 */
inline void TrimW(wchar_t* text)
{
    if (text == NULL)
    {
        return;
    }

    wchar_t* start = text;
    while (*start == L' ' || *start == L'\t' || *start == L'\r' || *start == L'\n')
    {
        ++start;
    }
    if (start != text)
    {
        memmove(text, start, (wcslen(start) + 1) * sizeof(wchar_t));
    }

    size_t length = wcslen(text);
    while (length > 0)
    {
        wchar_t last = text[length - 1];
        if (last == L' ' || last == L'\t' || last == L'\r' || last == L'\n')
        {
            text[--length] = L'\0';
        }
        else
        {
            break;
        }
    }
}

/* ==========================================================================
 * 三、IPv4 与 Winsock 辅助
 * ======================================================================== */

/*
 * 手工解析 IPv4 点分十进制文本。
 * 不使用 inet_addr(),原因有三:
 *   1. inet_addr() 在输入非法时返回 INADDR_NONE,与广播地址 255.255.255.255
 *      冲突,容易误判;
 *   2. inet_addr() 在新版编译器中标记为弃用;
 *   3. 手工解析可以给出严格的 0~255 校验,并兼容 Windows XP 等旧系统。
 * 成功时把网络字节序地址写入 address->s_addr,并返回 true。
 */
inline bool ParseIPv4Text(const char* text, in_addr* address)
{
    if (text == NULL || address == NULL)
    {
        return false;
    }

    const char* cursor = text;
    while (*cursor == ' ' || *cursor == '\t')
    {
        ++cursor;
    }

    unsigned int parts[4];
    int partIndex = 0;
    for (partIndex = 0; partIndex < 4; ++partIndex)
    {
        if (*cursor < '0' || *cursor > '9')
        {
            return false;
        }

        unsigned int value = 0;
        int digits = 0;
        while (*cursor >= '0' && *cursor <= '9')
        {
            value = value * 10 + (unsigned int)(*cursor - '0');
            if (value > 255 || ++digits > 3)
            {
                return false;
            }
            ++cursor;
        }
        parts[partIndex] = value;

        if (partIndex < 3)
        {
            if (*cursor != '.')
            {
                return false;
            }
            ++cursor;
        }
    }

    while (*cursor == ' ' || *cursor == '\t')
    {
        ++cursor;
    }
    if (*cursor != '\0')
    {
        return false; /* 例如 192.168.50.1abc 或多余的段 */
    }

    unsigned long hostOrder = (parts[0] << 24) | (parts[1] << 16) |
                              (parts[2] << 8) | parts[3];
    address->s_addr = htonl(hostOrder);
    return true;
}

/* 宽字符版本的 IPv4 解析:先转 UTF-8(IPv4 文本本身是 ASCII)再解析。 */
inline bool ParseIPv4TextW(const wchar_t* text, in_addr* address)
{
    if (text == NULL)
    {
        return false;
    }
    char utf8[64];
    WideToUtf8(text, utf8, (int)sizeof(utf8));
    return ParseIPv4Text(utf8, address);
}

/* 把网络字节序地址格式化为点分十进制窄字符串。 */
inline void FormatIPv4(const in_addr& address, char* output, int capacity)
{
    if (output == NULL || capacity <= 0)
    {
        return;
    }
    unsigned long hostOrder = ntohl(address.s_addr);
    StringCchPrintfA(output, (size_t)capacity, "%u.%u.%u.%u",
                     (unsigned int)((hostOrder >> 24) & 0xFFUL),
                     (unsigned int)((hostOrder >> 16) & 0xFFUL),
                     (unsigned int)((hostOrder >> 8) & 0xFFUL),
                     (unsigned int)(hostOrder & 0xFFUL));
}

/* 把网络字节序地址格式化为宽字符串,供 Win32 日志和标签直接显示。 */
inline void FormatIPv4W(const in_addr& address, wchar_t* output, int capacity)
{
    char text[32];
    FormatIPv4(address, text, (int)sizeof(text));
    Utf8ToWide(text, output, capacity);
}

/* 初始化 Winsock 2.2。服务器和客户端是两个独立进程,各自初始化、各自清理。 */
inline bool InitializeWinsock()
{
    WSADATA data;
    int result = WSAStartup(MAKEWORD(2, 2), &data);
    return result == 0;
}

/*
 * 把 Winsock 错误码转换成“中文说明 (错误码 N)”。
 * FormatMessageW 会使用系统语言;中文 Windows 上通常直接得到中文说明。
 */
inline void FormatWinsockErrorW(int code, wchar_t* output, int capacity)
{
    if (output == NULL || capacity <= 0)
    {
        return;
    }
    output[0] = L'\0';

    LPWSTR systemText = NULL;
    DWORD length = FormatMessageW(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL, (DWORD)code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (LPWSTR)&systemText, 0, NULL);

    if (length > 0 && systemText != NULL)
    {
        /* 去掉系统说明末尾的换行和空格。 */
        while (length > 0)
        {
            wchar_t last = systemText[length - 1];
            if (last == L'\r' || last == L'\n' || last == L' ')
            {
                systemText[--length] = L'\0';
            }
            else
            {
                break;
            }
        }
        StringCchPrintfW(output, (size_t)capacity, L"%s(错误码 %d)",
                         systemText, code);
        LocalFree(systemText);
    }
    else
    {
        StringCchPrintfW(output, (size_t)capacity, L"未知错误(错误码 %d)", code);
    }
}

/* 取当前毫秒计数。GetTickCount 为 32 位,约 49 天回绕;单次实验足够。 */
inline unsigned long NowMilliseconds()
{
    return (unsigned long)GetTickCount();
}

/* ==========================================================================
 * 四、广播应用层报文
 * ======================================================================== */

/*
 * 组包:把序号和 UTF-8 正文封装为 16 字节报头 + 正文。
 * 返回实际写入的字节数;参数非法时返回 0。
 * 调用者必须保证 buffer 至少有 BC_MAX_DATAGRAM 字节。
 */
inline int BuildBroadcastPacket(unsigned long sequence,
                                const char* payload,
                                int payloadLength,
                                char* buffer,
                                int capacity)
{
    if (payload == NULL || buffer == NULL)
    {
        return 0;
    }
    if (payloadLength <= 0 || payloadLength > BC_MAX_PAYLOAD)
    {
        return 0;
    }

    int totalLength = BC_HEADER_SIZE + payloadLength;
    if (capacity < totalLength)
    {
        return 0;
    }

    buffer[0] = 'B';
    buffer[1] = 'C';
    buffer[2] = 'S';
    buffer[3] = 'T';
    buffer[4] = (char)BC_VERSION;
    buffer[5] = (char)BC_TYPE_MESSAGE;
    buffer[6] = 0;
    buffer[7] = 0;

    /* 32 位字段先转网络字节序,再用 memcpy 写入,避免结构体对齐问题。 */
    unsigned long networkSequence = htonl(sequence);
    unsigned long networkLength = htonl((unsigned long)payloadLength);
    memcpy(buffer + 8, &networkSequence, 4);
    memcpy(buffer + 12, &networkLength, 4);

    memcpy(buffer + BC_HEADER_SIZE, payload, (size_t)payloadLength);
    return totalLength;
}

/*
 * 拆包并做严格校验。
 * data/length:recvfrom 收到的完整数据报;
 * packet     :输出只读视图,payload 指向 data 内部,不分配内存。
 * 返回 BroadcastParseResult 枚举值。
 */
inline int ParseBroadcastPacket(const char* data, int length, BroadcastPacket* packet)
{
    if (packet == NULL)
    {
        return BC_PARSE_TOO_SHORT;
    }
    packet->sequence = 0;
    packet->payload = NULL;
    packet->payloadLength = 0;

    if (data == NULL || length < BC_HEADER_SIZE)
    {
        return BC_PARSE_TOO_SHORT;
    }
    if (data[0] != 'B' || data[1] != 'C' || data[2] != 'S' || data[3] != 'T')
    {
        return BC_PARSE_BAD_MAGIC;
    }
    if ((unsigned char)data[4] != BC_VERSION)
    {
        return BC_PARSE_BAD_VERSION;
    }
    if ((unsigned char)data[5] != BC_TYPE_MESSAGE)
    {
        return BC_PARSE_BAD_TYPE;
    }

    unsigned long networkSequence = 0;
    unsigned long networkLength = 0;
    memcpy(&networkSequence, data + 8, 4);
    memcpy(&networkLength, data + 12, 4);

    unsigned long payloadLength = ntohl(networkLength);
    if (payloadLength == 0 || payloadLength > (unsigned long)BC_MAX_PAYLOAD)
    {
        return BC_PARSE_BAD_LENGTH;
    }
    if (payloadLength != (unsigned long)(length - BC_HEADER_SIZE))
    {
        return BC_PARSE_BAD_LENGTH;
    }

    packet->sequence = ntohl(networkSequence);
    packet->payload = data + BC_HEADER_SIZE;
    packet->payloadLength = (int)payloadLength;
    return BC_PARSE_OK;
}

/* 把拆包错误码转换成可以直接写日志的中文说明。 */
inline const wchar_t* BroadcastParseErrorText(int parseResult)
{
    switch (parseResult)
    {
    case BC_PARSE_TOO_SHORT:
        return L"数据报长度不足 16 字节";
    case BC_PARSE_BAD_MAGIC:
        return L"报文标识不是 BCST";
    case BC_PARSE_BAD_VERSION:
        return L"协议版本不匹配";
    case BC_PARSE_BAD_TYPE:
        return L"报文类型不是广播文本";
    case BC_PARSE_BAD_LENGTH:
        return L"正文长度与实际数据报不一致";
    default:
        return L"未知错误";
    }
}

/* ==========================================================================
 * 五、Win32 窗口与控件辅助
 * ======================================================================== */

/* 启用 DPI 感知,避免 125%/150% 缩放下窗口字体发虚。动态加载以兼容旧系统。 */
inline void EnableDpiAwareness()
{
    HMODULE user32Module = GetModuleHandleW(L"user32.dll");
    if (user32Module == NULL)
    {
        return;
    }
    typedef BOOL(WINAPI * SetProcessDPIAwareFunction)(VOID);
    SetProcessDPIAwareFunction setAware =
        (SetProcessDPIAwareFunction)GetProcAddress(user32Module, "SetProcessDPIAware");
    if (setAware != NULL)
    {
        setAware();
    }
}

/* 创建界面字体。height 为负值表示字符高度(像素)。 */
inline HFONT CreateUiFont(int pixelHeight, bool bold, const wchar_t* faceName)
{
    return CreateFontW(-pixelHeight, 0, 0, 0, bold ? FW_BOLD : FW_NORMAL,
                       FALSE, FALSE, FALSE, DEFAULT_CHARSET,
                       OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                       CLEARTYPE_QUALITY, DEFAULT_PITCH | FF_SWISS,
                       faceName);
}

/*
 * 创建子窗口控件的统一封装。
 * 所有界面控件都通过这里创建,保证字体、父窗口、实例句柄的处理一致。
 */
inline HWND CreateControlW(HWND parent,
                           const wchar_t* className,
                           const wchar_t* text,
                           DWORD style,
                           DWORD extendedStyle,
                           int x,
                           int y,
                           int width,
                           int height,
                           int controlId,
                           HFONT font)
{
    HWND control = CreateWindowExW(
        extendedStyle, className, text, WS_CHILD | WS_VISIBLE | style,
        x, y, width, height, parent, (HMENU)(INT_PTR)controlId,
        (HINSTANCE)GetWindowLongPtrW(parent, GWLP_HINSTANCE), NULL);
    if (control != NULL && font != NULL)
    {
        SendMessageW(control, WM_SETFONT, (WPARAM)font, TRUE);
    }
    return control;
}

/* 读取指定控件 ID 的宽字符文本。 */
inline void GetControlTextW(HWND parent, int controlId, wchar_t* output, int capacity)
{
    if (output == NULL || capacity <= 0)
    {
        return;
    }
    output[0] = L'\0';
    GetDlgItemTextW(parent, controlId, output, capacity);
}

/* 设置指定控件 ID 的宽字符文本。 */
inline void SetControlTextW(HWND parent, int controlId, const wchar_t* text)
{
    SetDlgItemTextW(parent, controlId, text);
}

/* 判断复选框是否被勾选。 */
inline bool IsCheckBoxChecked(HWND parent, int controlId)
{
    HWND control = GetDlgItem(parent, controlId);
    return control != NULL && SendMessageW(control, BM_GETCHECK, 0, 0) == BST_CHECKED;
}

/*
 * 向只读多行编辑框追加一行文字并滚动到末尾。
 * 为避免长时间运行后控件文本无限增长,超过约 100 万字符时清空重来。
 */
inline void AppendEditLineW(HWND edit, const wchar_t* text)
{
    if (edit == NULL || text == NULL)
    {
        return;
    }

    if (GetWindowTextLengthW(edit) > 1000000)
    {
        SetWindowTextW(edit, L"");
    }

    int end = GetWindowTextLengthW(edit);
    SendMessageW(edit, EM_SETSEL, (WPARAM)end, (LPARAM)end);
    SendMessageW(edit, EM_REPLACESEL, FALSE, (LPARAM)text);
    SendMessageW(edit, EM_REPLACESEL, FALSE, (LPARAM)L"\r\n");
}

/*
 * 把堆上的宽字符串通过自定义窗口消息投递给窗口线程。
 * 工作线程不直接操作控件,避免跨线程调用造成界面卡顿或状态竞争。
 * 窗口过程处理完消息后负责 free 这块内存。
 */
inline void PostWideMessage(HWND window, UINT message, const wchar_t* text)
{
    if (window == NULL || text == NULL)
    {
        return;
    }
    wchar_t* copy = DuplicateWideString(text);
    if (copy == NULL)
    {
        return;
    }
    if (!PostMessageW(window, message, 0, (LPARAM)copy))
    {
        free(copy);
    }
}

/* 生成 HH:MM:SS.mmm 形式的本地时间,用于日志和接收消息前缀。 */
inline void FormatTimeW(wchar_t* output, int capacity)
{
    if (output == NULL || capacity <= 0)
    {
        return;
    }
    SYSTEMTIME localTime;
    GetLocalTime(&localTime);
    StringCchPrintfW(output, (size_t)capacity, L"%02u:%02u:%02u.%03u",
                     localTime.wHour, localTime.wMinute,
                     localTime.wSecond, localTime.wMilliseconds);
}

/* ==========================================================================
 * 六、命令行、UTF-8 文件与自动测试辅助
 * ======================================================================== */

/*
 * 简易命令行参数容器。
 * 支持 “--key value” 和 “--flag” 两种形式;不依赖第三方库。
 * 参数用 CommandLineToArgvW 获取,因此中文参数不会经过 ANSI 代码页。
 */
struct CommandLineArgs
{
    int count;
    wchar_t** items;

    CommandLineArgs() : count(0), items(NULL) {}

    /* 是否存在指定开关,例如 --auto。 */
    bool Has(const wchar_t* name) const
    {
        for (int i = 1; i < count; ++i)
        {
            if (wcscmp(items[i], name) == 0)
            {
                return true;
            }
        }
        return false;
    }

    /* 读取 “--key value” 中的 value;未出现时返回 fallback。 */
    const wchar_t* Value(const wchar_t* name, const wchar_t* fallback) const
    {
        for (int i = 1; i + 1 < count; ++i)
        {
            if (wcscmp(items[i], name) == 0)
            {
                return items[i + 1];
            }
        }
        return fallback;
    }

    /* 读取整数参数;未出现或格式非法时返回 fallback(后续再做范围校验)。 */
    int IntValue(const wchar_t* name, int fallback) const
    {
        const wchar_t* text = Value(name, NULL);
        if (text == NULL)
        {
            return fallback;
        }
        return _wtoi(text);
    }
};

/* 获取当前进程的宽字符命令行参数。成功返回 true。 */
inline bool LoadCommandLine(CommandLineArgs* args)
{
    if (args == NULL)
    {
        return false;
    }
    args->count = 0;
    args->items = CommandLineToArgvW(GetCommandLineW(), &args->count);
    return args->items != NULL;
}

/* 释放 LoadCommandLine 分配的参数数组。 */
inline void FreeCommandLine(CommandLineArgs* args)
{
    if (args != NULL && args->items != NULL)
    {
        LocalFree(args->items);
        args->items = NULL;
        args->count = 0;
    }
}

/*
 * UTF-8 日志文件写入器。
 * 自动测试模式没有窗口,需要把运行过程写成日志文件供 Python 和用户查看。
 * 文件以 UTF-8 BOM 开头,确保记事本、VS Code、Python 都不会误判编码。
 */
class Utf8LogWriter
{
public:
    Utf8LogWriter() : m_handle(INVALID_HANDLE_VALUE) {}
    ~Utf8LogWriter() { Close(); }

    /* 创建(覆盖)日志文件并写入 BOM。 */
    bool Open(const wchar_t* path)
    {
        Close();
        m_handle = CreateFileW(path, GENERIC_WRITE, FILE_SHARE_READ, NULL,
                               CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        if (m_handle == INVALID_HANDLE_VALUE)
        {
            return false;
        }
        const unsigned char bom[3] = { 0xEF, 0xBB, 0xBF };
        return WriteBytes(bom, 3);
    }

    void Close()
    {
        if (m_handle != INVALID_HANDLE_VALUE)
        {
            CloseHandle(m_handle);
            m_handle = INVALID_HANDLE_VALUE;
        }
    }

    bool IsOpen() const { return m_handle != INVALID_HANDLE_VALUE; }

    /* 写一行宽字符文本(自动转换为 UTF-8)。 */
    bool WriteLine(const wchar_t* text)
    {
        if (!IsOpen() || text == NULL)
        {
            return false;
        }
        char utf8[8192];
        WideToUtf8(text, utf8, (int)sizeof(utf8));
        return WriteBytes(utf8, (DWORD)strlen(utf8)) && WriteBytes("\r\n", 2);
    }

    /* 写一行已经是 UTF-8/ASCII 的文本,用于性能摘要等无需转换的内容。 */
    bool WriteLineUtf8(const char* text)
    {
        if (!IsOpen() || text == NULL)
        {
            return false;
        }
        return WriteBytes(text, (DWORD)strlen(text)) && WriteBytes("\r\n", 2);
    }

private:
    /* 禁止复制,避免两个对象关闭同一个句柄。 */
    Utf8LogWriter(const Utf8LogWriter&);
    Utf8LogWriter& operator=(const Utf8LogWriter&);

    bool WriteBytes(const void* data, DWORD length)
    {
        if (!IsOpen() || data == NULL || length == 0)
        {
            return length == 0;
        }
        const unsigned char* cursor = (const unsigned char*)data;
        DWORD remaining = length;
        while (remaining > 0)
        {
            DWORD written = 0;
            if (!WriteFile(m_handle, cursor, remaining, &written, NULL))
            {
                return false;
            }
            if (written == 0)
            {
                return false;
            }
            cursor += written;
            remaining -= written;
        }
        return true;
    }

    HANDLE m_handle;
};

/* 写一个 UTF-8 文本文件;withBom 为 true 时在开头写入 BOM。 */
inline bool WriteUtf8File(const wchar_t* path, const char* utf8Text, bool withBom)
{
    if (path == NULL || utf8Text == NULL)
    {
        return false;
    }
    HANDLE file = CreateFileW(path, GENERIC_WRITE, FILE_SHARE_READ, NULL,
                              CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (file == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    bool ok = true;
    if (withBom)
    {
        const unsigned char bom[3] = { 0xEF, 0xBB, 0xBF };
        DWORD written = 0;
        ok = WriteFile(file, bom, 3, &written, NULL) != FALSE && written == 3;
    }
    if (ok)
    {
        DWORD length = (DWORD)strlen(utf8Text);
        DWORD written = 0;
        ok = WriteFile(file, utf8Text, length, &written, NULL) != FALSE &&
             written == length;
    }
    CloseHandle(file);
    return ok;
}

/* 写一个纯 ASCII 文本文件(统计 JSON 使用,不需要 BOM)。 */
inline bool WriteAsciiFile(const wchar_t* path, const char* text)
{
    return WriteUtf8File(path, text, false);
}

/* ==========================================================================
 * 七、两个程序共用的界面尺寸与颜色常量
 * ======================================================================== */

/* 窗口客户区统一为 900 x 640,服务器和客户端采用相同的视觉规格。 */
const int WINDOW_CLIENT_WIDTH = 900;
const int WINDOW_CLIENT_HEIGHT = 640;

/* 多行编辑框最多接受的字符数;0 表示由控件使用默认大值。 */
const int EDIT_TEXT_LIMIT = 1000000;

#endif /* BROADCAST_COMMON_H */

4.3 server.cpp/client.cpp 广播套接字初始化模块详解

4.3.1 OpenServerSocket() 与 OpenClientSocket()

OpenServerSocket() 负责创建 UDP 套接字、设置 SO_BROADCAST、绑定服务器源地址并构造广播目标地址;OpenClientSocket() 负责创建 UDP 套接字、设置 SO_REUSEADDR、设置接收缓冲区并绑定监听地址。两个函数原文如下:

点击展开/收起:OpenServerSocket() 与 OpenClientSocket() 完整函数
static bool OpenServerSocket(const in_addr& bindAddress,
                             const in_addr& broadcastAddress,
                             unsigned short port,
                             SOCKET* outSocket,
                             sockaddr_in* outDestination,
                             unsigned short* outLocalPort,
                             wchar_t* errorText,
                             int errorCapacity)
{
    if (outSocket == NULL || outDestination == NULL || outLocalPort == NULL)
    {
        return false;
    }
    *outSocket = INVALID_SOCKET;

    /*
     * 广播地址边界校验:0.0.0.0 是“任意本地地址”的绑定写法,不是广播地址。
     * 如果把它当广播目标,sendto 的行为没有实际广播意义,因此在这里直接拒绝,
     * 让 GUI 和自动测试都能得到明确的“边界外”错误提示。
     */
    if (broadcastAddress.s_addr == 0)
    {
        StringCchPrintfW(errorText, (size_t)errorCapacity,
                         L"广播地址不能是 0.0.0.0,请填写子网广播地址,"
                         L"例如 192.168.50.255。");
        return false;
    }

    SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (udpSocket == INVALID_SOCKET)
    {
        wchar_t reason[256];
        FormatWinsockErrorW(WSAGetLastError(), reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));
        StringCchPrintfW(errorText, (size_t)errorCapacity,
                         L"创建 UDP 套接字失败:%s", reason);
        return false;
    }

    /*
     * 关键设置:SO_BROADCAST。
     * Windows 的 UDP 套接字默认禁止向广播地址发送数据,必须显式打开该选项,
     * 否则 sendto 会返回 WSAEACCES(10013)。这是广播编程与普通 UDP 编程
     * 最重要的区别之一。
     */
    int broadcastOption = 1;
    if (setsockopt(udpSocket, SOL_SOCKET, SO_BROADCAST,
                   (const char*)&broadcastOption, sizeof(broadcastOption)) == SOCKET_ERROR)
    {
        wchar_t reason[256];
        FormatWinsockErrorW(WSAGetLastError(), reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));
        StringCchPrintfW(errorText, (size_t)errorCapacity,
                         L"设置 SO_BROADCAST 失败:%s", reason);
        closesocket(udpSocket);
        return false;
    }

    /* 适当增大发送缓冲区,降低突发广播时的丢包概率;失败不影响主流程。 */
    int sendBufferSize = 256 * 1024;
    setsockopt(udpSocket, SOL_SOCKET, SO_SNDBUF,
               (const char*)&sendBufferSize, sizeof(sendBufferSize));

    /*
     * 绑定服务器自己的地址,端口填 0 由系统分配。
     * 绑定源地址而不是 INADDR_ANY,可以保证广播从 TCP-Lab 实验网卡发出,
     * 而不是从 Wi-Fi 或虚拟网卡发出。
     */
    sockaddr_in localAddress;
    memset(&localAddress, 0, sizeof(localAddress));
    localAddress.sin_family = AF_INET;
    localAddress.sin_addr = bindAddress;
    localAddress.sin_port = 0;

    if (bind(udpSocket, (const sockaddr*)&localAddress, sizeof(localAddress)) == SOCKET_ERROR)
    {
        int errorCode = WSAGetLastError();
        wchar_t reason[256];
        FormatWinsockErrorW(errorCode, reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));

        wchar_t bindText[32];
        FormatIPv4W(bindAddress, bindText, (int)(sizeof(bindText) / sizeof(bindText[0])));
        if (errorCode == WSAEADDRNOTAVAIL)
        {
            StringCchPrintfW(errorText, (size_t)errorCapacity,
                             L"绑定 %s 失败:%s。本机没有该 IPv4 地址,"
                             L"请先运行 TCP-Lab 一键网卡工具,或把绑定地址改为 0.0.0.0。",
                             bindText, reason);
        }
        else
        {
            StringCchPrintfW(errorText, (size_t)errorCapacity,
                             L"绑定 %s 失败:%s", bindText, reason);
        }
        closesocket(udpSocket);
        return false;
    }

    /* 读取系统分配的源端口,显示在界面上便于核对抓包结果。 */
    sockaddr_in actualLocal;
    int actualLength = sizeof(actualLocal);
    memset(&actualLocal, 0, sizeof(actualLocal));
    if (getsockname(udpSocket, (sockaddr*)&actualLocal, &actualLength) == SOCKET_ERROR)
    {
        memset(&actualLocal, 0, sizeof(actualLocal));
    }

    sockaddr_in destination;
    memset(&destination, 0, sizeof(destination));
    destination.sin_family = AF_INET;
    destination.sin_addr = broadcastAddress;
    destination.sin_port = htons(port);

    *outSocket = udpSocket;
    *outDestination = destination;
    *outLocalPort = ntohs(actualLocal.sin_port);
    return true;
}

static bool OpenClientSocket(const in_addr& listenAddress,
                             unsigned short port,
                             SOCKET* outSocket,
                             unsigned short* outBoundPort,
                             wchar_t* errorText,
                             int errorCapacity)
{
    if (outSocket == NULL || outBoundPort == NULL)
    {
        return false;
    }
    *outSocket = INVALID_SOCKET;

    SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (udpSocket == INVALID_SOCKET)
    {
        wchar_t reason[256];
        FormatWinsockErrorW(WSAGetLastError(), reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));
        StringCchPrintfW(errorText, (size_t)errorCapacity,
                         L"创建 UDP 套接字失败:%s", reason);
        return false;
    }

    int reuseOption = 1;
    if (setsockopt(udpSocket, SOL_SOCKET, SO_REUSEADDR,
                   (const char*)&reuseOption, sizeof(reuseOption)) == SOCKET_ERROR)
    {
        wchar_t reason[256];
        FormatWinsockErrorW(WSAGetLastError(), reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));
        StringCchPrintfW(errorText, (size_t)errorCapacity,
                         L"设置 SO_REUSEADDR 失败:%s", reason);
        closesocket(udpSocket);
        return false;
    }

    /* 4 MB 接收缓冲区;系统可能按策略折半或限制上限,失败不影响接收。 */
    int receiveBufferSize = 4 * 1024 * 1024;
    setsockopt(udpSocket, SOL_SOCKET, SO_RCVBUF,
               (const char*)&receiveBufferSize, sizeof(receiveBufferSize));

    sockaddr_in localAddress;
    memset(&localAddress, 0, sizeof(localAddress));
    localAddress.sin_family = AF_INET;
    localAddress.sin_addr = listenAddress;
    localAddress.sin_port = htons(port);

    if (bind(udpSocket, (const sockaddr*)&localAddress, sizeof(localAddress)) == SOCKET_ERROR)
    {
        int errorCode = WSAGetLastError();
        wchar_t reason[256];
        FormatWinsockErrorW(errorCode, reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));

        wchar_t listenText[32];
        FormatIPv4W(listenAddress, listenText,
                    (int)(sizeof(listenText) / sizeof(listenText[0])));
        if (errorCode == WSAEADDRNOTAVAIL)
        {
            StringCchPrintfW(errorText, (size_t)errorCapacity,
                             L"绑定 %s:%u 失败:%s。本机没有该 IPv4 地址,"
                             L"请先运行 TCP-Lab 一键网卡工具,或把监听地址改为 0.0.0.0。",
                             listenText, (unsigned int)port, reason);
        }
        else if (errorCode == WSAEADDRINUSE)
        {
            StringCchPrintfW(errorText, (size_t)errorCapacity,
                             L"绑定 %s:%u 失败:%s。端口已被其他程序占用;"
                             L"请关闭占用程序,或改用其他端口。",
                             listenText, (unsigned int)port, reason);
        }
        else
        {
            StringCchPrintfW(errorText, (size_t)errorCapacity,
                             L"绑定 %s:%u 失败:%s", listenText,
                             (unsigned int)port, reason);
        }
        closesocket(udpSocket);
        return false;
    }

    sockaddr_in actualLocal;
    int actualLength = sizeof(actualLocal);
    memset(&actualLocal, 0, sizeof(actualLocal));
    if (getsockname(udpSocket, (sockaddr*)&actualLocal, &actualLength) == SOCKET_ERROR)
    {
        memset(&actualLocal, 0, sizeof(actualLocal));
    }

    *outSocket = udpSocket;
    *outBoundPort = ntohs(actualLocal.sin_port);
    return true;
}

4.4 server.cpp 服务器端程序详解

4.4.1 宏、全局状态和资源

server.cpp 定义服务器窗口类名、控件 ID、默认输入值和 ServerRuntime 运行状态。ServerRuntime 保存 UDP 套接字、目标地址、发送序号、成功/失败/字节计数、最近错误码、发送周期、停止事件、立即发送事件、日志文件和统计路径。服务器不保存客户端数组,因此没有 g_clientCount、g_clientSockets 或客户端槽位;这是广播服务器与 TCP 服务器最重要的结构差异。

4.4.2 ServerLog(message)

该函数把运行信息写入服务器日志。工作线程不能直接操作窗口控件,因此函数把宽字符消息复制到堆内存,通过 PostMessageW() 投递自定义日志消息给窗口线程;窗口线程收到后追加到编辑框并释放内存。函数原文如下:

点击展开/收起:ServerLog() 消息日志代码(22 行)
static void ServerLog(ServerRuntime& runtime, const wchar_t* text)
{
    if (text == NULL)
    {
        return;
    }

    wchar_t timeText[32];
    FormatTimeW(timeText, (int)(sizeof(timeText) / sizeof(timeText[0])));

    wchar_t line[2048];
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]), L"[%s] %s", timeText, text);

    if (runtime.notifyWindow != NULL)
    {
        PostWideMessage(runtime.notifyWindow, WM_APPEND_LOG, line);
    }
    else if (runtime.fileLog != NULL)
    {
        runtime.fileLog->WriteLine(line);
    }
}

4.4.3 SendOnePacket(runtime)

该函数完成一次广播发送:序号递增、调用 BuildBroadcastPacket() 组包、sendto() 发送、成功/失败计数、按间隔写日志;发送失败时保存错误码,并在 WSAENOBUFS 时让出 CPU。函数原文如下:

点击展开/收起:SendOnePacket() 广播发送代码
static bool SendOnePacket(ServerRuntime& runtime)
{
    if (runtime.socket == INVALID_SOCKET)
    {
        return false;
    }

    /* 序号从 1 开始,便于客户端把“第一包”与“尚未收到”区分开。 */
    runtime.sequence += 1;

    char packet[BC_MAX_DATAGRAM];
    int packetLength = BuildBroadcastPacket(runtime.sequence, runtime.payload,
                                            runtime.payloadLength, packet,
                                            (int)sizeof(packet));
    if (packetLength <= 0)
    {
        LONG failed = InterlockedIncrement(&runtime.failed);
        InterlockedExchange(&runtime.lastError, WSAEMSGSIZE);
        if (failed <= 5)
        {
            ServerLog(runtime, L"组包失败:正文长度超出协议上限。");
        }
        return false;
    }

    int sentBytes = sendto(runtime.socket, packet, packetLength, 0,
                           (const sockaddr*)&runtime.destination,
                           sizeof(runtime.destination));
    if (sentBytes == SOCKET_ERROR)
    {
        int errorCode = WSAGetLastError();
        LONG failed = InterlockedIncrement(&runtime.failed);
        InterlockedExchange(&runtime.lastError, errorCode);

        /* 只记录前 5 次和每第 100 次失败,避免持续失败时刷屏。 */
        if (failed <= 5 || (failed % 100) == 0)
        {
            wchar_t errorText[256];
            FormatWinsockErrorW(errorCode, errorText,
                                (int)(sizeof(errorText) / sizeof(errorText[0])));
            wchar_t line[512];
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"第 %lu 包广播失败:%s", runtime.sequence, errorText);
            ServerLog(runtime, line);
        }

        /* 发送缓冲区暂时耗尽时让出 CPU,避免空转把失败次数迅速放大。 */
        if (errorCode == WSAENOBUFS)
        {
            Sleep(1);
        }
        return false;
    }

    InterlockedIncrement(&runtime.sent);
    InterlockedExchangeAdd(&runtime.bytes, (LONG)sentBytes);

    bool shouldLog = false;
    if (runtime.notifyWindow != NULL)
    {
        /* GUI:慢速时按复选框逐包记录;高速时自动降为每 100 包一条。 */
        if (runtime.sequence == 1)
        {
            shouldLog = true;
        }
        else if (runtime.intervalMs <= 100)
        {
            shouldLog = (runtime.sequence % 100) == 0;
        }
        else
        {
            shouldLog = ReadCounter(&runtime.logEachSend) != 0;
        }
    }
    else
    {
        /* 自动模式:只记录首包和每 1000 包,控制日志体积。 */
        shouldLog = (runtime.sequence == 1) || ((runtime.sequence % 1000) == 0);
    }

    if (shouldLog)
    {
        wchar_t line[512];
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"第 %lu 包已广播,%d 字节,累计成功 %ld 包。",
                         runtime.sequence, sentBytes, ReadCounter(&runtime.sent));
        ServerLog(runtime, line);
    }

    return true;
}

4.4.4 BroadcastWorker(parameter)

该线程入口等待停止事件和“立即发送”事件,超时时间由发送周期决定;停止事件触发时退出,否则调用 SendOnePacket()。连续发送时定期 Sleep(0),保证窗口线程仍能刷新。函数原文如下:

点击展开/收起:BroadcastWorker() 发送工作线程代码

static DWORD WINAPI BroadcastWorker(LPVOID)
{
    HANDLE waitHandles[2];
    waitHandles[0] = g_stopEvent;
    waitHandles[1] = g_sendNowEvent;

    for (;;)
    {
        DWORD waitResult = WaitForMultipleObjects(2, waitHandles, FALSE,
                                                  (DWORD)g_server.intervalMs);

        if (waitResult == WAIT_OBJECT_0)
        {
            break; /* 停止事件 */
        }
        if (waitResult == WAIT_OBJECT_0 + 1)
        {
            ResetEvent(g_sendNowEvent); /* 手动发送事件,处理一次后复位 */
        }
        else if (waitResult != WAIT_TIMEOUT)
        {
            break; /* 等待失败,退出线程,避免死循环 */
        }

        if (InterlockedCompareExchange(&g_running, 1, 1) == 0)
        {
            break;
        }

        SendOnePacket(g_server);

        /* 连续发送时定期让出时间片,保证窗口线程仍能刷新界面。 */
        if (g_server.intervalMs == 0 && (g_server.sequence % 1000) == 0)
        {
            Sleep(0);
        }
    }

    return 0;
}

4.4.5 StartBroadcast()

该函数由“启动广播”按钮触发:读取并校验绑定地址、广播地址、端口、正文和周期;调用 OpenServerSocket() 创建广播套接字;创建停止事件、立即发送事件和发送线程;线程先挂起,写入“广播已启动”日志后再恢复;最后更新按钮和状态标签。完整原文见 server.cpp 的 StartBroadcast()。

4.4.6 StopBroadcast()

该函数设置停止事件、等待发送线程退出、关闭 UDP 套接字、关闭事件句柄并重置运行状态,最后更新按钮和日志。完整原文见 server.cpp 的 StopBroadcast()。

4.4.7 CreateServerControls(window, instance)

该函数创建绑定 IPv4、广播 IPv4、端口、正文、周期输入框,以及“启动广播”“停止广播”“立即发送”按钮、状态标签、发送计数标签和日志编辑框;每个控件分配唯一 ID,供窗口过程识别。完整原文见 server.cpp。

4.4.8 ServerWindowProc(window, message, wParam, lParam)

窗口过程处理 WM_CREATE、WM_COMMAND、WM_TIMER、自定义日志消息、WM_CLOSE 和 WM_DESTROY;启动/停止按钮调用对应函数,立即发送设置事件,定时器刷新状态,关闭窗口时先停止广播。完整原文见 server.cpp。

4.4.9 WinMain(instance, ..., showCommand)

WinMain() 开启高 DPI 感知、注册窗口类、创建主窗口和控件、进入消息循环,最后释放字体、窗口和 Winsock 资源。完整原文见 server.cpp。

server.cpp完整代码如下:

点击展开/收起:server.cpp 完整代码
/*
 * server.cpp —— 基于广播通信模型的服务器端(Win32 图形界面)
 * ============================================================================
 * 实验要求:服务器端向所有客户端广播“今天是个好日子!”。
 *
 * 本程序的核心网络步骤:
 *   1. WSAStartup 初始化 Winsock 2.2;
 *   2. socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP) 创建 UDP 套接字;
 *   3. setsockopt(SO_BROADCAST) 打开“允许发送广播”开关(UDP 默认禁止广播);
 *   4. bind 到服务器自己的 IPv4 地址(默认 192.168.50.1),端口由系统分配;
 *   5. 用 sendto 把数据报发往子网广播地址 192.168.50.255:1145;
 *   6. 广播由工作线程按周期执行,窗口线程始终可以响应按钮和重绘。
 *
 * 界面参数全部可以自由修改;默认值取自参考实验报告和 TCP-Lab 工具:
 *   服务器 IP 192.168.50.1、广播地址 192.168.50.255、端口 1145。
 *
 * 应用层报文在 common.h 中定义,16 字节报头包含序号和长度,正文为 UTF-8。
 * 所有窗口文字使用宽字符,网络正文使用 UTF-8,二者在边界处显式转换,
 * 因此中英文混写不会出现乱码。
 * ============================================================================
 */

#include "common.h"

/* ==========================================================================
 * 一、控件标识符与窗口消息
 * ======================================================================== */

#define IDC_BIND_IP 1001        /* 服务器本地绑定 IPv4 输入框 */
#define IDC_BROADCAST_IP 1002   /* 目标广播地址输入框 */
#define IDC_PORT 1003           /* 目标端口输入框 */
#define IDC_INTERVAL 1004       /* 广播周期输入框(毫秒) */
#define IDC_MESSAGE 1005        /* 广播正文输入框 */
#define IDC_START 1006          /* 启动广播按钮 */
#define IDC_STOP 1007           /* 停止广播按钮 */
#define IDC_SEND_NOW 1008       /* 立即广播一次按钮 */
#define IDC_CLEAR_LOG 1009      /* 清空日志按钮 */
#define IDC_LOG_EACH 1010       /* “每次发送都写日志”复选框 */
#define IDC_LOG 1011            /* 多行只读日志框 */
#define IDC_STATUS 1012         /* 状态标签 */
#define IDC_SENT 1013           /* 已发送计数标签 */
#define IDC_FAILED 1014         /* 失败计数标签 */
#define IDC_SOURCE 1015         /* 实际源地址标签 */
#define IDC_FOOTER 1016         /* 底部提示条 */

/* 工作线程 -> 窗口线程的自定义消息,lParam 为堆上的宽字符串。 */
#define WM_APPEND_LOG (WM_APP + 1)

/* 窗口类名,供 Win32 注册和自动化脚本查找窗口。 */
static const wchar_t SERVER_WINDOW_CLASS[] = L"BroadcastServerWindow";
static const wchar_t SERVER_WINDOW_TITLE[] = L"基于广播通信模型的服务器端";

/* ==========================================================================
 * 二、全局状态
 * ======================================================================== */

/*
 * 服务器运行期状态。
 * GUI 模式由窗口线程在启动前填写,工作线程只读其中的网络参数;
 * 发送计数使用 Interlocked 系列函数原子更新,窗口定时器只读显示。
 * 自动测试模式使用一个局部实例,因此同一份发送代码可以复用。
 */
struct ServerRuntime
{
    SOCKET socket;                          /* 已绑定本地地址的 UDP 套接字 */
    sockaddr_in destination;                /* 广播目标地址和端口 */
    char payload[BC_MAX_PAYLOAD + 1];       /* 正文 UTF-8 字节 */
    int payloadLength;                      /* 正文字节数 */
    int intervalMs;                         /* 广播周期,0 表示连续发送 */

    unsigned long sequence;                 /* 当前发送序号,仅工作线程修改 */
    volatile LONG sent;                     /* 成功发送的数据报数 */
    volatile LONG failed;                   /* sendto 失败次数 */
    volatile LONG bytes;                    /* 成功发送的字节数 */
    volatile LONG lastError;                /* 最近一次 Winsock 错误码 */
    volatile LONG logEachSend;              /* 是否每次发送都写日志 */

    HWND notifyWindow;                      /* GUI 模式下接收日志的窗口 */
    Utf8LogWriter* fileLog;                 /* 自动模式下写日志的文件对象 */
    wchar_t sourceDescription[128];         /* 形如 192.168.50.1:54321 */
    unsigned long startedAt;                /* 本次启动的毫秒计数 */
};

/* 唯一的 GUI 运行实例。 */
static ServerRuntime g_server;

/* 窗口与控件句柄。 */
static HWND g_window = NULL;
static HWND g_logEdit = NULL;
static HWND g_statusLabel = NULL;
static HWND g_sentLabel = NULL;
static HWND g_failedLabel = NULL;
static HWND g_sourceLabel = NULL;
static HWND g_footerLabel = NULL;
static HFONT g_uiFont = NULL;
static HFONT g_boldFont = NULL;

/* 线程和停止事件。stop 为手动重置事件,sendNow 为自动重置事件。 */
static HANDLE g_workerThread = NULL;
static HANDLE g_stopEvent = NULL;
static HANDLE g_sendNowEvent = NULL;
static volatile LONG g_running = 0;
static bool g_hasRun = false;

/* 启动前由命令行参数覆盖的初始值(GUI 输入框的默认文字)。 */
static wchar_t g_initialBindIp[64] = L"192.168.50.1";
static wchar_t g_initialBroadcastIp[64] = L"192.168.50.255";
static wchar_t g_initialPort[16] = L"1145";
static wchar_t g_initialInterval[16] = L"1000";
static wchar_t g_initialMessage[4096] = L"今天是个好日子!";

/* ==========================================================================
 * 三、日志与状态显示
 * ======================================================================== */

/*
 * 统一的服务器日志出口。
 * GUI 模式:格式化为 “[时间] 内容” 后 PostMessage 给窗口线程;
 * 自动模式:直接写入 UTF-8 日志文件。
 * 这样工作线程和自动测试共享同一套日志文本,便于对照。
 */
static void ServerLog(ServerRuntime& runtime, const wchar_t* text)
{
    if (text == NULL)
    {
        return;
    }

    wchar_t timeText[32];
    FormatTimeW(timeText, (int)(sizeof(timeText) / sizeof(timeText[0])));

    wchar_t line[2048];
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]), L"[%s] %s", timeText, text);

    if (runtime.notifyWindow != NULL)
    {
        PostWideMessage(runtime.notifyWindow, WM_APPEND_LOG, line);
    }
    else if (runtime.fileLog != NULL)
    {
        runtime.fileLog->WriteLine(line);
    }
}

/* 读取一个 volatile LONG 计数,保证和 Interlocked 写入的原子性一致。 */
static LONG ReadCounter(volatile LONG* counter)
{
    return InterlockedCompareExchange(counter, 0, 0);
}

/* 根据运行状态启用/禁用按钮,避免重复启动或重复停止。 */
static void UpdateButtonState(HWND window, bool running)
{
    EnableWindow(GetDlgItem(window, IDC_START), running ? FALSE : TRUE);
    EnableWindow(GetDlgItem(window, IDC_STOP), running ? TRUE : FALSE);
    EnableWindow(GetDlgItem(window, IDC_SEND_NOW), running ? TRUE : FALSE);
    EnableWindow(GetDlgItem(window, IDC_BIND_IP), running ? FALSE : TRUE);
    EnableWindow(GetDlgItem(window, IDC_BROADCAST_IP), running ? FALSE : TRUE);
    EnableWindow(GetDlgItem(window, IDC_PORT), running ? FALSE : TRUE);
    EnableWindow(GetDlgItem(window, IDC_INTERVAL), running ? FALSE : TRUE);
    EnableWindow(GetDlgItem(window, IDC_MESSAGE), running ? FALSE : TRUE);
}

/* 刷新状态标签。由窗口定时器每 200 毫秒调用一次,不阻塞网络线程。 */
static void UpdateStatusLabels()
{
    if (g_window == NULL)
    {
        return;
    }

    LONG sent = ReadCounter(&g_server.sent);
    LONG failed = ReadCounter(&g_server.failed);
    LONG bytes = ReadCounter(&g_server.bytes);
    LONG lastError = ReadCounter(&g_server.lastError);

    wchar_t line[256];
    if (InterlockedCompareExchange(&g_running, 1, 1) == 1)
    {
        SetWindowTextW(g_statusLabel, L"状态:广播中");
    }
    else
    {
        SetWindowTextW(g_statusLabel, g_hasRun ? L"状态:已停止" : L"状态:未启动");
    }

    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]), L"已发送:%ld 包", sent);
    SetWindowTextW(g_sentLabel, line);

    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]), L"失败:%ld 包", failed);
    SetWindowTextW(g_failedLabel, line);

    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]), L"源地址:%s",
                     g_server.sourceDescription[0] != L'\0' ? g_server.sourceDescription : L"-");
    SetWindowTextW(g_sourceLabel, line);

    if (InterlockedCompareExchange(&g_running, 1, 1) == 1)
    {
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"广播进行中:源 %s,累计发送 %ld 字节。窗口关闭时会自动停止广播并释放套接字。",
                         g_server.sourceDescription[0] != L'\0' ? g_server.sourceDescription : L"-",
                         bytes);
        SetWindowTextW(g_footerLabel, line);
    }
    else if (g_hasRun)
    {
        if (lastError != 0)
        {
            wchar_t errorText[256];
            FormatWinsockErrorW((int)lastError, errorText,
                                (int)(sizeof(errorText) / sizeof(errorText[0])));
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"已停止:共发送 %ld 包、失败 %ld 包、%ld 字节;最近错误:%s",
                             sent, failed, bytes, errorText);
        }
        else
        {
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"已停止:共发送 %ld 包、失败 %ld 包、%ld 字节。",
                             sent, failed, bytes);
        }
        SetWindowTextW(g_footerLabel, line);
    }
    else
    {
        SetWindowTextW(g_footerLabel,
                       L"就绪。请先用 TCP-Lab 一键网卡工具配置 192.168.50.1/192.168.50.2,"
                       L"再启动广播。");
    }
}

/* ==========================================================================
 * 四、套接字与发送逻辑
 * ======================================================================== */

/*
 * 创建并配置广播发送套接字。
 *
 * 参数:
 *   bindAddress      :服务器要绑定的本地 IPv4 地址,0.0.0.0 表示任意网卡;
 *   broadcastAddress :目标广播地址,例如 192.168.50.255;
 *   port             :目标端口,默认 1145;
 *   outSocket        :成功时返回套接字;
 *   outDestination   :成功时返回目标地址结构;
 *   outLocalPort     :成功时返回系统分配的源端口;
 *   errorText        :失败时写入中文错误说明。
 *
 * 返回 true 表示套接字已绑定并可以直接 sendto。
 */
static bool OpenServerSocket(const in_addr& bindAddress,
                             const in_addr& broadcastAddress,
                             unsigned short port,
                             SOCKET* outSocket,
                             sockaddr_in* outDestination,
                             unsigned short* outLocalPort,
                             wchar_t* errorText,
                             int errorCapacity)
{
    if (outSocket == NULL || outDestination == NULL || outLocalPort == NULL)
    {
        return false;
    }
    *outSocket = INVALID_SOCKET;

    /*
     * 广播地址边界校验:0.0.0.0 是“任意本地地址”的绑定写法,不是广播地址。
     * 如果把它当广播目标,sendto 的行为没有实际广播意义,因此在这里直接拒绝,
     * 让 GUI 和自动测试都能得到明确的“边界外”错误提示。
     */
    if (broadcastAddress.s_addr == 0)
    {
        StringCchPrintfW(errorText, (size_t)errorCapacity,
                         L"广播地址不能是 0.0.0.0,请填写子网广播地址,"
                         L"例如 192.168.50.255。");
        return false;
    }

    SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (udpSocket == INVALID_SOCKET)
    {
        wchar_t reason[256];
        FormatWinsockErrorW(WSAGetLastError(), reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));
        StringCchPrintfW(errorText, (size_t)errorCapacity,
                         L"创建 UDP 套接字失败:%s", reason);
        return false;
    }

    /*
     * 关键设置:SO_BROADCAST。
     * Windows 的 UDP 套接字默认禁止向广播地址发送数据,必须显式打开该选项,
     * 否则 sendto 会返回 WSAEACCES(10013)。这是广播编程与普通 UDP 编程
     * 最重要的区别之一。
     */
    int broadcastOption = 1;
    if (setsockopt(udpSocket, SOL_SOCKET, SO_BROADCAST,
                   (const char*)&broadcastOption, sizeof(broadcastOption)) == SOCKET_ERROR)
    {
        wchar_t reason[256];
        FormatWinsockErrorW(WSAGetLastError(), reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));
        StringCchPrintfW(errorText, (size_t)errorCapacity,
                         L"设置 SO_BROADCAST 失败:%s", reason);
        closesocket(udpSocket);
        return false;
    }

    /* 适当增大发送缓冲区,降低突发广播时的丢包概率;失败不影响主流程。 */
    int sendBufferSize = 256 * 1024;
    setsockopt(udpSocket, SOL_SOCKET, SO_SNDBUF,
               (const char*)&sendBufferSize, sizeof(sendBufferSize));

    /*
     * 绑定服务器自己的地址,端口填 0 由系统分配。
     * 绑定源地址而不是 INADDR_ANY,可以保证广播从 TCP-Lab 实验网卡发出,
     * 而不是从 Wi-Fi 或虚拟网卡发出。
     */
    sockaddr_in localAddress;
    memset(&localAddress, 0, sizeof(localAddress));
    localAddress.sin_family = AF_INET;
    localAddress.sin_addr = bindAddress;
    localAddress.sin_port = 0;

    if (bind(udpSocket, (const sockaddr*)&localAddress, sizeof(localAddress)) == SOCKET_ERROR)
    {
        int errorCode = WSAGetLastError();
        wchar_t reason[256];
        FormatWinsockErrorW(errorCode, reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));

        wchar_t bindText[32];
        FormatIPv4W(bindAddress, bindText, (int)(sizeof(bindText) / sizeof(bindText[0])));
        if (errorCode == WSAEADDRNOTAVAIL)
        {
            StringCchPrintfW(errorText, (size_t)errorCapacity,
                             L"绑定 %s 失败:%s。本机没有该 IPv4 地址,"
                             L"请先运行 TCP-Lab 一键网卡工具,或把绑定地址改为 0.0.0.0。",
                             bindText, reason);
        }
        else
        {
            StringCchPrintfW(errorText, (size_t)errorCapacity,
                             L"绑定 %s 失败:%s", bindText, reason);
        }
        closesocket(udpSocket);
        return false;
    }

    /* 读取系统分配的源端口,显示在界面上便于核对抓包结果。 */
    sockaddr_in actualLocal;
    int actualLength = sizeof(actualLocal);
    memset(&actualLocal, 0, sizeof(actualLocal));
    if (getsockname(udpSocket, (sockaddr*)&actualLocal, &actualLength) == SOCKET_ERROR)
    {
        memset(&actualLocal, 0, sizeof(actualLocal));
    }

    sockaddr_in destination;
    memset(&destination, 0, sizeof(destination));
    destination.sin_family = AF_INET;
    destination.sin_addr = broadcastAddress;
    destination.sin_port = htons(port);

    *outSocket = udpSocket;
    *outDestination = destination;
    *outLocalPort = ntohs(actualLocal.sin_port);
    return true;
}

/*
 * 发送一包广播数据。
 * 序号在每次调用时递增;sendto 成功才计入 sent,失败计入 failed 并记录错误码。
 * 日志做了限流:默认周期下每包都记;高速连续发送时每 100 包记一条,
 * 防止日志控件被大量文本拖慢。
 */
static bool SendOnePacket(ServerRuntime& runtime)
{
    if (runtime.socket == INVALID_SOCKET)
    {
        return false;
    }

    /* 序号从 1 开始,便于客户端把“第一包”与“尚未收到”区分开。 */
    runtime.sequence += 1;

    char packet[BC_MAX_DATAGRAM];
    int packetLength = BuildBroadcastPacket(runtime.sequence, runtime.payload,
                                            runtime.payloadLength, packet,
                                            (int)sizeof(packet));
    if (packetLength <= 0)
    {
        LONG failed = InterlockedIncrement(&runtime.failed);
        InterlockedExchange(&runtime.lastError, WSAEMSGSIZE);
        if (failed <= 5)
        {
            ServerLog(runtime, L"组包失败:正文长度超出协议上限。");
        }
        return false;
    }

    int sentBytes = sendto(runtime.socket, packet, packetLength, 0,
                           (const sockaddr*)&runtime.destination,
                           sizeof(runtime.destination));
    if (sentBytes == SOCKET_ERROR)
    {
        int errorCode = WSAGetLastError();
        LONG failed = InterlockedIncrement(&runtime.failed);
        InterlockedExchange(&runtime.lastError, errorCode);

        /* 只记录前 5 次和每第 100 次失败,避免持续失败时刷屏。 */
        if (failed <= 5 || (failed % 100) == 0)
        {
            wchar_t errorText[256];
            FormatWinsockErrorW(errorCode, errorText,
                                (int)(sizeof(errorText) / sizeof(errorText[0])));
            wchar_t line[512];
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"第 %lu 包广播失败:%s", runtime.sequence, errorText);
            ServerLog(runtime, line);
        }

        /* 发送缓冲区暂时耗尽时让出 CPU,避免空转把失败次数迅速放大。 */
        if (errorCode == WSAENOBUFS)
        {
            Sleep(1);
        }
        return false;
    }

    InterlockedIncrement(&runtime.sent);
    InterlockedExchangeAdd(&runtime.bytes, (LONG)sentBytes);

    bool shouldLog = false;
    if (runtime.notifyWindow != NULL)
    {
        /* GUI:慢速时按复选框逐包记录;高速时自动降为每 100 包一条。 */
        if (runtime.sequence == 1)
        {
            shouldLog = true;
        }
        else if (runtime.intervalMs <= 100)
        {
            shouldLog = (runtime.sequence % 100) == 0;
        }
        else
        {
            shouldLog = ReadCounter(&runtime.logEachSend) != 0;
        }
    }
    else
    {
        /* 自动模式:只记录首包和每 1000 包,控制日志体积。 */
        shouldLog = (runtime.sequence == 1) || ((runtime.sequence % 1000) == 0);
    }

    if (shouldLog)
    {
        wchar_t line[512];
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"第 %lu 包已广播,%d 字节,累计成功 %ld 包。",
                         runtime.sequence, sentBytes, ReadCounter(&runtime.sent));
        ServerLog(runtime, line);
    }

    return true;
}

/*
 * 广播工作线程。
 * 等待两个事件:
 *   stopEvent    :停止广播(手动重置);
 *   sendNowEvent :用户点击“立即广播一次”(自动重置)。
 * 超时时间就是广播周期;周期为 0 时超时立即返回,形成连续发送。
 * 窗口线程只设置事件和读取计数,不直接调用 sendto。
 */
static DWORD WINAPI BroadcastWorker(LPVOID)
{
    HANDLE waitHandles[2];
    waitHandles[0] = g_stopEvent;
    waitHandles[1] = g_sendNowEvent;

    for (;;)
    {
        DWORD waitResult = WaitForMultipleObjects(2, waitHandles, FALSE,
                                                  (DWORD)g_server.intervalMs);

        if (waitResult == WAIT_OBJECT_0)
        {
            break; /* 停止事件 */
        }
        if (waitResult == WAIT_OBJECT_0 + 1)
        {
            ResetEvent(g_sendNowEvent); /* 手动发送事件,处理一次后复位 */
        }
        else if (waitResult != WAIT_TIMEOUT)
        {
            break; /* 等待失败,退出线程,避免死循环 */
        }

        if (InterlockedCompareExchange(&g_running, 1, 1) == 0)
        {
            break;
        }

        SendOnePacket(g_server);

        /* 连续发送时定期让出时间片,保证窗口线程仍能刷新界面。 */
        if (g_server.intervalMs == 0 && (g_server.sequence % 1000) == 0)
        {
            Sleep(0);
        }
    }

    return 0;
}

/* ==========================================================================
 * 五、启动与停止
 * ======================================================================== */

/*
 * 从界面读取参数、校验、创建套接字并启动广播线程。
 * 所有错误都通过消息框或日志给出具体原因,方便排查实验环境问题。
 */
static bool StartBroadcast(HWND window)
{
    if (InterlockedCompareExchange(&g_running, 1, 0) != 0)
    {
        return false; /* 已经在运行 */
    }

    wchar_t bindText[64];
    wchar_t broadcastText[64];
    wchar_t portText[16];
    wchar_t intervalText[16];
    wchar_t messageText[4096];

    GetControlTextW(window, IDC_BIND_IP, bindText, (int)(sizeof(bindText) / sizeof(bindText[0])));
    GetControlTextW(window, IDC_BROADCAST_IP, broadcastText, (int)(sizeof(broadcastText) / sizeof(broadcastText[0])));
    GetControlTextW(window, IDC_PORT, portText, (int)(sizeof(portText) / sizeof(portText[0])));
    GetControlTextW(window, IDC_INTERVAL, intervalText, (int)(sizeof(intervalText) / sizeof(intervalText[0])));
    GetControlTextW(window, IDC_MESSAGE, messageText, (int)(sizeof(messageText) / sizeof(messageText[0])));

    TrimW(bindText);
    TrimW(broadcastText);
    TrimW(messageText);
    if (bindText[0] == L'\0')
    {
        StringCchCopyW(bindText, sizeof(bindText) / sizeof(bindText[0]), L"0.0.0.0");
    }

    in_addr bindAddress;
    in_addr broadcastAddress;
    if (!ParseIPv4TextW(bindText, &bindAddress))
    {
        MessageBoxW(window, L"服务器绑定 IPv4 地址格式无效。\n"
                            L"示例:192.168.50.1;也可以填写 0.0.0.0 表示任意网卡。",
                    L"参数错误", MB_OK | MB_ICONWARNING);
        InterlockedExchange(&g_running, 0);
        return false;
    }
    if (!ParseIPv4TextW(broadcastText, &broadcastAddress))
    {
        MessageBoxW(window, L"目标广播地址格式无效。\n"
                            L"默认应为 192.168.50.255(/24 子网的广播地址)。",
                    L"参数错误", MB_OK | MB_ICONWARNING);
        InterlockedExchange(&g_running, 0);
        return false;
    }

    int port = _wtoi(portText);
    if (port < 1 || port > 65535)
    {
        MessageBoxW(window, L"端口必须在 1 到 65535 之间。", L"参数错误",
                    MB_OK | MB_ICONWARNING);
        InterlockedExchange(&g_running, 0);
        return false;
    }

    int interval = _wtoi(intervalText);
    if (interval < 0 || interval > 60000)
    {
        MessageBoxW(window, L"广播周期必须在 0 到 60000 毫秒之间。\n"
                            L"填 0 表示连续发送,适合压力测试。",
                    L"参数错误", MB_OK | MB_ICONWARNING);
        InterlockedExchange(&g_running, 0);
        return false;
    }

    if (messageText[0] == L'\0')
    {
        MessageBoxW(window, L"广播内容不能为空。", L"参数错误",
                    MB_OK | MB_ICONWARNING);
        InterlockedExchange(&g_running, 0);
        return false;
    }

    char payloadUtf8[8192];
    WideToUtf8(messageText, payloadUtf8, (int)sizeof(payloadUtf8));
    int payloadLength = (int)strlen(payloadUtf8);
    if (payloadLength <= 0)
    {
        MessageBoxW(window, L"广播内容无法转换为 UTF-8,请重新输入。", L"参数错误",
                    MB_OK | MB_ICONWARNING);
        InterlockedExchange(&g_running, 0);
        return false;
    }
    if (payloadLength > BC_MAX_PAYLOAD)
    {
        wchar_t tip[256];
        StringCchPrintfW(tip, sizeof(tip) / sizeof(tip[0]),
                         L"广播内容过长:UTF-8 编码后为 %d 字节,\n"
                         L"协议上限为 %d 字节(约 460 个汉字)。",
                         payloadLength, BC_MAX_PAYLOAD);
        MessageBoxW(window, tip, L"参数错误", MB_OK | MB_ICONWARNING);
        InterlockedExchange(&g_running, 0);
        return false;
    }

    HANDLE stopEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
    HANDLE sendNowEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
    if (stopEvent == NULL || sendNowEvent == NULL)
    {
        if (stopEvent != NULL)
        {
            CloseHandle(stopEvent);
        }
        if (sendNowEvent != NULL)
        {
            CloseHandle(sendNowEvent);
        }
        MessageBoxW(window, L"创建线程同步事件失败。", L"启动失败",
                    MB_OK | MB_ICONERROR);
        InterlockedExchange(&g_running, 0);
        return false;
    }

    SOCKET udpSocket = INVALID_SOCKET;
    sockaddr_in destination;
    unsigned short localPort = 0;
    wchar_t errorText[512];
    if (!OpenServerSocket(bindAddress, broadcastAddress, (unsigned short)port,
                          &udpSocket, &destination, &localPort,
                          errorText, (int)(sizeof(errorText) / sizeof(errorText[0]))))
    {
        CloseHandle(stopEvent);
        CloseHandle(sendNowEvent);
        MessageBoxW(window, errorText, L"启动失败", MB_OK | MB_ICONERROR);
        InterlockedExchange(&g_running, 0);
        return false;
    }

    /*
     * 填写运行期状态。这里只在启动线程前写一次,之后网络参数保持不变,
     * 因此工作线程读取 payload、destination、intervalMs 时不需要加锁。
     */
    memset(&g_server, 0, sizeof(g_server));
    g_server.socket = udpSocket;
    g_server.destination = destination;
    memcpy(g_server.payload, payloadUtf8, (size_t)payloadLength + 1);
    g_server.payloadLength = payloadLength;
    g_server.intervalMs = interval;
    g_server.sequence = 0;
    g_server.notifyWindow = window;
    g_server.fileLog = NULL;
    g_server.logEachSend = IsCheckBoxChecked(window, IDC_LOG_EACH) ? 1 : 0;
    g_server.startedAt = NowMilliseconds();
    InterlockedExchange(&g_server.sent, 0);
    InterlockedExchange(&g_server.failed, 0);
    InterlockedExchange(&g_server.bytes, 0);
    InterlockedExchange(&g_server.lastError, 0);

    wchar_t sourceIpText[32];
    FormatIPv4W(bindAddress, sourceIpText, (int)(sizeof(sourceIpText) / sizeof(sourceIpText[0])));
    StringCchPrintfW(g_server.sourceDescription,
                     sizeof(g_server.sourceDescription) / sizeof(g_server.sourceDescription[0]),
                     L"%s:%u", sourceIpText, (unsigned int)localPort);

    g_stopEvent = stopEvent;
    g_sendNowEvent = sendNowEvent;
    InterlockedExchange(&g_running, 1);

    g_workerThread = CreateThread(NULL, 0, BroadcastWorker, NULL,
                                  CREATE_SUSPENDED, NULL);
    if (g_workerThread == NULL)
    {
        InterlockedExchange(&g_running, 0);
        closesocket(udpSocket);
        CloseHandle(stopEvent);
        CloseHandle(sendNowEvent);
        g_stopEvent = NULL;
        g_sendNowEvent = NULL;
        g_server.socket = INVALID_SOCKET;
        MessageBoxW(window, L"创建广播工作线程失败。", L"启动失败",
                    MB_OK | MB_ICONERROR);
        return false;
    }

    g_hasRun = true;
    UpdateButtonState(window, true);
    SetWindowTextW(g_statusLabel, L"状态:广播中");

    wchar_t targetText[32];
    FormatIPv4W(broadcastAddress, targetText, (int)(sizeof(targetText) / sizeof(targetText[0])));
    wchar_t line[1024];
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"广播已启动:源 %s,目标 %s:%u,周期 %d ms,内容“%s”。",
                     g_server.sourceDescription, targetText, (unsigned int)port,
                     interval, messageText);
    ServerLog(g_server, line);

    /*
     * 线程以挂起状态创建,先写完“广播已启动”日志再恢复执行,
     * 这样即使周期为 0(连续发送),日志顺序也不会倒置。
     */
    ResumeThread(g_workerThread);

    /* 启动后立即发送第一包,用户不用等到第一个周期结束。 */
    SetEvent(g_sendNowEvent);

    return true;
}

/*
 * 停止广播并释放资源。
 * 顺序很重要:先通知工作线程退出并等待它结束,再关闭套接字,
 * 避免工作线程还在 sendto 时套接字被另一个线程关闭。
 */
static void StopBroadcast()
{
    bool wasRunning = InterlockedCompareExchange(&g_running, 1, 1) == 1;

    if (wasRunning && g_stopEvent != NULL)
    {
        SetEvent(g_stopEvent);
    }

    if (g_workerThread != NULL)
    {
        DWORD waitResult = WaitForSingleObject(g_workerThread, 5000);
        if (waitResult == WAIT_TIMEOUT)
        {
            /*
             * 正常情况下不会走到这里:工作线程最多等待一个广播周期就会检查
             * 停止事件。若线程因未知原因卡住,终止它是最后的兜底,保证窗口
             * 可以关闭;日志中保留提示便于排查。
             */
            TerminateThread(g_workerThread, 0);
            ServerLog(g_server, L"警告:广播线程未在 5 秒内退出,已强制终止。");
        }
        CloseHandle(g_workerThread);
        g_workerThread = NULL;
    }

    if (g_server.socket != INVALID_SOCKET)
    {
        closesocket(g_server.socket);
        g_server.socket = INVALID_SOCKET;
    }
    if (g_stopEvent != NULL)
    {
        CloseHandle(g_stopEvent);
        g_stopEvent = NULL;
    }
    if (g_sendNowEvent != NULL)
    {
        CloseHandle(g_sendNowEvent);
        g_sendNowEvent = NULL;
    }

    InterlockedExchange(&g_running, 0);

    if (!wasRunning && !g_hasRun)
    {
        return;
    }

    if (wasRunning)
    {
        LONG sent = ReadCounter(&g_server.sent);
        LONG failed = ReadCounter(&g_server.failed);
        LONG bytes = ReadCounter(&g_server.bytes);
        wchar_t line[512];
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"广播已停止:共发送 %ld 包,失败 %ld 包,合计 %ld 字节。",
                         sent, failed, bytes);
        ServerLog(g_server, line);
    }

    if (g_window != NULL)
    {
        UpdateButtonState(g_window, false);
        SetWindowTextW(g_statusLabel, L"状态:已停止");
        UpdateStatusLabels();
    }
}

/* ==========================================================================
 * 六、界面创建与窗口过程
 * ======================================================================== */

/* 创建服务器窗口内的全部控件,并写入初始值。 */
static bool CreateServerControls(HWND window, HINSTANCE instance)
{
    (void)instance;

    g_uiFont = CreateUiFont(14, false, L"Microsoft YaHei UI");
    g_boldFont = CreateUiFont(15, true, L"Microsoft YaHei UI");

    /* 先创建分组框,后创建子控件,保证控件显示在分组框之上。 */
    CreateControlW(window, L"BUTTON", L"广播参数",
                   BS_GROUPBOX, 0, 14, 10, 872, 200, 0, g_uiFont);

    CreateControlW(window, L"STATIC", L"服务器绑定 IPv4:",
                   SS_LEFT | SS_CENTERIMAGE, 0, 28, 36, 104, 22, 0, g_uiFont);
    CreateControlW(window, L"EDIT", g_initialBindIp,
                   WS_BORDER | ES_AUTOHSCROLL, WS_EX_CLIENTEDGE,
                   136, 34, 158, 26, IDC_BIND_IP, g_uiFont);

    CreateControlW(window, L"STATIC", L"目标广播地址:",
                   SS_LEFT | SS_CENTERIMAGE, 0, 306, 36, 104, 22, 0, g_uiFont);
    CreateControlW(window, L"EDIT", g_initialBroadcastIp,
                   WS_BORDER | ES_AUTOHSCROLL, WS_EX_CLIENTEDGE,
                   414, 34, 158, 26, IDC_BROADCAST_IP, g_uiFont);

    CreateControlW(window, L"STATIC", L"端口:",
                   SS_LEFT | SS_CENTERIMAGE, 0, 586, 36, 44, 22, 0, g_uiFont);
    CreateControlW(window, L"EDIT", g_initialPort,
                   WS_BORDER | ES_NUMBER, WS_EX_CLIENTEDGE,
                   634, 34, 70, 26, IDC_PORT, g_uiFont);

    CreateControlW(window, L"STATIC", L"周期(ms):",
                   SS_LEFT | SS_CENTERIMAGE, 0, 718, 36, 76, 22, 0, g_uiFont);
    CreateControlW(window, L"EDIT", g_initialInterval,
                   WS_BORDER | ES_NUMBER, WS_EX_CLIENTEDGE,
                   798, 34, 74, 26, IDC_INTERVAL, g_uiFont);

    CreateControlW(window, L"STATIC", L"广播内容:",
                   SS_LEFT | SS_CENTERIMAGE, 0, 28, 72, 104, 22, 0, g_uiFont);
    HWND messageEdit = CreateControlW(window, L"EDIT", g_initialMessage,
                                      WS_BORDER | ES_AUTOHSCROLL, WS_EX_CLIENTEDGE,
                                      136, 70, 736, 26, IDC_MESSAGE, g_uiFont);
    if (messageEdit != NULL)
    {
        SendMessageW(messageEdit, EM_SETLIMITTEXT, 1000, 0);
    }

    CreateControlW(window, L"BUTTON", L"启动广播",
                   BS_PUSHBUTTON, 0, 136, 110, 100, 30, IDC_START, g_boldFont);
    CreateControlW(window, L"BUTTON", L"停止广播",
                   BS_PUSHBUTTON, 0, 244, 110, 100, 30, IDC_STOP, g_uiFont);
    CreateControlW(window, L"BUTTON", L"立即广播一次",
                   BS_PUSHBUTTON, 0, 352, 110, 110, 30, IDC_SEND_NOW, g_uiFont);
    CreateControlW(window, L"BUTTON", L"清空日志",
                   BS_PUSHBUTTON, 0, 470, 110, 100, 30, IDC_CLEAR_LOG, g_uiFont);

    HWND logEach = CreateControlW(window, L"BUTTON", L"每次发送都写日志",
                                  BS_AUTOCHECKBOX, 0, 586, 114, 180, 22,
                                  IDC_LOG_EACH, g_uiFont);
    if (logEach != NULL)
    {
        SendMessageW(logEach, BM_SETCHECK, BST_CHECKED, 0);
    }

    g_statusLabel = CreateControlW(window, L"STATIC", L"状态:未启动",
                                   SS_LEFT | SS_CENTERIMAGE, 0, 28, 152, 250, 22,
                                   IDC_STATUS, g_uiFont);
    g_sentLabel = CreateControlW(window, L"STATIC", L"已发送:0 包",
                                 SS_LEFT | SS_CENTERIMAGE, 0, 290, 152, 190, 22,
                                 IDC_SENT, g_uiFont);
    g_failedLabel = CreateControlW(window, L"STATIC", L"失败:0 包",
                                   SS_LEFT | SS_CENTERIMAGE, 0, 490, 152, 120, 22,
                                   IDC_FAILED, g_uiFont);
    g_sourceLabel = CreateControlW(window, L"STATIC", L"源地址:-",
                                   SS_LEFT | SS_CENTERIMAGE, 0, 620, 152, 250, 22,
                                   IDC_SOURCE, g_uiFont);

    CreateControlW(window, L"BUTTON", L"运行日志",
                   BS_GROUPBOX, 0, 14, 218, 872, 380, 0, g_uiFont);

    g_logEdit = CreateControlW(window, L"EDIT", L"",
                               WS_BORDER | ES_MULTILINE | ES_AUTOVSCROLL |
                                   ES_READONLY | WS_VSCROLL,
                               WS_EX_CLIENTEDGE, 28, 244, 844, 340,
                               IDC_LOG, g_uiFont);
    if (g_logEdit != NULL)
    {
        SendMessageW(g_logEdit, EM_SETLIMITTEXT, EDIT_TEXT_LIMIT, 0);
    }

    g_footerLabel = CreateControlW(window, L"STATIC",
                                   L"就绪。请先用 TCP-Lab 一键网卡工具配置 192.168.50.1/192.168.50.2,"
                                   L"再启动广播。",
                                   SS_LEFT | SS_CENTERIMAGE | SS_SUNKEN, 0,
                                   14, 606, 872, 24, IDC_FOOTER, g_uiFont);

    SetWindowTextW(window, SERVER_WINDOW_TITLE);
    UpdateButtonState(window, false);
    UpdateStatusLabels();
    return true;
}

/* 服务器窗口过程:处理按钮、定时器、工作线程日志和关闭流程。 */
static LRESULT CALLBACK ServerWindowProc(HWND window, UINT message,
                                         WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
        return CreateServerControls(window, (HINSTANCE)GetWindowLongPtrW(window, GWLP_HINSTANCE))
                   ? 0
                   : -1;

    case WM_COMMAND:
        switch (LOWORD(wParam))
        {
        case IDC_START:
            StartBroadcast(window);
            return 0;

        case IDC_STOP:
            StopBroadcast();
            return 0;

        case IDC_SEND_NOW:
            if (InterlockedCompareExchange(&g_running, 1, 1) == 1 &&
                g_sendNowEvent != NULL)
            {
                SetEvent(g_sendNowEvent);
            }
            else
            {
                MessageBoxW(window, L"广播尚未启动,请先点击“启动广播”。",
                            L"提示", MB_OK | MB_ICONINFORMATION);
            }
            return 0;

        case IDC_CLEAR_LOG:
            if (g_logEdit != NULL)
            {
                SetWindowTextW(g_logEdit, L"");
            }
            return 0;

        case IDC_LOG_EACH:
            InterlockedExchange(&g_server.logEachSend,
                                IsCheckBoxChecked(window, IDC_LOG_EACH) ? 1 : 0);
            return 0;

        default:
            break;
        }
        break;

    case WM_TIMER:
        UpdateStatusLabels();
        return 0;

    case WM_APPEND_LOG:
    {
        wchar_t* text = (wchar_t*)lParam;
        if (text != NULL)
        {
            AppendEditLineW(g_logEdit, text);
            free(text);
        }
        return 0;
    }

    case WM_CLOSE:
        StopBroadcast();
        DestroyWindow(window);
        return 0;

    case WM_DESTROY:
        KillTimer(window, 1);
        if (g_uiFont != NULL)
        {
            DeleteObject(g_uiFont);
            g_uiFont = NULL;
        }
        if (g_boldFont != NULL)
        {
            DeleteObject(g_boldFont);
            g_boldFont = NULL;
        }
        WSACleanup();
        PostQuitMessage(0);
        return 0;

    default:
        break;
    }

    return DefWindowProcW(window, message, wParam, lParam);
}

/* ==========================================================================
 * 七、自动测试模式(无窗口)
 * ======================================================================== */

/* 自动模式出错时写一份最小的统计文件,方便 Python 判断失败原因。 */
static void WriteServerErrorStats(const wchar_t* statsPath, const char* reason, int exitCode)
{
    char json[1024];
    StringCchPrintfA(json, sizeof(json),
                     "{\n"
                     "  \"role\": \"server\",\n"
                     "  \"sent\": 0,\n"
                     "  \"failed\": 0,\n"
                     "  \"bytes\": 0,\n"
                     "  \"elapsed_ms\": 0,\n"
                     "  \"pps\": 0.0,\n"
                     "  \"sequence\": 0,\n"
                     "  \"last_error\": 0,\n"
                     "  \"exit_code\": %d,\n"
                     "  \"error\": \"%s\"\n"
                     "}\n",
                     exitCode, reason != NULL ? reason : "");
    WriteAsciiFile(statsPath, json);
}

/* 自动模式结束后写统计 JSON(纯 ASCII 键值,Python 直接解析)。 */
static void WriteServerStats(const wchar_t* statsPath,
                             ServerRuntime& runtime,
                             unsigned long elapsedMs,
                             int exitCode,
                             const char* errorText)
{
    LONG sent = ReadCounter(&runtime.sent);
    LONG failed = ReadCounter(&runtime.failed);
    LONG bytes = ReadCounter(&runtime.bytes);
    LONG lastError = ReadCounter(&runtime.lastError);

    double pps = 0.0;
    if (elapsedMs > 0)
    {
        pps = 1000.0 * (double)sent / (double)elapsedMs;
    }

    char json[2048];
    StringCchPrintfA(json, sizeof(json),
                     "{\n"
                     "  \"role\": \"server\",\n"
                     "  \"sent\": %ld,\n"
                     "  \"failed\": %ld,\n"
                     "  \"bytes\": %ld,\n"
                     "  \"elapsed_ms\": %lu,\n"
                     "  \"pps\": %.2f,\n"
                     "  \"sequence\": %lu,\n"
                     "  \"last_error\": %ld,\n"
                     "  \"exit_code\": %d,\n"
                     "  \"error\": \"%s\"\n"
                     "}\n",
                     sent, failed, bytes, elapsedMs, pps,
                     runtime.sequence, lastError, exitCode,
                     errorText != NULL ? errorText : "");
    WriteAsciiFile(statsPath, json);
}

/*
 * 自动模式的高精度计时辅助。
 * --pps 需要比 Sleep(1) 更细的节奏控制,因此用 QueryPerformanceCounter;
 * 每次 wait 只在最后几毫秒忙等,其余时间 Sleep,兼顾精度和 CPU。
 */
static double QuerySeconds()
{
    static LARGE_INTEGER frequency;
    static bool initialized = false;
    if (!initialized)
    {
        QueryPerformanceFrequency(&frequency);
        initialized = true;
    }
    LARGE_INTEGER counter;
    QueryPerformanceCounter(&counter);
    if (frequency.QuadPart == 0)
    {
        return 0.0;
    }
    return (double)counter.QuadPart / (double)frequency.QuadPart;
}

static void WaitUntilSeconds(double targetSeconds)
{
    for (;;)
    {
        double now = QuerySeconds();
        double remaining = targetSeconds - now;
        if (remaining <= 0.0)
        {
            break;
        }
        if (remaining > 0.003)
        {
            DWORD sleepMs = (DWORD)((remaining - 0.001) * 1000.0);
            if (sleepMs == 0)
            {
                sleepMs = 1;
            }
            Sleep(sleepMs);
        }
        else
        {
            Sleep(0);
        }
    }
}

/*
 * 自动广播模式,供 stress_test.py 调用。
 *
 * 示例:
 *   server.exe --auto --bind 127.0.0.1 --broadcast 127.255.255.255 \
 *              --port 11545 --interval 0 --count 20000 \
 *              --stats server_stats.json --log server.log
 *
 * 速率测试示例:
 *   server.exe --auto --bind 192.168.50.1 --broadcast 192.168.50.255 \
 *              --port 1145 --pps 1000 --duration 10 \
 *              --stats server_stats.json --log server.log
 *
 * 该模式不创建窗口,只做网络发送和统计,适合批量压力测试。
 * 退出码:0 成功;2 参数/套接字错误或存在发送失败;3 日志/统计文件写入失败。
 */
static int RunAutoServer(const CommandLineArgs& args)
{
    wchar_t logPath[1024];
    wchar_t statsPath[1024];
    StringCchCopyW(logPath, sizeof(logPath) / sizeof(logPath[0]),
                   args.Value(L"--log", L"server_auto.log"));
    StringCchCopyW(statsPath, sizeof(statsPath) / sizeof(statsPath[0]),
                   args.Value(L"--stats", L"server_auto_stats.json"));

    const wchar_t* bindTextW = args.Value(L"--bind", L"127.0.0.1");
    const wchar_t* broadcastTextW = args.Value(L"--broadcast", L"255.255.255.255");
    const wchar_t* messageW = args.Value(L"--message", DEFAULT_MESSAGE_W);
    int port = args.IntValue(L"--port", (int)DEFAULT_PORT);
    int interval = args.IntValue(L"--interval", 0);
    int pps = args.IntValue(L"--pps", 0);
    int count = args.IntValue(L"--count", 1000);
    int durationSeconds = args.IntValue(L"--duration", 0);

    Utf8LogWriter logFile;
    bool logOpen = logFile.Open(logPath);
    if (!logOpen)
    {
        WriteServerErrorStats(statsPath, "log open failed", 3);
        return 3;
    }

    ServerRuntime runtime;
    memset(&runtime, 0, sizeof(runtime));
    runtime.socket = INVALID_SOCKET;
    runtime.fileLog = &logFile;
    runtime.notifyWindow = NULL;
    runtime.intervalMs = interval;

    logFile.WriteLine(L"广播服务器自动模式启动。");
    logFile.WriteLine(L"说明:本模式不显示窗口,用于批量压力测试。");

    if (port < 1 || port > 65535 || interval < 0 || interval > 60000 ||
        pps < 0 || pps > 1000000 ||
        count < 0 || durationSeconds < 0 ||
        (count == 0 && durationSeconds == 0))
    {
        logFile.WriteLine(L"参数错误:端口 1~65535,周期 0~60000,"
                          L"pps 0~1000000,count 与 duration 不能同时为 0。");
        WriteServerErrorStats(statsPath, "invalid arguments", 2);
        logFile.Close();
        return 2;
    }

    in_addr bindAddress;
    in_addr broadcastAddress;
    if (!ParseIPv4TextW(bindTextW, &bindAddress) ||
        !ParseIPv4TextW(broadcastTextW, &broadcastAddress))
    {
        logFile.WriteLine(L"参数错误:IPv4 地址格式无效。");
        WriteServerErrorStats(statsPath, "invalid ipv4 address", 2);
        logFile.Close();
        return 2;
    }

    char payload[8192];
    WideToUtf8(messageW, payload, (int)sizeof(payload));
    int payloadLength = (int)strlen(payload);
    if (payloadLength <= 0 || payloadLength > BC_MAX_PAYLOAD)
    {
        logFile.WriteLine(L"参数错误:广播内容为空或超过 1400 字节。");
        WriteServerErrorStats(statsPath, "invalid payload", 2);
        logFile.Close();
        return 2;
    }

    if (!InitializeWinsock())
    {
        logFile.WriteLine(L"Winsock 初始化失败。");
        WriteServerErrorStats(statsPath, "winsock init failed", 2);
        logFile.Close();
        return 2;
    }

    SOCKET udpSocket = INVALID_SOCKET;
    sockaddr_in destination;
    unsigned short localPort = 0;
    wchar_t errorText[512];
    if (!OpenServerSocket(bindAddress, broadcastAddress, (unsigned short)port,
                          &udpSocket, &destination, &localPort,
                          errorText, (int)(sizeof(errorText) / sizeof(errorText[0]))))
    {
        logFile.WriteLine(errorText);
        WriteServerErrorStats(statsPath, "open socket failed", 2);
        WSACleanup();
        logFile.Close();
        return 2;
    }

    runtime.socket = udpSocket;
    runtime.destination = destination;
    memcpy(runtime.payload, payload, (size_t)payloadLength + 1);
    runtime.payloadLength = payloadLength;
    runtime.sequence = 0;
    runtime.startedAt = NowMilliseconds();

    wchar_t bindText[32];
    wchar_t broadcastText[32];
    FormatIPv4W(bindAddress, bindText, (int)(sizeof(bindText) / sizeof(bindText[0])));
    FormatIPv4W(broadcastAddress, broadcastText, (int)(sizeof(broadcastText) / sizeof(broadcastText[0])));

    wchar_t line[1024];
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"自动模式参数:绑定 %s:%u,广播 %s:%d,周期 %d ms,"
                     L"目标速率 %d pps,目标 %d 包,时长 %d 秒。",
                     bindText, (unsigned int)localPort, broadcastText, port,
                     interval, pps, count, durationSeconds);
    logFile.WriteLine(line);
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"广播内容(UTF-8 共 %d 字节):%s", payloadLength, messageW);
    logFile.WriteLine(line);

    unsigned long started = NowMilliseconds();
    unsigned long durationMs = 0;
    if (durationSeconds > 0)
    {
        durationMs = (unsigned long)durationSeconds * 1000UL;
    }

    bool aborted = false;
    double ppsInterval = (pps > 0) ? (1.0 / (double)pps) : 0.0;
    double nextSendTime = QuerySeconds();
    unsigned long lastStatsWrite = started;
    for (;;)
    {
        if (durationMs > 0 && (NowMilliseconds() - started) >= durationMs)
        {
            break;
        }

        LONG sent = ReadCounter(&runtime.sent);
        LONG failed = ReadCounter(&runtime.failed);
        if (count > 0 && (sent + failed) >= count)
        {
            break;
        }

        /* 连续大量失败说明环境异常(如网卡被禁用),及时退出避免空转。 */
        if (failed >= 100 && sent == 0)
        {
            aborted = true;
            break;
        }

        /* --pps > 0 时按高精度目标时间点发送,优先于 --interval。 */
        if (pps > 0)
        {
            /*
             * 如果某次发送被系统调度延迟,不追赶超过 2 ms 的旧时间点,
             * 避免形成突发补发;这一思路参考了 GitHub 上的广播风暴脚本
             * pnio-rs/bench/bcast_storm.py 的 “cap the burst” 处理。
             */
            double nowSeconds = QuerySeconds();
            if (nextSendTime < nowSeconds - 0.002)
            {
                nextSendTime = nowSeconds;
            }
            WaitUntilSeconds(nextSendTime);
        }

        SendOnePacket(runtime);

        if (pps > 0)
        {
            nextSendTime += ppsInterval;
        }
        else if (interval > 0)
        {
            Sleep((DWORD)interval);
        }
        else if (((runtime.sequence % 1000) == 0))
        {
            Sleep(0);
        }

        /*
         * 每约 1 秒把当前统计写入 JSON。长时间稳定性和极限测试的 Python
         * 监控进程可以在服务器仍在运行时读取 sent/failed,从而观察趋势,
         * 而不是只能等进程结束。最终退出时还会再写一次带真实 exit_code 的版本。
         */
        unsigned long now = NowMilliseconds();
        if (now - lastStatsWrite >= 1000)
        {
            WriteServerStats(statsPath, runtime, now - started, 0, "");
            lastStatsWrite = now;
        }
    }

    unsigned long elapsed = NowMilliseconds() - started;
    LONG sent = ReadCounter(&runtime.sent);
    LONG failed = ReadCounter(&runtime.failed);
    LONG bytes = ReadCounter(&runtime.bytes);
    LONG lastError = ReadCounter(&runtime.lastError);

    bool success = (failed == 0) && (sent > 0) && !aborted;
    if (count > 0 && durationSeconds == 0 && sent < count)
    {
        success = false;
    }

    int exitCode = success ? 0 : 2;
    const char* errorTextA = success ? "" : "send failed or count not reached";
    WriteServerStats(statsPath, runtime, elapsed, exitCode, errorTextA);

    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"自动模式结束:成功 %ld 包,失败 %ld 包,%ld 字节,"
                     L"耗时 %lu ms,平均 %.2f 包/秒。",
                     sent, failed, bytes, elapsed,
                     elapsed > 0 ? (1000.0 * (double)sent / (double)elapsed) : 0.0);
    logFile.WriteLine(line);
    if (lastError != 0)
    {
        wchar_t errorTextW[256];
        FormatWinsockErrorW((int)lastError, errorTextW,
                            (int)(sizeof(errorTextW) / sizeof(errorTextW[0])));
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"最近一次错误:%s", errorTextW);
        logFile.WriteLine(line);
    }

    closesocket(runtime.socket);
    runtime.socket = INVALID_SOCKET;
    WSACleanup();
    logFile.Close();
    return exitCode;
}

/* ==========================================================================
 * 八、程序入口
 * ======================================================================== */

/* 命令行帮助文本。自动测试脚本不会触发该分支。 */
static const wchar_t SERVER_USAGE[] =
    L"基于广播通信模型的服务器端\n\n"
    L"图形界面(默认):\n"
    L"  server.exe [--bind 192.168.50.1] [--broadcast 192.168.50.255]\n"
    L"              [--port 1145] [--interval 1000] [--message 文本]\n\n"
    L"自动压力测试模式(无窗口):\n"
    L"  server.exe --auto --bind 127.0.0.1 --broadcast 127.255.255.255\n"
    L"              --port 11545 --interval 0 --count 20000\n"
    L"              --stats server_stats.json --log server.log\n\n"
    L"  server.exe --auto --bind 192.168.50.1 --broadcast 192.168.50.255\n"
    L"              --port 1145 --pps 1000 --duration 10\n"
    L"              --stats server_stats.json --log server.log\n\n"
    L"参数说明:\n"
    L"  --auto       不创建窗口,直接循环发送并写统计文件\n"
    L"  --interval   广播周期(毫秒),0 表示连续发送\n"
    L"  --pps        目标发送速率(包/秒),大于 0 时优先于 --interval\n"
    L"  --count      目标发送包数;0 表示按 --duration 运行\n"
    L"  --duration   运行秒数;与 --count 至少给出一个\n"
    L"  --stats      统计 JSON 输出路径\n"
    L"  --log        UTF-8 日志输出路径\n";

int WINAPI WinMain(HINSTANCE instance, HINSTANCE previousInstance,
                   LPSTR commandLine, int showCommand)
{
    (void)previousInstance;
    (void)commandLine;

    /* 高 DPI 下保持窗口清晰。 */
    EnableDpiAwareness();

    /* 套接字句柄在启动前必须是 INVALID_SOCKET,避免关闭未创建的句柄。 */
    memset(&g_server, 0, sizeof(g_server));
    g_server.socket = INVALID_SOCKET;

    CommandLineArgs args;
    LoadCommandLine(&args);

    if (args.Has(L"--help") || args.Has(L"/?"))
    {
        MessageBoxW(NULL, SERVER_USAGE, L"服务器端使用说明", MB_OK | MB_ICONINFORMATION);
        FreeCommandLine(&args);
        return 0;
    }

    if (args.Has(L"--auto"))
    {
        int result = RunAutoServer(args);
        FreeCommandLine(&args);
        return result;
    }

    /* GUI 模式的初始值:先取默认值,再允许命令行覆盖,便于截图和联调。 */
    StringCchCopyW(g_initialBindIp, sizeof(g_initialBindIp) / sizeof(g_initialBindIp[0]),
                   DEFAULT_BIND_IP_W);
    StringCchCopyW(g_initialBroadcastIp,
                   sizeof(g_initialBroadcastIp) / sizeof(g_initialBroadcastIp[0]),
                   DEFAULT_BROADCAST_IP_W);
    StringCchCopyW(g_initialPort, sizeof(g_initialPort) / sizeof(g_initialPort[0]), L"1145");
    StringCchCopyW(g_initialInterval,
                   sizeof(g_initialInterval) / sizeof(g_initialInterval[0]), L"1000");
    StringCchCopyW(g_initialMessage,
                   sizeof(g_initialMessage) / sizeof(g_initialMessage[0]),
                   DEFAULT_MESSAGE_W);

    const wchar_t* value = args.Value(L"--bind", NULL);
    if (value != NULL)
    {
        StringCchCopyW(g_initialBindIp, sizeof(g_initialBindIp) / sizeof(g_initialBindIp[0]), value);
    }
    value = args.Value(L"--broadcast", NULL);
    if (value != NULL)
    {
        StringCchCopyW(g_initialBroadcastIp,
                       sizeof(g_initialBroadcastIp) / sizeof(g_initialBroadcastIp[0]), value);
    }
    value = args.Value(L"--port", NULL);
    if (value != NULL)
    {
        StringCchCopyW(g_initialPort, sizeof(g_initialPort) / sizeof(g_initialPort[0]), value);
    }
    value = args.Value(L"--interval", NULL);
    if (value != NULL)
    {
        StringCchCopyW(g_initialInterval,
                       sizeof(g_initialInterval) / sizeof(g_initialInterval[0]), value);
    }
    value = args.Value(L"--message", NULL);
    if (value != NULL)
    {
        StringCchCopyW(g_initialMessage,
                       sizeof(g_initialMessage) / sizeof(g_initialMessage[0]), value);
    }

    if (!InitializeWinsock())
    {
        MessageBoxW(NULL, L"Winsock 初始化失败,程序无法启动。", L"错误",
                    MB_OK | MB_ICONERROR);
        FreeCommandLine(&args);
        return 1;
    }

    WNDCLASSEXW windowClass;
    memset(&windowClass, 0, sizeof(windowClass));
    windowClass.cbSize = sizeof(windowClass);
    windowClass.lpfnWndProc = ServerWindowProc;
    windowClass.hInstance = instance;
    windowClass.hCursor = LoadCursorW(NULL, IDC_ARROW);
    windowClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    windowClass.lpszClassName = SERVER_WINDOW_CLASS;
    windowClass.hIcon = LoadIconW(NULL, IDI_APPLICATION);
    windowClass.hIconSm = LoadIconW(NULL, IDI_APPLICATION);
    if (RegisterClassExW(&windowClass) == 0)
    {
        MessageBoxW(NULL, L"注册服务器窗口类失败。", L"错误", MB_OK | MB_ICONERROR);
        WSACleanup();
        FreeCommandLine(&args);
        return 1;
    }

    /* 固定窗口大小,避免用户缩放后控件错位;客户区为 900 x 640。 */
    DWORD windowStyle = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
    RECT windowRect;
    windowRect.left = 0;
    windowRect.top = 0;
    windowRect.right = WINDOW_CLIENT_WIDTH;
    windowRect.bottom = WINDOW_CLIENT_HEIGHT;
    AdjustWindowRectEx(&windowRect, windowStyle, FALSE, 0);
    int windowWidth = windowRect.right - windowRect.left;
    int windowHeight = windowRect.bottom - windowRect.top;

    g_window = CreateWindowExW(0, SERVER_WINDOW_CLASS, SERVER_WINDOW_TITLE,
                               windowStyle, CW_USEDEFAULT, CW_USEDEFAULT,
                               windowWidth, windowHeight, NULL, NULL,
                               instance, NULL);
    if (g_window == NULL)
    {
        MessageBoxW(NULL, L"创建服务器主窗口失败。", L"错误", MB_OK | MB_ICONERROR);
        WSACleanup();
        FreeCommandLine(&args);
        return 1;
    }

    ShowWindow(g_window, showCommand);
    UpdateWindow(g_window);
    SetTimer(g_window, 1, 200, NULL);

    MSG message;
    while (GetMessageW(&message, NULL, 0, 0) > 0)
    {
        TranslateMessage(&message);
        DispatchMessageW(&message);
    }

    FreeCommandLine(&args);
    return (int)message.wParam;
}

4.5 client.cpp 客户端程序详解

4.5.1 宏、全局变量和状态

client.cpp 定义客户端窗口类名、控件 ID、默认监听地址和端口。ClientRuntime 保存 UDP 套接字、接收计数、字节计数、序号缺失、重复计数、非法报文计数、正文匹配计数、首/末序号、停止事件、日志和统计路径。客户端不保存服务器地址,也不维护连接状态。

4.5.2 ClientLog(message)

该函数与服务器端 ServerLog() 类似,通过 PostMessageW() 把工作线程日志投递到窗口线程;GUI 模式更新日志控件,自动模式写入 UTF-8 文件。函数原文如下:

点击展开/收起:ClientLog() 消息日志代码
static void ClientLog(ClientRuntime& runtime, const wchar_t* text)
{
    if (text == NULL)
    {
        return;
    }

    wchar_t timeText[32];
    FormatTimeW(timeText, (int)(sizeof(timeText) / sizeof(timeText[0])));

    wchar_t line[2048];
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]), L"[%s] %s", timeText, text);

    if (runtime.notifyWindow != NULL)
    {
        PostWideMessage(runtime.notifyWindow, WM_APPEND_LOG, line);
    }
    else if (runtime.fileLog != NULL)
    {
        runtime.fileLog->WriteLine(line);
    }
}

4.5.3 ReceiveWorker(parameter) 与 HandleDatagram()

ReceiveWorker() 用 select() 等待可读事件,recvfrom() 接收数据报,再交给 HandleDatagram();HandleDatagram() 校验报头、更新计数、统计序号缺失/重复、转换正文并投递显示。两个函数原文如下:

点击展开/收起:HandleDatagram() 与 ReceiveWorker() 接收代码
static bool HandleDatagram(ClientRuntime& runtime,
                           const char* data,
                           int length,
                           const sockaddr_in& from)
{
    BroadcastPacket packet;
    int parseResult = ParseBroadcastPacket(data, length, &packet);
    if (parseResult != BC_PARSE_OK)
    {
        InterlockedIncrement(&runtime.malformed);

        if (runtime.malformedLogged < 10)
        {
            wchar_t fromText[32];
            FormatIPv4W(from.sin_addr, fromText,
                        (int)(sizeof(fromText) / sizeof(fromText[0])));
            wchar_t line[512];
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"丢弃无效数据报:%s(来自 %s:%u,长度 %d 字节)。",
                             BroadcastParseErrorText(parseResult), fromText,
                             (unsigned int)ntohs(from.sin_port), length);
            ClientLog(runtime, line);
            ++runtime.malformedLogged;
        }
        return false;
    }

    InterlockedIncrement(&runtime.received);
    InterlockedExchangeAdd(&runtime.bytes, (LONG)length);

    /*
     * 序号分析:
     *   firstSequence == 0 表示还没收到过合法包;
     *   新序号 == lastSequence + 1 表示连续;
     *   新序号更大且不连续,说明中间的数据报丢失;
     *   新序号不大于 lastSequence,说明重复或乱序。
     * UDP 广播不保证顺序,这个统计只用于实验分析,不影响消息显示。
     */
    if (runtime.firstSequence == 0)
    {
        runtime.firstSequence = packet.sequence;
        runtime.lastSequence = packet.sequence;

        if (!runtime.hasFirstPayload)
        {
            char payloadCopy[BC_MAX_PAYLOAD + 1];
            memcpy(payloadCopy, packet.payload, (size_t)packet.payloadLength);
            payloadCopy[packet.payloadLength] = '\0';
            Utf8ToWide(payloadCopy, runtime.firstPayload,
                       (int)(sizeof(runtime.firstPayload) / sizeof(runtime.firstPayload[0])));
            runtime.hasFirstPayload = true;
        }

        wchar_t fromText[32];
        FormatIPv4W(from.sin_addr, fromText,
                    (int)(sizeof(fromText) / sizeof(fromText[0])));
        wchar_t line[512];
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"收到首个广播包:来自 %s:%u,序号 %lu,正文长度 %d 字节。",
                         fromText, (unsigned int)ntohs(from.sin_port),
                         packet.sequence, packet.payloadLength);
        ClientLog(runtime, line);
    }
    else if (packet.sequence > runtime.lastSequence)
    {
        if (packet.sequence > runtime.lastSequence + 1)
        {
            unsigned long missing = packet.sequence - runtime.lastSequence - 1;
            InterlockedExchangeAdd(&runtime.gaps, (LONG)missing);

            wchar_t line[512];
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"序号不连续:上一包 %lu,本包 %lu,估算缺失 %lu 包。",
                             runtime.lastSequence, packet.sequence, missing);
            ClientLog(runtime, line);
        }
        runtime.lastSequence = packet.sequence;
    }
    else
    {
        /* 重复包(序号相等)或乱序包(序号更小)。 */
        InterlockedIncrement(&runtime.duplicates);
    }

    /* 正文不是以 '\0' 结尾的网络数据,先复制到本地缓冲区再转换。 */
    char payloadCopy[BC_MAX_PAYLOAD + 1];
    memcpy(payloadCopy, packet.payload, (size_t)packet.payloadLength);
    payloadCopy[packet.payloadLength] = '\0';

    wchar_t payloadWide[BC_MAX_PAYLOAD + 1];
    Utf8ToWide(payloadCopy, payloadWide,
               (int)(sizeof(payloadWide) / sizeof(payloadWide[0])));

    if (runtime.hasExpectedText && wcscmp(payloadWide, runtime.expectedText) == 0)
    {
        InterlockedIncrement(&runtime.matchedText);
    }

    wchar_t timeText[32];
    FormatTimeW(timeText, (int)(sizeof(timeText) / sizeof(timeText[0])));
    wchar_t fromText[32];
    FormatIPv4W(from.sin_addr, fromText,
                (int)(sizeof(fromText) / sizeof(fromText[0])));

    wchar_t line[2048];
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"[%s] 来自 %s:%u  序号 %lu  %s",
                     timeText, fromText, (unsigned int)ntohs(from.sin_port),
                     packet.sequence, payloadWide);

    if (runtime.notifyWindow != NULL)
    {
        if (ReadCounter(&runtime.showMessages) != 0)
        {
            /*
             * 显示节流:如果窗口线程处理不过来(待显示消息超过 300 条),
             * 就跳过本条显示,只保留统计。否则高速广播会把消息循环压垮。
             */
            if (ReadCounter(&runtime.pendingDisplay) < 300)
            {
                wchar_t* copy = DuplicateWideString(line);
                if (copy != NULL)
                {
                    InterlockedIncrement(&runtime.pendingDisplay);
                    if (!PostMessageW(runtime.notifyWindow, WM_APP_BROADCAST, 0,
                                      (LPARAM)copy))
                    {
                        InterlockedDecrement(&runtime.pendingDisplay);
                        free(copy);
                    }
                }
            }
            else
            {
                LONG skipped = InterlockedIncrement(&runtime.displaySkipped);
                if ((skipped % 500) == 0)
                {
                    wchar_t warning[256];
                    StringCchPrintfW(warning, sizeof(warning) / sizeof(warning[0]),
                                     L"界面繁忙,已省略显示 %ld 条广播(接收计数仍在增加)。",
                                     skipped);
                    ClientLog(runtime, warning);
                }
            }
        }
    }
    else if (runtime.fileLog != NULL)
    {
        /*
         * 自动模式日志:前 1000 条逐条记录,之后每 100 条记录一条,
         * 既保留正文样本,又避免日志文件过大影响测试。
         */
        if (runtime.validLogged < 1000 || (runtime.validLogged % 100) == 0)
        {
            runtime.fileLog->WriteLine(line);
        }
        ++runtime.validLogged;
    }

    return true;
}

static DWORD WINAPI ReceiveWorker(LPVOID)
{
    char buffer[65536];

    for (;;)
    {
        if (InterlockedCompareExchange(&g_running, 1, 1) == 0)
        {
            break;
        }

        fd_set readSet;
        FD_ZERO(&readSet);
        FD_SET(g_client.socket, &readSet);

        timeval timeout;
        timeout.tv_sec = 0;
        timeout.tv_usec = 200000; /* 200 ms */

        int selectResult = select(0, &readSet, NULL, NULL, &timeout);
        if (selectResult == SOCKET_ERROR)
        {
            int errorCode = WSAGetLastError();
            if (InterlockedCompareExchange(&g_running, 1, 1) == 0)
            {
                break;
            }
            wchar_t errorText[256];
            FormatWinsockErrorW(errorCode, errorText,
                                (int)(sizeof(errorText) / sizeof(errorText[0])));
            wchar_t line[512];
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"select 失败:%s。接收线程稍后重试。", errorText);
            ClientLog(g_client, line);
            Sleep(50);
            continue;
        }
        if (selectResult == 0)
        {
            continue; /* 超时,回到循环检查停止标志 */
        }

        sockaddr_in fromAddress;
        int fromLength = sizeof(fromAddress);
        memset(&fromAddress, 0, sizeof(fromAddress));

        int receivedBytes = recvfrom(g_client.socket, buffer, (int)sizeof(buffer), 0,
                                     (sockaddr*)&fromAddress, &fromLength);
        if (receivedBytes == SOCKET_ERROR)
        {
            int errorCode = WSAGetLastError();
            if (errorCode == WSAEWOULDBLOCK)
            {
                continue;
            }
            if (InterlockedCompareExchange(&g_running, 1, 1) == 0)
            {
                break;
            }
            wchar_t errorText[256];
            FormatWinsockErrorW(errorCode, errorText,
                                (int)(sizeof(errorText) / sizeof(errorText[0])));
            wchar_t line[512];
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"recvfrom 失败:%s。接收线程稍后重试。", errorText);
            ClientLog(g_client, line);
            Sleep(50);
            continue;
        }

        /* recvfrom 返回 0 表示收到一个空数据报,同样交给协议校验。 */
        HandleDatagram(g_client, buffer, receivedBytes, fromAddress);
    }

    return 0;
}

4.5.4 CreateClientControls(window, instance)

该函数创建监听 IPv4、端口输入框,“开始监听”“停止监听”按钮,正文显示编辑框、日志编辑框以及“已接收”“序号缺失”“非法报文”等状态标签;每个控件分配唯一 ID。完整原文见 client.cpp。

4.5.5 ClientWindowProc(window, message, wParam, lParam)

窗口过程处理“开始监听”“停止监听”、定时器刷新、自定义日志/正文消息和窗口关闭;开始监听时读取并校验参数、创建套接字并启动接收线程,停止时设置事件、等待线程退出并关闭套接字。完整原文见 client.cpp。

4.5.6 WinMain(instance, ..., showCommand)

WinMain() 注册客户端窗口类、创建窗口和控件、显示窗口并进入消息循环,关闭时释放字体、控件和 Winsock 资源。完整原文见 client.cpp。

client.cpp完整代码如下:

点击展开/收起:client.cpp 完整代码

/*
 * client.cpp —— 基于广播通信模型的客户端(Win32 图形界面)
 * ============================================================================
 * 实验要求:客户端接收服务器广播的“今天是个好日子!”并在本地显示。
 *
 * 本程序的核心网络步骤:
 *   1. WSAStartup 初始化 Winsock 2.2;
 *   2. socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP) 创建 UDP 套接字;
 *   3. setsockopt(SO_REUSEADDR) 允许同一台电脑运行多个客户端实例,
 *      便于“一个服务器广播、多个客户端同时接收”的实验演示;
 *   4. bind 到客户端地址(默认 192.168.50.2)和端口 1145;
 *   5. select 等待数据报,recvfrom 接收后按 common.h 的协议校验;
 *   6. 把 UTF-8 正文转换成宽字符,显示在窗口的“收到的广播消息”区域。
 *
 * 客户端不主动连接服务器。广播是“服务器发、客户端收”的单向数据报通信,
 * 客户端只需要在正确的端口上监听广播地址所在子网的数据报即可。
 *
 * 所有窗口文字使用宽字符,网络正文使用 UTF-8,二者在边界处显式转换,
 * 因此中英文混写不会出现乱码。
 * ============================================================================
 */

#include "common.h"

/* ==========================================================================
 * 一、控件标识符与窗口消息
 * ======================================================================== */

#define IDC_LISTEN_IP 2001      /* 客户端监听 IPv4 输入框 */
#define IDC_PORT 2002           /* 监听端口输入框 */
#define IDC_SHOW_MESSAGES 2003  /* “显示每条广播”复选框 */
#define IDC_START 2004          /* 开始监听按钮 */
#define IDC_STOP 2005           /* 停止监听按钮 */
#define IDC_CLEAR_MESSAGES 2006 /* 清空消息按钮 */
#define IDC_CLEAR_LOG 2007      /* 清空日志按钮 */
#define IDC_MESSAGES 2008       /* 多行只读消息显示框 */
#define IDC_LOG 2009            /* 多行只读运行日志框 */
#define IDC_STATUS 2010         /* 状态标签 */
#define IDC_RECEIVED 2011       /* 已接收计数标签 */
#define IDC_GAPS 2012           /* 序号跳变标签 */
#define IDC_MALFORMED 2013      /* 非法报文标签 */
#define IDC_SOURCE 2014         /* 监听地址标签 */
#define IDC_BYTES 2015          /* 接收字节标签 */
#define IDC_FOOTER 2016         /* 底部提示条 */

/* 工作线程 -> 窗口线程的自定义消息。 */
#define WM_APPEND_LOG (WM_APP + 1)
#define WM_APP_BROADCAST (WM_APP + 2)

static const wchar_t CLIENT_WINDOW_CLASS[] = L"BroadcastClientWindow";
static const wchar_t CLIENT_WINDOW_TITLE[] = L"基于广播通信模型的客户端";

/* ==========================================================================
 * 二、全局状态
 * ======================================================================== */

/*
 * 客户端运行期状态。
 * 接收线程负责更新计数和序号状态,窗口定时器只读计数用于显示。
 * 为了让“显示每条广播”不拖慢接收线程,待显示消息数超过上限时会跳过
 * 部分显示,但接收计数仍然准确。
 */
struct ClientRuntime
{
    SOCKET socket;                          /* 已绑定监听地址的 UDP 套接字 */

    volatile LONG received;                 /* 合法广播包数量 */
    volatile LONG malformed;                /* 非法/无关数据报数量 */
    volatile LONG gaps;                     /* 根据序号推算出的缺失包数 */
    volatile LONG duplicates;               /* 重复或乱序包数量 */
    volatile LONG bytes;                    /* 合法数据报总字节数 */
    volatile LONG displaySkipped;           /* 因界面繁忙而省略显示的数量 */
    volatile LONG pendingDisplay;           /* 已投递但窗口尚未处理的显示消息数 */
    volatile LONG showMessages;             /* 是否逐条显示广播 */
    volatile LONG matchedText;              /* 自动模式下与期望文本一致的包数 */

    unsigned long firstSequence;            /* 首个合法包的序号,0 表示尚未收到 */
    unsigned long lastSequence;             /* 已见过的最大序号 */
    bool hasFirstPayload;                   /* 是否已经保存首包正文 */
    wchar_t firstPayload[BC_MAX_PAYLOAD + 1]; /* 首包正文,供自动测试核对 */

    wchar_t expectedText[2048];             /* 自动模式期望正文 */
    bool hasExpectedText;                   /* 是否启用正文比对 */

    int malformedLogged;                    /* 已经写入日志的非法包条数 */
    int validLogged;                        /* 已经写入日志的合法包条数 */

    HWND notifyWindow;                      /* GUI 模式接收显示消息的窗口 */
    Utf8LogWriter* fileLog;                 /* 自动模式日志文件 */
    wchar_t boundDescription[128];          /* 形如 192.168.50.2:1145 */
};

static ClientRuntime g_client;

static HWND g_window = NULL;
static HWND g_messageEdit = NULL;
static HWND g_logEdit = NULL;
static HWND g_statusLabel = NULL;
static HWND g_receivedLabel = NULL;
static HWND g_gapsLabel = NULL;
static HWND g_malformedLabel = NULL;
static HWND g_sourceLabel = NULL;
static HWND g_bytesLabel = NULL;
static HWND g_footerLabel = NULL;
static HFONT g_uiFont = NULL;
static HFONT g_boldFont = NULL;

static HANDLE g_workerThread = NULL;
static HANDLE g_stopEvent = NULL;
static volatile LONG g_running = 0;
static bool g_hasRun = false;

/* 启动前由命令行参数覆盖的初始值。 */
static wchar_t g_initialListenIp[64] = L"192.168.50.2";
static wchar_t g_initialPort[16] = L"1145";

/* ==========================================================================
 * 三、日志与状态显示
 * ======================================================================== */

/* 统一的客户端日志出口:GUI 用窗口消息,自动模式写 UTF-8 文件。 */
static void ClientLog(ClientRuntime& runtime, const wchar_t* text)
{
    if (text == NULL)
    {
        return;
    }

    wchar_t timeText[32];
    FormatTimeW(timeText, (int)(sizeof(timeText) / sizeof(timeText[0])));

    wchar_t line[2048];
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]), L"[%s] %s", timeText, text);

    if (runtime.notifyWindow != NULL)
    {
        PostWideMessage(runtime.notifyWindow, WM_APPEND_LOG, line);
    }
    else if (runtime.fileLog != NULL)
    {
        runtime.fileLog->WriteLine(line);
    }
}

/* 原子读取计数。 */
static LONG ReadCounter(volatile LONG* counter)
{
    return InterlockedCompareExchange(counter, 0, 0);
}

/* 根据运行状态启用/禁用按钮和参数输入。 */
static void UpdateButtonState(HWND window, bool running)
{
    EnableWindow(GetDlgItem(window, IDC_START), running ? FALSE : TRUE);
    EnableWindow(GetDlgItem(window, IDC_STOP), running ? TRUE : FALSE);
    EnableWindow(GetDlgItem(window, IDC_LISTEN_IP), running ? FALSE : TRUE);
    EnableWindow(GetDlgItem(window, IDC_PORT), running ? FALSE : TRUE);
}

/* 刷新状态标签,由 200 毫秒定时器调用。 */
static void UpdateStatusLabels()
{
    if (g_window == NULL)
    {
        return;
    }

    LONG received = ReadCounter(&g_client.received);
    LONG malformed = ReadCounter(&g_client.malformed);
    LONG gaps = ReadCounter(&g_client.gaps);
    LONG bytes = ReadCounter(&g_client.bytes);
    LONG skipped = ReadCounter(&g_client.displaySkipped);

    if (InterlockedCompareExchange(&g_running, 1, 1) == 1)
    {
        SetWindowTextW(g_statusLabel, L"状态:监听中");
    }
    else
    {
        SetWindowTextW(g_statusLabel, g_hasRun ? L"状态:已停止" : L"状态:未启动");
    }

    wchar_t line[256];
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"已接收:%ld 包", received);
    SetWindowTextW(g_receivedLabel, line);

    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"序号缺失:%ld 包", gaps);
    SetWindowTextW(g_gapsLabel, line);

    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"非法报文:%ld 个", malformed);
    SetWindowTextW(g_malformedLabel, line);

    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"监听地址:%s",
                     g_client.boundDescription[0] != L'\0' ? g_client.boundDescription : L"-");
    SetWindowTextW(g_sourceLabel, line);

    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"接收字节:%ld 字节", bytes);
    SetWindowTextW(g_bytesLabel, line);

    if (InterlockedCompareExchange(&g_running, 1, 1) == 1)
    {
        if (skipped > 0)
        {
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"监听中:等待广播…… 界面繁忙,已省略显示 %ld 条(接收计数不受影响)。",
                             skipped);
        }
        else
        {
            StringCchCopyW(line, sizeof(line) / sizeof(line[0]),
                           L"监听中:等待广播…… 可同时运行多个客户端实例,观察“一对多”广播。");
        }
        SetWindowTextW(g_footerLabel, line);
    }
    else if (g_hasRun)
    {
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"已停止:共接收 %ld 包、%ld 字节;序号缺失 %ld、非法 %ld、重复/乱序 %ld。",
                         received, bytes, gaps, malformed,
                         ReadCounter(&g_client.duplicates));
        SetWindowTextW(g_footerLabel, line);
    }
    else
    {
        SetWindowTextW(g_footerLabel,
                       L"就绪。请先用 TCP-Lab 一键网卡工具配置 192.168.50.1/192.168.50.2,"
                       L"再开始监听。");
    }
}

/* ==========================================================================
 * 四、套接字与接收逻辑
 * ======================================================================== */

/*
 * 创建并绑定客户端接收套接字。
 *
 * SO_REUSEADDR 的作用:
 *   Windows 上多个进程可以同时绑定同一个 UDP 端口(配合 SO_REUSEADDR),
 *   广播数据报会分发给所有绑定该端口的套接字。这样可以在同一台电脑上
 *   启动多个 client.exe,直观演示“服务器一次广播、多个客户端同时收到”。
 *
 * SO_RCVBUF 的作用:
 *   压力测试时服务器可能在很短时间内发送成千上万个数据报。增大接收缓冲区
 *   可以吸收突发流量,减少因应用层来不及 recvfrom 造成的丢包。
 */
static bool OpenClientSocket(const in_addr& listenAddress,
                             unsigned short port,
                             SOCKET* outSocket,
                             unsigned short* outBoundPort,
                             wchar_t* errorText,
                             int errorCapacity)
{
    if (outSocket == NULL || outBoundPort == NULL)
    {
        return false;
    }
    *outSocket = INVALID_SOCKET;

    SOCKET udpSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    if (udpSocket == INVALID_SOCKET)
    {
        wchar_t reason[256];
        FormatWinsockErrorW(WSAGetLastError(), reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));
        StringCchPrintfW(errorText, (size_t)errorCapacity,
                         L"创建 UDP 套接字失败:%s", reason);
        return false;
    }

    int reuseOption = 1;
    if (setsockopt(udpSocket, SOL_SOCKET, SO_REUSEADDR,
                   (const char*)&reuseOption, sizeof(reuseOption)) == SOCKET_ERROR)
    {
        wchar_t reason[256];
        FormatWinsockErrorW(WSAGetLastError(), reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));
        StringCchPrintfW(errorText, (size_t)errorCapacity,
                         L"设置 SO_REUSEADDR 失败:%s", reason);
        closesocket(udpSocket);
        return false;
    }

    /* 4 MB 接收缓冲区;系统可能按策略折半或限制上限,失败不影响接收。 */
    int receiveBufferSize = 4 * 1024 * 1024;
    setsockopt(udpSocket, SOL_SOCKET, SO_RCVBUF,
               (const char*)&receiveBufferSize, sizeof(receiveBufferSize));

    sockaddr_in localAddress;
    memset(&localAddress, 0, sizeof(localAddress));
    localAddress.sin_family = AF_INET;
    localAddress.sin_addr = listenAddress;
    localAddress.sin_port = htons(port);

    if (bind(udpSocket, (const sockaddr*)&localAddress, sizeof(localAddress)) == SOCKET_ERROR)
    {
        int errorCode = WSAGetLastError();
        wchar_t reason[256];
        FormatWinsockErrorW(errorCode, reason,
                            (int)(sizeof(reason) / sizeof(reason[0])));

        wchar_t listenText[32];
        FormatIPv4W(listenAddress, listenText,
                    (int)(sizeof(listenText) / sizeof(listenText[0])));
        if (errorCode == WSAEADDRNOTAVAIL)
        {
            StringCchPrintfW(errorText, (size_t)errorCapacity,
                             L"绑定 %s:%u 失败:%s。本机没有该 IPv4 地址,"
                             L"请先运行 TCP-Lab 一键网卡工具,或把监听地址改为 0.0.0.0。",
                             listenText, (unsigned int)port, reason);
        }
        else if (errorCode == WSAEADDRINUSE)
        {
            StringCchPrintfW(errorText, (size_t)errorCapacity,
                             L"绑定 %s:%u 失败:%s。端口已被其他程序占用;"
                             L"请关闭占用程序,或改用其他端口。",
                             listenText, (unsigned int)port, reason);
        }
        else
        {
            StringCchPrintfW(errorText, (size_t)errorCapacity,
                             L"绑定 %s:%u 失败:%s", listenText,
                             (unsigned int)port, reason);
        }
        closesocket(udpSocket);
        return false;
    }

    sockaddr_in actualLocal;
    int actualLength = sizeof(actualLocal);
    memset(&actualLocal, 0, sizeof(actualLocal));
    if (getsockname(udpSocket, (sockaddr*)&actualLocal, &actualLength) == SOCKET_ERROR)
    {
        memset(&actualLocal, 0, sizeof(actualLocal));
    }

    *outSocket = udpSocket;
    *outBoundPort = ntohs(actualLocal.sin_port);
    return true;
}

/*
 * 处理一个收到的数据报。
 *
 * 处理顺序:
 *   1. 按 common.h 的协议拆包,失败则计入 malformed 并限流写日志;
 *   2. 合法包计入 received 和 bytes;
 *   3. 用序号判断是否缺包、重复或乱序;
 *   4. 把 UTF-8 正文转换为宽字符;
 *   5. GUI 模式投递到消息显示框,自动模式写入日志文件。
 */
static bool HandleDatagram(ClientRuntime& runtime,
                           const char* data,
                           int length,
                           const sockaddr_in& from)
{
    BroadcastPacket packet;
    int parseResult = ParseBroadcastPacket(data, length, &packet);
    if (parseResult != BC_PARSE_OK)
    {
        InterlockedIncrement(&runtime.malformed);

        if (runtime.malformedLogged < 10)
        {
            wchar_t fromText[32];
            FormatIPv4W(from.sin_addr, fromText,
                        (int)(sizeof(fromText) / sizeof(fromText[0])));
            wchar_t line[512];
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"丢弃无效数据报:%s(来自 %s:%u,长度 %d 字节)。",
                             BroadcastParseErrorText(parseResult), fromText,
                             (unsigned int)ntohs(from.sin_port), length);
            ClientLog(runtime, line);
            ++runtime.malformedLogged;
        }
        return false;
    }

    InterlockedIncrement(&runtime.received);
    InterlockedExchangeAdd(&runtime.bytes, (LONG)length);

    /*
     * 序号分析:
     *   firstSequence == 0 表示还没收到过合法包;
     *   新序号 == lastSequence + 1 表示连续;
     *   新序号更大且不连续,说明中间的数据报丢失;
     *   新序号不大于 lastSequence,说明重复或乱序。
     * UDP 广播不保证顺序,这个统计只用于实验分析,不影响消息显示。
     */
    if (runtime.firstSequence == 0)
    {
        runtime.firstSequence = packet.sequence;
        runtime.lastSequence = packet.sequence;

        if (!runtime.hasFirstPayload)
        {
            char payloadCopy[BC_MAX_PAYLOAD + 1];
            memcpy(payloadCopy, packet.payload, (size_t)packet.payloadLength);
            payloadCopy[packet.payloadLength] = '\0';
            Utf8ToWide(payloadCopy, runtime.firstPayload,
                       (int)(sizeof(runtime.firstPayload) / sizeof(runtime.firstPayload[0])));
            runtime.hasFirstPayload = true;
        }

        wchar_t fromText[32];
        FormatIPv4W(from.sin_addr, fromText,
                    (int)(sizeof(fromText) / sizeof(fromText[0])));
        wchar_t line[512];
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"收到首个广播包:来自 %s:%u,序号 %lu,正文长度 %d 字节。",
                         fromText, (unsigned int)ntohs(from.sin_port),
                         packet.sequence, packet.payloadLength);
        ClientLog(runtime, line);
    }
    else if (packet.sequence > runtime.lastSequence)
    {
        if (packet.sequence > runtime.lastSequence + 1)
        {
            unsigned long missing = packet.sequence - runtime.lastSequence - 1;
            InterlockedExchangeAdd(&runtime.gaps, (LONG)missing);

            wchar_t line[512];
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"序号不连续:上一包 %lu,本包 %lu,估算缺失 %lu 包。",
                             runtime.lastSequence, packet.sequence, missing);
            ClientLog(runtime, line);
        }
        runtime.lastSequence = packet.sequence;
    }
    else
    {
        /* 重复包(序号相等)或乱序包(序号更小)。 */
        InterlockedIncrement(&runtime.duplicates);
    }

    /* 正文不是以 '\0' 结尾的网络数据,先复制到本地缓冲区再转换。 */
    char payloadCopy[BC_MAX_PAYLOAD + 1];
    memcpy(payloadCopy, packet.payload, (size_t)packet.payloadLength);
    payloadCopy[packet.payloadLength] = '\0';

    wchar_t payloadWide[BC_MAX_PAYLOAD + 1];
    Utf8ToWide(payloadCopy, payloadWide,
               (int)(sizeof(payloadWide) / sizeof(payloadWide[0])));

    if (runtime.hasExpectedText && wcscmp(payloadWide, runtime.expectedText) == 0)
    {
        InterlockedIncrement(&runtime.matchedText);
    }

    wchar_t timeText[32];
    FormatTimeW(timeText, (int)(sizeof(timeText) / sizeof(timeText[0])));
    wchar_t fromText[32];
    FormatIPv4W(from.sin_addr, fromText,
                (int)(sizeof(fromText) / sizeof(fromText[0])));

    wchar_t line[2048];
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"[%s] 来自 %s:%u  序号 %lu  %s",
                     timeText, fromText, (unsigned int)ntohs(from.sin_port),
                     packet.sequence, payloadWide);

    if (runtime.notifyWindow != NULL)
    {
        if (ReadCounter(&runtime.showMessages) != 0)
        {
            /*
             * 显示节流:如果窗口线程处理不过来(待显示消息超过 300 条),
             * 就跳过本条显示,只保留统计。否则高速广播会把消息循环压垮。
             */
            if (ReadCounter(&runtime.pendingDisplay) < 300)
            {
                wchar_t* copy = DuplicateWideString(line);
                if (copy != NULL)
                {
                    InterlockedIncrement(&runtime.pendingDisplay);
                    if (!PostMessageW(runtime.notifyWindow, WM_APP_BROADCAST, 0,
                                      (LPARAM)copy))
                    {
                        InterlockedDecrement(&runtime.pendingDisplay);
                        free(copy);
                    }
                }
            }
            else
            {
                LONG skipped = InterlockedIncrement(&runtime.displaySkipped);
                if ((skipped % 500) == 0)
                {
                    wchar_t warning[256];
                    StringCchPrintfW(warning, sizeof(warning) / sizeof(warning[0]),
                                     L"界面繁忙,已省略显示 %ld 条广播(接收计数仍在增加)。",
                                     skipped);
                    ClientLog(runtime, warning);
                }
            }
        }
    }
    else if (runtime.fileLog != NULL)
    {
        /*
         * 自动模式日志:前 1000 条逐条记录,之后每 100 条记录一条,
         * 既保留正文样本,又避免日志文件过大影响测试。
         */
        if (runtime.validLogged < 1000 || (runtime.validLogged % 100) == 0)
        {
            runtime.fileLog->WriteLine(line);
        }
        ++runtime.validLogged;
    }

    return true;
}

/*
 * 客户端接收线程。
 * select 每 200 毫秒返回一次,既能及时接收广播,也能定期检查停止标志。
 * 线程只做接收、解析和 PostMessage,不直接操作窗口控件。
 */
static DWORD WINAPI ReceiveWorker(LPVOID)
{
    char buffer[65536];

    for (;;)
    {
        if (InterlockedCompareExchange(&g_running, 1, 1) == 0)
        {
            break;
        }

        fd_set readSet;
        FD_ZERO(&readSet);
        FD_SET(g_client.socket, &readSet);

        timeval timeout;
        timeout.tv_sec = 0;
        timeout.tv_usec = 200000; /* 200 ms */

        int selectResult = select(0, &readSet, NULL, NULL, &timeout);
        if (selectResult == SOCKET_ERROR)
        {
            int errorCode = WSAGetLastError();
            if (InterlockedCompareExchange(&g_running, 1, 1) == 0)
            {
                break;
            }
            wchar_t errorText[256];
            FormatWinsockErrorW(errorCode, errorText,
                                (int)(sizeof(errorText) / sizeof(errorText[0])));
            wchar_t line[512];
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"select 失败:%s。接收线程稍后重试。", errorText);
            ClientLog(g_client, line);
            Sleep(50);
            continue;
        }
        if (selectResult == 0)
        {
            continue; /* 超时,回到循环检查停止标志 */
        }

        sockaddr_in fromAddress;
        int fromLength = sizeof(fromAddress);
        memset(&fromAddress, 0, sizeof(fromAddress));

        int receivedBytes = recvfrom(g_client.socket, buffer, (int)sizeof(buffer), 0,
                                     (sockaddr*)&fromAddress, &fromLength);
        if (receivedBytes == SOCKET_ERROR)
        {
            int errorCode = WSAGetLastError();
            if (errorCode == WSAEWOULDBLOCK)
            {
                continue;
            }
            if (InterlockedCompareExchange(&g_running, 1, 1) == 0)
            {
                break;
            }
            wchar_t errorText[256];
            FormatWinsockErrorW(errorCode, errorText,
                                (int)(sizeof(errorText) / sizeof(errorText[0])));
            wchar_t line[512];
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"recvfrom 失败:%s。接收线程稍后重试。", errorText);
            ClientLog(g_client, line);
            Sleep(50);
            continue;
        }

        /* recvfrom 返回 0 表示收到一个空数据报,同样交给协议校验。 */
        HandleDatagram(g_client, buffer, receivedBytes, fromAddress);
    }

    return 0;
}

/* ==========================================================================
 * 五、启动与停止
 * ======================================================================== */

/* 从界面读取监听地址和端口,创建套接字并启动接收线程。 */
static bool StartListening(HWND window)
{
    if (InterlockedCompareExchange(&g_running, 1, 0) != 0)
    {
        return false;
    }

    wchar_t listenText[64];
    wchar_t portText[16];
    GetControlTextW(window, IDC_LISTEN_IP, listenText,
                    (int)(sizeof(listenText) / sizeof(listenText[0])));
    GetControlTextW(window, IDC_PORT, portText,
                    (int)(sizeof(portText) / sizeof(portText[0])));
    TrimW(listenText);
    if (listenText[0] == L'\0')
    {
        StringCchCopyW(listenText, sizeof(listenText) / sizeof(listenText[0]), L"0.0.0.0");
    }

    in_addr listenAddress;
    if (!ParseIPv4TextW(listenText, &listenAddress))
    {
        MessageBoxW(window, L"监听 IPv4 地址格式无效。\n"
                            L"示例:192.168.50.2;也可以填写 0.0.0.0 接收所有网卡的广播。",
                    L"参数错误", MB_OK | MB_ICONWARNING);
        InterlockedExchange(&g_running, 0);
        return false;
    }

    int port = _wtoi(portText);
    if (port < 1 || port > 65535)
    {
        MessageBoxW(window, L"端口必须在 1 到 65535 之间。", L"参数错误",
                    MB_OK | MB_ICONWARNING);
        InterlockedExchange(&g_running, 0);
        return false;
    }

    SOCKET udpSocket = INVALID_SOCKET;
    unsigned short boundPort = 0;
    wchar_t errorText[512];
    if (!OpenClientSocket(listenAddress, (unsigned short)port, &udpSocket,
                          &boundPort, errorText,
                          (int)(sizeof(errorText) / sizeof(errorText[0]))))
    {
        MessageBoxW(window, errorText, L"启动失败", MB_OK | MB_ICONERROR);
        InterlockedExchange(&g_running, 0);
        return false;
    }

    HANDLE stopEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
    if (stopEvent == NULL)
    {
        closesocket(udpSocket);
        MessageBoxW(window, L"创建停止事件失败。", L"启动失败",
                    MB_OK | MB_ICONERROR);
        InterlockedExchange(&g_running, 0);
        return false;
    }

    /* 重置运行期状态,再填入本次监听的参数。 */
    memset(&g_client, 0, sizeof(g_client));
    g_client.socket = udpSocket;
    g_client.notifyWindow = window;
    g_client.fileLog = NULL;
    g_client.showMessages = IsCheckBoxChecked(window, IDC_SHOW_MESSAGES) ? 1 : 0;

    wchar_t listenIpText[32];
    FormatIPv4W(listenAddress, listenIpText,
                (int)(sizeof(listenIpText) / sizeof(listenIpText[0])));
    StringCchPrintfW(g_client.boundDescription,
                     sizeof(g_client.boundDescription) / sizeof(g_client.boundDescription[0]),
                     L"%s:%u", listenIpText, (unsigned int)boundPort);

    g_stopEvent = stopEvent;
    InterlockedExchange(&g_running, 1);

    g_workerThread = CreateThread(NULL, 0, ReceiveWorker, NULL,
                                  CREATE_SUSPENDED, NULL);
    if (g_workerThread == NULL)
    {
        InterlockedExchange(&g_running, 0);
        closesocket(udpSocket);
        g_client.socket = INVALID_SOCKET;
        CloseHandle(stopEvent);
        g_stopEvent = NULL;
        MessageBoxW(window, L"创建接收线程失败。", L"启动失败",
                    MB_OK | MB_ICONERROR);
        return false;
    }

    g_hasRun = true;
    UpdateButtonState(window, true);
    SetWindowTextW(g_statusLabel, L"状态:监听中");

    wchar_t line[1024];
    if (listenAddress.s_addr == 0)
    {
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"开始监听 0.0.0.0:%u(所有网卡);等待服务器广播……",
                         (unsigned int)boundPort);
    }
    else
    {
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"开始监听 %s;等待服务器广播……", g_client.boundDescription);
    }
    ClientLog(g_client, line);

    /* 先写日志再恢复接收线程,保证日志顺序为“开始监听”在前。 */
    ResumeThread(g_workerThread);

    return true;
}

/* 停止接收线程并释放套接字。先停线程再关套接字,避免使用已关闭的句柄。 */
static void StopListening()
{
    bool wasRunning = InterlockedCompareExchange(&g_running, 1, 1) == 1;

    if (wasRunning && g_stopEvent != NULL)
    {
        SetEvent(g_stopEvent);
    }

    if (g_workerThread != NULL)
    {
        DWORD waitResult = WaitForSingleObject(g_workerThread, 5000);
        if (waitResult == WAIT_TIMEOUT)
        {
            TerminateThread(g_workerThread, 0);
            ClientLog(g_client, L"警告:接收线程未在 5 秒内退出,已强制终止。");
        }
        CloseHandle(g_workerThread);
        g_workerThread = NULL;
    }

    if (g_client.socket != INVALID_SOCKET)
    {
        closesocket(g_client.socket);
        g_client.socket = INVALID_SOCKET;
    }
    if (g_stopEvent != NULL)
    {
        CloseHandle(g_stopEvent);
        g_stopEvent = NULL;
    }

    InterlockedExchange(&g_running, 0);

    if (!wasRunning && !g_hasRun)
    {
        return;
    }

    if (wasRunning)
    {
        LONG received = ReadCounter(&g_client.received);
        LONG malformed = ReadCounter(&g_client.malformed);
        LONG gaps = ReadCounter(&g_client.gaps);
        LONG duplicates = ReadCounter(&g_client.duplicates);
        LONG bytes = ReadCounter(&g_client.bytes);
        wchar_t line[512];
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"已停止监听:接收 %ld 包、%ld 字节;序号缺失 %ld、"
                         L"非法 %ld、重复/乱序 %ld。",
                         received, bytes, gaps, malformed, duplicates);
        ClientLog(g_client, line);
    }

    if (g_window != NULL)
    {
        UpdateButtonState(g_window, false);
        SetWindowTextW(g_statusLabel, L"状态:已停止");
        UpdateStatusLabels();
    }
}

/* ==========================================================================
 * 六、界面创建与窗口过程
 * ======================================================================== */

/* 创建客户端窗口的全部控件。 */
static bool CreateClientControls(HWND window, HINSTANCE instance)
{
    (void)instance;

    g_uiFont = CreateUiFont(14, false, L"Microsoft YaHei UI");
    g_boldFont = CreateUiFont(15, true, L"Microsoft YaHei UI");

    CreateControlW(window, L"BUTTON", L"接收参数",
                   BS_GROUPBOX, 0, 14, 10, 872, 176, 0, g_uiFont);

    CreateControlW(window, L"STATIC", L"客户端监听 IPv4:",
                   SS_LEFT | SS_CENTERIMAGE, 0, 28, 36, 100, 22, 0, g_uiFont);
    CreateControlW(window, L"EDIT", g_initialListenIp,
                   WS_BORDER | ES_AUTOHSCROLL, WS_EX_CLIENTEDGE,
                   132, 34, 170, 26, IDC_LISTEN_IP, g_uiFont);

    CreateControlW(window, L"STATIC", L"端口:",
                   SS_LEFT | SS_CENTERIMAGE, 0, 316, 36, 44, 22, 0, g_uiFont);
    CreateControlW(window, L"EDIT", g_initialPort,
                   WS_BORDER | ES_NUMBER, WS_EX_CLIENTEDGE,
                   364, 34, 80, 26, IDC_PORT, g_uiFont);

    HWND showCheckbox = CreateControlW(window, L"BUTTON", L"显示每条广播",
                                       BS_AUTOCHECKBOX, 0, 460, 38, 160, 22,
                                       IDC_SHOW_MESSAGES, g_uiFont);
    if (showCheckbox != NULL)
    {
        SendMessageW(showCheckbox, BM_SETCHECK, BST_CHECKED, 0);
    }

    CreateControlW(window, L"STATIC", L"端口需与服务器一致(默认 1145)",
                   SS_LEFT | SS_CENTERIMAGE, 0, 620, 36, 250, 22, 0, g_uiFont);

    CreateControlW(window, L"BUTTON", L"开始监听",
                   BS_PUSHBUTTON, 0, 132, 76, 100, 30, IDC_START, g_boldFont);
    CreateControlW(window, L"BUTTON", L"停止监听",
                   BS_PUSHBUTTON, 0, 240, 76, 100, 30, IDC_STOP, g_uiFont);
    CreateControlW(window, L"BUTTON", L"清空消息",
                   BS_PUSHBUTTON, 0, 348, 76, 110, 30, IDC_CLEAR_MESSAGES, g_uiFont);
    CreateControlW(window, L"BUTTON", L"清空日志",
                   BS_PUSHBUTTON, 0, 466, 76, 100, 30, IDC_CLEAR_LOG, g_uiFont);

    g_statusLabel = CreateControlW(window, L"STATIC", L"状态:未启动",
                                   SS_LEFT | SS_CENTERIMAGE, 0, 28, 118, 250, 22,
                                   IDC_STATUS, g_uiFont);
    g_receivedLabel = CreateControlW(window, L"STATIC", L"已接收:0 包",
                                     SS_LEFT | SS_CENTERIMAGE, 0, 290, 118, 190, 22,
                                     IDC_RECEIVED, g_uiFont);
    g_gapsLabel = CreateControlW(window, L"STATIC", L"序号缺失:0 包",
                                 SS_LEFT | SS_CENTERIMAGE, 0, 490, 118, 100, 22,
                                 IDC_GAPS, g_uiFont);
    g_malformedLabel = CreateControlW(window, L"STATIC", L"非法报文:0 个",
                                      SS_LEFT | SS_CENTERIMAGE, 0, 600, 118, 120, 22,
                                      IDC_MALFORMED, g_uiFont);

    g_sourceLabel = CreateControlW(window, L"STATIC", L"监听地址:-",
                                   SS_LEFT | SS_CENTERIMAGE, 0, 28, 146, 420, 22,
                                   IDC_SOURCE, g_uiFont);
    g_bytesLabel = CreateControlW(window, L"STATIC", L"接收字节:0 字节",
                                  SS_LEFT | SS_CENTERIMAGE, 0, 460, 146, 300, 22,
                                  IDC_BYTES, g_uiFont);

    CreateControlW(window, L"BUTTON", L"收到的广播消息",
                   BS_GROUPBOX, 0, 14, 194, 872, 236, 0, g_uiFont);

    g_messageEdit = CreateControlW(window, L"EDIT", L"",
                                   WS_BORDER | ES_MULTILINE | ES_AUTOVSCROLL |
                                       ES_READONLY | WS_VSCROLL,
                                   WS_EX_CLIENTEDGE, 28, 220, 844, 196,
                                   IDC_MESSAGES, g_uiFont);
    if (g_messageEdit != NULL)
    {
        SendMessageW(g_messageEdit, EM_SETLIMITTEXT, EDIT_TEXT_LIMIT, 0);
    }

    CreateControlW(window, L"BUTTON", L"运行日志",
                   BS_GROUPBOX, 0, 14, 438, 872, 156, 0, g_uiFont);

    g_logEdit = CreateControlW(window, L"EDIT", L"",
                               WS_BORDER | ES_MULTILINE | ES_AUTOVSCROLL |
                                   ES_READONLY | WS_VSCROLL,
                               WS_EX_CLIENTEDGE, 28, 464, 844, 116,
                               IDC_LOG, g_uiFont);
    if (g_logEdit != NULL)
    {
        SendMessageW(g_logEdit, EM_SETLIMITTEXT, EDIT_TEXT_LIMIT, 0);
    }

    g_footerLabel = CreateControlW(window, L"STATIC",
                                   L"就绪。请先用 TCP-Lab 一键网卡工具配置 192.168.50.1/192.168.50.2,"
                                   L"再开始监听。",
                                   SS_LEFT | SS_CENTERIMAGE | SS_SUNKEN, 0,
                                   14, 602, 872, 24, IDC_FOOTER, g_uiFont);

    SetWindowTextW(window, CLIENT_WINDOW_TITLE);
    UpdateButtonState(window, false);
    UpdateStatusLabels();
    return true;
}

/* 客户端窗口过程。 */
static LRESULT CALLBACK ClientWindowProc(HWND window, UINT message,
                                         WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
        return CreateClientControls(window, (HINSTANCE)GetWindowLongPtrW(window, GWLP_HINSTANCE))
                   ? 0
                   : -1;

    case WM_COMMAND:
        switch (LOWORD(wParam))
        {
        case IDC_START:
            StartListening(window);
            return 0;

        case IDC_STOP:
            StopListening();
            return 0;

        case IDC_CLEAR_MESSAGES:
            if (g_messageEdit != NULL)
            {
                SetWindowTextW(g_messageEdit, L"");
            }
            return 0;

        case IDC_CLEAR_LOG:
            if (g_logEdit != NULL)
            {
                SetWindowTextW(g_logEdit, L"");
            }
            return 0;

        case IDC_SHOW_MESSAGES:
            InterlockedExchange(&g_client.showMessages,
                                IsCheckBoxChecked(window, IDC_SHOW_MESSAGES) ? 1 : 0);
            return 0;

        default:
            break;
        }
        break;

    case WM_TIMER:
        UpdateStatusLabels();
        return 0;

    case WM_APPEND_LOG:
    {
        wchar_t* text = (wchar_t*)lParam;
        if (text != NULL)
        {
            AppendEditLineW(g_logEdit, text);
            free(text);
        }
        return 0;
    }

    case WM_APP_BROADCAST:
    {
        wchar_t* text = (wchar_t*)lParam;
        if (text != NULL)
        {
            AppendEditLineW(g_messageEdit, text);
            free(text);
        }
        /* 与 HandleDatagram 中的 InterlockedIncrement 配对。 */
        if (ReadCounter(&g_client.pendingDisplay) > 0)
        {
            InterlockedDecrement(&g_client.pendingDisplay);
        }
        return 0;
    }

    case WM_CLOSE:
        StopListening();
        DestroyWindow(window);
        return 0;

    case WM_DESTROY:
        KillTimer(window, 1);
        if (g_uiFont != NULL)
        {
            DeleteObject(g_uiFont);
            g_uiFont = NULL;
        }
        if (g_boldFont != NULL)
        {
            DeleteObject(g_boldFont);
            g_boldFont = NULL;
        }
        WSACleanup();
        PostQuitMessage(0);
        return 0;

    default:
        break;
    }

    return DefWindowProcW(window, message, wParam, lParam);
}

/* ==========================================================================
 * 七、自动测试模式(无窗口)
 * ======================================================================== */

/* 自动模式早期错误:写一份最小统计文件。 */
static void WriteClientErrorStats(const wchar_t* statsPath, const char* reason, int exitCode)
{
    char json[1024];
    StringCchPrintfA(json, sizeof(json),
                     "{\n"
                     "  \"role\": \"client\",\n"
                     "  \"received\": 0,\n"
                     "  \"malformed\": 0,\n"
                     "  \"gaps\": 0,\n"
                     "  \"duplicates\": 0,\n"
                     "  \"bytes\": 0,\n"
                     "  \"elapsed_ms\": 0,\n"
                     "  \"first_sequence\": 0,\n"
                     "  \"last_sequence\": 0,\n"
                     "  \"matched_text\": 0,\n"
                     "  \"expect\": 0,\n"
                     "  \"strict\": 0,\n"
                     "  \"exit_code\": %d,\n"
                     "  \"error\": \"%s\"\n"
                     "}\n",
                     exitCode, reason != NULL ? reason : "");
    WriteAsciiFile(statsPath, json);
}

/* 自动模式结束后写统计 JSON。 */
static void WriteClientStats(const wchar_t* statsPath,
                             ClientRuntime& runtime,
                             unsigned long elapsedMs,
                             int expect,
                             bool strict,
                             int exitCode,
                             const char* errorText)
{
    LONG received = ReadCounter(&runtime.received);
    LONG malformed = ReadCounter(&runtime.malformed);
    LONG gaps = ReadCounter(&runtime.gaps);
    LONG duplicates = ReadCounter(&runtime.duplicates);
    LONG bytes = ReadCounter(&runtime.bytes);
    LONG matched = ReadCounter(&runtime.matchedText);

    char json[2048];
    StringCchPrintfA(json, sizeof(json),
                     "{\n"
                     "  \"role\": \"client\",\n"
                     "  \"received\": %ld,\n"
                     "  \"malformed\": %ld,\n"
                     "  \"gaps\": %ld,\n"
                     "  \"duplicates\": %ld,\n"
                     "  \"bytes\": %ld,\n"
                     "  \"elapsed_ms\": %lu,\n"
                     "  \"first_sequence\": %lu,\n"
                     "  \"last_sequence\": %lu,\n"
                     "  \"matched_text\": %ld,\n"
                     "  \"expect\": %d,\n"
                     "  \"strict\": %d,\n"
                     "  \"exit_code\": %d,\n"
                     "  \"error\": \"%s\"\n"
                     "}\n",
                     received, malformed, gaps, duplicates, bytes, elapsedMs,
                     runtime.firstSequence, runtime.lastSequence, matched,
                     expect, strict ? 1 : 0, exitCode,
                     errorText != NULL ? errorText : "");
    WriteAsciiFile(statsPath, json);
}

/*
 * 自动接收模式,供 stress_test.py 调用。
 *
 * 示例:
 *   client.exe --auto --listen 0.0.0.0 --port 11545 --duration 15 \
 *              --expect 20000 --strict --expect-text "今天是个好日子!" \
 *              --stats client_stats.json --log client.log
 *
 * 退出码:0 成功;2 参数/套接字错误;3 接收数量未达到期望或超时。
 */
static int RunAutoClient(const CommandLineArgs& args)
{
    wchar_t logPath[1024];
    wchar_t statsPath[1024];
    StringCchCopyW(logPath, sizeof(logPath) / sizeof(logPath[0]),
                   args.Value(L"--log", L"client_auto.log"));
    StringCchCopyW(statsPath, sizeof(statsPath) / sizeof(statsPath[0]),
                   args.Value(L"--stats", L"client_auto_stats.json"));

    const wchar_t* listenTextW = args.Value(L"--listen", L"0.0.0.0");
    const wchar_t* expectTextW = args.Value(L"--expect-text", NULL);
    int port = args.IntValue(L"--port", (int)DEFAULT_PORT);
    int durationSeconds = args.IntValue(L"--duration", 10);
    int expect = args.IntValue(L"--expect", 0);
    bool strict = args.Has(L"--strict");

    Utf8LogWriter logFile;
    if (!logFile.Open(logPath))
    {
        WriteClientErrorStats(statsPath, "log open failed", 3);
        return 3;
    }

    ClientRuntime runtime;
    memset(&runtime, 0, sizeof(runtime));
    runtime.socket = INVALID_SOCKET;
    runtime.fileLog = &logFile;
    runtime.notifyWindow = NULL;

    logFile.WriteLine(L"广播客户端自动模式启动。");
    logFile.WriteLine(L"说明:本模式不显示窗口,用于批量压力测试。");

    if (port < 1 || port > 65535 || durationSeconds < 1 || expect < 0)
    {
        logFile.WriteLine(L"参数错误:端口 1~65535,duration 必须大于 0,expect 不能为负数。");
        WriteClientErrorStats(statsPath, "invalid arguments", 2);
        logFile.Close();
        return 2;
    }

    in_addr listenAddress;
    if (!ParseIPv4TextW(listenTextW, &listenAddress))
    {
        logFile.WriteLine(L"参数错误:监听 IPv4 地址格式无效。");
        WriteClientErrorStats(statsPath, "invalid ipv4 address", 2);
        logFile.Close();
        return 2;
    }

    if (expectTextW != NULL)
    {
        StringCchCopyW(runtime.expectedText,
                       sizeof(runtime.expectedText) / sizeof(runtime.expectedText[0]),
                       expectTextW);
        runtime.hasExpectedText = true;
    }

    if (!InitializeWinsock())
    {
        logFile.WriteLine(L"Winsock 初始化失败。");
        WriteClientErrorStats(statsPath, "winsock init failed", 2);
        logFile.Close();
        return 2;
    }

    SOCKET udpSocket = INVALID_SOCKET;
    unsigned short boundPort = 0;
    wchar_t errorText[512];
    if (!OpenClientSocket(listenAddress, (unsigned short)port, &udpSocket,
                          &boundPort, errorText,
                          (int)(sizeof(errorText) / sizeof(errorText[0]))))
    {
        logFile.WriteLine(errorText);
        WriteClientErrorStats(statsPath, "open socket failed", 2);
        WSACleanup();
        logFile.Close();
        return 2;
    }

    runtime.socket = udpSocket;

    wchar_t listenIpText[32];
    FormatIPv4W(listenAddress, listenIpText,
                (int)(sizeof(listenIpText) / sizeof(listenIpText[0])));
    StringCchPrintfW(runtime.boundDescription,
                     sizeof(runtime.boundDescription) / sizeof(runtime.boundDescription[0]),
                     L"%s:%u", listenIpText, (unsigned int)boundPort);

    wchar_t line[1024];
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"自动模式参数:监听 %s,端口 %u,时长 %d 秒,期望 %d 包,严格模式 %d。",
                     runtime.boundDescription, (unsigned int)port,
                     durationSeconds, expect, strict ? 1 : 0);
    logFile.WriteLine(line);
    if (runtime.hasExpectedText)
    {
        StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                         L"正文比对基准:%s", runtime.expectedText);
        logFile.WriteLine(line);
    }

    unsigned long started = NowMilliseconds();
    unsigned long durationMs = (durationSeconds > 0)
                                   ? (unsigned long)durationSeconds * 1000UL
                                   : 0;
    int exitReason = 0; /* 0=未知,1=到达时长,2=达到期望包数 */
    unsigned long lastStatsWrite = started;
    char buffer[65536];
    for (;;)
    {
        if (durationMs > 0 && (NowMilliseconds() - started) >= durationMs)
        {
            exitReason = 1;
            break;
        }
        if (expect > 0 && ReadCounter(&runtime.received) >= expect)
        {
            exitReason = 2;
            break;
        }

        /*
         * 每约 1 秒写一次当前统计,供长时间稳定性测试在客户端运行期间读取
         * received/malformed 等计数,观察丢包是否随时间累积。退出时会再写
         * 一次带真实 exit_code 的最终版本。
         */
        unsigned long statsNow = NowMilliseconds();
        if (statsNow - lastStatsWrite >= 1000)
        {
            WriteClientStats(statsPath, runtime, statsNow - started,
                             expect, strict, 0, "");
            lastStatsWrite = statsNow;
        }

        fd_set readSet;
        FD_ZERO(&readSet);
        FD_SET(runtime.socket, &readSet);

        timeval timeout;
        timeout.tv_sec = 0;
        timeout.tv_usec = 100000; /* 100 ms,保证能及时检查时长和期望包数 */

        int selectResult = select(0, &readSet, NULL, NULL, &timeout);
        if (selectResult == SOCKET_ERROR)
        {
            wchar_t reason[256];
            FormatWinsockErrorW(WSAGetLastError(), reason,
                                (int)(sizeof(reason) / sizeof(reason[0])));
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"select 失败:%s", reason);
            logFile.WriteLine(line);
            Sleep(50);
            continue;
        }
        if (selectResult == 0)
        {
            continue;
        }

        sockaddr_in fromAddress;
        int fromLength = sizeof(fromAddress);
        memset(&fromAddress, 0, sizeof(fromAddress));
        int receivedBytes = recvfrom(runtime.socket, buffer, (int)sizeof(buffer), 0,
                                     (sockaddr*)&fromAddress, &fromLength);
        if (receivedBytes == SOCKET_ERROR)
        {
            int errorCode = WSAGetLastError();
            if (errorCode == WSAEWOULDBLOCK)
            {
                continue;
            }
            wchar_t reason[256];
            FormatWinsockErrorW(errorCode, reason,
                                (int)(sizeof(reason) / sizeof(reason[0])));
            StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                             L"recvfrom 失败:%s", reason);
            logFile.WriteLine(line);
            Sleep(50);
            continue;
        }

        HandleDatagram(runtime, buffer, receivedBytes, fromAddress);
    }

    unsigned long elapsed = NowMilliseconds() - started;
    LONG received = ReadCounter(&runtime.received);
    LONG malformed = ReadCounter(&runtime.malformed);
    LONG gaps = ReadCounter(&runtime.gaps);
    LONG duplicates = ReadCounter(&runtime.duplicates);
    LONG bytes = ReadCounter(&runtime.bytes);
    LONG matched = ReadCounter(&runtime.matchedText);

    bool success = true;
    if (expect > 0)
    {
        success = strict ? (received == expect) : (received >= expect);
    }
    if (success && runtime.hasExpectedText && matched != received)
    {
        success = false; /* 收到的正文与期望不一致 */
    }
    if (received == 0 && expect > 0)
    {
        success = false;
    }

    int exitCode = success ? 0 : 3;
    const char* errorTextA = success ? "" : "receive count or payload mismatch";
    WriteClientStats(statsPath, runtime, elapsed, expect, strict, exitCode, errorTextA);

    const wchar_t* reasonText = (exitReason == 2)
                                    ? L"达到期望包数"
                                    : (exitReason == 1 ? L"到达运行时长" : L"循环结束");
    StringCchPrintfW(line, sizeof(line) / sizeof(line[0]),
                     L"自动模式结束(%s):接收 %ld 包、%ld 字节;非法 %ld、序号缺失 %ld、"
                     L"重复/乱序 %ld、正文匹配 %ld,耗时 %lu ms。",
                     reasonText, received, bytes, malformed, gaps, duplicates,
                     matched, elapsed);
    logFile.WriteLine(line);

    closesocket(runtime.socket);
    runtime.socket = INVALID_SOCKET;
    WSACleanup();
    logFile.Close();
    return exitCode;
}

/* ==========================================================================
 * 八、程序入口
 * ======================================================================== */

static const wchar_t CLIENT_USAGE[] =
    L"基于广播通信模型的客户端\n\n"
    L"图形界面(默认):\n"
    L"  client.exe [--listen 192.168.50.2] [--port 1145]\n\n"
    L"自动压力测试模式(无窗口):\n"
    L"  client.exe --auto --listen 0.0.0.0 --port 11545 --duration 15\n"
    L"             --expect 20000 --strict --expect-text \"今天是个好日子!\"\n"
    L"             --stats client_stats.json --log client.log\n\n"
    L"参数说明:\n"
    L"  --auto         不创建窗口,直接接收并写统计文件\n"
    L"  --duration     最长运行秒数(必须大于 0)\n"
    L"  --expect       期望收到的合法包数;达到后提前结束\n"
    L"  --strict       要求接收数严格等于 --expect\n"
    L"  --expect-text  逐包比对的 UTF-8 正文,用于验证中文内容\n"
    L"  --stats        统计 JSON 输出路径\n"
    L"  --log          UTF-8 日志输出路径\n";

int WINAPI WinMain(HINSTANCE instance, HINSTANCE previousInstance,
                   LPSTR commandLine, int showCommand)
{
    (void)previousInstance;
    (void)commandLine;

    EnableDpiAwareness();

    /* 未启动时套接字必须是 INVALID_SOCKET,避免关闭未创建的句柄。 */
    memset(&g_client, 0, sizeof(g_client));
    g_client.socket = INVALID_SOCKET;

    CommandLineArgs args;
    LoadCommandLine(&args);

    if (args.Has(L"--help") || args.Has(L"/?"))
    {
        MessageBoxW(NULL, CLIENT_USAGE, L"客户端使用说明", MB_OK | MB_ICONINFORMATION);
        FreeCommandLine(&args);
        return 0;
    }

    if (args.Has(L"--auto"))
    {
        int result = RunAutoClient(args);
        FreeCommandLine(&args);
        return result;
    }

    StringCchCopyW(g_initialListenIp,
                   sizeof(g_initialListenIp) / sizeof(g_initialListenIp[0]),
                   DEFAULT_CLIENT_IP_W);
    StringCchCopyW(g_initialPort, sizeof(g_initialPort) / sizeof(g_initialPort[0]), L"1145");

    const wchar_t* value = args.Value(L"--listen", NULL);
    if (value != NULL)
    {
        StringCchCopyW(g_initialListenIp,
                       sizeof(g_initialListenIp) / sizeof(g_initialListenIp[0]), value);
    }
    value = args.Value(L"--port", NULL);
    if (value != NULL)
    {
        StringCchCopyW(g_initialPort, sizeof(g_initialPort) / sizeof(g_initialPort[0]), value);
    }

    if (!InitializeWinsock())
    {
        MessageBoxW(NULL, L"Winsock 初始化失败,程序无法启动。", L"错误",
                    MB_OK | MB_ICONERROR);
        FreeCommandLine(&args);
        return 1;
    }

    WNDCLASSEXW windowClass;
    memset(&windowClass, 0, sizeof(windowClass));
    windowClass.cbSize = sizeof(windowClass);
    windowClass.lpfnWndProc = ClientWindowProc;
    windowClass.hInstance = instance;
    windowClass.hCursor = LoadCursorW(NULL, IDC_ARROW);
    windowClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    windowClass.lpszClassName = CLIENT_WINDOW_CLASS;
    windowClass.hIcon = LoadIconW(NULL, IDI_APPLICATION);
    windowClass.hIconSm = LoadIconW(NULL, IDI_APPLICATION);
    if (RegisterClassExW(&windowClass) == 0)
    {
        MessageBoxW(NULL, L"注册客户端窗口类失败。", L"错误", MB_OK | MB_ICONERROR);
        WSACleanup();
        FreeCommandLine(&args);
        return 1;
    }

    DWORD windowStyle = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX;
    RECT windowRect;
    windowRect.left = 0;
    windowRect.top = 0;
    windowRect.right = WINDOW_CLIENT_WIDTH;
    windowRect.bottom = WINDOW_CLIENT_HEIGHT;
    AdjustWindowRectEx(&windowRect, windowStyle, FALSE, 0);
    int windowWidth = windowRect.right - windowRect.left;
    int windowHeight = windowRect.bottom - windowRect.top;

    g_window = CreateWindowExW(0, CLIENT_WINDOW_CLASS, CLIENT_WINDOW_TITLE,
                               windowStyle, CW_USEDEFAULT, CW_USEDEFAULT,
                               windowWidth, windowHeight, NULL, NULL,
                               instance, NULL);
    if (g_window == NULL)
    {
        MessageBoxW(NULL, L"创建客户端主窗口失败。", L"错误", MB_OK | MB_ICONERROR);
        WSACleanup();
        FreeCommandLine(&args);
        return 1;
    }

    ShowWindow(g_window, showCommand);
    UpdateWindow(g_window);
    SetTimer(g_window, 1, 200, NULL);

    MSG message;
    while (GetMessageW(&message, NULL, 0, 0) > 0)
    {
        TranslateMessage(&message);
        DispatchMessageW(&message);
    }

    FreeCommandLine(&args);
    return (int)message.wParam;
}

4.6 广播通信模型在程序中的实现

广播通信模型与 TCP 连接模型的核心差异在于:服务器不建立连接、不维护客户端表、不等待确认。广播模型在本程序中的实现分布在四个文件中。

common.h:定义 16 字节报头、BC_MAX_PAYLOAD=1400、Magic、版本、类型、序号和长度字段;BuildBroadcastPacket() 与 ParseBroadcastPacket() 完成组包/拆包;ParseIPv4Text() 与 FormatIPv4() 完成广播地址解析与格式化。

server.cpp:OpenServerSocket() 创建 UDP 套接字、设置 SO_BROADCAST、绑定 192.168.50.1、把目标地址设为 192.168.50.255:1145;SendOnePacket() 组包后 sendto();BroadcastWorker() 按周期或目标 pps 循环发送。服务器不调用 listen()、accept()、connect(),不保存客户端列表。

client.cpp:OpenClientSocket() 创建 UDP 套接字、设置 SO_REUSEADDR 和 4 MB 接收缓冲区、绑定 192.168.50.2:1145;ReceiveWorker() 用 select()/recvfrom() 接收;HandleDatagram() 解析报头、统计序号缺失并显示正文。SO_REUSEADDR 允许多个客户端进程绑定同一端口,是 128/144 并发测试的基础。

stress_test.py:用 Python 原始套接字复现同一协议,SO_BROADCAST 发送、SO_REUSEADDR 接收,支持多端点、边界和五类压力用例。

广播模型的关键步骤为:服务器创建 SOCK_DGRAM 套接字;设置 SO_BROADCAST;绑定实验网卡源地址;目标地址填写子网广播地址 192.168.50.255 和客户端端口 1145;调用 sendto();网卡发出以太网广播帧;交换机在同一 VLAN 内泛洪;客户端绑定 1145 并用 select()/recvfrom() 接收;解析 16 字节报头并更新统计。服务器不等待确认,UDP 不重传,丢包由客户端序号缺失计数和压力测试统计体现。

广播模型的线路速率与丢包率分别如式(4)和式(5)所示。式(4)中 \(R\) 为实测包速率,\(L_{p}\) 为正文长度,66 字节为以太网帧头、FCS、前导码、帧间隙以及 IP/UDP 报头的近似开销;式(5)中 \(N_{send}\) 为服务器发送数,\(N_{recv}\) 为客户端接收数。

\[B = R \cdot (L_{p} + 66) \cdot 8 \tag{4} \]

\[P_{loss} = \frac{N_{send} - N_{recv}}{N_{send}} \times 100\% \tag{5} \]

广播服务器不维护连接表,因此不存在 TCP 服务器常见的 MAX_CLIENTS=128 硬上限;实际边界是操作系统进程/线程、套接字句柄、接收缓冲区、CPU 和网卡资源。128 与 144 客户端测试的所有客户端均收到 10/10 包,说明第 129 个客户端不会像 TCP 连接表那样被服务器拒绝。

4.7 stress_test.py 压力测试脚本详解

4.7.1 build_packet(sequence, payload) 与 parse_packet(data)

build_packet() 按与 common.h 相同的字段顺序生成 16 字节报头;parse_packet() 执行长度、Magic、版本、类型和长度一致性校验。函数原文如下:

点击展开/收起:build_packet() 与 parse_packet() 协议代码
def build_packet(sequence, payload):
    """按 common.h 的格式组包:16 字节报头 + UTF-8 正文。"""
    return HEADER.pack(MAGIC, VERSION, TYPE_MESSAGE, 0,
                       sequence, len(payload)) + payload


def parse_packet(data):
    """严格解析;返回 (序号, 正文),不是本程序报文时返回 None。"""
    if len(data) < HEADER_SIZE:
        return None
    magic, version, packet_type, _reserved, sequence, payload_length = \
        HEADER.unpack_from(data, 0)
    if magic != MAGIC or version != VERSION or packet_type != TYPE_MESSAGE:
        return None
    if payload_length != len(data) - HEADER_SIZE:
        return None
    if not (1 <= payload_length <= MAX_PAYLOAD):
        return None
    return sequence, data[HEADER_SIZE:]

4.7.2 collect_configuration(args)

该函数负责收集测试参数:交互运行时依次提示服务器 IP、端口、广播地址、客户端端点和包数,回车使用默认值;非交互运行时从命令行读取。函数还会检查服务器/客户端地址是否已配置在本机、TCP-Lab 网卡是否 Up、端口是否有效,失败时打印启用步骤并返回错误,而不是静默改用回环地址。完整原文见 stress_test.py。

4.7.3 test_server_broadcast(context)

该函数在客户端端点启动 Python 接收端,绑定 192.168.50.2:端口,设置 SO_REUSEADDR 和接收超时;启动 server.exe --auto 向广播地址发送指定数量包;接收端逐包解析序号和正文,统计接收数、唯一序号数、丢包数和吞吐率;最后读取服务器统计 JSON 核对 sent、failed 和退出码。完整原文见 stress_test.py。

4.7.4 test_client_receive(context)

该函数支持 --client-endpoints 指定多个 IP:端口,对每个端点启动一个或多个 client.exe --auto,再启动服务器向对应端口广播;检查每个客户端的接收数、正文匹配数、非法报文数和退出码;同时注入空包、错误 Magic/版本/类型、长度不符、超长和截断报文,验证客户端只增加 malformed 计数而不崩溃。完整原文见 stress_test.py。

4.7.5 test_boundaries(context)

该函数执行服务器边界、客户端边界和并发容量三组测试。服务器边界包括正文 0/1401 字节、端口 0/65536、count 与 duration 同时为 0、interval=60001、非本机绑定和广播 0.0.0.0;客户端边界包括端口 0/65536、duration=0、非本机监听和 expect=-1;容量包括 3、16、128、144 个客户端。每个边界外用例检查退出码是否为 2,而不是崩溃或挂起。序号缺失统计如式(6):

\[G = \sum_{i=2}^{n} \max\left(0,s_i-s_{i-1}-1\right) \tag{6} \]

4.7.6 run_baseline_case(context) 与 run_rate_case(context)

基准用例使用 1 个客户端、服务器 --pps 5、--count 25,要求 25/25 接收、正文匹配 25/25、非法报文 0、序号缺失 0。速率用例固定 4 个客户端,服务器依次以 10、200、2000 pps 发送 5 秒;每档记录发送数、各客户端接收数、平均丢包、GUI 窗口响应超时次数和最大响应时间。GUI 探针启动真实客户端窗口,每 200 ms 调用 SendMessageTimeoutW(hwnd, WM_NULL, ..., 500) 检测消息泵是否在 500 ms 内响应。

4.7.7 run_client_count_case()、run_stability_case() 与 run_extreme_case()

客户端数量用例固定服务器 1000 pps、每档 5 秒,分别启动 1、2、4、8 个客户端;稳定性用例以 200 pps 运行 180 秒,每 2 秒读取服务器/客户端周期统计 JSON,记录发送/接收/丢包、进程存活、工作集和私有内存;内存增长如式(7),M(t) 为 t 时刻工作集,t_0 为起始采样时刻。极限用例让服务器以 --interval 0 最大速度发送 10 秒,2 个客户端同时接收,每秒读取统计并执行 ping 测量 ICMP 往返时间。

\[\Delta M = \max_{t}M(t) - M(t_{0}) \tag{7} \]

4.7.8 主程序入口

main() 解析命令行、构造 Context、打印测试配置、执行预检查,并按 --mode 分派到服务器吞吐、客户端接收、一对多广播、运行边界、五类用例、监听或灌包模式;测试结束后把每个 TestResult 写成 Markdown 报告和 JSON 统计。--mode cases 顺序运行基准、速率、客户端数量、稳定性和极限五个用例,任一用例失败则总退出码非 0。完整原文见 stress_test.py 的 parse_args()、main()、run_case_mode() 与 write_report()。

表4给出五类用例的客户端数量、服务器速率/时长和主要观察指标,作为脚本参数选择与结果判定的依据。

表4 五类压力测试用例参数

用例 客户端数 服务器速率/时长 主要观察指标
基准功能 1 5 pps,25 包 接收数、丢包、正文匹配、日志
发送速率 4 (含 GUI 探针) 10/200/2000 pps,每档5 s 接收数、丢包、GUI响应、服务器异常
客户端数量 1/2/4/8 1000 pps,每档 5 s 接收数、丢包趋势
长时间稳定性 1 200 pps,180 s 进程存活、内存增长、累计丢包
极限压力 2 --interval 0,10 s 崩溃、丢包、ICMP 响应

表5汇总脚本的主要命令行参数及其默认值,说明交互输入、非交互运行和五类用例的参数覆盖方式。

表5 压力测试脚本主要参数

参数 功能 默认值或处理方式
--server-ip 服务器绑定 IPv4 192.168.50.1
--port 服务器/客户端端口 1145
--broadcast-ip 广播目标地址 按服务器地址推导 /24 广播地址
--client-endpoints 客户端监听端点列表 192.168.50.2:1145
--count 每项测试包数 交互输入或默认 20000
--mode 测试模式 all、server、client、e2e、boundary、baseline、rate、clients、stability、extreme、cases
--boundary-clients 并发边界客户端数 默认 16;--quick 为 8;--full 为 32
--rate-clients 速率用例固定客户端数 4
--rates 速率档位 10,200,2000
--client-counts 客户端数量档位 1,2,4,8
--stability-seconds 稳定性持续时间 180 秒
--extreme-seconds 极限持续时间 10 秒
--yes 确认极限测试 非交互模式必须显式给出

4.8 编译、运行和压力测试步骤

  1. 按 4.1.1 节配置实验网卡,确认 192.168.50.1/24 与 192.168.50.2/24 均为 Preferred,并运行 python stress_test.py --mode lab-check 通过自检。
  2. 运行 build_msvc.bat --no-pause,生成 server.exe 与 client.exe。
  3. 双击 server.exe,在绑定 IPv4 中填写 192.168.50.1,广播 IPv4 填写 192.168.50.255,端口填写 1145,正文填写“今天是个好日子!”,周期填写 1000,点击“启动广播”,确认日志显示广播已启动。
  4. 双击一个或多个 client.exe,监听 IPv4 填写 192.168.50.2,端口填写 1145,点击“开始监听”,观察正文显示、接收计数、序号缺失和非法报文计数。
  5. 在项目目录运行 python stress_test.py,按提示输入服务器 IP、端口、广播地址、客户端端点和包数;直接回车使用默认值。脚本先检查 TCP-Lab 网卡,再启动自动模式服务器/客户端并生成报告。
  6. 运行边界测试:python stress_test.py --mode boundary --no-prompt;运行 128/144 客户端边界时增加 --boundary-clients 128 或 --boundary-clients 144。
  7. 运行五类用例:python stress_test.py --mode cases --no-prompt --yes;该命令包含 180 秒稳定性用例和 10 秒极限用例,完整运行约 4 分 20 秒。
  8. 在 test_output/ 下查看 Markdown 报告和 JSON 统计;在 screenshots/ 下查看界面截图。表6汇总服务器/客户端参数边界、非法报文、128/144 客户端容量以及五类压力用例的实测数据,用于判断程序在边界内和边界外的行为。

表6 边界、容量与五类压力测试实测结果

测试类别 条件 实测结果
服务器参数边界 正文 0/1401 B、端口 0/65536、count 与 duration 同时为 0、interval=60001、非本机绑定、广播 0.0.0.0 8/8 项在启动阶段返回 exit 2
客户端参数边界 端口 0/65536、duration=0、非本机监听、expect=-1 5/5 项返回 exit 2
非法与超长报文 空包、错误 Magic/版本/类型、长度不符、超长、截断 30/30 被丢弃,客户端不崩溃
有效正文边界 1 B 与 1400 B 正文 各 5 包发送/接收成功,客户端共接收 10 包
128 客户端容量 128 个客户端同时监听,服务器广播 10 包 128/128 客户端均收到 10/10
144 客户端容量 144 个客户端同时监听,服务器广播 10 包 144/144 客户端均收到 10/10
用例1 基准 5 pps、1 客户端、25 包 25/25,丢包 0.0%
用例2 速率 4 客户端、10/200/2000 pps、每档 5 s 发送 51/999/9986,平均丢包 0.0%,GUI 最大响应 22 ms,UI 超时 0 次
用例3 客户端数量 1/2/4/8 客户端、1000 pps、5 s 发送约 5000/4987/4988/4998,平均丢包 0.0%
用例4 稳定性 180 s、200 pps 35,997/35,997,最终丢包 0.0%;服务器内存增长约 5.0 MB,客户端约 0.1 MB
用例5 极限 10 s、--interval 0、2 客户端 发送 215,957 包(约 21,596 pps、15.5 Mbit/s),丢包 0.0%;ICMP 10/10,最大 51 ms

图10和图11分别为服务器端和客户端运行截图;图12客户端边界压力测试运行截图。

图片10

图10 服务器端运行截图

图示说明:服务器端运行界面截图:展示广播地址、端口、消息正文、发送周期、发送统计和日志信息。

图片11
图11 客户端运行截图

图示说明:客户端运行界面截图:展示监听地址、端口、收到的广播正文、接收数量及协议统计信息。

图片12
图12 压力测试运行截图

图示说明:压力测试运行截图:展示客户端数量边界或脚本压力测试的运行结果。

4.9 结果分析

在默认真实广播测试中,服务器从 192.168.50.1 向 192.168.50.255:1145 发送 20,000 包,客户端 192.168.50.2:1145 接收 20,000 包,丢包 0,正文匹配 20,000;服务器发送速率约 40,000 包/秒,Python 测试端接收速率约 39,006 包/秒。不同 IP、同一端口、不同端口以及混合端点的 10,000 包测试均实现 0 丢包。

设测试时长为 \(\Delta t_{run}\),接收包数为 \(N\),则实测包速率如式(8):

\[R = \frac{N}{\Delta t_{run}} \tag{8} \]

五类用例结果如表6所示:基准 25/25、0 丢包;速率 10/200/2000 pps 三档均未丢包,GUI 最大响应 22 ms;客户端数量 1/2/4/8 档均未丢包;稳定性 180 秒发送/接收 35,997/35,997,最终丢包 0.0%,服务器/客户端内存增长约 5.0/0.1 MB,无卡死;极限 10 秒发送 215,957 包,约 21,596 pps、15.5 Mbit/s,2 客户端共接收 431,914 包,估算丢包 0.0%,ICMP 10/10、最大 51 ms,无崩溃。五类压力测试关键指标对比情况如图13所示。

图13以四联图对比五类用例的发送规模、丢包率、GUI 最大响应和内存增长。

图13SCI四联性能数据图_16比9_300dpi

图13 五类压力测试关键指标对比图

图示说明:四联性能数据图:对比五类用例的发送包数、丢包率、GUI 最大响应和服务器/客户端内存增长。


五、实验小结(必写环节)

5.1 实验问题及解决方法

实验过程中遇到的问题涉及实验网卡配置、广播套接字选项、端口复用、中文编码、边界参数校验、高速发送日志以及测试环境隔离。表7汇总了主要问题、原因和处理措施。

表7 实验问题及处理措施

问题 原因 处理措施
服务器绑定失败,错误码 10049 本机没有 192.168.50.1,或 TCP-Lab 实验网卡未启用 以管理员身份运行一键配置脚本,确认 192.168.50.1/24 与 192.168.50.2/24 均为 Preferred
广播发送返回 10013 UDP 套接字未设置 SO_BROADCAST 在 OpenServerSocket() 中显式设置 SO_BROADCAST=1,失败时输出 Winsock 错误说明
第二个客户端绑定 1145 失败,错误码 10048 未设置地址复用 在 OpenClientSocket() 中设置 SO_REUSEADDR=1,允许多个客户端监听同一端口
中文正文显示为乱码 源码、执行字符集或网络正文编码不一致 源码保持 UTF-8 BOM,MSVC 使用 /utf-8,网络统一 UTF-8,界面使用宽字符 API
广播地址填写 0.0.0.0 时行为不明确 0.0.0.0 表示任意本地地址,不是广播目标 在 OpenServerSocket() 中拒绝该地址,提示填写子网广播地址
客户端 duration=0 且 expect>0 时永久等待 自动模式只检查期望包数,没有超时约束 要求 duration > 0,参数非法时返回 exit 2
高速发送时日志拖慢发送线程 每条日志同步写界面或磁盘 工作线程通过 PostMessage 异步更新界面,日志按固定间隔写入
把 128 当作广播客户端上限 TCP 服务器常见 MAX_CLIENTS=128,广播没有连接表 明确广播无 TCP 式 128 上限,用 128/144 客户端实测验证
测试结果出现重复序号、首包不是 1、边界正文不一致 手工打开的 GUI 服务器/客户端仍在运行,持续占用 1145 并发送默认消息 测试前关闭 GUI 实例;脚本增加 tasklist 实例检查,检测到残留进程即中止并打印 PID
边界测试误收无关广播 边界接收端未过滤正文,GUI 服务器的默认消息混入 接收端只统计与当前边界 payload 一致的报文,并强调测试环境独占

边界参数应满足式(9):

\[1 \leq p \leq 65535,\ \ \ \ 1 \leq L_{p} \leq 1400 \tag{9} \]

其中 \(p\) 为端口,\(L_{p}\) 为 UTF-8 正文字节数。服务器端还要求 count 与 duration 至少一个大于 0;客户端自动模式要求 duration > 0。这些约束使边界外输入在启动阶段被明确拒绝,而不是进入未定义行为。

5.2 实验总结

本实验完成了基于 UDP 广播的服务器端与客户端图形界面程序。服务器按周期向 192.168.50.255:1145 发送带 16 字节报头的中文广播,客户端监听 192.168.50.2:1145,完成报文接收、协议校验、序号统计和界面显示;服务器和客户端均通过工作线程执行网络操作,窗口线程保持响应。程序使用 SO_BROADCAST 实现广播发送,使用 SO_REUSEADDR 支持同一主机多客户端监听,使用 SO_RCVBUF/SO_SNDBUF 降低高速广播的缓冲区丢包概率,使用 PostMessage 保证工作线程与窗口线程的安全协同。

在真实 TCP-Lab 环境中,默认 20,000 包测试实现 0 丢包;不同 IP、不同端口、混合端点和一对多广播测试均通过;128 与 144 个客户端同时监听时全部收到广播,验证了广播模型没有 TCP 式 128 连接上限。五类压力用例中,基准用例 25/25、0 丢包;速率用例在 10/200/2000 pps 三档均未丢包,GUI 窗口最大响应约 22 ms、无响应超时;客户端数量用例在 1/2/4/8 档均未丢包;180 秒稳定性用例发送/接收 35,997/35,997,最终丢包 0.0%,服务器与客户端工作集增长约 5.0 MB 和 0.1 MB,无卡死或提前退出;10 秒极限用例发送 215,957 包,约 21,596 pps、15.5 Mbit/s,2 个客户端共接收 431,914 包,估算丢包 0.0%,ICMP 10/10 成功、最大 51 ms,无崩溃。

本实验也暴露了测试方法上的问题:手工打开的 GUI 服务器/客户端会持续占用 1145 并发送默认消息,使自动测试出现重复序号、首包非 1、边界正文不一致等假失败。该现象说明广播测试必须独占广播路径;脚本已加入启动前实例检查,检测到残留 server.exe/client.exe 时打印 PID 并中止。环境隔离后,测试结果才具有可解释性。

本实验的局限在于:TCP-Lab 为同一台 Windows 主机上的 KM-TEST 虚拟网卡,未复现真实交换机对多台主机的端口复制;极限用例约 15.5 Mbit/s,未达到网卡/主机饱和点;UDP 广播不保证可靠,0 丢包只代表当前实验环境。后续可在多台真实主机上重复客户端数量测试,或引入网络损伤工具注入确定性丢包/延迟,进一步分析广播模型在拥塞条件下的行为。

5.3 小组分工

表8列出本实验四名小组成员及其模块分工,覆盖公共协议、服务器端、客户端、压力测试和文档整理。

表8 小组成员及分工

成员 学号 分工
方致沅 20242136050 总体设计、common.h 广播协议、广播通信模型分析、模块整合与联调
王鑫杰 20242136047 server.cpp 服务器窗口、广播发送线程、速率控制、边界校验与资源释放
李润哲 20242136049 client.cpp 客户端窗口、接收线程、SO_REUSEADDR 多实例监听、界面显示与状态处理
康奕彬 20242136048 stress_test.py 五类压力用例、边界与容量测试、统计报告、编译配置与实验记录整理

5.4 小组成员实验感想

5.4.1 方致沅实验感想

本次实验中,本人主要负责总体设计、公共广播协议和模块整合。设计中最重要的是统一服务器与客户端对 16 字节报头、网络字节序、正文上限和默认地址的约定;只要其中一处不一致,客户端就会把合法广播判为非法报文。调试时曾遇到广播地址填写为 0.0.0.0 导致发送行为不明确的问题,后来在 OpenServerSocket() 中增加边界校验,使 GUI 和自动测试都能得到清晰错误提示。通过本次实验,本人进一步理解了广播“无连接、无确认、一对多”的模型特征,以及公共协议一致性对跨模块联调的作用。

5.4.2 王鑫杰实验感想

本次实验中,本人主要负责服务器窗口、广播发送线程和速率控制。服务器不需要像 TCP 服务器那样为每个客户端创建线程,但发送线程仍需与窗口线程通过事件和 PostMessage 协同,避免网络循环阻塞界面。调试速率用例时发现,单纯使用 Sleep(1) 受 Windows 定时器粒度影响,无法准确达到 2000 pps;后来在自动模式中加入 QueryPerformanceCounter 目标时间点和 2 ms 补发上限,速率才稳定。通过本次实验,本人掌握了 UDP 广播套接字、SO_BROADCAST、发送统计和边界参数校验的处理方法。

5.4.3 李润哲实验感想

本次实验中,本人主要负责客户端窗口、接收线程和多实例监听。最初同时启动两个客户端时,第二个客户端绑定 1145 失败并返回 10048;检查后确认需要设置 SO_REUSEADDR,才能让同一主机上的多个客户端绑定同一端口。接收线程使用 select() 等待数据报,解析报头后更新接收计数、序号缺失和正文显示;在高速广播下,显示必须节流,否则编辑框会成为瓶颈。通过本次实验,本人理解了广播接收端“只监听、不连接”的编程方式,以及 SO_REUSEADDR 对一对多测试的重要性。

5.4.4 康奕彬实验感想

本次实验中,本人主要负责压力测试脚本、五类用例和结果整理。测试脚本需要与 C++ 程序使用完全一致的 16 字节协议,否则会把协议差异误判为丢包;为此,脚本中的 build_packet() 与 parse_packet() 严格按相同字段顺序实现。设计五类用例时,本人认识到“0 丢包”并不等于“没有边界”:128/144 客户端测试说明广播没有 TCP 式连接上限,而 180 秒稳定性测试则需要同时观察内存、进程存活和累计丢包。一次未关闭 GUI 实例的运行产生了重复序号和首包非 1 的假失败,促使本人加入启动前实例检查;通过本次实验,本人掌握了真实广播测试、GUI 响应探针、内存采样和测试环境隔离方法。

六、附录

  1. 《Windows网络与通信程序设计》陈香凝,王烨阳,陈婷婷,张睁,人民邮电出版社,2017.3第3版

  2. Microsoft Winsock 文档:socket、bind、sendto、recvfrom、select、SO_BROADCAST、SO_REUSEADDR、SO_RCVBUF、SO_SNDBUF。

  3. Microsoft Win32 文档:CreateWindowExW、PostMessageW、SetEvent、WaitForMultipleObjects、SendMessageTimeoutW。

  4. 广播风暴与线速限速参考: https://github.com/core-engineering/pnio-rs/blob/main/bench/bcast_storm.py 。

  5. UDP flood 极限测试参考: https://github.com/mirac-s/FloodX 。

  6. 网络损伤/丢包注入参考: https://github.com/titanfyre/Network-Emulation-SDK 、 https://github.com/wesmar/WireScope 。

  7. 广播接收示例: https://github.com/nguyenchiemminhvu/LinuxNetworkProgramming/blob/main/00_tutorials/14_broadcasting.c 。

  8. TCP 客户端上限对照: https://github.com/Vikas2171/Chat_Application 。

posted @ 2026-11-18 21:37  fangzhiyuan  阅读(5)  评论(0)    收藏  举报