# issue 7 TCP回声服务器和客户端

一、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服务端和代码实现

服务的创建的基本流程（最简单的）

1. void run_client()
2. {
3.         int client = socket(PF_INET, SOCK_STREAM, 0);
4.         struct sockaddr_in servaddr;
5.         memset(&servaddr, 0, sizeof(servaddr)); //清零 防止意外
6.         servaddr.sin_family = AF_INET;
7.         servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
9.         servaddr.sin_port = htons(33005);
10.         int ret = connect(client, (struct sockaddr*)&servaddr, sizeof(servaddr));
11.         if (ret == 0) {
12.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
13.                 char buffer[1024] = "hello , here is client\n";
14.                 write(client, buffer, strlen(buffer));
15.                 memset(buffer, 0, sizeof(buffer));
16.                 read(client, buffer, sizeof(buffer));
17.                 std::cout << buffer;
18.         }
19.         else {
20.                 printf("%s(%d):%s       %d\r\n", __FILE__, __LINE__, __FUNCTION__, ret);
21.         }
22.         close(client);
23.         std::cout << "client done!" << std::endl;
24. }
25. void lession63_() {
26.         int server, client;
27.         struct sockaddr_in seraddr, cliaddr; //服务端和客户端的地址结构体
28.         socklen_t cliaddrlen;//客户端的地址结构体大小
29.         //const char* message = "hello world!\n";
31.         //1.创建服务器套接字
32.         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
33.         server = socket(PF_INET, SOCK_STREAM, 0);//TCP协议  什么是TCP，就是IPv4中面向了流的套接字
34.         if (server < 0) {
35.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
36.                 std::cout << "create socket failed!" << std::endl;
37.                 return;
38.         }
40.         //2.绑定服务器套接字和地址结构体
42.         // 设置SO_REUSEADDR选项，允许端口复用
46.         memset(&seraddr, 0, sizeof(seraddr));//清零
47.         seraddr.sin_family = AF_INET;        //地址协议族
48.         seraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
49.         seraddr.sin_port = htons(33005);
54.         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
55.         int on = 1;
56.         if (setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
57.                 perror("setsockopt");
58.                 close(server);
59.                 return;
60.         }
61.         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
63.         int ret = bind(server, (struct sockaddr*)&seraddr, sizeof(seraddr));
64.         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
65.         if (ret == -1) {
66.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
67.                 std::cout << "bind failed!" << std::endl;
68.                 close(server);
69.                 return;
70.         }
71.         ret = listen(server, 3);
72.         if (ret == -1) {
73.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
74.                 std::cout << "listen failed!" << std::endl;
75.                 close(server);
76.                 return;
77.         }
78.         char buffer[1024];
79.         while (1) {
80.                 memset(buffer, 0, sizeof(buffer));
81.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
82.                 cliaddrlen = sizeof(cliaddr);
83.                 client = accept(server, (struct sockaddr*)&cliaddr, &cliaddrlen/*&cliaddrlen*/);
84.                 if (client == -1) {
85.                         std::cout << "accept failed!" << std::endl;
86.                         close(server);
87.                         return;
88.                 }
89.                 //printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
90.                 read(client, buffer, sizeof(buffer));
91.                 ssize_t len = write(client, buffer, strlen(buffer)); //返回值就是实际写入的字节数
92.                 if (len != (ssize_t)strlen(buffer)) {
93.                         std::cout << "write failed!" << std::endl;
94.                         close(server);
95.                         return;
96.                 }
97.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
98.                 close(client);
99.         }
100.         close(server);
101.         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
103. }
104. void lession63()
105. {
106.         pid_t pid = fork();
107.         if (pid == 0) {
108.                 //开启客户端
109.                 sleep(2);//让服务端先启动       
110.                 run_client();
111.                 run_client();
112.         }
113.         else if (pid > 0) {
114.                 //开启服务端
115.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
116.                 lession63_();
117.                 int status = 0;
118.                 wait(&status);//避免子进程成为僵尸进程
119.         }
120.         else {
121.                 std::cout << "fork failed!" << pid << std::endl;
122.         }
123. }

复制代码

三、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。可以循环服务多个客户端。
六、回声服务器实现

        回声服务器：将从客户端收到的数据原样返回给客户端，即“回声”。

