按照自己的理解实现比特交换协议(alternating-bit protocol)

一开始的思路是想写两个程序的，发送端和接收端。但是后来想了下，因为是模拟的，所以不用这么麻烦，直接自己定制场景（比如说丢包阿，包出错阿，超时之类的）。

基本上是根据上图所写的，一个函数发包，一个函数接包（比如上图的wait_for_ack0），在这个发包函数里定制场景，在接包函数里处理场景。

说到处理场景，仔细看看wait for ack0上所写的：

　翻译一下：

 if ( rdt_rcv(rcvpkt) && (corrupt(rcvpkt)) || isACK(rcvpkt, ) )  // 如果有接受到包且包坏了， 或者接受到的ACK是1，那么就什么都不用做，因为会执行下面的超时函数
{
    ;// do nothing，静静地等待超时然后重新发包
}

if (timeout) // 如果超时，重新发包然后重新启动计时器
{
    udt_send(sndpkt);
    start_timer;
}

if ( rdt_rcv(rcvpkt) && notcorrupt(rcvpkt) && isACK(rcvpkt, ) ) // 只有凑齐接收到包且包正确且收到的回复正确，那么就可以停止计时了
{
    stop timer;
}

因为这是停等协议(stop and wait)，所以顺序是先发0包，再发1包，再发0包这样持续下去。

根据场景，我定义了这个一个数组：数据包丢失，确认包丢失，数据包出错，确认包出错，超时 5个场景。 丢失就会超时，出错就是验证校验和。

不过因为我懒，所以没有计算RTT之类的时间，校验和也忽略掉的。

这里给个思路，可以根据公式（大家可以看看计算机网路的书，上面有写算RTT的公式），只要你定义了数据包的大小，网速的话，根据包的个数是可以算出来RTT的。

下面是我自己定义的场景。

#define PACKAGE_LOSS 0
#define ACK_LOSS 1
#define PACK_CORRUPT 2
#define ACK_CORRUPT 3
#define TIME_OUT 4

int Flag[] = {}; // 0代表没有，1代表有

你在调用发包这个函数时就询问会出现哪种场景，我写得代码一次发包只能实现一种场景（不过根据场景的不同，有可能引发其他场景。比如丢包，这样自然就会引起超时了）。

在接收包的函数时，就定义解决场景，根据上图写。

