Stop-and-Wait

最新推荐文章于 2022-11-28 16:39:21 发布
最新推荐文章于 2022-11-28 16:39:21 发布
阅读量1.8k 收藏 33
点赞数 5
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46387709/article/details/117703588
版权

Stop-and-Wait协议 C语言 错误检测 重传 定时器
关键词由CSDN通过智能技术生成

计算机网络Stop-and-Wait协议实现（C语言）

文章目录

前言

实现单向传输情景下的Stop-and-Wait
主要是填充实验给出的空函数块

一、总代码

#include <stdio.h>
#include <string.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 *********/

#define OK 1
#define ERROR 0
typedef struct msg msg;
typedef struct pkt pkt;
 
void ComputeCheckSum(pkt* packet){
    packet->checksum = packet->seqnum + packet->acknum;
    int i;
    for(i = 0;i < 20;i += 4){
        int tmp1 = (int)packet->payload[i];
        int tmp2 = (int)packet->payload[i + 1];
        int tmp3 = (int)packet->payload[i + 2];
        int tmp4 = (int)packet->payload[i + 3];
        tmp2 *= 256;
        tmp3 *= 65536;
        tmp4 *= 16777216;
        packet->checksum += (tmp1 + tmp2 + tmp3 + tmp4);
     }
     packet->checksum = ~ packet->checksum;
}//设置较错码 
int TestCheckSum(pkt* packet){
    int check = packet->checksum;
    check += (packet->seqnum + packet->acknum);
    int i;
    for(i = 0;i < 20;i += 4){
        int tmp1 = (int)packet->payload[i];
        int tmp2 = (int)packet->payload[i + 1];
        int tmp3 = (int)packet->payload[i + 2];
        int tmp4 = (int)packet->payload[i + 3];
        tmp2 *= 256;
        tmp3 *= 65536;
        tmp4 *= 16777216;
        check += (tmp1 + tmp2 + tmp3 + tmp4);
    }
    return check;
}//检测收到的较错码，确认收到的包是否有误 
int A_sequenceNum = 0;
int Ajudge = 1;//判断发送端是否能发送包 
float A_interval = 25.0;//重发时间间隔 
int B_sequenceNum = 0;
char ACK[20] = "ACK";
char NAK[20] = "NAK";
pkt A_pkt;
pkt B_pkt;

/* called from layer 5, passed the data to be sent to other side */
A_output(message)
  struct msg message;
{
if(Ajudge){
        strncpy(A_pkt.payload,message.data,20);//从message截取20字节放到payload内 
        int n;
        A_pkt.seqnum = A_sequenceNum;
        A_pkt.acknum = 0;
        A_sequenceNum = (A_sequenceNum + 1) % 2;//发送包序号1与0之间切换 
        Ajudge = 0;   
        ComputeCheckSum(&A_pkt);
        tolayer3(0,A_pkt);  //发送 
        starttimer(0,A_interval); //开始计时 
        printf("A: sending:\n");
        printf("   seq:%d, ack:%d check:%X\n",A_pkt.seqnum,A_pkt.acknum,A_pkt.checksum);
        printf("   message: ");
        for(n = 0;n < 20;n ++) printf("%c",A_pkt.payload[n]);
        printf("\n");
    }
    return OK;
	
}

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;
{
	printf("receive scknum:%d,looking for:%d\n",packet.acknum,(A_sequenceNum + 1) % 2);
    int point_num = (A_sequenceNum + 1) % 2;
    if(point_num != packet.acknum) 
	return ERROR;    
    if(TestCheckSum(&packet) == -1){     
        if(!strcmp(packet.payload,ACK)){
            printf("ACK!\n");
            Ajudge = 1;
            stoptimer(0);
            return OK;
        }//如果收到ACK，将Ajudge置1进行下一个包的传输 
        else{
            printf("NAK!\n");
            tolayer3(0,A_pkt);
            starttimer(0,A_interval);
            return OK;
        }//收到NAK，重新发包，重置定时器 
    }
    else{
        printf("corrupted!\n");
        return ERROR;
    }   
    return OK;
}

/* called when A's timer goes off */
A_timerinterrupt()
{
    tolayer3(0,A_pkt);
    starttimer(0,A_interval);
    int n;
    printf("sending:\n");
    printf("        seq:%d, ack:%d check:%X\n",A_pkt.seqnum,A_pkt.acknum,A_pkt.checksum);
    printf("        message:");
    for(n = 0;n < 20;n ++) printf("%c",A_pkt.payload[n]);
    printf("\n\n");   
    return OK;
}  //重发 

