lb_recv.c

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

/*
***********************************************************************************************************
													  Amos
										  The Real_Time Operation System
												   Multi Task
								 (c) Copyright 1998-2002, ShangYaoHui, Shenzhen
											  All Right Reserved
												  VERSION 6.01

" By  : 商耀挥(ShangYaoHui)
 create time: 2002-7-1 16:31:29  
***********************************************************************************************************
*/

/************ head file list *************/
/* header include files -- defines (.h) */
#include "envopt.h"        /* environment options */
#include "envdep.h"        /* environment dependent */
#include "envind.h"        /* environment independent */

#include "gen.h"           /* general */
#include "cm5.h"           /* common functions */
#include "ssi.h"           /* system services */

/* header/extern include files (.x) */

#include "gen.x"           /* general */
#include "cm5.x"           /* common functions */
#include "ssi.x"           /* system services */

#include "cm_llist.h"
#include "cm_llist.x"

#ifdef WIN32
	#include "winbase.h"
	#include "winsock2.h"
#endif

#include "rx.h"
#include "rx.x"

#include "rx_msg.h"
#include "rx_msg.x"

#include "lb_cm.h"
#include "lb_cm.x"

#include "lb_recv.h"
#include "lb_recv.x"
#include "lb_xmit.h"
#include "lb_xmit.x"
#include "lb_msg.h"
#include "lb_msg.x"

#include "lb_bdy1.h"
#include "lb_bdy1.x"
#include "lb_bdy2.h"
#include "lb_bdy2.x"
#include "lb_bdy4.h"
#include "lb_bdy3.h"
#include "lb_bdy3.x"
#include "lb_bdy4.h"
#include "lb_bdy4.h"
#include "lb_bdy4.x"
#include "lb_bdy5.h"
#include "lb_bdy5.x"

/************* const define **************/

/******** import variable declare ********/

/******* gloable variable declare ********/

/*********** function declare ************/

/********** function prototype ***********/
S16 lbRecvProcess(ScCommCb_s * scCommCb)
{
	COMSTAT commStat;
	S32 err, len, actualLen;
	S16 ret = RFAILED;

	err = ClearCommError(scCommCb->comm, &err, &commStat );
	if(err == 0)
	{
		err = GetLastError();
	}

	len = commStat.cbInQue;

	if(len > 0)
	{
#if 0
		Data * recvBuf;
#endif	
		Data   recvBuf[2048];
#if 0
		if(ROK != SGetSBuf(0, 0, &recvBuf, len))
		{
			RXLOGERROR(ENTSC, 0, 0, "Error: no buf to recv comm message");
			RETVALUE(RFAILED);
		}
#endif
		ret = ReadFile(scCommCb->comm, recvBuf, len, &actualLen, NULLP);
		if(ret != FALSE)
		{
			#ifdef LO_DEBUG
			lbCmPrntBuf("Recv buf: ", recvBuf, (MsgLen)actualLen);
			LBLOG(scCommCb->commName, 0, 0);
			LBLOG("Recv msg", recvBuf, actualLen);

			#endif
			ret = lbParseRecvMsg(scCommCb, (Data *)recvBuf, (MsgLen)actualLen);
		}
#if 0
		SPutSBuf(0, 0, recvBuf, len);
#endif

	}
	RETVALUE(ret);
}


S16 lbRecvReadTotleAck(EquCfgEntry_s * equ, TranCb_s * tran, ReadTotleAck_s * ack)
{
	U8 gunId;
	U32 * volume;

	if(ack->ackCode != 'A')
	{
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}

	if(ack->gunNum != 1)
	{
		printf("error gun num\n");
		RETVALUE(RFAILED);
	}
	volume = (U32 *)(ack+1) ;

	for(gunId = 0; gunId < ack->gunNum; gunId++)
	{
		equ->totleVolume = ntohl(volume[gunId]);
		equ->duringVolume = ntohl(volume[gunId + ack->gunNum]);
	}

	RETVALUE(ROK);
}

S16 lbRecvReadFillCardAsnAck(EquCfgEntry_s * equ, TranCb_s * tran, ReadCardAsnAck_s * ack)
{

	if(ack->ackCode != 'A')
	{
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}

    memcpy(equ->crrntCardNo, ack->asn, 10);

	RETVALUE(ROK);
}

