Part 1 start network programming:chapter four ： 基于TCP的服务器端/客户端（1）

第四章：基于TCP的服务器端/客户端（1）

内容概述

前面是 创建套接字socket和 向套接字分配地址bind的过程
这里我们讨论通过套接字收发数据

1. TCP与UDP的区别数据传输方式不同
2. 协议栈的层次关系：链路层->IP层->tcp/udp层->应用层。
3. 基于TCP的服务器端和客户端详解
   服务器端定义的两个套接字的用途 serv_sock和clnt_sock（一个当做门卫，一个用于连接）
4. 详解connect函数（可以分配地址）
5. 回声服务器端和回声客户端的实现
   之前介绍套接字创建时我们选择的是 面向连接的套接字，本章主要讨论这种面向连接的服务器端/客户端的编写

正文

4.1 理解TCP 和 UDP

TCP（transmission control protocol：传输控制协议）
这两者的根本区别是数据传输方式不同。
基于网络协议的套接字一般分为TCP和UDP套接字。 TCP是面向连接的的套接字，也称 基于流（stream）的套接字

4.1.1 TCP/IP 协议栈

先介绍一下这个听起来很高大上的东西是什么：

从上图可以看出，TCP/IP协议栈一共4层，可以理解为数据收发分4个层次化的过程

也就是说，我们在进行"基于互联网的有效数据传输"时，并非一个庞大的协议解决问题，而是通过借助着4层的相互配合完成的，当然里面很多都是底层的原理，在编程时我们不需要写出来，但是一定要理解这个过程才能编程正确

4.1.2 TCP/IP协议的诞生

总体来说，我们的目标是：通过Internet完成有效数据传输
这其中涉及了很多东西，硬件上的，软件上的，算法等等，如何把这些有效结合起来，设计出一套完整的具有互换性的（通用性的）系统呢？

这样的系统 Open System 开放式系统类似于机械领域内的 互换性说法，也就是任何一个部分我们都有国家甚至是世界的标准，如果有问题随时可以换成新的，并且不会影响整个系统的作用。
（举个例子，路由器坏了随便换个新的就行，因为都是按照IP层的标准制造的）

下面我们具体讲解这几个层的内容

4.1.3 链路层

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

4.1.4 IP层

物理链接好后，就要传输数据了。在复杂的网络中首先我们要考虑路径的选择。IP层解决的就是这个问题。

IP本身是面向消息的、不可靠的协议。每次传输数据时都会帮我们选择路径，但并不一致。如果传输路径发生错误，则选择其他路径，如果发生数据丢失或错误，则无法解决

这就需要我们后面的TCP来搞定这个问题

4.1.5 TCP/UDP层

IP层解决的是数据传输中的路径选择问题，只要按照这个路径传输数据就行了。 但是IP传输并不稳定，这里需要我们的TCP/udp层以IP层提供的路径信息为基础，完成实际的数据传输，因此 TCP/UDP层 又称为 传输层（transport）。

TCP层又是如何保证传输稳定的呢？

IP层关注一个数据包（数据传输的基本单位）的传输过程。因此即使有多个数据包，每个数据包也是由IP层实际传输的，也就是说数据实际上就是IP层传输的，并且这个面向消息的传输过程是 无序的、容易丢失的。
TCP层的作用是在数据交换过程中可以确认对方已经接到数据，并重传丢失的数据，那么即使IP层不保证数据传输，这类通信也是可靠的。
例如：
主机A： 我已经正确收到第二个数据包啦~
主机B： 好的知道啦~
。。。
主机A： 我已经正确收到第三个数据包啦~
主机A： 我已经发送了第四个了~，您没收到第四个是吧，我重新发给您。

xxxxxxxxxxx图

总而言之，TCP/UDP层位于IP层之上，决定主机间的数据传输方式，TCP协议确认后向不可靠的IP协议赋予了可靠性。

4.1.6 应用层

上面说了很多，其实这里面的过程都是自动处理的，我们只要进行套接字编程就行。

