基于 WSAAsyncSelect 模型的通信程序设计实验

基于 WSAAsyncSelect 模型的通信程序设计实验

一、实验目的

  1. 熟悉 Windows 环境下基于 WSAAsyncSelect 模型的网络通信程序设计方法。
  2. 掌握 Winsock2 的初始化、套接字创建、地址绑定、监听、连接建立、数据收发和资源释放等基本操作。
  3. 理解 WSAAsyncSelect 将套接字网络事件转换为 Windows 窗口消息的工作原理。
  4. 掌握 FD_ACCEPT、FD_CONNECT、FD_READ、FD_WRITE 和 FD_CLOSE 等异步网络事件的处理方法。
  5. 掌握 Win32 图形界面程序中窗口过程、消息循环和网络通信功能的协同设计方法。
  6. 实现服务器端和客户端之间的双向数据传输,使客户端能够向服务器发送指定请求,并接收服务器返回的计算结果。
  7. 理解 TCP 字节流不保留应用层消息边界的特点,掌握粘包、拆包、部分发送和非阻塞错误的处理方法。
  8. 采用四字节长度前缀协议定义应用层消息边界,提高通信程序的完整性和可靠性。
  9. 使用 (C++) 实现 1 至 1000 范围内质数的判断和结果生成,并通过协议测试和实际通信验证结果的正确性。

二、实验内容与设计思想

1. 实验内容

本实验使用 (C++)、Win32 API 和 Windows Sockets 2 编写服务器端和客户端程序。两个程序均采用图形界面,并通过 WSAAsyncSelect 模型接收异步网络事件。

客户端连接服务器后发送以下请求:

请输出从1到1000内所有的质数

服务器接收并解析请求。当请求内容与预定命令一致时,服务器计算 1 至 1000 范围内的全部质数,将计算结果封装为应用层数据帧并返回客户端。客户端解析服务器响应,并在图形界面的结果区域中显示质数列表。

本实验的主要通信参数如表 1 所示。

表 1 通信任务配置

项目 配置
服务器 IPv4 地址 192.168.50.1
客户端本地 IPv4 地址 192.168.50.2
子网掩码 255.255.255.0
服务器监听端口 1145
传输层协议 TCP
网络层协议 IPv4
文本编码 UTF-8
应用层协议 4 字节长度字段加 UTF-8 正文
最大消息正文 8192 字节
通信方式 同一计算机上的两个地址或两台计算机
请求内容 请输出从1到1000内所有的质数
服务器响应 1 至 1000 范围内的全部质数

2. 系统总体设计

系统划分为客户端、服务器端、公共协议和协议测试四个部分。

服务器端负责绑定指定地址、监听端口、接受客户端连接、接收请求、计算质数并返回响应。客户端负责绑定本地地址、异步连接服务器、发送请求并显示服务器响应。公共协议部分负责数据帧封装、数据帧解析、UTF-8 文本处理、发送队列管理和质数计算。协议测试部分负责验证数据封装、分段解析、异常长度处理和质数计算结果。

系统的总体组成和数据流向如图 1 所示。

图1客户端与服务器系统总体结构

图 1 系统总体结构(图片说明:客户端与服务器 Win32 程序通过 TCP 连接,窗口消息循环接收 WSAAsyncSelect 网络事件,发送队列、接收缓存区和质数计算模块协同工作。)

3. WSAAsyncSelect 模型设计

WSAAsyncSelect 是 Windows Sockets 2 提供的一种异步网络事件通知机制。程序通过该函数将指定套接字、目标窗口、自定义消息编号和需要监视的网络事件集合建立关联。

其调用关系可以表示为:

\[WSAAsyncSelect(S,W,M,E) \tag{1} \]

式中:(S) 表示套接字;(W) 表示接收网络通知的窗口句柄;(M) 表示自定义窗口消息;(E) 表示需要监视的网络事件集合。

当套接字上发生指定事件时,Windows 将自定义消息投递到目标窗口。窗口过程使用以下代码获取事件类型和事件错误码:

int networkEvent = WSAGETSELECTEVENT(lParam);
int eventError = WSAGETSELECTERROR(lParam);

服务器端和客户端需要处理的主要网络事件如表 2 所示。

表 2 WSAAsyncSelect 网络事件

网络事件 适用对象 事件含义 处理方法
FD_ACCEPT 服务器监听套接字 有新的连接请求 调用 accept() 接受连接
FD_CONNECT 客户端套接字 异步连接完成 检查事件错误码并更新状态
FD_READ 已连接套接字 当前存在可接收数据 调用 recv() 接收数据
FD_WRITE 已连接套接字 套接字恢复可写状态 继续发送剩余数据
FD_CLOSE 已连接套接字 对端关闭连接 关闭套接字并清理状态

调用 WSAAsyncSelect 后,套接字自动进入非阻塞模式。因此,connect()、send() 和 recv() 可能返回 SOCKET_ERROR,同时通过 WSAGetLastError() 得到 WSAEWOULDBLOCK。该错误表示当前操作暂时不能立即完成,程序应等待后续网络事件,而不能直接将其判定为通信失败。

4. 应用层通信协议设计

TCP 提供可靠的字节流传输,但不保留应用程序每次调用 send() 时形成的消息边界。一次发送的数据可能需要经过多次 recv() 才能完整接收,多条消息也可能被合并到一次接收操作中。

为明确应用层消息边界,本实验采用四字节长度前缀协议。每条应用层消息由长度字段和消息正文组成,其数据结构如表 3 所示。

表 3 应用层数据帧结构

字段 长度 编码方式 作用
PayloadLength 4 字节 网络字节序无符号整数 表示正文的字节长度
Payload 可变长度 UTF-8 保存请求或响应正文
正文长度上限 8192 字节 固定限制 防止异常长度占用过多内存

设 UTF-8 消息正文为 (D),正文长度为 (L),长度字段为 (H),完整数据帧为 (P),则封装过程为:

\[L = |D| \tag{2} \]

\[H = htonl(L) \tag{3} \]

\[P = H \parallel D \tag{4} \]

\[|P| = 4 + |D| \tag{5} \]

其中,符号 (\parallel) 表示两个字节序列的连接操作。

数据帧的字节布局如图 2 所示。

图2应用层数据帧格式图

图 2 应用层数据帧格式图(图片说明:前 4 字节为网络字节序 PayloadLength,后 L 字节为 UTF-8 消息正文,完整帧长度为 4 + L。)

接收端将每次 recv() 得到的数据追加到接收缓存区。设缓存区当前字节数为 (B),数据帧正文长度为 (L),只有满足下式时才能提取一条完整消息:

\[B \ge 4 + L \tag{6} \]

若该条件不成立,程序保留缓存区中的已有数据,等待下一次 FD_READ 事件。

非阻塞套接字的一次 send() 也不保证发送全部数据。设完整数据帧长度为 (N),已发送字节数为 (K),则发送状态满足:

\[0 \le K \le N \tag{7} \]

剩余待发送字节数为:

\[R = N - K \tag{8} \]

当 send() 成功发送 (n) 个字节时,发送偏移量更新为:

\[K_{new} = K_{old} + n \tag{9} \]

当 (K = N) 时,说明当前数据帧已经发送完成,可以从发送队列中删除。当 send() 返回 WSAEWOULDBLOCK 时,程序不能丢弃尚未发送的数据,而应保留当前数据帧和偏移量,等待 FD_WRITE 事件后继续发送。

4.3 协议安全限制

为防止错误或恶意长度字段导致接收缓存区无限增长,程序将单条消息正文的最大长度限制为 8192 字节。若解析得到的长度 (L) 满足:

\[L > 8192 \tag{10} \]

则程序将其判定为协议错误,并终止当前消息的解析。该限制能够降低异常数据对程序内存和运行状态的影响。

5. 质数计算设计

服务器收到客户端请求后,需要计算 1 至 1000 范围内的全部质数。对于整数 (n),如果不存在满足 (2 \le d \le \lfloor \sqrt{n} \rfloor) 且能够整除 (n) 的整数 (d),则 (n) 为质数。其数学定义为:

\[Prime(n) \Leftrightarrow n \ge 2 \land \forall d \in [2,3,\ldots,\lfloor\sqrt{n}\rfloor],\ n \bmod d \ne 0 \tag{11} \]

当 (n < 2) 时,(n) 不是质数。对于大于或等于 2 的整数,只需检查不大于 (\sqrt{n}) 的因数。这是因为,如果 (n) 存在一对因数 (a) 和 (b),并且二者都大于 (\sqrt{n}),则有:

\[a \times b > n \tag{12} \]

这与 (a \times b = n) 矛盾。因此,一个合数至少存在一个不大于其平方根的因数。对于区间 ([1,N]),逐个整数执行试除法的总体时间复杂度为:

\[T(N) = \sum_{n=2}^{N} O(\sqrt{n}) = O(N\sqrt{N}) \tag{13} \]

除保存响应结果所需的字符串外,算法的额外空间复杂度为:

\[S(N) = O(1) \tag{14} \]

质数判断过程如图 3 所示。

图3质数判断流程图

图 3 质数判断流程(图片说明:先判断 n 是否小于 2,再从 2 到 sqrt(n) 逐个试除,若存在因数则判为非质数,否则判为质数。)

6. 服务器端设计

服务器端负责创建监听套接字、绑定服务器地址、接受客户端连接、接收请求、计算质数并返回响应。

服务器首先调用 WSAStartup() 初始化 Winsock 2.2,然后创建 IPv4 TCP 套接字,并将其绑定到 192.168.50.1:1145。完成绑定后,服务器为监听套接字注册 FD_ACCEPT 和 FD_CLOSE 事件,随后调用 listen() 进入监听状态。

当收到 FD_ACCEPT 时,服务器调用 accept() 获得客户端连接套接字,并为该套接字注册 FD_READ、FD_WRITE 和 FD_CLOSE 事件。

当收到 FD_READ 时,服务器循环调用 recv(),将接收的数据追加到缓存区。程序从缓存区中提取完整数据帧,并将 UTF-8 正文与预定请求进行比较。若请求正确,则调用质数计算函数生成响应;若请求不符合要求,则返回错误提示。

当收到 FD_WRITE 时,服务器继续发送队列中尚未发送完成的数据。当收到 FD_CLOSE 时,服务器关闭客户端连接套接字,清空相应缓存区和发送队列,并继续等待新的客户端连接。

服务器端完整处理过程如图 4 所示。

图4网络服务器消息处理流程图

