编程模拟实现数据链路层协议中的停等协议模板.doc

一、 试验题目: 编程模拟实现数据链路层协议中停等协议
二、 试验目:
1、 掌握停止等候协议基础原理
2、 了解数据链路层关键功效（数据犯错控制, 数据反复控制, 数据丢失控制等等）
3、 分析简单协议数据单元
4、 掌握停止等候协议运行机制
三、 停止等候协议算法,
在发送节点:
（1） 从主机取一个数据帧, 送交发送缓存。
（2） 发送状态变量V（S）初始化, V（S）←0。
（3） 将发送状态变量值写入数据帧中发送序号N（S）, N（S）←V（S）。
（4） 将发送缓存中数据帧发送出去。
（5） 设置超时计时器（选择合适超时重传时间Tout ）。
（6） 等候。
（7） 收到确定帧ACKn,
若n=1-V(S),则: 从主机取一个新数据帧, 放入发送缓存: V（S）←[1-V(S)]; 转到（3）。
不然, 丢弃这个确定帧, 转到（6）。
（8） 若超时计时器时间到, 则转到（4）。
在接收节点:
（1） 接收状态变量初始化, V（R）←0。
（2） 等候。
（3） 收到一个数据帧:
若N（S）=V(R), 则实施（4）;
不然丢弃此数据帧, 然后转到（6）。
（4） 将收到数据帧中数据部分送交上层软件。
（5） 更新接收状态变量, 准备接收下一个数据帧, V（R）←[1-V(R)]。
（6） n←V(R),发送确定帧ACK, 转到（2）。
四、 程序源代码:

#include <iostream>
#include <tchar.h>
#include <WinSock2.h>
#include <string.h>

//异常类
#ifndef __HZH_Exception__
#define __HZH_Exception__
#define EXCEPTION_MESSAGE_MAXLEN 256
class Exception
{
private:
char m_ExceptionMessage[EXCEPTION_MESSAGE_MAXLEN];
public:
Exception(char *msg)
{
strncpy(m_ExceptionMessage, msg, EXCEPTION_MESSAGE_MAXLEN);

}
char *GetMessage()
{
return m_ExceptionMessage;
}
};
#endif
#ifndef __ARQ_H__
#define __ARQ_H__

//停止等候协议BSC控制字符
#define STX (char)2 // 文始
#define ETX (char)3 // 文终
#define ENQ (char)5 // 问询
#define SYN (char)16 // 同时
#define EOT (char)4 // 送毕
#define ACK (char)6 // 正应答
#define NAK (char)15 // 负应答

//BSC数据报文格式
#define MAXBSCLENGTH 1000 //理想最大值是1500-46-4=1450,从而确保UDP协议IP数据报不分组
typedef struct Datagram
{
char header; //开始字符
bool number; //0或者1
char data[MAXBSCLENGTH];//正文
char bcc; //控制字符
char tail; //结束字符
} BSC;
#endif

// 服务器端口
#define SERVER_PORT 2280 //最大重传次数
#define MAXRETRY 8 //传送传时时间
#define TIMEOUT 3000
#pragma comment(lib,"ws2_32.lib")//设置link时lib库

using namespace std;
SOCKET PrimaryUDP;
char ServerIP[20];
char FilePath[MAX_PATH];
bool g_number = false; // 用作奇偶检校序号
char g_bcc; //返回控制字符

HANDLE m_hEvent;
void InitWinSock() // 初始化套接字
{
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
{
throw Exception("Windows sockets 2.2 startup unsuccessful");
}
else{
printf("Using %s (Status: %s)\n",
wsaData.szDescription, wsaData.szSystemStatus);
printf("with API versions %d.%d to %d.%d\n\n",
LOBYTE(wsaData.wVersion), HIBYTE(wsaData.wVersion),
LOBYTE(wsaData.wHighVersion), HIBYTE(wsaData.wHighVersion));
}
}
void mksock(int type)
{
PrimaryUDP = socket(AF_INET, type,0);
if (PrimaryUDP < 0)
{
throw Exception("create socket error");
}
}

void BindSock() // 绑定套接字
{
sockaddr_in sin;
sin.sin_addr.S_un.S_addr=INADDR_ANY;
sin.sin_family = AF_INET;
sin.sin_port = 0;
if (bind(PrimaryUDP, (struct sockaddr*)&sin, sizeof(sin)) < 0)
throw Exception("bind error");
}

