sipfrom.cxx

SIP（Session Initiation Protocol）是由IETF定义

/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact [e-mail].
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 */

static const char* const SipFrom_cxx_Version =
    "$Id: SipFrom.cxx,v 1.83 2002/11/09 02:15:50 derekm Exp $";

#include "global.h"
#include "SipFrom.hxx"
#include "symbols.hxx"
#include "cpLog.h"
#include "SipParserMode.hxx"
#include "SipUrl.hxx"
#include "TelUrl.hxx"
#include "NullUrl.hxx"
#include "SipTo.hxx"

using namespace Vocal;


string
SipFromParserException::getName( void ) const
{
    return "SipFromParserException";
}


SipFrom::SipFrom(UrlType uType)
        :
        displayName(),
        fromUrl(),
        tag(),
        token(),
        qstring(),
        tokenMap()

{
    urlType = uType;  //will be used to create Url objects, during set operation
}


SipFrom::SipFrom(Sptr <BaseUrl> src)
        :
        displayName(),
        fromUrl(duplicateUrl(src)),
        urlType(UNKNOWN_URL),
        tag(),
        token(),
        qstring(),
        tokenMap()

{
    if (fromUrl != 0)
    {
	if (fromUrl->getType() == SIP_URL)
	{
            urlType = SIP_URL;
	    Sptr <SipUrl> sipUrl;
	    sipUrl.dynamicCast(fromUrl);
	    sipUrl->initializeFrom();
	}
    }
}


SipFrom::SipFrom(const SipFrom& src)
        :
        displayName(src.displayName),
        fromUrl(duplicateUrl(src.fromUrl)),
        urlType(src.urlType),
        tag(src.tag),
        token(src.token),
        qstring(src.qstring),
        tokenMap(src.tokenMap)

{
    if (fromUrl != 0)
    {
	if (fromUrl->getType() == SIP_URL)
	{
	    Sptr <SipUrl> sipUrl;
	    sipUrl.dynamicCast(fromUrl);
	    sipUrl->initializeFrom();
	}
    }
}

SipFrom::SipFrom(const SipTo& src) 
    :
    displayName(src.getDisplayName()),
    fromUrl(src.getUrl()),
    urlType(fromUrl->getType()),
        tag(src.getTag()),
        token(src.getToken()),
        qstring(src.getQstring()),
        tokenMap(*src.getTokenDetails())
{
    if (fromUrl != 0)
    {
	if (fromUrl->getType() == SIP_URL)
	{
	    Sptr <SipUrl> sipUrl;
	    sipUrl.dynamicCast(fromUrl);
	    sipUrl->initializeFrom();
	}
    }
}

const SipFrom& 
SipFrom::operator =(const SipFrom& src)
{
    if (&src != this)
    {
        displayName = src.displayName;
        fromUrl = duplicateUrl(src.fromUrl);
        urlType = src.urlType;
        tag = src.tag;
        token = src.token;
        qstring = src.qstring;
        tokenMap = src.tokenMap;
	if (fromUrl != 0)
	{
	    if (fromUrl->getType() == SIP_URL)
	    {
		Sptr <SipUrl> sipUrl;
		sipUrl.dynamicCast(fromUrl);
		sipUrl->initializeFrom();
	    }
	}

    }
    return (*this);
}


SipFrom::SipFrom( const Data& data )
        :
        displayName(),
        fromUrl(),
        tag(),
        qstring(),
        tokenMap()
{
    try
    {
        decode(data);
	if (fromUrl != 0)
	{
	    if (fromUrl->getType() == SIP_URL)
	    {
		Sptr <SipUrl> sipUrl;
		sipUrl.dynamicCast(fromUrl);
		sipUrl->initializeFrom();
	    }
	}
    }
    catch (SipFromParserException&)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Decode in Constructor :o( ");
            throw SipFromParserException(
                "failed to decode the From string",
                __FILE__,
                __LINE__, DECODE_FROM_FAILED);
        }
    }
}