图 4 服务器端处理流程(图片说明:启动程序后创建窗口与监听套接字,绑定 192.168.50.1:1145,注册 FD_ACCEPT/FD_CLOSE,进入消息循环;WM_SOCKET_EVENT 中分别处理 FD_ACCEPT、FD_READ、FD_WRITE、FD_CLOSE 和错误事件。)

7. 客户端设计

客户端负责绑定本地地址、连接服务器、发送质数查询请求、接收服务器响应并显示结果。

客户端初始化 Winsock 后创建 IPv4 TCP 套接字,并绑定本地地址 192.168.50.2。客户端本地端口设置为 0,由操作系统动态分配。

完成本地地址绑定后,客户端注册 FD_CONNECT、FD_READ、FD_WRITE 和 FD_CLOSE 事件,然后调用 connect() 发起连接。由于套接字已进入非阻塞模式,connect() 可能返回 WSAEWOULDBLOCK。该返回值表示连接仍在建立,程序应继续等待 FD_CONNECT,而不能立即判定为连接失败。

当收到连接成功的 FD_CONNECT 事件后,客户端启用发送按钮。用户发送请求时,程序将 UTF-8 请求封装为长度前缀数据帧,并将数据帧加入发送队列。

当收到 FD_READ 时,客户端将服务器数据追加到接收缓存区,并按照长度前缀协议解析完整响应。解析完成后,程序将 UTF-8 响应转换为宽字符,并显示在 Win32 编辑框中。

当收到 FD_CLOSE 或连接超时时,客户端关闭套接字、停止定时器、清空发送队列和接收缓存区,并将界面恢复到未连接状态。

客户端完整处理过程如图 5 所示。

图5客户端Win32程序流程图

图 5 客户端处理流程(图片说明:客户端创建窗口和套接字,绑定本地地址,注册 FD_CONNECT/FD_READ/FD_WRITE/FD_CLOSE,异步 connect;FD_CONNECT 后发送请求,FD_READ 中解析长度前缀响应并显示质数结果。)

三、实验使用环境

项目 说明
操作系统 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. 配置实验网卡

实验使用 Microsoft KM-TEST Loopback Adapter 模拟两个网络通信端点,并将实验网卡命名为 TCP-Lab。

使用 PowerShell 检查实验网卡:

Get-NetAdapter -Name 'TCP-Lab' |
    Format-Table Name, InterfaceDescription, Status

实验网卡的检查结果应在此处插入,效果如图 6 所示。

图片6

图 6 实验网卡状态(图片说明:应显示 Name 为 TCP-Lab、InterfaceDescription 为 Microsoft KM-TEST 环回适配器、Status 为 Up。)

2. 配置 IPv4 地址

使用以下命令检查实验网卡的 IPv4 地址:

Get-NetIPAddress -InterfaceAlias 'TCP-Lab' -AddressFamily IPv4 |
    Format-Table IPAddress, PrefixLength, AddressState

实验环境应包含以下两个地址:

192.168.50.1/24
192.168.50.2/24

双地址配置结果应在此处插入,效果如图 7 所示。

图片7

图 7 实验 IPv4 地址配置(图片说明:应显示 192.168.50.2/24 和 192.168.50.1/24,AddressState 均为 Preferred。)

如果地址尚未配置,可以使用以下命令添加:

New-NetIPAddress -InterfaceAlias 'TCP-Lab' -IPAddress 192.168.50.1 -PrefixLength 24
New-NetIPAddress -InterfaceAlias 'TCP-Lab' -IPAddress 192.168.50.2 -PrefixLength 24

前缀长度 24 对应的子网掩码为:

255.255.255.0

3. 程序文件组成

本实验的代码统一放置在第四部分进行说明。项目源文件及其主要作用如表 4 所示。

表 4 程序文件组成

文件 主要功能
wsaasync_common.h 公共常量、数据帧协议、发送队列、字符转换和质数算法
server.cpp 监听连接、接收请求、计算质数并发送响应
client.cpp 连接服务器、发送请求并显示响应
protocol_test.cpp 协议自检、质数结果验证、长度前缀封装与解析测试
build.ps1 编译服务器、客户端和协议测试程序,并运行协议自检

4. 公共协议代码实现

公共头文件保存服务器地址、客户端地址、端口、消息长度上限和预定请求内容。关键常量如下:

const char DEFAULT_SERVER_IP[] = "192.168.50.1"; /* 默认 server endpoint 地址。 */
const char DEFAULT_CLIENT_IP[] = "192.168.50.2"; /* 默认 client source 地址。 */
const unsigned short DEFAULT_PORT = 1145;        /* 双方约定的 TCP port。 */
const int MAX_PAYLOAD_SIZE = 8192; /* 单条业务 payload 的最大字节数。 */
const int PACKET_HEADER_SIZE = 4;  /* u_long length header 固定占 4 bytes。 */
const int MAX_PACKET_SIZE = PACKET_HEADER_SIZE + MAX_PAYLOAD_SIZE;

数据帧封装和解析函数的接口如下:

inline int BuildPacket(char *packet, int capacity,
                       const char *payload, int payloadLength)
{
    u_long networkLength;
    if (payloadLength < 0 || payloadLength > MAX_PAYLOAD_SIZE ||
        capacity < PACKET_HEADER_SIZE + payloadLength)
        return 0;
    networkLength = htonl((u_long)payloadLength);
    memcpy(packet, &networkLength, PACKET_HEADER_SIZE);
    if (payloadLength > 0)
        memcpy(packet + PACKET_HEADER_SIZE, payload, payloadLength);
    return PACKET_HEADER_SIZE + payloadLength;
}

其中,BuildPacket() 将四字节网络序长度字段与 UTF-8 正文组合为完整数据帧;TryExtractPacket() 从接收缓存区中提取一条完整消息。

下面给出整理后的公共头文件完整实现。点击标题可展开/收起代码。

点击展开/收起:wsaasync_common.h(公共协议与工具函数完整代码)
#ifndef WSAASYNC_COMMON_H
#define WSAASYNC_COMMON_H

#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

/*
 * 网络正文统一使用 UTF-8。为避免 Visual C++ 6.0 按本机代码页改写中文字符串,
 * 实际参与网络传输的中文均写成显式 UTF-8 字节;变量名、函数名和算法名保持英文。
 */

const char DEFAULT_SERVER_IP[] = "192.168.50.1"; /* 默认 server endpoint 地址。 */
const char DEFAULT_CLIENT_IP[] = "192.168.50.2"; /* 默认 client source 地址。 */
const unsigned short DEFAULT_PORT = 1145;        /* 双方约定的 TCP port。 */

/*
 * TCP 字节流之上的应用层 packet 格式:
 *
 *   +--------------------------+-------------------------------+
 *   | 4-byte payload length    | UTF-8 payload bytes           |
 *   | unsigned, network order  | 共 payload length 字节         |
 *   +--------------------------+-------------------------------+
 *
 * TCP 不保留消息边界:一次 send() 可能需要多次 recv() 才能收完,也可能一次
 * recv() 收到连续写入的数据。4-byte length 使用 network byte order,接收方据此
 * 判断一个完整 payload 是否到达,避免把残缺的 UTF-8 中文误当作完整字符串。
 */
const int MAX_PAYLOAD_SIZE = 8192; /* 单条业务 payload 的最大字节数。 */
const int PACKET_HEADER_SIZE = 4;  /* u_long length header 固定占 4 bytes。 */
const int MAX_PACKET_SIZE = PACKET_HEADER_SIZE + MAX_PAYLOAD_SIZE;

/* REQUEST_TEXT:题目规定的固定请求“请输出从1到1000内所有的质数”。 */
const char REQUEST_TEXT[] =
    "\xE8\xAF\xB7\xE8\xBE\x93\xE5\x87\xBA\xE4\xBB\x8E\x31"
    "\xE5\x88\xB0\x31\x30\x30\x30\xE5\x86\x85\xE6\x89\x80"
    "\xE6\x9C\x89\xE7\x9A\x84\xE8\xB4\xA8\xE6\x95\xB0";

/* REPLY_PREFIX:服务器成功回应的 UTF-8 固定前缀。 */
const char REPLY_PREFIX[] =
    "\x31\xE5\x88\xB0\x31\x30\x30\x30\xE5\x86\x85\xE6\x89\x80"
    "\xE6\x9C\x89\xE7\x9A\x84\xE8\xB4\xA8\xE6\x95\xB0\xE5\xA6"
    "\x82\xE4\xB8\x8B\xEF\xBC\x9A\r\n";

/* REPLY_SUFFIX:服务器成功回应的 UTF-8 统计结尾。 */
const char REPLY_SUFFIX[] =
    "\r\n\xE5\x85\xB1\x31\x36\x38\xE4\xB8\xAA\xE8\xB4\xA8"
    "\xE6\x95\xB0\xE3\x80\x82";

/* ERROR_REPLY:收到非规定请求时返回的 UTF-8 错误信息。 */
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";

struct TransferState
{
    /* input 保存 recv() 累计得到的原始字节,内容包含 4-byte header。 */
    char input[MAX_PACKET_SIZE];
    int inputLength;

    /* output 保存等待 send() 的完整 packet,即 header 与 payload。 */
    char output[MAX_PACKET_SIZE];
    int outputLength;

    /* sent 表示本地 TCP stack 已接受的 output 字节数,用于处理 partial send。 */
    int sent;
};

/* ResetTransfer 将一个连接的收发长度和发送 offset 恢复为初始状态。 */
inline void ResetTransfer(TransferState *state)
{
    state->inputLength = 0;
    state->outputLength = 0;
    state->sent = 0;
}

/* AppendLog 向只读 multiline EDIT control 末尾追加一行 UTF-16 日志。 */
inline void AppendLog(HWND edit, const wchar_t *text)
{
    int length;
    if (edit == NULL || text == NULL)
        return;
    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);
}

/* AppendLogUtf8 将以 NUL 结尾的 UTF-8 网络文本转换成 UTF-16 后显示。 */
inline void AppendLogUtf8(HWND edit, const char *text)
{
    wchar_t wide[MAX_PAYLOAD_SIZE + 1];
    int count;
    if (text == NULL)
        return;
    count = MultiByteToWideChar(CP_UTF8, 0, text, -1, wide,
                                (int)(sizeof(wide) / sizeof(wide[0])));
    if (count == 0)
        AppendLog(edit, L"[invalid UTF-8 text]");
    else
        AppendLog(edit, wide);
}

