transport.c

基于h323协议的软phone

    /* start the network TPKT module */

    /* for each session there is one Q.931 connecting socket and two H.245 sockets,
       one for listenning and one for connecting. The extra TPKT element is for
       the Q.931 listenning socket.
       Note: We may statisticaly allocate less TPKT elements since simultaneous
             listen and connect in H.245 is rare */
    transGlobals->tpktCntrl = tpktInit((HAPP)hAppATrans, selEngine, numOfSessions * 3 + 1, portRange);
    if (transGlobals->tpktCntrl == NULL)
    {
        RvLogError(&transGlobals->hLog,
            (&transGlobals->hLog, "Transport layer can't open TPKT package."));

        /* release all */
        cmTransEnd( (HAPPTRANS)transGlobals );

        return NULL;
    }

    /* create timers pool (one for annex E and one for each zero-timer of a session) */
    transGlobals->hTimers = RvH323TimerConstruct(numOfSessions * 2, NULL);
    status = RvWatchdogAddResource(cmiGetWatchdogHandle((HAPP)hAppATrans), "TransportTimers", "Transport", "Host elements",
        (RvWatchdogResourceCallback_T)transWatchdogResourceCallback,(void*)transGlobals, &transGlobals->timersResourceVal);
    if ((transGlobals->hTimers == NULL) || (status < 0))
    {
         RvLogError(&transGlobals->hLog,
             (&transGlobals->hLog, "Transport layer can't allocate timers."));

        /* release all */
        cmTransEnd( (HAPPTRANS)transGlobals );

        return NULL;
    }

    /* start the network annex E module */
    if (annexESupported)
    {
        transGlobals->annexESupported = RV_TRUE;

        eStat = annexEInit(&(transGlobals->annexECntrl),
                          (HAPPANNEXE)transGlobals,
                          numOfSessions,
                          maxMessageSize,
                          numOfSessions,
                          transGlobals->hTimers,
                          selEngine,
                          portRange);

        if (eStat != annexEStatusNormal)
        {
            RvLogError(&transGlobals->hLog,
                (&transGlobals->hLog, "Transport layer can't open Annex E package."));

            /* release all */
            cmTransEnd( (HAPPTRANS)transGlobals );

            return NULL;
       }
       else
       {
         annexEEvents annexEEventHandlers = {   NULL /*annexEEvRestart*/,
                                                annexEEvNewMessage,
                                                annexEEvConnectionBroken,
                                                annexEEvUseOtherAddress,
                                                NULL /*annexEEvNotSupported*/,
                                                annexEEvWriteable
                                            };

         eStat = annexESetEventHandler(transGlobals->annexECntrl,
                                       &annexEEventHandlers);
         if (eStat != annexEStatusNormal)
         {
             RvLogError(&transGlobals->hLog,
                 (&transGlobals->hLog, "Transport layer can't set Annex E callbacks."));
         }
       }
    }
    else
        transGlobals->annexESupported = RV_FALSE;

    /* create syntax trees for decoding routines */
    transGlobals->synProtQ931 = pstConstruct(q931asn1GetSyntax(), (char *)"Q931Message");
    transGlobals->synProtH245 = pstConstruct(h245GetSyntax(), (char *)"MultimediaSystemControlMessage");
    transGlobals->synProtH450 = pstConstruct(q931asn1GetSyntax(),
                   (char *)"Q931Message.message.setup.userUser.h323-UserInformation.h323-uu-pdu.h4501SupplementaryService");

    /* return the handle to the module global element */
    RvLogInfo(&transGlobals->hLog,
             (&transGlobals->hLog, "Transport layer initialized. hAppTrans=%p",transGlobals));
    return (HAPPTRANS)transGlobals;
}

/**************************************************************************************
 * cmTransStart
 *
 * Purpose: To start the listenning process on TPKT and/or Annex E
 *
 * Input:   happTrans               - The handle to the instance of the transport module.
 *          TPKTcallSignalingAddr   - The TPKT Q.931 listenning address.
 *          annexEcallSignalingAddr - The annex E address.
 *          localIPAddress          - The local IP address as was received from the config.
 *
 * Output:  None.
 *
 * Returned value: cmTransOK - if success; cmTransErr - otherwise
 *
 **************************************************************************************/
