于 WSAEventSelect 模型的通信程序设计实验:水仙花数查询系统

基于 WSAEventSelect 模型的通信程序设计实验:水仙花数查询系统

关键词:Win32、Winsock2、WSAEventSelect、事件驱动、TCP、长度前缀协议、水仙花数


一、实验目的

  1. 了解 Windows 环境下基于 WSAEventSelect 模型的通信程序编写、编译与运行方法,掌握事件驱动网络程序的基本结构。
  2. 掌握 Winsock2 的初始化、套接字创建、地址绑定、监听、连接建立、数据收发和资源释放等操作。
  3. 理解套接字、事件对象与网络事件之间的关联关系,掌握 WSAEventSelect、WSAWaitForMultipleEvents 和 WSAEnumNetworkEvents 的使用方法。
  4. 掌握 FD_ACCEPT、FD_CONNECT、FD_READ、FD_WRITE 和 FD_CLOSE 等网络事件的处理方法,以及非阻塞操作中 WSAEWOULDBLOCK 的含义。
  5. 实现客户端向服务器发送查询请求、服务器完成水仙花数计算并返回结果的双向数据传递过程。
  6. 理解 TCP 字节流不保留应用层消息边界的特点,利用长度前缀协议和收发状态记录处理分段接收与部分发送。
  7. 掌握三位水仙花数的数学定义与枚举算法,通过正常输入、边界输入和异常通信测试验证程序的正确性。
  8. 理解 Win32 窗口消息与网络事件协同处理的方法,避免阻塞式网络操作影响图形界面的响应。

二、实验内容与设计思想

1. 实验内容

本实验使用 C++、Win32 API 和 Windows Sockets 2 编写服务器端与客户端程序,通过 WSAEventSelect 模型实现基于 IPv4 和 TCP 的通信。

客户端建立连接后,向服务器发送以下固定请求:

请输出从 1 到 1000 内所有的水仙花数。

服务器接收并解析请求,校验请求正文是否符合约定。对于合法请求,服务器调用独立的水仙花数计算模块,生成计算结果并返回客户端;对于不支持的请求,服务器返回错误说明。

本实验中的水仙花数限定为三位整数,要求该整数等于其各位数字的立方和。客户端仅负责请求发送、响应接收与结果显示,计算工作由服务器完成。

为明确通信双方的地址、端口与协议约定,表 1 列出了程序的主要通信参数。其中,默认双地址配置沿用参考实验,回环地址用于本机联调。

表 1 通信参数与业务约定

项目 配置或说明
网络层协议 IPv4
传输层协议 TCP
默认服务器地址 192.168.50.1
默认客户端本地地址 192.168.50.2
参考实验子网掩码 255.255.255.0
本机联调地址 127.0.0.1
默认服务器端口 1145
客户端本地端口 由操作系统动态分配
网络正文编码 UTF-8
应用层消息格式 四字节长度字段与消息正文
单条正文长度上限 8192 字节
单次事务等待时限 15 秒
服务器业务连接数量上限 32 条
请求内容 请输出从 1 到 1000 内所有的水仙花数
正确计算结果 153、370、371、407
连接使用方式 每条连接完成一次请求与一次响应

上述默认地址必须实际配置在相应计算机上才能用于绑定。若采用两台真实计算机,应填写各自实际可用的 IPv4 地址;客户端本地地址留空时,由操作系统选择适当的本地网络接口。


2. 系统总体结构

系统按照业务计算、服务器通信、客户端通信和公共支撑四个部分组织代码。业务算法与网络操作分离,有利于独立验证计算结果,并降低网络模块与算法模块之间的耦合程度。

四个核心代码文件的职责与调用关系如表 2 所示。

表 2 核心代码文件及职责

文件 主要职责 主要接口或功能
narcissistic.cpp 水仙花数计算与响应正文生成 IsNarcissistic、FindNarcissisticNumbers、BuildNarcissisticReply
server.cpp 监听、连接管理、请求解析、算法调用和响应发送 StartServer、AcceptClients、PrepareReply、HandleNetworkEvent
client.cpp 建立连接、发送请求、接收响应和界面状态管理 StartRequest、TrySendRequest、HandleReplyRead、CloseConnection
wsaevent_common.h 公共常量、协议封装、收发状态、事件循环和界面工具 BuildPacket、ReceivePacket、FlushOutput、RunEventMessageLoop

服务器程序由服务器源文件与算法源文件共同编译生成,客户端程序只编译客户端源文件。双方通过共同头文件使用一致的消息格式与收发规则。图 1 展示系统的模块组成,以及客户端请求、服务器计算和结果返回之间的关系。

图1WSAEventSelect水仙花数查询系统架构图

图1-系统总体结构
内容说明:客户端与服务器通过 IPv4/TCP 通信;客户端负责参数输入、非阻塞连接、请求发送和响应显示;服务器负责连接管理、请求解析和响应发送;服务器调用水仙花数算法模块完成计算;公共头文件为双方提供协议、收发状态和事件循环支撑。


3. WSAEventSelect 模型设计

3.1 套接字与事件对象关联

WSAEventSelect 将套接字与指定的事件对象关联,并设置需要监视的网络事件集合。当相关网络事件发生时,Winsock 将关联事件对象置为有信号状态,同时记录事件类型。调用该函数后,套接字进入非阻塞模式。

其关联关系可表示为:

\[A_i=(s_i,e_i,\mathcal M_i) \tag{2.3.1} \]

其中,\(s_i\) 表示套接字,\(e_i\) 表示关联事件对象,\(\mathcal M_i\) 表示监视的网络事件集合。

服务器监听套接字、服务器业务套接字和客户端套接字分别采用以下事件集合:

\[\mathcal M_{\text{listen}}=\{FD\_ACCEPT,FD\_CLOSE\} \tag{2.3.2} \]

\[\mathcal M_{\text{server}}=\{FD\_READ,FD\_WRITE,FD\_CLOSE\} \tag{2.3.3} \]

\[\mathcal M_{\text{client}}=\{FD\_CONNECT,FD\_READ,FD\_WRITE,FD\_CLOSE\} \tag{2.3.4} \]

各网络事件的作用和本实验中的处理方式如表 3 所示。

表 3 网络事件及处理方式

网络事件 适用对象 含义 本实验处理方式
FD_ACCEPT 服务器监听套接字 存在待接受的连接 调用 accept(),分配独立连接状态和事件对象
FD_CONNECT 客户端套接字 非阻塞连接结果已产生 检查事件错误码,成功后开始发送请求
FD_READ 已连接套接字 存在可读取数据 调用 recv(),推进当前数据帧接收状态
FD_WRITE 已连接套接字 套接字具备发送条件 根据发送偏移继续发送剩余数据
FD_CLOSE 已连接套接字 对端关闭或连接异常 先检查剩余数据,再根据状态结束或继续必要处理

3.2 事件等待与枚举

网络事件对象被触发后,程序调用 WSAEnumNetworkEvents 获取事件位掩码和对应错误码。传入关联事件句柄时,该函数还会原子地清除网络事件记录并复位事件对象。因此,本实验不单独调用 WSAResetEvent 代替网络事件枚举。

一次枚举可能返回多个网络事件。例如,数据到达与连接关闭可能在一次处理中同时被观察到。因此,程序对各事件位分别判断,不能只处理其中一个事件后忽略其他事件。

3.3 网络事件与图形界面的协同

本实验保留单线程 Win32 图形界面结构,使用 MsgWaitForMultipleObjects 同时等待网络事件对象与窗口消息。该函数可以在指定对象或符合条件的输入事件出现时结束等待,适用于窗口线程与事件对象的协同处理。

本程序的具体处理过程为:

  1. 处理当前窗口消息,包括按钮操作、窗口调整与超时通知。
  2. 收集仍然有效的网络事件句柄及其对应连接标识。
  3. 等待窗口消息或网络事件。
  4. 网络事件就绪后,通过 WSAWaitForMultipleEvents 确认事件状态。
  5. 调用 WSAEnumNetworkEvents,分派相应的网络处理函数。
  6. 处理结束后重新构建等待数组,避免继续使用已关闭的事件句柄。

定时器仅用于检查事务超时,网络数据到达与发送恢复均由事件对象通知。图 2 给出了窗口消息与网络事件协同处理的完整循环。

图2WSAEventSelect事件协同处理流程图

图2-事件与窗口消息协同处理流程
图片说明:程序初始化套接字与事件对象,使用 WSAEventSelect 建立关联;通过 MsgWaitForMultipleObjects 同时等待窗口消息和网络事件;网络事件就绪后依次执行 WSAWaitForMultipleEvents、WSAEnumNetworkEvents 和事件分派;退出时关闭套接字、事件对象和 Winsock。


4. 应用层通信协议设计

4.1 消息边界定义

TCP 提供有序字节流,但应用程序不能假定一次 send() 对应一次 recv()。完整消息可能被分成多个片段接收,也可能与其他数据连续到达。

本实验采用四字节长度前缀协议。设消息正文为 \(P\),其 UTF-8 编码后的字节长度为 \(L\),完整数据帧为 \(F\),则:

\[L=\left|UTF8(P)\right| \tag{2.4.1} \]

\[F=BE32(L)\parallel UTF8(P) \tag{2.4.2} \]

\[\left|F\right|=4+L,\quad 0\le L\le 8192 \tag{2.4.3} \]

其中,\(BE32\) 表示四字节大端编码,\(\parallel\) 表示字节序列拼接。长度字段使用 htonl() 与 ntohl() 完成主机字节序和网络字节序之间的转换。

数据帧各字段的含义如表 4 所示。

表 4 应用层数据帧格式

字段 长度 编码形式 说明
PayloadLength 4 字节 无符号整数,网络字节序 正文的 UTF-8 字节长度
Payload 0~8192 字节 UTF-8 请求或响应正文

C 字符串末尾的空字符不作为正文发送。零长度正文在帧结构上可以解析,但不满足本实验的合法业务请求要求。图 3 展示长度字段与正文的排列关系,以及接收端先解析长度、再读取正文的处理顺序。

图3TCP应用层长度前缀数据帧流程图

图3-应用层数据帧及接收顺序
图片说明:前 4 字节为网络字节序 PayloadLength,后续 L 字节为 UTF-8 正文;接收端先读取 4 字节头部,再按合法长度读取正文。

4.2 分段接收处理