/* AppendSocketError 将 Winsock error code 格式化为系统说明并写入 GUI 日志。 */
inline void AppendSocketError(HWND edit, const wchar_t *operation, int error)
{
    wchar_t systemText[256];
    wchar_t line[512];
    DWORD count;
    systemText[0] = L'\0';
    count = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM |
                               FORMAT_MESSAGE_IGNORE_INSERTS,
                           NULL, (DWORD)error, 0, systemText,
                           (DWORD)(sizeof(systemText) / sizeof(systemText[0])),
                           NULL);
    if (count == 0)
        wsprintfW(line, L"%s failed (Winsock error %d).", operation, error);
    else
        wsprintfW(line, L"%s failed (Winsock error %d): %s",
                  operation, error, systemText);
    AppendLog(edit, line);
}

/* ReadAsciiText 从 EDIT 读取仅含 ASCII 的 IPv4 等输入,写入 char buffer。 */
inline bool ReadAsciiText(HWND edit, char *output, int capacity)
{
    wchar_t wide[128];
    int count;
    if (capacity <= 0)
        return false;
    GetWindowTextW(edit, wide, (int)(sizeof(wide) / sizeof(wide[0])));
    count = WideCharToMultiByte(CP_ACP, 0, wide, -1, output, capacity,
                                NULL, NULL);
    return count > 0;
}

/* ReadPort 解析十进制 TCP port,并拒绝空值、0、尾随字符及越界数值。 */
inline bool ReadPort(HWND edit, unsigned short *port)
{
    wchar_t text[32];
    wchar_t *end;
    unsigned long value;
    GetWindowTextW(edit, text, (int)(sizeof(text) / sizeof(text[0])));
    if (text[0] == L'\0')
        return false;
    end = NULL;
    value = wcstoul(text, &end, 10);
    if (end == text || *end != L'\0' || value == 0 || value > 65535)
        return false;
    *port = (unsigned short)value;
    return true;
}

/*
 * MakeAddress 填充 IPv4 sockaddr_in。服务器在 allowAny=true 时可用空字符串或
 * 0.0.0.0 表示 INADDR_ANY;客户端的 remote IP 必须是具体 IPv4 地址。
 */
inline bool MakeAddress(const char *ip, unsigned short port,
                        bool allowAny, sockaddr_in *address)
{
    unsigned long value;
    memset(address, 0, sizeof(*address));
    address->sin_family = AF_INET;
    address->sin_port = htons(port);
    if (allowAny && (ip[0] == '\0' || strcmp(ip, "0.0.0.0") == 0))
    {
        address->sin_addr.s_addr = htonl(INADDR_ANY);
        return true;
    }
    value = inet_addr(ip);
    if (value == INADDR_NONE)
        return false;
    address->sin_addr.s_addr = value;
    return true;
}

/*
 * BuildPacket 将 payload 序列化为应用层 packet。返回值是必须发送的准确字节数;
 * 返回 0 表示 payloadLength 非法或 packet capacity 不足。
 */
inline int BuildPacket(char *packet, int capacity,
                       const char *payload, int payloadLength)
{
    u_long networkLength;
    if (payloadLength < 0 || payloadLength > MAX_PAYLOAD_SIZE ||
        capacity < PACKET_HEADER_SIZE + payloadLength)
        return 0;
    networkLength = htonl((u_long)payloadLength);
    memcpy(packet, &networkLength, PACKET_HEADER_SIZE);
    if (payloadLength > 0)
        memcpy(packet + PACKET_HEADER_SIZE, payload, payloadLength);
    return PACKET_HEADER_SIZE + payloadLength;
}

/*
 * PacketStatus 只检查已经缓存的 input,不读取 socket。
 * 返回 1:恰好收到一个完整 packet;返回 0:数据尚未收全;返回 -1:长度越界,
 * 或第一个 packet 后出现本实验协议不允许的额外字节。
 */
inline int PacketStatus(const TransferState *state, int *payloadLength)
{
    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;
    *payloadLength = (int)networkLength;
    if (state->inputLength < PACKET_HEADER_SIZE + *payloadLength)
        return 0;
    if (state->inputLength != PACKET_HEADER_SIZE + *payloadLength)
        return -1;
    return 1;
}

/*
 * ReceivePacket 读取 nonblocking socket 当前可取得的全部字节。循环调用 recv()
 * 直到 WSAEWOULDBLOCK,可以消费本次 readable 状态,使后续新数据到达时 Winsock
 * 能再次投递 FD_READ,而不会在 GUI thread 中阻塞。
 *
 * 返回值:
 *  1 = 完整 packet 已就绪
 *  0 = 还需要更多字节
 * -1 = socket error 或 protocol error
 * -2 = 对端在完整 packet 到达前关闭连接
 */
inline int ReceivePacket(SOCKET socketValue, TransferState *state,
                         int *payloadLength, int *socketError)
{
    for (;;)
    {
        int status = PacketStatus(state, payloadLength);
        int received;
        if (status != 0)
            return status;
        if (state->inputLength == MAX_PACKET_SIZE)
            return -1;
        received = recv(socketValue, state->input + state->inputLength,
                        MAX_PACKET_SIZE - state->inputLength, 0);
        if (received > 0)
        {
            state->inputLength += received;
            continue;
        }
        if (received == 0)
            return -2;
        *socketError = WSAGetLastError();
        if (*socketError == WSAEWOULDBLOCK)
            return 0;
        return -1;
    }
}

/*
 * FlushOutput 尽量把待发送 output 提交给 nonblocking socket。只有 send() 返回
 * 正数时才推进 sent offset,因此 partial send 不会造成字节重复或丢失。
 * 返回 1 表示全部发送;返回 0 表示 WSAEWOULDBLOCK,应等待 FD_WRITE;
 * 返回 -1 表示真实错误。
 */
inline int FlushOutput(SOCKET socketValue, TransferState *state,
                       int *socketError)
{
    while (state->sent < state->outputLength)
    {
        int sentNow = send(socketValue, state->output + state->sent,
                           state->outputLength - state->sent, 0);
        if (sentNow > 0)
        {
            state->sent += sentNow;
            continue;
        }
        if (sentNow == 0)
            return -1;
        *socketError = WSAGetLastError();
        if (*socketError == WSAEWOULDBLOCK)
            return 0;
        return -1;
    }
    return 1;
}

/*
 * IsPrime 使用 trial division 判断质数。divisor <= value / divisor 与
 * divisor * divisor <= value 等价,同时避免乘法 overflow。
 */
inline bool IsPrime(int value)
{
    int divisor;
    if (value < 2)
        return false;
    for (divisor = 2; divisor <= value / divisor; ++divisor)
        if (value % divisor == 0)
            return false;
    return true;
}

/* AppendBytes 在拼接 UTF-8 reply 时检查 capacity,防止 output 越界。 */
inline bool AppendBytes(char *output, int capacity, int *length,
                        const char *text, int textLength)
{
    if (textLength < 0)
        textLength = (int)strlen(text);
    if (*length + textLength > capacity)
        return false;
    memcpy(output + *length, text, textLength);
    *length += textLength;
    return true;
}

/*
 * BuildPrimeReply 在服务器端完成题目要求的计算:依次检查 [2, 1000] 内的
 * 每个 integer,把 prime number 追加到 reply,每行排 16 个,并校验 count=168。
 * 返回长度不包含 C-string terminator,因为 wire protocol 已经显式携带 payloadLength。
 */
inline int BuildPrimeReply(char *output, int capacity)
{
    int length = 0; /* output 中已经写入的 payload bytes。 */
    int number;     /* 当前接受 primality test 的候选整数。 */
    int count = 0;  /* 已写入 reply 的 prime number 数量。 */
    if (!AppendBytes(output, capacity, &length, REPLY_PREFIX, -1))
        return 0;
    for (number = 2; number <= 1000; ++number)
    {
        char value[16];
        int valueLength;
        if (!IsPrime(number))
            continue;
        sprintf(value, "%d", number);
        valueLength = (int)strlen(value);
        if (!AppendBytes(output, capacity, &length, value, valueLength))
            return 0;
        ++count;
        if (count % 16 == 0)
        {
            if (!AppendBytes(output, capacity, &length, "\r\n", 2))
                return 0;
        }
        else if (number != 997)
        {
            if (!AppendBytes(output, capacity, &length, " ", 1))
                return 0;
        }
    }
    if (count != 168)
        return 0;
    if (!AppendBytes(output, capacity, &length, REPLY_SUFFIX, -1))
        return 0;
    return length;
}

#endif

#endif

5. 质数算法代码实现

质数判断函数首先排除小于 2 的整数,然后检查是否存在不大于整数平方根的因数。

点击展开/收起:IsPrime 核心代码
/*
 * IsPrime 使用 trial division 判断质数。divisor <= value / divisor 与
 * divisor * divisor <= value 等价,同时避免乘法 overflow。
 */
inline bool IsPrime(int value)
{
    int divisor;
    if (value < 2)
        return false;
    for (divisor = 2; divisor <= value / divisor; ++divisor)
        if (value % divisor == 0)
            return false;
    return true;
}

服务器使用质数响应生成函数遍历 1 至 1000,将所有质数写入响应字符串。

BuildPrimeReply 在服务器端完成题目要求的计算:依次检查 ([2,1000]) 内的每个整数,把质数追加到 reply,每行排 16 个,并校验 count = 168。返回长度不包含 C 字符串结束符,因为 wire protocol 已经显式携带 payloadLength。

点击展开/收起:BuildPrimeReply 核心代码
inline int BuildPrimeReply(char* output, int capacity)
{
    int length = 0;   /* output 中已经写入的 payload bytes。 */
    int number;       /* 当前接受 primality test 的候选整数。 */
    int count = 0;    /* 已写入 reply 的质数数量。 */

    if (!AppendBytes(output, capacity, &length, REPLY_PREFIX, -1))
        return 0;

    for (number = 2; number <= 1000; ++number)
    {
        char value[16];
        int valueLength;

        if (!IsPrime(number))
            continue;

        sprintf(value, "%d", number);
        valueLength = (int)strlen(value);

        if (!AppendBytes(output, capacity, &length, value, valueLength))
            return 0;

        ++count;

        if (count % 16 == 0)
        {
            if (!AppendBytes(output, capacity, &length, "\r\n", 2))
                return 0;
        }
        else if (number != 997)
        {
            if (!AppendBytes(output, capacity, &length, " ", 1))
                return 0;
        }
    }

    if (count != 168)
        return 0;

    if (!AppendBytes(output, capacity, &length, REPLY_SUFFIX, -1))
        return 0;

    return length;
}

6. 服务器端代码实现

服务器启动监听的核心代码如下:

