// 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 "t_cenrep_helper.h"

#include <centralrepository.h>

#include <e32property.h>

#include <e32test.h>

#include <f32file.h>

#include <bautils.h>

#include <cenrepnotifyhandler.h>

#include "e32math.h"

#include "srvparams.h"

#include "srvreqs.h"

#include "srvdefs.h"

#include "transstate.h"

#include "obsrvr_noc.h"

#include "shrepos.h"

#include "install.h"

using namespace NCentralRepositoryConstants;

RTest TheTest(_L("Central Repository Defect Tests"));

_LIT( KCentralRepositoryServerName, "Centralrepositorysrv");

const TUid KUidDEF060843LRepository1    = { 0x00000001 };

const TUid KUidRep1						= { 0x00000100 };

const TUid KUidDEF053500LTestRepository = { 0x00000102 };

const TUid KUidDEF054368TestRepository  = { 0x00000103 };

const TUid KUidINC054688TestRepository  = { 0x100058db };

const TUid KUidDEF054632TestRepository  = { 0x10054632 };

const TUid KUidDEF054633TestRepository  = { 0x10054633 };

const TUid KUidLargeRepository          = { 0xCCCCCC01 };

const TUid KUidDEF055661TestRepository  = { 0x10055661 };

const TUid KUidINC056194TestRepository  = { 0x00056194 };

const TUid KUidDEF057778TestRepository  = { 0x00057778 };

const TUid KUidDEF057470TestRepository 	= { 0x10057470 };

const TUid KUidDEF058900TestRepository 	= { 0x10058900 };

const TUid KUidINC069013TestRepository 	= { 0x00000104 };

const TUid KUidPDEF098500LRepository		= { 0x10098500 };

const TUint32 KRangeDeletePartialKey 			= 0x04010000 ;

const TUint32 KDeleteKeyDoesntExist  			= 0x07000000 ;

const TUint32 KDeleteForbidden     				= 0x03010000 ;

const TUint32 KTransactionRangeDeletePartialKey = 0x02010000 ;

const TUint32 KRangeDeleteMask       			= 0x0F0F0000 ;

const TUint32 KNullKey							= 0x00000000 ;

const TUint32 KNotifyBannedKey					= static_cast<TUint32>(KRequestPending) ;

const TUint32 KNotificationKey1					= 0x80000101;

const TUint32 KNotificationKey2					= 0x80000201;

const TUint32 KNotificationKey3					= 0x80000301;

const TUint32 KNotificationKey4					= 0x80000401;

//

// Repository A

//

const TUint32 KNewInt = 1000;

const TInt KIntValue = 1234;

// Definitions for test DEF116629L()

// The structure to construct a TServerSetting object with a TInt value.

struct ServerSettingStruct

	{

	TUint32 key;

	TUint32 meta;

	TInt value;

	};

// The merge types to be tested

const TMergeType KMergerTypes[] = {ETransactionMerge,ERestoreMerge, ESWIUpgradeMerge, ESWIDowngradeMerge, ERomFlash};

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Test macroses and functions

LOCAL_C void CheckL(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		CleanupCDriveL();

		TheTest(EFalse, aLine);

		}

	}

LOCAL_C void CheckL(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

		CleanupCDriveL();

		TheTest(EFalse, aLine);

		}

	}

#define TEST(arg) ::CheckL((arg), __LINE__)

#define TEST2(aValue, aExpected) ::CheckL(aValue, aExpected, __LINE__)

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

