// Copyright (c) 1995-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 "sf_std.h"

#include "sf_file_cache.h"

#include "cl_std.h"

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

TInt OutputTraceInfo(CFsRequest* aRequest,TCorruptNameRec* aNameRec)

	{	

	RThread tT;

	RProcess tP;

	TBool nameUnknown=EFalse;

	TInt r=aRequest->Message().Client(tT,EOwnerThread);

	if(r!=KErrNone)

		{

		nameUnknown=ETrue;

		}

	else

		{

		r=tT.Process(tP);

		if(r!=KErrNone)	

			{

			tT.Close();	

			nameUnknown=ETrue;

			}

		}

	TName n;

	if(!nameUnknown)

		{

		n=tP.Name();

		TInt b=n.Locate('[');

		if (b>=0)

			n.SetLength(b);

		tP.Close();

		tT.Close();

		}

	else

		{

		n=_L("*Unknown*");

		}

	TPtrC t(aRequest->Src().FullName());

	// output a message via the debug port

	RDebug::Print(_L("@@@@ Corrupt file check %S tried to open %S"),&n,&t);

	// make a new log record & chain it in

	TCorruptLogRec* pLogRec= new TCorruptLogRec;

	if(pLogRec==NULL)

		return KErrNoMemory;

	TPtrC nPtr(n);

	if(pLogRec->Construct(aNameRec,&nPtr,gCorruptLogRecordList)!=KErrNone)

		{

		delete pLogRec;

		return KErrNoMemory;

		}

	else

		{

		gCorruptLogRecordList=pLogRec;

		// really a count of number of log records

		gNumberOfCorruptHits++;

		}

	return KErrNone;

	}

TCorruptLogRec::TCorruptLogRec()

	:iProcessName(NULL),iNameRec(NULL),iNext(NULL)

	{}

TCorruptLogRec::~TCorruptLogRec()

	{ // free off name memory

	delete iProcessName;

	}

void TCorruptLogRec::DestroyList()

	{

	TCorruptLogRec* pList=gCorruptLogRecordList;

	while(pList!=NULL)

		{

		TCorruptLogRec* pThis=pList;

		pList=pList->iNext;

		delete pThis;

		}

	gCorruptLogRecordList=NULL;

	gNumberOfCorruptHits=0;

	}

TInt TCorruptLogRec::Construct(TCorruptNameRec* aNameRec, TPtrC* aProcessName, TCorruptLogRec* aChain)

	{

	iProcessName=aProcessName->Alloc();

	if(iProcessName==NULL)

		return KErrNoMemory;

	iNameRec=aNameRec;

	iNext=aChain;

	return KErrNone;

	}

TInt TCorruptLogRec::GetLogRecord(TFsDebugCorruptLogRecordBuf& aLogRecord,TInt aLogRecNum)

	{

	if(aLogRecNum<=0)

		{

		return KErrArgument;

		}

	else if(aLogRecNum>gNumberOfCorruptHits)

		{

		return KErrNotFound;

		}

	TCorruptLogRec* pList=gCorruptLogRecordList;

	for(TInt i=1;i<aLogRecNum && pList!=NULL;i++)

		{	

		pList=pList->iNext;

		}

	TInt r=KErrNotFound;

	if(pList)

		{

		aLogRecord().iProcessName=pList->iProcessName->Des();

		aLogRecord().iFileName=pList->iNameRec->Name();

		aLogRecord().iError=pList->iNameRec->ReturnCode();

		r=KErrNone;

		}

	return r;

	}

TCorruptNameRec::TCorruptNameRec()

:iName(NULL),iNext(NULL){} 

TInt TCorruptNameRec::Construct(TPtr* aName,TInt aReturnCode, TBool aUseOnce, TCorruptNameRec* aChain)

	{

	iName=aName->Alloc();

	if(iName==NULL)

		return KErrNoMemory;

	iReturnCode=aReturnCode;

	iUseOnce=aUseOnce;

	iConsumed=EFalse;

	iNext=aChain;

	return KErrNone;

	}

