---

packet.c

/*packet.c 
universal packet parsing functions for the Pc-pack's coprocessor.
2002 Nathan Gustavson
Emac.inc of Carbondale 
*/

#include <sys/types.h>
#include <asm/types.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define LIBCOMP /*don't include extern declarations*/
#include "../includes/packet.h"


/*function prototypes*/

int PcpkParsePacket(char *, PcpkPacket *);
PcpkHeader PcpkParseHeader(char *, PcpkPacket *);
int PcpkParseData(char *, PcpkPacket *);
int PcpkPacketAssign(PcpkPacket *);
unsigned int Pcpkonescount(unsigned char);
int PcpkPacketDestroy (PcpkPacket *);
char *cutbyte(char *stringin, __u8 *cutbbuffer);
unsigned short *cutword(char *stringin, __u8 *cutbbuffer);
char *PcpkPackGen(__u8 device,__u8 maskcnt,void *data);
__u8 asciihead(__u8 head);
void nwconvert(long data, char *asciiout, int size);
char ctoa(__u8 nibble);
__u8 hexatoc(char *asc);



/*
PcpkParsePacket
-------------------------------------------------------------------------------
fills a PcpkPacket
if data is available

parameters:
*asciipacket - the received ascii string (the entire packet).
*packet - pointer to a packet structure to be filled

returns:
success:
0

failure:
NOPACKET - no valid packet header found.


*/
int PcpkParsePacket(char *asciipacket,PcpkPacket *packet)
{
PcpkParseHeader(asciipacket,packet);

PcpkParseData(asciipacket,packet);
return 0;
}


/*
PcpkParseHeader
-------------------------------------------------------------------------------
sets up the packet 
This function is separated from the rest of the packet parsing 
routines because it will be needed by the interrupt handler
to know how long of a string to read before resetting it's pointer.
For a full packet parsing function use PcpkParsePacket, above.

parameters:
*rxpacket - the received ascii string or byte array(the entire packet).
*packet - pointer to a packet structure to be filled

returns:
 success:
  the header in hexidecimal
  also, important parameters are stored in the PcpkPacket passed to it.

*/
PcpkHeader PcpkParseHeader(char *rxpacket,PcpkPacket *packet)
{
PcpkHeader header;
int error;

#ifdef ASCIIPACKETS
char tokenbuffer[4];
char *asciiheader = &tokenbuffer[0];
char packetbuffer[MAXPACKETSIZE];
char *asciipacket = &packetbuffer[0];
char cutbbuffer[5];/*a global buffer for the byte strsep function*/
 

strcpy(asciipacket,rxpacket);
/*copy packet in case the original was read only (a literal)*/
//asciiheader = strsep(&asciipacket,DELIM);/*get header*/

asciiheader = cutbyte(asciipacket, cutbbuffer);


asciiheader[0] = (char)TRANS(asciiheader[0]);/*do header translation*/


header = (PcpkHeader)strtoul(asciiheader,NULL,16); /*convert to hex*/

#endif /*end ifdef asciipackets*/


#ifdef BINPACKETS
header = *rxpacket;
#endif


packet->type = PTYPE(header);

if(packet->extended==TRUE)
  packet->type+=EXTNULCMD;

packet->maskcnt = MASK(header);
packet->format = FORMAT(packet->type);

error = PcpkPacketAssign(packet);

if(error<0)
return error;
      
return header;
}