bool ASendto()
{
sockaddr_in remote;
remote.sin_addr.S_un.S_addr = inet_addr(ServerIP);
remote.sin_family = AF_INET;
remote.sin_port =htons(SERVER_PORT);
int fromlen = sizeof(remote);
FILE * file;//打开文件
if((file = fopen(FilePath, "rb")) == NULL)
{
cout<<FilePath<<" open error"<<endl;
return false;
}
cout<<"file open succeed"<<endl;
// 设置文件指针位置
SetFilePointer(file, 0, NULL, FILE_BEGIN);
BSC bsc;
bsc.header = STX;bsc.tail = ETX;
// 设为有信号
SetEvent(m_hEvent);// 分段序号
bool number = false;
unsigned long dwRead = -1;
bool sendComplete = false;
while(!sendComplete)
{
// 清空数据
memset(bsc.data,0,MAXBSCLENGTH);
// 目前分块奇偶序号
bsc.number=number;
// 统计目前分块序号
g_number = bsc.number;
if (dwRead ==-1)
//第一次应发送文件请求消息
{
//发送文件请求
bsc.bcc = ENQ;
char * filename = FilePath;
if ((filename = strrchr(FilePath,'\\'))==NULL)
filename = FilePath;
else
++filename;
strcpy(bsc.data,filename);
dwRead = 0;
}
else
{
if(!feof(file))
{
bsc.bcc = SYN;
int i = fread(bsc.data, sizeof(char),MAXBSCLENGTH , file);
cout<<"read:"<<i<<"\tsend:"<<sizeof(bsc.data)<<endl;
dwRead+=i;
}
else
{
// 发送完成
bsc.bcc = EOT;
sendComplete = true;
cout<<"send complete.send size:"<<dwRead<<endl;
fclose(file);
}
}
for(int i=0;i<MAXRETRY;i++)
{
sendto(PrimaryUDP,(char*)&bsc,sizeof(bsc),0,(sockaddr*)&remote,fromlen);
ResetEvent(m_hEvent);
DWORD reslut = WaitForSingleObject(m_hEvent,TIMEOUT);
if (reslut == WAIT_OBJECT_0)
{
//收到应答消息,一个是ACK,一个是NAK
if (g_bcc == NAK)
{
if (i == MAXRETRY -1)
{
return false;
}
continue; // 继续重传
}
else
{
// 收到应答消息
break;
}
}
else if(i == MAXRETRY-1)
{
cout<<"send file failed"<<endl;
return false;
}
}
number = !number; // 开始发下一段数据
}
return true;
}

DWORD WINAPI ARecv(LPVOID lpParam)
{
sockaddr_in remote;
int sinlen = sizeof(remote);
BSC buffer;
int iread = 0;
while (true)
{
iread = recvfrom(PrimaryUDP,(char*)&buffer,sizeof(buffer),0,(sockaddr*)&remote,&sinlen);
// 处理ACK与NAK
if (iread == SOCKET_ERROR)
{
continue;
}
// 与目前分块序号进行比较,看是不是目前块应答
if (buffer.number!=g_number)
{
continue;
}
if (buffer.bcc == ACK || buffer.bcc == NAK)
{
// 保留返回控制字符
g_bcc = buffer.bcc;
SetEvent(m_hEvent);
}
}
return 0;
}

int _tmain(int argc, _TCHAR* argv[])
{
InitWinSock();
mksock(SOCK_DGRAM);
BindSock();
cout<<"Please input receiver ip:";
cin>>ServerIP;
cout<<"Please input the file path:";
cin>>FilePath;
m_hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
CreateThread(NULL, 0, ARecv, NULL, 0, NULL);
if (!ASendto()){
cout<<"file send failed"<<endl;
getchar();
}
getchar();
getchar();
return 0;
}

// receiver.cpp : 定义控制台应用程序入口点。
// 服务器端口
#define SERVER_PORT 2280
#pragma comment(lib,"ws2_32.lib")//设置link时lib库
using namespace std;
//SOCKET PrimaryUDP;
char FileSavePath[MAX_PATH];

void rInitWinSock()//初始化套接字
{
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
{
throw Exception("Windows sockets 2.2 startup unsuccessful");
}
else{
printf("Using %s (Status: %s)\n",
wsaData.szDescription, wsaData.szSystemStatus);
printf("with API versions %d.%d to %d.%d\n\n",
LOBYTE(wsaData.wVersion), HIBYTE(wsaData.wVersion),
LOBYTE(wsaData.wHighVersion), HIBYTE(wsaData.wHighVersion));
}
}
void rmksock(int type)
{
PrimaryUDP = socket(AF_INET, type,0);
if (PrimaryUDP < 0)
{
throw Exception("create socket error");
}
}

void rBindSock()
{
sockaddr_in sin;
sin.sin_addr.S_un.S_addr = INADDR_ANY;
sin.sin_family = AF_INET;
sin.sin_port = htons(SERVER_PORT);
if (bind(PrimaryUDP, (struct sockaddr*)&sin, sizeof(sin)) < 0)
throw Exception("bind error");
}

