ospusageind.c

mgcp协议源代码。支持多种编码：g711

    return(ospvAltInfoSize);
}

#endif /* OSPC_DEBUG */

/**/
/*-----------------------------------------------------------------------*
 * OSPPUsageIndSetComponentId() - creates space and copies in the string.
 *-----------------------------------------------------------------------*/
void      
OSPPUsageIndSetComponentId(
    OSPTUSAGEIND  *ospvUsageInd,    /* In - pointer to Usage Indication struct */
    unsigned char *ospvComponentId  /* In - pointer to component id string */
    )
{
    int len = OSPM_STRLEN((const char *)ospvComponentId);

    if(ospvUsageInd != OSPC_OSNULL)
    {
        if(ospvUsageInd->ospmUsageIndComponentId != OSPC_OSNULL)
        {
            OSPM_FREE(ospvUsageInd->ospmUsageIndComponentId);    
        }

        OSPM_MALLOC(ospvUsageInd->ospmUsageIndComponentId, unsigned char, len + 1);
        OSPM_MEMSET(ospvUsageInd->ospmUsageIndComponentId, 0, len + 1);
        OSPM_MEMCPY(ospvUsageInd->ospmUsageIndComponentId, ospvComponentId, len);
    }

    return;
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPUsageIndMoveSourceAlt() - move the source alt list from list
 *-----------------------------------------------------------------------*/
void                                /* nothing returned */
OSPPUsageIndMoveSourceAlt(
    OSPTUSAGEIND *ospvUsageInd,     /* usage indication to set */
    OSPTLIST     *ospvList          /* list to move */
    )
{
    if((ospvUsageInd != OSPC_OSNULL) &&
        (ospvList != OSPC_OSNULL))
    {

        OSPPListNew(&(ospvUsageInd->ospmUsageIndSourceAlternate));

        OSPPListMove(&(ospvUsageInd->ospmUsageIndSourceAlternate),
            ospvList);
    }

    return;
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPUsageIndCopySourceAlt() - Copy the source alt list
 *-----------------------------------------------------------------------*/
void                                /* nothing returned */
OSPPUsageIndCopySourceAlt(
    OSPTUSAGEIND *ospvUsageInd,     /* usage indication to set */
    OSPTLIST     *ospvList          /* list to move */
    )
{
    OSPTALTINFO *altinfo1    = OSPC_OSNULL,
        *altinfo2    = OSPC_OSNULL;

    if((ospvUsageInd != OSPC_OSNULL) &&
        (ospvList != OSPC_OSNULL))
    {

        OSPPListNew(&(ospvUsageInd->ospmUsageIndSourceAlternate));


        for(altinfo1 = (OSPTALTINFO *)OSPPListFirst(ospvList);
            altinfo1 != OSPC_OSNULL;
            altinfo1 = (OSPTALTINFO *)OSPPListNext(ospvList, altinfo1))
        {

            altinfo2 = OSPPAltInfoNew(OSPPAltInfoGetSize(altinfo1),
                OSPPAltInfoGetValue(altinfo1),
                OSPPAltInfoGetType(altinfo1));
            if(altinfo2 != OSPC_OSNULL)
            {
                OSPPListAppend(&(ospvUsageInd)->ospmUsageIndSourceAlternate, altinfo2);
            }
            altinfo2 = OSPC_OSNULL;
        }
    }

    if(altinfo2 != OSPC_OSNULL)
    {
        OSPPAltInfoDelete(&altinfo2);
    }

    return;
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPUsageIndMoveDestinationAlt() - move the destination alt list from 
 * a list
 *-----------------------------------------------------------------------*/
void                                /* nothing returned */
OSPPUsageIndMoveDestinationAlt(
    OSPTUSAGEIND *ospvUsageInd,     /* usage indication to set */
    OSPTLIST     *ospvList          /* list to move */
    )
{
    if((ospvUsageInd != OSPC_OSNULL) &&
        (ospvList != OSPC_OSNULL))
    {

        OSPPListNew(&(ospvUsageInd->ospmUsageIndDestinationAlternate));

        OSPPListMove(&(ospvUsageInd->ospmUsageIndDestinationAlternate),
            ospvList);
    }

    return;
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPUsageIndNew() - creates a new (empty) usage indication
 *-----------------------------------------------------------------------*/
OSPTUSAGEIND *                                 /* returns pointer or NULL */
    OSPPUsageIndNew()
{
    OSPTUSAGEIND *ospvUsageInd = OSPC_OSNULL;

    OSPM_MALLOC(ospvUsageInd, OSPTUSAGEIND,sizeof(OSPTUSAGEIND));
    if (ospvUsageInd != OSPC_OSNULL)
    {
        OSPM_MEMSET(ospvUsageInd, 0, sizeof(OSPTUSAGEIND));

        OSPPListLinkNew (&(ospvUsageInd->ospmUsageIndLink));
        ospvUsageInd->ospmUsageIndTimestamp = (OSPTTIME)0;
        ospvUsageInd->ospmUsageIndTransactionId = (OSPTTRXID)OSPC_OSNULL;
        ospvUsageInd->ospmUsageIndCallId = (OSPTCALLID *)OSPC_OSNULL;
        ospvUsageInd->ospmUsageIndSourceNumber[0] = '\0';
        ospvUsageInd->ospmUsageIndDestNumber[0] = '\0';
        ospvUsageInd->ospmUsageIndDuration   = -1;
        ospvUsageInd->ospmUsageIndTNCustId   = 0L;
        ospvUsageInd->ospmUsageIndTNDeviceId = 0L;
        ospvUsageInd->ospmUsageIndTNFailReasonInd = 0;
        OSPPListNew (&(ospvUsageInd->ospmUsageIndSourceAlternate));
        OSPPListNew(&(ospvUsageInd->ospmUsageIndDestinationAlternate));
        ospvUsageInd->ospmUsageIndTNStats = OSPC_OSNULL;
        ospvUsageInd->ospmUsageIndComponentId = OSPC_OSNULL;
        ospvUsageInd->ospmUsageIndMessageId = OSPC_OSNULL;
    }

    return ospvUsageInd;
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPUsageIndDelete() - deletes a usage indication
 *-----------------------------------------------------------------------*/
void
OSPPUsageIndDelete(OSPTUSAGEIND **ospvUsageInd)
{
    OSPTALTINFO     *altinfo    = OSPC_OSNULL;

    if (*ospvUsageInd)
    {
        if (OSPPUsageIndHasCallId(*ospvUsageInd))
        {
            OSPPCallIdDelete(&((*ospvUsageInd)->ospmUsageIndCallId));
        }

        if(OSPPUsageIndHasComponentId(*ospvUsageInd))
        {
            OSPM_FREE((*ospvUsageInd)->ospmUsageIndComponentId);
        }

        while(!OSPPListEmpty(&((*ospvUsageInd)->ospmUsageIndSourceAlternate)))
        {
            altinfo = (OSPTALTINFO *)OSPPListRemove(&((*ospvUsageInd)->ospmUsageIndSourceAlternate));
            OSPM_FREE(altinfo);
            altinfo = OSPC_OSNULL;
        }  

        OSPPListDelete(&((*ospvUsageInd)->ospmUsageIndSourceAlternate));

        while(!OSPPListEmpty(&((*ospvUsageInd)->ospmUsageIndDestinationAlternate)))
        {
            altinfo = (OSPTALTINFO *)OSPPListRemove(&((*ospvUsageInd)->ospmUsageIndDestinationAlternate));
            OSPM_FREE(altinfo);
            altinfo = OSPC_OSNULL;
        }

        if(OSPPUsageIndHasTNStatistics(*ospvUsageInd))
        {
            OSPPStatisticsDelete(&((*ospvUsageInd)->ospmUsageIndTNStats));
        }

        if(OSPPUsageIndHasComponentId(*ospvUsageInd))
        {
            OSPM_FREE((*ospvUsageInd)->ospmUsageIndComponentId);
        }

        if(OSPPUsageIndHasMessageId(*ospvUsageInd))
        {
            OSPM_FREE((*ospvUsageInd)->ospmUsageIndMessageId);
        }

        OSPPListDelete(&((*ospvUsageInd)->ospmUsageIndDestinationAlternate));
        OSPM_FREE(*ospvUsageInd);
        *ospvUsageInd = OSPC_OSNULL;
    }
    return;
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPUsageIndSetCallId() - sets the call ID for an usage
 *-----------------------------------------------------------------------*/
void                                       /* nothing returned */
OSPPUsageIndSetCallId(
    OSPTUSAGEIND   *ospvUsageInd,            /* usage indication */
    OSPTCALLID    *ospvCallId              /* call ID */
)
{
    if (ospvUsageInd   != OSPC_OSNULL) 
    {
        if ((ospvCallId) != OSPC_OSNULL)
        {
            if ((ospvUsageInd)->ospmUsageIndCallId != OSPC_OSNULL)
            {
                OSPPCallIdDelete(&((ospvUsageInd)->ospmUsageIndCallId));
            }
            (ospvUsageInd)->ospmUsageIndCallId = 
                OSPPCallIdNew((ospvCallId)->ospmCallIdLen, (ospvCallId)->ospmCallIdVal); 
        }
    }
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPUsageIndHasTNStatistics() - does usageind have statistics?
 *-----------------------------------------------------------------------*/
OSPTBOOL       
    OSPPUsageIndHasTNStatistics(
    OSPTUSAGEIND *ospvUsageInd
    )
{
    OSPTBOOL hasstats = OSPC_FALSE;

    if(ospvUsageInd != OSPC_OSNULL)
    {
        if(ospvUsageInd->ospmUsageIndTNStats != OSPC_OSNULL)
        {
            hasstats = OSPC_TRUE;
        }
    }

    return hasstats;
}


/**/
/*-----------------------------------------------------------------------*
 * OSPPUsageIndSetTNStatistics() - set values for statistics in usageind
 *-----------------------------------------------------------------------*/
void
OSPPUsageIndSetTNStatistics(
    OSPTUSAGEIND    *ospvUsageInd,      /* In - ptr to usage ind */
    OSPTSTATISTICS  *ospvStatistics     /* In - ptr to completed stats struct*/
)
{
    if((ospvUsageInd != OSPC_OSNULL) && (ospvStatistics != OSPC_OSNULL))
    {
        ospvUsageInd->ospmUsageIndTNStats = OSPPStatisticsNew();
        OSPM_MEMCPY(ospvUsageInd->ospmUsageIndTNStats, 
            ospvStatistics,
            sizeof(OSPTSTATISTICS));

    }

    return;

}


/**/
/*-----------------------------------------------------------------------*
 * OSPPUsageIndToElement() - create an XML element from a usage ind
 *-----------------------------------------------------------------------*/
int                                 /* returns error code */
OSPPUsageIndToElement(
    OSPTLIST         *ospvUsageInd, /* usage ind list */
    OSPTXMLELEM      **ospvElem     /* where to put XML element pointer */
)
{
    int             ospvErrCode = OSPC_ERR_NO_ERROR;
    OSPTXMLELEM     *usgindelem   = OSPC_OSNULL,
        *subelem    = OSPC_OSNULL;
    OSPTXMLATTR     *attr       = OSPC_OSNULL;
    int             len         = 0;
    OSPTTRXID       trxid       = 0;
    OSPTALTINFO     *altinfo    = OSPC_OSNULL;
    OSPTUSAGEIND    *usage      = OSPC_OSNULL;
    char            random[OSPC_MAX_RANDOM];
    OSPTBOOL        isbase64    = OSPC_TRUE;

    OSPM_MEMSET(random, 0, OSPC_MAX_RANDOM);

    if (ospvElem == OSPC_OSNULL)
    {
        ospvErrCode = OSPC_ERR_XML_NO_ELEMENT;
    }
    if (ospvUsageInd == OSPC_OSNULL)
    {
        ospvErrCode = OSPC_ERR_DATA_NO_USAGEIND;
    }

    if(ospvErrCode == OSPC_ERR_NO_ERROR)
    {
        /* create the "Message" element as the parent */
        *ospvElem = OSPPXMLElemNew(OSPPMsgGetElemName(ospeElemMessage), "");

        if(*ospvElem == OSPC_OSNULL)
        {
            ospvErrCode = OSPC_ERR_XML_NO_ELEMENT;
        }
        else
        {
            /* Add the Message attribute */
            usage = (OSPTUSAGEIND *)OSPPListFirst(ospvUsageInd);
            attr = OSPPXMLAttrNew((const unsigned char *)OSPPMsgGetAttrName(ospeAttrMessageId), 
                (OSPPUsageIndHasMessageId(usage))?(const unsigned char *)(usage->ospmUsageIndMessageId): (const unsigned char *)"NULL");

            if (attr != OSPC_OSNULL) 
            {
                OSPPXMLElemAddAttr(*ospvElem, attr);
                attr = OSPC_OSNULL;
            }
            else
            {
                ospvErrCode = OSPC_ERR_XML_NO_ATTR;
            }

            /* random */
            if((OSPPUtilGetRandom(random, 0) > 0) &&
                (ospvErrCode == OSPC_ERR_NO_ERROR))
            {
                attr = OSPPXMLAttrNew((const unsigned char *)OSPPMsgGetAttrName(ospeAttrRandom),
                    (const unsigned char *)random);

                if (attr != OSPC_OSNULL) 
                {
                    OSPPXMLElemAddAttr(*ospvElem, attr);
                    attr = OSPC_OSNULL;