接收状态使用 inputLength 保存当前已接收字节数。程序先接收完整头部,再根据解析得到的合法长度读取正文,每次读取量不超过当前帧尚缺的字节数。

设已接收字节数为 \(R\),则完整帧的判定条件为:

\[R\ge 4+L \tag{2.4.4} \]

若尚未满足完整性条件,程序保留现有数据并等待后续事件。若长度超过上限,或对端在完整帧到达前关闭连接,则终止当前事务。

本实验规定一条连接只处理一次请求。即使 TCP 流中存在后续帧,程序也不会把后续帧合并到第一条请求中执行,不支持同一连接上的流水线多请求。

4.3 部分发送处理

发送状态使用 outputLength 保存完整帧长度,使用 sent 保存已经成功提交给 TCP 的字节数。

设完整帧长度为 \(T\),已发送字节数为 \(S\),则:

\[0\le S\le T \tag{2.4.5} \]

\[T_{\text{remain}}=T-S \tag{2.4.6} \]

当一次 send() 成功发送 \(k\) 字节时:

\[S_{\text{new}}=S_{\text{old}}+k \tag{2.4.7} \]

当 \(S=T\) 时,本次发送完成。若返回 WSAEWOULDBLOCK,则保留数据和偏移量,等待 FD_WRITE 后续块发送。

程序在新请求或新响应生成后立即尝试发送。只有暂时不能继续发送时,才依靠后续 FD_WRITE 恢复发送过程。


5. 水仙花数计算流程

5.1 数学定义

设三位整数为 \(n\),其百位、十位和个位分别为 \(a\)、\(b\) 和 \(c\),则:

\[n=100a+10b+c,\quad 1\le a\le 9,\ 0\le b\le 9,\ 0\le c\le 9 \tag{2.5.1} \]

水仙花数应满足:

\[n=a^3+b^3+c^3 \tag{2.5.2} \]

各位数字可通过整数除法和取余运算得到:

\[a=\left\lfloor\frac{n}{100}\right\rfloor \tag{2.5.3} \]

\[b=\left\lfloor\frac{n}{10}\right\rfloor\bmod 10 \tag{2.5.4} \]

\[c=n\bmod 10 \tag{2.5.5} \]

题目查询范围为 \([1,1000]\),但水仙花数必须是三位数,因此实际候选区间为:

\[[1,1000]\cap[100,999]=[100,999] \tag{2.5.6} \]

单个数字即使满足各位立方和条件,也不属于本实验规定的三位水仙花数。

5.2 算法步骤与结果

算法首先检查参数,再将查询区间限制到三位数范围。随后依次枚举候选整数,提取各位数字,计算立方和,并将满足条件的整数按升序保存。

最终得到的结果集合为:

\[N=\{n\in\mathbb Z\mid 100\le n\le 999,\ n=a^3+b^3+c^3\}=\{153,370,371,407\} \tag{2.5.7} \]

\[|N|=4 \tag{2.5.8} \]

为验证计算结果,表 5 列出了四个结果对应的数位分解与立方和。

表 5 水仙花数计算结果验证

整数 百位 十位 个位 立方和验证
153 1 5 3 \(1^3+5^3+3^3=153\)
370 3 7 0 \(3^3+7^3+0^3=370\)
371 3 7 1 \(3^3+7^3+1^3=371\)
407 4 0 7 \(4^3+0^3+7^3=407\)

计算过程使用整数乘法,不依赖浮点幂运算。若候选区间包含 \(N\) 个整数,则扫描时间复杂度为:

\[T(N)=O(N) \tag{2.5.9} \]

除结果存储外,数位提取和判断只需要固定数量的变量,辅助空间复杂度为:

\[S_{\text{aux}}(N)=O(1) \tag{2.5.10} \]

图 4 给出了区间限制、逐个判断、结果保存和响应正文生成的流程。

图4水仙花数计算流程图

图4-水仙花数计算流程
图片说明:先检查参数并将区间限制在三位数范围,再逐个提取百位、十位和个位,计算立方和并判断是否等于原数,最后保存结果并生成响应正文。


6. 服务器端工作流程

服务器端首先初始化 Winsock,创建监听套接字,并根据界面输入绑定本机地址与端口。完成监听后,服务器创建事件对象,并通过 WSAEventSelect 关联 FD_ACCEPT 和 FD_CLOSE。

当 FD_ACCEPT 发生时,服务器调用 accept() 获取业务套接字。每条业务连接分配独立事件对象与收发状态,并监视 FD_READ、FD_WRITE 和 FD_CLOSE。

收到完整请求后,服务器按以下步骤处理:

  1. 比较请求长度和全部正文字节,确认请求是否与约定一致。
  2. 合法请求调用 BuildNarcissisticReply(),实际执行水仙花数计算。
  3. 非法请求生成“不支持的请求”错误正文。
  4. 将响应封装为长度前缀数据帧,立即尝试发送。
  5. 暂时不可发送时保存发送偏移,等待 FD_WRITE。
  6. 响应全部提交给 TCP 后关闭本次连接,继续服务其他客户端。

服务器使用 replying 标志防止同一请求被重复处理或覆盖尚未发完的响应。事务超时、协议错误和网络错误仅清理相应业务连接,不影响其他连接。图 5 展示服务器从监听建立到请求处理、响应发送与连接清理的完整流程。

图5WSAEventSelect服务器端工作流程图

图5-服务器端工作流程
图片说明:服务器初始化 Winsock,创建监听套接字并绑定地址;接受连接后为每条业务连接创建独立事件对象;收到完整请求后调用水仙花数算法,封装响应并发送;发送完成后关闭本次连接,继续监听。


7. 客户端工作流程

客户端采用“连接并查询”的操作方式。用户输入服务器地址、服务器端口及可选本地地址后,程序先检查参数,再创建套接字。

若指定本地地址,客户端执行绑定;若本地地址为空,则由操作系统自动选择。客户端在调用 connect() 前创建并关联事件对象,使连接操作以非阻塞方式执行。

客户端的主要逻辑阶段可表示为:

\[Idle\rightarrow Connecting\rightarrow Sending\rightarrow Receiving\rightarrow Idle \]

上述阶段是对程序处理过程的逻辑划分,实际代码通过套接字有效性、连接标志、发送标志和收发状态共同记录当前进度。

当连接成功后,客户端立即发送固定查询请求。完整响应到达后,程序将 UTF-8 正文转换为宽字符文本并显示,随后释放连接并恢复输入控件。图 6 展示客户端参数检查、连接结果处理、请求发送、响应接收与状态恢复之间的关系。

图6WSAEventSelect 客户端工作流程图

图6-客户端工作流程
图片说明:客户端检查服务器地址、本地地址和端口,创建套接字并关联事件对象;非阻塞连接成功后发送固定请求;收到完整响应后显示结果并释放连接,恢复界面状态。


8. 服务器端与客户端之间的双向数据传递流程

本实验的双向通信由查询请求和计算响应两个方向构成。请求从客户端传向服务器,响应从服务器传回客户端,二者使用同一条已建立的 TCP 连接。

从应用层角度,一次成功事务包括连接建立、请求传输、服务器计算、响应传输和连接结束五个阶段。服务器发送函数返回成功,仅表示相应字节已提交给本地 TCP;客户端成功解析完整响应,才能证明本次应用层响应已完整到达。图 7 以横向泳道流程图说明双方在同一事务中的职责和数据传递方向。

图7客户端与服务器双向数据传递流程图

图7-客户端与服务器双向数据传递流程
图片说明:客户端发起连接并发送查询请求;服务器接收请求、调用水仙花数算法并发送响应;客户端累计接收并解析完整响应,最后关闭连接。


三、实验使用环境

项目 说明
操作系统 Microsoft Windows 7/8/10/11
编程环境 Visual C++ 6.0
语言标准 C++98
网络库 Windows Sockets 2,链接 ws2_32.lib
编译工具 构建脚本支持 MSYS2 UCRT64 的 g++
实验网卡 Microsoft KM-TEST Loopback Adapter,命名为 TCP-Lab

四、实验步骤和调试过程

1. 配置与检查通信环境

首先确认服务器与客户端运行位置,并选择通信方式。

采用本机回环方式时,服务器监听地址填写 127.0.0.1,客户端服务器地址也填写 127.0.0.1。客户端本地地址留空,或填写 127.0.0.1。

采用参考实验的双地址方式时,应先确认 192.168.50.1 与 192.168.50.2 已配置在相应接口上。采用两台计算机时,则使用两台机器实际可达的地址。

地址配置检查应包括接口状态、IPv4 地址、子网掩码以及路由条件。图 8 为网络参数检查截图,用于记录正式实验采用的实际配置。

图片8

图8-实验网络参数检查
图片说明:检查 TCP-Lab 网卡状态为 Up,并确认 IPv4 地址 192.168.50.1/24、192.168.50.2/24 均为 Preferred。


2. 公共头文件实现

共同头文件统一定义通信参数、最大消息长度、固定请求正文和收发状态结构,并提供以下公共功能:

  • BuildPacket():封装四字节长度字段与正文。
  • PacketStatus():检查当前缓冲区是否具备完整数据帧。
  • ReceivePacket():推进非阻塞接收过程。
  • FlushOutput():按照已发送偏移继续发送。
  • CloseSocketEvent():关闭套接字及关联事件对象。
  • RunEventMessageLoop():协调窗口消息与网络事件。
  • 地址、端口校验与中文日志显示工具。

收发状态中的 inputLength、outputLength 和 sent 分别表示已接收长度、待发送总长度和已发送长度。每条连接使用独立状态,防止并发连接之间相互覆盖数据。

点击展开/收起:wsaevent_common.h(公共头文件完整代码)
#ifndef WSAEVENT_COMMON_H
#define WSAEVENT_COMMON_H

/*
 * 共同头文件:网络参数、TCP 数据帧、非阻塞收发、事件消息循环和界面工具。
 * 包含顺序很重要:winsock2.h 必须放在 windows.h 前,避免旧 winsock.h 冲突。
 * 全部代码使用 C++98 语法;不依赖 C++11、MFC 或第三方网络库。
 */
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#include <winsock2.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>

#ifdef _MSC_VER
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdi32.lib")
#endif

