《计算机网络自顶向下》 Miscellaneous Lab1 Implementing a Reliable Transport Protocol（实现可靠的传输协议（上））

文章目录

前引
Lab1 实现可靠的传输协议
- Lab1 文档查阅（友情提供下载链接）
- 查看c语言参数声明的说明
- 原模版代码（个人整理格式后）
- 原模板代码（稍加分析）
- 交替位协议版本代码实现
- 交替位协议版本实现效果

前引

各位好我写到这里其实我也还是挺意外的因为其实我是想在CS144中再手撕TCP的但是没想到《计算机自顶向下》里面居然有这个小实验那既然有哪里有不做的道理反正CS144的实验也是迟早要完成的

我的预计本来是把Socket编程+Wireshark实验+CS144完成了配套着《计算机自顶向下》+之前快速看完的哈工大课程我们就愉快的完成计算机网络的学习哈哈哈但是其实发现要完成的还是相当多的

Lab1 实现可靠的传输协议

Lab1 文档查阅（友情提供下载链接）

方便大家下载相关文档下面是查阅链接
Programming Assignment 5: Implementing a Reliable Transport Protocol
prog2.c代码

下面是查阅的文档截图详细的大家还是点进去仔细看看吧这里我用的是谷歌的自带翻译所以查阅起来比较方便阅读

我们大概要完成的任务就是下图中的从A->B的信息传递只需要完成单向的哈哈不是说单项的B就不向A传递信息了 B如果不向A握手那还怎么连接呢

文档中指示了我们需要完成下面五个函数
A_output(message)，其中message是一个msg类型的结构体，包含要发送到B端的数据。每当发送端 (A) 的上层有消息要发送时，就会调用此例程。您的协议的工作是确保此类消息中的数据按顺序正确传递到接收方上层。

A_input(packet)，其中packet是pkt类型的结构体。每当从 B 端发送的数据包（即，作为B 端过程执行的tolayer3()的结果）到达 A 端时，将调用该例程。数据包是从 B 端发送的（可能已损坏的）数据包。

A_timerinterrupt() 当 A 的定时器超时（从而产生定时器中断）时，将调用该例程。您可能希望使用此例程来控制数据包的重新传输。请参阅下面的starttimer() 和stoptimer()以了解计时器的启动和停止方式。

A_init()在调用任何其他 A 端例程之前，该例程将被调用一次。它可用于执行任何所需的初始化。

B_input(packet)，其中packet是pkt类型的结构体。每当从 A 端发送的数据包（即，作为A 端过程执行的tolayer3()的结果）到达 B 端时，将调用该例程。数据包是从 A 端发送的（可能已损坏的）数据包。

B_init()在调用任何其他 B 端例程之前，该例程将被调用一次。它可用于执行任何所需的初始化。

查看c语言参数声明的说明

我刚刚在查看官方文档的时候看到了下面的c语言参数代码让我百思不得其解因为我实在没看到过这样子的声明

这个是什么啊我是真的这样想的第一个既没有返回值参数还是这样设置的第二个是int AorB char datasent[20]

tolayer5(AorB,datasent)int AorB;char datasent[20];
{int i;  if (TRACE>2) {printf("          TOLAYER5: data received: ");for (i=0; i<20; i++)  printf("%c",datasent[i]);printf("\n");}
}

之后我试了一下函数如下如果没有返回值的话默认为return 0

#include <stdio.h>f(a)
int a;
{printf("nono\n");
}main()
{int a = f(a);printf("goog %d\n",a);return;
}

原模版代码（个人整理格式后）

尽管不得不说这个网络模拟器和调试的地方确实提供模板的老师写的很好但是不得不说确实太乱了 - - 乱到很多时候我读代码都不忍直视读都读不下去实在是受不了了

于是在大概花了个5-6分钟左右我把格式做了优化看起来也整洁很多