void TCorruptNameRec::ResetListConsumed()

	{

	TCorruptNameRec* pList=gCorruptFileNameList;

	while(pList!=NULL)

		{

		pList->iConsumed=EFalse;

		pList=pList->Next();

		}

	}

LOCAL_C void checkCorruptNamesList(CFsRequest* aRequest, TInt &aError)

	{

	aError=KErrNone;

	TPtrC path(aRequest->Src().FullName());

	TCorruptNameRec* pList=gCorruptFileNameList;

	while(pList)

		{

		if(pList->Name().MatchF(path)==0)

			{

			if(!pList->Consumed())

				{

				aError=pList->ReturnCode();

				pList->SetConsumed();

				OutputTraceInfo(aRequest,pList);

				}

			break;

			}

		pList=pList->Next();

		}

	}

#endif

LOCAL_C TInt DoInitNoParse(CFsRequest* aRequest)

//

// Common init for read and write access to files

//

	{

	CFileShare* share = GetShareFromHandle(aRequest->Session(), aRequest->Message().Int3());

	if(!share)

		return(KErrBadHandle);

	aRequest->SetDrive(&share->File().Drive());

	aRequest->SetScratchValue64( MAKE_TINT64(ETrue, (TUint) share) );

	return KErrNone;

	}

_LIT(KDrivePath,"?:");

LOCAL_C TInt DoInitialise(CFsRequest* aRequest)

//

//	Common initialisation code use file share to determine asychronicity

//

	{

	CFileShare* share = GetShareFromHandle(aRequest->Session(), aRequest->Message().Int3());

	if(!share)

		return(KErrBadHandle);

	aRequest->SetDrive(&share->File().Drive());

	aRequest->SetScratchValue64( MAKE_TINT64(ETrue, (TUint) share) );

	TBuf<2> drive(KDrivePath);

	drive[0]=TText(aRequest->DriveNumber()+'A');

	aRequest->Src().Set(share->File().FileName(),NULL,&drive);

	return KErrNone;

	}

LOCAL_C TInt InitialiseScratchToShare(CFsRequest* aRequest)

//

// Common code used to initialise the scratch value to the CFileShare* from the request

//	

	{

	CFileShare* share=GetShareFromHandle(aRequest->Session(), aRequest->Message().Int3());

	if(!share)

		return(KErrBadHandle);

	aRequest->SetScratchValue64( MAKE_TINT64(ETrue, (TUint) share) );

	return(KErrNone);

	}

LOCAL_C TInt FsFileOpenL(CFsRequest* aRequest, TFileOpen anOpen)

//

// Open a file.

//

	{

	TInt r;

    TUint32 mode=aRequest->Message().Int1();

	if (anOpen==EFileCreate || anOpen==EFileReplace)

		{

		r = CheckDiskSpace(0, aRequest);

		if(r != KErrNone)

            return r;

        mode|=EFileWrite;

		}

	TInt h;

    r=aRequest->Drive()->FileOpen(aRequest,h,aRequest->Src().FullName().Mid(2),mode,anOpen);

	if (r!=KErrNone)

		return(r);

    TPtrC8 pH((TUint8*)&h,sizeof(TInt));

	TRAP(r, aRequest->WriteL(KMsgPtr3,pH))

	CheckForLeaveAfterOpenL(r, aRequest, h);

	aRequest->Session()->IncResourceCount();

    return(KErrNone);

	}

TInt TFsFileOpen::DoRequestL(CFsRequest* aRequest)

//

//

//

	{

	__PRINT(_L("TFsFileOpen::DoRequestL(CFsRequest* aRequest)"));

	return FsFileOpenL(aRequest, EFileOpen);

	}

TInt TFsFileCreate::DoRequestL(CFsRequest* aRequest)

//

//

//

	{

	__PRINT(_L("TFsFileCreate::DoRequestL(CFsRequest* aRequest)"));

	return FsFileOpenL(aRequest, EFileCreate);

	}

TInt TFsFileCreate::Initialise(CFsRequest* aRequest)

//

//

