diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SIP/Codec/src/CSIPEventHeader.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/realtimenetprots/sipfw/SIP/Codec/src/CSIPEventHeader.cpp Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,439 @@ +// Copyright (c) 2005-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 : CSIPEventHeader.cpp +// Part of : SIP Codec +// Version : SIP/4.0 +// + + + +#include "sipeventheader.h" +#include "CSIPEventHeaderParams.h" +#include "CSIPTokenizer.h" +#include "sipcodecerr.h" +#include "SIPSyntaxCheck.h" +#include "sipstrings.h" +#include "sipstrconsts.h" +#include "sipcodecutils.h" +#include "_sipcodecdefs.h" + +_LIT8(KDot, "."); + + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::DecodeL +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPEventHeader* CSIPEventHeader::DecodeL (const TDesC8& aValue) + { + CSIPEventHeader* eventHeader = new(ELeave) CSIPEventHeader; + CleanupStack::PushL(eventHeader); + eventHeader->ConstructL(); + eventHeader->ParseL(aValue); + CleanupStack::Pop(eventHeader); + return eventHeader; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::NewL +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPEventHeader* CSIPEventHeader::NewL(const TDesC8& aEventPackage) + { + CSIPEventHeader* self = CSIPEventHeader::NewLC(aEventPackage); + CleanupStack::Pop(self); + return self; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::NewLC +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPEventHeader* CSIPEventHeader::NewLC(const TDesC8& aEventPackage) + { + CSIPEventHeader* self=new(ELeave) CSIPEventHeader(); + CleanupStack::PushL(self); + self->ConstructL(aEventPackage); + return self; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::CSIPEventHeader +// ---------------------------------------------------------------------------- +// +CSIPEventHeader::CSIPEventHeader() +: CSIPParameterHeaderBase( ';' ) + { + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::ConstructL +// ---------------------------------------------------------------------------- +// +void CSIPEventHeader::ConstructL() + { + iParams = new(ELeave)CSIPEventHeaderParams; + iEventTemplates = new(ELeave) CDesC8ArraySeg(1); + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::ConstructL +// ---------------------------------------------------------------------------- +// +void CSIPEventHeader::ConstructL (const TDesC8& aEventPackage) + { + ConstructL (); + SetEventPackageL (aEventPackage); + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::ConstructL +// ---------------------------------------------------------------------------- +// +void CSIPEventHeader::ConstructL (const CSIPEventHeader& aSIPEventHeader) + { + iParams = CSIPEventHeaderParams::NewL (*(aSIPEventHeader.iParams)); + SetEventTemplatesL(*aSIPEventHeader.iEventTemplates); + SetEventPackageL(aSIPEventHeader.EventPackage()); + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::~CSIPEventHeader +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPEventHeader::~CSIPEventHeader() + { + delete iParams; + delete iEventPackage; + delete iEventTemplates; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::CloneL +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPHeaderBase* CSIPEventHeader::CloneL () const + { + CSIPEventHeader* clone = new(ELeave)CSIPEventHeader; + CleanupStack::PushL(clone); + clone->ConstructL(*this); + CleanupStack::Pop(clone); + return clone; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::Name +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +EXPORT_C RStringF CSIPEventHeader::Name() const + { + return SIPStrings::StringF(SipStrConsts::EEventHeader); + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::HasCompactName +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +TBool CSIPEventHeader::HasCompactName () const + { + return ETrue; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::CompactName +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +RStringF CSIPEventHeader::CompactName () const + { + return SIPStrings::StringF(SipStrConsts::EEventHeaderCompact); + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::operator== +// ---------------------------------------------------------------------------- +// +EXPORT_C TBool +CSIPEventHeader::operator==(const CSIPEventHeader& aSIPEventHeader) const + { + if(iEventPackage->Compare(*(aSIPEventHeader.iEventPackage)) != 0) + { + return EFalse; + } + + if(iEventTemplates->MdcaCount() != + aSIPEventHeader.iEventTemplates->MdcaCount()) + { + return EFalse; + } + for (TInt i=0; i < iEventTemplates->MdcaCount(); i++) + { + if(iEventTemplates->MdcaPoint(i) != + aSIPEventHeader.iEventTemplates->MdcaPoint(i)) + { + return EFalse; + } + } + return (*iParams == *(aSIPEventHeader.iParams)); + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::SetEventPackageL +// ---------------------------------------------------------------------------- +// +EXPORT_C void CSIPEventHeader::SetEventPackageL (const TDesC8& aEventPackage) + { + HBufC8* tmp = aEventPackage.AllocLC(); + tmp->Des().Trim(); + if (!SIPSyntaxCheck::Token(*tmp) || (tmp->Find(KDot) != KErrNotFound)) + { + User::Leave(KErrSipCodecEventHeader); + } + CleanupStack::Pop(tmp); + delete iEventPackage; + iEventPackage = tmp; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::EventPackage +// ---------------------------------------------------------------------------- +// +EXPORT_C const TDesC8& CSIPEventHeader::EventPackage() const + { + return *iEventPackage; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::SetEventTemplatesL +// ---------------------------------------------------------------------------- +// +EXPORT_C void CSIPEventHeader::SetEventTemplatesL( + const MDesC8Array& aEventTemplates) + { + CDesC8ArraySeg* eventTemplates = new(ELeave) CDesC8ArraySeg(1); + CleanupStack::PushL(eventTemplates); + for (TInt i=0; i < aEventTemplates.MdcaCount(); i++) + { + CheckTemplateL(aEventTemplates.MdcaPoint(i)); + eventTemplates->AppendL(aEventTemplates.MdcaPoint(i)); + } + CleanupStack::Pop(eventTemplates); + delete iEventTemplates; + iEventTemplates = eventTemplates; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::EventTemplates +// ---------------------------------------------------------------------------- +// +EXPORT_C const MDesC8Array& CSIPEventHeader::EventTemplates () const + { + return *iEventTemplates; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::InternalizeValueL +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPHeaderBase* CSIPEventHeader::InternalizeValueL( + RReadStream& aReadStream) + { + CSIPEventHeader* self = new(ELeave)CSIPEventHeader; + CleanupStack::PushL(self); + self->ConstructL(); + self->DoInternalizeValueL(aReadStream); + CleanupStack::Pop(self); + return self; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::CheckTemplateL +// ---------------------------------------------------------------------------- +// +void CSIPEventHeader::CheckTemplateL (const TDesC8& aParam) const + { + // event-template Param + if (!SIPSyntaxCheck::Token(aParam) || aParam.Find(KDot) != KErrNotFound) + { + User::Leave(KErrSipCodecEventHeader); + } + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::DoInternalizeValueL +// ---------------------------------------------------------------------------- +// +void CSIPEventHeader::DoInternalizeValueL (RReadStream& aReadStream) + { + iEventPackage = SIPCodecUtils::ReadDescFromStreamL(aReadStream); + TUint32 templateCount = aReadStream.ReadUint32L(); + + for (TUint32 i=0; i < templateCount; i++) + { + HBufC8* value = SIPCodecUtils::ReadDescFromStreamL(aReadStream); + CleanupStack::PushL(value); + iEventTemplates->AppendL(*value); + CleanupStack::PopAndDestroy(value); + } + + delete iParams; + iParams = NULL; + iParams = CSIPEventHeaderParams::InternalizeL(aReadStream); + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::ExternalizeValueL +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +void CSIPEventHeader::ExternalizeValueL (RWriteStream& aWriteStream) const + { + aWriteStream.WriteUint32L (iEventPackage->Length()); + if (iEventPackage->Length() > 0) + { + aWriteStream.WriteL (EventPackage()); + } + + aWriteStream.WriteUint32L (iEventTemplates->MdcaCount()); + for (TInt i=0; i < iEventTemplates->MdcaCount(); i++) + { + aWriteStream.WriteUint32L (iEventTemplates->MdcaPoint(i).Length()); + aWriteStream.WriteL (iEventTemplates->MdcaPoint(i)); + } + iParams->ExternalizeL (aWriteStream); + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::PreferredPlaceInMessage +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +CSIPHeaderBase::TPreferredPlace +CSIPEventHeader::PreferredPlaceInMessage () const + { + return CSIPHeaderBase::EBottom; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::BaseDecodeL +// ---------------------------------------------------------------------------- +// +RPointerArray CSIPEventHeader::BaseDecodeL( + const TDesC8& aValue) + { + CSIPEventHeader* eventHeader = new(ELeave) CSIPEventHeader; + CleanupStack::PushL(eventHeader); + eventHeader->ConstructL(); + eventHeader->ParseL(aValue); + RPointerArray headerArray; + headerArray.AppendL(eventHeader); + CleanupStack::Pop(eventHeader); + return headerArray; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::ToTextMandatoryPartLC +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +HBufC8* CSIPEventHeader::ToTextMandatoryPartLC () const + { + TUint encodedLength = 0; + RPointerArray templatesAsText; + CleanupStack::PushL (TCleanupItem(ResetAndDestroy,&templatesAsText)); + + encodedLength += iEventPackage->Length(); + for (TInt i=0; i < iEventTemplates->MdcaCount(); i++) + { + HBufC8* templateAsText = (iEventTemplates->MdcaPoint(i)).AllocLC(); + encodedLength += templateAsText->Length() + 1;// param separator length + templatesAsText.AppendL(templateAsText); + CleanupStack::Pop(templateAsText); + } + + HBufC8* encodedHeader = HBufC8::NewL (encodedLength); + TPtr8 encodedHeaderPtr = encodedHeader->Des(); + + encodedHeaderPtr.Append(*iEventPackage); + + for (TInt j=0; j < templatesAsText.Count(); j++) + { + encodedHeaderPtr.Append('.'); // dot + encodedHeaderPtr.Append (*templatesAsText[j]); + } + + CleanupStack::PopAndDestroy(); // templatesAsText + CleanupStack::PushL(encodedHeader); + return encodedHeader; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::ParseMandatoryPartL +// ---------------------------------------------------------------------------- +// +void CSIPEventHeader::ParseMandatoryPartL (const TDesC8& aMandatoryPart) + { + __ASSERT_ALWAYS (aMandatoryPart.Length() > 0, + User::Leave (KErrSipCodecEventHeader)); + HBufC8* tmp = aMandatoryPart.AllocLC(); + tmp->Des().Trim(); + + TLex8 lex(*tmp); + lex.SkipSpace(); + CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(lex.Remainder(), '.'); + + TLex8 lex2(tokenizer->Tokens()[0]); + SetEventPackageL(lex2.Remainder()); + + for (TInt j=1; j < tokenizer->Tokens().Count(); j++) + { + CheckTemplateL((tokenizer->Tokens()[j])); + iEventTemplates->AppendL((tokenizer->Tokens()[j])); + } + + CleanupStack::PopAndDestroy(tokenizer); + CleanupStack::PopAndDestroy(tmp); + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::Params +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +const CSIPParamContainerBase& CSIPEventHeader::Params () const + { + return *iParams; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::Params +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +CSIPParamContainerBase& CSIPEventHeader::Params () + { + return *iParams; + } + +// ---------------------------------------------------------------------------- +// CSIPEventHeader::ResetAndDestroy +// ---------------------------------------------------------------------------- +// +void CSIPEventHeader::ResetAndDestroy (TAny* anArray) + { + (reinterpret_cast*> (anArray))->ResetAndDestroy(); + }