DWORD WINAPI rARecv(LPVOIDlpParam)
{
FILE * file = NULL;
sockaddr_in remote;
int sinlen = sizeof(remote);
BSC buffer,bsc;
bsc.header = STX;bsc.tail = ETX;
memset(bsc.data, 0, MAXBSCLENGTH);
int iread = 0;
unsigned long dwReceived = 0;
bool number = true;//发送方数据开始发送时序号设为0,为了判定是不是第一次一段数据,所以这里标为1
while (true)
{
iread= recvfrom(PrimaryUDP,(char*)&buffer,sizeof(buffer),0,(sockaddr*)&remote,&sinlen);
if (SOCKET_ERROR == iread || buffer.header != STX || buffer.tail != ETX)
{
// 数据错误,发送负应答
cout<<"received a error data"<<endl;
bsc.bcc = NAK;bsc.number=false;//number这时没有实际意义
sendto(PrimaryUDP,(char*)&bsc,sizeof(bsc),0,(sockaddr*)&remote,sinlen);
continue;
}
if (buffer.number == number)
{
// 反复收到数据,发送应答消息
cout<<"received a repeat data"<<endl;
bsc.bcc = ACK;
bsc.number = buffer.number;
sendto(PrimaryUDP,(char*)&bsc,sizeof(bsc),0,(sockaddr*)&remote,sinlen);
continue;

}

switch(buffer.bcc)
{
case ENQ:
{
number = !number;//准备接收下一段数据
// 文件请求
cout<<"received a file request message,filename:"<<buffer.data<<endl;
// 打开文件
if(strcmp((FileSavePath+strlen(FileSavePath)-1),"\\")!=0)
strcat(FileSavePath,"\\");
strcat(FileSavePath,buffer.data);
if((file = fopen(FileSavePath, "ab")) == NULL)
{
cout<<"file open failed"<<endl;
return -1;
}
break;
}
case SYN:
{
number = !number;// 文字发送中
int i =0;
if((i=fwrite(buffer.data, sizeof(char), sizeof(buffer.data), file)) <= 0)
{
cout << "write failed" << endl;
return -1;
}
dwReceived += i;
cout<<"write:"<<i<<"\treceived:"<<sizeof(buffer.data)<<endl;
break;
}
case EOT:
{
number = !number;// 文件发送完成
cout<<"file received completely,save path:"<<FileSavePath<<",received size:"<<dwReceived<<endl;
fclose(file);
break;
}
default:
{
// 数据错误,发送负应答
bsc.bcc = NAK;bsc.number=false;
sendto(PrimaryUDP,(char*)&bsc,sizeof(bsc),0,(sockaddr*)&remote,sinlen);
continue;
break;
}
}
// 发送应答消息
bsc.bcc = ACK;
bsc.number = buffer.number;
sendto(PrimaryUDP,(char*)&bsc,sizeof(bsc),0,(sockaddr*)&remote,sinlen);
}
return 0;
}
int r_tmain(int argc, _TCHAR* argv[])
{
InitWinSock();
mksock(SOCK_DGRAM);
BindSock();
CreateThread(NULL, 0, ARecv, NULL, 0, NULL);
cout<<"Please input the file save path:";
cin>>FileSavePath;
cout<<"receiver start succeed"<<endl;
getchar();
getchar();
return 0;
}

运行结果:

五、 试验总结:
停止等候协议是数据链路层多个协议中最简单协议, 是数据链路层多种协议基础。此试验是基于winsock编程, 是在VC++6.0实现。它采取用户机/服务器（C/S）模型, 即发送数据一端为用户端, 接收数据一端为服务器端。停止等候协议就是经过双方收发数据而达成相互通信目。当收方收到一个正确数据帧后, 便会向发方发送一个确定帧ACK,表示发送数据正确接收。当发方收到确定帧后才能发送一个新数据帧, 这么就实现了接收方对发送方流量控制。
因为通信线路质量各方面影响, 数据帧从发送方到接收方传输过程中可能会出现差错。为了确保数据正确性和完整性, 接收方在收到数据后, 会用一定方法对接收到数据进行差错检验, 所以接收方很轻易检测出收到数据帧是否出现差错。当接收方发觉收到数据出现差错时, 就会向发送方发送一个否认帧NAK,表示对方发送数据错误。发送方会依据接收方发来信息做出对应操作。采取这么有效检错机制, 数据链路层能够对上面网络层提供了可靠传输服务。
经过这次课程设计, 我对winsock编程又有了深入了解, 因为网络问题, 没能把全部结果运行出来, 这是这次试验不足。
六、 参考文件:
[1]COMPUTER NETRWORKS .计算机网络（第4版）.Andrew S.Tanenbaum
[2]Internet原理与应用 刘化君 等编著 电子工业出版社
[3]计算机网络（第五版）谢希仁　编著　电子工业出版社
[4]网络编程与开发技术 殷肖川 等编著 西安交通大学