//

	{

	TInt r=ParseNoWildSubstCheckPtr0(aRequest,aRequest->Src());

 	if (r!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysFileCreate,&KCapFsPriFileCreate,&KCapFsROFileCreate, __PLATSEC_DIAGNOSTIC_STRING("Create File")); 

	if (r!=KErrNone)

		return(r);

	if (OpenOnDriveZOnly)

		{

		aRequest->SetDrive(&TheDrives[EDriveZ]);

		aRequest->SetSubstedDrive(NULL);

		}

	return(r);

	}

TInt TFsFileReplace::DoRequestL(CFsRequest* aRequest)

//

//

//

	{

	__PRINT(_L("TFsFileReplace::DoRequestL(CFsRequest* aRequest)"));

	return FsFileOpenL(aRequest, EFileReplace);

	}

TInt TFsFileReplace::Initialise(CFsRequest* aRequest)

//

//

//

	{

	TInt r=ParseNoWildSubstCheckPtr0(aRequest,aRequest->Src());

 	if (r!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysFileReplace,&KCapFsPriFileReplace,&KCapFsROFileReplace, __PLATSEC_DIAGNOSTIC_STRING("Replace File")); 

	if (r!=KErrNone)

		return(r);

	if (OpenOnDriveZOnly)	// Yuck! yet another global

		{

		aRequest->SetDrive(&TheDrives[EDriveZ]);

		aRequest->SetSubstedDrive(NULL);

		}

	return(r);

	}

#ifdef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

#define __PLATSEC_DIAGNOSTIC_MESSAGE(s)	NULL

static const TInt KMsgBuffSize = KMaxPath;

#else

	#if defined(_UNICODE) && !defined(__KERNEL_MODE__)

static const TInt KCharMsgMaxLen = KMaxPath - 1;

static const TInt KMsgBuffSize = KMaxPath;

	#else

static const TInt KCharMsgMaxLen = 50;

static const TInt KMsgBuffSize = KMaxPath + KMsgMaxLen + 1;

	#endif	// #if defined(_UNICODE) && !defined(__KERNEL_MODE__)

// Local function to format a message

static

const char* FmtPlatSecMessage(TBufC<KMsgBuffSize>& buff, CFsRequest& req, const char* str)

    {

    char* p = (char*)buff.Ptr();

	const char* const base = p;

    // copy message string (if any)

    if(str)

        {

        while(*str && p < &base[KCharMsgMaxLen - 2]) // 2 for trailing ": "

            *p++ = *str++;

        *p++ = ':';

        *p++ = ' ';

        }

    // append filename

    const TDesC& fname = req.Src().FullName();

    const TInt end = Min(fname.Length(), 

                         KMsgBuffSize * sizeof(*buff.Ptr()) - (p - base) - 1);

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

        *p++ = (char)fname[i];

    *p = 0;

    return base;

    }

#define __PLATSEC_DIAGNOSTIC_MESSAGE(s) FmtPlatSecMessage(thisPath, *aRequest, s)

#endif	// #ifdef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__

TInt TFsFileOpen::Initialise(CFsRequest* aRequest)

//

// Parse and execute FileOpen service otherwise sets flag for  

// asynchronous service