S16 lbRecvReadBlkCardAsnAck(EquCfgEntry_s * equ, TranCb_s * tran, ReadCardAsnAck_s * ack)
{
	RxCmdEntry_s * entry;
    CardAsn_s * ent;

	if(ack->ackCode != 'A')
	{
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}

	LBGETCMDENTRY(0, CMD_DIR, entry);
	LBGETTRAN(entry, equ, tran);
	lbBuildCfm(equ,tran , BLK_CARD_RQST, NULLP);
	if(ROK != cmHashListFind(&rxCb.BlkListHl, ack->asn, 10, 0, (PTR*)&ent))
	{
		equ->cfmStat = RFAILED;
	}
	else
	{
		equ->cfmStat = ROK;

		LBGETCMDENTRY(0, CMD_DIR, entry);
		LBGETTRAN(entry, equ, tran);
		lbBuildGetCardInfo(equ,tran , NULLP);


		LBGETCMDENTRY(0, IND_DIR, entry);
		LBGETTRAN(entry, equ, tran);

		lbIndCardInfoMsg(equ,tran , NULLP);
	}

	RETVALUE(ROK);
}


S16 lbRecvReadWorkerCardAsnAck(EquCfgEntry_s * equ, TranCb_s * tran, ReadCardAsnAck_s * ack)
{

	if(ack->ackCode != 'A')
	{
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}


	memcpy(equ->workerCardNo, ack->asn, 10);

	RETVALUE(ROK);
}


S16 lbRecvReadCardInfoAck(EquCfgEntry_s * equ, TranCb_s * tran, ReadCardInfoAck_s * ack)
{

	if(ack->ackCode != 'A')
	{
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}


	memcpy(equ->crrntCardNo, ack->asn, 10);

	equ->crrntCardInfo.cardType = ack->cardType;
	equ->crrntCardInfo.cardValue = ntohl(ack->cardValue);
	equ->crrntCardInfo.cardStat = ack->cardStat;
	equ->crrntCardInfo.cardBallencStat = ack->cardBallencStat;
	equ->crrntCardInfo.cardBallencValue = ntohl(ack->cardBallencValue);

	RETVALUE(ROK);
}

