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

TInt TFsMkDir::DoRequestL(CFsRequest* aRequest)

//

// Make a directory path.

//

	{

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

    TInt r = CheckDiskSpace(0, aRequest);

    if(r != KErrNone)

        return r;

	r=aRequest->Drive()->CheckMount();

	if (r!=KErrNone)

		return(r);

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

		return(KErrAlreadyExists);

    TPtrC ptr;

	ptr.Set(aRequest->Src().Path().Ptr(), aRequest->Src().Path().Length()-1);

	if (ptr.Length()<=1)

		return(KErrBadName);

    if (IsIllegalFullName(aRequest->Src().FullName()))

		return(KErrBadName);

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

		{

		TLex lex(ptr);

		TFileName filename;

		FOREVER

			{

			lex.Inc(); // Skip a delimiter

			TInt res=lex.Remainder().Locate(KPathDelimiter);

			if (res==KErrNotFound)

				break;

    		lex.Inc(res);

			filename+=lex.MarkedToken();	

			lex.Mark();

			TEntry entry;

			if ((r=aRequest->Drive()->Entry(filename,entry))==KErrNone)

				{

				if (!entry.IsDir())

					return(KErrAccessDenied);

				continue;

				}

    		if (r!=KErrNotFound)

				return(r);

    		if ((r=aRequest->Drive()->MkDir(filename))!=KErrNone)

				return(r);

			}

		}

    return(aRequest->Drive()->MkDir(ptr));

	}

TInt TFsMkDir::Initialise(CFsRequest* aRequest)

//

//

//

	{

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

	if (r!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysMkDir,&KCapFsPriMkDir,&KCapFsROMkDir, __PLATSEC_DIAGNOSTIC_STRING("Make Directory"));

	return(r);

	}

TInt TFsRmDir::DoRequestL(CFsRequest* aRequest)

//

// Remove a directory.

//

	{

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

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

		return(KErrInUse);

	if (IsIllegalFullName(aRequest->Src().FullName()))

		return(KErrBadName);

	TPtrC ptr;

	ptr.Set(aRequest->Src().Path().Ptr(), aRequest->Src().Path().Length()-1);

	return(aRequest->Drive()->RmDir(ptr));

	}

TInt TFsRmDir::Initialise(CFsRequest* aRequest)

//

//

//

	{

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

	if (r!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysRmDir,&KCapFsPriRmDir,&KCapFsRORmDir, __PLATSEC_DIAGNOSTIC_STRING("Remove Directory"));

	return(r);

	}

TInt TFsDelete::DoRequestL(CFsRequest* aRequest)

//

// Delete a file.

//

	{

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

	return(aRequest->Drive()->Delete(aRequest->Src().FullName().Mid(2)));

	}

TInt TFsDelete::Initialise(CFsRequest* aRequest)

//

//

//

	{

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

	if (r!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysDelete,&KCapFsPriDelete,&KCapFsRODelete, __PLATSEC_DIAGNOSTIC_STRING("Delete"));

	return(r);

	}

TInt TFsRename::DoRequestL(CFsRequest* aRequest)

//

// Rename a file or directory. Wild cards not allowed.

//

	{

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

    TInt r = CheckDiskSpace(0, aRequest);

    if(r != KErrNone)

        return r;

    r = aRequest->Drive()->Rename(aRequest->Src().FullName().Mid(2),aRequest->Dest().FullName().Mid(2));

	return (r);

	}

TInt TFsRename::Initialise(CFsRequest* aRequest)

//

//

//

	{

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

	if (r!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysRename,&KCapFsPriRename,&KCapFsRORename, __PLATSEC_DIAGNOSTIC_STRING("File Server Rename"));

	if(r!=KErrNone)

		return(r);

	TDrive* pOldDrive=aRequest->Drive();

	if ((r=ParseNoWildSubstCheckPathPtr1(aRequest,aRequest->Dest()))!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Dest().FullName().Mid(2),&KCapFsSysRename,&KCapFsPriRename,&KCapFsRORename, __PLATSEC_DIAGNOSTIC_STRING("File Server Rename"));	

	if(r == KErrNone)

		{

		if (pOldDrive!=aRequest->Drive())

			r=KErrArgument;

		}

	return(r);

	}

TInt TFsReplace::DoRequestL(CFsRequest* aRequest)

//

// Replace an old file with a new file atomically

//

	{

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

    TInt r = CheckDiskSpace(0, aRequest);

    if(r != KErrNone)

        return r;

	return(aRequest->Drive()->Replace(aRequest->Src().FullName().Mid(2),aRequest->Dest().FullName().Mid(2)));

	}

TInt TFsReplace::Initialise(CFsRequest* aRequest)

//

//

