handle.cpre

商业银行前置系统

    ASSERT_NULL(pfile = fopen(szFileName, "a"));
    
    if (!VERIFY(fprintf(pfile, 
                        "帐号: %s\n"
                        "金额: %lf\n"
                        "传输时间: %s\n"
                        "交易时间: %s\n"
                        "交易日期: %s\n"
                        "系统跟踪号: %s\n"
                        "清算日期: %s\n"
                        "商户类型: %s\n"
                        "POS输入模式: %s\n"
                        "POS条件码: %s\n"
                        "代理机构标识码: %s\n"
                        "发送机构标识码: %s\n"
                        "检索参考号: %s\n"
                        "授权应答码: %s\n"
                        "受卡终端标识码: %s\n"
                        "受卡方标识码: %s\n"
                        "受卡方名称地址: %s\n"
                        "交易货币代码: %s\n"
                        "原因码: %s\n"
                        "接收机构标识码: %s\n"
                        "回扣率(*10000): %s\n\n"
                        "**************************************************\n",
                        szPan,
                        atof(szTransAmt) / 100,
                        szTransmissDateTime,
                        szLocalTransTime, 
                        szLocalTransDate, 
                        szTraceNo, 
                        szSettleDate, 
                        szMerchType,
                        szEntryMode,
                        szConditionCode,
                        szRetrievalRefNo,
                        szAuthResp,
                        szTermId,
                        szAcceptorId,
                        szAcceptorName,
                        szAcqId,
                        szForwardId,
                        szCurrCode,
                        &szReservePriv[3],
                        szDestId,
                        szNationReserve) >= 0))
    {
        fclose(pfile);
        return EXCEPTION;
    }

    fclose(pfile);
    return NORMAL;
}

RESULT SetRespCode(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szRespCode[AP_LEN_RESPCODE + 1];
    UINT n = 0;
    
    bufclr(szRespCode);
    AP_DEMAND_EXT(AP_PATH_RESPCODE, szRespCode);
    
    while (pszRespCode[n][0] != NULL)
    {
        if (strcmp(pszRespCode[n][0], szRespCode) == 0)
        {
            strcpy(szRespCode, pszRespCode[n][1]);
            break;
        }
        n++;
    }
    
    if (pszRespCode[n][0] == NULL)
        strcpy(szRespCode, "93");
    
    ASSERT_NORMAL(FillRespIso8583(piso8583stru, szRespCode));
    return NORMAL;
}

RESULT SetExpDate(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szExpDate[AP_LEN_EXPDATE + 1];
    
    bufclr(szExpDate);

    AP_DEMAND_EXT(AP_PATH_EXPDATE, szExpDate);
    
    if (strcmp(szExpDate, "") == 0 ||
        atoi(szExpDate + 2) > 12 || atoi(szExpDate + 2) == 0)
        strcpy(szExpDate, "9912");
        
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_EXPDATE, szExpDate,
                                  SIZE_EXPDATE));
    return NORMAL;
}

RESULT SetAuthResp(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szAuthCode[AP_LEN_AUTHCODE + 1];
    
    bufclr(szAuthCode);

    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_AUTHCODE, szAuthCode));
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_AUTHRESP, szAuthCode,
                                  SIZE_AUTHRESP));

    return NORMAL;
}

RESULT SetAddResp(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_ADDRESP, szRespSeqNo,
                                  AP_LEN_SEQNO));
    return NORMAL;
}

