基于 Select 模型的通信程序设计实验
基于 Select 模型的通信程序设计实验
一、实验目的
- 熟悉 Windows 环境下基于 Select 模型的网络通信程序的编写、编译和运行方法。
- 掌握 Winsock 初始化、套接字创建、地址绑定、监听、连接建立、数据收发及资源释放的基本过程。
- 理解 Select 模型的工作原理,掌握使用套接字集合监视可读、可写事件的方法。
- 理解非阻塞套接字与
select配合使用的方式,能够根据就绪状态处理连接和数据收发。 - 在同一台计算机上使用两个私有 IPv4 地址,分别运行服务器与客户端,实现双向通信。
- 完成客户端发送计算请求、服务器计算并返回结果的通信过程。
- 理解 TCP 字节流与应用层消息之间的区别,掌握分段接收、消息结束判断、部分发送及异常处理方法。
二、实验内容与设计思想
2.1 实验内容
根据实验要求,使用 C++ 和 Windows Winsock 接口编写服务器端与客户端程序,通过 Select 模型实现双向数据传递。
客户端向服务器发送:
计算从 1 到 100 的奇数和
服务器接收并识别完整请求后,通过循环计算从 1 到 100 的所有奇数之和,并向客户端回应:
从 1 到 100 的奇数和为:2500
计算过程为:
从 1 到 100 共有 50 个奇数,因此:
程序在服务器端使用循环完成实际计算,客户端收到回应后检查内容是否符合预期。
本实验在同一台计算机上运行两个独立进程,使用已配置在实验虚拟网卡上的两个私有 IPv4 地址,模拟服务器和客户端两个通信端点。
表 1 项目配置表
| 项目 | 配置 |
|---|---|
| 实验网卡名称 | TCP-Lab |
| 实验网卡类型 | Microsoft KM-TEST Loopback Adapter |
| 服务器 IP 地址 | 192.168.50.1 |
| 服务器监听端口 | 1145 |
| 客户端 IP 地址 | 192.168.50.2 |
程序中指定的本地 IP 必须已配置在操作系统中。代码中的地址字符串只用于构造套接字地址,不会自动修改网卡配置。
2.2 总体设计思想
程序划分为公共功能模块、服务器端和客户端三个部分。
公共头文件定义双方共用的地址、端口、消息内容、缓冲区容量和超时参数,并封装 Winsock 初始化、地址解析、非阻塞模式设置及等待套接字就绪等功能。
服务器维护一个监听套接字和多个已连接客户端的状态,通过 select 同时监视连接请求及各客户端的数据收发事件。
客户端绑定指定的本地源地址后连接服务器,通过 select 等待连接结果、发送条件和接收条件,完成一次请求与回应后退出。
服务器完成某个客户端的通信后,仅关闭该客户端连接,继续监听其他客户端。这样既满足实验规定的计算请求,也能体现 Select 模型处理多个连接的特点。
2.3 服务器端设计思想
服务器首先调用 WSAStartup 初始化 Winsock 2.2,然后调用 socket 创建 IPv4 TCP 套接字。
创建套接字后,服务器将监听端点绑定到 192.168.50.1:1145,设置非阻塞模式,再调用 listen 进入监听状态。
服务器为每个客户端保存以下信息:已连接套接字句柄;接收缓冲区和已接收字节数;发送缓冲区和回应总长度;已发送字节数;最近一次成功活动的时间。
主循环每次重新构造读集合与写集合:将监听套接字加入读集合,等待新的连接请求;将尚未收到完整请求的客户端套接字加入读集合;将已经生成回应、但尚未发送完毕的客户端套接字加入写集合;调用 select 等待事件;根据返回的就绪集合执行 accept、recv 或 send。
监听套接字可读时,表示存在可以接受的连接请求。服务器调用 accept 获得新的已连接套接字,并将其加入客户端状态数组。
已连接套接字可读时,服务器接收数据并累计保存。只有收到消息结束标记后,才将缓冲区作为完整字符串进行比较和处理。
收到规定请求后,服务器计算奇数和并生成回应。随后通过写集合等待可写状态,将回应完整发送。发送完成后关闭该客户端连接,继续处理其他连接。
2.4 客户端设计思想
客户端初始化 Winsock 并创建 TCP 套接字后,先调用 bind,将本地 IP 绑定为 192.168.50.2,本地端口设置为 0,由操作系统分配可用临时端口。
客户端设置非阻塞模式,再调用 connect 连接服务器 192.168.50.1:1145。
如果 connect 返回 WSAEWOULDBLOCK,表示连接尚在建立过程中,不能直接认定为失败。客户端通过 select 观察写集合和异常集合,再使用 getsockopt 查询 SO_ERROR,确认连接结果。
连接成功后,客户端调用 getsockname 读取实际本地 IP 和端口,并输出到控制台,便于与服务器看到的客户端地址交叉核对。
随后,客户端等待套接字可写,发送规定请求;请求发送完整后,再等待套接字可读并累计接收服务器回应。
当接收到完整回应且内容与预期一致时,客户端输出验证成功信息,关闭套接字并释放 Winsock 资源。
2.5 Select 模型与非阻塞模式的配合
Select 模型通过 select 函数判断套接字是否满足当前操作的条件。
本实验主要使用以下两类事件:
- 可读事件:监听套接字存在连接请求,或者已连接套接字存在可接收数据、关闭通知等情况。
- 可写事件:套接字可以尝试发送数据;对于正在建立连接的非阻塞套接字,也可用于判断连接成功。
select 会修改传入的集合,只保留已经就绪的套接字。因此,每次进入事件循环都必须重新执行 FD_ZERO 和 FD_SET。
套接字采用非阻塞模式,可以避免某次 accept、recv 或 send 因暂时无法完成而长时间阻塞整个网络处理线程;select 则使程序在没有事件时等待,避免持续重复调用收发函数造成忙轮询。
即使 select 报告就绪,程序仍然检查后续网络调用的返回值,并处理 WSAEWOULDBLOCK、连接关闭及实际错误。
2.6 文本编码与消息边界设计
TCP 提供可靠、有序的字节流传输,但不会为应用程序保留消息边界。一次 send 发送的内容,不一定由对端的一次 recv 完整接收。
本实验约定:正文使用 UTF-8 编码;每条消息以一个 '\0' 字节结束;一条完整消息最多占用 1024 字节,包括结束标记;每个连接只处理一条请求和一条回应。
发送时,程序将正文和结束标记一并发送,并根据 send 实际返回的字节数更新偏移量。
接收时,程序将新数据追加到已有数据之后,通过 memchr 查找结束标记。只有完整收到消息,才调用 strcmp 比较字符串或使用 %s 输出文本。
这种方式能够处理中文字符跨多次接收的情况,避免将尚未收齐的 UTF-8 字符提前显示。
三、实验使用环境
| 项目 | 说明 |
|---|---|
| 操作系统 | Microsoft Windows 7 / 8 / 10 / 11 |
| 原报告列出的编程环境 | Visual C++ 6.0 |
| 实际编译记录使用工具 | MSYS2 UCRT64 g++,按 C++98 标准编译 |
| 验证范围 | 同一台计算机上的两个独立进程;多连接、分段传输与异常路径由自动测试覆盖 |
四、实验步骤和调试过程
4.1 检查实验网卡
本实验沿用已配置的 Microsoft KM-TEST Loopback Adapter,网卡名称为 TCP-Lab。
在 PowerShell 中执行:
Get-NetAdapter -Name 'TCP-Lab' |
Format-Table Name,InterfaceDescription,Status
核对网卡名称、设备描述与状态,确认后续地址操作针对专用实验网卡。

