static DWORD memrw(__CMD_PARA_OBJ* lpCmdObj)
{
DWORD dwAddress = 0;
WORD wr = 0;
DWORD dwTmp = 0;
CHAR strBuffer[16];
if(NULL == lpCmdObj) //Parameter check.
return SHELL_CMD_PARSER_FAILED;
if(lpCmdObj->byParameterNum < 2) //Not enough parameter.
{
PrintLine("Please input the address where to read.");
return SHELL_CMD_PARSER_SUCCESS;
}
if(!Str2Hex(lpCmdObj->Parameter[1],&dwAddress)) //Invalid address value.
{
PrintLine("Please input the correct address.");
return SHELL_CMD_PARSER_SUCCESS;
}
wr = *((WORD*)dwAddress);
dwTmp += wr;
Hex2Str(dwTmp,&strBuffer[4]); //Convert to string.
strBuffer[0] = ' ';
strBuffer[1] = ' ';
strBuffer[2] = '0';
strBuffer[3] = 'x';
PrintLine(strBuffer); //Print out the result.
return SHELL_CMD_PARSER_SUCCESS;
}
static DWORD memrd(__CMD_PARA_OBJ* lpCmdObj)
{
DWORD dwAddress = 0;
DWORD dwTmp = 0;
CHAR strBuffer[16];
if(NULL == lpCmdObj) //Parameter check.
return IOCTRL_TERMINAL;
if(lpCmdObj->byParameterNum < 2) //Not enough parameter.
{
PrintLine("Please input the address where to read.");
return IOCTRL_NORMAL;
}
if(!Str2Hex(lpCmdObj->Parameter[1],&dwAddress)) //Invalid address value.
{
PrintLine("Please input the correct address.");
return IOCTRL_NORMAL;
}
dwTmp = *((DWORD*)dwAddress);
Hex2Str(dwTmp,&strBuffer[4]); //Convert to string.
strBuffer[0] = ' ';
strBuffer[1] = ' ';
strBuffer[2] = '0';
strBuffer[3] = 'x';
PrintLine(strBuffer); //Print out the result.
return IOCTRL_NORMAL;
}
/* Using printf might cause text section overflow */
static void Print_Val(const char *str, uint32_t val)
{
char buf[9];
int ret;
buf[8] = 0;
DEBUGSTR(str);
ret = Hex2Str(buf, val);
DEBUGSTR(&buf[8 - ret]);
DEBUGSTR("\r\n");
}
//
//The following routine prints out bug's information.
//
VOID __BUG(LPSTR lpszFileName,DWORD dwLineNum)
{
BYTE strBuff[12];
PrintLine("BUG oencountered.");
PrintStr("File name: ");
PrintStr(lpszFileName);
Hex2Str(dwLineNum,strBuff);
PrintLine("Lines: ");
PrintStr(strBuff);
}
//
//The implementation of FormString routine.
//This routine formats a string,and copy it into a buffer.
//It's function likes sprintf.
//
INT FormString(LPSTR lpszBuff,LPSTR lpszFmt,LPVOID* lppParam)
{
DWORD dwIndex = 0;
LPSTR lpszTmp = NULL;
CHAR Buff[12];
if((NULL == lpszBuff) || (NULL == lpszBuff))
return -1;
lpszTmp = lpszBuff;
while(*lpszFmt)
{
if('%' == *lpszFmt) //Should process.
{
lpszFmt ++; //Skip '%'.
switch(*lpszFmt)
{
case 'd': //Convert an integer to string.
Int2Str(*((DWORD*)lppParam[dwIndex ++]),Buff); //Convert to string.
StrCpy(Buff,lpszTmp);
lpszTmp += StrLen(Buff);
lpszFmt ++;
break;
case 'c': //Convert a character to string.
*lpszTmp ++= *((BYTE*)lppParam[dwIndex ++]);
lpszFmt ++;
break;
case 's': //Append a string.
StrCpy((LPSTR)lppParam[dwIndex],lpszTmp);
lpszTmp += StrLen((LPSTR)lppParam[dwIndex ++]);
lpszFmt ++;
break;
case 'x': //Convert an integer to string in hex.
case 'X':
Hex2Str(*((DWORD*)lppParam[dwIndex ++]),Buff); //Convert to string.
StrCpy(Buff,lpszTmp);
lpszTmp += StrLen(Buff);
lpszFmt ++;
break;
default: //Unsupported now.
break;
}
}
*lpszTmp = *lpszFmt;
if(0 == *lpszTmp) //Reach end.
break;
lpszTmp ++;
lpszFmt ++;
}
*lpszTmp = 0; //End sign.
return (lpszTmp - lpszBuff);
}
VOID PrintVirtualArea(__VIRTUAL_MEMORY_MANAGER* lpMemMgr)
{
CHAR strBuff[12];
__VIRTUAL_AREA_DESCRIPTOR* lpVad = NULL;
LPVOID lpAddr = NULL;
if(NULL == lpMemMgr)
return;
lpVad = lpMemMgr->lpListHdr;
PrintLine(" Virtuam memory manager's reserved area :");
while(lpVad)
{
PrintLine("---------------------");
//PrintLine((LPSTR)&lpVad->strName[0]);
lpAddr = lpVad->lpStartAddr;
Hex2Str((DWORD)lpAddr,strBuff);
PrintLine(strBuff);
lpAddr = lpVad->lpEndAddr;
Hex2Str((DWORD)lpAddr,strBuff);
PrintLine(strBuff);
lpVad = lpVad->lpNext;
}
PrintLine(" Finished to print out.");
}
static DWORD inputd(__CMD_PARA_OBJ* lpParamObj)
{
DWORD dwVal = 0;
WORD wPort = 0;
CHAR strBuffer[15];
if(NULL == lpParamObj) //Parameter check.
return IOCTRL_TERMINAL;
if(lpParamObj->byParameterNum < 2) //Not enough parameters.
{
PrintLine("Please input the port value.");
return IOCTRL_NORMAL;
}
if(!Str2Hex(lpParamObj->Parameter[1],&dwVal)) //Incorrect port value.
{
PrintLine("Please input the port correctly.");
return IOCTRL_NORMAL;
}
wPort = (WORD)(dwVal);
#ifdef __I386__ //Read data from port.
__asm{
push eax
push edx
mov dx,wPort
in eax,dx
mov dwVal,eax
pop edx
pop eax
}
#else
#endif
strBuffer[0] = ' ';
strBuffer[1] = ' ';
strBuffer[2] = ' ';
strBuffer[3] = ' ';
Hex2Str(dwVal,&strBuffer[4]);
PrintLine(strBuffer); //Print out the byte.
return 0;
}
//
//The following are the implementations of all command handler.
//The handler's name is the same as command.
//
static DWORD inputb(__CMD_PARA_OBJ* lpCmdObj)
{
WORD wInputPort = 0;
UCHAR bt = 0;
DWORD dwInputPort = 0;
CHAR strBuffer[15] = {0};
if(NULL == lpCmdObj) //Parameter check.
{
return SHELL_CMD_PARSER_FAILED;
}
if(lpCmdObj->byParameterNum < 2) //Two small parameters.
{
PrintLine("Please input the port where to read.");
return SHELL_CMD_PARSER_SUCCESS;
}
if(!Str2Hex(lpCmdObj->Parameter[1],&dwInputPort)) //Convert the string value to hex.
{
PrintLine("Invalid port value.");
return SHELL_CMD_PARSER_SUCCESS;
}
wInputPort = (WORD)dwInputPort; //Now,wInputPort contains the port number.
//ReadByteFromPort(&bt,wInputPort); //Read one byte from port.
bt = __inb(wInputPort);
dwInputPort = 0;
dwInputPort += bt;
strBuffer[0] = ' ';
strBuffer[1] = ' ';
strBuffer[2] = ' ';
strBuffer[3] = ' ';
Hex2Str(dwInputPort,&strBuffer[4]);
PrintLine(strBuffer); //Print out the byte.
return SHELL_CMD_PARSER_SUCCESS;
}
static DWORD inputw(__CMD_PARA_OBJ* lpCmdObj)
{
WORD wInputPort = 0;
WORD wr = 0;
DWORD dwInputPort = 0;
CHAR strBuffer[15] = {0};
if(NULL == lpCmdObj) //Parameter check.
return IOCTRL_TERMINAL;
if(lpCmdObj->byParameterNum < 2) //Two small parameters.
{
PrintLine("Please input the port where to read.");
return IOCTRL_NORMAL;
}
if(!Str2Hex(lpCmdObj->Parameter[1],&dwInputPort)) //Convert the string value to hex.
{
PrintLine("Invalid port value.");
return IOCTRL_NORMAL;
}
wInputPort = (WORD)(dwInputPort); //Now,wInputPort contains the port number.
//ReadWordFromPort(&wr,wInputPort); //Read one byte from port.
wr = __inw(wInputPort);
dwInputPort = 0;
dwInputPort += wr;
strBuffer[0] = ' ';
strBuffer[1] = ' ';
strBuffer[2] = ' ';
strBuffer[3] = ' ';
Hex2Str(dwInputPort,&strBuffer[4]);
PrintLine(strBuffer); //Print out the byte.
return 0;
}
static DWORD memalloc(__CMD_PARA_OBJ* lpCmdObj)
{
DWORD dwMemSize = 0;
LPVOID lpMemAddr = NULL;
CHAR strBuffer[16];
if(NULL == lpCmdObj) //Parameter check.
return SHELL_CMD_PARSER_FAILED;
if(lpCmdObj->byParameterNum < 2) //Not enough parameters.
{
PrintLine("Please input the memory size to be allocated.");
return SHELL_CMD_PARSER_SUCCESS;
}
if(!Str2Hex(lpCmdObj->Parameter[1],&dwMemSize)) //Invalid size value.
{
PrintLine("Invalid memory size value.");
return SHELL_CMD_PARSER_SUCCESS;
}
lpMemAddr = KMemAlloc(dwMemSize,KMEM_SIZE_TYPE_ANY);
if(NULL == lpMemAddr) //Failed to allocate memory.
{
PrintLine("Can not allocate memory.");
return SHELL_CMD_PARSER_SUCCESS;
}
Hex2Str((DWORD)lpMemAddr,&strBuffer[4]); //Convert to string.
strBuffer[0] = ' ';
strBuffer[1] = ' ';
strBuffer[2] = '0';
strBuffer[3] = 'x';
PrintLine(strBuffer); //Print out the result.
return SHELL_CMD_PARSER_SUCCESS;
}
int MonMoveIpc2Txn( T_IpcIntTxnDef * tIpcIntTxn, Tbl_txn_Def * tTxn )
{
char sFuncName[] = "MonMoveIpc2Txn";
int nReturnCode;
char sCurrentTime[15];
char tIpcIntTxnEmvLen[F055_LEN_LEN + 1]; //转换后数据的大小
char tIpcIntTxnEmvVal[2*F055_VAL_LEN + 1]; //存储转换后的数据
char sTxnNum[FLD_TXN_NUM_LEN+1];
memset(sTxnNum,0x00,sizeof(sTxnNum));
memcpy(sTxnNum,tIpcIntTxn->sTxnNum,FLD_TXN_NUM_LEN);
HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "%s begin.", sFuncName);
memcpy (tTxn->trans_state , TRANS_STATE_NO_RSP, FLD_TRANS_STATE_LEN);
memset (tTxn->revsal_flag , REV_CAN_FLAG_NULL, 1);
memset (tTxn->cancel_flag , REV_CAN_FLAG_NULL, 1);
memcpy (tTxn->batch_flag , FLAG_NO, 1);
memset (tTxn->amt_return , '0', sizeof (tTxn->amt_return)-1 );
/* 设置revsal_flag, cancel_flag初始值 */
switch (tIpcIntTxn->sTxnNum[INDEX_TXN_NUM_TYPE])
{
case TXN_NUM_NORMAL:
case TXN_NUM_CANCEL:
memset (tTxn->revsal_flag, REV_CAN_FLAG_NORMAL, 1);
memset (tTxn->cancel_flag, REV_CAN_FLAG_NORMAL, 1);
break;
case TXN_NUM_REVSAL:
case TXN_NUM_CANCEL_REVSAL:
break ;
case TXN_NUM_NOTICE:
memset(tTxn->revsal_flag,REV_CAN_FLAG_NORMAL,1);
break;
}
memcpy (tTxn->trans_type, tIpcIntTxn->sTransType, FLD_TRANS_TYPE_LEN);
memcpy (sTxnNum, tIpcIntTxn->sTxnNum , FLD_TXN_NUM_LEN);
HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "sTxnNum[%s]sMsgSrcId[%4.4s][%6.6s].",
sTxnNum,tIpcIntTxn->sMsgSrcId,tIpcIntTxn->sSysTraceAuditNum);
if( sTxnNum[INDEX_TXN_NUM_TYPE] == TXN_NUM_REVSAL ||
sTxnNum[INDEX_TXN_NUM_TYPE] == TXN_NUM_CANCEL_REVSAL )
{
if( memcmp( tIpcIntTxn->sMsgSrcId,"16",SRV_ID_LEN-2)==0 ||
memcmp( tIpcIntTxn->sMsgSrcId,"17",SRV_ID_LEN-2)==0 || memcmp ( tIpcIntTxn->sMsgSrcId,"18",SRV_ID_LEN-2)==0)
memcpy (tTxn->sys_seq_num, tIpcIntTxn->sSysTraceAuditNum, F011_LEN);
else
memcpy (tTxn->sys_seq_num, tIpcIntTxn->sSysSeqNum, FLD_SYS_SEQ_NUM_LEN);
}else
memcpy (tTxn->sys_seq_num, tIpcIntTxn->sSysSeqNum, FLD_SYS_SEQ_NUM_LEN);
memcpy (tTxn->cup_ssn , tIpcIntTxn->sSysSeqNum , F011_LEN);
memcpy (tTxn->msg_src_id , tIpcIntTxn->sMsgSrcId , SRV_ID_LEN);
memcpy (tTxn->msg_dest_id , tIpcIntTxn->sMsgDestId , SRV_ID_LEN);
memcpy (tTxn->txn_num , tIpcIntTxn->sTxnNum , FLD_TXN_NUM_LEN);
memcpy (tTxn->trans_code , tIpcIntTxn->sTransCode , FLD_TXN_CODE_LEN);
//memcpy (tTxn->key_rsp , tIpcIntTxn->sKeyRsp , KEY_RSP_LEN);
//HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "key_rsp[%s].", tTxn->key_rsp);
memcpy (tTxn->key_revsal , tIpcIntTxn->sKeyRevsal , KEY_REVSAL_LEN);
memcpy (tTxn->key_cancel , tIpcIntTxn->sKeyCancel , KEY_CANCEL_LEN);
if(memcmp(tIpcIntTxn->sTxnNum, "1102", 4) == 0)
memcpy(tTxn->key_cancel+F042_LEN+F041_LEN, tIpcIntTxn->sRetrivlRefNum, F037_LEN );
memcpy (tTxn->host_date , tIpcIntTxn->sHostDate , FLD_HOST_DATE_LEN);
memcpy (tTxn->host_ssn , tIpcIntTxn->sHostSSN , FLD_HOST_SSN_LEN);
memcpy (tTxn->term_ssn , tIpcIntTxn->sTermSSN , FLD_HOST_SSN_LEN);
memcpy (tTxn->header_buf , tIpcIntTxn->sHeaderBuf , HEADER_BUF_LEN);
memcpy (tTxn->msg_type , tIpcIntTxn->sMsgType , F000_MSG_TYPE_LEN);
if (tIpcIntTxn->cF002Ind == FLAG_YES_C)
{
memcpy (tTxn->pan_len , tIpcIntTxn->sPrimaryAcctNumLen , F002_LEN_LEN);
memcpy (tTxn->pan , tIpcIntTxn->sPrimaryAcctNum , F002_VAL_LEN);
}
else
{
memset (tTxn->pan_len , ' ', F002_LEN_LEN);
memset (tTxn->pan , ' ', F002_VAL_LEN);
}
memcpy (tTxn->processing_code , tIpcIntTxn->sProcessingCode , F003_LEN);
memcpy (tTxn->amt_trans , tIpcIntTxn->sAmtTrans , F004_LEN);
memcpy (tTxn->amt_settlmt , tIpcIntTxn->sAmtSettlmt , F005_LEN);
memcpy (tTxn->amt_cdhldr_bil , tIpcIntTxn->sAmtCdhldrBil , F006_LEN);
memcpy (tTxn->trans_date_time , tIpcIntTxn->sTransmsnDateTime , F007_LEN);
memcpy (tTxn->conv_rate_stlm , tIpcIntTxn->sConvRateSettlmt , F009_LEN);
memcpy (tTxn->conv_rate_cdhldr , tIpcIntTxn->sConvRateCdhldrBil , F010_LEN);
memcpy(tTxn->order_no, tIpcIntTxn->sAddtnlData, 40);
memcpy (tTxn->time_local_trans , tIpcIntTxn->sTimeLocalTrans , F012_LEN);
memcpy (tTxn->date_local_trans , tIpcIntTxn->sDateLocalTrans , F013_LEN);
memcpy (tTxn->date_expr , tIpcIntTxn->sDateExpr , F014_LEN);
memcpy (tTxn->date_settlmt , tIpcIntTxn->sDateSettlmt , F015_LEN);
memcpy (tTxn->date_conv , tIpcIntTxn->sDateConv , F016_LEN);
memcpy (tTxn->mchnt_type , tIpcIntTxn->sMchntType , F018_LEN);
memcpy (tTxn->acq_cntry_code , tIpcIntTxn->sAcqInstCntryCode , F019_LEN);
memcpy (tTxn->pos_entry_mode , tIpcIntTxn->sPosEntryModeCode , F022_LEN);
memcpy (tTxn->pos_cond_code , tIpcIntTxn->sPosCondCode , F025_LEN);
if (tIpcIntTxn->cF026Ind == FLAG_YES_C)
memcpy (tTxn->pos_pin_cap_code , tIpcIntTxn->sPosPinCaptrCode , F026_LEN);
else
memset (tTxn->pos_pin_cap_code , ' ', F026_LEN);
if (tIpcIntTxn->cF028Ind == FLAG_YES_C)
memcpy (tTxn->amt_trans_fee , tIpcIntTxn->sAmtTransFee , F028_LEN);
else
memset (tTxn->amt_trans_fee , ' ', F028_LEN);
memcpy (tTxn->acq_inst_id_code , tIpcIntTxn->sAcqInstIdCode , F032_VAL_LEN);
memcpy (tTxn->fwd_inst_id_code , tIpcIntTxn->sFwdInstIdCode , F033_VAL_LEN);
if (tIpcIntTxn->cF035Ind == FLAG_YES_C)
{
memset (tTxn->track_2_data_len , ' ', F035_LEN_LEN);
memset (tTxn->track_2_data , ' ', F035_VAL_LEN);
}
else
{
memset (tTxn->track_2_data_len , ' ', F035_LEN_LEN);
memset (tTxn->track_2_data , ' ', F035_VAL_LEN);
}
if (tIpcIntTxn->cF036Ind == FLAG_YES_C)
{
memset (tTxn->track_3_data_len , ' ', F036_LEN_LEN);
memset (tTxn->track_3_data , ' ', F036_VAL_LEN);
}
else
{
memset (tTxn->track_3_data_len , ' ', F036_LEN_LEN);
memset (tTxn->track_3_data , ' ', F036_VAL_LEN);
}
memcpy (tTxn->retrivl_ref , tIpcIntTxn->sRetrivlRefNum , F037_LEN);
if (tIpcIntTxn->cF038Ind == FLAG_YES_C)
memcpy (tTxn->authr_id_resp , tIpcIntTxn->sAuthrIdResp , F038_LEN);
else
memset (tTxn->authr_id_resp , ' ', F038_LEN);
memcpy (tTxn->resp_code , tIpcIntTxn->sRespCode , F039_LEN);
if( sTxnNum[INDEX_TXN_NUM_TYPE] == TXN_NUM_REVSAL ||
sTxnNum[INDEX_TXN_NUM_TYPE] == TXN_NUM_CANCEL_REVSAL )
{
if( memcmp( tIpcIntTxn->sMsgSrcId,"16",SRV_ID_LEN-2)==0 ||
memcmp( tIpcIntTxn->sMsgSrcId,"17",SRV_ID_LEN-2)==0 || memcmp( tIpcIntTxn->sMsgSrcId,"18",SRV_ID_LEN-2)==0 )
{
nReturnCode=SwitchMerchantInf(1, tIpcIntTxn,tIpcIntTxn->sMsgSrcId);
if( nReturnCode != 0 )
{
HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "SwitchMerchantInf error[%d].", nReturnCode);
}
HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "key_rsp[%48.48s].", tIpcIntTxn->sKeyRsp);
HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "冲正交易计算key_rsp开始");
SwtCustSetKeyRsp (tIpcIntTxn);
}
}
memcpy (tTxn->key_rsp , tIpcIntTxn->sKeyRsp , KEY_RSP_LEN);
HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "key_rsp[%48.48s].", tTxn->key_rsp);
memcpy (tTxn->card_accp_term_id, tIpcIntTxn->sCardAccptrTermnlId , F041_LEN);
memcpy (tTxn->card_accp_id , tIpcIntTxn->sCardAccptrId , F042_LEN);
memcpy (tTxn->card_accp_name , tIpcIntTxn->sCardAccptrNameLoc , F043_LEN);
if (tIpcIntTxn->cF044Ind == FLAG_YES_C)
{
memcpy (tTxn->track_1_data_len , tIpcIntTxn->sAddtnlRespCodeLen , F044_LEN_LEN);
memcpy (tTxn->track_1_data , tIpcIntTxn->sAddtnlRespCode , F044_VAL_LEN);
}
else
{
memset (tTxn->track_1_data_len , ' ', F044_LEN_LEN);
memset (tTxn->track_1_data , ' ', F044_VAL_LEN);
}
memcpy (tTxn->addtnl_data_len , tIpcIntTxn->sAddtnlDataPrivateLen, F048_LEN_LEN);
memcpy (tTxn->addtnl_data , tIpcIntTxn->sAddtnlDataPrivate , F048_VAL_LEN);
memcpy (tTxn->currcy_code_trans, tIpcIntTxn->sCurrcyCodeTrans , F049_LEN);
memcpy (tTxn->currcy_code_stlm , tIpcIntTxn->sCurrcyCodeSettlmt , F050_LEN);
memcpy (tTxn->currcy_code_chldr, tIpcIntTxn->sCurrcyCodeCdhldrBil , F051_LEN);
if (tIpcIntTxn->cF054Ind == FLAG_YES_C)
{
memcpy (tTxn->addtnl_amt_len , tIpcIntTxn->sAddtnlAmtLen , F054_LEN_LEN);
memcpy (tTxn->addtnl_amt , tIpcIntTxn->sAddtnlAmt , 40);
}
else
{
memset (tTxn->addtnl_amt_len , ' ', F054_LEN_LEN);
memset (tTxn->addtnl_amt , ' ', 40);
}
memcpy(tTxn->ips_mercht, tIpcIntTxn->sAddtnlAmt+30, 15);
memset (tTxn->emv_len , ' ', F055_LEN_LEN);
memset (tTxn->emv_val , ' ', F055_VAL_LEN);
memcpy (tTxn->fld_reserved_len , tIpcIntTxn->sFldReservedLen , F060_LEN_LEN);
memcpy (tTxn->fld_reserved , tIpcIntTxn->sFldReserved , F060_VAL_LEN);
//HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "tTxn->fld_reserved[%s]",tTxn->fld_reserved);
//HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "tTxn->term_ssn[%s]",tTxn->term_ssn);
memcpy (tTxn->ch_auth_info_len , tIpcIntTxn->sChAuthInfoLen , F061_LEN_LEN);
memcpy (tTxn->ch_auth_info , tIpcIntTxn->sChAuthInfo , F061_VAL_LEN);
if (tIpcIntTxn->cF062Ind == FLAG_YES_C)
{
memcpy (tTxn->switch_data_len , tIpcIntTxn->sSwitchingDataLen , F062_LEN_LEN);
memcpy (tTxn->switch_data , tIpcIntTxn->sSwitchingData , F062_VAL_LEN);
}
else
{
memset (tTxn->switch_data_len , ' ', F062_LEN_LEN);
memset (tTxn->switch_data , ' ', F062_VAL_LEN);
}
memcpy (tTxn->finacl_data_len , tIpcIntTxn->sFinaclNetDataLen,F063_LEN_LEN);
memcpy (tTxn->finacl_data , tIpcIntTxn->sFinaclNetData,F063_VAL_LEN);
memcpy (tTxn->orig_data_elemts , tIpcIntTxn->sOrigDataElemts , F090_LEN);
memcpy (tTxn->replacement_amts , tIpcIntTxn->sReplacementAmts , F095_LEN);
memcpy (tTxn->rcvg_code_len , tIpcIntTxn->sRcvgInstIdCodeLen , F100_LEN_LEN);
memcpy (tTxn->rcvg_code , tIpcIntTxn->sRcvgInstIdCode , F100_VAL_LEN);
if (tIpcIntTxn->cF102Ind == FLAG_YES_C)
{
memcpy (tTxn->acct_id1_len , tIpcIntTxn->sAcctId1Len , F102_LEN_LEN);
memcpy (tTxn->acct_id1 , tIpcIntTxn->sAcctId1 , F102_VAL_LEN);
}
else
{
memset (tTxn->acct_id1_len , ' ', F102_LEN_LEN);
memset (tTxn->acct_id1 , ' ', F102_VAL_LEN);
}
if (tIpcIntTxn->cF103Ind == FLAG_YES_C)
{
memcpy (tTxn->acct_id2_len , tIpcIntTxn->sAcctId2Len , F103_LEN_LEN);
memcpy (tTxn->acct_id2 , tIpcIntTxn->sAcctId2 , F103_VAL_LEN);
}
else
{
memset (tTxn->acct_id2_len , ' ', F103_LEN_LEN);
memset (tTxn->acct_id2 , ' ', F103_VAL_LEN);
}
if (tIpcIntTxn->cF104Ind == FLAG_YES_C)
{
memcpy (tTxn->trans_descrpt_len, tIpcIntTxn->sTransDescrptLen , F104_LEN_LEN);
memcpy (tTxn->trans_descrpt , tIpcIntTxn->sTransDescrpt , F104_VAL_LEN);
}
else
{
memset (tTxn->trans_descrpt_len, ' ', F104_LEN_LEN);
memset (tTxn->trans_descrpt , ' ', F104_VAL_LEN);
}
if (tIpcIntTxn->cF121Ind == FLAG_YES_C)
{
memcpy (tTxn->cup_swresved_len , tIpcIntTxn->sNationalSwResvedLen , F121_LEN_LEN);
memcpy (tTxn->cup_swresved , tIpcIntTxn->sNationalSwResved , F121_VAL_LEN);
}
else
{
memset (tTxn->cup_swresved_len , ' ', F121_LEN_LEN);
memset (tTxn->cup_swresved , ' ', F121_VAL_LEN);
}
if (tIpcIntTxn->cF122Ind == FLAG_YES_C)
{
memcpy (tTxn->acq_swresved_len , tIpcIntTxn->sAcqInstResvdLen, F122_LEN_LEN);
memcpy (tTxn->acq_swresved , tIpcIntTxn->sAcqInstResvd, F122_VAL_LEN);
}
else
{
memset (tTxn->acq_swresved_len , ' ', F122_LEN_LEN);
memset (tTxn->acq_swresved , ' ', F122_VAL_LEN);
}
if (tIpcIntTxn->cF123Ind == FLAG_YES_C)
{
memcpy (tTxn->iss_swresved_len , tIpcIntTxn->sIssrInstResvdLen, F123_LEN_LEN);
memcpy (tTxn->iss_swresved , tIpcIntTxn->sIssrInstResvd, F123_VAL_LEN);
}
else
{
memset (tTxn->iss_swresved_len , ' ', F123_LEN_LEN);
memset (tTxn->iss_swresved , ' ', F123_VAL_LEN);
}
memcpy (tTxn->host_trans_fee1 , tIpcIntTxn->sHostTransFee1 , FLD_HOST_TRANS_FEE_LEN);
memcpy (tTxn->host_trans_fee2 , tIpcIntTxn->sHostTransFee2 , FLD_HOST_TRANS_FEE_LEN);
/*if(tIpcIntTxn->sTxnNum[INDEX_TXN_NUM_REQ_RSP] == TXN_NUM_BDT_REQ)
memcpy (tTxn->tlr_num , tIpcIntTxn->sCardSeqId , F023_LEN);
else*/
memcpy (tTxn->tlr_num , tIpcIntTxn->sTlrNum , FLD_TLR_NUM_LEN);
memcpy (tTxn->open_inst , tIpcIntTxn->sOpenInst , FLD_INST_LEN);
memcpy (tTxn->stlm_inst , tIpcIntTxn->sStlmInst , FLD_INST_LEN);
memcpy (tTxn->msq_type , tIpcIntTxn->sMsqType , 16);
memcpy (tTxn->misc_flag , tIpcIntTxn->sMiscFlag , FLD_MISC_FLAG_LEN);
memcpy (tTxn->misc_1 , tIpcIntTxn->sMisc , FLD_MISC_LEN);
memcpy (tTxn->misc_2 , tIpcIntTxn->sMisc2 , FLD_MISC_LEN);
// 因为和终端以及核心定义的MSGTYPE和PROCESS CODE都不一样 把终端的PROCESS CODE 和MSGTYPE 放在misc_1里
// SwtTxn2Ipc时从这里取MSGTYPE 和 PROCESS CODE
memcpy(tTxn->misc_1+10, tIpcIntTxn->sMsgType, F000_MSG_TYPE_LEN);
memcpy(tTxn->misc_1 + 10 + F000_MSG_TYPE_LEN, tIpcIntTxn->sProcessingCode, F003_LEN);
HtLog("t.dat",HT_LOG_MODE_ERROR,__FILE__,__LINE__,"misc_1 = [%.128s] ", tTxn->misc_1);
memset(sCurrentTime, 0, sizeof(sCurrentTime));
CommonGetCurrentTime (sCurrentTime);
memcpy (tTxn->inst_date , sCurrentTime, 14);
memcpy (tTxn->updt_date , sCurrentTime, 14);
memcpy (tTxn->authr_id_r , tIpcIntTxn->sAuthrIdResp, F038_LEN);
if (tIpcIntTxn->cF055Ind == FLAG_YES_C)
{
memcpy (tTxn->emv_len , tIpcIntTxn->sEmvValLen, F055_LEN_LEN);
HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "%s.",tTxn->emv_len);
Hex2Str(tIpcIntTxn->sEmvVal , tIpcIntTxnEmvVal, atoi(tTxn->emv_len));
memcpy (tTxn->emv_val , tIpcIntTxnEmvVal, atoi(tTxn->emv_len)*2); //存储到数据库中
memcpy (tTxn->rsp_emv_len , tIpcIntTxn->sEmvValLen, F055_LEN_LEN);
memcpy (tTxn->rsp_emv_val , tIpcIntTxn->sEmvVal, F055_VAL_LEN);
}
else
{
memset (tTxn->emv_len , ' ', F055_LEN_LEN);
memset (tTxn->emv_val , ' ', F055_VAL_LEN);
memset (tTxn->rsp_emv_len , ' ', F055_LEN_LEN);
memset (tTxn->rsp_emv_val , ' ', F055_VAL_LEN);
}
HtLog (gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "%s end.", sFuncName);
return 0;
}
int stream_component_open(VideoState* is, int stream_index) {
AVFormatContext* pFormatCtx = is->pFormatCtx;
AVCodecContext* codecCtx;
AVCodec* codec;
SDL_AudioSpec wanted_spec, spec;
if (stream_index < 0 || stream_index >= pFormatCtx->nb_streams) {
return -1;
}
codec = avcodec_find_decoder(
pFormatCtx->streams[stream_index]->codec->codec_id);
if (!codec) {
fprintf(stderr, "Unsupported codec!\n");
return -1;
}
codecCtx = avcodec_alloc_context3(codec);
if (avcodec_copy_context(codecCtx, pFormatCtx->streams[stream_index]->codec)
!= 0) {
fprintf(stderr, "Couldn't copying codec context");
return -1;
}
if (codecCtx->codec_type == AVMEDIA_TYPE_AUDIO) {
wanted_spec.freq = codecCtx->sample_rate;
wanted_spec.format = AUDIO_S16SYS;
wanted_spec.channels = codecCtx->channels;
wanted_spec.silence = 0;
wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
wanted_spec.callback = audio_callback;
wanted_spec.userdata = is;
if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {
fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
return -1;
}
is->au_convert_ctx = swr_alloc();
uint64_t out_channel_layout = AV_CH_LAYOUT_STEREO;
AVSampleFormat out_sample_fmt = AV_SAMPLE_FMT_S16;
int out_sample_rate = 44100;
int64_t in_channel_layout = av_get_default_channel_layout(
codecCtx->channels);
is->au_convert_ctx = swr_alloc_set_opts(is->au_convert_ctx,
out_channel_layout, out_sample_fmt, out_sample_rate,
in_channel_layout, codecCtx->sample_fmt, codecCtx->sample_rate,
0,
NULL);
swr_init(is->au_convert_ctx);
}
if (avcodec_open2(codecCtx, codec, NULL) < 0) {
fprintf(stderr, "Unsupported codec!\n");
return -1;
}
switch (codecCtx->codec_type) {
case AVMEDIA_TYPE_AUDIO:
is->audioStream = stream_index;
is->audio_st = pFormatCtx->streams[stream_index];
is->audio_ctx = codecCtx;
is->audio_buf_size = 0;
is->audio_buf_index = 0;
memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));
packet_queue_init(&is->audioq);
SDL_PauseAudio(0);
break;
case AVMEDIA_TYPE_VIDEO:
is->videoStream = stream_index;
is->video_st = pFormatCtx->streams[stream_index];
is->video_ctx = codecCtx;
Hex2Str(codecCtx->extradata, codecCtx->extradata_size);
printf("AVCodecID:%d\n", codec->id);
is->frame_timer = (double) av_gettime() / 1000000.0;
is->frame_last_delay = 40e-3;
is->video_current_pts_time = av_gettime();
packet_queue_init(&is->videoq);
is->video_tid = SDL_CreateThread(video_thread, "video_thread", is);
is->sws_ctx = sws_getContext(is->video_ctx->width,
is->video_ctx->height, is->video_ctx->pix_fmt,
is->video_ctx->width, is->video_ctx->height, AV_PIX_FMT_YUV420P,
SWS_BILINEAR, NULL, NULL, NULL);
break;
default:
break;
}
}
int ConvFSKOutToIn(char* vvpInBuf,
char* vvpOutBuf,
int* vnpOutBufL)
{
TXN_MSG_DTL stMsgDtl;
TERM_TXN_MESS stTermTxnMess;
TERM_MANAGE_MESS stMngMess;
unsigned char sLen[2];
unsigned char sTmp[32];
unsigned char* lspInBuf;
unsigned char* lspTmpBuf;
unsigned char* lspOutBuf;
unsigned char sMsgType[2];
unsigned char sOutBuf[1024];
unsigned char cChkVal;
char sTermTxn[4];
char sTxnNum[5];
int iMsgLen, iLen;
int iRet, iTmp;
int iOffSet;
HtLog(gsLogFile, HT_LOG_MODE_NORMAL, __FILE__, __LINE__, "%s begin", __func__ );
iOffSet = SRV_ID_LEN*2+FLD_MSQ_TYPE_LEN;
lspInBuf = (unsigned char*)vvpInBuf + iOffSet;
memcpy(vvpOutBuf, vvpInBuf, iOffSet );
/**取终端交易码**/
/* HtDebugString (gsLogFile, HT_LOG_MODE_DEBUG, __FILE__, __LINE__, (char *)lspInBuf, 256 );*/
memset(sTermTxn, 0, sizeof(sTermTxn));
memcpy(sTermTxn, lspInBuf+(EPOS_HEADER_LEN-4), 4 );
/* sTermTxn[4] = '\0'; */
HtLog(gsLogFile, HT_LOG_MODE_NORMAL, __FILE__, __LINE__, "终端交易码[%s]", sTermTxn );
/**连接请求**/
if(memcmp(sTermTxn, TXN_CONNECT, 4) == 0 )
{
HtLog(gsLogFile, HT_LOG_MODE_NORMAL, __FILE__, __LINE__, "终端请求连接......");
#if 0
/**取得内部交易码**/
iRet = DbsConnect();
if(iRet )
{
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__,
"连接数据库错 DbsConnect error [%d]", iRet );
return (130 * 10 + NIllDataExp);
}
memset(sTxnNum, 0, sizeof(sTxnNum));
iRet = GetInTxnNum(sTermTxn, sTxnNum );
if ( iRet )
{
DbsDisconnect ();
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__,
"取交易码错 GetInTxnNum error [%d]", iRet );
return (130 * 10 + NIllDataExp);
}
iRet = DbsDisconnect ();
if (iRet)
{
HtLog(gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "Disconnect error[%d]", iRet);
return iRet;
}
#endif
memcpy(vvpOutBuf+iOffSet, lspInBuf, (EPOS_HEADER_LEN-4) );
memcpy(vvpOutBuf+(iOffSet+EPOS_HEADER_LEN-4), sTxnNum, 4 );
*vnpOutBufL = iOffSet + (EPOS_HEADER_LEN );
return 0;
}
/**取报文中的消息类型**/
memset(sMsgType, 0x00, sizeof(sMsgType));
memcpy(sMsgType, lspInBuf+EPOS_HEADER_LEN, 1 );
/* 终端发起交易报文 <<电话posII规范>>12.2.3 */
if(sMsgType[0] == 0x87 )
{
/**87报文必须有MAC**/
/**交易报文**/
memset((unsigned char*)&stTermTxnMess, ' ', sizeof(stTermTxnMess));
memset((unsigned char*)&stMsgDtl, ' ', sizeof(stMsgDtl));
iMsgLen = 0;
/**消息类型**/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, lspInBuf+EPOS_HEADER_LEN, 1 );
Hex2Str(sTmp, stTermTxnMess.msg_type, 1 );
iMsgLen = iMsgLen + 2;
/**长度**/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, lspInBuf+EPOS_HEADER_LEN+1, 2 );
iMsgLen = sTmp[0]*256 + sTmp[1];
sprintf((char *)stTermTxnMess.sLen, "%04X", iMsgLen );
iMsgLen = iMsgLen + 4 ;
/**随机数**/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, lspInBuf+EPOS_HEADER_LEN+1+2, 4 );
Hex2Str(sTmp, stTermTxnMess.syn_ran, 4 );
iMsgLen = iMsgLen + 8;
/*交易同步序号*/
iTmp = 0;
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, lspInBuf+EPOS_HEADER_LEN+1+2+4, 1 );
iTmp = sTmp[0];
memset(sTmp, 0, sizeof(sTmp));
sprintf((char *)sTmp, "%02d", iTmp );
memcpy(stTermTxnMess.syn_no, sTmp, 2 );
iMsgLen = iMsgLen + 2;
/*消息内容长度*/
iLen = 0;
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, lspInBuf+EPOS_HEADER_LEN+1+2+4+1, 2 );
iLen = sTmp[0]*256 + sTmp[1];
sprintf((char *)stTermTxnMess.sMsgLen, "%04X", iLen );
iMsgLen = iMsgLen + 4;
/**BEGIN消息内容***/
memset(sOutBuf, 0, sizeof(sOutBuf));
memcpy(sOutBuf, lspInBuf+EPOS_HEADER_LEN+1+2+4+1+2, iLen );
/* HtDebugString (gsLogFile, HT_LOG_MODE_DEBUG, __FILE__, __LINE__, (char *)sOutBuf , iLen );*/
/**保存转换前的消息内容,用于MAC计算**/
snprintf((char *)stTermTxnMess.sMacData, 5, "%04X", (iLen-8) );
HtLog(gsLogFile, HT_LOG_MODE_DEBUG, __FILE__, __LINE__, "%5.5s", stTermTxnMess.sMacData );
memcpy(stTermTxnMess.sMacData+4, sOutBuf, (iLen-8) );
/**转换消息内容**/
iRet = MessOutToIn(sOutBuf, &stMsgDtl );
if(iRet )
{
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "MessOutToIn error [%d]", iRet );
return (130 * 10 + NIllDataExp);
}
iMsgLen = iMsgLen + sizeof(stMsgDtl ) ;
/**END消息内容***/
/**校验位**/
memcpy(&stTermTxnMess.stMsgDtl, &stMsgDtl, sizeof(stMsgDtl));
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, lspInBuf+(EPOS_HEADER_LEN+1+2+4+1+2+iLen), 1 );
Hex2Str(sTmp, stTermTxnMess.chk_data, 1 );
iMsgLen = iMsgLen + 2;
cChkVal = GenChkVal(lspInBuf+EPOS_HEADER_LEN, 1+2+4+1+2+iLen );
if(cChkVal != sTmp[0] )
{
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__,
"校验位错误 GenChkVal error cChkVal[%c][%c]TermTxnMess.chk_data" );
return (130 * 10 + NIllDataExp);
}
#if 0
/**取内部交易码**/
iRet = DbsConnect();
if(iRet )
{
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__,
"连接数据库错 DbsConnect error [%d]", iRet );
return (130 * 10 + NIllDataExp);
}
memset(sTxnNum, 0, sizeof(sTxnNum));
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTxnNum, stMsgDtl.sTxnCode, 3 );
sprintf((char *)sTmp, "%s", sTxnNum );
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "终端交易码[%s]", sTmp );
memset(sTxnNum, 0, sizeof(sTxnNum));
iRet = GetInTxnNum(sTmp, sTxnNum ); /* FROM TBL_TERM_TXN */
if(iRet)
{
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__,
"取交易码[%s]错 GetInTxnNum error [%d]", sTmp, iRet );
return (130 * 10 + NIllDataExp);
}
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "内部交易码[%s]", sTxnNum );
iRet = DbsDisconnect ();
if (iRet)
{
HtLog(gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "Disconnect error[%d]", iRet);
return iRet;
}
#endif
memcpy(vvpOutBuf+iOffSet, lspInBuf, (EPOS_HEADER_LEN-4) );
memcpy(vvpOutBuf + (iOffSet+EPOS_HEADER_LEN-4), sTxnNum, 4 );
memcpy(vvpOutBuf + (iOffSet+EPOS_HEADER_LEN), (unsigned char*)&stTermTxnMess, sizeof(stTermTxnMess) );
*vnpOutBufL = iOffSet + (EPOS_HEADER_LEN ) + sizeof(stTermTxnMess);
return 0;
}
/***其他报文类型 如0x82 ***/
memset(&stMngMess, 0, sizeof(stMngMess));
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, lspInBuf+EPOS_HEADER_LEN, 1 );
Hex2Str(sTmp, stMngMess.msg_type, 1 );
HtLog(gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "msg_type[%s]", stMngMess.msg_type );
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, lspInBuf+EPOS_HEADER_LEN+1, 2 );
iMsgLen = sTmp[0]*256 + sTmp[1];
sprintf((char *)stMngMess.sLen , "%02X", iMsgLen );
/**随机数**/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, lspInBuf+EPOS_HEADER_LEN+3, 4 );
Hex2Str(sTmp, stMngMess.syn_ran, 4 );
/**同步序号**/
iTmp = 0;
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, lspInBuf+EPOS_HEADER_LEN+7, 1 );
iTmp = sTmp[0];
memset(sTmp, 0, sizeof(sTmp));
sprintf((char *)sTmp, "%02d", iTmp );
memcpy(stMngMess.syn_no, sTmp, 2 );
/**校验位**/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, lspInBuf+EPOS_HEADER_LEN+8, 1 );
Hex2Str(sTmp, stMngMess.chk_data, 1 );
memset(sTxnNum, 0, sizeof(sTxnNum));
if(!memcmp(stMngMess.msg_type, "83", 2 ) )
strcpy(sTxnNum, "6032" ); /* 接收完成报文 */
else if (!memcmp(stMngMess.msg_type, "82", 2 ) )
strcpy(sTxnNum, "6042" ); /* 连接完成报文 */
else
{
HtLog(gsLogFile, HT_LOG_MODE_DEBUG, __FILE__, __LINE__,
"取交易码错 msg_type error [%s]", stMngMess.msg_type );
return (130 * 10 + NIllDataExp);
}
HtLog(gsLogFile, HT_LOG_MODE_NORMAL, __FILE__,__LINE__, "sTxnNum[%s]", sTxnNum );
memcpy(vvpOutBuf+iOffSet, lspInBuf, (EPOS_HEADER_LEN-4) );
memcpy(vvpOutBuf+iOffSet+(EPOS_HEADER_LEN-4), sTxnNum, 4 );
memcpy(vvpOutBuf+iOffSet+(EPOS_HEADER_LEN), (unsigned char*)&stMngMess, sizeof(stMngMess));
*vnpOutBufL = iOffSet + (EPOS_HEADER_LEN )+ sizeof(stMngMess);
/* HtDebugString (gsLogFile, HT_LOG_MODE_DEBUG, __FILE__, __LINE__, vvpOutBuf, *vnpOutBufL );*/
HtLog(gsLogFile, HT_LOG_MODE_NORMAL, __FILE__, __LINE__, "%s end", __func__ );
return 0;
}
/*********************
***转换外部消息内容***
*********************/
int MessOutToIn(unsigned char *sMess, TXN_MSG_DTL *pstMsgDtl )
{
unsigned char sTmp[16];
unsigned char sTmp2[16];
unsigned char cFlwCd[6];
unsigned char sBuf[256];
int i, j, iTmp;
int iLen , iCnt;
int iMacFlg;
/*MAC标志*/
iMacFlg = 0;
/*报文类型*/
i = 0;
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, sMess, 1 );
Hex2Str(sTmp, pstMsgDtl->sMsqType, 1 );
i += 1;
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "报文类型[%2.2s]", pstMsgDtl->sMsqType );
/*结束标志*/
memcpy(sTmp, sMess+i, 1 );
sprintf((char *)pstMsgDtl->sEndFlg, "%02d", sTmp[0] );
i += 1;
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "结束标志[%2.2s]", pstMsgDtl->sEndFlg );
/**程序版本号*/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, sMess+i, 2 );
bcd_to_asc(pstMsgDtl->sProVer, sTmp, 4, 1 );
i += 2;
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "程序版本号[%4.4s]", pstMsgDtl->sProVer );
/**应用版本号**/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, sMess+i, 4 );
bcd_to_asc(pstMsgDtl->sAppVer, sTmp, 8, 1 );
i += 4;
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "应用版本号[%8.8s]", pstMsgDtl->sAppVer );
/**来电显示标志**/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, sMess+i, 1 );
sprintf((char *)pstMsgDtl->sShowFlg, "%02s", sTmp );
i += 1;
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "来电显示标志[%2.2s]", pstMsgDtl->sShowFlg );
/**序列号**/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, sMess+i, 8 );
bcd_to_asc(pstMsgDtl->sTsamNo, sTmp, 16, 1 );
i += 8;
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "序列号[%16.16s]", pstMsgDtl->sTsamNo );
/**交易流水号**/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, sMess+i, 3 );
bcd_to_asc(pstMsgDtl->sTxnSeq, sTmp, 6, 1 );
i += 3;
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "交易流水号[%6.6s]", pstMsgDtl->sTxnSeq );
/**交易代码**/
memcpy(pstMsgDtl->sTxnCode, sMess+i, 3 );
i += 3;
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "交易代码[%3.3s]", pstMsgDtl->sTxnCode );
/*流程代码总数*/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, sMess+i, 1 );
iCnt = sTmp[0];
sprintf((char *)pstMsgDtl->sFlowNum , "%02X", iCnt );
i += 1;
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "流程代码总数[%2.2s]", pstMsgDtl->sFlowNum );
/*流程代码集*/
iLen = 0;
memset(sBuf, 0, sizeof(sBuf));
for(j=0; j < iCnt; j ++ )
{
iTmp = 0;
memset(sTmp, 0, sizeof(sTmp));
memset(sTmp2, 0, sizeof(sTmp2));
memset(cFlwCd, 0, sizeof(cFlwCd));
memcpy(sTmp, sMess+i, 1 );
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "流程代码第1个字节[%X]", sTmp[0] );
sTmp[0] = sTmp[0] >> 6;
if(sTmp[0] == 0x03 )
{
/*3字节操作码*/
memcpy(sTmp2, sMess+i, 3 );
Hex2Str(sTmp2, cFlwCd, 3 );
memcpy(sBuf+iLen, cFlwCd, 6 );
i = i + 3;
iLen = iLen + 6;
/*判断是否有MAC*/
if(memcmp(cFlwCd, "CD", 2 ) == 0 )
iMacFlg = 1;
}
else if(sTmp[0] == 0x00 )
{
/*双字节操作码*/
memcpy(sTmp2, sMess+i, 2 );
Hex2Str(sTmp2, cFlwCd, 2 );
memcpy(sBuf+iLen, cFlwCd, 4 );
i = i + 2;
iLen = iLen + 4;
/*判断是否有MAC*/
if(memcmp(cFlwCd, "0D", 2 ) == 0 )
iMacFlg = 1;
}
else
{
/*单字节码*/
memcpy(sTmp2, sMess+i, 1 );
Hex2Str(sTmp2, cFlwCd, 1 );
memcpy(sBuf+iLen, cFlwCd, 2 );
i = i + 1;
iLen = iLen + 2;
/*判断是否有MAC*/
if(memcmp(cFlwCd, "8D", 2 ) == 0 )
iMacFlg = 1;
}
}
if(iLen > 128 )
{
HtLog(gsLogFile, HT_LOG_MODE_DEBUG, __FILE__, __LINE__, "流程代码超长" );
return -1;
}
memcpy(pstMsgDtl->sFlowCode, sBuf, iLen );
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "流程代码[%128.128s]", pstMsgDtl->sFlowCode );
/**有效数据长度**/
memset(sTmp, 0, sizeof(sTmp));
memcpy(sTmp, sMess+i, 2 );
i += 2;
iLen = sTmp[0]*256 + sTmp[1];
/*sprintf((char *)pstMsgDtl->sDataLen[0], "%04X", iLen ); */
sprintf((char *)&pstMsgDtl->sDataLen[0], "%04X", iLen );
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "有效数据长度[%d] 报文当前位置[%d]", iLen, i );
/**有效数据,不包括MAC**/
if((iLen < 8 )&&(iMacFlg == 1))
{
HtLog(gsLogFile, HT_LOG_MODE_ERROR, __FILE__, __LINE__, "报文不正确" );
return -1;
}
/* HtDebugString (gsLogFile, HT_LOG_MODE_DEBUG, __FILE__, __LINE__, (char *)(sMess+i) , iLen);*/
if(iMacFlg == 1 )
{
memcpy(pstMsgDtl->sDataDtl, sMess+i, (iLen - 8));
i += (iLen - 8 );
/**取MAC**/
memcpy(pstMsgDtl->sMac, sMess+i, 8 );
}
else
{
memcpy(pstMsgDtl->sDataDtl, sMess+i, iLen );
i += iLen ;
/**没有MAC**/
memcpy(pstMsgDtl->sMac, "00000000", 8 );
}
HtLog(gsLogFile, HT_LOG_MODE_DEBUG, __FILE__, __LINE__, "有效数据:" );
/* HtDebugString (gsLogFile, HT_LOG_MODE_DEBUG, __FILE__, __LINE__, (char *)pstMsgDtl->sDataDtl, iLen );*/
return 0;
}
