lb_cm.c

中国石油二期加油站IC系统后台通讯软件

	RETVALUE(ROK);
}


S16 lbCmBuildInd(U8 cmdCode, U32 seq, TranCb_s * tran, Buffer * msg)
{
	CmdMsg_s * cmdNode;

	if(ROK != lbCmGetCmdNode(tran, &cmdNode))
	{
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(RFAILED);
	}

	cmdNode->msg = msg;
	cmdNode->msgCode = cmdCode;
	cmdNode->action = NULLP;
	cmdNode->rqstType = 0;
	cmdNode->machId = 0;
	cmdNode->sideId = 0;
	cmdNode->gunId = 0;
	cmdNode->dir = IND_DIR;
	cmdNode->indSeq = seq;
	cmdNode->stat = RDY_SEND;

	cmdNode->timer = 1;
	cmdNode->retry = CMD_RETRY_TIMES;
	cmdNode->loadTimer = CMD_RETRY_TIMEOUT;


	RETVALUE(ROK);
}


S16 lbBuildIndCfm(U8 rqstParam, U8 cmdCode, U8 type, TranCb_s * tran)
{
	CmdMsg_s * cmdNode;

	if(ROK != lbCmGetCmdNode(tran, &cmdNode))
	{
		RXLOGERROR(0, 0, 0, "ERROR");
		RETVALUE(RFAILED);
	}
	cmdNode->rqstParam = rqstParam;
	cmdNode->msg = NULLP;
	cmdNode->msgCode = cmdCode;
	cmdNode->action = NULLP;
	cmdNode->rqstType = 0;
	cmdNode->machId = 0;
	cmdNode->sideId = 0;
	cmdNode->gunId = 0;
	cmdNode->dir = IND_DIR;

	cmdNode->alRqstCfmType = type;
	cmdNode->stat = RDY_SEND;

	cmdNode->timer = 1;
	cmdNode->retry = CMD_RETRY_TIMES;
	cmdNode->loadTimer = CMD_RETRY_TIMEOUT;



	RETVALUE(ROK);
}



S16 lbProcEquCfg(U32 gunNum, EquCfg_s * equCfgArray, U8 ver)
{
	RxCmdEntry_s * entry;
	TranCb_s * tran;
	EquCfgEntry_s * equEntry, * temp;
	EquCfg_s cfg;
	CmdMsg_s * cmdNode;
	U32 i = 0;
	U16 price;
	Time_s time;

	if(rxCb.first == TRUE)
	{
		equEntry = (EquCfgEntry_s *)cmLListFirst(&rxCb.pEquCfgList);
		while(NULLP != equEntry)
		{
			if(equEntry->scCommCb!= NULLP)
			{
				CloseHandle(equEntry->scCommCb->comm);
				SPutSBuf(0, 0, (Data *)equEntry->scCommCb, sizeof(ScCommCb_s ));
			}
			temp = (EquCfgEntry_s *)cmLListNext(&rxCb.pEquCfgList);

			cmLListDelFrm(&rxCb.pEquCfgList, (CmLList *)equEntry);
			SPutSBuf(0, 0, (Data *)equEntry, sizeof(EquCfgEntry_s));

			equEntry = temp;
		}


		if(gunNum > 0)
		{
			LBGETCMDENTRY(0, CMD_DIR, entry);
		}

		while(gunNum--)
		{
			if(ROK != SGetSBuf(0, 0, (Data **)&equEntry, sizeof(EquCfgEntry_s)))
			{
				RXLOGERROR(0, 0,0, "ERROR");
				RETVALUE(RFAILED);
			}
			memset(equEntry, 0, sizeof(EquCfgEntry_s));
			memcpy(&equEntry->entry, &equCfgArray[i++], sizeof(EquCfg_s));

			equEntry->scCommCb = createScCommCb(equEntry);
			if(equEntry->scCommCb == NULLP)
			{
				RXLOGERROR(0, 0,0, "ERROR");
				RETVALUE(RFAILED);
			}
			equEntry->cardInStat = FALSE;
			equEntry->crrntAcount = 0;
			equEntry->crrntVolume = 0;
			equEntry->duringVolume = 0;
			equEntry->stat = GUN_DOWN;
			equEntry->lastStat = GUN_DOWN;
			equEntry->cmdProcErrCode = 0;
			equEntry->first = TRUE;

			cmLListInit(&equEntry->histroy);

			cmLListAdd2Tail(&rxCb.pEquCfgList, (CmLList*)equEntry);
			if(ROK != lbCmGetPriceByOilType(equEntry->entry.oilType, &price, &time))
			{
				continue;
			}

			LBGETTRAN(entry, equEntry, tran);
			lbBuildSetOilTypeCmd(equEntry, tran);
			lbBuildSetPriceCmd(equEntry, tran, price, &time); 

		}
		rxCb.cfg.tranKeyVer = ver;
		rxCb.first = FALSE;
	}
	else
	{
		if(gunNum > 0)
		{
			LBGETCMDENTRY(0, CMD_DIR, entry);
		}

		while(gunNum--)
		{
			memcpy(&cfg, &equCfgArray[i++], sizeof(EquCfg_s));

			equEntry = findEqu(cfg.gunId);
			if(equEntry == NULLP)
			{
				continue;
			}

			if(ROK != lbCmGetPriceByOilType(equEntry->entry.oilType, &price, &time))
			{
				continue;
			}


			LBGETTRAN(entry, equEntry, tran);
			lbBuildSetOilTypeCmd(equEntry, tran);


			lbBuildSetPriceCmd(equEntry, tran, price, &time); 

		}
	}



	RETVALUE(ROK);
}

