al_receiving.c

Go to the documentation of this file.

#include "standard.h"
#include "al.h"
#include "al_sending.h" 
#include "al_receiving.h"
#include "rcpc.h"
#include "crc4.h"
#include "arq.h"
#include "uep_rcpcc.h"
#include "LList.h"
#include "between.h"

#define DEF_MAX_ARQ 3

/***************************************************
 * output buffer stuff                             *
 ***************************************************/

extern int debug;


al_receiving_entity *new_al_receiving_entity(channel_info *nfo)
     /*
      * Makes a new AL-Receiving Entity.
      */
{
  al_receiving_entity *new_al;
  
  new_al = (al_receiving_entity *) malloc(sizeof(al_receiving_entity));
  /*  printf("new al_receiving entity has address %x\n",new_al); */
  if (new_al == NULL)
    error("new_al_receiving_entity", "can't malloc al_receiving_entity");
  else {
    new_al->outgoing_data = mkbuffer(MAX_AL_BUFFER_SIZE, sizeof(byte));
    new_al->incoming_data = mkbuffer(MAX_AL_BUFFER_SIZE, sizeof(byte));

    new_al->type = nfo->type;
    new_al->framed = nfo->framed;
    new_al->seq_num = nfo->seq_num;

    new_al->rcpc_code = nfo->rcpc_code;
    new_al->rcpc_rate = nfo->rcpc_rate;

    new_al->crc_bytes = nfo->crc_bytes;

    new_al->old_threshold = nfo->old_threshold;

    /* Initialize other parameters */
    new_al->max_arq = DEF_MAX_ARQ;
    new_al->last_recd = 31;
    new_al->last_written = 31;
    new_al->initialized = 0;
    new_al->bad_payloads = 0;
  }
  return new_al;
}



void send_to_al(al_receiving_entity *which, byte b)
     /* 
      * write the byte to the incoming data buffer.
      */
{
  bwrite(which->incoming_data, &b);
}


void send_closing_flag(al_receiving_entity *which)
     /*
      * called by mux to signal the end of an AL-PDU.
      *
      * check the crc on the data in incoming buffer (incoming_data).  if it 
      * is good, transfers the data to the outgoing buffer (outgoing_data).  
      */
{
  byte inbuf[MAX_AL_BUFFER_SIZE];
  byte inbyte;
  byte computedCRC,receivedCRC;
  unsigned short computedCRC16,receivedCRC16;
  int i;
  int len=blevel(which->incoming_data);
  
  if (len > 0) {
    if (which->type == AL1) {
    /* just transfer incoming buffer to outgoing buffer.. */
      for(i=0;i<len;i++) {
        bread(which->incoming_data,(void *) &inbyte);
        bwrite(which->outgoing_data,(void *) &inbyte);
      }
    }
    else if (which->type == AL2) {
    /* check one byte crc, if good transfer to outgoing.  if not, put back
       into incoming */
      computedCRC = 0;
      for(i=0;i<len-1;i++) {
        bread(which->incoming_data,(void *) inbuf+i);
        crc8(&computedCRC,inbuf[i]);
      }
      bread(which->incoming_data,(void *) inbuf+(len-1));
      receivedCRC = inbuf[len-1];
      if (computedCRC == receivedCRC) { /* put data without crc into outgoing buf */
        if (debug) printf("AL receiving good CRC\n");
        for(i=0;i<len-1;i++)
          bwrite(which->outgoing_data,(void *) inbuf + i);
      }
      else { /* put all data back into incoming_data, bad crc */
        if (debug) printf("AL receiving bad CRC\n");
        for(i=0;i<len;i++)
          bwrite(which->incoming_data,(void *) inbuf + i);
      }
    }
    else if (which->type == AL3) {
    /* check two byte crc, if good transfer to outgoing.  if not, put back into
       incoming */
      computedCRC16 = 0;
      for(i=0;i<len-2;i++) {
        bread(which->incoming_data,(void *) inbuf+i);
        crc16(&computedCRC16,inbuf[i]);
      }
      bread(which->incoming_data,(void *) inbuf+(len-2));
      bread(which->incoming_data,(void *) inbuf+(len-1));
      receivedCRC16 = inbuf[len-2];
      receivedCRC16 = (receivedCRC16 << 8) | (inbuf[len-1]);
      if (computedCRC16 == receivedCRC16) { /* put data without crc into outgoing buf */
        if (debug) printf("AL receiving good CRC\n");
        for(i=0;i<len-2;i++)
          bwrite(which->outgoing_data,(void *) inbuf + i);
      }
      else { /* bad crc, send it anyway. could modify to send with an error msg */
        if (debug) printf("AL receiving bad CRC\n");
        for(i=0;i<len-2;i++)
          bwrite(which->outgoing_data,(void *) inbuf + i);
      }
    }
  }
}


int al_indication(al_receiving_entity *which)
/*
 * Called by AL user (receiver) to check if there is any data waiting for
 * it in the receive buffer.  Returns 1 if data is there, 0 if not
 */
{
  if (blevel(which->outgoing_data))
    return 1;
  else
    return 0;
}


byte al_receive(al_receiving_entity *which)
/* 
 * called by al_user, which must call al_indication before
 */
{
  byte b;

  bread(which->outgoing_data, &b);

  return b;
}

---