rcpc.c

Go to the documentation of this file.

#include "standard.h"
#include "rcpc.h"
#include "Buffer.h"
#include "arq.h"
#include "between.h"
#include "error.h"

int max_arq(int rtype)
/*
 * returns the most arq's that can be sent for a given rate type rtype
 */
{
  int rval;

  switch (rtype) {
    case 24:
      rval = 3;
      break;
    case 23:
    case 22:
      rval = 2;
      break;
    case 21:
    case 20:
    case 19:
    case 18:
    case 17:
    case 16:
      rval = 1;
      break;
    case 15:
    case 14:
    case 13:
    case 12:
    case 11:
    case 10:
    case 9:
    case 8:
    case 7:
    case 6:
    case 5:
    case 4:
    case 3:
    case 2:
    case 1:
    case 0:
      rval = 0;
      break;
    default:
      error("max_arq","Invalid rtype input");
  }
}


int inc_xmit_count(buf_rcpc *br)
/*
 * increments xmit count of br and returns it modulo 2
 */
{
  br->xmit_count = (br->xmit_count + 1);
    return (br->xmit_count) % 2;
}

buf_rcpc *find_rcpc(Buffer *rcpcs, int seq_num)
/* 
 * Finds an rcpc buffer entry with a given timestamp
 * Returns a pointer to it if it exists, or NULL if it doesn't
 */
{
  int i;
  buf_rcpc *rcpc;
 
  for (i=blevel(rcpcs)-1; i >= 0; i--) {
    rcpc = bpeek(rcpcs, i);
    if (seq_num == rcpc->sequence_number)
      return (rcpc);
  }
  return(NULL);
}
 
buf_rcpc *place_rcpc(Buffer *rcpcs, int seq_num, byte *data, int num_bytes,
                     int arq_type, int last_written, int *last_recd, 
                     int old_threshold)
/*
 * Places a block of bytes in the correct rcpc structure, and returns
 * a pointer to it.
 * seq_num is the sequence number
 * data is the byte array of data to put in the block
 * num_bytes is the length of the byte array
 * arq_type is the arq_type (1,2 or 3)
 * last_written is the seq_num of last packet written out from buffer
 * last_recd is seq_num of last new packet received
 */
{
  buf_rcpc *rcpc,new_rcpc;
  int i,old;


  old = minus(last_written,old_threshold);
  if (between(seq_num,old,last_written) || (seq_num == last_written)) {
    printf("place_rcpc() - Disregarding packet %d.  It's too old\n",seq_num);
    return(NULL);
  } 
  else {
    if ((between(seq_num,*last_recd,old)) || (seq_num == old)) { 
      /* it's a new entry */
      *last_recd = seq_num;
      /* cheat to find out if we're going to overwrite the last buffer entry
       * and if we are, be sure to free any allocated blocks
       */
      if (rcpcs->full) {
        rcpc=bpeek(rcpcs, 0);
        if (rcpc->block[0]!=NULL) free(rcpc->block[0]);
        if (rcpc->block[1]!=NULL) free(rcpc->block[1]);
        if (rcpc->block[2]!=NULL) free(rcpc->block[2]);
        if (rcpc->block[3]!=NULL) free(rcpc->block[3]);
      }
      new_rcpc.sequence_number=seq_num;
      new_rcpc.count=1;
      new_rcpc.xmit_count=1;
      new_rcpc.length=num_bytes;
      new_rcpc.block[0]=malloc(num_bytes);
      new_rcpc.block[1]=NULL;
      new_rcpc.block[2]=NULL;
      new_rcpc.block[3]=NULL;
      if (new_rcpc.block[0]==NULL) {
        fprintf(stderr, "place_rcpc: malloc() failure\n");
        return NULL;
      }
      for (i=0; i<num_bytes; i++) {
        new_rcpc.block[0][i]=data[i];
      }
      bwrite(rcpcs, &new_rcpc);
      return(find_rcpc(rcpcs,seq_num));
    }
    else { /* it's a retransmission */
      /* 
       */
        printf("Got retransmission of sequence number %d\n",seq_num);
        rcpc = find_rcpc(rcpcs,seq_num);
        if (rcpc->count == 4) {
          printf("place_rcpc()-ERROR tried to place block into full rcpc struct\n");
          return(NULL);
        }
        if (arq_type == 1) {
          for (i=0; i<num_bytes; i++) {
            rcpc->block[0][i]=data[i];
          }
        } else {
          rcpc->block[rcpc->count]=malloc(num_bytes);
          if (rcpc->block[rcpc->count]==NULL) {
            fprintf(stderr, "place_rcpc: malloc() failure\n");
            return(rcpc);
          }
          for (i=0; i<num_bytes; i++) {
            rcpc->block[rcpc->count][i]=data[i];
          }
          rcpc->count++;
        }
        /* rcpc->xmit_count++; */
        return(rcpc);
      }
    }
/*  } */
}
 

---