/*

 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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 "policycache.h"

 #include "policylist.h"

 #include "policyreader.h"

 #include "promptrequest.h"

 #include "serviceconfig.h"

 #include <f32file.h>

 #include <ups/upserr.h>

 #include "upslog.h"

 using namespace UserPromptService;

 EXPORT_C CPolicyCache* CPolicyCache::NewL(RFs& aFs, const TDesC& aPolicyPath)

 /**

 Creates a new policy cache.

 @param aFs			The file server session used to load policy files.\n

 					Ownership is not transferred.

 @param aPolicyPath	The path of the policy files (minus the drive). It must be

 					in the following form "\private\sid\policies\"

 @return				A pointer to the new policy cache object.

 */

 	{

 	CPolicyCache* self = new(ELeave) CPolicyCache(aFs);

 	CleanupStack::PushL(self);

 	self->ConstructL(aPolicyPath);

 	CleanupStack::Pop(self);

 	return self;

 	}

 CPolicyCache::CPolicyCache(RFs& aFs) 

 /**

 Constructor

 @param aFs	The file server session used to load policy files.

 */

 	: iFs(aFs)

 	{	

 	}

 CPolicyCache::~CPolicyCache()

 /**

 Destructor

 */

 	{

 	iPolicyLists.ResetAndDestroy();

 	delete iPolicyPath;

 	}

 void CPolicyCache::ConstructL(const TDesC& aPolicyPath)

 /**

 Second phase constructor, resolves the system drive.

 @param aPolicyPath	The directory where the policy files are stored.

 */

 	{

 	iPolicyPath = aPolicyPath.AllocL();

 	iSystemDriveChar = iFs.GetSystemDriveChar();

 	}

 EXPORT_C const CPolicy* CPolicyCache::MatchL(const CPromptRequest& aRequest)

 /**

 Finds the first policy that matches the request.

 @param	aRequest	The request data from the system server.

 @return				A copy of the policy object to apply to the request. If a policy

 					file exists but no policy is defined then a default policy object

 					is returned that current request to be accepted or denied.

 @leave KErrUpsMissingPolicyFile	If no policy file is found for the requested server sid and service id.								

 @leave KErrUpsBadPolicyFile		If an error occured whilst parsing a policy file.

 */

 	{

 	CPolicyList::TId id(aRequest.ServerSid(), aRequest.ServiceId());		

 	const CPolicyList* list = PolicyList(id);

 	if (!list)

 		{

 		// Policy list not found so try and load it. This

 		// leaves if a UPS policy file is not found.

 		list = LoadPolicyListL(id);				

 		}

 	ASSERT(list);	

 	return list->Match(aRequest);

 	}

 const CPolicyList* CPolicyCache::PolicyList(const CPolicyList::TId& aId) const

 /**

 Gets the specified policy list if it is loaded.

 @param	The ID of the policy list.

 @return A pointer to the policy list if it is loaded; otherwise, is returned.

 */

 	{

 	TInt count = iPolicyLists.Count();

 	for (TInt i = 0; i < count; ++i) // Check if policy list is in the cache

 		{

 		if (iPolicyLists[i]->Id() == aId)

 			{

 			return iPolicyLists[i];			

 			}

 		}

 	return 0;

 	}

 CPolicyList* CPolicyCache::LoadPolicyListL(const CPolicyList::TId& aId)

 /**

 Loads a list of policies from the policy file for the specified system server and service.

 @param	aId	A tuple of the system server SID and service UID that identifies a policy file.

 @return		The list of policies, or N

 @leave		KErrUpsBadPolicyFile if an error occured whilst parsing a policy file.

 			KErrUpsMissingPolicyFile if the policy file was not found on the Z or the system drive.

 */

 	{

 	RBuf fn;

 	fn.CreateL(KMaxFileName);

 	CleanupClosePushL(fn);

 	LocatePolicyFileL(fn, aId);		

 	CPolicyList* l(0);

 	TRAPD(err, l = ParseListL(aId, fn));			

 	if (err != KErrNone && err != KErrNoMemory)

 		{

 		DEBUG_PRINTF2(_L("Unable to parse %S"), &fn);

 		err = KErrUpsBadPolicyFile;

 		if (fn[0] == 'Z')

 			{			

 			DEBUG_PRINTF2(_L("Unable to parse %S"), &fn);

 			User::Panic(KUpsPoliciesPanicCat, EUpsPoliciesCorruptRomPolicy);			

 			}

 		else {

 			// If we failed to read the policy file from the system 

 			// drive then try the Z drive.

 			fn[0] = 'Z';

 			TRAP(err, l = ParseListL(aId, fn));

 			if (err == KErrNone)

 				{

 				DEBUG_PRINTF2(_L("Ignoring corrupt policy file on system drive. Loading %S"), &fn);

 				}

 			else if (err != KErrNotFound && err != KErrNoMemory)

 				{

 				DEBUG_PRINTF2(_L("Unable to parse %S"), &fn);

 				User::Panic(KUpsPoliciesPanicCat, EUpsPoliciesCorruptRomPolicy);

 				}			

 			}

 		}

 	User::LeaveIfError(err);

 	CleanupStack::PushL(l);

 	iPolicyLists.AppendL(l);

 	CleanupStack::Pop(l);		

 	CleanupStack::PopAndDestroy(&fn);

 	return l;

 	}

 void CPolicyCache::LocatePolicyFileL(TDes& aPolicyFileName, const CPolicyList::TId& aId)

 /**

 Determines whether the policy file should be loaded from the Z drive 

 or the system drive and returns the filename.

 @param aPolicyFileName	Descriptor to populate with the filename.

 @param aId				The id of the policy file to load.

 @leave KErrUpsMissingPolicyFile The policy file was not found on either the Z drive

 								or the system drive.

 */	

 	{

 	_LIT(KDriveSpec, "!:");

 	aPolicyFileName.Zero();

 	aPolicyFileName.Append(KDriveSpec);

 	aPolicyFileName.Append(*iPolicyPath);

 	aId.AppendNameToPath(aPolicyFileName);

 	// System drive eclipses Z drive	

 	aPolicyFileName[0] = iSystemDriveChar;

 	if (! FileExistsL(aPolicyFileName))

 		{

 		aPolicyFileName[0] = 'Z';

 		if (! FileExistsL(aPolicyFileName))

 			{

 			DEBUG_PRINTF3(_L8("No policy file for system server sid = 0x%08x, service id = 0x%08x"),

 				aId.iServerSid.iId, aId.iServiceId.iUid);

 			User::Leave(KErrUpsMissingPolicyFile);	

 			}

 		}

 	}

 CPolicyList* CPolicyCache::ParseListL(const CPolicyList::TId& aId, const TDesC& aPolicyFileName)

 /**

 Parses a policy file and constructs a policy list object.

 @param	aId				The policy file id that will be used to locate the policy list within

 						the policy cache.

 @param	aPolicyFileName	The absolute path of the policy file to parse.

 @return The new policy list object.

 */

 	{

 	CPolicyReader* r = CPolicyReader::NewLC(iFs, aPolicyFileName);

 	CPolicyList* l = CPolicyList::NewL(aId, *r);	

 	CleanupStack::PopAndDestroy(r);

 	return l;

 	}

 EXPORT_C void CPolicyCache::ServiceConfigL(const TSecureId& aServerSid, RArray<TServiceConfig>& aConfigs)

 /**

 Loads the service configuration data from the policy files for every service provided

 by a given system server.

 @param	aServerSid	The secure id of the system server.

 @param	aConfigs	The RArray to populate with the configuration data.

 */

 	{				

 	RArray<TUint> services;

 	CleanupClosePushL(services);

 	DEBUG_PRINTF2(_L8("Loading service configuration for system server 0x%08x"), aServerSid.iId);

 	FindServicesL(aServerSid, services);

 	TInt numServices = services.Count();

 	// Load the services

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

 		{

 		CPolicyList::TId id(aServerSid, TUid::Uid(services[i]));		

 		const CPolicyList* list = PolicyList(id);

 		if (list)

 			{

 			// Use in-memory service configuration

 			aConfigs.AppendL(list->ServiceConfig());

 			}

 		else 

 			{

 			// Load policy file into cache

 			CPolicyList* loadedList = LoadPolicyListL(id);

 			aConfigs.AppendL(loadedList->ServiceConfig());

 			}

 		}						

 	CleanupStack::PopAndDestroy(&services);

 	}

 void CPolicyCache::FindServicesL(const TSecureId& aServerSid, RArray<TUint>& aServices)

 /**

 Finds all of the policy files on Z drive and C drive for this system server		

 A wildcard string is used to filter out policy files for other system servers.

 @param aServerSid	The secure id of the system server.

 @param aServices	The array of service ids to populate.

 */

 	{

 	_LIT(KFilenameTemplate, "ups_%08x_????????.rsc");

 	TBuf<32> pattern;

 	pattern.AppendFormat(KFilenameTemplate, aServerSid.iId);

 	RBuf fn;	// Store current file/directory name.

 	fn.CreateL(KMaxFileName);

 	CleanupClosePushL(fn);	

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

 		{

 		TUint driveChar = (i == 0) ? TChar('Z') : iSystemDriveChar;

 		fn.Zero();

 		_LIT(KDirFormat, "%c:%S");

 		fn.AppendFormat(KDirFormat, driveChar, &*iPolicyPath);

 		CDir* dir(0);	

 		TInt err = iFs.GetDir(fn, KEntryAttNormal, ESortNone, dir);

 		if (err == KErrPathNotFound) 

 			{

 			continue;

 			}

 		User::LeaveIfError(err);

 		CleanupStack::PushL(dir);

 		// Find the services

 		TInt count = dir->Count();

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

 			{

 			const TEntry& e((*dir)[j]);

 			if (e.iName.MatchF(pattern) >= 0)

 				{

 				fn.Zero();

 				_LIT(KFileFormat, "%C:%S%S");

 				fn.AppendFormat(KFileFormat, driveChar, iPolicyPath, &e.iName);

 				CPolicyList::TId policyListId;

 				TRAP(err, CPolicyList::TId::IdL(fn, policyListId))

 				if (err == KErrNoMemory)

 					{

 					// Do not let OOM cause us to ignore policy files

 					User::Leave(err);

 					}

 				if (err == KErrNone)

 					{

 					// Ensure there are no duplicate service configs due to eclisped policy files.

 					err = aServices.InsertInOrder(static_cast<TUint>(policyListId.iServiceId.iUid));

 					if (err != KErrAlreadyExists)

 						{

 						User::LeaveIfError(err);

 						}

 					}

 				else

 					{

 					DEBUG_PRINTF2(_L("%S does not match UPS policy filename rules"), &fn);

 					}

 				}

 			// Policy file is for a different system server

 			}		

 		CleanupStack::PopAndDestroy(dir);

 		}	

 	CleanupStack::PopAndDestroy(&fn);

 	}

 TBool CPolicyCache::FileExistsL(const TDesC& aFileName)

 /**

 Checks whether a file exists.

 - If the FileName corresponds to a directory then EFalse is returned.

 @param	aFileName	The absolute path of the file to check.

 @return ETrue, if aFileName exists; otherwise, EFalse is returned.

 */

 	{

 	TBool exists = EFalse;

 	TEntry* e = new(ELeave) TEntry();		

 	TInt err = iFs.Entry(aFileName, *e);

 	if (err == KErrNone && ! e->IsDir())

 		{

 		exists = ETrue;			

 		}

 	delete e;

 	return exists;

 	}