#include <stdio.h>/* ******************************************************************ALTERNATING BIT AND GO-BACK-N NETWORK EMULATOR: VERSION 1.1  J.F.KuroseThis code should be used for PA2, unidirectional or bidirectionaldata transfer protocols (from A to B. Bidirectional transfer of datais for extra credit and is not required).  Network properties:- one way network delay averages five time units (longer if thereare other messages in the channel for GBN), but can be larger- packets can be corrupted (either the header or the data portion)or lost, according to user-defined probabilities- packets will be delivered in the order in which they were sent(although some can be lost).
**********************************************************************/#define BIDIRECTIONAL 0    /* change to 1 if you're doing extra credit *//* and write a routine called B_output *//* a "msg" is the data unit passed from layer 5 (teachers code) to layer  */
/* 4 (students' code).  It contains the data (characters) to be delivered */
/* to layer 5 via the students transport level protocol entities.         */
struct msg
{char data[20];
};/* a packet is the data unit passed from layer 4 (students code) to layer */
/* 3 (teachers code).  Note the pre-defined packet structure, which all   */
/* students must follow. */
struct pkt
{int seqnum;int acknum;int checksum;char payload[20];
};/********* STUDENTS WRITE THE NEXT SEVEN ROUTINES *********/
#define send_cnts_MAX 3
#define send_time_MAX  6struct msg A_msg;
int A_sendcnts;
float A_sendtime;/* called from layer 5, passed the data to be sent to other side */
A_output(message)struct msg message;
{starttimerr(A,A_sendtime);
}B_output(message)  /* need be completed only for extra credit */struct msg message;
{}/* called from layer 3, when a packet arrives for layer 4 */
A_input(packet)struct pkt packet;
{}/* called when A's timer goes off */
A_timerinterrupt()
{}/* the following routine will be called once (only) before any other */
/* entity A routines are called. You can use it to do any initialization */
A_init()
{int i;for(i=0;i<20;++i)A_msg[i] = '\0';A_sendcnts = 0;A_sendtime = 0;
}/* Note that with simplex transfer from a-to-B, there is no B_output() *//* called from layer 3, when a packet arrives for layer 4 at B*/
B_input(packet)struct pkt packet;
{}/* called when B's timer goes off */
B_timerinterrupt()
{}/* the following rouytine will be called once (only) before any other */
/* entity B routines are called. You can use it to do any initialization */
B_init()
{}/*****************************************************************
***************** NETWORK EMULATION CODE STARTS BELOW ***********
The code below emulates the layer 3 and below network environment:- emulates the tranmission and delivery (possibly with bit-level corruptionand packet loss) of packets across the layer 3/4 interface- handles the starting/stopping of a timer, and generates timerinterrupts (resulting in calling students timer handler).- generates message to be sent (passed from later 5 to 4)THERE IS NOT REASON THAT ANY STUDENT SHOULD HAVE TO READ OR UNDERSTAND
THE CODE BELOW.  YOU SHOLD NOT TOUCH, OR REFERENCE (in your code) ANY
OF THE DATA STRUCTURES BELOW.  If you're interested in how I designed
the emulator, you're welcome to look at the code - but again, you should have
to, and you defeinitely should not have to modify
******************************************************************/struct event {float evtime;           /* event time */int evtype;             /* event type code */int eventity;           /* entity where event occurs */struct pkt *pktptr;     /* ptr to packet (if any) assoc w/ this event */struct event *prev;struct event *next;};
struct event *evlist = NULL;   /* the event list *//* possible events: */int TRACE = 1;             /* for my debugging */
int nsim = 0;              /* number of messages from 5 to 4 so far */
int nsimmax = 0;           /* number of msgs to generate, then stop */
float time = 0.000;
float lossprob;            /* probability that a packet is dropped  */
float corruptprob;         /* probability that one bit is packet is flipped */
float lambda;              /* arrival rate of messages from layer 5 */
int   ntolayer3;           /* number sent into layer 3 */
int   nlost;               /* number lost in media */
int ncorrupt;              /* number corrupted by media*/main()
{struct event *eventptr;struct msg  msg2give;struct pkt  pkt2give;int i,j;char c;init();A_init();B_init();while (1){eventptr = evlist;            /* get next event to simulate */if (eventptr==NULL)goto terminate;evlist = evlist->next;        /* remove this event from event list */if (evlist!=NULL)evlist->prev=NULL;if (TRACE>=2){printf("\nEVENT time: %f,",eventptr->evtime);printf("  type: %d",eventptr->evtype);if (eventptr->evtype==0)printf(", timerinterrupt  ");else if (eventptr->evtype==1)printf(", fromlayer5 ");elseprintf(", fromlayer3 ");printf(" entity: %d\n",eventptr->eventity);}time = eventptr->evtime;        /* update time to next event time */if (nsim==nsimmax)break;                        /* all done with simulation */if (eventptr->evtype == FROM_LAYER5){generate_next_arrival();   /* set up future arrival *//* fill in msg to give with string of same letter */j = nsim % 26;for (i=0; i<20; i++)msg2give.data[i] = 97 + j;if (TRACE>2){printf("          MAINLOOP: data given to student: ");for (i=0; i<20; i++)printf("%c", msg2give.data[i]);printf("\n");}nsim++;if (eventptr->eventity == A)A_output(msg2give);elseB_output(msg2give);}else if (eventptr->evtype ==  FROM_LAYER3){pkt2give.seqnum = eventptr->pktptr->seqnum;pkt2give.acknum = eventptr->pktptr->acknum;pkt2give.checksum = eventptr->pktptr->checksum;for (i=0; i<20; i++)pkt2give.payload[i] = eventptr->pktptr->payload[i];if (eventptr->eventity ==A)      /* deliver packet by calling */A_input(pkt2give);            /* appropriate entity */elseB_input(pkt2give);free(eventptr->pktptr);          /* free the memory for packet */}else if (eventptr->evtype ==  TIMER_INTERRUPT){if (eventptr->eventity == A)A_timerinterrupt();elseB_timerinterrupt();}else    printf("INTERNAL PANIC: unknown event type \n");free(eventptr);}terminate:printf(" Simulator terminated at time %f\n after sending %d msgs from layer5\n",time,nsim);
}init()                         /* initialize the simulator */
{int i;float sum, avg;float jimsrand();printf("-----  Stop and Wait Network Simulator Version 1.1 -------- \n\n");printf("Enter the number of messages to simulate: ");scanf("%d",&nsimmax);       // 发送数据包数目printf("Enter packet loss probability [enter 0.0 for no loss]:");scanf("%f",&lossprob);      // 丢包率printf("Enter packet corruption probability [0.0 for no corruption]:");scanf("%f",&corruptprob);   // 包损坏率printf("Enter average time between messages from sender's layer5 [ > 0.0]:");scanf("%f",&lambda);        // 平均物理层传输时间printf("Enter TRACE:");scanf("%d",&TRACE);         // 追踪 用于调试的srand(9999);              /* init random number generator */sum = 0.0;                /* test random number generator for students */for (i=0; i<1000; i++)sum=sum+jimsrand();    /* jimsrand() should be uniform in [0,1] */avg = sum/1000.0;         // 随机概率 估计值在0.25 ~ 0.75if (avg < 0.25 || avg > 0.75){printf("It is likely that random number generation on your machine\n" );printf("is different from what this emulator expects.  Please take\n");printf("a look at the routine jimsrand() in the emulator code. Sorry. \n");exit(0);}ntolayer3 = 0;nlost = 0;ncorrupt = 0;time=0.0;                    /* initialize time to 0.0 */generate_next_arrival();     /* initialize event list */
}/****************************************************************************/
/* jimsrand(): return a float in range [0,1].  The routine below is used to */
/* isolate all random number generation in one location.  We assume that the*/
/* system-supplied rand() function return an int in therange [0,mmm]        */
/****************************************************************************/float jimsrand()
{double mmm = 2147483647;   /* largest int  - MACHINE DEPENDENT!!!!!!!!   */float x;                   /* individual students may need to change mmm */x = rand()/mmm;            /* x should be uniform in [0,1] */return(x);
}/********************* EVENT HANDLINE ROUTINES *******/
/*  The next set of routines handle the event list   */
/*****************************************************/generate_next_arrival()
{double x,log(),ceil();struct event *evptr;char *malloc();float ttime;int tempint;if (TRACE>2)printf("          GENERATE NEXT ARRIVAL: creating new arrival\n");x = lambda*jimsrand()*2;  /* x is uniform on [0,2*lambda] *//* having mean of lambda        */evptr = (struct event *)malloc(sizeof(struct event));evptr->evtime =  time + x;evptr->evtype =  FROM_LAYER5;if (BIDIRECTIONAL && (jimsrand()>0.5) )evptr->eventity = B;elseevptr->eventity = A;insertevent(evptr);
}// 由之前生成的包中的eventtime决定 传输顺序 在队列中的什么位置
insertevent(p)struct event *p;
{struct event *q,*qold;if (TRACE>2){printf("            INSERTEVENT: time is %lf\n",time);printf("            INSERTEVENT: future time will be %lf\n",p->evtime);}q = evlist;     /* q points to header of list in which p struct inserted */if (q==NULL)    /* list is empty */{evlist=p;p->next=NULL;p->prev=NULL;}else{for (qold = q; q !=NULL && p->evtime > q->evtime; q=q->next)qold=q;if (q==NULL)    /* end of list */{qold->next = p;p->prev = qold;p->next = NULL;}else if (q==evlist) /* front of list */{p->next=evlist;p->prev=NULL;p->next->prev=p;evlist = p;}else            /* middle of list */{p->next=q;p->prev=q->prev;q->prev->next=p;q->prev=p;}}
}printevlist()
{struct event *q;int i;printf("--------------\nEvent List Follows:\n");for(q = evlist; q!=NULL; q=q->next)printf("Event time: %f, type: %d entity: %d\n",q->evtime,q->evtype,q->eventity);printf("--------------\n");
}/********************** Student-callable ROUTINES ***********************//* called by students routine to cancel a previously-started timer */
stoptimer(AorB)int AorB;  /* A or B is trying to stop timer */
{struct event *q,*qold;if (TRACE>2)printf("          STOP TIMER: stopping timer at %f\n",time);/* for (q=evlist; q!=NULL && q->next!=NULL; q = q->next)  */for (q=evlist; q!=NULL ; q = q->next){/* remove this event */if ( (q->evtype==TIMER_INTERRUPT  && q->eventity==AorB) ){if (q->next==NULL && q->prev==NULL)evlist=NULL;         /* remove first and only event on list */else if (q->next==NULL) /* end of list - there is one in front */q->prev->next = NULL;else if (q==evlist)     /* front of list - there must be event after */{q->next->prev=NULL;evlist = q->next;}else    /* middle of list */{q->next->prev = q->prev;q->prev->next =  q->next;}free(q);return;}}printf("Warning: unable to cancel your timer. It wasn't running.\n");
}starttimer(AorB,increment)int AorB;  /* A or B is trying to stop timer */float increment;
{struct event *q;struct event *evptr;char *malloc();if (TRACE>2)printf("          START TIMER: starting timer at %f\n",time);/* be nice: check to see if timer is already started, if so, then  warn *//* for (q=evlist; q!=NULL && q->next!=NULL; q = q->next)  */for (q=evlist; q!=NULL ; q = q->next){if (q->evtype==TIMER_INTERRUPT  && q->eventity==AorB ){printf("Warning: attempt to start a timer that is already started\n");return;}}/* create future event for when timer goes off */evptr = (struct event *)malloc(sizeof(struct event));evptr->evtime =  time + increment;evptr->evtype =  TIMER_INTERRUPT;evptr->eventity = AorB;insertevent(evptr);
}/************************** TOLAYER3 ***************/
tolayer3(AorB,packet)int AorB;  /* A or B is trying to stop timer */
struct pkt packet;
{struct pkt *mypktptr;struct event *evptr,*q;char *malloc();float lastime, x, jimsrand();int i;ntolayer3++;/* simulate losses: */if (jimsrand() < lossprob){nlost++;if (TRACE>0)printf("          TOLAYER3: packet being lost\n");return;}/* make a copy of the packet student just gave me since he/she may decide */
/* to do something with the packet after we return back to him/her */mypktptr = (struct pkt *)malloc(sizeof(struct pkt));mypktptr->seqnum = packet.seqnum;mypktptr->acknum = packet.acknum;mypktptr->checksum = packet.checksum;for (i=0; i<20; i++)mypktptr->payload[i] = packet.payload[i];if (TRACE>2){printf("          TOLAYER3: seq: %d, ack %d, check: %d ", mypktptr->seqnum,mypktptr->acknum,  mypktptr->checksum);for (i=0; i<20; i++)printf("%c",mypktptr->payload[i]);printf("\n");}/* create future event for arrival of packet at the other side */evptr = (struct event *)malloc(sizeof(struct event));evptr->evtype =  FROM_LAYER3;   /* packet will pop out from layer3 */evptr->eventity = (AorB+1) % 2; /* event occurs at other entity */evptr->pktptr = mypktptr;       /* save ptr to my copy of packet *//* finally, compute the arrival time of packet at the other end.medium can not reorder, so make sure packet arrives between 1 and 10time units after the latest arrival time of packetscurrently in the medium on their way to the destination */lastime = time;/* for (q=evlist; q!=NULL && q->next!=NULL; q = q->next) */for (q=evlist; q!=NULL ; q = q->next){if ( (q->evtype==FROM_LAYER3  && q->eventity==evptr->eventity) )lastime = q->evtime;}evptr->evtime =  lastime + 1 + 9*jimsrand();/* simulate corruption: */if (jimsrand() < corruptprob){ncorrupt++;if ( (x = jimsrand()) < .75)mypktptr->payload[0]='Z';   /* corrupt payload */else if (x < .875)mypktptr->seqnum = 999999;elsemypktptr->acknum = 999999;if (TRACE>0)printf("          TOLAYER3: packet being corrupted\n");}if (TRACE>2)printf("          TOLAYER3: scheduling arrival on other side\n");insertevent(evptr);
}tolayer5(AorB,datasent)int AorB;char datasent[20];
{int i;if (TRACE>2){printf("          TOLAYER5: data received: ");for (i=0; i<20; i++)printf("%c",datasent[i]);printf("\n");}
}

