sipxtapiinternal.cpp

基于sipfoundy 公司开发的sipx协议API

        case SipSubscribeClient::SUBSCRIPTION_SETUP:     // Established dialog
            pInfo.state = SIPX_SUBSCRIPTION_ACTIVE;
            break;

        case SipSubscribeClient::SUBSCRIPTION_FAILED:    // Failed dialog setup or refresh
            // Could potentially differentiate between failed active
            // and failed expired based upon the expiration and the 
            // current time
            pInfo.state = SIPX_SUBSCRIPTION_FAILED;
            break;

        case SipSubscribeClient::SUBSCRIPTION_TERMINATED:
            pInfo.state = SIPX_SUBSCRIPTION_EXPIRED;
            break;

        case SipSubscribeClient::SUBSCRIPTION_UNKNOWN:
            errorState = "SUBSCRIPTION_UNKNOWN";
            pInfo.state = SIPX_SUBSCRIPTION_FAILED;
            break;

        default:
            {
                pInfo.state = SIPX_SUBSCRIPTION_FAILED;
                errorState ="unknown: ";
                char numBuf[20];
                sprintf(numBuf, "%d", newState);
                errorState.append(numBuf);
            }
            break;
        }

        // If the dialog changed from and early dialog to an 
        // established dialog, update the dialog handle in the
        // subcription data structure
        if(earlyDialogHandle && dialogHandle && 
            SipDialog::isEarlyDialog(*subscriptionData->pDialogHandle))
        {
            *(subscriptionData->pDialogHandle) = dialogHandle;
        }

        // Fire the event if it is a supported state change
        if(errorState.isNull())
        {
            sipxFireEvent(subscriptionData->pInst->pCallManager, 
                       EVENT_CATEGORY_SUB_STATUS, 
                       &pInfo);
        }
        else
        {
            OsSysLog::add(FAC_SIPXTAPI, PRI_ERR,
                "sipxSubscribeClientSubCallback: invalid SubscriptionState: %s",
                errorState.data());
        }
    }

    // Cannot find subsription data for this handle
    else
    {
        OsSysLog::add(FAC_SIPXTAPI, PRI_ERR,
            "sipxSubscribeClientSubCallback: cannot find subscription data for handle: %p",
            applicationData);
    }
}


void sipxSubscribeClientNotifyCallback(const char* earlyDialogHandle,
                                     const char* dialogHandle,
                                     void* applicationData,
                                     const SipMessage* notifyRequest)
{
    SIPX_SUB subscriptionHandle = (SIPX_SUB)applicationData;
    SIPX_SUBSCRIPTION_DATA* subscriptionData = 
        (SIPX_SUBSCRIPTION_DATA*) gpSubHandleMap->findHandle(subscriptionHandle);

    if(subscriptionData && subscriptionData->pInst)
    {
        SIPX_NOTIFY_INFO pInfo;
        UtlString userAgent;
        UtlString contentType;
        const HttpBody* contentBody = NULL;
        int bodyLength = 0;
        const char* bodyBytes = NULL;

        // If the dialog changed from and early dialog to an 
        // established dialog, update the dialog handle in the
        // subcription data structure
        if(earlyDialogHandle && dialogHandle && 
            SipDialog::isEarlyDialog(*subscriptionData->pDialogHandle))
        {
            *(subscriptionData->pDialogHandle) = dialogHandle;
        }

        if(notifyRequest)
        {
            notifyRequest->getUserAgentField(&userAgent);
            notifyRequest->getContentType(&contentType);
            contentBody = notifyRequest->getBody();

            if(contentBody)
            {
                contentBody->getBytes(&bodyBytes, &bodyLength);
            }
        }

        pInfo.nSize = sizeof(SIPX_NOTIFY_INFO);
        pInfo.hSub = (SIPX_SUB) applicationData;
        pInfo.szNotiferUserAgent = userAgent;
        pInfo.nContentLength = bodyLength;
        pInfo.pContent = bodyBytes;
        pInfo.szContentType = contentType;
        
        sipxFireEvent(subscriptionData->pInst->pCallManager, 
           EVENT_CATEGORY_NOTIFY, 
           &pInfo);

    }

    // No data for the subscription handle
    else
    {
        OsSysLog::add(FAC_SIPXTAPI, PRI_ERR,
            "sipxSubscribeClientNotifyCallback: cannot find subscription data for handle: %p",
            applicationData);
    }
}