RESULT SetAddAmt(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szAccType[AP_LEN_ACCTYPE + 1];
    char szCurrType[AP_LEN_CURRTYPE + 1];
    char szBal[AP_LEN_BAL + 1];
    char szAvailBal[AP_LEN_BAL + 1];
    char szAddAmt[SIZE_ADDAMT_MAX + 1];
    char *pcSign;
    
    bufclr(szAccType);
    bufclr(szCurrType);
    bufclr(szBal);
    bufclr(szAvailBal);
    bufclr(szAddAmt);

    memset(szAddAmt, '0', SIZE_ADDAMT_MAX);

    /*
     * 组装帐户类型。
     */

    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_ACCTYPE, szAccType));

    if (strcmp(szAccType, AP_ACCTYPE_CREDITCARD) == 0 || 
        strcmp(szAccType, AP_ACCTYPE_LOANCARD) == 0)
    {
        memcpy(szAddAmt, "30", 2);
        memcpy(&szAddAmt[20], "30", 2);
    }
    else
    {
        memcpy(szAddAmt, "10", 2);
        memcpy(&szAddAmt[20], "10", 2);
    }
    
    /*
     * 组装数量类型。
     */
    
    memcpy(&szAddAmt[2], "01", 2);
    memcpy(&szAddAmt[22], "02", 2);
    
    /*
     * 组装货币代码。
     */
     
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_CURRTYPE, szCurrType));

    memcpy(&szAddAmt[4], szCurrType, 3);
    memcpy(&szAddAmt[24], szCurrType, 3);
    
    /*
     * 组装余额。
     */
    
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_BAL, szBal));

    if ((pcSign = strchr(szBal, '-')) != NULL)
    {
        *pcSign = '0';
        szAddAmt[7] = 'D';
    }
    else 
        szAddAmt[7] = 'C';
        
    sprintf(szBal, "%012.0lf", atof(szBal) * 100);
    memcpy(&szAddAmt[8], szBal, 12);
    
    /*
     * 组装可用余额。
     */
    
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_AVAILBAL, szAvailBal));

    if ((pcSign = strchr(szAvailBal, '-')) != NULL)
    {
        *pcSign = '0';
        szAddAmt[27] = 'D';
    }
    else 
        szAddAmt[27] = 'C';
        
    sprintf(szAvailBal, "%012.0lf", atof(szAvailBal) * 100);
    memcpy(&szAddAmt[28], szAvailBal, 12);
        
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_ADDAMT, szAddAmt,
                                  SIZE_ADDAMT_MAX));
    return NORMAL;
}

RESULT SetSettle(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szNum[AP_LEN_NUM + 1];
    char szFee[AP_LEN_FEE + 1];
    char szAmt[AP_LEN_AMT + 1];
    char szNetSettleAmt[SIZE_NETSETTLEAMT + 1];

    bufclr(szNum);
    bufclr(szAmt);
    bufclr(szFee);
    bufclr(szNetSettleAmt);

    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_CREDITNUM, szNum));
    sprintf(szNum, "%010d", atoi(szNum));
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_CREDITNUM, szNum,
                                  SIZE_CREDITNUM));
                                  
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_REVERSECREDITNUM, szNum));
    sprintf(szNum, "%010d", atoi(szNum));
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_REVERSECREDITNUM, szNum,
                                  SIZE_REVERSECREDITNUM));
                                  
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_DEBITNUM, szNum));
    sprintf(szNum, "%010d", atoi(szNum));
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_DEBITNUM, szNum,
                                  SIZE_DEBITNUM));
                                  
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_REVERSEDEBITNUM, szNum));
    sprintf(szNum, "%010d", atoi(szNum));
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_REVERSEDEBITNUM, szNum, 
                                  SIZE_REVERSEDEBITNUM));
                                  
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_TRANSFERNUM, szNum));
    sprintf(szNum, "%010d", atoi(szNum));
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_TRANSFERNUM, szNum, 
                                  SIZE_TRANSFERNUM));
                                  
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_REVERSETRANSFERNUM, szNum));
    sprintf(szNum, "%010d", atoi(szNum));
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_REVERSETRANSFERNUM, 
                                  szNum, SIZE_REVERSETRANSFERNUM));
                                  
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_QUERYNUM, szNum));
    sprintf(szNum, "%010d", atoi(szNum));
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_INQNUM, szNum, 
                                  SIZE_INQNUM));
                                  
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_AUTHNUM, szNum));
    sprintf(szNum, "%010d", atoi(szNum));
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_AUTHNUM, szNum, 
                                  SIZE_AUTHNUM));
                                  
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_CREDITFEE, szFee));
    sprintf(szFee, "%012.0lf", atof(szFee) * 100);
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_CREDITFEE, szFee, 
                                  SIZE_CREDITFEE));
                                  
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_DEBITFEE, szFee));
    sprintf(szFee, "%012.0lf", atof(szFee) * 100);
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_DEBITFEE, szFee,
                                  SIZE_DEBITFEE));
   
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_CREDITAMT, szAmt));
    sprintf(szAmt, "%016.0lf", atof(szAmt) * 100);
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_CREDITAMT, szAmt, 
                                  SIZE_CREDITAMT));
                                  
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_DEBITAMT, szAmt));
    sprintf(szAmt, "%016.0lf", atof(szAmt) * 100);
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_DEBITAMT, szAmt,
                                  SIZE_DEBITAMT));
    
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_REVERSECREDITAMT, szAmt));
    sprintf(szAmt, "%016.0lf", atof(szAmt) * 100);
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_REVERSECREDITAMT, szAmt,
                                  SIZE_REVERSECREDITAMT));
                                  
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_REVERSEDEBITAMT, szAmt));
    sprintf(szAmt, "%016.0lf", atof(szAmt) * 100);
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_REVERSEDEBITAMT, szAmt,
                                  SIZE_REVERSEDEBITAMT));
    
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_SETTLEAMT, szAmt));

    szNetSettleAmt[0] = (atof(szAmt) >= 0 ? 'C' : 'D');
    sprintf(&szNetSettleAmt[1], "%016.0lf", atof(szAmt) * 100);
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_NETSETTLEAMT,
                                  szNetSettleAmt, SIZE_NETSETTLEAMT));
    return NORMAL;
}

