TCP/IP网络编程：P4-＞基于TCP的服务器端/客户端(上)

本系列文章为《TCP/IP网络编程----尹圣雨》学习笔记，前面的系列文章链接如下
TCP/IP网络编程：P1-＞理解网络编程和套接字
TCP/IP网络编程：P2-＞套接字类型与协议设置
TCP/IP网络编程：P3-＞地址族与数据序列

---

前言

我们已经学习了创建套接字和向套接字分配地址，接下来正式讨论通过套接字收发数据。

一、理解TCP和UDP

前言

根据数据传输方式不同，基于网络协议的套接字一般为TCP和UDP套接字。因为TCP是面向连接的，因此又称基于流(stream)的套接字。TCP是Transmission Control Protocol(传输控制协议)的简写，意为“对数据传输过程的控制”。

1.1 TCP/IP协议栈

TCP所属的TCP/IP协议栈

如下图所示：

可以看出
①TCP/IP协议栈分为4层，可以理解为数据收发分成4个层次化过程。也就是说，面对“基于互联网的有效数据传输”的命题，并非通过1个庞大协议解决问题，而是化整为零，通过层次化方案----TCP/IP协议栈解决。
②各层可能通过操作系统等软件实现，也可能通过类似NIC的硬件设备实现。

1.2 TCP/IP协议的诞生背景

思考

问题： “通过因特网完成有效数据传输”这个课题让许多专家聚集到了一起，这些人是硬件、系统、路由算法等各领域的顶级专家。为何需要这么多领域的专家呢？
答案： 我们之前只关注套接字创建及应用，却忽略了计算机网络问题并非仅凭软件就能解决。编写软件前需要构建硬件系统，在此基础上需要通过软件实现各种算法。所以才需要众多领域的专家进行讨论，以形成各种规定。因此，把这个大问题划分成若干小问题再逐个攻破，将大幅提高效率。把通过因特网完成有效数据传输问题按照不同领域划分成小问题后，出现多种协议，它们通过层级结构建立了紧密联系。

开放式系统(Open System)

①把协议分成多个层次具有哪些优点？协议设计更容易？当然这也足以成为优点之一。但还有更重要的原因就是，为了通过标准化操作设计开放式系统。
②标准本身就在于对外公开，引导更多的人遵守规范。以多个标准为依据设计的系统称为开放式系统，我们现在学习的TCP/IP协议栈也属于其中之一。
开放式系统具有的优点
③路由器用来完成IP层交互任务。某公司原来使用A公司的路由器，现要将其替换成B公司的，是否可行？这并非难事，并不一定要换成同一公司的同一型号路由器，因为所有生产商都会按照IP层标准制造。
④各位的计算机是否装有网络接口卡，也就是所谓的网卡？尚未安装也无妨，其实很容易买到，因为所有网卡制造商都会遵守链路层的协议标准。这就是开放式系统的优点。
⑤标准的存在意味着高速的技术发展，这也是开放式系统设计最大的原因所在。实际上，软件工程中的“面向对象”(Object Oriented)的诞生背景中也有标准化的影子。也就是说，标准对于技术发展起着举足轻重的作用。

1.3 链路层

链路层是物理链接领域标准化的结果，专门定义LAN、WAN、MAN等网络标准链路层就负责这些标准。若两台主机通过网络进行数据交换，就需要物理连接，链路层就负责这些标准。

1.4 IP层

①准备好物理连接后就要传输数据。为了在复杂的网络中传输数据,首先需要考虑路径的选择。向目标传输数据需要经过哪条路径？解决此问题就是IP层，该层使用的协议就是IP。
②IP本身是面向消息的、不可靠的协议。每次传输数据时会帮我们选择路径，但并不一致。如果传输中发生路径错误，则选择其他路径；但如果发生数据丢失或错误，则无法解决。换言之，IP协议无法应对数据错误。

1.5 TCP/UDP层

思考