void sipxLineReleaseLock(SIPX_LINE_DATA* pData, SIPX_LOCK_TYPE type) 
{
    if ((type != SIPX_LOCK_NONE) && validLineData(pData))
    {
        switch (type)
        {
            case SIPX_LOCK_READ:
                // TODO: What happens if this fails?
                pData->pMutex->releaseRead() ;
                break ;
            case SIPX_LOCK_WRITE:
                // TODO: What happens if this fails?
                pData->pMutex->releaseWrite() ;
                break ;
        }
    }
}


void sipxInfoReleaseLock(SIPX_INFO_DATA* pData, SIPX_LOCK_TYPE type) 
{
    if (type != SIPX_LOCK_NONE)
    {
        switch (type)
        {
            case SIPX_LOCK_READ:
                // TODO: What happens if this fails?
                pData->pMutex->releaseRead() ;
                break ;
            case SIPX_LOCK_WRITE:
                // TODO: What happens if this fails?
                pData->pMutex->releaseWrite() ;
                break ;
        }
    }
}

UtlBoolean validLineData(const SIPX_LINE_DATA* pData) 
{
    UtlBoolean bValid = FALSE ;

    if (pData && pData->lineURI && pData->pInst && 
            pData->pInst->pCallManager && pData->pMutex)
    {
        bValid = TRUE ;
    }

    return bValid ;
}


void sipxLineObjectFree(const SIPX_LINE hLine)
{
    SIPX_LINE_DATA* pData = sipxLineLookup(hLine, SIPX_LOCK_WRITE) ;
    
    if (pData)
    {
        pData->pInst->pLock->acquire() ;
        pData->pInst->nLines-- ;
        assert(pData->pInst->nLines >= 0) ;
        pData->pInst->pLock->release() ;

        const void* pRC = gpLineHandleMap->removeHandle(hLine); 
        if (pRC)
        {            
            if (pData->lineURI)
            {
                delete pData->lineURI ;
            }

            if (pData->pMutex)
            {
                delete pData->pMutex ;
            }

            if (pData->pLineAliases)
            {
                UtlVoidPtr* pValue ;
                while (pValue = (UtlVoidPtr*) pData->pLineAliases->get())
                {
                    Url* pUri = (Url*) pValue->getValue() ;
                    if (pUri)
                    {
                        delete pUri ;
                    }
                    delete pValue ;
                }
            }

            delete pData ;
        }
        else
        {
            sipxLineReleaseLock(pData, SIPX_LOCK_WRITE) ;
        }
    }
}



void sipxInfoObjectFree(SIPX_INFO hInfo)
{

    SIPX_INFO_DATA* pData = sipxInfoLookup(hInfo, SIPX_LOCK_WRITE) ;
    
    if (pData)
    {
        const void* pRC = gpInfoHandleMap->removeHandle(hInfo); 
        if (pRC)
        {
            sipxInfoFree(pData) ;   
        }
        else
        {
            sipxInfoReleaseLock(pData, SIPX_LOCK_WRITE) ;
        }
    }
}

void sipxInfoFree(SIPX_INFO_DATA* pData)
{
    if (pData)
    {
        if (pData->pMutex)
        {
            delete pData->pMutex ;
        }
        free((void*)pData->infoData.pContent);
        free((void*)pData->infoData.szContentType);
        free((void*)pData->infoData.szFromURL);
        free((void*)pData->infoData.szUserAgent);
        
        delete pData;
    }
}