TRANSERR cmTransStart(IN HAPPTRANS happTrans,
                      IN cmTransportAddress *TPKTcallSignalingAddr,
                      IN cmTransportAddress *annexEcallSignalingAddr,
                      IN int                localIPAddress,
                      IN CMTRANSANNEXEPARAM *cmTransAnnexEParam)
{
    cmTransGlobals *transGlobals = (cmTransGlobals *)happTrans;
    TRANSERR        reply = cmTransOK;

    if (!transGlobals)
        return cmTransErr;

    /* lock the module */
    RvMutexLock(&transGlobals->lockSessionsList);

    /* save the local IP into the global area */
    transGlobals->localIPAddress = localIPAddress;

    /* start the listenning process for TPKT */
    if (TPKTcallSignalingAddr->type != -1)
    {
        transGlobals->hTPKTListen = (cmTransHost *)emaAdd(transGlobals->hEmaHosts, NULL);

        if (transGlobals->hTPKTListen)
        {
            memset(transGlobals->hTPKTListen, 0, sizeof(cmTransHost));
            if (!TPKTcallSignalingAddr->ip)
                TPKTcallSignalingAddr->ip = transGlobals->localIPAddress;

            if (transGlobals->hostEventHandlers.cmEvTransHostListen)
            {
                RvLogInfo(&transGlobals->hLog,
                    (&transGlobals->hLog, "cmEvTransHostListen(hsHost = %d(%p), haHost=NULL, type=cmTransQ931Conn, address = (ip:%x,port:%d))",
                        emaGetIndex((EMAElement)transGlobals->hTPKTListen), transGlobals->hTPKTListen,
                        TPKTcallSignalingAddr->ip, TPKTcallSignalingAddr->port));

                reply = transGlobals->hostEventHandlers.cmEvTransHostListen(
                                        (HSTRANSHOST)transGlobals->hTPKTListen,
                                        NULL,
                                        cmTransQ931Conn,
                                        TPKTcallSignalingAddr);
                transGlobals->hTPKTListen->reported = RV_TRUE;
            }

            /* if user rejected the listen */
            if (reply == cmTransIgnoreMessage)
            {
                closeHostInternal((HSTRANSHOST)transGlobals->hTPKTListen, RV_TRUE);
                transGlobals->hTPKTListen = NULL;

                RvLogInfo(&transGlobals->hLog,
                    (&transGlobals->hLog, "cmTransStart initiate listen on TPKT refused by user"));
            }
            else
            {
                transGlobals->hTPKTListen->hTpkt =
                    tpktOpen(transGlobals->tpktCntrl,
                             TPKTcallSignalingAddr,
                             RvH323ConnectionQ931,
                             tpktMultiServer,
                             transQ931AcceptHandler,
                             (void *)transGlobals);

                /* if listenning started OK, get the allocated address for listen */
                if (transGlobals->hTPKTListen->hTpkt)
                    getGoodAddress(transGlobals, transGlobals->hTPKTListen->hTpkt, NULL, cmTransQ931Conn, TPKTcallSignalingAddr);


                /* report that the listen started (or failed) */
                if (transGlobals->hostEventHandlers.cmEvTransHostListening)
                {
                    int numOfLocks;
                    RvLogInfo(&transGlobals->hLog,
                        (&transGlobals->hLog, "cmEvTransHostListening(hsHost = %d(%p), haHost=NULL, type=cmTransQ931Conn, address = (ip:%x,port:%d), error=%d)",
                            emaGetIndex((EMAElement)transGlobals->hTPKTListen), transGlobals->hTPKTListen,
                            TPKTcallSignalingAddr->ip, TPKTcallSignalingAddr->port,
                            (transGlobals->hTPKTListen->hTpkt == NULL)));

                    emaLock((EMAElement)transGlobals->hTPKTListen);
                    numOfLocks = emaPrepareForCallback((EMAElement)transGlobals->hTPKTListen);
                    transGlobals->hostEventHandlers.cmEvTransHostListening(
                                            (HSTRANSHOST)transGlobals->hTPKTListen,
                                            NULL,
                                            cmTransQ931Conn,
                                            TPKTcallSignalingAddr,
                                            (transGlobals->hTPKTListen->hTpkt == NULL));
                    emaReturnFromCallback((EMAElement)transGlobals->hTPKTListen, numOfLocks);
                    emaUnlock((EMAElement)transGlobals->hTPKTListen);
                    transGlobals->hTPKTListen->reported = RV_TRUE;
                }

                /* if we had an error starting the listenning, call the whole thing off */
                if ( !(transGlobals->hTPKTListen->hTpkt) )
                {
                    closeHostInternal((HSTRANSHOST)transGlobals->hTPKTListen, RV_TRUE);
                    transGlobals->hTPKTListen = NULL;

                    RvMutexUnlock(&transGlobals->lockSessionsList);
                    RvLogError(&transGlobals->hLog,
                        (&transGlobals->hLog, "cmTransStart failed to initiate listen on TPKT"));
                    return cmTransErr;
                }
            }
        }
    }

    /* set the annex E parameters */
    if (transGlobals->annexESupported)
    {
        annexEStatus eStat;

        eStat = annexESetProtocolParams(transGlobals->annexECntrl,
                                        (int)cmTransAnnexEParam->t_R1,
                                        (int)cmTransAnnexEParam->t_R2,
                                        (int)cmTransAnnexEParam->n_R1,
                                        (int)cmTransAnnexEParam->t_IMA1,
                                        (int)cmTransAnnexEParam->n_IMA1,
                                        (int)cmTransAnnexEParam->t_DT);

        if (eStat != annexEStatusNormal)
        {
            RvMutexUnlock(&transGlobals->lockSessionsList);
            RvLogError(&transGlobals->hLog,
                (&transGlobals->hLog,
                     "cmTransStart failed to set annex E protocol params eStat=%d", eStat));
            return cmTransErr;
        }
    }


    /* Start the annex E "listenning" process (openning the UDP socket on the given address) */
    if ( (transGlobals->annexESupported) && (annexEcallSignalingAddr->type != -1) )
    {
        annexEStatus eStat = annexESetLocalAddress(transGlobals->annexECntrl, annexEcallSignalingAddr);
        if (eStat != annexEStatusNormal)
        {
            RvMutexUnlock(&transGlobals->lockSessionsList);
            RvLogError(&transGlobals->hLog,
                (&transGlobals->hLog,
                     "cmTransStart failed to set Local address for annex E eStat=%d", eStat));
            return cmTransErr;
        }

        eStat = annexEStart(transGlobals->annexECntrl);
        if (eStat != annexEStatusNormal)
        {
            RvMutexUnlock(&transGlobals->lockSessionsList);
            RvLogError(&transGlobals->hLog,
                (&transGlobals->hLog, "cmTransStart failed annexEStart eStat=%d", eStat));
            return cmTransErr;
        }

        eStat = annexEGetLocalAddress(transGlobals->annexECntrl, annexEcallSignalingAddr);
        if (eStat != annexEStatusNormal)
        {
            RvMutexUnlock(&transGlobals->lockSessionsList);
            RvLogError(&transGlobals->hLog,
                (&transGlobals->hLog, "cmTransStart failed annexEGetLocalAddress eStat=%d", eStat));
            return cmTransErr;
        }
    }

    RvMutexUnlock(&transGlobals->lockSessionsList);

    return cmTransOK;
}