const int MAX_PAYLOAD_SIZE = 8192;       /* 单条正文最多 8192 字节。 */
const int PACKET_HEADER_SIZE = 4;        /* 长度字段:4 字节无符号网络序整数。 */
const int MAX_PACKET_SIZE = PACKET_HEADER_SIZE + MAX_PAYLOAD_SIZE;
const int MAX_CLIENTS = 32;             /* 加上监听事件仍小于等待函数的限制。 */
const unsigned short DEFAULT_PORT = 1145;
const DWORD TRANSACTION_TIMEOUT = 15000; /* 一次连接/请求/响应最多等待 15 秒。 */
const wchar_t DEFAULT_SERVER_IP[] = L"192.168.50.1";
const wchar_t DEFAULT_CLIENT_IP[] = L"192.168.50.2";

/*
 * 请求正文严格等于题目的“请输出从1到1000内所有的水仙花数”。
 * 网络字符串显式写为 UTF-8 字节,避免 VC++ 6.0 的本机代码页改变传输内容。
 * 界面使用宽字符 Windows API,源码编码与网络编码互不混淆。
 */
const char REQUEST_TEXT[] =
    "\xE8\xAF\xB7\xE8\xBE\x93\xE5\x87\xBA\xE4\xBB\x8E" "1"
    "\xE5\x88\xB0" "1000" "\xE5\x86\x85\xE6\x89\x80"
    "\xE6\x9C\x89\xE7\x9A\x84\xE6\xB0\xB4\xE4\xBB\x99"
    "\xE8\x8A\xB1\xE6\x95\xB0";
/* 不支持的请求返回“错误:不支持的请求。”,同样遵守长度前缀协议。 */
const char ERROR_REPLY[] =
    "\xE9\x94\x99\xE8\xAF\xAF\xEF\xBC\x9A\xE4\xB8\x8D"
    "\xE6\x94\xAF\xE6\x8C\x81\xE7\x9A\x84\xE8\xAF\xB7"
    "\xE6\xB1\x82\xE3\x80\x82";

/* 算法只在 narcissistic.cpp 中实现;服务器链接该文件,客户端不执行计算。 */
bool IsNarcissistic(int number);
int FindNarcissisticNumbers(int first, int last, int *numbers, int capacity);
int BuildNarcissisticReply(char *output, int capacity);

/*
 * 每条 TCP 连接有自己的状态;一次连接处理一个请求和一个响应,然后关闭。
 * inputLength 是已收字节数;sent 是已发送字节数。保留它们才能正确处理拆包和
 * 部分发送。数组容量固定,收到伪造的超大长度时不会申请无限内存。
 */
struct TransferState
{
    char input[MAX_PACKET_SIZE];
    int inputLength;
    char output[MAX_PACKET_SIZE];
    int outputLength;
    int sent;
};

inline void ResetTransfer(TransferState *state)
{
    state->inputLength = 0;
    state->outputLength = 0;
    state->sent = 0;
}

/* 打包后返回准确字节数;C 字符串结尾的 '\0' 不属于网络正文。 */
inline int BuildPacket(char *packet, int capacity, const char *payload, int length)
{
    u_long networkLength;
    if (packet == NULL || length < 0 || length > MAX_PAYLOAD_SIZE ||
        capacity < PACKET_HEADER_SIZE + length || (length > 0 && payload == NULL))
        return 0;
    networkLength = htonl((u_long)length);
    memcpy(packet, &networkLength, PACKET_HEADER_SIZE);
    if (length > 0)
        memcpy(packet + PACKET_HEADER_SIZE, payload, length);
    return PACKET_HEADER_SIZE + length;
}

/* 检查已有缓冲区:1=完整,0=待续,-1=非法长度。使用 memcpy 避免未对齐访问。 */
inline int PacketStatus(const TransferState *state, int *length)
{
    u_long networkLength;
    if (state->inputLength < PACKET_HEADER_SIZE)
        return 0;
    memcpy(&networkLength, state->input, PACKET_HEADER_SIZE);
    networkLength = ntohl(networkLength);
    if (networkLength > (u_long)MAX_PAYLOAD_SIZE)
        return -1;
    *length = (int)networkLength;
    return state->inputLength >= PACKET_HEADER_SIZE + *length ? 1 : 0;
}

/*
 * 非阻塞接收。先只读满 4 字节头部,再按合法长度读取正文;一次 recv 不必读满。
 * 每次最多读取当前帧尚缺的字节,所以即使多帧粘在 TCP 流中,也不会把第二帧
 * 混入第一帧。这里明确采用“一连接一问一答”,后续帧不会被执行。
 * 返回 1=完整帧,0=暂时无数据,-1=协议/套接字错误,-2=对端提前关闭。
 */
inline int ReceivePacket(SOCKET socketValue, TransferState *state,
                         int *length, int *socketError)
{
    *socketError = 0;
    for (;;)
    {
        int status = PacketStatus(state, length);
        int target = PACKET_HEADER_SIZE;
        int received;
        if (status != 0)
            return status;
        if (state->inputLength >= PACKET_HEADER_SIZE)
            target += *length;
        received = recv(socketValue, state->input + state->inputLength,
                        target - state->inputLength, 0);
        if (received > 0)
        {
            state->inputLength += received;
            continue;
        }
        if (received == 0)
            return -2;
        *socketError = WSAGetLastError();
        if (*socketError == WSAEWOULDBLOCK)
        {
            *socketError = 0; /* 暂时不可读不属于通信失败。 */
            return 0;
        }
        return -1;
    }
}

/*
 * 有新数据时立即调用 send,而不是等待一个未必再次产生的 FD_WRITE。
 * 只有 send 返回 WSAEWOULDBLOCK 后,才等待 FD_WRITE 并从 sent 偏移继续。
 * 返回 1=全部提交给 TCP,0=暂时阻塞,-1=真实错误。
 */
inline int FlushOutput(SOCKET socketValue, TransferState *state, int *socketError)
{
    *socketError = 0;
    while (state->sent < state->outputLength)
    {
        int count = send(socketValue, state->output + state->sent,
                         state->outputLength - state->sent, 0);
        if (count > 0)
        {
            state->sent += count;
            continue;
        }
        *socketError = count == 0 ? WSAECONNRESET : WSAGetLastError();
        if (*socketError == WSAEWOULDBLOCK)
        {
            *socketError = 0;
            return 0;
        }
        return -1;
    }
    return 1;
}

/* 先取消关联并关闭套接字,再关闭事件;closesocket 不会自动释放 WSAEVENT。 */
inline void CloseSocketEvent(SOCKET *socketValue, WSAEVENT *eventValue)
{
    if (*socketValue != INVALID_SOCKET)
    {
        WSAEventSelect(*socketValue, NULL, 0);
        closesocket(*socketValue);
        *socketValue = INVALID_SOCKET;
    }
    if (*eventValue != WSA_INVALID_EVENT)
    {
        WSACloseEvent(*eventValue);
        *eventValue = WSA_INVALID_EVENT;
    }
}

/* 日志为只读多行编辑框。限制累计长度,避免长时间运行后控件无限增长。 */
inline void AppendLog(HWND edit, const wchar_t *text)
{
    int length;
    if (edit == NULL || text == NULL)
        return;
    length = GetWindowTextLengthW(edit);
    if (length > 60000)
    {
        SetWindowTextW(edit, L"(较早的日志已清理)\r\n");
        length = GetWindowTextLengthW(edit);
    }
    SendMessageW(edit, EM_SETSEL, (WPARAM)length, (LPARAM)length);
    SendMessageW(edit, EM_REPLACESEL, FALSE, (LPARAM)text);
    SendMessageW(edit, EM_REPLACESEL, FALSE, (LPARAM)L"\r\n");
    SendMessageW(edit, EM_SCROLLCARET, 0, 0);
}

/* 按显式字节数转换,不能把网络缓冲区直接当作以 NUL 结尾的字符串。 */
inline void AppendLogUtf8(HWND edit, const char *text, int length)
{
    wchar_t wide[MAX_PAYLOAD_SIZE + 1];
    int count;
    if (length <= 0 || length > MAX_PAYLOAD_SIZE)
    {
        AppendLog(edit, L"(空正文或无效长度)");
        return;
    }
    count = MultiByteToWideChar(CP_UTF8, 0, text, length, wide, MAX_PAYLOAD_SIZE);
    if (count == 0)
        AppendLog(edit, L"UTF-8 文本转换失败。");
    else
    {
        wide[count] = L'\0';
        AppendLog(edit, wide);
    }
}

inline void AppendSocketError(HWND edit, const wchar_t *operation, int error)
{
    wchar_t systemText[256];
    wchar_t line[512];
    systemText[0] = L'\0';
    FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                   NULL, (DWORD)error, 0, systemText, 256, NULL);
    wsprintfW(line, L"%s 失败,错误码 %d:%s", operation, error, systemText);
    AppendLog(edit, line);
}

/* 逐字符验证 ASCII,拒绝中文、过长输入以及隐式截断后的地址。 */
inline bool ReadAsciiText(HWND edit, char *output, int capacity)
{
    wchar_t text[128];
    int length = GetWindowTextLengthW(edit);
    int index;
    if (length >= 128 || length >= capacity)
        return false;
    GetWindowTextW(edit, text, 128);
    for (index = 0; index < length; ++index)
    {
        if (text[index] > 127)
            return false;
        output[index] = (char)text[index];
    }
    output[length] = '\0';
    return true;
}

inline bool ReadPort(HWND edit, unsigned short *port)
{
    char text[8];
    unsigned long value = 0;
    int index;
    if (!ReadAsciiText(edit, text, sizeof(text)) || text[0] == '\0')
        return false;
    for (index = 0; text[index] != '\0'; ++index)
    {
        if (text[index] < '0' || text[index] > '9')
            return false;
        value = value * 10 + (text[index] - '0');
        if (value > 65535)
            return false;
    }
    *port = (unsigned short)value;
    return value != 0;
}

/*
 * 严格解析四段十进制 IPv4,不接受 inet_addr 的缩写、八进制等歧义形式。
 * 本地绑定可用 0.0.0.0;远端地址必须具体;拒绝广播地址。
 */