/**

@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4015

@SYMTestCaseDesc When having multiple connections to a particular repository, starting a

transaction and then killing that connection, should not cause a reset.

@SYMTestPriority High

@SYMTestActions

	Essentially - this deals with multiple connections, the lack of cancelling a transaction,

 	either by shutting the sub-session to the CR server directly (or by a crashing application

 	where all open sub-sessions to CR from that application are closed) and the cache manager

 	inside CR.

   Previously, CR's cache manager would reclaim repository memory regardless of the state

   of the repository (in transaction or not).  However, if a repository is closed and its

   no longer an open repository (cache manager reclaimed the memory), it would not remove

   references to the sub-session for this repository in the transaction queue.  Simply put,

   the sub-session's data would be deleted but there would still be references to that

   deleted data.  When you established a new connection (any operation would cause this) you'd

   walk down an invalid pointer.  Most of the time this would cause the server to crash.

   Now, if you're in an active transaction, the cache manager does not reclaim the data.

   Which means that there will always be valid references in the transaction queue.

   ThreadA                                   CR                        CR Cache Manager

   Connection 1.

   CRepository::NewLC(X) --------------->   EInitialize

   Connection 2.

   CRepository::NewLC(X) --------------->   EInitialize

   Connection 2, Start Transaction

   StartTransaction     ---------------->   ETransactionStart

   Before

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

   Wait 10 seconds

                                                 <--------------------------- Evict(X)

   Connection 2. Close

   delete connection2 ------------------>   EClose (would leave invalid references)

   Connection 1.

   GetInt             ------------------>   EGetInt (would attach to repository, derefence

                                                     invalid pointer, CR would crash)

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

   Now

   Wait 10 seconds

                                                                              Reschedule

                                                  (CR cache manager sees that Repository X

                                                   is in a transaction and just reschedules

                                                   it)

   Connection 2. Close

   delete connection2 --------------------> EClose (memory is now available so it cancels

                                                    the active transaction)

   GetInt             --------------------> EGetInt (attaches to the open repository, all is

                                                     fine)

   delete connection2 --------------------> EClose (repository X has no more observers so

                                                    it is scheduled to have its memory reclaimed

                                                    by CR cache manager)

@SYMTestExpectedResults The test must not fail.

@SYMDEF DEF111734

*/

LOCAL_C void DEF111734L()

	{

	/* first establish a connection. this is important because if there are no observers

	 * on a repository, the repository's shared data is deleted directly */

	CRepository* rep;

	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054368TestRepository));

	/* second establish a second connection.  this will be used to start a transaction */

	CRepository* rep2;

	User::LeaveIfNull(rep2 = CRepository::NewLC(KUidDEF054368TestRepository));

	/* establish a transaction, this manipulates the transaction queue for this repository */

	rep2->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

	/* now wait.  this should be plenty of time to allow cache manager in CR to reclaim

	 * the data for this repository */

	User::After(5050000 + 9500000);

	TInt i = 0;

	const TInt KInt1_InitialValue = 100;

	const TUint32 KInt1 = 0x1;

	/* destory the connection - this will cause a "close" operation in CR */

	CleanupStack::PopAndDestroy(rep2);

	/* attempt to reconnect to the repository. */

	TInt r = rep->Get(KInt1, i);

	/* if the fix is not in the build, then CR will crash.

	 * Errcode will be KErrServerTerminated */

	TEST2(r, KErrNone);

	/* just for completion's sake, check the return value */

	TEST(i == KInt1_InitialValue);

	// Close repository

	CleanupStack::PopAndDestroy(rep);

	}

LOCAL_C void DEF053500L()

	{

	CRepository* rep;

	// Open repository with hex key value setting

	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF053500LTestRepository));

	// Close repository

	CleanupStack::PopAndDestroy(rep);

	}

LOCAL_C void DEF054368L()

	{

	CRepository* rep;

	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054368TestRepository));

	TInt i = 0;

	const TInt KInt1_InitialValue = 100;

	const TInt KInt2_InitialValue = 200;

	const TInt KInt3_InitialValue = -100;

	const TInt KInt4_InitialValue = -200;

	const TInt KInt5_InitialValue = 0xc8;

	const TUint32 KInt1 = 0x1;

	const TUint32 KInt2 = 0x2;

	const TUint32 KInt3 = 0x3;

	const TUint32 KInt4 = 0x4;

    const TUint32 KInt5 = 0x5;

	TInt r = rep->Get(KInt1, i);

	TEST2(r, KErrNone);

	TEST(i==KInt1_InitialValue);

	r = rep->Get(KInt2, i);

	TEST2(r, KErrNone);

	TEST(i==KInt2_InitialValue);

	r = rep->Get(KInt3, i);

	TEST2(r, KErrNone);

	TEST(i==KInt3_InitialValue);

	r = rep->Get(KInt4, i);

	TEST2(r, KErrNone);

	TEST(i==KInt4_InitialValue);

	r = rep->Get(KInt5, i);

	TEST2(r, KErrNone);

	TEST(i==KInt5_InitialValue);

	// Close repository

	CleanupStack::PopAndDestroy(rep);

	}

