// 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:

// Implementation of sbtypes

// 

//

/**

 @file

*/

#include <e32std.h>

#include <connect/panic.h>

#include "sbtypes.h"

#include <s32mem.h>

#include <apgcli.h>

#include <apmstd.h>

namespace conn

	{

	EXPORT_C CDataOwnerInfo* CDataOwnerInfo::NewL( CSBGenericDataType* aGenericDataType,

										  TCommonBURSettings aCommonSettings,

										  TPassiveBURSettings aPassiveSettings,

										  TActiveBURSettings aActiveSettings,

										  const TDriveList& aDriveList )

	/**

	Symbian constructor. This constructor is used to create a CDataOwnerInfo from it's 

	constituent parts, rather than from an externalised class etc.

	@param aGenericDataType pointer to CSBGenericDataType object

	@param aCommonSettings flags for storing common backup and restore settings

	@param aPassiveSettings flags for storing passive backup and restore settings

	@param aActiveSettings flags for storing active backup and restore settings

	@param aDriveList the array of drives the data owner has data on

	@return A pointer to the CDataOwnerInfo object

	*/

		{

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

		CleanupStack::PushL(self);

		self->ConstructL(aGenericDataType, aCommonSettings, aPassiveSettings, aActiveSettings, aDriveList);

		CleanupStack::Pop(self);

		return self;

		}

	EXPORT_C CDataOwnerInfo* CDataOwnerInfo::NewL( const TDesC8& aFlatDataOwnerInfo )

	/**

	Symbian constructor for constructing a CDataOwnerInfo object from an externalised CDataOwnerInfo 

	object. This may be used when taking an externalised class out of a PC message or over IPC.

	@param aFlatDataOwnerInfo a flat data owner info returned from IPC

	@return A pointer to the CDataOwnerInfo object

	*/

		{

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

		CleanupStack::PushL(self);

		self->ConstructL(aFlatDataOwnerInfo);

		CleanupStack::Pop(self);

		return self;

		}

	CDataOwnerInfo::CDataOwnerInfo()

	/**

	C++ Constructor 

	*/

		{

		}

	EXPORT_C CDataOwnerInfo::~CDataOwnerInfo()

	/**

	C++ Destructor

	*/

		{

		delete iGenericDataType;

		}

	void CDataOwnerInfo::ConstructL(CSBGenericDataType* aGenericDataType,

									TCommonBURSettings aCommonSettings,

									TPassiveBURSettings aPassiveSettings,

									TActiveBURSettings aActiveSettings,

									const TDriveList& aDriveList)

	/**

	Symbian OS 2nd phase constructor.

	@param aGenericDataType pointer to CSBGenericDataType object

	@param aCommonSettings flags for storing common backup and restore settings

	@param aPassiveSettings flags for storing passive backup and restore settings

	@param aActiveSettings flags for storing active backup and restore settings

	@param aDriveList the array of drives the data owner has data on

	*/

		{

		if (aGenericDataType == NULL)

			{

			User::Leave(KErrArgument);

			}

		iGenericDataType = aGenericDataType;

		iCommonBURSettings = aCommonSettings;

		iPassiveBURSettings = aPassiveSettings;

		iActiveBURSettings = aActiveSettings;

		iDriveList = aDriveList;

		}

	void CDataOwnerInfo::ConstructL(const TDesC8& aFlatDataOwnerInfo)

	/**

	Symbian OS 2nd phase constructor. Internalise a descriptor containing a flattened 

	object of this type

	@param aFlatDataOwnerInfo a flat data owner info returned from IPC

	*/

		{

		// TPtr8 that points to aFlatDataOwnerInfo (which remains const)

		TPtr8 pSource(const_cast<TUint8*>(aFlatDataOwnerInfo.Ptr()), aFlatDataOwnerInfo.Size());

		pSource.SetMax();

		// Position that we've read up to in the externalised class buffer

		TInt sourcePos = 0;

		TInt32 genericDataTypeSize;

		// Extract the CSBGenericDataType's size

		UnpackTypeAdvance(genericDataTypeSize, pSource, sourcePos);

		// Construct a new CSBGenericDataType from the message

		iGenericDataType = CSBGenericDataType::NewL(pSource.MidTPtr(sourcePos, genericDataTypeSize));

		sourcePos += genericDataTypeSize;

		UnpackTypeAdvance(iCommonBURSettings, pSource, sourcePos);

		UnpackTypeAdvance(iPassiveBURSettings, pSource, sourcePos);

		UnpackTypeAdvance(iActiveBURSettings, pSource, sourcePos);

		UnpackTypeAdvance(iDriveList, pSource, sourcePos);

		}

	EXPORT_C CSBGenericDataType& CDataOwnerInfo::Identifier()

	/**

	Getter method for returning a reference to the CSBGenericDataType

	object

	@return Reference to the CSBGenericDataType object

	*/

		{

		return *iGenericDataType;

		}

	EXPORT_C const CSBGenericDataType& CDataOwnerInfo::Identifier() const

	/**

	Getter method for returning a reference to a const CSBGenericDataType

	object, containing information including 

	@return Reference to the const CSBGenericDataType object

	*/

		{

		return *iGenericDataType;

		}

	EXPORT_C TCommonBURSettings CDataOwnerInfo::CommonSettings() const

	/**

	Getter method for returning the Backup and Restore flags that

	the were specified in the Data Owner's backup registration file

	that relate to both Active and Passive backup

	@return The Common backup and restore settings of the Data Owner

	*/

		{

		return iCommonBURSettings;

		}

	EXPORT_C TPassiveBURSettings CDataOwnerInfo::PassiveSettings() const

	/**

	Getter method for returning the Passive Backup and Restore flags that

	the were specified in the Data Owner's backup registration file

	@return The passive backup and restore settings of the data owner

	*/

		{

		return iPassiveBURSettings;

		}

	EXPORT_C TActiveBURSettings CDataOwnerInfo::ActiveSettings() const

	/**

	Getter method for returning the Active Backup and Restore flags that

	the were specified in the Data Owner's backup registration file

	@return The active backup and restore settings of the data owner

	*/

		{

		return iActiveBURSettings;

		}

	EXPORT_C TDriveList& CDataOwnerInfo::DriveList()

	/**

	Getter method for returning the list of drives on which the Data Owner stores

	data to be backed up

	@return The drive list of the data owner

	*/

		{

		return iDriveList;

		}

	EXPORT_C const TDriveList& CDataOwnerInfo::DriveList() const

	/**

	Const getter method for returning the list of drives on which the Data Owner stores

	data to be backed up

	@return The drive list of the data owner

	*/

		{

		return iDriveList;

		}

	EXPORT_C HBufC8* CDataOwnerInfo::ExternaliseL()

	/**

	Method to externalise the data owner so that it can be passed flat over the IPC interface 

	or appended to a PC bound message, pops the pointer off the cleanup stack before it is

	returned

	@return The externalised buffer

	*/

		{

		HBufC8* dataOwnerBuffer = ExternaliseLC();

		CleanupStack::Pop(dataOwnerBuffer);

		return dataOwnerBuffer;

		}

	EXPORT_C HBufC8* CDataOwnerInfo::ExternaliseLC()

	/**

	Method to externalise the data owner so that it can be passed flat over the IPC interface 

	or appended to a PC bound message, leaves the pointer on the cleanup stack.

	@return The externalised buffer

	*/

		{

		HBufC8* dataBuffer = HBufC8::NewLC(Size());				

		TPtr8 bufferPtr(dataBuffer->Des());

		iDriveList.SetMax();	// Ensure that the drivelist array is set to max

		const TDesC8& dataType = iGenericDataType->Externalise();

		TInt32 typeSize = dataType.Size();

		bufferPtr.Append(reinterpret_cast<TUint8*>(&typeSize),sizeof(TInt32));

		bufferPtr.Append(dataType);

		bufferPtr.Append(reinterpret_cast<TUint8*>(&iCommonBURSettings), sizeof(TCommonBURSettings));

		bufferPtr.Append(reinterpret_cast<TUint8*>(&iPassiveBURSettings), sizeof(TPassiveBURSettings));

		bufferPtr.Append(reinterpret_cast<TUint8*>(&iActiveBURSettings), sizeof(TActiveBURSettings));

		bufferPtr.Append(iDriveList);

		return dataBuffer;

		}

	EXPORT_C TInt CDataOwnerInfo::Size() const

	/**

	Getter for returning the total flattened size of the object. Used for calculating the 

	size of a descriptor to fit the externalised instance of this object

	@return Size of class in bytes once flattened

	*/

		{

		TInt size = 	sizeof(TCommonBURSettings) +

						sizeof(TPassiveBURSettings) +

						sizeof(TActiveBURSettings) +

						sizeof(TInt32) + 	// Buffer size is stored as a TInt32

						iGenericDataType->Externalise().Size() +

						iDriveList.Size();

		return size;

		}

	// CSBGenericDataType			

	EXPORT_C CSBGenericDataType* CSBGenericDataType::NewL(const TDesC8& aDes)

	/**

	Symbian constructor. A base CSBGenericDataType may only be instantiated from a previously 

	externalised data type. This is the method that is used to take a generic data type from 

	either an IPC response or from a message sent by the PC. This method will not take ownership 

	of the descriptor aDes

	@param aDes descriptor containing the buffer of data

	@return A pointer to the CSBGenericDataType object

	*/

		{

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

		CleanupStack::PushL(self);

		self->ConstructL(aDes);

		CleanupStack::Pop(self);

		return self;

		}

	CSBGenericDataType::CSBGenericDataType(): iDataBuffer(NULL)

	/**

	C++ Constructor. Any derived types must increment iSize in their C++ constructors in order 

	that when CSBGenericDataType::BaseConstructL() is called, the data buffer is initialised 

	to be large enough to accomodate the data stored by the derived type

	*/

		{

		// Initialise iSize

		iSize = sizeof(TSBDerivedType);

		}

	EXPORT_C CSBGenericDataType::~CSBGenericDataType()

	/**

	C++ Destructor

	*/

		{

		delete iDataBuffer;

		}

	void CSBGenericDataType::ConstructL(const TDesC8& aDes)

	/**

	Symbian OS 2nd phase constructor. Called when creating a base class from raw data

	i.e. off the wire/IPC. Creates the base type data buffer to store object data in

	@param aDes descriptor containing the buffer of data

	*/

		{

		// Store the length of the descriptor as our max length

		iSize = aDes.Size();

		// Create a new buffer and copy the passed one into it

		iDataBuffer = HBufC8::NewL(iSize);

		*iDataBuffer = aDes;

		TInt offset = 0;

		// Initialise member pointers of all classes in the inheritence tree

		InitialiseL(offset);

		// The base type should be as long as the des passed in (more info in a derived)

		iDataBuffer->Des().SetLength(iSize);

		}

	void CSBGenericDataType::InitialiseL(TInt& aOffset)

	/**

	Initialise all of member data offsets inside the base and derived classes

	@param 	aOffset The running offset indicating the position in the descriptor that has 

			been parsed up to

	*/

		{

		if (iSize < sizeof(TSBDerivedType))

			{

			User::Leave(KErrCorrupt);

			}

		// Throwaway type used to determine the offset advance

		TSBDerivedType derivedType;

		iDerivedTypeOffset = aOffset;

		UnpackTypeAdvance(derivedType, *iDataBuffer, aOffset);

		if (derivedType < 0 || derivedType > KMaxDerivedTypes)

			{

			User::Leave(KErrCorrupt);

			}

		iDataBuffer->Des().SetLength(aOffset);

		}

	void CSBGenericDataType::BaseConstructL()

	/**

	Symbian OS 2nd phase constructor. Called by derived classes when creating an end 

	derived class i.e. CSBSecureId. Constructs base class data buffer to store object

	data in. Size of buffer has been determined by C++ constructors of all classes 

	in inheritence tree incrementing iSize member so that a buffer big enough to store

	the data of all classes is created.

	*/

		{

		// All derived classes should += their size to iSize

		iDataBuffer = HBufC8::NewL(iSize);

		}

	EXPORT_C const TDesC8& CSBGenericDataType::Externalise() const

	/**

	Getter for a reference to the buffer containing the data

	@return  Reference to the buffer containing the data

	*/

		{

		return *iDataBuffer;

		}

	EXPORT_C TSBDerivedType CSBGenericDataType::DerivedTypeL() const

	/**

	Getter method for returning the type of the derived object. Used to determine at run time 

	which derived type this base type contains

	@return The type of the derived object

	*/

		{

		TSBDerivedType derivedType;

		UnpackType(derivedType, *iDataBuffer, iDerivedTypeOffset);

		return derivedType;

		}

	void CSBGenericDataType::UnpackDescriptorTypeAdvance(TDesC16& aDes, TInt& aOffset)

		/**

		Function to copy a simple type from a specified position in aDes

		defined by aOffset. aOffset is advanced so that on return, the new 

		offset is stored enabling the next call to UnpackType() to point at the position 

		following this type.

		@param aDes The buffer that contains the type T pointed to by aPtr

		@param aOffset The running index of where the following type begins. Updated by ExtractPointer

		*/

		{

		// Set length of the unicode string in characters

		TUint32 length;

		UnpackTypeAdvance(length, *iDataBuffer, aOffset);

		TUint8* pRawSource = reinterpret_cast<TUint8*>(const_cast<TUint16*>(aDes.Ptr()));

		TUint8* pRawTarget = const_cast<TUint8*>(static_cast<const TUint8*>(iDataBuffer->Ptr() + aOffset));

		for (TInt32 index = 0; index < (length * KCharWidthInBytes) ; index++)

			{

			*pRawTarget++ = *pRawSource++;

			aOffset++;

			}

		}

	void CSBGenericDataType::UnpackDescriptorTypeAdvance(TDesC8& aDes, TInt& aOffset)

		/**

		Function to copy a simple type from a specified position in aDes

		defined by aOffset. aOffset is advanced so that on return, the new 

		offset is stored enabling the next call to UnpackType() to point at the position 

		following this type.

		@param aDes The buffer that contains the descriptor to copy from

		@param aOffset The running index of where the following type begins. Updated by ExtractPointer

		*/

		{

		// Set length of the string in 8-bit byte characters

		TUint32 length;

		UnpackTypeAdvance(length, *iDataBuffer, aOffset);

		TUint8* pRawSource = const_cast<TUint8*>(aDes.Ptr());

		TUint8* pRawTarget = const_cast<TUint8*>(iDataBuffer->Ptr() + aOffset);

		for (TInt32 index = 0; index < length ; index++)

			{

			*pRawTarget++ = *pRawSource++;

			aOffset++;

			}

		}

	void CSBGenericDataType::UnpackTPtrAdvance(TPtrC16& aDes, TInt& aOffset)

		/**

		Function to copy a simple type from a specified position in aDes

		defined by aOffset. aOffset is advanced so that on return, the new 

		offset is stored enabling the next call to UnpackType() to point at the position 

		following this type.

		@param aDes The buffer that contains the type T pointed to by aPtr

		@param aOffset The running index of where the following type begins. Updated by ExtractPointer

		*/

		{

		// Set length of the unicode string in characters

		TInt32 length;

		UnpackTypeAdvance(length, *iDataBuffer, aOffset);

		aDes.Set(reinterpret_cast<const TUint16*>(iDataBuffer->Ptr() + aOffset), length);

		aOffset += aDes.Size();

		}

	void CSBGenericDataType::UnpackTPtrAdvance(TPtrC8& aDes, TInt& aOffset)

		/**

		Function to copy a simple type from a specified position in aDes

		defined by aOffset. aOffset is advanced so that on return, the new 

		offset is stored enabling the next call to UnpackType() to point at the position 

		following this type.

		@param aDes The buffer that contains the descriptor to copy from

		@param aOffset The running index of where the following type begins. Updated by ExtractPointer

		*/

		{

		// Set length of the string in 8-bit byte characters

		TInt32 length;

		UnpackTypeAdvance(length, *iDataBuffer, aOffset);

		aDes.Set(iDataBuffer->Ptr() + aOffset, length);

		aOffset += aDes.Size();

		}

	void CSBGenericDataType::PackDescriptorTypeAdvance(const TDesC16& aDes, TInt& aOffset)

		/**

		Templated function to copy a simple type into a specified position in aDes

		defined by aOffset. aOffset is not advanced as a result of this operation

		@param aDes The buffer to copy from

		@param aOffset The running index of where the following type begins. Updated by ExtractPointer

		*/

		{

		TInt32 length = aDes.Length();

		PackTypeAdvance(length, *iDataBuffer, aOffset);

 		TUint8* pRawSource = const_cast<TUint8*>(reinterpret_cast<const TUint8*>(aDes.Ptr()));

		TUint8* pRawTarget = const_cast<TUint8*>(reinterpret_cast<const TUint8*>(iDataBuffer->Ptr())) + aOffset;

		for (TInt32 index = 0; index < (length * KCharWidthInBytes); index++)

			{

			*pRawTarget++ = *pRawSource++;

			aOffset++;

			}

		}

	void CSBGenericDataType::PackDescriptorTypeAdvance(const TDesC8& aDes, TInt& aOffset)

		/**

		Templated function to copy a simple type into a specified position in aDes

		defined by aOffset. aOffset is not advanced as a result of this operation

		@param aDes The buffer to copy from