This release addresses the following:
- Multiple concurrent file transfer bug fixes. i.e. one device is concurrently receiving multiple files from multiple devices
// 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>
CSIPAcceptHeader::DecodeL (const TDesC8& aValue)
{
RPointerArray<CSIPHeaderBase> baseheaders = BaseDecodeL(aValue);
CSIPHeaderBase::PushLC(&baseheaders);
RPointerArray<CSIPAcceptHeader> acceptHeaders;
CleanupClosePushL(acceptHeaders);
TInt count = baseheaders.Count();
for (TInt i=0; i < count; i++)
{
CSIPAcceptHeader* header =
static_cast<CSIPAcceptHeader*>(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<CSIPHeaderBase>
CSIPAcceptHeader::BaseDecodeL(const TDesC8& aValue)
{
RPointerArray<CSIPHeaderBase> 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;
}