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

 			}

 		CFileCB& fileCb=((CFileShare*)obj)->File();

 		TEntry fileEntry;

 		// Set kEntryAttPacked to indicate it is in packed form

 		fileEntry.iAtt=fileCb.Att() | KEntryAttPacked;

 		TInt64 fileSize = fileCb.Size64();

 		fileEntry.iSize = I64LOW(fileSize);

 		fileEntry.iModified=fileCb.Modified();

 		fileEntry.iName=fileCb.FileName();

 		// Pack - Copy iSizeHigh and reset iReserved in packed form

 		TUint32* pSizeHigh = PtrAdd((TUint32*)&fileEntry, EntrySize(fileEntry, EFalse));

 		*pSizeHigh++ = I64HIGH(fileSize);	// Copy iSizeHigh

 		*pSizeHigh 	 = 0;					// Reset iReserved

 		TInt entrySize=EntrySize(fileEntry, ETrue);

 		if (entryArray.Length()+entrySize>entryArray.MaxLength())

 			break;

 		TPtrC8 pfileEntry((TUint8*)&fileEntry,entrySize);

 		entryArray.Append(pfileEntry);

 		entryListPos++;

 		}

 	idClient = session->ThreadId();

 	session->Handles().Unlock();

 	if (entryArray.Length()==0)

 		listPos.iSession++;

 	if (fileFound==EFalse && entryArray.Length()==0)

 		goto Start;

 	listPos.iEntryListPos=entryListPos;

 End:

 	aRequest->WriteL(KMsgPtr1,id);

 	aRequest->WriteL(KMsgPtr0,listPkg);

 	aRequest->WriteL(KMsgPtr2,entryArray);

 	return(KErrNone);

 	}

 TInt TFsListOpenFiles::Initialise(CFsRequest* /*aRequest*/)

 //

 //

 //

 	{

 	return KErrNone;

 	}

 LOCAL_C void FsFileTempFinishL(CFsRequest* aRequest,TFileName& aN,TInt aH)

 	{

 	aRequest->WriteL(KMsgPtr2,aRequest->Src().Drive());

 	aRequest->WriteL(KMsgPtr2,aN,2);

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

 	aRequest->WriteL(KMsgPtr3,pH);

 	}

 TInt TFsFileTemp::DoRequestL(CFsRequest* aRequest)

 //

 // Create a temporary file.

 //

 	{

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

     TInt r = CheckDiskSpace(0, aRequest);

     if(r != KErrNone)

         return r;

     TFileName n;

 	TInt h;

 	r=aRequest->Drive()->FileTemp(aRequest,h,aRequest->Src().FullName().Mid(2),n,aRequest->Message().Int1());

 	if (r!=KErrNone)

 		return(r);

     TRAP(r, FsFileTempFinishL(aRequest,n,h))

 	CheckForLeaveAfterOpenL(r,aRequest,h);

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

     return(KErrNone);

 	}

 TInt TFsFileTemp::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

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

 	if (r!=KErrNone)

 		return(r);

 	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysFileTemp,&KCapFsPriFileTemp,&KCapFsROFileTemp, __PLATSEC_DIAGNOSTIC_STRING("Temp File")); 

 	if (r!=KErrNone)

 		return(r);

 	if (aRequest->Src().NameOrExtPresent())

 		return(KErrBadName);

 	return(r);

 	}

 TInt TFsFileRead::DoRequestL(CFsRequest* aRequest)

 //

 // Read from a file.

 //

 	{

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

 	__PRINT1(_L("aRequest->Session() = 0x%x"),aRequest->Session());

 	CFsMessageRequest& msgRequest = *(CFsMessageRequest*) aRequest;

 	__ASSERT_DEBUG(msgRequest.CurrentOperationPtr() != NULL, Fault(EBadOperationIndex));

 	TMsgOperation& currentOperation = msgRequest.CurrentOperation();

 	CFileShare* share;

 	CFileCB* file;

 	GetFileFromScratch(aRequest, share, file);

 	TInt r = file->CheckMount();

 	__PRINT1(_L("share->CheckMount() returned = %d"),r);

 	if (r!=KErrNone)

 		return(r);

 	TInt& len = currentOperation.iReadWriteArgs.iLength;

 	TInt& totalLen = currentOperation.iReadWriteArgs.iTotalLength;

 	TInt64 pos = currentOperation.iReadWriteArgs.iPos;

 	TInt& offset = currentOperation.iReadWriteArgs.iOffset;

 	// Fair scheduling - 

 	// Needs extended file API to work (so that we can sepcify an offset)

 	// Also needs a separate drive thread to prevent excessive stack usage

 	len = Min(len, totalLen);

 	if (file->ExtendedFileInterfaceSupported() && !FsThreadManager::IsDriveSync(aRequest->DriveNumber(), EFalse))

 		{

 		len = Min(len, file->FairSchedulingLen());

 		}

 	if (pos == KCurrentPosition64)

 		pos = share->iPos;

 	currentOperation.iReadWriteArgs.iPos = pos;

 	__ASSERT_DEBUG(len > 0, Fault(EInvalidReadLength));

 	__ASSERT_DEBUG(len <= totalLen, Fault(EInvalidReadLength));

 	// The mount and any extensions must all support local buffers in order to support

 	// internally generated requests (ie - requests originating from plugins)

 	if ((aRequest->Message().Handle() == KLocalMessageHandle || !currentOperation.iClientRequest) && !file->LocalBufferSupport())

 		{

 		r = KErrNotSupported;

 		}

 	TInt reqLen = len;

 	if(r == KErrNone)

 		{

 		if (currentOperation.iClientRequest)	

 			{

 			// Current operation points to a descriptor

 			// The request originated from a client (with a normal message handle) or a plugin (KLocalMessageHandle)

 			TRAP(r,file->ReadL(pos, len, (TPtr8*) aRequest->Message().Ptr0(), aRequest->Message(), offset))

 			}

 		else

 			{

 			// Current operation points to a local buffer

 			// The request originated from the file server (e.g. file cache) with a local message handle (KLocalMessageHandle)

 			TPtr8 dataDesc((TUint8*) currentOperation.iReadWriteArgs.iData + currentOperation.iReadWriteArgs.iOffset, len, len);

 			const RLocalMessage msg;

 			TRAP(r,file->ReadL(pos, len, &dataDesc, msg, 0));

 			}

 		}

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

 	CCacheManager* manager = CCacheManagerFactory::CacheManager();

 	if (manager)

 		{

 		manager->Stats().iUncachedPacketsRead++;

 		manager->Stats().iUncachedBytesRead+= len;

 		}

 #endif

 //RDebug::Print(_L("ReadR: req %08X pos %ld\t len %d file %08X\n"), aRequest, pos, len, file);

 #if defined (_DEBUG_READ_AHEAD)

 	RDebug::Print(_L("ReadR: req %08X pos %ld\t len %d nextPos %ld file %08X\n"), aRequest, pos, len, pos + len, file);

 #endif

 	offset+= len;

 	currentOperation.iReadWriteArgs.iPos+= len;

 	totalLen-= reqLen;

 	// update the file share's position IF this request came from the client

 	if (share && r==KErrNone && currentOperation.iClientRequest)

 		{

 		__e32_atomic_store_ord64(&share->iPos, pos + len);

 		}

 	// re-issue request if not complete (to support fair scheduling)

 	if (r == KErrNone && totalLen > 0)

 		return CFsRequest::EReqActionBusy;	// dispatch request again to back of queue

 	return(r);

 	}

 TInt TFsFileRead::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	CFsMessageRequest& msgRequest = *(CFsMessageRequest*) aRequest;

 	TInt r = DoInitNoParse(aRequest);

 	if (r != KErrNone)

 		return r;

 	CFileShare* share;

 	CFileCB* file;

 	GetFileFromScratch(aRequest, share, file);

 	TMsgOperation* msgOp = msgRequest.CurrentOperationPtr();

 	if (!msgOp)	// initialised already ?

 		{

 		r = msgRequest.PushOperation(TFsFileRead::Complete);

 		if (r != KErrNone)

 			return r;

 		msgOp = msgRequest.CurrentOperationPtr();

 		}

 	// try to serialize requests to prevent asynchronous requests being processed out of sequence -

 	// this isn't possible if a plugin is loaded as this may issue it's own requests 

 	if (!share->RequestStart(&msgRequest))

 		return CFsRequest::EReqActionPending;

 	TDrive& drive = share->File().Drive();

 	TInt64 pos, reqPos;

 	TInt len, reqLen;

 	reqLen = len = aRequest->Message().Int1();

 	if(aRequest->IsDescData(KMsgPtr2))

 		{//-- 64-bit file addressing, absolute read position is TInt64

 			TPckg<TInt64> pkPos(reqPos);

 			aRequest->ReadL(KMsgPtr2, pkPos);

 		}

 	else

 		{

 		if(aRequest->Message().Int2() == (TInt)I64LOW(KCurrentPosition64))

 			reqPos = KCurrentPosition64; // Position is KCurrentPosition64 (-1)

 		else //-- legacy, RFile addressing

 			reqPos = MAKE_TINT64(0,aRequest->Message().Int2());	// Position is absolute value < 4GB, it's TUint

 		}

     msgOp->iClientPosition = pos = reqPos;

 	if (len < 0)

 		return KErrArgument;

 	if (len == 0)

 		return CFsRequest::EReqActionComplete;

 	if (pos == KCurrentPosition64)

 		pos = share->iPos;

 	const TInt64 fileSize = file->CachedSize64();

 	if (pos > fileSize)

 		pos = fileSize;

 	if ((r = file->CheckLock64(share,pos,len)) != KErrNone)

 		return r;

 	TDes8* pD = (TDes8*) aRequest->Message().Ptr0();

 	if((share->iMode & EFileReadAsyncAll) && (aRequest->Message().ClientStatus() != NULL))

 		{

 		drive.Lock();

 		if (pos + len > fileSize)

 			{

 			r = share->File().AddAsyncReadRequest(share, reqPos, reqLen, aRequest);

 			drive.UnLock();

 			return (r == KErrNone)?CFsRequest::EReqActionComplete:r;

 			}

 		drive.UnLock();

 		}

     if (pos == fileSize)

 		{

 		__e32_atomic_store_ord64(&share->iPos, pos);

 		r = aRequest->Write(KMsgPtr0, KNullDesC8);

 		return(r == KErrNone?CFsRequest::EReqActionComplete:r);

 		}

     if (pos + len > fileSize)

 		{

 		// filesize - pos shall of TInt size

 		// Hence to suppress warning

 		len = (TInt)(fileSize - pos);

 		}

 	msgOp->Set(pos, len, (TDesC8*) pD);

 //RDebug::Print(_L("ReadI: req %08X pos %ld\t len %d file %08X\n"), aRequest, pos, len, file);

 #if defined (_DEBUG_READ_AHEAD)

 	RDebug::Print(_L("ReadI: req %08X pos %ld\t len %d file %08X\n"), aRequest, pos, len, file);

 #endif

 	return KErrNone;

 	}

 TInt TFsFileRead::PostInitialise(CFsRequest* aRequest)

 	{

 	CFileShare* share = (CFileShare*) aRequest->ScratchValue();

 	CFileCB* file = &share->File();

 	TInt r = KErrNone;

 	CFileCache* fileCache = file->FileCache();

 	if (fileCache)

 		{

 		r = fileCache->ReadBuffered(*(CFsMessageRequest*)aRequest, share->iMode);

 		// if we're not reading from cache, force read ahead position & length to be recalculated

 		if (r == KErrNone)

 			fileCache->ResetReadAhead();

 		}

 	return r;

 	}

 TInt TFsFileRead::Complete(CFsRequest* aRequest)

 	{

 //		RDebug::Print(_L("TFsFileRead::Complete() aRequest %08X"), aRequest); 

 	CFsMessageRequest& msgRequest = *(CFsMessageRequest*) aRequest;

 	CFileShare* share;

 	CFileCB* file;

 	GetFileFromScratch(aRequest, share, file);

 	// Flag the request as having ended to allow another async read to occur

 	share->RequestEnd(&msgRequest);

 	// issue read-ahead

 	CFileCache* fileCache = file->FileCache();

 	if (fileCache && msgRequest.LastError() == KErrNone)

 		fileCache->ReadAhead(msgRequest, share->iMode);

 	return CFsRequest::EReqActionComplete;

 	}

 void GetFileFromScratch(CFsRequest* aRequest, CFileShare*& aShare, CFileCB*& aFile)

 	{

 	TInt64 scratchValue = aRequest->ScratchValue64();

 	TBool scratchValueIsShare  I64HIGH(scratchValue);

 	TUint32 scratchValueLow = I64LOW(scratchValue);

 	aShare = NULL;

 	aFile = NULL;

 	if (scratchValueIsShare)

 		{

 		aShare = (CFileShare*) scratchValueLow;

 		if (aShare)

 			aFile = &aShare->File();

 		}

 	else

 		{

 		aFile = (CFileCB*) scratchValueLow;

 		}

 	}

 /**

     Common init preamble for TFsFileWrite::Initialise() and TFsFileWrite::DoRequestL()

     @param   aShare     pointer to the file share

     @param   aFile      pointer to the file object this function is called for

     @param   aPos       file position to write data. Note that it can be KCurrentPosition64 i.e. KMaxTUint64

     @param   aLen       length of the data to write

     @param   aFileSize  current file size

     @param   aFsOp      File Server message code. See TFsMessage. It must be ether EFsFileWrite for normal write, or EFsFileWriteDirty when file cache flushes dirty data

 */

 TInt TFsFileWrite::CommonInit(CFileShare* aShare, CFileCB* aFile, TInt64& aPos, TInt& aLen, TInt64 aFileSize, TFsMessage aFsOp)

 	{

     if (aShare && aPos==KCurrentPosition64)

 		{//-- write to the current position in the file

 		aPos = aShare->iPos;

 		}

 	if(aPos > aFileSize)

 		aPos = aFileSize;

         //-- check that the new position won't exceed maximum file size

         {

         const TUint64 endPos = aPos+aLen;

 	    //-- Large file mode check. Legacy RFile size can't exceed 2G-1

         if(aShare && !(aShare->IsFileModeBig()) && (endPos > KMaxLegacyFileSize))

 		    return KErrTooBig;

         //-- check CMountCB limitation on maximum file size

         if(endPos > aFile->MaxSupportedSize())

             return KErrNotSupported; //-- this is for the sake of error codes consistency; current FSYs return 

                                      //-- this code in the case of accessing a file beyond its limit

        }

 	if (aShare)

 		{

 		TInt r;

 		if ((r=aFile->CheckLock64(aShare,aPos,aLen))!=KErrNone)

 			return(r);

 		}

     ASSERT(aFsOp == EFsFileWrite || aFsOp == EFsFileWriteDirty);

     if(aFsOp == EFsFileWrite)

         {//-- this call is originated from explicit file write operation. Set 'Archive' attribute and new file time.

         aFile->SetArchiveAttribute(); //-- it will also set KEntryAttModified

         }

     else

         {//-- don't touch data and attributes if it is cache flushing dirty data

         aFile->iAtt |= KEntryAttModified;

         }

 	return KErrNone;

 	}

 void TFsFileWrite::CommonEnd(CFsMessageRequest* aMsgRequest, TInt aRetVal, TUint64 aInitSize, TUint64 aNewSize, TInt64 aNewPos, TBool aFileWrite)

 //

 // Common end for TFsFileWrite::DoRequestL() and CFileCache::WriteBuffered()

 //

 	{

 	CFileShare* share;

 	CFileCB* file;

 	GetFileFromScratch(aMsgRequest, share, file);

 	CFileCache* fileCache = file->FileCache();

 	ASSERT(aFileWrite || fileCache);

 	TMsgOperation& currentOperation = aMsgRequest->CurrentOperation();

 	if (aRetVal == KErrNone || aRetVal == CFsRequest::EReqActionComplete)

 		{

 		if (share)

 			{

 			__e32_atomic_store_ord64(&share->iPos, aNewPos);

 			}

 		if ((TUint64)aNewPos > aNewSize)

 			{

 			if(aFileWrite)

 				file->SetSize64(aNewPos, EFalse);

 			else

 				fileCache->SetSize64(aNewPos);

 			aNewSize = aNewPos;

 			}

 		// ensure cached file is at least as big as uncached file

 		if (fileCache && fileCache->Size64() < aNewPos)

 			{

 			file->SetCachedSize64(aNewPos);

 			}

 		// Service async reads if the file has grown & this is the last fair-scheduled request

 		// If the file has grown, flag this and call CFileCB::NotifyAsyncReaders()

 		// later in TFsFileWrite::Complete() - we need to delay the call because

 		// CFileCB::NotifyAsyncReaders() may requeue a request which will cause 

 		// the drive thread to spin because this file share is still marked as in use

 		// (by CFileShare::RequestStart())

 		if((aNewSize > aInitSize) && (currentOperation.iReadWriteArgs.iTotalLength == 0))

 			{

 			file->SetNotifyAsyncReadersPending(ETrue);

 			}

         file->iAtt |= KEntryAttModified;

 		}

 	else if (aRetVal == KErrCorrupt)

 		file->SetFileCorrupt(ETrue);

 	else if (aRetVal == KErrBadPower || (aRetVal == KErrAbort && !PowerOk()))

 		file->SetBadPower(ETrue);

 	file->ResetReadAhead();

 	aMsgRequest->SetFreeChanged(aNewSize != aInitSize);

 	}

 TInt TFsFileWrite::DoRequestL(CFsRequest* aRequest)

 //

 // Write to a file.

 //

 	{

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

 	CFsMessageRequest& msgRequest = *(CFsMessageRequest*) aRequest;

 	__ASSERT_DEBUG(msgRequest.CurrentOperationPtr() != NULL, Fault(EBadOperationIndex));

 	TMsgOperation& currentOperation = msgRequest.CurrentOperation();

 	TInt r;

 	CFileShare* share;

 	CFileCB* file;

 	GetFileFromScratch(aRequest, share, file);

 	TInt64 initSize = file->Size64();

 	r = file->CheckMount();

 	if (r!=KErrNone)

 		return(r);

 	TInt& len = currentOperation.iReadWriteArgs.iLength;

 	// Fair scheduling - 

 	// Needs extended file API to work (so that we can specify an offset)

 	// Also needs a separate drive thread to prevent excessive stack usage

 	len = Min(len, currentOperation.iReadWriteArgs.iTotalLength);

 	if (file->ExtendedFileInterfaceSupported() && !FsThreadManager::IsDriveSync(aRequest->DriveNumber(), EFalse))

 		{

 		len = Min(len, file->FairSchedulingLen());

 		}

 	__ASSERT_DEBUG(len <= currentOperation.iReadWriteArgs.iTotalLength, Fault(EInvalidWriteLength));

     const TFsMessage fsOp = (TFsMessage)aRequest->Operation()->Function(); 

     r = CommonInit(share, file, currentOperation.iReadWriteArgs.iPos, len, initSize, fsOp);

 	if (r != KErrNone)

 		return r;

     TInt64 pos = currentOperation.iReadWriteArgs.iPos;

 	TInt64 upos = pos+len;

 	if (upos > initSize)

 		{

 		r = CheckDiskSpace(upos - initSize, aRequest);

         if(r != KErrNone)

             return r;

 		}

 	// The mount and any extensions must all support local buffers in order to support

 	// internally generated requests (ie - requests originating from plugins)

 	if ((aRequest->Message().Handle() == KLocalMessageHandle || !currentOperation.iClientRequest) && !file->LocalBufferSupport())

 		{

 		r = KErrNotSupported;

 		}

 	if(r == KErrNone)

 		{

 		if (currentOperation.iClientRequest)

 			{

 			TRAP(r,file->WriteL(pos, len, (const TPtrC8*) aRequest->Message().Ptr0(), aRequest->Message(), currentOperation.iReadWriteArgs.iOffset))

 			}

 		else

 			{

 			TPtr8 dataDesc((TUint8*) currentOperation.iReadWriteArgs.iData + currentOperation.iReadWriteArgs.iOffset, len, len);

 			const RLocalMessage msg;

 			TRAP(r,file->WriteL(pos, len, &dataDesc, msg, 0));

 			}

 		}

 //RDebug::Print(_L("WriteR: req %08X pos %ld\t len %d file %08X\n"), aRequest, pos, len, file);

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

 	CCacheManager* manager = CCacheManagerFactory::CacheManager();

 	if (manager)

 		{

 		manager->Stats().iUncachedPacketsWritten++;

 		manager->Stats().iUncachedBytesWritten+= len;

 		}

 #endif

 	if (r == KErrNone)

 		{

 		// update position, offset  & length remaining

 		currentOperation.iReadWriteArgs.iOffset+= len;

 		currentOperation.iReadWriteArgs.iPos+= len;

 		currentOperation.iReadWriteArgs.iTotalLength-= len;

 		}

 	TUint64 currentSize = MAKE_TUINT64(file->iBody->iSizeHigh,file->iSize);

 	CommonEnd(&msgRequest, r, initSize, currentSize, pos+len, ETrue);

 	// re-issue request if not complete (to support fair scheduling)

 	if (r == KErrNone && currentOperation.iReadWriteArgs.iTotalLength > 0)

 		return CFsRequest::EReqActionBusy;	// dispatch request again to back of queue

 	return(r);

 	}

 TInt TFsFileWrite::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	CFsMessageRequest& msgRequest = *(CFsMessageRequest*) aRequest;

 	TInt r = DoInitNoParse(aRequest);

 	if (r != KErrNone)

 		return r;

 	// If the drive has been dismounted, don't even attempt to write to the file as that

 	// will create dirty data which can then not be flushed without hitting ASSERTs etc.

 	if (!FsThreadManager::IsDriveAvailable(aRequest->DriveNumber(), EFalse))

 		return KErrNotReady;

 	CFileShare* share;

 	CFileCB* file;

 	GetFileFromScratch(aRequest, share, file);

 	// Bail out if there's a new mount which isn't ours - this would fail

 	// later on anyway when TFsFileWrite::DoRequestL() called CFileCB::CheckMount()

 	if ( !file->Drive().IsCurrentMount(file->Mount())  )

 		return KErrDisMounted;

 	TMsgOperation* msgOp = msgRequest.CurrentOperationPtr();

 	if (!msgOp)	// initialised already ?

 		{

 		r = msgRequest.PushOperation(TFsFileWrite::Complete);

 		if (r != KErrNone)

 			return r;

 		msgOp = msgRequest.CurrentOperationPtr();

 		}

 	// try to serialize requests to prevent asynchronous requests being processed out of sequence -

 	// this isn't possible if a plugin is loaded as this may issue it's own requests 

 	if (share && !share->RequestStart(&msgRequest))

 		return CFsRequest::EReqActionPending;

 	TInt64 pos;

 	if(aRequest->IsDescData(KMsgPtr2))

 		{//-- 64-bit file addressing, absolute read position is TInt64

 			TPckg<TInt64> pkPos(pos);

 			aRequest->ReadL(KMsgPtr2, pkPos);

 		}

 	else

 		{

 		if(aRequest->Message().Int2() == (TInt)I64LOW(KCurrentPosition64))

 			pos = KCurrentPosition64;// Position is KCurrentPosition64 (-1)

 		else

 			pos = MAKE_TINT64(0,aRequest->Message().Int2());// Position is absolute value < 4GB, it's a TUint type

 		}

 	msgOp->iClientPosition = pos;

 	TInt len = aRequest->Message().Int1();

 	TDesC8* pD = (TDes8*) aRequest->Message().Ptr0();

 	if (len == 0)

 		return CFsRequest::EReqActionComplete;

 	if (len < 0)

 		return KErrArgument;

 	//if this request was sent down from a plugin, then we want to

 	//ignore the mode that the files was opened in.

 	if (share && !msgRequest.IsPluginRequest())

 		{

 		if ((share->iMode & EFileWrite)==0 || 

 			(share->iMode & KFileShareMask) == EFileShareReadersOnly)

 			{

 			return(KErrAccessDenied);

 			}

 		}

     const TFsMessage fsOp = (TFsMessage)aRequest->Operation()->Function(); 

     r = CommonInit(share, file, pos, len, file->CachedSize64(), fsOp);

 	if (r != KErrNone)

 		return r;

 	msgOp->Set(pos, len, pD);

 	return KErrNone;

 	}

 TInt TFsFileWrite::PostInitialise(CFsRequest* aRequest)

 	{

 	CFileShare* share = (CFileShare*) aRequest->ScratchValue();

 	CFileCB* file = &share->File();

 	TInt r = KErrNone;

 	CFileCache* fileCache = file->FileCache();

 	if (fileCache)

 		{

 		// If there's no data left proceed straight to completion stage

 		// This can happen when re-posting a completed write request to 

 		// start the dirty data timer

 		if (((CFsMessageRequest*) aRequest)->CurrentOperation().iReadWriteArgs.iTotalLength == 0)

 			return CFsRequest::EReqActionComplete;

 		r = fileCache->WriteBuffered(*(CFsMessageRequest*)aRequest, share->iMode);

 		}

 	return r;

 	}

 TInt TFsFileWrite::Complete(CFsRequest* aRequest)

 	{

 	CFsMessageRequest& msgRequest = *(CFsMessageRequest*) aRequest;

 	CFileShare* share;

 	CFileCB* file;

 	GetFileFromScratch(aRequest, share, file);

 	if (share)

 		share->RequestEnd(&msgRequest);

 	if (file->NotifyAsyncReadersPending())

 		file->NotifyAsyncReaders();

 	return CFsRequest::EReqActionComplete;

 	}

 TInt TFsFileLock::DoRequestL(CFsRequest* aRequest)

 //

 // Lock a region of the file.

 //

 	{

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

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	// We must wait for ALL shares to have no active requests (see RequestStart())

 	// and post this request to the back of the queue if there are any. This is to 

 	// avoid a fair-scheduled write from writing to a locked region of a file

 	CSessionFs* session = aRequest->Session();

 	if (session)

 		{

 		TBool fileInUse = EFalse;

 		session->Handles().Lock();

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

 		CFileCB* file = &share->File();

 		for (TInt n=0; n<count; n++)

 			{

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

 			if (obj != NULL && 

 				obj->UniqueID() == FileShares->UniqueID() &&

 				(file == &((CFileShare*) obj)->File()) &&

 				((CFileShare*) obj)->RequestInProgress())

 				{

 				CFsMessageRequest& msgRequest = *(CFsMessageRequest*)aRequest;

 				if(msgRequest.IsPluginRequest())

 					break;

 				fileInUse = ETrue;

 				break;

 				}

 			}

 		session->Handles().Unlock();

 		if (fileInUse)

 			return CFsRequest::EReqActionBusy;

 		}

 	TInt64 pos, length;

 	if(aRequest->IsDescData(KMsgPtr0))

 		{

 		TPckg<TInt64> pkPos(pos);

 		aRequest->ReadL(KMsgPtr0, pkPos);

 		}

 	else

 		{

 		pos = MAKE_TINT64(0, aRequest->Message().Int0());

 		}

     if(aRequest->IsDescData(KMsgPtr1))

 		{

 		TPckg<TInt64> pkLength(length);

 		aRequest->ReadL(KMsgPtr1, pkLength);

 		if(length <= 0)

 			User::Leave(ELockLengthZero);

 		}

 	else

 		{

 		length = aRequest->Message().Int1();

 		if(length <= 0) 

 			User::Leave(ELockLengthZero);

 		}

 	return(share->File().AddLock64(share, pos, length));

 	}

 TInt TFsFileLock::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileUnlock::DoRequestL(CFsRequest* aRequest)

 //

 // Unlock a region of the file.

 //

 	{

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

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	TInt64 pos, length;

     if(aRequest->IsDescData(KMsgPtr0))

 		{

 		TPckg<TInt64> pkPos(pos);

 		aRequest->ReadL(KMsgPtr0, pkPos);

 		}

 	else

 		{

 		pos = MAKE_TINT64(0, aRequest->Message().Int0());

 		}

     if(aRequest->IsDescData(KMsgPtr1))

 		{

 		TPckg<TInt64> pkLength(length);

 		aRequest->ReadL(KMsgPtr1, pkLength);

 		if(length <= 0)

 			User::Leave(EUnlockLengthZero);

 		}

 	else

 		{

 		length = aRequest->Message().Int1();

 		if(length <= 0) 

 			User::Leave(EUnlockLengthZero);

 		}

 	return(share->File().RemoveLock64(share, pos, length));

 	}

 TInt TFsFileUnlock::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileSeek::DoRequestL(CFsRequest* aRequest)

 //

 // Set the file position.

 //

 	{

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

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	TInt64 size = share->File().CachedSize64();

 	TInt64 pos;

 	if(aRequest->IsDescData(KMsgPtr0))

 		{

 		TPckg<TInt64> pkPos(pos);

 		aRequest->ReadL(KMsgPtr0, pkPos);

 		}

 	else

 		{

 		pos = aRequest->Message().Int0();

 		}

 	TInt r,t;

 	if (share->iPos != pos)

 		share->File().ResetReadAhead();

 	switch (aRequest->Message().Int1())

 		{

 	case ESeekCurrent:

 		pos+=share->iPos;

 		if (pos<0)

 			pos=0;

         if (pos>size)

 			pos=size;

 		// Large file mode check

 		if((!(share->IsFileModeBig())) && ((TUint64)pos > KMaxLegacyFileSize))

 			return (KErrTooBig);

 		break;

 	case ESeekEnd:

 		pos+=size;

 		if (pos<0)

 			pos=0;

 		if (pos>size)

 			pos=size;

 		// Large file mode check

 		if((!(share->IsFileModeBig())) && ((TUint64)pos > KMaxLegacyFileSize))

 			return (KErrTooBig);

         break;

 	case ESeekAddress:

 		t = (TUint)pos;

 		r = share->File().Address(t);

 		pos = (TUint)t;

 		if(KErrNone != r)

 			return(r);

 		goto writeBackPos;

 	case ESeekStart:

 		if (pos>=0)

             {

             share->iPos = pos;

             return KErrNone;

             }

 		return(KErrArgument);

 	default:

 		return(KErrArgument);

 		}

 	__e32_atomic_store_ord64(&share->iPos, pos);

 writeBackPos:

 	TPckgC<TInt64> pkNewPos(pos);

 	aRequest->WriteL(KMsgPtr2, pkNewPos);

 	return(KErrNone);

 	}

 TInt TFsFileSeek::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileFlush::DoRequestL(CFsRequest* aRequest)

 //

 // Commit any data in memory to the media.

 //

 	{

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

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	// if any write requests are being fair scheduled, wait for them to complete

 	if (share->RequestInProgress())

 		return CFsRequest::EReqActionBusy;

 	// flush the write cache

 	TInt r;

 	CFileCache* fileCache = share->File().FileCache();

 	if (fileCache && (r = fileCache->FlushDirty(aRequest)) != CFsRequest::EReqActionComplete)

 	    {

 		//To be used in notification framework

 	    //CFsMessageRequest& msgRequest = (CFsMessageRequest&)*aRequest;

 	    //msgRequest.iUID = msgRequest.Message().Identity();

 		return r;

 	    }

 	if ((share->File().Att()&KEntryAttModified)==0)

 		return(KErrNone);

 	if ((share->iMode&EFileWrite)==0)

 		return(KErrAccessDenied);

 	r=share->CheckMount();

 	if (r!=KErrNone)

 		return(r);

 	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileCBFlushDataL, EF32TraceUidFileSys, &share->File());

 	TRAP(r,share->File().FlushDataL());

 	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECFileCBFlushDataLRet, EF32TraceUidFileSys, r);

 	return(r);

 	}

 TInt TFsFileFlush::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileSize::DoRequestL(CFsRequest* aRequest)

 //

 // Get the file size.

 //

 	{

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

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	TInt64 size = share->File().CachedSize64();

 	// Large file mode check and error handling is done at client library side.

 	// Return file size even if it is greater than 2GB - 1.

 	TPckgC<TInt64> pkSize(size);

 	aRequest->WriteL(KMsgPtr0, pkSize);

 	return(KErrNone);

 	}

 TInt TFsFileSize::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileSetSize::DoRequestL(CFsRequest* aRequest)

 //

 // Set the file size.

 //

 	{

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

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	if ((share->iMode&EFileWrite)==0)

 		return(KErrAccessDenied);

 	TInt r=share->CheckMount();

 	if (r!=KErrNone)

 		return(r);

 	TInt64 size;

 	if(aRequest->IsDescData(KMsgPtr0))

 		{

 		TPckg<TInt64> pkSize(size);

 		aRequest->ReadL(KMsgPtr0, pkSize);

 		}

 	else

 		{

 		size = aRequest->Message().Int0();

 		}

 	if(size < 0)

 		User::Leave(ESizeNegative);

 	// Large file mode check

 	if((!(share->IsFileModeBig())) && ((TUint64)size > KMaxLegacyFileSize))

 		return (KErrTooBig);

 	CFileCB& file=share->File();

 	// flush the write cache

 	CFileCache* fileCache = share->File().FileCache();

 	if (fileCache && (r = fileCache->FlushDirty(aRequest)) != CFsRequest::EReqActionComplete)

 		return r;

 	if (size==file.Size64())

 		return(KErrNone);

 	TBool fileHasGrown = size > file.Size64();

 	if (fileHasGrown)

 		{

 		r = CheckDiskSpace(size - file.Size64(), aRequest);

         if(r != KErrNone)

             return r;

 		r=file.CheckLock64(share,file.Size64(),size-file.Size64());

 		}	

 	else

 		r=file.CheckLock64(share,size,file.Size64()-size);

 	if (r!=KErrNone)

 		return(r);

 	__PRINT1(_L("Owner mount size before SetSize() = %d"),I64LOW(file.Mount().Size()));

 	TRAP(r,file.SetSizeL(size))

 	if (r!=KErrNone)

 		{

 		//	Set size failed

 		__PRINT1(_L("SetSize() failed = %d"),r);

 		__PRINT1(_L("Owner mount size now = %d"),I64LOW(file.Mount().Size()));

 		return(r);

 		}

 	file.SetArchiveAttribute();

 	file.SetSize64(size, EFalse);

 	file.SetCachedSize64(size);

 	if(fileHasGrown)

 		file.NotifyAsyncReaders();	// Service outstanding async reads if the file has grown

 	return(r);

 	}

 TInt TFsFileSetSize::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileAtt::DoRequestL(CFsRequest* aRequest)

 //

 // Get the file attributes.

 //

 	{

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

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 //	TInt att=(TInt)aRequest->FileShare()->File().Att()&KEntryAttMaskSupported;

 	TInt att=(TInt)share->File().Att();	// DRM: let ROM XIP attribute through

 	TPtrC8 pA((TUint8*)&att,sizeof(TInt));

 	aRequest->WriteL(KMsgPtr0,pA);

     return(KErrNone);

 	}

 TInt TFsFileAtt::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileSetAtt::DoRequestL(CFsRequest* aRequest)

 //

 // Set the file attributes.

 //

 	{

 	__PRINT(_L("TFsFileSetAtt::DoRequestL(CSessionFs* aSession)"));

     TInt r = CheckDiskSpace(0, aRequest);

     if(r != KErrNone)

         return r;

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	r=share->CheckMount();

 	if (r!=KErrNone)

 		return(r);

     if ((share->iMode&EFileWrite)==EFalse)

 		return(KErrAccessDenied);

     TUint setAttMask=(TUint)(aRequest->Message().Int0());

 	TUint clearAttMask=(TUint)aRequest->Message().Int1();

 	ValidateAtts(share->File().Att(),setAttMask,clearAttMask);

 	TRACE5(UTF::EBorder, UTraceModuleFileSys::ECFileCBSetEntryL, EF32TraceUidFileSys, &share->File(), 0, 0, setAttMask,clearAttMask);

 	TRAP(r,share->File().SetEntryL(TTime(0),setAttMask,clearAttMask))

 	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECFileCBSetEntryLRet, EF32TraceUidFileSys, r);

 	return(r);

 	}

 TInt TFsFileSetAtt::Initialise(CFsRequest* aRequest)

 //

 //	Call GetShareFromHandle to determine asynchronicity ***

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileModified::DoRequestL(CFsRequest* aRequest)

 //

 // Get the modified date and time.

 //

 	{

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

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	TTime mod=share->File().Modified();

 	TPtrC8 pM((TUint8*)&mod,sizeof(TTime));

 	aRequest->WriteL(KMsgPtr0,pM);

     return(KErrNone);

 	}

 TInt TFsFileModified::Initialise(CFsRequest* aRequest)

 //

 //	Call GetShareFromHandle to determine asynchronicity ***

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileSetModified::DoRequestL(CFsRequest* aRequest)

 //

 // Set the modified date and time.

 //

 	{

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

     TInt r = CheckDiskSpace(0, aRequest);

     if(r != KErrNone)

         return r;

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	r=share->CheckMount();

 	if (r!=KErrNone)

 		return(r);

 	if ((share->iMode&EFileWrite)==EFalse)

 		return(KErrAccessDenied);

 	TTime time;

 	TPtr8 t((TUint8*)&time,sizeof(TTime));

 	aRequest->ReadL(KMsgPtr0,t);

 	TRACE5(UTF::EBorder, UTraceModuleFileSys::ECFileCBSetEntryL, EF32TraceUidFileSys, &share->File(), 0, 0, KEntryAttModified,0);

 	TRAP(r,share->File().SetEntryL(time,KEntryAttModified,0))

 	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECFileCBSetEntryLRet, EF32TraceUidFileSys, r);

 	return(r);

 	}

 TInt TFsFileSetModified::Initialise(CFsRequest* aRequest)

 //

 //	Call GetShareFromHandle to determine asynchronicity ***

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileSet::DoRequestL(CFsRequest* aRequest)

 //

 // Set the attributes and the modified date and time.

 //

 	{

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

     TInt r = CheckDiskSpace(0, aRequest);

     if(r != KErrNone)

         return r;

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	r=share->CheckMount();

 	if (r!=KErrNone)

 		return(r);

     if (share->File().Att()&KEntryAttReadOnly)

 		return(KErrAccessDenied);

     if ((share->iMode&EFileWrite)==0)

 		{

 		if(share->File().Drive().IsWriteProtected())

 			return(KErrAccessDenied);

 		}

     TTime time;

 	TPtr8 t((TUint8*)&time,sizeof(TTime));

 	aRequest->ReadL(KMsgPtr0,t);

 	TUint setAttMask=(TUint)(aRequest->Message().Int1()|KEntryAttModified);

 	TUint clearAttMask=(TUint)aRequest->Message().Int2();

 	ValidateAtts(share->File().Att(),setAttMask,clearAttMask);//	Validate attributes

 	TRACE5(UTF::EBorder, UTraceModuleFileSys::ECFileCBSetEntryL, EF32TraceUidFileSys, &share->File(), 0, 0, setAttMask,clearAttMask);

 	TRAP(r,share->File().SetEntryL(time,setAttMask,clearAttMask))

 	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECFileCBSetEntryLRet, EF32TraceUidFileSys, r);

 	return(r);

 	}

 TInt TFsFileSet::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileChangeMode::DoRequestL(CFsRequest* aRequest)

 //

 // The access to a file may be changed from share exclusive to share readers only or vice versa.

 // KErrAccessDenied is returned if the file has multiple readers.

 //

 	{

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

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	TInt r=share->CheckMount();

 	if (r!=KErrNone)

 		return(r);

 	const TFileMode currentMode = (TFileMode)share->iMode;

 	const TFileMode newMode = (TFileMode)aRequest->Message().Int0();

 		// check argument 

 		// (only EFileShareExclusive and EFileShareReadersOnly are allowed)

 	if((newMode & ~EFileShareReadersOnly) != 0)

 		return KErrArgument;

 		// check if the file is in EFileShareAny mode

 	if( (currentMode & EFileShareAny) ||

 	    // or the file has been opened for writing in EFileShareExclusive mode, 

 		// and an attempt is made to change the access mode to EFileShareReadersOnly

 		((currentMode & EFileWrite) && 

 		 (currentMode & KFileShareMask) == EFileShareExclusive && 

 		 newMode == EFileShareReadersOnly) )

 		return KErrAccessDenied;

 		// check if an attempt is made to change the share mode to EFileShareExclusive

 		// while the file has multiple readers

 	if (newMode == EFileShareExclusive && (currentMode & KFileShareMask) != EFileShareExclusive)

 		{ 

 		// Check no other CFileCB is reading the file.

 		FileShares->Lock();

 		TInt count=FileShares->Count();

 		TBool found=EFalse;

 		while(count--)

 			{

 			CFileShare* fileShare=(CFileShare*)(*FileShares)[count];

 			if (&fileShare->File()==&share->File())

 				{

 				if (found)

 					{

 					FileShares->Unlock();

 					return(KErrAccessDenied);

 					}

 				found=ETrue;

 				}

 			}

 		FileShares->Unlock();

 		}

 	share->iMode&=~KFileShareMask;

 	share->iMode|=newMode;

 	share->File().SetShare(newMode);

 	return(KErrNone);

 	}

 TInt TFsFileChangeMode::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	TInt r = DoInitNoParse(aRequest);

 	if(r != KErrNone)

 		return r;

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	if(CompareResource(share->File().FileName().Mid(2)) )

 		{

 		if(!KCapFsFileChangeMode.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("File Change Mode")))

 			return KErrPermissionDenied;

 		}

 	return KErrNone;

 	}

 TInt TFsFileRename::DoRequestL(CFsRequest* aRequest)

 //

 // Rename the file if it was openned EFileShareExclusive

 //

 	{

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

     TInt r = CheckDiskSpace(0, aRequest);

     if(r != KErrNone)

         return r;

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	r=share->CheckMount();

 	if (r!=KErrNone)

 		return(r);

 	TInt currentMode=(share->iMode&KFileShareMask);

 	if ((currentMode&EFileShareAny) || (currentMode&EFileShareReadersOnly))

 		return(KErrAccessDenied); // File must be EFileShareExclusive

 	if ((share->iMode&EFileWrite)==0)

 		return(KErrAccessDenied); // File must have write permission

 	TPtrC filePath = aRequest->Dest().FullName().Mid(2);

 	CFileCB& file = share->File();

 	TRACEMULT2(UTF::EBorder, UTraceModuleFileSys::ECFileCBRenameL, EF32TraceUidFileSys, 

 		(TUint) &file, filePath);

 	TRAP(r,file.RenameL(filePath));

 	TRACERETMULT1(UTF::EBorder, UTraceModuleFileSys::ECFileCBRenameLRet, EF32TraceUidFileSys, r);

 	// Re-write the file's folded name & re-calculate the hash

 	if (r == KErrNone)

 		{

 		TFileName filePathF;

 		filePathF.CopyF(filePath);

 	    TRAP(r, AllocBufferL(file.iFileNameF, filePathF));

 		file.iNameHash=CalcNameHash(*file.iFileNameF);

 		}

 	return(r);

 	}

 TInt TFsFileRename::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	TInt r=DoInitialise(aRequest);

 	if(r!=KErrNone)

 		return(r);

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	TFileName newName;

 	TRAP(r,aRequest->ReadL(KMsgPtr0,newName));

 	if(r!=KErrNone)

 		return(r);

 	TDriveUnit currentDrive(share->File().Mount().Drive().DriveNumber());

 	TDriveName driveName=currentDrive.Name();

 	r=aRequest->Dest().Set(newName,&share->File().FileName(),&driveName);

 	if (r!=KErrNone)

 		return(r);

 	if (aRequest->Dest().IsWild())

 		return(KErrBadName);

 	TInt driveNo;

 	if ((r=RFs::CharToDrive(aRequest->Dest().Drive()[0],driveNo))!=KErrNone)

 		return(r);

 	TDrive& drive=TheDrives[driveNo];

  	if(drive.IsSubsted())

 		{

 		if ((drive.Subst().Length()+aRequest->Dest().FullName().Length())>(KMaxFileName+3))

 			return(KErrBadName);

 		TFileName n=drive.Subst();

 		n+=aRequest->Dest().FullName().Mid(3);

 		r=aRequest->Dest().Set(n,NULL,NULL);

 		if(r!=KErrNone)

 			return(r);

 		}

 	TDriveUnit newDrive(aRequest->Dest().Drive());

 	if (newDrive!=currentDrive)

 		return(KErrBadName);

 	if (IsIllegalFullName(aRequest->Dest().FullName().Mid(2)))

 		return(KErrBadName);

 	r=PathCheck(aRequest,aRequest->Dest().FullName().Mid(2),&KCapFsSysFileRename,&KCapFsPriFileRename,&KCapFsROFileRename, __PLATSEC_DIAGNOSTIC_STRING("File Rename"));

 	return(r);

 	}

 TInt TFsFileDrive::DoRequestL(CFsRequest* aRequest)

 //

 // Get the drive info for the file.

 //

 	{

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

 	CFileShare* share=(CFileShare*)aRequest->ScratchValue();

 	TDrive *dr = &share->File().Drive();

 	TPckgBuf<TInt> pkiF(dr->DriveNumber());		// copy drive number to user

 	aRequest->WriteL(KMsgPtr0, pkiF);

 	TDriveInfo di;								// copy drive info to user

 	dr->DriveInfo(di);

 	TPckgC<TDriveInfo> pkdiF(di);

 	aRequest->WriteL(KMsgPtr1, pkdiF);

 	return(KErrNone);

 	}

 TInt TFsFileDrive::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	return(DoInitNoParse(aRequest));

 	}

 TInt TFsFileDuplicate::DoRequestL(CFsRequest* aRequest)

 //

 // Duplicate the received file handle ready for transfer to another process.

 // The new file handle is written back to the client in a a mangled form to prevent

 // it from being used. Calling TFsFileAdopt will de-mangle the handle.

 //

 	{

 	CFileShare* pS = (CFileShare*)aRequest->ScratchValue();

 	// get the file control block from the client's file share

 	CFileCB& fileCB = pS->File();

 	// Create a new file share and initialize it with the 

 	// client file share's file control block, position & mode

 	CFileShare* pNewFileShare = new CFileShare(&fileCB);

 	if (pNewFileShare == NULL)

 		return KErrNoMemory;

 	// We need to call CFileCB::PromoteShare immediately after the CFileShare 

 	// instance is created since the destructor calls CFileCB::DemoteShare()

 	// which checks the share count is non-zero

 	pNewFileShare->iMode = pS->iMode;

 	fileCB.PromoteShare(pNewFileShare);

 	TInt r = fileCB.Open();	// increment the ref count

 	if (r == KErrNone)

 		TRAP(r, pNewFileShare->InitL());

 	__e32_atomic_store_ord64(&pNewFileShare->iPos, pS->iPos);

 	// Add new file share to the global file share container

 	if (r == KErrNone)

 		TRAP(r, FileShares->AddL(pNewFileShare,ETrue));

 	// Add new file share to list owned by this session

 	TInt newHandle;

 	if (r == KErrNone)

 		TRAP(r,newHandle = aRequest->Session()->Handles().AddL(pNewFileShare,ETrue));

 	if (r!=KErrNone)

 		{

 		pNewFileShare->Close();

 		return r;

 		}

 	newHandle^= KSubSessionMangleBit;

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

 	aRequest->WriteL(KMsgPtr3, pH);

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

 	return(KErrNone);

 	}

 TInt TFsFileDuplicate::Initialise(CFsRequest* aRequest)

 	{

 	TInt handle = aRequest->Message().Int0();

 	CFileShare* share = GetShareFromHandle(aRequest->Session(), handle);

 	// If the handle is invalid, either panic (CFsMessageRequest::Dispatch() will 

 	// panic if we return KErrBadHandle) or complete the request with KErrArgument.

 	// The latter case is the behaviour for the (deprecated) RFile::Adopt() to

 	// prevent a server from panicing if the passed file handle is invalid.

 	if(!share)

 		return aRequest->Message().Int1()?KErrBadHandle:KErrArgument;

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

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

 	return(KErrNone);

 	}

 TInt TFsFileAdopt::DoRequestL(CFsRequest* aRequest)

 //

 // Adopt the passed file handle. This assumes that the handle has already been 

 // duplicated by calling TFsFileDuplicate and is therefore mangled.

 //

 	{

 	if (((CFileShare*)aRequest->ScratchValue()) == NULL)

 		return KErrBadHandle;

 	TInt adoptType = aRequest->Message().Int1();

 	// EFileBigFile mode check

 	switch(adoptType)

 		{

 		case KFileAdopt32:

 			// Request is from RFile::Adopt or RFile::AdoptFromXXX: Force NO EFileBigFile

 			((CFileShare*)aRequest->ScratchValue())->iMode &= ~EFileBigFile;

 			break;

 		case KFileAdopt64:

 			// Request is from RFile64::AdoptFromXXX: Force EFileBigFile

 			((CFileShare*)aRequest->ScratchValue())->iMode |= EFileBigFile;

 			break;

 		case KFileDuplicate:

 			// Request is from RFile::Duplucate

 			// adopt original file mode - do nothing

 			break;

 		//default:

 			// Do nothing

 		}

 	// De-mangle the existing sub-session handle and return it to the client

 	TInt newHandle = aRequest->Message().Int0() ^ KSubSessionMangleBit;

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

 	aRequest->WriteL(KMsgPtr3,pH);

 	return(KErrNone);

 	}

 TInt TFsFileAdopt::Initialise(CFsRequest* aRequest)

 	{

 	TInt handle = aRequest->Message().Int0() ^KSubSessionMangleBit;

 	CFileShare* share = GetShareFromHandle(aRequest->Session(), handle);

 	// Normally returning KErrBadHandle will result in a panic, but when a server calls 

 	// RFile::AdoptXXX() and it's client has given it a bad handle then it's not a good 

 	// idea to panic the server. So we return KErrNone here and allow 

 	// TFsFileAdopt::DoRequestL() to return KErrBadHandle

 	if (share)

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

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

 	return(KErrNone);

 	}

 TInt TFsFileName::DoRequestL(CFsRequest* aRequest)

 //

 // Get the name of a file. 

 // i.e. including the name & extension but excluding the drive and path

 //

 	{

 	CFileShare* share = (CFileShare*)aRequest->ScratchValue();

 	// Search backwards until a backslash is found

 	// This should always succeed as this is a full pathname

 	TPtrC name(share->File().FileName());

 	TInt offset = name.LocateReverse('\\');

 	aRequest->WriteL(KMsgPtr0, name.Mid(offset+1));

 	return(KErrNone);

 	}

 TInt TFsFileName::Initialise(CFsRequest* aRequest)

 //

 // Get the full name of a file, including path and drive 

 //

 //

 	{

 	return InitialiseScratchToShare(aRequest);

 	}

 TInt TFsFileFullName::DoRequestL(CFsRequest* aRequest)

 //

 // Get the full name of a file, including path and drive 

 //

 	{

 	CFileShare* share = (CFileShare*)aRequest->ScratchValue();

 	// Write the drive letter and ':'

 	TBuf<2> driveBuf(KDrivePath);

 	driveBuf[0]=TText('A' + share->File().Drive().DriveNumber());

 	aRequest->WriteL(KMsgPtr0, driveBuf);

 	// Write the file and path including leading '\'

 	TPtrC name(share->File().FileName());

 	aRequest->WriteL(KMsgPtr0, name, 2);

 	return(KErrNone);

 	}

 TInt TFsFileFullName::Initialise(CFsRequest* aRequest)

 //

 //

 //

 	{

 	return InitialiseScratchToShare(aRequest);

 	}

 TInt TFsGetMediaSerialNumber::DoRequestL(CFsRequest* aRequest)

 //

 // Acquire capability from media and return serial number if supported.

 //

     {

     // Get request parameters

     const TInt drvNum = aRequest->Message().Int1();

 	// Get media capability

     TLocalDriveCapsV5Buf capsBuf;

 	TInt r = KErrNone;

 	// is the drive local?

 	if (!IsProxyDrive(drvNum))

 		{

 		// if not valid local drive, use default values in localDriveCaps

 		// if valid local drive and not locked, use TBusLocalDrive::Caps() values

 		// if valid drive and locked, hard-code attributes

 		r = GetLocalDrive(drvNum).Caps(capsBuf);

 		}

 	else  // this need to be made a bit nicer

 		{   

 		CExtProxyDrive* pD = GetProxyDrive(drvNum);

 		if(pD)

 			r = pD->Caps(capsBuf);

 		else

 			r = KErrNotReady;

 		}

 	if (r != KErrNone)

         return r;

     TLocalDriveCapsV5& capsV5 = capsBuf();

     // Return serial number if supported

     if (capsV5.iSerialNumLength == 0)

         return KErrNotSupported;

     TPtrC8 snPtr(capsV5.iSerialNum, capsV5.iSerialNumLength);

     aRequest->WriteL(KMsgPtr0, snPtr);

 	return KErrNone;

     }

 TInt TFsGetMediaSerialNumber::Initialise(CFsRequest* aRequest)

 //

 // Validate drive number and its attributes passed in a request object.

 //

     {

     const TInt drvNum = aRequest->Message().Int1();

     TInt nRes = ValidateDrive(drvNum, aRequest);

     if(nRes != KErrNone)

         return KErrBadName; //-- incorrect drive number

     if(aRequest->Drive()->IsSubsted())

         return KErrNotSupported; //-- the drive is substed, this operation doesn't make a sense

     if(!IsValidLocalDriveMapping(drvNum))

 	    return KErrNotReady;

     return KErrNone;

     }

 TInt TFsBlockMap::Initialise(CFsRequest* aRequest)

 	{

 	TInt r = DoInitNoParse(aRequest);

 	if(r!=KErrNone)

 		return r;

 	TInt blockMapUsage = aRequest->Message().Int2();

 	if ( blockMapUsage == EBlockMapUsagePaging )

 		{

 		CFileShare* share = (CFileShare*) aRequest->ScratchValue();

 		CFileCB& file = share->File();

 		// To determine whether the drive where this file resides is pageable, we need to locate 

 		// the specific TBusLocalDrive object first; querying the drive attributes directly from the 

 		// (composite) file system is no good as this API treats all slave file systems as "ROM & not pageable.

 		TBusLocalDrive* localDrive;

 		TInt r = file.LocalDrive(localDrive);

 		if (r != KErrNone)

 			return r;

 		TLocalDriveCapsV4Buf caps;

 		r = localDrive->Caps(caps);

 		if (r != KErrNone)

 			return r;

 		__PRINT4(_L("TFsBlockMap::Initialise, drive %d file %S iMediaAtt %08X iDriveAtt %08X\n"), file.DriveNumber(), &file.FileName(), caps().iMediaAtt, caps().iDriveAtt);

 		if ( !(caps().iDriveAtt & KDriveAttPageable))

 			return KErrNotSupported;

 		}

 	return KErrNone;

 	}

 TInt TFsBlockMap::DoRequestL(CFsRequest* aRequest)

 	{

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

 	__PRINT1(_L("aRequest->Session() = 0x%x"), aRequest->Session());

 	CFileShare* share = (CFileShare*) aRequest->ScratchValue();

 	TInt r = share->CheckMount();

 	__PRINT1(_L("share->CheckMount() returned - %d"), r);

 	if ( r != KErrNone )

 		return(r);

 	SBlockMapInfo reqInfo;

 	SBlockMapArgs args;

 	TPckg<SBlockMapArgs> pkArgs(args);

 	aRequest->ReadL(KMsgPtr1, pkArgs);

 	CFileCB& file = share->File();

 	TInt64& reqStartPos = args.iStartPos;

 	TInt64 reqEndPos = args.iEndPos;

 	if ( ( reqStartPos > file.Size64() ) || ( reqStartPos < 0 ) )

 		return KErrArgument;

 	const TInt64 KReadToEOF = -1;

 	if ( reqEndPos != KReadToEOF )

  		{

 		if ( !( reqEndPos >= reqStartPos ) )

 			return KErrArgument;

 		}

 	else

 		reqEndPos = file.Size64();

 	// If the requested start position is equal to the size of the file

 	// then we read no data and return an empty BlockMap.

 	if ( reqStartPos == file.Size64() || reqEndPos == 0 || reqEndPos == reqStartPos )

 		{

 		TPckg<SBlockMapInfo> pkInfo(reqInfo);

 		TRAP(r,aRequest->WriteL(KMsgPtr0,pkInfo) );

  		if ( r == KErrNone )

  			return(KErrArgument);

 		else

 			return(r);

 		}

 	r = share->File().BlockMap(reqInfo, reqStartPos, reqEndPos);

 	TPckg<SBlockMapInfo> pkInfo(reqInfo);

 	aRequest->WriteL(KMsgPtr0, pkInfo);

 	aRequest->WriteL(KMsgPtr1, pkArgs);

 	return(r);

 	}

 #pragma warning( disable : 4705 )	// statement has no effect

 /**

 Default constructor

 */

 EXPORT_C CFileCB::CFileCB()

 	{

 	}

 #pragma warning( default : 4705 )

 /**

 Destructor.

 Frees resources before destruction of the object.

 */

 EXPORT_C CFileCB::~CFileCB()

 	{

 	// NB Must be careful to close the file cache BEFORE deleting iFileNameF

 	// as CFileCache may steal it (!)

 	if (FileCache())

 		FileCache()->Close();

 	if (iBody && iBody->iDeleteOnClose)

 		{

 		TRACEMULT2(UTF::EBorder, UTraceModuleFileSys::ECMountCBDeleteL, EF32TraceUidFileSys, DriveNumber(), FileName());

 		TInt r;

 		TRAP(r, iMount->DeleteL(FileName()));

 		TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECMountCBDeleteLRet, EF32TraceUidFileSys, r);

 		}

 	if(iMount)

 		iMount->Close();

 	if (iMountLink.iNext!=NULL)

 		{

 		iMountLink.Deque();

 		}

 	delete iFileName;

 	delete iFileNameF;

 	if (iFileLocks)

 		{

 		iFileLocks->Close();

 		delete iFileLocks;

 		}

 	delete iBody;

 	}

 /**

     Initialise CFileCB object.

     @internalTechnology

     @param  aDrive

     @param  aCreatedDrive

     @param  aName           file name descriptor

 */

 EXPORT_C void CFileCB::InitL(TDrive* aDrive, TDrive* aCreatedDrive, HBufC* aName)

 	{

 	// Take ownership of heap-allocated objects aName and aLock before attempting any memory allocation 

 	// to avoid leaking memory

 	iFileName = aName;

     DoInitL(aDrive->DriveNumber());

 	iDrive=aDrive;

 	iCreatedDrive=aCreatedDrive;

 	TFileName tempName;

 	tempName.CopyF(*aName);

 	iFileNameF=tempName.AllocL();

 	iNameHash=CalcNameHash(*iFileNameF);

 	// see whether the file system supports the CFileCB extended API

 	MExtendedFileInterface* extendedFileInterface = NULL;

 	GetInterfaceTraced(CFileCB::EExtendedFileInterface, (void*&) extendedFileInterface, NULL);

 	iBody = new(ELeave)CFileBody(this, extendedFileInterface);

 	iMount=&iDrive->CurrentMount();

 	iBody->InitL();

 	User::LeaveIfError(iMount->Open());

 	//-- create file locks array

     ASSERT(!iFileLocks);

     iFileLocks = new(ELeave) TFileLocksArray(KFileShareLockGranularity, _FOFF(TFileShareLock, iPosLow));

     }

 TInt CFileCB::FindLock(TInt aPosLow,TInt aPosHigh)

 	{

 	return FindLock64(aPosLow, aPosHigh);

 	}

 TInt CFileCB::AddLock(CFileShare* aFileShare,TInt aPos,TInt aLength)

 	{

 	return AddLock64(aFileShare, aPos, aLength);

 	}

 TInt CFileCB::RemoveLock(CFileShare* aFileShare,TInt aPos,TInt aLength)

 	{

 	return RemoveLock64(aFileShare, aPos, aLength);

 	}

 TInt CFileCB::CheckLock(CFileShare* aFileShare,TInt aPos,TInt aLength)

 	{

 	return CheckLock64(aFileShare, aPos, aLength);

 	}

 /**

     Remove any locks held by aFileShare.

 */

 void CFileCB::RemoveLocks(CFileShare* aFileShare)

 	{

 	TInt i=0;

 	while (i<FileLocks().Count())

 		{

 		if (FileLocks()[i].MatchOwner(aFileShare))

 			FileLocks().Remove(i);

 		else

 			i++;

 		}

 	}

 void CFileCB::PromoteShare(CFileShare* aShare)

 //

 // Manages share promotion after the share has been added to the FilsShares container.

 //

 //  - Assumes the share has already been validated using ValidateShare()

 //

 //  - The count of promoted shares (ie - non-EFileShareReadersOrWriters) is incremented

 //	  to allow the share mode to be demoted when the last promoted share is closed.

 //

 	{

 	TShare reqShare = (TShare)(aShare->iMode & KFileShareMask);

 	if(reqShare != EFileShareReadersOrWriters)

 		{

 		iBody->iPromotedShares++;

 		iShare = reqShare;

 		}

 	}

 void CFileCB::DemoteShare(CFileShare* aShare)

 //

 // Manages share demotion after the share has been removed from the FileShares container.

 //

 //  - If the share being removed is not EFileShareReadersOrWriters, then the current

 //	  share mode may require demotion back to EFileShareReadersOrWriters.

 //

 //	- This is determined by the iPromotedShares count, incremented in PromoteShare()

 //

 	{

 	if((aShare->iMode & KFileShareMask) != EFileShareReadersOrWriters)

 		{

 		if(--iBody->iPromotedShares == 0)

 			{

 			// Don't worry if the file has never been opened as EFileShareReadersOrWriters

 			//  - in this case the CFileCB object is about to be closed anyway.

 			iShare = EFileShareReadersOrWriters;

 			}

 		}

 	__ASSERT_DEBUG(iBody->iPromotedShares>=0,Fault(EFileShareBadPromoteCount));

 	}

 RArray<TAsyncReadRequest>& CFileCB::AsyncReadRequests()

 //

 // Gets a reference to the pending asynchronous read requests for this file.

 //

 //  - The request is completed when all data is available or the request is cancelled.

 //

 	{

 	return(*iBody->iAsyncReadRequests);

 	}

 TInt CFileCB::AddAsyncReadRequest(CFileShare* aShareP, TInt64 aPos, TInt aLen, CFsRequest* aRequestP)

 //

 // Adds a pending asynchronous read request to the list.

 //

 //  - The request is completed when all data is available or the request is cancelled.

 //

 	{

 	__ASSERT_ALWAYS(aRequestP->Operation()->Function() == EFsFileRead, Fault(EBaseRequestMessage));

 	TAsyncReadRequest req(aPos + aLen, aShareP, aRequestP);

 	TInt err = AsyncReadRequests().InsertInSignedKeyOrderAllowRepeats(req);

 	if(err != KErrNone)

 		return err;

 	aRequestP->SetCompleted(EFalse);

 	return KErrNone;

 	}

 TInt CFileCB::CancelAsyncReadRequest(CFileShare* aShareP, TRequestStatus* aStatusP)

 //

 // Cancels (and completes) an outstanding read request for the specified share.

 //

 //	- aStatusP == NULL cancels all outstanding read requests.

 //

 	{

 	TInt i=0;

 	Drive().Lock();

 	while (i < AsyncReadRequests().Count())

 		{

 		TAsyncReadRequest& req = AsyncReadRequests()[i];

 		if(req.CompleteIfMatching(aShareP, aStatusP, KErrCancel))

 			{

 			iBody->iAsyncReadRequests->Remove(i);

 			if(aStatusP != NULL)

 				{

 				Drive().UnLock();

 				return KErrNone;

 				}

 			}

 		else

 			{

 			i++;

 			}

 		}

 	Drive().UnLock();

 	return KErrNone;

 	}

 void CFileCB::NotifyAsyncReaders()

 //

 // Determine if any outstanding read requests require completion.

 //

 //  - Called whenever the file size changes (due to a write operation or SetSize)

 //

 //  - Any outstanding read requests are re-issued (rather then completed in the 

 //    context of the current operation so not to affect performance of the writer).

 //

 //  - Should the file size shrink before the request is serviced, the request will

 //    be added back onto the queue.

 //

 //	- A future optimisation may issue the request as data becomes available (which

 //	  would minimise the final latency between writer and reader) but the current

 //	  implementation reads all requested data in one operation.

 //

 	{

 	Drive().Lock();

 	SetNotifyAsyncReadersPending(EFalse);

 	while(AsyncReadRequests().Count())

 		{

 		TAsyncReadRequest& req = AsyncReadRequests()[0];

 		if(req.iEndPos > CachedSize64())

 			break;

 		// Make a copy and then remove it from the queue before releasing the lock - 

 		// because the file server thread could append to the RArray and this might 

 		// cause a re-allocation which would move the whole array (!)

 		TAsyncReadRequest reqCopy = req;

 		AsyncReadRequests().Remove(0);

 		Drive().UnLock();

 		// allocate a new request, push a TMsgOperation onto the request's stack (duplicating

 		// the functionality of TFsFileRead::Initialise()) & dispatch the request

 		CFsClientMessageRequest* pRequest = NULL;

 		const TOperation& oP = OperationArray[EFsFileRead];

 		TInt r = RequestAllocator::GetMessageRequest(oP, reqCopy.iMessage, pRequest);

 		if (r != KErrNone)

 			{

 			reqCopy.iMessage.Complete(r);	// complete the client's message with an error

 			continue;

 			}

 		pRequest->Set(reqCopy.iMessage, oP, reqCopy.iSessionP);

 		r = DoInitNoParse(pRequest);

 		if (r != KErrNone)

 			{

 			pRequest->Complete(r);		// complete the client's message with an error

 			continue;

 			}

 		r = pRequest->PushOperation(TFsFileRead::Complete);

 		if (r != KErrNone)

 			{

 			pRequest->Complete(r);		// complete the client's message with an error

 			continue;

 			}

 		pRequest->CurrentOperation().Set(

 			reqCopy.iEndPos - pRequest->Message().Int1(), 

 			pRequest->Message().Int1(), 

 			(TDes8*) pRequest->Message().Ptr0());

 		// don't call Initialise()

 		pRequest->SetState(CFsRequest::EReqStatePostInitialise);

 		pRequest->Dispatch();

 		Drive().Lock();

 		}

 	Drive().UnLock();

 	}

 /**

 Gets the address of the file that the file control block represents. 

 The default implementation returns KErrNotSupported and should only

 be overridden for ROM file systems.

 @param aPos On return, should contain the address of the file that

             the file control block represents.

 @return KErrNone, if successful,otherwise one of the other system wide error

         codes,

 */

 EXPORT_C TInt CFileCB::Address(TInt& /*aPos*/) const

 	{

 	return(KErrNotSupported);

 	}

 /**

 Sets the archive attribute, KEntryAttArchive, in iAtt.

 */

 EXPORT_C void CFileCB::SetArchiveAttribute()

 	{

 	iAtt|=KEntryAttArchive;

 	iAtt|=KEntryAttModified;

 	iModified.UniversalTime();

 	}