8583.c

c语言编写的8583解包程序 在unix环境下测试通过

#include <stdio.h>
#include <signal.h>
#include "8583.h"


#define k_TRUE     0
#define k_FALSE    1

extern struct BITD bittab[];

int  pack_8583(char *tx_buf, struct PACK_DATA *pack_str)
{
	char tmpbuf[500];
	int  i,*Length,status,r,Len,Len_Pack,Bit;
	char *pack_tail;
	char *Ptr_Dest;
	char *Ptr_Source;
	char Ptr_fnt;

	status = k_FALSE;
	pack_tail = tx_buf;

	memcpy(pack_tail,pack_str->bitmap,8);

SBlog_print(__FILE__,__LINE__,"[%02x %02x %02x %02x %02x %02x %02x %02x]",
	*pack_tail, *(pack_tail+1), *(pack_tail+2), *(pack_tail+3), 
	*(pack_tail+4), *(pack_tail+5), *(pack_tail+6), *(pack_tail+7)); 

	pack_tail += 8;

	i = 1;
	do
	{
		if(bittest(pack_str->bitmap,i))
		{
			Length = bittab[i-1].Length;
			if( Length == 0)
				Len = bittab[i-1].Max;
			else
				Len = *bittab[i-1].Length;

			Ptr_Source      = bittab[i-1].Send_Data;
			Ptr_fnt         = bittab[i-1].Tx_Function_No;

			status = k_TRUE;

			switch (bittab[i-1].Attrib)
			{
				case TRACKX:
				case NUMERIC:
					if (bittab[i-1].Format == LLLVAR)
					{
						itobcd(Len,pack_tail,2);
						pack_tail += 2;
					}
					else if (bittab[i-1].Format == LLVAR)
					{
						itobcd(Len,pack_tail,1);
						pack_tail += 1;
					}
					Len_Pack = (Len+1)/2;
					break;

				case ALPHANUM:
				case ALPHANUMS:
					if (bittab[i-1].Format == LLLVAR)
					{
						itobcd(Len, pack_tail,2);
						pack_tail += 2;
					}
					else if (bittab[i-1].Format == LLVAR)
					{
						itobcd(Len, pack_tail,1);
						pack_tail += 1;
					}
					Len_Pack = Len;
					break;

				case BITS:
					Len_Pack = Len/8;
					break;

				default:
					SBlog_print(__FILE__,__LINE__,
						"i->[%d]--[%d]",i, 
						bittab[i-1].Attrib);
					status = k_FALSE;
					break;
			}
			if (status != k_TRUE)
				break;

			Bit = i;
			if (Ptr_fnt == 1)
			{
				Ptr_Dest = pack_tail;
				Set_Memcpy(Bit,Len,Len_Pack,Ptr_Dest,Ptr_Source);
				pack_tail += Len_Pack;
			}
			else if(Ptr_fnt == 2)
			{
				Ptr_Dest = pack_tail;
				r=Set_Mac(tx_buf,(pack_tail-tx_buf),
					pack_tail);
				if(r<0) return(-5);
				pack_tail += Len_Pack;
			}
		}
		i++;
	}while(i <= BIT64);

	if(status != k_TRUE)
	{
		SBlog_print(__FILE__,__LINE__, 
			"The status != k_TRUE !!  i->[%d]",i); 
		return(-1);
	}
	else
		return(pack_tail-tx_buf);
}


