**
第四章 基于TCP的服务器端/客户端（1）
**
主要内容：
这里我们讨论通过套接字收发数据
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层模型包括：
网络接口层：MAC VLAN
网络层:IP ARP ICMP
传输层:TCP UDP
应用层:HTTP DNS SMTP
我们在进行"基于互联网的有效数据传输"时，并非一个庞大的协议解决问题，而是通过借助着4层的相互配合完成的，当然里面很多都是底层的原理，在编程时我们不需要写出来，但是一定要理解这个过程才能编程正确。
补充关于OSl七层模式及其协议：
OSI七层模型及其包含的协议如下:
物理层: 比特流传输 传输单位：比特
数据链路层: 提供介质访问，链路管理,传输单位为帧,主要包括的协议为MAC VLAN PPP
网络层：负责数据包从源到宿的传递和网际互连，传输单位为包,主要包括的协议为IP ARP ICMP
传输层：提供端到端的可靠报文传递和错误恢复，传输单位为报文,主要包括的协议为TCP UDP
会话层：建立、维护和管理会话，传输单位为SPDU，主要包括的协议为RPC NFS
表示层: 处理数据格式和加密等,传输单位为PPDU，主要包括的协议为JPEG ASII
应用层: 提供应用程序间通信,传输单位为APDU，主要包括的协议为FTP HTTP DNS
4.1.2 TCP/IP协议的诞生
下面具体讲解这几个层：
4.1.3 链路层
链路层是物理链接领域标准化的结果，也是最基本的领域，专门定义LAN、WAN、MAN等网络标准。
若两台主机通过网络进行数据交换，则需要下图的物理链接，链路层就负责这些标准。
网络连接结构图
4.1.4 IP层
物理链接好后，就要传输数据了。
在复杂的网络中首先我们要考虑路径的选择。IP层解决的就是这个问题。
IP本身是面向消息的、不可靠的协议。每次传输数据时都会帮我们选择路径，但并不一致。如果传输路径发生错误，则选择其他路径，如果发生数据丢失或错误，则无法解决
这就需要我们后面的TCP来搞定这个问题
4.1.5 TCP/IP层
**IP层解决的是数据传输中的路径选择问题，**只要按照这个路径传输数据就行了。
但是IP传输并不稳定，这里需要我们的TCP/UDP层以IP层提供的路径信息为基础，完成实际的数据传输，因此 TCP/UDP层 又称为 传输层（transport）。
TCP层又是如何保证传输稳定的呢？
IP层关注一个**数据包（数据传输的基本单位）的传输过程。因此即使有多个数据包，每个数据包也是由IP层实际传输的，也就是说数据实际上就是IP层传输的，并且这个面向消息的传输过程是 无序的、容易丢失的。
TCP层的作用是在数据交换过程中可以确认对方已经接到数据，并重传丢失的数据，那么即使IP层不保证数据传输，这类通信也是可靠的。
利用的TCP的”三次握手四次挥手“**的机制。
三次握手机制：
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
四次挥手机制
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客户端的默认函数调用顺序
有个问题：客户端套接字不用分配地址信息嘛？？？
实现服务器端必经过程之一就是給套接字分配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的服务器端/客户端函数调用关系
1.服务器端创建套接字后连续调用bind,listen 函数进入等待状态。
2.客户端通调用connect函数发起连接请求;
（注意：只有在服务器端在调用了listen函数之后进入了等待状态之后，客户端才能调用connect函数请求连接）
3.客户端在调用connect函数之前，服务器端可能已经调用了accept函数，此时如果队列中没有等待状态的客户端请求，服务器端将进入柱塞状态，直到客户端调用connect函数为止。
4.3 实现迭代服务器端/客户端
服务器端将客户端传输的字符串数据原封不动地传回客户端，就像回声一样。在此之前，需要解释下迭代服务器端的代码。
4.3.1 实现迭代服务器端
之前的 hellow world服务器端处理了一个客户端连接请求就退出了，连接请求等待队列实际没有什么用了。这并非实际的服务器，在设置好等待队列的大小后，应向所有客户端提供服务。如果想继续受理后续的客户端连接请求，应该插入循环语句反复调用accept函数，如下图所示逻辑
从图中可以看出，调用accept函数之后，紧接着调用I/O相关的read write函数，然后调用close函数，这并非针对服务器端套接字，
而是针对accept函数调用时创建的套接字。（client是通过accept得到的返回值，套接字）
调用close函数意味着结束了针对某一个客户端的服务，如果此时还想服务其他客户端就要重新调用accept函数。
4.3.2 代码实现
首先梳理下程序的基本运行方式：
- 服务器端在同一时刻只与一个客户端相连，并提供回声服务
- 服务器端依次向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);
}
在这里插入代码片
**
基于TCP的服务器端/客户端（2）
**
第四章通过回声示例讲了一下TCP的服务器/客户端实现方法~ 这只是编程角度，这里通过TCP原理角度出发，讲解这个过程，同时解决掉上一章末尾的问题。
回声客户端的修正版
tcp套接字中的io缓冲原理
tcp工作原理（握手过程）
5.1 回声客户端的完美实现
5.1.1 只有回声客户有问题？
有问题的部分：
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);
}
在这里插入代码片
这里有一个很重要的问题没有考虑，就是如果客户端在发送数据的后，服务器开始接受，这时如果服务器运行的更慢，可能我们客户端的第二次循环已经开始了！！！又write了一次，那这时我们客户端会read出来个啥呢？
可能是会把所有write进 写入缓冲的数据都 read出来吧~，这肯定不是我们想要的啊！
所以！我们要控制我们客户端的read，让他每次只读我们传过去的字节数！
5.1.2 回声客户端解决的办法
实际上解决方法就很简单了，重要的是发现问题的过程，这里其实只要把read放到一个while循环里就ok了~接不到我想要的大小的回声我就一直read，直到我满意为止。
上代码：
echo_client2.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,recv_len,recv_count;
struct sockaddr_in serv_addr;
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 ");
}
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]));
if(connect(sock,(struct sockaddr*)&serv_addr,sizeof(serv_addr)) == -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;
}
str_len = write(sock,message,strlen(message));
recv_len = 0;
// 这里就是修改的部分
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;
}
message[recv_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);
}
其中
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;
}
在这里插入代码片
这里要好好理解一下，
recv_cnt 用来存储 每次读到的字节数
read函数将每次读取的信息存到 message中（比如第一次读了3个字节，第二次再存就从数组的第3个位置开始）
可能大家有个问题：while中为什么不用 recv_len ！= str_len
有可能在接收的时候出现异常，比如 str_len = 5, 第一次接受了3个，第二次又接受了3个，那就没法停止循环了
不能及时发现错误。
5.1.3 如果问题不在于回声客户端：定义应用层协议
上面的程序中，我们在客户端程序中直接定义了write的str_len 这实际上在应用中不太可能直接得到。
这时就需要些应用层的协议了（例如之前的收到 q 就退出）
下面写一个计算器的TCP程序，感受一下应用层协议的定义过程。
要求：先发送几个数字，再发送一种计算方法，返回结果。
细节自己定，我就写个我自己的
operator_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[]) // main的参数不变，还是这样的，一会赋值服务器的IP地址
{
struct sockaddr_in serv_addr; // 服务器地址信息结构体
int sock_client;
int count; // 用来接收输入数字的个数
int result; // 用来接收返回的结算结果
char message[BUF_SIZE]; // 传输用的字符数组
if(argc != 3){
printf("Usage %s <IP> <port>\n", argv[0]);
exit(1);
}
// 1. 分配套接字，并初始化一会连接时用的 服务器端的地址信息
sock_client = socket(PF_INET,SOCK_STREAM,0);
if (sock_client == -1)
{
error_handling("socket() error");
}
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]));
// 2. 下面进行连接被~
if(connect(sock_client,(struct sockaddr*)&serv_addr,sizeof(serv_addr)) == -1){
error_handling("connected error!");
}
else{
puts("Connected.....");
}
// 3. 连上了开始接受我们的输入数字和符号、同时存入我们想要传过去的字符数组
fputs("请输入想要计算几个数字呀~ ： ",stdout);
scanf("%d",&count);
message[0] = (char)count; // 这样写感觉会有问题，如果count是两位数呢，一个位置是不就装不下了
for(int i = 0;i < count ;i++){
printf(" 请输入第 %d 个数：",i+1);
scanf("%d",(int*)&message[4*i+1]);
}
fgetc(stdin); // 删除缓冲中的字符\n
fputs("请输入操作符：",stdout);
scanf("%c",&message[count*4 + 1]);
// 4. 该输入的搞定了，接下来就传过去被~ 传完了接回来结果。
write(sock_client,message,count *4 + 2);
printf("客户端已经运行write函数\n");
read(sock_client,&result,4); // 因为是 int 所以最大4个字节
printf("客户端已经运行read函数\n");
printf("计算结果为：%d:",result);
close(sock_client);
return 0;
}
void error_handling(char* message)
{
fputs(message,stderr);
fputc('\n',stderr);
exit(1);
}
在这里插入代码片
下面是服务器端代码
operator_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 calculate(int num_count,int recv_message[],char operator);
int main(int argc, char* argv[]) // main的参数不变，还是这样的，一会赋值服务器的IP地址
{
struct sockaddr_in server_addr,client_addr;
socklen_t client_addr_len;
int server_sock,client_sock;
int result = 0,num_count = 0;
int recv_len,temp_recv;
char recv_message[BUF_SIZE];
if(argc != 2){ // 除了程序名还有1个参数
printf("Usage: %s <port>\n", argv[0]);
exit(1);
}
//声明变量不说了，一会在上面用一个声明一个
// 1. 创建服务器端的套接字 并初始化地址结构体其中的地址信息
server_sock = socket(PF_INET,SOCK_STREAM,0);
if(server_sock == -1){
error_handling("socket() error!");
}
memset(&server_addr,0,sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(atoi(argv[1]));
// 2. 用bind给创建好的server_sock分配一下地址信息
if(bind(server_sock,(struct sockaddr*)&server_addr,sizeof(server_addr)) == -1){
error_handling("bind() error");
}
// 3. 三步走最后一步 listen
if(listen(server_sock,5) == -1){
error_handling("listen() error ");
}
printf("init ok\n");
// 4. 开始正式接收啦~ 一共有5个机会哦
for(int i = 0; i < 5; i++){
client_sock = accept(server_sock,(struct sockaddr*)&client_addr,&client_addr_len);
read(client_sock,&num_count,1); // 接收 一个字符的 计算的个数
// 接下来接收 计算的数字（为了防止缓冲区爆炸，我们用while循环来接收我们想要的字节数）
recv_len = 0;
while(recv_len < (num_count*4 + 1)) // 4*数字个数+1个计算字符
{
temp_recv = read(client_sock,&recv_message[recv_len],BUF_SIZE -1);
recv_len += temp_recv;
}
// 读取结束，开始计算
result = calculate(num_count,(int*)recv_message,recv_message[recv_len-1]);
// 计算结束，传送结果给客户端
write(client_sock,(char*)&result,sizeof(result));
close(client_sock);
}
close(server_sock);
return 0;
}
int calculate(int num_count,int recv_message[],char operator)
{
int result = 0;
switch(operator)
{
case '+':
for(int i = 0; i < num_count;i++){
result += recv_message[i];
}
break;
case '-':
for(int i = 0; i < num_count;i++){
result -= recv_message[i];
}
break;
case '*':
for(int i = 0; i < num_count;i++){
result *= recv_message[i];
}
break;
}
return result;
}
void error_handling(char* message)
{
fputs(message,stderr);
fputc('\n',stderr);
exit(1);
}
在这里插入代码片
TCP原理：
5.2.1 TCP套接字中的I/O缓冲
TCP套接字的数据收发无边界，也就是说，服务器调用一次write函数传输了 2个字节，客户端可以分两次调用read函数，每次读一个，也可以一次把两个都读了。
如果每次只读部分数据，那剩下的数据去哪里了呢？
实际上，write函数调用之后并非立即传输数据，read函数调用。实际情况如下图所示：
调用write函数时，数据将移到输出缓冲中，在适当时候（不管是分别传送还是一次性传送）传向对方的输入缓冲。
这时对方将调用read函数从输入缓冲读取数据。
I/O缓冲特性如下
- I/O缓冲在每个TCP套接字中单独存在。
- I/O缓冲在创建套接字时自动生成。
- 即使关闭套接字 也会继续传输 输出缓冲中遗留的数据。（能够继续往外传）
- 关闭套接字将丢失输入缓冲中的数据。（不能继续接收数据）
这里提出一个问题？
“客户端当前的空闲输入缓冲为50字节，而服务器传输了100字节怎么办？”
其实这是一个伪命题，在TCP中这是不会出现的，因为TCP会控制数据流。通过TCP中的滑动窗口协议，其内容类似下面的对话内容：
套接字A；“你好，最多可以向我传输50字节的内容”
套接字A；“好的”
套接字A；“您好，我腾出了20个字节的空间，现在最多可以接收70个字节”
套接字A；“好的”
既然write函数会把数据传输到输出缓存中去，那write函数执行结束返回时代表着什么呢？
其实，write 和 win下的 send函数不会在完成向对方主机的数据传输时返回，而是在将数据移到输出缓冲时返回。
TCP会保证输出缓冲数据的传输。
5.2.2 TCP内部工作原理1：与对方套接字的连接（包含传说中的三次握手）
TCP套接字从创建到消失的过程分为下面3步：
与对方套接字建立连接
与对方套接字进行数据交换
断开与对方套接字的连接
第一步：与对方套接字建立连接即三次握手 五颗星!!!
套接字是以全双工（Full-duplex）方式工作的，可以双向传递数据。
三次握手的过程：
三次握手：
第一次握手：
建立连接时，客户端发送SYN包到服务器，该报序列号seq假设为x,客户端进入SYN_SEND状态；
第二次握手：
服务器收到客户端发送来的SYN包，确认其SYN标志为1，确定服务器端申请建立连接，于是服务器端将标志位SYN,ACK都置1，ack为x+1,随机产生序列号seq=y,并将该数据包发送给客户端，已确认连接请求。
第三次握手
客户端收到SYN+ACK包后，检验其是否正确，如正确，则向服务器端发送ACK，值为y+1,服务器端接收到ACK数据包，确认正确则连接建立成功，客户端和服务器端进入ESTABLISHED状态，完成三次握手。
【SYN】seq：1000，ACK：- （对应shake1）
上方含义：“当前传递数据包序号为1000，如果接受无误，请通知我发送1001号数据包”
【SYN+ACK】seq：2000，ACK：1001 （对应shake2）
上方含义：“当前传递数据包序号2000，如果接受无误，请通知我发送2001号数据包；
你发送的1000号数据包已收到，请传递SEQ为1001的数据包”
【ACK】seq：1001，ACK：2001 （对应shake3）
上方含义：“当前传递数据包序号1001，如果接受无误，请通知我发送1002号数据包
你发送的2000号数据包已经接受，请传递2001号数据包”
注意：
SYN，ACK是标志位。
seq，AN是数据包序号。
Server第二次握手将ACK置1，且进行资源分配，
client第三次握手将ACK置1，并进行资源分配。
5.2.3 TCP内部工作原理2：与对方主机的数据交换(第二步）
第一步的三次握手完成了数据交换的准备，接下来开始交换数据
TCP套接字的数据交换过程：
上图是主机A分两次两个数据包向主机B传递200字节的数据：
seq：1200
上方含义：“当前传递数据包序号为1200，里面包含100 byte data ，如果接受无误，请通知我发送1301号数据包”
ACK：1301
上方含义：“ 你发送的数据包已收到，请传递seq为1301的数据包”
seq：1301
上方含义：“当前传递数据包序号1301，里面包含100字节的数据，如果接受无误，请通知我发送1402号数据包”
ACK：1402
上方含义：“你发送数据包已收到，请传递seq为1402的数据包”
从上面的过程可看出 序号并不是连贯的，而是增加了字节数大小的序号。
即 ACK号 = seq号 + 传递的字节数 + 1
上方是传递正常时的情况。下面看一下如果传递过程中数据包消失的情况。丢包
上图是超时重传 的过程：
图中通过seq 1301数据包向主机B传递100字节数据，但是中间发生了错误。主机B未收到。
超过一段时间后，主机A仍为接收到seq 1301 的ACK确认，因此试着重传该数据包。
为了完成数据包重传，TCP套接字启动计数器以等待ACK应答，若相应计时器发生超时（Time-out）则重传。
5.2.4 断开与套接字的连接即四次挥手 五颗星！！！！！！！！！！
可以简单的理解为：
套接字A：我希望断开连接~
套接字B：好的，请稍后
套接字B：我已经准备就绪，可以断开
套接字A：好的，收到。
FIN表示断开连接。也就是说双方各发一次FIN消息后断开连接
**【FIN】**seq：5000，ACK：- （对应shake1）
上方含义：“当前传递数据包序号为5000，我请求断开连接！如果接受无误，请通知我发送5001号数据包”
【ACK】seq：7500，ACK：5001 （对应shake2）
上方含义：“当前传递数据包序号7500，如果接受无误，请通知我发送7501号数据包；
你发送的断开请求已收到，请稍等，下次请传递SEQ为5001的数据包”
**【FIN】**seq：7501，ACK：5001 （对应shake3）
上方含义：“当前传递数据包序号为7501，如果接受无误，请通知我发送7502号数据包
ok 我已经准备好了，下次可以传递SEQ为 5001 的数据包”
【ACK】seq：5001，ACK：7502 （对应shake4）
上方含义：“当前传递数据包序号5001，如果接受无误，请通知我发送5002号数据包
你发送的7501号数据包已经接受”
有个问题：为什么B给A发了两次一帮的东西，其实，第二次FIN数据包中的ACK 5001只是因为接受ACK消息后未接受数据重传的。
1-客户端进程发出连接释放报文，并停止发送数据。释放数据报文首部，FIN=1，其序列号Seq=u;
2-服务端收到连接释放报文，发出确认报文ACK=1,ack=u+1,并带上自己的序列号seq=v；
此时服务器进入了CLOSE_WAIT状态，客户端向服务器端的方向就释放了，这时候处于半关闭状态，即客户端没有数据要发送了，但服务端若还要发送数据，客户端仍然接受。这个状态持续一段时间，也就是整个CLOSE_WAIT状态持续的时间。
3-客户端收到服务器端的确认请求后，此时客户端进入**FIN_WAIT_2（终止等待2）**状态，等待服务器端发送连接释放报文。
服务器将最后的数据发送完毕后，就会发送连接释放报文，FIN=1，ack=u+1,由于半关闭状态，服务器可能又发送了一些数据，假定此时序列号为seq=w,此时，服务器进入了LAST_ACK状态，等待客户端确认。
4-客户端收到连接释放报文后，必须发出确认，ACK=1,ack=w+1,而自己的序列号是seq=u+1,此时，客户端就进入time_wait状态，此时TCP连接还没有释放，经过2MSL（报文最大生存时间后），当客户端撤销相应的TCB后才进入CLOSED状态。
服务器端只有收到了客户端发送的确认，立即进入CLOSED状态，同样撤销TCB后，就结束TCP连接。被动关闭的一方结束TCP连接的时间要比客户端早一些。
补充面试相关
TCP报文段几个重要的字段含义：
确认位 ACK：只有当 ACK = 1 时，确认号字段才有效。TCP 规定，在连接建立后所有传送的报文段都必须把 ACK 置为 1。
同步位 SYN：SYN = 1表示这是一个连接请求或连接接收报文。
终止位 FIN：用来释放一个连接。FIN = 1 表明此报文段的发送方的数据已经发送完毕，并要求释放传输连接。
（同步位SYN /初始序号seq/连接确认ACK/确认号ack/终止控制位FIN）
(1) 为什么四次挥手发送最后一次报文后要等待 2MSL（报文最大生存时间）的时间？【重点】
- 为了保证 A 发送的最后一个确认报文段能够到达 B。如果 A 不等待 2MSL，若当A发送的最后确认报文段丢失，则B不会进入正常关闭状态，因为 A 此时已经关闭，不可能再收到B的重传报文了。
- 防止出现 “已失效的连接请求报文段延误到达的现象”。A 在发送完最后一个确认报文段后，再经过 2MSL 可保证在连接持续的时间内所产生的所有报文段从网络中消失。
(2) TCP 使用的是 GBN（后退N帧协议）还是 SR（选择重传协议）？
因为 TCP 使用累计确认，看起来像是 GBN。但是，正确收到但失序的报文并不会被丢弃，而是缓存起来，并且发送冗余 ACK 指明希望收到的下一个报文段，这是 TCP 方式和 GBN 的显著区别。因此，TCP 的差错恢复机制可以看成是 GBN 和 SR 协议的混合体。
(3) 为什么超时时间发生时 cwnd 被置为 1，而收到 3 个冗余 ACK 时 cwnd 只是减半？
答：首先应分析哪种情况的网络拥塞程度更严重。其实不难发现，在收到 3 个冗余 ACK 的情况下，网络虽然拥塞，但至少 ACK 报文段能够被正确交付。而当超时发生时，说明网络可能已经拥塞的连 ACK 报文段都传输不了了，发送方只能等待超时后重传数据。因此，超时时间发生时，网络拥塞更严重，所以发送方应该最大限度地抑制数据发送量，所以 cwnd 置为 1；收到 3 个冗余 ACK 时，网络拥塞相对而言不是很严重，所以 cwnd 减半即可。
4) 为什么不采用 “两次握手” 建立连接？【重点】
答：这主要是为了防止两次握手情况下已失效的连接请求报文段突然又传送到服务端，而产生了错误。考虑以下情况：客户 A 向服务器 B 发送 TCP 连接请求，第一个连接请求报文在网络的某个结点长时间滞留，A 超时后认为报文丢失，于是再重传一次连接请求，B 收到后建立连接。数据传输完毕后双方断开连接。此时，前一个滞留在网络中的连接请求到达了服务端 B，若采用的是 “两次握手”，则这种情况下 B 认为传输连接已经建立，并一直等待 A 传输数据，而 A 此时并无连接请求，因此不予理睬，这样就造成了 B 的资源白白浪费了。
(5) 是否 TCP 和 UDP 都需要计算往返时间 RTT？
答：往返时间 RTT 只是针对传输层 TCP 协议才很重要，因为 TCP 要根据 RTT 的值来设置超时计时器的超时时间。UDP 没有确认和重传机制，因此 RTT 对 UDP 没有什么意义。
(6) 为什么 TCP 在建立连接的时候不能每次选择相同的、固定的初始序号？
答：1) 假如 A 和 B 频繁地建立连接，传送一些 TCP 报文段后再释放连接，然后又不断的建立新的连接、传送报文段和释放连接。
2) 假如每一次建立连接时，主机 A 都选择相同的、固定的初始序号，如 1。
3) 若主机 A 发送出的某些 TCP 报文段在网络中会滞留较长的时间，以致造成主机 A 超时重传这些 TCP 报文段。
4) 若有一些在网络中滞留时间较长的 TCP 报文段最后终于到达了主机 B，但这时传送该报文段的那个连接早已释放了，而在到达主机 B 时的 TCP 连接是一条新的 TCP 连接。
以上这些情况可能会导致在新的 TCP 连接中的主机 B 有可能会接收在旧的连接传送的、已经没有意义的、过时的 TCP 报文段（因为这个 TCP 报文段的序号有可能正好处于新的连接所使用的序号范围内）。因为必须使得迟到的 TCP 报文段的序号不在新的连接中使用的序号范围内。所以，TCP 在建立新的连接时所选择的初始序号一定要和前面的一些连接所使用过的序号不一样。因此，不同的 TCP 连接不能使用相同的初始序号。
(7) 在使用 TCP 传输数据时，如果有一个确认报文段丢失了，也不一定会引起与该确认报文段对应的数据的重传。试说明理由。
答：这是因为发送方可能还未重传时，就收到了更高序号的确认。例如主机 A 连续发送两个报文段，均正确到达主机 B。B 连续发送两个确认 ACK1 和 ACK2（ACK2 的序号比 ACK1 的序号高）。但前一个确认帧在传输时丢失了。若在超时前，ACK2 被 A 接收，更高的序号代表该序号之前的所有字节都被接收了，所以 A 知道前一个报文也被正确的接收了，这种情况下 A 不会重传第一个报文段。
7090
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
