// 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        : sipconcreteprofile.cpp

// Part of     : SIP / SIP Profile Agent / SIP Concrete Profile

// Implementation

//

//  INCLUDE FILES

#include "sipconcreteprofile.h"

#include "sipprofileparameter.h"

#include "sipprofile.h"

#include "sipmanagedprofile.h"

#include "extensionintparam.h"

#include "extensionboolparam.h"

#include "extensiondescrparam.h"

#include "extensiondescrarrayparam.h"

#include <random.h>

#include <utf.h>

#include <commsdattypesv1_1.h>

#include <commsdat.h>

#include <e32const.h>

#include "SipProfileLog.h"

const TInt KBitsInByte = 8;

const TInt KContactUserNameLength = 20;

const TUint KParameterLength = 25;

const TUint32 KDefaultSNAPIdentifier = KMaxTUint32;

_LIT8(KSIPProfileParameter, "%u");

using namespace CommsDat;

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::NewL

// -----------------------------------------------------------------------------

//

EXPORT_C CSIPConcreteProfile* CSIPConcreteProfile::NewL()

	{

	CSIPConcreteProfile* self = CSIPConcreteProfile::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::NewLC

// -----------------------------------------------------------------------------

//

EXPORT_C CSIPConcreteProfile* CSIPConcreteProfile::NewLC()

	{

	CSIPConcreteProfile* self = new (ELeave) CSIPConcreteProfile();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::CSIPConcreteProfile

// -----------------------------------------------------------------------------

//

CSIPConcreteProfile::CSIPConcreteProfile()

	{

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::ConstructL

// -----------------------------------------------------------------------------

//	

void CSIPConcreteProfile::ConstructL()

	{

	iSIPAORUri8 = CUri8::NewL();

	iSIPRegistrar = HBufC8::NewL(0);

	iSIPProviderName = HBufC8::NewL(0);

	iSIPPrivateIdentity = HBufC8::NewL(0);

	iSIPOutboundProxy = HBufC8::NewL(0);

	iSIPSigComp = EFalse;

	iSecurityNegotiation = EFalse;

	iSIPAutoRegistered = EFalse;

	iStatus = EUnregistered;

	iDefaultProfile = EFalse;

	iDynamicProxyResolving = EFalse;

	iDynamicProxy = HBufC8::NewL(0);

	iSIPContactHeaderParams = new (ELeave) CDesC8ArrayFlat(1);

	iSIPRegisteredAORs = new (ELeave) CDesC8ArrayFlat(1);

	iSIPNegotiatedSecurityMechanism = HBufC8::NewL(0);

	iSIPHeaders = new (ELeave) CDesC8ArrayFlat(1);

	HBufC8* username = CreateContactUserNameLC();

	SetExtensionParameterL(KSIPContactHeaderUser,*username);

	CleanupStack::PopAndDestroy(username);

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::CloneL

// -----------------------------------------------------------------------------

//	

EXPORT_C CSIPConcreteProfile* CSIPConcreteProfile::CloneL() const

	{

	return CloneL(EFalse);

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::CloneWithDynamicValuesL

// -----------------------------------------------------------------------------

//	

EXPORT_C CSIPConcreteProfile* CSIPConcreteProfile::CloneWithDynamicValuesL() const

	{

	return CloneL(ETrue);

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::CloneL(TBool)

// -----------------------------------------------------------------------------

//

CSIPConcreteProfile* CSIPConcreteProfile::CloneL(TBool aWithDynamicValues) const

	{

	CSIPConcreteProfile* newCopy = CSIPConcreteProfile::NewLC();

	newCopy->SetIapId(IapId());

	newCopy->SetProfileType(ProfileType());

	newCopy->SetRegistrarL(*iSIPRegistrar);

	newCopy->SetOutboundProxyL(*iSIPOutboundProxy);

	newCopy->SetPrivateIdentityL(PrivateIdentity());

	newCopy->SetProviderNameL(ProviderName());

	newCopy->SetServerParameterL(KSIPRegistrar, KSIPDigestRealm,

		ServerParameter(KSIPRegistrar, KSIPDigestRealm));

	newCopy->SetServerParameterL(KSIPRegistrar, KSIPDigestUserName,

		ServerParameter(KSIPRegistrar, KSIPDigestUserName));

	newCopy->SetServerParameterL(KSIPRegistrar, KSIPDigestPassword,

		ServerParameter(KSIPRegistrar, KSIPDigestPassword));

	TInt i = 0;

	for (i = 0; i < iSIPRegistrarExtParameter.Count(); i++)

		{

		CSIPProfileParameter* param = iSIPRegistrarExtParameter[i];

		newCopy->SetServerExtensionParameterL(KSIPRegistrar, param->Key(), param->ValueL());

		}

	newCopy->SetServerParameterL(KSIPOutboundProxy, KSIPDigestRealm,

		ServerParameter(KSIPOutboundProxy, KSIPDigestRealm));

	newCopy->SetServerParameterL(KSIPOutboundProxy, KSIPDigestUserName,

		ServerParameter(KSIPOutboundProxy, KSIPDigestUserName));

	newCopy->SetServerParameterL(KSIPOutboundProxy, KSIPDigestPassword,

		ServerParameter(KSIPOutboundProxy, KSIPDigestPassword));

	for (i = 0; i < iSIPOutboundProxyExtParameter.Count(); i++)

		{

		CSIPProfileParameter* param = iSIPOutboundProxyExtParameter[i];

		newCopy->SetServerExtensionParameterL(KSIPOutboundProxy, param->Key(), param->ValueL());

		}

	newCopy->SetAORL(AOR());

	newCopy->EnableSigComp(IsSigCompEnabled());

	newCopy->EnableSecurityNegotiation(IsSecurityNegotiationEnabled());

	newCopy->SetAutoRegistrationEnabled(IsAutoRegistrationEnabled());

	newCopy->SetDynamicProxyL(DynamicProxy());

	newCopy->SetContactHeaderParamsL(ContactHeaderParams());

	newCopy->SetSIPHeadersL(SIPHeaders());

	newCopy->SetStatus(EUnregistered);

	newCopy->SetContextId(0);

	newCopy->SetDefault(EFalse);

	newCopy->SetLastRegistrationError(KErrNone);

	CloneExtensionParamsL(*newCopy);

	if (aWithDynamicValues) // All vales are copied

		{

		newCopy->SetId(Id());

		newCopy->SetStatus(Status());

		newCopy->SetContextId(ContextId());

		newCopy->SetLastRegistrationError(LastRegistrationError());				

		}

	else

		{

		newCopy->SetStatus(EUnregistered);

		newCopy->SetContextId(0);

		newCopy->SetDefault(EFalse);

		newCopy->SetLastRegistrationError(KErrNone);

	    // The Contact-header's user-part must be unique. 

	    // It is stored in the extension parameters to preserve data compatibility.

		HBufC8* username = CreateContactUserNameLC();

		newCopy->SetExtensionParameterL(KSIPContactHeaderUser,*username);

		CleanupStack::PopAndDestroy(username);			

		}

	CleanupStack::Pop(newCopy);

	return newCopy;

	}		

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::~CSIPConcreteProfile

// Destructor.

// -----------------------------------------------------------------------------

//	

EXPORT_C CSIPConcreteProfile::~CSIPConcreteProfile()

	{

	if (iSIPHeaders)

	    {

	    iSIPHeaders->Reset();   

	    }

	delete iSIPHeaders;

	delete iSIPNegotiatedSecurityMechanism;

	if (iSIPRegisteredAORs)

	    {

	    iSIPRegisteredAORs->Reset();

	    }

	delete iSIPRegisteredAORs;

    if (iSIPContactHeaderParams)

        {

        iSIPContactHeaderParams->Reset();

        }

	delete iSIPContactHeaderParams;

	iSIPOutboundProxyParameter.ResetAndDestroy();

	iSIPOutboundProxyExtParameter.ResetAndDestroy();

	iSIPRegistrarParameter.ResetAndDestroy();

	iSIPRegistrarExtParameter.ResetAndDestroy();	

	delete iDynamicProxy;

	delete iSIPAORUri8;

	delete iSIPRegistrar;

	delete iSIPProviderName;

	delete iSIPPrivateIdentity;

	delete iSIPOutboundProxy;

	iExtensionIntParams.Close();

	iExtensionBoolParams.Close();

	iExtensionDescrParams.ResetAndDestroy();

	iExtensionDescrArrayParams.ResetAndDestroy();

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::Id

// -----------------------------------------------------------------------------

//	

EXPORT_C TUint32 CSIPConcreteProfile::Id() const

	{

	return iSIPProfileId;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::SetId

// -----------------------------------------------------------------------------

//	

EXPORT_C void CSIPConcreteProfile::SetId(TUint32 aId)

	{

	iSIPProfileId = aId;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::SetIapId

// -----------------------------------------------------------------------------

//	

EXPORT_C void CSIPConcreteProfile::SetIapId(TUint32 aIapId)

	{

	iSIPIAPId = aIapId;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::IapId

// -----------------------------------------------------------------------------

//	

EXPORT_C TUint32 CSIPConcreteProfile::IapId() const

	{

	return iSIPIAPId;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::SetProfileTypeL

// -----------------------------------------------------------------------------

//	

EXPORT_C void CSIPConcreteProfile::SetProfileType(

    const TSIPProfileTypeInfo& aProfileType) 

	{

	iSIPProfileType.iSIPProfileClass = aProfileType.iSIPProfileClass;

	iSIPProfileType.iSIPProfileName = aProfileType.iSIPProfileName;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::ProfileType

// -----------------------------------------------------------------------------

//	

EXPORT_C const TSIPProfileTypeInfo& CSIPConcreteProfile::ProfileType() const

	{

	return iSIPProfileType;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::Server

// -----------------------------------------------------------------------------

//	

EXPORT_C const TDesC8& CSIPConcreteProfile::Server(TUint32 aServer) const

	{

	switch(aServer) 

		{

		case KSIPOutboundProxy:

			return *iSIPOutboundProxy;

		case KSIPRegistrar:

			return *iSIPRegistrar;

		default:

			return KNullDesC8;

		}

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::ServerParameter

// -----------------------------------------------------------------------------

//	

EXPORT_C const TDesC8& CSIPConcreteProfile::ServerParameter(

    TUint32 aServer,

    TUint32 aServerParam) const

	{

	if (aServerParam == KSIPDigestUserName || 

		aServerParam == KSIPDigestRealm ||

		aServerParam == KSIPDigestPassword)

		{

		TBuf8<KParameterLength> parameter;

		parameter.Format(KSIPProfileParameter, aServerParam);

		switch(aServer) 

			{

			case KSIPOutboundProxy:

				return Parameter(&iSIPOutboundProxyParameter, parameter);

			case KSIPRegistrar:

				return Parameter(&iSIPRegistrarParameter, parameter);

			default:

				return KNullDesC8;

			}

		}

	else

		{

		return KNullDesC8;

		}

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::ServerExtensionParameter

// -----------------------------------------------------------------------------

//	

EXPORT_C const TDesC8& CSIPConcreteProfile::ServerExtensionParameter(

    TUint32 aServer,

	const TDesC8& aName) const

	{

	switch(aServer) 

		{

		case KSIPOutboundProxy:

			return Parameter(&iSIPOutboundProxyExtParameter, aName);

		case KSIPRegistrar:

			return Parameter(&iSIPRegistrarExtParameter, aName);

		default:

			return KNullDesC8;

		}

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::SetServerL

// -----------------------------------------------------------------------------

//	

EXPORT_C void CSIPConcreteProfile::SetServerL(

    TUint32 aServer, 

							     const TDesC8& aSipUri)

	{

	switch(aServer) 

		{

		case KSIPOutboundProxy:

			SetOutboundProxyL(aSipUri);

			break;

		case KSIPRegistrar:

			SetRegistrarL(aSipUri);

			break;

		default:

			User::Leave (KErrArgument);

		}

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::SetServerParameterL

// -----------------------------------------------------------------------------

//	

EXPORT_C void CSIPConcreteProfile::SetServerParameterL(

    TUint32 aServer,

    TUint32 aServerParam,

    const TDesC8& aValue)

	{

	__ASSERT_ALWAYS(aServerParam == KSIPDigestUserName ||

		aServerParam == KSIPDigestRealm ||

		aServerParam == KSIPDigestPassword , User::Leave(KErrArgument));

	TBuf8<KParameterLength> parameter;

	parameter.Format(KSIPProfileParameter, aServerParam);

	switch(aServer) 

		{

		case KSIPOutboundProxy:

			SetParameterL(&iSIPOutboundProxyParameter, parameter, aValue);

			break;

		case KSIPRegistrar:

			SetParameterL(&iSIPRegistrarParameter, parameter, aValue);

			break;

		default:

			User::Leave (KErrArgument);

		}

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::SetServerExtensionParameterL

// -----------------------------------------------------------------------------

//	

EXPORT_C void CSIPConcreteProfile::SetServerExtensionParameterL(

    TUint32 aServer,

    const TDesC8& aName,

    const TDesC8& aValue)

	{

	switch(aServer) 

		{

		case KSIPOutboundProxy:

			SetParameterL(&iSIPOutboundProxyExtParameter, aName, aValue);

			break;

		case KSIPRegistrar:

			SetParameterL(&iSIPRegistrarExtParameter, aName, aValue);

			break;

		default:

			User::Leave (KErrArgument);

		}

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::SetAORL

// -----------------------------------------------------------------------------

//	

EXPORT_C void CSIPConcreteProfile::SetAORL(const TDesC8& aAOR)

	{

    TUriParser8 parser;

    User::LeaveIfError(parser.Parse(aAOR));

    CUri8* tmp = CUri8::NewL(parser);

	delete iSIPAORUri8;

	iSIPAORUri8 = tmp;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::AOR

// -----------------------------------------------------------------------------

//	

EXPORT_C const TDesC8& CSIPConcreteProfile::AOR() const

	{

	return iSIPAORUri8->Uri().UriDes();

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::AORUri8

// -----------------------------------------------------------------------------

//	

EXPORT_C const TUriC8& CSIPConcreteProfile::AORUri8() const

    {

    return iSIPAORUri8->Uri();

    }

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::PrivateIdentity

// -----------------------------------------------------------------------------

//	

EXPORT_C const TDesC8& CSIPConcreteProfile::PrivateIdentity() const

	{

	return *iSIPPrivateIdentity;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::SetPrivateIdentityL

// -----------------------------------------------------------------------------

//	

EXPORT_C void CSIPConcreteProfile::SetPrivateIdentityL(

    const TDesC8& aPrivateIdentity)

	{

	HBufC8* tmp = aPrivateIdentity.AllocL();

	delete iSIPPrivateIdentity;

	iSIPPrivateIdentity = tmp;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::SetProviderNameL

// -----------------------------------------------------------------------------

//	

EXPORT_C void CSIPConcreteProfile::SetProviderNameL(

    const TDesC8& aProviderName)

	{

	HBufC8* tmp = aProviderName.AllocL();

	delete iSIPProviderName;

	iSIPProviderName = tmp;

	}

// -----------------------------------------------------------------------------

// CSIPConcreteProfile::ProviderName

// -----------------------------------------------------------------------------

//	

EXPORT_C const TDesC8& CSIPConcreteProfile::ProviderName() const

	{