int unpack8583(char *rcv_buf,struct PACK_DATA *pack_str)
{
	char    i,j, r, *pack_tail2;
	int         status,Len,Len_Pack,Bit;
	char    tmpstr[500], tmp_mac[9], lendata[2], val[2];
	char    *Ptr_Dest;
	char    *Ptr_Source;
	char    Ptr_fnt;

	pack_tail2 = rcv_buf;

	/*receive bitmap*/
	memcpy(pack_str->bitmap,pack_tail2, 8);
	pack_tail2 += 8;

	/*receive data*/
	i = 1;

	do
	{
		if(bittest(pack_str->bitmap,i))
		{
			Ptr_Dest = bittab[i-1].Receive_Data;
			Ptr_fnt = bittab[i-1].Rcv_Function_No;

			status = k_TRUE;

			switch (bittab[i-1].Attrib)
			{
				case TRACKX:
				case NUMERIC:
					if (bittab[i-1].Format == LLLVAR)
					{
						memcpy( lendata, pack_tail2, 2);
						Len = bcdtoi(lendata ,  4);
						*bittab[i-1].Length=Len;
						pack_tail2 += 2;
					}
					else if (bittab[i-1].Format == LLVAR)
					{
						memcpy(lendata, pack_tail2, 1);
						Len = bcdtoi(lendata,2);
						*bittab[i-1].Length=Len;
						pack_tail2 += 1;
					}else
						Len = bittab[i-1].Max;
					Len_Pack = (Len+1)/2;
					break;

				case ALPHANUM:
				case ALPHANUMS:
					if (bittab[i-1].Format == LLLVAR)
					{
						memcpy( lendata, pack_tail2, 2);
						pack_tail2 += 2;
						Len = bcdtoi(lendata, 4);
						*bittab[i-1].Length=Len;
					}
					else if (bittab[i-1].Format == LLVAR)
					{
						memcpy(lendata,  pack_tail2, 1);
						pack_tail2 += 1;
						Len = bcdtoi(lendata,2);
						*bittab[i-1].Length=Len;
					}else
						Len = bittab[i-1].Max;
					Len_Pack = Len;
					break;

				case BITS:
					Len = bittab[i-1].Max;
					Len_Pack = Len/8;
					break;

				default:
					status = k_FALSE;
					break;
			}
			if (status != k_TRUE)
				break;

			Ptr_Source = pack_tail2;
			pack_tail2 =pack_tail2+Len_Pack;

			Bit = i;
			if( (status =unpack_fct(Bit,Len,Len_Pack,Ptr_Dest,
					Ptr_Source,Ptr_fnt)) != k_TRUE)
				break;

			if(Ptr_fnt == 2)
			{
				r=Set_Mac(rcv_buf,(Ptr_Source - rcv_buf),
					tmp_mac);
				if(r<0) return(-7);
				if( memcmp(tmp_mac, pack_str->mac, 8) != 0)
				{
					SBlog_print(__FILE__,__LINE__,
						"MAC err!");
					SBlog_print(__FILE__,__LINE__, 
"[%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x]", 
tmp_mac[0], tmp_mac[1], tmp_mac[2], tmp_mac[3], tmp_mac[4], 
tmp_mac[5], tmp_mac[6], tmp_mac[7]);
					SBlog_print(__FILE__,__LINE__, 
"[%02x][%02x][%02x][%02x][%02x][%02x][%02x][%02x]", 
pack_str->mac[0], pack_str->mac[1], pack_str->mac[2], pack_str->mac[3], 
pack_str->mac[4], pack_str->mac[5], pack_str->mac[6], pack_str->mac[7]);
					return(-8);
				}
			}
		}
		i++;
	}while(i <= BIT64);
	return (status) ;
}


int     unpack_fct(int Bit3,int Len3,int Len_Pack3,char *Ptr_Dest3,
				char *Ptr_Source3,char Ptr_fnt3)
{
	int status;
	if((Ptr_Dest3)&&Ptr_fnt3)
	{
		if( Set_Memcpy(Bit3,Len3,Len_Pack3,Ptr_Dest3,Ptr_Source3)!= k_TRUE)
			return(k_FALSE);
	}
	return(k_TRUE);
}



int Set_Mac( char *in_data,int data_len, char *mac_res)
{
	unsigned char data[500],mid_buf[10],mac_key[17];
	int lng,i,j,r;

	if(data_len > 500)
		return -1;

	memset(data,0,500);
	memcpy(data,in_data,data_len);
	memcpy(mac_key, "\x30\x45\x0D\xE9\x8D\x2F\xCA\x1D\x1D\xCE\x64\x9C\x4D\xE4\xC6\x85", 16);

	lng = (data_len+7)/8;
	memset(mac_res,0,8);
	for( i = 0; i < lng; i++)
	{
		for( j = 0; j < 8; j++)
			mac_res[j] ^= data[i*8+j];
		memcpy(mid_buf,mac_res,8);
		trDES(mac_key,mid_buf,mac_res);
	}
	return 0;
}


int Set_Memcpy(int Bit2,int Len2,int Len_Pack2,char *Ptr_Dest2, 
	char *Ptr_Source2)
{
	if ( (bittab[Bit2-1].Attrib == NUMERIC)&&( Len2 % 2) )
	{
		memcpy(Ptr_Dest2, Ptr_Source2, Len_Pack2);
		*(Ptr_Dest2 + Len_Pack2-1) = 
			(*(Ptr_Source2 + Len_Pack2-1)) & 0xf0;
	}
	else
		memcpy(Ptr_Dest2, Ptr_Source2, Len_Pack2);

	return(k_TRUE);
}