Miscellaneous Lab1 Implementing a Reliable Transport Protocol
#include <stdio.h>
/* ******************************************************************
ALTERNATING BIT AND GO-BACK-N NETWORK EMULATOR: VERSION 1.1 J.F.Kurose
This code should be used for PA2, unidirectional or bidirectional
data transfer protocols (from A to B. Bidirectional transfer of data
is for extra credit and is not required). Network properties:
- one way network delay averages five time units (longer if there
are 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 *********/
/* called from layer 5, passed the data to be sent to other side */
/*
这段代码只实现了GBN协议——带有发送窗口的、累计确认的回退N步协议。
至于实验要求中的NAK，限于时间和408考试要求不再实现。
发送方的动作：
1. 收到上层rdt()调用，将用户报文加入缓存池后等待时机发送。
2. 在计时器超时发生时，将整个发送窗口内部的内容全数发送。
3. 收到一个ACK（不管是累计确认还是单个确认），判断报文是否出现差错，如果无差错就交付并且推动窗口。
接收方的动作：
1. 判断报文是否通过检验和
2. 返回ACK。
3. 定时发送累计ACK。 (2000ms)
*/
struct msg Q[1005];
#define wndSz 10
int head, tail; /*
在实际的Linux系统中，UDP、TCP接口应当是配合有一个内存池的，发送、接受窗口应该是独立于这个内存池的
另外的内存；这里为了讨论方便把两个内存池合二为一了。
*/
int hope; //B窗口的期望ACK。
int checkUp(struct pkt packet) {
int sum = 0;
short* take = &packet;
// 3 * int + 20 * char = 16 * 2B
for (int i = 0; i < 16; i ++) {
sum = sum + (int)(take[i] & ((1 << 16) - 1)); //一定要与这个16位全1，不然做的不是16位加法（位扩展成负数的情况下）
}
while (sum / 65536)
sum = sum % 65536 + sum / 65536;
short ans = sum;
ans = ~ans;
return ans & ((int)(1 << 16) - 1);
}
void sndMessage(int tail) {
struct pkt package;
package.seqnum = tail;
package.acknum = 0;
package.checksum = 0;
strncpy(package.payload, Q[tail].data, 20);
package.checksum = checkUp(package); //先给checksum设置成0，计算完之后再塞进去
tolayer3(0, package);
}
void A_output(message)
struct msg message;
{
if (head == tail) {
starttimer(0, 600.0);
} //有数据包了，设置一下计时器，否则不用计时。
Q[tail ++] = message;
if (tail < head + wndSz) {
sndMessage(tail - 1);
}
}
void B_output(message) /* need be completed only for extra credit */
struct msg message;
{
}
/* called from layer 3, when a packet arrives for layer 4 */
void A_input(packet)
struct pkt packet;
{
if (checkUp(packet)) {
printf("A收到的报文有差错.\n");
return; //ACK是否通过?
}
printf(" 收到了关于%d的ACK\n", packet.acknum);
for (int i = head; i <= packet.acknum; i ++) {
/*
一个思考是，这个过程中是不是要开中断？
*/
head ++;
if (head + wndSz < tail) {
sndMessage(head + wndSz); //根据ACK向后移动窗口. 可能是累计确认
}
}
if (head == tail) {
stoptimer(0);
}
}
/* called when A's timer goes off */
void A_timerinterrupt()
{
printf("\n重传: \n");
for (int i = head; i < (head + wndSz <= tail? head + wndSz: tail); i ++) {
sndMessage(i);
}
printf("\n重传结束\n");
starttimer(0, 600.0);
}
/* the following routine will be called once (only) before any other */
/* entity A routines are called. You can use it to do any initialization */
void A_init()
{
head = 0, tail = 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*/
void B_input(packet)
struct pkt packet;
{
if (checkUp(packet) || packet.seqnum > hope) {
if (checkUp(packet))
printf("B收到的报文有差错\n");
else
printf("B收到了一个不在接收窗口里的报文\n");
return; // 抛弃发生错误的报文以及ACK大于当前窗口的报文。
}
tolayer5(1, packet.payload);
struct pkt package;
package.seqnum = 0;
if (hope == packet.seqnum)
package.acknum = hope ++; //和当前窗口值相同，保存
else package.acknum = packet.seqnum; //否则丢弃
package.checksum = 0;
strcpy(package.payload, packet.payload);
package.checksum = checkUp(package);
tolayer3(1, package);
}
/* called when B's timer goes off */
char sent[20] = "this is a total ack";
void B_timerinterrupt()
{
printf("\nB的累计确认:\n");
struct pkt package;
package.seqnum = 0;
package.acknum = hope - 1;
package.checksum = 0;
strncpy(package.payload, sent, 20);
package.checksum = checkUp(package);
tolayer3(1, package);
starttimer(1, 2000.0); // 2000ms一次发送累计ACK.
}
/* the following rouytine will be called once (only) before any other */
/* entity B routines are called. You can use it to do any initialization */
void B_init()
{
hope = 0;
starttimer(1, 2000.0);
}
/*****************************************************************
***************** 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 corruption
and packet loss) of packets across the layer 3/4 interface
- handles the starting/stopping of a timer, and generates timer
interrupts (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 definitely 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: */
#define TIMER_INTERRUPT 0
#define FROM_LAYER5 1
#define FROM_LAYER3 2
#define OFF 0
#define ON 1
#define A 0
#define B 1
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*/
int 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("\n事件发生时间: %f,",eventptr->evtime);
// printf(" 来自终端: %d",eventptr->evtype);
if (eventptr->evtype==0)
printf(", 时钟中断 ");
else if (eventptr->evtype==1)
printf(", 收到应用层数据 ");
else
printf(", 收到网络层数据 ");
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(" 随机数据报文: ");
for (i=0; i<20; i++)
printf("%c", msg2give.data[i]);
printf("\n");
}
nsim++;
if (eventptr->eventity == A)
A_output(msg2give);
else
B_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 */
else
B_input(pkt2give);
free(eventptr->pktptr); /* free the memory for packet */
}
else if (eventptr->evtype == TIMER_INTERRUPT) {
if (eventptr->eventity == A)
A_timerinterrupt();
else
B_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);
}
void 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;
if (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 = 13331; /* largest int - MACHINE DEPENDENT!!!!!!!! */
float x; /* individual students may need to change mmm */
x = rand() % 13331 / 13331.0; /* x should be uniform in [0,1] */
return(x);
}
/********************* EVENT HANDLINE ROUTINES *******/
/* The next set of routines handle the event list */
/*****************************************************/
void 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;
else
evptr->eventity = A;
insertevent(evptr);
}
void 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;
}
}
}
void 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 */
void 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)
if ( (q->evtype==TIMER_INTERRUPT && q->eventity==AorB) ) {
/* remove this event */
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");
}
void 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 ***************/
void 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(" seq: %d, ack %d, check: %d ", packet.seqnum,
packet.acknum, packet.checksum);
printf(" IP数据报%d%c丢失.\n", AorB? packet.acknum :packet.seqnum, (AorB? 'B': 'A'));
}
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(" %c的网络层收到数据报: ", (AorB? 'B': 'A'));
printf(" 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 10
time units after the latest arrival time of packets
currently 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;
else
mypktptr->acknum = 999999;
if (TRACE>0)
printf(" 网路层: 数据报文%d%c被污染\n", packet.seqnum, (AorB? 'B': 'A'));
}
if (TRACE>2)
printf(" 网络层: 成功交付%d%c给%c\n", (AorB? packet.acknum: packet.seqnum), (AorB? 'B': 'A'), (AorB? 'A': 'B'));
insertevent(evptr);
}
void tolayer5(AorB,datasent)
int AorB;
char datasent[20];
{
int i;
if (TRACE>2) {
printf(" %c 的应用层收到上层的数据报: ", (AorB? 'B': 'A'));
for (i=0; i<20; i++)
printf("%c",datasent[i]);
printf("entity %c\n", (AorB? 'A': 'B'));
}
}
2136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