点击展开/收起:服务器启动监听核心代码
    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)
    {
        AppendSocketError(g_logEdit, L"bind", WSAGetLastError());
        StopServer();
        return false;
    }
    if (listen(g_listener, SOMAXCONN) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"listen", WSAGetLastError());
        StopServer();
        return false;
    }
    /* WSAAsyncSelect 自动设置 nonblocking,并把 FD_ACCEPT/FD_CLOSE 投递给 WndProc。 */
    if (WSAAsyncSelect(g_listener, g_mainWindow, WM_SERVER_SOCKET,
                       FD_ACCEPT | FD_CLOSE) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"WSAAsyncSelect", WSAGetLastError());
        StopServer();
        return false;
    }

服务器处理请求时,将客户端请求与预定 UTF-8 命令进行比较:

点击展开/收起:服务器处理请求核心代码
if (request == REQUEST_TEXT)
{
    std::string response = BuildPrimeResponse();
    QueuePacket(clientContext.sendQueue, response);
    FlushSendQueue(clientContext.socketHandle, clientContext.sendQueue);
}
else
{
    QueuePacket(clientContext.sendQueue, "无法识别的请求。");
}

服务器窗口过程根据网络事件调用对应函数:

点击展开/收起:服务器窗口过程处理核心代码
case WM_SOCKET_EVENT:
{
    SOCKET socketHandle = static_cast<SOCKET>(wParam);
    int networkEvent = WSAGETSELECTEVENT(lParam);
    int eventError = WSAGETSELECTERROR(lParam);
    // 根据套接字和事件类型调用相应处理函数。
    break;
}

server.cpp 的完整整理代码如下。

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

/*
 * WSAAsyncSelect 服务器结构
 * -------------------------
 * GUI thread 同时承担 network event thread。WSAAsyncSelect 把每个 socket 与
 * 当前 window 关联,并自动切换为 nonblocking mode;Winsock 随后向
 * ServerWindowProc 投递 WM_SERVER_SOCKET,而不是进入阻塞式 accept/recv/send loop。
 *
 * Listener state:FD_ACCEPT -> accept 当前排队的全部连接。
 * Client state:  FD_READ   -> 累计接收一个 length-prefixed request。
 *                FD_WRITE  -> 继续发送上次阻塞或未发完的 reply。
 *                FD_CLOSE  -> 只释放发生关闭事件的 client。
 *
 * 所有 socket operation 都不能阻塞 GUI message loop。
 */
const wchar_t SERVER_CLASS_NAME[] = L"WSAAsyncSelectPrimeServer";
const UINT WM_SERVER_SOCKET = WM_APP + 1;
const int ID_SERVER_IP = 101;
const int ID_SERVER_PORT = 102;
const int ID_SERVER_TOGGLE = 103;
const int ID_SERVER_LOG = 104;
const int MAX_CLIENTS = 32;

struct ClientState
{
    /* socketValue 保存已连接 TCP socket;INVALID_SOCKET 表示该 array slot 空闲。 */
    SOCKET socketValue;

    /* transfer 独立保存该 client 的 packet framing 和 partial I/O offset。 */
    TransferState transfer;
};

/*
 * 本实验使用固定大小 g_clients 存储连接。所有 window handle、listener 和 client
 * state 均由单一 GUI thread 管理,使 socket message 与所属连接的对应关系清晰,
 * 同时不需要 lock 或额外 worker thread。
 */
static HWND g_mainWindow = 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;       /* 唯一 listening socket。 */
static ClientState g_clients[MAX_CLIENTS];       /* 各连接的独立 state array。 */
static bool g_winsockStarted = false;            /* WSAStartup 是否成功。 */

/*
 * CloseClient 先取消后续异步通知,再关闭 TCP 两个方向并释放一个 slot。
 * message queue 中可能仍留有关闭前已投递的旧消息,因此 HandleSocketMessage
 * 在处理 notification 前还会确认该 SOCKET 是否仍存在于 g_clients。
 */
static void CloseClient(int index, const wchar_t *reason)
{
    if (index < 0 || index >= MAX_CLIENTS ||
        g_clients[index].socketValue == INVALID_SOCKET)
        return;
    WSAAsyncSelect(g_clients[index].socketValue, g_mainWindow, 0, 0);
    shutdown(g_clients[index].socketValue, SD_BOTH);
    closesocket(g_clients[index].socketValue);
    g_clients[index].socketValue = INVALID_SOCKET;
    ResetTransfer(&g_clients[index].transfer);
    if (reason != NULL)
        AppendLog(g_logEdit, reason);
}

/* FindClient 把 WM_SERVER_SOCKET 的 wParam 中的 SOCKET 映射到 client state slot。 */
static int FindClient(SOCKET socketValue)
{
    int index;
    for (index = 0; index < MAX_CLIENTS; ++index)
        if (g_clients[index].socketValue == socketValue)
            return index;
    return -1;
}

/* FindFreeClient 为 accept() 得到的新连接查找可用 state slot。 */
static int FindFreeClient(void)
{
    int index;
    for (index = 0; index < MAX_CLIENTS; ++index)
        if (g_clients[index].socketValue == INVALID_SOCKET)
            return index;
    return -1;
}

/* StopServer 先关闭全部已连接 client,再取消并关闭 listener。 */
static void StopServer(void)
{
    int index;
    for (index = 0; index < MAX_CLIENTS; ++index)
        CloseClient(index, NULL);
    if (g_listener != INVALID_SOCKET)
    {
        WSAAsyncSelect(g_listener, g_mainWindow, 0, 0);
        closesocket(g_listener);
        g_listener = INVALID_SOCKET;
    }
    if (g_ipEdit != NULL)
        EnableWindow(g_ipEdit, TRUE);
    if (g_portEdit != NULL)
        EnableWindow(g_portEdit, TRUE);
    if (g_toggleButton != NULL)
        SetWindowTextW(g_toggleButton, L"Start listening");
}

/*
 * StartServer 校验 GUI 输入并创建 listening socket。只有 bind() 与 listen()
 * 成功后才注册 WSAAsyncSelect;注册操作同时启用 window message notification,
 * 并把 listener 切换成 nonblocking mode。
 */
static bool StartServer(void)
{
    char ip[64];             /* 从 GUI 读取的 local IPv4 文本。 */
    unsigned short port;     /* 服务器监听 TCP port。 */
    sockaddr_in local;       /* 传给 bind() 的 local endpoint。 */
    BOOL exclusive = TRUE;   /* 禁止其他 socket 复用同一监听地址。 */
    wchar_t line[256];       /* 格式化 GUI 日志的临时 buffer。 */

    if (!ReadAsciiText(g_ipEdit, ip, sizeof(ip)) ||
        !ReadPort(g_portEdit, &port) ||
        !MakeAddress(ip, port, true, &local))
    {
        AppendLog(g_logEdit, L"Invalid local IPv4 address or port.");
        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)
    {
        AppendSocketError(g_logEdit, L"bind", WSAGetLastError());
        StopServer();
        return false;
    }
    if (listen(g_listener, SOMAXCONN) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"listen", WSAGetLastError());
        StopServer();
        return false;
    }
    /* WSAAsyncSelect 自动设置 nonblocking,并把 FD_ACCEPT/FD_CLOSE 投递给 WndProc。 */
    if (WSAAsyncSelect(g_listener, g_mainWindow, WM_SERVER_SOCKET,
                       FD_ACCEPT | FD_CLOSE) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"WSAAsyncSelect", WSAGetLastError());
        StopServer();
        return false;
    }
    EnableWindow(g_ipEdit, FALSE);
    EnableWindow(g_portEdit, FALSE);
    SetWindowTextW(g_toggleButton, L"Stop listening");
    wsprintfW(line, L"Listening on %S:%u with WSAAsyncSelect.", ip,
              (unsigned int)port);
    AppendLog(g_logEdit, line);
    return true;
}

/* FinishReply 结束一个 request/reply transaction,但 listener 继续服务其他连接。 */
static void FinishReply(int index)
{
    AppendLog(g_logEdit, L"Reply sent; closing this client connection.");
    CloseClient(index, NULL);
}

/*
 * TrySendReply 在 reply 准备完成或收到 FD_WRITE 时立即尝试推进发送。
 * 若 socket 暂时不可写,TransferState.sent 保留下一字节 offset;发送缓冲区再次
 * 可用后,Winsock 会重新投递 FD_WRITE,从该 offset 继续发送。
 */
static void TrySendReply(int index)
{
    int error = 0;
    int status;
    if (index < 0 || g_clients[index].socketValue == INVALID_SOCKET ||
        g_clients[index].transfer.outputLength == 0)
        return;
    status = FlushOutput(g_clients[index].socketValue,
                         &g_clients[index].transfer, &error);
    if (status == 1)
        FinishReply(index);
    else if (status < 0)
    {
        AppendSocketError(g_logEdit, L"send", error);
        CloseClient(index, L"Client closed after send failure.");
    }
}

/*
 * PrepareReply 处理一个完整 request packet,只接受题目规定的精确文本。
 * 匹配成功后,服务器在 runtime 计算 prime numbers,封装 UTF-8 reply packet,
 * 随后立即尝试第一次 send;其他文本得到 ERROR_REPLY。
 */
static void PrepareReply(int index, int payloadLength)
{
    TransferState *transfer = &g_clients[index].transfer;
    const char *payload = transfer->input + PACKET_HEADER_SIZE;
    char reply[MAX_PAYLOAD_SIZE];
    int replyLength;

    if (payloadLength == (int)strlen(REQUEST_TEXT) &&
        memcmp(payload, REQUEST_TEXT, payloadLength) == 0)
    {
        AppendLog(g_logEdit, L"Request received:");
        AppendLogUtf8(g_logEdit, REQUEST_TEXT);
        replyLength = BuildPrimeReply(reply, sizeof(reply));
    }
    else
    {
        AppendLog(g_logEdit, L"Unsupported request received.");
        replyLength = (int)strlen(ERROR_REPLY);
        memcpy(reply, ERROR_REPLY, replyLength);
    }
    if (replyLength <= 0)
    {
        AppendLog(g_logEdit, L"Could not build the reply.");
        CloseClient(index, NULL);
        return;
    }
    transfer->outputLength = BuildPacket(transfer->output,
                                          sizeof(transfer->output),
                                          reply, replyLength);
    transfer->sent = 0;
    if (transfer->outputLength == 0)
    {
        AppendLog(g_logEdit, L"Reply exceeds the protocol limit.");
        CloseClient(index, NULL);
        return;
    }
    TrySendReply(index);
}