void
SipFrom::scanSipFrom( const Data & tmpdata)
{
    Data sipdata;
    Data data = tmpdata;
    int ret = data.match("<", &sipdata, true);
    if (ret == NOT_FOUND)
    {
        Data value;
        Data tmpval;
        int retn = data.match(";", &value, true) ;
        if (retn == NOT_FOUND)
        {  // it's Ok becos it Can be URl only since Addrs. Params are Optional
            tmpval = value;

            fromUrl = BaseUrl::decode(data);
            urlType = fromUrl->getType();
        }
        else if (retn == FIRST)
        {
            if (SipParserMode::sipParserMode())
            {
                cpLog(LOG_ERR, "Failed to Decode in ScanSIPFrom :o( ");
                throw SipFromParserException("failed in Decode", __FILE__, __LINE__, DECODE_FROM_FAILED);

            }

        }
        else if (retn == FOUND)
        { // if found then it has the Addrs-params
            tmpval = value;

            fromUrl = BaseUrl::decode(tmpval);
            value = data;
            parseAddrParam(value);
        }

    }
    else if (ret == FIRST)
    {
        try
        {
            parseUrl(data);
        }
        catch (SipFromParserException&)
        {
            if (SipParserMode::sipParserMode())
            {
                cpLog(LOG_ERR, "Failed to Decode in ScanSIPFrom :o( ");
                throw SipFromParserException("failed in Decode in scanSipFrom", __FILE__, __LINE__, URL_FAILED);

            }

        }

    }

    else if (ret == FOUND)
    {
        parseNameInfo(sipdata);
        Data urlvalue;
        parseUrl(data);
    }
}


void
SipFrom::parseUrl(const Data& data)
{
    Data urlvalue = data;
    Data avalue;
    int retur = urlvalue.match(">", &avalue, true);
    if (retur == NOT_FOUND)
    {
        if (SipParserMode::sipParserMode())
        {
            cpLog(LOG_ERR, "Failed to Parse in ParseUrl() :o( ");
            throw SipFromParserException("failed in Decode", __FILE__, __LINE__, URL_FAILED);

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

        }
    }
    else if (retur == FOUND)
    {
        avalue.removeSpaces(); //Fix for PINGTEL SPACES
   
        fromUrl = BaseUrl::decode(avalue);
        Data te = urlvalue;
        Data fik;
        //remove spaces since of form <url>SP;tag= (pingtel bug)
        te.removeSpaces();
        int rety = te.match(";", &fik, true);
        if (rety == FOUND)
        {
            if (SipParserMode::sipParserMode())
            {
                cpLog(LOG_ERR, "Failed to Parse in ParseUrl()  :o( ");
                throw SipFromParserException("failed in Decode", __FILE__, __LINE__, URL_FAILED);

            }
        }
        else if (rety == FIRST)
        {
            parseAddrParam(te);
        }
        else if (rety == NOT_FOUND)
        {}

    }
}


void
SipFrom::parseNameInfo(const Data& data)
{
    Data newnameinfo;
    Data nameinfo = data;
    //nameinfo.removeSpaces();  // !jf! to handle problem with 7960
    setDisplayName(nameinfo);

}


void
SipFrom::parseAddrParam(const Data& data)
{
    Data addrparm = data;
    Data parm;
    while (1)
    {
        int ret = addrparm.match(";", &parm, true);
        if (ret == NOT_FOUND)
        {
            parseAddrParamExt(addrparm);
            break;
        }
        else if (ret == FIRST)
        {}

        else if (ret == FOUND)
        {
            parseAddrParamExt(parm);
        }
    }
}


void
SipFrom::parseAddrParamExt(const Data& newdat)
{
    Data checkdata = newdat;
    Data parmvalue;
    int retn = checkdata.match("=", &parmvalue, true);
    if (retn == NOT_FOUND)
    {
        tokenMap[checkdata] = "";
    }
    else if (retn == FIRST)
    {
    }

    else if (retn == FOUND)
    {
        parmvalue.removeSpaces();
        parseTag(parmvalue, checkdata);
    }
}


void
SipFrom::parseTag(const Data& ltoken, const Data& vdata)
{
    if (ltoken == TAG_CHECK)
    {
        tag = vdata;
        tag.removeSpaces();
    }
    else
    {
        Data copy = ltoken;
        Data copy2 = vdata;
        copy.removeSpaces();
        copy2.removeSpaces();