//

	{

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

	if (r!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysReplace,&KCapFsPriReplace,&KCapFsROReplace, __PLATSEC_DIAGNOSTIC_STRING("File Server Replace"));	

	if(r!=KErrNone)

		return(r);

	TDrive* pOldDrive=aRequest->Drive();

	if ((r=ParseNoWildSubstCheckPtr1(aRequest,aRequest->Dest()))!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Dest().FullName().Mid(2),&KCapFsSysReplace,&KCapFsPriReplace,&KCapFsROReplace, __PLATSEC_DIAGNOSTIC_STRING("File Server Replace"));	

	if(r == KErrNone)

		{

		if (pOldDrive!=aRequest->Drive())

			r=KErrArgument;

		}

	return(r);

	}

TInt TFsEntry::DoRequestL(CFsRequest* aRequest)

//

// Get all the entry details.

//

	{

	__PRINT(_L("TInt TFsEntry::DoRequestL(CFsRequest* aRequest)"));

	TEntry t; 

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

	TInt r=aRequest->Drive()->Entry(filePath,t);

	if (r!=KErrNone)

		return(r);

	// If the file is open, get the file size from the CFileCB object as there may be cached data

	CFileCB* file;

	aRequest->Drive()->IsFileOpen(filePath, file);

	if (file)

		t.SetFileSize(file->CachedSize64());

	TPckgC<TEntry> p(t);

	aRequest->WriteL(KMsgPtr1,p);

	return(KErrNone);

	}

TInt TFsEntry::Initialise(CFsRequest* aRequest)

//

//

//

	{

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

	if (r!=KErrNone)

		return(r);

	// Check the capabilites but always allow the entry to be read for private, system and 

	// resource directories as long as there are no sub folders or files specified

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsEntry, __PLATSEC_DIAGNOSTIC_STRING("Entry"), ETrue);	

	return(r);

	}

TInt TFsSetEntry::DoRequestL(CFsRequest* aRequest)

//

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

//

	{

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

    TInt r = CheckDiskSpace(0, aRequest);

    if(r != KErrNone)

        return r;

	TTime entryTime;

	TPckgBuf<TTime> timeBuf;

	aRequest->ReadL(KMsgPtr1,timeBuf);

	entryTime=timeBuf();

	const RMessage2& msg = aRequest->Message();

	return(aRequest->Drive()->SetEntry(aRequest->Src().FullName().Mid(2),entryTime,msg.Int2(),msg.Int3()));

	}

TInt TFsSetEntry::Initialise(CFsRequest* aRequest)

//

//

//

	{

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

	if (r!=KErrNone)

		return(r);

 	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysSetEntry,&KCapFsPriSetEntry,&KCapFsROSetEntry, __PLATSEC_DIAGNOSTIC_STRING("Set Entry"));	

	return(r);

	}

LOCAL_C void FsReadFileSectionFileClose(CFsRequest* aRequest, CFileShare* aShare)

	{

	aRequest->Session()->DecResourceCount();

	TInt handle = aRequest->Session()->Handles().At(aShare, EFalse);

	aRequest->Session()->Handles().Remove(handle,ETrue);

	// close the file share

	aRequest->SetScratchValue64(0);

	}

LOCAL_C CFileShare* FsReadFileSectionFileOpen(CFsRequest* aRequest)

	{

	TInt handle;

	TUint32 mode = EFileShareReadersOrWriters | EFileRead | EFileReadAheadOff;

	TInt r = aRequest->Drive()->FileOpen(aRequest,handle,aRequest->Src().FullName().Mid(2),mode,EFileOpen);

	if (r!=KErrNone)

		return(NULL);

	CFileShare* share = (CFileShare*) SessionObjectFromHandle(handle, FileShares->UniqueID(), aRequest->Session());

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

	CFileCB& file = share->File();

	if (!file.FileCache())

		{

		FsReadFileSectionFileClose(aRequest, share);

		share = NULL;

		}

	return share;

	}

TInt TFsReadFileSection::Complete(CFsRequest* aRequest)

	{

	FsReadFileSectionFileClose(aRequest, (CFileShare*) aRequest->ScratchValue());

	return CFsRequest::EReqActionComplete;

	}

TInt TFsReadFileSection::DoRequestL(CFsRequest* aRequest)

//

//	Read from a file regardless of lock state

