// Copyright (c) 2006-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:

// \f32test\loader\t_loader_delete.cpp

// 

//

#include <e32test.h>

#include <f32file.h>

#include "t_loader_delete.h"

static RTest test(_L("t_loader_delete"));

// helper functions

static void TestWithCaps(TUint32 aCaps, TInt aExpectedError);

static void TestWithCaps(TUint32 aCaps, TInt aExpectedError, const TDesC& aFileName);

static void SetHelperCaps(TUint32 aCaps);

static void CreateTestFile(RFs& aFs, const TDesC& aTestFile);

static void RunHelper(const TDesC& aFileToDelete, TInt aExpectedError);

static void TestWithCaps(TUint32 aCaps, TInt aExpectedError)

/**

	Test calling RLoader::Delete from a process with the supplied capabilities.

	@param	aCapMask		Capabilities of process which calls RLoader::Delete.

	@param	aExpectedError	Expected error reason.  The launched executable is expected

							to panic with category KTldPanicCat and this reason, which

							is the expected return code from RLoader::Delete.

 */

	{

	TestWithCaps(aCaps, aExpectedError, KTldTcbFile);

	TestWithCaps(aCaps, aExpectedError, KTldAllFilesFile);

	// the following function function calls should fail with either

	// KErrPermissionDenied if this process is not TCB+AllFiles, or with KErrBadName

	// because the filename is not fully qualified.

	TBool pdExp = (aExpectedError == KErrPermissionDenied);

	// test filenames which are not fully qualified

	TInt remapErr = pdExp ? KErrPermissionDenied : KErrBadName;

	TestWithCaps(aCaps, remapErr, KTldFileNoPath);

	TestWithCaps(aCaps, remapErr, KTldFileNoDrive);

	// test cannot delete non-existent file

	TInt rootNonExistErr = pdExp ? KErrPermissionDenied : KErrNotFound;

	TestWithCaps(aCaps, rootNonExistErr, KTldFileNonExistRoot);

	TInt dirNonExistErr = pdExp ? KErrPermissionDenied : KErrPathNotFound;

	TestWithCaps(aCaps, dirNonExistErr, KTldFileNonExistDir);

	}

static void TestWithCaps(TUint32 aCaps, TInt aExpectedError, const TDesC& aFileName)

/**

	Helper function for TestWithCaps(TUint32, TInt).  This function invokes

	a helper executable with the supplied capabilities and tells it to delete

	the supplied filename.

 	@param	aCapMask		Capabilities of process which calls RLoader::Delete.

	@param	aExpectedError	Expected error reason.  The launched executable is expected

							to panic with category KTldPanicCat and this reason, which

							is the expected return code from RLoader::Delete.

	@param	aFileName		The helper executable is told to delete this file.

*/

	{

	test.Printf(

		_L("TestWithCaps,aCaps=0x%x,aExpectedError=%d,aFileName=\"%S\"\n"),

		aCaps, aExpectedError, &aFileName);

	TInt r;

	// create the file to delete

	RFs fs;

	r = fs.Connect();

	test(r == KErrNone);

	// if this file is expected to exist then create it

	TPtrC dirName;

	TBool shouldExist = (aFileName == KTldTcbFile || aFileName == KTldAllFilesFile);

	if (shouldExist)

		{

		TParsePtrC pp(aFileName);

		dirName.Set(pp.DriveAndPath());

		r = fs.MkDirAll(dirName);

		test(r == KErrNone || r == KErrAlreadyExists);

		CreateTestFile(fs, aFileName);

		}

	SetHelperCaps(aCaps);

	RunHelper(aFileName, aExpectedError);

	if (shouldExist)

		{

		// if the file could not be deleted then delete it now

		TEntry e;

		// a C++ bool for the following equality operator

		bool exists = (fs.Entry(aFileName, e) == KErrNone);

		test(exists == (aExpectedError != KErrNone));

		if (exists)

			{

			r = fs.Delete(aFileName);

			test(r == KErrNone);

			}

		// delete the immediate containing directory.  The error code is not

		// used because the directory may be used for something else.

		fs.RmDir(dirName);

		}

	// delete the generated different-caps file

	r = fs.Delete(_L("c:\\sys\\bin\\tld_helper_caps.exe"));

	test(r == KErrNone);

	r = fs.Delete(_L("c:\\sys\\hash\\tld_helper_caps.exe"));

	test(r == KErrNone || r == KErrNotFound || r == KErrPathNotFound);

	fs.Close();

	}

