ospdest.c

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

OSPPDestHasToken(
    OSPTDEST *ospvDest                     /* destination in question */
)
{

    unsigned ospvHasToken = OSPC_FALSE;

    if (ospvDest != OSPC_OSNULL) 
    {
        ospvHasToken = (OSPPListFirst(&(ospvDest->ospmDestTokens)) != OSPC_OSNULL);
    }
    return(ospvHasToken);

}

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestAddToken() - adds a token to a destination
 *-----------------------------------------------------------------------*/
void                                       /* nothing returned */
OSPPDestAddToken(
    OSPTDEST  *ospvDest,                   /* destination in question */
    OSPTTOKEN *ospvToken                   /* token to add */
)
{
    if (ospvDest != OSPC_OSNULL) 
    {
        OSPPListAppend(&(ospvDest->ospmDestTokens), (ospvToken));
    }
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestFirstToken() - gets first token for destination
 *-----------------------------------------------------------------------*/
OSPTTOKEN *                                /* returns null if none */
OSPPDestFirstToken(
    OSPTDEST *ospvDest
    )
{
    OSPTTOKEN *ospvToken = OSPC_OSNULL;

    if (ospvDest != OSPC_OSNULL) 
    {
        ospvToken = (OSPTTOKEN *)OSPPListFirst(&(ospvDest)->ospmDestTokens);
    }
    return(ospvToken);
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestNextToken() - gets next token (in list) for destination
 *-----------------------------------------------------------------------*/
OSPTTOKEN *                                /* returns NULL if no more */
OSPPDestNextToken(
    OSPTDEST  *ospvDest,                   /* destination in question */
    OSPTTOKEN *ospvToken                   /* current token */
    )
{

    OSPTTOKEN *ospvNextToken = OSPC_OSNULL;

    if (ospvDest  != OSPC_OSNULL) 
    {
        if (ospvToken != OSPC_OSNULL) 
        {
            ospvToken = (OSPTTOKEN *)OSPPListNext(&(ospvDest)->ospmDestTokens, ospvToken);
        }
    }
    return(ospvNextToken);

}

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestHasLimit() - does a destination have a usage limit?
 *-----------------------------------------------------------------------*/
unsigned                                   /* returns non-zero if limit */
OSPPDestHasLimit(
    OSPTDEST *ospvDest                     /* destination in question */
)
{

    unsigned ospvHasLimit = OSPC_FALSE;

    if (ospvDest != OSPC_OSNULL) 
    {
        ospvHasLimit = (ospvDest->ospmDestHasLimit);
    }
    return(ospvHasLimit);
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestSetLimit() -  sets usage limit for a destination
 *-----------------------------------------------------------------------*/
void                                       /* nothing returned */
OSPPDestSetLimit(
    OSPTDEST *ospvDest,                    /* destination in question */
    unsigned  ospvLimit                    /* limit to set */
)
{
    if (ospvDest != OSPC_OSNULL) 
    {
        ospvDest->ospmDestLimit=ospvLimit;
        ospvDest->ospmDestHasLimit=OSPC_TRUE;
    }
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestGetLimit() - returns the usage limit for a destination
 *-----------------------------------------------------------------------*/
unsigned                                   /* returns usage limit */
OSPPDestGetLimit(
    OSPTDEST *ospvDest                     /* destination in question */
)
{
    unsigned ospvLimit = 0;

    if (ospvDest != OSPC_OSNULL) 
    {
        ospvLimit = ((ospvDest)->ospmDestLimit);
    }
    return(ospvLimit);
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestHasTNFailReason() - Does dest have a TransNexus Fail Rsn
 *-----------------------------------------------------------------------*/
unsigned                                   /* returns non-zero if time */
OSPPDestHasTNFailReason(
    OSPTDEST *ospvDest               /* dest in question */
)
{
    unsigned ospvHasTNFailReason = OSPC_FALSE;

    if (ospvDest != OSPC_OSNULL)
    {
        ospvHasTNFailReason = ((ospvDest)->ospmDestTNFailReasonInd);
    }
    return(ospvHasTNFailReason);
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestSetTNFailReason() - Set TransNexus Fail Reason
 *-----------------------------------------------------------------------*/
void                                       /* nothing returned */
OSPPDestSetTNFailReason(
    OSPTDEST *ospvDest,
    unsigned     ospvTNFailReason
)
{
    if (ospvDest != OSPC_OSNULL)
    {
        (ospvDest)->ospmDestTNFailReason    = (ospvTNFailReason);
        (ospvDest)->ospmDestTNFailReasonInd = 1;
    }
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestGetTNFailReason() - returns TN Fail Rsn for a dest
 *-----------------------------------------------------------------------*/
unsigned                                 /* returns the fail reason value */
OSPPDestGetTNFailReason(
    OSPTDEST *ospvDest               /* usage request */
    )
{
    unsigned ospvTNFailReason = 0;

    if (ospvDest != OSPC_OSNULL)
    {
        ospvTNFailReason = (ospvDest)->ospmDestTNFailReason;
    }
    return(ospvTNFailReason);
}
#endif /* OSPC_DEBUG */

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestNew() - creates a new (empty) destination
 *-----------------------------------------------------------------------*/
OSPTDEST *                                 /* returns pointer or NULL */
OSPPDestNew()
{
    OSPTDEST *ospvDest = OSPC_OSNULL;

    OSPM_MALLOC(ospvDest, OSPTDEST,sizeof(OSPTDEST));
    if (ospvDest != OSPC_OSNULL)
    {
        /* start with setting all to 0 */
        OSPM_MEMSET(ospvDest, 0, sizeof(OSPTDEST));
        OSPPListLinkNew(&(ospvDest->ospmDestLink));
        ospvDest->ospmDestValidAfter = OSPC_TIMEMIN;
        ospvDest->ospmDestValidUntil = OSPC_TIMEMAX;
        OSPPListNew(&(ospvDest->ospmDestTokens));
        ospvDest->ospmDestHasLimit = OSPC_FALSE;

    }

    return(ospvDest);
}

/*-----------------------------------------------------------------------*
 * OSPPDestDelete() - deletes a Destination structure
 *-----------------------------------------------------------------------*/
void
OSPPDestDelete(
    OSPTDEST **ospvDest)
{
    /*   OSPTTOKEN *token, *otoken = OSPC_OSNULL; */
    OSPTTOKEN *tmptoken = OSPC_OSNULL;

    if (*ospvDest != OSPC_OSNULL) 
    {
        /* first delete the callid */
        if (((*ospvDest)->ospmDestCallId) != OSPC_OSNULL) 
        {
            OSPPCallIdDelete(&((*ospvDest)->ospmDestCallId));
        }

        while (!OSPPListEmpty((OSPTLIST *)&((*ospvDest)->ospmDestTokens))) 
        {
            tmptoken = (OSPTTOKEN *)OSPPListRemove(
                (OSPTLIST *)&((*ospvDest)->ospmDestTokens));
            if (tmptoken != (OSPTTOKEN *)OSPC_OSNULL) 
            {
                OSPPTokenDelete(&tmptoken);
            }
        }
        OSPPListDelete((OSPTLIST *)&((*ospvDest)->ospmDestTokens));
        /* finally delete the object */
        OSPM_FREE(*ospvDest);
        *ospvDest = OSPC_OSNULL;
    }
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestFromElement() - get destination from an XML element
 *-----------------------------------------------------------------------*/
unsigned                          /* returns error code */
OSPPDestFromElement(
    OSPTXMLELEM *ospvElem,        /* input is XML element */
    OSPTDEST   **ospvDest         /* where to put destination pointer */
)
{
    unsigned      ospvErrCode   = OSPC_ERR_NO_ERROR;
    OSPTXMLELEM  *elem          = OSPC_OSNULL;
    OSPTDEST     *dest          = OSPC_OSNULL;
    OSPTTOKEN    *token         = OSPC_OSNULL;
    OSPTCALLID   *callId        = OSPC_OSNULL;
    unsigned      limit         = 0;
    unsigned long failure       = 0L;
    OSPTTIME      t             = 0L;

    if (ospvElem == OSPC_OSNULL)
    {
        ospvErrCode = OSPC_ERR_XML_NO_ELEMENT;
    }
    if (ospvDest == OSPC_OSNULL)
    {
        ospvErrCode = OSPC_ERR_DATA_NO_DEST;
    }

    if (ospvErrCode == OSPC_ERR_NO_ERROR)
    {
        /* create the destination object */
        dest = OSPPDestNew();

        if (dest == OSPC_OSNULL)
        {
            ospvErrCode = OSPC_ERR_DATA_NO_DEST;
        }

        /*
         * The Destination element should consist of several child
         * elements. We'll run through what's there and pick out
         * the information we need.
         */

        for ( elem = (OSPTXMLELEM *)OSPPXMLElemFirstChild(ospvElem);
            (elem != (OSPTXMLELEM *)OSPC_OSNULL) && (ospvErrCode == OSPC_ERR_NO_ERROR);
            elem = (OSPTXMLELEM *)OSPPXMLElemNextChild(ospvElem, elem) )
        {
            switch (OSPPMsgGetElemPart(OSPPXMLElemGetName(elem)))
            {
                case ospeElemDestInfo:
                OSPPDestSetNumber(dest, (const unsigned char *)OSPPXMLElemGetValue(elem));
                break;
                case ospeElemDestAlt:
                /*                OSPPDestSetAddr(dest, (const unsigned char *)OSPPXMLElemGetValue(elem)); */
                OSPPDestDevSetAddr(dest, (const unsigned char *)OSPPXMLElemGetValue(elem));
                break;
                case ospeElemDestSigAddr:
                /*                OSPPDestDevSetAddr(dest, (const unsigned char *)OSPPXMLElemGetValue(elem)); */
                OSPPDestSetAddr(dest, (const unsigned char *)OSPPXMLElemGetValue(elem)); 
                break;
                case ospeElemToken:
                ospvErrCode = OSPPTokenFromElement(elem, &token);
                if (ospvErrCode == OSPC_ERR_NO_ERROR)
                {
                    OSPPDestAddToken(dest, token);
                }
                break;
                case ospeElemValidAfter:
                    t=0;
                    if(*(OSPPXMLElemGetValue(elem)) != 0)
                    {
                        ospvErrCode = OSPPMsgTimeFromElement(elem, &t);
                    }
                    else
                    {
                        t = OSPC_TIMEMIN;
                    }
                    if (ospvErrCode == OSPC_ERR_NO_ERROR)
                    {
                        OSPPDestSetValidAfter(dest,t);
                    }
                break;
                case ospeElemValidUntil:
                    t=0;
                    if(*(OSPPXMLElemGetValue(elem)) != 0)
                    {
                        ospvErrCode = OSPPMsgTimeFromElement(elem, &t);
                    }
                    else
                    {
                        t = OSPC_TIMEMAX;
                    }
                    if (ospvErrCode == OSPC_ERR_NO_ERROR)
                    {
                        OSPPDestSetValidUntil(dest,t);
                    }
                break;
                case ospeElemUsageDetail:
                ospvErrCode = OSPPUsageFromElement(elem, &limit);
                if (ospvErrCode == OSPC_ERR_NO_ERROR)
                {
                    OSPPDestSetLimit(dest,limit);
                }
                break;
                case ospeElemAuthURL:
                OSPPDestSetAuthority(dest, (const unsigned char *)OSPPXMLElemGetValue(elem));
                break;
                case ospeElemCallId:
                ospvErrCode = OSPPCallIdFromElement(elem, &callId);
                if (ospvErrCode == OSPC_ERR_NO_ERROR)
                {
                    OSPPDestSetCallId(dest, callId->ospmCallIdVal, callId->ospmCallIdLen);
                    OSPPCallIdDelete(&callId);
                }
                break;
                case ospeElemTNFailReason:
                ospvErrCode = OSPPMsgNumFromElement(elem, &failure);
                OSPPDestSetTNFailReason(dest, (unsigned)failure);
                break;
                default:
                /*
                 * This is an element we don't understand. If it's
                 * critical, then we have to report an error.
                 * Otherwise we can ignore it.
                 */
                if (OSPPMsgElemIsCritical(elem))
                {
                    ospvErrCode = OSPC_ERR_XML_BAD_ELEMENT;
                }
                break;
            }
        }

        if (ospvErrCode == OSPC_ERR_NO_ERROR)
        {
            *ospvDest = dest;
        }
    }
    return(ospvErrCode);
}

/**/
/*-----------------------------------------------------------------------*
 * OSPPDestSetCallId() - sets the call ID for a destination
 *-----------------------------------------------------------------------*/
void                                       /* nothing returned */
OSPPDestSetCallId(
    OSPTDEST            *ospvDest,  /* destination */
    const unsigned char *ospvValue, /* call ID value */
    unsigned            ospvLen
)
{
    if (ospvDest != OSPC_OSNULL)
    {
        if (ospvValue != OSPC_OSNULL)
        {
            if ((ospvDest)->ospmDestCallId != OSPC_OSNULL) 
            {
                OSPPCallIdDelete(&((ospvDest)->ospmDestCallId));
            }
            (ospvDest)->ospmDestCallId = 
                OSPPCallIdNew( ospvLen, (ospvValue));
        }
    }
}