/*
PcpkParseData
------------------------------------------------------------------------------
universal c packet parsing function for the pcpack.
say that ten times fast.

parameters:
 *rxpacket - the received ascii string or byte array(the entire packet).
 *packet - pointer to a packet structure to be filled

returns:
 success:
  0
 failure:
 -1 

notes:
   The ascii version of this  function could have been a lot short
shorter and cleaner if I could have figured out a way
to dynamically declare a variables type in straight C.
Gcc seems to demand that all typedefs and declarations
happen before anything else, hence I was limited.
If anyone sees this code and has a suggestion, 
I would be appreciate an e-mail, at ngustavson@emacinc.com. 

   The binary char implementation of this function is very simple,
just a malloc and memcpy, the word version has to run through the whole
"update the pointer" process. This way data is stored correctly.
A straight memcpy would store the data in little endian format, and 
everyone one would get confused and start calling me. 


*/
int PcpkParseData(char *rxpacket,PcpkPacket *packet)
{
size_t packetsize;/*size of the data packet in bytes*/
size_t datanum;
char tokenbuffer[MAXPACKETSIZE];
void *token = &tokenbuffer[0];
//unsigned int asciicount;
char *bytedata;
__u16 *wrddata;/*some crazy OS's like linux think an int is 4 bytes*/
//char wdata;
char cutbbuffer[5];/*a global buffer for the byte strsep function*/

#ifdef ASCIIPACKETS
char packetbuffer[MAXPACKETSIZE];
char *asciipacket = &packetbuffer[0];
#endif



packetsize = (packet->datasize)*(packet->datanum);
//packet->data = vmalloc(packetsize);  
/*virtual allocation fails during interrupt tasks
so, ta hell wit it, I'll break down and use a fixed size array*/

#ifdef BINPACKETS
++rxpacket; /*point past the header*/
#endif


#ifdef ASCIIPACKETS
strcpy(asciipacket,rxpacket);
/*copy packet in case the original was read only (a literal)*/
#ifdef DELIM
strsep(&asciipacket,DELIM);/* identify string and move past header */
/* allocate memory for the data packet */
#endif
#endif

bytedata = packet->data; /*2 different alignments for the 2 situations*/
wrddata = (__u16 *)packet->data;

switch(packet->datasize)
  {
  
  case 1:
    {
#ifdef BINPACKETS /*a much simpler function, just a memcopy and a malloc*/
      memcpy(packet->data,rxpacket,packetsize);
      return 0;
#endif 

      for(datanum=2;datanum<=packetsize*2;datanum+=2)
    {

      token = cutbyte(&asciipacket[datanum],cutbbuffer);
      /*2,4,6,8,10....*/
#ifdef DELIM      
      token = strsep(&asciipacket,DELIM);
      /*delim no longer works*/
#endif

     

     if(token == NULL)
       {
         packet->datanum = (datanum-2)/2;
         //realloc(packet->data, datanum);
         return PARSEERROR; 
       }
        *bytedata = (unsigned char)strtoul(token,NULL,16);;
    ++bytedata;
    }
      break;
    }
  case 2:
    {
      for(datanum=2;datanum<=packetsize*2;datanum+=4)
    {
     // for(asciicount=1;asciicount<=2;asciicount++)
       // {    
#ifdef ASCIIPACKETS
          token = cutword(&asciipacket[datanum],cutbbuffer);
          /*2,4,6,8,10...*/
#ifdef DELIM 
          token = strsep(&asciipacket,DELIM);
          /*delimeters no longer work here*/
#endif        
          *wrddata = (unsigned short)strtoul(token,NULL,16);
#endif
          
#ifdef BINPACKETS
          if(*rxpacket==0)
        token = NULL;;
          wdata = *rxpacket;
          ++rxpacket;
#endif
          

          
          
          if(token == NULL)
        {/* error, reallocate memory for incorrect packet size*/
          packet->datanum = (datanum-2)/4;
          //realloc(packet->data, datanum);
          return PARSEERROR; 
        }
          


     //}
        *wrddata = (unsigned short)strtoul(token,NULL,16);
      ++wrddata;/*point to the next data item*/
    }
      break;
    }
 
  }


return 0;
}



/*  PcpkPacketAssign
-----------------------------------------------------------------------------
 *
 *  assign parameters to packet structure based
 *  on written documentation in packet.h
 *  data is assigned based on PcpkPacket.format, so it must be already set.
 *  a switch statement was so that if other parameters need to
 *  be added later, changes would be easy.
 */
