/** \brief
* 接收数据
* \param pDesc PSIMPLEX_DESC结构体
* \param RecBuff 接收缓存
* \param nRecLen 接收长度
* \return true：成功，false：失败
*/
bool SimplexSock::RecvData(PSIMPLEX_DESC pDesc,unsigned char* RecBuff,int& nRecLen)
{
try{
int bytes_left;
int bytes_read;
unsigned char* ptr=RecBuff;
bytes_left=nRecLen;
while(bytes_left>0)
{
bytes_read=read(pDesc->socket_Recdesc,ptr,bytes_left);
trace_log(DBG,"cIp[%s],nPort[%d] socket[%d] start read bytes_read[%d] ",pDesc->cIp,pDesc->nPort,pDesc->socket_Recdesc,bytes_read);
if(bytes_read<0)
{
if(errno==EINTR)
{
bytes_read=0;
}else if(errno==EAGAIN){
bytes_read=0;
break;
}else{/**< 通讯异常 */
pDesc->nMask=0;
nRecLen=0;
trace_log(ERR,"cIp[%s],nPort[%d] socket read err",pDesc->cIp,pDesc->nPort);
return false;
}
}else if(bytes_read==0){
if(bytes_left==nRecLen)/**< 服务器断开 */
{
pDesc->nMask=0;
nRecLen=0;
trace_log(ERR,"cIp[%s],nPort[%d] socket read err",pDesc->cIp,pDesc->nPort);
return false;
}
break;
}
bytes_left-=bytes_read;
trace_log(DBG,"RecvData:");
trace_mem(ptr,bytes_read);
ptr+=bytes_read;
}
nRecLen-=bytes_left;
pDesc->tRecIdle=time(0);
return true;
}catch(...){
trace_log(ERR,"Error in ClientYinLian::RecvData()");
return false;
}
}
/** \brief
* 计算mab
* \param in: pData TRADEDATA结构指针
* \param in: obj8583 8583包
* \param out: bMac 8字节
* \return 失败返回非0，成功返回0
*/
int CTradeBase::GenMacData( TRADEDATA * pData,BYTE* bMabTmp,int bMabLen,BYTE* bMac)
{
int nLenMab=0,nLen=0;
int inum = 0;
BYTE bMak[17]={0},bTmp[8]={0},bOut[8]={0},bMakTemp[8+1] = {0};
BYTE bMab[1024],temp1[32] = {0},temp2[32] = {0};
//nLenMab=BuildMab(obj8583,bMab);
nLenMab = bMabLen;
memcpy(bMab,bMabTmp,bMabLen);
trace_log(DBG, "bMab,pData->RcvBrchCode:%s,pData->SndBrchCode:%s",pData->RcvBrchCode,pData->SndBrchCode);
trace_mem(bMabTmp, bMabLen);
if(bSoftEncrypt)
{
/**< 软计算 */
nLen=8*((nLenMab+7)/8);
for(int i=nLenMab;i<nLen;i++)
bMab[i]=0x00;
inum = nLen/8;
Ccommon::Asc2Bcd((char *)pData->bMacKey,bMak, 32);
memcpy(bMakTemp,bMak,8);
memcpy(bTmp,bMab,8);
for(int j = 1;j<inum;j++)
{
memset(bOut,0,8);
memcpy(bOut,bMab+j*8,8);
Ccommon::ExclusiveOR(bTmp,bOut,bTmp,8);
}
BcdToAsc(temp1, bTmp, 16);
memcpy(temp2,temp1,8);
memset(bTmp,0x00,sizeof(bTmp));
des.DesEncrypt(ENCRYPT, temp2, bMakTemp, bTmp);
Ccommon::ExclusiveOR(bTmp,bTmp,temp1+8,8);
memset(temp1,0x00,sizeof(temp1));
des.DesEncrypt(ENCRYPT, bTmp, bMakTemp, temp1);
BcdToAsc(temp2, temp1, 16);
memcpy(bMac,temp2,8);
}else{
/**< 硬计算 */
if(!cryptComm.CalculateMac(pData->RcvBrchCode,
pData->SndBrchCode,bMab, nLenMab,bMac))
{
trace_log(ERR, "Get mac failed!");
return RET_PACK;
}
}
return 0;
}
//交易流程控制
int DoTradeCtrl(void * pNode)
{
int iRet = RET_SYSEXP;
if ( pNode == NULL)
{
trace_log(ERR, "paramter error!");
return iRet;
}
TRADEDATA * pData = (TRADEDATA *)pNode;
POS_TRADE_TYPE TradeType = (POS_TRADE_TYPE)pData->TransData.HeadData.RTradeType;
trace_log(SYS, "TradeType[%c]!", (char)TradeType);
TransProcess transProcess;
return transProcess.Process(TradeType, pData);
}
bool StartServices()
{
if (NULL == g_ThreadPoolMgr)
g_ThreadPoolMgr = new ThreadPoolManager();
g_ThreadPoolMgr->Init(g_Cfg.threadPool_CNF.TastSize,g_Cfg.threadPool_CNF.ThreadMax,g_Cfg.threadPool_CNF.ThreadPre);
if(0==x_svrinit((LPFN_XSVRCALLBACK)&T_CUP_SX_POSP))
{
trace_log(DBG, "x_svrinit[t_cup_sx_posp] success!");
}else trace_log(ERR, "x_svrinit[t_cup_sx_posp] failed!");
if(NULL ==mqClient) mqClient=new MqClient();
return true;
}
//截获KILL/PKILL信号
void catcher(int signo)
{
//停止服务
StopServices();
trace_log(SYS, "Service Stopped.");
exit(0);
}
/**< 跟第三方系统进行通信 */
int CTradeBase::DoSendAndRcv(unsigned char *ReqBuf, int ReqLen,unsigned char *RepBuf, int *RepLen, int TimeOut,char* errDesc)
{
trace_log(DBG, "SndBuf len:%d",ReqLen);
trace_mem(ReqBuf, ReqLen);
SocketClient client;
return client.SendToHost(ReqBuf,ReqLen,RepBuf,*RepLen,g_Cfg.CupHost.cIp,g_Cfg.CupHost.iPort,40,errDesc);
}
/** \brief
* \param in: bIsSettle 是否清算
* 设置时间和日期 （sndObj[12]域和[13]域）
*/
void CTradeBase::SetDateTime(bool bIsSettle)
{
BYTE bTmpData[FIELD_MAXLEN]={0};
char cCurTime[15] = {0};
struct tm stCurTime;
time_t ltime;
time( <ime );
localtime_xgd(<ime, &stCurTime);
sprintf(cCurTime, "%4d%02d%02d%02d%02d%02d", stCurTime.tm_year + 1900, stCurTime.tm_mon + 1,
stCurTime.tm_mday, stCurTime.tm_hour, stCurTime.tm_min, stCurTime.tm_sec);
//12 交易时间
trace_log(DBG, "cCurTime = %s, stCurTime.tm_sec=%d", cCurTime, stCurTime.tm_sec);
memset(bTmpData, 0, sizeof(bTmpData));
memcpy(bTmpData, cCurTime + 8, 6);
sndObj.SetValueByStr(12, (char *)bTmpData);
//13 交易日期
memset(bTmpData, 0, sizeof(bTmpData));
memcpy(bTmpData, cCurTime + 4, 4);
sndObj.SetValueByStr(13, (char *)bTmpData);
//14 清算日期
if(bIsSettle)
{
sndObj.SetValueByStr(15, (char *)bTmpData);
}
}
void trace_power_flow(unsigned long mpidr, unsigned char mode)
{
switch (mode) {
case CPU_UP:
trace_log("core %ld:%ld ON\n",
(mpidr & MPIDR_CLUSTER_MASK) >> MPIDR_AFFINITY_BITS,
(mpidr & MPIDR_CPU_MASK));
break;
case CPU_DOWN:
trace_log("core %ld:%ld OFF\n",
(mpidr & MPIDR_CLUSTER_MASK) >> MPIDR_AFFINITY_BITS,
(mpidr & MPIDR_CPU_MASK));
break;
case CPU_SUSPEND:
trace_log("core %ld:%ld SUSPEND\n",
(mpidr & MPIDR_CLUSTER_MASK) >> MPIDR_AFFINITY_BITS,
(mpidr & MPIDR_CPU_MASK));
break;
case CLUSTER_UP:
trace_log("cluster %ld ON\n",
(mpidr & MPIDR_CLUSTER_MASK) >> MPIDR_AFFINITY_BITS);
break;
case CLUSTER_DOWN:
trace_log("cluster %ld OFF\n",
(mpidr & MPIDR_CLUSTER_MASK) >> MPIDR_AFFINITY_BITS);
break;
case CLUSTER_SUSPEND:
trace_log("cluster %ld SUSPEND\n",
(mpidr & MPIDR_CLUSTER_MASK) >> MPIDR_AFFINITY_BITS);
break;
default:
trace_log("unknown power mode\n");
break;
}
}
bool LsnBase::sendSmsbyweina(char *smsdesc)
{
if(NULL == smsdesc)
{
return false;
}
CURL *curl;
CURLcode res;
curl = curl_easy_init();
if(curl)
{
curl_easy_setopt(curl, CURLOPT_URL, smsdesc);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
res = curl_easy_perform(curl);
}
if(res != CURLE_OK)
{
trace_log(SYS, "curl_easy_perform() failed: %s.",curl_easy_strerror(res));
}
curl_easy_cleanup(curl);
return true;
}
/**< 处理响应数据 */
void TranBase::RespData()
{
try{
if( pTrasferData->TlvDataLen )
{
/**< 解TLV */
CTLVTemplet tlvObj;
int nTlvICLen=0,nDateTimeLen=0;
unsigned char uICData[256]={0};
char cDateTime[10]={0};
if(1 == tlvObj.UnPackTLVData(pTrasferData->TlvDataLen, pTrasferData->TlvData))
{
nTlvICLen= tlvObj.GetTLVItemByHex(TAG_FIELD55_RSP, uICData, sizeof(uICData));
if(nTlvICLen)
{
pMsg8583recv->SetValueByHex(55,uICData,nTlvICLen);
}
nDateTimeLen=tlvObj.GetTLVItemByHex(TAG_DATETIME,(unsigned char*) myData.cTranDateTime, sizeof(myData.cTranDateTime));
if(10== strlen(myData.cTranDateTime) )
{
memset(cDateTime,0,sizeof(cDateTime));
memcpy(cDateTime,myData.cTranDateTime+4,6);
pMsg8583recv->SetValueByStr(12,cDateTime);
memset(cDateTime,0,sizeof(cDateTime));
memcpy(cDateTime,myData.cTranDateTime,4);
pMsg8583recv->SetValueByStr(13,cDateTime);
}
}
}
}catch(...){
trace_log(SYS, "Error in TranBase::RespData");
return ;
}
}
void test1()
{
trace_log(DBG,"------------------test1-----------------");
TestThread test;
test.Start();
//sleep(2);
}
/************************************************************************
函数功能:SetWorkKey(重置密钥)
参数说明: cRcvCode[in] 受理机构号
cSndCode[in] 接入机构号
ucWorkKey[in] 银联下发的工作密钥
iWKLen[in] 密钥总长度
iKeyType[in] 密钥类型
返回值: true 成功，false 失败
************************************************************************/
bool EnCryptComm::SetWorkKey(char * cRcvCode, char * cSndCode, unsigned char * ucWorkKey, int iWKLen, int iKeyCnt)
{
unsigned char Buffer[1024]={0};
unsigned vLen = 0;
/**< CMD */
Buffer[vLen++] = 0x60; /**< 快钱更新工作密钥 */
Buffer[vLen++] =1; //机构接入
/**< 受理机构号 */
memset(&Buffer[vLen], ' ', 20);
memcpy((char*)&Buffer[vLen], cRcvCode, strlen(cRcvCode));
vLen += 20;
/**< 接入机构号 */
memset(&Buffer[vLen], ' ', 16);
memcpy((char*)&Buffer[vLen], cSndCode, strlen(cSndCode));
vLen += 16;
/**< 工作密钥 */
Buffer[vLen++]=iWKLen; //密钥总长度
Buffer[vLen++]=16;
memcpy(Buffer+vLen,ucWorkKey,16);
vLen+=16;
Buffer[vLen++]=4;
memcpy(Buffer+vLen,ucWorkKey+16,4);
vLen+=4;
Buffer[vLen++]=8;
memcpy(Buffer+vLen,ucWorkKey+20,8);
vLen+=8;
Buffer[vLen++]=4;
memcpy(Buffer+vLen,ucWorkKey+28,4);
vLen+=4;
trace_log(DBG,"Buffer_workkey len:%d",vLen);
trace_mem(Buffer,vLen);
if(!GetDataFromHsm(Buffer, vLen))
{
trace_log(ERR, "SetWorkKey call GetDataFromHsm return false.");
return false;
}
return true;
}
/************************************************************************
函数功能:SetWorkKey(设置快钱工作密钥)
参数说明: cRcvCode[in] 受理机构号
cSndCode[in] 接入机构号
ucWorkKey[in] 银联下发的工作密钥
iWKLen[in] 密钥总长度
iKeyCnt[in] 下发密钥个数
返回值: true 成功，false 失败
************************************************************************/
bool EnCryptComm::SetWorkKey(char * cMercId, char * cTermId, unsigned char * ucWorkKey, int iWKLen, int iKeyCnt)
{
unsigned char Buffer[1024]={0};
unsigned vLen = 0;
/**< CMD */
Buffer[vLen++] = 0x60; /**< 盛付通更新工作密钥 */
Buffer[vLen++] =0;
//此处有可能会换成商户号和终端号
/**< 受理机构号 */
memset(&Buffer[vLen], ' ', 20);
memcpy((char*)&Buffer[vLen], cMercId, strlen(cMercId));
vLen += 20;
/**< 接入机构号 */
memset(&Buffer[vLen], ' ', 16);
memcpy((char*)&Buffer[vLen], cTermId, strlen(cTermId));
vLen += 16;
/**< 工作密钥 */
Buffer[vLen++]=iWKLen;
int nKey=0,nCheck=0;
nKey=16;
nCheck=4;
for(int i=0;i<iKeyCnt ;i++)
{
Buffer[vLen++] = nKey;
memcpy(Buffer + vLen, ucWorkKey+(nKey+nCheck)*i, nKey);
vLen += nKey;
Buffer[vLen++] = nCheck;
memcpy(Buffer + vLen, ucWorkKey+nKey+(nKey+nCheck)*i, nCheck);
vLen+=nCheck;
}
trace_log(DBG,"Buffer_workkey len:%d",vLen);
trace_mem(Buffer,vLen);
if(!GetDataFromHsm(Buffer, vLen))
{
trace_log(ERR, "SetWorkKey call GetDataFromHsm return false.");
return false;
}
return true;
}
bool CMyServer::Start()
{
if (NULL == m_lpfnOnSocketData)
return false;
//启动端口服务
m_bPortActive = StartServer(m_uPortNum, m_lpfnOnSocketData,m_lpfnOnSocketConnect, m_lpfnOnSocketClose,5*60);
if (m_bPortActive)
{
trace_log(DBG,"Service Port[%d] Start...OK.", m_uPortNum);
}
else
trace_log(DBG,"Service Port[%d] Start...failed!", m_uPortNum);
return m_bPortActive;
}
int main(int argc, const char *argv[])
{
trace = 1;
trace_log(NULL);
func1();
return 0;
}
int DoChnLogin(TRADEDATA *pData, bool bLoginFlag)
{
if(pData == NULL)
{
trace_log(ERR, "paramter error!");
return -1;
}
pData->bIsLogin = bLoginFlag;
TransProcess transProcess;
if(transProcess.Process(POS_SIGN, pData)!=0)
{
trace_log(ERR, "login in failed!");
return -1;
}
return 0;
}
/** \brief
* 构造PinBlock
* \param in: cAccount 账号
* \param in: pin 密码数据
* \param out: outdata PinBlock数据
* \return 失败返回-1，成功返回0
*/
int CTradeBase::PinBlock(char * cAccount, const BYTE *pin, BYTE *outdata)
{
trace_log(DBG,"PinBlock in---!");
if(!cAccount || !pin || !outdata)
{
trace_log(ERR, "Input parameter error!");
return -1;
}
BYTE sTempData[100] = {0};
BYTE sTemppan[12] = {0};
BYTE pan[8] = {0};
BYTE PinBlock[8] = {0};
BYTE sTempPinBlock[8] = {0};
int nCutLen = 12;
int nPanLen = 8;
int nPinLen = 6;
int i;
memcpy(sTempData, cAccount+strlen(cAccount)-nCutLen-1, nCutLen);
trace_log(DBG, "The cutting off pan is: %s", sTempData);
Ccommon::Asc2Bcd((char*)sTempData, sTemppan, nCutLen, NL);
for(i = 0; i < 2; i++)
pan[i] = 0x00;
memcpy(pan + 2, sTemppan, nPanLen - 2);
memset(sTempData, 0, sizeof(sTempData));
memcpy(sTempData, pin, strlen((char*)pin));
Ccommon::Asc2Bcd((char*)sTempData, sTempPinBlock, nPinLen, NL);
PinBlock[0] = nPinLen;
memcpy(PinBlock+1, sTempPinBlock, nPinLen/2);
for(i = nPinLen/2 + 1; i < nPanLen; i++)
PinBlock[i] = 0xFF;
memset(sTempData, 0, sizeof(sTempData));
for( i = 0; i < nPanLen; i++ )
{
sTempData[i] = pan[i] ^ PinBlock[i];
}
memcpy(outdata, sTempData, nPanLen);
return 0;
}
void CMyServer::Stop()
{
if (m_bPortActive)
{
m_bPortActive = false;
CloseServer(m_uPortNum);
trace_log(SYS, "Service Port[%d] Closed.", m_uPortNum);
}
}
TransProcess::~TransProcess()
{
//dtor
if( dbConn.isConnected()||dbConn.isAlive() )
{
dbConn.Disconnect();
}
trace_log(DBG,"~TransProcess()");
}
/** \brief
* 计算mab
* \param in: pData TRADEDATA结构指针
* \param in: obj8583 8583包
* \param out: bMac 8字节
* \return 失败返回非0，成功返回0
*/
int CTradeBase::GenMacData( TRADEDATA * pData,CUPS8583 obj8583,BYTE* bMac)
{
int nLenMab=0,nLen=0;
BYTE bMak[17]={0},bTmp[8]={0},bOut[8]={0};
BYTE bMab[1024];
nLenMab=BuildMab(obj8583,bMab);
if(bSoftEncrypt)
{
/**< 软计算 */
nLen=8*((nLenMab+7)/8);
for(int i=nLenMab;i<nLen;i++)
bMab[i]=0x00;
Ccommon::Asc2Bcd(pData->bMacKey,bMak, 32);
memcpy(bTmp,bMab,8);
for(int i=0;i<nLen/8;i++)
{
des.DesEncrypt(ENCRYPT,bTmp,bMak,bOut);
trace_log(DBG," EnDES: %d",i);
trace_mem(bOut,8);
if(i<nLen/8-1)
{
for( int j = 0; j< 8 ; j++ )
{
bTmp[j] = bOut[j] ^ bMab[(i+1)*8+j];
}
}
}
des.DesEncrypt(DECRYPT,bOut,bMak+8,bTmp);
trace_log(DBG," DeDES:");
trace_mem(bTmp,8);
des.DesEncrypt(ENCRYPT,bTmp,bMak,bMac);
trace_log(DBG," EnDES: ");
trace_mem(bMac,8);
}else{
/**< 硬计算 */
if(!cryptComm.CalculateMac(pData->RcvBrchCode,pData->SndBrchCode,bMab, nLenMab,bMac))
{
trace_log(ERR, "Get mac failed!");
return RET_PACK;
}
}
return 0;
}
/**从线程池收到的终端请求数据*/
int OnFromTerm(QUEUE_LIST *pDataNode)
{
try
{
int ret;
Dataprocess dataProcess;
trace_mem(pDataNode->Buffer, pDataNode->Length);
ms_delay(20);
/**< 交易消息类型解包 */
ret = dataProcess.Unpack(pDataNode->Buffer, pDataNode->Length);
/**< 交易消息类型的业务处理*/
if(ret==0)
{
trace_log(DBG, "Unpack package success");
//数据处理
ret = dataProcess.Process();
if(ret==0)
{
trace_log(DBG, "Trade process success");
}else if(ret==-2){
return -1;
}else trace_log(DBG, "Trade process failed");
}
/**< 交易消息类型打包*/
unsigned int iOutLen=ONE_PACKSIZE;
ret = dataProcess.Pack(pDataNode->Buffer, iOutLen);
pDataNode->Length=iOutLen;
if(ret!=0)
{
trace_log(ERR, "pack package failed");
return -1;
}
trace_log(DBG, "Pack package success");
//if(dataProcess.myData.tradeType==POS_CONSUME)/**< 为了冲正的测试 */
//{
// return -1;
//}
return 0;
}catch(...){
return -1;
}
}
/** \brief
* 设置密码
* \param in: pData TRADEDATA结构指针
* \param in: tlvObj tlv结构
* \param in:2磁道数据
* \param out: bHasPin 是否有密码
* \return 失败返回非0，成功返回0
*/
int CTradeBase::SetPinKey( TRADEDATA * pData, CTLVTemplet tlvObj,bool& bHasPin)
{
//52密码
BYTE bTmpData[FIELD_MAXLEN]={0};
BYTE bTmpPinData[9] = {0};
BYTE bTmpTpk[17] = {0};
BYTE bTmpPinBlock[17] = {0};
memset(bTmpData, 0, sizeof(bTmpData));
trace_log(DBG,"SetPinKey start!");
int nFieldDataLen = tlvObj.GetTLVItemByHex(TAG_ENCRYPTPWD, bTmpData, sizeof(bTmpData));
if(nFieldDataLen > 0)
{
trace_log(DBG,"PinBlock start!");
bHasPin=true;
if(bSoftEncrypt)
{
/**< 软加密 */
memset(bTmpData, 0, sizeof(bTmpData));
if(PinBlock(pData->TransData.HeadData.Account, (BYTE*)bTmpData, bTmpPinBlock)!=0)
{
trace_log(ERR,"PinBlock faile");
return -1;
}
Ccommon::Asc2Bcd((char *)pData->bPinKey,bTmpTpk, 32);
if(des.THreeDes(bTmpPinBlock,bTmpTpk,bTmpPinData,ENCRYPT,TWO_3DES)!=0)
{
trace_log(ERR,"EnPin faile");
return -1;
}
}else{
/**< 硬加密 */
if(!cryptComm.TranslatePin(pData->TransData.HeadData.LMerchNo, pData->TransData.HeadData.LTermNo,
pData->RcvBrchCode,pData->SndBrchCode,pData->TransData.HeadData.Account, bTmpData, bTmpPinData, 1, 1))
{
trace_log(ERR, "Call TranslatePin fail!");
return RET_SYSEXP;
}
}
sndObj.SetValueByHex(52, bTmpPinData, 8);
}
return 0;
}
int CIso8583<_Ty>::SetValueByHex(const int iIndex, const unsigned char *pHexData, int iDataLen, int iValidLen)
{
if(m_pIFF == NULL || m_pIFF->GetField(iIndex) == NULL)
{
trace_log(ERR, "The parameters m_pIFF is empty.");
return 0;
}
if(iIndex < 0 || iIndex >= m_pIFF->GetMF()->iFieldCnt)
{
trace_log(ERR, "iIndex overflow.");
return 0;
}
int iRet = m_pIFF->GetField(iIndex)->SetValueByHex(pHexData, iDataLen, iValidLen);
if(iRet && !SetBitMap(iIndex))
{
return 0;
}
return iRet;
}
/**
*启动服务
**/
bool StartServices()
{
if (NULL == g_ThreadPoolMgr)
g_ThreadPoolMgr = new ThreadPoolManager();
g_ThreadPoolMgr->Init(100000,300,10);
g_TradeSvr = new CMyServer(g_Cfg.TradePort, &OnSocketData,&OnSocketConnect,&OnSocketClose, false, false);
if (!g_TradeSvr->Start())
return false;
if(0==x_svrinit((LPFN_XSVRCALLBACK)&AS_POS))
{
trace_log(DBG, "x_svrinit[AS_POS] success!");
}else trace_log(ERR, "x_svrinit[AS_POS] failed!");
g_Pub2WebIns=Publist2Web::GetInstancePtr();
return true;
}
bool CTradePayback::DifferentDay(void *pNode)
{
if (pNode == NULL)
{
trace_log(ERR, "Parameter error!");
return false;
}
TRADEDATA *pData = (TRADEDATA*)pNode;
CTLVTemplet tlvObj;
if (1 != tlvObj.UnPackTLVData(pData->TransData.TlvDataLen, pData->TransData.TlvData))
{
trace_log(ERR, "UnPackTLVData fail!");
return false;
}
unsigned char bFieldData[FIELD_MAXLEN]={0} ,cTmpData[FIELD_MAXLEN]={0};
unsigned int iFieldDataLen = 0;
//取交易时间
iFieldDataLen = tlvObj.GetTLVItemByHex(TAG_CURTIME, bFieldData, sizeof(bFieldData));
if (iFieldDataLen <= 0)
{
trace_log(ERR, "GetTLVItemByHex[2F02] fail!");
return false;
}
// 取原交易时间
iFieldDataLen = tlvObj.GetTLVItemByHex(TAG_ORIGTIME, cTmpData, sizeof(bFieldData));
if (iFieldDataLen <= 0)
{
trace_log(ERR, "GetTLVItemByHex[2F07] fail!");
return false;
}
// 判断是否当日
trace_log(DBG, "payback CURTIME[%s] ORIGTIME[%s]", bFieldData, cTmpData);
if (memcmp(bFieldData, cTmpData, 8) == 0)
{
// 是当日，不调用核心记账
return false;
}
return true;
}
int main(int argc, char* argu[])
{
time_t tempTime = 0;
time(&tempTime);
tm* CurTime = localtime(&tempTime);
trace_log(DBG, "time: %ld", tempTime);
trace_log(DBG, "%4d-%02d-%2d ", CurTime->tm_year + 1900, CurTime->tm_mon+1, CurTime->tm_mday);
test1();
test2();
test3();
//sleep(5);
time(&tempTime);
trace_log(DBG, "time: %ld", tempTime);
sleep(1);
time(&tempTime);
trace_log(DBG, "time: %ld", tempTime);
return 0;
}
Dataprocess::Dataprocess()
{
try
{
Init();
memset(&trasData,0,sizeof(trasData));
memset(&myData,0,sizeof(myData));
pMsg8583recv = new MSGISO8583;
if(NULL == pMsg8583recv )
{
trace_log(ERR, "create MSGISO8583 object failed");
}
}
catch(...)
{
trace_log(SYS, "Error in Dataprocess::Dataprocess()");
}
}
/**< 处���交易 */
int TransProcess::Process(POS_TRADE_TYPE tradeType,TRADEDATA *pData)
{
trace_log(DBG,"start get DBConn");
if(GetConn()!=0)
{
trace_log(ERR,"GetSQLConn fail");
return -1;
}
trace_log(DBG,"get DBConn success");
map<POS_TRADE_TYPE,TranFunc>::iterator itor;
itor=mapTran.find(tradeType);
if(itor==mapTran.end())
{
trace_log(ERR,"no the trade_type:%d",tradeType);
return -1;
}
return itor->second(&dbConn,pData);
}
/**************************************************************
函数名称: GetDataFromHsm
函数功能: 连接加密机从其获取数据
入口参数: pMsgBuffer[in/out]:发送或返回的数据中的MSG
iLen[in/out]:发送或返回数据的长度
相关调用:
返 回 值: true成功， false失败
**************************************************************/
bool EnCryptComm::GetDataFromHsm(unsigned char *pMsgBuffer, unsigned & iLen)
{
unsigned char cmd = pMsgBuffer[0], Buffer[1024]={0};
unsigned sLen;//发送数据长度
sLen = iLen + 7;
memcpy(Buffer, &sLen, 2);//LC
Buffer[2]=0xF1;//INS
Buffer[3]=0;//SEQ
//CR默认为0
memcpy(&Buffer[6], pMsgBuffer, iLen);//MSG
Buffer[sLen-1] = CalcSum(Buffer, sLen - 1);//CRC
char errDesc[512]={0};
unsigned char cRecBuf[1024]={0};
int recLen=0;
SocketClient client;
int iErrorCode=client.SendToHost(Buffer,sLen,cRecBuf,recLen,g_Cfg.EncHost.Host, g_Cfg.EncHost.Port,20,errDesc);
if(0==iErrorCode)
{
trace_log(DBG, "recv from enchost");
trace_mem(cRecBuf, recLen);
if(cRecBuf[recLen-1] == CalcSum(cRecBuf, recLen - 1) && cRecBuf[6] == cmd && cRecBuf[8] == CMD_OK)
{//校验值正确,与原命令字相同,返回码为成功
if(memcmp(pMsgBuffer+2, cRecBuf+9, LEN_MERCHNO+LEN_TERMINO)!=0)//+LEN_TERMINO
{//比较商户号与终端号
trace_log(DBG, "The return data from encryptor is not match!!");
return false;
}
memcpy(pMsgBuffer, cRecBuf+6, recLen-7);//去掉LC,INS,SEQ,CR,CRC
iLen = recLen-7;
trace_log(DBG,"GetDataFromHsm->iLen=%d",iLen);
return true;
}
else
{
trace_log(ERR, "GetDataFromHsm else CalcSum %d", recLen);
return false ;
}
}else{
trace_log(ERR,errDesc);
return false;
}
}
int CTradeLogin::GetWorkCrypt(SAConnection *pSaconn,const BYTE *data,const BYTE* key, int nDataLen,TRADEDATA * pData)
{
if(!data || nDataLen <= 0)
{
trace_log(ERR, "Input paramedter error!");
return -1;
}
BYTE p[16+1] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
BYTE temp_data[128] = {0};
BYTE tpk[17] = {0}; //pin 密钥
BYTE tak[17] = {0}; //mac 密钥
BYTE tdk[17] = {0}; //磁道 密钥
int nKeyLen = 16; //密钥长度
trace_log(DBG,"data Len:%d",nDataLen);
//获取pin密钥明文
memset((char *)temp_data,0x00,sizeof((char *)temp_data));
memcpy( temp_data,data, 16);
des.THreeDes(temp_data,key,tpk,DECRYPT,TWO_3DES);
des.THreeDes(temp_data+8,key,tpk+8,DECRYPT,TWO_3DES);
memset((char *)temp_data,0x00,sizeof((char *)temp_data));
des.THreeDes(p,tpk,temp_data,ENCRYPT,TWO_3DES);
if(memcmp(temp_data,data+16,4) != 0) return 1;
Ccommon::Hex2Str(tpk,(char *)pData->bPinKey,nKeyLen);
//获取MAc密钥明文
memset((char *)temp_data,0x00,sizeof((char *)temp_data));
memcpy( temp_data,data+20, 16);
des.THreeDes(temp_data,key,tak,DECRYPT,TWO_3DES);
des.THreeDes(temp_data+8,key,tak+8,DECRYPT,TWO_3DES);
memset((char *)temp_data,0x00,sizeof((char *)temp_data));
des.DesEncrypt(ENCRYPT,p,tak,temp_data);
if(memcmp(temp_data,data+36,4) != 0) return 1;
Ccommon::Hex2Str(tak,(char *)pData->bMacKey,nKeyLen);
return 0;
}
