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

// MSVREG.CPP

//

#include "MSVREG.H"

#include "MSVRUIDS.H"

#include "MSVPANIC.H"

#include "MsvSecurityCapabilitySet.h"

#include <f32file.h>

#include <s32strm.h>

#include <e32uid.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "msvconsts.h"				

#endif

/** Creates a new CMtmDllInfo and initialises it with values describing an MTM 

component. 

@param aHumanReadableName Descriptor holding a descriptive name for the MTM 

component 

@param aUidType Group of UIDs for the MTM. The UIDs should be as follows: UID1: 

always KDynamicLibraryUid UID2: identifies whether the MTM component is a 

Client-side MTM, User Interface MTM, UI Data MTM, or Server-side MTM. UID3: 

identifies this concrete MTM uniquely 

@param aFilename A full filename (including drive and path) of the MTM dll

@param aEntryPointOrdinalNumber Ordinal of factory function for the MTM 

@param aVersion Version information for the MTM component 

@leave KErrNoMemory A memory allocation failed 

@return New CMtmDllInfo initialised with passed values */

EXPORT_C CMtmDllInfo* CMtmDllInfo::NewL(const TDesC& aHumanReadableName,const TUidType& aUidType,const TDesC& aFilename,TInt aEntryPointOrdinalNumber,const TVersion aVersion)

	{

	CMtmDllInfo* mtmdllinfo=new(ELeave) CMtmDllInfo(aUidType,aEntryPointOrdinalNumber,aVersion);

	CleanupStack::PushL(mtmdllinfo);

	mtmdllinfo->ConstructL(aHumanReadableName, aFilename);

	CleanupStack::Pop(mtmdllinfo);

	return mtmdllinfo;	

	}

/** Creates a new CMtmDllInfo initialised from another CMtmDllInfo object. 

@param aMtmDllInfo A CMtmDllInfo object from which to initialise this

@leave KErrNoMemory A memory allocation failed 

@return New CMtmDllInfo initialised with passed CMtmDllInfo */

EXPORT_C CMtmDllInfo* CMtmDllInfo::NewL(const CMtmDllInfo& aMtmDllInfo)

	{

	CMtmDllInfo* mtmdllinfo = new(ELeave) CMtmDllInfo(aMtmDllInfo);

	CleanupStack::PushL(mtmdllinfo);

	mtmdllinfo->ConstructL(*aMtmDllInfo.iHumanReadableName, *aMtmDllInfo.iFilename);

	CleanupStack::Pop(mtmdllinfo);

	return mtmdllinfo;

	}

/** Creates a new CMtmDllInfo and initialises it with values read from a stream. 

The contents of the stream to read will have been created by CMtmDllInfo::ExternalizeL().

@param aStream Stream to read from 

@leave KErrNoMemory A memory allocation failed

@return New CMtmDllInfo */

EXPORT_C CMtmDllInfo* CMtmDllInfo::NewL(RReadStream& aStream)

	{

	CMtmDllInfo* mtmdllinfo=new(ELeave) CMtmDllInfo();

	CleanupStack::PushL(mtmdllinfo);

	mtmdllinfo->InternalizeL(aStream);

	CleanupStack::Pop();

	return mtmdllinfo;	

	}

/** Destructor. */

EXPORT_C CMtmDllInfo::~CMtmDllInfo()

	{

	delete iHumanReadableName;

	delete iFilename;

	}

EXPORT_C void CMtmDllInfo::SetHumanReadableNameL(const TDesC& aHumanReadableName)

/** Sets the descriptive name of the MTM component for which the object holds registration 

data.

@param aHumanReadableName Descriptor holding a descriptive name for the MTM 

component */

	{

	__ASSERT_DEBUG(aHumanReadableName.Length()<=KHumanReadableNameLength,PanicServer(EMsvHumanReadableNameTooLong));

	HBufC* humanreadablename=HBufC::NewL(aHumanReadableName.Length());

	delete iHumanReadableName;

	iHumanReadableName=humanreadablename;

	iHumanReadableName->Des().Copy(aHumanReadableName);

	}

/** Internalises the object from a stream. 

The contents of the stream to read will have been created by CMtmDllInfo::ExternalizeL().

@param aStream Stream to read from 

@leave Error Standard streaming errors

*/