int PcpkPacketAssign(PcpkPacket *packet)
{

packet->extended = FALSE; //by default extended packets are off

switch(packet->format)
  {
  case INVLTYP:
    return NOPACKET;
    
  case MRKTYP0:
    {
      packet->datasize = 1;
      packet->datanum = Pcpkonescount(packet->maskcnt);
      packet->mult = 0;
      break;
    }

  case MRKTYP1:
    {
      packet->datasize = 2;
      packet->datanum = Pcpkonescount(packet->maskcnt);
      packet->mult = 0;
      break;
    }

  case MRKTYP2:
    {
      packet->datasize = 1;
      packet->maskcnt = packet->maskcnt|(packet->mult<<4);
      packet->datanum = packet->maskcnt;
      packet->mult = 0;
      break;
    }

  case MRKTYP3:
    {
      packet->datasize = 2;
      packet->datanum = 1;
      packet->mult = 0;
      break;
    }

 case MRKTYP4:
    {
      packet->datasize = 0;
      packet->datanum = 0;
      packet->mult = 0;     
      break;
    }

  case MRKTYP5:
    {
      packet->extended = TRUE;
      packet->datanum = 0;
      packet->mult = 0;     
      break;
    }

  case MRKTYP6:
    {
     packet->extended = TRUE;
     packet->datanum = 0;
     packet->mult = packet->maskcnt;
     break;  
    }

  default:
    {
     packet->datanum = 0;
     packet->mult = 0;
    }


  }/*end switch(packet->type)*/


return 0;
}



/*Pcpkonescount
-------------------------------------------------------------------------------
counts the ones in a 4 bit mask
*/
unsigned int Pcpkonescount(unsigned char mask)
{
unsigned int count;
unsigned int ones = 0;

for(count=0;count<=3;count++)
  {
  ones += mask&0x01;
  mask >>= 1;
  }

return  ones;
}



/*PcpkPacketDestroy
------------------------------------------------------------------------------
destroys a previously allocated packet
and frees the memory used.
*/
int PcpkPacketDestroy (PcpkPacket *packet)
{
  /*no longer needed*/
//vfree(packet->data);

return 0;
}


/* a strsep type function that separates a string into tokens, ala strsep,
but instead of basing it on delimiters, does bytes

returns the token, doesn't modify the original string

this used to use a global variable so wasn't thread safe, but this has
been changed for the 37e12. The buffer is now passed into the function
from the calling function, not as pretty, but much safer.
*/
char *cutbyte(char *stringin, __u8 *cutbbuffer)
{
strncpy(&cutbbuffer[0],stringin,2);/*copy byte to the global buffer*/
cutbbuffer[2] = '\0';/*end the string*/
return &cutbbuffer[0];
}


unsigned short *cutword(char *stringin, __u8 *cutbbuffer)
{
strncpy(&cutbbuffer[0],stringin,4);/*copy word to the global buffer*/
cutbbuffer[4] = '\0';/*end the string*/
return (unsigned short *)&cutbbuffer[0];
}