图1 实验虚拟网卡信息
4.2 检查双 IP 地址配置
本机已经配置:
192.168.50.1/24192.168.50.2/24
两个地址的状态均为 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
PrefixLength 24 对应子网掩码 255.255.255.0。同机通信不需要为实验网卡设置默认网关和 DNS。

图2 服务器与客户端本机地址配置
4.3 程序文件划分
表 3 程序文件及主要功能
| 文件 | 主要功能 |
|---|---|
select_common.h |
公共配置、协议文本、初始化、地址解析、非阻塞设置及就绪等待 |
server.cpp |
监听连接、维护客户端状态、接收请求、计算并发送回应 |
client.cpp |
绑定源地址、连接服务器、发送请求并验证回应 |
build.ps1 |
分别编译服务器和客户端 |
test_local.py |
自动验证正常通信、并发、分段传输及异常处理 |
README.md |
配置、编译、运行和代码阅读说明 |
4.4 公共头文件完整代码:select_common.h
公共头文件 select_common.h 定义双方使用的配置和协议文本,并封装共用操作。
中文文本以 UTF-8 字节转义形式保存,避免旧编译器根据本地代码页改变网络字符串。
点击展开/收起:select_common.h 完整代码
#ifndef SELECT_COMMON_H
#define SELECT_COMMON_H
// Winsock2 的类型、函数和错误码,必须在 windows.h 之前包含。
#include <winsock2.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef _MSC_VER
// 告诉 MSVC 链接 Winsock2 库;MinGW 则在编译命令中使用 -lws2_32。
#pragma comment(lib, "ws2_32.lib")
#endif
// 不传命令行参数时,服务端监听此 IP;该地址必须已配置在本机。
const char DEFAULT_SERVER_IP[] = "192.168.50.1";
// 客户端先 bind 到此 IP,确保发起连接时使用指定的源地址。
const char DEFAULT_CLIENT_IP[] = "192.168.50.2";
// 服务器监听端口,unsigned short 与 16 位 TCP 端口范围相对应。
const unsigned short DEFAULT_PORT = 1145;
// 每条完整消息最多 1024 字节,包含 '\0',因此正文最多 1023 字节。
const int BUFFER_SIZE = 1024;
// 客户端连接、发送、接收三个阶段分别使用 10 秒时限。
const DWORD CLIENT_TIMEOUT_MS = 10000;
// 服务器已接受的连接,连续 30 秒无成功收发时会被清理。
const DWORD SERVER_IDLE_MS = 30000;
// 请求正文:计算从 1 到 100 的奇数和。
// 显式写 UTF-8 字节可避免旧编译器根据本地代码页转换中文。
const char REQUEST_TEXT[] =
"\xE8\xAE\xA1\xE7\xAE\x97" "1"
"\xE5\x88\xB0" "100"
"\xE7\x9A\x84\xE5\xA5\x87\xE6\x95\xB0\xE5\x92\x8C";
// 回应固定前缀:从 1 到 100 的奇数和为:;具体结果由服务器计算后追加。
const char REPLY_PREFIX[] =
"\xE4\xBB\x8E" "1"
"\xE5\x88\xB0" "100"
"\xE7\x9A\x84\xE5\xA5\x87\xE6\x95\xB0\xE5\x92\x8C"
"\xE4\xB8\xBA\xEF\xBC\x9A";
// 统一输出错误。operation 是出错步骤名称,error 是已取得的错误码。
inline void ReportError(const char *operation, int error)
{
printf("%s failed: %d\n", operation, error);
if (error == WSAEADDRNOTAVAIL)
printf("Configure the requested local IP on the TCP-Lab adapter first.\n");
if (error == WSAEADDRINUSE)
printf("This address/port is already in use. Check the other server.\n");
if (error == WSAECONNREFUSED)
printf("Start the server first and check its IP and port.\n");
}
// 为当前进程初始化 Winsock。成功后,main 负责最终调用一次 WSACleanup。
inline bool InitWinsock()
{
SetConsoleOutputCP(CP_UTF8);
// stdout 采用无缓冲模式,使日志立即写出。
setvbuf(stdout, NULL, _IONBF, 0);
WSADATA data;
int error = WSAStartup(MAKEWORD(2, 2), &data);
if (error != 0)
{
ReportError("WSAStartup", error);
return false;
}
if (LOBYTE(data.wVersion) != 2 || HIBYTE(data.wVersion) != 2)
{
printf("Winsock 2.2 is unavailable.\n");
WSACleanup();
return false;
}
return true;
}
// 把点分十进制 IPv4 和主机字节序端口,填入 sockaddr_in 地址结构。
// 仅允许 RFC1918 私有地址和 127/8 回环地址;不检查网卡是否真的拥有该 IP。
inline bool MakeAddress(const char *ip, unsigned short port, sockaddr_in *address)
{
unsigned long host = 0;
const char *p = ip;
for (int part = 0; part < 4; ++part)
{
unsigned int value = 0;
int digits = 0;
while (*p >= '0' && *p <= '9')
{
value = value * 10 + (*p++ - '0');
if (++digits > 3 || value > 255)
return false;
}
if (digits == 0 || (part < 3 ? *p != '.' : *p != '\0'))
return false;
host = (host << 8) | value;
if (part < 3)
++p;
}
bool allowed =
(host & 0xFF000000UL) == 0x0A000000UL || // 10.0.0.0/8
(host & 0xFFF00000UL) == 0xAC100000UL || // 172.16.0.0/12
(host & 0xFFFF0000UL) == 0xC0A80000UL || // 192.168.0.0/16
(host & 0xFF000000UL) == 0x7F000000UL; // 127.0.0.0/8
if (!allowed)
return false;
memset(address, 0, sizeof(*address));
address->sin_family = AF_INET;
address->sin_port = htons(port);
address->sin_addr.s_addr = htonl(host);
return true;
}
// 把命令行端口文本解析为 1..65535;禁止符号、空格、字母、空串和端口 0。
inline bool ParsePort(const char *text, unsigned short *port)
{
unsigned long value = 0;
if (*text == '\0')
return false;
for (const char *p = text; *p; ++p)
{
if (*p < '0' || *p > '9')
return false;
value = value * 10 + (*p - '0');
if (value > 65535)
return false;
}
if (value == 0)
return false;
*port = (unsigned short)value;
return true;
}
// 给一个已创建的套接字开启非阻塞模式;不创建连接,也不等待数据。
inline bool SetNonblocking(SOCKET s)
{
u_long enabled = 1;
if (ioctlsocket(s, FIONBIO, &enabled) == SOCKET_ERROR)
{
ReportError("ioctlsocket", WSAGetLastError());
return false;
}
return true;
}
// 客户端等待一个套接字就绪,返回 true 才继续当前操作。
// writing=true 等待可写;writing=false 等待可读。
// connecting=true 额外监听异常集合,并通过 SO_ERROR 核对连接结果。
inline bool WaitReady(SOCKET s, bool writing, bool connecting, DWORD started)
{
DWORD elapsed = GetTickCount() - started;
if (elapsed >= CLIENT_TIMEOUT_MS)
{
printf("select timeout (10 seconds).\n");
return false;
}
DWORD remaining = CLIENT_TIMEOUT_MS - elapsed;
timeval timeout;
timeout.tv_sec = (long)(remaining / 1000);
timeout.tv_usec = (long)(remaining % 1000) * 1000;
fd_set ready, errors;
FD_ZERO(&ready);
FD_ZERO(&errors);
FD_SET(s, &ready);
if (connecting)
FD_SET(s, &errors);
int n = select(0,
writing ? NULL : &ready,
writing ? &ready : NULL,
connecting ? &errors : NULL,
&timeout);
if (n == SOCKET_ERROR)
{
ReportError("select", WSAGetLastError());
return false;
}
if (n == 0)
{
printf("select timeout (10 seconds).\n");
return false;
}
if (connecting)
{
int error = 0;
int length = sizeof(error);
if (getsockopt(s, SOL_SOCKET, SO_ERROR,
(char *)&error, &length) == SOCKET_ERROR)
{
ReportError("getsockopt", WSAGetLastError());
return false;
}
if (error != 0)
{
ReportError("connect", error);
return false;
}
}
return FD_ISSET(s, &ready) != 0;
}
#endif
4.5 服务器端完整代码:server.cpp
服务器使用 ClientState 保存每个连接的状态。outputLength 为 0 表示仍在接收请求,大于 0 表示已有回应等待发送。
默认情况下,FD_SETSIZE 为 64。程序为监听套接字保留一个位置,因此最多同时维护 63 个客户端连接。
服务器主线为:初始化 → socket → bind → 非阻塞 → listen → 反复 select → accept 新连接 / recv 请求 / 计算 / send 回应 → 统一清理。
点击展开/收起:server.cpp 完整代码
#include "select_common.h"
// 每个 fd_set 最多容纳 FD_SETSIZE 个套接字,默认 64。
// 读集合最坏情况下包含 1 个 listener 和全部客户端,所以留出 1 个位置。
const int MAX_CLIENTS = FD_SETSIZE - 1;
// 每个有效连接都有独立状态;慢客户端不会占用另一个客户端的输入/输出缓冲区。
struct ClientState
{
SOCKET socket; // 连接句柄;INVALID_SOCKET 表示该数组槽位空闲。
char input[BUFFER_SIZE]; // 累积收到的请求字节;发现 '\0' 后才能当 C 字符串使用。
int received; // input 中已经存了多少字节;同时是下一次 recv 的写入偏移量。
char output[BUFFER_SIZE]; // 请求完整后生成的回应,包括末尾的 '\0'。
int outputLength; // 0 表示仍在收请求;大于 0 表示已有回应,转为等待可写。
int sent; // output 中已交给 send 的字节数;剩余长度为 outputLength-sent。
DWORD lastActivity; // accept 或最近一次成功收发时的毫秒计数,用于清理空闲连接。
};
// static 限定此全局变量只在本源文件可见;初值 0 表示继续运行,1 表示请求停止。
// volatile 本身不保证线程同步;这里的并发访问通过 Interlocked 系列函数完成。
static volatile LONG stopping = 0;
// 控制台事件回调可能在系统创建的另一个线程执行,因此停止标志使用原子操作。
BOOL WINAPI HandleConsoleEvent(DWORD eventType)
{
if (eventType == CTRL_C_EVENT ||
eventType == CTRL_BREAK_EVENT ||
eventType == CTRL_CLOSE_EVENT)
{
InterlockedExchange(&stopping, 1);
return TRUE;
}
return FALSE;
}
// 关闭一个已连接客户端并把槽位标成空闲;调用者保证 socket 当前有效。
void CloseClient(ClientState *client)
{
closesocket(client->socket);
client->socket = INVALID_SOCKET;
}
// 仅在 input 已包含 '\0' 时调用:识别请求并生成完整回应,不直接调用 send。
// 改变 outputLength 即改变连接状态,主循环下一轮会把它加入写集合。
void PrepareReply(ClientState *client)
{
printf("Received: %s\n", client->input);
if (strcmp(client->input, REQUEST_TEXT) == 0)
{
int sum = 0;
for (int number = 1; number <= 100; number += 2)
sum += number;
sprintf(client->output, "%s%d", REPLY_PREFIX, sum);
printf("Calculation: 1 + 3 + ... + 99 = %d\n", sum);
}
else
{
strcpy(client->output, "ERROR: unsupported request");
}
client->outputLength = (int)strlen(client->output) + 1;
client->sent = 0;
}
int main(int argc, char *argv[])
{
unsigned short port = DEFAULT_PORT;
sockaddr_in local;
const char *ip = argc >= 2 ? argv[1] : DEFAULT_SERVER_IP;
if (argc > 3 ||
(argc == 3 && !ParsePort(argv[2], &port)) ||
!MakeAddress(ip, port, &local))
{
printf("Usage: server.exe [local_IP [port]]\n");
printf("Use a private or loopback IPv4 address and port 1..65535.\n");
return 1;
}
if (!InitWinsock())
return 1;
ClientState clients[MAX_CLIENTS];
for (int index = 0; index < MAX_CLIENTS; ++index)
clients[index].socket = INVALID_SOCKET;
SOCKET listener = INVALID_SOCKET;
int result = 1;
bool handlerInstalled = false;
do
{
listener = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (listener == INVALID_SOCKET)
{
ReportError("socket", WSAGetLastError());
break;
}
BOOL exclusive = TRUE;
if (setsockopt(listener, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
(const char *)&exclusive, sizeof(exclusive)) == SOCKET_ERROR)
{
ReportError("setsockopt", WSAGetLastError());
break;
}
if (bind(listener, (sockaddr *)&local, sizeof(local)) == SOCKET_ERROR)
{
ReportError("bind", WSAGetLastError());
break;
}
if (!SetNonblocking(listener))
break;
if (listen(listener, SOMAXCONN) == SOCKET_ERROR)
{
ReportError("listen", WSAGetLastError());
break;
}
handlerInstalled = SetConsoleCtrlHandler(HandleConsoleEvent, TRUE) != 0;
if (!handlerInstalled)
{
printf("SetConsoleCtrlHandler failed: %lu\n", GetLastError());
break;
}
printf("Select server listening on %s:%u\n", ip, (unsigned int)port);
printf("Max clients: %d. Press Ctrl+C to stop.\n", MAX_CLIENTS);
result = 0;
} while (false);
while (InterlockedCompareExchange(&stopping, 0, 0) == 0)
{
fd_set reads, writes;
FD_ZERO(&reads);
FD_ZERO(&writes);
FD_SET(listener, &reads);
for (int i = 0; i < MAX_CLIENTS; ++i)
{
if (clients[i].socket == INVALID_SOCKET)
continue;
if (clients[i].outputLength > 0)
FD_SET(clients[i].socket, &writes);
else
FD_SET(clients[i].socket, &reads);
}
timeval timeout;
timeout.tv_sec = 1;
timeout.tv_usec = 0;
int ready = select(0, &reads, &writes, NULL, &timeout);
if (ready == SOCKET_ERROR)
{
ReportError("select", WSAGetLastError());
result = 1;
break;
}
if (ready > 0)
{
for (int i = 0; i < MAX_CLIENTS; ++i)
{
ClientState *client = &clients[i];
if (client->socket == INVALID_SOCKET)
continue;
if (GetTickCount() - client->lastActivity >= SERVER_IDLE_MS)
{
printf("Closing idle client (30 seconds).\n");
CloseClient(client);
continue;
}
if (FD_ISSET(client->socket, &reads))
{
int oldReceived = client->received;
int n = recv(client->socket,
client->input + oldReceived,
BUFFER_SIZE - oldReceived,
0);
if (n == SOCKET_ERROR)
{
int error = WSAGetLastError();
if (error != WSAEWOULDBLOCK)
{
ReportError("recv", error);
CloseClient(client);
}
continue;
}
if (n == 0)
{
printf("Client closed before a complete request.\n");
CloseClient(client);
continue;
}
client->lastActivity = GetTickCount();
char *end = (char *)memchr(client->input + oldReceived,
'\0', n);
client->received += n;
if (end != NULL)
{
PrepareReply(client);
}
else if (client->received >= BUFFER_SIZE)
{
printf("Request too long; closing client.\n");
CloseClient(client);
}
}
if (client->socket != INVALID_SOCKET &&
FD_ISSET(client->socket, &writes))
{
int n = send(client->socket,
client->output + client->sent,
client->outputLength - client->sent,
0);
if (n == SOCKET_ERROR)
{
int error = WSAGetLastError();
if (error != WSAEWOULDBLOCK)
{
ReportError("send", error);
CloseClient(client);
}
continue;
}
if (n == 0)
{
CloseClient(client);
continue;
}
client->lastActivity = GetTickCount();
client->sent += n;
if (client->sent == client->outputLength)
{
printf("Reply sent: %s\n", client->output);
shutdown(client->socket, SD_SEND);
CloseClient(client);
}
}
}
if (FD_ISSET(listener, &reads))
{
sockaddr_in peer;
int length = sizeof(peer);
SOCKET s = accept(listener, (sockaddr *)&peer, &length);
if (s == INVALID_SOCKET)
{
int error = WSAGetLastError();
if (error != WSAEWOULDBLOCK)
ReportError("accept", error);
}
else
{
int slot;
for (slot = 0; slot < MAX_CLIENTS; ++slot)
{
if (clients[slot].socket == INVALID_SOCKET)
break;
}
if (slot == MAX_CLIENTS || !SetNonblocking(s))
{
printf("Cannot accept another client; closing connection.\n");
closesocket(s);
continue;
}
ClientState *client = &clients[slot];
client->socket = s;
client->received = 0;
client->outputLength = 0;
client->sent = 0;
client->lastActivity = GetTickCount();
printf("Client connected: %s:%u\n",
inet_ntoa(peer.sin_addr),
(unsigned int)ntohs(peer.sin_port));
}
}
}
}
for (int i = 0; i < MAX_CLIENTS; ++i)
{
if (clients[i].socket != INVALID_SOCKET)
CloseClient(&clients[i]);
}
if (listener != INVALID_SOCKET)
closesocket(listener);
if (handlerInstalled)
SetConsoleCtrlHandler(HandleConsoleEvent, FALSE);
WSACleanup();
printf("Server stopped.\n");
return result;
}
4.6 客户端完整代码:client.cpp
客户端明确绑定本地源地址,连接指定服务器,发送完整请求并接收回应。只有回应完整且内容正确时,程序才输出 PASS 并返回 0。
客户端主线为:解析地址 → 初始化 Winsock → socket → bind 本地源地址 → 设置非阻塞 → connect / 等待连接结果 → 等可写并发完请求 → 等可读并接收回应 → 检查结果 → 关闭套接字并退出。
连接、发送、接收三个阶段分别从新的 started 开始计时;同一阶段内重试时不重置 started,防止阶段总耗时无限延长。
点击展开/收起:client.cpp 完整代码
#include "select_common.h"
int main(int argc, char *argv[])
{
unsigned short port = DEFAULT_PORT;
const char *serverIp = argc >= 2 ? argv[1] : DEFAULT_SERVER_IP;
const char *clientIp = argc >= 3 ? argv[2] : DEFAULT_CLIENT_IP;
sockaddr_in remote, local;
if (argc > 4 ||
(argc == 4 && !ParsePort(argv[3], &port)) ||
!MakeAddress(serverIp, port, &remote) ||
!MakeAddress(clientIp, 0, &local))
{
printf("Usage: client.exe [server_IP [local_IP [server_port]]]\n");
printf("Use private or loopback IPv4 addresses and port 1..65535.\n");
return 1;
}
if (!InitWinsock())
return 1;
SOCKET s = INVALID_SOCKET;
int result = 1;
do
{
s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (s == INVALID_SOCKET)
{
ReportError("socket", WSAGetLastError());
break;
}
// bind 指定客户端的“来源”,不是指定服务器目的地。
// local 已由 MakeAddress 填好,本地 IP 必须存在于本机网卡配置中。
if (bind(s, (sockaddr *)&local, sizeof(local)) == SOCKET_ERROR)
{
ReportError("client bind", WSAGetLastError());
break;
}
if (!SetNonblocking(s))
break;
DWORD started = GetTickCount();
// 使用 remote 中的目的 IP 和端口发起连接;s 已经绑定好了本地源地址。
if (connect(s, (sockaddr *)&remote, sizeof(remote)) == SOCKET_ERROR)
{
int error = WSAGetLastError();
// 非阻塞 connect 返回 SOCKET_ERROR 不一定意味着连接失败。
if (error != WSAEWOULDBLOCK)
{
ReportError("connect", error);
break;
}
// true,true 分别表示“观察可写”和“这是连接阶段”。
// WaitReady 观察写/异常集合,并调用 getsockopt(SO_ERROR) 验证最终结果。
if (!WaitReady(s, true, true, started))
break;
}
int localLength = sizeof(local);
if (getsockname(s, (sockaddr *)&local, &localLength) == SOCKET_ERROR)
{
ReportError("getsockname", WSAGetLastError());
break;
}
printf("Client local endpoint: %s:%u\n",
inet_ntoa(local.sin_addr),
(unsigned int)ntohs(local.sin_port));
printf("Connected to server: %s:%u\n",
serverIp, (unsigned int)port);
int length = (int)strlen(REQUEST_TEXT) + 1;
int sent = 0;
started = GetTickCount();
while (sent < length)
{
if (!WaitReady(s, true, false, started))
break;
int n = send(s, REQUEST_TEXT + sent, length - sent, 0);
if (n == SOCKET_ERROR)
{
int error = WSAGetLastError();
if (error == WSAEWOULDBLOCK)
continue;
ReportError("send", error);
break;
}
if (n == 0)
break;
sent += n;
}
if (sent != length)
break;
printf("Sent: %s\n", REQUEST_TEXT);
char buffer[BUFFER_SIZE];
int received = 0;
bool complete = false;
started = GetTickCount();
while (received < BUFFER_SIZE)
{
if (!WaitReady(s, false, false, started))
break;
int n = recv(s, buffer + received, BUFFER_SIZE - received, 0);
if (n == SOCKET_ERROR)
{
int error = WSAGetLastError();
if (error == WSAEWOULDBLOCK)
continue;
ReportError("recv", error);
break;
}
if (n == 0)
{
printf("Server closed before a complete reply.\n");
break;
}
complete = memchr(buffer + received, '\0', n) != NULL;
received += n;
if (complete)
break;
}
if (!complete)
{
if (received == BUFFER_SIZE)
printf("Reply too long.\n");
break;
}
printf("Received: %s\n", buffer);
char expected[BUFFER_SIZE];
sprintf(expected, "%s2500", REPLY_PREFIX);
if (strcmp(buffer, expected) != 0)
{
printf("Unexpected calculation result.\n");
break;
}
printf("PASS: bidirectional communication completed; odd-number sum = 2500.\n");
result = 0;
} while (false);
if (s != INVALID_SOCKET)
closesocket(s);
WSACleanup();
return result;
}
4.7 编译程序
在 PowerShell 中进入项目目录:
Set-Location -LiteralPath "C:\Users\Administrator\Desktop\Network_Protocol_analysis_programming_assignment\Communication Program Design Based on Select Model"
执行编译脚本:
powershell -NoProfile -ExecutionPolicy Bypass -File .\build.ps1 -Compiler D:\msys64\ucrt64\bin\g++.exe
脚本分别编译两个源文件,并生成:
server.exe
client.exe
也可以直接执行:
powershell -NoProfile -ExecutionPolicy Bypass -File .\build.ps1

