diff -r 000000000000 -r 307788aac0a8 realtimenetprots/sipfw/SIP/Codec/src/CSIPViaHeader.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/realtimenetprots/sipfw/SIP/Codec/src/CSIPViaHeader.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 : CSIPViaHeader.cpp +// Part of : SIP Codec +// Version : SIP/4.0 +// + + + + +#include "sipviaheader.h" +#include "CSIPViaHeaderParams.h" +#include "CSIPTokenizer.h" +#include "siphostport.h" +#include "sipcodecerr.h" +#include "SIPSyntaxCheck.h" +#include "sipstrings.h" +#include "sipstrconsts.h" +#include "sipcodecutils.h" +#include "_sipcodecdefs.h" + + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::DecodeL +// ----------------------------------------------------------------------------- +// +EXPORT_C RPointerArray +CSIPViaHeader::DecodeL (const TDesC8& aValue) + { + RPointerArray baseheaders = BaseDecodeL(aValue); + CSIPHeaderBase::PushLC(&baseheaders); + RPointerArray viaheaders; + CleanupClosePushL(viaheaders); + TInt count = baseheaders.Count(); + for (TInt i=0; i(baseheaders[i]); + viaheaders.AppendL(via); + } + CleanupStack::Pop(2); // viaheaders, baseheaders + baseheaders.Close(); + return viaheaders; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::NewL +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPViaHeader* CSIPViaHeader::NewL (RStringF aTransport, + CSIPHostPort* aSentByHostPort) + { + CSIPViaHeader* self = CSIPViaHeader::NewLC (aTransport,aSentByHostPort); + CleanupStack::Pop(self); + return self; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::NewLC +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPViaHeader* CSIPViaHeader::NewLC (RStringF aTransport, + CSIPHostPort* aSentByHostPort) + { + CSIPViaHeader* self = new(ELeave)CSIPViaHeader; + CleanupStack::PushL(self); + self->ConstructL(aTransport,aSentByHostPort); + return self; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::CSIPViaHeader +// ----------------------------------------------------------------------------- +// +CSIPViaHeader::CSIPViaHeader() + : CSIPParameterHeaderBase(';') + { + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::ConstructL +// ----------------------------------------------------------------------------- +// +void CSIPViaHeader::ConstructL() + { + iSentProtocolName = SIPStrings::StringF(SipStrConsts::ESIP); + iSentProtocolVersion = + SIPStrings::StringF(SipStrConsts::EDefaultVersionNumber); + iParams = new(ELeave)CSIPViaHeaderParams; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::ConstructL +// ----------------------------------------------------------------------------- +// +void CSIPViaHeader::ConstructL(RStringF aTransport, + CSIPHostPort* aSentByHostPort) + { + __ASSERT_ALWAYS(aSentByHostPort, User::Leave(KErrArgument)); + + ConstructL(); + SetTransportL(aTransport); + iSentByHostPort = aSentByHostPort; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::ConstructL +// ----------------------------------------------------------------------------- +// +void CSIPViaHeader::ConstructL (const CSIPViaHeader& aViaHeader) + { + iSentProtocolName = aViaHeader.SentProtocolName().Copy(); + iSentProtocolVersion = aViaHeader.SentProtocolVersion().Copy(); + iTransport = aViaHeader.Transport().Copy(); + iParams = CSIPViaHeaderParams::NewL(*(aViaHeader.iParams)); + iSentByHostPort = CSIPHostPort::NewL(*(aViaHeader.iSentByHostPort)); + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::~CSIPViaHeader +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPViaHeader::~CSIPViaHeader() + { + delete iSentByHostPort; + delete iParams; + iTransport.Close(); + iSentProtocolVersion.Close(); + iSentProtocolName.Close(); + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::CloneL +// From CSIPHeaderBase: +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPHeaderBase* CSIPViaHeader::CloneL () const + { + CSIPViaHeader* clone = new(ELeave)CSIPViaHeader; + CleanupStack::PushL(clone); + clone->ConstructL(*this); + CleanupStack::Pop(clone); + return clone; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::operator== +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CSIPViaHeader::operator==(const CSIPViaHeader& aViaHeader) + { + if (iTransport != aViaHeader.Transport()) + { + return EFalse; + } + if (iSentProtocolName != aViaHeader.iSentProtocolName) + { + return EFalse; + } + if (iSentProtocolVersion != aViaHeader.iSentProtocolVersion) + { + return EFalse; + } + if (!(*iSentByHostPort == *aViaHeader.iSentByHostPort)) + { + return EFalse; + } + return (*iParams == *(aViaHeader.iParams)); + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::Transport +// ----------------------------------------------------------------------------- +// +EXPORT_C RStringF CSIPViaHeader::Transport () const + { + return iTransport; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::SetTransportL +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIPViaHeader::SetTransportL(RStringF aTransport) + { + SetTransportL(aTransport.DesC()); + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::SentByHostPort +// ----------------------------------------------------------------------------- +// +EXPORT_C CSIPHostPort& CSIPViaHeader::SentByHostPort() + { + return *iSentByHostPort; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::SentProtocolName +// ----------------------------------------------------------------------------- +// +EXPORT_C RStringF CSIPViaHeader::SentProtocolName () const + { + return iSentProtocolName; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::SentProtocolVersion +// ----------------------------------------------------------------------------- +// +EXPORT_C RStringF CSIPViaHeader::SentProtocolVersion () const + { + return iSentProtocolVersion; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::SetSentProtocolVersionL +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIPViaHeader::SetSentProtocolVersionL(RStringF aVersion) + { + SetSentProtocolVersionL(aVersion.DesC()); + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::ViaTtl +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CSIPViaHeader::TtlParam() const + { + return iParams->IntParamValue(SIPStrings::StringF(SipStrConsts::ETtl)); + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::SetViaTtlL +// ----------------------------------------------------------------------------- +// +EXPORT_C void CSIPViaHeader::SetTtlParamL (TInt aValue) + { + iParams->SetParamL(SIPStrings::StringF(SipStrConsts::ETtl), aValue); + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::MoreThanOneAllowed +// From CSIPHeaderBase: +// ----------------------------------------------------------------------------- +// +TBool CSIPViaHeader::MoreThanOneAllowed () const + { + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::Name +// From CSIPHeaderBase: +// ----------------------------------------------------------------------------- +// +EXPORT_C RStringF CSIPViaHeader::Name() const + { + return SIPStrings::StringF(SipStrConsts::EViaHeader); + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::HasCompactName +// From CSIPHeaderBase: +// ----------------------------------------------------------------------------- +// +TBool CSIPViaHeader::HasCompactName () const + { + return ETrue; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::CompactName +// From CSIPHeaderBase: +// ----------------------------------------------------------------------------- +// +RStringF CSIPViaHeader::CompactName () const + { + return SIPStrings::StringF(SipStrConsts::EViaHeaderCompact); + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::ExternalizeSupported +// From CSIPHeaderBase: +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CSIPViaHeader::ExternalizeSupported () const + { + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::BaseDecodeL +// ----------------------------------------------------------------------------- +// +RPointerArray CSIPViaHeader::BaseDecodeL (const TDesC8& aValue) + { + RPointerArray headers; + CSIPHeaderBase::PushLC(&headers); + CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(aValue, ','); + for (TInt i=0; i < tokenizer->Tokens().Count(); i++) + { + CSIPViaHeader* header = new(ELeave)CSIPViaHeader; + CleanupStack::PushL(header); + header->ConstructL(); + header->ParseL(tokenizer->Tokens()[i]); + headers.AppendL(header); + CleanupStack::Pop(header); + } + CleanupStack::PopAndDestroy(tokenizer); + CleanupStack::Pop(); // headers + return headers; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::PreferredPlaceInMessage +// From CSIPHeaderBase: +// ----------------------------------------------------------------------------- +// +CSIPHeaderBase::TPreferredPlace CSIPViaHeader::PreferredPlaceInMessage () const + { + return CSIPHeaderBase::ETop; + } + +// ----------------------------------------------------------------------------- +// CSIPFromToHeader::ToTextMandatoryPartLC +// From CSIPParameterHeaderBase: +// ----------------------------------------------------------------------------- +// +HBufC8* CSIPViaHeader::ToTextMandatoryPartLC () const + { + TPtrC8 sentProtocolName(iSentProtocolName.DesC()); + TUint encodedLength = sentProtocolName.Length() + 1; // SLASH + + TPtrC8 sentProtocolVersion(iSentProtocolVersion.DesC()); + encodedLength += sentProtocolVersion.Length() + 1; // SLASH + + TPtrC8 transport(iTransport.DesC()); + encodedLength += transport.Length() + 1; // SP + + HBufC8* encodedSentByHostPort = iSentByHostPort->ToTextLC(); + encodedLength += encodedSentByHostPort->Length(); + + HBufC8* encodingResult = HBufC8::NewL (encodedLength); + TPtr8 encodingResultPtr = encodingResult->Des(); + + encodingResultPtr.Append(sentProtocolName); + encodingResultPtr.Append('/'); // SLASH + encodingResultPtr.Append(sentProtocolVersion); + encodingResultPtr.Append('/'); // SLASH + encodingResultPtr.Append(transport); + encodingResultPtr.Append(' '); // SP + encodingResultPtr.Append(*encodedSentByHostPort); + + CleanupStack::PopAndDestroy(encodedSentByHostPort); + CleanupStack::PushL (encodingResult); + return encodingResult; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::ParseMandatoryPartL +// From CSIPParameterHeaderBase: +// ----------------------------------------------------------------------------- +// +void CSIPViaHeader::ParseMandatoryPartL (const TDesC8& aMandatoryPart) + { + __ASSERT_ALWAYS (aMandatoryPart.Length()>0,User::Leave(KErrSipCodecViaHeader)); + + // sent-protocol + TInt endPos = 0; + ParseSentProtocolL(aMandatoryPart,endPos); + if (endPos >= aMandatoryPart.Length()-1) + { + User::Leave (KErrSipCodecViaHeader); + } + TLex8 lex(aMandatoryPart.Mid(endPos+1)); + lex.SkipSpace(); + // sent-by + iSentByHostPort = CSIPHostPort::DecodeL (lex.Remainder()); + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::Params +// From CSIPParameterHeaderBase: +// ----------------------------------------------------------------------------- +// +const CSIPParamContainerBase& CSIPViaHeader::Params () const + { + return *iParams; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::Params +// From CSIPParameterHeaderBase: +// ----------------------------------------------------------------------------- +// +CSIPParamContainerBase& CSIPViaHeader::Params () + { + return *iParams; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::ParseSentProtocolL +// ----------------------------------------------------------------------------- +// +void CSIPViaHeader::ParseSentProtocolL ( + const TDesC8& aValue, + TInt& aLength) + { + __ASSERT_ALWAYS (aValue.Length()>0, User::Leave(KErrSipCodecViaHeader)); + + TInt length = 0; + TInt slashPos = aValue.Locate ('/'); + if (slashPos <= 0 || slashPos == aValue.Length()-1) + { + User::Leave(KErrSipCodecViaHeader); + } + SetSentProtocolNameL(aValue.Left(slashPos)); + length += (slashPos+1); + + TPtrC8 remainder (aValue.Mid(slashPos+1)); + slashPos = remainder.Locate ('/'); + if (slashPos <= 0 || slashPos == remainder.Length()-1) + { + User::Leave (KErrSipCodecViaHeader); + } + SetSentProtocolVersionL(remainder.Left(slashPos)); + length += (slashPos+1); + + TLex8 lex(remainder.Mid(slashPos+1)); + lex.Mark(); + SetTransportL (lex.NextToken()); + length += lex.Offset(); + + aLength = length; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::SetTransportL +// ----------------------------------------------------------------------------- +// +void CSIPViaHeader::SetTransportL(const TDesC8& aTransport) + { + HBufC8* tmp = aTransport.AllocLC(); + tmp->Des().Trim(); + tmp->Des().UpperCase(); + if (!SIPSyntaxCheck::Token(*tmp)) + { + User::Leave(KErrSipCodecViaHeader); + } + RStringF tmpString = SIPStrings::Pool().OpenFStringL(*tmp); + CleanupStack::PopAndDestroy(tmp); + iTransport.Close(); + iTransport = tmpString; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::SetSentProtocolVersionL +// ----------------------------------------------------------------------------- +// +void CSIPViaHeader::SetSentProtocolVersionL(const TDesC8& aVersion) + { + RStringF tmp = + SIPCodecUtils::CheckAndCreateTokenL(aVersion, KErrSipCodecViaHeader); + iSentProtocolVersion.Close(); + iSentProtocolVersion = tmp; + } + +// ----------------------------------------------------------------------------- +// CSIPViaHeader::SetSentProtocolNameL +// ----------------------------------------------------------------------------- +// +void CSIPViaHeader::SetSentProtocolNameL (const TDesC8& aName) + { + RStringF tmp = + SIPCodecUtils::CheckAndCreateTokenL(aName, KErrSipCodecViaHeader); + iSentProtocolName.Close(); + iSentProtocolName = tmp; + }