inline bool MakeAddress(const char *ip, unsigned short port, bool allowAny,
                        sockaddr_in *address)
{
    unsigned long value = 0;
    int part;
    const char *cursor = ip;
    for (part = 0; part < 4; ++part)
    {
        unsigned int octet = 0;
        int digits = 0;
        while (*cursor >= '0' && *cursor <= '9')
        {
            octet = octet * 10 + (*cursor++ - '0');
            if (++digits > 3 || octet > 255)
                return false;
        }
        if (digits == 0 || (part < 3 ? *cursor != '.' : *cursor != '\0'))
            return false;
        value = (value << 8) | octet;
        if (part < 3)
            ++cursor;
    }
    if ((!allowAny && value == 0) || value == 0xffffffffUL)
        return false;
    memset(address, 0, sizeof(*address));
    address->sin_family = AF_INET;
    address->sin_port = htons(port);
    address->sin_addr.s_addr = htonl(value);
    return true;
}

/* 简化重复的控件创建代码。控件编号用于 WM_COMMAND 分派。 */
inline HWND MakeControl(HWND parent, const wchar_t *kind, const wchar_t *text,
                        DWORD style, int x, int y, int width, int height, int id)
{
    HWND control = CreateWindowExW(wcscmp(kind, L"EDIT") == 0 ? WS_EX_CLIENTEDGE : 0,
        kind, text, WS_CHILD | WS_VISIBLE | style, x, y, width, height,
        parent, (HMENU)(size_t)id, GetModuleHandle(NULL), NULL);
    SendMessageW(control, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), TRUE);
    return control;
}

/*
 * WSAEventSelect 的核心是“事件对象”,不是窗口套接字消息或定时器轮询。
 * 为使单线程 Win32 界面也能响应,MsgWaitForMultipleObjects 同时等待网络事件
 * 和 GUI 消息;网络唤醒后用 WSAWaitForMultipleEvents 确认事件,再由回调调用
 * WSAEnumNetworkEvents 原子地读取/清除网络记录并复位事件。
 * 不单独 WSAResetEvent,否则可能丢失与读取并发发生的新网络事件。
 *
 * 每次分派后重建数组,避免处理关闭连接后失效的事件句柄;key 保存业务槽位。
 * 本实验最多 33 个网络事件,低于 MAXIMUM_WAIT_OBJECTS - 1 的 GUI 等待上限。
 */
typedef int (*CollectEventsFunction)(WSAEVENT *events, int *keys);
typedef void (*DispatchEventFunction)(int key);
inline int RunEventMessageLoop(HWND window, CollectEventsFunction collect,
                               DispatchEventFunction dispatch)
{
    for (;;)
    {
        MSG message;
        WSAEVENT events[MAX_CLIENTS + 1];
        int keys[MAX_CLIENTS + 1];
        int count;
        DWORD result;
        while (PeekMessageW(&message, NULL, 0, 0, PM_REMOVE))
        {
            if (message.message == WM_QUIT)
                return (int)message.wParam;
            if (!IsDialogMessageW(window, &message))
            {
                TranslateMessage(&message);
                DispatchMessageW(&message);
            }
        }
        count = collect(events, keys);
        result = MsgWaitForMultipleObjects((DWORD)count, events, FALSE,
                                           INFINITE, QS_ALLINPUT);
        if (result == WAIT_FAILED)
        {
            MessageBoxW(window, L"事件等待失败,程序将退出。", L"错误", MB_ICONERROR);
            DestroyWindow(window);
            return 1;
        }
        if (result >= WAIT_OBJECT_0 + (DWORD)count)
            continue; /* GUI 消息就绪;下一轮把消息全部取出。 */
        {
            DWORD index = result - WAIT_OBJECT_0;
            DWORD ready = WSAWaitForMultipleEvents(1, &events[index], FALSE, 0, FALSE);
            if (ready == WSA_WAIT_EVENT_0)
                dispatch(keys[index]);
            else if (ready == WSA_WAIT_FAILED)
            {
                MessageBoxW(window, L"WSAWaitForMultipleEvents 失败。", L"错误", MB_ICONERROR);
                DestroyWindow(window);
                return 1;
            }
        }
    }
}

/* 两个 exe 共用窗口注册代码;WinMain 和窗口过程仍分别位于各自源文件中。 */
inline HWND CreateMainWindow(HINSTANCE instance, const wchar_t *className,
                             const wchar_t *title, WNDPROC procedure)
{
    WNDCLASSEXW windowClass;
    memset(&windowClass, 0, sizeof(windowClass));
    windowClass.cbSize = sizeof(windowClass);
    windowClass.lpfnWndProc = procedure;
    windowClass.hInstance = instance;
    windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    windowClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    windowClass.lpszClassName = className;
    if (!RegisterClassExW(&windowClass))
        return NULL;
    return CreateWindowExW(0, className, title, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 820, 510, NULL, NULL, instance, NULL);
}

#endif


3. 水仙花数算法文件实现

算法文件分别实现单个整数判断、区间枚举和响应正文生成。

  • IsNarcissistic() 首先排除非三位数,再提取各位数字进行整数运算。
  • FindNarcissisticNumbers() 检查查询区间和结果数组容量,按升序保存符合条件的整数。
  • BuildNarcissisticReply() 调用枚举函数,将实际结果与数量组织为 UTF-8 正文。

响应生成时同时检查输出容量,并为本地字符串终止符预留空间;传输时仍依据显式正文长度封装数据帧。

点击展开/收起:narcissistic.cpp(水仙花数算法完整代码)
#include "wsaevent_common.h"

/*
 * 水仙花数算法文件。
 * 按 Requirements.txt 的定义,仅考虑三位数:n = 百位^3 + 十位^3 + 个位^3。
 * 即使 1 也等于自身各位的立方和,它不是三位数,所以不属于本实验的答案。
 * 不使用浮点 pow,直接做整数乘法,避免舍入误差且容易阅读。
 */
bool IsNarcissistic(int number)
{
    int hundreds;
    int tens;
    int units;
    if (number < 100 || number > 999)
        return false;
    hundreds = number / 100;
    tens = (number / 10) % 10;
    units = number % 10;
    return number == hundreds * hundreds * hundreds +
                     tens * tens * tens + units * units * units;
}

/*
 * 枚举闭区间 [first, last],结果按从小到大存入 numbers。
 * 返回找到的数量;返回 -1 表示参数错误或数组容量不足。
 * 先把区间限制到 [100, 999],因此最多判断 900 次,也避免极端整数边界溢出。
 * 每个候选数的判断耗时固定,扫描区间的时间复杂度 O(N),辅助空间 O(1)。
 */
int FindNarcissisticNumbers(int first, int last, int *numbers, int capacity)
{
    int number;
    int count = 0;
    if (numbers == NULL || capacity < 0 || first > last)
        return -1;
    if (first < 100)
        first = 100;
    if (last > 999)
        last = 999;
    for (number = first; number <= last; ++number)
    {
        if (IsNarcissistic(number))
        {
            if (count >= capacity)
                return -1;
            numbers[count++] = number;
        }
    }
    return count;
}

/* 追加正文时预留字符串终止字节。返回的网络正文长度仍不包括终止字节。 */
static bool AppendText(char *output, int capacity, int *length, const char *text)
{
    int count = (int)strlen(text);
    if (count >= capacity - *length)
        return false;
    memcpy(output + *length, text, count);
    *length += count;
    output[*length] = '\0';
    return true;
}

/*
 * 每收到合法请求才调用算法计算,不能把 153、370、371、407 硬编码为业务答案。
 * 输出示例:1到1000内所有的水仙花数:\r\n153 370 371 407\r\n共4个。
 * 返回正文 UTF-8 字节数;0 表示容量不够或算法参数异常。
 */
int BuildNarcissisticReply(char *output, int capacity)
{
    const char prefix[] =
        "1\xE5\x88\xB0" "1000\xE5\x86\x85\xE6\x89\x80"
        "\xE6\x9C\x89\xE7\x9A\x84\xE6\xB0\xB4\xE4\xBB\x99"
        "\xE8\x8A\xB1\xE6\x95\xB0\xEF\xBC\x9A\r\n";
    int numbers[900];
    int count = FindNarcissisticNumbers(1, 1000, numbers, 900);
    int index;
    int length = 0;
    char text[32];
    if (output == NULL || capacity <= 0 || count < 0)
        return 0;
    output[0] = '\0';
    if (!AppendText(output, capacity, &length, prefix))
        return 0;
    for (index = 0; index < count; ++index)
    {
        /* 每个数字至多三位,32 字节临时数组足够容纳数字和分隔空格。 */
        sprintf(text, index == 0 ? "%d" : " %d", numbers[index]);
        if (!AppendText(output, capacity, &length, text))
            return 0;
    }
    sprintf(text, "\r\n\xE5\x85\xB1%d\xE4\xB8\xAA\xE3\x80\x82", count);
    if (!AppendText(output, capacity, &length, text))
        return 0;
    return length;
}


4. 服务器端实现

服务器处理请求时,将客户端请求与预定 UTF-8 命令进行比较;合法请求调用 BuildNarcissisticReply(),非法请求返回错误正文。服务器窗口过程根据网络事件调用对应函数。

点击展开/收起:server.cpp(服务器端完整代码)
#include "wsaevent_common.h"

/*
 * 服务器:初始化 Winsock -> socket/bind/listen -> WSAEventSelect -> 等待事件。
 * 监听事件负责 accept;每个客户端独立拥有套接字、事件对象、收发状态和超时。
 * FD_READ 收到完整请求后调用 narcissistic.cpp 计算,再通过 send 返回结果。
 * 所有操作由同一界面线程完成,不存在跨线程访问控件或共享缓冲区的问题。
 */
enum { ID_IP = 101, ID_PORT, ID_TOGGLE, ID_LOG, SERVER_TIMER = 1 };
struct ClientState
{
    SOCKET socketValue;
    WSAEVENT eventValue;
    TransferState transfer;
    DWORD started;  /* GetTickCount 起始时刻,使用无符号差值安全处理计数回绕。 */
    bool replying; /* true 表示请求已经处理,后续不能重复计算或覆盖发送缓冲区。 */
};

static HWND g_window = NULL;
static HWND g_ipEdit = NULL;
static HWND g_portEdit = NULL;
static HWND g_toggleButton = NULL;
static HWND g_logEdit = NULL;
static SOCKET g_listener = INVALID_SOCKET;
static WSAEVENT g_listenerEvent = WSA_INVALID_EVENT;
static ClientState g_clients[MAX_CLIENTS];
static bool g_winsockStarted = false;

