ospstatistics.c

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

/*
*########################################################################
*########################################################################
*########################################################################
*                                                               
*   COPYRIGHT (c) 1998, 1999 by TransNexus, LLC                          
*                                                                    
*   This software contains proprietary and confidential information  
*   of TransNexus, LLC. Except as may be set forth in the license    
*   agreement under which this software is supplied, use, disclosure, 
*   or reproduction is prohibited without the prior, express, written
*   consent of TransNexus, LLC.                                      
*                                     
*
*
*
*
*
*
*#########################################################################
*#########################################################################
*#########################################################################
*/

/*
 * ospstatistics.c - OSP Statistics elements functions
 */

#include "osp.h"
#include "ospstatistics.h"
#include "ospmsgelem.h"
#include "ospmsgattr.h"
#include "ospmsg.h"

/* Delete Statistics structure */
void
OSPPStatisticsDelete(
    OSPTSTATISTICS  **ospvStatistics
)
{
    if(*ospvStatistics != OSPC_OSNULL)
    {
        OSPM_FREE(*ospvStatistics);
        *ospvStatistics = OSPC_OSNULL;
    }

    return;
}

/* Get value for fractionreceived */
signed
OSPPStatisticsGetFracReceived(
    OSPTSTATISTICS  *ospvStatistics
)
{
    signed fracrecvd = 0;

    if(ospvStatistics != OSPC_OSNULL)
    {
        fracrecvd = ospvStatistics->ospmLossFractionReceived;
    }

    return fracrecvd;
}

/* Get value for OneWay.Minimum */
unsigned
OSPPStatisticsGetOneWayMinimum(
    OSPTSTATISTICS  *ospvStatistics
)
{
    unsigned min = 0;
    if(ospvStatistics != OSPC_OSNULL)
    {
        min = ospvStatistics->ospmOneWay.Minimum;
    }

    return min;
}

/* Get value for OneWay.Mean */
unsigned
OSPPStatisticsGetOneWayMean(
    OSPTSTATISTICS  *ospvStatistics
)
{
    unsigned mean = 0;
    if(ospvStatistics != OSPC_OSNULL)
    {
        mean = ospvStatistics->ospmOneWay.Mean;
    }

    return mean;
}

/* Get value for OneWay.Variance */
float
OSPPStatisticsGetOneWayVariance(
    OSPTSTATISTICS  *ospvStatistics
)
{
    float var = 0;
    if(ospvStatistics != OSPC_OSNULL)
    {
        var = ospvStatistics->ospmOneWay.Variance;
    }

    return var;
}

/* Get value for OneWay.Samples */
unsigned
OSPPStatisticsGetOneWaySamples(
    OSPTSTATISTICS  *ospvStatistics
)
{
    unsigned samp = 0;
    if(ospvStatistics != OSPC_OSNULL)
    {
        samp = ospvStatistics->ospmOneWay.NumberOfSamples;
    }

    return samp;
}

/* Get value for packetsreceived */
unsigned
OSPPStatisticsGetPktReceived(
    OSPTSTATISTICS  *ospvStatistics
)
{
    unsigned pktsrecvd = 0;

    if(ospvStatistics != OSPC_OSNULL)
    {
        pktsrecvd = ospvStatistics->ospmLossPacketsReceived;
    }

    return pktsrecvd;
}

/* Get value for fractionsent */
signed
OSPPStatisticsGetFracSent(
    OSPTSTATISTICS  *ospvStatistics
)
{
    signed fracsent = 0;

    if(ospvStatistics != OSPC_OSNULL)
    {
        fracsent = ospvStatistics->ospmLossFractionSent;
    }

    return fracsent;
}

/* Get value for packetssent */
unsigned
OSPPStatisticsGetPktSent(
    OSPTSTATISTICS  *ospvStatistics
)
{
    unsigned pktssent = 0;

    if(ospvStatistics != OSPC_OSNULL)
    {
        pktssent = ospvStatistics->ospmLossPacketsSent;
    }

    return pktssent;
}

/* Get value for RoundTrip.Minimum */
unsigned
OSPPStatisticsGetRoundTripMinimum(
    OSPTSTATISTICS  *ospvStatistics
)
{
    unsigned min = 0;
    if(ospvStatistics != OSPC_OSNULL)
    {
        min = ospvStatistics->ospmRoundTrip.Minimum;
    }

    return min;
}

/* Get value for RoundTrip.Mean */
unsigned
OSPPStatisticsGetRoundTripMean(
    OSPTSTATISTICS  *ospvStatistics
)
{
    unsigned mean = 0;
    if(ospvStatistics != OSPC_OSNULL)
    {
        mean = ospvStatistics->ospmRoundTrip.Mean;
    }

    return mean;
}

/* Get value for RoundTrip.Variance */
float
OSPPStatisticsGetRoundTripVariance(
    OSPTSTATISTICS  *ospvStatistics
)
{
    float var = 0;
    if(ospvStatistics != OSPC_OSNULL)
    {
        var = ospvStatistics->ospmRoundTrip.Variance;
    }

    return var;
}

