// Copyright (c) 2003-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:

//

/**

 @file cs_subconn.cpp

*/

#include <comms-infras/nifprvar.h>

#include <ecom/ecom.h>

#include <es_sock.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_sock_partner.h>

#include <es_sock_internal.h>

#endif

#include <comms-infras/sockmes.h>

#include <connpref.h>

#include <comms-infras/ss_log.h>

#include <comms-infras/es_parameterbundle.h>

#include <comms-infras/es_parameterfamily.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockCSockcssbcn, "ESockCSockcssbcn");

#endif

using Meta::STypeId;

EXPORT_C CSubConParameterSet* CSubConParameterSet::NewL(const STypeId& aTypeId)

/** Creates a new sub-connection parameter set using ECOM to load the DLL plugin

    that implements the set.

@param aTypeId Id of the class (Composed of Uid of the implementation and an integer sub-type

@return a generic pointer to a specific parameter set if successful, otherwise leaves with system error code.

*/

	{

	return static_cast<CSubConParameterSet*>(Meta::SMetaDataECom::NewInstanceL(aTypeId));

	}

CSubConParameterSet::~CSubConParameterSet()

/** Empty (virtual) sub-connection parameter set destructor

*/

	{

	}

CSubConParameterSet::CSubConParameterSet()

/** Empty sub-connection parameter set constructor

*/

	{

	}

EXPORT_C CSubConGenericParameterSet::~CSubConGenericParameterSet()

/** Empty (virtual) sub-connection generic parameter set destructor

*/

	{

	LOG( ESockLog::Printf(_L8("CSubConGenericParameterSet::~CSubConGenericParameterSet() %08x"), this););

	}

EXPORT_C CSubConGenericParameterSet::CSubConGenericParameterSet()

/** Empty sub-connection generic parameter set constructor

*/

	{

	LOG( ESockLog::Printf(_L8("CSubConGenericParameterSet::CSubConGenericParameterSet() %08x"), this););

	}

EXPORT_C CSubConExtensionParameterSet::~CSubConExtensionParameterSet()

/** Empty (virtual) sub-connection extension parameter set destructor

*/

	{

	}

EXPORT_C CSubConExtensionParameterSet::CSubConExtensionParameterSet()

/** Empty sub-connection extension parameter set constructor

*/

	{

	}

EXPORT_C CSubConParameterFamily* CSubConParameterFamily::NewL(RSubConParameterBundle& aBundle, TUint32 aFamilyId)

/** Creates a new sub-connection parameter set family. This class is used as a container for a number of parameter

    sets (generic and extension) that make up a family. It is a specific instantiatable class and therefore creates

	an instance of CSubConParameterFamily without using ECOM. 

Note:

The aBundle parameter that is passed into this method will take ownership of the newly created 

CSubConParameterFamily object.  When the bundle is destroyed, this family object will also be 

destroyed  (along with any parameter sets that are owned by the family).

@param aBundle Family container (bundle) that this family is to be added to

@param aFamilyId identifier for the specific family type, currently only 4, QoS (KSubConQoSFamily),Authorisation (KSubConAuthorisationFamily),

CallDescrParams (KSubConnCallDescrParamsFamily) and ContextDescrParams (KSubConnContextDescrParamsFamily), are defined.

@return a pointer to a sub-connection parameter family if successful, otherwise leaves with system error code.

*/

	{

	CSubConParameterFamily* family = new (ELeave) CSubConParameterFamily(aFamilyId);

	CleanupStack::PushL(family);

	family->ConstructL(aBundle);

	CleanupStack::Pop(family);

	return family;

	}

EXPORT_C CSubConParameterFamily* CSubConParameterFamily::NewL(CSubConParameterBundle& aBundle, TUint32 aFamilyId)

