au_dlg.cpp

map协议源代码

                    }

                    AUACC_PRINT("AuLiMatHOMgmtRsp:MA_SNDENDSIG \n");
                }
                break;
            case MA_PROCACCSIG:
                {
                    AUACC_PRINT("AuLiMatHOMgmtRsp:MA_PROCaCCSIG \n");
                }
                break;
            case MA_FWDACCSIG:
                {
                    AUACC_PRINT("AuLiMatHOMgmtRsp:MA_FWDACCSIG \n");
                }
                break;
            case MA_PRE_SUBSHO:
                {
                    MaPreSubHoRsp opr;

                    cmZero((Data *)&opr,sizeof(MaPreSubHoRsp));
                    memcpy(&tInvId, &invkId, sizeof(MaInvokeId));
                    if (maAccPreSubHoRsp(&opr) != ROK)
                    {
                        return(RFAILED);
                    }

                    memset(&usrErr, 0, sizeof(MaUsrErr));
                    memcpy(&tUsrErr, &usrErr, sizeof(MaUsrErr));
                    if (ROK == AuLiMatHOMgmtRsp(&(dlgQueue->auPst), spId,
                         auDlgId, maDlgId,
                         &tInvId, oprCode, &tUsrErr, (MaHoEv *) &opr))
                    {
                        smAuSts.lAuOprRsp++;
                    }

                    AUACC_PRINT("AuLiMatHOMgmtRsp:MA_PRE_SUBSHO \n");
                }
                break;
