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

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

文章目录

  • 前言
  • 一、理解TCP和UDP
    • 1.1 TCP/IP协议栈
    • 1.2 TCP/IP协议的诞生背景
    • 1.3 链路层
    • 1.4 IP层
    • 1.5 TCP/UDP层
    • 1.6 应用层
  • 二、实现基于TCP的服务器端/客户端
    • 2.1 TCP服务器端的默认函数调用顺序
    • 2.2 进入等待连接请求状态
    • 2.3 受理客户端连接请求
    • 2.4 回顾Hello world服务器端
    • 2.5 TCP客户端的默认函数调用顺序
    • 2.6 回顾Hello world客户端
    • 2.7 基于TCP的服务器端/客户端函数调用关系
  • 三、实现迭代服务器端/客户端
    • 3.1 迭代服务器端
    • 3.2 迭代回声服务器端/客户端
    • 3.3 回声客户端存在的问题
  • 四、基于Windows的实现
    • 4.1 基于Windows的回声服务器端
    • 4.2 基于Windows的回声客户端


前言

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


一、理解TCP和UDP

前言

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


1.1 TCP/IP协议栈

TCP所属的TCP/IP协议栈

如下图所示:
TCP/IP网络编程:P4->基于TCP的服务器端/客户端(上)_第1张图片
可以看出
①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等网络标准链路层就负责这些标准。若两台主机通过网络进行数据交换,就需要物理连接,链路层就负责这些标准。
TCP/IP网络编程:P4->基于TCP的服务器端/客户端(上)_第2张图片


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/IP网络编程:P4->基于TCP的服务器端/客户端(上)_第3张图片
④总之,TCP和UDP存在于IP层之上,决定主机之间的数据传输方式,TCP协议确认后向不可靠的IP协议赋予可靠性。


1.6 应用层

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


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

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


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

绝大部分TCP服务器端都按照下图所示的顺序调用:
TCP/IP网络编程:P4->基于TCP的服务器端/客户端(上)_第4张图片
调用socket函数创建套接字,声明并初始化地址信息结构体变量,调用bind函数向套接字分配地址。这2个阶段之前已讨论过,下面讲解之后的几个过程。


2.2 进入等待连接请求状态

背景

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

listen函数定义

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

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

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


2.3 受理客户端连接请求

背景

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

accept函数定义

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

accept函数调用过程

accept函数受理连接请求等待队列中待处理的客户端连接请求。函数调用成功时,accept函数内部将产生用于数据I/O的套接字,并返回其文件描述符。需要强调的是,套接字是自动创建的,并自动与发起连接请求的客户端建立连接。下图展示了accept函数调用过程。
TCP/IP网络编程:P4->基于TCP的服务器端/客户端(上)_第6张图片
上图展示了“从等待队列中取出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 \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客户端的默认函数调用顺序

客户端的实现顺序

客户端的实现顺序比服务器端简单许多,因为创建套接字和请求连接就是客户端的全部内容,如下图所示。
TCP/IP网络编程:P4->基于TCP的服务器端/客户端(上)_第7张图片
与服务器端相比,区别就在于“请求连接”,它是创建客户端套接字后向服务器端发起的连接请求。服务器端调用listen函数后创建连接请求等待队列,之后客户端即可请求连接。那如何发起连接请求呢?通过调用connect函数完成。

connect函数定义

#include
//成功时返回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  \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服务器端/客户端的实现顺序,实际上二者并非相互独立,它们之间的交互过程如下图所示。
TCP/IP网络编程:P4->基于TCP的服务器端/客户端(上)_第8张图片
总体流程整理如下:服务器端创建套接字后连续调用bind、listen函数进入等待状态,客户端通过调用connect函数发起连接请求。需要注意的是,客户端只能等到服务器端调用listen函数后才能调用connect函数。同时要清楚,客户端调用connect函数前,服务器端有可能率先调用accept函数。当然,此时服务器端在调用accept函数时进入阻塞(blocking)状态,直到客户端调用connect函数为止。


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

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


3.1 迭代服务器端

背景

之前讨论的Hello world服务器端处理完一个客户端连接请求即退出,连接请求等待队列实际没有太大意义。但这并非我们想象的服务器端。设置好等待队列的大小后,应向所有客户端提供服务。如果想继续受理后续的客户端连接请求,最简单的办法就是插入循环语句反复调用accept函数,如下图所示。
TCP/IP网络编程:P4->基于TCP的服务器端/客户端(上)_第9张图片
----从上图可以看出,调用accept函数后,紧接着调用I/O相关的read、write函数,然后调用close函数。close并非针对服务器端套接字,而是针对accept函数调用时创建的套接字。
----调用close函数就意味着结束了针对某一客户端的服务。此时如果还想服务于其他客户端,就要重新调用accept函数。
问题: 这算什么啊?又不是银行窗口,好歹也算是一个服务器端,难道同一时刻只能服务于一个客户端吗?
答案: 是的!同一时刻确实只能服务于一个客户端,将来学完进程和线程后,就可以编写同时服务多个客户端的服务器端了。目前只能做到这一步。


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

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

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

回声服务器端程序

#include 
#include 
#include 
#include 
#include 
#include 

#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 \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 
#include 
#include 
#include 
#include 
#include 

#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  \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与服务器端建立连接,最后传递一些字符串。
TCP/IP网络编程:P4->基于TCP的服务器端/客户端(上)_第10张图片


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 
#include 
#include 
#include 

#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 \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 
#include 
#include 
#include 

#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  \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);
}

运行,可以看出服务器端显示已连接一个客户端。
在这里插入图片描述
输入一些字符串,可以看出都从服务器端发送回来了。
TCP/IP网络编程:P4->基于TCP的服务器端/客户端(上)_第11张图片
断开连接,然后重新连接到服务器端,可以看到连接的客户端数量多了1个。
TCP/IP网络编程:P4->基于TCP的服务器端/客户端(上)_第12张图片

你可能感兴趣的:(TCP/IP网络编程,网络,tcp/ip,网络协议,服务器,后端)