//

	{

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

	TAny* pDes=(TAny*)(aRequest->Message().Ptr0());

	TInt64 pos;

	if(aRequest->IsDescData(KMsgPtr2))

		{

		TPckg<TInt64> pkPos(pos);

		aRequest->ReadL(KMsgPtr2, pkPos);

		}

	else

		{

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

		}

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

	// Try to open file so we can take advantage of file caching

	CFileShare* share = FsReadFileSectionFileOpen(aRequest);

	if (share)

		{

		CFsMessageRequest& msgRequest = *(CFsMessageRequest*) aRequest;

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

		CFileCB& file = share->File();

		TInt64 size = file.Size64();

		TInt r = KErrNone;

		if (pos > size)

			pos = size;

		if (pos + len > size)

		// filesize - pos shall of TInt size

		// Hence to suppress warning

			len = (TInt)(size - pos);

		if (len <= 0)

			r = KErrArgument;

		if (r == KErrNone)

			r = msgRequest.PushOperation(pos, len, (TDesC8*) pDes, 0, TFsReadFileSection::Complete, 0, EFsFileRead);

		msgRequest.SetState(CFsRequest::EReqStatePostInitialise);	// DO call PostInitialise()

		if (r == KErrNone)

			{

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

			return CFsRequest::EReqActionBusy; // dispatch the request again

			}

		FsReadFileSectionFileClose(aRequest, share);

		}

	TInt r = KErrNone;

	if (len < 0)

		r = KErrArgument;

	else if (len > 0)

		r = aRequest->Drive()->ReadFileSection64(aRequest->Src().FullName().Mid(2),pos,pDes,len,aRequest->Message());

	// zero return buffer, but only if we haven't written any data to it already, otherwise kernel's

	// writeback of descriptor length will conflict with that wrttien by media driver

	if (r != KErrNone || len == 0)

		aRequest->WriteL(KMsgPtr0,KNullDesC8);

	return r == KErrEof ? KErrNone : r;  

	}

TInt TFsReadFileSection::Initialise(CFsRequest* aRequest)

//

//

//

	{

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

	if (r!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysReadFileSection,&KCapFsPriReadFileSection, __PLATSEC_DIAGNOSTIC_STRING("Read File Section"));	

	return(r);

	}

TInt TFsCheckDisk::DoRequestL(CFsRequest* aRequest)

//

// Check the disk's integrity

//

	{

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

	// flush all files on this drive

	TInt r = aRequest->Drive()->FlushCachedFileInfo();

	if (r == CFsRequest::EReqActionBusy)	// ignore any flush errors

		return(r);

	return(aRequest->Drive()->CheckDisk());

	}

TInt TFsCheckDisk::Initialise(CFsRequest* aRequest)

//

//

//

	{

	if (!KCapFsCheckDisk.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("CheckDisk")))						

		return KErrPermissionDenied;

	return ParseSubstPtr0(aRequest,aRequest->Src());	//may make the rfs function call take a drive instead of path

	}

TInt TFsScanDrive::DoRequestL(CFsRequest* aRequest)

//

//

//

	{

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

	// flush all files on this drive

	TInt r = aRequest->Drive()->FlushCachedFileInfo();

	if (r == CFsRequest::EReqActionBusy)	// ignore any flush errors

		return(r);

	r=aRequest->Drive()->CheckMount();

	if(r!=KErrNone)

		return(r);

	if (aRequest->Drive()->CurrentMount().LockStatus()<0)

		return(KErrInUse);

	r=aRequest->Drive()->ScanDrive();

	// notify sessions since drive contents may have changed

	if(r==KErrNone)

		FsNotify::DiskChange(aRequest->DriveNumber());

	return(r);

	}

TInt TFsScanDrive::Initialise(CFsRequest* aRequest)

//

//

//

	{

	TInt r;

	if(!KCapFsScanDrive.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("ScanDrive")))	

		return KErrPermissionDenied;

	r=ParseSubstPtr0(aRequest,aRequest->Src());		//may make the rfs function call take a drive instead of path

	return(r);										//then  no need for parse, just needs to check for susted and reject them

	}

TInt TFsGetShortName::DoRequestL(CFsRequest* aRequest)

//

// Get the short name associated with a long file name

//

	{

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

	TBuf<0x10> shortName;

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

	if (r!=KErrNone)

		return(r);

	aRequest->WriteL(KMsgPtr1,shortName);

	return(KErrNone);

	}

TInt TFsGetShortName::Initialise(CFsRequest* aRequest)

//

//

//

	{

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

	if (r!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysGetShortName,&KCapFsPriGetShortName, __PLATSEC_DIAGNOSTIC_STRING("Get Short Name"));	

	return(r);

	}

TInt TFsGetLongName::DoRequestL(CFsRequest* aRequest)

//

// Get the long name associated with a short file name

//

	{

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

	TFileName longName;

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

	if (r!=KErrNone)

		return(r);

	aRequest->WriteL(KMsgPtr1,longName);

	return(KErrNone);

	}

TInt TFsGetLongName::Initialise(CFsRequest* aRequest)

//

//

//

	{

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

	if (r!=KErrNone)

		return(r);

	r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysGetLongName,&KCapFsPriGetLongName, __PLATSEC_DIAGNOSTIC_STRING("Get Long Name"));	

	return(r);

	}

TInt TFsIsFileInRom::DoRequestL(CFsRequest* aRequest)

//

// Return the address of the file

//

	{

	__PRINT(_L("DoIsFileInRom"));