然而，在编程过程中，根据实际的业务我们需要改变 服务器端和客户端之间的 数据传输规则，这就是 应用层协议。
网络编程大部分内容就是设计并实现应用层协议。

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

这里我们实现完整的TCP服务器端，这个过程中我们要关注套接字使用方法和数据传输方法！

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

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

4.2.2 进入等待连接请求状态

我们在使用bind函数给套接字分配了地址之后，接下来就要通过调用listen函数进入等待连接请求状态。

只有服务器端调用listen函数之后，客户端才能进入可发出连接请求的状态，换言之这时客户端才能调用connect函数（若提前调用会发生错误。）

#include <sys/socket.h>

int listen(int sock,int backlog);
-> 成功时返回0.失败返回-1

sock：希望进入等待连接状态的套接字文件描述符，传递的描述符套接字参数成为服务器端套接字（监听套接字）
backlog： 连接请求等待队列的长度，表示最多使 几个 连接请求进入队列。

服务器的等待连接请求状态：客户端请求连接时，服务器在受理连接前一直使客户端的请求处于等待状态。

等待连接请求状态

由上图可知作为listen函数的第一个参数传递的文件描述符套接字的用途。

客户端连接请求本身也是从网络中接收到的一种数据,而要想接收就需要套接字。此任务就由服务器端套接字完成。
服务器端套接字是接收连接请求的一名门卫或一扇门。

客户端如果向服务器端询问:“请冋我是否可以发起连接?”
服务器端套接字就会亲切应答:“您好!当然可以,但系统正忙,请到等候室排号等待,准备好后会立即受理您的连接。”
同时将连接请求请到等候室。

调用 listen函数即可生成这种门卫(服务器端套接字),listen函数的第二个参数决定了等候室的大小。
等候室称为连接请求等待队列,准备好服务器端套接字和连接请求等待队列后,这种可接收连接请求的状态称为等待连接请求状态。

listen函数的第二个参数值与服务器端的特性有关,像频繁接收请求的Web服务器端至少应为15。
另外,连接请求队列的大小始终根据实验结果而定。

4.2.3 受理客户端连接请求

调用 listen函数后,若有新的连接请求,则应按序受理。受理请求意味着进入可接受数据的状态。

include <sys/socket.h>
int accept(int sock,struct sockaddr *addr,socklen_t *addrlen);
-> 成功时返回创建的套接字文件描述符，失败时返回-1

sock：服务器套接字的文件描述符
addr：保存发起连接请求的客户端地址信息的变量地址值，调用函数后向传递进入函数的地址变量参数填充客户端地址信息
addrlen：第二个参数addr结构体的长度，这里是存有长度的变量地址。函数调用完成后，该变量即被填入客户端地址长度。

进入这种 可以接收数据的状态所需参数中sock是服务器套接字，但是服务器端套接字之前已经做了门卫，如果还用一个套接字的话，既要用来接收客户端的连接请求，一会又要和客户端进行数据传输，这不行呀。
是不是需要另一个套接字来完成呢？

是的~ accept函数会自动创建一个新的套接字，并连接到发起请求的客户端，并作为返回值返回。

accept 函数受理连接请求等待队列中 待处理的客户端连接请求。 函数调用成功时，accept函数内部将产生用于 数据I/O的套接字，并返回其文件描述符。

受理连接请求状态

从上图可以看出，accept函数调用时，从等待队列中取出一个连接请求，创建套接字并完成连接请求~

使用这个新创建的套接字 来作为 客户端的代表

4.2.4 回顾 Hello World服务器端

