一、TCP/IP协议栈
为什么需要理解协议栈？
学习C/C++就是要懂底层的原理。不然永远是“调包侠”
根据数据传输方式的不同，基于网络协议（这里是指基于TCP/IP协议）的套接字一般分为TCP 套接字和UDP 套接字。因为TCP 套接字是面向连接的，因此又称基于流（stream）的套接字。 TCP 是TransmissionControl Protocol（传输控制协议）的简写，意为"对数据传输过程的控制"。
第一层次：数据链路层
如图所示：链路层是物理链接领域标准化的结果，也是最基本的领域，专门定义LAN、WAN、MAN 等网络标准。若两台主机通过网络进行数据交换，则需要下图所示的物理连接，
链路层就负责这些标准。
第二层次：IP 层
准备好物理连接后就要传输数据。为了在复杂的网络中传输数据，首先需要考虑路径的
选择。向目标传输数据需要经过哪条路径?解决此问题就是IP 层，该层使用的协议就是IP。
IP 是面向消息的、不可靠的协议。每次传输数据时会帮我们选择路径，但并不一致。如
果传输中发生路径错误，则选择其他路径;但如果发生数据丢失或错误，则无法解决。换言
之，IP 协议是无法应对数据错误的。因此，又要下放一层。
第三层次：TCP/UDP 层
IP 层解决数据传输中的路径选择问题，只需照此路径传输数据即可。TCP 和UDP 层以
IP 层提供的路径信息为基础完成实际的数据传输，故该层又称传输层（Transport）。
IP 层只关注1 个数据包（数据传输的基本单位）的传输过程。因此，即使传输多个数据
包，每个数据包也是由IP 层实际传输的，也就是说传输顺序及传输本身是不可靠的。若只
利用IP 层传输数据，则有可能导致后传输的数据包B 比先传输的数据包A 提早到达。另外，
传输的数据包A、B、C 中有可能只收到A 和C，甚至收到的C 可能已损毁。
若添加TCP 协议则按照下图的对话方式进行数据交换。
第四层次：应用层
前面三个层次，套接字通信过程中都是自动处理的。为了"使程序员从这些细节中解放
出来"。选择数据传输路径、数据确认过程都被隐藏到套接字内部。前面三个层次都是为了
给应用层提供服务的。
二、TCP服务端和代码实现
服务的创建的基本流程（最简单的）
void run_client()
{int client = socket(PF_INET, SOCK_STREAM, 0);struct sockaddr_in servaddr;memset(&servaddr, 0, sizeof(servaddr)); //清零 防止意外servaddr.sin_family = AF_INET;servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");servaddr.sin_port = htons(33005);int ret = connect(client, (struct sockaddr*)&servaddr, sizeof(servaddr));if (ret == 0) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);char buffer[1024] = "hello , here is client\n";write(client, buffer, strlen(buffer));memset(buffer, 0, sizeof(buffer));read(client, buffer, sizeof(buffer));std::cout << buffer;}else {printf("%s(%d):%s %d\r\n", __FILE__, __LINE__, __FUNCTION__, ret);}close(client);std::cout << "client done!" << std::endl;
}
void lession63_() {int server, client;struct sockaddr_in seraddr, cliaddr; //服务端和客户端的地址结构体socklen_t cliaddrlen;//客户端的地址结构体大小//const char* message = "hello world!\n";//1.创建服务器套接字printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);server = socket(PF_INET, SOCK_STREAM, 0);//TCP协议 什么是TCP，就是IPv4中面向了流的套接字if (server < 0) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);std::cout << "create socket failed!" << std::endl;return;}//2.绑定服务器套接字和地址结构体// 设置SO_REUSEADDR选项，允许端口复用memset(&seraddr, 0, sizeof(seraddr));//清零seraddr.sin_family = AF_INET; //地址协议族seraddr.sin_addr.s_addr = inet_addr("127.0.0.1");seraddr.sin_port = htons(33005);printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);int on = 1;if (setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {perror("setsockopt");close(server);return;}printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);int ret = bind(server, (struct sockaddr*)&seraddr, sizeof(seraddr));printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);if (ret == -1) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);std::cout << "bind failed!" << std::endl;close(server);return;}ret = listen(server, 3);if (ret == -1) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);std::cout << "listen failed!" << std::endl;close(server);return;}char buffer[1024];while (1) {memset(buffer, 0, sizeof(buffer));printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);cliaddrlen = sizeof(cliaddr);client = accept(server, (struct sockaddr*)&cliaddr, &cliaddrlen/*&cliaddrlen*/);if (client == -1) {std::cout << "accept failed!" << std::endl;close(server);return;}//printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);read(client, buffer, sizeof(buffer));ssize_t len = write(client, buffer, strlen(buffer)); //返回值就是实际写入的字节数if (len != (ssize_t)strlen(buffer)) {std::cout << "write failed!" << std::endl;close(server);return;}printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);close(client);}close(server);printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);}
void lession63()
{pid_t pid = fork();if (pid == 0) {//开启客户端sleep(2);//让服务端先启动 run_client();run_client();}else if (pid > 0) {//开启服务端printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);lession63_();int status = 0;wait(&status);//避免子进程成为僵尸进程}else {std::cout << "fork failed!" << pid << std::endl;}
}
三、connect函数和TCP客户端
connect函数：
#include<sys/socket.h>
int connect(int sock,struct sockaddr*servaddr, socklen_t addrlen);
→成功时返回0，失败时返回-1。
● sock 客户端套接字文件描述符。
● servaddr 保存目标服务器端地址信息的变量地址值。
●addrlen 以字节为单位传递已传递给第二个结构体参数servaddr 的地址变量长度。
客户端套接字地址信息在哪？
实现服务器端必经过程之一就是给套接字分配IP 和端口号。但客户端实现过程中并未出现
套接字地址分配，而是创建套接字后立即调用conect 函数。难道客户端套接字无需分配IP
和端口?
答案：当然不是!
网络数据交换必须分配IP 和端口。既然如此，那客户端套接字何时、何地、如何分配
地址呢?
.何时? 调用connect 函数时。
.何地? 操作系统，更准确地说是在内核中。
.如何? IP 用计算机（主机）的IP，端口随机。
客户端的IP 地址和端口在调用connect 函数时自动分配，无需调用标记的bind 函数进
行分配。
这就是与服务端的不同。
TCP客户端
四、客户端代码实现和联调
基于TCP服务端/客户端的函数调用关系
五、迭代服务器
前面的普通服务器TCP 的缺点：一次服务。只能给一个客户端服务。
迭代服务器比较原始，它的原型可以描述成：
这个改动就是，当处理完一个客户端后，会再次进入accept，等待连接。
也就是说，这个程序是一个一个处理各个客户端发来的连接的，比如一个客户端发来一个
连接，那么只要它还没有完成自己的任务，那么它就一直会占用服务器的进程直到处理完毕
后服务器关闭掉这个socket。可以循环服务多个客户端。
六、回声服务器实现
回声服务器：将从客户端收到的数据原样返回给客户端，即“回声”。
void run_client65()
{int client = socket(PF_INET, SOCK_STREAM, 0);struct sockaddr_in servaddr;memset(&servaddr, 0, sizeof(servaddr)); //清零 防止意外servaddr.sin_family = AF_INET;servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");servaddr.sin_port = htons(33005);int ret = connect(client, (struct sockaddr*)&servaddr, sizeof(servaddr));while (ret == 0) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);char buffer[256] = "";fputs("input message(Q to quit):", stdout);//输出提示符fgets(buffer, sizeof(buffer), stdin/*标准输入流*/);//读入一行if ((strcmp(buffer, "Q\n") == 0) || (strcmp(buffer, "q\n") == 0)) {break;}size_t len = strlen(buffer);size_t send_len = 0;while (send_len < len); {ssize_t ret = write(client, buffer + send_len, len - send_len);//发给服务器if (ret <= 0){fputs("write failed!\n", stdout);close(client);std::cout << "client done!" << std::endl;return;}send_len += (size_t)ret;}memset(buffer, 0, sizeof(buffer));size_t read_len = 0;while (read_len < len){ssize_t ret = read(client, buffer + read_len, len - read_len);if (ret <= 0){fputs("read failed!\n", stdout);close(client);std::cout << "client done!" << std::endl;return;}send_len += (size_t)ret;}std::cout << "from server:" << buffer;}close(client);std::cout << "client done!" << std::endl;
}
void server65() {int server, client;struct sockaddr_in seraddr, cliaddr; //服务端和客户端的地址结构体socklen_t cliaddrlen;//客户端的地址结构体大小//1.创建服务器套接字printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);server = socket(PF_INET, SOCK_STREAM, 0);//TCP协议 什么是TCP，就是IPv4中面向了流的套接字if (server < 0) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);std::cout << "create socket failed!" << std::endl;return;}//2.绑定服务器套接字和地址结构体memset(&seraddr, 0, sizeof(seraddr));//清零seraddr.sin_family = AF_INET; //地址协议族seraddr.sin_addr.s_addr = inet_addr("127.0.0.1");seraddr.sin_port = htons(33005);//printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);int on = 1;if (setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {perror("setsockopt");close(server);return;}//printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);int ret = bind(server, (struct sockaddr*)&seraddr, sizeof(seraddr));printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);if (ret == -1) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);std::cout << "bind failed!" << std::endl;close(server);return;}ret = listen(server, 3);if (ret == -1) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);std::cout << "listen failed!" << std::endl;close(server);return;}char buffer[1024];for (int i = 0; i < 2; i++) {memset(buffer, 0, sizeof(buffer));printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);cliaddrlen = sizeof(cliaddr);client = accept(server, (struct sockaddr*)&cliaddr, &cliaddrlen/*&cliaddrlen*/);if (client == -1) {std::cout << "accept failed!" << std::endl;close(server);return;}printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);//ssize_t len=read(client, buffer, sizeof(buffer));ssize_t len = 0;while ((len = read(client, buffer, sizeof(buffer))) > 0) {len = write(client, buffer, len); //返回值就是实际写入的字节数if (len != (ssize_t)strlen(buffer)) {std::cout << "write failed! len:" << len << " buffer:" << buffer << std::endl;close(server);return;}memset(buffer, 0, len);}printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);close(client);}close(server);printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
}
void lession65()
{pid_t pid = fork();if (pid == 0) { //子进程//开启服务端server65();}else if (pid > 0) {for (int i = 0; i < 2; i++)run_client65();int status = 0;wait(&status);//避免子进程成为僵尸进程}else {std::cout << "fork failed!" << pid << std::endl;}
}
七、回声服务器存在的问题和解决
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 个字符串，因此这种假设在某种程度上也算合理。
但是我们之前讲过："TCP 不存在数据边界"的内容吗?
上述客户端是基于TCP 的，因此，多次调用write 函数传递的字符串有可能一次性传递
到服务器端。此时客户端有可能从服务器端收到多个字符串，这不是我们希望看到的结果。
还需考虑服务器端的如下情况∶
"字符串太长，需要分2 个数据包发送!"
我们的回声服务器端/客户端给出的结果是正确的。但这只是运气好罢了!只是因为收发
的数据小，而且运行环境为同一台计算机或相邻的两台计算机，所以没发生错误，可实际上
仍存在发生错误的可能。
八、回声服务器实战：计算器的网络实现（上）
这里进行客户端的实现：
void run_client66()
{int client = socket(PF_INET, SOCK_STREAM, 0);struct sockaddr_in servaddr;memset(&servaddr, 0, sizeof(servaddr)); //清零 防止意外servaddr.sin_family = AF_INET;servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");servaddr.sin_port = htons(33005);int ret = connect(client, (struct sockaddr*)&servaddr, sizeof(servaddr));char buffer[255 * 4] = "";while (ret == 0) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);fputs("Operand count:", stdout);//输出提示符int opnd_cnt = 0;scanf("%d", &opnd_cnt);if (opnd_cnt <= 1 && opnd_cnt >= 256) {fputs("opnd_cnt error,too small or too big!\n", stdout);close(client);std::cout << "client done!" << opnd_cnt << std::endl;return;}buffer[0] = (char)opnd_cnt; //服务器此处需要解释为无符号for (int i = 0; i < opnd_cnt; i++) {scanf("%d", buffer + 1 + i * 4);}fgetc(stdin);printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);fputs("Operator:", stdout);buffer[1 + opnd_cnt * 4] = (char)fgetc(stdin);//buffer[1 + opnd_cnt * 4] = (char)fgetc(stdin);//fgetc(stdin); // 清除换行符printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);size_t len = opnd_cnt * 4 + 2;size_t send_len = 0;printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);while (send_len < len) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);ssize_t ret = write(client, buffer + send_len, len - send_len);//发给服务器if (ret <= 0){fputs("write failed!\n", stdout);close(client);std::cout << "client done!" << std::endl;return;}send_len += (size_t)ret;}memset(buffer, 0, sizeof(buffer));printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);size_t read_len = 0;while (read_len < 4){printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);ssize_t ret = read(client, buffer + read_len, len - read_len);if (ret <= 0){fputs("read failed!\n", stdout);close(client);std::cout << "client done!" << std::endl;return;}read_len += (size_t)ret;}printf("from server:%d\n", *(int*)buffer);}close(client);std::cout << "client done!" << std::endl;
}
九、回声服务器实战：计算器的网络实现（下）
这里实现服务端：（包含计算函数和主函数）
int calculate(int count, int oprand[], char op) {int result = 0;switch (op) {case '+':for (int i = 0; i < count; i++) {result += oprand[i];}break;case '-':result = oprand[0];for (int i = 1; i < count; i++) {result -= oprand[i];}break;case '*':result = oprand[0];for (int i = 1; i < count; i++) {result *= oprand[i];}break;default:break;}return result;
}
void server66() {int server, client;struct sockaddr_in seraddr, cliaddr; //服务端和客户端的地址结构体socklen_t cliaddrlen;//客户端的地址结构体大小//1.创建服务器套接字printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);server = socket(PF_INET, SOCK_STREAM, 0);//TCP协议 什么是TCP，就是IPv4中面向了流的套接字if (server < 0) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);std::cout << "create socket failed!" << std::endl;return;}//2.绑定服务器套接字和地址结构体memset(&seraddr, 0, sizeof(seraddr));//清零seraddr.sin_family = AF_INET; //地址协议族seraddr.sin_addr.s_addr = inet_addr("127.0.0.1");seraddr.sin_port = htons(33005);//printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);int on = 1;if (setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {perror("setsockopt");close(server);return;}//printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);int ret = bind(server, (struct sockaddr*)&seraddr, sizeof(seraddr));printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);if (ret == -1) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);std::cout << "bind failed!" << std::endl;close(server);return;}ret = listen(server, 3);if (ret == -1) {printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);std::cout << "listen failed!" << std::endl;close(server);return;}char buffer[1024];for (int i = 0; i < 2; i++) {memset(buffer, 0, sizeof(buffer));printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);cliaddrlen = sizeof(cliaddr);client = accept(server, (struct sockaddr*)&cliaddr, &cliaddrlen/*&cliaddrlen*/);if (client == -1) {std::cout << "accept failed!" << std::endl;close(server);return;}//printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);//ssize_t len=read(client, buffer, sizeof(buffer));ssize_t len = 0;len = read(client, buffer, 1);int result;if (len > 0) {for (unsigned int i = 0; i < ((unsigned)buffer[0] & 0xFF); i++) {read(client, buffer + 1 + i * 4, 4);}read(client, buffer + 1 + ((unsigned)buffer[0] & 0xFF) * 4, 1);result = calculate((int)buffer[0] & 0xFF, (int*)(buffer + 1), buffer[1 + ((unsigned)buffer[0] & 0xFF) * 4]);write(client, &result, 4);std::cout << "result" << result << std::endl;}while ((len = read(client, buffer, sizeof(buffer))) > 0) {len = write(client, buffer, len); //返回值就是实际写入的字节数if (len != (ssize_t)strlen(buffer)) {std::cout << "write failed! len:" << len << " buffer:" << buffer << std::endl;close(server);return;}memset(buffer, 0, len);}printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);read(client, buffer, 1);close(client);}close(server);printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
}
void lession66()
{pid_t pid = fork();if (pid == 0) { //子进程//开启服务端server66();}else if (pid > 0) {for (int i = 0; i < 2; i++)run_client66();int status = 0;wait(&status);//避免子进程成为僵尸进程}else {std::cout << "fork failed!" << pid << std::endl;}
}
十、TCP套接字的IO缓冲
我们知道，TCP 套接字的数据收发无边界。服务器端即使调用1 次write 函数传输40 字
节的数据，客户端也有可能通过4 次read 函数调用每次读取10 字节。但此处也有一些疑问，
服务器端一次性传输了40 字节，而客户端居然可以缓慢地分批接收。客户端接收10 字节后，
剩下的30 字节在何处等候呢?是不是像飞机为等待着陆而在空中盘旋一样，剩下30 字节也
在网络中徘徊并等待接收呢?
实际上，write 函数调用后并非立即传输数据，read 函数调用后也并非马上接收数据。
更准确地说，如下图所示，write 函数调用瞬间，数据将移至输出缓冲;read 函数调用瞬间，
从输人缓冲读取数据。
调用write 函数时，数据将移到输出缓冲，在适当的时候（不管是分别传送还是一次性
传送）传向对方的输入缓冲。这时对方将调用read 函数从输入缓冲读取数据。这些I/O 缓
冲特性可整理如下。
A: I/O 缓冲在每个TCP 套接字中单独存在。
B: I/O 缓冲在创建套接字时自动生成。
C: 即使关闭套接字也会继续传递输出缓冲中遗留的数据。
D: 关闭套接字将丢失输入缓冲中的数据。
那么，下面这种情况会引发什么事情?理解了I/O 缓冲后，其流程∶
"客户端输入缓冲为50 字节，而服务器端传输了100 字节。"
这的确是个问题。输入缓冲只有50 字节，却收到了100 字节的数据。可以提出如下解决方
案∶
填满输入缓冲前迅速调用read 函数读取数据，这样会腾出一部分空间，问题就解决了。
其实根本不会发生这类问题，因为TCP 会控制数据流。
TCP 中有滑动窗口（Sliding Window）协议，用对话方式呈现如下。
套接字A∶"你好，最多可以向我传递50 字节。"
套接字B∶"OK!"
套接字A∶"我腾出了20 字节的空间，最多可以收70 字节。
套接字B∶"OK!"
数据收发也是如此，因此TCP 中不会因为缓冲溢出而丢失数据。