eldsmart.c

AT Command for Modem G18 Motorola

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "gen.h"
#include "ccv500hw.h"
#include "mif1low.h"
#include "eldsmart.h"
#include "display.h"
#include "keybhal.h"
#include "lista.h"
#include "timeutil.h"
#include "keyb.h"
#include "iosys.h"
#include "flash.h"
#include "dffs.h"
#include "cpuhal.h"
#include "serhal.h"
#include "icc.hpp"
#include "iccasync.h"

#define STX  0x02
#define ACK  0x06
#define NACK 0x0F
#define PIC_SOCKET  COM_PIC_SOCKET

KEY t_key[16] =
  {{{0xBD, 0xDE, 0x6F, 0x37, 0x83, 0x83}},
	{{0x14, 0x8A, 0xC5, 0xE2, 0x28, 0x28}},
	{{0x7D, 0x3E, 0x9F, 0x4F, 0x95, 0x95}},
	{{0xAD, 0xD6, 0x6B, 0x35, 0xC8, 0xC8}},
	{{0xDF, 0xEF, 0x77, 0xBB, 0xE4, 0xE4}},
	{{0x09, 0x84, 0x42, 0x21, 0xBC, 0xBC}},
	{{0x5F, 0xAF, 0xD7, 0xEB, 0xA5, 0xA5}},
	{{0x29, 0x14, 0x8A, 0xC5, 0x9F, 0x9F}},
	{{0xFA, 0xFD, 0xFE, 0x7F, 0xFF, 0xFF}},
	{{0x73, 0x39, 0x9C, 0xCE, 0xBE, 0xBE}},
	{{0xFC, 0x7E, 0xBF, 0xDF, 0xBF, 0xBF}},
	{{0xCF, 0xE7, 0x73, 0x39, 0x51, 0x51}},
	{{0xF7, 0xFB, 0x7D, 0x3E, 0x5A, 0x5A}},
	{{0xF2, 0x79, 0x3C, 0x1E, 0x8D, 0x8D}},
	{{0xCF, 0xE7, 0x73, 0x39, 0x45, 0x45}},
	{{0xB7, 0xDB, 0x6D, 0xB6, 0x7D, 0x7D}}};

//------------------------------------------------------------------------------
//teclado da planeta
/*unsigned char Keyboard_map[17]={ K_NDEF, K_UP, 0x03, 0x02, 0X01,
											K_DOWN, 0x06, 0x05, 0X04, K_NDEF,
											0x09, 0x08, 0X07, K_DEL, K_ENT,
											0x00, K_CANC};      */

//------------------------------------------------------------------------------
//teclado novo james - reconfigurado e para posi鏰o em mesa

unsigned char Keyboard_map[17]={ K_NDEF,0X01,0X04,0X07,K_ENT,0X02,0X05,0X08,
											0X00,0x03,0X06,0X09,K_CANC,K_UP,K_DOWN,
											K_F1,K_DEL};
*/
//------------------------------------------------------------------------------
//teclado novo james - reconfigurado e para posi鏰o na parede
/*
unsigned char Keyboard_map[17]={ K_NDEF,K_ENT,0X07,0X04,0X01,
													 0X00,0X08,0X05,0X02,
													 K_CANC,0X09,0X06,0x03,
													 K_F2,K_F1,K_DOWN,K_UP};

//------------------------------------------------------------------------------
*/
ULONG work_serial;
int n_max_log=0;

struct DISPLAY_CCB displayCCB;        // objeto para acesso display
struct KEYBOARD_CCB keyboard;         // teclado
struct config_def config_lib;
char msg[256];
int next_log_seq;
int next_log_rec = 0;
//Funcoes Locais
BOOL has_card(ULONG *n_serie);
int rxChar(int socket, UCHAR *dataRead, int bytesRead);
BOOL get_pic_resp(UCHAR *resp, UCHAR respSize);

BOOL detect_card(ULONG *n_serie, BOOL save_serial)
{
	UINT cont, tag;
	BOOL has_card = FALSE;

	for(cont=0; cont<2; cont++)
		if(mif_request_2(0, &tag) == 0)
		{
			if(mif_anticoll(0, n_serie) == 0)
			{
				has_card = TRUE;
				if(save_serial)
					work_serial = *n_serie;
				else
					work_serial = 0;
			}
			break;
		}

	return has_card;
}


BOOL has_card(ULONG *n_serie)
{
	UINT cont, tag;
	BOOL has_card = FALSE;

	for(cont=0; cont<2; cont++)
		if(mif_request_2(0, &tag) == 0)
		{
			if(mif_anticoll(0, n_serie) == 0)
				has_card = TRUE;
			break;
		}

	return has_card;
}