SIPX_LINE sipxLineLookupHandle(const char* szURI)
{
    gpLineHandleMap->lock() ;

    UtlHashMapIterator iter(*gpLineHandleMap);
    Url                urlURI(szURI) ; 

    UtlInt* pIndex = NULL;
    UtlVoidPtr* pObj = NULL;
    SIPX_LINE hLine = SIPX_LINE_NULL ;

    // First pass: strict matching
    while ((pIndex = dynamic_cast<UtlInt*>(iter())))
    {
        pObj = dynamic_cast<UtlVoidPtr*>(gpLineHandleMap->findValue(pIndex));
        SIPX_LINE_DATA* pData = NULL ;
        if (pObj)
        {
            pData = (SIPX_LINE_DATA*) pObj->getValue() ;
            if (pData)
            {         
                // Check main line definition
                if (urlURI.isUserHostPortEqual(*pData->lineURI))
                {
                    hLine = pIndex->getValue() ;
                    break ;
                }

                // Check for line aliases
                if (pData->pLineAliases)
                {
                    UtlVoidPtr* pValue ;
                    Url* pUrl ;
                    UtlSListIterator iterator(*pData->pLineAliases) ;

                    while ((pValue = (UtlVoidPtr*) iterator()))
                    {
                        pUrl = (Url*) pValue->getValue() ;

                        if (urlURI.isUserHostPortEqual(*pUrl))
                        {
                            hLine = pIndex->getValue() ;
                            break ;
                        }
                    }
                }
            }
        }
    }

    // Second pass: Relax port
    if (hLine == SIPX_LINE_NULL)
    {
        iter.reset() ;    
        while ((pIndex = dynamic_cast<UtlInt*>(iter())))
        {
            pObj = dynamic_cast<UtlVoidPtr*>(gpLineHandleMap->findValue(pIndex));
            SIPX_LINE_DATA* pData = NULL ;
            if (pObj)
            {
                pData = (SIPX_LINE_DATA*) pObj->getValue() ;
                if (pData)
                {         
                    // Check main line definition
                    if (urlURI.isUserHostEqual(*pData->lineURI))
                    {
                        hLine = pIndex->getValue() ;
                        break ;
                    }

                    // Check for line aliases
                    if (pData->pLineAliases)
                    {
                        UtlVoidPtr* pValue ;
                        Url* pUrl ;
                        UtlSListIterator iterator(*pData->pLineAliases) ;

                        while ((pValue = (UtlVoidPtr*) iterator()))
                        {
                            pUrl = (Url*) pValue->getValue() ;

                            if (urlURI.isUserHostEqual(*pUrl))
                            {
                                hLine = pIndex->getValue() ;
                                break ;
                            }
                        }
                    }
                }
            }
        }
    }

    // Third pass: username only
    if (hLine == SIPX_LINE_NULL)
    {
        iter.reset() ;    
        while ((pIndex = dynamic_cast<UtlInt*>(iter())))
        {
            pObj = dynamic_cast<UtlVoidPtr*>(gpLineHandleMap->findValue(pIndex));
            SIPX_LINE_DATA* pData = NULL ;
            if (pObj)
            {
                pData = (SIPX_LINE_DATA*) pObj->getValue() ;
                if (pData)
                {
                    UtlString uriUsername ;
                    UtlString hostUsername ;
                                       
                    urlURI.getUserId(uriUsername) ;
                    pData->lineURI->getUserId(hostUsername) ;

                    if (uriUsername.compareTo(hostUsername, 
                            UtlString::ignoreCase) == 0)
                    {
                        hLine = pIndex->getValue() ;
                        break ;
                    }

                    // Check for line aliases
                    if (pData->pLineAliases)
                    {
                        UtlVoidPtr* pValue ;
                        Url* pUrl ;
                        UtlSListIterator iterator(*pData->pLineAliases) ;

                        while ((pValue = (UtlVoidPtr*) iterator()))
                        {
                            pUrl = (Url*) pValue->getValue() ;
                            UtlString aliasUsername ;

                            pUrl->getUserId(aliasUsername) ;

                            if (uriUsername.compareTo(aliasUsername, UtlString::ignoreCase) == 0)
                            {
                                hLine = pIndex->getValue() ;
                                break ;
                            }
                        }
                    }
                }
            }
        }
    }

    gpLineHandleMap->unlock() ;

    return hLine;
}


UtlBoolean sipxRemoveCallHandleFromConf(const SIPX_CONF hConf, 
                                        const SIPX_CALL hCall) 
{
    //
    // WARNING: This relies on outside locking
    // 


    UtlBoolean bFound = false ;
    SIPX_CONF_DATA* pConfData = (SIPX_CONF_DATA*) gpConfHandleMap->findHandle(hConf) ;
    size_t idx ;

    // First find the handle
    for (idx=0; idx < pConfData->nCalls; idx++)
    {
        if (pConfData->hCalls[idx] == hCall)
        {
            bFound = true ;
            break ; 
        }
    }

    if (bFound)
    {
        // Next step on it.
        pConfData->nCalls-- ;

        for (; idx < pConfData->nCalls; idx++)
        {
            pConfData->hCalls[idx] = pConfData->hCalls[idx+1] ;
        }

        pConfData->hCalls[pConfData->nCalls] = SIPX_CALL_NULL ;
    }

    return bFound ;
}


UtlBoolean validConfData(const SIPX_CONF_DATA* pData) 
{
    UtlBoolean bValid = FALSE ;

    if (pData && pData->pMutex)
    {
        bValid = TRUE ;
    }

    return bValid ;
}


SIPX_CONF_DATA* sipxConfLookup(const SIPX_CONF hConf, SIPX_LOCK_TYPE type)