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