原模板代码（稍加分析）

有什么说什么做这个Lab的老师写的代码也太不规范了吧
不知道是不是年代很久以前？还是怎么样我光理解很多地方都理解了很久 - - 真的很看不懂一些地方的赋值初始化命名方式

真的很想改一些地方的但是源于感谢这个Lab老师编写的代码还有老师在代码的注释行专门强调了不允许修改下面的代码既然这样源于尊重和理解我们就不改了

但是最后还是改了因为一些需求
首先我想用累积确认还有仅用ACK确认最后一次已经收到的包这样的话就可以不用ACK和NAK了 我是想先把交替位协议版本给做了再做有流水线的GBN滑动窗口 反正刚开始它让我们要用NAK 和 ACK 我就用了之后的话对于GBN我再改吧

对了这里我实现的仅实现了单边的交流没有实现双边的- - 能力有限对于双边的或者更好的就留在CS144那里来弄吧

对于刚开始拿到这个代码的hxd来说确实挺难的因为各个地方都没有思路这里的话我对每个代码块做一个小说明吧因为基本上代码我都是看完了再来写的

A_output(message) A的应用层到传输层 Layer5->Layer3 协议包装msg包装成数据包packet
A_input(packet) A的传输层处理数据包对于坏包或者检测错误用于处理不需要回传给应用层
A_timerinterrupt() A的计时器如果超时的话则进入A_timerinterrupt处理进入函数处理由一个队列（老师自己做的模拟器后面会写）自动处理
A_init() 最开始的初始化我初始化的很少处理了一些全局变量
B_init() 最开始的初始化B 对于交替位处理我基本没怎么做处理
B_input(packet) B的传输层处理数据包负责给A传输ACK那些的如果包数据正确即向第五层应用层发送