/** Creates a new sub-connection parameter set family. This class is used as a container for a number of parameter

    sets (generic and extension) that make up a family. It is a specific instantiatable class and therefore creates

	an instance of CSubConParameterFamily without using ECOM. 

Note:

The aBundle parameter that is passed into this method will take ownership of the newly created 

CSubConParameterFamily object.  When the bundle is destroyed, this family object will also be 

destroyed  (along with any parameter sets that are owned by the family).

@param aBundle Family container (bundle) that this family is to be added to.

@param aFamilyId identifier for the specific family type, currently only 4, QoS (KSubConQoSFamily),Authorisation (KSubConAuthorisationFamily),

CallDescrParams (KSubConnCallDescrParamsFamily) and ContextDescrParams (KSubConnContextDescrParamsFamily), are defined.

@return a pointer to a sub-connection parameter family if successful, otherwise leaves with system error code.

*/

	{

	CSubConParameterFamily* family = new (ELeave) CSubConParameterFamily(aFamilyId);

	CleanupStack::PushL(family);

	family->ConstructL(aBundle);

	CleanupStack::Pop(family);

	return family;

	}

EXPORT_C TInt32 CSubConParameterFamily::ExtractFamilyAndCreateBufferL(TPtrC8& aBuffer, TPtrC8& aContainerBuffer)

/** Used internally to extract the family id for the descriptor storing the serialised version of this object (and others).

    It also sets up a new buffer that is the section of the original buffer that represents this object only.

@param aBuffer Source buffer containing mulitple serialised objects (family at the start)

@param aContainerBuffer Set up by this method and represents only the serialised data of the family object.

@return the family Id, otherwise leaves with system error code.

*/

	{

	const TInt KDataHdrLen = 2 * static_cast<TInt>(sizeof(TUint32));

	// Guard to ensure length of data, pointed to by the descriptor, is not too small,

	// I.e. we are pointing to something!

	if (aBuffer.Length() < KDataHdrLen)

		{

		User::Leave(KErrArgument);

		}

 	// Obtain the 'length' value of the data pointed to by the descriptor

 	// Has to be at least size of header!

    TInt32 dataLength;

    Mem::Copy(&dataLength, aBuffer.Ptr(),sizeof(TInt32));

	// Guard to ensure 'length' value of data contains enough data to read.

	// i.e. aBuffer.Length() could point to some data whose 'length' is zero.

	//

	// Guard to ensure length of data, pointed to by the descriptor and specified by that

	// descriptor, is not smaller that the length stated in the data itself.

	// i.e. could be an array of objects.

	if ((dataLength < KDataHdrLen) || (aBuffer.Length() < dataLength))

		{

		User::Leave(KErrArgument);

		}

 	// Obtain the 'familyId' value of the data pointed to by the descriptor

	TInt32 familyId;

	Mem::Copy(&familyId, aBuffer.Ptr() + sizeof(TInt32),sizeof(TInt32));

	// Set up the container buffer

	// Point it past the 'length' & 'familyId' fields (header).

	// The data pointed to may be an array of user defined datatypes, and each datatype

	// may have arbitrary data following the header fields.

	// Point aContainerBuffer to that arbitrary data.

	aContainerBuffer.Set(aBuffer.Ptr() + KDataHdrLen, dataLength - KDataHdrLen);

	// Move source buffer ptr on to the next family, plus any following data

	aBuffer.Set(aBuffer.Ptr() + dataLength, aBuffer.Length() - dataLength);

	return familyId;

	}

EXPORT_C CSubConParameterFamily* CSubConParameterFamily::LoadL(RSubConParameterBundle& aBundle, TPtrC8& aBuffer)

/** Creates a new sub-connection parameter set family from a buffer containing the serialised object.

Note:

The aBundle parameter that is passed into this method will take ownership of the newly created 

CSubConParameterFamily object.  When the bundle is destroyed, this family object will also be 

destroyed  (along with any parameter sets that are owned by the family).

@param aBundle Family container (bundle) that this family is to be added to

@param aBuffer Buffer containing the serialised object information

@return a pointer to a sub-connection parameter family if successful, otherwise leaves with system error code.

*/

	{

	TInt32 familyId = 0;

	TPtrC8 containerBuffer(aBuffer.Ptr(), aBuffer.Length());

	familyId = ExtractFamilyAndCreateBufferL(aBuffer, containerBuffer);

	CSubConParameterFamily* family = new (ELeave) CSubConParameterFamily(familyId);

	CleanupStack::PushL(family);

	family->ConstructL(aBundle);

	User::LeaveIfError(family->Load(containerBuffer));

	CleanupStack::Pop(family);

	return family;

	}