LOCAL_C void DEF055680L()

	{

	CRepository* rep;

	// Open repository

	User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));

	// Find setting whose value the test doesn't have permission to look at

	RArray<TUint32> foundIds;

	TInt r = KErrNone;

	r = rep->FindL(0x810100, 0xFFFFFFFF, foundIds);

	TEST2(r, KErrNone);

	TEST2(foundIds.Count(), 1);

	TInt val;

	r = rep->Get(foundIds[0], val);

	TEST2(r, KErrPermissionDenied);

	foundIds.Reset();

	r = rep->Create(KNewInt, KIntValue);

	TEST2(r, KErrNone);

	//Reset repository to remove any changes made during this test

	r = rep->Reset();

	TEST2(r, KErrNone);

	// Close repository

	CleanupStack::PopAndDestroy(rep);

	}

LOCAL_C void DEF054632L()

	{

	CRepository* rep;

	//----------Testing for correct default policy behaviour---------------

	/*---------------------10054632.txt------------------------------------

	[platsec]

	cap_rd=ReadDeviceData cap_wr=WriteDeviceData

	0x3 0x4 cap_wr=NetworkServices

	[Main]

	0x1 int 1 0 cap_rd=CommDD

	0x2 int 2 1 cap_wr=CommDD

	0x3 int 3 0

	0x4 int 4 0

	0x5 int 5 0 cap_rd=CommDD

	---------------------------------------------------------------------*/

	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054632TestRepository));

	//testing single policies

	TInt err=KErrNone;

	const TInt key_2=2;

	const TInt key_1=1;

	TInt value=0;

	err=rep->Get(key_2,value);

	TEST2(err,KErrNone);

	err=rep->Set(key_1,value);

	TEST2(err,KErrNone);

	//testing range policies

	const TInt key_3=3;

	err=rep->Get(key_3,value);

	TEST2(err,KErrNone);

	CleanupStack::PopAndDestroy(rep);

	//------Testing for correct policy behaviour with no default policies-----

	/*--------------------------10054633.txt----------------------------------

	[platsec]

	0x3 0x4 cap_rd=CommDD

	[Main]

	0x1 int 1 0 cap_rd=CommDD

	0x2 int 2 1 cap_wr=CommDD

	0x3 int 3 0

	0x4 int 4 0

	------------------------------------------------------------------------*/

	User::LeaveIfNull(rep=CRepository::NewLC(KUidDEF054633TestRepository));

	//testing single policies

	err=rep->Get(key_1,value);

	TEST2(err,KErrPermissionDenied);

	err=rep->Set(key_1,value);

	TEST2(err,KErrPermissionDenied);

	err=rep->Set(key_2,value);

	TEST2(err,KErrPermissionDenied);

	err=rep->Get(key_2,value);

	TEST2(err,KErrPermissionDenied);

	//testing range policies

	err=rep->Get(key_3,value);

	TEST2(err,KErrPermissionDenied);

	const TInt key_4=4;

	err=rep->Set(key_4,value);

	TEST2(err,KErrPermissionDenied);

	err=rep->Get(key_4,value);

	TEST2(err,KErrPermissionDenied);

	CleanupStack::PopAndDestroy(rep);

	}

/**

This test will be checking the robustness of the modified array structure

for the single policies, range policies.

*/