问题： IP层解决数据传输中的路径选择问题，只需按照此路径传输数据即可。TCP和UDP层以IP提供的路径信息为基础完成实际的数据传输，故该层又称传输层(Transport)。TCP可以保证可靠的数据传输，但它发送数据时以IP层为基础(这也是协议栈结构层次化的原因)。那该如何理解二者关系呢？
答案：
①IP层只关注1个数据包(数据传输的基本单位)的传输过程。因此，即使传输多个数据包，每个数据包也是由IP层实际传输的，也就是说传输顺序及传输本身是不可靠的。若只利用IP层传输数据，则有可能导致后传输的数据包B比先传输的数据包A提早到达。
②另外，传输的数据包A、B、C中有可能只收到A和C，甚至收到的C可能已损毁。反之，若添加TCP协议则按照如下对话进行数据交换。
----主机A：“正确收到第二个数据包！”
----主机B：“嗯，知道了。”
----主机A：“正确收到第三个数据包！”
----主机B：”可我已发送第四个数据包了啊！哦，您没收到第四个数据包吧？我给您重传！”
这就是TCP的作用。如果数据交换过程中可以确认对方已收到数据，并重传丢失的数据，那么即便IP层不保证数据传输，这类通信也是可靠的。
③下图简单描述了TCP的功能。

④总之，TCP和UDP存在于IP层之上，决定主机之间的数据传输方式，TCP协议确认后向不可靠的IP协议赋予可靠性。

1.6 应用层

①上述内容是套接字通信过程中自动处理的。选择数据传输路径、数据确认过程都被隐藏到套接字内部。
②向程序员提供的工具就是套接字，只需要利用套接字编出程序即可。编写软件的过程中，需要根据程序的特点来决定服务器和客户端之间的数据传输规则，这便是应用层协议。网络编程的大部分内容就是设计并实现应用层协议。

二、实现基于TCP的服务器端/客户端

本节实现完整的TCP服务器端，在此过程中各位将理解套接字使用方法及数据传输方法。

2.1 TCP服务器端的默认函数调用顺序

绝大部分TCP服务器端都按照下图所示的顺序调用：

调用socket函数创建套接字，声明并初始化地址信息结构体变量，调用bind函数向套接字分配地址。这2个阶段之前已讨论过，下面讲解之后的几个过程。

2.2 进入等待连接请求状态

背景

我们已调用bind函数给套接字分配了地址，接下来就要通过调用listen函数进入等待连接请求状态。只有调用了listen函数，客户端才能进入可发出连接请求的状态。换言之，这时客户端才能调用connect函数(若提前调用将发生错误)。

listen函数定义

#include<sys/socket.h>
//成功时返回0，失败时返回-1。
int listen(int sock, int backlog);
/*
sock：希望进入等待连接请求状态的套接字文件描述符，传递的描述符套接字参数称为服务器端套接字(监听套接字)。
backlog：连接请求等待队列(Queue)的长度，若为5，则队列长度为5，表示最多使5个连接请求进入队列。
*/

等待连接请求状态、连接请求等待队列

服务器端处于等待连接请求状态是指：客户端请求连接时，受理连接前一直使请求处于等待状态。下图给出了这个过程。

①由上图可知作为listen函数的第一个参数传递的文件描述符套接字的用途。客户端连接请求本身也是从网络中接收到的一种数据，而要想接收就需要套接字。此任务就由服务器端套接字来完成。服务器端套接字是接受连接请求的一名门卫或一扇门。
②----客户端如果向服务器端询问：“请问我是否可以发起连接？”服务器端套接字就会回答：“您好！当然可以，但系统正忙，请到等候室排号等待，准备好后会立即受理您的连接。”同时将连接请求请到等候室。
----调用listen函数即可生成这种门卫(服务器端套接字)，listen函数的第二个参数决定了等候室的大小。该参数值与服务器端的特性有关，像频繁接收请求的Web服务器端至少应为15。另外，连接请求队列的大小始终根据实验结果而定。
----等候室称为连接请求等待队列，准备好服务器端套接字和请求等待队列后，这种可接收连接请求的状态称为等待连接请求状态。

2.3 受理客户端连接请求

背景

调用listen函数后，若有新的连接请求，则按序受理。受理请求意味着进入可接受数据的状态。也许各位已经猜到进入这种状态所需部件----当然是套接字！大家可能认为可以使用服务器端套接字，但服务器端套接字是做门卫的。如果在与客户端的数据交换中使用门卫，那谁来守门呢？因此需要另外一个套接字，但没必要亲自创建。下面这个函数自动创建套接字，并连接到发起请求的客户端。

accept函数定义