/*
PcpkPackGen
--------------------------------------------------------------
A general packet creating function
*/
char *PcpkPackGen(__u8 device,__u8 maskcnt,void *data)
{

__u8 type = hdrTbl[device];
char *packet;
__u16 datanum;
__u8 datasiz = 2;/*2 ascii chars for 1 char default*/
char *databuff;
__u16 offset;
__u8 bitmask = 8;
__u16 *__u16ptr = data;
char *charptr = data;
int count=0;
//__u8 maskhigh = maskcnt;
__u8 mask = maskcnt;

maskcnt&=0x0F;
/*
if(maskcnt>0x0F)
{
GENDEBUG("invalid mask\n");
return NULL;
}
*/
if(device>=LPHEADERS)
{
switch(type)
{
case MRKTYP2:
    /*data is an array of bytes*/
    datanum = mask;
    datasiz = 2;    

    if(NULL==(databuff = malloc(datanum*datasiz + 1)))
    return FAILURE;


        for(offset=0;offset<datanum;offset++)   
    nwconvert((int)charptr[offset],&databuff[offset*datasiz],datasiz);
  
    //sprintf(&databuff[offset*datasiz],"%X",charptr[offset]);
    
    databuff[offset*datasiz]=0;

    break;

}

}
else
{
switch(type)
{
  case INVLTYP:
  GENDEBUG("invalid type\n");
  return NULL;


  
  case MRKTYP0:
    /*data is an array of masked 4 bytes*/
    datasiz=2;
    datanum = Pcpkonescount(maskcnt);
    if(NULL==(databuff = malloc(datanum*datasiz + 1)))
    return FAILURE;

    for(offset=0;offset<4;offset++)
    {
    if(bitmask&maskcnt)
      {
       nwconvert((__u16)charptr[offset],&databuff[count*datasiz],datasiz);
       count++;
      }
    bitmask>>=1;
    }
    databuff[count*datasiz]=0;
    break;
 



 
  
  case MRKTYP1:/*change data size*/
    /*data is an array of masked 4 __u16s*/
    datasiz = 4;
        
    datanum = Pcpkonescount(maskcnt);

    if(NULL==(databuff = malloc(datanum*datasiz + 1)))
    return FAILURE;

    for(offset=0;offset<4;offset++)
    {
    if(bitmask&maskcnt)
      {
       //sprintf(&databuff[count*datasiz],"%X",__u16ptr[offset]);
       nwconvert(__u16ptr[offset],&databuff[count*datasiz],datasiz);
       count++;
      }     
     

    bitmask>>=1;
    }
    databuff[count*datasiz]=0;
    break;
  



  case MRKTYP2:
    /*data is an array of bytes*/
    datanum = maskcnt;
    datasiz = 2;    

    if(NULL==(databuff = malloc(datanum*datasiz + 1)))
    return FAILURE;


        for(offset=0;offset<datanum;offset++)   
    nwconvert((int)charptr[offset],&databuff[offset*datasiz],datasiz);
  
    //sprintf(&databuff[offset*datasiz],"%X",charptr[offset]);
    
    databuff[offset*datasiz]=0;

    break;


case MRKTYP3:
    /*data is a single word*/
    datanum = 1;
    datasiz = 4;

    if(NULL==(databuff = malloc(datanum*datasiz + 1)))
    return FAILURE;


        nwconvert(__u16ptr[0],&databuff[0],datasiz);
    
    databuff[datasiz]=0;

    break;


case MRKTYP4:
    /*data a header only*/
    if(NULL==(databuff = malloc(1)))
    return FAILURE;

    *databuff = 0;
    break;



}
}

if(device>=EXTNULCMD)//extended packet
  packet = malloc((datanum*datasiz)+(HEADERSIZE*2)+1);
else
  packet = malloc((datanum*datasiz)+HEADERSIZE+1);


if(packet==NULL)
{
GENDEBUG("unable to allocate memory for packet\n");
return FAILURE;
}
/*generate the header*/
packet[DELIMITER] = (device + 0x61);
//sprintf(&packet[MASKNIB],"%X",maskcnt);
nwconvert(maskcnt,&packet[MASKNIB],1);
//sprintf keeps going insane


if(device>=EXTNULCMD)//extended packet
  {
  packet[DELIMITER] = (EXTCMD + 0x61);
  packet[EXT_DELIMITER] = device - EXTNULCMD + 'A';
  nwconvert(maskcnt,&packet[EXT_MASKNIB],1);
  nwconvert((maskcnt>>4),&packet[MASKNIB],1);//redo original
  packet[EXT_MASKNIB+1]=0;
  }
else
  packet[MASKNIB+1]=0;

if(device>=LPHEADERS)
packet[DELIMITER] = (LONG_EXT + 0x61);



/*cat the data*/

strcat(packet,databuff);

free(databuff);
/*destroy the temporary data storage*/

return packet;
}


__u8 asciihead(__u8 head)
{
if(head>TRANSFLIP)
return(head - 10);

return(head - 0x31);
}



void nwconvert(long data, char *asciiout, int size)
{
int i;

    for(i=(size-1);i>=0;i--)
     {
      asciiout[i] = ctoa(((__u8)data&0x0F));
      data>>=4;
     }
} 



char ctoa(__u8 nibble)
{
if (nibble>9)
    return(nibble + 55);
else
    return(nibble + 48);
}

__u8 hexatoc(char *asc)
{
__u8 charback = 0;
int charnum;
__u8 temp;
int expon;

for(charnum=0;charnum<=1;charnum++)
{
if(asc[charnum]>=97)
    temp = asc[charnum] - 87;
else    
if(asc[charnum]>=65)
    temp = asc[charnum] - 55;
else
    temp = asc[charnum] - 48;


//expon = 16^(1-charnum);
expon = 1<<(4*(1-charnum));
temp*=expon;
charback+= temp;
}

return charback;
}

---