cmgeneral.c

基于h323协议的软phone

                __pvtBuildByFieldIds(msgNodeId,app->hVal,tmpNodeId,
                    {_q931(message) _q931(information) LAST_TOKEN},0,NULL);

                tmpNodeId1=pvtAdd(app->hVal,msgNodeId,__q931(userUser),0,NULL,NULL);
                pvtAdd(app->hVal,tmpNodeId1,__q931(protocolDiscriminator),5,NULL,NULL);

                __pvtBuildByFieldIds(tmpNodeId1,app->hVal,tmpNodeId1,
                    {_q931(h323_UserInformation) _q931(h323_uu_pdu) _q931(h323_message_body) _q931(information) LAST_TOKEN},0,NULL);

                pvtAdd(app->hVal,tmpNodeId1,__q931(protocolIdentifier),length,OID,NULL);

                /* Setup Acknowledge */
                tmpNodeId=pvtAdd(app->hVal,app->appDB,__q931(setupAck),0,NULL,NULL);

                pvtAdd(app->hVal,tmpNodeId,__q931(protocolDiscriminator),8,NULL,NULL);

                __pvtBuildByFieldIds(msgNodeId,app->hVal,tmpNodeId,
                    {_q931(message) _q931(setupAck) LAST_TOKEN},0,NULL);

                tmpNodeId1=pvtAdd(app->hVal,msgNodeId,__q931(userUser),0,NULL,NULL);
                pvtAdd(app->hVal,tmpNodeId1,__q931(protocolDiscriminator),5,NULL,NULL);

                __pvtBuildByFieldIds(tmpNodeId1,app->hVal,tmpNodeId1,
                    {_q931(h323_UserInformation) _q931(h323_uu_pdu) _q931(h323_message_body) _q931(setupAcknowledge) LAST_TOKEN},0,NULL);

                pvtAdd(app->hVal,tmpNodeId1,__q931(protocolIdentifier),length,OID,NULL);

                /* Progress */
                tmpNodeId=pvtAdd(app->hVal,app->appDB,__q931(progress),0,NULL,NULL);

                pvtAdd(app->hVal,tmpNodeId,__q931(protocolDiscriminator),8,NULL,NULL);

                __pvtBuildByFieldIds(msgNodeId,app->hVal,tmpNodeId,
                    {_q931(message) _q931(progress) LAST_TOKEN},0,NULL);

                tmpNodeId1=pvtAdd(app->hVal,msgNodeId,__q931(userUser),0,NULL,NULL);
                pvtAdd(app->hVal,tmpNodeId1,__q931(protocolDiscriminator),5,NULL,NULL);

                __pvtBuildByFieldIds(tmpNodeId1,app->hVal,tmpNodeId1,
                    {_q931(h323_UserInformation) _q931(h323_uu_pdu) _q931(h323_message_body) _q931(progress) LAST_TOKEN},0,NULL);

                pvtAdd(app->hVal,tmpNodeId1,__q931(protocolIdentifier),length,OID,NULL);

                /* Notify */
                tmpNodeId=pvtAdd(app->hVal,app->appDB,__q931(notify),0,NULL,NULL);

                pvtAdd(app->hVal,tmpNodeId,__q931(protocolDiscriminator),8,NULL,NULL);

                __pvtBuildByFieldIds(msgNodeId,app->hVal,tmpNodeId,
                    {_q931(message) _q931(notify) LAST_TOKEN},0,NULL);

                tmpNodeId1=pvtAdd(app->hVal,msgNodeId,__q931(userUser),0,NULL,NULL);
                pvtAdd(app->hVal,tmpNodeId1,__q931(protocolDiscriminator),5,NULL,NULL);

                __pvtBuildByFieldIds(tmpNodeId1,app->hVal,tmpNodeId1,
                    {_q931(h323_UserInformation) _q931(h323_uu_pdu) _q931(h323_message_body) _q931(notify) LAST_TOKEN},0,NULL);

                pvtAdd(app->hVal,tmpNodeId1,__q931(protocolIdentifier),length,OID,NULL);

                cmiRASUpdateCallSignalingAddress(app->rasManager,app->q931Chan, app->q931AnnexEChan);
            }

            /* Set the intial CRV of the application to a random value */
            {
                RvRandom randomValue;
                cmLock(hApp);
                RvRandomGeneratorGetValue(&app->randomGenerator, &randomValue);
                app->crv = (int)randomValue % 32767;
                cmUnlock(hApp);
            }
            /* Initialize RAS */
            rv = rasStart(app);

            app->postControlDisconnectionDelay=2000;
            pvtGet(app->hVal,pvtGetChild(app->hVal,app->q931Conf,__q931(postControlDisconnectionDelay),NULL),NULL,NULL,&app->postControlDisconnectionDelay,NULL);


            /* Initialize H245 */
            cmH245Start(hApp);

            /* We're done */
            app->start=RV_TRUE;
        }
    }
    cmiAPIExit(hApp, "cmStart=%d", rv);
    return rv;
}