#include<sys/socket.h>
//成功时返回创建的套接字文件描述符，失败时返回-1。
int accept(int sock, struct sockaddr * adr, socklen_t * addrlen);
/*
sock     服务器套接字的文件描述符
addr     保存发起连接请求的客户端地址信息的变量地址值，调用函数后向传递来的地址变量参数填充客户端地址信息。
addrlen  第二个参数addr结构体的长度，但是存有长度的变量地址。函数调用完成后，该变量即被填入客户端地址长度。
> */

accept函数调用过程

accept函数受理连接请求等待队列中待处理的客户端连接请求。函数调用成功时，accept函数内部将产生用于数据I/O的套接字，并返回其文件描述符。需要强调的是，套接字是自动创建的，并自动与发起连接请求的客户端建立连接。下图展示了accept函数调用过程。

上图展示了“从等待队列中取出1个连接请求，创建套接字并完成连接请求”的过程。服务器端单独创建的套接字与客户端建立连接后进行数据交换。

2.4 回顾Hello world服务器端

我们按照服务器端实现顺序把看起来很复杂的第1章代码进行了重新整理。可以看出，服务器端的基本实现过程实际上非常简单，就以下五个过程。

int main(int argc, char *argv[])
{
    int serv_sock; 
    int clnt_sock; 

    struct sockaddr_in serv_addr; 
    struct sockaddr_in clnt_addr; 
    socklen_t clnt_addr_size;
    char message[] = "Hello World!";
    if (argc != 2) 
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }
	
	/*
	1、服务器端实现过程中首先要创建套接字，但此时套接字尚非真正的服务器端套接字。	
	*/
    serv_sock = socket(PF_INET, SOCK_STREAM, 0); 
    if (serv_sock == -1)
        error_handling("socket() error");

	/*
	2、为了完成套接字地址分配，初始化结构体变量并调用bind函数。
	*/
    memset(&serv_addr, 0, sizeof(serv_addr));      
    serv_addr.sin_family = AF_INET;                
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); 
    serv_addr.sin_port = htons(atoi(argv[1]));     
    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) 
        error_handling("bind() error");
	
	/*
	3、调用listen函数进入等待连接请求状态，此时的套接字才是真正的服务器端套接字
	*/
    if (listen(serv_sock, 5) == -1) 
        error_handling("listen() error");

    clnt_addr_size = sizeof(clnt_addr);
    
	/*
	4、调用accept函数从队头取1个连接请求与客户端建立连接，并返回创建的套接字文件描述符。另外，调用accept函数时若等待队列为空，则accept函数不会返回，直到队列中出现新的客户端连接。
	*/
    clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
    if (clnt_sock == -1)
        error_handling("accept() error");
	
	/*
	5、调用write函数向客户端传输数据，调用close函数关闭连接。
	*/
    write(clnt_sock, message, sizeof(message)); 
    close(clnt_sock);                           
    close(serv_sock);    
                          
    return 0;
}

2.5 TCP客户端的默认函数调用顺序

客户端的实现顺序

客户端的实现顺序比服务器端简单许多，因为创建套接字和请求连接就是客户端的全部内容，如下图所示。

与服务器端相比，区别就在于“请求连接”，它是创建客户端套接字后向服务器端发起的连接请求。服务器端调用listen函数后创建连接请求等待队列，之后客户端即可请求连接。那如何发起连接请求呢？通过调用connect函数完成。

connect函数定义

#include<sys/socket.h>
//成功时返回0，失败时返回-1。
int connect(int sock, struct sockaddr *servaddr, socklen_t addrlen);
/*
sock      客户端套接字文件描述符
servaddr  保存目标服务器端地址信息的变量地址值。
addrlen   已传递给第二个结构体参数servaddr的地址变量长度。
*/

注意

客户端调用connect函数后，发生以下情况之一才会返回(完成函数调用)。
①服务器端接受连接请求。
②发生断网等异常情况而中断连接请求。
需要注意，所谓的“接收连接“并不意味着服务器端调用accept函数，其实是服务器端把连接请求信息记录到等待队列。因此connect函数返回后并不立即进行数据交换。

思考：客户端套接字地址信息在哪

问题： 实现服务器端必经过程之一就是给套接字分配IP和端口号。但客户端实现过程中并未出现套接字地址分配，而是创建套接字后立即调用connect函数。难道客户端套接字无需分配IP和端口？当然不是！网络数据交换必须分配IP和端口。既然如此，那客户端套接字何时、何地、如何分配地址呢？
答案：
①何时？
调用connect函数时。
②何地?
操作系统，更准确地说是在内核中。
③如何？
IP用计算机(主机)的IP，端口则随机。
总结： 客户端的IP地址和端口在调用connect函数时自动分配，无需调用标记的bind函数进行分配。