/* Get value for RoundTrip.Samples */
unsigned
OSPPStatisticsGetRoundTripSamples(
    OSPTSTATISTICS  *ospvStatistics
)
{
    unsigned samp = 0;
    if(ospvStatistics != OSPC_OSNULL)
    {
        samp = ospvStatistics->ospmRoundTrip.NumberOfSamples;
    }

    return samp;
}

/* Check for existence of LossReceived statistics */
OSPTBOOL
    OSPPStatisticsHasLossReceived(
    OSPTSTATISTICS *ospvStatistics
    )
{
    if(ospvStatistics != OSPC_OSNULL)
    {
        return ospvStatistics->ospmHasReceivedStats;
    }
    else
    {
        return OSPC_FALSE;
    }
}

/* Check for existence of LossSent statistics */
OSPTBOOL
    OSPPStatisticsHasLossSent(
    OSPTSTATISTICS *ospvStatistics
    )
{
    if(ospvStatistics != OSPC_OSNULL)
    {
        return ospvStatistics->ospmHasSentStats;
    }
    else
    {
        return OSPC_FALSE;
    }
}

/* Check for existence of OneWay statistics */
OSPTBOOL
    OSPPStatisticsHasOneWay(
    OSPTSTATISTICS *ospvStatistics
    )
{
    if(ospvStatistics != OSPC_OSNULL)
    {
        return ospvStatistics->ospmHasOneWay;
    }
    else
    {
        return OSPC_FALSE;
    }
}

/* Check for existence of RoundTrip statistics */
OSPTBOOL
    OSPPStatisticsHasRoundTrip(
    OSPTSTATISTICS *ospvStatistics
    )
{
    if(ospvStatistics != OSPC_OSNULL)
    {
        return ospvStatistics->ospmHasRoundTrip;
    }
    else
    {
        return OSPC_FALSE;
    }
}

