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) 2007-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 : CURIContainer.cpp
// Part of : SIP Codec
// Version : SIP/4.0
//
#include "uricontainer.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "sipuri.h"
#include "sipcodecerr.h"
#include "SIPHeaderLookup.h"
#include "_sipcodecdefs.h"
// ----------------------------------------------------------------------------
// CURIContainer::DecodeL
// ----------------------------------------------------------------------------
//
EXPORT_C CURIContainer* CURIContainer::DecodeL(const TDesC8& aValue)
{
HBufC8* trimmedValue = aValue.AllocLC();
trimmedValue->Des().Trim();
__ASSERT_ALWAYS(trimmedValue->Length() > 0, User::Leave(KErrSipCodecURI));
CURIContainer* container = new(ELeave) CURIContainer;
CleanupStack::PushL(container);
container->ConstructL();
if(SIPHeaderLookup::ConvertToSIPURI())
{
if(FindSIP(*trimmedValue))
{
CSIPURI* sipuri = CSIPURI::DecodeL(*trimmedValue);
CleanupStack::PushL(sipuri);
container->iSIPURI = sipuri;
CleanupStack::Pop(sipuri);
}
else
{
CUri8* uri8 = CreateUri8L(*trimmedValue);
CleanupStack::PushL(uri8);
container->iUri8 = uri8;
CleanupStack::Pop(uri8);
}
}
else
{
CUri8* uri8 = CreateUri8L(*trimmedValue);
CleanupStack::PushL(uri8);
container->iUri8 = uri8;
CleanupStack::Pop(uri8);
}
CleanupStack::Pop(container);
CleanupStack::PopAndDestroy(trimmedValue);
return container;
}
// ----------------------------------------------------------------------------
// CURIContainer::NewL
// ----------------------------------------------------------------------------
//
EXPORT_C CURIContainer* CURIContainer::NewL(CUri8* aUri8)
{
CURIContainer* self = CURIContainer::NewLC(aUri8);
CleanupStack::Pop(self);
return self;
}
// ----------------------------------------------------------------------------
// CURIContainer::NewLC
// ----------------------------------------------------------------------------
//
EXPORT_C CURIContainer* CURIContainer::NewLC(CUri8* aUri8)
{
CURIContainer* self = new(ELeave) CURIContainer;
CleanupStack::PushL(self);
self->ConstructL(aUri8);
return self;
}
// ----------------------------------------------------------------------------
// CURIContainer::NewL
// ----------------------------------------------------------------------------
//
EXPORT_C CURIContainer* CURIContainer::NewL(const CURIContainer& aURI)
{
CURIContainer* self = CURIContainer::NewLC(aURI);
CleanupStack::Pop(self);
return self;
}
// ----------------------------------------------------------------------------
// CURIContainer::NewLC
// ----------------------------------------------------------------------------
//
EXPORT_C CURIContainer* CURIContainer::NewLC(const CURIContainer& aURI)
{
CURIContainer* self = new (ELeave) CURIContainer;
CleanupStack::PushL(self);
self->ConstructL(aURI);
return self;
}
// ----------------------------------------------------------------------------
// CURIContainer::~CURIContainer
// ----------------------------------------------------------------------------
//
EXPORT_C CURIContainer::~CURIContainer()
{
delete iSIPURI;
delete iUri8;
SIPHeaderLookup::Close();
}
// ----------------------------------------------------------------------------
// CURIContainer::ConstructL
// ----------------------------------------------------------------------------
//
void CURIContainer::ConstructL()
{
SIPHeaderLookup::OpenL();
}
// ----------------------------------------------------------------------------
// CURIContainer::ConstructL
// ----------------------------------------------------------------------------
//
void CURIContainer::ConstructL(CUri8* aUri8)
{
SIPHeaderLookup::OpenL();
if(SIPHeaderLookup::ConvertToSIPURI())
{
if(FindSIP(aUri8->Uri().UriDes()))
{
iSIPURI = CSIPURI::DecodeL(aUri8->Uri().UriDes());
delete aUri8;
}
else
{
iUri8 = aUri8;
}
}
else
{
iUri8 = aUri8;
}
}
// ----------------------------------------------------------------------------
// CURIContainer::ConstructL
// ----------------------------------------------------------------------------
//
void CURIContainer::ConstructL(const CURIContainer& aURI)
{
SIPHeaderLookup::OpenL();
if(aURI.IsSIPURI())
{
HBufC8* sipuriastext = aURI.iSIPURI->ToTextL();
CleanupStack::PushL(sipuriastext);
iSIPURI = CSIPURI::DecodeL(*sipuriastext);
CleanupStack::PopAndDestroy(sipuriastext);
}
else
{
iUri8 = CUri8::NewL(aURI.Uri8()->Uri());
}
}
// ----------------------------------------------------------------------------
// CURIContainer::IsSIPURI
// ----------------------------------------------------------------------------
//
EXPORT_C TBool CURIContainer::IsSIPURI() const
{
if(iSIPURI)
{
return ETrue;
}
return EFalse;
}
// ----------------------------------------------------------------------------
// CURIContainer::SIPURI
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPURI* CURIContainer::SIPURI()
{
return iSIPURI;
}
// ----------------------------------------------------------------------------
// CURIContainer::SIPURI
// ----------------------------------------------------------------------------
//
EXPORT_C const CSIPURI* CURIContainer::SIPURI() const
{
return iSIPURI;
}
// ----------------------------------------------------------------------------
// CURIContainer::Uri8
// ----------------------------------------------------------------------------
//
EXPORT_C const CUri8* CURIContainer::Uri8() const
{
return iUri8;
}
// ----------------------------------------------------------------------------
// CURIContainer::operator==
// ----------------------------------------------------------------------------
//
EXPORT_C TBool CURIContainer::operator==(const CURIContainer& aURI) const
{
if(aURI.IsSIPURI() && IsSIPURI())
{
return (*iSIPURI == *aURI.iSIPURI);
}
if(!aURI.IsSIPURI() && !IsSIPURI())
{
if(aURI.Uri8()->Uri().UriDes().Compare(Uri8()->Uri().UriDes()) == 0)
{
return ETrue;
}
return EFalse;
}
return EFalse;
}
// ----------------------------------------------------------------------------
// CURIContainer::ToTextL
// ----------------------------------------------------------------------------
//
EXPORT_C HBufC8* CURIContainer::ToTextL() const
{
__ASSERT_ALWAYS((iUri8 || iSIPURI), User::Leave(KErrSipCodecURIContainer));
if(iSIPURI)
{
return iSIPURI->ToTextL();
}
return iUri8->Uri().UriDes().AllocL();
}
// ----------------------------------------------------------------------------
// CURIContainer::InternalizeL
// ----------------------------------------------------------------------------
//
EXPORT_C CURIContainer* CURIContainer::InternalizeL(RReadStream& aReadStream)
{
CURIContainer* container = new(ELeave) CURIContainer;
CleanupStack::PushL(container);
container->ConstructL();
container->DoInternalizeL(aReadStream);
CleanupStack::Pop(container);
return container;
}
// ----------------------------------------------------------------------------
// CURIContainer::ExternalizeL
// ----------------------------------------------------------------------------
//
EXPORT_C void CURIContainer::ExternalizeL(RWriteStream& aWriteStream) const
{
if(IsSIPURI())
{
HBufC8* tmp = iSIPURI->ToTextL();
CleanupStack::PushL(tmp);
aWriteStream.WriteUint32L(tmp->Des().Length());
aWriteStream.WriteL(tmp->Des());
CleanupStack::PopAndDestroy(tmp);
}
else
{
TPtrC8 uri8(iUri8->Uri().UriDes());
aWriteStream.WriteUint32L(uri8.Length());
aWriteStream.WriteL(uri8);
}
}
// ----------------------------------------------------------------------------
// CURIContainer::CloneAsUri8L
// ----------------------------------------------------------------------------
//
EXPORT_C CUri8* CURIContainer::CloneAsUri8L() const
{
HBufC8* uriAsText = ToTextL();
CleanupStack::PushL(uriAsText);
CUri8* clone = CreateUri8L(*uriAsText);
CleanupStack::PopAndDestroy(uriAsText);
return clone;
}
// ----------------------------------------------------------------------------
// CURIContainer::DoInternalizeL
// ----------------------------------------------------------------------------
//
void CURIContainer::DoInternalizeL(RReadStream& aReadStream)
{
TInt length(aReadStream.ReadUint32L());
HBufC8* buffer = HBufC8::NewLC(length);
TPtr8 bufptr(buffer->Des());
aReadStream.ReadL(bufptr, length);
if(SIPHeaderLookup::ConvertToSIPURI())
{
if(FindSIP(bufptr))
{
iSIPURI = CSIPURI::DecodeL(bufptr);
}
else
{
iUri8 = CreateUri8L(bufptr);
}
}
else
{
iUri8 = CreateUri8L(bufptr);
}
CleanupStack::PopAndDestroy(buffer);
}
// ----------------------------------------------------------------------------
// CURIContainer::CreateUri8L
// ----------------------------------------------------------------------------
//
CUri8* CURIContainer::CreateUri8L(const TDesC8& aValue)
{
TUriParser8 parser;
User::LeaveIfError(parser.Parse(aValue));
TPtrC8 scheme(parser.Extract(EUriScheme));
if (scheme.CompareF(SIPStrings::StringF(SipStrConsts::ESip).DesC()) == 0)
{
User::LeaveIfError(parser.Validate());
}
return CUri8::NewL(parser);
}
// ----------------------------------------------------------------------------
// CURIContainer::FindSIP
// ----------------------------------------------------------------------------
//
TBool CURIContainer::FindSIP(const TDesC8& aValue)
{
_LIT8(KSIP, "sip:");
_LIT8(KSIPS, "sips:");
TPtrC8 value(aValue);
if(value.FindF(KSIP) == 0 ||
value.FindF(KSIPS) == 0)
{
return ETrue;
}
return EFalse;
}