EXPORT_C void CMtmDllInfo::InternalizeL(RReadStream& aStream)

	{

	HBufC* humanreadablename=HBufC::NewL(aStream,KHumanReadableNameLength);

	delete iHumanReadableName;

	iHumanReadableName=humanreadablename;

	iMessagingCapability = aStream.ReadInt8L();

	iSendBodyCapability = aStream.ReadInt8L();

	iCapabilitiesAvailable = aStream.ReadInt8L();

	TUid uid1,uid2,uid3;

	aStream >> uid1;

	aStream >> uid2;

	aStream >> uid3;

	TUidType uidtype(uid1,uid2,uid3);

	iUidType=uidtype;                 

	iEntryPointOrdinalNumber=aStream.ReadInt32L();

	iVersion.iMajor=aStream.ReadInt8L();

	iVersion.iMinor=aStream.ReadInt8L();

	iVersion.iBuild=aStream.ReadInt16L();

	HBufC* temp;

	if (uid3.iUid == KUidMtmDefaultSpecificVal)

		{

		// We can assume we are reading data from an updated stream.

		// The version number should be <= 2.0.

		__ASSERT_DEBUG((iVersion.iMajor < KMtmComponentCurrentMajorVersionNumber) || (iVersion.iMajor == KMtmComponentCurrentMajorVersionNumber&& iVersion.iMinor == KMtmComponentCurrentMinorVersionNumber), PanicServer(EMsvBadMtmVersionNumber));

		temp = HBufC::NewL(aStream, KMaxFileName);

		}

	else

		{

		// Just create a zero length filename for old versions

		temp = KNullDesC().AllocL();

		}

	delete iFilename;

	iFilename = temp;

	}

// no longer used but as it is exported it has been kept

/** Externalises the object to a stream. 

@param aStream Stream to write to 

@leave Error Standard streaming errors

*/

EXPORT_C void CMtmDllInfo::ExternalizeL(RWriteStream& aStream) const

	{

	aStream << *iHumanReadableName;

	aStream.WriteInt8L(iMessagingCapability);

	aStream.WriteInt8L(iSendBodyCapability);

	aStream.WriteInt8L(iCapabilitiesAvailable);

	aStream << iUidType[0];                 

	aStream << iUidType[1];                 

	aStream << iUidType[2];                 

	aStream.WriteInt32L(iEntryPointOrdinalNumber);

	aStream.WriteInt8L(iVersion.iMajor);

	aStream.WriteInt8L(iVersion.iMinor);

	aStream.WriteInt16L(iVersion.iBuild);

	if (iUidType[2].iUid == KUidMtmDefaultSpecificVal)

		{

		// The version number should be <= 2.0.

		__ASSERT_DEBUG((iVersion.iMajor < KMtmComponentCurrentMajorVersionNumber) || (iVersion.iMajor == KMtmComponentCurrentMajorVersionNumber && iVersion.iMinor == KMtmComponentCurrentMinorVersionNumber), PanicServer(EMsvBadMtmVersionNumber));

		aStream << FileName();

		}

	}

/** Overloaded equality operator.

@param aMtmDllInfo Object to compare

@return True if the iFileName member and the UIDs (iUidType member) are the same in both objects,

otherwise false

*/

EXPORT_C TBool CMtmDllInfo::operator==(const CMtmDllInfo& aMtmDllInfo) const

	{

	return (FileName().CompareF(aMtmDllInfo.FileName()) == 0 && (iUidType==aMtmDllInfo.iUidType));

	}

CMtmDllInfo::CMtmDllInfo(const TUidType& aUidType,TInt aEntryPointOrdinalNumber,const TVersion aVersion):

	iUidType(aUidType),                

	iEntryPointOrdinalNumber(aEntryPointOrdinalNumber),

	iVersion(aVersion)

	{

	__DECLARE_NAME(_S("CMtmDllInfo"));

	}

CMtmDllInfo::CMtmDllInfo()

	{

	}

CMtmDllInfo::CMtmDllInfo(const CMtmDllInfo& aMtmDllInfo):

	iUidType(aMtmDllInfo.iUidType),

	iEntryPointOrdinalNumber(aMtmDllInfo.iEntryPointOrdinalNumber),

	iVersion(aMtmDllInfo.iVersion),

	iMessagingCapability(aMtmDllInfo.iMessagingCapability),

	iSendBodyCapability(aMtmDllInfo.iSendBodyCapability),

	iCapabilitiesAvailable(aMtmDllInfo.iCapabilitiesAvailable)

	{

	}

void CMtmDllInfo::ConstructL(const TDesC& aHumanReadableName, const TDesC& aFilename)

	{

	iHumanReadableName = aHumanReadableName.AllocL();

	iFilename = aFilename.AllocL();

	}

