diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SIP/Codec/src/CSIPAcceptHeader.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/realtimenetprots/sipfw/SIP/Codec/src/CSIPAcceptHeader.cpp Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,431 @@ +// 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 : CSIPAcceptHeader.cpp +// Part of : SIP Codec +// Version : SIP/4.0 +// + + + + +#include "sipacceptheader.h" +#include "CSIPAcceptHeaderParams.h" +#include "SIPSyntaxCheck.h" +#include "CSIPTokenizer.h" +#include "sipcodecerr.h" +#include "sipstrings.h" +#include "sipstrconsts.h" +#include "sipcodecutils.h" +#include "_sipcodecdefs.h" + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::DecodeL +// ---------------------------------------------------------------------------- +// +EXPORT_C RPointerArray +CSIPAcceptHeader::DecodeL (const TDesC8& aValue) + { + RPointerArray baseheaders = BaseDecodeL(aValue); + CSIPHeaderBase::PushLC(&baseheaders); + RPointerArray acceptHeaders; + CleanupClosePushL(acceptHeaders); + TInt count = baseheaders.Count(); + for (TInt i=0; i < count; i++) + { + CSIPAcceptHeader* header = + static_cast(baseheaders[i]); + User::LeaveIfError (acceptHeaders.Append(header)); + } + CleanupStack::Pop(2); //acceptHeaders, baseheaders + baseheaders.Close(); + return acceptHeaders; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::NewL +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPAcceptHeader* CSIPAcceptHeader::NewL ( + const TDesC8& aMediaType, + const TDesC8& aMediaSubtype) + { + CSIPAcceptHeader* self = + CSIPAcceptHeader::NewLC (aMediaType,aMediaSubtype); + CleanupStack::Pop(self); + return self; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::NewLC +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPAcceptHeader* CSIPAcceptHeader::NewLC ( + const TDesC8& aMediaType, + const TDesC8& aMediaSubtype) + { + CSIPAcceptHeader* self = new(ELeave)CSIPAcceptHeader; + CleanupStack::PushL(self); + self->ConstructL(aMediaType,aMediaSubtype); + return self; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::CSIPAcceptHeader +// ---------------------------------------------------------------------------- +// +CSIPAcceptHeader::CSIPAcceptHeader(TBool aEmpty) + : CSIPParameterHeaderBase( ';' ), iEmpty(aEmpty) + { + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::ConstructL +// ---------------------------------------------------------------------------- +// +void CSIPAcceptHeader::ConstructL () + { + iParams = new(ELeave)CSIPAcceptHeaderParams; + iMediaType = KNullDesC8().AllocL(); + iMediaSubtype = KNullDesC8().AllocL(); + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::ConstructL +// ---------------------------------------------------------------------------- +// +void CSIPAcceptHeader::ConstructL (const TDesC8& aMediaType, + const TDesC8& aMediaSubtype) + { + iParams = new(ELeave)CSIPAcceptHeaderParams; + SetMediaTypeL (aMediaType); + SetMediaSubtypeL (aMediaSubtype); + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::ConstructL +// ---------------------------------------------------------------------------- +// +void CSIPAcceptHeader::ConstructL (const CSIPAcceptHeader& aAcceptHeader) + { + if (iEmpty) + { + ConstructL (); + } + else + { + SetMediaTypeL (aAcceptHeader.MediaType()); + SetMediaSubtypeL (aAcceptHeader.MediaSubtype()); + iParams = CSIPAcceptHeaderParams::NewL(*(aAcceptHeader.iParams)); + } + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::~CSIPAcceptHeader +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPAcceptHeader::~CSIPAcceptHeader() + { + delete iParams; + delete iMediaSubtype; + delete iMediaType; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::CloneL +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPHeaderBase* CSIPAcceptHeader::CloneL () const + { + CSIPAcceptHeader* clone = new (ELeave) CSIPAcceptHeader(iEmpty); + CleanupStack::PushL(clone); + clone->ConstructL(*this); + CleanupStack::Pop(clone); + return clone; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::Name +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +EXPORT_C RStringF CSIPAcceptHeader::Name () const + { + return SIPStrings::StringF(SipStrConsts::EAcceptHeader); + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::IsEmpty +// ---------------------------------------------------------------------------- +// +EXPORT_C TBool CSIPAcceptHeader::IsEmpty () const + { + return iEmpty; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::MediaType +// ---------------------------------------------------------------------------- +// +EXPORT_C const TDesC8& CSIPAcceptHeader::MediaType () const + { + return *iMediaType; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::SetMediaTypeL +// ---------------------------------------------------------------------------- +// +EXPORT_C void CSIPAcceptHeader::SetMediaTypeL (const TDesC8& aMediaType) + { + __ASSERT_ALWAYS (!iEmpty, User::Leave(KErrArgument)); + SIPCodecUtils::CheckAndSetValueL(iMediaType, + aMediaType, + KErrSipCodecAcceptHeader); + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::MediaSubtype +// ---------------------------------------------------------------------------- +// +EXPORT_C const TDesC8& CSIPAcceptHeader::MediaSubtype () const + { + return *iMediaSubtype; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::SetMediaSubtypeL +// ---------------------------------------------------------------------------- +// +EXPORT_C void +CSIPAcceptHeader::SetMediaSubtypeL (const TDesC8& aMediaSubtype) + { + __ASSERT_ALWAYS (!iEmpty, User::Leave(KErrArgument)); + HBufC8* tmp = aMediaSubtype.AllocLC(); + tmp->Des().Trim(); + if (!SIPSyntaxCheck::Token(*tmp)) + { + User::Leave(KErrSipCodecAcceptHeader); + } + CleanupStack::Pop(tmp); + delete iMediaSubtype; + iMediaSubtype = tmp; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::QParameter +// ---------------------------------------------------------------------------- +// +EXPORT_C TReal CSIPAcceptHeader::QParameter () const + { + return iParams->RealParamValue(SIPStrings::StringF(SipStrConsts::EQ)); + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::SetQParameterL +// ---------------------------------------------------------------------------- +// +EXPORT_C void CSIPAcceptHeader::SetQParameterL (TReal aQValue) + { + __ASSERT_ALWAYS (!iEmpty, User::Leave(KErrArgument)); + iParams->SetParamL(SIPStrings::StringF(SipStrConsts::EQ), aQValue); + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::MoreThanOneAllowed +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +TBool CSIPAcceptHeader::MoreThanOneAllowed () const + { + return ETrue; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::InternalizeValueL +// ---------------------------------------------------------------------------- +// +EXPORT_C CSIPHeaderBase* CSIPAcceptHeader::InternalizeValueL ( + RReadStream& aReadStream) + { + CSIPAcceptHeader* self = new(ELeave)CSIPAcceptHeader; + CleanupStack::PushL(self); + self->DoInternalizeValueL(aReadStream); + CleanupStack::Pop(self); + return self; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::ExternalizeValueL +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +void CSIPAcceptHeader::ExternalizeValueL(RWriteStream& aWriteStream) const + { + if (!iEmpty) + { + aWriteStream.WriteUint8L(1); + aWriteStream.WriteUint32L (iMediaType->Length()); + aWriteStream.WriteL (*iMediaType); + aWriteStream.WriteUint32L (iMediaSubtype->Length()); + aWriteStream.WriteL (*iMediaSubtype); + iParams->ExternalizeL (aWriteStream); + } + else + { + aWriteStream.WriteUint8L(0); + } + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::DoInternalizeValueL +// ---------------------------------------------------------------------------- +// +void CSIPAcceptHeader::DoInternalizeValueL(RReadStream& aReadStream) + { + if (aReadStream.ReadUint8L()) // not empty + { + iMediaType = SIPCodecUtils::ReadDescFromStreamL(aReadStream); + iMediaSubtype = SIPCodecUtils::ReadDescFromStreamL(aReadStream); + iParams = CSIPAcceptHeaderParams::InternalizeL(aReadStream); + } + else + { + iEmpty = ETrue; + ConstructL(); + } + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::PreferredPlaceInMessage +// From CSIPHeaderBase: +// ---------------------------------------------------------------------------- +// +CSIPHeaderBase::TPreferredPlace +CSIPAcceptHeader::PreferredPlaceInMessage () const + { + return CSIPHeaderBase::EBottom; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::BaseDecodeL +// ---------------------------------------------------------------------------- +// +RPointerArray +CSIPAcceptHeader::BaseDecodeL(const TDesC8& aValue) + { + RPointerArray headers; + CSIPHeaderBase::PushLC(&headers); + TLex8 lex(aValue); + lex.SkipSpace(); + TPtrC8 remainder(lex.Remainder()); + + if (remainder.Length() == 0) + { + CSIPAcceptHeader* header = new(ELeave)CSIPAcceptHeader(ETrue); + CleanupStack::PushL(header); + header->ConstructL(); + headers.AppendL(header); + CleanupStack::Pop(header); + } + else + { + CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(remainder, ','); + for (TInt i=0; i < tokenizer->Tokens().Count(); i++) + { + CSIPAcceptHeader* header = new(ELeave)CSIPAcceptHeader; + CleanupStack::PushL (header); + header->ConstructL(); + header->ParseL(tokenizer->Tokens()[i]); + headers.AppendL(header); + CleanupStack::Pop(header); + } + CleanupStack::PopAndDestroy(tokenizer); + } + + CleanupStack::Pop(); // headers + return headers; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::ToTextMandatoryPartLC +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +HBufC8* CSIPAcceptHeader::ToTextMandatoryPartLC () const + { + HBufC8* encodingResult = 0; + if (!iEmpty) + { + TUint encodedLength = iMediaType->Length() + 1; // SLASH + encodedLength += iMediaSubtype->Length(); + + encodingResult = HBufC8::NewLC (encodedLength); + TPtr8 encodingResultPtr = encodingResult->Des(); + + encodingResultPtr.Append(*iMediaType); + encodingResultPtr.Append('/'); // SLASH + encodingResultPtr.Append(*iMediaSubtype); + } + else + { + encodingResult = KNullDesC8().AllocLC(); + } + return encodingResult; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::ParseMandatoryPartL +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +void CSIPAcceptHeader::ParseMandatoryPartL (const TDesC8& aMandatoryPart) + { + __ASSERT_ALWAYS (aMandatoryPart.Length() > 0, + User::Leave(KErrSipCodecAcceptHeader)); + TLex8 lex(aMandatoryPart); + lex.SkipSpace(); + TPtrC8 remainder(lex.Remainder()); + + const TInt KMaxSlashPos = remainder.Length()-2; + TInt slashPos = remainder.Locate('/'); + if (slashPos <= 0 || slashPos > KMaxSlashPos) + { + User::Leave (KErrSipCodecAcceptHeader); + } + + SetMediaTypeL (remainder.Left(slashPos)); + remainder.Set(remainder.Mid(slashPos+1)); + SetMediaSubtypeL (remainder); + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::Params +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +const CSIPParamContainerBase& CSIPAcceptHeader::Params () const + { + return *iParams; + } + +// ---------------------------------------------------------------------------- +// CSIPAcceptHeader::Params +// From CSIPParameterHeaderBase: +// ---------------------------------------------------------------------------- +// +CSIPParamContainerBase& CSIPAcceptHeader::Params () + { + return *iParams; + }