说了一下我们需要编写的五个函数
如果对于双方都有交互的话其实对于B的超时器还是得弄一个但是我们现在先做单边的交替位实验就省了

我先说一下这个实验的网络模拟器的大致怎么回事
光看我这个文字是对整个Lab没有一个大致的了解的我们得一步步看主函数里面的流程先是初始化各种参数参数包括 总共发多少条信息 丢包率 坏包率 两条信息预计发送的间隔 调试信息等级

先说一下 两条信息预计发送间隔是怎么回事我们的信息发送是根据一个evlist来的对于超时器其实也是一个event 他是根据任务发生时间来排序的这里再提一嘴我们的消息发送过去一般是5的时间单位两条信息时间间隔是我们的evlist自动循环的也就是如果设置为20 那我们的信息也就是自动平均20往外发送一条新的 而不是受我们控制当然如果是对于重传的那些当然是我们控制例如我们此刻为10的时间单位要发送的信息5秒后到达那就是预计15秒后到那我们的发送任务就插入任务队列根据时间排序如果我们的定时器就在发送的时候启动我们自己设置多少秒后停止定时器启动A_timerinterrupt 比如12秒因为来回大概是5*2=10秒定时器就按照任务终止时间插入到任务队列进去了

上面写了很多但原理就是这样对于丢包 包损坏 这些都是随机数产生的详情请见tolayer3是怎么控制 丢包和包损坏的
然后就是自己填了刚开始调试的时候可以填写10 0 0 100 3 看看信息seq ack是否正确然后再坏包看看自己的重传是否成功了把这些做了大概就对于交替位协议版本有个认识了