图3 服务器与客户端编译结果
表 4 编译参数说明
| 参数 | 作用 |
|---|---|
-std=c++98 |
使用 C++98 语言标准 |
-Wall -Wextra |
开启常用和额外警告 |
-pedantic |
检查偏离所选语言标准的用法 |
-O2 |
启用常规优化 |
-static |
尽量静态链接编译器运行库 |
-finput-charset=UTF-8 |
指定源文件编码 |
-fexec-charset=UTF-8 |
指定普通字符串的执行字符集 |
-lws2_32 |
链接 Winsock 2 接口库 |
编译成功后显示:
Built server.exe
Built client.exe
4.8 手动运行服务器与客户端
打开两个 PowerShell 窗口,分别进入项目目录。
在第一个窗口启动服务器:
.\server.exe
服务器显示:
Select server listening on 192.168.50.1:1145
Max clients: 63. Press Ctrl+C to stop.
确认监听成功后,在第二个窗口启动客户端:
.\client.exe
程序也支持明确指定地址和端口:
.\server.exe 192.168.50.1 1145
.\client.exe 192.168.50.1 192.168.50.2 1145
客户端参数依次为服务器 IP、客户端本地 IP 和服务器端口。
本次实际测试日志中的客户端输出为:
Client local endpoint: 192.168.50.2:60682
Connected to server: 192.168.50.1:1145
Sent: 计算从1到100的奇数和
Received: 从1到100的奇数和为:2500
PASS: bidirectional communication completed; odd-number sum = 2500.
服务器对应输出为:
Client connected: 192.168.50.2:60682
Received: 计算从1到100的奇数和
Calculation: 1 + 3 + ... + 99 = 2500
Reply sent: 从1到100的奇数和为:2500
两端记录的客户端端点均为 192.168.50.2:60682,表明客户端源地址绑定符合设计。60682 为本次运行分配的临时端口,再次运行时可能变化。