/*
 * HandleClientRead 取完当前 readable bytes 并推进 receive state machine。
 * partial request 保留在该 client 的 TransferState 中,等待下一次 FD_READ;
 * 提前关闭、非法 length 或真实 recv error 只会关闭受影响的 client。
 */
static void HandleClientRead(int index)
{
    int payloadLength = 0;
    int error = 0;
    int status = ReceivePacket(g_clients[index].socketValue,
                               &g_clients[index].transfer,
                               &payloadLength, &error);
    if (status == 1)
        PrepareReply(index, payloadLength);
    else if (status == -2)
        CloseClient(index, L"Client closed before sending a complete request.");
    else if (status < 0)
    {
        if (error != 0)
            AppendSocketError(g_logEdit, L"recv", error);
        else
            AppendLog(g_logEdit, L"Invalid or oversized request packet.");
        CloseClient(index, NULL);
    }
}

/*
 * AcceptClients 清空 listener 的 pending connection queue。一次 FD_ACCEPT 可能
 * 对应多个排队连接,因此循环 accept() 直到 WSAEWOULDBLOCK。每个 accepted socket
 * 都注册独立的 WSAAsyncSelect event mask,并分配自己的 TransferState。
 */
static void AcceptClients(void)
{
    for (;;)
    {
        sockaddr_in peer;
        int peerLength = sizeof(peer);
        SOCKET clientSocket = accept(g_listener, (sockaddr *)&peer, &peerLength);
        int index;
        wchar_t line[256];
        if (clientSocket == INVALID_SOCKET)
        {
            int error = WSAGetLastError();
            if (error != WSAEWOULDBLOCK)
                AppendSocketError(g_logEdit, L"accept", error);
            return;
        }
        index = FindFreeClient();
        if (index < 0)
        {
            closesocket(clientSocket);
            AppendLog(g_logEdit, L"Server is full; new connection rejected.");
            continue;
        }
        if (WSAAsyncSelect(clientSocket, g_mainWindow, WM_SERVER_SOCKET,
                           FD_READ | FD_WRITE | FD_CLOSE) == SOCKET_ERROR)
        {
            AppendSocketError(g_logEdit, L"WSAAsyncSelect(client)",
                              WSAGetLastError());
            closesocket(clientSocket);
            continue;
        }
        g_clients[index].socketValue = clientSocket;
        ResetTransfer(&g_clients[index].transfer);
        wsprintfW(line, L"Client connected: %S:%u", inet_ntoa(peer.sin_addr),
                  (unsigned int)ntohs(peer.sin_port));
        AppendLog(g_logEdit, line);
    }
}

/*
 * HandleSocketMessage 解析一个 asynchronous socket notification:
 *
 *   wParam                         = 状态发生变化的 SOCKET
 *   WSAGETSELECTEVENT(lParam)      = FD_ACCEPT/READ/WRITE/CLOSE
 *   WSAGETSELECTERROR(lParam)      = 该事件的 Winsock error,0 表示无错误
 *
 * listener event 与 connected-client event 分开处理,避免混淆监听和业务连接。
 */
static void HandleSocketMessage(WPARAM wParam, LPARAM lParam)
{
    SOCKET socketValue = (SOCKET)wParam;
    int eventValue = WSAGETSELECTEVENT(lParam);
    int eventError = WSAGETSELECTERROR(lParam);
    int index;

    if (socketValue == g_listener)
    {
        if (eventError != 0)
        {
            AppendSocketError(g_logEdit, L"listener event", eventError);
            StopServer();
            return;
        }
        if (eventValue == FD_ACCEPT)
            AcceptClients();
        else if (eventValue == FD_CLOSE)
        {
            AppendLog(g_logEdit, L"Listening socket closed.");
            StopServer();
        }
        return;
    }

    index = FindClient(socketValue);
    if (index < 0)
        return; /* 忽略已经关闭 socket 对应的残留 queued message。 */
    if (eventError != 0)
    {
        AppendSocketError(g_logEdit, L"client socket event", eventError);
        CloseClient(index, NULL);
        return;
    }
    if (eventValue == FD_READ)
        HandleClientRead(index);
    else if (eventValue == FD_WRITE)
        TrySendReply(index);
    else if (eventValue == FD_CLOSE)
        CloseClient(index, L"Client connection closed.");
}

/* CreateServerControls 创建地址输入框、启动/停止按钮和可滚动日志框。 */
static void CreateServerControls(HWND window)
{
    HFONT font = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
    HWND label;
    label = CreateWindowExW(0, L"STATIC", L"Local IP:", WS_CHILD | WS_VISIBLE,
                            12, 14, 65, 22, window, NULL, NULL, NULL);
    SendMessageW(label, WM_SETFONT, (WPARAM)font, TRUE);
    g_ipEdit = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"192.168.50.1",
                               WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL,
                               78, 10, 135, 24, window,
                               (HMENU)ID_SERVER_IP, NULL, NULL);
    SendMessageW(g_ipEdit, WM_SETFONT, (WPARAM)font, TRUE);
    label = CreateWindowExW(0, L"STATIC", L"Port:", WS_CHILD | WS_VISIBLE,
                            225, 14, 38, 22, window, NULL, NULL, NULL);
    SendMessageW(label, WM_SETFONT, (WPARAM)font, TRUE);
    g_portEdit = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"1145",
                                 WS_CHILD | WS_VISIBLE | ES_NUMBER,
                                 264, 10, 70, 24, window,
                                 (HMENU)ID_SERVER_PORT, NULL, NULL);
    SendMessageW(g_portEdit, WM_SETFONT, (WPARAM)font, TRUE);
    g_toggleButton = CreateWindowExW(0, L"BUTTON", L"Start listening",
                                     WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
                                     346, 9, 125, 26, window,
                                     (HMENU)ID_SERVER_TOGGLE, NULL, NULL);
    SendMessageW(g_toggleButton, WM_SETFONT, (WPARAM)font, TRUE);
    g_logEdit = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"",
                                WS_CHILD | WS_VISIBLE | WS_VSCROLL |
                                    ES_MULTILINE | ES_AUTOVSCROLL |
                                    ES_READONLY,
                                12, 48, 459, 300, window,
                                (HMENU)ID_SERVER_LOG, NULL, NULL);
    SendMessageW(g_logEdit, WM_SETFONT, (WPARAM)font, TRUE);
}

/*
 * ServerWindowProc 是主 Win32 dispatcher。普通 GUI command 与 network readiness
 * event 共用同一 message queue,这是 WSAAsyncSelect model 的核心工作方式。
 */
static LRESULT CALLBACK ServerWindowProc(HWND window, UINT message,
                                         WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
    {
        int index;
        WSADATA data;
        g_mainWindow = window;
        for (index = 0; index < MAX_CLIENTS; ++index)
        {
            g_clients[index].socketValue = INVALID_SOCKET;
            ResetTransfer(&g_clients[index].transfer);
        }
        CreateServerControls(window);
        if (WSAStartup(MAKEWORD(2, 2), &data) != 0)
        {
            MessageBoxW(window, L"WSAStartup failed.", L"Server", MB_ICONERROR);
            return -1;
        }
        g_winsockStarted = true;
        AppendLog(g_logEdit, L"Press Start listening to begin.");
        return 0;
    }
    case WM_COMMAND:
        if (LOWORD(wParam) == ID_SERVER_TOGGLE && HIWORD(wParam) == BN_CLICKED)
        {
            if (g_listener == INVALID_SOCKET)
                StartServer();
            else
            {
                StopServer();
                AppendLog(g_logEdit, L"Server stopped.");
            }
        }
        return 0;
    case WM_SIZE:
        if (g_logEdit != NULL)
            MoveWindow(g_logEdit, 12, 48,
                       LOWORD(lParam) > 24 ? LOWORD(lParam) - 24 : 1,
                       HIWORD(lParam) > 60 ? HIWORD(lParam) - 60 : 1, TRUE);
        return 0;
    case WM_SERVER_SOCKET:
        HandleSocketMessage(wParam, lParam);
        return 0;
    case WM_DESTROY:
        StopServer();
        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)
{
    WNDCLASSEXW windowClass;
    HWND window;
    MSG message;
    (void)previous;
    (void)commandLine;
    memset(&windowClass, 0, sizeof(windowClass));
    windowClass.cbSize = sizeof(windowClass);
    windowClass.lpfnWndProc = ServerWindowProc;
    windowClass.hInstance = instance;
    windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    windowClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    windowClass.lpszClassName = SERVER_CLASS_NAME;
    if (!RegisterClassExW(&windowClass))
        return 1;
    window = CreateWindowExW(0, SERVER_CLASS_NAME,
                             L"WSAAsyncSelect Prime Server",
                             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
                             510, 420, NULL, NULL, instance, NULL);
    if (window == NULL)
        return 1;
    ShowWindow(window, showCommand);
    UpdateWindow(window);
    /* 同一个 message loop 同时驱动 user interface 和全部 socket I/O。 */
    while (GetMessageW(&message, NULL, 0, 0) > 0)
    {
        TranslateMessage(&message);
        DispatchMessageW(&message);
    }
    return (int)message.wParam;
}

7. 客户端代码实现

客户端创建套接字后绑定本地地址,并注册异步网络事件:

点击展开/收起:客户端创建套接字核心代码
    g_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (g_socket == INVALID_SOCKET)
    {
        AppendSocketError(g_logEdit, L"socket", WSAGetLastError());
        return;
    }
    if (WSAAsyncSelect(g_socket, g_mainWindow, WM_CLIENT_SOCKET,
                       FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"WSAAsyncSelect", WSAGetLastError());
        CloseConnection();
        return;
    }

    /* localIp 为空时不调用 bind(),由 Windows 自动选择 source address。 */
    if (localIp[0] != '\0')
    {
        if (!MakeAddress(localIp, 0, false, &local))
        {
            AppendLog(g_logEdit, L"Invalid local IPv4 address.");
            CloseConnection();
            return;
        }
        if (bind(g_socket, (sockaddr *)&local, sizeof(local)) == SOCKET_ERROR)
        {
            AppendSocketError(g_logEdit, L"client bind", WSAGetLastError());
            CloseConnection();
            return;
        }
    }
连接成功后,客户端将质数查询请求加入发送队列:
点击展开/收起:客户端将质数查询请求加入发送队列核心代码

std::string request(REQUEST_TEXT);

