// 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 : CSIPParam.cpp
// Part of : SIP Codec
// Version : SIP/4.0
//
#include "CSIPParam.h"
#include "SIPSyntaxCheck.h"
#include "sipstrings.h"
#include "sipcodecerr.h"
// -----------------------------------------------------------------------------
// CSIPParam::DecodeL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::DecodeL(const TDesC8& aValue)
{
TPtrC8 pname;
TPtrC8 pvalue;
TBool hasValue = ParseL(aValue,pname,pvalue);
if (hasValue)
{
return CSIPParam::NewL(pname,pvalue);
}
return CSIPParam::NewL(pname);
}
// -----------------------------------------------------------------------------
// CSIPParam::ParseL
// -----------------------------------------------------------------------------
//
TBool CSIPParam::ParseL(const TDesC8& aInput, TPtrC8& aName, TPtrC8& aValue)
{
__ASSERT_ALWAYS (aInput.Length() > 0, User::Leave (KErrSipCodecAnyParam));
TInt equalsPos = aInput.Locate('=');
if (equalsPos == 0 || equalsPos == aInput.Length()-1)
{
User::Leave (KErrSipCodecAnyParam);
}
TBool hasValue = EFalse;
if (equalsPos > 0 && !SIPSyntaxCheck::StartsAndEndsWithQuotes(aInput))
{
aName.Set(aInput.Left(equalsPos));
aValue.Set(aInput.Mid(equalsPos+1));
hasValue = ETrue;
}
else
{
aName.Set(aInput);
}
return hasValue;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(RStringF aName)
{
CSIPParam* self = CSIPParam::NewLC(aName);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(RStringF aName)
{
CSIPParam* self = new(ELeave)CSIPParam;
CleanupStack::PushL(self);
self->ConstructL(aName);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(const TDesC8& aName)
{
CSIPParam* self = CSIPParam::NewLC(aName);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(const TDesC8& aName)
{
CSIPParam* self = new(ELeave)CSIPParam;
CleanupStack::PushL(self);
self->ConstructL(aName);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(RStringF aName, RStringF aValue)
{
CSIPParam* self = CSIPParam::NewLC(aName,aValue);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(RStringF aName, RStringF aValue)
{
CSIPParam* self = new(ELeave)CSIPParam;
CleanupStack::PushL(self);
self->ConstructL(aName,aValue);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(RStringF aName, const TDesC8& aValue)
{
CSIPParam* self = CSIPParam::NewLC(aName,aValue);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(RStringF aName, const TDesC8& aValue)
{
CSIPParam* self = new(ELeave)CSIPParam;
CleanupStack::PushL(self);
self->ConstructL(aName,aValue);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(const TDesC8& aName, const TDesC8& aValue)
{
CSIPParam* self = CSIPParam::NewLC(aName,aValue);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(const TDesC8& aName, const TDesC8& aValue)
{
CSIPParam* self = new(ELeave)CSIPParam;
CleanupStack::PushL(self);
self->ConstructL(aName,aValue);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(const CSIPParam& aSIPParam)
{
CSIPParam* self = CSIPParam::NewLC(aSIPParam);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(const CSIPParam& aSIPParam)
{
CSIPParam* self = new(ELeave)CSIPParam(aSIPParam);
CleanupStack::PushL(self);
self->ConstructL(aSIPParam);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::CSIPParam
// -----------------------------------------------------------------------------
//
CSIPParam::CSIPParam()
{
}
// -----------------------------------------------------------------------------
// CSIPParam::CSIPParam
// -----------------------------------------------------------------------------
//
CSIPParam::CSIPParam(const CSIPParam& aSIPParam) : CBase()
{
iName = aSIPParam.Name().Copy();
iValue = aSIPParam.Value().Copy();
iHasValue = aSIPParam.HasValue();
iAddQuotesWhenEncoding = aSIPParam.iAddQuotesWhenEncoding;
}
// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPParam::ConstructL(RStringF aName)
{
iDesValue = KNullDesC8().AllocL();
SetL(iName,aName.DesC());
}
// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPParam::ConstructL(const TDesC8& aName)
{
iDesValue = KNullDesC8().AllocL();
SetL(iName,aName);
}
// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPParam::ConstructL(RStringF aName, RStringF aValue)
{
iDesValue = KNullDesC8().AllocL();
SetL(iName,aName.DesC());
SetL(iValue,aValue.DesC(),EFalse);
iHasValue = ETrue;
}
// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPParam::ConstructL(RStringF aName, const TDesC8& aValue)
{
iDesValue = KNullDesC8().AllocL();
SetL(iName,aName.DesC());
SetL(iValue,aValue,EFalse);
iHasValue = ETrue;
}
// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPParam::ConstructL(const TDesC8& aName, const TDesC8& aValue)
{
iDesValue = KNullDesC8().AllocL();
SetL(iName,aName);
SetL(iValue,aValue,EFalse);
iHasValue = ETrue;
}
// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPParam::ConstructL(const CSIPParam& aSIPParam)
{
iDesValue = aSIPParam.iDesValue->AllocL();
}
// -----------------------------------------------------------------------------
// CSIPParam::~CSIPParam
// -----------------------------------------------------------------------------
//
CSIPParam::~CSIPParam()
{
iName.Close();
iValue.Close();
delete iDesValue;
}
// -----------------------------------------------------------------------------
// CSIPParam::Name
// -----------------------------------------------------------------------------
//
RStringF CSIPParam::Name() const
{
return iName;
}
// -----------------------------------------------------------------------------
// CSIPParam::HasValue
// -----------------------------------------------------------------------------
//
TBool CSIPParam::HasValue() const
{
return iHasValue;
}
// -----------------------------------------------------------------------------
// CSIPParam::Value
// -----------------------------------------------------------------------------
//
RStringF CSIPParam::Value() const
{
return iValue;
}
// -----------------------------------------------------------------------------
// CSIPParam::DesValue
// -----------------------------------------------------------------------------
//
const TDesC8& CSIPParam::DesValue() const
{
return *iDesValue;
}
// -----------------------------------------------------------------------------
// CSIPParam::SetValueL
// -----------------------------------------------------------------------------
//
void CSIPParam::SetValueL(const TDesC8& aValue, TBool aAddQuotesWhenEncoding)
{
HBufC8* tmp = aValue.AllocLC();
if (!aAddQuotesWhenEncoding)
{
tmp->Des().Trim();
}
RStringF tmpStr = SIPStrings::Pool().OpenFStringL(*tmp);
CleanupStack::Pop(tmp);
iValue.Close();
iValue = tmpStr;
iHasValue = ETrue;
iAddQuotesWhenEncoding = aAddQuotesWhenEncoding;
if (aAddQuotesWhenEncoding)
{
delete iDesValue;
iDesValue = tmp;
tmp = NULL;
}
delete tmp;
}
// -----------------------------------------------------------------------------
// CSIPParam::operator==
// -----------------------------------------------------------------------------
//
TBool CSIPParam::operator==(const CSIPParam& aSIPParam) const
{
if (aSIPParam.HasValue() != HasValue())
{
return EFalse;
}
if (iName != aSIPParam.Name())
{
return EFalse;
}
if (HasValue() && iValue != aSIPParam.Value())
{
return EFalse;
}
return ETrue;
}
// -----------------------------------------------------------------------------
// CSIPParam::ToTextLC
// -----------------------------------------------------------------------------
//
HBufC8* CSIPParam::ToTextLC () const
{
TPtrC8 name = iName.DesC();
TPtrC8 value = iValue.DesC();
TUint length = name.Length();
if (HasValue())
{
length += 1; // '='
if (iAddQuotesWhenEncoding)
{
const TInt KQuotesLength = 2;
length += KQuotesLength;
length += iDesValue->Length();
}
else
{
length += value.Length();
}
}
HBufC8* result = HBufC8::NewLC(length);
TPtr8 resultPtr(result->Des());
resultPtr.Append(name);
if (HasValue())
{
resultPtr.Append('=');
if (iAddQuotesWhenEncoding)
{
resultPtr.Append('"');
resultPtr.Append(*iDesValue);
resultPtr.Append('"');
}
else
{
resultPtr.Append(value);
}
}
return result;
}
// -----------------------------------------------------------------------------
// CSIPParam::InternalizeL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::InternalizeL (RReadStream& aReadStream)
{
CSIPParam* self = new(ELeave)CSIPParam;
CleanupStack::PushL(self);
self->DoInternalizeL(aReadStream);
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CSIPParam::ExternalizeL
// -----------------------------------------------------------------------------
//
void CSIPParam::ExternalizeL(RWriteStream& aWriteStream) const
{
TPtrC8 name(iName.DesC());
aWriteStream.WriteUint32L(name.Length());
aWriteStream.WriteL(name);
TPtrC8 value(iValue.DesC());
aWriteStream.WriteUint32L(value.Length());
if (value.Length() > 0)
{
aWriteStream.WriteL(value);
}
aWriteStream.WriteUint8L(iHasValue);
aWriteStream.WriteUint8L(iAddQuotesWhenEncoding);
TInt desValueLength = iDesValue->Length();
aWriteStream.WriteUint32L(desValueLength);
if (desValueLength > 0)
{
aWriteStream.WriteL(*iDesValue);
}
}
// -----------------------------------------------------------------------------
// CSIPParam::DoInternalizeL
// -----------------------------------------------------------------------------
//
void CSIPParam::DoInternalizeL(RReadStream& aReadStream)
{
TUint32 nameLength = aReadStream.ReadUint32L();
HBufC8* name = HBufC8::NewLC(nameLength);
TPtr8 namePtr(name->Des());
aReadStream.ReadL(namePtr, nameLength);
iName = SIPStrings::Pool().OpenFStringL(namePtr);
CleanupStack::PopAndDestroy(name);
TUint32 valueLength = aReadStream.ReadUint32L();
HBufC8* value = HBufC8::NewLC(valueLength);
if (valueLength > 0)
{
TPtr8 valuePtr(value->Des());
aReadStream.ReadL(valuePtr, valueLength);
iValue = SIPStrings::Pool().OpenFStringL(valuePtr);
}
CleanupStack::PopAndDestroy(value);
iHasValue = (aReadStream.ReadUint8L() != 0);
iAddQuotesWhenEncoding = (aReadStream.ReadUint8L() != 0);
TUint32 desValueLength = aReadStream.ReadUint32L();
iDesValue = HBufC8::NewL(desValueLength);
if (desValueLength > 0)
{
TPtr8 desValuePtr(iDesValue->Des());
aReadStream.ReadL(desValuePtr, desValueLength);
}
}
// -----------------------------------------------------------------------------
// CSIPParam::SetL
// -----------------------------------------------------------------------------
//
void CSIPParam::SetL(RStringF& aString, const TDesC8& aDes, TBool aCheckLength)
{
HBufC8* tmp = aDes.AllocLC();
tmp->Des().Trim();
if (aCheckLength && tmp->Length() == 0)
{
User::Leave(KErrSipCodecAnyParam);
}
aString = SIPStrings::Pool().OpenFStringL(*tmp);
CleanupStack::PopAndDestroy(tmp);
}