/*added by Bruce for LCS  2003/7/3 */
            case MA_PROVSUBSLOC:
                {
                    /* added by Bruce for LCS 2003/8/29 */
                    static int masubloc=0;
                    MaPrvSubsLocRsp opr;

                    cmZero((Data *)&opr,sizeof(MaPrvSubsLocRsp));
                    memcpy(&tInvId, &invkId, sizeof(MaInvokeId));
                    if (maAccPrvSubsLocRsp(&opr) != ROK)
                    {
                        return(RFAILED);
                    }

                    memset(&usrErr, 0, sizeof(MaUsrErr));
                    memcpy(&tUsrErr, &usrErr, sizeof(MaUsrErr));

                    ++masubloc;
                    switch(masubloc%=4)
                    {
                        case 0:
                            AUACC_PRINT(" The value of masubloc is %d \r\n",masubloc);
                            break;
                        case 1:
                            AUACC_PRINT(" The value of masubloc is %d , unauthorizedRequestingNetwork \r\n",masubloc);
                            maAcc_unauth_net(&tUsrErr);
                            maAccPrintUsrErr(&tUsrErr, MA_UNAUTH_REQ_NET);
                            break;
                        case 2:
                            AUACC_PRINT(" The value of masubloc is %d , unauthorizedLCSClient  \r\n",masubloc);
                            maAcc_unauth_client(&tUsrErr);
                            maAccPrintUsrErr(&tUsrErr, MA_UNAUTH_LCSCLIENT);
                            break;
                        case 3:
                            AUACC_PRINT(" The value of masubloc is %d , positionMethodFailure \r\n",masubloc);
                            maAcc_posi_fail(&tUsrErr);
                            maAccPrintUsrErr(&tUsrErr, MA_POSITION_METH_FAIL);
                            break;
                    }

                    if (ROK == AuLiMatLocServRsp(&(dlgQueue->auPst), spId,
                         auDlgId, maDlgId,
                         &tInvId, oprCode, &tUsrErr, (MaLocServEv *) &opr))
                    {
                        smAuSts.lAuOprRsp++;
                    }

                    AUACC_PRINT("AuLiMatLocServRsp:MA_PROVSUBSLOC \n");
                }
                break;
            case MA_SENDROUTINFOFORLCS:
                {
                    MaRoutInfoForLcsRsp opr;

                    cmZero((Data *)&opr,sizeof(MaRoutInfoForLcsRsp));
                    memcpy(&tInvId, &invkId, sizeof(MaInvokeId));
                    if (maAccRoutInfoForLcsRsp(&opr) != ROK)
                    {
                        return(RFAILED);
                    }

                    memset(&usrErr, 0, sizeof(MaUsrErr));
                    memcpy(&tUsrErr, &usrErr, sizeof(MaUsrErr));
                    if (ROK == AuLiMatLocServRsp(&(dlgQueue->auPst), spId,
                                  auDlgId, maDlgId,
                               &tInvId, oprCode, &tUsrErr, (MaLocServEv *) &opr))
                    {
                        smAuSts.lAuOprRsp++;
                    }

                    AUACC_PRINT("AuLiMatLocServRsp:MA_SENDROUTINFOFORLCS \n");
                }
                break;
            case MA_SUBSLOCRPT:
                {
                    MaSubsLocRptRsp opr;

                    cmZero((Data *)&opr,sizeof(MaSubsLocRptRsp));
                    memcpy(&tInvId, &invkId, sizeof(MaInvokeId));
                    if (maAccSubsLocRptRsp(&opr) != ROK)
                    {
                        return(RFAILED);
                    }

                    memset(&usrErr, 0, sizeof(MaUsrErr));
                    memcpy(&tUsrErr, &usrErr, sizeof(MaUsrErr));

                    maAcc_unknown(&tUsrErr);
                    maAccPrintUsrErr(&tUsrErr, MA_UNKNOWN_OR_UNREACH);
                    if (ROK == AuLiMatLocServRsp(&(dlgQueue->auPst), spId,
                        auDlgId, maDlgId,
                        &tInvId, oprCode, &tUsrErr, (MaLocServEv *) &opr))
                    {
                        smAuSts.lAuOprRsp++;
                    }

                    AUACC_PRINT("AuLiMatLocServRsp:MA_SUBSLOCRPT \n");
                }
                break;

            case MA_ACTVSS:
                {
                    MaActvSSRsp opr;

                    cmZero((Data *)&opr,sizeof(MaActvSSRsp));
                    memcpy(&tInvId, &invkId, sizeof(MaInvokeId));
                    if (maAccActvSSRsp(&opr) != ROK)
                    {
                        return(RFAILED);
                    }

                    memset(&usrErr, 0, sizeof(MaUsrErr));
                    memcpy(&tUsrErr, &usrErr, sizeof(MaUsrErr));
                    if (ROK == AuLiMatSSRsp(&(dlgQueue->auPst), spId,
                        auDlgId, maDlgId,
                        &tInvId, oprCode, &tUsrErr, (MaSSEv *) &opr))
                    {
                        smAuSts.lAuOprRsp++;
                    }

                    AUACC_PRINT("AuLiMatSSRsp:MA_ACTVSS \n");
                }
                break;

            case MA_DACTVSS:
                {
                    MaDactvSSRsp opr;

                    cmZero((Data *)&opr,sizeof(MaDactvSSRsp));
                    memcpy(&tInvId, &invkId, sizeof(MaInvokeId));
                    if (maAccDactvSSRsp(&opr) != ROK)
                    {
                        return(RFAILED);
                    }

                    memset(&usrErr, 0, sizeof(MaUsrErr));
                    memcpy(&tUsrErr, &usrErr, sizeof(MaUsrErr));
                    if (ROK == AuLiMatSSRsp(&(dlgQueue->auPst), spId,
                        auDlgId, maDlgId,
                        &tInvId, oprCode, &tUsrErr, (MaSSEv *) &opr))
                    {
                        smAuSts.lAuOprRsp++;
                    }

                    AUACC_PRINT("AuLiMatSSRsp:MA_DACTVSS \n");
                }
                break;
            }

            if (auCloseDialog)
            {
                /* send close req */
                memcpy(&tCloseEv, &closeEv, sizeof(MaCloseEv));
                tCloseEv.rlsCause = MA_NORMAL_RELEASE;
                AuLiMatCloseReq(&(dlgQueue->auPst), spId, auDlgId, maDlgId, &tCloseEv);

                /* Sts */
                smAuSts.lAuCloseReq++;

                AUACC_PRINT("AuLiMatCloseRq_______auDlgId = %ld maDlgId = %ld\n",
                        auDlgId, maDlgId);
            }
            else
            {
#ifndef MATV2
            AuLiMatDelimReq(&(dlgQueue->auPst), spId, auDlgId, maDlgId);
#endif

                AUACC_PRINT("AuLiMatDelimReq_______auDlgId = %ld maDlgId = %ld\n",
                        auDlgId, maDlgId);
            }
            
            break;

        default:
            AUACC_PRINT("debug delimit here\r\n");
            accAuStopTmr(AU_GAURD_TMR, this);
            break;
    }
    RETVALUE(ROK);
}

S16 Dialog::auLiMatCloseIndPrs(MaAccMsgQElm *msg)
{
    AUACC_PRINT("Dialog::auLiMatCloseIndPrs________auDlgId = %ld,\
            maDlgId = %ld\n", auDlgId, maDlgId);

    switch (dsmState)
    {
        case AU_WF_CLOSE_IND:
            accAuStopTmr(AU_GAURD_TMR, this);
            break;
        default:
            AUACC_PRINT("AuLiMatCloseInd,receive DlgCloseReq \r\ndebug close here\r\n");
            accAuStopTmr(AU_GAURD_TMR, this);
            break;
    }

    RETVALUE(ROK);
}

S16 Dialog::auLiMatAbrtReqPrs(MaAccMsgQElm *msg)
{
    AUACC_PRINT("Dialog::auLiMatAbrtReqPrs\n");

    RETVALUE(ROK);
}

S16 Dialog::auLiMatAbrtIndPrs(MaAccMsgQElm *msg)
{
    AUACC_PRINT("Dialog::auLiMatAbrtIndPrs\n");

    RETVALUE(ROK);
}

S16 Dialog::auLiMatNotIndPrs(MaAccMsgQElm *msg)
{
    AUACC_PRINT("Dialog::auLiMatNotIndPrs, cause: \n", msg->s.notEv.cause);

#if 0
    if (msg->suDlgId != AU_ID_NULL)
    {
        AuLiMatCloseReq();
    }
#endif
    RETVALUE(ROK);
}