LOCAL_C void INC054688L()

	{

	CRepository* rep;

	User::LeaveIfNull(rep = CRepository::NewLC(KUidINC054688TestRepository));

	//--------------CHECKING THE SINGLE POLICIES ARRAY----------------------

	//The ini file has been structured so that the key will be equal to the

	//key value so we can test it using a loop.

	//and also to check some policy checking, we set all the even entries to

	//be non accessible due to insufficient capabilities

	//The key tested for the single policies are from 1 to 24

	const TInt KMaxKeyEntry=24;

	TInt err=KErrNone;

	TInt key_value=0;

	for (TInt i=1;i<=KMaxKeyEntry;i++)

		{

		err=rep->Get(i,key_value);

		//even entries alway not accessible due to insufficient caps

		if (i%2==0)

			TEST2(err,KErrPermissionDenied);

		else

			{

			TEST2(err,KErrNone);

			TEST2(i,key_value);

			}

		}

	//--------------CHECKING THE RANGE POLICIES ARRAY----------------------

	//The range policies in the [platsec] section are arranged in key pairs

	//e.g 25-26,27-28.For testing purpose, the odd pairs(e.g 25-26 is the

	//first pair) will require capabilities that the test lacks off hence

	//causing KErrPermissionDenied when trying to read those range.

	//The key tested for the arary policies are from 25-38 and the value

	//matches the key

	const TInt startRangeKey=25;

	const TInt KMaxRangeKey=38;

	TInt numberOfPairs=(KMaxRangeKey-startRangeKey+1)/2;

	TInt key_value1=0;

	TInt err1=KErrNone;

	for (TInt j=0;j<numberOfPairs;j++)

		{

		//Get first key of the pair

		err=rep->Get(startRangeKey+(2*j),key_value);

		//Get second key of the pair

		err1=rep->Get(startRangeKey+(2*j)+1,key_value1);

		//start from j=0(first pair)

		if ((j+1)%2==0)

			{

			TEST2(err,KErrNone);

			TEST2(err1,KErrNone);

			TEST2(startRangeKey+(2*j),key_value);

			TEST2(startRangeKey+(2*j)+1,key_value1);

			}

		//only odd pairs are non-accessible due to insufficient caps

		else

			{

			TEST2(err,KErrPermissionDenied);

			TEST2(err1,KErrPermissionDenied);

			}

		}

	//Before closing the repository, modify one of the key to see whether

	//the policy array behaves similarly after a rewrite of the ini file

	const TInt keyToChange=3;

	const TInt modifiedValue=3;

	err=rep->Set(keyToChange,modifiedValue);

	TEST2(err,KErrNone);

	// Close repository

	CleanupStack::PopAndDestroy(rep);

	User::After(KGeneralDelay);

	//Reopen the repository again after that minor update which will cause

	//all the entry in the ini file to be reversed

	User::LeaveIfNull(rep = CRepository::NewLC(KUidINC054688TestRepository));

	//---------RECHECKING THE POLICY ARRAY AFTER UPDATE--------------------

	for (TInt i=1;i<=KMaxKeyEntry;i++)

		{

		err=rep->Get(i,key_value);

		//even entries alway not accessible due to insufficient caps

		if (i%2==0)

			TEST2(err,KErrPermissionDenied);

		else

			{

			TEST2(err,KErrNone);

			TEST2(i,key_value);

			}

		}

	//---------RECHECKING THE RANGE POLICY ARRAY AFTER UPDATE-------------

	for (TInt j=0;j<numberOfPairs;j++)

		{

		//Get first key of the pair

		err=rep->Get(startRangeKey+(2*j),key_value);

		//Get second key of the pair

		err1=rep->Get(startRangeKey+(2*j)+1,key_value1);

		//start from j=0(first pair)

		if ((j+1)%2==0)

			{

			TEST2(err,KErrNone);

			TEST2(err1,KErrNone);

			TEST2(startRangeKey+(2*j),key_value);

			TEST2(startRangeKey+(2*j)+1,key_value1);

			}

		//only odd pairs are non-accessible due to insufficient caps

		else

			{

			TEST2(err,KErrPermissionDenied);

			TEST2(err1,KErrPermissionDenied);

			}

		}

	CleanupStack::PopAndDestroy(rep);

	}

LOCAL_C void DEF055661L()

	{

	/*--------------------10055661.txt----------------------------------------

	[platsec]

	cap_rd=ReadDeviceData cap_wr=AlwaysFail

	0x3 0x4 cap_wr=NetworkServices

	[Main]

	0x1 int 1 0 cap_rd=AlwaysPass

	0x2 int 2 1 cap_rd=AlwaysFail

	0x3 int 3 0

	0x4 int 4 0 cap_rd=AlwaysFail

	0x5 int 5 0 cap_wr=AlwaysPass

	-------------------------------------------------------------------------*/

	CRepository* rep;

	User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF055661TestRepository));

	TInt err=KErrNone;

	TInt keyValue=0;

	//Key 1

	err=rep->Get(1,keyValue);

	TEST2(err,KErrNone);

	TEST2(keyValue,1);

	err=rep->Set(1,keyValue);

	TEST2(err,KErrPermissionDenied);

	//Key 2

	err=rep->Get(2,keyValue);

	TEST2(err,KErrPermissionDenied);

	err=rep->Set(2,keyValue);