RDT实现回退N帧协议
net_exp.h
给出在RDT协议实现中的一些函数和参量的定义
#ifndef NETEXP_H
#define NETEXP_H
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <time.h>
#define RDT_SERVER_ADDRESS "127.0.0.1" //RDT服务器端IP
#define RDT_RECV_PORT 8003 //RDT接收端端口号
#define RDT_SEND_PORT 8004 //RDT发送端端口号
#define RDT_BEGIN_SEQ 1 //RDT数据包初始序列号,(假设数据包序列号不循环)
#define RDT_PKT_LOSS_RATE 10 //不可靠数据传输层的丢包率
#define RDT_TIME_OUT 5 //数据包超时时限
#define RDT_HEADER_LEN (4 + 4) //RDT头标长度
#define RDT_DATA_LEN 1000 //RDT中数据域长度
#define RDT_PKT_LEN ( RDT_DATA_LEN + RDT_HEADER_LEN ) //RDT中数据包长度
//RDT包类型
#define RDT_CTRL_BEGN 0 //初始包
#define RDT_CTRL_DATA 1 //数据包
#define RDT_CTRL_ACK 2 //ACK包
#define RDT_CTRL_NACK 3 //NACK包
#define RDT_CTRL_END 4 //结束包
/*
RDT packet format: |CTRL|SEQ|...DATA...|
将数据封装成RDT数据包,头部只包含控制域和序列号域,其中控制域用来标识RDT数据包类型,序列号域是包含此数据包的序列号。
函数返回RDT数据包长度
*/
int pack_rdt_pkt( char *data_buf, char *rdt_pkt, int data_len, int seq_num, int flag );
/*
RDT packet format: |CTRL|SEQ|...DATA...|
将数据包解封装。
函数返回RDT包中的数据长度
*/
int unpack_rdt_pkt( char *data_buf, char *rdt_pkt, int pkt_len, int *seq_num, int *flag );
/*
模拟不可靠数据传输,以一定的概率(RDT_PKT_LOSS_RATE)丢弃数据包,调用形式和recvfrom一致
*/
void udt_sendto( int sock_fd, char *pkt, int pkt_len, int flags, struct sockaddr *recv_addr, int addr_len );
#endif
rdt_pkt_util.c实现net_exp.h中包装的函数
#include "net_exp.h"
/*
将数据封装成RDT数据包:即在数据前加上RDT数据包头部
*/
int pack_rdt_pkt( char *data_buf, char *rdt_pkt, int data_len, int seq_num, int flag )
{
char *ptr = rdt_pkt;
uint32_t ctrl_net_order = htonl( flag );
uint32_t seq_net_order = htonl( seq_num );
memcpy( ptr, &ctrl_net_order, sizeof(uint32_t) );
ptr += sizeof(uint32_t);
memcpy( ptr, &seq_net_order, sizeof(uint32_t) );
ptr += sizeof(uint32_t);
if( data_len > 0 && data_buf != NULL )
memcpy( ptr, data_buf, data_len );
return (RDT_HEADER_LEN+data_len);
}
/*
将RDT数据包解封装
*/
int unpack_rdt_pkt( char *data_buf, char *rdt_pkt, int pkt_len, int *seq_num, int *flag )
{
char *ptr = rdt_pkt;
uint32_t ctrl_net_order, seq_net_order;
int data_len;
memcpy( &ctrl_net_order, ptr, sizeof(uint32_t) );
ptr += sizeof(uint32_t);
*flag = ntohl( ctrl_net_order );
memcpy( &seq_net_order, ptr, sizeof(uint32_t) );
ptr += sizeof(uint32_t);
*seq_num = ntohl( seq_net_order );
data_len = pkt_len - RDT_HEADER_LEN;
if( data_buf != NULL && data_len > 0 )
memcpy( data_buf, ptr, data_len );
return data_len;
}
/*
模拟不可靠数据传输,以一定的概率(RDT_PKT_LOSS_RATE)丢弃数据包
*/
void udt_sendto( int sock_fd, char *pkt, int pkt_len, int flags, struct sockaddr *recv_addr, int addr_len )
{
int seed = rand() % 100;
if( seed >= RDT_PKT_LOSS_RATE )
sendto( sock_fd, pkt, pkt_len, flags, recv_addr, addr_len );
else //pkt lost
printf( " emulate packet lost!\n" );
}
发送方rdt_stopwait_sender.c
#include "net_exp.h"
SLD_WIN sending_window; //滑动窗口数据结构体
int total_send_byte = 0; //记录累计发送的字节数
void usage( char **argv )
{
printf( "wrong argument!\n" );
printf( "usage: %s send_file_name. \n", argv[0] );
}
/*
处理接收端发回的ACK,重新设置滑动窗口内数据包的状态
*/
void slide_window_ack( int ack_num )
{
pthread_mutex_lock( &sending_window.lock );//将互斥量上锁
printf( "\t[child thread] recv ack# %-8d\n", ack_num );
if( ack_num >= sending_window.send_left && ack_num < sending_window.send_right )
{
int succ_pkt_seq;
for( succ_pkt_seq = sending_window.send_left; succ_pkt_seq <= ack_num; succ_pkt_seq++ )
if( sending_window.rdt_pkts[succ_pkt_seq % sending_window.win_len].state == 1 )
{
sending_window.rdt_pkts[succ_pkt_seq % sending_window.win_len].state = 2; //set pkt state to acked
total_send_byte += (sending_window.rdt_pkts[succ_pkt_seq % sending_window.win_len].pkt_len - RDT_HEADER_LEN);
}
}
else
{
if( ack_num < sending_window.send_left )
printf( "\t[child thread] already acked #pkt %-8d\n", ack_num );
else
{
printf( "\t[child thread] recv wrong acked, #ack[%d] > sending_window.send_right[%d].\n", ack_num, sending_window.send_right );
sleep(10); //wrong ack, do something?
}
}
pthread_mutex_unlock( &sending_window.lock ); //将互斥量上锁
}
/*
用于监听端口并接收ACK包的线程函数
*/
void *recv_acks_thread( void *arg )
{
int *sock_fd = ( int *) arg;
char rdt_pkt[RDT_PKT_LEN];
int pkt_len;
struct sockaddr_in reply_addr;
int reply_addr_len;
int reply_ack_seq;
int reply_ack_flag;
memset( &reply_addr, 0, sizeof(reply_addr) );
reply_addr_len = sizeof( reply_addr );
printf( "\t[child thread] waiting acks..\n" );
while(1)
{
/*检查是否有数据包到达*/
pkt_len = recvfrom( *sock_fd, rdt_pkt, RDT_PKT_LEN, MSG_PEEK,
(struct sockaddr *)&reply_addr, &reply_addr_len );
if( pkt_len > 0 ) //有数据包到达
{
pkt_len = recvfrom( *sock_fd, rdt_pkt, RDT_PKT_LEN, 0,
(struct sockaddr *)&reply_addr, &reply_addr_len );
unpack_rdt_pkt( NULL, rdt_pkt, pkt_len, &reply_ack_seq, &reply_ack_flag );
if( reply_ack_flag == RDT_CTRL_ACK ) //有ACK包到达
slide_window_ack( reply_ack_seq ); //重新设置滑动窗口状态
}
}
}
/*
检查滑动窗口内是否有数据包需要发送,返回窗口内待发送的数据包数。
*/
int pre_sending_rdt_pkt( FILE *fp )
{
int pkt_to_send = 0;
char read_buf[RDT_DATA_LEN];
int send_base_acked;
pthread_mutex_lock( &sending_window.lock );
STATE_PKT *ptr_pkt_left = &sending_window.rdt_pkts[ sending_window.send_left % sending_window.win_len];
send_base_acked = (ptr_pkt_left->state == RDT_PKT_ST_ACKED) ? 1 : 0;
/*
如果滑动窗口最左端的包已经收到ACK,则将滑动窗口滑动到下一个没收到ACK的包的位置,
同时将新数据包装入滑动窗口右端空缺位置。
*/
if( send_base_acked == 1 )
{
int new_pkt_seq;
int max_acked;
max_acked = sending_window.send_left;
while( max_acked < sending_window.send_right &&
(sending_window.rdt_pkts[max_acked % sending_window.win_len].state == RDT_PKT_ST_ACKED) )
max_acked++;
sending_window.send_left = max_acked;
for( new_pkt_seq = sending_window.send_right;
new_pkt_seq < (sending_window.send_left + sending_window.win_len);
new_pkt_seq++ )
{
if( feof(fp) ) //检查是否已到达发送文件结尾
break;
int read_len, rdt_pkt_len;
STATE_PKT *ptr_pkt_new = &sending_window.rdt_pkts[new_pkt_seq % sending_window.win_len];
read_len = fread( read_buf, sizeof(char), RDT_DATA_LEN, fp ); //读取发送文件中的数据
rdt_pkt_len = pack_rdt_pkt( read_buf,
ptr_pkt_new->rdt_pkt,
read_len,
new_pkt_seq,
RDT_CTRL_DATA ); //封装为RDT数据包
//初始化新RDT数据包状态
ptr_pkt_new->pkt_seq = new_pkt_seq;
ptr_pkt_new->pkt_len = rdt_pkt_len;
ptr_pkt_new->state = RDT_PKT_ST_INIT;
memset( &(ptr_pkt_new->send_time), 0, sizeof(struct timeval) );
pkt_to_send++;
}
sending_window.send_right = new_pkt_seq;
}
/*
如果滑动窗口最左端的包还没有收到数据包,则检查其是否超时,如果超时,则重新发送所有滑动窗口内的数据包。否则继续等待。
*/
else
{
struct timeval time_now;
gettimeofday( &time_now, NULL );
/*
如果是第一次发送数据,将滑动窗口初始化,填满待发送的数据
*/
if( sending_window.send_left == sending_window.send_right )
{
int new_pkt_seq;
for( new_pkt_seq = sending_window.send_right;
new_pkt_seq < (sending_window.send_left + sending_window.win_len);
new_pkt_seq++ )
{
int read_len, rdt_pkt_len;
if( feof(fp) ) //检查是否已到达发送文件结尾
break;
STATE_PKT *ptr_pkt_new = &sending_window.rdt_pkts[new_pkt_seq % sending_window.win_len];
read_len = fread( read_buf, sizeof(char), RDT_DATA_LEN, fp );
rdt_pkt_len = pack_rdt_pkt( read_buf,
ptr_pkt_new->rdt_pkt,
read_len,
new_pkt_seq,
RDT_CTRL_DATA );
ptr_pkt_new->pkt_seq = new_pkt_seq;
ptr_pkt_new->pkt_len = rdt_pkt_len;
ptr_pkt_new->state = RDT_PKT_ST_INIT; //set pkt state to init state
memset( &(ptr_pkt_new->send_time), 0, sizeof(struct timeval) );
pkt_to_send++;
}
sending_window.send_right = new_pkt_seq;
printf( "[main thread] begin sending, slide window[%d,%d).\n",
sending_window.send_left, sending_window.send_right );
}
else if( time_out( time_now, ptr_pkt_left->send_time ) ) //第一个数据包超时
{
int i;
//重新发送窗口内所有数据包
for( i = sending_window.send_left; i < sending_window.send_right; i++ )
{
STATE_PKT *ptr_pkt = &sending_window.rdt_pkts[i % sending_window.win_len];
memset( &(ptr_pkt->send_time), 0, sizeof(struct timeval) );
ptr_pkt->state = RDT_PKT_ST_TMOUT;
pkt_to_send++;
}
printf( "[main thread] slide window[%d,%d), first pkt time out.\n",
sending_window.send_left, sending_window.send_right );
}
else
{
pkt_to_send = 0; //没有超时,继续等待ACK
}
}
pthread_mutex_unlock( &sending_window.lock );
return pkt_to_send;
}
/*
Go-Back-N 协议发送端函数
输入参数:
send_file_name: 待发送的文件名
sock_fd:发送数据的socket (同时从该socket发送数据包和接受数据包ACK)
recv_addr_ptr: 接收端的地址
说明:
创建一个子线程用于接收监听端口并接受ACK
而主线程用于维护滑动窗口并发送数据包
*/
int deliver_file( char *send_file_name, int sock_fd, struct sockaddr_in *recv_addr_ptr )
{
char recv_pkt_buf[RDT_PKT_LEN];
int seq_num = RDT_BEGIN_SEQ;
struct sockaddr_in reply_addr;
int reply_addr_len;
int reply_ack_seq;
int reply_ack_flag;
pthread_t worker_thread;
int reply_thread;
FILE *fp;
int i, j, read_len, pkt_len;
int counter = 1;
STATE_PKT *ptr_pkt;
if( (fp = fopen( send_file_name, "r" )) == NULL )
{
printf( "open file : %s failed.\n", send_file_name );
return 1;
}
memset( &reply_addr, 0, sizeof(reply_addr) );
//初始化互斥量
pthread_mutex_init( &sending_window.lock, NULL );
//初始化滑动窗口
sending_window.win_len = RDT_SENDWIN_LEN;
sending_window.send_left = RDT_BEGIN_SEQ;
sending_window.send_right = RDT_BEGIN_SEQ; //[slide window]= [RDT_BEGIN_SEQ, RDT_BEGIN_SEQ)
ptr_pkt = &sending_window.rdt_pkts[sending_window.send_left % sending_window.win_len];
ptr_pkt->pkt_seq = RDT_BEGIN_SEQ;
ptr_pkt->state = 0;
//创建子线程用于接收ACK
reply_thread = pthread_create( &worker_thread, NULL, recv_acks_thread, (void *)&sock_fd );
if( reply_thread != 0 )
{
perror( "pthread_create failed.\n" );
exit( 1 );
}
while(1)
{
int pkt_to_send;
/*检查滑动窗口内是否有数据包需要发送*/
pkt_to_send = pre_sending_rdt_pkt( fp );
if( pkt_to_send > 0 )
{
printf( "[main thread] #%d pkts to send.\n", pkt_to_send );
for( i = sending_window.send_left; i < sending_window.send_right; i++ )
{
STATE_PKT *ptr_pkt;
ptr_pkt = &sending_window.rdt_pkts[ i % sending_window.win_len];
if( ptr_pkt->state == RDT_PKT_ST_INIT || ptr_pkt->state == RDT_PKT_ST_TMOUT )
{
udt_sendto( sock_fd, ptr_pkt->rdt_pkt, ptr_pkt->pkt_len, 0,
(struct sockaddr *)recv_addr_ptr, sizeof(*recv_addr_ptr) );
ptr_pkt->state = RDT_PKT_ST_SENT;
gettimeofday( &ptr_pkt->send_time, NULL );
printf( "[main thread] send count #%-8d rdt_pkt #%-8d %-10d bytes.\n", counter++, ptr_pkt->pkt_seq, ptr_pkt->pkt_len );
}
}
printf( "[main thread] slide window: [%d,%d).\n", sending_window.send_left, sending_window.send_right );
}
else
{
//检查文件是否发送完
if( sending_window.send_left == sending_window.send_right && feof(fp) ) //data transfer finished
{
printf( "[main thread] finished sending! slide window: [%d,%d).\n", sending_window.send_left, sending_window.send_right );
reply_thread = pthread_cancel( worker_thread ); /*删除子线程*/
if( reply_thread != 0 )
{
printf( "[main thread] pthread_cancel failed.\n" );
exit(1);
}
break;
}
}
}
//删除互斥量
pthread_mutex_destroy( &sending_window.lock );
//结束发送过程,给接受端发送结束数据包(包类型为RDT_CTRL_END)
if( feof(fp) )
{
char rdt_pkt[RDT_PKT_LEN];
int rdt_pkt_len;
int new_pkt_seq = sending_window.send_left;
rdt_pkt_len = pack_rdt_pkt( NULL,
rdt_pkt,
0,
new_pkt_seq,
RDT_CTRL_END );
sendto( sock_fd, rdt_pkt, rdt_pkt_len, 0, (struct sockaddr *)recv_addr_ptr, sizeof(*recv_addr_ptr) );
}
printf( "\n\nsend file %s finished\ntotal send %d bytes.\n", send_file_name, total_send_byte );
fclose( fp );
return 0;
}
int main( int argc, char **argv )
{
struct sockaddr_in recv_addr, send_addr;
int sock_fd;
if( argc != 2 )
{
usage( argv );
exit(0);
}
srand ( time(NULL) );
if( ( sock_fd = socket( AF_INET, SOCK_DGRAM, 0 ) ) == -1 )
{
printf( "error! information: %s\n", strerror(errno) );
exit(1);
}
memset( &send_addr, 0, sizeof(send_addr) );
send_addr.sin_family = AF_INET;
send_addr.sin_addr.s_addr = htonl( INADDR_ANY );
send_addr.sin_port = htons( RDT_SEND_PORT );
if( ( sock_fd = socket( AF_INET, SOCK_DGRAM, 0 ) ) == -1 )
{
printf( "error! information: %s\n", strerror(errno) );
exit(1);
}
//将socket绑定到本地的某个端口,同时从该socket发送数据包和接受ACK
if( bind( sock_fd, (struct sockaddr *)&send_addr, sizeof(send_addr) ) == -1 )
{
close( sock_fd );
printf( "error! information: %s\n", strerror(errno) );
exit(1);
}
//设置接收端地址
memset( &recv_addr, 0, sizeof(recv_addr) );
recv_addr.sin_family = AF_INET;
recv_addr.sin_addr.s_addr = inet_addr( RDT_SERVER_ADDRESS );
recv_addr.sin_port = htons( RDT_RECV_PORT );
//调用传输文件的函数
if( deliver_file( argv[1], sock_fd, &recv_addr ) != 0 )
{
printf( "deliver file %s failed.\n", argv[1] );
close( sock_fd );
exit(1);
}
close( sock_fd );
return 0;
}
接收方rdt_stopwait_receiver.c
#include "net_exp.h"
void usage( char **argv )
{
printf( "wrong argument!\n" );
printf( "usage: %s save_file_name\n", argv[0] );
}
/*
Go-Back-N 协议接收端接受函数
输入参数:
save_file_name: 保存文件名
sock_fd:接受数据的socket
*/
int receive_file( char *save_file_name, int sock_fd )
{
char reply_pkt_buf[RDT_PKT_LEN];
int reply_pkt_len;
char rdt_pkt[RDT_PKT_LEN];
char rdt_data[RDT_DATA_LEN];
uint32_t seq_net_order;
int seq_num;
int flag;
int exp_seq_num;
int total_recv_byte = 0;
struct sockaddr_in client_addr;
int i, j, sin_len, pkt_len, data_len;
int counter = 1;
FILE *fp;
if( (fp = fopen( save_file_name, "w" )) == NULL )
{
printf( "open file : %s failed.\n", save_file_name );
return 1;
}
memset( &client_addr, 0, sizeof(client_addr) );
sin_len = sizeof( client_addr );
exp_seq_num = RDT_BEGIN_SEQ;
//TODO
while(1) //接收RDT数据包,直到所有数据全部接收完毕
{
/*
step 1. 接收RDT数据包 : recvfrom()
step 2. 解封装RDT数据包 : unpack_rdt_pkt()
step 3. 检查此数据包是否为期待的数据包 : seq_num==exp_seq_num
step 4. 封装一个新的RDT数据包(ACK包) : pack_rdt_pkt()
step 5. 调用不可靠数据传输发送新的RDT数据包(ACK包): udt_sendto()
*/
pkt_len = recvfrom(sock_fd, rdt_pkt, RDT_PKT_LEN, 0, (struct sockaddr *) &client_addr,&sin_len);
int data_len=unpack_rdt_pkt(rdt_data, rdt_pkt, pkt_len, &seq_num, &flag);
if (flag == RDT_CTRL_END) {
reply_pkt_len=pack_rdt_pkt(NULL,reply_pkt_buf,0,seq_num,RDT_CTRL_ACK);
// udt_sendto(sock_fd,reply_pkt_buf,reply_pkt_len,0,(struct sockaddr*)&client_addr,sin_len);
sendto(sock_fd,reply_pkt_buf,reply_pkt_len,0,(struct sockaddr*)&client_addr,sin_len);
break;
} else if (seq_num == exp_seq_num && flag == RDT_CTRL_DATA) {
exp_seq_num += 1;
total_recv_byte+=data_len;
fwrite(rdt_data, sizeof(char),data_len, fp);
reply_pkt_len=pack_rdt_pkt(NULL,reply_pkt_buf,0,seq_num,RDT_CTRL_ACK);
//udt_sendto(sock_fd,reply_pkt_buf,reply_pkt_len,0,(struct sockaddr*)&client_addr,sin_len);
sendto( sock_fd, reply_pkt_buf, reply_pkt_len, 0, (struct sockaddr*)&client_addr, sin_len );
}
}
printf( "\n\nreceive file succeed. write to file %s\ntotal recv %d byte\n",
save_file_name, total_recv_byte );
fflush( fp );
fclose( fp );
return 0;
}
int main( int argc, char **argv )
{
struct sockaddr_in recv_addr;
int sin_len;
int sock_fd;
int pkt_len;
srand ( time(NULL) );
if( argc != 2 )
{
usage( argv );
exit(0);
}
memset( &recv_addr, 0, sizeof(recv_addr) );
recv_addr.sin_family = AF_INET;
recv_addr.sin_addr.s_addr = htonl( INADDR_ANY );
recv_addr.sin_port = htons( RDT_RECV_PORT );
if( ( sock_fd = socket( AF_INET, SOCK_DGRAM, 0 ) ) == -1 )
{
printf( "error! information: %s\n", strerror(errno) );
exit(1);
}
if( bind( sock_fd, (struct sockaddr *)&recv_addr, sizeof(recv_addr) ) == -1 )
{
close( sock_fd );
printf( "error! information: %s\n", strerror(errno) );
exit(1);
}
if( receive_file( argv[1], sock_fd ) != 0 )
{
printf( "receive file %s failed.\n", argv[1] );
close( sock_fd );
exit(1);
}
close( sock_fd );
return 0;
}