S16 Dialog::auLiMatStaIndPrs(MaAccMsgQElm *msg)
{
    AUACC_PRINT("Dialog::auLiMatStaIndPrs\n");

#if 0
    if (msg->suDlgId != AU_ID_NULL)
    {
        AuLiMatCloseReq();
    }
#endif
    RETVALUE(ROK);
}

S16 Dialog::auLiMatUpLocIndPrs(MaAccMsgQElm *msg)
{
    AUACC_PRINT("Dialog::auLiMatUpLocIndPrs________auDlgId = %ld,\
            maDlgId = %ld\n", auDlgId, maDlgId);

    invkId.pres = msg->s.operEv.invId.pres;
    invkId.octet = msg->s.operEv.invId.octet;
    oprCode = msg->s.operEv.oprCode;
    dsmState = AU_WF_DELIM_IND;
    RETVALUE(ROK);
}

S16 Dialog::auLiMatUpLocCfmPrs(MaAccMsgQElm *msg)
{
    AUACC_PRINT("Dialog::auLiMatUpLocCfmPrs________auDlgId = %ld,\
            maDlgId = %ld\n", auDlgId, maDlgId);

    dsmState = AU_WF_CLOSE_IND;
    RETVALUE(ROK);
}


S16 Dialog::startDlg(MaOprType type)
{
    SpAddr      srcAddr;    /* Source Address */
    SpAddr      dstAddr;    /* Destination Address */
    MaApConName acn;        /* Application Context Name */
    MaApConName altAcn;
    U8          oprClass1;
    U8          maVer;

    oprCode = type;

    memset(&srcAddr, 0, sizeof(SpAddr));
    memset(&dstAddr, 0, sizeof(SpAddr));

    accFillAddr(&srcAddr, &dstAddr);

    memset(&acn, 0, sizeof(MaApConName));
    memset(&altAcn, 0, sizeof(MaApConName));
    auFillAcn(type, &acn, &altAcn, &oprClass1, &maVer, LMA_VER2P);
    maAccSetOpenEvent(&openEv,&srcAddr,&dstAddr,&acn,FALSE,FALSE);

    AUACC_PRINT("AuLiMatOpenReq_______auDlgId = %ld maDlgId = %ld\n",
            auDlgId, maDlgId);

    AuLiMatOpenReq(&(dlgQueue->auPst), spId, auDlgId, maDlgId, &openEv);

    dsmState = AU_WF_DLG_CFM;

    RETVALUE(ROK);
}

/*---------------------- Class Dialog_Queue ------------------------------*/
Dialog_Queue::Dialog_Queue()
{
#ifdef _MULTI_THREAD
    pthread_mutex_init(&Lock, NULL);
#endif

    minDlgId = MIN_AU_DLG_ID;
    maxDlgId = MAX_AU_DLG_ID;
    maxDlgNum = MAX_DLG_NUM;
    actDlgNum = 0;
    auDlgIdPool = minDlgId - 1;

    bitMapInit();
    dlgQueueInit();

    /* Initialize the Post Structure For Sending Requests to MAP from AU */
#ifdef LCAULIMAT
    auPst.selector  = AU_SEL_LC;
#else
    auPst.selector  = AU_SEL_TC;
#endif
    auPst.region    = AU_REG;
    auPst.pool  = AU_POOL;
    auPst.prior = PRIOR2;
    auPst.route = RTESPEC;
    auPst.dstProcId = SFndProcId(); /* mod by anders 2004-01-16 */
    auPst.dstEnt    = ENTMA;
    /* Arthur yin added, map INst shall be determined by macro */
    auPst.dstInst   = MA_INST_0;
    auPst.srcProcId = SFndProcId();
    auPst.srcEnt    = ENTAU;
    auPst.srcInst   = AU_INST_0;

    dlgIdGenSucNum = 0;
    dlgIdGenFalNum = 0;
    dlgGenSucNum = 0;
    dlgGenFalNum = 0;

}

Dialog_Queue::~Dialog_Queue()
{
    bitMapFree();
#ifdef _MULTI_THREAD
    pthread_mutex_destroy(&Lock);
#endif

}

/*
 * Function name: dlgQueueInit
 * Des:           Initial the Dialog Queue
 * Return Value : ROK or RFAILED
 */
S16 Dialog_Queue::dlgQueueInit()
{
    S16     i;

#ifdef _MULTI_THREAD
    pthread_mutex_lock(&Lock);
#endif

    for (i = 0; i < AU_HASH_SIZE; i++)
    {
        auDlgQueue[i] = NULLP;
    }

#ifdef _MULTI_THREAD
    pthread_mutex_unlock(&Lock);
#endif

    RETVALUE(ROK);
}

/*
 * Function name: bitMapInit
 * Des:           Initial the bit Map
 * Return Value : ROK or RFAILED
 */
S16 Dialog_Queue::bitMapInit()
{