sipredirect.cxx

Vovida 社区开源的 SIP 协议源码

        if (rety == FOUND)
        {
        }

        if (rety == FIRST)
        {
            parseTag(te);
        }
        if (rety == NOT_FOUND)
        {}

    }
}


void
SipRedirect::parseToken(const Data& data)
{
    int i = 0;
    Data resdata;
    Data edata = data;
    while (i == 0)
    {
        resdata = isToken(edata);
        if ( resdata != edata)
        {

            edata = resdata;
        }
        else
        {
            i = 1;
        }

    }
    if (isReason(edata))
    {
        parseReason(edata);
    }
    else
        if ( isCounter(edata))
        {
            parseCounter(edata);
        }
        else if ( isLimit(edata))
        {
            parseLimit(edata);
        }
}

void
SipRedirect::parseTag( Data& data)
{

    Data addrparm = data;
    Data parm;
    int ret = addrparm.match("=", &parm, true);
    if (ret == NOT_FOUND)
    {
        // if addrparm != 0 exception
    }

    if (ret == FIRST)
    {
        //exception
    }

    if (ret == FOUND)
    {
        //parse tokens
        //parse reason and rest of the stuff

        if (!isEmpty(parm))
        {
            Data value;
            if (parm == "tag")
            {
                Data parma;
                int sret = addrparm.match(";", &parma, true);
                if (sret == FOUND)
                {
                    setTag(parma);
                    parseToken(addrparm);
                }

            }
            else
            {
                parseToken(data);

            }

        }

    }

}

void
SipRedirect::parseReason(const Data& data)
{
    Data addrparm = data;
    Data parm;
    int ret = addrparm.match("=", &parm, true);
    if (ret == NOT_FOUND)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in parseLimit:o( ");
            throw SipRedirectParserException("failed in Decode", __FILE__, __LINE__, LIMIT_ERR);

        }
    }
    if (ret == FIRST)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in parseLimit :o( ");
            throw SipRedirectParserException("failed in Decode", __FILE__, __LINE__, LIMIT_ERR);

        }

    }
    if (ret == FOUND)
    {

        Data te = addrparm;

        Data fik;

        int rety = te.match(";", &fik, true);

        if (rety == FOUND)
        {
            setReason(fik);
            if (isCounter(te))
            {
                parseCounter(te);
            }

            else if (isLimit(te))
            {
                parseLimit(te);
            }
        }
        if (rety == FIRST)
        {
            if (SipParserMode::sipParserMode())
            {
                cpLog(LOG_ERR, "Failed to Parse in parseLimit :o( ");
                throw SipRedirectParserException("failed in Decode", __FILE__, __LINE__, LIMIT_ERR);
            }
        }
        if (rety == NOT_FOUND)
        {}


    }
}



void
SipRedirect::parseCounter(const Data& data)
{
    Data addrparm = data;
    Data parm;

    int ret = addrparm.match("=", &parm, true);
    if (ret == NOT_FOUND)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in parseCounter :o( ");
            throw SipRedirectParserException("failed in Decode", __FILE__, __LINE__, COUNT_FAILED);

        }
    }
    if (ret == FIRST)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in parseCounter :o( ");
            throw SipRedirectParserException("failed in Decode", __FILE__, __LINE__, COUNT_FAILED);

        }

    }
    if (ret == FOUND)
    {

        Data te = addrparm;

        Data fik;

        int rety = te.match(";", &fik, true);

        if (rety == FOUND)
        {
            setCounter(fik);
            if ( isLimit(te))
            {
                parseLimit(te);
            }
        }
        if (rety == FIRST)
        {
            if (SipParserMode::sipParserMode())
            {
                cpLog(LOG_ERR, "Failed to Decode in ParseCounter :o( ");
                throw SipRedirectParserException("failed in Decode", __FILE__, __LINE__, COUNT_FAILED);

            }


        }
        if (rety == NOT_FOUND)
        {
            if (isEmpty(fik))
            {
                setCounter(te);
            }
        }

    }
}





void
SipRedirect::parseLimit(const Data& data)
{
    Data addrparm = data;
    Data parm;
    int ret = addrparm.match("=", &parm, true);
    if (ret == NOT_FOUND)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in parseReason:o( ");
            throw SipRedirectParserException("failed in Decode", __FILE__, __LINE__, LIMIT_ERR);

        }
    }
    if (ret == FIRST)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in parseReason :o( ");
            throw SipRedirectParserException("failed in Decode", __FILE__, __LINE__, LIMIT_ERR);

        }

    }
    if (ret == FOUND)
    {

        Data te = addrparm;

        Data fik;

        int rety = te.match(";", &fik, true);

        if (rety == FOUND)
        {
        }

        if (rety == FIRST)
        {

            if (SipParserMode::sipParserMode())
            {
                cpLog(LOG_ERR, "Failed to Decode in ParseReason  :o( ");
                throw SipRedirectParserException("failed in Decode", __FILE__, __LINE__, REASON_FAILED);

            }
        }
        if (rety == NOT_FOUND)
        {
            setLimit(te);
        }

    }
}



