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

图1-系统总体结构
内容说明:客户端与服务器通过 IPv4/TCP 通信;客户端负责参数输入、非阻塞连接、请求发送和响应显示;服务器负责连接管理、请求解析和响应发送;服务器调用水仙花数算法模块完成计算;公共头文件为双方提供协议、收发状态和事件循环支撑。
3. WSAEventSelect 模型设计
3.1 套接字与事件对象关联
WSAEventSelect 将套接字与指定的事件对象关联,并设置需要监视的网络事件集合。当相关网络事件发生时,Winsock 将关联事件对象置为有信号状态,同时记录事件类型。调用该函数后,套接字进入非阻塞模式。
其关联关系可表示为:
其中,\(s_i\) 表示套接字,\(e_i\) 表示关联事件对象,\(\mathcal M_i\) 表示监视的网络事件集合。
服务器监听套接字、服务器业务套接字和客户端套接字分别采用以下事件集合:
各网络事件的作用和本实验中的处理方式如表 3 所示。
表 3 网络事件及处理方式
| 网络事件 | 适用对象 | 含义 | 本实验处理方式 |
|---|---|---|---|
FD_ACCEPT |
服务器监听套接字 | 存在待接受的连接 | 调用 accept(),分配独立连接状态和事件对象 |
FD_CONNECT |
客户端套接字 | 非阻塞连接结果已产生 | 检查事件错误码,成功后开始发送请求 |
FD_READ |
已连接套接字 | 存在可读取数据 | 调用 recv(),推进当前数据帧接收状态 |
FD_WRITE |
已连接套接字 | 套接字具备发送条件 | 根据发送偏移继续发送剩余数据 |
FD_CLOSE |
已连接套接字 | 对端关闭或连接异常 | 先检查剩余数据,再根据状态结束或继续必要处理 |
3.2 事件等待与枚举
网络事件对象被触发后,程序调用 WSAEnumNetworkEvents 获取事件位掩码和对应错误码。传入关联事件句柄时,该函数还会原子地清除网络事件记录并复位事件对象。因此,本实验不单独调用 WSAResetEvent 代替网络事件枚举。
一次枚举可能返回多个网络事件。例如,数据到达与连接关闭可能在一次处理中同时被观察到。因此,程序对各事件位分别判断,不能只处理其中一个事件后忽略其他事件。
3.3 网络事件与图形界面的协同
本实验保留单线程 Win32 图形界面结构,使用 MsgWaitForMultipleObjects 同时等待网络事件对象与窗口消息。该函数可以在指定对象或符合条件的输入事件出现时结束等待,适用于窗口线程与事件对象的协同处理。
本程序的具体处理过程为:
- 处理当前窗口消息,包括按钮操作、窗口调整与超时通知。
- 收集仍然有效的网络事件句柄及其对应连接标识。
- 等待窗口消息或网络事件。
- 网络事件就绪后,通过
WSAWaitForMultipleEvents确认事件状态。 - 调用
WSAEnumNetworkEvents,分派相应的网络处理函数。 - 处理结束后重新构建等待数组,避免继续使用已关闭的事件句柄。
定时器仅用于检查事务超时,网络数据到达与发送恢复均由事件对象通知。图 2 给出了窗口消息与网络事件协同处理的完整循环。

图2-事件与窗口消息协同处理流程
图片说明:程序初始化套接字与事件对象,使用WSAEventSelect建立关联;通过MsgWaitForMultipleObjects同时等待窗口消息和网络事件;网络事件就绪后依次执行WSAWaitForMultipleEvents、WSAEnumNetworkEvents和事件分派;退出时关闭套接字、事件对象和 Winsock。
4. 应用层通信协议设计
4.1 消息边界定义
TCP 提供有序字节流,但应用程序不能假定一次 send() 对应一次 recv()。完整消息可能被分成多个片段接收,也可能与其他数据连续到达。
本实验采用四字节长度前缀协议。设消息正文为 \(P\),其 UTF-8 编码后的字节长度为 \(L\),完整数据帧为 \(F\),则:
其中,\(BE32\) 表示四字节大端编码,\(\parallel\) 表示字节序列拼接。长度字段使用 htonl() 与 ntohl() 完成主机字节序和网络字节序之间的转换。
数据帧各字段的含义如表 4 所示。
表 4 应用层数据帧格式
| 字段 | 长度 | 编码形式 | 说明 |
|---|---|---|---|
PayloadLength |
4 字节 | 无符号整数,网络字节序 | 正文的 UTF-8 字节长度 |
Payload |
0~8192 字节 | UTF-8 | 请求或响应正文 |
C 字符串末尾的空字符不作为正文发送。零长度正文在帧结构上可以解析,但不满足本实验的合法业务请求要求。图 3 展示长度字段与正文的排列关系,以及接收端先解析长度、再读取正文的处理顺序。

