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

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


一、实验目的

  1. 熟悉 Windows 环境下基于 Select 模型的网络通信程序的编写、编译和运行方法。
  2. 掌握 Winsock 初始化、套接字创建、地址绑定、监听、连接建立、数据收发及资源释放的基本过程。
  3. 理解 Select 模型的工作原理,掌握使用套接字集合监视可读、可写事件的方法。
  4. 理解非阻塞套接字与 select 配合使用的方式,能够根据就绪状态处理连接和数据收发。
  5. 在同一台计算机上使用两个私有 IPv4 地址,分别运行服务器与客户端,实现双向通信。
  6. 完成客户端发送计算请求、服务器计算并返回结果的通信过程。
  7. 理解 TCP 字节流与应用层消息之间的区别,掌握分段接收、消息结束判断、部分发送及异常处理方法。

二、实验内容与设计思想

2.1 实验内容

根据实验要求,使用 C++ 和 Windows Winsock 接口编写服务器端与客户端程序,通过 Select 模型实现双向数据传递。

客户端向服务器发送:

计算从 1 到 100 的奇数和

服务器接收并识别完整请求后,通过循环计算从 1 到 100 的所有奇数之和,并向客户端回应:

从 1 到 100 的奇数和为:2500

计算过程为:

\[S = 1 + 3 + 5 + \dots + 99 \]

从 1 到 100 共有 50 个奇数,因此:

\[S = \frac{(1 + 99)\times 50}{2} = 2500 \]

程序在服务器端使用循环完成实际计算,客户端收到回应后检查内容是否符合预期。

本实验在同一台计算机上运行两个独立进程,使用已配置在实验虚拟网卡上的两个私有 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
图1 实验虚拟网卡信息

4.2 检查双 IP 地址配置

本机已经配置:

  • 192.168.50.1/24
  • 192.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

图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

图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

图4 服务器端运行结果

图片5

图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 等待 → 检查就绪状态 → 处理已有连接 → 接受新连接 → 进入下一轮

基于Select模型的TCP通信流程

图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 学时

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