2.6 回顾Hello world客户端

我们按照客户端实现顺序把看起来很复杂的第1章代码进行了重新整理。可以看出，客户端的基本实现过程实际上非常简单，就以下五个过程。

int main(int argc, char *argv[])
{
    int sock;
    struct sockaddr_in serv_addr;
    char message[30];
    int str_len;

    if (argc != 3)
    {
        printf("Usage : %s <IP> <port>\n", argv[0]);
        exit(1);
    }
	
	/*
	1、创建准备连接服务器的套接字，此时创建的是TCP套接字
	*/
    sock = socket(PF_INET, SOCK_STREAM, 0);
    if (sock == -1)
        error_handling("socket() error");
	
	/*
	2、结构体变量serv_addr中初始化IP和端口信息。初始化值目标服务器端套接字的IP和端口信息。
	*/
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_addr.sin_port = htons(atoi(argv[2]));
	
	/*
	3、调用convert函数向服务器端发起连接请求
	*/
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
        error_handling("connect() error!");
	
	/*
	4、完成连接后，接收服务端传输的数据
	*/
    str_len = read(sock, message, sizeof(message) - 1);
    if (str_len == -1)
        error_handling("read() error!");

    printf("Message from server : %s \n", message);
	
	/*
	5、接受数据后调用close函数关闭套接字，结束与服务器端的连接
	*/
    close(sock);
    return 0;
}

2.7 基于TCP的服务器端/客户端函数调用关系

客户端与服务器端的交换过程

前面讲解了TCP服务器端/客户端的实现顺序，实际上二者并非相互独立，它们之间的交互过程如下图所示。

总体流程整理如下：服务器端创建套接字后连续调用bind、listen函数进入等待状态，客户端通过调用connect函数发起连接请求。需要注意的是，客户端只能等到服务器端调用listen函数后才能调用connect函数。同时要清楚，客户端调用connect函数前，服务器端有可能率先调用accept函数。当然，此时服务器端在调用accept函数时进入阻塞(blocking)状态，直到客户端调用connect函数为止。

三、实现迭代服务器端/客户端

本节编写回声(echo)服务器端/客户端。顾名思义，服务器端将客户端传输的字符串数据原封不动地传回客户端，就像回声一样。在此之前，需要先解释一下迭代服务器端。

3.1 迭代服务器端

背景

之前讨论的Hello world服务器端处理完一个客户端连接请求即退出，连接请求等待队列实际没有太大意义。但这并非我们想象的服务器端。设置好等待队列的大小后，应向所有客户端提供服务。如果想继续受理后续的客户端连接请求，最简单的办法就是插入循环语句反复调用accept函数，如下图所示。

----从上图可以看出，调用accept函数后，紧接着调用I/O相关的read、write函数，然后调用close函数。close并非针对服务器端套接字，而是针对accept函数调用时创建的套接字。
----调用close函数就意味着结束了针对某一客户端的服务。此时如果还想服务于其他客户端，就要重新调用accept函数。
问题： 这算什么啊？又不是银行窗口，好歹也算是一个服务器端，难道同一时刻只能服务于一个客户端吗？
答案： 是的！同一时刻确实只能服务于一个客户端，将来学完进程和线程后，就可以编写同时服务多个客户端的服务器端了。目前只能做到这一步。

3.2 迭代回声服务器端/客户端

前面讲的就是迭代服务器端。即使服务器端以迭代方式运转，客户端代码亦无太大区别。接下来创建迭代回声服务器端及其配套的回声客户端。首先整理一下程序的基本运行方式：

• 服务器端在同一时刻只与一个客户端相连，并提供回声服务。
• 服务器端依次向5个客户端提供服务并退出。
• 客户端接收用户输入的字符串并发送到服务器端。
• 服务器端将接受的字符串数据传回客户端，即“回声”。
• 服务器端与客户端之间的字符串回声一直执行到客户端输入Q为止。

回声服务器端程序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 1024
void error_handling(char *message);