QueuePacket(clientContext.sendQueue, request);
FlushSendQueue(clientContext.socketHandle, clientContext.sendQueue);
`client.cpp` 的完整整理代码如下。
点击展开/收起:client.cpp(客户端完整代码)
#include "wsaasync_common.h"

/*
 * WSAAsyncSelect 客户端状态机
 * ---------------------------
 * Button click -> 创建、bind 并 connect nonblocking socket
 * FD_CONNECT   -> asynchronous connection result 已产生
 * FD_WRITE     -> 继续发送尚未提交的 request bytes
 * FD_READ      -> 累计接收 length-prefixed reply
 * FD_CLOSE     -> 释放当前 connection
 *
 * 所有 state transition 都在 GUI thread 的 ClientWindowProc 内完成,因此
 * connect()、send() 和 recv() 推进期间 window 仍保持响应。
 */
const wchar_t CLIENT_CLASS_NAME[] = L"WSAAsyncSelectPrimeClient";
const UINT WM_CLIENT_SOCKET = WM_APP + 1;
const UINT CLIENT_TIMER_ID = 1;
const int ID_CLIENT_SERVER_IP = 201;
const int ID_CLIENT_LOCAL_IP = 202;
const int ID_CLIENT_PORT = 203;
const int ID_CLIENT_SEND = 204;
const int ID_CLIENT_LOG = 205;

static HWND g_mainWindow = 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; /* 当前唯一 client TCP socket。 */
static TransferState g_transfer;         /* 当前 transaction 的收发 state。 */
static bool g_connected = false;         /* FD_CONNECT 是否已成功处理。 */
static bool g_requestSentLogged = false; /* 防止重复记录同一发送成功日志。 */
static bool g_winsockStarted = false;    /* WSAStartup 是否成功。 */

/* SetClientInputsEnabled 防止 asynchronous transaction 期间修改连接参数。 */
static void SetClientInputsEnabled(BOOL enabled)
{
    EnableWindow(g_serverIpEdit, enabled);
    EnableWindow(g_localIpEdit, enabled);
    EnableWindow(g_portEdit, enabled);
    EnableWindow(g_sendButton, enabled);
}

/*
 * CloseConnection 结束当前 transaction,并把 GUI 恢复到初始状态。
 * 在 closesocket 前取消 WSAAsyncSelect,避免继续请求新 notification;关闭前刚刚
 * 投递的旧消息仍可能留在 queue 中,因此 HandleSocketMessage 还会核对 socketValue。
 */
static void CloseConnection(void)
{
    KillTimer(g_mainWindow, CLIENT_TIMER_ID);
    if (g_socket != INVALID_SOCKET)
    {
        WSAAsyncSelect(g_socket, g_mainWindow, 0, 0);
        shutdown(g_socket, SD_BOTH);
        closesocket(g_socket);
        g_socket = INVALID_SOCKET;
    }
    g_connected = false;
    g_requestSentLogged = false;
    ResetTransfer(&g_transfer);
    SetClientInputsEnabled(TRUE);
}

/*
 * TrySendRequest 始终从 TransferState.sent offset 继续发送,不会重新从 packet
 * 开头发送。would-block 不是失败:函数返回 message loop,等待后续 FD_WRITE
 * notification 后再恢复发送。
 */
static void TrySendRequest(void)
{
    int error = 0;
    int status;
    if (!g_connected || g_socket == INVALID_SOCKET)
        return;
    status = FlushOutput(g_socket, &g_transfer, &error);
    if (status == 1 && !g_requestSentLogged)
    {
        g_requestSentLogged = true;
        AppendLog(g_logEdit, L"Request sent:");
        AppendLogUtf8(g_logEdit, REQUEST_TEXT);
        AppendLog(g_logEdit, L"Waiting for the server reply...");
    }
    else if (status < 0)
    {
        AppendSocketError(g_logEdit, L"send", error);
        CloseConnection();
    }
}

/*
 * ConnectionEstablished 完成 FD_CONNECT transition。getsockname 取得实际 local
 * endpoint,包括系统动态分配的 source port,便于与服务器日志交叉验证。
 * g_connected guard 防止 connect 立即成功且随后又收到 FD_CONNECT 时重复发送请求。
 */
static void ConnectionEstablished(void)
{
    sockaddr_in local;
    int localLength = sizeof(local);
    wchar_t line[256];
    if (g_connected)
        return;
    g_connected = true;
    if (getsockname(g_socket, (sockaddr *)&local, &localLength) == 0)
    {
        wsprintfW(line, L"Connected. Client endpoint: %S:%u",
                  inet_ntoa(local.sin_addr),
                  (unsigned int)ntohs(local.sin_port));
        AppendLog(g_logEdit, line);
    }
    else
        AppendLog(g_logEdit, L"Connected to the server.");
    TrySendRequest();
}

/*
 * StartRequest 构造题目规定的精确 UTF-8 request,创建 TCP socket,并在 connect()
 * 前注册 event。WSAAsyncSelect 会把 socket 设置为 nonblocking,因此
 * WSAEWOULDBLOCK 表示 connection in progress,而不是连接失败。
 *
 * Local IP 非空时,bind() 强制使用指定 source interface/address;留空则让 Windows
 * 按 routing table 自动选择,适合在两台真实 PC 上运行。
 */
static void StartRequest(void)
{
    char serverIp[64];       /* remote server IPv4 文本。 */
    char localIp[64];        /* 可选 source IPv4 文本。 */
    unsigned short port;     /* remote server TCP port。 */
    sockaddr_in remote;      /* 传给 connect() 的 endpoint。 */
    sockaddr_in local;       /* localIp 非空时传给 bind()。 */
    int result;              /* connect() 的立即返回值。 */

    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"Invalid server IPv4 address or port.");
        return;
    }

    ResetTransfer(&g_transfer);
    g_transfer.outputLength = BuildPacket(g_transfer.output,
                                           sizeof(g_transfer.output),
                                           REQUEST_TEXT,
                                           (int)strlen(REQUEST_TEXT));
    if (g_transfer.outputLength == 0)
    {
        AppendLog(g_logEdit, L"Could not build the request packet.");
        return;
    }
    g_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (g_socket == INVALID_SOCKET)
    {
        AppendSocketError(g_logEdit, L"socket", WSAGetLastError());
        return;
    }
    if (WSAAsyncSelect(g_socket, g_mainWindow, WM_CLIENT_SOCKET,
                       FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE) == SOCKET_ERROR)
    {
        AppendSocketError(g_logEdit, L"WSAAsyncSelect", WSAGetLastError());
        CloseConnection();
        return;
    }

    /* localIp 为空时不调用 bind(),由 Windows 自动选择 source address。 */
    if (localIp[0] != '\0')
    {
        if (!MakeAddress(localIp, 0, false, &local))
        {
            AppendLog(g_logEdit, L"Invalid local IPv4 address.");
            CloseConnection();
            return;
        }
        if (bind(g_socket, (sockaddr *)&local, sizeof(local)) == SOCKET_ERROR)
        {
            AppendSocketError(g_logEdit, L"client bind", WSAGetLastError());
            CloseConnection();
            return;
        }
    }

    SetClientInputsEnabled(FALSE);
    AppendLog(g_logEdit, L"Connecting asynchronously...");
    SetTimer(g_mainWindow, CLIENT_TIMER_ID, 15000, NULL);
    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();
        }
    }
}

/*
 * HandleReplyRead 取完当前可读的 reply bytes,并依据 4-byte length 判断消息完整。
 * 收到的 payload 与本地 BuildPrimeReply 生成的 expected result 逐字节比较;因此
 * PASS 表示 168 个 prime number 均按正确顺序完整到达,而非只匹配少量标志值。
 */
static void HandleReplyRead(void)
{
    int payloadLength = 0;
    int error = 0;
    int status = ReceivePacket(g_socket, &g_transfer,
                               &payloadLength, &error);
    if (status == 1)
    {
        char payload[MAX_PAYLOAD_SIZE + 1];
        char expected[MAX_PAYLOAD_SIZE];
        int expectedLength;
        memcpy(payload, g_transfer.input + PACKET_HEADER_SIZE, payloadLength);
        payload[payloadLength] = '\0';
        AppendLog(g_logEdit, L"Server reply:");
        AppendLogUtf8(g_logEdit, payload);
        expectedLength = BuildPrimeReply(expected, sizeof(expected));
        if (expectedLength == payloadLength &&
            memcmp(payload, expected, payloadLength) == 0)
            AppendLog(g_logEdit,
                      L"PASS: the complete prime-number reply was received.");
        else
            AppendLog(g_logEdit, L"The reply was complete but unexpected.");
        CloseConnection();
    }
    else if (status == -2)
    {
        AppendLog(g_logEdit, L"Server closed before a complete reply arrived.");
        CloseConnection();
    }
    else if (status < 0)
    {
        if (error != 0)
            AppendSocketError(g_logEdit, L"recv", error);
        else
            AppendLog(g_logEdit, L"Invalid or oversized reply packet.");
        CloseConnection();
    }
}

/*
 * HandleSocketMessage 分派 Winsock 封装在 WM_CLIENT_SOCKET 中的 event 与 error。
 * wParam 标识 socket;lParam 包含一个 FD_* event 及其对应 error code。
 */
static void HandleSocketMessage(WPARAM wParam, LPARAM lParam)
{
    int eventValue;
    int eventError;
    if ((SOCKET)wParam != g_socket || g_socket == INVALID_SOCKET)
        return; /* 忽略已经关闭的旧 socket 对应的 queued message。 */
    eventValue = WSAGETSELECTEVENT(lParam);
    eventError = WSAGETSELECTERROR(lParam);
    if (eventError != 0)
    {
        AppendSocketError(g_logEdit, L"socket event", eventError);
        CloseConnection();
        return;
    }
    if (eventValue == FD_CONNECT)
        ConnectionEstablished();
    else if (eventValue == FD_WRITE)
        TrySendRequest();
    else if (eventValue == FD_READ)
        HandleReplyRead();
    else if (eventValue == FD_CLOSE)
    {
        AppendLog(g_logEdit, L"Server connection closed.");
        CloseConnection();
    }
}