#ifndef UP_LAYER_UNSECRET
S16 lbProcProvinceBlk(U32 itemNum, BlkCardLine_s * array, U8 type)
{
	CmdMsg_s * cmdNode;
	EquCfgEntry_s * equ;
	Buffer * msg;
	U32  i;
	BlkListCmd_s cmd;

	RxCmdEntry_s * entry;
	TranCb_s * tran;

	equ = (EquCfgEntry_s *)cmLListFirst(&rxCb.pEquCfgList);
	if(equ != NULLP)
	{
		LBGETCMDENTRY(0, CMD_DIR, entry);
	}

	while(NULLP != equ)
	{
		LBGETTRAN(entry, equ, tran);
		for(i = 0; i<itemNum ; i++)
		{
			if(ROK != lbCmGetCmdNode(tran, &cmdNode))
			{
				RXLOGERROR(0, 0, 0, "ERROR");
				RETVALUE(RFAILED);
			}
			if(ROK != SGetMsg(0, 0, &msg))
			{
				lbCmDestroyCmdNode(cmdNode);
				RXLOGERROR(0, 0, 0, "ERROR");
				RETVALUE(RFAILED);
			}

			memset((Data *)&cmd, 0, sizeof(BlkListCmd_s));

			cmd.hdr.frameStart = 0x55aa;
			cmd.hdr.sideId = equ->entry.sideId;
			cmd.hdr.dataLen = 109;
			cmd.type = type;
			cmd.cmd = 0xd2;

			cmd.cnt = htons(i+1);
			memcpy(&cmd.line, &array[i], sizeof(BlkCardLine_s));

			SAddPstMsgMult((Data *)&cmd, (MsgLen)(cmd.hdr.dataLen + 3), msg);

			cmdNode->msg = msg;
			cmdNode->msgCode = 0xd2;
			cmdNode->action = NULLP;
			cmdNode->machId = equ->entry.machId;
			cmdNode->sideId = equ->entry.sideId;
			cmdNode->gunId = equ->entry.pGunId;
			cmdNode->dir = CMD_DIR;
			cmdNode->chId = equ->entry.channelId;
			cmdNode->stat = RDY_SEND;

			cmdNode->timer = 1;
			cmdNode->retry = 500;
			cmdNode->loadTimer = BLKRETRY_TIMER;
		}
		if(ROK != lbCmGetCmdNode(tran, &cmdNode))
		{
			RXLOGERROR(0, 0, 0, "ERROR");
			RETVALUE(RFAILED);
		}
		if(ROK != SGetMsg(0, 0, &msg))
		{
			lbCmDestroyCmdNode(cmdNode);
			RXLOGERROR(0, 0, 0, "ERROR");
			RETVALUE(RFAILED);
		}

		memset((Data *)&cmd, 0, sizeof(BlkListCmd_s));

		cmd.hdr.frameStart = 0x55aa;
		cmd.hdr.sideId = equ->entry.sideId;
		cmd.hdr.dataLen = 3;
		cmd.cmd = 0xd2;
		cmd.cnt = 0;

		SAddPstMsgMult((Data *)&cmd, (MsgLen)(cmd.hdr.dataLen + 3), msg);

		cmdNode->msg = msg;
		cmdNode->msgCode = 0xd2;
		cmdNode->action = NULLP;
		cmdNode->machId = equ->entry.machId;
		cmdNode->sideId = equ->entry.sideId;
		cmdNode->gunId = equ->entry.pGunId;
		cmdNode->dir = CMD_DIR;
		cmdNode->chId = equ->entry.channelId;

		cmdNode->timer = 1;
		cmdNode->retry = CMD_RETRY_TIMES;
		cmdNode->loadTimer = 1000;

		equ = (EquCfgEntry_s *)cmLListNext(&rxCb.pEquCfgList);
	}
	RETVALUE(ROK);
}