交替位协议版本代码实现

这个Lab分两篇博客来发因为这篇博客已经快3w字了当然是包括代码的字数编辑字的时候开始有点点卡顿了 - - 所以分两篇来吧这样看起来也更好看一点
这里贴了我实现的GBN的博客链接
实现可靠的传输协议（下）（GBN版本）

这里写一下我的交替位协议版本代码实现思路
首先是A发送给B包则即刻开始计时器发送过去文档中说了一般都是5个时间单位则我们代码设置的超时时间为12个时间单位
由于我们的信息发送是由evlist自动控制的如果两个信息发送时间间隔太短的话就不存在交替的情况了如果忽略不发那条信息的话也不好所以我们就设置长一点按照文档推荐的1000来设置意思就是发送完第一条消息后 1000秒后再发第二条中间有充足的时间重传 ACK确认

我们的交替位思路如下
A->B 即刻打开超时器
B->A 如果checksum 不相等则将ack位置为0 相等的话 ack位置为1 acknum = A_packet.seq+1 表示确认
A收到消息有下面几种情况 第一个就是发送出去丢包那就是超时器到了时间自己重发第二个就是接受到的ack位为0 即nak 或者 checksum错了立即关闭之前的超时器并重新设置超时器立即重发第三个就是真的由于延迟晚到了还是会被超时器重发
A如果正确收到消息后我们即关闭超时器停止即可等到evlist 下一次的自动发送

但是考虑下面这种情况如果A->B成功发送且无错仅因为延迟问题晚到了后超时器又重发消息之后连续两个ack 我们对于定时器我们每次正确收到消息的时候就自动关闭之前所有的超时器那么第二次ack就没有超时器关闭
对于这个情况我们的程序发送printf("Warning: unable to cancel your timer. It wasn't running.\n"); 哈哈其实没有超时器关就没有呗反正都ack了关都关完了该关的也关了也就不管了对程序也没有影响

好了就说那么多有点困了 - - 下面直接放代码大家凑合着看
睡醒了忽然忘了有点东西忘了说了模板中的一些代码我也还是改了部分的比如我的数据包里面多了个ack 有些地方根据个人需求来改毕竟程序是自己跑的嘛哈哈哈去吃晚饭了！

