声明：禁止以任何形式转载本文章。本文章仅供个人学习记录与交流探讨，文章中提供的思路只是一种解决方案，代码也并非完整代码，如有需要，请自行设计协议并完成编程任务。
食用本文章之前，推荐阅读：C++实现流式socket聊天程序
目录
在C++实现流式socket聊天程序中，我们使用TCP协议传输数据，TCP实现的是可靠传输。但对于简单的交互应用和一些对延时敏感的应用来说，TCP需要握手挥手、维护连接状态、差错重传，这些都会增加延时。因此，这些应用通常使用UDP服务，而需要在UDP之上，也就是应用层增加可靠机制，保证数据正常传输。
本文实现了一个简单的基于UDP协议的可靠传输，实现的功能主要有：
- 建立连接三次握手
- 以二进制形式单向传输数据
- 差错检测：检查消息类型、序列号、校验和
- 确认重传：包括差错重传和超时重传
- 流量控制：停等机制
- 断开连接四次握手
UDP协议的基本框架
我们先来看看如何使用UDP协议发送和接收消息。
以Server服务器为例：
// 加载环境
WSADATA wsaData;
WSAStartup(MAKEWORD(2, 2), &wsaData);
// 创建数据报套接字
SOCKET sockServer = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
// 绑定ip地址和端口
sockaddr_in addrServer;
memset(&addrServer, 0, sizeof(sockaddr_in));
addrServer.sin_family = AF_INET;
addrServer.sin_port = htons(8000);
addrServer.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
bind(sockServer, (SOCKADDR*)&addrServer, sizeof(SOCKADDR))
// 客户端地址
sockaddr_in addrClient;
// 接收和发送消息，注意这里的recvfrom是阻塞函数
int len = sizeof(SOCKADDR);
while(true){
recvfrom(sockSrv, recvBuf, 1024, 0, (SOCKADDR *)&addrClient, &len);
sendto(sockSrv, sendBuf, 1024, 0, (SOCKADDR *)&addrClient, len);
}
// 关闭监听套接字
closesocket(sockServer);
//清理环境
WSACleanup();客户端也是同样的流程，只是可以不需要绑定ip地址和端口。
下面，我们在这个基本框架之上，尝试实现可靠传输。
程序实现
消息类型
首先我们需要为传输的数据设计一个消息头，存储一些重要信息，以便实现后续的功能。需要明确的是，我们需要以二进制形式传输数据，因此必须考虑消息头里的数据类型的位数。在此提供一种设计方案：
struct HeadMsg {
u_short len; // 数据长度，16位
u_short checkSum; // 校验和，16位
unsigned char type; // 消息类型
unsigned char seq; // 序列号，可以表示0-255
};- len：表示传输的数据长度，共16位，也就是最多可以传输8192字节的数据
- checkSum：表示校验和，共16位，负责校验传输的消息和数据是否被损坏
- type：表示消息类型，共8位，可以自行设计每一位表示的类型，1表示有效，0表示无效
- seq：表示序列号，共8位，可以表示0-255
有了消息头之后，我们每次发送消息时都要设置好消息头，再加上要传输的数据。接下来，我们从最简单的三次握手和四次挥手开始。
三次握手
在TCP中，三次握手的流程如下：
- 第一次握手：Client发送SYN消息
- 第二次握手：Server发送SYN_ACK消息
- 第三次握手：Client发送ACK消息
本文章的设计和TCP中的三次握手一致。当然你也可以设计二次握手，即只需一方发出请求连接就确立；也可以设计四次握手，需要双方分别发送建立连接的请求。
主动握手的代码如下：
HeadMsg h1;
h1.type = SYN;
char *sendBuf = new char[1024];
memset(sendBuf, 0, sizeof(sendBuf));
memcpy(sendBuf, &h1, sizeof(h1));
if (sendto(sockClient, sendBuf, 1024, 0, (SOCKADDR*)&addrServer, sizeof(SOCKADDR)) == -1) {
return false;
}
else {
cout << "Client: [SYN] Seq=0" << endl;
}其中的memcpy函数在本文章中会经常使用：
// 从b地址开始，把c个字节的数据写入a地址
memcpy(a, b, c);对于发送的消息，初步只设置了消息头的消息类型，其它的功能我们后续一步步完善。
等待握手的代码如下：
char *recvBuf = new char[1024];
memset(recvBuf, 0, sizeof(recvBuf));
int addrlen = sizeof(SOCKADDR);
HeadMsg h2;
while (true) {
if (recvfrom(sockClient, recvBuf, 1024, 0, (SOCKADDR*)&addrServer, &addrlen) > 0) {
memcpy(&h2, recvBuf, sizeof(h2));
if (h2.type == SYN_ACK) {
cout << "Server: [SYN, ACK] Seq=0 Ack=1" << endl;
break;
}
else {
return false;
}
}
}大家可以自行完善三次握手的过程。接下来我们介绍四次挥手：
四次挥手
在TCP中，双方都可以先发送挥手，也就是断开连接的请求。你可以设计三次挥手，即把二三次挥手结合在一起发送；也可以设计二次挥手，一方请求断开连接则暴力断开连接；也可以制定哪一方先发送挥手。
本文章中，为了方便，设计发送端先发送挥手。
- 第一次挥手：Server发送FIN_ACK消息
- 第二次挥手：Client发送ACK消息
- 第三次挥手：Client发送FIN_ACK消息
- 第四次挥手：Server发送ACK消息
四次挥手的代码和三次握手类似：
// 挥手
HeadMsg h1;
h1.type = FIN;
char *sendBuf = new char[1024];
memset(sendBuf, 0, sizeof(sendBuf));
memcpy(sendBuf, &h1, sizeof(h1));
if (sendto(sockServer, sendBuf, 1024, 0, (SOCKADDR*)&addrClient, sizeof(SOCKADDR)) == -1) {
return false;
}
else {
cout << "Server: [FIN, ACK] Seq=n" endl;
}
// 等待挥手
char *recvBuf = new char[1024];
memset(recvBuf, 0, sizeof(recvBuf));
int addrlen = sizeof(SOCKADDR);
HeadMsg h2;
while (true) {
if (recvfrom(sockServer, recvBuf, 1024, 0, (SOCKADDR*)&addrClient, &addrlen) > 0) {
memcpy(&h2, recvBuf, sizeof(h2));
if (h2.type == ACK) {
cout << "Client: [ACK] Seq=n"<< " Ack=m" << endl;
break;
}
else {
return false;
}
}
}接下来我们介绍发送和接收消息，也就是本文章的重点部分。
发送消息
以二进制方式读文件
我们需要以二进制方式读文件并将其保存到缓冲区，这部分和协议设计没什么关系，但是由于过去很少接触，还是介绍一下：
// 以二进制方式打开文件
ifstream fin(file.c_str(), ifstream::in | ios::binary);
if (!fin) {
cout << "Error: cannot open file!" << endl;
return false;
}
fin.seekg(0, fin.end); // 指针定位在文件尾
int length = fin.tellg(); // 获取文件大小（字节）
fin.seekg(0, fin.beg); // 指针定位在文件头
char *data = new char[length];
memset(data, 0, sizeof(data));
fin.read(data, length);
fin.close();发送消息的基本框架
接下来明确一下我们发送消息的基本框架：
- 设置头部信息，除了消息类型，现在我们还需要加上序列号和校验和
- 发送消息并开始计时，等待收到ACK确认的消息
- 由于文件可能过大，需要分批次发送（别忘了消息头里len是16位的限制！）
- 收到ACK消息，检查消息类型、序列号、校验和
- 若收到了错误的ACK消息：重新发送消息
- 若收到了正确的ACK消息：继续发送下一条消息
- 若超过最大等待时间还没有收到正确的ACK消息：重新发送消息，重新计时
细心的同学可能发现，如果一直没有收到或收到错误的ACK消息，发送端会一直重新发送信息。因此，大家可以自行设计如何跳出发送消息，例如设置最大重传次数、最大等待时间等。
// 设置信息头
HeadMsg h;
h.seq = curSeq;
h.len = packLen;
h.type = PSH;
char *sendBuf = new char[h.len+sizeof(h)];
memset(sendBuf, 0, sizeof(sendBuf));
memcpy(sendBuf, &h, sizeof(h));
// data存放的是读入的二进制数据，sentLen是已发送的长度，作为分批次发送的偏移量
memcpy(sendBuf + sizeof(h), data + sentLen, h.len);
sentLen += (int)h.len;
// 计算校验和
h.checkSum = checkSumVerify((u_short *)sendBuf, sizeof(h) + h.len);
memcpy(sendBuf, &h, sizeof(h));
// 发送消息
if (sendto(sockServer, sendBuf, h.len + sizeof(h), 0, (SOCKADDR*)&addrClient, sizeof(SOCKADDR)) == -1) {
cout << "Error: fail to send messages!" << endl;
return false;
}
// 等待接收消息
char *recvBuf = new char[1024];
memset(recvBuf, 0, sizeof(recvBuf));
int addrlen = sizeof(SOCKADDR);
while (true) {
if (recvfrom(sockServer, recvBuf, 1024, 0, (SOCKADDR*)&addrClient, &addrlen) > 0) {
// 收到消息需要验证消息类型、序列号和校验和
else {
// 差错重传并重新计时
}
}
else {
// 超时重传并重新计时
}
}差错检测
收到消息后，我们需要检查消息是否正确。
首先，需要检查消息类型是否正确。本文章设计的发送数据时的消息类型为PSH，大家也可以自行设计。
其次，需要检查消息的序列号是否正确。接收端每次发送ACK消息时，序列号都为其最后正确收到的消息的序列号。例如发送端发送一条序列号seq=n的消息，接收端收到后，会发送ACK消息确认，序列号seq=n；若发送端的消息损坏，接收端同样会发送ACK消息，但是这是序列号seq=n-1，也就是最后正确收到的消息是n-1号消息，以此来告诉发送端你的消息损坏了。因此，在发送端，我们只需要正确设置序列号就可以了。本文章的消息头中，序列号有8位，可以表示0-255。在发送端，我们只需要维护一个全局变量seq即可。
// 初始化8位序列号
unsigned char seq = 0;
// 每次成功发送消息后，序列号+1，但是要注意序列号空间有限
seq = (seq + 1) % 256;
// 收到消息时检查序列号
if(h.seq == seq)最后，需要检查校验和是否正确。校验和是消息头中的冗余字段，用来检测数据报传输过程中出现的差错。校验和的计算方法是：
- 将消息头的校验和设置为0
- 将消息头和数据看成16位整数序列，不足16位的最后补0
- 每16位相加，溢出的部分加到最低位上
- 最后的结果取反
接收端接收到数据时，需要用同样的方法计算校验和，但是不需要先将校验和清零。如果校验和结果全为0，说明消息正确，否则，说明消息损坏。
实现校验和的具体代码如下：
// 校验和：每16位相加后取反，接收端校验时若结果为全0则为正确消息
u_short checkSumVerify(u_short* msg, int length) {
int count = (length + 1) / 2;
u_short* buf = (u_short*)malloc(length + 1);
memset(buf, 0, length + 1);
memcpy(buf, msg, length);
u_long checkSum = 0;
while (count--) {
checkSum += *buf++;
if (checkSum & 0xffff0000) {
checkSum &= 0xffff;
checkSum++;
}
}
return ~(checkSum & 0xffff);
}确认重传
确认重传包括差错重传和超时重传。
差错重传就是在刚刚的差错检测部分，如果发现收到的ACK消息有错，则重新发送数据报，代码和上面一样，不再赘述。
超时重传就是如果超出最大响应时间还没有收到ACK消息，则重新发送数据报。
// 开始计时
clock_t start = clock();
// 发送消息......
// 如果超时
if (clock() - start > maxTime) {
// 重新发送数据报......
// 重新计时
clock_t start = clock();
}注意，差错重传和超时重传都要重新计时。
接收消息
虽然本文章实现的是单向传输，有一个发送端和一个接收端，但是其实双方都需要发送和接收消息，有很多代码是类似的。
接收消息的基本框架
char *recvBuf = new char[maxSize + sizeof(h1)];
memset(recvBuf, 0, sizeof(recvBuf));
// 等待接收消息
while (true) {
// 收到消息需要验证校验和及序列号
if (recvfrom(sockClient, recvBuf, maxSize+sizeof(h1), 0, (SOCKADDR*)&addrServer, &addrlen) > 0) {
memcpy(&h1, recvBuf, sizeof(h1));
HeadMsg h2;
h2.type = ACK;
char *sendBuf = new char[1024];
memset(sendBuf, 0, sizeof(sendBuf));
if (h1.seq == (lastAck+1)%256 && !checkSumVerify((u_short*)recvBuf, len)) {
lastAck = (lastAck + 1) % 256;
h2.seq = lastAck;
h2.checkSum = checkSumVerify((u_short*)&h2, sizeof(h2));
memcpy(sendBuf, &h2, sizeof(h2));
sendto(sockClient, sendBuf, 1024, 0, (SOCKADDR*)&addrServer, sizeof(SOCKADDR));
memcpy(data + totalLen, recvBuf + sizeof(h1), h1.len);
totalLen += (int)h1.len;
}
else { // 差错重传
h2.seq = lastAck;
h2.checkSum = checkSumVerify((u_short*)&h2, sizeof(h2));
memcpy(sendBuf, &h2, sizeof(h2));
sendto(sockClient, sendBuf, 1024, 0, (SOCKADDR*)&addrServer, sizeof(SOCKADDR));
}
}
}其中，需要特别注意lastAck的设置，一定是最后接收到的正确消息的序列号。
以二进制方式写文件
在上述代码中，我们将接收到的数据存入data缓冲区，总长度为totalLen。所有的数据接收完毕后，我们需要将其写入指定位置。
// 以二进制方式写入文件
ofstream fout(file.c_str(), ofstream::out | ios::binary);
if (!fout) {
cout << "Error: cannot open file!" << endl;
return false;
}
fout.write(data, totalLen);
fout.close();其实三次握手和四次挥手本质上也是发送和接收消息。现在，大家可以把三次握手和四次挥手的代码更新一下，加上序列号、校验和、确认重传等，使协议更加完整。
至此，我们完成了基于UDP协议的可靠传输。
程序测试
运行程序，可以看到三次握手的过程，成功建立连接。发送端输出消息提示用户输入需要传输的文件或者断开连接。
我们随便选择一个数据，发送端很快开始发送文件，并输出相关信息。从左到右依次为，发送的数据长度（字节）、消息类型、序列号、校验和。最后输出发送的数据总长度、传输时间和吞吐率。
查看接收端，同样也输出了相关信息。接收消息完毕后，成功写入文件。
发送端断开连接，可以看到四次挥手的过程，成功断开连接。
如果加上我们人为设置的丢包、损坏和延时，测试如下：
可以看到接收端在很努力地搞破坏，而我们的发送端不辞辛劳地重传。
本文章成功实现了基于UDP协议的可靠传输。但这个协议的设计还存在一些缺陷，例如，流量控制采用停等机制可能造成延时过长，没有设置拥塞控制等。后续将对这两部分进行改进，拟采用基于滑动窗口的流量控制机制，实现RENO算法的拥塞控制。
5634
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