#else

S16 lbProcProvinceBlk(Buffer * cardAsnBuffer, U32 itemNum, U8 blkListType)
{
	CmdMsg_s * cmdNode;
	EquCfgEntry_s * equ;
	Buffer * msg, * temp, * cmd_msg;
	U32  i;
	BlkListCmd_s cmd;

	RxCmdEntry_s * entry;
	TranCb_s * tran;
	MsgLen len;

	equ = (EquCfgEntry_s *)cmLListFirst(&rxCb.pEquCfgList);
	if(equ != NULLP)
	{
		LBGETCMDENTRY(0, CMD_DIR, entry);
	}

	while(NULLP != equ)
	{
		U16 cnt;

		LBGETTRAN(entry, equ, tran);

		SAddMsgRef(cardAsnBuffer, 0, 0, &msg);

		SFndLenMsg(msg, &len);

		cnt = 1;

		while(len >= 100)
		{
			if(ROK != lbCmGetCmdNode(tran, &cmdNode))
			{
				RXLOGERROR(0, 0, 0, "ERROR");
				RETVALUE(RFAILED);
			}
			if(ROK != SGetMsg(0, 0, &cmd_msg))
			{
				lbCmDestroyCmdNode(cmdNode);
				RXLOGERROR(0, 0, 0, "ERROR");
				RETVALUE(RFAILED);
			}

			memset((Data *)&cmd, 0, sizeof(BlkListCmd_s));

			cmd.hdr.frameStart = 0x55aa;

			cmd.hdr.sideId = 0;

			cmd.hdr.dataLen = 106;

			cmd.cmd = 0xdb;

			cmd.cnt = htons(cnt++);

			cmd.type = blkListType;

			cmd.asnNum = 10;

			if(ROK != SAddPstMsgMult((Data *)&cmd, 9, cmd_msg))
			{
				RXLOGERROR(0, 0, 0, "ERROR");
				RETVALUE(RFAILED);
			}

			if(RFAILED == SSegMsg(msg, 100, &temp))
			{
				RXLOGERROR(0, 0, 0, "ERROR");
				RETVALUE(RFAILED);
			}

			if( ROK != SCatMsg(cmd_msg, msg, M1M2))
			{
				RXLOGERROR(0, 0, 0, "ERROR");
				RETVALUE(RFAILED);
			}

			SPutMsg(msg);

			msg = temp;

			cmdNode->msg = cmd_msg;
			cmdNode->msgCode = 0xdb;
			cmdNode->action = NULLP;
			cmdNode->machId = equ->entry.machId;
			cmdNode->sideId = equ->entry.sideId;
			cmdNode->gunId = equ->entry.pGunId;
			cmdNode->dir = CMD_DIR;
			cmdNode->chId = equ->entry.channelId;
			cmdNode->stat = RDY_SEND;

			cmdNode->timer = 1;
			cmdNode->retry = 500;
			cmdNode->loadTimer = BLKRETRY_TIMER;

			if( msg == NULL)
			{
				len -= 100;
				break;
			}
			SFndLenMsg(msg, &len);

		}
		if(ROK != lbCmGetCmdNode(tran, &cmdNode))
		{
			RXLOGERROR(0, 0, 0, "ERROR");
			RETVALUE(RFAILED);
		}
		if(ROK != SGetMsg(0, 0, &cmd_msg))
		{
			lbCmDestroyCmdNode(cmdNode);
			RXLOGERROR(0, 0, 0, "ERROR");
			RETVALUE(RFAILED);
		}

		memset((Data *)&cmd, 0, sizeof(BlkListCmd_s));

		cmd.hdr.frameStart = 0x55aa;

		cmd.hdr.sideId = 0;

		cmd.hdr.dataLen = 6 + len;

		cmd.cmd = 0xdb;

		cmd.cnt = 0;

		cmd.type = blkListType;

		cmd.asnNum = len / 10;

		SAddPstMsgMult((Data *)&cmd, 9, cmd_msg);
		if(len > 0)
		{
			SCatMsg(cmd_msg, msg, M1M2);
			SPutMsg(msg);
		}


		cmdNode->msg = cmd_msg;
		cmdNode->msgCode = 0xdb;
		cmdNode->action = NULLP;
		cmdNode->machId = equ->entry.machId;
		cmdNode->sideId = equ->entry.sideId;
		cmdNode->gunId = equ->entry.pGunId;
		cmdNode->dir = CMD_DIR;
		cmdNode->chId = equ->entry.channelId;
		cmdNode->stat = RDY_SEND;

		cmdNode->timer = 1;
		cmdNode->retry = 500;
		cmdNode->loadTimer = BLKRETRY_TIMER;

		equ = (EquCfgEntry_s *)cmLListNext(&rxCb.pEquCfgList);
	}


	RETVALUE(ROK);
}