/* Create loss received element */
int
OSPPStatisticsLossReceivedToElement(
    OSPTSTATISTICS *ospvStatistics, 
    OSPTXMLELEM    **ospvElem
)
{
    int         errorcode   = OSPC_ERR_NO_ERROR;
    OSPTXMLELEM *elem       = OSPC_OSNULL;
    OSPTXMLATTR *attr       = OSPC_OSNULL;

    if(ospvElem == OSPC_OSNULL)
    {
        errorcode = OSPC_ERR_XML_NO_ELEMENT;
    }

    if(ospvStatistics == OSPC_OSNULL)
    {
        errorcode = OSPC_ERR_DATA_NO_STATS;
    }

    if(errorcode == OSPC_ERR_NO_ERROR)
    {

        *ospvElem = OSPPXMLElemNew(OSPPMsgGetElemName(ospeElemTNLossRcvd), "");
        if(*ospvElem == OSPC_OSNULL)
        {
            errorcode = OSPC_ERR_XML_NO_ELEMENT;
        }

        if(errorcode == OSPC_ERR_NO_ERROR)
        {
            attr = OSPPXMLAttrNew(
                (const unsigned char *)OSPPMsgGetAttrName(ospeAttrCritical),
                (const unsigned char *)"False");

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

    /* Loss Packets Received */
    if(errorcode== OSPC_ERR_NO_ERROR)
    {
        errorcode = OSPPMsgNumToElement(OSPPStatisticsGetPktReceived(ospvStatistics),
            (const unsigned char *)OSPPMsgGetElemName(ospeElemTNPackets), &elem);

        if(errorcode == OSPC_ERR_NO_ERROR)
        {
            attr = OSPPXMLAttrNew(
                (const unsigned char *)OSPPMsgGetAttrName(ospeAttrCritical),
                (const unsigned char *)"False");
            if (attr != OSPC_OSNULL) 
            {
                OSPPXMLElemAddAttr(elem, attr);
                attr = OSPC_OSNULL;
            }
            else
            {
                errorcode = OSPC_ERR_XML_NO_ATTR;
            }

            if (errorcode == OSPC_ERR_NO_ERROR)
            {
                OSPPXMLElemAddChild(*ospvElem, elem);
                elem = OSPC_OSNULL;
            }
        }
    }

    /* Loss Fraction Received */
    if(errorcode== OSPC_ERR_NO_ERROR)
    {
        errorcode = OSPPMsgNumToElement(OSPPStatisticsGetFracReceived(ospvStatistics),
            (const unsigned char *)OSPPMsgGetElemName(ospeElemTNFraction), &elem);

        if(errorcode == OSPC_ERR_NO_ERROR)
        {
            attr = OSPPXMLAttrNew(
                (const unsigned char *)OSPPMsgGetAttrName(ospeAttrCritical),
                (const unsigned char *)"False");
            if (attr != OSPC_OSNULL) 
            {
                OSPPXMLElemAddAttr(elem, attr);
                attr = OSPC_OSNULL;
            }
            else
            {
                errorcode = OSPC_ERR_XML_NO_ATTR;
            }

            if (errorcode == OSPC_ERR_NO_ERROR)
            {
                OSPPXMLElemAddChild(*ospvElem, elem);
                elem = OSPC_OSNULL;
            }
        }
    }

    /* clean up */
    if(attr != OSPC_OSNULL)
    {
        OSPM_FREE(attr);
        attr = OSPC_OSNULL;
    }

    if(elem != OSPC_OSNULL)
    {
        OSPM_FREE(elem);
        elem = OSPC_OSNULL;
    }

    return errorcode;
}

/* Create loss sent element */
int
OSPPStatisticsLossSentToElement(
    OSPTSTATISTICS *ospvStatistics, 
    OSPTXMLELEM    **ospvElem
)
{
    int         errorcode   = OSPC_ERR_NO_ERROR;
    OSPTXMLELEM *elem       = OSPC_OSNULL;
    OSPTXMLATTR *attr       = OSPC_OSNULL;

    if(ospvElem == OSPC_OSNULL)
    {
        errorcode = OSPC_ERR_XML_NO_ELEMENT;
    }

    if(ospvStatistics == OSPC_OSNULL)
    {
        errorcode = OSPC_ERR_DATA_NO_STATS;
    }

    if(errorcode == OSPC_ERR_NO_ERROR)
    {

        *ospvElem = OSPPXMLElemNew(OSPPMsgGetElemName(ospeElemTNLossSent), "");
        if(*ospvElem == OSPC_OSNULL)
        {
            errorcode = OSPC_ERR_XML_NO_ELEMENT;
        }

        if(errorcode == OSPC_ERR_NO_ERROR)
        {
            attr = OSPPXMLAttrNew(
                (const unsigned char *)OSPPMsgGetAttrName(ospeAttrCritical),
                (const unsigned char *)"False");

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

    /* Loss Packets Sent */
    if(errorcode== OSPC_ERR_NO_ERROR)
    {
        errorcode = OSPPMsgNumToElement(OSPPStatisticsGetPktSent(ospvStatistics),
            (const unsigned char *)OSPPMsgGetElemName(ospeElemTNPackets), &elem);

        if(errorcode == OSPC_ERR_NO_ERROR)
        {
            attr = OSPPXMLAttrNew(
                (const unsigned char *)OSPPMsgGetAttrName(ospeAttrCritical),
                (const unsigned char *)"False");
            if (attr != OSPC_OSNULL) 
            {
                OSPPXMLElemAddAttr(elem, attr);
                attr = OSPC_OSNULL;
            }
            else
            {
                errorcode = OSPC_ERR_XML_NO_ATTR;
            }

            if (errorcode == OSPC_ERR_NO_ERROR)
            {
                OSPPXMLElemAddChild(*ospvElem, elem);
                elem = OSPC_OSNULL;
            }
        }
    }

    /* Loss Fraction Sent */
    if(errorcode== OSPC_ERR_NO_ERROR)
    {
        errorcode = OSPPMsgNumToElement(OSPPStatisticsGetFracSent(ospvStatistics),
            (const unsigned char *)OSPPMsgGetElemName(ospeElemTNFraction), &elem);

        if(errorcode == OSPC_ERR_NO_ERROR)
        {
            attr = OSPPXMLAttrNew(
                (const unsigned char *)OSPPMsgGetAttrName(ospeAttrCritical),
                (const unsigned char *)"False");
            if (attr != OSPC_OSNULL) 
            {
                OSPPXMLElemAddAttr(elem, attr);
                attr = OSPC_OSNULL;
            }
            else
            {
                errorcode = OSPC_ERR_XML_NO_ATTR;
            }

            if (errorcode == OSPC_ERR_NO_ERROR)
            {
                OSPPXMLElemAddChild(*ospvElem, elem);
                elem = OSPC_OSNULL;
            }
        }
    }

    /* clean up */
    if(attr != OSPC_OSNULL)
    {
        OSPM_FREE(attr);
        attr = OSPC_OSNULL;
    }

    if(elem != OSPC_OSNULL)
    {
        OSPM_FREE(elem);
        elem = OSPC_OSNULL;
    }

    return errorcode;
}

/* Create new Statistics Structure */
OSPTSTATISTICS *
    OSPPStatisticsNew(void)
{
    OSPTSTATISTICS  *ospvStatistics = OSPC_OSNULL;

    OSPM_MALLOC(ospvStatistics, OSPTSTATISTICS, sizeof(OSPTSTATISTICS));

    if (ospvStatistics != OSPC_OSNULL)
    {
        OSPM_MEMSET(ospvStatistics, 0, sizeof(OSPTSTATISTICS));
    }

    return ospvStatistics;
}

/* OneWay to Element */
int
OSPPStatisticsOneWayToElement(
    OSPTSTATISTICS  *ospvStatistics,
    OSPTXMLELEM     **ospvElem
)
{
    int         errorcode   = OSPC_ERR_NO_ERROR;
    OSPTXMLELEM *elem       = OSPC_OSNULL;
    OSPTXMLATTR *attr       = OSPC_OSNULL;

    if(ospvElem == OSPC_OSNULL)
    {
        errorcode = OSPC_ERR_XML_NO_ELEMENT;
    }

    if(ospvStatistics == OSPC_OSNULL)
    {
        errorcode = OSPC_ERR_DATA_NO_STATS;
    }
    if(errorcode == OSPC_ERR_NO_ERROR)
    {