1. void run_client65()
2. {
3.         int client = socket(PF_INET, SOCK_STREAM, 0);
4.         struct sockaddr_in servaddr;
5.         memset(&servaddr, 0, sizeof(servaddr)); //清零 防止意外
6.         servaddr.sin_family = AF_INET;
7.         servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
9.         servaddr.sin_port = htons(33005);
10.         int ret = connect(client, (struct sockaddr*)&servaddr, sizeof(servaddr));
11.         while (ret == 0) {
12.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
13.                 char buffer[256] = "";
15.                 fputs("input message(Q to quit):", stdout);//输出提示符
16.                 fgets(buffer, sizeof(buffer), stdin/*标准输入流*/);//读入一行
17.                 if ((strcmp(buffer, "Q\n") == 0) || (strcmp(buffer, "q\n") == 0)) {
18.                         break;
19.                 }
21.                 size_t len = strlen(buffer);
22.                 size_t send_len = 0;
23.                 while (send_len < len); {
24.                         ssize_t ret = write(client, buffer + send_len, len - send_len);//发给服务器
25.                         if (ret <= 0)
26.                         {
27.                                 fputs("write failed!\n", stdout);
28.                                 close(client);
29.                                 std::cout << "client done!" << std::endl;
30.                                 return;
31.                         }
32.                         send_len += (size_t)ret;
33.                 }
34.                 memset(buffer, 0, sizeof(buffer));
35.                 size_t read_len = 0;
36.                 while (read_len < len)
37.                 {
38.                         ssize_t ret = read(client, buffer + read_len, len - read_len);
39.                         if (ret <= 0)
40.                         {
41.                                 fputs("read failed!\n", stdout);
42.                                 close(client);
43.                                 std::cout << "client done!" << std::endl;
44.                                 return;
45.                         }
46.                         send_len += (size_t)ret;
47.                 }
49.                 std::cout << "from server:" << buffer;
50.         }
51.         close(client);
52.         std::cout << "client done!" << std::endl;
53. }
54. void server65() {
55.         int server, client;
56.         struct sockaddr_in seraddr, cliaddr; //服务端和客户端的地址结构体
57.         socklen_t cliaddrlen;//客户端的地址结构体大小
59.         //1.创建服务器套接字
60.         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
61.         server = socket(PF_INET, SOCK_STREAM, 0);//TCP协议  什么是TCP，就是IPv4中面向了流的套接字
62.         if (server < 0) {
63.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
64.                 std::cout << "create socket failed!" << std::endl;
65.                 return;
66.         }
68.         //2.绑定服务器套接字和地址结构体
69.         memset(&seraddr, 0, sizeof(seraddr));//清零
70.         seraddr.sin_family = AF_INET;        //地址协议族
71.         seraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
72.         seraddr.sin_port = htons(33005);
74.         //printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
75.         int on = 1;
76.         if (setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
77.                 perror("setsockopt");
78.                 close(server);
79.                 return;
80.         }
81.         //printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
83.         int ret = bind(server, (struct sockaddr*)&seraddr, sizeof(seraddr));
84.         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
85.         if (ret == -1) {
86.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
87.                 std::cout << "bind failed!" << std::endl;
88.                 close(server);
89.                 return;
90.         }
91.         ret = listen(server, 3);
92.         if (ret == -1) {
93.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
94.                 std::cout << "listen failed!" << std::endl;
95.                 close(server);
96.                 return;
97.         }
98.         char buffer[1024];
99.         for (int i = 0; i < 2; i++) {
100.                 memset(buffer, 0, sizeof(buffer));
101.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
102.                 cliaddrlen = sizeof(cliaddr);
103.                 client = accept(server, (struct sockaddr*)&cliaddr, &cliaddrlen/*&cliaddrlen*/);
104.                 if (client == -1) {
105.                         std::cout << "accept failed!" << std::endl;
106.                         close(server);
107.                         return;
108.                 }
109.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
110.                 //ssize_t len=read(client, buffer, sizeof(buffer));
111.                 ssize_t len = 0;
112.                 while ((len = read(client, buffer, sizeof(buffer))) > 0) {
113.                         len = write(client, buffer, len); //返回值就是实际写入的字节数
114.                         if (len != (ssize_t)strlen(buffer)) {
115.                                 std::cout << "write failed!    len:" << len << "  buffer:" << buffer << std::endl;
116.                                 close(server);
117.                                 return;
118.                         }
119.                         memset(buffer, 0, len);
120.                 }
122.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
123.                 close(client);
124.         }
125.         close(server);
126.         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
127. }
128. void lession65()
129. {
130.         pid_t pid = fork();
131.         if (pid == 0) {   //子进程
132.                 //开启服务端
133.                 server65();
134.         }
135.         else if (pid > 0) {
136.                 for (int i = 0; i < 2; i++)
137.                         run_client65();
138.                 int status = 0;
139.                 wait(&status);//避免子进程成为僵尸进程
140.         }
141.         else {
142.                 std::cout << "fork failed!" << pid << std::endl;
143.         }
144. }

