sipaccept.cxx

Vovida 社区开源的 SIP 协议源码

                __FILE__,
                __LINE__, DECODE_ACCEPT_FAILED);
        }

    }
    else if (check == FOUND)

        //value has the correct

        if (pdata.length())
        {
            try
            {
                parseMediaExtension(pvalue, pdata);
            }
            catch (SipAcceptParserException&)
            {

                if (SipParserMode::sipParserMode())
                {

                    throw SipAcceptParserException(
                        "failed to decode the Accept string",
                        __FILE__,
                        __LINE__, DECODE_ACCEPT_FAILED);
                }

            }
        }
}


void
SipAccept::parseMediaExtension(const Data& extensiondata, const Data& extensionvalue)
{
    Data mdiatokenparm = extensiondata ;
    Data mdiatokenvalue = extensionvalue;
    setMediaToken(mdiatokenparm);
    setMediaTokenValue(mdiatokenvalue);


}

void
SipAccept::parseAcceptParm(const Data & tempdata)
{
    Data tempvalue;
    Data acparm = tempdata;
    while (acparm.length())
    {
        int ret = acparm.match(SEMICOLON, &tempvalue, true);
        if (ret == FOUND)
        {
            parseAcceptParms(tempvalue);
        }
        else if (ret == FIRST)
        {
            if (SipParserMode::sipParserMode())
            {

                throw SipAcceptParserException(
                    "failed to decode the Accept string",
                    __FILE__,
                    __LINE__, DECODE_ACCEPT_FAILED);
            }
        }
        else if (ret == NOT_FOUND)
        {
            Data pvalue;
            Data pdata = acparm;
            int check = pdata.match("=", &pvalue , true);

            if ( check == NOT_FOUND)
            {
                setMediaToken(pvalue);
            }
            else if (check == FIRST)
            {
                if (SipParserMode::sipParserMode())
                {

                    throw SipAcceptParserException(
                        "failed to decode the Accept string",
                        __FILE__,
                        __LINE__, DECODE_ACCEPT_FAILED);
                }


            }
            else if (check == FOUND)

                //value has the correct

                if (pdata.length())
                {
                    try
                    {
                        parseAcceptExtension(pvalue, pdata);
                    }
                    catch (SipAcceptParserException&)
                    {
                        if (SipParserMode::sipParserMode())
                        {

                            throw SipAcceptParserException(
                                "failed to decode the Accept  string",
                                __FILE__,
                                __LINE__, DECODE_ACCEPT_FAILED);
                        }


                    }
                }
            break;

        }

    }
}
void
SipAccept::parseAcceptParms(const Data& data)
{

    Data pvalue;
    Data pdata = data;
    // Check for the Parms With Constant "=" sign
    int check = pdata.match("=", &pvalue , true);

    if ( check == NOT_FOUND)
    {
        setAcceptExtensionParm(pvalue);
    }
    else if (check == FOUND)
    {
        parseAcceptExtension(pvalue, pdata);
    }
    else //if (check == FIRST)
    {
        //do nothing
    }
}



void
SipAccept::parseAcceptExtension(const Data& extensiondata, const Data& extensionvalue)
{
    if (extensiondata == QVALUE)
    {
        qValue = extensionvalue;
    }
    else
    {
        setAcceptExtensionParm(extensiondata);
        setAcceptExtensionValue(extensionvalue);
    }

}

const SipAccept& SipAccept::operator =(const SipAccept& src)
{
    if (&src != this)
    {
        mediaType = src.mediaType;
        mediaSubtype = src.mediaSubtype;
        qValue = src.qValue;
        mediatoken = src.mediatoken;
        mediatokenValue = src.mediatokenValue;
        accepttoken = src.accepttoken;
        accepttokenValue = src.accepttokenValue;
        allmedia = src.allmedia;
        flagmedia = src.flagmedia;
    }
    return (*this);
}

bool SipAccept::operator == (const SipAccept& src) const
{
    if (
        (mediaType == src.mediaType) &&
        (mediaSubtype == src.mediaSubtype) &&
        (qValue == src.qValue) &&
        (mediatoken == src.mediatoken) &&
        (mediatokenValue == src.mediatokenValue) &&
        (accepttoken == src.accepttoken) &&
        (accepttokenValue == src.accepttokenValue) &&
        (allmedia == src.allmedia) &&
        (flagmedia == src.flagmedia)
    )
    {
        return true;
    }
    else
    {
        return false;
    }
}

SipAccept::SipAccept( const SipAccept& src )
        : mediaType(src.mediaType),
        mediaSubtype(src.mediaSubtype),
        qValue(src.qValue),
        mediatoken(src.mediatoken),
        mediatokenValue(src.mediatokenValue),
        accepttoken(src.accepttoken),
        accepttokenValue(src.accepttokenValue),
        allmedia(src.allmedia),
        flagmedia(src.flagmedia)
{}


Data 
SipAccept::getMediaType() const
{
    return mediaType;
}

void 
SipAccept::setMediaType(const Data& srcmediaType)
{
    mediaType = srcmediaType;
    //when mediaType is set, the subTYpe is set as *.
    mediaSubtype = ALL_MEDIASUBTYPES;
}

Data 
SipAccept::getMediaSubtype() const
{
    return mediaSubtype;
}

void 
SipAccept::setMediaSubtype(const Data& srcmediaSubtype)
{
    mediaSubtype = srcmediaSubtype;
}

Data 
SipAccept::getqValue() const
{
    return qValue;
}

void 
SipAccept::setqValue(const Data& srcqValue)
{
    qValue = srcqValue;
}

Data 
SipAccept::getMediaToken() const
{
    return mediatoken;
}

void 
SipAccept::setMediaToken(const Data& srcToken)
{
    mediatoken = srcToken;
}

Data 
SipAccept::getMediaTokenValue() const
{
    return mediatokenValue;
}

void 
SipAccept::setMediaTokenValue(const Data& srcTokenValue)
{
    mediatokenValue = srcTokenValue;
}


void 
SipAccept::setAcceptExtensionParm(const Data& newaccepttoken)
{
    accepttoken = newaccepttoken;
}


void 
SipAccept::setAcceptExtensionValue(const Data& newaccepttokenvalue)
{
    accepttokenValue = newaccepttokenvalue;
}


Data 
SipAccept::getAccpetExtensionParm() const
{
    return accepttoken;
}


Data 
SipAccept::getAccpetExtensionValue() const
{
    return accepttokenValue;
}


/*** return the encoded string version of this. This call should only be
     used inside the stack and is not part of the API */
Data 
SipAccept::encode() const
{
    Data data;
    if (allmedia)
    {
        data = "*";
        data += "/";
        data += "*";
    }
    if (mediaType.length())
    {
        data = mediaType;
        data += "/";
        data += mediaSubtype;
    }

    if ( (mediatoken.length()) && (mediatokenValue.length()) )
    {
        data += SEMICOLON;
        data += mediatoken;
        data += "=";
        data += mediatokenValue;
    }

    if (qValue.length())
    {
        data += SEMICOLON;
        data += "q=";
        data += qValue;
    }

    if ((accepttoken.length()) && (accepttokenValue.length() == 0) )
    {
        data += SEMICOLON;
        data += accepttoken;

    }
    if ((accepttoken.length()) && (accepttokenValue.length()))
    {
        data += SEMICOLON;
        data += accepttoken;
        data += "=";
        data += accepttokenValue;
    }
    return data;
}






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


bool
SipAccept::compareSipHeader(SipHeader* msg) const
{
    SipAccept* otherMsg = dynamic_cast<SipAccept*>(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: */