TPtrC CMtmDllInfo::FileName() const

	{

	return *iFilename;

	}

/** Sets a flag to indicate that the MTM can send messages. 

@param aCapability True to set the flag, false to clear it

*/

void CMtmDllInfo::SetMessagingCapability(TBool aCapability)

	{

	iMessagingCapability = aCapability;

	}

/** Sets a flag to indicate that the MTM can handle body text. 

@param aCapability True to set the flag, false to clear it

*/

void CMtmDllInfo::SetSendBodyCapability(TBool aCapability)

	{

	iSendBodyCapability = aCapability;

	}

/** Sets a flag to indicate that settings have been made for 

the MessagingCapability() and SendBodyCapability() flags.

These settings are optional, so may not have been made 

for all MTMs.  

@param aCapability True if the settings exist; otherwise false

*/

void CMtmDllInfo::SetCapabilitiesAvailable(TBool aCapability)

	{

	iCapabilitiesAvailable = aCapability;

	}

/** Tests if the flag that indicates that the MTM can send 

messages has been set. 

@return True if the flag has been set; otherwise false

*/

EXPORT_C TBool CMtmDllInfo::MessagingCapability() const

	{

	return iMessagingCapability;

	}

/** Tests if the flag that indicates that the MTM can handle  

body text has been set. 

@return True if the flag has been set; otherwise false

*/

EXPORT_C TBool CMtmDllInfo::SendBodyCapability() const

	{

	return iSendBodyCapability;

	}

/** Tests if settings have been made for the MessagingCapability() 

and SendBodyCapability() flags.

These settings are optional, so may not have been made 

for all MTMs.  

@return True if the settings exist; otherwise false

*/

EXPORT_C TBool CMtmDllInfo::CapabilitiesAvailable() const

	{

	return iCapabilitiesAvailable;

	}

/** Default constructor. */

EXPORT_C CMtmDllInfoArray::CMtmDllInfoArray():

	CArrayPtrFlat<CMtmDllInfo>(8)

	{

	__DECLARE_NAME(_S("CMtmDllInfoArray"));

	}

/** Destructor. */

EXPORT_C CMtmDllInfoArray::~CMtmDllInfoArray()

	{

	ResetAndDestroy();

	}

EXPORT_C void CMtmDllInfoArray::AddMtmDllInfoL(CMtmDllInfo* aMtmDllInfo)

/** Appends a CMtmDllInfo to the array.

@param aMtmDllInfo CMtmDllInfo to append 

@leave KErrNoMemory A memory allocation failed */

	{

	CleanupStack::PushL(aMtmDllInfo);

	AppendL(aMtmDllInfo);

	CleanupStack::Pop();

	}

/** Creates a new CMtmGroupData and initialise it with registration data for an 

MTM group. 

@param aMtmTypeUid UID that uniquely identifies the MTM group 

@param aTechnologyTypeUid UID that can be used to indicate the messaging technology 

which the MTM group implements 

@param aMtmDllInfoArray Array of registration data for the MTM components in 

the group. This function takes immediate responsibility for aMtmDllInfoArray,

so it should not be on the cleanup stack prior to the call. If successful, 

the newly created CMtmGroupData takes ownership of the object

@param aMtmRequiredCaps The required security capabilities for this MTM group

@leave KErrNoMemory A memory allocation failed 

@return New initialised CMtmGroupData */

EXPORT_C CMtmGroupData* CMtmGroupData::NewL(TUid aMtmTypeUid, TUid aTechnologyTypeUid, CMtmDllInfoArray* aMtmDllInfoArray, const TCapabilitySet& aMtmRequiredCaps)

	{

	__ASSERT_DEBUG(aMtmDllInfoArray != NULL, PanicServer(EMsvConstructWithNullDllInfoArray));

	CleanupStack::PushL(aMtmDllInfoArray);	

	CMtmGroupData* self = new(ELeave) CMtmGroupData(aMtmTypeUid, aTechnologyTypeUid, aMtmDllInfoArray, aMtmRequiredCaps);

	CleanupStack::Pop(aMtmDllInfoArray); 

	return self;	

	}

/** Creates a new CMtmGroupData and initialises it with another CMtmGroupData

@param aMtmTypeGroupData Another CMtmGroupData from which to copy

@leave KErrNoMemory A memory allocation failed 

@return New initialised CMtmGroupData */