复制代码

七、回声服务器存在的题目和办理

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

复制代码

以上代码有个错误假设∶
"每次调用read、write 函数时都会以字符串为单位执行实际的I/O 操纵（读文件是输入，写文件是输出）。"
        当然，每次调用write 函数都会通报1 个字符串，因此这种假设在某种程度上也算合理。
但是我们之前讲过："TCP 不存在数据边界"的内容吗?
        上述客户端是基于TCP 的，因此，多次调用write 函数通报的字符串有可能一次性通报
到服务器端。此时客户端有可能从服务器端收到多个字符串，这不是我们希望看到的结果。
还需思量服务器端的如下情况∶
"字符串太长，须要分2 个数据包发送!"
        我们的回声服务器端/客户端给出的结果是精确的。但这只是运气好罢了!只是由于收发
的数据小，而且运行情况为同一台计算机或相邻的两台计算机，所以没发生错误，可实际上
仍存在发生错误的可能。
八、回声服务器实战：计算器的网络实现（上）

这里举行客户端的实现：

1. void run_client66()
2. {
3.         int client = socket(PF_INET, SOCK_STREAM, 0);
4.         struct sockaddr_in servaddr;
5.         memset(&servaddr, 0, sizeof(servaddr)); //清零 防止意外
6.         servaddr.sin_family = AF_INET;
7.         servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
9.         servaddr.sin_port = htons(33005);
10.         int ret = connect(client, (struct sockaddr*)&servaddr, sizeof(servaddr));
11.         char buffer[255 * 4] = "";
12.         while (ret == 0) {
13.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
16.                 fputs("Operand count:", stdout);//输出提示符
17.                 int opnd_cnt = 0;
18.                 scanf("%d", &opnd_cnt);
19.                 if (opnd_cnt <= 1 && opnd_cnt >= 256) {
20.                         fputs("opnd_cnt error,too small or too big!\n", stdout);
21.                         close(client);
22.                         std::cout << "client done!" << opnd_cnt << std::endl;
23.                         return;
24.                 }
25.                 buffer[0] = (char)opnd_cnt;         //服务器此处需要解释为无符号
26.                 for (int i = 0; i < opnd_cnt; i++) {
27.                         scanf("%d", buffer + 1 + i * 4);
28.                 }
29.                 fgetc(stdin);
30.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
31.                 fputs("Operator:", stdout);
32.                 buffer[1 + opnd_cnt * 4] = (char)fgetc(stdin);
33.                 //buffer[1 + opnd_cnt * 4] = (char)fgetc(stdin);
34.                 //fgetc(stdin); // 清除换行符
36.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
38.                 size_t len = opnd_cnt * 4 + 2;
39.                 size_t send_len = 0;
40.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
41.                 while (send_len < len) {
42.                         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
43.                         ssize_t ret = write(client, buffer + send_len, len - send_len);//发给服务器
44.                         if (ret <= 0)
45.                         {
46.                                 fputs("write failed!\n", stdout);
47.                                 close(client);
48.                                 std::cout << "client done!" << std::endl;
49.                                 return;
50.                         }
51.                         send_len += (size_t)ret;
52.                 }
53.                 memset(buffer, 0, sizeof(buffer));
55.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
56.                 size_t read_len = 0;
57.                 while (read_len < 4)
58.                 {
59.                         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
60.                         ssize_t ret = read(client, buffer + read_len, len - read_len);
61.                         if (ret <= 0)
62.                         {
63.                                 fputs("read failed!\n", stdout);
64.                                 close(client);
65.                                 std::cout << "client done!" << std::endl;
66.                                 return;
67.                         }
68.                         read_len += (size_t)ret;
69.                 }
71.                 printf("from server:%d\n", *(int*)buffer);
72.         }
73.         close(client);
74.         std::cout << "client done!" << std::endl;
75. }

复制代码

九、回声服务器实战：计算器的网络实现（下）

这里实现服务端：（包含计算函数和主函数）

