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

//

#include <e32test.h>

#include <e32panic.h>

#include <f32file.h>

#include <bautils.h>

#include <ecom/ecom.h>

#include "EComUidCodes.h"

#include "Interface.h"

#include "T_PlatSecInterface.h"

#include "../EcomTestUtils/EcomTestUtils.h"

#include "LoadManager.h"

/**----------------------------Client CAP-----------------------------------------

             Client Capability Set="ReadUserData" "WriteUserData"

*/

/** ---------------------------Plugins used in this test case----------------------

- T_PlatSecECom1.dll in DRIVE Z:

  Details:-Resource file=102026AB.rss

		  -Capability Set="ReadUserData" "WriteUserData"

		  -ImplementationUid=0x102026AA based on InterfaceUid=0x102026A8

- T_PlatSecECom2.dll in DRIVE Z:

  Details:-Resource file=102026AD.rss

  		  -Capability Set="ReadUserData"

  		  -ImplementationUid=0x102026AC based on InterfaceUid=0x102026A9

- T_PlatSecECom3.dll in DRIVE Z:

  Details:-Resource file=102026AF.rss

          -Capability Set="ReaderUserData" "WriteUserData" "AllFiles"

          -ImplementationUid=0x102026AE based on InterfaceUid=0x102026A9

- T_PlatSecECom4.dll in DRIVE C:

  Details:-Resource file=10202666.rss

  		  -Capability Set="ReadUserData" "WriteUserData" "ProtServ"

  		  -ImplementationUid=0x102026B1 based on InterfaceUid=0x102026A8

- T_PlatSecResolver.dll in DRIVE Z:

  Details:-Resource file=10202777.rss

  		  -Capability Set="ReadUserData"

  		  -ImplementationUid=0x10202747 based on InterfaceUid=0x102027E7

- EComExample.dll in Drive Z:

  Details:-Contain two implementation and one Resolver, only interested in the resolver

  		  -Resource file=10009DB1.RSS

  		  -Capability Set="All -Tcb"

  		  -ImplementationUid=0x10009DD0 based on InterfaceUid=0x10009D90

-------------------------------------------------------------------------------------

*/

/** Test cases covered in this test code:

1.	Testing Client API capability filtering in ListImplementation(TUid aInterfaceUid) in Z,C;

2.	Testing Client API capability filtering in CreateImplementation(TUid aImplementationUid) in Z,C;

3.	Testing Client API capability checking in Loading a non-default resolver in the server side

*/

class RCapCheckTest

	{

public:

	static TBool IsPlatSecEnforcementOn();

	//Test case 1

	static void ListImpl_InterfaceL();

	//Test case 2

	static void CreateImpl_Implementation();

	//Test case 3

	static void ListImpl_NonDefaultResolverL();

	//Test case 4

	static void ListImpl_InterfaceWithoutCapCheckL();

	};

/**--------------------Utility Functions--------------------------------------------*/

// Plugins files that need to be copied from Z: to C:

_LIT(KResourceFileNameC,	 "C:\\resource\\plugins\\T_PlatSecECom4.rsc");

_LIT(KExampleDllFileNameC,	 "C:\\sys\\bin\\T_PlatSecECom4.dll");

_LIT(KResourceFileNameZ,	 "Z:\\RAMONLY\\T_PlatSecECom4.rsc");

_LIT(KExampleDllFileNameZ,	 "Z:\\RAMONLY\\T_PlatSecECom4.dll");

const TInt KOneSecond = 1000000;

LOCAL_D RFs	TheFs;

LOCAL_D RTest test(_L("Capability Checking Test"));

// Copy the Plugins to specific folder for testing purpose