下面给出完整代码（有一些地方可能会出错，但也弄出个大概，仅供参考）

 #include <stdio.h>
   #include <stdlib.h>

   #define DATA_LENGTH 20

   struct Pkt
   {
       int seqnum;
       int checksum;
      char data[DATA_LENGTH];
  };

  #define PACKAGE_LOSS 0
  #define ACK_LOSS 1
  #define PACK_CORRUPT 2
  #define ACK_CORRUPT 3
  #define TIME_OUT 4

  int Flag[] = {};

  int nsimmax = ; // the number of message
  int n_package = ;
  struct Pkt *pkt_ptr = NULL;

  void init()
  {
      int i = ;
      int j = ;
      int k = ;

      printf("---- Stop and Wait Network Simulator Version 1.0 ----\n");
      printf("Enter the number of messages to simulate: ");
      scanf("%d", &nsimmax);

      pkt_ptr = (struct Pkt *)malloc(nsimmax * sizeof(struct Pkt)); // nsimmax packages
      if (pkt_ptr == NULL)
      {
          perror("Malloc Error: ");
          exit();
      }

      // Fill some data in Pkt.data

      for (i = ; i < nsimmax; i++)
      {
          for (j = ; j < DATA_LENGTH; j++)
          {
              pkt_ptr[i].data[j] =  + k;
          }

          k++;
      }

  }

  void Question(int *p)
  {
      int i = ;

      printf("--------------\n");
      printf("0 - Nothing wrong\n");
      printf("1 - Packet loss\n");
      printf("2 - ACK loss\n");
      printf("3 - Packet error\n");
      printf("4 - ACK error\n");
      printf("5 - Time out\n");
      printf("--------------\n");

      printf("Choice: ");
      scanf("%d", &i);

      if (i != )
      {
          p[i - ] = ;
      }
  }

  void send()
  {

      if (Flag[] == )
      {
          printf("SEND: Package loss\n");
          Flag[] = ; // time out
      }

      else if (Flag[] == )
      {
          printf("SEND: ACK loss\n");
          Flag[] = ; // time out
      }

      else if (Flag[] == )
      {
          printf("SEND: Packet error\n");
      }

      else if (Flag[] == )
      {
         printf("SEND: ACK error\n");
     }

     else if (Flag[] == )
     {
         printf("SEND: Time out\n");
     }

     else
     {
         printf("SEND: Nothing wrong\n");
     }

     printf("\n");

 }

 void rdt_send0()
 {
     Question(Flag);

     printf("SEND: Send package 0\n");
     printf("SEND: Start timer\n\n");

     send();

 }

 void rdt_send1()
 {
     Question(Flag);

     printf("SEND: Send package 1\n");
     printf("SEND: Start timer\n\n");

     send();

 }

 void waitACK0()
 {
     int i = ;

     while ()
     {
         if ((Flag[] ==  && Flag[] == ) || Flag[] == )
         {
             printf("-------------------\n");
             if (Flag[] == ) // Send error package
             {
                 printf("RECV: SEND NAK0\n");
             }

             if (Flag[] == ) // Error ACK0 means ACK1
             {
                 printf("RECV: Receive package 0\n");

                 printf("The data is: ");
                 for (i = ; i < DATA_LENGTH; i++)
                     printf("%c", pkt_ptr[n_package].data[i]);
                 printf("\n");

                 printf("RECV: SEND ACK1\n");
                 printf("SEND: ACK should be 0\n");
             }
             printf("-------------------\n");

             Flag[] = ; // package error or error ACK can lead to time out
         }

         if (Flag[] == ) // time out
         {
             printf("SEND: Time out\n");
             printf("SEND: Resend package0...\n");
             if (Flag[] == ) // package 0 loss
             {
                 Flag[] = ;
             }

             if (Flag[] == ) // ACK 0 loss
             {
                 printf("RECV: Detetch the redundant, discard the package0\n");
                 Flag[] = ;
             }

             if (Flag[] == ) // package 0 error
             {
                 Flag[] = ;
             }

             if (Flag[] == )
             {
                 printf("RECV: Detetch the redundant, discard the package0\n");
                 Flag[] = ;
             }

             printf("SEND: Start timer\n");
             Flag[] = ;
         }

         if (Flag[] ==  && Flag[] ==  && Flag[] == )
         {
             printf("SEND: Stop timer\n");
             printf("-------------------\n");
             printf("RECV: reveive package0\n");
             printf("RECV: send ACK0\n");

             printf("The data is: ");
             for (i = ; i < DATA_LENGTH; i++)
                 printf("%c", pkt_ptr[n_package].data[i]);
             printf("\n");

             break;
         }
     }
 }

 void waitACK1()
 {
     int i = ;

     while ()
     {
         if ((Flag[] ==  && Flag[] == ) || Flag[] == )
         {
             printf("-------------------\n");
             if (Flag[] == ) // Send error package
             {
                 printf("RECV: SEND NAK0\n");
             }

             if (Flag[] == ) // Error ACK0 means ACK1
             {
                 printf("RECV: Receive package 0\n");

                 printf("The data is: ");
                 for (i = ; i < DATA_LENGTH; i++)
                     printf("%c", pkt_ptr[n_package].data[i]);
                 printf("\n");

                 printf("RECV: SEND ACK1\n");
                 printf("SEND: ACK should be 0\n");
             }
             printf("-------------------\n");

             Flag[] = ; // package error or error ACK can lead to time out
         }

         if (Flag[] == ) // time out
         {
             printf("SEND: Time out\n");
             printf("SEND: Resend package0...\n");
             if (Flag[] == ) // package 1 loss
             {
                 Flag[] = ;
             }

             if (Flag[] == ) // ACK 1 loss
             {
                 printf("RECV: Detetch the redundant, discard the package1\n");
                 Flag[] = ;
             }

             if (Flag[] == ) // package 1 error
             {
                 Flag[] = ;
             }

             if (Flag[] == )
             {
                 printf("RECV: Detetch the redundant, discard the package1\n");
                 Flag[] = ;
             }

             printf("SEND: Start timer\n");
             Flag[] = ;
         }

         if (Flag[] ==  && Flag[] ==  && Flag[] == )
         {
             printf("SEND: Stop timer\n");
             printf("-------------------\n");
             printf("RECV: reveive package1\n");
             printf("RECV: send ACK1\n");

             printf("The data is: ");
             for (i = ; i < DATA_LENGTH; i++)
                 printf("%c", pkt_ptr[n_package].data[i]);
             printf("\n");

             break;
         }
     }
 }

 void run()
 {
     init();
     while ()
     {
         printf("--------%d package ------------\n", n_package);
         rdt_send0();
         waitACK0();
         n_package++;
         if (n_package == nsimmax)
             break;

         printf("--------%d package ------------\n", n_package);
         rdt_send1();
         waitACK1();
         n_package++;

         if (n_package == nsimmax)
             break;
     }

     return;

 }

 int main(void)
 {
     run();
     return ;
 }

因为是停等协议，所以有两个send函数，有两个wait for ACK函数，都是差不多的，只是一个是发0包，接0包，一个是发1包，接1包。

下面给出运行结果：