1. int calculate(int count, int oprand[], char op) {
2.         int result = 0;
3.         switch (op) {
4.         case '+':
5.                 for (int i = 0; i < count; i++) {
6.                         result += oprand[i];
7.                 }
8.                 break;
9.         case '-':
10.                 result = oprand[0];
11.                 for (int i = 1; i < count; i++) {
12.                         result -= oprand[i];
13.                 }
14.                 break;
15.         case '*':
16.                 result = oprand[0];
17.                 for (int i = 1; i < count; i++) {
18.                                 result *= oprand[i];
19.                 }
20.                 break;
21.         default:
22.                 break;
23.         }
24.         return result;
25. }
26. void server66() {
27.         int server, client;
28.         struct sockaddr_in seraddr, cliaddr; //服务端和客户端的地址结构体
29.         socklen_t cliaddrlen;//客户端的地址结构体大小
31.         //1.创建服务器套接字
32.         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
33.         server = socket(PF_INET, SOCK_STREAM, 0);//TCP协议  什么是TCP，就是IPv4中面向了流的套接字
34.         if (server < 0) {
35.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
36.                 std::cout << "create socket failed!" << std::endl;
37.                 return;
38.         }
40.         //2.绑定服务器套接字和地址结构体
41.         memset(&seraddr, 0, sizeof(seraddr));//清零
42.         seraddr.sin_family = AF_INET;        //地址协议族
43.         seraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
44.         seraddr.sin_port = htons(33005);
46.         //printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
47.         int on = 1;
48.         if (setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
49.                 perror("setsockopt");
50.                 close(server);
51.                 return;
52.         }
53.         //printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
55.         int ret = bind(server, (struct sockaddr*)&seraddr, sizeof(seraddr));
56.         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
57.         if (ret == -1) {
58.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
59.                 std::cout << "bind failed!" << std::endl;
60.                 close(server);
61.                 return;
62.         }
63.         ret = listen(server, 3);
64.         if (ret == -1) {
65.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
66.                 std::cout << "listen failed!" << std::endl;
67.                 close(server);
68.                 return;
69.         }
70.         char buffer[1024];
71.         for (int i = 0; i < 2; i++) {
72.                 memset(buffer, 0, sizeof(buffer));
73.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
74.                 cliaddrlen = sizeof(cliaddr);
75.                 client = accept(server, (struct sockaddr*)&cliaddr, &cliaddrlen/*&cliaddrlen*/);
76.                 if (client == -1) {
77.                         std::cout << "accept failed!" << std::endl;
78.                         close(server);
79.                         return;
80.                 }
81.                 //printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
82.                 //ssize_t len=read(client, buffer, sizeof(buffer));
83.                 ssize_t len = 0;
84.                 len = read(client, buffer, 1);
85.                 int result;
86.                 if (len > 0) {
87.                         for (unsigned int i = 0; i < ((unsigned)buffer[0] & 0xFF); i++) {
88.                                 read(client, buffer + 1 + i * 4, 4);
89.                         }
90.                         read(client, buffer + 1 + ((unsigned)buffer[0] & 0xFF) * 4, 1);
91.                         result = calculate((int)buffer[0] & 0xFF, (int*)(buffer + 1), buffer[1 + ((unsigned)buffer[0] & 0xFF) * 4]);
92.                         write(client, &result, 4);
93.                         std::cout << "result" << result << std::endl;
94.                 }
95.                 while ((len = read(client, buffer, sizeof(buffer))) > 0) {
96.                         len = write(client, buffer, len); //返回值就是实际写入的字节数
97.                         if (len != (ssize_t)strlen(buffer)) {
98.                                 std::cout << "write failed!    len:" << len << "  buffer:" << buffer << std::endl;
99.                                 close(server);
100.                                 return;
101.                         }
102.                         memset(buffer, 0, len);
103.                 }
105.                 printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
106.                 read(client, buffer, 1);
107.                 close(client);
108.         }
109.         close(server);
110.         printf("%s(%d):%s\r\n", __FILE__, __LINE__, __FUNCTION__);
111. }
112. void lession66()
113. {
114.         pid_t pid = fork();
115.         if (pid == 0) {   //子进程
116.                 //开启服务端
117.                 server66();
118.         }
119.         else if (pid > 0) {
120.                 for (int i = 0; i < 2; i++)
121.                         run_client66();
122.                 int status = 0;
123.                 wait(&status);//避免子进程成为僵尸进程
124.         }
125.         else {
126.                 std::cout << "fork failed!" << pid << std::endl;
127.         }
128. }

复制代码

十、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 中不会由于缓冲溢出而丢失数据。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。