LOCAL_C void CopyPluginsL()

	{

	// Copy the dlls and .rsc files on to RAM

	TRAPD(err, EComTestUtils::FileManCopyFileL(KResourceFileNameZ,KResourceFileNameC));

	test(err == KErrNone);

	TRAP(err, EComTestUtils::FileManCopyFileL(KExampleDllFileNameZ,KExampleDllFileNameC));

	test(err == KErrNone);

	// Wait, so that ECom server looks for plugins copied from Z: to C drive

	// ECOM server could be already started. It means that when we copy some

	// ECOM plugins from Z: to C: drive - ECOM server should look for and

	// find the new ECOM plugins. The ECOM server uses for that CDiscoverer::CIdleScanningTimer

	// which is an active object. So the discovering service is asynchronous. We have to

	// wait some time until it finishes. Otherwise ListImplementationsL could fail to find

	// requested implementations.

	User::After(KOneSecond * 3);

	}

// Deleting plugin from the RAM for cleanup purpose

inline LOCAL_C void DeleteTestPlugin()

	{

	TRAPD(err, EComTestUtils::FileManDeleteFileL(KResourceFileNameC));

	test(err == KErrNone);

	TRAP(err, EComTestUtils::FileManDeleteFileL(KExampleDllFileNameC));

#if defined(__WINS__) || defined (__WINSCW__)

    if (err != KErrNone)

   	    {

        TESTC(test, err, KErrAccessDenied); // DLL File locked under Windows emulator due to it being demand paged

        }

    else

       	TESTC(test, err, KErrNone); // DLL File not locked on Windows

#elif defined(__EPOC32__)

   	TESTC(test, err, KErrNone); // DLL File not locked on target hardware

#endif

    // Do no test at all as its an unexpected platform.

}

TBool RCapCheckTest::IsPlatSecEnforcementOn()

	{

	return PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement);

	}

/**

--------------------------Test case 1---------------------------------------------

Testing Client API capability filtering in ListImplementation(TUid aInterfaceUid);

-Client CapSet listing implemenation with InterfaceUid=0x102026A9

 *Two existing Impl based on that Interface T_PlatSecECom2.dll & T_PlatSecEcom3.dll

  one with lower capability set than the client

 *Expected array count=1 as it wont be able to load T_PlatSecECom2.dll

  when PlatSec is enforced, count=2 otherwise.

-Client Capset listing implementation with InterfaceUid=0x102026A8

 *Test to ensure it pick up plugins in other drive else than Z

@SYMTestCaseID          SYSLIB-ECOM-CT-0771

@SYMTestCaseDesc	    Testing Client API capability filtering in ListImplementation(TUid aInterfaceUid)

@SYMTestPriority 	    High

@SYMTestActions  	    Ensure it picks up plugins in other drive else than Z

                        List of all available implementations which

	                    satisfy this given interface and check for the validity.

@SYMTestExpectedResults The test must not fail.

@SYMREQ                 REQ0000

*/

void RCapCheckTest::ListImpl_InterfaceL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0771 List Implementation Capability checking\n "));

	// Input parameter

	const TUid interfaceUid = {0x102026A9};

	// Output parameters

	TInt err = KErrNone;

	RImplInfoPtrArray* implementationArray=new (ELeave) RImplInfoPtrArray;

	//Listing implementation from interface=0x102026A9

	TRAP(err, REComSession::ListImplementationsL(interfaceUid, *implementationArray));

	test(KErrNone == err);

	if (RCapCheckTest::IsPlatSecEnforcementOn())

		{

		//Only will return one implementation in T_PlatSecECom3.dll

		test(1 == implementationArray->Count());

		const TUid expectedImplUid = {0x102026AE};

		test(expectedImplUid == (*implementationArray)[0]->ImplementationUid());

		}

	else

		{

		//Return two implementations from T_PlatSecECom2.dll and T_PlatSecECom3.dll

		test(2 == implementationArray->Count());

		}

	implementationArray->ResetAndDestroy();

	//Listing implementation from interface=0x102026A8

	const TUid interfaceUid2 = {0x102026A8};

	TRAP(err, REComSession::ListImplementationsL(interfaceUid2, *implementationArray));

	test(KErrNone == err);

	test(2 == implementationArray->Count());

	implementationArray->ResetAndDestroy();

	delete implementationArray;

	}