/* 只清理指定连接,其余客户端和监听套接字继续工作。 */
static void CloseClient(int index, const wchar_t *reason)
{
    if (g_clients[index].socketValue == INVALID_SOCKET)
        return;
    CloseSocketEvent(&g_clients[index].socketValue, &g_clients[index].eventValue);
    ResetTransfer(&g_clients[index].transfer);
    g_clients[index].replying = false;
    if (reason != NULL)
        AppendLog(g_logEdit, reason);
}

static void StopServer(void)
{
    int index;
    KillTimer(g_window, SERVER_TIMER);
    for (index = 0; index < MAX_CLIENTS; ++index)
        CloseClient(index, NULL);
    CloseSocketEvent(&g_listener, &g_listenerEvent);
    EnableWindow(g_ipEdit, TRUE);
    EnableWindow(g_portEdit, TRUE);
    SetWindowTextW(g_toggleButton, L"开始监听");
}

/* 参数校验或资源创建失败时走统一清理路径,保证用户可以修改参数后重新启动。 */
static bool StartServer(void)
{
    char ip[64];
    unsigned short port;
    sockaddr_in local;
    BOOL exclusive = TRUE;
    wchar_t line[256];
    if (!ReadAsciiText(g_ipEdit, ip, sizeof(ip)) || !ReadPort(g_portEdit, &port) ||
        !MakeAddress(ip, port, true, &local))
    {
        AppendLog(g_logEdit, L"请输入合法的本机 IPv4 地址和 1~65535 的端口。");
        return false;
    }
    g_listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (g_listener == INVALID_SOCKET)
    {
        AppendSocketError(g_logEdit, L"socket", WSAGetLastError());
        return false;
    }
    /* 独占地址,防止另一服务器悄悄复用相同监听端口。 */
    if (setsockopt(g_listener, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
                   (const char *)&exclusive, sizeof(exclusive)) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"setsockopt", WSAGetLastError());
        StopServer();
        return false;
    }
    if (bind(g_listener, (sockaddr *)&local, sizeof(local)) == SOCKET_ERROR ||
        listen(g_listener, SOMAXCONN) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"bind/listen", WSAGetLastError());
        StopServer();
        return false;
    }
    g_listenerEvent = WSACreateEvent();
    if (g_listenerEvent == WSA_INVALID_EVENT ||
        WSAEventSelect(g_listener, g_listenerEvent, FD_ACCEPT | FD_CLOSE) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"创建/关联监听事件", WSAGetLastError());
        StopServer();
        return false;
    }
    /* 定时器仅检查连接超时,网络就绪由事件对象唤醒,绝不靠定时器轮询。 */
    if (SetTimer(g_window, SERVER_TIMER, 1000, NULL) == 0)
    {
        AppendLog(g_logEdit, L"无法创建超时定时器。");
        StopServer();
        return false;
    }
    EnableWindow(g_ipEdit, FALSE);
    EnableWindow(g_portEdit, FALSE);
    SetWindowTextW(g_toggleButton, L"停止监听");
    wsprintfW(line, L"已监听 %S:%u,使用 WSAEventSelect,最多接入 %d 个客户端。",
              ip, (unsigned int)port, MAX_CLIENTS);
    AppendLog(g_logEdit, line);
    return true;
}

/* 完成发送后用 SD_SEND 正常结束发送方向;默认关闭方式让 TCP 继续发送已排队数据。 */
static void TrySendReply(int index)
{
    ClientState *client = &g_clients[index];
    int error = 0;
    int status;
    if (!client->replying)
        return;
    status = FlushOutput(client->socketValue, &client->transfer, &error);
    if (status == 1)
    {
        shutdown(client->socketValue, SD_SEND);
        CloseClient(index, L"响应已提交给 TCP,本次连接结束,继续等待其他请求。");
    }
    else if (status < 0)
    {
        AppendSocketError(g_logEdit, L"send", error);
        CloseClient(index, NULL);
    }
}

static void PrepareReply(int index, int payloadLength)
{
    ClientState *client = &g_clients[index];
    const char *payload = client->transfer.input + PACKET_HEADER_SIZE;
    char reply[MAX_PAYLOAD_SIZE];
    int replyLength;
    /* 同时比较长度和全部字节,避免只匹配前缀或被正文中的 NUL 干扰。 */
    if (payloadLength == (int)strlen(REQUEST_TEXT) &&
        memcmp(payload, REQUEST_TEXT, payloadLength) == 0)
    {
        AppendLog(g_logEdit, L"收到合法请求:");
        AppendLogUtf8(g_logEdit, payload, payloadLength);
        replyLength = BuildNarcissisticReply(reply, sizeof(reply));
    }
    else
    {
        AppendLog(g_logEdit, L"收到不支持的请求,将返回错误正文。");
        replyLength = (int)strlen(ERROR_REPLY);
        memcpy(reply, ERROR_REPLY, replyLength);
    }
    if (replyLength <= 0)
    {
        CloseClient(index, L"构造响应失败。");
        return;
    }
    AppendLogUtf8(g_logEdit, reply, replyLength);
    client->transfer.outputLength = BuildPacket(client->transfer.output,
        sizeof(client->transfer.output), reply, replyLength);
    client->transfer.sent = 0;
    if (client->transfer.outputLength == 0)
    {
        CloseClient(index, L"响应超过协议允许的长度。");
        return;
    }
    client->replying = true;
    TrySendReply(index); /* 主动首次发送,不能仅依赖初始 FD_WRITE 的先后顺序。 */
}

static void HandleClientRead(int index)
{
    int length = 0;
    int error = 0;
    int status = ReceivePacket(g_clients[index].socketValue,
                               &g_clients[index].transfer, &length, &error);
    if (status == 1)
        PrepareReply(index, length);
    else if (status == -2)
        CloseClient(index, L"客户端在请求完整到达前关闭了连接。");
    else if (status < 0)
    {
        if (error != 0)
            AppendSocketError(g_logEdit, L"recv", error);
        CloseClient(index, L"请求接收失败或长度字段超过 8192 字节。");
    }
}

/*
 * 新连接继承监听套接字的事件关联,因此必须为 accept 得到的套接字重新关联
 * 独立事件,监视 FD_READ/FD_WRITE/FD_CLOSE;监听事件继续只处理新的连接。
 * 每轮接受次数有上限,避免持续连接请求使图形界面长期得不到执行机会。
 */
static void AcceptClients(void)
{
    int accepted;
    for (accepted = 0; accepted < MAX_CLIENTS; ++accepted)
    {
        sockaddr_in peer;
        int peerLength = sizeof(peer);
        SOCKET value = accept(g_listener, (sockaddr *)&peer, &peerLength);
        WSAEVENT eventValue;
        int index;
        wchar_t line[256];
        if (value == INVALID_SOCKET)
        {
            int error = WSAGetLastError();
            if (error != WSAEWOULDBLOCK)
                AppendSocketError(g_logEdit, L"accept", error);
            return;
        }
        for (index = 0; index < MAX_CLIENTS; ++index)
            if (g_clients[index].socketValue == INVALID_SOCKET)
                break;
        if (index == MAX_CLIENTS)
        {
            closesocket(value);
            AppendLog(g_logEdit, L"连接数已满,拒绝新连接。");
            continue;
        }
        eventValue = WSACreateEvent();
        if (eventValue == WSA_INVALID_EVENT ||
            WSAEventSelect(value, eventValue, FD_READ | FD_WRITE | FD_CLOSE) == SOCKET_ERROR)
        {
            AppendSocketError(g_logEdit, L"创建/关联客户端事件", WSAGetLastError());
            CloseSocketEvent(&value, &eventValue);
            continue;
        }
        g_clients[index].socketValue = value;
        g_clients[index].eventValue = eventValue;
        g_clients[index].started = GetTickCount();
        g_clients[index].replying = false;
        ResetTransfer(&g_clients[index].transfer);
        wsprintfW(line, L"客户端接入:%S:%u", inet_ntoa(peer.sin_addr),
                  (unsigned int)ntohs(peer.sin_port));
        AppendLog(g_logEdit, line);
    }
}

/* key=-1 为监听事件;其他 key 为客户端数组下标。WSANETWORKEVENTS 是位掩码! */
static void HandleNetworkEvent(int key)
{
    WSANETWORKEVENTS events;
    if (key == -1)
    {
        if (WSAEnumNetworkEvents(g_listener, g_listenerEvent, &events) == SOCKET_ERROR)
        {
            AppendSocketError(g_logEdit, L"WSAEnumNetworkEvents(listener)", WSAGetLastError());
            StopServer();
            return;
        }
        if (events.lNetworkEvents & FD_ACCEPT)
        {
            if (events.iErrorCode[FD_ACCEPT_BIT] == 0)
                AcceptClients();
            else
                AppendSocketError(g_logEdit, L"FD_ACCEPT", events.iErrorCode[FD_ACCEPT_BIT]);
        }
        if (events.lNetworkEvents & FD_CLOSE)
        {
            AppendLog(g_logEdit, L"监听套接字已关闭。");
            StopServer();
        }
        return;
    }
    ClientState *client = &g_clients[key];
    if (WSAEnumNetworkEvents(client->socketValue, client->eventValue, &events) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"WSAEnumNetworkEvents(client)", WSAGetLastError());
        CloseClient(key, NULL);
        return;
    }
    if ((events.lNetworkEvents & FD_READ) && events.iErrorCode[FD_READ_BIT] != 0)
    {
        AppendSocketError(g_logEdit, L"FD_READ", events.iErrorCode[FD_READ_BIT]);
        CloseClient(key, NULL);
        return;
    }
    /* FD_CLOSE 可能与最后的数据同时出现,必须先尝试读完请求,不能直接丢弃。 */
    if (!client->replying && (events.lNetworkEvents & (FD_READ | FD_CLOSE)))
        HandleClientRead(key);
    if (client->socketValue == INVALID_SOCKET)
        return;
    if (events.lNetworkEvents & FD_WRITE)
    {
        if (events.iErrorCode[FD_WRITE_BIT] != 0)
        {
            AppendSocketError(g_logEdit, L"FD_WRITE", events.iErrorCode[FD_WRITE_BIT]);
            CloseClient(key, NULL);
            return;
        }
        TrySendReply(key);
    }
    if (client->socketValue != INVALID_SOCKET && (events.lNetworkEvents & FD_CLOSE))
    {
        if (events.iErrorCode[FD_CLOSE_BIT] != 0)
        {
            AppendSocketError(g_logEdit, L"FD_CLOSE", events.iErrorCode[FD_CLOSE_BIT]);
            CloseClient(key, NULL);
        }
        else if (!client->replying)
            CloseClient(key, L"客户端连接结束,请求未完成。");
        /* 正常 FIN 仅关闭对端发送方向;若响应还没发完,继续等待 FD_WRITE。 */
    }
}