/************************************************************************
 * cmStop
 * purpose: Stops the stack's activity
 *
 *          After the Stack is stopped by cmStop(), the application may change
 *          configuration settings and then use cmStart() to start Stack
 *          activity again.
 *
 * input  : hApp    - Stack handle for the application
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmStop(
        IN  HAPP        hApp)
{
    cmElem* app=(cmElem*)hApp;
    if (!app)
        return RV_ERROR_UNKNOWN;

    cmiAPIEnter(hApp, "cmStop(hApp=0x%p)", app);

    if (app->start)
    {
        /* Stop our internal modules */
        rasStop(app);
        cmH245Stop(hApp);
        cmTransStop(app->hTransport);

        /* Make sure we don't leave any un-needed PVT nodes */
        if(RV_PVT_NODEID_IS_VALID(app->q931Chan))
        {
            pvtDelete(app->hVal, app->q931Chan);
            app->q931Chan = RV_PVT_INVALID_NODEID;
        }
        if(RV_PVT_NODEID_IS_VALID(app->appDB))
        {
            pvtDelete(app->hVal, app->appDB);
            app->appDB = RV_PVT_INVALID_NODEID;
        }
        if (RV_PVT_NODEID_IS_VALID(app->q931AnnexEChan))
        {
            pvtDelete(app->hVal, app->q931AnnexEChan);
            app->q931AnnexEChan = RV_PVT_INVALID_NODEID;
        }

        /* Indicate that we've stopped */
        app->start = RV_FALSE;
    }

    cmiAPIExit(hApp, "cmStop=0");
    return 0;
}

/************************************************************************
 * cmEnd
 * purpose: Shuts down the Conference Manager instance and releases all
 *          resources that were in use by the Conference Manager instance.
 * input  : hApp    - Stack handle for the application
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 * notes  : cmEnd() must be called from the same thread that called cmInitialize().
 ************************************************************************/
RVAPI
int RVCALLCONV cmEnd(
        IN   HAPP        hApp)
{
    cmElem* app=(cmElem*)hApp;
    RvMutexLock(&rvCmGlobalMutex);

    if (app)
    {
        /* Stop and close the watchdog */
        RvH323TimerCancel(cmGetTimersHandle(hApp), &app->watchdogTimer);

        cmStop(hApp);

        /* Make sure to print the last watchdog resources now, after the CM is stopped */
        RvLogDebug(&app->logWatchdog, (&app->logWatchdog,
            "Resources at beginning of cmEnd():"));
        RvWatchdogPrint(&app->watchdog, &app->logWatchdog);

        cmTransEnd(app->hTransport);
        cmiEndChannels(app->hChannels);
        cmiEndCalls(app->hCalls);
        RvH323TimerDestruct(app->hTimers);
        configTreesEnd(app);
        rasEnd(app);
        ciDestruct(app->hCfg);
        catDestruct(app->hCat);
        fastStartEnd(app);
        endPVT_PST(app);
        perDestruct();
	 if (app->portRange != NULL)
        {
            RvPortRangeDestruct(app->portRange);
            RvMemoryFree(app->portRange);
        }
        mibDestroyStatistic(app->hStatistic);
        RvH323UniqueIdGeneratorDestruct(app->guidGenerator);
        RvRandomGeneratorDestruct(&app->randomGenerator);
        RvWatchdogEnd(&app->watchdog);

        seliEnd();
        RvLockDestruct(&app->appLock);
        RvMutexDestruct(&app->applicationLock);
        RvMemoryFree(app);
    }

    encodeDecodeBufferEnd();
    msClose();

    RvMutexUnlock(&rvCmGlobalMutex);

    cmShutdown();

    return RV_OK;
}