RESULT SetMacInResetKey(PISO8583STRU piso8583stru, PUCHAR pcKey)
{
    UCHAR cMacA[SIZE_MAC];
    UCHAR cMacB[SIZE_MAC];
    UCHAR cZero[SIZE_KEY];

    bufclr(cMacA);
    bufclr(cMacB);
    bufclr(cZero);
    
    ASSERT_NORMAL(CalcMac(piso8583stru, cAdminMac, cMacA, pcKey));    
    ASSERT_NORMAL(Des(cMacB, cZero, pcKey, TRUE));
    
    memcpy(cMacA + 4, cMacB, 4);
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_MAC, cMacA, SIZE_MAC));
    return NORMAL;
}

RESULT FillRespIso8583(PISO8583STRU piso8583stru, PCSTR pszRespCode)
{
    char szMsgId[SIZE_MSGID + 1];
    UINT nSize;

    bufclr(szMsgId);

    nSize = SIZE_MSGID;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_MSGID, szMsgId, &nSize));

    szMsgId[2]++;
    SetBitInIso8583(piso8583stru, BIT_MSGID, szMsgId, SIZE_MSGID);
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_RESPCODE, pszRespCode,
                                  SIZE_RESPCODE));
    return NORMAL;
}

RESULT VerifyMacInResetKey(PISO8583STRU piso8583stru, PUCHAR pcKey)
{
    UCHAR cMacA[SIZE_MAC], cMacB[SIZE_MAC], cMacC[SIZE_MAC];
    UCHAR cZero[SIZE_KEY];
    UINT nSize;
    
    bufclr(cMacA);
    bufclr(cMacB);
    bufclr(cMacC);
    bufclr(cZero);
    
    nSize = SIZE_MAC;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_MAC, cMacA, &nSize));
    ASSERT_NORMAL(CalcMac(piso8583stru, cAdminMac, cMacB, pcKey));

    ASSERT_NORMAL(Des(cMacC, cZero, pcKey, TRUE));

    memcpy(cMacB + 4, cMacC, 4);
    if (memcmp(cMacA, cMacB, SIZE_MAC) == 0)
        return NORMAL;
        
    return MACERR;
}

/*
 * ASSURE_NORMAL宏