BOOL card_auth(KEY *key, UCHAR authKey, UCHAR setor)
{
	BOOL status = FALSE;
	ULONG serial_card;
	char trailer;
	UCHAR size,mode=0x00;

	if(authKey==2)
		mode = 0x04;

	if(has_card(&serial_card))
		// Se work_card for igual a zero assume que se trata de um novo cartao.
		if((serial_card == work_serial) || (work_serial == 0))
			if(mif_select(serial_card, &size) == 0)
					if(mif_load_key(mode, setor, &(t_key[setor]), key) == 0)
					{
						trailer = (setor*4) + 3;
						if(mif_authentication_2(mode, setor, trailer) == 0)
							status = TRUE;
					}
	return status;
}


BOOL get_field(KEY *key, struct card_map *field, ULONG *lvar)
{
	BOOL status = FALSE;
	UCHAR setor, dataRead[16];

	setor = field->block/4;

	if(card_auth(key, 0, setor))
		if(mif_read(field->block, dataRead) == 0)
		{
			*lvar = get_value(dataRead, field->ini, field->len);
			status = TRUE;
		}

	return status;
}



BOOL get_block(KEY *key, UCHAR authKey, UCHAR block, UCHAR *dataRead)
{
	BOOL status = FALSE;

	if(card_auth(key, authKey, block/4))
	{
		if(mif_read(block, dataRead) == 0)
			status = TRUE;
	}

	return status;
}



BOOL set_block(KEY *key, UCHAR authKey, UCHAR block, UCHAR *dataRead)
{
	BOOL status = FALSE;

	if(block%4 != 3)
		if(card_auth(key, authKey, block/4))
			if(mif_write(block, dataRead) == 0)
				status = TRUE;

	return status;
}

BOOL set_field(KEY *key, struct card_map *field, ULONG lvar)
{
	BOOL status = FALSE;
	UCHAR setor, dataRead[16];

	setor = field->block/4;

	if(card_auth(key, 0, setor))
	{
		if(mif_read(field->block, dataRead)==0)
		{
			set_value(dataRead, lvar, field->ini, field->len);
			if(card_auth(key, 4, setor))
				if(mif_write(field->block, dataRead) == 0)
					status = TRUE;
		}
	}
	return status;
}



ULONG get_value(UCHAR *dataRead, UCHAR ini, UCHAR len)
{
	ULONG value = 0;
	UCHAR cont, mask;
	ULONG mask_value = 0x00000001L;

	mask = 0x01<<(ini%8);

	for(cont=0; cont<len; cont++, ini++)
	{
		if(dataRead[ini/8] & mask)
			value |= mask_value;

		if(mask == 0x80)
			mask = 0x01;
		else
			mask <<= 1;

		mask_value <<= 1;
	}
	return value;
}


ULONG get_value2(UCHAR *dataRead, UINT ini, UCHAR len)
{
	// Funcao de acordo com especificacao da Digicon (Mapa do cartao de usuario v2.7)

	ULONG value = 0;
	UCHAR cont, mask;
	UINT  ndx;
	ULONG mask_value = 0x00000001L;

	ndx = ini+len;

	// Determina posicao inicial do bit na mascara de comparacao
	mask = 0x01;
	if((ndx % 8) != 0)
		mask <<= (8-(ndx%8));

	ndx--;
	for(cont=0; cont<len; cont++, ndx--)
	{
		if(dataRead[ndx/8] & mask)
			value |= mask_value;

		if(mask == 0x80)
			mask = 0x01;
		else
			mask <<= 1;

		mask_value <<= 1;
	}
	return value;
}




void set_value(UCHAR *dataWrite, ULONG value, UCHAR ini, UCHAR len)
{
	UCHAR cont, mask;
	ULONG mask_value = 0x00000001L;

	mask = 0x01<<(ini%8);

	for(cont=0; cont<len; cont++, ini++)
	{
		if (value & mask_value)
			dataWrite[ini/8] |= mask;     //liga o bit
		else
			dataWrite[ini/8] &= (~mask);  //desliga o bit

		if(mask == 0x80)
			mask = 0x01;
		else
			mask <<= 1;

		mask_value <<= 1;
	}
}


void set_value2(UCHAR *dataWrite, ULONG value, UINT ini, UCHAR len)
{
	UCHAR cont, mask;
	UINT ndx;
	ULONG mask_value = 0x00000001L;

	ndx = ini+len;

	// Determina posicao inicial do bit na mascara de comparacao
	mask = 0x01;
	if((ndx % 8) != 0)
		mask <<= (8-(ndx%8));

	ndx--;
	for(cont=0; cont<len; cont++, ndx--)
	{
		if (value & mask_value)
			dataWrite[ndx/8] |= mask;     //liga o bit
		else
			dataWrite[ndx/8] &= (~mask);  //desliga o bit

		if(mask == 0x80)
			mask = 0x01;
		else
			mask <<= 1;

		mask_value <<= 1;
	}
}


void Init_Display(void)
{

	displayCCB.numOfLines = 2;
	displayCCB.numOfCols = 16;
	displayCCB.m5_10	= 0;
	displayCCB.nLines = 0;
	displayCCB.shift	= 1;
	displayCCB.inc = 0;
	displayCCB.graphic = 0;

	DisplayOpen(&displayCCB);

}