图3-应用层数据帧及接收顺序
图片说明:前 4 字节为网络字节序PayloadLength,后续L字节为 UTF-8 正文;接收端先读取 4 字节头部,再按合法长度读取正文。
4.2 分段接收处理
接收状态使用 inputLength 保存当前已接收字节数。程序先接收完整头部,再根据解析得到的合法长度读取正文,每次读取量不超过当前帧尚缺的字节数。
设已接收字节数为 \(R\),则完整帧的判定条件为:
若尚未满足完整性条件,程序保留现有数据并等待后续事件。若长度超过上限,或对端在完整帧到达前关闭连接,则终止当前事务。
本实验规定一条连接只处理一次请求。即使 TCP 流中存在后续帧,程序也不会把后续帧合并到第一条请求中执行,不支持同一连接上的流水线多请求。
4.3 部分发送处理
发送状态使用 outputLength 保存完整帧长度,使用 sent 保存已经成功提交给 TCP 的字节数。
设完整帧长度为 \(T\),已发送字节数为 \(S\),则:
当一次 send() 成功发送 \(k\) 字节时:
当 \(S=T\) 时,本次发送完成。若返回 WSAEWOULDBLOCK,则保留数据和偏移量,等待 FD_WRITE 后续块发送。
程序在新请求或新响应生成后立即尝试发送。只有暂时不能继续发送时,才依靠后续 FD_WRITE 恢复发送过程。
5. 水仙花数计算流程
5.1 数学定义
设三位整数为 \(n\),其百位、十位和个位分别为 \(a\)、\(b\) 和 \(c\),则:
水仙花数应满足:
各位数字可通过整数除法和取余运算得到:
题目查询范围为 \([1,1000]\),但水仙花数必须是三位数,因此实际候选区间为:
单个数字即使满足各位立方和条件,也不属于本实验规定的三位水仙花数。
5.2 算法步骤与结果
算法首先检查参数,再将查询区间限制到三位数范围。随后依次枚举候选整数,提取各位数字,计算立方和,并将满足条件的整数按升序保存。
最终得到的结果集合为:
为验证计算结果,表 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\) 个整数,则扫描时间复杂度为:
除结果存储外,数位提取和判断只需要固定数量的变量,辅助空间复杂度为:
图 4 给出了区间限制、逐个判断、结果保存和响应正文生成的流程。

图4-水仙花数计算流程
图片说明:先检查参数并将区间限制在三位数范围,再逐个提取百位、十位和个位,计算立方和并判断是否等于原数,最后保存结果并生成响应正文。
6. 服务器端工作流程
服务器端首先初始化 Winsock,创建监听套接字,并根据界面输入绑定本机地址与端口。完成监听后,服务器创建事件对象,并通过 WSAEventSelect 关联 FD_ACCEPT 和 FD_CLOSE。
当 FD_ACCEPT 发生时,服务器调用 accept() 获取业务套接字。每条业务连接分配独立事件对象与收发状态,并监视 FD_READ、FD_WRITE 和 FD_CLOSE。
收到完整请求后,服务器按以下步骤处理:
- 比较请求长度和全部正文字节,确认请求是否与约定一致。
- 合法请求调用
BuildNarcissisticReply(),实际执行水仙花数计算。 - 非法请求生成“不支持的请求”错误正文。
- 将响应封装为长度前缀数据帧,立即尝试发送。
- 暂时不可发送时保存发送偏移,等待
FD_WRITE。 - 响应全部提交给 TCP 后关闭本次连接,继续服务其他客户端。
服务器使用 replying 标志防止同一请求被重复处理或覆盖尚未发完的响应。事务超时、协议错误和网络错误仅清理相应业务连接,不影响其他连接。图 5 展示服务器从监听建立到请求处理、响应发送与连接清理的完整流程。

图5-服务器端工作流程
图片说明:服务器初始化 Winsock,创建监听套接字并绑定地址;接受连接后为每条业务连接创建独立事件对象;收到完整请求后调用水仙花数算法,封装响应并发送;发送完成后关闭本次连接,继续监听。
7. 客户端工作流程
客户端采用“连接并查询”的操作方式。用户输入服务器地址、服务器端口及可选本地地址后,程序先检查参数,再创建套接字。
若指定本地地址,客户端执行绑定;若本地地址为空,则由操作系统自动选择。客户端在调用 connect() 前创建并关联事件对象,使连接操作以非阻塞方式执行。
客户端的主要逻辑阶段可表示为:
上述阶段是对程序处理过程的逻辑划分,实际代码通过套接字有效性、连接标志、发送标志和收发状态共同记录当前进度。
当连接成功后,客户端立即发送固定查询请求。完整响应到达后,程序将 UTF-8 正文转换为宽字符文本并显示,随后释放连接并恢复输入控件。图 6 展示客户端参数检查、连接结果处理、请求发送、响应接收与状态恢复之间的关系。

图6-客户端工作流程
图片说明:客户端检查服务器地址、本地地址和端口,创建套接字并关联事件对象;非阻塞连接成功后发送固定请求;收到完整响应后显示结果并释放连接,恢复界面状态。
8. 服务器端与客户端之间的双向数据传递流程
本实验的双向通信由查询请求和计算响应两个方向构成。请求从客户端传向服务器,响应从服务器传回客户端,二者使用同一条已建立的 TCP 连接。
从应用层角度,一次成功事务包括连接建立、请求传输、服务器计算、响应传输和连接结束五个阶段。服务器发送函数返回成功,仅表示相应字节已提交给本地 TCP;客户端成功解析完整响应,才能证明本次应用层响应已完整到达。图 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-实验网络参数检查
图片说明:检查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-服务器与客户端编译结果
图片说明:展示服务器与客户端分别编译的命令结果。
7. 程序运行与结果观察
首先运行服务器,输入合法监听地址和端口,点击“开始监听”。服务器日志应显示监听端点及当前网络模型。
随后运行客户端,填写服务器地址与端口,点击“连接并查询”。连接成功后,客户端自动发送固定请求,服务器完成计算并返回响应。
图 10 为服务器运行截图,用于展示监听状态、客户端接入、合法请求接收和响应发送记录。

图10-服务器接收请求并返回结果
图片说明:服务器日志显示监听地址、客户端接入、收到合法请求、水仙花数结果153 370 371 407、共 4 个,以及响应已提交给 TCP。
客户端接收完整响应后,应显示 1 到 1000 内所有的水仙花数。
图 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 所示。

图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 版。

浙公网安备 33010602011771号