/**

--------------------------Test case 2----------------------------------------------------

Testing Client API capability filtering in CreateImplementation(TUid aImplementationUid);

- Client try to create Implementation with different capset

- If Client.CAPS > Plugin.CAPS Expected Result=FAIL

- If Client.CAPS < Plugin.CAPS Expected Result=OK

- If Client.CAPS = Plugin.CAPS Expected Result=OK

@SYMTestCaseID          SYSLIB-ECOM-CT-0772

@SYMTestCaseDesc	    Testing Client API capability filtering in CreateImplementation(TUid aImplementationUid)

@SYMTestPriority 	    High

@SYMTestActions  	    Create Implementation with different capsets

@SYMTestExpectedResults The test must not fail.

@SYMREQ                 REQ0000

*/

void RCapCheckTest::CreateImpl_Implementation()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0772 Create Implementation Capability filtering\n "));

	// Output parameters

	TInt ret=KErrNone;

	TUid returnedimplUid;

	TAny* ImplCreation=NULL;

	//Creating Implementation with CAPS="ReadUserData"

	const TUid ImplUid2 = {0x102026AC};

	TRAP(ret,ImplCreation=REComSession::CreateImplementationL(ImplUid2,returnedimplUid));

	if (RCapCheckTest::IsPlatSecEnforcementOn())

		{

		test(KErrPermissionDenied == ret);

		test(NULL == ImplCreation);

		}

	else

		{

		test(KErrNone == ret);

		test(NULL != ImplCreation);

		test(ImplUid2 == returnedimplUid);

		//Cast to CPlatSecInterface2

		CPlatSecInterface2* impl2=reinterpret_cast <CPlatSecInterface2*> (ImplCreation);

		test(ImplUid2 == impl2->ImplId());

		REComSession::DestroyedImplementation(returnedimplUid);

		delete ImplCreation;

		ImplCreation = NULL;

		}

	//Creating Implementation with CAPS="ReadUserData WriteUserData AllFiles"

	const TUid ImplUid3 = {0x102026AE};

	TUid instanceKey;

	TRAP(ret,ImplCreation=REComSession::CreateImplementationL(ImplUid3,instanceKey));

	CInstanceInfoSimple* instanceInfo = reinterpret_cast <CInstanceInfoSimple*> (instanceKey.iUid);

	returnedimplUid = instanceInfo->ImplementationUid();

	test(KErrNone == ret);

	test(NULL != ImplCreation);

	test(ImplUid3 == returnedimplUid);

	//Cast to CPlatSecInterface3

	CPlatSecInterface3* impl3=reinterpret_cast <CPlatSecInterface3*> (ImplCreation);

	test(ImplUid3 == impl3->ImplId());

	REComSession::DestroyedImplementation(instanceKey);

	delete ImplCreation;

	ImplCreation = NULL;

	//Creating Implementation with CAPS="ReadUserData WriteUserData"

	const TUid ImplUid1 = {0x102026AA};

	TRAP(ret,ImplCreation=REComSession::CreateImplementationL(ImplUid1,instanceKey));

	instanceInfo = reinterpret_cast <CInstanceInfoSimple*> (instanceKey.iUid);

	returnedimplUid = instanceInfo->ImplementationUid();

	test(KErrNone == ret);

	test(NULL != ImplCreation);

	test(ImplUid1 == returnedimplUid);

	//Cast to CPlatSecInterface1

	CPlatSecInterface1* impl1=reinterpret_cast <CPlatSecInterface1*> (ImplCreation);

	test(ImplUid1 == impl1->ImplId());

	REComSession::DestroyedImplementation(instanceKey);

	delete ImplCreation;

	ImplCreation = NULL;

	//Creating Implementation in C:\ with CAPS="ReadUserData WriteUserData ProtServ"

	const TUid ImplUid4 = {0x102026B1};

	TRAP(ret,ImplCreation=REComSession::CreateImplementationL(ImplUid4,instanceKey));

	instanceInfo = reinterpret_cast <CInstanceInfoSimple*> (instanceKey.iUid);

	returnedimplUid = instanceInfo->ImplementationUid();

	test(KErrNone == ret);

	test(NULL != ImplCreation);

	test(ImplUid4 == returnedimplUid);

	REComSession::DestroyedImplementation(instanceKey);

	delete ImplCreation;

	ImplCreation = NULL;

	}