void Display(char *msg, int msg_size, int linha, int coluna)
{
	DisplayPutMsgTo(&displayCCB, msg, msg_size, linha, coluna);
}


void Init_Keyboard(void)
{
	KeyBoardOpen(&keyboard, 0x00, 0x00, 0x01);
	KeyBoardEnable();
}


unsigned char read_keyboard(void)
{
	return Keyboard_map[KeyBoardRead()];
}


/*Funcao para controle do Menu */
UCHAR display_menu(struct menu_option * menu, UCHAR father, UCHAR elementos)
{
	UCHAR cont, key, option = 0;
	char opt,msg[17];
	ULONG serial;

	struct{
		UCHAR str[MAX_TEXT];
		UCHAR ndx;
	}menu_aux[MAX_MENU_ITENS];


	opt = 0;

	DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"                "),0,0);
	DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"                "),1,0);

//	sprintf(msg, "\n\rNivel: %02d ",father);
//	WriteIO(msg, 0, 0);

	memset(menu_aux[0].str, 0x00, sizeof(menu_aux[0].str));

	for(cont=0; cont < elementos; cont++)
		if(menu[cont].father == father)
		{
			memmove(menu_aux[option].str, menu[cont].str, 15);
			menu_aux[option].ndx = cont;
			option++;
		}

	do
	{
		DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"%01d-%s",opt+1,menu_aux[opt].str),0,0);
		if(option > 1)
			DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"%01d-%s",opt+2,menu_aux[opt+1].str),1,0);

		key = read_keyboard();

		if(key == K_UP)
			opt--;
		else if(key == K_DOWN)
			opt++;
		else if((key == K_CANC) && (father != 0))
		{
			for(cont=0; cont < elementos; cont++)
				if(menu[cont].id == father)
						return display_menu(menu, menu[cont].father, elementos);
		}
		else if(key > 0 && key <= option)
				  if(menu[menu_aux[key-1].ndx].function == 0)
					  return display_menu(menu, menu[menu_aux[key-1].ndx].id, elementos);
				  else
					  return menu[menu_aux[key-1].ndx].function;

		if(opt < 0)
			opt = 0;

		if(option > 1)
		{
			if((opt+2) > option)
				opt--;
		}
		else
			if(opt > (option-1))
				opt--;

	}while(has_card(&serial));

	return 0;
}


unsigned long get_value_input(unsigned char value_limit, unsigned char n_digits, BOOL decimal,
										char *str)
{
	ULONG limit,value,aux_value;
	UCHAR key=K_NDEF;
	char msg[100],digits=0,pos,ini_pos;


	if ((n_digits <= 0) || (n_digits >14))
		return -1;


	if (!decimal)
		ini_pos = 15-(n_digits+1);
	else
		ini_pos = 15-(n_digits+4);

	DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"                "),1,0);
	DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"%s",str),1,0);

	DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"]"),1,15);
	DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"["),1,ini_pos);

	if (value_limit==1)
		limit = 0xffff;
	else
		limit = 0x7fffffffL;

	aux_value  = value = 0;
	pos = (decimal ? 11:14);
	while (key!=K_CANC && key!=K_ENT)
	{
		 key = read_keyboard();

		 aux_value = value;

		 if (key<=9)
		 {
			 if((limit/10) >= aux_value)
				 if(key <= (limit-(aux_value*10)))
				 {
					 aux_value = key + (aux_value*10);

			 //limita o valor a 2 ou 4 bytes
					 if (aux_value<=limit && aux_value>0 && digits<n_digits)
					 {
						 value = aux_value;
						 pos = 14-digits;//n_digits-digits;
						 if (!decimal)
							 digits += 1;
						 else
							 digits += ((value/100)>0 ? 1:0);
					 }
				 }
		 }

		 if (key==K_F2)
		 {
			 if ((digits>0))
				 digits -= 1;

			 if (digits==0)
				 pos = 14;//n_digits;
			 else
				 pos = 15-digits;//(n_digits-digits)+1;

			 value = value/10;

			 DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"                "),1,0);

			 DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"%s",str),1,0);
			 DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"]"),1,15);
			 DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"["),1,ini_pos);

		 }

		 if (!decimal)
			 DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"%lu",value),1,pos);
		 else
			 DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"%lu,%02lu",value/100,value%100),1,
																  11-(digits>1?digits-1:0));
	}

	if (key==K_CANC)
		value = 0;

	DisplayPutMsgTo(&displayCCB,msg,sprintf(msg,"                "),1,0);

	return value;

}


int open_file(char * nm_file, unsigned long file_size, int rec_size)
{
	int  hFile=-1;
	long cont,registros=0;
	UCHAR *buffer;
	char msg[100];

	//Verifica se arquivo existe ou nao
	//Se nao existir, cria arquivo e limpa seu conteudo
	if ( (hFile=OpenFile(FLASH_INTERNA, nm_file, MODO_ESCRITA))<0)
	{
		sprintf(msg,"\n\rVai criar e limpar arquivo!! - %s",nm_file);
		WriteIO(msg,0,0);

		//Arquivo nao existe...cria e limpa!