/* 轮转客户端顺序以避免低下标的活跃连接长期占据优先级。 */
static int CollectEvents(WSAEVENT *events, int *keys)
{
    static int next = 0;
    int count = 0;
    int offset;
    for (offset = 0; offset < MAX_CLIENTS; ++offset)
    {
        int index = (next + offset) % MAX_CLIENTS;
        if (g_clients[index].socketValue != INVALID_SOCKET)
        {
            events[count] = g_clients[index].eventValue;
            keys[count++] = index;
        }
    }
    next = (next + 1) % MAX_CLIENTS;
    if (g_listener != INVALID_SOCKET)
    {
        events[count] = g_listenerEvent;
        keys[count++] = -1;
    }
    return count;
}

static LRESULT CALLBACK ServerWindowProc(HWND window, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
    {
        WSADATA data;
        int index;
        int error;
        g_window = window;
        for (index = 0; index < MAX_CLIENTS; ++index)
        {
            g_clients[index].socketValue = INVALID_SOCKET;
            g_clients[index].eventValue = WSA_INVALID_EVENT;
        }
        MakeControl(window, L"STATIC", L"监听地址", 0, 12, 16, 68, 24, 0);
        g_ipEdit = MakeControl(window, L"EDIT", DEFAULT_SERVER_IP, WS_TABSTOP | ES_AUTOHSCROLL,
                                82, 12, 150, 26, ID_IP);
        MakeControl(window, L"STATIC", L"端口", 0, 250, 16, 40, 24, 0);
        g_portEdit = MakeControl(window, L"EDIT", L"1145", WS_TABSTOP | ES_NUMBER,
                                  295, 12, 70, 26, ID_PORT);
        g_toggleButton = MakeControl(window, L"BUTTON", L"开始监听", WS_TABSTOP,
                                      385, 11, 120, 28, ID_TOGGLE);
        MakeControl(window, L"STATIC", L"算法:三位数等于各位数字的立方和;范围:1~1000。",
                    0, 12, 52, 760, 24, 0);
        g_logEdit = MakeControl(window, L"EDIT", L"", WS_TABSTOP | WS_VSCROLL |
            ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY, 12, 84, 770, 360, ID_LOG);
        SendMessageW(g_logEdit, EM_SETLIMITTEXT, 100000, 0);
        error = WSAStartup(MAKEWORD(2, 2), &data);
        if (error != 0)
        {
            MessageBoxW(window, L"Winsock 2.2 初始化失败。", L"服务器", MB_ICONERROR);
            return -1;
        }
        g_winsockStarted = true;
        AppendLog(g_logEdit, L"请确认监听地址属于本机,然后点击“开始监听”。");
        AppendLog(g_logEdit, L"本机测试可改为 127.0.0.1;两机实验填写服务器实际 IPv4 地址。");
        return 0;
    }
    case WM_COMMAND:
        if (LOWORD(wParam) == ID_TOGGLE && HIWORD(wParam) == BN_CLICKED)
        {
            if (g_listener == INVALID_SOCKET)
                StartServer();
            else
            {
                StopServer();
                AppendLog(g_logEdit, L"服务器已停止。");
            }
        }
        return 0;
    case WM_TIMER:
        if (wParam == SERVER_TIMER)
        {
            int index;
            DWORD now = GetTickCount();
            for (index = 0; index < MAX_CLIENTS; ++index)
                if (g_clients[index].socketValue != INVALID_SOCKET &&
                    (DWORD)(now - g_clients[index].started) >= TRANSACTION_TIMEOUT)
                    CloseClient(index, L"连接超过 15 秒仍未完成,已释放资源。");
        }
        return 0;
    case WM_GETMINMAXINFO:
        ((MINMAXINFO *)lParam)->ptMinTrackSize.x = 650;
        ((MINMAXINFO *)lParam)->ptMinTrackSize.y = 350;
        return 0;
    case WM_SIZE:
        if (g_logEdit != NULL && wParam != SIZE_MINIMIZED)
            MoveWindow(g_logEdit, 12, 84, LOWORD(lParam) - 24, HIWORD(lParam) - 96, TRUE);
        return 0;
    case WM_DESTROY:
        StopServer();
        if (g_winsockStarted)
        {
            WSACleanup();
            g_winsockStarted = false;
        }
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProcW(window, message, wParam, lParam);
}

/* Win32 GUI 入口,网络事件处理入口在 RunEventMessageLoop 的 dispatch 回调中。 */
int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, int showCommand)
{
    HWND window;
    (void)previous;
    (void)commandLine;
    window = CreateMainWindow(instance, L"WSAEventSelectNarcissisticServer",
        L"WSAEventSelect 水仙花数服务器", ServerWindowProc);
    if (window == NULL)
        return 1;
    ShowWindow(window, showCommand);
    UpdateWindow(window);
    return RunEventMessageLoop(window, CollectEvents, HandleNetworkEvent);
}


5. 客户端实现

客户端通过 StartRequest() 校验地址与端口,封装固定请求,创建套接字并按需绑定本地地址。在调用 connect() 前关联网络事件,使连接过程以非阻塞方式进行。

ConnectionEstablished() 统一处理立即连接成功和 FD_CONNECT 成功两种情况,避免重复启动发送。TrySendRequest() 维护请求发送进度,HandleReplyRead() 按长度前缀协议接收并显示服务器响应。

通信进行期间,客户端暂时禁用相关输入控件。无论事务成功、失败或超时,均通过统一清理函数恢复可操作状态。

点击展开/收起:client.cpp(客户端完整代码)
#include "wsaevent_common.h"

/*
 * 客户端状态机:空闲 -> 非阻塞连接 -> 发送固定请求 -> 接收完整响应 -> 空闲。
 * 点击按钮启动一次查询;每次查询都创建新的连接,可连续多次操作。
 * 本文件只负责通信和显示;水仙花数在服务器端计算,客户端不伪造或本地生成答案。
 */
enum { ID_SERVER_IP = 201, ID_LOCAL_IP, ID_PORT, ID_SEND, ID_LOG, CLIENT_TIMER = 1 };
static HWND g_window = NULL;
static HWND g_serverIpEdit = NULL;
static HWND g_localIpEdit = NULL;
static HWND g_portEdit = NULL;
static HWND g_sendButton = NULL;
static HWND g_logEdit = NULL;
static SOCKET g_socket = INVALID_SOCKET;
static WSAEVENT g_event = WSA_INVALID_EVENT;
static TransferState g_transfer;
static bool g_connected = false;
static bool g_requestSent = false;
static bool g_winsockStarted = false;

static void SetInputsEnabled(BOOL enabled)
{
    EnableWindow(g_serverIpEdit, enabled);
    EnableWindow(g_localIpEdit, enabled);
    EnableWindow(g_portEdit, enabled);
    EnableWindow(g_sendButton, enabled);
}

/* 任意成功或失败分支都恢复界面和资源,用户可以直接再次发起查询。 */
static void CloseConnection(void)
{
    KillTimer(g_window, CLIENT_TIMER);
    CloseSocketEvent(&g_socket, &g_event);
    ResetTransfer(&g_transfer);
    g_connected = false;
    g_requestSent = false;
    SetInputsEnabled(TRUE);
}

static void TrySendRequest(void)
{
    int error = 0;
    int status;
    if (!g_connected || g_requestSent)
        return;
    status = FlushOutput(g_socket, &g_transfer, &error);
    if (status == 1)
    {
        g_requestSent = true;
        AppendLog(g_logEdit, L"请求已发送:");
        AppendLogUtf8(g_logEdit, REQUEST_TEXT, (int)strlen(REQUEST_TEXT));
        AppendLog(g_logEdit, L"等待服务器计算并返回结果……");
    }
    else if (status < 0)
    {
        AppendSocketError(g_logEdit, L"send", error);
        CloseConnection();
    }
}

/* connect 可能立即成功,也可能随后产生 FD_CONNECT;此保护避免同一请求发送两遍。 */
static void ConnectionEstablished(void)
{
    sockaddr_in local;
    int length = sizeof(local);
    wchar_t line[256];
    if (g_connected)
        return;
    g_connected = true;
    if (getsockname(g_socket, (sockaddr *)&local, &length) == 0)
    {
        wsprintfW(line, L"连接成功,本地端点:%S:%u", inet_ntoa(local.sin_addr),
                  (unsigned int)ntohs(local.sin_port));
        AppendLog(g_logEdit, line);
    }
    TrySendRequest();
}

static void StartRequest(void)
{
    char serverIp[64];
    char localIp[64];
    unsigned short port;
    sockaddr_in remote;
    sockaddr_in local;
    int result;
    if (g_socket != INVALID_SOCKET)
        return;
    if (!ReadAsciiText(g_serverIpEdit, serverIp, sizeof(serverIp)) ||
        !ReadAsciiText(g_localIpEdit, localIp, sizeof(localIp)) ||
        !ReadPort(g_portEdit, &port) || !MakeAddress(serverIp, port, false, &remote))
    {
        AppendLog(g_logEdit, L"服务器 IPv4 地址或端口格式不正确。");
        return;
    }
    /* 本地地址留空时由系统选网卡;指定时必须确实属于运行客户端的计算机。 */
    if (localIp[0] != '\0' && !MakeAddress(localIp, 0, true, &local))
    {
        AppendLog(g_logEdit, L"本地 IPv4 地址格式不正确。");
        return;
    }
    ResetTransfer(&g_transfer);
    g_transfer.outputLength = BuildPacket(g_transfer.output, sizeof(g_transfer.output),
                                           REQUEST_TEXT, (int)strlen(REQUEST_TEXT));
    g_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (g_socket == INVALID_SOCKET)
    {
        AppendSocketError(g_logEdit, L"socket", WSAGetLastError());
        return;
    }
    if (localIp[0] != '\0' && bind(g_socket, (sockaddr *)&local, sizeof(local)) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"客户端 bind", WSAGetLastError());
        CloseConnection();
        return;
    }
    g_event = WSACreateEvent();
    if (g_event == WSA_INVALID_EVENT || WSAEventSelect(g_socket, g_event,
        FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"创建/关联客户端事件", WSAGetLastError());
        CloseConnection();
        return;
    }
    /* WSAEventSelect 必须在 connect 前调用,它也会自动启用非阻塞模式。 */
    SetInputsEnabled(FALSE);
    if (SetTimer(g_window, CLIENT_TIMER, TRANSACTION_TIMEOUT, NULL) == 0)
    {
        AppendLog(g_logEdit, L"无法创建超时定时器。");
        CloseConnection();
        return;
    }
    AppendLog(g_logEdit, L"正在通过 WSAEventSelect 建立连接……");
    result = connect(g_socket, (sockaddr *)&remote, sizeof(remote));
    if (result == 0)
        ConnectionEstablished();
    else
    {
        int error = WSAGetLastError();
        if (error != WSAEWOULDBLOCK)
        {
            AppendSocketError(g_logEdit, L"connect", error);
            CloseConnection();
        }
        /* WSAEWOULDBLOCK 表示正在连接,继续等待 FD_CONNECT,不当作失败。 */
    }
}