/* CreateClientControls 创建 server/local 地址输入、发送按钮和可滚动日志框。 */
static void CreateClientControls(HWND window)
{
    HFONT font = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
    HWND label;
    label = CreateWindowExW(0, L"STATIC", L"Server IP:",
                            WS_CHILD | WS_VISIBLE, 12, 14, 68, 22,
                            window, NULL, NULL, NULL);
    SendMessageW(label, WM_SETFONT, (WPARAM)font, TRUE);
    g_serverIpEdit = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT",
                                     L"192.168.50.1",
                                     WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL,
                                     80, 10, 130, 24, window,
                                     (HMENU)ID_CLIENT_SERVER_IP, NULL, NULL);
    SendMessageW(g_serverIpEdit, WM_SETFONT, (WPARAM)font, TRUE);
    label = CreateWindowExW(0, L"STATIC", L"Local IP:",
                            WS_CHILD | WS_VISIBLE, 222, 14, 58, 22,
                            window, NULL, NULL, NULL);
    SendMessageW(label, WM_SETFONT, (WPARAM)font, TRUE);
    g_localIpEdit = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT",
                                    L"192.168.50.2",
                                    WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL,
                                    280, 10, 130, 24, window,
                                    (HMENU)ID_CLIENT_LOCAL_IP, NULL, NULL);
    SendMessageW(g_localIpEdit, WM_SETFONT, (WPARAM)font, TRUE);
    label = CreateWindowExW(0, L"STATIC", L"Port:",
                            WS_CHILD | WS_VISIBLE, 422, 14, 36, 22,
                            window, NULL, NULL, NULL);
    SendMessageW(label, WM_SETFONT, (WPARAM)font, TRUE);
    g_portEdit = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"1145",
                                 WS_CHILD | WS_VISIBLE | ES_NUMBER,
                                 458, 10, 65, 24, window,
                                 (HMENU)ID_CLIENT_PORT, NULL, NULL);
    SendMessageW(g_portEdit, WM_SETFONT, (WPARAM)font, TRUE);
    g_sendButton = CreateWindowExW(0, L"BUTTON", L"Connect and send request",
                                   WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
                                   535, 9, 180, 26, window,
                                   (HMENU)ID_CLIENT_SEND, NULL, NULL);
    SendMessageW(g_sendButton, WM_SETFONT, (WPARAM)font, TRUE);
    g_logEdit = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"",
                                WS_CHILD | WS_VISIBLE | WS_VSCROLL |
                                    ES_MULTILINE | ES_AUTOVSCROLL |
                                    ES_READONLY,
                                12, 48, 703, 330, window,
                                (HMENU)ID_CLIENT_LOG, NULL, NULL);
    SendMessageW(g_logEdit, WM_SETFONT, (WPARAM)font, TRUE);
}

/*
 * ClientWindowProc 统一处理 GUI action、asynchronous network event 和 transaction
 * timeout。15-second timer 防止不可达或无回应的 peer 使控件永久禁用;
 * 整个处理过程不使用任何 blocking wait。
 */
static LRESULT CALLBACK ClientWindowProc(HWND window, UINT message,
                                         WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_CREATE:
    {
        WSADATA data;
        g_mainWindow = window;
        ResetTransfer(&g_transfer);
        CreateClientControls(window);
        if (WSAStartup(MAKEWORD(2, 2), &data) != 0)
        {
            MessageBoxW(window, L"WSAStartup failed.", L"Client", MB_ICONERROR);
            return -1;
        }
        g_winsockStarted = true;
        AppendLog(g_logEdit,
                  L"Press Connect and send request after the server is listening.");
        return 0;
    }
    case WM_COMMAND:
        if (LOWORD(wParam) == ID_CLIENT_SEND && HIWORD(wParam) == BN_CLICKED)
            StartRequest();
        return 0;
    case WM_SIZE:
        if (g_logEdit != NULL)
            MoveWindow(g_logEdit, 12, 48,
                       LOWORD(lParam) > 24 ? LOWORD(lParam) - 24 : 1,
                       HIWORD(lParam) > 60 ? HIWORD(lParam) - 60 : 1, TRUE);
        return 0;
    case WM_CLIENT_SOCKET:
        HandleSocketMessage(wParam, lParam);
        return 0;
    case WM_TIMER:
        if (wParam == CLIENT_TIMER_ID && g_socket != INVALID_SOCKET)
        {
            AppendLog(g_logEdit, L"Operation timed out after 15 seconds.");
            CloseConnection();
        }
        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)
{
    WNDCLASSEXW windowClass;
    HWND window;
    MSG message;
    (void)previous;
    (void)commandLine;
    memset(&windowClass, 0, sizeof(windowClass));
    windowClass.cbSize = sizeof(windowClass);
    windowClass.lpfnWndProc = ClientWindowProc;
    windowClass.hInstance = instance;
    windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    windowClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    windowClass.lpszClassName = CLIENT_CLASS_NAME;
    if (!RegisterClassExW(&windowClass))
        return 1;
    window = CreateWindowExW(0, CLIENT_CLASS_NAME,
                             L"WSAAsyncSelect Prime Client",
                             WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
                             755, 455, NULL, NULL, instance, NULL);
    if (window == NULL)
        return 1;
    ShowWindow(window, showCommand);
    UpdateWindow(window);
    /* 同一个 message loop 处理 control、timer 和 socket notification。 */
    while (GetMessageW(&message, NULL, 0, 0) > 0)
    {
        TranslateMessage(&message);
        DispatchMessageW(&message);
    }
    return (int)message.wParam;
}

8. 协议测试程序

为验证质数算法、应用层数据帧封装、网络字节序长度解析以及响应正文的一致性,本实验编写了独立的 protocol_test.cpp 协议测试程序。该程序不创建网络套接字,而是在本地内存中模拟服务器响应的生成、封装和解析过程,从而在运行服务器端与客户端之前检查公共算法和通信协议是否正确。

协议测试程序依次完成以下操作:

  1. 遍历 1 至 1000 范围内的全部整数,调用 IsPrime() 独立统计质数数量。
  2. 检查 2 和 997 能否被正确判断为质数。
  3. 检查 1000 能否被正确判断为非质数。
  4. 调用 BuildPrimeReply() 生成服务器质数响应正文。
  5. 调用 BuildPacket() 将响应正文封装为四字节长度前缀数据帧。
  6. 调用 PacketStatus() 解析网络字节序长度字段。
  7. 检查解析得到的正文长度是否与原始响应长度一致。
  8. 使用 memcmp() 对原始响应和解析后的正文进行逐字节比较。
  9. 输出请求字节数、响应字节数和质数数量。
  10. 在直接运行或调试模式下等待用户按下 Enter 键后退出。

为保证中文请求能够在控制台中正确显示,程序在输出测试结果前调用:

SetConsoleOutputCP(CP_UTF8);

测试成功后,控制台输出内容如下:

Request: 请输出从1到1000内所有的质数
PASS: request bytes=38, reply bytes=709, prime count=168
Press Enter to exit...

程序显示上述结果后不会立即关闭控制台窗口,而是停留在 Press Enter to exit... 提示处。用户按下 Enter 键后,程序以退出码 0 正常结束。这样可以避免直接运行 protocol_test.exe 时窗口快速关闭,便于观察和记录完整测试结果。

协议测试程序的实际运行结果如图 8 所示。

图片8

图 8 协议测试程序实际运行结果(图片说明:控制台应输出 Request、PASS: request bytes=38, reply bytes=709, prime count=168,并停留在 Press Enter to exit... 提示处。)

protocol_test.cpp 具体代码如下。

点击展开/收起:protocol_test.cpp(协议测试完整代码)
#include "wsaasync_common.h"

/*
 * protocol self-test 不打开 socket。在运行 GUI 程序前,验证题目规定的 prime
 * count、packet serialization、network-order length decoding,以及 payload
 * 逐字节保持不变。
 */
int main(int argc, char *argv[])
{
    char reply[MAX_PAYLOAD_SIZE];
    TransferState state;
    int replyLength;       /* BuildPrimeReply 返回的 payload bytes。 */
    int packetLength;      /* header 与 payload 的总 bytes。 */
    int payloadLength = 0; /* PacketStatus 解码出的 network length。 */
    int primeCount = 0;    /* self-test 独立统计的 prime count。 */
    int value;             /* [1,1000] 内的当前测试值。 */
    bool waitForEnter = true; /* 直接运行时保留控制台窗口,自动构建时可跳过等待。 */

    /*
     * build.ps1 使用 --no-wait 执行自动 self-test,避免构建任务等待用户输入。
     * 用户直接运行或调试 protocol_test.exe 时不传该参数,测试成功后必须按
     * Enter 键退出,因此可以完整查看控制台中的 request 和 PASS 信息。
     */
    if (argc > 1 && strcmp(argv[1], "--no-wait") == 0)
        waitForEnter = false;

    /* 独立统计 IsPrime 接受的全部 value,验证 [1,1000] 内应有 168 个质数。 */
    for (value = 1; value <= 1000; ++value)
        if (IsPrime(value))
            ++primeCount;
    if (primeCount != 168 || !IsPrime(2) || !IsPrime(997) || IsPrime(1000))
        return 1;

    replyLength = BuildPrimeReply(reply, sizeof(reply));
    if (replyLength <= 0)
        return 2;

    /* 复用 state.input 模拟一个已经完整到达的 TCP packet。 */
    ResetTransfer(&state);
    packetLength = BuildPacket(state.input, sizeof(state.input),
                               reply, replyLength);
    if (packetLength <= 0)
        return 3;
    state.inputLength = packetLength;
    if (PacketStatus(&state, &payloadLength) != 1 ||
        payloadLength != replyLength ||
        memcmp(state.input + PACKET_HEADER_SIZE, reply, replyLength) != 0)
        return 4;

    SetConsoleOutputCP(CP_UTF8);
    printf("Request: %s\n", REQUEST_TEXT);
    printf("PASS: request bytes=%u, reply bytes=%d, prime count=%d\n",
           (unsigned int)strlen(REQUEST_TEXT), replyLength, primeCount);

    if (waitForEnter)
    {
        int inputCharacter;
        printf("Press Enter to exit...\n");
        fflush(stdout);

        /* 只接受换行或输入结束;其他按键不会提前关闭测试窗口。 */
        do
        {
            inputCharacter = getchar();
        } while (inputCharacter != '\n' && inputCharacter != EOF);
    }

    return 0;
}

9. 构建脚本

在项目目录中执行以下命令:

powershell -ExecutionPolicy Bypass -File .\build.ps1

构建脚本负责分别编译服务器端、客户端和协议测试程序。build.ps1 中编译命令如下。

点击展开/收起:build.ps1(构建脚本完整代码)

编译完成后,项目目录中应生成:

server.exe
client.exe
protocol_test.exe

10. 运行服务器端与客户端

首先运行 server.exe,确认服务器地址为 192.168.50.1、监听端口为 1145,然后单击“开始监听”。

随后运行 client.exe,设置以下参数:

