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

void starttimer(int AorB, float increment);
void stoptimer(int AorB);
void tolayer3(int AorB, struct pkt packet);
void tolayer5(int AorB, char datasent[20]);

#define SWAP(x) (x == 0 ? 1 : 0)

#define A_B_RTT 15

int A_seq;
int A_waiting_ack;
struct pkt A_last_packet;

int B_seq;
int B_waiting_ack;
struct pkt B_last_packet;

// The checksum of a packet is calculated
//Take all the bits in the packet and do the summation

int calculate_checksum(struct pkt *packet){
int cs = 0;
cs += packet->seqnum;
cs += packet->acknum;
for (int i = 0; i < 20; ++i)
   cs += packet->payload[i];
return cs;
}

/* called from layer 5, passed the data to be sent to other side */
void A_output(message)
struct msg message;
{
if (A_waiting_ack){
   /* If A is waiting for ACK from B, ignore new packet from layer 5 */
   printf("\tA_output: Waiting for ACK from B. Ignore new message: [%s]\n", message.data);
   return;
}else{
   /* A is waiting for upper layer, send new msg comming from layer 5 to B */
   printf("\tA_output: Sending new message to B: [%s]\n", message.data);

   /* Create new packet with the msg and send it to layer 3 below*/
   struct pkt packet;
   packet.seqnum = A_seq;
   memmove(packet.payload, message.data, 20);
   packet.checksum = calculate_checksum(&packet);

   A_last_packet = packet;
   A_waiting_ack = 1;

   tolayer3(0, packet);
   starttimer(0, A_B_RTT);
}
}

void B_output(message)
struct msg message;
{

}

/* called from layer 3, when a packet arrives for layer 4 */
void A_input(packet)
struct pkt packet;
{
/* if the checksum of the packet is not matching, ignore the packet.[ACK]*/
if (packet.checksum != calculate_checksum(&packet)){
   printf("\tA_input: Corrupted packet received and droped.\n");
   return;
}

/* if the sequence of the received ACK is not the expected sequence, drop it*/
if (packet.acknum != A_seq){
   printf("\tA_input: Unexpected packet received and droped.\n");
   return;
}

/* valid ACK received for last packet */
printf("\tA_input: ACK received for Last packet.\n");
stoptimer(0);

// change the sequence and change the state.
A_seq = SWAP(A_seq);
A_waiting_ack = 0;
}

/* This is called when A's timer goes off */
void A_timerinterrupt()
{
/* if A is waiitng for ACK from B, resend the packet*/
if (A_waiting_ack){
   printf("\tA_timerinterrupt: Resending last packet after timeout: [%s].\n", A_last_packet.payload);
   tolayer3(0, A_last_packet);
   starttimer(0, A_B_RTT);
}
}

/* 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()
{
A_seq = 0;
A_waiting_ack = 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 the checksum of the packet is not matching, ignore the packet and send NAK
if(packet.checksum != calculate_checksum(&packet)){
   printf("\tB_input: Corrupted packet received. Droped and sending NAK.\n");

   struct pkt nak_packet;
   nak_packet.acknum = SWAP(B_seq);
   nak_packet.checksum = calculate_checksum(&nak_packet);
   tolayer3(1, nak_packet);

   return

How do you locate errors in your codes? Report any less-than-frie...