diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SIP/Codec/src/CSIPContactHeader.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/realtimenetprots/sipfw/SIP/Codec/src/CSIPContactHeader.cpp Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,490 @@ +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// Name : CSIPContactHeader.cpp +// Part of : SIP Codec +// Version : SIP/4.0 +// + + + + +#include "sipcontactheader.h" +#include "sipaddress.h" +#include "sipuri.h" +#include "CSIPContactHeaderParams.h" +#include "CSIPTokenizer.h" +#include "sipcodecerr.h" +#include "sipstrings.h" +#include "sipstrconsts.h" +#include "uricontainer.h" +#include "_sipcodecdefs.h" + +_LIT8 (KStar, "*"); + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::DecodeL +// ---------------------------------------------------------------------------- +// +EXPORT_C RPointerArray +CSIPContactHeader::DecodeL (const TDesC8& aValue) + { + RPointerArray baseheaders = BaseDecodeL(aValue); + CSIPHeaderBase::PushLC(&baseheaders); + RPointerArray contactHeaders; + CleanupClosePushL(contactHeaders); + TInt count = baseheaders.Count(); + for (TInt i=0; i(baseheaders[i]); + User::LeaveIfError(contactHeaders.Append(contact)); + } + CleanupStack::Pop(2); // contactHeaders, baseheaders + baseheaders.Close(); + return contactHeaders; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::NewL +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPContactHeader* CSIPContactHeader::NewL(CSIPAddress* aSIPAddress) + { + CSIPContactHeader* self = CSIPContactHeader::NewLC(aSIPAddress); + CleanupStack::Pop(self); + return self; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::NewLC +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPContactHeader* CSIPContactHeader::NewLC(CSIPAddress* aSIPAddress) + { + CSIPContactHeader* self = new(ELeave)CSIPContactHeader; + CleanupStack::PushL(self); + self->ConstructL(aSIPAddress); + return self; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::CSIPContactHeader +// ---------------------------------------------------------------------------- +// +CSIPContactHeader::CSIPContactHeader(TBool aIsStar) + : CSIPParameterHeaderBase(';'), + iIsStar (aIsStar) + { + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::ConstructL +// ---------------------------------------------------------------------------- +// +void CSIPContactHeader::ConstructL () + { + iParams = new(ELeave)CSIPContactHeaderParams; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::ConstructL +// ---------------------------------------------------------------------------- +// +void CSIPContactHeader::ConstructL (CSIPAddress* aSIPAddress) + { + ConstructL (); + SetSIPAddressL (aSIPAddress); + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::ConstructL +// ---------------------------------------------------------------------------- +// +void CSIPContactHeader::ConstructL (const CSIPContactHeader& aContactHeader) + { + if (aContactHeader.Star()) + { + iIsStar = ETrue; + ConstructL (); + } + else + { + iParams = CSIPContactHeaderParams::NewL (*(aContactHeader.iParams)); + iSIPAddress = CSIPAddress::NewL (*(aContactHeader.iSIPAddress)); + } + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::~CSIPContactHeader +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPContactHeader::~CSIPContactHeader() + { + delete iParams; + delete iSIPAddress; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::CloneL +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPHeaderBase* CSIPContactHeader::CloneL () const + { + CSIPContactHeader* clone = new(ELeave)CSIPContactHeader; + CleanupStack::PushL(clone); + clone->ConstructL(*this); + CleanupStack::Pop(clone); + return clone; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::operator== +// ---------------------------------------------------------------------------- +// +EXPORT_C TBool +CSIPContactHeader::operator==(const CSIPContactHeader& aSIPContactHeader) const + { + if (aSIPContactHeader.Star() != iIsStar) + { + return EFalse; + } + if (iIsStar) + { + return ETrue; + } + if (!(*iSIPAddress == *(aSIPContactHeader.SIPAddress()))) + { + return EFalse; + } + return (*iParams == *(aSIPContactHeader.iParams)); + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::ExpiresParameter +// ---------------------------------------------------------------------------- +// +EXPORT_C TInt CSIPContactHeader::ExpiresParameter () const + { + if (iIsStar) + { + return 0; + } + RStringF expires = SIPStrings::StringF(SipStrConsts::EExpires); + return iParams->IntParamValue(expires); + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::SetExpiresParameterL +// ---------------------------------------------------------------------------- +// +EXPORT_C void CSIPContactHeader::SetExpiresParameterL (TInt aExpiresParam) + { + __ASSERT_ALWAYS (!iIsStar, User::Leave(KErrSipCodecContactSetToStar)); + RStringF expires = SIPStrings::StringF(SipStrConsts::EExpires); + iParams->SetParamL(expires,aExpiresParam); + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::QParameter +// ---------------------------------------------------------------------------- +// +EXPORT_C TReal CSIPContactHeader::QParameter () const + { + if (iIsStar) + { + return 0; + } + return iParams->RealParamValue(SIPStrings::StringF(SipStrConsts::EQ)); + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::SetQParameterL +// ---------------------------------------------------------------------------- +// +EXPORT_C void CSIPContactHeader::SetQParameterL (TReal aQValue) + { + __ASSERT_ALWAYS (!iIsStar, + User::Leave(KErrSipCodecContactSetToStar)); + iParams->SetParamL(SIPStrings::StringF(SipStrConsts::EQ),aQValue); + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::Star +// ---------------------------------------------------------------------------- +// +EXPORT_C TBool CSIPContactHeader::Star () const + { + return iIsStar; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::SIPAddress +// ---------------------------------------------------------------------------- +// +EXPORT_C const CSIPAddress* CSIPContactHeader::SIPAddress() const + { + return iSIPAddress; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::SIPAddress +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPAddress* CSIPContactHeader::SIPAddress() + { + return iSIPAddress; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::SetSIPAddressL +// ---------------------------------------------------------------------------- +// +EXPORT_C void CSIPContactHeader::SetSIPAddressL (CSIPAddress* aSIPAddress) + { + __ASSERT_ALWAYS (!iIsStar, + User::Leave(KErrSipCodecContactSetToStar)); + __ASSERT_ALWAYS (aSIPAddress != 0, + User::Leave(KErrSipCodecContactAddress)); + + delete iSIPAddress; + iSIPAddress = aSIPAddress; + + if(iSIPAddress->URI().IsSIPURI()) + { + CSIPURI& sipURI = *(iSIPAddress->URI().SIPURI()); + sipURI.DeleteParam(SIPStrings::StringF(SipStrConsts::EMethod)); + } + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::MoreThanOneAllowed +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +TBool CSIPContactHeader::MoreThanOneAllowed () const + { + return ETrue; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::Name +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +EXPORT_C RStringF CSIPContactHeader::Name() const + { + return SIPStrings::StringF(SipStrConsts::EContactHeader); + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::HasCompactName +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +TBool CSIPContactHeader::HasCompactName () const + { + return ETrue; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::CompactName +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +RStringF CSIPContactHeader::CompactName () const + { + return SIPStrings::StringF(SipStrConsts::EContactHeaderCompact); + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::InternalizeValueL +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPHeaderBase* CSIPContactHeader::InternalizeValueL( + RReadStream& aReadStream) + { + CSIPContactHeader* self = new(ELeave)CSIPContactHeader(EFalse); + CleanupStack::PushL(self); + self->DoInternalizeValueL(aReadStream); + CleanupStack::Pop(self); + return self; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::ExternalizeValueL +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +void CSIPContactHeader::ExternalizeValueL (RWriteStream& aWriteStream) const + { + if (iIsStar) + { + aWriteStream.WriteUint8L(1); + } + else + { + aWriteStream.WriteUint8L(0); + iSIPAddress->ExternalizeL(aWriteStream); + iParams->ExternalizeL (aWriteStream); + } + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::DoInternalizeValueL +// ---------------------------------------------------------------------------- +// +void CSIPContactHeader::DoInternalizeValueL (RReadStream& aReadStream) + { + if (aReadStream.ReadUint8L() == 1) // is STAR + { + iIsStar = ETrue; + iParams = new(ELeave)CSIPContactHeaderParams; + } + else + { + iIsStar = EFalse; + CSIPAddress* tmpAddr = CSIPAddress::InternalizeL (aReadStream); + CleanupStack::PushL(tmpAddr); + SetSIPAddressL(tmpAddr); + CleanupStack::Pop(tmpAddr); + iParams = CSIPContactHeaderParams::InternalizeL (aReadStream); + } + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::PreferredPlaceInMessage +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +CSIPHeaderBase::TPreferredPlace +CSIPContactHeader::PreferredPlaceInMessage () const + { + return CSIPHeaderBase::EMiddleTop; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::BaseDecodeL +// ---------------------------------------------------------------------------- +// +RPointerArray +CSIPContactHeader::BaseDecodeL (const TDesC8& aValue) + { + __ASSERT_ALWAYS (aValue.Length() > 0, + User::Leave(KErrSipCodecContactHeader)); + + RPointerArray headers; + CSIPHeaderBase::PushLC(&headers); + CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(aValue, ',', ETrue); + TBool star=EFalse; + for (TInt i=0; i < tokenizer->Tokens().Count(); i++) + { + CSIPContactHeader* contactHeader = new(ELeave)CSIPContactHeader; + CleanupStack::PushL(contactHeader); + contactHeader->ConstructL(); + contactHeader->ParseL (tokenizer->Tokens()[i], ETrue, ETrue); + if (!star) star = contactHeader->iIsStar; + if (star && i > 0) + { + User::Leave(KErrSipCodecContactSetToStar); + } + headers.AppendL(contactHeader); + CleanupStack::Pop(contactHeader); + } + CleanupStack::PopAndDestroy(tokenizer); + CleanupStack::Pop(); // headers + return headers; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::ParamInsertionAllowed +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +TBool CSIPContactHeader::ParamInsertionAllowed () const + { + return !(iIsStar); + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::ToTextMandatoryPartLC +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +HBufC8* CSIPContactHeader::ToTextMandatoryPartLC () const + { + if (iIsStar) + { + return KStar().AllocLC(); + } + return iSIPAddress->ToTextLC(ETrue); + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::ParseMandatoryPartL +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +void CSIPContactHeader::ParseMandatoryPartL (const TDesC8& aMandatoryPart) + { + TLex8 lex(aMandatoryPart); + lex.SkipSpace(); + if (lex.Peek() == '*') + { + lex.Inc(); + lex.SkipSpace(); + if (lex.Remainder().Length() > 0) + { + User::Leave(KErrSipCodecContactHeader); + } + iIsStar = ETrue; + } + else + { + CSIPAddress* sipAddress = CSIPAddress::DecodeL(lex.Remainder()); + CleanupStack::PushL(sipAddress); + SetSIPAddressL(sipAddress); + CleanupStack::Pop(sipAddress); + } + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::Params +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +const CSIPParamContainerBase& CSIPContactHeader::Params () const + { + return *iParams; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::Params +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +CSIPParamContainerBase& CSIPContactHeader::Params () + { + return *iParams; + } + +// ---------------------------------------------------------------------------- +// CSIPContactHeader::RemoveExpiresParam +// ---------------------------------------------------------------------------- +// +EXPORT_C void CSIPContactHeader::RemoveExpiresParam() + { + RStringF expires = SIPStrings::StringF(SipStrConsts::EExpires); + iParams->DeleteParam(expires); + }