int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock; // 这个 clnt_sock 将用来表示服务器端上真正与客户端相连接的那个套接字
    char message[BUF_SIZE];
    int str_len, i;

    struct sockaddr_in serv_adr, clnt_adr; // 这个 clnt_adr 将用来存储连接的客户端的地址信息，注意和 clnt_sock 表示的对象的不同
    socklen_t clnt_adr_sz;

    if (argc != 2)
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }

    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    if (serv_sock == -1)
        error_handling("socket() error");

    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_adr.sin_port = htons(atoi(argv[1]));

    if (bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("bind() error");

    if (listen(serv_sock, 5) == -1)
        error_handling("listen() error");

    clnt_adr_sz = sizeof(clnt_adr);

	/*
	1、为处理5个客户端连接而添加的循环语句。共调用5次accept函数，依次向5个客户端提供服务。
	*/
    for (int i = 0; i < 5; i++)
    {
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);
        if (clnt_sock == -1)
            error_handling("accept() error");
        else
            printf("Connected client %d \n", i + 1);
		
		/*
		2、实际完成回声服务的代码，原封不动地传输读取的字符串。
		*/
        while ((str_len = read(clnt_sock, message, BUF_SIZE)) != 0)
            write(clnt_sock, message, str_len);
		
		/*
		3、针对套接字调用close函数，向连接的相应套接字发送EOF。
		*/
        close(clnt_sock);
    }
    /*
	4、向5个客户端提供服务后关闭服务器端套接字并终止程序。
	*/
    close(serv_sock);
    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

首先执行gcc echo_server.c -o eserver编译源文件，然后执行./eserver 9190等待客户端消息的来临。

回声客户端程序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 1024
void error_handling(char* message);