EXPORT_C CMtmGroupData* CMtmGroupData::NewL(const CMtmGroupData& aMtmGroupData)

	{

	CMtmGroupData* self = new(ELeave) CMtmGroupData(aMtmGroupData.iMtmTypeUid, aMtmGroupData.iTechnologyTypeUid, NULL, aMtmGroupData.iMtmRequiredCaps);

	CleanupStack::PushL(self);

	self->ConstructL(aMtmGroupData);

	CleanupStack::Pop(self);

	return self;

	}

CMtmGroupData::CMtmGroupData(TUid aMtmTypeUid, TUid aTechnologyTypeUid, CMtmDllInfoArray* aMtmDllInfoArray,const TCapabilitySet& aMtmRequiredCaps):

	iMtmTypeUid(aMtmTypeUid),

	iTechnologyTypeUid(aTechnologyTypeUid),

	iMtmDllInfoArray(aMtmDllInfoArray),

	iMtmRequiredCaps(aMtmRequiredCaps)

	{

	}

void CMtmGroupData::AppendMtmDllInfoArrayL(const CMtmDllInfoArray& aMtmDllInfoArray)

	{

	TInt count=aMtmDllInfoArray.Count();

	for (TInt ii=0; ii<count; ++ii)

		{

		CMtmDllInfo* mtmdllinfo = CMtmDllInfo::NewL(*aMtmDllInfoArray[ii]);

		AppendMtmDllInfoL(mtmdllinfo);

		}

	}

void CMtmGroupData::ConstructL(const CMtmGroupData& aMtmGroupData)

	{

	iMtmDllInfoArray = new(ELeave) CMtmDllInfoArray();

	AppendMtmDllInfoArrayL(aMtmGroupData.MtmDllInfoArray());

	}

void CMtmGroupData::ConstructL()

	{

	iMtmDllInfoArray = new(ELeave) CMtmDllInfoArray();

	}

EXPORT_C CMtmGroupData* CMtmGroupData::NewL(RReadStream& aStream)

/** Creates a new CMtmGroupData and initialises it from the specified stream.

@param aStream Stream from which to read previously externalised CMtmGroupData 

@leave KErrNoMemory A memory allocation failed 

@return New initialised CMtmGroupData */

	{

	CMtmGroupData* mtmgroupdata=new(ELeave) CMtmGroupData();

	CleanupStack::PushL(mtmgroupdata);

	mtmgroupdata->ConstructL();

	mtmgroupdata->InternalizeL(aStream);

	CleanupStack::Pop();

	return mtmgroupdata;	

	}

/** Destructor. */

EXPORT_C CMtmGroupData::~CMtmGroupData()

	{

	delete iMtmDllInfoArray;

	}

EXPORT_C void CMtmGroupData::InternalizeL(RReadStream& aStream)

/** Internalises group registration data. 

@param aStream Stream from which to internalise object */

	{

	MtmDllInfoArrayPrivate().ResetAndDestroy();

	aStream >> iMtmTypeUid;

	aStream >> iTechnologyTypeUid;

	TInt count=aStream.ReadInt32L();

	for (TInt i=0; i<count; i++)

		{

		CMtmDllInfo* mtmdllinfo=CMtmDllInfo::NewL(aStream);

		AppendMtmDllInfoL(mtmdllinfo);

		}

	MsvSecurityCapabilitySetUtils::InternalizeL(aStream,iMtmRequiredCaps);

	}

/** Returns a constant reference to the array of MTM dll information objects owned by the CMtmGroupData.

@return A constant reference to the MTM dll info array*/

EXPORT_C const CMtmDllInfoArray& CMtmGroupData::MtmDllInfoArray() const

	{

	// Return a const reference to the dll info array

	__ASSERT_DEBUG(iMtmDllInfoArray != NULL, PanicServer(EMsvAttemptToUseNullDllInfoArray));

	return *iMtmDllInfoArray;

	}

CMtmDllInfoArray& CMtmGroupData::MtmDllInfoArrayPrivate()

	{

	// Return a non-const reference to the dll info array. Only for use within

	// this class

	__ASSERT_DEBUG(iMtmDllInfoArray != NULL, PanicServer(EMsvAttemptToUseNullDllInfoArray));

	return *iMtmDllInfoArray;

	}

EXPORT_C const TCapabilitySet& CMtmGroupData::GetMtmRequiredCapabilities() const

	{

	return iMtmRequiredCaps;

	}

 // not used but as it is exported it has been kept

EXPORT_C void CMtmGroupData::ExternalizeL(RWriteStream& aStream) const

