handle.cpre

商业银行前置系统

    }
    else
    {
        szPosBal[14] = 'D';
        sprintf(&szPosBal[15], "%10.2lf", -dAmt);
    }
     
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_BAL, szPosBal,
                                  SIZE_BAL_MAX));
    return NORMAL;
}

RESULT SetDateTime(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szRespDate[AP_LEN_DATE + 1];           
    char szRespTime[AP_LEN_TIME + 1];           

    TIMESTRU timestru;
    UINT nSize;

    bufclr(szRespDate);
    bufclr(szRespTime);

    timestru = GetTime();

    if (AP_DEMAND_EXT(AP_PATH_RESPTIME, szRespTime) != NORMAL)
        sprintf(szRespTime, "%02d%02d%02d",
                timestru.nHour, timestru.nMin, timestru.nSec);

    if (AP_DEMAND_EXT(AP_PATH_RESPDATE, szRespDate) != NORMAL)
        sprintf(szRespDate, "%04d%02d%02d",
                timestru.nYear, timestru.nMon, timestru.nDay);

    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_TIME, szRespTime,
                                  SIZE_TIME));

    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_DATE, szRespDate + 4,
                                  SIZE_DATE));
    return NORMAL;
}

RESULT SetHostTrace(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szRespSeqNo[AP_LEN_SEQNO + 1];           

    bufclr(szRespSeqNo);

    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_RESPSEQNO, szRespSeqNo));

    ASSERT_NORMAL(SetBitInIso8583(piso8583stru,  BIT_HOSTTRACE, szRespSeqNo,
                                  SIZE_HOSTTRACE));
    return NORMAL;
}

RESULT SetCertNo(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szCertNo[AP_LEN_CERTNO + 1];
    UINT nSize;

    bufclr(szCertNo);

    if (AP_DEMAND_EXT(AP_PATH_CERTNO, szCertNo) == NORMAL)
        VERIFY_NORMAL(SetBitInIso8583(piso8583stru, BIT_CERTNO, szCertNo, 
                                      strlen(szCertNo)));
    return NORMAL;
}

RESULT SetFundType(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szCurrType[AP_LEN_CURRTYPE + 1];

    bufclr(szCurrType);

    if (AP_DEMAND_EXT(AP_PATH_CURRTYPE, szCurrType) == NORMAL)
        VERIFY_NORMAL(SetBitInIso8583(piso8583stru, BIT_FUNDTYPE, szCurrType,
                                      SIZE_FUNDTYPE));
    return NORMAL;
}

RESULT CreateReqXml(PXMLSTRU pxmlstruReq)
{
    ASSERT_NORMAL(CreateXml(pxmlstruReq, FALSE, AP_PATH_ROOT, NULL));
    return NORMAL;
}

TIMESTRU ConvStrToTimeStru(PCHAR pcDateTime)
{
    TIMESTRU timestru;
    char szData[5];

    bufclr(szData);
    memcpy(szData, pcDateTime, 4);
    timestru.nYear = (UINT)atoi(szData);

    bufclr(szData);
    memcpy(szData, pcDateTime + 4, 2);
    timestru.nMon = (UINT)atoi(szData);

    bufclr(szData);
    memcpy(szData, pcDateTime + 6, 2);
    timestru.nDay = (UINT)atoi(szData);

    bufclr(szData);
    memcpy(szData, pcDateTime + 8, 2);
    timestru.nHour = (UINT)atoi(szData);

    bufclr(szData);
    memcpy(szData, pcDateTime + 10, 2);
    timestru.nMin = (UINT)atoi(szData);

    bufclr(szData);
    memcpy(szData, pcDateTime + 12, 2);
    timestru.nSec = (UINT)atoi(szData);

    return timestru;

}

RESULT VerifyMac(PISO8583STRU piso8583stru, PUCHAR pcKey)
{
    EXEC SQL BEGIN DECLARE SECTION;
    char szWorkKey[SIZE_KEY * 2 + 1];
    char szOldWorkKey[SIZE_KEY * 2 + 1];
    char szTermId[SIZE_TERMID + 1];
    char szInitKeyDateTime[14 + 1];
    EXEC SQL END DECLARE SECTION;

    UCHAR cMacA[SIZE_MAC];
    UCHAR cMacB[SIZE_MAC];
    char cKey[SIZE_KEY + 1];
    TIMESTRU timestruCurrent, timestruInitKey;
    UINT nSize;
    long lSec;

    bufclr(cMacA);
    bufclr(cMacB);

    nSize = SIZE_MAC;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_MAC, cMacA, &nSize));

    ASSERT_NORMAL(SetMac(piso8583stru, pcKey));

    nSize = sizeof(cMacB);
    GetBitInIso8583(piso8583stru, BIT_MAC, cMacB, &nSize);
    
    if (memcmp(cMacA, cMacB, SIZE_MAC) == 0)
        return NORMAL;

    bufclr(szTermId);
    bufclr(szOldWorkKey);
    bufclr(szWorkKey);
    bufclr(szInitKeyDateTime);
    bufclr(cKey);

    nSize = SIZE_TERMID;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_TERMID, szTermId, &nSize));

    EXEC SQL SELECT workkey, oldworkkey, initkeydatetime
             INTO :szWorkKey, :szOldWorkKey, :szInitKeyDateTime
             FROM pos 
             WHERE termid = :szTermId;

    ASSERT_SQL_NORMAL();
    
    timestruCurrent = GetTime();

    timestruInitKey = ConvStrToTimeStru(szInitKeyDateTime);

    lSec = GetTimeDefer(timestruInitKey, timestruCurrent);

    if (lSec > atol(szConvKeyTime) * 60)
        return INVALID;

    ShiftCharToHex(szOldWorkKey, cKey, SIZE_KEY);

    ASSERT_NORMAL(SetMac(piso8583stru, cKey));

    nSize = sizeof(cMacB);
    GetBitInIso8583(piso8583stru, BIT_MAC, cMacB, &nSize);
    
    if (memcmp(cMacA, cMacB, SIZE_MAC) == 0)
    {
        ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_ADDRESP, 
                                      szWorkKey, SIZE_KEY * 2));
        return NORMAL;
    }

    return INVALID;
}