#include <stdio.h>/* ******************************************************************ALTERNATING BIT AND GO-BACK-N NETWORK EMULATOR: VERSION 1.1  J.F.KuroseThis code should be used for PA2, unidirectional or bidirectionaldata transfer protocols (from A to B. Bidirectional transfer of datais for extra credit and is not required).  Network properties:- one way network delay averages five time units (longer if thereare other messages in the channel for GBN), but can be larger- packets can be corrupted (either the header or the data portion)or lost, according to user-defined probabilities- packets will be delivered in the order in which they were sent(although some can be lost).
**********************************************************************/#define BIDIRECTIONAL 0    /* change to 1 if you're doing extra credit *//* and write a routine called B_output */
#define  TIMER_INTERRUPT 0
#define  FROM_LAYER5     1
#define  FROM_LAYER3     2#define  OFF             0
#define  ON              1
#define   A    0
#define   B    1typedef int bool;
#define true 1
#define false 0/* a "msg" is the data unit passed from layer 5 (teachers code) to layer  */
/* 4 (students' code).  It contains the data (characters) to be delivered */
/* to layer 5 via the students transport level protocol entities.         */
struct msg
{char data[20];
};/* a packet is the data unit passed from layer 4 (students code) to layer */
/* 3 (teachers code).  Note the pre-defined packet structure, which all   */
/* students must follow. */
struct pkt
{int seqnum;int acknum;int checksum;int ack;char payload[20];
};/********* STUDENTS WRITE THE NEXT SEVEN ROUTINES *********/const float send_time_MAX = 12.0;
struct pkt A_packet;
int A_sendseq;
int B_acknum;/* called from layer 5, passed the data to be sent to other side */
A_output(message)struct msg message;
{int i,checksum = 0;for(i=0;i<20;++i){checksum += message.data[i];A_packet.payload[i] = message.data[i];}A_packet.seqnum = A_sendseq;A_packet.acknum = 0;A_packet.ack = 1;A_packet.checksum = checksum + A_packet.seqnum + A_packet.acknum + A_packet.ack;starttimer(A,send_time_MAX);tolayer3(A,A_packet);
}/* called from layer 3, when a packet arrives for layer 4 */
A_input(packet)struct pkt packet;
{int checksum = 0,i;for(i=0;i<20;++i)checksum += packet.payload[i];checksum += (packet.ack + packet.acknum + packet.seqnum);if(checksum == packet.checksum && packet.ack){A_sendseq += (packet.acknum - A_sendseq);stoptimer(A);}else if(!packet.ack || packet.acknum != A_sendseq + 1 || checksum != packet.checksum){stoptimer(A);starttimer(A,send_time_MAX);tolayer3(A,A_packet);}
}/* called when A's timer goes off */
A_timerinterrupt()
{starttimer(A,send_time_MAX);tolayer3(A,A_packet);
}/* the following routine will be called once (only) before any other */
/* entity A routines are called. You can use it to do any initialization */
A_init()
{A_sendseq = 0;
}/* the following rouytine will be called once (only) before any other */
/* entity B routines are called. You can use it to do any initialization */
B_init()
{B_acknum = -1;
}/* Note that with simplex transfer from a-to-B, there is no B_output() */
/* called from layer 3, when a packet arrives for layer 4 at B*/
B_input(packet)struct pkt packet;
{int i,checksum = 0;for(i=0;i<20;++i)checksum += packet.payload[i];checksum += (packet.seqnum + packet.acknum + packet.ack);struct pkt* p = (struct pkt*)malloc(sizeof(struct pkt));struct pkt send_packet = *p;for(i=0;i<20;++i)send_packet.payload[i] = '\0';if(checksum == packet.checksum){if(B_acknum < packet.seqnum+1) tolayer5(B,packet.payload);send_packet.seqnum = 1;send_packet.acknum = packet.seqnum + 1;send_packet.ack = 1;B_acknum = send_packet.acknum;send_packet.checksum = send_packet.seqnum + send_packet.acknum + send_packet.ack;}else{send_packet.seqnum = 1;send_packet.acknum = packet.seqnum + 1;send_packet.ack = 0;send_packet.checksum = send_packet.seqnum + send_packet.acknum + send_packet.ack;}tolayer3(B,send_packet);
}B_output(message)  /* need be completed only for extra credit */struct msg message;
{}/* called when B's timer goes off */
B_timerinterrupt()
{}/*****************************************************************
***************** NETWORK EMULATION CODE STARTS BELOW ***********
The code below emulates the layer 3 and below network environment:- emulates the tranmission and delivery (possibly with bit-level corruptionand packet loss) of packets across the layer 3/4 interface- handles the starting/stopping of a timer, and generates timerinterrupts (resulting in calling students timer handler).- generates message to be sent (passed from later 5 to 4)THERE IS NOT REASON THAT ANY STUDENT SHOULD HAVE TO READ OR UNDERSTAND
THE CODE BELOW.  YOU SHOLD NOT TOUCH, OR REFERENCE (in your code) ANY
OF THE DATA STRUCTURES BELOW.  If you're interested in how I designed
the emulator, you're welcome to look at the code - but again, you should have
to, and you defeinitely should not have to modify
******************************************************************/struct event {float evtime;           /* event time */int evtype;             /* event type code */int eventity;           /* entity where event occurs */struct pkt *pktptr;     /* ptr to packet (if any) assoc w/ this event */struct event *prev;struct event *next;};
struct event *evlist = NULL;   /* the event list */int TRACE = 1;             /* for my debugging */
int nsim = 0;              /* number of messages from 5 to 4 so far */
int nsimmax = 0;           /* number of msgs to generate, then stop */
float time = 0.000;
float lossprob;            /* probability that a packet is dropped  */
float corruptprob;         /* probability that one bit is packet is flipped */
float lambda;              /* arrival rate of messages from layer 5 */
int   ntolayer3;           /* number sent into layer 3 */
int   nlost;               /* number lost in media */
int ncorrupt;              /* number corrupted by media*/main()
{struct event *eventptr;struct msg  msg2give;struct pkt  pkt2give;int i,j;char c;init();A_init();B_init();while (1){eventptr = evlist;            /* get next event to simulate */if (eventptr==NULL)goto terminate;evlist = evlist->next;        /* remove this event from event list */if (evlist!=NULL)evlist->prev=NULL;if (TRACE>=2){printf("\nEVENT time: %f,",eventptr->evtime);printf("  type: %d",eventptr->evtype);if (eventptr->evtype==0)printf(", timerinterrupt  ");else if (eventptr->evtype==1)printf(", fromlayer5 ");elseprintf(", fromlayer3 ");printf(" entity: %d\n",eventptr->eventity);}time = eventptr->evtime;        /* update time to next event time */if (nsim==nsimmax)break;                        /* all done with simulation */if (eventptr->evtype == FROM_LAYER5){generate_next_arrival();   /* set up future arrival *//* fill in msg to give with string of same letter */j = nsim % 26;for (i=0; i<20; i++)msg2give.data[i] = 97 + j;if (TRACE>2){printf("          MAINLOOP: data given to student: ");for (i=0; i<20; i++)printf("%c", msg2give.data[i]);printf("\n");}nsim++;if (eventptr->eventity == A)A_output(msg2give);elseB_output(msg2give);}else if (eventptr->evtype ==  FROM_LAYER3){pkt2give.seqnum = eventptr->pktptr->seqnum;pkt2give.acknum = eventptr->pktptr->acknum;pkt2give.checksum = eventptr->pktptr->checksum;pkt2give.ack = eventptr->pktptr->ack;for (i=0; i<20; i++)pkt2give.payload[i] = eventptr->pktptr->payload[i];if (eventptr->eventity == A)      /* deliver packet by calling */A_input(pkt2give);            /* appropriate entity */elseB_input(pkt2give);free(eventptr->pktptr);          /* free the memory for packet */}else if (eventptr->evtype ==  TIMER_INTERRUPT){if (eventptr->eventity == A)A_timerinterrupt();elseB_timerinterrupt();}else    printf("INTERNAL PANIC: unknown event type \n");free(eventptr);}terminate:printf(" Simulator terminated at time %f\n after sending %d msgs from layer5\n",time,nsim);
}init()                         /* initialize the simulator */
{int i;float sum, avg;float jimsrand();printf("-----  Stop and Wait Network Simulator Version 1.1 -------- \n\n");printf("Enter the number of messages to simulate: ");scanf("%d",&nsimmax);       // 发送数据包数目printf("Enter packet loss probability [enter 0.0 for no loss]:");scanf("%f",&lossprob);      // 丢包率printf("Enter packet corruption probability [0.0 for no corruption]:");scanf("%f",&corruptprob);   // 包损坏率printf("Enter average time between messages from sender's layer5 [ > 0.0]:");scanf("%f",&lambda);        // 平均物理层传输时间printf("Enter TRACE:");scanf("%d",&TRACE);         // 追踪 用于调试的srand(9999);              /* init random number generator */sum = 0.0;                /* test random number generator for students */for (i=0; i<1000; i++)sum=sum+jimsrand();    /* jimsrand() should be uniform in [0,1] */avg = sum/1000.0;         // 随机概率 估计值在0.25 ~ 0.75if (avg < 0.25 || avg > 0.75){printf("It is likely that random number generation on your machine\n" );printf("is different from what this emulator expects.  Please take\n");printf("a look at the routine jimsrand() in the emulator code. Sorry. \n");exit(0);}ntolayer3 = 0;nlost = 0;ncorrupt = 0;time=0.0;                    /* initialize time to 0.0 */generate_next_arrival();     /* initialize event list */
}/****************************************************************************/
/* jimsrand(): return a float in range [0,1].  The routine below is used to */
/* isolate all random number generation in one location.  We assume that the*/
/* system-supplied rand() function return an int in therange [0,mmm]        */
/****************************************************************************/float jimsrand()
{double mmm = 0x7fff;   /* largest int  - MACHINE DEPENDENT!!!!!!!!   */float x;                   /* individual students may need to change mmm */x = rand()/mmm;            /* x should be uniform in [0,1] */return(x);
}/********************* EVENT HANDLINE ROUTINES *******/
/*  The next set of routines handle the event list   */
/*****************************************************/generate_next_arrival()
{double x,log(),ceil();struct event *evptr;char *malloc();float ttime;int tempint;if (TRACE>2)printf("          GENERATE NEXT ARRIVAL: creating new arrival\n");x = lambda*jimsrand()*2;  /* x is uniform on [0,2*lambda] *//* having mean of lambda        */evptr = (struct event *)malloc(sizeof(struct event));evptr->evtime =  time + x;evptr->evtype =  FROM_LAYER5;if (BIDIRECTIONAL && (jimsrand()>0.5) )evptr->eventity = B;elseevptr->eventity = A;insertevent(evptr);
}// 由之前生成的包中的eventtime决定 传输顺序 在队列中的什么位置
insertevent(p)struct event *p;
{struct event *q,*qold;if (TRACE>2){printf("            INSERTEVENT: time is %lf\n",time);printf("            INSERTEVENT: future time will be %lf\n",p->evtime);}q = evlist;     /* q points to header of list in which p struct inserted */if (q==NULL)    /* list is empty */{evlist=p;p->next=NULL;p->prev=NULL;}else{for (qold = q; q !=NULL && p->evtime > q->evtime; q=q->next)qold=q;if (q==NULL)    /* end of list */{qold->next = p;p->prev = qold;p->next = NULL;}else if (q==evlist) /* front of list */{p->next=evlist;p->prev=NULL;p->next->prev=p;evlist = p;}else            /* middle of list */{p->next=q;p->prev=q->prev;q->prev->next=p;q->prev=p;}}
}printevlist()
{struct event *q;int i;printf("--------------\nEvent List Follows:\n");for(q = evlist; q!=NULL; q=q->next)printf("Event time: %f, type: %d entity: %d\n",q->evtime,q->evtype,q->eventity);printf("--------------\n");
}/********************** Student-callable ROUTINES ***********************//* called by students routine to cancel a previously-started timer */
stoptimer(AorB)int AorB;  /* A or B is trying to stop timer */
{struct event *q,*qold;if (TRACE>2)printf("          STOP TIMER: stopping timer at %f\n",time);/* for (q=evlist; q!=NULL && q->next!=NULL; q = q->next)  */for (q=evlist; q!=NULL ; q = q->next){/* remove this event */if ( (q->evtype==TIMER_INTERRUPT  && q->eventity==AorB) ){if (q->next==NULL && q->prev==NULL)evlist=NULL;         /* remove first and only event on list */else if (q->next==NULL) /* end of list - there is one in front */q->prev->next = NULL;else if (q==evlist)     /* front of list - there must be event after */{q->next->prev=NULL;evlist = q->next;}else    /* middle of list */{q->next->prev = q->prev;q->prev->next =  q->next;}free(q);return;}}printf("Warning: unable to cancel your timer. It wasn't running.\n");
}starttimer(AorB,increment)int AorB;  /* A or B is trying to stop timer */float increment;
{struct event *q;struct event *evptr;char *malloc();if (TRACE>2)printf("          START TIMER: starting timer at %f\n",time);/* be nice: check to see if timer is already started, if so, then  warn *//* for (q=evlist; q!=NULL && q->next!=NULL; q = q->next)  */for (q=evlist; q!=NULL ; q = q->next){if (q->evtype==TIMER_INTERRUPT  && q->eventity==AorB ){printf("Warning: attempt to start a timer that is already started\n");return;}}/* create future event for when timer goes off */evptr = (struct event *)malloc(sizeof(struct event));evptr->evtime =  time + increment;evptr->evtype =  TIMER_INTERRUPT;evptr->eventity = AorB;insertevent(evptr);
}/************************** TOLAYER3 ***************/
tolayer3(AorB,packet)int AorB;  /* A or B is trying to stop timer */
struct pkt packet;
{struct pkt *mypktptr;struct event *evptr,*q;char *malloc();float lastime, x, jimsrand();int i;ntolayer3++;/* simulate losses: */if (jimsrand() < lossprob){nlost++;if (TRACE>0)printf("          TOLAYER3: packet being lost\n");return;}/* make a copy of the packet student just gave me since he/she may decide */
/* to do something with the packet after we return back to him/her */mypktptr = (struct pkt *)malloc(sizeof(struct pkt));mypktptr->seqnum = packet.seqnum;mypktptr->acknum = packet.acknum;mypktptr->ack = packet.ack;mypktptr->checksum = packet.checksum;for (i=0; i<20; i++)mypktptr->payload[i] = packet.payload[i];if (TRACE>2){printf("          TOLAYER3: seq: %d, acknum %d, check: %d ,ack %d ", mypktptr->seqnum,mypktptr->acknum,  mypktptr->checksum,mypktptr->ack);for (i=0; i<20; i++)printf("%c",mypktptr->payload[i]);printf("\n");}/* create future event for arrival of packet at the other side */evptr = (struct event *)malloc(sizeof(struct event));evptr->evtype =  FROM_LAYER3;   /* packet will pop out from layer3 */evptr->eventity = (AorB+1) % 2; /* event occurs at other entity */evptr->pktptr = mypktptr;       /* save ptr to my copy of packet *//* finally, compute the arrival time of packet at the other end.medium can not reorder, so make sure packet arrives between 1 and 10time units after the latest arrival time of packetscurrently in the medium on their way to the destination */lastime = time;/* for (q=evlist; q!=NULL && q->next!=NULL; q = q->next) */for (q=evlist; q!=NULL ; q = q->next){if ( (q->evtype==FROM_LAYER3  && q->eventity==evptr->eventity) )lastime = q->evtime;}evptr->evtime =  lastime + 1 + 9*jimsrand();/* simulate corruption: */if (jimsrand() < corruptprob){ncorrupt++;if ( (x = jimsrand()) < .75)mypktptr->payload[0]='Z';   /* corrupt payload */else if (x < .875)mypktptr->seqnum = 999999;elsemypktptr->acknum = 999999;if (TRACE>0)printf("          TOLAYER3: packet being corrupted\n");}if (TRACE>2)printf("          TOLAYER3: scheduling arrival on other side\n");insertevent(evptr);
}tolayer5(AorB,datasent)int AorB;char datasent[20];
{int i;if (TRACE>2){printf("          TOLAYER5: data received: ");for (i=0; i<20; i++)printf("%c",datasent[i]);printf("\n");}
}

交替位协议版本实现效果

其实我还是调试了很久才弄出来的- - 因为各种问题
首先得理解程序才能写然后自己得看各种地方出没出错然后得注意细节还得按照程序原本的发送方式发送理解了才能写的出来调试出来下面就是大概的流程了

下面找一段非常典型的来发出来吧

理一下下面发生了什么吧
786s 发送包预计795s到达
786s 开始计时器预计798s重发

786s 包损坏 795s 包不仅损坏还丢失了
798s 重发定时器启动立马开始重发重启定时器 810s再次重发
798s 刚发的包又丢失了
810s 再次重启的定时器启动预计811s 到达定时器同时再次启动预计822s重发
811s 到达且包正常
.....

由于我的丢包率和坏包率设置的很高好像两个都是百分之30 就出现了上面的情况由于两条信息的间隔我设置的很高好像是1000 就不会存在还在重发就会发出第二条新消息的情况反正到最后就发出去了 …

这个例子挑的好像不是很好但还是能看得出来定时器的重要性和时间设置的重要性比特位交互的效率肯定是很低的最常用的还是需要滑动窗口那这篇博客就先到这里 ^^ GBN下一篇博客写