// 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);
	}