static void HandleReplyRead(void)
{
    int length = 0;
    int error = 0;
    int status = ReceivePacket(g_socket, &g_transfer, &length, &error);
    if (status == 1)
    {
        AppendLog(g_logEdit, L"服务器返回:");
        AppendLogUtf8(g_logEdit, g_transfer.input + PACKET_HEADER_SIZE, length);
        AppendLog(g_logEdit, L"完整响应已接收,本次查询结束。可再次点击按钮查询。");
        CloseConnection();
    }
    else if (status == -2)
    {
        AppendLog(g_logEdit, L"服务器在完整响应到达前关闭了连接。");
        CloseConnection();
    }
    else if (status < 0)
    {
        if (error != 0)
            AppendSocketError(g_logEdit, L"recv", error);
        else
            AppendLog(g_logEdit, L"响应长度字段非法,超过 8192 字节。");
        CloseConnection();
    }
}

/*
 * 一次枚举可能同时包含 CONNECT、READ、WRITE、CLOSE,必须逐位判断,不能写
 * 成互斥的 else-if 链。每次操作后检查套接字是否已关闭,防止继续使用旧资源。
 */
static void HandleNetworkEvent(int key)
{
    WSANETWORKEVENTS events;
    (void)key;
    if (WSAEnumNetworkEvents(g_socket, g_event, &events) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"WSAEnumNetworkEvents", WSAGetLastError());
        CloseConnection();
        return;
    }
    if (events.lNetworkEvents & FD_CONNECT)
    {
        if (events.iErrorCode[FD_CONNECT_BIT] != 0)
        {
            AppendSocketError(g_logEdit, L"FD_CONNECT", events.iErrorCode[FD_CONNECT_BIT]);
            CloseConnection();
            return;
        }
        ConnectionEstablished();
    }
    if (g_socket == INVALID_SOCKET)
        return;
    if ((events.lNetworkEvents & FD_READ) && events.iErrorCode[FD_READ_BIT] != 0)
    {
        AppendSocketError(g_logEdit, L"FD_READ", events.iErrorCode[FD_READ_BIT]);
        CloseConnection();
        return;
    }
    /* 先读最后一段数据,再处理关闭事件,避免服务器发完立即关闭时丢失结果。 */
    if (events.lNetworkEvents & (FD_READ | FD_CLOSE))
        HandleReplyRead();
    if (g_socket == INVALID_SOCKET)
        return;
    if (events.lNetworkEvents & FD_WRITE)
    {
        if (events.iErrorCode[FD_WRITE_BIT] != 0)
        {
            AppendSocketError(g_logEdit, L"FD_WRITE", events.iErrorCode[FD_WRITE_BIT]);
            CloseConnection();
            return;
        }
        TrySendRequest();
    }
    if (g_socket != INVALID_SOCKET && (events.lNetworkEvents & FD_CLOSE))
    {
        if (events.iErrorCode[FD_CLOSE_BIT] != 0)
            AppendSocketError(g_logEdit, L"FD_CLOSE", events.iErrorCode[FD_CLOSE_BIT]);
        AppendLog(g_logEdit, L"服务器连接已关闭,本次响应未完成。");
        CloseConnection();
    }
}

static int CollectEvents(WSAEVENT *events, int *keys)
{
    if (g_socket == INVALID_SOCKET)
        return 0;
    events[0] = g_event;
    keys[0] = 0;
    return 1;
}