1. 服务器端：hello_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int serv_sock;											// 服务器端套接字文件描述符
	int clnt_sock;											// 客户端套接字文件描述符

	struct sockaddr_in serv_addr;							// IPv4地址信息结构体
	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);
	}

	serv_sock = socket(PF_INET, SOCK_STREAM, 0);			// 服务器端分配套接字 IPv4面向连接基于流的套接字
	if(serv_sock == -1){
		error_handling("socket() error");
	}

	memset(&serv_addr, 0, sizeof(serv_addr));				// 初始化服务器端的IPv4地址信息结构体 信息
	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){	// 把服务器端的套接字和IPv4地址信息结合
		error_handling("bind() error");
	}
															
	if(listen(serv_sock, 5) == -1){							// 服务器端 进入等待连接请求状态 队列长度为5  
		error_handling("listen() error");					// 此时套接字成为服务器端套接字
	}

	clnt_addr_size = sizeof(clnt_addr);						 
	//调用accept函数从队头去一个连接请求与客户端建立连接，并返回创建的套接字文件描述符。若等待队列为空，则不会返回，直至队列中出现新的客户端连接
	clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size);

	if(clnt_sock == -1){
		error_handling("accept() error");
	}
	
	write(clnt_sock, message, sizeof(message));				// 调用write函数向客户端传输数据
	close(clnt_sock);
	close(serv_sock);
	return 0;
}
void error_handling(char* message)
{
	fputs(message,stderr);
	fputc('\n',stderr);
	exit(1);
}

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

接下来是客户端的实现顺序，这里比服务器端简单很多。只需要创建套接字和请求连接。

下图表示TCP客户端函数调用顺序

有个问题：客户端套接字不用分配地址信息嘛？？？

实现服务器端必经过程之一就是給套接字分配P和端口号。但客户端实现过程中并未出现套接宇地址分配,而是创建套接字后立即调用 connect函数。
难道客户端套接宇无需分配IP和端口?

当然不是!网络数据交換必须分配IP和端口。既然如此,那客户端套接字何时、何地、如何分配地址呢?
何时? 调用 connect函数时。
何地? 操作系统,更准确地说是在内核中。
如何? IP用计算机(主机)的IP,端口随机。
客户端的IP地址和端口在调用 connect函数时自动分配,无需调用标记的bind函数进行分配。

4.2.6 回顾Hello world 客户端

hello_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
void error_handling(char *message);