S16 lbRecvAuthAck( EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack)
{
	if(ack->ackCode != 'A')
	{
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}

S16 lbRecvFinishFillAck( EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack)
{
	if(ack->ackCode != 'A')
	{
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}

S16 lbRecvCloseDuringAck( EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack)
{

	if(ack->ackCode != 'A')
	{
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}
	equ->duringVolume = 0;

	RETVALUE(ROK);
}

S16 lbRecvGetCrrntPriceAck(EquCfgEntry_s * equ, TranCb_s * tran,  ReadCrrntPriceAck_s * ack)
{
	if(ack->ackCode != 'A')
	{
		equ->cmdProcErrCode |= 0x01;
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}


	equ->crrntPrice = ack->price;

	RETVALUE(ROK);

}

S16 lbRecvWriteBackupPriceAck( EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack)
{
	if(ack->ackCode != 'A')
	{
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}


S16 lbRecvReadOilTypeAck(EquCfgEntry_s * equ, TranCb_s * tran, ReadOilTypeAck_s * ack)
{

	if(ack->ackCode != 'A')
	{
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}
	equ->readOilType = ack->oilType;

	RETVALUE(ROK);
}

S16 lbRecvWriteOilTypeAck( EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack)
{
	if(ack->ackCode != 'A' && ack->ackCode != 'W')
	{
		printf("error : ackcode\n");
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}



S16 lbRecvSpecCodeAck(EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack, CmdMsg_s * cmdNode)
{
	if(ack->ackCode == 'W')
	{
		cmdNode->stat = HAVE_ACK_W;
		RETVALUE(RFAILED);
	}
	else if(ack->ackCode == 'E')
	{
		equ->cmdProcErrCode |= 0x01;
	}
	else if(ack->ackCode != 'A')
	{
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}

S16 lbRecvWriteGreyAck(EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack, CmdMsg_s * cmdNode)
{
	if(ack->ackCode == 'W')
	{
		cmdNode->stat = HAVE_ACK_W;
		RETVALUE(RFAILED);
	}
	else if(ack->ackCode == 'E')
	{
		equ->cmdProcErrCode |= 0x01;
	}
	else if(ack->ackCode != 'A')
	{
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}

S16 lbRecvSetTimeAck(EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack, CmdMsg_s * cmdNode)
{
	if(ack->ackCode == 'W')
	{
		cmdNode->stat = HAVE_ACK_W;
		RETVALUE(RFAILED);
	}
	else if(ack->ackCode == 'E')
	{
		equ->cmdProcErrCode |= 0x01;
	}
	else if(ack->ackCode != 'A')
	{
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}

S16 lbRecvSetNetModeAck(EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack, CmdMsg_s * cmdNode)
{
	if(ack->ackCode == 'W')
	{
		cmdNode->stat = HAVE_ACK_W;
		RETVALUE(RFAILED);
	}
	else if(ack->ackCode == 'E')
	{
		equ->cmdProcErrCode |= 0x01;
	}
	else if(ack->ackCode != 'A')
	{
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}

S16 lbRecvGetRecAck(EquCfgEntry_s * equ, TranCb_s * tran, GetRecAck_s * ack, CmdMsg_s * cmdNode)
{
	RxCmdEntry_s * entry;

	if(ack->ackCode == 'W')
	{
		cmdNode->stat = HAVE_ACK_W;
		RETVALUE(RFAILED);
	}
	else if(ack->ackCode == 'E')
	{
		equ->cmdProcErrCode |= 0x01;
	}
	else if(ack->ackCode != 'A')
	{
		RETVALUE(RFAILED);
	}

	memcpy(&equ->record, &ack->rec, sizeof(Record_s));

	LBGETCMDENTRY(0, IND_DIR, entry);
	LBGETTRAN(entry, equ, tran);
	lbIndRecMsg(equ, tran);

	LBGETCMDENTRY(0, CMD_DIR, entry);
	LBGETTRAN(entry, equ, tran);
	lbBuildCfm(equ, tran, IND_REC_RQST, NULLP);





	RETVALUE(ROK);
}

S16 lbRecvGetGreyAck(EquCfgEntry_s * equ, TranCb_s * tran, GetGreyAck_s * ack, CmdMsg_s * cmdNode)
{
	CmHashListCp * hash;
	GreyRecordEnt_s * ent;
	RxCmdEntry_s * entry;
	EquCfgEntry_s * blastEqu;

	S16 seq = 0;
	
	if(ack->ackCode == 'W')
	{
		cmdNode->stat = HAVE_ACK_W;
		RETVALUE(RFAILED);
	}
	else if(ack->ackCode == 'E')
	{
		equ->cmdProcErrCode |= 0x01;
	}
	else if(ack->ackCode != 'A')
	{
		RETVALUE(RFAILED);
	}

	if(cmdNode->action == 1)
	{

		if(cmLListLen(&rxCb.pEquCfgList) < 2)
		{
			RETVALUE(ROK);
		}

		blastEqu = (EquCfgEntry_s *)cmLListFirst(&rxCb.pEquCfgList);

		LBGETCMDENTRY(0, CMD_DIR, entry);
		while(blastEqu != NULLP)
		{
			if(blastEqu == equ)
			{
				blastEqu = (EquCfgEntry_s *)cmLListNext(&rxCb.pEquCfgList);
				continue;
			}
			memcpy(&blastEqu->grey, &ack->record, 28);
			LBGETTRAN(entry, blastEqu, tran);

			lbBuildWriteGreyCmd(blastEqu, tran);
			blastEqu = (EquCfgEntry_s *)cmLListNext(&rxCb.pEquCfgList);
		}
		LBGETCMDENTRY(0, CMD_DIR, entry);
		LBGETTRAN(entry, equ, tran);
		lbBuildCfm(equ,tran , LOAD_GREY_RQST, NULLP);
	}
	else if(cmdNode->action == 2)
	{
		switch (ack->record.mark)
		{
		case 0x01:
			hash = &rxCb.GreyListProteroHl;
			break;

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

		case 0x03:
			hash = &rxCb.GreyListPoneyHl;
			break;
		}

		while(ROK == cmHashListFind(hash, ack->record.asn, 10, seq, (PTR *)&ent))
		{
			if(memcmp(ent->record.time, ack->record.time, 7) == 0)
			{
				LBGETCMDENTRY(0, CMD_DIR, entry);
				LBGETTRAN(entry, equ, tran);
				lbBuildReleaseGreyCmd(equ,tran , (Data *)&ent->record);

				RETVALUE(ROK);;
			}
			seq++;
		}
		LBGETCMDENTRY(0, CMD_DIR, entry);
		LBGETTRAN(entry, equ, tran);
		lbBuildCfm(equ,tran , REL_GREY_RQST, NULLP);

	}




	RETVALUE(ROK);
}

S16 lbRecvBlkListAck(EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack, CmdMsg_s * cmdNode)
{
	if(ack->ackCode == 'W')
	{
		cmdNode->stat = HAVE_ACK_W;
		RETVALUE(RFAILED);
	}
	else if(ack->ackCode == 'E')
	{
		equ->cmdProcErrCode |= 0x01;
	}
	else if(ack->ackCode != 'A')
	{
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}

S16 lbRecvSendGreyAck(EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack, CmdMsg_s * cmdNode)
{
	if(ack->ackCode == 'W')
	{
		cmdNode->stat = HAVE_ACK_W;
		RETVALUE(RFAILED);
	}
	else if(ack->ackCode == 'E')
	{
		equ->cmdProcErrCode |= 0x01;
	}
	else if(ack->ackCode != 'A')
	{
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}


S16 lbRecvSysCfgAck(EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack, CmdMsg_s * cmdNode)
{
	if(ack->ackCode == 'W')
	{
		cmdNode->stat = HAVE_ACK_W;
		RETVALUE(RFAILED);
	}
	else if(ack->ackCode == 'E')
	{
		equ->cmdProcErrCode |= 0x01;
	}
	else if(ack->ackCode != 'A')
	{
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}





S16 lbRecvGetHistroyAck(EquCfgEntry_s * equ, TranCb_s * tran, GetHistoryAck_s * ack, CmdMsg_s * cmdNode)
{
	HistroyEntry_s * hisEntry;
	MsgLen idx;

	if(ack->ackCode == 'W')
	{
		cmdNode->stat = HAVE_ACK_W;
	}
	else if(ack->ackCode == 'E')
	{
		equ->cmdProcErrCode |= 0x01;
		lbCmDestroyCmdNode(cmdNode);
	}
	else
	{
		if(ack->stat == 0x00) /* null record */
		{
			lbCmDestroyCmdNode(cmdNode);
		}
		else if (ack->stat == 0x01) /* please continue */
		{
			if (ROK != SGetSBuf(0, 0, (Data **)&hisEntry, sizeof(HistroyEntry_s )))
			{
				RXLOGERROR(0, 0, 0, "ERROR");
				RETVALUE(RFAILED);
			}

			memcpy(&hisEntry->record, &ack->record, sizeof(Record_s));

			cmLListAdd2Tail(&equ->histroy, (CmLList *)hisEntry);

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

			FIELD_INDEX(MsgB_s, val, idx);

			SRepMsg(0x03, cmdNode->msg, idx);

		}
		else if(ack->stat == 0x02) /* complete */
		{
			lbCmDestroyCmdNode(cmdNode);
		}
	}
	RETVALUE(ROK);
}


S16 lbRecvCmdCfmAck( EquCfgEntry_s * equ, TranCb_s * tran, CommonAck_s * ack, CmdMsg_s * cmdNode)
{
	if(ack->ackCode == 'W')
	{
		rxLog("WROKING");
		cmdNode->stat = HAVE_ACK_W;
		RETVALUE(RFAILED);
	}
	else if(ack->ackCode == 'E')
	{
		rxLog("error: cfm cmd error");
//		equ->cmdProcErrCode |= 0x01;
	}
	else if(ack->ackCode != 'A')
	{
		RETVALUE(RFAILED);
	}
	RETVALUE(ROK);
}




/******************* modify histroy list *******************
001. create at: 2002-7-1 16:31:29 by Shangyaohui

****************** modify histroy list end ****************/