#endif

S16 lbProcCountryBlk(Buffer * cardAsnBuffer, U32 itemNum, U8 blkListType)
{
	CardAsn_s * asnEnt;
	MsgLen len;
	CardAsn_s dAsnEnt;


	switch(blkListType)
	{
	case 0x01:
		while(ROK == cmHashListGetNext(&rxCb.BlkListHl, NULLP, (PTR*)&asnEnt))
		{
			cmHashListDelete(&rxCb.BlkListHl, (PTR)asnEnt);

			SPutSBuf(0, 0, (Data *)asnEnt, sizeof(CardAsn_s));
		}
	case 0x02:
		SFndLenMsg(cardAsnBuffer, &len);
		while(len >= 10)
		{
			if(ROK != SGetSBuf(0 ,0, (Data **)&asnEnt, sizeof(CardAsn_s)))
			{
				RXLOGERROR(0, 0, 0, "ERROR");
				RETVALUE(RFAILED);
			}

			SRemPreMsgMult(asnEnt->asn, 10, cardAsnBuffer);

			if(0 == memcmp(asnEnt->asn, "\0\0\0\0\0\0\0\0\0\0", 10))
			{
				break;
			}

			cmHashListInsert(&rxCb.BlkListHl, (PTR)asnEnt, asnEnt->asn, 10);
			SFndLenMsg(cardAsnBuffer, &len);
		}
		break;

	case 0x03:
		SFndLenMsg(cardAsnBuffer, &len);
		while(len >= 10)
		{

			SRemPreMsgMult(dAsnEnt.asn, 10, cardAsnBuffer);

			if(0 == memcmp(dAsnEnt.asn, "\0\0\0\0\0\0\0\0\0\0", 10))
			{
				break;
			}

			if(ROK != cmHashListFind(&rxCb.BlkListHl, dAsnEnt.asn, 10, 0, (PTR*)&asnEnt))
			{
				SFndLenMsg(cardAsnBuffer, &len);
				continue;
			}

			cmHashListDelete(&rxCb.BlkListHl, (PTR)asnEnt);
			SPutSBuf(0, 0, (Data *)asnEnt, sizeof(CardAsn_s));

			SFndLenMsg(cardAsnBuffer, &len);
		}
		break;
	}
	RETVALUE(ROK);
}