int main(int argc, char *argv[])
{
	int sock;
	struct sockaddr_in serv_addr;
	char message[] = "Hello world";
	int str_len;

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

	sock = socket(PF_INET, SOCK_STREAM, 0);				// 创建准备连接服务器端的套接字 此时创建的是TCP套接字
	if(sock == -1){
		error_handling("socket() error");
	}

	memset(&serv_addr, 0, sizeof(serv_addr));			// 结构体变量serv_addr中初始化IP和端口信息，初始化值为目标
	serv_addr.sin_family = AF_INET;						// 服务器的套接字的IP和端口号信息
	serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
	serv_addr.sin_port = htons(atoi(argv[2]));

	if(connect(sock,(struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1){	// 调用connect函数向服务器端发送连接请求
		error_handling("bind() error");					// 在connect过程中完成了为本地socket分配ip和随机端口号的过程
	}
	/*
	 *  fd:显示数据接受对象的文件描述  buf：要保存的数据的缓冲地址值  nbytes：要接收数据的最大字节数
	 * ssize_t read(int fd, void* buf,size_t nbytes);
	 * 成功时返回接收的字节数，（但遇到文件结尾则返回0），失败返回-1
	 */
	str_len = read(sock,message,sizeof(message) - 1);	// 完成连接后，接收服务器端传输的数据。
	if(str_len == -1){
		error_handling("read() error!");
	}

	printf("message from server : %s\n",message );
	close(sock);										// 接收数据后调用close函数关闭套接字，结束语服务器端的连接。
	return 0;
}
void error_handling(char* message)
{
	fputs(message,stderr);
	fputc('\n',stderr);
	exit(1);
}

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

上面说的服务器端 和 客户端并非相互独立的，下图是他们之间函数调用的过程。

服务器端创建套接字后连续调用bind、listen函数进入等待状态，
客户端通过调用connect函数发起连接请求
（注意：只有在服务器端在调用了listen函数之后进入了等待状态之后，服务器才能调用connect函数请求连接）

客户端在调用connect函数之前，服务器端可能已经调用了accept函数，此时如果队列中没有等待状态的客户端请求，服务器端将进入柱塞状态，
知道客户端调用connect函数为止。

4.3 实现迭代服务器端/ 客户端

本节实现回声服务器端/客户端（回声：echo）。
服务器端将客户端传输的字符串数据原封不动地传回客户端，就像回声一样。在此之前，需要解释下迭代服务器端的代码。

4.3.1 实现迭代服务器端

之前的 hellow world服务器端处理了一个客户端连接请求就退出了，连接请求等待队列实际没有什么用了。
这并非实际的服务器，在设置好等待队列的大小后，应向所有客户端提供服务。
如果想继续受理后续的客户端连接请求，应该插入循环语句反复调用accept函数，如下图所示逻辑

从图中可以看出，调用accept函数之后，紧接着调用I/O相关的read write函数，然后调用close函数，这并非针对服务器端套接字，
而是针对accept函数调用时创建的套接字。（client是通过accept得到的返回值，套接字）

调用close函数意味着结束了针对某一个客户端的服务，如果此时还想服务其他客户端就要重新调用accept函数。
（难道一次只能服务一个客户端嘛？？？当然不是啦~ 以后学完进程和线程之后就能够同时服务多个客户端啦~）

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

上面修改了原来的服务器端逻辑，下面修改一下回声客户端，并把这两部分的代码搞一下~

首先梳理下程序的基本运行方式：

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

下面上代码~

服务器端：
echo_server.c

#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[1])
{
	int serv_sock, clnt_sock;
	char message[BUF_SIZE];
	int str_len;

	struct sockaddr_in serv_adr, clnt_adr;
	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);

	for(int i = 0; i < 5;i++)	// 处理5个客户端连接，一共调用5次accept函数没提供5次服务
	{
		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);
		}
		
		while((str_len = read(clnt_sock, message, BUF_SIZE)) != 0){	//这里是实现回声的代码，直接传输读取到的字符串
			write(clnt_sock, message, str_len);
		}
		
		close(clnt_sock);						// 在for中 如果while接收到 客户端不在发送内容，就会关闭这个客户端套接字连接
	}
	close(serv_sock);							// 向5个客户端提供服务后 关闭服务器端套接字并终止程序。
	return 0;
}

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

接下来是回声客户端的代码：

echo_client.c

#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("socket () error ");
	}
	// 初始化服务器端的地址信息  这个信息是从main函数的参数中读取的
	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]));


	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));
		/*
	 	 *  fd:显示数据接受对象的文件描述  buf：要保存的数据的缓冲地址值  nbytes：要接收数据的最大字节数
	 	 *  ssize_t read(int fd, void* buf,size_t nbytes);
	 	 *  成功时返回接收的字节数，（但遇到文件结尾则返回0），失败返回-1
	 	 */
		str_len = read(sock,message,BUF_SIZE - 1);
		message[str_len] = 0;
		printf("Message from server: %s", message);
	}

	close(sock);
	return 0;
}


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

调用结果：

4.3.2 回声客户端存在的问题

下列是客户端的一段代码：

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

上面代码有点问题：

问题：
如果客户端在发送数据的后，服务器开始接受，这时如果服务器运行的更慢，可能我们客户端的第二次循环已经开始了！！！又write了一次，那这时我们客户端会read出来个啥呢？
我们会进行下面这样的修改，这里先大概看一下，具体的我们下一章中将具体讲解，大家可以根据解决方法感受一下我们的目的是什么？？？
while(recv_len < str_len)
{
recv_cnt = read(sock,&message[recv_len],BUF_SIZE - 1);
if(recv_cnt == -1){
error_handling(“read() error!”);
}
recv_len += recv_cnt;
}

这些问题源自TCP的特性，第五章给出解决方案~（这里没看懂的小伙伴没关系，我第一次也有点乱，不太理解怎么解决，可以看了第五章回头来对比一下）