EXPORT_C CSubConParameterFamily* CSubConParameterFamily::LoadL(CSubConParameterBundle& aBundle, TPtrC8& aBuffer)

/** Creates a new sub-connection parameter set family from a buffer containing the serialised object.

Note:

The aBundle parameter that is passed into this method will take ownership of the newly created 

CSubConParameterFamily object.  When the bundle is destroyed, this family object will also be 

destroyed  (along with any parameter sets that are owned by the family).

@param aBundle Family container (bundle) that this family is to be added to

@param aBuffer Buffer containing the serialised object information

@return a pointer to a sub-connection parameter family if successful, otherwise leaves with system error code.

*/

	{

	TInt32 familyId = 0;

	TPtrC8 containerBuffer(aBuffer.Ptr(), aBuffer.Length());

	familyId = ExtractFamilyAndCreateBufferL(aBuffer, containerBuffer);

	CSubConParameterFamily* family = new (ELeave) CSubConParameterFamily(familyId);

	CleanupStack::PushL(family);

	family->ConstructL(aBundle);

	User::LeaveIfError(family->Load(containerBuffer));

	CleanupStack::Pop(family);

	return family;

	}

EXPORT_C CSubConParameterFamily::~CSubConParameterFamily()

/** Sub-connection parameter family destructor. It cleans up the arrays deleting all

    the paarmeter sets it ownes

*/

	{

	iGenericSets.ResetAndDestroy();

	iExtensionSets[ERequested].ResetAndDestroy();

	iExtensionSets[EAcceptable].ResetAndDestroy();

	iExtensionSets[EGranted].ResetAndDestroy();

	}

EXPORT_C void CSubConParameterFamily::SetGenericSetL(CSubConGenericParameterSet& aGenericSet, TParameterSetType aType)

/** Assigns the generic parameter set of a sub-connection parameter set family.

Note:

The CSubConParameterFamily object takes ownership of the parameter set that is passed into 

this method.  When the family object is destroyed, any parameter sets owned by this object 

will also be destroyed.

@param aGenericSet Generic Parameter Set to be assigned to the family (family takes ownership)

@param aType The type of the set (requested, acceptable or granted)

@exception leaves with KAlreadyExists if a set is already assigned to the family.

*/

	{

	if (iGenericSets[aType] != NULL)

		{

		User::Leave(KErrAlreadyExists);

		}

	iGenericSets[aType] = &aGenericSet;

	}

/**

Adds an extension parameter set to a sub-connection parameter set family.

Note:

The CSubConParameterFamily object takes ownership of the parameter set that is passed into 

this method.  When the family object is destroyed, any parameter sets owned by this object 

will also be destroyed.

@param aExtensionSet Extension Parameter Set to be added to the family (family takes ownership)

@param aType The type of the set (requested, acceptable or granted)

@exception leaves with KErrNoMemory in out of memeory conditions.

*/

EXPORT_C void CSubConParameterFamily::AddExtensionSetL(CSubConExtensionParameterSet& aExtensionSet, TParameterSetType aType)

	{

	iExtensionSets[aType].AppendL(&aExtensionSet);

	}

/**

Searches a sub-connection parameter family for an extension parameter set.

DO NOT USE this form of the method. It is broken. This is only capable of finding extension sets

contained within IP Subconnection Provider, and these extension sets have been deprecated.

@param aSetId Although a TUid, this is the extension class Id 

@param aType The type of the set from TParameterSetType (ERequested, EAcceptable or EGranted)

@return Pointer to the extension set if found, otherwise a NULL pointer.

*/

