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

西河刘卡车医 发表于 2024-12-1 11:57:24

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

一、TCP/IP协议栈

        为什么须要理解协议栈？
        学习C/C++就是要懂底层的原理。不然永久是“调包侠”
        根据数据传输方式的差别，基于网络协议（这里是指基于TCP/IP协议）的套接字一般分为TCP 套接字和UDP 套接字。由于TCP 套接字是面向毗连的，因此又称基于流（stream）的套接字。 TCP 是TransmissionControl Protocol（传输控制协议）的简写，意为"对数据传输过程的控制"。
https://i-blog.csdnimg.cn/direct/b0e55d9ba9d947fba4f566661ef76761.png
第一层次：数据链路层

        如图所示：链路层是物理链接领域标准化的结果，也是最基本的领域，专门定义LAN、WAN、MAN 等网络标准。若两台主机通过网络举行数据交换，则须要下图所示的物理毗连，
链路层就负责这些标准。
https://i-blog.csdnimg.cn/direct/530b5595e4e2469ca7595f76a0ca7a23.png
第二层次：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 协议则按照下图的对话方式举行数据交换。
https://i-blog.csdnimg.cn/direct/1d78b332e757449cba9a92eb9cc556bd.png
第四层次：应用层

        前面三个层次，套接字通信过程中都是自动处置惩罚的。为了"使步伐员从这些细节中解放
出来"。选择数据传输路径、数据确认过程都被隐蔽到套接字内部。前面三个层次都是为了
给应用层提供服务的。
二、TCP服务端和代码实现

服务的创建的基本流程（最简单的）
https://i-blog.csdnimg.cn/direct/7da4ab6b7c23451e90d4070c6ee4b62f.png
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 = "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;
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客户端

https://i-blog.csdnimg.cn/direct/6aca7cca5b364582abdac7641118e454.png

四、客户端代码实现和联调

基于TCP服务端/客户端的函数调用关系
https://i-blog.csdnimg.cn/direct/ed1c8f5e1ee94880a4d7a691199d176e.png
五、迭代服务器

        前面的普通服务器TCP 的缺点：一次服务。只能给一个客户端服务。
        迭代服务器比力原始，它的原型可以描述成：
https://i-blog.csdnimg.cn/direct/9180119d45f14ab395bfeac8f92bd008.png
        这个改动就是，当处置惩罚完一个客户端后，会再次进入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 = "";

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;
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= 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 = "";
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 = (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 = (char)fgetc(stdin);
//buffer = (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;
}
break;
case '-':
result = oprand;
for (int i = 1; i < count; i++) {
result -= oprand;
}
break;
case '*':
result = oprand;
for (int i = 1; i < count; i++) {
result *= oprand;
}
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;
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 & 0xFF); i++) {
read(client, buffer + 1 + i * 4, 4);
}
read(client, buffer + 1 + ((unsigned)buffer & 0xFF) * 4, 1);
result = calculate((int)buffer & 0xFF, (int*)(buffer + 1), buffer & 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 函数调用瞬间，
从输人缓冲读取数据。
https://i-blog.csdnimg.cn/direct/7fb1446931aa4012be34fde59d9cb3f9.png
        调用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企服之家，中国第一个企服评测及商务社交产业平台。

页: [1]

ToB企服应用市场:ToB评测及商务社交产业平台's Archiver

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