RESULT SetMac(PISO8583STRU piso8583stru, PUCHAR pcKey)
{
    char cMsg[SIZE_MSG_ISO8583];
    UCHAR cMac[SIZE_MAC];
    UINT nSize;
    UINT n;
   
    bufclr(cMsg);
    bufclr(cMac);

    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_MAC, cMac, SIZE_MAC));

    nSize = sizeof(cMsg);
    ASSERT_NORMAL(ExportIso8583(piso8583stru, cMsg, &nSize));

    nSize -= SIZE_MAC;
    ASSERT_NORMAL(Ansix99(cMac, (PCUCHAR)cMsg, nSize, pcKey));

    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_MAC, cMac, SIZE_MAC));
    return NORMAL;
}

RESULT GetKey(PISO8583STRU piso8583stru, PUCHAR pcKey)
{
    EXEC SQL BEGIN DECLARE SECTION;
    char szWorkKey[SIZE_KEY * 2 + 1];
    char szTermId[SIZE_TERMID + 1];
    EXEC SQL END DECLARE SECTION;

    UINT nSize;

    bufclr(szTermId);
    bufclr(szWorkKey);

    nSize = SIZE_TERMID;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_TERMID, szTermId, &nSize));

    EXEC SQL SELECT workkey INTO :szWorkKey FROM pos WHERE termid = :szTermId;
    ASSERT_SQL_NORMAL();

    ShiftCharToHex(szWorkKey, (PCHAR)pcKey, SIZE_KEY);
    return NORMAL;
}

BOOL IsEntryMode(PISO8583STRU piso8583stru, PCSTR pszEntryMode)
{
    char szEntryMode[SIZE_ENTRYMODE + 1];
    UINT nSize;

    bufclr(szEntryMode);

    nSize = SIZE_ENTRYMODE;
    VERIFY_NORMAL(GetBitInIso8583(piso8583stru, BIT_ENTRYMODE, szEntryMode,
                                  &nSize));

    if (strcmp(pszEntryMode, szEntryMode) == 0)
        return TRUE;

    return FALSE;
}

RESULT WriteRecordInUpload(PISO8583STRU piso8583stru)
{ 
    char szPan[SIZE_PAN_MAX + 1];
    char szAmt[SIZE_AMT + 1];
    char szHostTrace[SIZE_HOSTTRACE + 1];
    char szAuthCode[SIZE_AUTHCODE + 1];
    char szTermId[SIZE_TERMID + 1];
    char szVouchNoBatchNo[SIZE_VOUCHNOBATCHNO_MAX + 1];
    char szBatchNo[SIZE_BATCHNO + 1];
    char szTransCode[AP_LEN_TRANSCODE + 1];
    char szFileName[32 + 1];
    FILE *pfile;
    UINT nSize;

    bufclr(szPan);
    bufclr(szAmt);
    bufclr(szHostTrace);
    bufclr(szAuthCode);
    bufclr(szTermId);
    bufclr(szVouchNoBatchNo);
    bufclr(szBatchNo);
    bufclr(szTransCode);
    bufclr(szFileName);

    ASSERT_NORMAL(GetTransCodeInUpLoad(piso8583stru, szTransCode));

    nSize = SIZE_TERMID;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_TERMID, szTermId, &nSize));

    nSize = SIZE_VOUCHNOBATCHNO_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_VOUCHNOBATCHNO, 
                                  szVouchNoBatchNo, &nSize));

    DETECT(nSize == SIZE_VOUCHNOBATCHNO_MAX);
    
    strcpy(szBatchNo, szVouchNoBatchNo + SIZE_VOUCHNO);
   
    nSize = SIZE_PAN_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_PAN, szPan, &nSize));

    nSize = SIZE_AMT;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_AMT, szAmt, &nSize));

    nSize = SIZE_HOSTTRACE;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_HOSTTRACE, 
                                  szHostTrace, &nSize));

    ASSERT_NORMAL(AP_DEMAND_CFG(AP_PATH_CFG_INSTALLPATH, szFileName));
    sprintf(szFileName + strlen(szFileName),
            "/log/ca/pos/up%8s.%6s", szTermId, szBatchNo);
    
    ASSERT_NULL(pfile = fopen(szFileName, "a"));

    if (!VERIFY(fprintf(pfile, "%-19s|%12.2lf|%12s|%8s|%6.6s|%6s|%4s\n",
                        szPan, atof(szAmt) / 100, szHostTrace,
                        szTermId, szVouchNoBatchNo, szBatchNo,
                        szTransCode) >= 0))
    {
        fclose(pfile);
        return EXCEPTION;
    }
               
    fclose(pfile);
    return NORMAL;
}