//

	{

	TInt r=ParseNoWildSubstCheckPtr0(aRequest,aRequest->Src());

 	if (r!=KErrNone)

		return(r);

	TBufC<KMsgBuffSize> thisPath(aRequest->Src().FullName().Mid(2));

	TUint32 mode = (aRequest->Message().Int1() & ~(EFileStreamText | EFileReadAsyncAll | EFileBigFile));

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

// see if file is on our "Most Wanted" list

	TInt errorCode;

	checkCorruptNamesList(aRequest,errorCode);

	if(errorCode!=KErrNone)

		{

		return errorCode;

		}

#endif

	CFsMessageRequest* msgRequest = (CFsMessageRequest*)aRequest;

	if (OpenOnDriveZOnly)

		{

		aRequest->SetDrive(&TheDrives[EDriveZ]);

		aRequest->SetSubstedDrive(NULL);

		}

	if(msgRequest->IsPluginRequest())

		{

		// Always allow plugins to open files, regardless of the clients policy

		return KErrNone;

		}

	if(ComparePrivate(thisPath))

		{

		if(! SIDCheck(aRequest,thisPath))

			{

			if(!KCapFsPriFileOpen.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_MESSAGE("File Open in private path")))

				return KErrPermissionDenied;

			}

		}

	else if(CompareResource(thisPath))

		{

 		if(mode != EFileShareReadersOrWriters && mode != EFileShareReadersOnly && mode != EFileRead) 

 		// File opening mode EFileShareReadersOrWriters|EFileRead will fail the above test and not 

 		// be checked for policy, whereas file opening mode EFileShareReadersOrWriters|EFileWrite 

 		// will pass the test and will be checked for policy. 

 		// EFileRead is 0 whereas EFileWrite is non 0.

 			{

			if(!KCapFsROFileOpenWr.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_MESSAGE("File Open in resource path")))

				return KErrPermissionDenied;

			}

		}

	else if(CompareSystem(thisPath))

		{

		if(!(mode & EFileShareReadersOnly) && (mode & EFileWrite))

			{

			if(!KCapFsSysFileOpenWr.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_MESSAGE("File Open in system path")))

				return KErrPermissionDenied;

			}

		else

			{

			if(!KCapFsSysFileOpenRd.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_MESSAGE("File Open in system path")))

				return KErrPermissionDenied;

			}

		}

	return(r);

	}

#undef __PLATSEC_DIAGNOSTIC_MESSAGE	

TInt TFsIsFileOpen::DoRequestL(CFsRequest* aRequest)

//

// Return whether a file is open or not

//

	{

	__PRINT(_L("TFsIsFileOpen::DoRequestL(CFsRequest* aRequest)"));

	CFileCB* file;

	TInt r=aRequest->Drive()->IsFileOpen(aRequest->Src().FullName().Mid(2),file);

	if (r!=KErrNone)

		return(r);

	TBool isOpen = file?(TBool)ETrue:(TBool)EFalse;

	TPtrC8 pA((TUint8*)&isOpen,sizeof(TBool));

	aRequest->WriteL(KMsgPtr1,pA);

	return(KErrNone);

	}

TInt TFsIsFileOpen::Initialise(CFsRequest* aRequest)

//

//

//

	{

	TInt r=ParseNoWildSubstCheckPtr0(aRequest,aRequest->Src());

	if (r!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysIsFileOpen,&KCapFsPriIsFileOpen, __PLATSEC_DIAGNOSTIC_STRING("Is File Open")); 

	return(r);

	}

TInt TFsListOpenFiles::DoRequestL(CFsRequest* aRequest)

//

// List open files

//

	{

	__PRINT(_L("TFsListOpenFiles::DoRequestL(CFsRequest* aRequest)"));

	TOpenFileListPos listPos;

	TPckg<TOpenFileListPos> listPkg(listPos);

	aRequest->ReadL(KMsgPtr0,listPkg);

	TBuf8<KEntryArraySize> entryArray(0);

	TThreadId idClient;

	TPckgC<TThreadId> id(idClient);	

	CSessionFs* session;

	TBool fileFound=(listPos.iEntryListPos) ? (TBool)ETrue : EFalse;

	TInt entryListPos;

	TInt count;

Start:

	FOREVER

		{

		session=(*TheFileServer)[listPos.iSession];	//this global may not be the best way AJ

		if (session==NULL)

			goto End;

		session->Handles().Lock();

		count=session->Handles().Count();

		if (count)

			break;

		session->Handles().Unlock();

		listPos.iSession++;

		}

	entryListPos=listPos.iEntryListPos;

	while (entryListPos<count)

		{

		CObjPromotion* obj=(CObjPromotion*)session->Handles()[entryListPos];

		if (obj==NULL || obj->UniqueID()!=FileShares->UniqueID())

			{

			entryListPos++;

			continue; // Is not a CFileShare

			}