/*

* 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;

	}