int main(int argc, char* argv[])
{
    int sock;
    char message[BUF_SIZE];
    int str_len;
    struct sockaddr_in serv_adr;

    if(argc != 3){
        printf("Usage : %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    sock = socket(PF_INET, SOCK_STREAM, 0);
    if(sock == -1)
        error_handling("sock() error");

    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_adr.sin_port = htons(atoi(argv[2]));

	/*
	1、调用connect函数。若调用该函数引起的连接请求被注册到服务器端等待队列，则connect函数将完成正常调用。
	因此，即使通过第35行代码输出了连接提示字符串——如果服务器尚未调用accept函数——也不会真正建立服务关系。
	*/
    if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("connect() error!");
    else
        puts("Connected............");
    
    while(1)
    {
        fputs("Input message(Q to quit): ", stdout);
        fgets(message, BUF_SIZE, stdin); 

        if(!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;
        
        write(sock, message, strlen(message));
        str_len = read(sock, message, BUF_SIZE-1);
        message[str_len] = 0;
        printf("Message from server; %s", message);
    }
    /*
    2、调用close函数向相应套接字发送EOF(EOF即意味着中断连接)。
    */
    close(sock);
    return 0;
}

void error_handling(char* message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

首先执行gcc echo_client.c -o eclient编译源文件，然后执行./eclient 127.0.0.1 9190与服务器端建立连接，最后传递一些字符串。

3.3 回声客户端存在的问题

下列是echo_client.c的第45~48行代码：

write(sock, message, strlen(message));
str_len = read(sock, message, BUF_SIZE - 1);
message[str_len] = 0;
printf("Message from server: %s", message);

存在的问题

以上代码有个错误假设：
①每次调用read、write函数时都会以字符串为单位执行实际的I/O操作。
当然，每次调用write函数都会传递1个字符串，因此这种假设在某种程度上也算合理。但第2章中提到过“TCP不存在数据边界”的内容，上述客户端是基于TCP的，因此，多次调用write函数传递的字符串有可能一次性传递到服务器端。此时客户端有可能从服务器端收到多个字符串，这不是我们希望看到的结果。
还需考虑服务器端的如下情况：
②字符串太长，需要分2个数据包发送！
服务器端希望通过调用1次write函数传输数据，但如果数据太大，操作系统就有可能把数据分成多个数据包发送到客户端。另外，在此过程中，客户端有可能在尚未收到全部数据包时就调用read函数。
所有这些问题都源自TCP的数据传输特性，后续会提供解决方法。
问题： 但上述示例不是正常运转了吗？
答案： 当然，我们的回声服务器端/客户端给出的结果是正确的。但这只是运气好罢了！只是因为收发的数据小，而且运行环境为同一台计算机或相邻的两台计算机，所以没发生错误，可实际上仍存在发生错误的可能。

四、基于Windows的实现

4.1 基于Windows的回声服务器端

为了将Linux平台下的示例转化成Windows平台示例，需要记住以下4点：

①通过WSAStartup、WSACleanup函数初始化并清除套接字相关库。
②把数据类型和变量名切换为Windows风格。
③数据传输中用recv、send函数而非read、write函数。
④关闭套接字时用closesocket函数而非close函数。

基于Windows的回声服务器端

#pragma comment(lib,"ws2_32.lib")
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <WinSock2.h>

#define BUF_SIZE 1024
void ErrorHandling(char *message);

int main(int argc, char* argv[])
{
	WSADATA wsaData;
	SOCKET hServSock, hClntSock;
	char message[BUF_SIZE];
	int strlen, i;

	SOCKADDR_IN servAdr, clntAdr;
	int clntAdrSize;

	if (argc != 2) {
		printf("Usage : %s <port>\n", argv[0]);
		exit(1);
	}

	if(WSAStartup(MAKEWORD(2,2), &wsaData) != 0)
		ErrorHandling("socket() error");

	hServSock = socket(PF_INET, SOCK_STREAM, 0);
	if(hServSock == INVALID_SOCKET)
		ErrorHandling("socket() error");

	memset(&servAdr, 0, sizeof(servAdr));
	servAdr.sin_family = AF_INET;
	servAdr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);
	servAdr.sin_port = htons(atoi(argv[1]));

	if(bind(hServSock, (SOCKADDR*)&servAdr, sizeof(servAdr))==SOCKET_ERROR)
		ErrorHandling("bind() error");

	if(listen(hServSock, 5) == SOCKET_ERROR)
		ErrorHandling("listen() error");

	clntAdrSize = sizeof(clntAdr);

	for (i = 0; i < 5; i++)
	{
		hClntSock = accept(hServSock, (SOCKADDR*)&clntAdr, &clntAdrSize);
		if(hClntSock==-1)
			ErrorHandling("accept() error");
		else
			printf("connected client %d \n", i+1);

		while((strlen=recv(hClntSock, message, BUF_SIZE, 0)) != 0)
			send(hClntSock, message, strlen, 0);

		closesocket(hClntSock);
	}
	closesocket(hServSock);
	WSACleanup();
	return 0;
}

void ErrorHandling(char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}

运行，可以看出服务器端正在等待消息来临。

4.2 基于Windows的回声客户端

基于Windows的回声客户端

#pragma comment(lib,"ws2_32.lib")
#pragma warning(disable:4996)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <WinSock2.h>

#define BUF_SIZE 1024
void ErrorHandling(const char *message);

int main(int argc, char* argv[])
{
	WSADATA wsaData;
	SOCKET hSocket;
	char message[BUF_SIZE];
	int strLen;
	SOCKADDR_IN servAdr;


	if (argc != 3) {
		printf("Usage : %s <IP> <port>\n", argv[0]);
		exit(1);
	}

	if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
		ErrorHandling("socket() error");

	hSocket = socket(PF_INET, SOCK_STREAM, 0);
	if (hSocket == INVALID_SOCKET)
		ErrorHandling("socket() error");

	memset(&servAdr, 0, sizeof(servAdr));
	servAdr.sin_family = AF_INET;
	servAdr.sin_addr.S_un.S_addr = inet_addr(argv[1]);
	servAdr.sin_port = htons(atoi(argv[2]));

	if (connect(hSocket, (SOCKADDR*)&servAdr, sizeof(servAdr)) == SOCKET_ERROR)
		ErrorHandling("bind() error");
	else
		puts("Connected............");

	while (1)
	{
		fputs("Input message(Q to quit): ", stdout);
		fgets(message, BUF_SIZE, stdin);

		if(!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
			break;

		send(hSocket, message, strlen(message), 0);
		strLen = recv(hSocket, message, BUF_SIZE-1, 0);
		message[strLen] = 0;
		printf("Message from server: %s", message);
	}
	closesocket(hSocket);
	WSACleanup();
	return 0;
}

void ErrorHandling(const char *message)
{
	fputs(message, stderr);
	fputc('\n', stderr);
	exit(1);
}

运行，可以看出服务器端显示已连接一个客户端。

输入一些字符串，可以看出都从服务器端发送回来了。

断开连接，然后重新连接到服务器端，可以看到连接的客户端数量多了1个。