sipdiversion.cxx

SIP（Session Initiation Protocol）是由IETF定义

    int retur = urlvalue.match(">", &avalue, true);
    if (retur == NOT_FOUND)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in ParseUrl() :o( ");
            throw SipDiversionParserException("failed in Decode", __FILE__, __LINE__, PARSE_RURL_FAILED);

        }
    }
    if (retur == FIRST)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in ParseUrl()  :o( ");
            throw SipDiversionParserException("failed in Decode", __FILE__, __LINE__, PARSE_RURL_FAILED);

        }
    }
    if (retur == FOUND)
    {

        rurl = BaseUrl::decode(avalue);

        Data te = urlvalue;

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

        if (rety == FOUND)
        {
        }

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


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

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

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


void
SipDiversion::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
SipDiversion::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 SipDiversionParserException("failed in Decode", __FILE__, __LINE__, LIMIT_ERR);

        }
    }
    if (ret == FIRST)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in parseLimit :o( ");
            throw SipDiversionParserException("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);
            }
	    // else { diversion extension }
        }
        if (rety == FIRST)
        {
            if (SipParserMode::sipParserMode())
            {
                cpLog(LOG_ERR, "Failed to Parse in parseLimit :o( ");
                throw SipDiversionParserException("failed in Decode", __FILE__, __LINE__, LIMIT_ERR);
            }
        }
        if (rety == NOT_FOUND)
        {
        }
    }
}


void
SipDiversion::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 SipDiversionParserException("failed in Decode", __FILE__, __LINE__, COUNT_FAILED);

        }
    }
    if (ret == FIRST)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in parseCounter :o( ");
            throw SipDiversionParserException("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);
            }
	    // else { diversion extension }
        }
        if (rety == FIRST)
        {
            if (SipParserMode::sipParserMode())
            {
                cpLog(LOG_ERR, "Failed to Decode in ParseCounter :o( ");
                throw SipDiversionParserException("failed in Decode", __FILE__, __LINE__, COUNT_FAILED);

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

    }
}


void
SipDiversion::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 SipDiversionParserException("failed in Decode", __FILE__, __LINE__, LIMIT_ERR);
        }
    }
    if (ret == FIRST)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in parseReason :o( ");
            throw SipDiversionParserException("failed in Decode", __FILE__, __LINE__, LIMIT_ERR);

        }
    }
    if (ret == FOUND)
    {

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

        if (rety == FOUND)
        {
	    //parse extension
        }

        if (rety == FIRST)
        {

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

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


bool
SipDiversion::operator< (const SipDiversion& src) const
{
    if ( //(host == src.host) &&
        (rcounter < src.rcounter) &&
        (rlimit < src.rlimit) &&
        (rreason < src.rreason)
    )
    {
        return true;
    }
    return false;
}


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


Sptr < SipDiversion::TokenMapDiversion >
SipDiversion::getTokenDetails()
{
    Sptr < SipDiversion::TokenMapDiversion > dmap = new TokenMapDiversion(tokenMap) ;

    return dmap;
}


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


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


//is the string a token  or not
Data 
SipDiversion::isToken(const Data& sdata )
{
    Data vdata;
    Data mdata("OVER");
    Data ldata = sdata;
    if ( ! isEmpty(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 
SipDiversion::isCounter(const Data& sdata)
{
    if ( ! isEmpty(sdata))
    {
        Data data = sdata;
        Data value;
        int retn = data.match("=", &value, true) ;

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

    return false;
}


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

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

    }

    return false;

}


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

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

    }
    return false;
}


bool 
SipDiversion::isEmpty(const Data& sdata)
{
    Data data = sdata;
    if ( data.length() == 0)
    {
        return true;
    }
    return false;
}


void 
SipDiversion::print()
{
    TokenMapDiversion::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;


    }

}


SipHeader*
SipDiversion::duplicate() const
{
    return new SipDiversion(*this);
}


bool
SipDiversion::compareSipHeader(SipHeader* msg) const
{
    SipDiversion* otherMsg = dynamic_cast<SipDiversion*>(msg);
    if(otherMsg != 0)
    {
	return (*this == *otherMsg);
    }
    else
    {
	return false;
    }
}


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