/* 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_sequenceNum = 0;
    Ajudge = 1;
    return OK;
}


/* 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 n;
    printf("receiving:\n");
    printf("          seq:%d, ack:%d check:%X\n",packet.seqnum,packet.acknum,packet.checksum);
    printf("          message:");
    for(n = 0;n < 20;n ++) printf("%c",packet.payload[n]);
    printf("\n\n");
    printf("receive:%d,looking for:%d\n",packet.seqnum,B_sequenceNum);
    if(packet.seqnum != B_sequenceNum){
        tolayer3(1,B_pkt);
        printf("B:sending:\n");
        printf("  seq:%d, ack:%d check:%X\n",B_pkt.seqnum,B_pkt.acknum,B_pkt.checksum);
        printf("  message:");
        for(n = 0;n < 20;n ++) printf("%c",B_pkt.payload[n]);
        printf("\n\n");
        return OK;
    }//处理发送包序号在过程中改变的情况，B端回复与上次之前的包 
    B_pkt.seqnum = 0;
    B_pkt.acknum = B_sequenceNum;
    
    if(TestCheckSum(&packet) == -1){      
        strncpy(B_pkt.payload,ACK,20);
        msg receive;
        strncpy(receive.data,packet.payload,20);
        tolayer5(1,receive); 
        B_sequenceNum = (B_sequenceNum + 1) % 2;       
    }//收到的包没有损坏 
    else{
	strncpy(B_pkt.payload,NAK,20);        
    ComputeCheckSum(&B_pkt);
    printf("B:sending:\n");
    printf("  seq:%d, ack:%d check:%X\n",B_pkt.seqnum,B_pkt.acknum,B_pkt.checksum);
    printf("  message:");
    for(n = 0;n < 20;n ++) printf("%c",B_pkt.payload[n]);
    printf("\n\n");
    tolayer3(1,B_pkt);
    return OK;
	}//收到的包与发送不一致 
}

/* called when B's timer goes off */
B_timerinterrupt()
{
	return OK;
}