/**

--------------------------Test case 3----------------------------------------------------

Testing Client API capability filtering in ListImplementation by specifying a non-default

resolver Uid.  The resolver is loaded in the server side.

If PlatSecEnforcement is ON, the non-default resolver should have at least the "ProtServ"

capability in order to be successfully loaded.

- Testing using a non-default resolver T_PlatSecResolver.dll with CAPS=ReadUserData

- Testing using a non-default resolver EComExample.dll with CAPS=All-Tcb

@SYMTestCaseID          SYSLIB-ECOM-CT-0773

@SYMTestCaseDesc	    Testing Client API capability filtering in CreateImplementation(TUid aImplementationUid)

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for listing all available implementations using a non-default resolver  with CAPS=ReadUserData

                        Tests for listing all available implementations using a non-default resolver with CAPS=All-Tcb

@SYMTestExpectedResults The test must not fail.

@SYMREQ                 REQ0000

*/

void RCapCheckTest::ListImpl_NonDefaultResolverL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0773 Capability checking in loading non-default resolver in server side\n "));

	// Input parameters

	const TUid interfaceUid = {0x102026A9};

	const TUid resolverUid	= {0x10202747};

	TEComResolverParams resolverparams;

	_LIT8(KDummyData,"dummy");

	//Set any resolver data type as it will never reach the resolving part

	resolverparams.SetDataType(KDummyData());

	// Output parameters

	TInt err=KErrNone;

	RImplInfoPtrArray* implementationArray=new (ELeave) RImplInfoPtrArray;

	//Listing implementation from interface=0x102026A9 using T_PlatSecResolver.dll

	TRAP(err,REComSession::ListImplementationsL(interfaceUid,resolverparams,resolverUid,*implementationArray));

	if (RCapCheckTest::IsPlatSecEnforcementOn())

		{

		//ensure that no resolver returned here because of lacking the capability ProtServ

		test(KErrPermissionDenied == err);

		}

	else

		{

		//No resolver should be found based on the dummy resolver data

		test(KEComErrNoResolver == err);

		}

	test(0 == implementationArray->Count());

	//Listing implementation from interface=0x10009DD0 using EComExample.dll

	const TUid resolverUid2 = {0x10009DD0};

	TRAP(err,REComSession::ListImplementationsL(interfaceUid,resolverparams,resolverUid2,*implementationArray));

	//ensure that no problem here as the resolver has the capability ProtServ

	test(KErrNone == err);

	if (RCapCheckTest::IsPlatSecEnforcementOn())

		{

		//Only will return one implementation in T_PlatSecECom3.dll

		test(1 == implementationArray->Count());

		const TUid expectedImplUid = {0x102026AE};

		test(expectedImplUid == (*implementationArray)[0]->ImplementationUid());

		}

	else

		{

		//Return two implementations from T_PlatSecECom2.dll and T_PlatSecECom3.dll

		test(2 == implementationArray->Count());

		}

	implementationArray->ResetAndDestroy();

	delete implementationArray;

	implementationArray = NULL;

	}