/** Externalises group registration data. 

This is the method by which registration data is written to a MTM registration 

data file.

@param aStream Stream to which to externalise object */

	{

	aStream << iMtmTypeUid;

	aStream << iTechnologyTypeUid;

	const CMtmDllInfoArray& mtmDllInfoArray = MtmDllInfoArray();

	TInt count=mtmDllInfoArray.Count();

	aStream.WriteInt32L(count);

	for (TInt ii=0; ii<count; ++ii)

		aStream << *mtmDllInfoArray[ii];

	MsvSecurityCapabilitySetUtils::ExternalizeL(aStream,iMtmRequiredCaps);

	}

EXPORT_C TBool CMtmGroupData::operator==(const CMtmGroupData& aMtmGroupData) const

/** Tests for equality with another CMtmGroupData object.

@param aMtmGroupData CMtmGroupData object with which to compare 

@return ETrue: equal, EFalse: unequal.  */

	{

	TBool isequal=((iMtmTypeUid==aMtmGroupData.iMtmTypeUid) && (iTechnologyTypeUid==aMtmGroupData.iTechnologyTypeUid));

	if (isequal)

		{

		const CMtmDllInfoArray& mtmDllInfoArray1 = MtmDllInfoArray();

		const CMtmDllInfoArray& mtmDllInfoArray2 = aMtmGroupData.MtmDllInfoArray();

		TInt count1=mtmDllInfoArray1.Count();

		TInt count2=mtmDllInfoArray2.Count();

		TBool isequal=(count1==count2);

		for (TInt ii=0; (ii<count1) && isequal; ++ii)

			isequal=(mtmDllInfoArray1[ii]==mtmDllInfoArray2[ii]);

		}

	if (isequal)

		{

		isequal = (iMtmRequiredCaps.HasCapabilities(aMtmGroupData.iMtmRequiredCaps)

			&& aMtmGroupData.iMtmRequiredCaps.HasCapabilities(iMtmRequiredCaps));

		}

	return isequal;

	}

CMtmGroupData::CMtmGroupData(TUid aMtmTypeUid,TUid aTechnologyTypeUid):

	iMtmTypeUid(aMtmTypeUid),

	iTechnologyTypeUid(aTechnologyTypeUid)

	{

	__DECLARE_NAME(_S("CMtmGroupData"));

	}

void CMtmGroupData::AppendMtmDllInfoL(CMtmDllInfo* aMtmDllInfo)

	{

	CMtmDllInfoArray& mtmDllInfoArray = MtmDllInfoArrayPrivate();

	TInt index = mtmDllInfoArray.Count();

	CleanupStack::PushL(aMtmDllInfo);

	if (index==KMsvNumMtmDllTypes)

		User::Leave(KErrNotSupported);  //  There may be a better error value

	if (aMtmDllInfo->iUidType[0]!=KDynamicLibraryUid)  

		User::Leave(KErrNotSupported);  

	TUid mtmdlltypeuid[KMsvNumMtmDllTypes] = { KUidMtmServerComponentVal, KUidMtmClientComponentVal, KUidMtmUiComponentVal, KUidMtmUiDataComponentVal };

	__ASSERT_DEBUG(aMtmDllInfo->iUidType[1]==mtmdlltypeuid[index],PanicServer(EMsvMtmDllInfoSecondUidIncorrect));

	if (aMtmDllInfo->iUidType[1]!=mtmdlltypeuid[index])  

		User::Leave(KErrNotSupported);

	mtmDllInfoArray.AppendL(aMtmDllInfo);

	CleanupStack::Pop(aMtmDllInfo);

	}

/**

@internalComponent

*/

EXPORT_C CRegisteredMtmDll* CRegisteredMtmDll::NewL(TUid aMtmTypeUid,TUid aTechnologyTypeUid,const CMtmDllInfo& aMtmDllInfo,const TTimeIntervalMicroSeconds32 aTimeoutMicroSeconds32,MRegisteredMtmDllObserver& aRegisteredMtmDllObserver)

	{

	CRegisteredMtmDll* registereredmtmdll=new(ELeave) CRegisteredMtmDll(aMtmTypeUid,aTechnologyTypeUid,aTimeoutMicroSeconds32,aRegisteredMtmDllObserver);

	CleanupStack::PushL(registereredmtmdll);

	registereredmtmdll->ConstructL(aMtmDllInfo);

	CleanupStack::Pop();

	return registereredmtmdll;	

	}

EXPORT_C CRegisteredMtmDll::~CRegisteredMtmDll()

	{