图4 服务器端运行结果

图5 客户端运行结果
客户端完成一次通信后退出。服务器继续监听,可以再次运行客户端进行验证。结束服务器时,在服务器窗口按 Ctrl+C。
五、实验小结
5.1 实验完成情况
本实验实现了基于 Select 模型的 TCP 服务器端与客户端程序。
服务器绑定 192.168.50.1:1145,客户端绑定 192.168.50.2,双方在同一条 TCP 连接上完成请求与回应。
客户端发送“计算从 1 到 100 的奇数和”,服务器实际执行求和循环并返回“从 1 到 100 的奇数和为:2500”。客户端完整接收回应并通过内容核对。
服务器使用一个网络事件循环管理多个连接,可以在某个客户端请求尚未完成时继续服务其他客户端。自动测试的 13 组检查全部通过。
5.2 Select 模型工作过程分析
Select 模型的核心是先等待套接字就绪,再执行对应操作。
程序先将监听套接字和需要收发的客户端套接字加入相应集合,调用 select 等待事件。返回后,使用 FD_ISSET 判断具体套接字的状态,再分别执行 accept、recv 或 send。
每个客户端具有独立状态,使一条消息可以分散到多轮循环中处理,而不必阻塞整个服务器等待全部数据。
本实验中,一个客户端连接依次经历:
接受连接 → 等待请求 → 累计接收 → 生成回应 → 等待可写 → 完整发送 → 关闭连接
服务器则重复执行:
重建集合 → select 等待 → 检查就绪状态 → 处理已有连接 → 接受新连接 → 进入下一轮
图6 Select 模型工作流程
5.3 对 TCP 字节流的认识
TCP 连接成功只说明通信通道已经建立,应用程序仍需定义消息格式和业务规则。
一次发送不一定对应一次完整接收,因此程序不能将某次 recv 返回正数直接当成完整消息。
本实验使用零字节结束标记和字节偏移量,明确判断消息边界和收发进度。服务器发送日志、计算日志和客户端验证输出分别反映不同阶段,需要结合观察才能确认一次请求完整结束。
5.4 程序局限与改进方向
本程序适用于 Select 模型和短文本请求—回应通信的学习,当前存在以下边界:
- 只识别固定计算请求,未实现任意范围或多种计算命令。
- 每个连接只处理一条请求,没有实现持续会话。
- 默认最多同时维护 63 个客户端连接。
- 完整消息最多 1024 字节。
- 空闲时限不等于连接总寿命,持续缓慢发送的连接仍可能存活较长时间。
后续可以扩展命令格式,采用长度字段组织消息,并增加请求总时限、连接统计和运行监测功能。
5.5 小组成员实验心得
方致远
通过本次实验,我进一步理解了程序地址配置与操作系统网卡配置之间的关系。服务器监听的 IP 和客户端绑定的源 IP 都必须在本机实际存在。结合客户端 getsockname 输出与服务器 accept 得到的地址核对,也使我认识到,验证通信是否符合设计,应检查实际运行端点,而不仅是查看代码中的默认参数。
王鑫杰
本次实验使我对 Select 模型的事件处理过程有了更清晰的认识。服务器根据连接状态选择读集合或写集合,并在 select 返回后执行相应操作。由于 select 会修改集合,每轮都需要重新构造。通过分析客户端状态数组,我理解了程序如何保存多条连接的收发进度,并在一个网络事件循环中交替处理。
李润哲
通过梳理文本收发代码,我认识到 TCP 传输的是字节流,不能假设一次接收就是一条完整消息。中文字符也可能在不同接收过程中被拆开,因此应先累计原始字节,确认消息完整后再比较和输出。发送端同样需要依据实际返回字节数推进偏移量,这使数据收发的边界和进度更加明确。
康奕彬
本次实验让我认识到,网络程序的验证应同时覆盖正常流程和异常流程。除了检查结果为 2500,还应核对源地址、并发连接、分段消息、提前关闭和超时等情况。测试日志可以保存这些证据,方便重复核对。同时,报告应区分代码中考虑的分支与测试实际触发的情况,准确说明验证范围。
六、附录
《Windows 网络与通信程序设计》陈香凝,王烨阳,陈婷婷,张峥,人民邮电出版社,2017.3 第 3 版。
基于 Select 模型的通信程序设计实验报告
课程名称:网络协议分析
班级:网安 2412
指导教师:余元辉
实验项目名称:基于 Select 模型的通信程序设计
实验项目编号:2
组号:14
上机实践时间:2 学时

浙公网安备 33010602011771号