/**

--------------------------Test case 4---------------------------------------------

Testing Client API without capability filtering in ListImplementation(TUid aInterfaceUid);

-Client CapSet listing implemenation with InterfaceUid=0x102026A9

 *Two existing Impl based on that Interface T_PlatSecECom2.dll & T_PlatSecEcom3.dll

  one with lower capability set than the client

 *Expected array count=2 as it will be able to load T_PlatSecECom2.dll

  when PlatSec is enforced, count=2 otherwise.

-Client Capset listing implementation with InterfaceUid=0x102026A8

 *Test to ensure it pick up plugins in other drive else than Z

@SYMTestCaseID          BASESRVCS-ECOM-T-4026

@SYMTestCaseDesc	    Testing Client API without capability filtering in ListImplementation(TUid aInterfaceUid)

@SYMTestPriority 	    High

@SYMTestActions  	    Ensure it picks up plugins in other drive else than Z

                        List of all available implementations which

	                    satisfy this given interface and check for the validity.

@SYMTestExpectedResults The test must not fail.

@SYMREQ                 CR1573,REQ11641 and REQ11793

*/

void RCapCheckTest::ListImpl_InterfaceWithoutCapCheckL()

	{

	test.Next(_L(" @SYMTestCaseID:BASESRVCS-ECOM-T-4026 List Implementation Without Capability checking and trying to Create Implementation\n "));

	// Input parameter

	const TUid interfaceUid = {0x102026A9};

	// Output parameters

	TInt err = KErrNone;

	RImplInfoPtrArray* implementationArray=new (ELeave) RImplInfoPtrArray;

	TBool capability = EFalse;

	//Listing implementation from interface=0x102026A9

	TRAP(err, REComSession::ListImplementationsL(interfaceUid, *implementationArray,capability));

	test(KErrNone == err);

	if (RCapCheckTest::IsPlatSecEnforcementOn())

		{

		TInt count=implementationArray->Count();

		test(2 == implementationArray->Count());

		}

	TUid returnedimplUid;

	TAny* ImplCreation=NULL;

	//Creating Implementation with CAPS="ReadUserData"

	const TUid ImplUid2 = {0x102026AC};

	TRAP(err,ImplCreation=REComSession::CreateImplementationL(ImplUid2,returnedimplUid));

	if (RCapCheckTest::IsPlatSecEnforcementOn())

		{

		test(KErrPermissionDenied == err);

		test(NULL == ImplCreation);

		}	

	implementationArray->ResetAndDestroy();

	//Listing implementation from interface=0x102026A8

	const TUid interfaceUid2 = {0x102026A8};

	TRAP(err, REComSession::ListImplementationsL(interfaceUid2, *implementationArray));

	test(KErrNone == err);

	test(2 == implementationArray->Count());

	implementationArray->ResetAndDestroy();

	delete implementationArray;

	}

LOCAL_C void RunTestL()

	{

	__UHEAP_MARK;

	//Test case 1

	RCapCheckTest::ListImpl_InterfaceL();

	//Test case 2

	RCapCheckTest::CreateImpl_Implementation();

	//Test case 3

	RCapCheckTest::ListImpl_NonDefaultResolverL();

	//Test case 4

	RCapCheckTest::ListImpl_InterfaceWithoutCapCheckL();

	//We do not want any memory leak here

	REComSession::FinalClose();

	__UHEAP_MARKEND;

	}

GLDEF_C TInt E32Main()

	{

	TInt err=KErrNone;

	__UHEAP_MARK;

	test.Title();

	test.Start(_L("Capability Checking tests."));

	// This test is only applicable for secure ECom.

	CTrapCleanup* cleanup = CTrapCleanup::New();

	CActiveScheduler* scheduler = new(ELeave)CActiveScheduler;

	CActiveScheduler::Install(scheduler);

	TRAP(err, CopyPluginsL());

	test(err==KErrNone);

	TRAP(err,RunTestL());

	test(err==KErrNone);

	// Cleanup files. If the cleanup fails that is no problem,

	// as any subsequent tests will replace them. The only downside

	// would be the disk not being tidied

	DeleteTestPlugin();

	delete scheduler;

	delete cleanup;

	test.End();

	test.Close();

	__UHEAP_MARKEND;

	return(0);

	}