static LRESULT CALLBACK ClientWindowProc(HWND window, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
    {
        WSADATA data;
        g_window = window;
        MakeControl(window, L"STATIC", L"服务器 IP", 0, 12, 16, 74, 24, 0);
        g_serverIpEdit = MakeControl(window, L"EDIT", DEFAULT_SERVER_IP,
            WS_TABSTOP | ES_AUTOHSCROLL, 88, 12, 145, 26, ID_SERVER_IP);
        MakeControl(window, L"STATIC", L"端口", 0, 248, 16, 40, 24, 0);
        g_portEdit = MakeControl(window, L"EDIT", L"1145", WS_TABSTOP | ES_NUMBER,
                                  290, 12, 65, 26, ID_PORT);
        MakeControl(window, L"STATIC", L"本地 IP", 0, 375, 16, 62, 24, 0);
        g_localIpEdit = MakeControl(window, L"EDIT", DEFAULT_CLIENT_IP,
            WS_TABSTOP | ES_AUTOHSCROLL, 440, 12, 145, 26, ID_LOCAL_IP);
        g_sendButton = MakeControl(window, L"BUTTON", L"连接并查询", WS_TABSTOP,
                                     605, 11, 140, 28, ID_SEND);
        MakeControl(window, L"STATIC", L"请求:请输出从1到1000内所有的水仙花数",
                    0, 12, 52, 760, 24, 0);
        g_logEdit = MakeControl(window, L"EDIT", L"", WS_TABSTOP | WS_VSCROLL |
            ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY, 12, 84, 770, 360, ID_LOG);
        SendMessageW(g_logEdit, EM_SETLIMITTEXT, 100000, 0);
        if (WSAStartup(MAKEWORD(2, 2), &data) != 0)
        {
            MessageBoxW(window, L"Winsock 2.2 初始化失败。", L"客户端", MB_ICONERROR);
            return -1;
        }
        g_winsockStarted = true;
        AppendLog(g_logEdit, L"先启动服务器监听,再点击“连接并查询”。");
        AppendLog(g_logEdit, L"本机测试:服务器 IP 填 127.0.0.1,本地 IP 留空或填 127.0.0.1。");
        AppendLog(g_logEdit, L"本地 IP 留空时,Windows 自动选择用于连接服务器的网卡。");
        return 0;
    }
    case WM_COMMAND:
        if (LOWORD(wParam) == ID_SEND && HIWORD(wParam) == BN_CLICKED)
            StartRequest();
        return 0;
    case WM_TIMER:
        if (wParam == CLIENT_TIMER && g_socket != INVALID_SOCKET)
        {
            AppendLog(g_logEdit, L"15 秒内未完成请求,请检查地址、监听状态和网络连通性。");
            CloseConnection();
        }
        return 0;
    case WM_GETMINMAXINFO:
        ((MINMAXINFO *)lParam)->ptMinTrackSize.x = 800;
        ((MINMAXINFO *)lParam)->ptMinTrackSize.y = 350;
        return 0;
    case WM_SIZE:
        if (g_logEdit != NULL && wParam != SIZE_MINIMIZED)
            MoveWindow(g_logEdit, 12, 84, LOWORD(lParam) - 24, HIWORD(lParam) - 96, TRUE);
        return 0;
    case WM_DESTROY:
        CloseConnection();
        if (g_winsockStarted)
        {
            WSACleanup();
            g_winsockStarted = false;
        }
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProcW(window, message, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE instance, HINSTANCE previous, LPSTR commandLine, int showCommand)
{
    HWND window;
    (void)previous;
    (void)commandLine;
    window = CreateMainWindow(instance, L"WSAEventSelectNarcissisticClient",
        L"WSAEventSelect 水仙花数客户端", ClientWindowProc);
    if (window == NULL)
        return 1;
    ShowWindow(window, showCommand);
    UpdateWindow(window);
    return RunEventMessageLoop(window, CollectEvents, HandleNetworkEvent);
}


6. 编译与可执行程序生成

服务器和客户端必须分别编译,因为两个源文件各自包含 WinMain 入口。

服务器编译时加入 server.cpp 与 narcissistic.cpp;客户端编译时加入 client.cpp。两个程序均需要链接 Winsock 和 Win32 界面相关库。

四个核心源码文件为 UTF-8 编码。以下命令为编译命令:

点击展开/收起:编译命令
g++ -std=c++98 -pedantic -Wall -Wextra -Werror -O2 -finput-charset=UTF-8 -static -mwindows -s server.cpp narcissistic.cpp -o server.exe -lws2_32 -luser32 -lgdi32
g++ -std=c++98 -pedantic -Wall -Wextra -Werror -O2 -finput-charset=UTF-8 -static -mwindows -s client.cpp -o client.exe -lws2_32 -luser32 -lgdi32

编译成功后应生成 server.exe 和 client.exe。图 9 为最终编译过程截图,用于记录实际执行的命令和生成结果。

图片9

图9-服务器与客户端编译结果
图片说明:展示服务器与客户端分别编译的命令结果。


7. 程序运行与结果观察

首先运行服务器,输入合法监听地址和端口,点击“开始监听”。服务器日志应显示监听端点及当前网络模型。

随后运行客户端,填写服务器地址与端口,点击“连接并查询”。连接成功后,客户端自动发送固定请求,服务器完成计算并返回响应。

图 10 为服务器运行截图,用于展示监听状态、客户端接入、合法请求接收和响应发送记录。

图片10

图10-服务器接收请求并返回结果
图片说明:服务器日志显示监听地址、客户端接入、收到合法请求、水仙花数结果 153 370 371 407、共 4 个,以及响应已提交给 TCP。

客户端接收完整响应后,应显示 1 到 1000 内所有的水仙花数。

图 11 为客户端运行截图,用于展示服务器返回的完整结果以及查询结束后的界面状态。

图片11

图11-客户端接收并显示计算结果
图片说明:客户端日志显示连接成功、本地端点、请求已发送、服务器返回的完整水仙花数结果,以及本次查询结束。


8. 调试与测试结果

测试分别覆盖算法正确性、数据帧边界、网络异常和非阻塞发送恢复。网络联调直接执行生产源码中的服务器与客户端事件处理函数,使用回环 TCP 传输验证实际字节内容。

表 7 汇总此前已完成版本的测试项目、判定依据与结果。图形界面全流程、实体双机通信及旧版环境兼容性单独列为待补充项目。

表 7 测试项目与验证结果

测试项目 方法或输入 判定依据 结果
水仙花数计算 查询 1 至 1000 结果为 153、370、371、407 通过
单个整数判断 逐一检查 -1000 至 2000 仅四个规定结果返回真 通过
算法边界 无结果区间、容量不足、极端整数边界 正常返回空结果或明确错误 通过
帧完整性 逐字节构造请求帧 未完整时等待,完整后正确解析 通过
正常请求与响应 发送固定 UTF-8 请求 响应全部字节与预期一致 通过
请求分段传输 请求逐字节发送 正确累计并处理一次请求 通过
客户端半关闭 完整请求后关闭发送方向 仍能收到正确响应 通过
非法业务请求 空正文、错误文本、附加空字符 返回不支持请求的错误正文 通过
最大正文 8192 字节 非规定正文 可解析帧并返回业务错误 通过
非法长度 超过 8192 字节的长度字段 终止连接,不按超大长度分配内存 通过
截断请求 请求未完整时关闭连接 不执行不完整请求 通过
并发查询 16 个工作线程提交 32 项查询任务 各任务返回正确结果 通过
重复查询 连续建立连接并请求 每次得到完整响应 通过
客户端响应解析 分段响应、立即 FIN、截断及超长响应 正确区分完整响应与异常 通过
连接拒绝 连接未监听端口 结束失败事务并释放连接 通过
发送恢复 填满发送缓冲区以触发 WSAEWOULDBLOCK FD_WRITE 唤醒后续传,字节一致 通过

并发查询测试说明已提交任务能够独立完成,但不能据此推断已验证 32 条连接同时长期保持的全部边界行为。

此外,源码编码发生变化后,应同步修订构建配置并重新执行编译检查,保证报告记录的源码、编译命令和可执行程序相互对应。


五、实验小结

1. 小组分工

本实验按照公共协议、服务器、客户端和算法测试四个方向组织工作。各成员在完成主要模块的同时,共同参与接口讨论、代码检查和联合调试。表 8 列出了沿用参考报告分工逻辑形成的本实验分工安排。

表 8 小组成员分工

成员 学号 主要分工
方致远 202412136050 系统总体设计、公共协议、事件消息循环、模块整合与联合调试
王鑫杰 202412136047 服务器界面、监听与连接管理、请求处理、响应发送和资源清理
李润哲 202412136049 客户端界面、非阻塞连接、请求发送、响应接收和状态恢复
康奕彬 202412136048 水仙花数算法、边界与协议测试、编译配置、实验记录和报告整理

2. 实验过程中遇到的问题及解决方法

实验中的主要技术问题涉及消息完整性、非阻塞发送、事件与资源管理,以及构建环境一致性。表 9 将需要处理的问题、原因和相应措施进行对应说明,并区分已经验证的处理方法与尚需完成的工作。

表 9 实验问题与处理措施

问题 原因分析 解决方法或处理措施 当前状态
一次接收不能保证获得完整请求 TCP 不保留应用层消息边界 使用长度前缀,并保留累计接收状态 分段测试通过
非阻塞发送可能只发送部分数据 发送缓冲区可能暂时不可写 保留发送偏移,收到 FD_WRITE 后续传 测试时主动填满缓冲区,验证阻塞后的续传
将 WSAEWOULDBLOCK 误判为失败 操作暂时不能完成 保留连接并等待 FD_CONNECT,检查事件错误码 处理逻辑通过验证
关闭事件可能伴随未读数据 对端发送结束与末端处理存在时间差 在 FD_CLOSE 清理前先处理剩余帧数据 相关测试通过
多条连接状态容易混淆 多条连接同时存在且生成 每条连接独立维护套接字、事件和收发状态 并发任务测试通过
非三位数可能误入算法结果 数学判断与题目限定范围不同 判断前明确限制为三位数 边界测试通过
编译时无法覆盖正在运行的 exe Windows 对运行中的可执行文件存在占用 关闭本次测试进程后重新编译 已处理

这些问题表明,网络程序调试不能仅观察正常请求是否返回结果,还需要验证数据不完整、发送暂时阻塞、连接提前结束和资源重复使用等情况。


3. WSAEventSelect 模型工作过程分析

WSAEventSelect 模型通过事件对象连接网络状态变化与应用程序处理逻辑。程序首先创建套接字和事件对象,指定需要监视的事件集合;相关网络状态出现后,事件对象进入有信号状态,使等待函数返回;程序随后枚举事件、检查错误码,并调用相应处理函数推进连接状态。

本实验的事件处理过程包括建立事件关联、等待事件、枚举与复位、推进收发状态和重新等待五个阶段。完成本轮收发处理后,程序返回事件等待阶段,形成持续运行的处理循环,其流程如图 12 所示。

图12WSAEventSelect 模型工作流程图

图12-WSAEventSelect模型工作流程
图片说明:创建套接字与事件对象后,通过 WSAEventSelect 建立关联;事件对象有信号时,使用 WSAEnumNetworkEvents 枚举事件并检查错误码;分派处理完成后重新进入等待循环。

事件发生并不意味着完整业务事务已经完成。FD_READ 只表明存在读取条件,程序仍需依据应用层长度判断请求是否完整;FD_WRITE 只提供发送恢复机会,程序仍需检查剩余字节;FD_CONNECT 产生后还必须检查错误码。

因此,事件模型解决“何时推进操作”的问题,应用层协议与状态记录解决“操作推进到何种程度”的问题。两者配合,才能构成可靠的请求与响应处理过程。

本程序还通过窗口消息与事件对象的联合等待,使界面操作和网络处理在同一线程中有序执行。该设计减少了线程同步需求,但也要求事件处理函数及时返回,不能在窗口线程执行耗时过长的计算或阻塞等待。


4. 实验总结

本实验实现了基于 WSAEventSelect 模型的 Win32 TCP 查询系统,完成了客户端发送固定请求、服务器解析请求并计算水仙花数、客户端接收和显示响应的完整业务设计。

算法按照三位数定义枚举候选整数,得到 153、370、371 和 407 四个结果。计算与网络通信相互分离,便于独立检查数学正确性和通信正确性。

通信部分采用长度前缀协议、独立接收状态和发送偏移,能够处理分段传输、部分发送以及异常长度。事件处理部分区分监听套接字与业务套接字,并针对连接失败、半关闭、事务超时和资源释放设置了对应路径。

已完成的验证覆盖算法、协议及生产代码事件处理函数的回环通信。后续还应统一当前源码与构建脚本的字符集配置,补充实际窗口操作截图,并在课程指定环境和实体双机条件下验证运行情况。


5. 小组成员实验感想

5.1 方致沅实验感想

本次实验中,我主要负责系统总体结构、公共通信协议、事件消息循环和模块整合。相比前一次 WSAAsyncSelect 实验,本次需要把注意力从窗口套接字消息转移到事件对象、事件等待和网络事件枚举之间的关系。

在公共模块设计中,我重点处理了 TCP 消息边界与收发状态保存问题。由于一次接收不一定对应完整请求,我采用四字节长度前缀描述正文长度,并使用独立状态记录接收进度。对于部分发送,则保存已发送偏移,在后续可写事件到来时继续处理。

事件与窗口消息的协同也是本次设计的重要问题。通过联合等待窗口消息和网络事件,可以避免窗口线程长期停留在单一网络等待中。此次实验使我进一步理解了事件通知、协议解析和业务状态之间的分工,也认识到公共接口的一致性对联合调试十分重要。

5.2 王鑫杰实验感想

本次实验中,我主要负责服务器端界面、监听套接字、连接接受、请求处理和响应发送。服务器需要同时管理监听连接和多条业务连接,因此必须明确区分两类套接字的事件集合与生命周期。

在连接管理中,我重点解决了事件句柄与连接状态的对应问题。每次接受新连接后,为其创建独立事件对象并重新设置事件关联,使请求接收、响应发送和连接清理能够对应到正确的客户端。

在关闭处理方面,我认识到收到 FD_CLOSE 后不能不加判断地立即释放所有状态,应先检查是否还有需要处理的数据。对于已经收到完整请求的正常半关闭连接,也应考虑尚未完成的响应发送。通过本次实验,我加深了对非阻塞服务器状态管理和资源释放顺序的理解。

5.3 李润哲实验感想

本次实验中,我主要负责客户端界面、非阻塞连接、请求发送、响应接收和控件状态管理。客户端虽然只维护一条当前连接,但仍需要清楚区分连接进行中、请求发送中和响应接收中的状态。

对我而言,最需要准确理解的是 WSAEWOULDBLOCK。它表示当前操作暂时不能立即完成,不能直接等同于连接失败。因此,客户端在连接尚未完成时保留套接字,等待 FD_CONNECT,再根据事件错误码决定后续处理。

响应显示同样需要完整性判断。只有收到长度字段规定的全部正文后,才能进行文本转换和显示;否则可能把不完整的中文数据误当作最终结果。此次实验使我认识到,网络状态与界面状态应统一管理,并在成功、失败和超时后恢复到可继续操作的状态。

5.4 康奕彬实验感想

本次实验中,我主要负责水仙花数算法、边界测试、协议测试和实验记录。算法实现首先需要准确理解题目中的“三位数”限制,不能仅根据各位立方和相等就接受单个数字。

我采用整数除法和取余提取数位,通过整数乘法计算立方和,并检查查询区间和结果数组容量。测试不仅核对最终四个结果,还覆盖非三位数、无结果区间、容量不足和极端整数边界。

通信测试方面,正常的小型响应不足以验证发送阻塞处理,因此需要人为填满发送缓冲区,再检查 FD_WRITE 触发后的续传结果。编译和整理过程中还应关注源码编码与编译参数是否一致。此次实验使我认识到,测试应围绕可能失效的边界设计,实验报告也应明确区分已经取得的验证结果与尚需补充的运行证据。


六、附录

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

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