/**************************************************************************************
 * cmTransStop
 *
 * Purpose: Stops all the listenning processes that were started by cmTransStart.
 *
 * Input:   hAppTrans - A handle to the entire transport module
 *
 * Output:  None.
 *
 **************************************************************************************/
TRANSERR cmTransStop(IN HAPPTRANS hAppTrans)
{
    cmTransGlobals *transGlobals = (cmTransGlobals *)hAppTrans;

    if (!transGlobals)
        return cmTransErr;

    /* lock the module */
    RvMutexLock(&transGlobals->lockSessionsList);

    /* close the listenning process of TPKT for Q.931 connections */
    if (transGlobals->hTPKTListen)
    {
        closeHostInternal((HSTRANSHOST)transGlobals->hTPKTListen, RV_TRUE);
        transGlobals->hTPKTListen = NULL;
    }

    /* stop the annex E */
    if (transGlobals->annexESupported)
        annexEStop(transGlobals->annexECntrl);

    RvMutexUnlock(&transGlobals->lockSessionsList);

    return cmTransOK;
}

/**************************************************************************************
 * cmTransEnd
 *
 * Purpose: Shuts down the module and deallocates all its components.
 *
 * Input:   hAppTrans - A handle to the entire transport module
 *
 * Output:  None.
 *
 **************************************************************************************/
TRANSERR cmTransEnd(IN HAPPTRANS hAppTrans)
{

    cmTransGlobals *transGlobals = (cmTransGlobals *)hAppTrans;

    if (hAppTrans)
    {
        /* lock the module */
        RvMutexLock(&transGlobals->lockSessionsList);

        /* close the annex E package */
        if (transGlobals->annexECntrl)
            annexEEnd(transGlobals->annexECntrl);

        /* close the tpkt package */
        if (transGlobals->tpktCntrl)
            tpktEnd(transGlobals->tpktCntrl);

        /* release the messages rPool */
        if (transGlobals->messagesRPool)
            rpoolDestruct(transGlobals->messagesRPool);