服务器地址:192.168.50.1
客户端地址:192.168.50.2
服务器端口:1145

单击“连接服务器”后,客户端进入异步连接状态。连接成功时,程序启用发送按钮。客户端发送以下请求:

请输出从1到1000内所有的质数

客户端和服务器的运行结果,如图 9 所示。

图片9

图 9 客户端与服务器运行结果(图片说明:服务器日志显示监听、客户端连接、收到请求、发送响应并关闭连接;客户端日志显示异步连接、本地端点、发送请求、收到完整质数列表以及 PASS 提示。)

11. 协议测试结果

为验证质数算法、应用层数据帧封装、网络字节序长度解析以及响应正文的一致性,本实验编写了独立的 protocol_test.cpp 协议测试程序。该程序不创建网络套接字,而是在本地内存中模拟服务器响应的生成、封装和解析过程,从而在运行服务器端与客户端之前检查公共算法和通信协议是否正确。

协议测试程序依次完成以下操作:

  1. 遍历 1 至 1000 范围内的全部整数,调用 IsPrime() 独立统计质数数量。
  2. 检查 2 和 997 能否被正确判断为质数。
  3. 检查 1000 能否被正确判断为非质数。
  4. 调用 BuildPrimeReply() 生成服务器质数响应正文。
  5. 调用 BuildPacket() 将响应正文封装为四字节长度前缀数据帧。
  6. 调用 PacketStatus() 解析网络字节序长度字段。
  7. 检查解析得到的正文长度是否与原始响应长度一致。
  8. 使用 memcmp() 对原始响应和解析后的正文进行逐字节比较。
  9. 输出请求字节数、响应字节数和质数数量。
  10. 在直接运行或调试模式下等待用户按下 Enter 键后退出。

为保证中文请求能够在控制台中正确显示,程序在输出测试结果前调用:

SetConsoleOutputCP(CP_UTF8);

测试成功后,控制台输出内容如下:

Request: 请输出从1到1000内所有的质数
PASS: request bytes=38, reply bytes=709, prime count=168
Press Enter to exit...

程序显示上述结果后不会立即关闭控制台窗口,而是停留在 Press Enter to exit... 提示处。用户按下 Enter 键后,程序以退出码 0 正常结束。这样可以避免直接运行 protocol_test.exe 时窗口快速关闭,便于观察和记录完整测试结果。

协议测试程序的实际运行结果如图 10所示。

图片9

图 10 协议测试程序实际运行结果(图片说明:应显示 Request、PASS: request bytes=38, reply bytes=709, prime count=168,以及 Press Enter to exit... 提示。)

协议测试的各项实际结果如表 6 所示。

表 6 协议测试结果

测试项目 实际结果 结论
请求正文长度 38 字节 正确
质数响应正文长度 709 字节 正确
1 至 1000 范围内的质数数量 168 个 正确
最小质数 2 的判断 质数 正确
最大被测质数 997 的判断 质数 正确
整数 1000 的判断 非质数 正确
质数响应生成 成功 正确
四字节长度前缀封装 成功 正确
网络字节序长度解析 709 字节 正确
响应正文逐字节比较 完全一致 正确
直接运行退出方式 按 Enter 键退出 符合设计
自动构建退出方式 使用 --no-wait 自动退出 不阻塞构建程序
成功退出码 0 正确

请求正文的 UTF-8 字节长度为:

\[L_{\mathrm{request}} = 38\ \mathrm{Bytes} \tag{15} \]

按照四字节长度前缀协议,请求数据帧总长度为:

\[P_{\mathrm{request}} = 4 + L_{\mathrm{request}} = 4 + 38 = 42\ \mathrm{Bytes} \tag{16} \]

质数响应正文长度为:

\[L_{\mathrm{reply}} = 709\ \mathrm{Bytes} \tag{17} \]

因此,质数响应数据帧总长度为:

\[P_{\mathrm{reply}} = 4 + L_{\mathrm{reply}} = 4 + 709 = 713\ \mathrm{Bytes} \tag{18} \]

质数数量满足:

\[\pi(1000) = 168 \tag{19} \]

其中,(\pi(N)) 表示不大于 (N) 的质数数量。

协议测试程序使用不同退出码表示不同测试阶段发生的错误:

  • 返回值 1 表示质数数量或质数边界判断失败;
  • 返回值 2 表示质数响应生成失败;
  • 返回值 3 表示应用层数据帧封装失败;
  • 返回值 4 表示长度解析或响应正文比较失败;
  • 返回值 0 表示全部协议测试通过。

直接运行 protocol_test.exe 时,程序默认等待 Enter 键。构建脚本自动执行协议测试时使用:

protocol_test.exe --no-wait

--no-wait 参数只用于自动构建过程。该模式下,测试成功后程序直接返回退出码 0,使 build.ps1 能够继续完成后续构建流程。该设计同时满足了人工运行时保留测试窗口和自动构建时避免等待输入的需求。

五、实验小结

1. 小组分工

本实验由四名小组成员共同完成。成员分工如表 7 所示。

表 7 小组成员分工

成员 学号 主要分工
方致沅 20242136050 系统总体设计、公共通信协议、发送队列设计、模块整合与联合调试
王鑫杰 20242136047 服务器端界面、监听套接字、连接管理和请求处理
李润哲 20242136049 客户端界面、异步连接、请求发送、响应接收和状态控制
康奕彬 20242136048 质数算法、协议测试、构建脚本、实验数据记录和报告整理

小组成员在完成各自主要任务的同时,共同参与接口讨论、代码检查、实验网卡配置和最终联合测试。

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

实验初期,小组对 WSAAsyncSelect 异步连接过程的理解不够准确,将 connect() 返回的 WSAEWOULDBLOCK 直接判定为连接失败。经过分析,小组将连接流程修改为等待 FD_CONNECT,并通过事件错误码判断最终结果。

在数据传输测试中,小组发现一次 send() 与一次 recv() 之间不存在固定对应关系。为解决消息边界问题,小组设计了四字节长度前缀协议,并通过接收缓存区循环提取完整数据帧。

对于非阻塞发送不完整的问题,小组建立发送队列,保存完整数据帧和已发送偏移量。当套接字暂时不可写时,程序保留未发送数据,在收到 FD_WRITE 后继续发送。

在中文请求处理中,小组发现 UTF-8 字符数量与实际字节数量不同。最终统一使用 UTF-8 字节字符串,并以字节数填写长度字段。

小组还通过统一界面状态管理解决了按钮状态与连接状态不同步的问题,并通过独立协议测试程序验证拆包、粘包、超长消息和质数结果。

3. 实验总结

本实验完成了一个基于 WSAAsyncSelect 模型的 Win32 TCP 通信系统。服务器端能够监听 192.168.50.1:1145,客户端能够绑定 192.168.50.2 并异步连接服务器。客户端发送质数查询请求后,服务器完成请求解析、质数计算和响应发送,客户端最终显示 1 至 1000 范围内的全部质数。

实验表明,WSAAsyncSelect 能够将网络事件转换为 Windows 窗口消息,使套接字通信和图形界面事件在同一消息循环中处理。该模型能够避免窗口线程因阻塞式网络操作而失去响应。

本实验采用四字节长度前缀、接收缓存区和发送队列,解决了 TCP 粘包、拆包和部分发送问题。协议测试结果表明,程序能够正确处理分段输入、连续数据帧和异常长度字段。

质数计算采用试除法,最终得到 168 个质数,与理论结果 (\pi(1000)=168) 一致。通过本实验,小组掌握了 Winsock 初始化、异步连接、窗口消息处理、TCP 数据传输、应用层协议设计、非阻塞错误处理和资源释放等技术。

4. 小组成员实验感想

4.1 方致沅实验感想

本次实验中,我主要负责系统总体结构、公共通信协议、发送队列和模块整合。实验初期,我对 TCP 消息边界的理解不够深入,曾认为一次发送可以对应一次接收。经过分段接收测试,我认识到 TCP 只提供字节流,必须由应用层协议定义消息边界。

为解决这一问题,我参与设计了四字节长度前缀协议,并实现了缓存解析和发送队列。调试过程中还遇到了网络字节序转换问题,最终通过 htonl() 和 ntohl() 完成长度字段转换。

通过本次实验,我掌握了应用层协议、缓冲区和部分发送的处理方法,也认识到清晰的公共接口能够显著降低服务器端与客户端的联合调试难度。

4.2 王鑫杰实验感想

本次实验中,我主要负责服务器端窗口、监听套接字、连接接受、请求接收和响应发送。实验过程中,监听套接字与客户端连接套接字的事件曾被混合处理,导致程序无法准确判断事件来源。

经过调试,我根据 wParam 中的套接字句柄区分监听套接字和连接套接字,并分别处理 FD_ACCEPT、FD_READ、FD_WRITE 和 FD_CLOSE。

我还认识到,recv() 返回 SOCKET_ERROR 时不能立即关闭连接。当错误码为 WSAEWOULDBLOCK 时,只表示当前没有更多数据。通过本次实验,我掌握了服务器端异步事件处理和套接字生命周期管理方法。

4.3 李润哲实验感想

本次实验中,我主要负责客户端图形界面、异步连接、请求发送、响应接收和界面状态控制。客户端开发中最主要的问题是将 WSAEWOULDBLOCK 误判为错误,导致套接字在连接建立前被提前关闭。

修改后,客户端在调用 connect() 后等待 FD_CONNECT,并通过事件错误码判断连接结果。同时,我将客户端划分为未连接、连接中和已连接三种状态,统一更新按钮和状态文本。

通过本次实验,我掌握了非阻塞连接、连接超时和界面状态控制方法,也认识到图形界面网络程序需要向用户准确反映当前通信状态。

4.4 康奕彬实验感想

本次实验中,我主要负责质数算法、协议测试、构建脚本、实验数据记录和报告整理。质数算法的初始版本曾错误地将 1 视为质数,修改后对所有小于 2 的整数直接返回非质数。

协议测试初期只验证完整数据帧,无法发现拆包问题。随后我将数据帧人为拆分为多个片段,并增加连续数据帧、异常长度和边界质数测试,从而提高了测试覆盖范围。

编译阶段还遇到中文编码不一致的问题。通过统一使用 UTF-8 源文件和执行字符集,最终保证请求、响应和控制台输出能够正确显示。通过本次实验,我认识到自动化测试不仅要验证正常路径,还应覆盖边界和异常情况。

六、附录

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

posted @ 2026-10-28 21:22  fangzhiyuan  阅读(9)  评论(0)    收藏  举报