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


/**
 @file
 @test
*/

#include "stsfilepathprotection.h"

#include <usif/sts/sts.h>
#include <scs/cleanuputils.h>
#include <e32def.h>
#include <f32file.h>

_LIT(KStsPrivatePathSecName, "STS private path file registration APIs test");

using namespace Usif;

CStsPrivatePathProtectionSecTest* CStsPrivatePathProtectionSecTest::NewL()
	{
	CStsPrivatePathProtectionSecTest* self=new(ELeave) CStsPrivatePathProtectionSecTest();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CStsPrivatePathProtectionSecTest::CStsPrivatePathProtectionSecTest()
	{
	SetSidRequired(TUid::Uid(0x10285DDF)); //this ID must match the one used in the file path below
	}
	
void CStsPrivatePathProtectionSecTest::ConstructL()
	{
	SetNameL(KStsPrivatePathSecName);
	}

void CStsPrivatePathProtectionSecTest::RunTestL()
	{
	RStsSession stsSession;
	TInt32 transactionId(stsSession.CreateTransactionL());
	CleanupClosePushL(stsSession);
	TInt err(0);	
	TUint newFileMode(EFileShareExclusive | EFileWrite);
	
	_LIT(KOwnPrivatePathFilename, 	"c:\\private\\10285DDF\\file.txt");

	TRAP(err, stsSession.RegisterNewL(KOwnPrivatePathFilename));
	CheckFailL(err, _L("RegisterNewL - own private path c:\\private\\10285DDF"));
	
	RFile dummyFileHandle;
	CleanupClosePushL(dummyFileHandle);

	TRAP(err, stsSession.CreateNewL(KOwnPrivatePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("CreateNewL - own private path c:\\private\\10285DDF"));
	
	TRAP(err, stsSession.RemoveL(KOwnPrivatePathFilename));
	CheckFailL(err, _L("RemoveL - own private path c:\\private\\10285DDF"));

	TRAP(err, stsSession.RegisterTemporaryL(KOwnPrivatePathFilename));
	CheckFailL(err, _L("RegisterTemporaryL - own private path c:\\private\\10285DDF"));

	TRAP(err, stsSession.CreateTemporaryL(KOwnPrivatePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("CreateTemporaryL - own private path c:\\private\\10285DDF"));

	TRAP(err, stsSession.OverwriteL(KOwnPrivatePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("OverwriteL - own private path c:\\private\\10285DDF"));
	
	//---------------------------------------------------------------------------------	
	
	// This test should always pass, as we are registering a file in an import directory which can be accessed regardless of the SID
	SetExpectPermissionDenied(EFalse); 
	_LIT(KOthersImportPrivatePathFilename, "c:\\private\\99999999\\import\\file.txt");
	

	TRAP(err, stsSession.RegisterNewL(KOthersImportPrivatePathFilename));
	CheckFailL(err, _L("RegisterNewL - others import path c:\\private\\99999999\\import"));
	
	TRAP(err, stsSession.CreateNewL(KOthersImportPrivatePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("CreateNewL - others import path c:\\private\\99999999\\import"));
	
	TRAP(err, stsSession.RemoveL(KOthersImportPrivatePathFilename));
	CheckFailL(err, _L("RemoveL - others import path c:\\private\\99999999\\import"));

	TRAP(err, stsSession.RegisterTemporaryL(KOthersImportPrivatePathFilename));
	CheckFailL(err, _L("RegisterTemporaryL - others import path c:\\private\\99999999\\import"));

	TRAP(err, stsSession.CreateTemporaryL(KOthersImportPrivatePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("CreateTemporaryL - others import path c:\\private\\99999999\\import"));

	TRAP(err, stsSession.OverwriteL(KOthersImportPrivatePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("OverwriteL - others import path c:\\private\\99999999\\import"));
	
	//---------------------------------------------------------------------------------	
	
	// This test should always fail, as we are registering a file in a private directory which does not belong to us
	SetExpectPermissionDenied(ETrue); 
	_LIT(KOthersPrivatePathFilename, "c:\\private\\99999999\\file.txt");

	TRAP(err, stsSession.RegisterNewL(KOthersPrivatePathFilename));
	CheckFailL(err, _L("RegisterNewL - others private path c:\\private\\99999999"));
	
	TRAP(err, stsSession.CreateNewL(KOthersPrivatePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("CreateNewL - others private path c:\\private\\99999999"));
	
	TRAP(err, stsSession.RemoveL(KOthersPrivatePathFilename));
	CheckFailL(err, _L("RemoveL - others private path c:\\private\\99999999"));

	TRAP(err, stsSession.RegisterTemporaryL(KOthersPrivatePathFilename));
	CheckFailL(err, _L("RegisterTemporaryL - others private path c:\\private\\99999999"));

	TRAP(err, stsSession.CreateTemporaryL(KOthersPrivatePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("CreateTemporaryL - others private path c:\\private\\99999999"));

	TRAP(err, stsSession.OverwriteL(KOthersPrivatePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("OverwriteL - others private path c:\\private\\99999999"));
	
	CleanupStack::PopAndDestroy(&dummyFileHandle);
	CleanupStack::PopAndDestroy(&stsSession);
	}

//---------------CStsTCBPathProtectionSecTest------------------

_LIT(KStsTCBPathSecName, "STS TCB path file registration APIs test");

CStsTCBPathProtectionSecTest* CStsTCBPathProtectionSecTest::NewL()
	{
	CStsTCBPathProtectionSecTest* self=new(ELeave) CStsTCBPathProtectionSecTest();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CStsTCBPathProtectionSecTest::CStsTCBPathProtectionSecTest()
	{
	SetCapabilityRequired(ECapabilityTCB);
	}
	
void CStsTCBPathProtectionSecTest::ConstructL()
	{
	SetNameL(KStsTCBPathSecName);
	}

void CStsTCBPathProtectionSecTest::RunTestL()
	{
	RStsSession stsSession;
	TInt32 transactionId(stsSession.CreateTransactionL());
	CleanupClosePushL(stsSession);
	TInt err(0);	
	
	_LIT(KTcbPathFilename, "c:\\sys\\file.txt");

	TRAP(err, stsSession.RegisterNewL(KTcbPathFilename));
	CheckFailL(err, _L("RegisterNewL - \\sys path"));
	
	TUint newFileMode(EFileShareExclusive | EFileWrite);
	RFile dummyFileHandle;
	CleanupClosePushL(dummyFileHandle);

	TRAP(err, stsSession.CreateNewL(KTcbPathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("CreateNewL - \\sys path"));
	
	TRAP(err, stsSession.RemoveL(KTcbPathFilename));
	CheckFailL(err, _L("RemoveL - \\sys path"));

	TRAP(err, stsSession.RegisterTemporaryL(KTcbPathFilename));
	CheckFailL(err, _L("RegisterTemporaryL - \\sys path"));

	TRAP(err, stsSession.CreateTemporaryL(KTcbPathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("CreateTemporaryL - \\sys path"));

	TRAP(err, stsSession.OverwriteL(KTcbPathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("OverwriteL - \\sys path"));


	_LIT(KResourcePathFilename, "c:\\resource\\file.txt");

	TRAP(err, stsSession.RegisterNewL(KResourcePathFilename));
	CheckFailL(err, _L("RegisterNewL - \\resource path"));
	
	TRAP(err, stsSession.CreateNewL(KResourcePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("CreateNewL - \\resource path"));

	TRAP(err, stsSession.RemoveL(KResourcePathFilename));
	CheckFailL(err, _L("RemoveL - \\resource path"));

	TRAP(err, stsSession.RegisterTemporaryL(KResourcePathFilename));
	CheckFailL(err, _L("RegisterTemporaryL - \\resource path"));

	TRAP(err, stsSession.CreateTemporaryL(KResourcePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("CreateTemporaryL - \\resource path"));

	TRAP(err, stsSession.OverwriteL(KResourcePathFilename, dummyFileHandle, newFileMode));
	dummyFileHandle.Close();
	CheckFailL(err, _L("OverwriteL - \\resource path"));
		
	CleanupStack::PopAndDestroy(&dummyFileHandle);
	CleanupStack::PopAndDestroy(&stsSession);
	}

 
 //---------------CStsPublicPathSecTest------------------
 
 _LIT(KStsPublicPathSecName, "STS public path file registration APIs test");
 
 CStsPublicPathSecTest* CStsPublicPathSecTest::NewL()
 	{
 	CStsPublicPathSecTest* self=new(ELeave) CStsPublicPathSecTest();
 	CleanupStack::PushL(self);
 	self->ConstructL();
 	CleanupStack::Pop(self);
 	return self;
 	}
 
 CStsPublicPathSecTest::CStsPublicPathSecTest()
 	{
 	}
 	
 void CStsPublicPathSecTest::ConstructL()
 	{
 	SetNameL(KStsPublicPathSecName);
 	}
 
 void CStsPublicPathSecTest::RunTestL()
 	{
 	RStsSession stsSession;
 	TInt32 transactionId(stsSession.CreateTransactionL());
 	CleanupClosePushL(stsSession);
 	TInt err(0);	

	TUint newFileMode(EFileShareExclusive | EFileWrite);

 	//this test must always pass
 	SetExpectPermissionDenied(EFalse); 
 	_LIT(KPublicPathFilename, "c:\\publicdir\\file.txt");
 
 	TRAP(err, stsSession.RegisterNewL(KPublicPathFilename));
 	CheckFailL(err, _L("RegisterNewL - \\publicdir path"));
 	
 	RFile dummyFileHandle;
 	CleanupClosePushL(dummyFileHandle);
 
 	TRAP(err, stsSession.CreateNewL(KPublicPathFilename, dummyFileHandle, newFileMode));
 	dummyFileHandle.Close();
 	CheckFailL(err, _L("CreateNewL - \\publicdir path"));
 	
 	TRAP(err, stsSession.RemoveL(KPublicPathFilename));
 	CheckFailL(err, _L("RemoveL - \\publicdir path"));
 
 	TRAP(err, stsSession.RegisterTemporaryL(KPublicPathFilename));
 	CheckFailL(err, _L("RegisterTemporaryL - \\publicdir path"));
 
 	TRAP(err, stsSession.CreateTemporaryL(KPublicPathFilename, dummyFileHandle, newFileMode));
 	dummyFileHandle.Close();
 	CheckFailL(err, _L("CreateTemporaryL - \\publicdir path"));
 
 	TRAP(err, stsSession.OverwriteL(KPublicPathFilename, dummyFileHandle, newFileMode));
 	dummyFileHandle.Close();
 	CheckFailL(err, _L("OverwriteL - \\publicdir path"));
 
 	CleanupStack::PopAndDestroy(&dummyFileHandle);
 	CleanupStack::PopAndDestroy(&stsSession);
 	}