EXPORT_C CSubConExtensionParameterSet* CSubConParameterFamily::FindExtensionSet(TUid aSetId, TParameterSetType aType)

	{

	// Old Ipscpr Factory IUD  = 0x10204309

	STypeId type = STypeId::CreateSTypeId(0x10204309, aSetId.iUid);

	TUint length = iExtensionSets[aType].Count();

	for (TUint i = 0; i < length; ++i)

		{

		if (iExtensionSets[aType][i]->GetTypeId() == type)

			{

			return static_cast<CSubConExtensionParameterSet*>(iExtensionSets[aType][i]);

			}

		}

	return NULL;

   }

/**

Searches a sub-connection parameter family for an extension parameter set.

@param aSetId The STypeId of the extension set

@param aType The type of the set from TParameterSetType (ERequested, EAcceptable or EGranted)

@return Pointer to the extension set if found, otherwise a NULL pointer.

*/

EXPORT_C CSubConExtensionParameterSet* CSubConParameterFamily::FindExtensionSet(STypeId aSetId, TParameterSetType aType)

	{

	TUint length = iExtensionSets[aType].Count();

	for (TUint i = 0; i < length; ++i)

		{

		if (iExtensionSets[aType][i]->GetTypeId() == aSetId)

			{

			return static_cast<CSubConExtensionParameterSet*>(iExtensionSets[aType][i]);

			}

		}

/*

 * This is a workaround for the relocated QoS extension parameter set classes. If an

 * extension set class is requested from the new factory and it can't be found another

 * check needs to be made to see if the equivalent deprecated class is there.

 *  

 * Normally this couldn't be done, but in this case its Ok since the classes

 * we're searching on are actually identical. 

 *

 * This can be removed once the deprecated class CSubConQosIPLinkR99ParamSet and

 * its friends are removed from ipscpr.

 *

 * Hardcoded values are being used here since;

 *    i)  They shouldn't be changing

 *    ii) It avoids having to include two unnecessary header files

 *

 * New Umts Factory UID    = 0x1020D460

 * Old Ipscpr Factory IUD  = 0x10204309

 * 

*/

   if (aSetId.iUid == TUid::Uid(0x1020D460))

      {

      STypeId alternateTypeId = STypeId::CreateSTypeId(0x10204309, aSetId.iType);

   	for (TUint i = 0; i < length; ++i)

   		{

   		if (iExtensionSets[aType][i]->GetTypeId() == alternateTypeId)

   			{

   			return static_cast<CSubConExtensionParameterSet*>(iExtensionSets[aType][i]);

   			}

   		}

      }

	return NULL;

	}

EXPORT_C CSubConGenericParameterSet* CSubConParameterFamily::GetGenericSet(TParameterSetType aType)

/** Accessor for the sub-connection generic parameter set of a family.

@param aType The type of the set (requested, acceptable or granted)

@return Pointer to the generic set if set, otherwise a NULL pointer.

*/

	{

	return static_cast<CSubConGenericParameterSet*>(iGenericSets[aType]);

	}

EXPORT_C TUint CSubConParameterFamily::Length() const

/** Calculates the length of buffer required to serialise this parameter set family.

@return Length of buffer required.

*/

	{

	return sizeof(TInt32) + sizeof(TInt32) + iGenericSets.Length() + iExtensionSets[ERequested].Length() + iExtensionSets[EAcceptable].Length() + iExtensionSets[EGranted].Length();

	}

EXPORT_C TInt CSubConParameterFamily::Load(TPtrC8& aBuffer)