bool
SipRedirect::operator< (const SipRedirect& src) const
{
    if ( //(host == src.host) &&


        (rcounter < src.rcounter) &&
        (rlimit < src.rlimit) &&
        (rreason < src.rreason)
    )


    {
        return true;
    }
    return false;
}


void SipRedirect::setTokenDetails(const Data& token, const Data& tokenValue)
{
    tokenMap[token] = tokenValue;
}


Sptr < SipRedirect::TokenMapRedirect >
SipRedirect::getTokenDetails()
{
    Sptr < SipRedirect::TokenMapRedirect > dmap = new TokenMapRedirect(tokenMap) ;

    return dmap;
}


void SipRedirect::setTag(const Data& newtag)
{
    tag = newtag;
}


Data SipRedirect::getTag() const
{
    return tag;
}


//is the string a token  or not
Data SipRedirect::isToken(const Data& sdata )
{
    Data vdata;
    Data mdata("OVER");
    Data ldata = sdata;
    if ( ! isEmpty(ldata))
    {
        //	if ((!(isReason(ldata))) && ( !(isCounter(ldata))) && (!(isLimit(ldata))))
        if ( isReason(ldata) == false)
        {
            if ( isCounter(ldata) == false)
            {
                if ( isLimit(ldata) == false)
                {
                    Data data = ldata;
                    Data value;
                    int retn = data.match("=", &value, true) ;
                    if (retn == FOUND)
                        //if (!isEmpty(&data))
                    {
                        Data dat;

                        Data gdata = data;
                        int ret = gdata.match(";", &dat, true) ;
                        if ( ret == FOUND)
                            //    if ((!isEmpty(&dat)) && (ret !=0))
                        {
                            tokenMap[value] = dat;
                            return gdata;
                        }
                        else if (ret == NOT_FOUND)
                        {
                            tokenMap[value] = data;
                            return vdata;
                        }
                        else if (ret == FIRST)
                        {}


                    }
                    if ( retn == NOT_FOUND)
                    {
                        return ldata;
                    }
                }
            }
        }
        return ldata;
    }

    return vdata;
}

bool SipRedirect::isCounter(const Data& sdata)
{
    if ( ! isEmpty(sdata))
    {
        Data data = sdata;
        Data value;
        int retn = data.match("=", &value, true) ;

        if (retn == FOUND)
        {
            if (value == "redir-counter")
            {
                return true;
            }
            return false;
        }

    }

    return false;
}

bool SipRedirect::isLimit(const Data& sdata)
{
    if ( ! isEmpty(sdata))
    {
        Data data = sdata;
        Data value;
        int retn = data.match("=", &value, true) ;

        if (retn == FOUND)
        {
            if (value == "redir-limit")
            {
                return true;
            }
            return false;
        }

    }

    return false;

}

//is it a reason string or not
bool SipRedirect::isReason(const Data& sdata)
{
    if ( ! isEmpty(sdata))
    {
        Data data = sdata;
        Data value;
        int retn = data.match("=", &value, true) ;

        if (retn == FOUND)
        {
            if (value == "redir-reason")
            {
                return true;
            }
            return false;
        }

    }
    return false;
}

//function checks whether the data string is empty or not
bool SipRedirect::isEmpty(const Data& sdata)
{
    Data data = sdata;
    if ( data.length() == 0)
    {
        return true;
    }
    return false;
}


void SipRedirect::print()
{
    TokenMapRedirect::iterator i = tokenMap.begin();
    while (i != tokenMap.end())
    {
        Data token1 = i->first;
        Data tokenValue1 = i->second;
        cpLog(LOG_DEBUG_STACK, "token1: %s", token1.logData());
        cpLog(LOG_DEBUG_STACK, "tokenValue1: %s", tokenValue1.logData());
        ++i;


    }

}


/* Local Variables: */
/* c-file-style: "stroustrup" */
/* indent-tabs-mode: nil */
/* c-file-offsets: ((access-label . -) (inclass . ++)) */
/* c-basic-offset: 4 */
/* End: */