RESULT WriteTitleInUpload(PISO8583STRU piso8583stru)
{ 
    char szTermId[SIZE_TERMID + 1];
    char szBatchNo[SIZE_BATCHNO_MAX + 1];
    char szFileName[32 + 1];
    UINT nSize;
    FILE *pfile;

    bufclr(szTermId);
    bufclr(szBatchNo);
    bufclr(szFileName);

    nSize = SIZE_TERMID;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_TERMID, szTermId, &nSize));
    
    nSize = SIZE_BATCHNO_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_BATCHNO, szBatchNo,
                                  &nSize));
                                  
    DETECT(nSize == SIZE_BATCHNO_MAX);

    ASSERT_NORMAL(AP_DEMAND_CFG(AP_PATH_CFG_INSTALLPATH, szFileName));
    sprintf(szFileName + strlen(szFileName),
            "/log/ca/pos/up%8s.%6s", szTermId, szBatchNo);
            
    ASSERT_NULL(pfile = fopen(szFileName, "w"));

    if (!VERIFY(fprintf(pfile, 
                        "卡号               |金额        |系统跟踪号  |"
                        "终端号  |凭证号|批次号|交易\n") >= 0))
    {
        fclose(pfile);
        return EXCEPTION;
    }

    fclose(pfile);
    return NORMAL;
}

#define BATCHNOERR 1000

RESULT CheckBatchNo(PISO8583STRU piso8583stru)
{
    EXEC SQL BEGIN DECLARE SECTION;
    char szTermId[SIZE_TERMID + 1];
    char szMerchId[SIZE_MERCHID + 1];
    char szBatchNo[SIZE_BATCHNO + 1];
    EXEC SQL END DECLARE SECTION;
   
    char szCurBatchNo[SIZE_BATCHNO_MAX + 1];
    char szVouchNoBatchNo[SIZE_VOUCHNOBATCHNO_MAX + 1];
    UINT nSize;

    bufclr(szTermId);
    bufclr(szMerchId);
    bufclr(szBatchNo);
    bufclr(szCurBatchNo);
    bufclr(szVouchNoBatchNo);

    nSize = SIZE_TERMID;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_TERMID, szTermId, &nSize));

    nSize = SIZE_MERCHID;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_MERCHID, szMerchId, &nSize));

    nSize = SIZE_VOUCHNOBATCHNO_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_VOUCHNOBATCHNO, 
                                  szVouchNoBatchNo, &nSize));

    if (nSize == SIZE_BATCHNO_MAX)
        strcpy(szCurBatchNo, szVouchNoBatchNo);

    else if (nSize == SIZE_VOUCHNOBATCHNO_MAX)
        strcpy(szCurBatchNo, szVouchNoBatchNo + SIZE_VOUCHNO);
        
    else
        DETECT(FALSE);

    EXEC SQL SELECT batchno 
             INTO :szBatchNo 
             FROM pos 
             WHERE termid = :szTermId and merchid = :szMerchId;

    ASSERT_SQL_NORMAL();

    if (strcmp(szCurBatchNo, szBatchNo) != 0)
    {
        VERIFY_NORMAL(FillRespIso8583(piso8583stru, "80"));
        return BATCHNOERR;
    }
    return NORMAL;
}

/*
 * 将POS 上送的批次号加一，用此批次号更新POS 表中的批次号。 本函数在
 * POS上送二次结算后调用（不管结算结果如何）。
 */

RESULT UpdateBatchNo(PISO8583STRU piso8583stru)
{
    EXEC SQL BEGIN DECLARE SECTION;
    char szBatchNo[SIZE_BATCHNO_MAX + 1];
    char szTrace[SIZE_TRACE + 1];
    char szTermId[SIZE_TERMID + 1];
    char szMerchId[SIZE_MERCHID + 1];
    char szSysBatchNo[SIZE_BATCHNO_MAX + 1];
    EXEC SQL END DECLARE SECTION;

    UINT nSize;
    
    bufclr(szBatchNo);
    bufclr(szSysBatchNo);
    bufclr(szTermId);
    bufclr(szMerchId);