/** Instructs this sub-connection family to set its members based on the serialiesd data

    in the buffer passed.

@param aBuffer Buffer containing the serialised family object

@return KErrNone if successful, otherwise system wide error

*/

	{

	TInt ret = iGenericSets.GetTypeId().Check(aBuffer);

	if (ret == KErrNone)

		{

		ret = iGenericSets.Load(aBuffer);

		}

	if (ret != KErrNone)

		{

		return ret;

		}

	if (aBuffer.Length() == 0)

		{

		iGenericSets.ResetAndDestroy();

		return KErrArgument;

		}

	ret = iExtensionSets[ERequested].GetTypeId().Check(aBuffer);

	if (ret == KErrNone)

		{

		ret = iExtensionSets[ERequested].Load(aBuffer);

		}

	if (ret != KErrNone)

		{

		iGenericSets.ResetAndDestroy();

		return ret;

		}

	if (aBuffer.Length() > 0)

		{

		ret = iExtensionSets[EAcceptable].GetTypeId().Check(aBuffer);

		if (ret == KErrNone)

			{

			ret = iExtensionSets[EAcceptable].Load(aBuffer);

			}

		if (ret != KErrNone)

			{

			iGenericSets.ResetAndDestroy();

			iExtensionSets[ERequested].ResetAndDestroy();

			return ret;

			}

		}

	if (aBuffer.Length() > 0)

		{

		ret = iExtensionSets[EGranted].GetTypeId().Check(aBuffer);

		if (ret == KErrNone)

			{

			ret = iExtensionSets[EGranted].Load(aBuffer);

			}

		if (ret != KErrNone)

			{

			iGenericSets.ResetAndDestroy();

			iExtensionSets[ERequested].ResetAndDestroy();

			iExtensionSets[EAcceptable].ResetAndDestroy();

			return ret;

			}

		}

	return KErrNone;

	}

EXPORT_C TInt CSubConParameterFamily::Store(TDes8& aDes) const

/** Instructs this sub-connection family to create a serialised version of itself

    and append it to the buffer that has been passed.

@param aDes Buffer to append the serialised object to

@return KErrNone if successful, otherwise system wide error (e.g. KErrOverflow if the descriptor is too small)

If unsuccessful, there is no guarantee as to the buffer or data stored in it.

*/

	{	

	// Needs to be at least this size to store len and familyId ptrs

	// aDes can only grow upto MaxLength.

	if (aDes.MaxLength() < (2 * static_cast<TInt>(sizeof(TUint32))))

		{

		return KErrOverflow;

		}

	TUint len = Length();

	aDes.Append((TUint8*)&len, sizeof(TUint32));

	aDes.Append((TUint8*)&iFamilyId, sizeof(TUint32));

	TInt ret = iGenericSets.Store(aDes);

	if (ret != KErrNone)

		{

		return ret;

		}

	ret = iExtensionSets[ERequested].Store(aDes);

	if (ret != KErrNone)

		{

		return ret;

		}

	ret = iExtensionSets[EAcceptable].Store(aDes);

	if (ret != KErrNone)

		{

		return ret;

		}

	return iExtensionSets[EGranted].Store(aDes);

	}

EXPORT_C void CSubConParameterFamily::ClearAllParameters(TParameterSetType aType)

/** Clears (removes and deletes) all parameter sets with the type specified

@param aType The type of the set to be deleted(requested, acceptable or granted)

*/

	{

	if (iGenericSets[aType] != NULL)

		{

		delete iGenericSets[aType];

		iGenericSets[aType] = NULL;

		}

	iExtensionSets[aType].ResetAndDestroy();

	}

void CSubConParameterFamily::CopyToFamilyL(RParameterFamily& aDest) const 

	{

	__ASSERT_DEBUG((TInt)CSubConParameterFamily::ENumValues == (TInt)RParameterFamily::ENumValues, User::Panic(KSpecAssert_ESockCSockcssbcn, 1));

	TInt type=0;

	for ( ; type<ENumValues; ++type)

		{

		XParameterSetBase* srcSet =

			 static_cast<XParameterSetBase*>(iGenericSets[type]);

		if(srcSet)

			{

			XParameterSetBase* newSet =

				static_cast<XParameterSetBase*>

				(XParameterSetBase::NewInstanceL(srcSet->GetTypeId()));

			newSet->Copy(*srcSet);

			aDest.AddParameterSetL(newSet,RParameterFamily::TParameterSetType(type));

			}