static void SetHelperCaps(TUint32 aCaps)

/**

	Create an instance of the helper executable, tld_helper.exe,

	with the supplied capabilities.

 */

	{

	TInt r;

	_LIT(KCommandLineArgsFormat, "tld_helper.exe %x c:\\sys\\bin\\tld_helper_caps.exe");

	TBuf<128> cmdLine;

	cmdLine.Format(KCommandLineArgsFormat, aCaps);

	RProcess p;

	r = p.Create(_L("setcap.exe"), cmdLine);

	test(r == KErrNone);

	TRequestStatus rs;

	p.Logon(rs);

	test(rs == KRequestPending);

	p.Resume();

	User::WaitForRequest(rs);

	p.Close();

	}

static void CreateTestFile(RFs& aFs, const TDesC& aTestFile)

/**

	Create an empty file with the supplied name.  This function is used

	to create file which can be deleted with RLoader::Delete.

	@param	aFs				Open file server session.

	@param	aTestFile		The test file's name.

 */

	{

	TInt r;

	RFile f;

	r = f.Replace(aFs, aTestFile, EFileWrite | EFileStream | EFileShareExclusive);

	test(r == KErrNone);

	f.Close();

	}

static void RunHelper(const TDesC& aFileToDelete, TInt aExpectedError)

/**

	Invoke the helper executable, tell it to delete the supplied file.

	@param	aFileToDelete	Name of file which helper executable should delete

							with RLoader::Delete.

	@param	aExpectedError	The expected return code from RLoader::Delete.

 */

	{

	TInt r;

	// run the helper exe, which will try to delete the file with RLoader::Delete

	RProcess ph;

	r = ph.Create(_L("tld_helper_caps.exe"), aFileToDelete);

	test(r == KErrNone);

	TRequestStatus rsh;

	ph.Logon(rsh);

	test(rsh == KRequestPending);

	ph.Resume();

	User::WaitForRequest(rsh);

	// process has died so check the panic category and reason match the expected values

	test(ph.ExitType() == EExitPanic);

	test(ph.ExitCategory() == KTldPanicCat);

	test(ph.ExitReason() == aExpectedError);

	ph.Close();

	}

TInt E32Main()

/** 

	Executable entrypoint calls test functions within heap check.

 */

	{

	test.Title();

	test.Start(_L("Testing RLoader::Delete"));

	__UHEAP_MARK;

	const TUint32 KTcbMask = 1UL << ECapabilityTCB;

	const TUint32 KAllFilesMask = 1UL << ECapabilityAllFiles;

	//Check whether RLoader::Delete handles the case of a bad descriptor being passed 

	//as the filename( KBadDescriptor is not itself the malformed desciptor but

	//it trigers the check)

	TestWithCaps(KTcbMask | KAllFilesMask     , KErrBadDescriptor, KBadDescriptor);

	// TCB | AllFiles sufficient without any other caps

	TestWithCaps(KTcbMask | KAllFilesMask, KErrNone);

	// TCB necessary

	TestWithCaps(~KTcbMask, KErrPermissionDenied);

	// AllFiles necessary

	TestWithCaps(~KAllFilesMask, KErrPermissionDenied);

	// neither TCB nor AllFiles

	TestWithCaps(~(KTcbMask | KAllFilesMask), KErrPermissionDenied);

	TestWithCaps(0, KErrPermissionDenied);

	__UHEAP_MARKEND;

	test.End();

	return KErrNone;

    }