S16 lbPrcGreyList(Buffer * greyBuffer, U8 type)
{
	CmHashListCp * hash;
	GreyRecordEnt_s * ent;
	GreyRecordEnt_s  dEnt;
	MsgLen len;
	U16 seq;
	S16 ret;

	switch(type & 0xf0)
	{
	case 0x10:
		hash = &rxCb.GreyListProteroHl;


		break;

	case 0x20:
		hash = &rxCb.GreyListIBankHl;
		break;

	case 0x30:
		hash = &rxCb.GreyListPoneyHl;
		break;
	default:
		RETVALUE(RFAILED);
	}

	switch(type & 0x0f)
	{
	case 0x01:
		while(ROK == cmHashListGetNext(hash, NULLP, (PTR*)&ent))
		{
			cmHashListDelete(&rxCb.BlkListHl, (PTR)ent);

			SPutSBuf(0, 0, (Data *)ent, sizeof(GreyRecordEnt_s));
		}
	case 0x02:
		SFndLenMsg(greyBuffer, &len);
		while(len >= sizeof(GreyRecord_s))
		{
			if(ROK != SGetSBuf(0 ,0, (Data **)&ent, sizeof(GreyRecordEnt_s)))
			{
				RXLOGERROR(0, 0, 0, "ERROR");
				RETVALUE(RFAILED);
			}

			SRemPreMsgMult((Data *)&ent->record, sizeof(GreyRecord_s), greyBuffer);


			cmHashListInsert(hash, (PTR)ent, ent->record.asn, 10);
			SFndLenMsg(greyBuffer, &len);
		}
		break;

	case 3:
		SFndLenMsg(greyBuffer, &len);
		while(len >= 10)
		{

			SRemPreMsgMult((Data *)&dEnt.record, sizeof(GreyRecord_s), greyBuffer);
			seq = 0;

			while(ROK == (ret = cmHashListFind(hash, dEnt.record.asn, 10, seq, (PTR*)&ent)))
			{
				if(0 == memcmp(dEnt.record.time, ent->record.time, 7))
				{
					break;
				}
				seq++;
			}
			if(ret != ROK)
			{
				SFndLenMsg(greyBuffer, &len);
				continue;
			}

			cmHashListDelete(hash, (PTR)ent);
			SPutSBuf(0, 0, (Data *)ent, sizeof(GreyRecordEnt_s));

			SFndLenMsg(greyBuffer, &len);
		}
		break;
	}
	RETVALUE(ROK);
}

S16 lbCmPrntBuf(Txt * desc, Data * buf, MsgLen len)
{
	Data printbuf[2048];
	U32  idx = 0;
	rxLog(desc);
	while(len--)
	{
		idx += sprintf(&printbuf[idx], "%2x ", *buf++); 
	}
	rxLog(printbuf);
	RETVALUE(ROK);
}

S16 lbGetFileBuf(Txt * path, Buffer * msg)
{
	FILE * fd;
	U32 bufLen = 0;
	Data key;
	Bool flag = TRUE;