/************************************************************************
 * cmGetVersion
 * purpose: Returns the version of the Conference Manager in use.
 * input  : none
 * output : none
 * return : Pointer to the string representing the version of the
 *          Conference Manager. For example, "3.0.0.0" or "2.5".
 ************************************************************************/
RVAPI
char* RVCALLCONV cmGetVersion(void)
{
    return (char*)RV_H323_STACK_VERSION;
}


/************************************************************************
 * cmGetVersionName
 * purpose: Returns the version of the Conference Manager in use.
 * input  : buff    - Buffer to set the version in
 *          length  - Maximum length of the buffer in bytes
 * output : none
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
RVAPI
int RVCALLCONV cmGetVersionName(
        IN    char*   buff,
        IN    int     length)
{
    strncpy(buff, RV_H323_STACK_VERSION, (RvSize_t)length);
    return 0;
}


RVAPI
int RVCALLCONV cmSetGenEventHandler(
                              IN    HAPP    hApp,
                              IN    CMEVENT cmEvent,
                              IN    int     size)
{
    cmElem* app=(cmElem*)hApp;
    if (hApp == NULL) return RV_ERROR_UNKNOWN;

    cmiAPIEnter(hApp, "cmSetGenEventHandler(hApp=0x%p,cmEvent,size=%d)", hApp, size);
    memset(&app->cmMyEvent, 0, sizeof(app->cmMyEvent));
    memcpy(&app->cmMyEvent, cmEvent, (RvSize_t)RvMin((int)sizeof(app->cmMyEvent), size));
    cmiAPIExit(hApp, "cmSetGenEventHandler=0");
    return 0;
}

RVAPI
int RVCALLCONV cmGetGenEventHandler(
                              IN    HAPP    hApp,
                              OUT   CMEVENT cmEvent,
                              IN    int     size)
{
    cmElem* app=(cmElem*)hApp;
    if (hApp == NULL) return RV_ERROR_UNKNOWN;

    cmiAPIEnter(hApp, "cmGetGenEventHandler(hApp=0x%p,cmEvent,size=%d)", hApp, size);
    memset(cmEvent,0, (RvSize_t)size);
    memcpy(cmEvent, &app->cmMyEvent, (RvSize_t)RvMin((int)sizeof(app->cmMyEvent), size));
    cmiAPIExit(hApp, "cmGetGenEventHandler=0");

    return 0;

}


RVAPI
int RVCALLCONV cmSetCallEventHandler(
                                   IN   HAPP        hApp,
                                   IN   CMCALLEVENT cmCallEvent,
                                   IN   int     size)
{
    cmElem* app=(cmElem*)hApp;
    if (hApp == NULL) return RV_ERROR_UNKNOWN;

    cmiAPIEnter(hApp, "cmSetCallEventHandler(hApp=0x%p,cmCallEvent,size=%d)", hApp, size);
    memset(&app->cmMyCallEvent, 0, sizeof(app->cmMyCallEvent));
    memcpy(&app->cmMyCallEvent, cmCallEvent, (RvSize_t)RvMin((int)sizeof(app->cmMyCallEvent), size));
    cmiAPIExit(hApp, "cmSetCallEventHandler=0");
    return 0;
}



RVAPI
int RVCALLCONV cmGetCallEventHandler(
                                   IN      HAPP        hApp,
                                   OUT     CMCALLEVENT cmCallEvent,
                                   INOUT   int         size)
{
    cmElem* app=(cmElem*)hApp;
    if (hApp == NULL) return RV_ERROR_UNKNOWN;

    cmiAPIEnter(hApp, "cmGetCallEventHandler(hApp=0x%p,cmCallEvent,size=%d)", hApp, size);
    memset(cmCallEvent, 0, (RvSize_t)size);
    memcpy(cmCallEvent, &app->cmMyCallEvent, (RvSize_t)RvMin((int)sizeof(app->cmMyCallEvent), size));
    cmiAPIExit(hApp, "cmGetCallEventHandler=0");

    return RV_OK;

}


RVAPI int RVCALLCONV /* Real number of channels in configuration or RV_ERROR_UNKNOWN */
cmGetConfigChannels(
/* build array containing the channel names as appear in
the configuration. The strings are copied into array elements */
                    IN  HAPP        hApp,
                    IN  int         arraySize,
                    IN  int         elementLength, /* sizeof each string in array */
                    OUT char*       array[] /* allocated wit