/* 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_sequenceNum = 0;
    return OK;
}


/*****************************************************************
***************** 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 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: */
#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*/

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 ");
             else
	     printf(", 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);  
             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);
}



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;
   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(-1);
    }

   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 = 32767;   /* 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;
    else
      evptr->eventity = A;
   insertevent(evptr);
} 


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) 
    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");
}


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 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("          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");
   }
  
}

二、代码块

1.直接利用的函数

starttimer(calling_entity,increment) 其中calling_entity为0(用于启动a端计时器)或1(用于启动B端计时器)，increment是一个浮点值，表示在计时器中断之前将经过的时间。A的计时器应该只由A端例程启动(或停止)，b端计时器也是如此。给我们一个可以使用的适当增量值的概念:当媒体中没有其他消息时，发送到网络的数据包平均需要5个时间单位到达另一端。

stoptimer(calling_entity) 其中calling_entity为0(用于停止a端定时器)或1(用于停止B端定时器)。

tolayer3(calling_entity,packet) 其中calling_entity为0(用于a端发送)或1(用于B端发送)，并且packet是一个类型为pkt的结构。调用这个例程将导致数据包被发送到网络中，目的地是另一个实体。

tolayer5(calling_entity,message) 其中calling_entity为0(对于a端发送到第5层)或1(对于b端发送到第5层)，message是一个msg类型的结构。对于单向数据传输，我们将只调用calling_entity等于1(交付到b端)。调用这个例程将导致数据被传递到第5层。

2.结构体

两个在后面函数频繁用到的结构体，msg结构就是代表一个存储信息的数组，pkt代表一个包，题目中有A端，B端，默认A端发送包，B端将收到无误的包传给上层，以及根据包的对错发送NAK和ACK，所以对于A端pkt中的acknum一直为0，B端seqnum一直为1.

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];//发送窗口大小
    };

3.较错码

为防止两端收到的包出现被破坏的情况，在发送端设置了较错码，即pkt的checksum，在接收端定义了检测较错码的函数，通过取反加一的规律构造函数

void ComputeCheckSum(pkt* packet){
    packet->checksum = packet->seqnum + packet->acknum;
    int i;
    for(i = 0;i < 20;i += 4){
        int tmp1 = (int)packet->payload[i];
        int tmp2 = (int)packet->payload[i + 1];
        int tmp3 = (int)packet->payload[i + 2];
        int tmp4 = (int)packet->payload[i + 3];
        tmp2 *= 256;
        tmp3 *= 65536;
        tmp4 *= 16777216;
        packet->checksum += (tmp1 + tmp2 + tmp3 + tmp4);
     }
     packet->checksum = ~ packet->checksum;
}//设置较错码 
int TestCheckSum(pkt* packet){
    int check = packet->checksum;
    check += (packet->seqnum + packet->acknum);
    int i;
    for(i = 0;i < 20;i += 4){
        int tmp1 = (int)packet->payload[i];
        int tmp2 = (int)packet->payload[i + 1];
        int tmp3 = (int)packet->payload[i + 2];
        int tmp4 = (int)packet->payload[i + 3];
        tmp2 *= 256;
        tmp3 *= 65536;
        tmp4 *= 16777216;
        check += (tmp1 + tmp2 + tmp3 + tmp4);
    }
    return check;
}//检测收到的较错码，确认收到的包是否有误

4.变量

AB两端用到的变量

int A_sequenceNum = 0;
int Ajudge = 1;//判断发送端是否能发送包 
float A_interval = 25.0;//重发时间间隔 
int B_sequenceNum = 0;
char ACK[20] = "ACK";
char NAK[20] = "NAK";
pkt A_pkt;
pkt B_pkt;

5.A_output函数

其中message是msg类型的结构，包含要发送到b端的数据。这个例程将在发送侧(A)的上层有消息要发送时被调用。我们的协议的工作是确保这样一个消息中的数据被按顺序和正确地发送到接收方的上层。
A_output(message)
struct msg message;
{
if(Ajudge){
strncpy(A_pkt.payload,message.data,20);//从message截取20字节放到payload内
int n;
A_pkt.seqnum = A_sequenceNum;
A_pkt.acknum = 0;
A_sequenceNum = (A_sequenceNum + 1) % 2;//发送包序号1与0之间切换
Ajudge = 0;
ComputeCheckSum(&A_pkt);
tolayer3(0,A_pkt); //发送
starttimer(0,A_interval); //开始计时
printf(“A: sending:\n”);
printf(" seq:%d, ack:%d check:%X\n",A_pkt.seqnum,A_pkt.acknum,A_pkt.checksum);
printf(" message: “);
for(n = 0;n < 20;n ++) printf(”%c",A_pkt.payload[n]);
printf("\n");
}
return OK;

}

6.A_input函数

其中packet是pkt类型的结构。这个例程将在从b端发送的数据包到达a端时被调用(例如，由于b端过程执行tolayer3())。packet是从b端发送的数据包(可能已损坏)。

A_input(packet)
  struct pkt packet;
{
	printf("receive scknum:%d,looking for:%d\n",packet.acknum,(A_sequenceNum + 1) % 2);
    int point_num = (A_sequenceNum + 1) % 2;
    if(point_num != packet.acknum) 
	return ERROR;    //检测包是否被损坏
    if(TestCheckSum(&packet) == -1){     
        if(!strcmp(packet.payload,ACK)){
            printf("ACK!\n");
            Ajudge = 1;
            stoptimer(0);
            return OK;
        }//如果收到ACK，将Ajudge置1进行下一个包的传输 
        else{
            printf("NAK!\n");
            tolayer3(0,A_pkt);
            starttimer(0,A_interval);
            return OK;
        }//收到NAK，重新发包，重置定时器 
    }
    else{
        printf("corrupted!\n");
        return ERROR;
    }   
    return OK;
}

7.A_timerinterrupt()函数

这个例程将在A的计时器到期时被调用(从而产生一个计时器中断)。我们可能希望使用这个例程来控制数据包的重传。请参阅下面的starttimer()和stoptimer()了解计时器是如何启动和停止的。

A_timerinterrupt()
{
    tolayer3(0,A_pkt);
    starttimer(0,A_interval);
    int n;
    printf("sending:\n");
    printf("        seq:%d, ack:%d check:%X\n",A_pkt.seqnum,A_pkt.acknum,A_pkt.checksum);
    printf("        message:");
    for(n = 0;n < 20;n ++) printf("%c",A_pkt.payload[n]);
    printf("\n\n");   
    return OK;
}  //重发

8.B_input函数

其中packet是pkt类型的结构。这个例程将在从a端发送的数据包到达b端时被调用(例如，由于a端过程执行tolayer3())。packet是从a端发送的数据包(可能已损坏)。
最难理解的是B端的input函数，先总结一下B端接受信息会碰到的情况
首先需要比较的是包的序号，因为不排除A端包的序号由0变为1的可能性
其次比较包的内容，用到的就是较错码

1）如果包的序号发生改变，B端给的回应包的acknum应该与上次发送一致

if(packet.seqnum != B_sequenceNum){
        tolayer3(1,B_pkt);
        printf("B:sending:\n");
        printf("  seq:%d, ack:%d check:%X\n",B_pkt.seqnum,B_pkt.acknum,B_pkt.checksum);
        printf("  message:");
        for(n = 0;n < 20;n ++) printf("%c",B_pkt.payload[n]);
        printf("\n\n");
        return OK;
    }//处理发送包序号在过程中改变的情况，B端回复与上次之前的包

2）如果包内容改变（较错码改变）

 if(TestCheckSum(&packet) == -1){      
        strncpy(B_pkt.payload,ACK,20);
        msg receive;
        strncpy(receive.data,packet.payload,20);
        tolayer5(1,receive); 
        B_sequenceNum = (B_sequenceNum + 1) % 2;       
    }//收到的包没有损坏 
    else{
	strncpy(B_pkt.payload,NAK,20);        
    ComputeCheckSum(&B_pkt);
    printf("B:sending:\n");
    printf("  seq:%d, ack:%d check:%X\n",B_pkt.seqnum,B_pkt.acknum,B_pkt.checksum);
    printf("  message:");
    for(n = 0;n < 20;n ++) printf("%c",B_pkt.payload[n]);
    printf("\n\n");
    tolayer3(1,B_pkt);
    return OK;
	}//收到的包与发送不一致

总结

比较困难的是情况考虑的全面，一直忘记包的序号也会改变这一情况，所以对于信息传输，一定要考虑可能发生的每种情况，以及应对的措施，不然总会有意想不到的结果发生

￥布川内酷￥
关注
  • 5
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算机网络之传输层（上）
yang_yi520的博客
07-02 368
checksum 校验和 ************************可靠数据传输没有仔细看*******************************有限状态自动机。箭头代表状态的迁移 可靠数据传输的基本原理 rdt2.0 2.1 3.0 没听，直接来到了滑动窗口协议， 看到下边和这里边有关系，又回来听了 左图为停等协议，右图为流水线协议 绿色代表发完已经接收确认的，黄色代表已经发送但还没有确认的，蓝色代表还可以使用的序列号GBN不会缓存乱序到达的序列号，会直接丢弃。 这个图的简单过程：
停止等待协议算法c语言实现,利用udp模拟arq停止等待协议
weixin_42160645的博客
05-24 1625
停止等待arq协议：停止等待协议(stop-and-wait)是最简单但也是最基础的数据链路层协议。很多有关协议的基本概念都可以从这个协议中学习到。“停止等待”就是每发送完一个分组就停止发送，等待对方的确认。在收到确认后再发送下一个分组。由于这里我们采用的是端对端的传输，所以我们并没有采用tcp进行流式套接字的传输，而是采用udp，进行的数据报的传输。UDP 是User Datagram Prot...
计算机网络
m0_67623521的博客
11-18 1835
通过这一层的封装，两个计算机之间的通信好像变成了它们之间两个进程之间的直接通信，端口号代表了进程的标识符（0-65535，0-2^16-1）。
可靠传输的实现机制1——停止等待协议SW（Stop and Wait）
m0_53133879的博客
09-14 2238
在开始这篇博客之前，大家来思考一下，什么是可靠传输呢？想要实现可靠传输需要解决哪些问题呢？就好像你给你的同桌传纸条，最基本的问题，你要确保纸条会被同桌收到，两台主机之前的信息交流也是如此，要确保你发送的信息被对方收到。那么在停止等待协议SW中，这一点是如何做到的呢？我们先来初步了解一下SW的工作原理，基本过程如下图所示以下图片均来自UP主——湖科大教书匠视频链接：【计算机网络微课堂（有字幕无背景音乐版）】 https://www.bilibili.com/video/BV1c4411d7jb?
《计算机网络自顶向下》 Miscellaneous Lab1 Implementing a Reliable Transport Protocol（实现可靠的传输协议（上））
Love 6's Private Blog
09-08 2209
文章目录前引Lab1 实现可靠的传输协议Lab1 文档查阅（友情提供下载链接） 前引 各位好 我写到这里其实我也还是挺意外的 因为其实我是想在CS144中再手撕TCP的 但是没想到《计算机自顶向下》里面居然有这个小实验 那既然有 哪里有不做的道理 反正CS144的实验也是迟早要完成的 我的预计本来是把Socket编程+Wireshark实验+CS144完成了 配套着《计算机自顶向下》+之前快速看完的哈工大课程 我们就愉快的完成计算机网络的学习 哈哈哈 但是其实发现要完成的还是相当多的 Lab1 实现可
stop-and-wait.rar_stop-and-wait_停止等待
07-15
使用python编写的停止等待协议，实现简单的数据传输。
stop-and-wait-ARQ.zip_ARQ
09-20
通过分析提供的"stop-and-wait ARQ.txt"文件，我们可以深入理解该协议的C语言实现，包括如何创建序列号、设置超时、构建和解析ACK，以及如何处理错误和重传。尽管这个实现可能不包含流量控制或其他高级特性，但它...
Stop-and-Wait-Protocol-Implemented-in-UDP-C
03-29
在UDP-C中实施停止并等待协议 该程序在C中的STOP和WAIT ARQ协议上。有2个文件： Client.c：此文件将数据帧发送到服务器，并等待确认。 Server.c：此文件从客户端接收数据帧并发送确认。
Java-UDP-Stop-and-Wait:一个用 Java 编写的 UDP 服务器和客户端来模拟 UDP 停止等待 ARQ
06-16
"停止等待"（Stop-and-Wait）是一种简单的错误控制协议，用于确保数据包正确、有序地传输。这个Java-UDP-Stop-and-Wait项目就是为了解决这个问题，通过Java编程语言来模拟UDP停止等待ARQ协议。 在Java中，我们可以...
Stop-and-WaitARQSimulation.rar_ARQ_arq matlab code_stop and wait
07-14
本代码是基于MATLAB的停止等待arq机制的程序，使用MATLAB语言编写，实现STOP-AND-WAIT机制。
stop and wait
03-22
computer networks protocol
计算机网络课程实验——可靠传输协议：（1）问题描述
OrdinaryCrazy的博客
04-15 2840
Programming Assignment #2: Implementing a Reliable Transport Protocol Overview In this assignmentoratory programming assignment, you will be writing the sending and receiving transport-level code
停止等待协议
chenyson的博客
05-08 5416
停止等待协议（stop-and-wati），是数据链据层一个很重要的协议，基本原理就是说每发送一个分组，必须要停下来等待，等接收方确认后才可继续发送下一个分组。如果没收到确认，就只能超时重传。 优点：很简单，每次发送一个分组就等待确认。 缺点：信道利用率不高，每次都要等。 为了克服停止等待的缺点，于是乎又出现了另外两种协议。 1.连续ARQ（Automatic Repeat reQuest）协议，...
计算机网络课程实验——可靠传输协议：（2）ABP（unidirectional）
OrdinaryCrazy的博客
04-15 2887
/* Zhang Jingtun(Ordinary Crazy) */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; /* ****************************************************************** ALTERNATING BI...
计算机网络云南大学实验四,计算机网络实验报告-云南大学-李海-第七次实验报告...
weixin_35884854的博客
07-04 277
计算机网络实验报告-云南大学-李海-第七次实验报告 (25页) 本资源提供全文预览，点击全文预览即可全文预览,如果喜欢文档就下载吧，查找使用更方便哦！14.9 积分实验七、传输层可靠传输协议GBN编程实验报告序号： 姓名：周坤 学号20121120256成绩 指导老师：李海一、 实验目的：1、 通过编写实现一个简单可靠的数据传输协议GBN的发送和接收代码，模拟可靠数据传输2、 理解TCP协议可靠...
停止等待协议（SW）——可靠传输协议的实现机制一
越努力越幸运的博客
11-24 4851
本博客参考视频链接： https://www.bilibili.com/video/BV1x4411d7HU?p=25 文章目录SW（Stop and Wait）停止等待协议1.确认与否认2.超时重传3.确认丢失4.确认迟到5.总结6.SW的信道利用率7.例题 SW（Stop and Wait）停止等待协议 这里通过把SW可能遇到的问题，把SW分成四个小部分来讲，即该协议使用过程中可能会遇到的问题以及该协议如何解决此类问题。 1.确认与否认 首先，每次发送方都只发一个数据分组，接收方对数据分组进行差错检测，
Stanford CS 144 Note 15 - Flow control (Stop-and-Wait + Sliding Window)
LeoYYZ的博客
07-02 347
两种flow control的方法 - Stop-and-Wait以及Sliding Window
无线传感器网络：差错控制（Stop and Wait，Go Back N，Selective Repeat）
myDarling_的博客
11-28 961
WSN 的差错控制机制
c语言实现stop-and-wait
最新发布
04-04
Stop-and-Wait是一种简单的数据链路层协议，用于在不可靠的通信信道上传输数据。下面是用C语言实现Stop-and-Wait协议的示例代码： ``` #include #include #include #define MAX_SEQ_NUM 2 // 最大序列号 #...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值